Go API

Types

Defines essential types for ZKsync Era

This section describes various types used in the ZKsync Era. These types are essential for interacting with the blockchain, performing transactions, and managing accounts.

AllowanceParams

Contains the parameters required for approval of an ERC20 token.

type AllowanceParams struct {
  Token     common.Address // Token address
  Allowance *big.Int       // Allowance amount
}

CallMsg

Contains parameters for contract call from an account associated with AdapterL1, AdapterL2, Deployer orAdapter. Its primary purpose is to be transformed into types.CallMsg, wherein the From field represents the associated account.

type CallMsg struct {
            To         *common.Address     // The address of the recipient.
            Gas        uint64              // If 0, the call executes with near-infinite gas.
            GasPrice   *big.Int            // Wei <-> gas exchange ratio.
            GasFeeCap  *big.Int            // EIP-1559 fee cap per gas.
            GasTipCap  *big.Int            // EIP-1559 tip per gas.
            Value      *big.Int            // Amount of wei sent along with the call.
            Data       []byte              // Input data, usually an ABI-encoded contract method invocation
            AccessList types.AccessList    // EIP-2930 access list.
            Meta       *zkTypes.Eip712Meta // EIP-712 metadata.
}

func (m *CallMsg) ToCallMsg(from common.Address) zkTypes.CallMsg

CallOpts

Is the collection of options to fine tune a contract call request from an account associated with AdapterL1, AdapterL2, Deployer or Adapter. Its primary purpose is to be transformed into bind.CallOpts, wherein the From field represents the associated account.

type CallOpts struct {
            Pending     bool            // Whether to operate on the pending state or the last known one
            BlockNumber *big.Int        // Optional the block number on which the call should be performed
            Context     context.Context // Network context to support cancellation and timeouts (nil = no timeout)
}

Create2Transaction

Represents the parameters for deploying a contract or account using the CREATE2 opcode. This transaction is initiated by the account associated with Deployer.

type Create2Transaction struct {
            Bytecode     []byte        // The bytecode of smart contract or smart account.
            Calldata     []byte        // The constructor calldata.
            Salt         []byte        // The create2 salt.
            Dependencies [][]byte      // The bytecode of dependent smart contracts or smart accounts.
            Auth         *TransactOpts // Authorization data.
}

func (t *Create2Transaction) ToTransaction(deploymentType DeploymentType) (*Transaction, error)

CreateTransaction

Represents the parameters for deploying a contract or account using the CREATE opcode. This transaction is initiated by the account associated with Deployer.

type CreateTransaction struct {
            Bytecode     []byte        // The bytecode of smart contract or smart account.
            Calldata     []byte        // The constructor calldata.
            Dependencies [][]byte      // The bytecode of dependent smart contracts or smart accounts.
            Auth         *TransactOpts // Authorization data.
}

func (t *CreateTransaction) ToTransaction(deploymentType DeploymentType) (*Transaction, error)

DeploymentType

Represents an enumeration of deployment types.

type DeploymentType string

const (
            DeployContract DeploymentType = "CONTRACT"
            DeployAccount  DeploymentType = "ACCOUNT"
)

DepositCallMsg

Contains the common data required to execute a deposit call on L2 from L1. This execution is initiated by the account associated with AdapterL2.

type DepositCallMsg struct {
            To     common.Address // The address that will receive the deposited tokens on L2.
            Token  common.Address // The address of the token to deposit.
            Amount *big.Int       // The amount of the token to be deposited.

            // If the ETH value passed with the transaction is not explicitly stated Value,
            // this field will be equal to the tip the operator will receive on top of the base cost
            // of the transaction.
            OperatorTip *big.Int

            // The address of the bridge contract to be used. Defaults to the default ZKsync bridge
            // (either L1EthBridge or L1Erc20Bridge).
            BridgeAddress *common.Address

            L2GasLimit *big.Int // Maximum amount of L2 gas that transaction can consume during execution on L2.

            // The maximum amount L2 gas that the operator may charge the user for single byte of pubdata.
            GasPerPubdataByte *big.Int

            // The address on L2 that will receive the refund for the transaction.
            // If the transaction fails, it will also be the address to receive L2Value.
            RefundRecipient common.Address

            CustomBridgeData []byte // Additional data that can be sent to a bridge.

            Value     *big.Int // The amount of wei sent along with the call.
            Gas       uint64   // If 0, the call executes with near-infinite gas.
            GasPrice  *big.Int // Wei <-> gas exchange ratio.
            GasFeeCap *big.Int // EIP-1559 fee cap per gas.
            GasTipCap *big.Int // EIP-1559 tip per gas.

            AccessList types.AccessList // EIP-2930 access list.
}

