Snapshot notice
These contracts target protocol version 27, commit 9076929.

📦 Installation

To install with Foundry-ZKsync:

forge install matter-labs/zksync-contracts

Add the following to the remappings.txt file of your project:

@matterlabs/zksync-contracts/=lib/v2-testnet-contracts/

To install with Hardhat:

bun install @matterlabs/zksync-contracts

🚀 Quick start

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {IPaymaster} from
    "@matterlabs/zksync-contracts/contracts/system-contracts/interfaces/IPaymaster.sol";

contract MyPaymaster is IPaymaster {
    // Your implementation here
}

See more examples in the official docs.

📖 Documentation

• API reference: https://docs.zksync.io
• Canonical source: matter-labs/era-contracts

🤝 Contributing

Bug fixes, new snapshots, and added ABIs are welcome! Open an issue before large changes and follow the standard PR workflow.

📜 License

Dual-licensed under MIT / Apache-2.0. See LICENSE-MIT and LICENSE-APACHE.

Installation

To install with Foundry-ZKsync:

forge install matter-labs/zksync-contracts

Add the following to the remappings.txt file of your project:

@matterlabs/zksync-contracts/=lib/v2-testnet-contracts/

To install with Hardhat:

bun install @matterlabs/zksync-contracts

Getting Started

1. Add the package

   # Hardhat / npm / bun
   npm add @matterlabs/zksync-contracts
   # or Foundry
   forge install matter-labs/zksync-contracts
   

2. Implement a contract

   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.20;
   
   import {IPaymaster} from
       "@matterlabs/zksync-contracts/contracts/system-contracts/interfaces/IPaymaster.sol";
   
   contract MyPaymaster is IPaymaster {
       // implement paymaster logic here
   }
   

3. Build & test

   • Hardhat npx hardhat compile
   • Foundry forge build

Contents

• bridge
• bridgehub
• common
• governance
• state-transition
• vendor

Contents

• asset-router
• interfaces
• ntv
• EthTransferFailed
• NativeTokenVaultAlreadySet
• WrongMsgLength
• ZeroAmountToTransfer
• WrongAmountTransferred
• EmptyToken
• ClaimFailedDepositFailed
• WrongL2Sender
• WrongCounterpart

Contents

• IAssetRouterBase
• IAssetRouterBase constants
• IL1AssetRouter
• IL2AssetRouter

IAssetRouterBase

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

BRIDGE_HUB

function BRIDGE_HUB() external view returns (IBridgehub);

setAssetHandlerAddressThisChain

Sets the asset handler address for a specified asset ID on the chain of the asset deployment tracker.

The caller of this function is encoded within the assetId, therefore, it should be invoked by the asset deployment tracker contract.

No access control on the caller, as msg.sender is encoded in the assetId.

Typically, for most tokens, ADT is the native token vault. However, custom tokens may have their own specific asset deployment trackers.

setAssetHandlerAddressOnCounterpart should be called on L1 to set asset handlers on L2 chains for a specific asset ID.

function setAssetHandlerAddressThisChain(
  bytes32 _assetRegistrationData,
  address _assetHandlerAddress
) external;

Parameters

assetHandlerAddress

function assetHandlerAddress(bytes32 _assetId) external view returns (address);

finalizeDeposit

Finalize the withdrawal and release funds.

We have both the legacy finalizeWithdrawal and the new finalizeDeposit functions, finalizeDeposit uses the new format. On the L2 we have finalizeDeposit with new and old formats both.

function finalizeDeposit(
  uint256 _chainId,
  bytes32 _assetId,
  bytes memory _transferData
) external payable;

Parameters

Events

BridgehubDepositBaseTokenInitiated

event BridgehubDepositBaseTokenInitiated(
  uint256 indexed chainId, address indexed from, bytes32 assetId, uint256 amount
);

BridgehubDepositInitiated

event BridgehubDepositInitiated(
  uint256 indexed chainId,
  bytes32 indexed txDataHash,
  address indexed from,
  bytes32 assetId,
  bytes bridgeMintCalldata
);

BridgehubWithdrawalInitiated

event BridgehubWithdrawalInitiated(
  uint256 chainId,
  address indexed sender,
  bytes32 indexed assetId,
  bytes32 assetDataHash
);

AssetDeploymentTrackerRegistered

event AssetDeploymentTrackerRegistered(
  bytes32 indexed assetId,
  bytes32 indexed additionalData,
  address assetDeploymentTracker
);

AssetHandlerRegistered

event AssetHandlerRegistered(
  bytes32 indexed assetId, address indexed _assetHandlerAddress
);

DepositFinalizedAssetRouter

event DepositFinalizedAssetRouter(
  uint256 indexed chainId, bytes32 indexed assetId, bytes assetData
);

Constants

Git Source

LEGACY_ENCODING_VERSION

The encoding version used for legacy txs.

bytes1 constant LEGACY_ENCODING_VERSION = 0x00;

NEW_ENCODING_VERSION

The encoding version used for new txs.

bytes1 constant NEW_ENCODING_VERSION = 0x01;

SET_ASSET_HANDLER_COUNTERPART_ENCODING_VERSION

The encoding version used for txs that set the asset handler on the counterpart contract.

bytes1 constant SET_ASSET_HANDLER_COUNTERPART_ENCODING_VERSION = 0x02;

IL1AssetRouter

Git Source

Inherits: IAssetRouterBase, IL1SharedBridgeLegacy

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

depositLegacyErc20Bridge

Initiates a deposit by locking funds on the contract and sending the request of processing an L2 transaction where tokens would be minted.

If the token is bridged for the first time, the L2 token contract will be deployed. Note however, that the newly-deployed token does not support any custom logic, i.e. rebase tokens' functionality is not supported.

*If the L2 deposit finalization transaction fails, the _refundRecipient will receive the _l2Value. Please note, the contract may change the refund recipient's address to eliminate sending funds to addresses out of control.

• If _refundRecipient is a contract on L1, the refund will be sent to the aliased _refundRecipient.
• If _refundRecipient is set to address(0) and the sender has NO deployed bytecode on L1, the refund will be sent to the msg.sender address.
• If _refundRecipient is set to address(0) and the sender has deployed bytecode on L1, the refund will be sent to the aliased msg.sender address.*

The address aliasing of L1 contracts as refund recipient on L2 is necessary to guarantee that the funds are controllable through the Mailbox, since the Mailbox applies address aliasing to the from address for the L2 tx if the L1 msg.sender is a contract. Without address aliasing for L1 contracts as refund recipients they would not be able to make proper L2 tx requests through the Mailbox to use or withdraw the funds from L2, and the funds would be lost.

function depositLegacyErc20Bridge(
  address _originalCaller,
  address _l2Receiver,
  address _l1Token,
  uint256 _amount,
  uint256 _l2TxGasLimit,
  uint256 _l2TxGasPerPubdataByte,
  address _refundRecipient
) external payable returns (bytes32 txHash);

Parameters

Returns

L1_NULLIFIER

function L1_NULLIFIER() external view returns (IL1Nullifier);

L1_WETH_TOKEN

function L1_WETH_TOKEN() external view returns (address);

nativeTokenVault

function nativeTokenVault() external view returns (INativeTokenVault);

setAssetDeploymentTracker

function setAssetDeploymentTracker(
  bytes32 _assetRegistrationData,
  address _assetDeploymentTracker
) external;

setNativeTokenVault

function setNativeTokenVault(INativeTokenVault _nativeTokenVault) external;

setL1Erc20Bridge

function setL1Erc20Bridge(IL1ERC20Bridge _legacyBridge) external;

bridgeRecoverFailedTransfer

Withdraw funds from the initiated deposit, that failed when finalizing on L2.

Processes claims of failed deposit, whether they originated from the legacy bridge or the current system.

function bridgeRecoverFailedTransfer(
  uint256 _chainId,
  address _depositSender,
  bytes32 _assetId,
  bytes calldata _assetData
) external;

Parameters

bridgeRecoverFailedTransfer

Withdraw funds from the initiated deposit, that failed when finalizing on L2.

Processes claims of failed deposit, whether they originated from the legacy bridge or the current system.

function bridgeRecoverFailedTransfer(
  uint256 _chainId,
  address _depositSender,
  bytes32 _assetId,
  bytes memory _assetData,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
) external;

Parameters

transferFundsToNTV

Transfers funds to Native Token Vault, if the asset is registered with it. Does nothing for ETH or non-registered tokens.

assetId is not the padded address, but the correct encoded id (NTV stores respective format for IDs)

function transferFundsToNTV(
  bytes32 _assetId,
  uint256 _amount,
  address _originalCaller
) external returns (bool);

Parameters

finalizeWithdrawal

Finalize the withdrawal and release funds

function finalizeWithdrawal(
  uint256 _chainId,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes calldata _message,
  bytes32[] calldata _merkleProof
) external;

Parameters

bridgehubDeposit

Initiates a transfer transaction within Bridgehub, used by requestL2TransactionTwoBridges.

Data has the following abi encoding for legacy deposits: address _l1Token, uint256 _amount, address _l2Receiver for new deposits: bytes32 _assetId, bytes _transferData

function bridgehubDeposit(
  uint256 _chainId,
  address _originalCaller,
  uint256 _value,
  bytes calldata _data
) external payable returns (L2TransactionRequestTwoBridgesInner memory request);

Parameters

Returns

getDepositCalldata

Generates a calldata for calling the deposit finalization on the L2 native token contract.

function getDepositCalldata(
  address _sender,
  bytes32 _assetId,
  bytes memory _assetData
) external view returns (bytes memory);

Parameters

Returns

bridgehubDepositBaseToken

Allows bridgehub to acquire mintValue for L1->L2 transactions.

If the corresponding L2 transaction fails, refunds are issued to a refund recipient on L2.

function bridgehubDepositBaseToken(
  uint256 _chainId,
  bytes32 _assetId,
  address _originalCaller,
  uint256 _amount
) external payable;

Parameters

bridgehubConfirmL2Transaction

Routes the confirmation to nullifier for backward compatibility.

Confirms the acceptance of a transaction by the Mailbox, as part of the L2 transaction process within Bridgehub. This function is utilized by requestL2TransactionTwoBridges to validate the execution of a transaction.

function bridgehubConfirmL2Transaction(
  uint256 _chainId,
  bytes32 _txDataHash,
  bytes32 _txHash
) external;

Parameters

isWithdrawalFinalized

function isWithdrawalFinalized(
  uint256 _chainId,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex
) external view returns (bool);

Events

BridgehubMintData

event BridgehubMintData(bytes bridgeMintData);

BridgehubDepositFinalized

event BridgehubDepositFinalized(
  uint256 indexed chainId,
  bytes32 indexed txDataHash,
  bytes32 indexed l2DepositTxHash
);

ClaimedFailedDepositAssetRouter

event ClaimedFailedDepositAssetRouter(
  uint256 indexed chainId, bytes32 indexed assetId, bytes assetData
);

AssetDeploymentTrackerSet

event AssetDeploymentTrackerSet(
  bytes32 indexed assetId,
  address indexed assetDeploymentTracker,
  bytes32 indexed additionalData
);

LegacyDepositInitiated

event LegacyDepositInitiated(
  uint256 indexed chainId,
  bytes32 indexed l2DepositTxHash,
  address indexed from,
  address to,
  address l1Token,
  uint256 amount
);

IL2AssetRouter

Git Source

Inherits: IAssetRouterBase

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

withdraw

function withdraw(bytes32 _assetId, bytes calldata _transferData)
  external
  returns (bytes32);

L1_ASSET_ROUTER

function L1_ASSET_ROUTER() external view returns (address);

withdrawLegacyBridge

function withdrawLegacyBridge(
  address _l1Receiver,
  address _l2Token,
  uint256 _amount,
  address _sender
) external;

finalizeDepositLegacyBridge

function finalizeDepositLegacyBridge(
  address _l1Sender,
  address _l2Receiver,
  address _l1Token,
  uint256 _amount,
  bytes calldata _data
) external;

setAssetHandlerAddress

Used to set the assetHandlerAddress for a given assetId.

Will be used by ZK Gateway

function setAssetHandlerAddress(
  uint256 _originChainId,
  bytes32 _assetId,
  address _assetHandlerAddress
) external;

setLegacyTokenAssetHandler

Function that allows native token vault to register itself as the asset handler for a legacy asset.

function setLegacyTokenAssetHandler(bytes32 _assetId) external;

Parameters

Events

WithdrawalInitiatedAssetRouter

