Go API

WalletL2

Manages and interacts with accounts on L2

The WalletL2 class provides functionalities for managing and interacting with accounts on the Layer 2 (L2) network. It includes methods for creating wallets, querying balances, transferring tokens, and interacting with smart contracts on the ZKsync network.

`Address`

Returns the address of the associated account.

Address() common.Address

Example

fmt.Println("Address: ", wallet.Address())

`AllBalances`

Returns all balances for confirmed tokens given by an associated account.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.

AllBalances(ctx context.Context) (map[common.Address]*big.Int, error)

Example

balances, err := wallet.AllBalances(context.Background())
if err != nil {
            log.Panic(err)
}
fmt.Printf("Balances: %+v\n", balances)

`Balance`

Returns the balance of the specified token that can be either ETH or any ERC20 token. The block number can be nil, in which case the balance is taken from the latest known block.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`token`	`common.Address`	L2 token address.
`at`	`*big.Int`	Block number.

Balance(ctx context.Context, token common.Address, at *big.Int) (*big.Int, error)

Example

balance, err := wallet.Balance(context.Background(), utils.EthAddress, nil)
if err != nil {
            log.Panic(err)
}
fmt.Println("Balance: ", balance)

`CallContract`

Executes a message call for EIP-712 transaction, which is directly executed in the VM of the node, but never mined into the blockchain.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`msg`	`CallMsg`	Contains parameters for contract call using EIP-712 transaction.
`blockNumber`	`*big.Int` (optional)	Selects the block height at which the call runs. It can be `nil`, in which case the code is taken from the latest known block. Note that state from very old blocks might not be available.

CallContract(ctx context.Context, msg CallMsg, blockNumber *big.Int) ([]byte, error)

Example

// The Crown token on testnet
TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")

tokenAbi, err := erc20.IERC20MetaData.GetAbi()
if err != nil {
            log.Panic(err)
}
symbolCalldata, err := tokenAbi.Pack("symbol")
if err != nil {
            log.Panic(err)
}

result, err := wallet.CallContract(context.Background(), types.CallMsg{
            CallMsg: ethereum.CallMsg{
                        To:   &TokenAddress,
                        Data: symbolCalldata,
            },
}, nil)
if err != nil {
            log.Panic(err)
}
unpack, err := tokenAbi.Unpack("symbol", result)
if err != nil {
            log.Panic(err)
}
symbol := *abi.ConvertType(unpack[0], new(string)).(*string)
fmt.Println("Symbol: ", symbol)

`DeploymentNonce`

Returns the deployment nonce of the account.

Inputs

Parameter	Type	Description
`opts`	`CallOpts` (optional)	Call options.

func (a *WalletL2) DeploymentNonce(opts *CallOpts) (*big.Int, error)

Example

deploymentNonce, err := wallet.DeploymentNonce(nil)
if err != nil {
    log.Panic(err)
}

`EstimateGasTransfer`

Estimates the amount of gas required for a transfer transaction.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`msg`	`TransferCallMsg`	Transfer call parameters.

EstimateGasTransfer(ctx context.Context, msg TransferCallMsg) (uint64, error)

Example

gas, err := wallet.EstimateGasTransfer(context.Background(), accounts.TransferCallMsg{
            To:   common.HexToAddress("<Receipt address>"),
            Amount: big.NewInt(7_000_000_000),
            Token:  utils.EthAddress,
})
if err != nil {
            log.Panic(err)
}
fmt.Println("Gas: ", gas)

`EstimateGasWithdraw`

Estimates the amount of gas required for a withdrawal transaction.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`msg`	`WithdrawalCallMsg`	Withdrawal call parameters.

EstimateGasWithdraw(ctx context.Context, msg WithdrawalCallMsg) (uint64, error)

Example

gas, err := wallet.EstimateGasWithdraw(context.Background(), accounts.WithdrawalCallMsg{
            To:   wallet.Address(),
            Amount: big.NewInt(7_000_000),
            Token:  utils.EthAddress,
})
if err != nil {
            log.Panic(err)
}
fmt.Println("Gas: ", gas)

`Init`

Creates an instance of WalletL2 associated with the account provided by the raw private key.

func NewWalletL2(rawPrivateKey []byte, client *clients.Client) (*WalletL2, error)

Creates an instance of WalletL2. The client can be optional; if it is not provided, only SignTransaction, Address, Signer can be performed, as the rest of the functionalities require communication to the network.

func NewWalletL2FromSigner(signer *Signer, client *clients.Client) (*WalletL2, error)

Example

PrivateKey     := os.Getenv("PRIVATE_KEY")
ZkSyncEraProvider := "https://testnet.era.zksync.dev"

client, err := clients.Dial(ZkSyncEraProvider)
if err != nil {
            log.Panic(err)
}
defer client.Close()

wallet, err := accounts.NewWallet(common.Hex2Bytes(PrivateKey), &client)
if err != nil {
            log.Panic(err)
}

`IsBaseToken`

Returns whether the token is the base token.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`token`	`common.Address`	Token address.

IsBaseToken(ctx context.Context, token common.Address) (bool, error)

Example

isBaseToken, err := wallet.IsBaseToken(
  context.Background(),
  common.HexToAddress("0x5C221E77624690fff6dd741493D735a17716c26B")
)
if err != nil {
    log.Panic(err)
}
fmt.Println("Is base token: ", isBaseToken)

