Types

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

type Cache struct {}

// NewCache creates an instance of Cache with the provided clients.
// Contracts returned from Cache are associated with the provided clients.
func NewCache(clientL2 *clients.Client, clientL1 *ethclient.Client) *Cache

// MainContractAddress returns the main contract address from cache.
// If not already cached, it fetches the addresses,
// caches it, and then returns the value from the cache.
func (c *Cache) MainContractAddress() (common.Address, error)
// BridgehubAddress returns the Bridgehub contract address from cache.
// If not already cached, it fetches the addresses,
// caches it, and then returns the value from the cache.
func (c *Cache) BridgehubAddress() (common.Address, error)
// L2DefaultBridgeAddress returns the L2 default bridge address from cache.
// If not already cached, it fetches the bridge addresses,
// caches them, and then returns the value from the cache.
func (c *Cache) L2DefaultBridgeAddress() (common.Address, error)
// L1DefaultBridgeAddress returns the L1 default bridge address from cache.
// If not already cached, it fetches the bridge addresses,
// caches them, and then returns the value from the cache.
func (c *Cache) L1DefaultBridgeAddress() (common.Address, error)
// L2SharedBridgeAddress returns the L2 shared bridge address from cache.
// If not already cached, it fetches the bridge addresses,
// caches them, and then returns the value from the cache.
func (c *Cache) L2SharedBridgeAddress() (common.Address, error)
// L1SharedBridgeAddress returns the L1  shared bridge address from cache.
// If not already cached, it fetches the bridge addresses,
// caches them, and then returns the value from the cache.
func (c *Cache) L1SharedBridgeAddress() (common.Address, error)
// MainContract returns the main contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) MainContract() (*hyperchain.IZkSyncHyperchain, error)
// Bridgehub returns the Bridgehub contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) Bridgehub() (*bridgehub.IBridgehub, error)
// L2BridgeContracts returns the L2 bridge contracts from cache.
// It is not cached, fetches the contracts, cache them and
// returns the value from cache.
func (c *Cache) L2BridgeContracts() (*types.L2BridgeContracts, error)
// L1BridgeContracts returns the L1 bridge contracts from cache.
// It is not cached, fetches the contracts, cache them and
// returns the value from cache.
func (c *Cache) L1BridgeContracts() (*types.L1BridgeContracts, error)
// L2DefaultBridge returns the L2 default bridge contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) L2DefaultBridge() (*l2bridge.IL2Bridge, error)
// L1DefaultBridge returns the L1 default bridge contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) L1DefaultBridge() (*l1bridge.IL1Bridge, error)
// L2SharedBridge returns the L2 shared bridge contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) L2SharedBridge() (*l2sharedbridge.IL2SharedBridge, error)
// L1SharedBridge returns the L2 shared bridge contract from cache.
// It is not cached, fetches the contract, cache it and
// returns the value from cache.
func (c *Cache) L1SharedBridge() (*l1sharedbridge.IL1SharedBridge, error)

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

 // GasPerPubdata denotes the maximum amount of gas the user is willing
 // to pay for a single byte of pubdata.
 GasPerPubdata *big.Int
 // CustomSignature is used for the cases in which the signer's account
 // is not an EOA.
 CustomSignature hexutil.Bytes
 // FactoryDeps is a non-empty array of bytes. For deployment transactions,
 // it should contain the bytecode of the contract being deployed.
 // If the contract is a factory contract, i.e. it can deploy other contracts,
 // the array should also contain the bytecodes of the contracts which it can deploy.
 FactoryDeps []hexutil.Bytes
 // PaymasterParams contains parameters for configuring the custom paymaster
 // for the transaction.
 PaymasterParams *types.PaymasterParams
}

// ToCallMsg transforms CallMsg to types.CallMsg.
func (m *CallMsg) ToCallMsg(from common.Address) types.CallMsg

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)
}

// ToCallOpts transforms CallOpts to bind.CallOpts.
func (o *CallOpts) ToCallOpts(from common.Address) *bind.CallOpts

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.
}

// ToTransaction transforms Create2Transaction to Transaction.
func (t *Create2Transaction) ToTransaction(deploymentType DeploymentType) (*Transaction, error)

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.
}

// ToTransaction transforms CreateTransaction to Transaction.
func (t *CreateTransaction) ToTransaction(deploymentType DeploymentType) (*Transaction, error)

type DeploymentType string

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

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

 BridgeAddress *common.Address // The address of the bridge contract to be used.

 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.
}