event WithdrawalInitiatedAssetRouter(
  uint256 chainId,
  address indexed l2Sender,
  bytes32 indexed assetId,
  bytes assetData
);

Contents

• AssetHandlerModifiers
• IAssetHandler
• IBridgedStandardToken
• IL1AssetDeploymentTracker
• IL1AssetHandler
• IL1BaseTokenAssetHandler
• IL1ERC20Bridge
• FinalizeL1DepositParams
• IL1Nullifier
• IL1SharedBridgeLegacy
• IL2SharedBridgeLegacy
• IL2SharedBridgeLegacyFunctions
• IL2WrappedBaseToken
• IWETH9

IAssetHandler

Git Source

Author: Matter Labs

Used for any asset handler and called by the AssetRouter

Note: security-contact: security@matterlabs.dev

Functions

bridgeMint

Note, that while payable, this function will only receive base token on L2 chains, while L1 the provided msg.value is always 0. However, this may change in the future, so if your AssetHandler implementation relies on it, it is better to explicitly check it.

function bridgeMint(uint256 _chainId, bytes32 _assetId, bytes calldata _data)
  external
  payable;

Parameters

bridgeBurn

Burns bridged tokens and returns the calldata for L2 <-> L1 message.

In case of native token vault _data is the tuple of _depositAmount and _l2Receiver.

function bridgeBurn(
  uint256 _chainId,
  uint256 _msgValue,
  bytes32 _assetId,
  address _originalCaller,
  bytes calldata _data
) external payable returns (bytes memory _bridgeMintData);

Parameters

Returns

Events

BridgeMint

Emitted when a token is minted

event BridgeMint(
  uint256 indexed chainId,
  bytes32 indexed assetId,
  address receiver,
  uint256 amount
);

BridgeBurn

Emitted when a token is burned

event BridgeBurn(
  uint256 indexed chainId,
  bytes32 indexed assetId,
  address indexed sender,
  address receiver,
  uint256 amount
);

IBridgedStandardToken

Git Source

Functions

bridgeMint

function bridgeMint(address _account, uint256 _amount) external;

bridgeBurn

function bridgeBurn(address _account, uint256 _amount) external;

l1Address

function l1Address() external view returns (address);

originToken

function originToken() external view returns (address);

l2Bridge

function l2Bridge() external view returns (address);

assetId

function assetId() external view returns (bytes32);

nativeTokenVault

function nativeTokenVault() external view returns (address);

Events

BridgeInitialize

event BridgeInitialize(
  address indexed l1Token, string name, string symbol, uint8 decimals
);

BridgeMint

event BridgeMint(address indexed account, uint256 amount);

BridgeBurn

event BridgeBurn(address indexed account, uint256 amount);

IL1AssetDeploymentTracker

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

bridgeCheckCounterpartAddress

function bridgeCheckCounterpartAddress(
  uint256 _chainId,
  bytes32 _assetId,
  address _originalCaller,
  address _assetHandlerAddressOnCounterpart
) external view;

IL1AssetHandler

Git Source

Author: Matter Labs

Used for any asset handler and called by the L1AssetRouter

Note: security-contact: security@matterlabs.dev

Functions

bridgeRecoverFailedTransfer

function bridgeRecoverFailedTransfer(
  uint256 _chainId,
  bytes32 _assetId,
  address _depositSender,
  bytes calldata _data
) external payable;

Parameters

IL1BaseTokenAssetHandler

Git Source

Author: Matter Labs

Used for any asset handler and called by the L1AssetRouter

Note: security-contact: security@matterlabs.dev

Functions

tokenAddress

Used to get the token address of an assetId

function tokenAddress(bytes32 _assetId) external view returns (address);

IL1ERC20Bridge

Git Source

Author: Matter Labs

Legacy Bridge interface before ZK chain migration, used for backward compatibility with ZKsync Era

Note: security-contact: security@matterlabs.dev

Functions

isWithdrawalFinalized

function isWithdrawalFinalized(uint256 _l2BatchNumber, uint256 _l2MessageIndex)
  external
  view
  returns (bool);

deposit

function deposit(
  address _l2Receiver,
  address _l1Token,
  uint256 _amount,
  uint256 _l2TxGasLimit,
  uint256 _l2TxGasPerPubdataByte,
  address _refundRecipient
) external payable returns (bytes32 txHash);

deposit

function deposit(
  address _l2Receiver,
  address _l1Token,
  uint256 _amount,
  uint256 _l2TxGasLimit,
  uint256 _l2TxGasPerPubdataByte
) external payable returns (bytes32 txHash);

claimFailedDeposit

function claimFailedDeposit(
  address _depositSender,
  address _l1Token,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
) external;

finalizeWithdrawal

function finalizeWithdrawal(
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes calldata _message,
  bytes32[] calldata _merkleProof
) external;

l2TokenAddress

function l2TokenAddress(address _l1Token) external view returns (address);

L1_NULLIFIER

function L1_NULLIFIER() external view returns (IL1Nullifier);

L1_ASSET_ROUTER

function L1_ASSET_ROUTER() external view returns (IL1AssetRouter);

L1_NATIVE_TOKEN_VAULT

function L1_NATIVE_TOKEN_VAULT() external view returns (IL1NativeTokenVault);

l2TokenBeacon

function l2TokenBeacon() external view returns (address);

l2Bridge

function l2Bridge() external view returns (address);

depositAmount

function depositAmount(
  address _account,
  address _l1Token,
  bytes32 _depositL2TxHash
) external view returns (uint256 amount);

Events

DepositInitiated

event DepositInitiated(
  bytes32 indexed l2DepositTxHash,
  address indexed from,
  address indexed to,
  address l1Token,
  uint256 amount
);

WithdrawalFinalized

event WithdrawalFinalized(
  address indexed to, address indexed l1Token, uint256 amount
);

ClaimedFailedDeposit

event ClaimedFailedDeposit(
  address indexed to, address indexed l1Token, uint256 amount
);

IL1Nullifier

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

isWithdrawalFinalized

function isWithdrawalFinalized(
  uint256 _chainId,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex
) external view returns (bool);

claimFailedDepositLegacyErc20Bridge

function claimFailedDepositLegacyErc20Bridge(
  address _depositSender,
  address _l1Token,
  uint256 _amount,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
) external;

claimFailedDeposit

function claimFailedDeposit(
  uint256 _chainId,
  address _depositSender,
  address _l1Token,
  uint256 _amount,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
) external;

finalizeDeposit

function finalizeDeposit(
  FinalizeL1DepositParams calldata _finalizeWithdrawalParams
) external;

BRIDGE_HUB

function BRIDGE_HUB() external view returns (IBridgehub);

legacyBridge

function legacyBridge() external view returns (IL1ERC20Bridge);

depositHappened

function depositHappened(uint256 _chainId, bytes32 _l2TxHash)
  external
  view
  returns (bytes32);

bridgehubConfirmL2TransactionForwarded

function bridgehubConfirmL2TransactionForwarded(
  uint256 _chainId,
  bytes32 _txDataHash,
  bytes32 _txHash
) external;

l1NativeTokenVault

function l1NativeTokenVault() external view returns (IL1NativeTokenVault);

setL1NativeTokenVault

function setL1NativeTokenVault(IL1NativeTokenVault _nativeTokenVault) external;

setL1AssetRouter

function setL1AssetRouter(address _l1AssetRouter) external;

chainBalance

function chainBalance(uint256 _chainId, address _token)
  external
  view
  returns (uint256);

l2BridgeAddress

function l2BridgeAddress(uint256 _chainId) external view returns (address);

transferTokenToNTV

function transferTokenToNTV(address _token) external;

nullifyChainBalanceByNTV

function nullifyChainBalanceByNTV(uint256 _chainId, address _token) external;

bridgeRecoverFailedTransfer

Withdraw funds from the initiated deposit, that failed when finalizing on L2.

Processes claims of failed deposit, whether they originated from the legacy bridge or the current system.

function bridgeRecoverFailedTransfer(
  uint256 _chainId,
  address _depositSender,
  bytes32 _assetId,
  bytes memory _assetData,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
) external;

Parameters

finalizeWithdrawal

Legacy function to finalize withdrawal via the same interface as the old L1SharedBridge.

Note, that we need to keep this interface, since the L2AssetRouter will continue returning the previous address as the l1SharedBridge. The value returned by it is used in the SDK for finalizing withdrawals.

function finalizeWithdrawal(
  uint256 _chainId,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes calldata _message,
  bytes32[] calldata _merkleProof
) external;

Parameters

Events

BridgehubDepositFinalized

event BridgehubDepositFinalized(
  uint256 indexed chainId,
  bytes32 indexed txDataHash,
  bytes32 indexed l2DepositTxHash
);

IL1SharedBridgeLegacy

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

l2BridgeAddress

function l2BridgeAddress(uint256 _chainId) external view returns (address);

IL2SharedBridgeLegacy

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

l2TokenBeacon

function l2TokenBeacon() external returns (UpgradeableBeacon);

withdraw

function withdraw(address _l1Receiver, address _l2Token, uint256 _amount)
  external;

l1TokenAddress

function l1TokenAddress(address _l2Token) external view returns (address);

l2TokenAddress

function l2TokenAddress(address _l1Token) external view returns (address);

l1Bridge

function l1Bridge() external view returns (address);

l1SharedBridge

function l1SharedBridge() external view returns (address);

deployBeaconProxy

function deployBeaconProxy(bytes32 _salt) external returns (address);

sendMessageToL1

function sendMessageToL1(bytes calldata _message) external returns (bytes32);

Events

FinalizeDeposit

event FinalizeDeposit(
  address indexed l1Sender,
  address indexed l2Receiver,
  address indexed l2Token,
  uint256 amount
);

IL2SharedBridgeLegacyFunctions

Git Source

Author: Matter Labs

Functions

finalizeDeposit

function finalizeDeposit(
  address _l1Sender,
  address _l2Receiver,
  address _l1Token,
  uint256 _amount,
  bytes calldata _data
) external;

Events

FinalizeDeposit

event FinalizeDeposit(
  address indexed l1Sender,
  address indexed l2Receiver,
  address indexed l2Token,
  uint256 amount
);

WithdrawalInitiated

event WithdrawalInitiated(
  address indexed l2Sender,
  address indexed l1Receiver,
  address indexed l2Token,
  uint256 amount
);

IL2WrappedBaseToken

Git Source

Functions

deposit

function deposit() external payable;

withdraw

function withdraw(uint256 _amount) external;

depositTo

function depositTo(address _to) external payable;

withdrawTo

function withdrawTo(address _to, uint256 _amount) external;

Events

Initialize

event Initialize(string name, string symbol, uint8 decimals);

IWETH9

Git Source

Functions

deposit

function deposit() external payable;

withdraw

function withdraw(uint256 wad) external;

Contents

• IL1NativeTokenVault
• IL2NativeTokenVault
• INativeTokenVault

IL1NativeTokenVault

Git Source

Inherits: INativeTokenVault, IL1AssetDeploymentTracker

Author: Matter Labs

The NTV is an Asset Handler for the L1AssetRouter to handle native tokens

Note: security-contact: security@matterlabs.dev

Functions

L1_NULLIFIER

The L1Nullifier contract

function L1_NULLIFIER() external view returns (IL1Nullifier);

chainBalance

Returns the total number of specific tokens locked for some chain

function chainBalance(uint256 _chainId, bytes32 _assetId)
  external
  view
  returns (uint256);

registerEthToken

Registers ETH token

function registerEthToken() external;

Events

TokenBeaconUpdated

event TokenBeaconUpdated(address indexed l2TokenBeacon);

IL2NativeTokenVault

Git Source

Inherits: INativeTokenVault

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

l2TokenAddress

function l2TokenAddress(address _l1Token) external view returns (address);

setLegacyTokenAssetId

function setLegacyTokenAssetId(address _l2TokenAddress) external;

Events

FinalizeDeposit

event FinalizeDeposit(
  address indexed l1Sender,
  address indexed l2Receiver,
  address indexed l2Token,
  uint256 amount
);

WithdrawalInitiated

event WithdrawalInitiated(
  address indexed l2Sender,
  address indexed l1Receiver,
  address indexed l2Token,
  uint256 amount
);

L2TokenBeaconUpdated

event L2TokenBeaconUpdated(
  address indexed l2TokenBeacon, bytes32 indexed l2TokenProxyBytecodeHash
);

INativeTokenVault

Git Source

Author: Matter Labs

The NTV is an Asset Handler for the L1AssetRouter to handle native tokens