func (m *DepositCallMsg) ToDepositTransaction() DepositTransaction
func (m *DepositCallMsg) ToRequestExecuteCallMsg() RequestExecuteCallMsg
func (m *DepositCallMsg) ToCallMsg(from, l1Bridge common.Address) (ethereum.CallMsg, error)
func (m *DepositCallMsg) ToTransactOpts() *TransactOpts

DepositTransaction

Represents a deposit transaction on L2 from L1 initiated by the account associated with AdapterL1.

type DepositTransaction struct {
  To     common.Address // The address of the token to deposit.
  Token  common.Address // The address of the token to deposit.
  Amount *big.Int       // The amount of the token to be deposited.

  // If the ETH value passed with the transaction is not explicitly stated Auth.Value,
  // this field will be equal to the tip the operator will receive on top of the base cost
  // of the transaction.
  OperatorTip *big.Int

  // The address of the bridge contract to be used. Defaults to the default ZKsync bridge
  // (either L1EthBridge or L1Erc20Bridge).
  BridgeAddress *common.Address

  // Whether should the token approval be performed under the hood. Set this flag to true if you
  // bridge an ERC20 token and didn't call the approveERC20 function beforehand.
  ApproveERC20 bool

  // Whether should the base token approval be performed under the hood. Set this flag to true if you
  // bridge an ERC20 token and didn't call the approveERC20 function beforehand.
  ApproveBaseERC20 bool

  L2GasLimit *big.Int // Maximum amount of L2 gas that transaction can consume during execution on L2.

  // The maximum amount L2 gas that the operator may charge the user for single byte of pubdata.
  GasPerPubdataByte *big.Int

  // The address on L2 that will receive the refund for the transaction.
  // If the transaction fails, it will also be the address to receive L2Value.
  RefundRecipient common.Address

  CustomBridgeData []byte // Additional data that can be sent to the bridge.

  ApproveAuth     *TransactOpts // Authorization data for the token approval transaction.
  ApproveBaseAuth *TransactOpts // Authorization data for the base token approval transaction.
}

func (t *DepositTransaction) ToRequestExecuteTransaction() *RequestExecuteTransaction
func (t *DepositTransaction) ToDepositCallMsg(opts *TransactOpts) DepositCallMsg
func (t *DepositTransaction) PopulateEmptyFields(from common.Address)

FullDepositFee

Represents the total ETH fee required for performing the deposit on both L1 and L2 networks.

type FullDepositFee struct {
            MaxFeePerGas, // MaxFeePerGas of the L1 transaction if 1559 transaction is used.
            MaxPriorityFeePerGas, // MaxPriorityFeePerGas of the L1 transaction if 1559 transaction is used.
            GasPrice, // Gas price of the L1 transaction if legacy transaction is used.
            BaseCost, // Base cost of the L2 transaction.
            L1GasLimit, // Gas limit of the L1 transaction.
            L2GasLimit *big.Int // Gas limit of the L2 transaction.
}

PayloadSigner

Signs various types of payloads, optionally using a some kind of secret. Returns the serialized signature. The client is used to fetch data from the network if it is required for signing.

type PayloadSigner func(ctx context.Context, payload []byte, secret interface{}, client *clients.BaseClient) ([]byte, error)

RequestExecuteCallMsg

Contains the common data required to execute a call for a request execution of an L2 transaction from L1. This execution is initiated by the account associated with AdapterL1.

