Accounts: L1->L2 transactions

async approveERC20(    token: Address,    amount: BigNumberish,    overrides?: ethers.CallOverrides): Promise<ethers.providers.TransactionResponse>

import * as zksync from "zksync-web3";import { ethers } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new zksync.Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const USDC_ADDRESS = "0xd35cceead182dcee0f148ebac9447da2c4d449c4";const txHandle = await wallet.approveERC20(  USDC_ADDRESS,  "10000000" // 10.0 USDC);await txHandle.wait();

async depositBaseCost(params?: {    gasPrice?: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;}): Promise<BigNumber>

async deposit(transaction: {    token: Address;    amount: BigNumberish;    to?: Address;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;    operatorTip?: BigNumberish;    approveERC20?: boolean;    overrides?: ethers.CallOverrides;    approveOverrides?: ethers.CallOverrides;}): Promise<PriorityOpResponse>

import * as zksync from "zksync-web3";import { ethers } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new zksync.Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const USDC_ADDRESS = "0xd35cceead182dcee0f148ebac9447da2c4d449c4";const usdcDepositHandle = await wallet.deposit({  token: USDC_ADDRESS,  amount: "10000000",  approveERC20: true,});// Note that we wait not only for the L1 transaction to complete but also for it to be// processed by zkSync. If we want to wait only for the transaction to be processed on L1,// we can use `await usdcDepositHandle.waitL1Commit()`await usdcDepositHandle.wait();const ethDepositHandle = await wallet.deposit({  token: zksync.utils.ETH_ADDRESS,  amount: "10000000",});// Note that we wait not only for the L1 transaction to complete but also for it to be// processed by zkSync. If we want to wait only for the transaction to be processed on L1,// we can use `await ethDepositHandle.waitL1Commit()`await ethDepositHandle.wait();

async addTokenBaseCost(params?: {    gasPrice?: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;}): Promise<BigNumber>

async addToken(transaction: {    token: Address;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;    operatorTip?: BigNumberish;    overrides?: ethers.CallOverrides;}): Promise<PriorityOpResponse>

import * as zksync from "zksync-web3";import { ethers } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new zksync.Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const MLTT_ADDRESS = "0x690f4886c6911d81beb8130db30c825c27281f22";const addTokenHandle = await wallet.addToken({ token: MLTT_ADDRESS });// Note that we wait not only for the L1 transaction to complete but also for it to be// processed by zkSync. If we want to wait only for the transaction to be processed on L1,// we can use `await addTokenHandle.waitL1Commit()`await addTokenHandle.wait();

async withdrawBaseCost(params?: {    gasPrice?: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;}): Promise<BigNumber>

async requestL1Withdraw(transaction: {    token: Address;    amount: BigNumberish;    to: Address;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;    operatorTip?: BigNumberish;    overrides?: ethers.CallOverrides;}): Promise<PriorityOpResponse>

import * as zksync from "zksync-web3";import { ethers } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new zksync.Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const gasPrice = await wallet.providerL1!.getGasPrice();const txCostPrice = await wallet.withdrawBaseCost({  gasPrice,});console.log(`Withdrawing the token will cost ${ethers.utils.formatEther(txCostPrice)} ETH`);const withdrawTx = await wallet.requestL1Withdraw({  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  amount: "100",  to: wallet.address,  overrides: {    gasPrice,  },});await withdrawTx.wait();

async executeBaseCost(params: {    ergsLimit: BigNumberish;    calldataLength: number;    gasPrice?: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;}): Promise<BigNumber>

async requestL1Execute(transaction: {    contractAddress: Address;    calldata: ethers.BytesLike;    ergsLimit: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;    operatorTip?: BigNumberish;    overrides?: ethers.CallOverrides;}): Promise<PriorityOpResponse>

import * as zksync from "zksync-web3";import { BigNumber, ethers } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new zksync.Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const gasPrice = await wallet.providerL1!.getGasPrice();// The calldata can be encoded the same way as for Ethereum.// Here is an example on how to get the calldata from an ABI:const abi = [  {    inputs: [],    name: "increment",    outputs: [],    stateMutability: "nonpayable",    type: "function",  },];const contractInterface = new ethers.utils.Interface(abi);const calldata = contractInterface.encodeFunctionData("increment", []);const ergsLimit = BigNumber.from(1000);const txCostPrice = await wallet.executeBaseCost({  gasPrice,  calldataLength: ethers.utils.arrayify(calldata).length,  ergsLimit,});console.log(`Executing the transaction will cost ${ethers.utils.formatEther(txCostPrice)} ETH`);const executeTx = await wallet.requestL1Execute({  calldata,  ergsLimit,  contractAddress: "0x19a5bfcbe15f98aa073b9f81b58466521479df8d",  overrides: {    gasPrice,    value: txCostPrice,  },});await executeTx.wait();

async deployContractBaseCost(params?: {    ergsLimit: BigNumberish;    bytecodeLength: BigNumberish;    calldataLength: BigNumberish;    gasPrice?: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;}): Promise<BigNumber>

async requestL1DeployContract(transaction: {    bytecode: ethers.BytesLike;    calldata: ethers.BytesLike;    ergsLimit: BigNumberish;    queueType?: PriorityQueueType;    opTree?: PriorityOpTree;    operatorTip?: BigNumberish;    overrides?: ethers.CallOverrides;}): Promise<PriorityOpResponse>

import { Wallet, Provider, ContractFactory } from "zksync-web3";import { ethers, BigNumber } from "ethers";const PRIVATE_KEY = "0xc8acb475bb76a4b8ee36ea4d0e516a755a17fad2e84427d5559b37b544d9ba5a";const zkSyncProvider = new Provider("https://zksync2-testnet.zksync.dev/");const ethereumProvider = ethers.getDefaultProvider("goerli");const wallet = new Wallet(PRIVATE_KEY, zkSyncProvider, ethereumProvider);const gasPrice = await wallet.providerL1!.getGasPrice();// The zkEVM bytecode of the contract.const bytecode = "0x...";// ABI of the smart contract. Here the smart contract// takes a single parameter to its constructor of an `address` type.const abi = [  {    inputs: [      {        internalType: "address",        name: "newGovernance",        type: "address",      },    ],    stateMutability: "nonpayable",    type: "constructor",  },];// Please note that the constructor calldata must be encoded by our SDK.// Here is an example of how it can be done:// 1. Create a contract factory.const factory = new ContractFactory(abi, bytecode, wallet);// 2. Get the L2 deployment transaction's data. The calldata on L1 is encoded the same as on L2.// `wallet.address` here is a constructor parameter.const l2DeployCalldata = factory.getDeployTransaction(wallet.address).data!;// 3. Remove the first 32 bytes.`l2DeployCalldata is a concatenation of `keccak256(bytecode)` and the actual calldata.// Please note that to save gas the calldata that we send to L1 doesn't have the keccak256(bytecode) part.// That's why we omit the first 32 bytes.const calldata = ethers.utils.arrayify(l2DeployCalldata).slice(32);const ergsLimit = BigNumber.from(1000);const txCostPrice = await wallet.deployContractBaseCost({  gasPrice,  calldataLength: ethers.utils.arrayify(calldata).length,  bytecodeLength: ethers.utils.arrayify(bytecode).length,  ergsLimit,});console.log(`Deploying the contract will cost ${ethers.utils.formatEther(txCostPrice)} ETH`);const deployTx = await wallet.requestL1DeployContract({  calldata,  ergsLimit,  bytecode,  overrides: {    gasPrice,  },});await deployTx.wait();