Note: security-contact: security@matterlabs.dev

Functions

WETH_TOKEN

The Weth token address

function WETH_TOKEN() external view returns (address);

ASSET_ROUTER

The AssetRouter contract

function ASSET_ROUTER() external view returns (IAssetRouterBase);

L1_CHAIN_ID

The chain ID of the L1 chain

function L1_CHAIN_ID() external view returns (uint256);

originChainId

Returns the chain ID of the origin chain for a given asset ID

function originChainId(bytes32 assetId) external view returns (uint256);

registerToken

Registers tokens within the NTV.

Allows the bridge to register a token address for the vault.

No access control is ok, since the bridging of tokens should be permissionless. This requires permissionless registration.

The goal is to allow bridging native tokens automatically, by registering them on the fly.

function registerToken(address _l1Token) external;

ensureTokenIsRegistered

Ensures that the native token is registered with the NTV.

This function is used to ensure that the token is registered with the NTV.

function ensureTokenIsRegistered(address _nativeToken)
  external
  returns (bytes32);

getERC20Getters

Used to get the the ERC20 data for a token

function getERC20Getters(address _token, uint256 _originChainId)
  external
  view
  returns (bytes memory);

tokenAddress

Used to get the token address of an assetId

function tokenAddress(bytes32 assetId) external view returns (address);

assetId

Used to get the assetId of a token

function assetId(address token) external view returns (bytes32);

calculateCreate2TokenAddress

Used to get the expected bridged token address corresponding to its native counterpart

function calculateCreate2TokenAddress(
  uint256 _originChainId,
  address _originToken
) external view returns (address);

tryRegisterTokenFromBurnData

Tries to register a token from the provided _burnData and reverts if it is not possible.

function tryRegisterTokenFromBurnData(
  bytes calldata _burnData,
  bytes32 _expectedAssetId
) external;

Events

BridgedTokenBeaconUpdated

event BridgedTokenBeaconUpdated(
  address bridgedTokenBeacon, bytes32 bridgedTokenProxyBytecodeHash
);

Bridge Errors

EthTransferFailed

Git Source

error EthTransferFailed();

NativeTokenVaultAlreadySet

Git Source

error NativeTokenVaultAlreadySet();

WrongMsgLength

Git Source

error WrongMsgLength(uint256 expected, uint256 length);

ZeroAmountToTransfer

Git Source

error ZeroAmountToTransfer();

WrongAmountTransferred

Git Source

error WrongAmountTransferred(uint256 balance, uint256 nullifierChainBalance);

EmptyToken

Git Source

error EmptyToken();

ClaimFailedDepositFailed

Git Source

error ClaimFailedDepositFailed();

WrongL2Sender

Git Source

error WrongL2Sender(address providedL2Sender);

WrongCounterpart

Git Source

error WrongCounterpart();

Contents

• L2TransactionRequestDirect
• L2TransactionRequestTwoBridgesOuter
• L2TransactionRequestTwoBridgesInner
• BridgehubMintCTMAssetData
• BridgehubBurnCTMAssetData
• IBridgehub
• ICTMDeploymentTracker
• IMessageRoot
• NotRelayedSender
• NotAssetRouter
• ChainIdAlreadyPresent
• ChainNotPresentInCTM
• AssetIdAlreadyRegistered
• CTMNotRegistered
• ChainIdNotRegistered
• SecondBridgeAddressTooLow
• NotInGatewayMode
• SLNotWhitelisted
• IncorrectChainAssetId
• NotCurrentSL
• HyperchainNotRegistered
• IncorrectSender
• AlreadyCurrentSL
• ChainExists
• MessageRootNotRegistered
• NoEthAllowed
• NotOwner
• WrongCounterPart
• NotL1
• OnlyBridgehub
• OnlyChain
• NotOwnerViaRouter
• ChainNotLegacy

IBridgehub

Git Source

Inherits: IAssetHandler, IL1AssetHandler

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

setPendingAdmin

Starts the transfer of admin rights. Only the current admin or owner can propose a new pending one.

New admin can accept admin rights by calling acceptAdmin function.

function setPendingAdmin(address _newPendingAdmin) external;

Parameters

acceptAdmin

Accepts transfer of admin rights. Only pending admin can accept the role.

function acceptAdmin() external;

chainTypeManagerIsRegistered

Getters

function chainTypeManagerIsRegistered(address _chainTypeManager)
  external
  view
  returns (bool);

chainTypeManager

function chainTypeManager(uint256 _chainId) external view returns (address);

assetIdIsRegistered

function assetIdIsRegistered(bytes32 _baseTokenAssetId)
  external
  view
  returns (bool);

baseToken

function baseToken(uint256 _chainId) external view returns (address);

baseTokenAssetId

function baseTokenAssetId(uint256 _chainId) external view returns (bytes32);

sharedBridge

function sharedBridge() external view returns (address);

messageRoot

function messageRoot() external view returns (IMessageRoot);

getZKChain

function getZKChain(uint256 _chainId) external view returns (address);

getAllZKChains

function getAllZKChains() external view returns (address[] memory);

getAllZKChainChainIDs

function getAllZKChainChainIDs() external view returns (uint256[] memory);

migrationPaused

function migrationPaused() external view returns (bool);

admin

function admin() external view returns (address);

assetRouter

function assetRouter() external view returns (address);

proveL2MessageInclusion

Mailbox forwarder

function proveL2MessageInclusion(
  uint256 _chainId,
  uint256 _batchNumber,
  uint256 _index,
  L2Message calldata _message,
  bytes32[] calldata _proof
) external view returns (bool);

proveL2LogInclusion

function proveL2LogInclusion(
  uint256 _chainId,
  uint256 _batchNumber,
  uint256 _index,
  L2Log memory _log,
  bytes32[] calldata _proof
) external view returns (bool);

proveL1ToL2TransactionStatus

function proveL1ToL2TransactionStatus(
  uint256 _chainId,
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof,
  TxStatus _status
) external view returns (bool);

requestL2TransactionDirect

function requestL2TransactionDirect(
  L2TransactionRequestDirect calldata _request
) external payable returns (bytes32 canonicalTxHash);

requestL2TransactionTwoBridges

function requestL2TransactionTwoBridges(
  L2TransactionRequestTwoBridgesOuter calldata _request
) external payable returns (bytes32 canonicalTxHash);

l2TransactionBaseCost

function l2TransactionBaseCost(
  uint256 _chainId,
  uint256 _gasPrice,
  uint256 _l2GasLimit,
  uint256 _l2GasPerPubdataByteLimit
) external view returns (uint256);

createNewChain

function createNewChain(
  uint256 _chainId,
  address _chainTypeManager,
  bytes32 _baseTokenAssetId,
  uint256 _salt,
  address _admin,
  bytes calldata _initData,
  bytes[] calldata _factoryDeps
) external returns (uint256 chainId);

addChainTypeManager

function addChainTypeManager(address _chainTypeManager) external;

removeChainTypeManager

function removeChainTypeManager(address _chainTypeManager) external;

addTokenAssetId

function addTokenAssetId(bytes32 _baseTokenAssetId) external;

setAddresses

function setAddresses(
  address _sharedBridge,
  ICTMDeploymentTracker _l1CtmDeployer,
  IMessageRoot _messageRoot
) external;

whitelistedSettlementLayers

function whitelistedSettlementLayers(uint256 _chainId)
  external
  view
  returns (bool);

registerSettlementLayer

function registerSettlementLayer(
  uint256 _newSettlementLayerChainId,
  bool _isWhitelisted
) external;

settlementLayer

function settlementLayer(uint256 _chainId) external view returns (uint256);

forwardTransactionOnGateway

function forwardTransactionOnGateway(
  uint256 _chainId,
  bytes32 _canonicalTxHash,
  uint64 _expirationTimestamp
) external;

ctmAssetIdFromChainId

function ctmAssetIdFromChainId(uint256 _chainId)
  external
  view
  returns (bytes32);

ctmAssetIdFromAddress

function ctmAssetIdFromAddress(address _ctmAddress)
  external
  view
  returns (bytes32);

l1CtmDeployer

function l1CtmDeployer() external view returns (ICTMDeploymentTracker);

ctmAssetIdToAddress

function ctmAssetIdToAddress(bytes32 _assetInfo)
  external
  view
  returns (address);

setCTMAssetAddress

function setCTMAssetAddress(bytes32 _additionalData, address _assetAddress)
  external;

L1_CHAIN_ID

function L1_CHAIN_ID() external view returns (uint256);

registerAlreadyDeployedZKChain

function registerAlreadyDeployedZKChain(uint256 _chainId, address _hyperchain)
  external;

getHyperchain

return the ZK chain contract for a chainId

It is a legacy method. Do not use!

function getHyperchain(uint256 _chainId) external view returns (address);

registerLegacyChain

function registerLegacyChain(uint256 _chainId) external;

pauseMigration

function pauseMigration() external;

unpauseMigration

function unpauseMigration() external;

Events

NewPendingAdmin

pendingAdmin is changed

Also emitted when new admin is accepted and in this case, newPendingAdmin would be zero address

event NewPendingAdmin(
  address indexed oldPendingAdmin, address indexed newPendingAdmin
);

NewAdmin

Admin changed

event NewAdmin(address indexed oldAdmin, address indexed newAdmin);

AssetRegistered

CTM asset registered

event AssetRegistered(
  bytes32 indexed assetInfo,
  address indexed _assetAddress,
  bytes32 indexed additionalData,
  address sender
);

SettlementLayerRegistered

event SettlementLayerRegistered(
  uint256 indexed chainId, bool indexed isWhitelisted
);

MigrationStarted

Emitted when the bridging to the chain is started.

event MigrationStarted(
  uint256 indexed chainId,
  bytes32 indexed assetId,
  uint256 indexed settlementLayerChainId
);

Parameters

MigrationFinalized

Emitted when the bridging to the chain is complete.

event MigrationFinalized(
  uint256 indexed chainId, bytes32 indexed assetId, address indexed zkChain
);

Parameters

NewChain

event NewChain(
  uint256 indexed chainId,
  address chainTypeManager,
  address indexed chainGovernance
);

ChainTypeManagerAdded

event ChainTypeManagerAdded(address indexed chainTypeManager);

ChainTypeManagerRemoved

event ChainTypeManagerRemoved(address indexed chainTypeManager);

BaseTokenAssetIdRegistered

event BaseTokenAssetIdRegistered(bytes32 indexed assetId);

ICTMDeploymentTracker

Git Source

Inherits: IL1AssetDeploymentTracker

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

bridgehubDeposit

function bridgehubDeposit(
  uint256 _chainId,
  address _originalCaller,
  uint256 _l2Value,
  bytes calldata _data
) external payable returns (L2TransactionRequestTwoBridgesInner memory request);

BRIDGE_HUB

function BRIDGE_HUB() external view returns (IBridgehub);

L1_ASSET_ROUTER

function L1_ASSET_ROUTER() external view returns (IAssetRouterBase);

registerCTMAssetOnL1

function registerCTMAssetOnL1(address _ctmAddress) external;

calculateAssetId

function calculateAssetId(address _l1CTM) external view returns (bytes32);

IMessageRoot

Git Source

Author: Matter Labs

MessageRoot contract is responsible for storing and aggregating the roots of the batches from different chains into the MessageRoot.

Note: security-contact: security@matterlabs.dev

Functions

BRIDGE_HUB

function BRIDGE_HUB() external view returns (IBridgehub);

addNewChain

function addNewChain(uint256 _chainId) external;

addChainBatchRoot

function addChainBatchRoot(
  uint256 _chainId,
  uint256 _batchNumber,
  bytes32 _chainBatchRoot
) external;

Contents