type RequestExecuteCallMsg struct {
            ContractAddress common.Address // The L2 receiver address.
            Calldata        []byte         // The input of the L2 transaction.
            L2GasLimit      *big.Int       // Maximum amount of L2 gas that transaction can consume during execution on L2.
  MintValue       *big.Int       // The amount of base token that needs to be minted on non-ETH-based L2.
  L2Value         *big.Int       // `msg.value` of L2 transaction.
            FactoryDeps     [][]byte       // An array of L2 bytecodes that will be marked as known on L2.

            // If the ETH value passed with the transaction is not explicitly stated Value,
            // this field will be equal to the tip the operator will receive on top of the base cost
            // of the transaction.
            OperatorTip *big.Int

            // The maximum amount L2 gas that the operator may charge the user for single byte of pubdata.
            GasPerPubdataByte *big.Int

            // The address on L2 that will receive the refund for the transaction.
            // If the transaction fails, it will also be the address to receive L2Value.
            RefundRecipient common.Address

            Value     *big.Int // The amount of wei sent along with the call.
            Gas       uint64   // If 0, the call executes with near-infinite gas.
            GasPrice  *big.Int // Wei <-> gas exchange ratio.
            GasFeeCap *big.Int // EIP-1559 fee cap per gas.
            GasTipCap *big.Int // EIP-1559 tip per gas.

            AccessList types.AccessList // EIP-2930 access list.
}

func (m *RequestExecuteCallMsg) ToRequestExecuteTransaction() RequestExecuteTransaction
// Deprecated in favor of ToCallMsgWithChainID
func (m *RequestExecuteCallMsg) ToCallMsg(from common.Address) (ethereum.CallMsg, error)
func (m *RequestExecuteCallMsg) ToCallMsgWithChainID(from common.Address, chainID *big.Int) (ethereum.CallMsg, error)
func (m *RequestExecuteCallMsg) ToTransactOpts() TransactOpts

RequestExecuteTransaction

Represents a request execution of L2 transaction from L1 initiated by the account associated with AdapterL1.

type RequestExecuteTransaction struct {
            ContractAddress common.Address // The L2 receiver address.
            Calldata        []byte         // The input of the L2 transaction.
            L2GasLimit      *big.Int       // Maximum amount of L2 gas that transaction can consume during execution on L2.
  MintValue       *big.Int       // The amount of base token that needs to be minted on non-ETH-based L2.
  L2Value         *big.Int       // `msg.value` of L2 transaction.
            FactoryDeps     [][]byte       // An array of L2 bytecodes that will be marked as known on L2.

            // If the ETH value passed with the transaction is not explicitly stated Auth.Value,
            // this field will be equal to the tip the operator will receive on top of the base cost
            // of the transaction.
            OperatorTip *big.Int

            // The maximum amount L2 gas that the operator may charge the user for single byte of pubdata.
            GasPerPubdataByte *big.Int

            // The address on L2 that will receive the refund for the transaction.
            // If the transaction fails, it will also be the address to receive L2Value.
            RefundRecipient common.Address
}

func (t *RequestExecuteTransaction) ToRequestExecuteCallMsg(opts *TransactOpts) RequestExecuteCallMsg
func (t *RequestExecuteTransaction) ToCallMsg(from common.Address, opts *TransactOpts) zkTypes.CallMsg

Transaction

Transaction is similar to types.Transaction712 but does not include the From field. This design is intended for use abstraction which already have an associated account with AdapterL2. The From field is bound to the specific account, and thus, it is not included in this type.

type Transaction struct {
            To        *common.Address // The address of the recipient.
            Data      hexutil.Bytes   // Input data, usually an ABI-encoded contract method invocation.
            Value     *big.Int        // Funds to transfer along the transaction (nil = 0 = no funds).
            Nonce     *big.Int        // Nonce to use for the transaction execution.
            GasTipCap *big.Int        // EIP-1559 tip per gas.
            GasFeeCap *big.Int        // EIP-1559 fee cap per gas.
            Gas       uint64          // Gas limit to set for the transaction execution.

            AccessList types.AccessList // EIP-2930 access list.

            ChainID *big.Int            // Chain ID of the network.
            Meta    *zkTypes.Eip712Meta // EIP-712 metadata.
}

func (t *Transaction) ToTransaction712(from common.Address) *zkTypes.Transaction712
func (t *Transaction) ToCallMsg(from common.Address) zkTypes.CallMsg