// ToDepositTransaction transforms DepositCallMsg to DepositTransaction.
func (m *DepositCallMsg) ToDepositTransaction() DepositTransaction
// ToRequestExecuteCallMsg transforms DepositCallMsg to RequestExecuteCallMsg.
func (m *DepositCallMsg) ToRequestExecuteCallMsg() RequestExecuteCallMsg
// ToCallMsg transforms DepositCallMsg to ethereum.CallMsg.
func (m *DepositCallMsg) ToCallMsg(from, l1Bridge common.Address) (ethereum.CallMsg, error)
// ToTransactOpts transforms DepositCallMsg to TransactOptsL1.
func (m *DepositCallMsg) ToTransactOpts() TransactOptsL1
// PopulateEmptyFields populates required empty fields with default values.
func (m *DepositCallMsg) PopulateEmptyFields(from common.Address)

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

 BridgeAddress *common.Address // The address of the bridge contract to be used.

 // 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 ApproveToken function beforehand.
 ApproveToken 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 ApproveToken function beforehand.
 ApproveBaseToken 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     *TransactOptsL1 // Authorization data for the token approval transaction.
 ApproveBaseAuth *TransactOptsL1 // Authorization data for the base token approval transaction.

}

// ToRequestExecuteTransaction transforms DepositTransaction to RequestExecuteTransaction.
func (t *DepositTransaction) ToRequestExecuteTransaction() *RequestExecuteTransaction
// ToDepositCallMsg transforms DepositTransaction to DepositCallMsg.
func (t *DepositTransaction) ToDepositCallMsg(opts *TransactOptsL1) DepositCallMsg
// PopulateEmptyFields populates required empty fields with default values.
func (t *DepositTransaction) PopulateEmptyFields(from common.Address)

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.
}

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

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.
}

// ToRequestExecuteTransaction transforms RequestExecuteCallMsg to RequestExecuteTransaction.
func (m *RequestExecuteCallMsg) ToRequestExecuteTransaction() RequestExecuteTransaction
// ToCallMsgWithChainID transforms RequestExecuteCallMsg to ethereum.CallMsg.
func (m *RequestExecuteCallMsg) ToCallMsgWithChainID(from common.Address, chainID *big.Int) (ethereum.CallMsg, error)
// ToTransactOpts transforms RequestExecuteCallMsg to TransactOptsL1.
func (m *RequestExecuteCallMsg) ToTransactOpts() TransactOptsL1

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
}

// ToRequestExecuteCallMsg transforms RequestExecuteTransaction to RequestExecuteCallMsg.
func (t *RequestExecuteTransaction) ToRequestExecuteCallMsg(opts *TransactOptsL1) RequestExecuteCallMsg
// ToCallMsg transforms RequestExecuteTransaction to types.CallMsg.
func (t *RequestExecuteTransaction) ToCallMsg(from common.Address, opts *TransactOptsL1) types.CallMsg

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.

 ChainID *big.Int // Chain ID of the network.

 // GasPerPubdata denotes the maximum amount of gas the user is willing
 // to pay for a single byte of pubdata.
 GasPerPubdata *big.Int `json:"gasPerPubdata,omitempty"`
 // CustomSignature is used for the cases in which the signer's account
 // is not an EOA.
 CustomSignature hexutil.Bytes `json:"customSignature,omitempty"`
 // FactoryDeps is a non-empty array of bytes. For deployment transactions,
 // it should contain the bytecode of the contract being deployed.
 // If the contract is a factory contract, i.e. it can deploy other contracts,
 // the array should also contain the bytecodes of the contracts which it can deploy.
 FactoryDeps []hexutil.Bytes `json:"factoryDeps"`
 // PaymasterParams contains parameters for configuring the custom paymaster
 // for the transaction.
 PaymasterParams *types.PaymasterParams `json:"paymasterParams,omitempty"`
}

// ToTransaction transforms Transaction to types.Transaction.
func (t *Transaction) ToTransaction(from common.Address) *types.Transaction
// ToCallMsg transforms Transaction to types.CallMsg.
func (t *Transaction) ToCallMsg(from common.Address) types.CallMsg

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

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).

 PaymasterParams *types.PaymasterParams // The paymaster parameters.
 // GasPerPubdata denotes the maximum amount of gas the user is willing
 // to pay for a single byte of pubdata.
 GasPerPubdata *big.Int
}

type TransactOptsL1 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).
}

// ToTransactOpts transforms TransactOptsL1 to bind.TransactOpts.
func (t *TransactOptsL1) ToTransactOpts(from common.Address, signer bind.SignerFn) *bind.TransactOpts

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.

 PaymasterParams *types.PaymasterParams // The paymaster parameters.
 // GasPerPubdata denotes the maximum amount of gas the user is willing
 // to pay for a single byte of pubdata.
 GasPerPubdata *big.Int
}

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

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.
}

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

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.

 PaymasterParams *types.PaymasterParams // The paymaster parameters.
 // GasPerPubdata denotes the maximum amount of gas the user is willing
 // to pay for a single byte of pubdata.
 GasPerPubdata *big.Int
}

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

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.
 BridgeAddress *common.Address // The address of the bridge contract to be used.
}

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