• interfaces
• libraries
• PriorityTreeCommitment
• ZKChainCommitment
• Config constants
• AccessToFallbackDenied
• AccessToFunctionDenied
• OnlySelfAllowed
• RestrictionWasNotPresent
• RestrictionWasAlreadyPresent
• CallNotAllowed
• RemovingPermanentRestriction
• UnallowedImplementation
• AddressAlreadySet
• AddressHasNoCode
• AddressMismatch
• AmountMustBeGreaterThanZero
• AssetHandlerDoesNotExist
• AssetIdMismatch
• AssetIdAlreadyRegistered
• AlreadyWhitelisted
• AssetIdNotSupported
• BaseTokenGasPriceDenominatorNotSet
• BatchHashMismatch
• BatchNotExecuted
• BatchNumberMismatch
• BridgeHubAlreadyRegistered
• BridgeMintNotImplemented
• CanOnlyProcessOneBatch
• CantExecuteUnprovenBatches
• CantRevertExecutedBatch
• ChainIdAlreadyExists
• ChainIdCantBeCurrentChain
• ChainIdMismatch
• ChainIdNotRegistered
• ChainIdTooBig
• DelegateCallFailed
• DenominatorIsZero
• DeployFailed
• DeployingBridgedTokenForNativeToken
• DepositDoesNotExist
• DepositExists
• DiamondAlreadyFrozen
• DiamondNotFrozen
• EmptyAddress
• EmptyAssetId
• EmptyBytes32
• EmptyDeposit
• ETHDepositNotSupported
• FacetExists
• GasPerPubdataMismatch
• GenesisBatchCommitmentZero
• GenesisBatchHashZero
• GenesisIndexStorageZero
• GenesisUpgradeZero
• HashedLogIsDefault
• HashMismatch
• ZKChainLimitReached
• IncorrectBridgeHubAddress
• InsufficientChainBalance
• InvalidCaller
• InvalidDelay
• InvalidLogSender
• InvalidNumberOfBlobs
• InvalidProof
• InvalidProtocolVersion
• InvalidPubdataPricingMode
• InvalidSelector
• InvalidUpgradeTxn
• L2TimestampTooBig
• L2WithdrawalMessageWrongLength
• LengthIsNotDivisibleBy32
• LogAlreadyProcessed
• MalformedBytecode
• MerkleIndexOutOfBounds
• MerklePathEmpty
• MerklePathOutOfBounds
• MigrationPaused
• MissingSystemLogs
• MsgValueMismatch
• MsgValueTooLow
• NoCallsProvided
• NoFunctionsForDiamondCut
• NoFundsTransferred
• NonEmptyCalldata
• NonEmptyMsgValue
• NonIncreasingTimestamp
• NonSequentialBatch
• NonSequentialVersion
• NotInitializedReentrancyGuard
• NotWhitelisted
• OnlyEraSupported
• OperationExists
• OperationMustBePending
• OperationMustBeReady
• OriginChainIdNotFound
• PreviousOperationNotExecuted
• PriorityOperationsRollingHashMismatch
• PriorityTxPubdataExceedsMaxPubDataPerBatch
• ProtocolIdMismatch
• ProtocolIdNotGreater
• PubdataGreaterThanLimit
• QueueIsEmpty
• Reentrancy
• RemoveFunctionFacetAddressNotZero
• RemoveFunctionFacetAddressZero
• ReplaceFunctionFacetAddressZero
• RevertedBatchNotAfterNewLastBatch
• SelectorsMustAllHaveSameFreezability
• SharedBridgeValueNotSet
• SharedBridgeNotSet
• SlotOccupied
• CTMAlreadyRegistered
• CTMNotRegistered
• SystemLogsSizeTooBig
• TimeNotReached
• TimestampError
• TokenNotSupported
• TokensWithFeesNotSupported
• TooManyFactoryDeps
• TooMuchGas
• TransactionNotAllowed
• TxHashMismatch
• TxnBodyGasLimitNotEnoughGas
• Unauthorized
• UndefinedDiamondCutAction
• UnexpectedSystemLog
• UpgradeBatchNumberIsNotZero
• UnsupportedEncodingVersion
• ValidateTxnNotEnoughGas
• ValueMismatch
• VerifiedBatchesExceedsCommittedBatches
• WithdrawalAlreadyFinalized
• WithdrawFailed
• WrongMagicValue
• ZeroAddress
• ZeroChainId
• EmptyData
• UnsupportedCommitBatchEncoding
• UnsupportedProofBatchEncoding
• UnsupportedExecuteBatchEncoding
• IncorrectBatchBounds
• AssetHandlerNotRegistered
• NotARestriction
• NotAllowed
• BytecodeAlreadyPublished
• CallerNotTimerAdmin
• DeadlineNotYetPassed
• NewDeadlineNotGreaterThanCurrent
• NewDeadlineExceedsMaxDeadline
• AlreadyPermanentRollup
• InvalidDAForPermanentRollup
• TimerAlreadyStarted
• MerklePathLengthMismatch
• MerkleNothingToProve
• MerkleIndexOrHeightMismatch
• MerkleWrongIndex
• MerkleWrongLength
• NoCTMForAssetId
• SettlementLayersMustSettleOnL1
• TokenNotLegacy
• IncorrectTokenAddressFromNTV
• InvalidProofLengthForFinalNode
• LegacyEncodingUsedForNonL1Token
• TokenIsLegacy
• LegacyBridgeUsesNonNativeToken
• AssetRouterAllowanceNotZero
• BurningNativeWETHNotSupported
• NoLegacySharedBridge
• TooHighDeploymentNonce
• ChainAlreadyLive
• MigrationsNotPaused
• WrappedBaseTokenAlreadyRegistered
• InvalidNTVBurnData
• InvalidSystemLogsLength
• LegacyBridgeNotSet
• LegacyMethodForNonL1Token
• UnknownVerifierType
• EmptyProofLength
• SharedBridgeKey
• BytecodeError
• UpgradeTxVerifyParam
• IL2ToL1Messenger
• L2ContractAddresses constants
• TxStatus
• L2Log
• L2Message
• WritePriorityOpParams
• L2CanonicalTransaction
• BridgehubL2TransactionRequest

IL1Messenger

Git Source

Author: Matter Labs

The interface of the L1 Messenger contract, responsible for sending messages to L1.

Note: security-contact: security@matterlabs.dev

Functions

sendToL1

function sendToL1(bytes calldata _message) external returns (bytes32);

IL2ContractDeployer

Git Source

Author: Matter Labs

System smart contract that is responsible for deploying other smart contracts on a ZK chain.

Functions

allowedBytecodeTypesToDeploy

Returns what types of bytecode are allowed to be deployed on this chain

function allowedBytecodeTypesToDeploy()
  external
  view
  returns (AllowedBytecodeTypes mode);

forceDeployOnAddresses

This method is to be used only during an upgrade to set bytecodes on specific addresses.

function forceDeployOnAddresses(ForceDeployment[] calldata _deployParams)
  external;

create2

Deploys a contract with similar address derivation rules to the EVM's CREATE2 opcode.

function create2(bytes32 _salt, bytes32 _bytecodeHash, bytes calldata _input)
  external;

Parameters

setAllowedBytecodeTypesToDeploy

Changes what types of bytecodes are allowed to be deployed on the chain.

function setAllowedBytecodeTypesToDeploy(
  AllowedBytecodeTypes newAllowedBytecodeTypes
) external;

Parameters

Structs

ForceDeployment

A struct that describes a forced deployment on an address.

struct ForceDeployment {
  bytes32 bytecodeHash;
  address newAddress;
  bool callConstructor;
  uint256 value;
  bytes input;
}

Properties

Contents

• restriction
• Call
• IAccessControlRestriction
• IChainAdmin
• IChainAdminOwnable
• IGovernance
• IPermanentRestriction

Contents

• IRestriction
• IRestriction constants
• RestrictionValidator

IRestriction

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

getSupportsRestrictionMagic

A method used to check that the contract supports this interface.

function getSupportsRestrictionMagic() external view returns (bytes32);

Returns

validateCall

Ensures that the invoker has the required role to call the function.

function validateCall(Call calldata _call, address _invoker) external view;

Parameters

Constants

Git Source

RESTRICTION_MAGIC

The magic value that has to be returned by the getSupportsRestrictionMagic

bytes32 constant RESTRICTION_MAGIC = keccak256("Restriction");

IAccessControlRestriction

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Events

RoleSet

Emitted when the required role for a specific function is set.

event RoleSet(
  address indexed target, bytes4 indexed selector, bytes32 requiredRole
);

FallbackRoleSet

Emitted when the required role for a fallback function is set.

event FallbackRoleSet(address indexed target, bytes32 requiredRole);

IChainAdmin

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

getRestrictions

Returns the list of active restrictions.

function getRestrictions() external view returns (address[] memory);

isRestrictionActive

Checks if the restriction is active.

function isRestrictionActive(address _restriction) external view returns (bool);

Parameters

addRestriction

Adds a new restriction to the active restrictions set.

function addRestriction(address _restriction) external;

Parameters

removeRestriction

Removes a restriction from the active restrictions set.

Sometimes restrictions might need to enforce their permanence (e.g. if a chain should be a rollup forever).

function removeRestriction(address _restriction) external;

Parameters

multicall

Execute multiple calls as part of contract administration.

Intended for batch processing of contract interactions, managing gas efficiency and atomicity of operations.

Note, that this function lacks access control. It is expected that the access control is implemented in a separate restriction contract.

Even though all the validation from external modules is executed via staticcall, the function is marked as nonReentrant to prevent reentrancy attacks in case the staticcall restriction is lifted in the future.

function multicall(Call[] calldata _calls, bool _requireSuccess)
  external
  payable;

Parameters

Events

UpdateUpgradeTimestamp

Emitted when the expected upgrade timestamp for a specific protocol version is set.

event UpdateUpgradeTimestamp(
  uint256 indexed protocolVersion, uint256 upgradeTimestamp
);

CallExecuted

Emitted when the call is executed from the contract.

event CallExecuted(Call call, bool success, bytes returnData);

RestrictionAdded

Emitted when a new restriction is added.

event RestrictionAdded(address indexed restriction);

RestrictionRemoved

Emitted when a restriction is removed.

event RestrictionRemoved(address indexed restriction);

EnableEvmEmulator

The EVM emulator has been enabled

event EnableEvmEmulator();

IChainAdminOwnable

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

setTokenMultiplierSetter

function setTokenMultiplierSetter(address _tokenMultiplierSetter) external;

setUpgradeTimestamp

function setUpgradeTimestamp(
  uint256 _protocolVersion,
  uint256 _upgradeTimestamp
) external;

multicall

function multicall(Call[] calldata _calls, bool _requireSuccess)
  external
  payable;

setTokenMultiplier

function setTokenMultiplier(
  IAdmin _chainContract,
  uint128 _nominator,
  uint128 _denominator
) external;

Events

UpdateUpgradeTimestamp

Emitted when the expected upgrade timestamp for a specific protocol version is set.

event UpdateUpgradeTimestamp(
  uint256 indexed _protocolVersion, uint256 _upgradeTimestamp
);

CallExecuted

Emitted when the call is executed from the contract.

event CallExecuted(Call _call, bool _success, bytes _returnData);

NewTokenMultiplierSetter

Emitted when the new token multiplier address is set.

event NewTokenMultiplierSetter(
  address _oldTokenMultiplierSetter, address _newTokenMultiplierSetter
);

Structs

Call

Represents a call to be made during multicall.

struct Call {
  address target;
  uint256 value;
  bytes data;
}

Properties

IGovernance

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

isOperation

function isOperation(bytes32 _id) external view returns (bool);

isOperationPending

function isOperationPending(bytes32 _id) external view returns (bool);

isOperationReady

function isOperationReady(bytes32 _id) external view returns (bool);

isOperationDone

function isOperationDone(bytes32 _id) external view returns (bool);

getOperationState

function getOperationState(bytes32 _id) external view returns (OperationState);

scheduleTransparent

function scheduleTransparent(Operation calldata _operation, uint256 _delay)
  external;

scheduleShadow

function scheduleShadow(bytes32 _id, uint256 _delay) external;

cancel

function cancel(bytes32 _id) external;

execute

function execute(Operation calldata _operation) external payable;

executeInstant

function executeInstant(Operation calldata _operation) external payable;

hashOperation

function hashOperation(Operation calldata _operation)
  external
  pure
  returns (bytes32);

updateDelay

function updateDelay(uint256 _newDelay) external;

updateSecurityCouncil

function updateSecurityCouncil(address _newSecurityCouncil) external;

Events

TransparentOperationScheduled

Emitted when transparent operation is scheduled.

event TransparentOperationScheduled(
  bytes32 indexed _id, uint256 delay, Operation _operation
);

ShadowOperationScheduled

Emitted when shadow operation is scheduled.

event ShadowOperationScheduled(bytes32 indexed _id, uint256 delay);

OperationExecuted

Emitted when the operation is executed with delay or instantly.

event OperationExecuted(bytes32 indexed _id);

ChangeSecurityCouncil

Emitted when the security council address is changed.

event ChangeSecurityCouncil(
  address _securityCouncilBefore, address _securityCouncilAfter
);

ChangeMinDelay

Emitted when the minimum delay for future operations is modified.