`L2BridgeContracts`

Returns L2 bridge contracts.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.

L2BridgeContracts(ctx context.Context) (*zkTypes.L2BridgeContracts, error)

Example

contracts, err := wallet.L2BridgeContracts(context.Background())
if err != nil {
            log.Panic(err)
}

`SendTransaction`

Injects a transaction into the pending pool for execution. Any unset transaction fields are prepared using the PopulateTransaction method.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`tx`	`Transaction`	Transaction parameters.

SendTransaction(ctx context.Context, tx *Transaction) (common.Hash, error)

Example

// The Crown token on testnet
TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
// Paymaster for Crown token on testnet
PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")

abi, err := erc20.IERC20MetaData.GetAbi()
if err != nil {
            log.Panic(err)
}

// Encode transfer function from token contract
calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
if err != nil {
            log.Panic(err)
}

// Create paymaster parameters with encoded paymaster input
paymasterParams, err := utils.GetPaymasterParams(
            PaymasterAddress,
            &zkTypes.ApprovalBasedPaymasterInput{
                        Token:            TokenAddress,
                        MinimalAllowance: big.NewInt(1),
                        InnerInput:       []byte{},
            })
if err != nil {
            log.Panic(err)
}

hash, err := wallet.SendTransaction(context.Background(), &accounts.Transaction{
            To:   &TokenAddress,
            Data: calldata,
            Meta: &types.Eip712Meta{
                        PaymasterParams: paymasterParams,
            },
})
if err != nil {
            log.Panic(err)
}

_, err = client.WaitMined(context.Background(), hash)
if err != nil {
            log.Panic(err)
}

fmt.Println("Tx: ", hash)

`Signer`

Returns the signer of the associated account.

Signer() Signer

Example

fmt.Printf("Signer %+v\n", wallet.Signer())

`SignTransaction`

Returns a signed transaction that is ready to be broadcast to the network. The input transaction must be a valid transaction with all fields having appropriate values. To obtain a valid transaction, you can use the PopulateTransaction method.

Inputs

Parameter	Type	Description
`tx`	`zkTypes.Transaction712`	EIP-712 transaction parameters.

SignTransaction(tx *zkTypes.Transaction712) ([]byte, error)

Example

// The Crown token on testnet
TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
// Paymaster for Crown token on testnet
PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")

abi, err := erc20.IERC20MetaData.GetAbi()
if err != nil {
            log.Panic(err)
}

// Encode transfer function from token contract
calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
if err != nil {
            log.Panic(err)
}

preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
            To:   &TokenAddress,
            Data: calldata,
})

signedTx, err := wallet.SignTransaction(preparedTx)
if err != nil {
            log.Panic(err)
}
fmt.Printf("Signed tx: %+v\n", signedTx)

`Transfer`

Moves the ETH or any ERC20 token from the associated account to the target account.

Inputs

Parameter	Type	Description
`auth`	`*TransactOpts` (optional)	Transaction options.
`tx`	`TransferTransaction`	Transfer transaction parameters.

Transfer(auth *TransactOpts, tx TransferTransaction) (*types.Transaction, error)

Example

tx, err := wallet.Transfer(nil, accounts.TransferTransaction{
            To:     common.HexToAddress("<Receipt address>"),
            Amount: big.NewInt(7_000_000_000),
            Token:  utils.EthAddress,
})
if err != nil {
            log.Panic(err)
}
fmt.Println("Transaction: ", tx.Hash())

`Withdraw`

Initiates the withdrawal process which withdraws ETH or any ERC20 token from the associated account on L2 network to the target account on L1 network.

Inputs

Parameter	Type	Description
`auth`	`*TransactOpts` (optional)	Transaction options.
`tx`	`WithdrawalTransaction`	Withdrawal transaction parameters.

Withdraw(auth *TransactOpts, tx WithdrawalTransaction) (*types.Transaction, error)

Example

tx, err := wallet.Withdraw(nil, accounts.WithdrawalTransaction{
            To:     wallet.Address(),
            Amount: big.NewInt(1_000_000_000_000_000_000),
            Token:  utils.EthAddress,
})
if err != nil {
            panic(err)
}
fmt.Println("Withdraw transaction: ", tx.Hash())

PopulateTransaction

Designed for users who prefer a simplified approach by providing only the necessary data to create a valid EIP-712 transaction. The only required fields are Transaction.To and either Transaction.Data or Transaction.Value (or both, if the method is payable). Any other fields that are not set will be prepared by this method.

Inputs

Parameter	Type	Description
`ctx`	`context.Context`	Context.
`tx`	`Transaction`	Transaction parameters.

PopulateTransaction(ctx context.Context, tx Transaction) (*zkTypes.Transaction712, error)

Example

// The Crown token on testnet
TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
// Paymaster for Crown token on testnet
PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")

abi, err := erc20.IERC20MetaData.GetAbi()
if err != nil {
            log.Panic(err)
}

// Encode transfer function from token contract
calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
if err != nil {
            log.Panic(err)
}

preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
            To:   &TokenAddress,
            Data: calldata,
})
fmt.Printf("Prepared tx: %+v\n", preparedTx)

WalletL1

Manages and interacts with accounts on L1

SmartAccount

Flexible signer for various payloads