TransactionBuilder

Populates missing fields in a tx with default values. The client is used to fetch data from the network if it is required.

type TransactionBuilder func(ctx context.Context, tx *zkTypes.Transaction712, secret interface{}, client *clients.BaseClient) error

TransactOpts

Contains common data required to create a valid transaction on both L1 and L2 using the account associated with AdapterL1, AdapterL2 or Deployer. Its primary purpose is to be transformed into bind.TransactOpts, wherein the From and Signer fields are linked to the associated account.

type TransactOpts struct {
            Nonce     *big.Int        // Nonce to use for the transaction execution (nil = use pending state).
            Value     *big.Int        // Funds to transfer along the transaction (nil = 0 = no funds).
            GasPrice  *big.Int        // Gas price to use for the transaction execution (nil = gas price oracle).
            GasFeeCap *big.Int        // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle).
            GasTipCap *big.Int        // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle).
            GasLimit  uint64          // Gas limit to set for the transaction execution (0 = estimate).
            Context   context.Context // Network context to support cancellation and timeouts (nil = no timeout).
}

func (t *TransactOpts) ToTransactOpts(from common.Address, signer bind.SignerFn) *bind.TransactOpts

TransferCallMsg

Contains the common data required to execute a transfer call on L2. This execution is initiated by the account associated with AdapterL2.

type TransferCallMsg struct {
            To     common.Address // The address of the recipient.
            Amount *big.Int       // The amount of the token to transfer.
            Token  common.Address // The address of the token. ETH by default.

            Gas       uint64   // If 0, the call executes with near-infinite gas.
            GasPrice  *big.Int // Wei <-> gas exchange ratio.
            GasFeeCap *big.Int // EIP-1559 fee cap per gas.
            GasTipCap *big.Int // EIP-1559 tip per gas.

            AccessList types.AccessList // EIP-2930 access list.
}

func (m *TransferCallMsg) ToTransferCallMsg(from common.Address) clients.TransferCallMsg

TransferTransaction

Represents a transfer transaction on L2 initiated by the account associated with AdapterL2.

type TransferTransaction struct {
            To     common.Address // The address of the recipient.
            Amount *big.Int       // The amount of the token to transfer.
            Token  common.Address // The address of the token. ETH by default.
}

func (t *TransferTransaction) ToTransaction(opts *TransactOpts) *Transaction
func (t *TransferTransaction) ToTransferCallMsg(from common.Address, opts *TransactOpts) clients.TransferCallMsg

WithdrawalCallMsg

Contains the common data required to execute a withdrawal call on L1 from L2. This execution is initiated by the account associated with AdapterL2

type WithdrawalCallMsg struct {
            To            common.Address  // The address of the recipient on L1.
            Amount        *big.Int        // The amount of the token to transfer.
            Token         common.Address  // The address of the token. ETH by default.
            BridgeAddress *common.Address // The address of the bridge contract to be used.

            Gas       uint64   // If 0, the call executes with near-infinite gas.
            GasPrice  *big.Int // Wei <-> gas exchange ratio.
            GasFeeCap *big.Int // EIP-1559 fee cap per gas.
            GasTipCap *big.Int // EIP-1559 tip per gas.

            AccessList types.AccessList // EIP-2930 access list.
}

func (m *WithdrawalCallMsg) ToWithdrawalCallMsg(from common.Address) clients.WithdrawalCallMsg

WithdrawalTransaction

Represents a withdrawal transaction on L1 from L2 initiated by the account associated with AdapterL2.

type WithdrawalTransaction struct {
            To     common.Address // The address that will receive the withdrawn tokens on L1.
            Token  common.Address // The address of the token to withdraw.
            Amount *big.Int       // The amount of the token to withdraw.

            // The address of the bridge contract to be used. Defaults to the default ZKsync bridge
            // (either L2EthBridge or L2Erc20Bridge).
            BridgeAddress *common.Address
}

func (t *WithdrawalTransaction) ToWithdrawalCallMsg(from common.Address, opts *TransactOpts) *clients.WithdrawalCallMsg

Made with ❤️ by the ZKsync Community