event ChangeMinDelay(uint256 _delayBefore, uint256 _delayAfter);

OperationCancelled

Emitted when the operation with specified id is cancelled.

event OperationCancelled(bytes32 indexed _id);

Structs

Operation

Defines the structure of an operation that Governance executes.

struct Operation {
  Call[] calls;
  bytes32 predecessor;
  bytes32 salt;
}

Properties

Enums

OperationState

This enumeration includes the following states:

enum OperationState {
  Unset,
  Waiting,
  Ready,
  Done
}

IPermanentRestriction

Git Source

Author: Matter Labs

The interface for the permanent restriction contract.

Note: security-contact: security@matterlabs.dev

Events

AdminImplementationAllowed

Emitted when the implementation is allowed or disallowed.

event AdminImplementationAllowed(
  bytes32 indexed implementationHash, bool isAllowed
);

AllowedDataChanged

Emitted when a certain calldata is allowed or disallowed.

event AllowedDataChanged(bytes data, bool isAllowed);

SelectorValidationChanged

Emitted when the selector is labeled as validated or not.

event SelectorValidationChanged(bytes4 indexed selector, bool isValidated);

AllowL2Admin

Emitted when the L2 admin is whitelisted or not.

event AllowL2Admin(address indexed adminAddress);

Contents

• chain-deps
• chain-interfaces
• l2-deps
• libraries
• ChainTypeManagerInitializeData
• ChainCreationParams
• IChainTypeManager
• L1DAValidatorAddressIsZero
• L2DAValidatorAddressIsZero
• AlreadyMigrated
• NotChainAdmin
• ProtocolVersionNotUpToDate
• ExecutedIsNotConsistentWithVerified
• VerifiedIsNotConsistentWithCommitted
• InvalidNumberOfBatchHashes
• PriorityQueueNotReady
• UnsupportedProofMetadataVersion
• LocalRootIsZero
• LocalRootMustBeZero
• NotSettlementLayer
• NotHyperchain
• MismatchL2DAValidator
• MismatchNumberOfLayer1Txs
• InvalidBatchesDataLength
• PriorityOpsDataLeftPathLengthIsNotZero
• PriorityOpsDataRightPathLengthIsNotZero
• PriorityOpsDataItemHashesLengthIsNotZero
• OperatorDAInputTooSmall
• InvalidNumberOfBlobs
• InvalidL2DAOutputHash
• OnlyOneBlobWithCalldataAllowed
• PubdataInputTooSmall
• PubdataLengthTooBig
• InvalidPubdataHash
• InvalidPubdataSource
• BlobHashBlobCommitmentMismatchValue
• L1DAValidatorInvalidSender
• InvalidCommitment
• InitialForceDeploymentMismatch
• AdminZero
• OutdatedProtocolVersion
• NotL1
• InvalidStartIndex
• InvalidUnprocessedIndex
• InvalidNextLeafIndex
• NotAllBatchesExecuted
• NotHistoricalRoot
• ContractNotDeployed
• NotMigrated
• ValL1DAWrongInputLength

Contents

• IAdmin
• InitializeData
• InitializeDataNewChain
• IDiamondInit
• SystemLogKey
• LogProcessingOutput
• IExecutor
• IExecutor constants
• IGetters
• PubdataSource
• L1DAValidatorOutput
• IL1DAValidator
• ILegacyGetters
• IMailbox
• ITransactionFilterer
• VerifierParams
• IVerifier
• IVerifierV2
• IZKChain
• IZKChainBase

IAdmin

Git Source

Inherits: IZKChainBase

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

setPendingAdmin

Starts the transfer of admin rights. Only the current admin can propose a new pending one.

New admin can accept admin rights by calling acceptAdmin function.

function setPendingAdmin(address _newPendingAdmin) external;

Parameters

acceptAdmin

Accepts transfer of admin rights. Only pending admin can accept the role.

function acceptAdmin() external;

setValidator

Change validator status (active or not active)

function setValidator(address _validator, bool _active) external;

Parameters

setPorterAvailability

Change zk porter availability

function setPorterAvailability(bool _zkPorterIsAvailable) external;

Parameters

setPriorityTxMaxGasLimit

Change the max L2 gas limit for L1 -> L2 transactions

function setPriorityTxMaxGasLimit(uint256 _newPriorityTxMaxGasLimit) external;

Parameters

changeFeeParams

Change the fee params for L1->L2 transactions

function changeFeeParams(FeeParams calldata _newFeeParams) external;

Parameters

setTokenMultiplier

Change the token multiplier for L1->L2 transactions

function setTokenMultiplier(uint128 _nominator, uint128 _denominator) external;

setPubdataPricingMode

Change the pubdata pricing mode before the first batch is processed

function setPubdataPricingMode(PubdataPricingMode _pricingMode) external;

Parameters

setTransactionFilterer

Set the transaction filterer

function setTransactionFilterer(address _transactionFilterer) external;

allowEvmEmulation

Allow EVM emulation on chain

function allowEvmEmulation() external returns (bytes32 canonicalTxHash);

upgradeChainFromVersion

Perform the upgrade from the current protocol version with the corresponding upgrade data

function upgradeChainFromVersion(
  uint256 _protocolVersion,
  Diamond.DiamondCutData calldata _cutData
) external;

Parameters

executeUpgrade

Executes a proposed governor upgrade

Only the ChainTypeManager contract can execute the upgrade

function executeUpgrade(Diamond.DiamondCutData calldata _diamondCut) external;

Parameters

freezeDiamond

Instantly pause the functionality of all freezable facets & their selectors

Only the governance mechanism may freeze Diamond Proxy

function freezeDiamond() external;

unfreezeDiamond

Unpause the functionality of all freezable facets & their selectors

Only the CTM can unfreeze Diamond Proxy

function unfreezeDiamond() external;

genesisUpgrade

function genesisUpgrade(
  address _l1GenesisUpgrade,
  address _ctmDeployer,
  bytes calldata _forceDeploymentData,
  bytes[] calldata _factoryDeps
) external;

setDAValidatorPair

Set the L1 DA validator address as well as the L2 DA validator address.

While in principle it is possible that updating only one of the addresses is needed, usually these should work in pair and L1 validator typically expects a specific input from the L2 Validator. That's why we change those together to prevent admins of chains from shooting themselves in the foot.

function setDAValidatorPair(address _l1DAValidator, address _l2DAValidator)
  external;

Parameters

makePermanentRollup

Makes the chain as permanent rollup.

This is a security feature needed for chains that should be trusted to keep their data available even if the chain admin becomes malicious and tries to set the DA validator pair to something which does not publish DA to Ethereum.

DANGEROUS: once activated, there is no way back!

function makePermanentRollup() external;

forwardedBridgeBurn

Similar to IL1AssetHandler interface, used to send chains.

function forwardedBridgeBurn(
  address _settlementLayer,
  address _originalCaller,
  bytes calldata _data
) external payable returns (bytes memory _bridgeMintData);

forwardedBridgeRecoverFailedTransfer

Similar to IL1AssetHandler interface, used to claim failed chain transfers.

function forwardedBridgeRecoverFailedTransfer(
  uint256 _chainId,
  bytes32 _assetInfo,
  address _originalCaller,
  bytes calldata _chainData
) external payable;

forwardedBridgeMint

Similar to IL1AssetHandler interface, used to receive chains.

function forwardedBridgeMint(
  bytes calldata _data,
  bool _contractAlreadyDeployed
) external payable;

prepareChainCommitment

function prepareChainCommitment()
  external
  view
  returns (ZKChainCommitment memory commitment);

Events

IsPorterAvailableStatusUpdate

Porter availability status changes

event IsPorterAvailableStatusUpdate(bool isPorterAvailable);

ValidatorStatusUpdate

Validator's status changed

event ValidatorStatusUpdate(address indexed validatorAddress, bool isActive);

NewPendingAdmin

pendingAdmin is changed

Also emitted when new admin is accepted and in this case, newPendingAdmin would be zero address

event NewPendingAdmin(
  address indexed oldPendingAdmin, address indexed newPendingAdmin
);

NewAdmin

Admin changed

event NewAdmin(address indexed oldAdmin, address indexed newAdmin);

NewPriorityTxMaxGasLimit

Priority transaction max L2 gas limit changed

event NewPriorityTxMaxGasLimit(
  uint256 oldPriorityTxMaxGasLimit, uint256 newPriorityTxMaxGasLimit
);

NewFeeParams

Fee params for L1->L2 transactions changed

event NewFeeParams(FeeParams oldFeeParams, FeeParams newFeeParams);

PubdataPricingModeUpdate

Validium mode status changed

event PubdataPricingModeUpdate(PubdataPricingMode validiumMode);

NewTransactionFilterer

The transaction filterer has been updated

event NewTransactionFilterer(
  address oldTransactionFilterer, address newTransactionFilterer
);

NewBaseTokenMultiplier

BaseToken multiplier for L1->L2 transactions changed

event NewBaseTokenMultiplier(
  uint128 oldNominator,
  uint128 oldDenominator,
  uint128 newNominator,
  uint128 newDenominator
);

ExecuteUpgrade

Emitted when an upgrade is executed.

event ExecuteUpgrade(Diamond.DiamondCutData diamondCut);

MigrationComplete

Emitted when the migration to the new settlement layer is complete.

event MigrationComplete();

Freeze

Emitted when the contract is frozen.

event Freeze();

Unfreeze

Emitted when the contract is unfrozen.

event Unfreeze();

EnableEvmEmulator

The EVM emulator has been enabled

event EnableEvmEmulator();

NewL2DAValidator

New pair of DA validators set

event NewL2DAValidator(
  address indexed oldL2DAValidator, address indexed newL2DAValidator
);

NewL1DAValidator

event NewL1DAValidator(
  address indexed oldL1DAValidator, address indexed newL1DAValidator
);

BridgeMint

event BridgeMint(address indexed _account, uint256 _amount);

IDiamondInit

Git Source

Functions

initialize

function initialize(InitializeData calldata _initData)
  external
  returns (bytes32);

IExecutor

Git Source

Inherits: IZKChainBase

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

commitBatchesSharedBridge

Function called by the operator to commit new batches. It is responsible for:

• Verifying the correctness of their timestamps.
• Processing their L2->L1 logs.
• Storing batch commitments.

function commitBatchesSharedBridge(
  uint256 _chainId,
  uint256 _processFrom,
  uint256 _processTo,
  bytes calldata _commitData
) external;

Parameters

proveBatchesSharedBridge

Batches commitment verification.

Only verifies batch commitments without any other processing.

function proveBatchesSharedBridge(
  uint256 _chainId,
  uint256 _processBatchFrom,
  uint256 _processBatchTo,
  bytes calldata _proofData
) external;

Parameters

executeBatchesSharedBridge

The function called by the operator to finalize (execute) batches. It is responsible for:

• Processing all pending operations (commpleting priority requests).
• Finalizing this batch (i.e. allowing to withdraw funds from the system)

function executeBatchesSharedBridge(
  uint256 _chainId,
  uint256 _processFrom,
  uint256 _processTo,
  bytes calldata _executeData
) external;

Parameters

revertBatchesSharedBridge

Reverts unexecuted batches

function revertBatchesSharedBridge(uint256 _chainId, uint256 _newLastBatch)
  external;

Parameters

Events

BlockCommit

Event emitted when a batch is committed

It has the name "BlockCommit" and not "BatchCommit" due to backward compatibility considerations

event BlockCommit(
  uint256 indexed batchNumber,
  bytes32 indexed batchHash,
  bytes32 indexed commitment
);

Parameters

BlocksVerification

Event emitted when batches are verified

It has the name "BlocksVerification" and not "BatchesVerification" due to backward compatibility considerations

event BlocksVerification(
  uint256 indexed previousLastVerifiedBatch,
  uint256 indexed currentLastVerifiedBatch
);

Parameters

BlockExecution

Event emitted when a batch is executed

It has the name "BlockExecution" and not "BatchExecution" due to backward compatibility considerations

event BlockExecution(
  uint256 indexed batchNumber,
  bytes32 indexed batchHash,
  bytes32 indexed commitment
);

Parameters

BlocksRevert

Event emitted when batches are reverted

It has the name "BlocksRevert" and not "BatchesRevert" due to backward compatibility considerations

event BlocksRevert(
  uint256 totalBatchesCommitted,
  uint256 totalBatchesVerified,
  uint256 totalBatchesExecuted
);

Parameters

Structs

StoredBatchInfo

Rollup batch stored data

struct StoredBatchInfo {
  uint64 batchNumber;
  bytes32 batchHash;
  uint64 indexRepeatedStorageChanges;
  uint256 numberOfLayer1Txs;
  bytes32 priorityOperationsHash;
  bytes32 l2LogsTreeRoot;
  uint256 timestamp;
  bytes32 commitment;
}

Properties

CommitBatchInfo

Data needed to commit new batch

pubdataCommitments format: This will always start with a 1 byte pubdataSource flag. Current allowed values are 0 (calldata) or 1 (blobs) kzg: list of: opening point (16 bytes) || claimed value (32 bytes) || commitment (48 bytes) || proof (48 bytes) = 144 bytes calldata: pubdataCommitments.length - 1 - 32 bytes of pubdata and 32 bytes appended to serve as the blob commitment part for the aux output part of the batch commitment

For 2 blobs we will be sending 288 bytes of calldata instead of the full amount for pubdata.

When using calldata, we only need to send one blob commitment since the max number of bytes in calldata fits in a single blob and we can pull the linear hash from the system logs

struct CommitBatchInfo {
  uint64 batchNumber;
  uint64 timestamp;
  uint64 indexRepeatedStorageChanges;
  bytes32 newStateRoot;
  uint256 numberOfLayer1Txs;
  bytes32 priorityOperationsHash;
  bytes32 bootloaderHeapInitialContentsHash;
  bytes32 eventsQueueStateHash;
  bytes systemLogs;
  bytes operatorDAInput;
}

Properties

Constants

Git Source

L2_LOG_ADDRESS_OFFSET

Offset used to pull Address From Log. Equal to 4 (bytes for isService)

uint256 constant L2_LOG_ADDRESS_OFFSET = 4;

L2_LOG_KEY_OFFSET

Offset used to pull Key From Log. Equal to 4 (bytes for isService) + 20 (bytes for address)

uint256 constant L2_LOG_KEY_OFFSET = 24;

L2_LOG_VALUE_OFFSET

Offset used to pull Value From Log. Equal to 4 (bytes for isService) + 20 (bytes for address) + 32 (bytes for key)

uint256 constant L2_LOG_VALUE_OFFSET = 56;

MAX_NUMBER_OF_BLOBS

Max number of blobs currently supported

uint256 constant MAX_NUMBER_OF_BLOBS = 6;

TOTAL_BLOBS_IN_COMMITMENT

The number of blobs that must be present in the commitment to a batch. It represents the maximal number of blobs that circuits can support and can be larger than the maximal number of blobs supported by the contract (MAX_NUMBER_OF_BLOBS).

uint256 constant TOTAL_BLOBS_IN_COMMITMENT = 16;

IGetters

Git Source

Inherits: IZKChainBase

Author: Matter Labs

Most of the methods simply return the values that correspond to the current diamond proxy and possibly not to the ZK Chain as a whole. For example, if the chain is migrated to another settlement layer, the values returned by this facet will correspond to the values stored on this chain and possilbly not the canonical state of the chain.

Note: security-contact: security@matterlabs.dev

Functions

getVerifier

function getVerifier() external view returns (address);

Returns

getAdmin

function getAdmin() external view returns (address);

Returns

getPendingAdmin

function getPendingAdmin() external view returns (address);

Returns

getBridgehub

function getBridgehub() external view returns (address);

Returns

getChainTypeManager

function getChainTypeManager() external view returns (address);

Returns

getChainId

function getChainId() external view returns (uint256);

Returns

getBaseToken

function getBaseToken() external view returns (address);

Returns

getBaseTokenAssetId

function getBaseTokenAssetId() external view returns (bytes32);

Returns

getTotalBatchesCommitted

function getTotalBatchesCommitted() external view returns (uint256);

Returns

getTotalBatchesVerified

function getTotalBatchesVerified() external view returns (uint256);

Returns

getTotalBatchesExecuted

function getTotalBatchesExecuted() external view returns (uint256);

Returns

getTransactionFilterer

function getTransactionFilterer() external view returns (address);

getTotalPriorityTxs

function getTotalPriorityTxs() external view returns (uint256);

Returns

getPriorityTreeStartIndex

function getPriorityTreeStartIndex() external view returns (uint256);

Returns

getPriorityTreeRoot

function getPriorityTreeRoot() external view returns (bytes32);

Returns

isPriorityQueueActive

function isPriorityQueueActive() external view returns (bool);

Returns

getFirstUnprocessedPriorityTx

The function that returns the first unprocessed priority transaction.

Returns zero if and only if no operations were processed from the queue.

If all the transactions were processed, it will return the last processed index, so in case exactly unprocessed transactions are needed, one should check that getPriorityQueueSize() is greater than 0.

function getFirstUnprocessedPriorityTx() external view returns (uint256);

Returns

getPriorityQueueSize

function getPriorityQueueSize() external view returns (uint256);

Returns

isValidator

function isValidator(address _address) external view returns (bool);

Returns

l2LogsRootHash

function l2LogsRootHash(uint256 _batchNumber)
  external
  view
  returns (bytes32 merkleRoot);

Returns

storedBatchHash

For unfinalized (non executed) batches may change

returns zero for non-committed batches

function storedBatchHash(uint256 _batchNumber) external view returns (bytes32);

Returns

getL2BootloaderBytecodeHash

function getL2BootloaderBytecodeHash() external view returns (bytes32);

Returns

getL2DefaultAccountBytecodeHash

function getL2DefaultAccountBytecodeHash() external view returns (bytes32);

Returns

getL2EvmEmulatorBytecodeHash

function getL2EvmEmulatorBytecodeHash() external view returns (bytes32);

Returns

getVerifierParams

This function is deprecated and will soon be removed.

function getVerifierParams() external view returns (VerifierParams memory);

Returns

isDiamondStorageFrozen

function isDiamondStorageFrozen() external view returns (bool);

Returns

getProtocolVersion

function getProtocolVersion() external view returns (uint256);

Returns

getSemverProtocolVersion

function getSemverProtocolVersion()
  external
  view
  returns (uint32, uint32, uint32);

Returns

getL2SystemContractsUpgradeTxHash

function getL2SystemContractsUpgradeTxHash() external view returns (bytes32);

Returns

getL2SystemContractsUpgradeBatchNumber

*It is equal to 0 in the following two cases:

• No upgrade transaction has ever been processed.
• The upgrade transaction has been processed and the batch with such transaction has been executed (i.e. finalized).*

function getL2SystemContractsUpgradeBatchNumber()
  external
  view
  returns (uint256);

Returns

getPriorityTxMaxGasLimit

function getPriorityTxMaxGasLimit() external view returns (uint256);

Returns

isEthWithdrawalFinalized

function isEthWithdrawalFinalized(
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex
) external view returns (bool);

Parameters

Returns

getPubdataPricingMode

function getPubdataPricingMode() external view returns (PubdataPricingMode);

Returns

baseTokenGasPriceMultiplierNominator

function baseTokenGasPriceMultiplierNominator() external view returns (uint128);

Returns

baseTokenGasPriceMultiplierDenominator

function baseTokenGasPriceMultiplierDenominator()
  external
  view
  returns (uint128);

Returns

facets

function facets() external view returns (Facet[] memory);

Returns

facetFunctionSelectors

function facetFunctionSelectors(address _facet)
  external
  view
  returns (bytes4[] memory);

Returns

facetAddresses

function facetAddresses() external view returns (address[] memory facets);

Returns

facetAddress

function facetAddress(bytes4 _selector) external view returns (address facet);

Returns

isFunctionFreezable

function isFunctionFreezable(bytes4 _selector) external view returns (bool);

Returns

isFacetFreezable

function isFacetFreezable(address _facet)
  external
  view
  returns (bool isFreezable);

Returns

getSettlementLayer

function getSettlementLayer() external view returns (address);

Returns

Structs

Facet

Faсet structure compatible with the EIP-2535 diamond loupe

struct Facet {
  address addr;
  bytes4[] selectors;
}

Properties

IL1DAValidator

Git Source

Functions

checkDA

The function that checks the data availability for the given batch input.

function checkDA(
  uint256 _chainId,
  uint256 _batchNumber,
  bytes32 _l2DAValidatorOutputHash,
  bytes calldata _operatorDAInput,
  uint256 _maxBlobsSupported
) external returns (L1DAValidatorOutput memory output);

Parameters

ILegacyGetters

Git Source

Inherits: IZKChainBase

Author: Matter Labs

This interface contains getters for the ZKsync contract that should not be used, but still are kept for backward compatibility.

Note: security-contact: security@matterlabs.dev

Functions

getTotalBlocksCommitted

It is a deprecated method, please use getTotalBatchesCommitted instead

function getTotalBlocksCommitted() external view returns (uint256);

Returns

getTotalBlocksVerified

It is a deprecated method, please use getTotalBatchesVerified instead.

function getTotalBlocksVerified() external view returns (uint256);

Returns

getTotalBlocksExecuted

It is a deprecated method, please use getTotalBatchesExecuted instead.

function getTotalBlocksExecuted() external view returns (uint256);

Returns

storedBlockHash

For unfinalized (non executed) batches may change

It is a deprecated method, please use storedBatchHash instead.

returns zero for non-committed batches

function storedBlockHash(uint256 _batchNumber) external view returns (bytes32);

Returns

getL2SystemContractsUpgradeBlockNumber

It is a deprecated method, please use getL2SystemContractsUpgradeBatchNumber instead.

*It is equal to 0 in the following two cases:

• No upgrade transaction has ever been processed.
• The upgrade transaction has been processed and the batch with such transaction has been executed (i.e. finalized).*

function getL2SystemContractsUpgradeBlockNumber()
  external
  view
  returns (uint256);

Returns

IMailbox

Git Source

Inherits: IZKChainBase

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

proveL2MessageInclusion

Prove that a specific arbitrary-length message was sent in a specific L2 batch number

function proveL2MessageInclusion(
  uint256 _batchNumber,
  uint256 _index,
  L2Message calldata _message,
  bytes32[] calldata _proof
) external view returns (bool);

Parameters

Returns

proveL2LogInclusion

Prove that a specific L2 log was sent in a specific L2 batch

function proveL2LogInclusion(
  uint256 _batchNumber,
  uint256 _index,
  L2Log memory _log,
  bytes32[] calldata _proof
) external view returns (bool);

Parameters

Returns

proveL1ToL2TransactionStatus

Prove that the L1 -> L2 transaction was processed with the specified status.

function proveL1ToL2TransactionStatus(
  bytes32 _l2TxHash,
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof,
  TxStatus _status
) external view returns (bool);

Parameters

Returns

finalizeEthWithdrawal

Finalize the withdrawal and release funds

function finalizeEthWithdrawal(
  uint256 _l2BatchNumber,
  uint256 _l2MessageIndex,
  uint16 _l2TxNumberInBatch,
  bytes calldata _message,
  bytes32[] calldata _merkleProof
) external;

Parameters

requestL2Transaction

Request execution of L2 transaction from L1.

*If the L2 deposit finalization transaction fails, the _refundRecipient will receive the _l2Value. Please note, the contract may change the refund recipient's address to eliminate sending funds to addresses out of control.

• If _refundRecipient is a contract on L1, the refund will be sent to the aliased _refundRecipient.
• If _refundRecipient is set to address(0) and the sender has NO deployed bytecode on L1, the refund will be sent to the msg.sender address.
• If _refundRecipient is set to address(0) and the sender has deployed bytecode on L1, the refund will be sent to the aliased msg.sender address.*

The address aliasing of L1 contracts as refund recipient on L2 is necessary to guarantee that the funds are controllable, since address aliasing to the from address for the L2 tx will be applied if the L1 msg.sender is a contract. Without address aliasing for L1 contracts as refund recipients they would not be able to make proper L2 tx requests through the Mailbox to use or withdraw the funds from L2, and the funds would be lost.

function requestL2Transaction(
  address _contractL2,
  uint256 _l2Value,
  bytes calldata _calldata,
  uint256 _l2GasLimit,
  uint256 _l2GasPerPubdataByteLimit,
  bytes[] calldata _factoryDeps,
  address _refundRecipient
) external payable returns (bytes32 canonicalTxHash);

Parameters

Returns

bridgehubRequestL2Transaction

when requesting transactions through the bridgehub

function bridgehubRequestL2Transaction(
  BridgehubL2TransactionRequest calldata _request
) external returns (bytes32 canonicalTxHash);

bridgehubRequestL2TransactionOnGateway

On the Gateway the chain's mailbox receives the tx from the bridgehub.

function bridgehubRequestL2TransactionOnGateway(
  bytes32 _canonicalTxHash,
  uint64 _expirationTimestamp
) external;

requestL2ServiceTransaction

Request execution of service L2 transaction from L1.

Used for chain configuration. Can be called only by DiamondProxy itself.

function requestL2ServiceTransaction(
  address _contractL2,
  bytes calldata _l2Calldata
) external returns (bytes32 canonicalTxHash);

Parameters

requestL2TransactionToGatewayMailbox

On L1 we have to forward to the Gateway's mailbox which sends to the Bridgehub on the Gw

function requestL2TransactionToGatewayMailbox(
  uint256 _chainId,
  bytes32 _canonicalTxHash,
  uint64 _expirationTimestamp
) external returns (bytes32 canonicalTxHash);

Parameters

l2TransactionBaseCost

Estimates the cost in Ether of requesting execution of an L2 transaction from L1

function l2TransactionBaseCost(
  uint256 _gasPrice,
  uint256 _l2GasLimit,
  uint256 _l2GasPerPubdataByteLimit
) external view returns (uint256);

Parameters

Returns

proveL2LeafInclusion

Proves that a certain leaf was included as part of the log merkle tree.

Warning: this function does not enforce any additional checks on the structure of the leaf. This means that it can accept intermediate nodes of the Merkle tree as a _leaf as well as the default "empty" leaves. It is the responsibility of the caller to ensure that the _leaf is a hash of a valid leaf.

function proveL2LeafInclusion(
  uint256 _batchNumber,
  uint256 _batchRootMask,
  bytes32 _leaf,
  bytes32[] calldata _proof
) external view returns (bool);

Events

NewPriorityRequest

transfer Eth to shared bridge as part of migration process

New priority request event. Emitted when a request is placed into the priority queue

event NewPriorityRequest(
  uint256 txId,
  bytes32 txHash,
  uint64 expirationTimestamp,
  L2CanonicalTransaction transaction,
  bytes[] factoryDeps
);

Parameters

NewRelayedPriorityTransaction

New relayed priority request event. It is emitted on a chain that is deployed on top of the gateway when it receives a request relayed via the Bridgehub.

IMPORTANT: this event most likely will be removed in the future, so no one should rely on it for indexing purposes.

event NewRelayedPriorityTransaction(
  uint256 txId, bytes32 txHash, uint64 expirationTimestamp
);

Parameters

ITransactionFilterer

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

isTransactionAllowed

Check if the transaction is allowed

function isTransactionAllowed(
  address sender,
  address contractL2,
  uint256 mintValue,
  uint256 l2Value,
  bytes memory l2Calldata,
  address refundRecipient
) external view returns (bool);

Parameters

Returns

IVerifier

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

verify

Verifies a zk-SNARK proof.

function verify(uint256[] calldata _publicInputs, uint256[] calldata _proof)
  external
  view
  returns (bool);

Returns

verificationKeyHash

Calculates a keccak256 hash of the runtime loaded verification keys.

function verificationKeyHash() external view returns (bytes32);

Returns

IVerifierV2

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

verify

Verifies a zk-SNARK proof.

function verify(uint256[] calldata _publicInputs, uint256[] calldata _proof)
  external
  view
  returns (bool);

Returns

verificationKeyHash

Calculates a keccak256 hash of the runtime loaded verification keys.

function verificationKeyHash() external view returns (bytes32);

Returns

IZKChain

Git Source

Inherits: IAdmin, IExecutor, IGetters, IMailbox

Events

ProposeTransparentUpgrade

event ProposeTransparentUpgrade(
  Diamond.DiamondCutData diamondCut,
  uint256 indexed proposalId,
  bytes32 proposalSalt
);

IZKChainBase

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

getName

function getName() external view returns (string memory);

Returns

Contents

• IComplexUpgrader
• IL2GatewayUpgrade
• ForceDeployment
• ZKChainSpecificForceDeploymentsData
• IL2GenesisUpgrade
• ISystemContext

IComplexUpgrader

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

forceDeployAndUpgrade

function forceDeployAndUpgrade(
  IL2ContractDeployer.ForceDeployment[] calldata _forceDeployments,
  address _delegateTo,
  bytes calldata _calldata
) external payable;

upgrade

function upgrade(address _delegateTo, bytes calldata _calldata)
  external
  payable;

IL2GatewayUpgrade

Git Source

Functions

upgrade

function upgrade(
  IL2ContractDeployer.ForceDeployment[] calldata _forceDeployments,
  address _ctmDeployer,
  bytes calldata _fixedForceDeploymentsData,
  bytes calldata _additionalForceDeploymentsData
) external payable;

IL2GenesisUpgrade

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

genesisUpgrade

function genesisUpgrade(
  uint256 _chainId,
  address _ctmDeployer,
  bytes calldata _fixedForceDeploymentsData,
  bytes calldata _additionalForceDeploymentsData
) external payable;

Events

UpgradeComplete

event UpgradeComplete(uint256 _chainId);

ISystemContext

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

setChainId

function setChainId(uint256 _newChainId) external;

Contents

• AddressAliasHelper

AddressAliasHelper

Git Source

State Variables

offset

uint160 private constant offset =
  uint160(0x1111000000000000000000000000000000001111);

Functions

applyL1ToL2Alias

Utility function converts the address that submitted a tx to the inbox on L1 to the msg.sender viewed on L2

function applyL1ToL2Alias(address l1Address)
  internal
  pure
  returns (address l2Address);

Parameters

Returns

undoL1ToL2Alias

Utility function that converts the msg.sender viewed on L2 to the address that submitted a tx to the inbox on L1

function undoL1ToL2Alias(address l2Address)
  internal
  pure
  returns (address l1Address);

Parameters

Returns

actualRefundRecipient

Utility function used to calculate the correct refund recipient

function actualRefundRecipient(
  address _refundRecipient,
  address _originalCaller
) internal view returns (address _recipient);

Parameters

Returns

Contents

• data-availability
• errors
• interfaces
• vendor
• IL1Messenger
• IContractDeployer
• IBaseToken
• ICompressor
• IPubdataChunkPublisher
• L2ContractHelper
• Transaction
• L2ContractHelper constants
• CalldataForwardingMode
• U32CastOverflow
• Utils
• SystemContractsCaller
• SystemContractsCaller constants

Contents

• IConsensusRegistry
• IL2DAValidator
• ExecutionResult
• IPaymaster
• IPaymaster constants
• IPaymasterFlow

IConsensusRegistry

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

add

function add(
  address _nodeOwner,
  uint32 _validatorWeight,
  BLS12_381PublicKey calldata _validatorPubKey,
  BLS12_381Signature calldata _validatorPoP,
  uint32 _attesterWeight,
  Secp256k1PublicKey calldata _attesterPubKey
) external;

deactivate

function deactivate(address _nodeOwner) external;

activate

function activate(address _nodeOwner) external;

remove

function remove(address _nodeOwner) external;

changeValidatorWeight

function changeValidatorWeight(address _nodeOwner, uint32 _weight) external;

changeAttesterWeight

function changeAttesterWeight(address _nodeOwner, uint32 _weight) external;

changeValidatorKey

function changeValidatorKey(
  address _nodeOwner,
  BLS12_381PublicKey calldata _pubKey,
  BLS12_381Signature calldata _pop
) external;

changeAttesterKey

function changeAttesterKey(
  address _nodeOwner,
  Secp256k1PublicKey calldata _pubKey
) external;

commitAttesterCommittee

function commitAttesterCommittee() external;

commitValidatorCommittee

function commitValidatorCommittee() external;

getAttesterCommittee

function getAttesterCommittee()
  external
  view
  returns (CommitteeAttester[] memory);

getValidatorCommittee

function getValidatorCommittee()
  external
  view
  returns (CommitteeValidator[] memory);

Events

NodeAdded

event NodeAdded(
  address indexed nodeOwner,
  uint32 validatorWeight,
  BLS12_381PublicKey validatorPubKey,
  BLS12_381Signature validatorPoP,
  uint32 attesterWeight,
  Secp256k1PublicKey attesterPubKey
);

NodeDeactivated

event NodeDeactivated(address indexed nodeOwner);

NodeActivated

event NodeActivated(address indexed nodeOwner);

NodeRemoved

event NodeRemoved(address indexed nodeOwner);

NodeDeleted

event NodeDeleted(address indexed nodeOwner);

NodeValidatorWeightChanged

event NodeValidatorWeightChanged(address indexed nodeOwner, uint32 newWeight);

NodeAttesterWeightChanged

event NodeAttesterWeightChanged(address indexed nodeOwner, uint32 newWeight);

NodeValidatorKeyChanged

event NodeValidatorKeyChanged(
  address indexed nodeOwner,
  BLS12_381PublicKey newPubKey,
  BLS12_381Signature newPoP
);

NodeAttesterKeyChanged

event NodeAttesterKeyChanged(
  address indexed nodeOwner, Secp256k1PublicKey newPubKey
);

ValidatorsCommitted

event ValidatorsCommitted(uint32 commit);

AttestersCommitted

event AttestersCommitted(uint32 commit);

Errors

UnauthorizedOnlyOwnerOrNodeOwner

error UnauthorizedOnlyOwnerOrNodeOwner();

NodeOwnerExists

error NodeOwnerExists();

NodeOwnerDoesNotExist

error NodeOwnerDoesNotExist();

NodeOwnerNotFound

error NodeOwnerNotFound();

ValidatorPubKeyExists

error ValidatorPubKeyExists();

AttesterPubKeyExists

error AttesterPubKeyExists();

InvalidInputNodeOwnerAddress

error InvalidInputNodeOwnerAddress();

InvalidInputBLS12_381PublicKey

error InvalidInputBLS12_381PublicKey();

InvalidInputBLS12_381Signature

error InvalidInputBLS12_381Signature();

InvalidInputSecp256k1PublicKey

error InvalidInputSecp256k1PublicKey();

Structs

Node

Represents a consensus node.

struct Node {
  uint32 attesterLastUpdateCommit;
  uint32 validatorLastUpdateCommit;
  uint32 nodeOwnerIdx;
  AttesterAttr attesterLatest;
  AttesterAttr attesterSnapshot;
  ValidatorAttr validatorLatest;
  ValidatorAttr validatorSnapshot;
}

Properties

AttesterAttr

Represents the attester attributes of a consensus node.

struct AttesterAttr {
  bool active;
  bool removed;
  uint32 weight;
  Secp256k1PublicKey pubKey;
}

Properties

CommitteeAttester

Represents an attester within a committee.

struct CommitteeAttester {
  uint32 weight;
  Secp256k1PublicKey pubKey;
}

Properties

ValidatorAttr

Represents the validator attributes of a consensus node.

struct ValidatorAttr {
  bool active;
  bool removed;
  uint32 weight;
  BLS12_381PublicKey pubKey;
  BLS12_381Signature proofOfPossession;
}

Properties

CommitteeValidator

Represents a validator within a committee.

struct CommitteeValidator {
  uint32 weight;
  BLS12_381PublicKey pubKey;
  BLS12_381Signature proofOfPossession;
}

Properties

BLS12_381PublicKey

Represents BLS12_381 public key.

struct BLS12_381PublicKey {
  bytes32 a;
  bytes32 b;
  bytes32 c;
}

Properties

BLS12_381Signature

Represents BLS12_381 signature.

struct BLS12_381Signature {
  bytes32 a;
  bytes16 b;
}

Properties

Secp256k1PublicKey

Represents Secp256k1 public key.

struct Secp256k1PublicKey {
  bytes1 tag;
  bytes32 x;
}

Properties

IL2DAValidator

Git Source

Functions

validatePubdata

function validatePubdata(
  bytes32 _chainedLogsHash,
  bytes32 _logsRootHash,
  bytes32 _chainedMessagesHash,
  bytes32 _chainedBytecodesHash,
  bytes calldata _totalL2ToL1PubdataAndStateDiffs
) external returns (bytes32 outputHash);

IPaymaster

Git Source

Functions

validateAndPayForPaymasterTransaction

Called by the bootloader to verify that the paymaster agrees to pay for the fee for the transaction. This transaction should also send the necessary amount of funds onto the bootloader address.

The developer should strive to preserve as many steps as possible both for valid and invalid transactions as this very method is also used during the gas fee estimation (without some of the necessary data, e.g. signature).

function validateAndPayForPaymasterTransaction(
  bytes32 _txHash,
  bytes32 _suggestedSignedHash,
  Transaction calldata _transaction
) external payable returns (bytes4 magic, bytes memory context);

Parameters

Returns

postTransaction

Called by the bootloader after the execution of the transaction. Please note that there is no guarantee that this method will be called at all. Unlike the original EIP4337, this method won't be called if the transaction execution results in out-of-gas.

The exact amount refunded depends on the gas spent by the "postOp" itself and so the developers should take that into account.

function postTransaction(
  bytes calldata _context,
  Transaction calldata _transaction,
  bytes32 _txHash,
  bytes32 _suggestedSignedHash,
  ExecutionResult _txResult,
  uint256 _maxRefundedGas
) external payable;

Parameters

Constants

Git Source

PAYMASTER_VALIDATION_SUCCESS_MAGIC

bytes4 constant PAYMASTER_VALIDATION_SUCCESS_MAGIC =
  IPaymaster.validateAndPayForPaymasterTransaction.selector;

IPaymasterFlow

Git Source

Author: Matter Labs

This is NOT an interface to be implemented by contracts. It is just used for encoding.

The interface that is used for encoding/decoding of different types of paymaster flows.

Note: security-contact: security@matterlabs.dev

Functions

general

function general(bytes calldata input) external;

approvalBased

function approvalBased(
  address _token,
  uint256 _minAllowance,
  bytes calldata _innerInput
) external;

Contents

• AddressAliasHelper

AddressAliasHelper

Git Source

State Variables

offset

uint160 internal constant offset =
  uint160(0x1111000000000000000000000000000000001111);

Functions

applyL1ToL2Alias

Utility function converts the address that submitted a tx to the inbox on L1 to the msg.sender viewed on L2

function applyL1ToL2Alias(address l1Address)
  internal
  pure
  returns (address l2Address);

Parameters

Returns

undoL1ToL2Alias

Utility function that converts the msg.sender viewed on L2 to the address that submitted a tx to the inbox on L1

function undoL1ToL2Alias(address l2Address)
  internal
  pure
  returns (address l1Address);

Parameters

Returns

Contents

• interfaces
• libraries
• SystemLogKey
• Constants
• AddressHasNoCode
• CallerMustBeBootloader
• CallerMustBeEvmContract
• CallerMustBeSystemContract
• CompressionValueAddError
• CompressionValueTransformError
• CompressionValueSubError
• CompressorInitialWritesProcessedNotEqual
• CompressorEnumIndexNotEqual
• DerivedKeyNotEqualToCompressedValue
• DictionaryDividedByEightNotGreaterThanEncodedDividedByTwo
• EmptyBytes32
• EncodedAndRealBytecodeChunkNotEqual
• EncodedLengthNotFourTimesSmallerThanOriginal
• EVMBytecodeHash
• EVMBytecodeHashUnknown
• EVMEmulationNotSupported
• FailedToChargeGas
• FailedToPayOperator
• HashIsNonZero
• HashMismatch
• IndexOutOfBounds
• IndexSizeError
• InsufficientFunds
• InvalidCall
• InvalidCodeHash
• InvalidInput
• InvalidNonceOrderingChange
• InvalidSig
• Keccak256InvalidReturnData
• MalformedBytecode
• NonceAlreadyUsed
• NonceIncreaseError
• NonceNotUsed
• NonEmptyAccount
• NonEmptyMsgValue
• NotAllowedToDeployInKernelSpace
• Overflow
• ReconstructionMismatch
• ShaInvalidReturnData
• StateDiffLengthMismatch
• SystemCallFlagRequired
• TooMuchPubdata
• Unauthorized
• UnknownCodeHash
• UnsupportedOperation
• UnsupportedPaymasterFlow
• UnsupportedTxType
• ValueMismatch
• ZeroNonceError
• SloadContractBytecodeUnknown
• PreviousBytecodeUnknown
• InvalidChainId
• UpgradeTransactionMustBeFirst
• L2BlockNumberZero
• PreviousL2BlockHashIsIncorrect
• CannotInitializeFirstVirtualBlock
• L2BlockAndBatchTimestampMismatch
• InconsistentNewBatchTimestamp
• NoVirtualBlocks
• CannotReuseL2BlockNumberFromPreviousBatch
• IncorrectSameL2BlockTimestamp
• IncorrectSameL2BlockPrevBlockHash
• IncorrectVirtualBlockInsideMiniblock
• IncorrectL2BlockHash
• NonMonotonicL2BlockTimestamp
• CurrentBatchNumberMustBeGreaterThanZero
• TimestampsShouldBeIncremental
• ProvidedBatchNumberIsNotCorrect
• CodeOracleCallFailed
• ReturnedBytecodeDoesNotMatchExpectedHash
• SecondCallShouldHaveCostLessGas
• ThirdCallShouldHaveSameGasCostAsSecondCall
• CallToKeccakShouldHaveSucceeded
• KeccakReturnDataSizeShouldBe32Bytes
• KeccakResultIsNotCorrect
• KeccakShouldStartWorkingAgain
• KeccakMismatchBetweenNumberOfInputsAndOutputs
• KeccakHashWasNotCalculatedCorrectly
• TransactionFailed
• NotEnoughGas
• TooMuchGas
• InvalidNewL2BlockNumber
• InvalidNonceKey
• CodeHashReason
• SigField
• PubdataField
• BytecodeError

Contents

• IAccount
• IAccount constants
• IAccountCodeStorage
• IBaseToken
• IBootloaderUtilities
• IBridgehub
• IComplexUpgrader
• ICompressor
• ICompressor constants
• ForceDeployment
• IContractDeployer
• ICreate2Factory
• IEvmHashesStorage
• ImmutableData
• IImmutableSimulator
• IKnownCodesStorage
• L2ToL1Log
• IL1Messenger
• IL1Messenger constants
• IL2DAValidator
• ZKChainSpecificForceDeploymentsData
• FixedForceDeploymentsData
• IL2GenesisUpgrade
• IL2SharedBridgeLegacy
• IL2StandardToken
• IL2WrappedBaseToken
• IMailbox
• IMessageRoot
• INonceHolder
• ExecutionResult
• IPaymaster
• IPaymaster constants
• IPaymasterFlow
• IPubdataChunkPublisher
• ISystemContext
• ISystemContextDeprecated

IAccount

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

validateTransaction

Called by the bootloader to validate that an account agrees to process the transaction (and potentially pay for it).

The developer should strive to preserve as many steps as possible both for valid and invalid transactions as this very method is also used during the gas fee estimation (without some of the necessary data, e.g. signature).

function validateTransaction(
  bytes32 _txHash,
  bytes32 _suggestedSignedHash,
  Transaction calldata _transaction
) external payable returns (bytes4 magic);

Parameters

Returns

executeTransaction

function executeTransaction(
  bytes32 _txHash,
  bytes32 _suggestedSignedHash,
  Transaction calldata _transaction
) external payable;

executeTransactionFromOutside

function executeTransactionFromOutside(Transaction calldata _transaction)
  external
  payable;

payForTransaction

function payForTransaction(
  bytes32 _txHash,
  bytes32 _suggestedSignedHash,
  Transaction calldata _transaction
) external payable;

prepareForPaymaster

function prepareForPaymaster(
  bytes32 _txHash,
  bytes32 _possibleSignedHash,
  Transaction calldata _transaction
) external payable;

Constants

Git Source

ACCOUNT_VALIDATION_SUCCESS_MAGIC

bytes4 constant ACCOUNT_VALIDATION_SUCCESS_MAGIC =
  IAccount.validateTransaction.selector;

IAccountCodeStorage

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

storeAccountConstructingCodeHash

function storeAccountConstructingCodeHash(address _address, bytes32 _hash)
  external;

storeAccountConstructedCodeHash

function storeAccountConstructedCodeHash(address _address, bytes32 _hash)
  external;

markAccountCodeHashAsConstructed

function markAccountCodeHashAsConstructed(address _address) external;

getRawCodeHash

function getRawCodeHash(address _address)
  external
  view
  returns (bytes32 codeHash);

getCodeHash

function getCodeHash(uint256 _input) external view returns (bytes32 codeHash);

getCodeSize

function getCodeSize(uint256 _input) external view returns (uint256 codeSize);

isAccountEVM

function isAccountEVM(address _addr) external view returns (bool);

IBaseToken

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

balanceOf

function balanceOf(uint256) external view returns (uint256);

transferFromTo

function transferFromTo(address _from, address _to, uint256 _amount) external;

totalSupply

function totalSupply() external view returns (uint256);

mint

function mint(address _account, uint256 _amount) external;

withdraw

function withdraw(address _l1Receiver) external payable;

withdrawWithMessage

function withdrawWithMessage(
  address _l1Receiver,
  bytes calldata _additionalData
) external payable;

Events

Mint

event Mint(address indexed account, uint256 amount);

Transfer

event Transfer(address indexed from, address indexed to, uint256 value);

Withdrawal

event Withdrawal(
  address indexed _l2Sender, address indexed _l1Receiver, uint256 _amount
);

WithdrawalWithMessage

event WithdrawalWithMessage(
  address indexed _l2Sender,
  address indexed _l1Receiver,
  uint256 _amount,
  bytes _additionalData
);

IBootloaderUtilities

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

getTransactionHashes

function getTransactionHashes(Transaction calldata _transaction)
  external
  view
  returns (bytes32 txHash, bytes32 signedTxHash);

IBridgehub

Git Source

Author: Matter Labs

Note: security-contact: security@matterlabs.dev

Functions

setAddresses

function setAddresses(
  address _assetRouter,
  address _ctmDeployer,
  address _messageRoot
) external;

owner

function owner() external view returns (address);

IComplexUpgrader

Git Source

Author: Matter Labs

The interface for the ComplexUpgrader contract.

Note: security-contact: security@matterlabs.dev

Functions

forceDeployAndUpgrade

function forceDeployAndUpgrade(
  ForceDeployment[] calldata _forceDeployments,
  address _delegateTo,
  bytes calldata _calldata
) external payable;

upgrade

function upgrade(address _delegateTo, bytes calldata _calldata)
  external
  payable;

ICompressor

Git Source

Author: Matter Labs

The interface for the Compressor contract, responsible for verifying the correctness of the compression of the state diffs and bytecodes.

Note: security-contact: security@matterlabs.dev

Functions

publishCompressedBytecode

function publishCompressedBytecode(
  bytes calldata _bytecode,
  bytes calldata _rawCompressedData
) external returns (bytes32 bytecodeHash);

verifyCompressedStateDiffs

function verifyCompressedStateDiffs(
  uint256 _numberOfStateDiffs,
  uint256 _enumerationIndexSize,
  bytes calldata _stateDiffs,
  bytes calldata _compressedStateDiffs
) external returns (bytes32 stateDiffHash);

Constants

Git Source

OPERATION_BITMASK

uint8 constant OPERATION_BITMASK = 7;

LENGTH_BITS_OFFSET

uint8 constant LENGTH_BITS_OFFSET = 3;

MAX_ENUMERATION_INDEX_SIZE

uint8 constant MAX_ENUMERATION_INDEX_SIZE = 8;

IContractDeployer

Git Source

Author: Matter Labs

Interface of the contract deployer contract -- a system contract responsible for deploying other contracts.

Note: security-contact: security@matterlabs.dev

Functions

allowedBytecodeTypesToDeploy

Returns what types of bytecode are allowed to be deployed on this chain.

function allowedBytecodeTypesToDeploy()
  external
  view
  returns (AllowedBytecodeTypes mode);

Returns

getNewAddressCreate2

Calculates the address of a deployed contract via create2

function getNewAddressCreate2(
  address _sender,
  bytes32 _bytecodeHash,
  bytes32 _salt,
  bytes calldata _input
) external view returns (address newAddress);

Parameters

Returns

getNewAddressCreate

Calculates the address of a deployed contract via create

function getNewAddressCreate(address _sender, uint256 _senderNonce)
  external
  pure
  returns (address newAddress);

Parameters

Returns

create2

Deploys a contract with similar address derivation rules to the EVM's CREATE2 opcode.

function create2(bytes32 _salt, bytes32 _bytecodeHash, bytes calldata _input)
  external
  payable
  returns (address newAddress);

Parameters

Returns

create2Account

Deploys a contract account with similar address derivation rules to the EVM's CREATE2 opcode.

this method may be callable only in system mode, that is checked in the createAccount by onlySystemCall modifier.

function create2Account(
  bytes32 _salt,
  bytes32 _bytecodeHash,
  bytes calldata _input,
  AccountAbstractionVersion _aaVersion
) external payable returns (address newAddress);

Parameters

Returns