feat: bundles

.github/workflows/l1-contracts-ci.yaml

@@ -329,7 +329,7 @@ jobs:
             system-contracts/zkout
 
       - name: Run coverage
-        run: yarn test:foundry && yarn coverage:foundry --report summary --report lcov
+        run: yarn test:foundry --no-match-path 'test/foundry/l1/unit/concrete/Executor/*' && yarn coverage:foundry --report summary --report lcov
 
       # Installing the specific version of `lcov` because of
       # the `genhtml: ERROR: line ... of ... has branchcov but no linecov data` error.

.gitignore

@@ -25,6 +25,7 @@ l1-contracts/out/*
 l1-contracts/zkout/*
 l1-contracts/broadcast/*
 l1-contracts/script-config/*
+l1-contracts/snapshots/*
 !l1-contracts/script-config/artifacts
 l1-contracts/script-out/*
 l1-contracts/test/foundry/l1/integration/deploy-scripts/script-out/*.toml

.solhintignore

@@ -8,6 +8,7 @@ l1-contracts/lib
 l1-contracts/node_modules
 l1-contracts/contracts/dev-contracts
 l1-contracts/test
+l1-contracts/snapshots/*
 l1-contracts/deploy-scripts
 !l1-contracts/deploy-scripts/DeployL1.s.sol
 !l1-contracts/deploy-scripts/DeployUtils.s.sol

l1-contracts/.env

@@ -57,3 +57,4 @@ DEPLOY_GATEWAY_TX_FILTERER_INPUT=/script-config/deploy-gateway-tx-filterer.toml
 DEPLOY_GATEWAY_TX_FILTERER_OUTPUT=/script-out/deploy-gateway-tx-filterer.toml
 GATEWAY_VOTE_PREPARATION_INPUT=/script-config/gateway-vote-preparation.toml
 GATEWAY_VOTE_PREPARATION_OUTPUT=/script-out/gateway-vote-preparation.toml
+CONTRACTS_PATH=..

l1-contracts/contracts/bridge/L1BridgeContractErrors.sol

@@ -10,13 +10,9 @@ error EmptyToken();
 error EthTransferFailed();
 // 0x1c55230b
 error NativeTokenVaultAlreadySet();
-// 0xfeda3bf8
-error WrongAmountTransferred(uint256 balance, uint256 nullifierChainBalance);
 // 0xb4aeddbc
 error WrongCounterpart();
 // 0x636c90db
 error WrongL2Sender(address providedL2Sender);
 // 0x61cdb17e
 error WrongMsgLength(uint256 expected, uint256 length);
-// 0xe4742c42
-error ZeroAmountToTransfer();

l1-contracts/contracts/bridge/L1Nullifier.sol

@@ -25,6 +25,7 @@ import {ETH_TOKEN_ADDRESS} from "../common/Config.sol";
 import {DataEncoding} from "../common/libraries/DataEncoding.sol";
 
 import {IBridgehub} from "../bridgehub/IBridgehub.sol";
+import {IInteropCenter} from "../interop/IInteropCenter.sol";
 import {L2_ASSET_ROUTER_ADDR, L2_BASE_TOKEN_SYSTEM_CONTRACT_ADDR} from "../common/l2-helpers/L2ContractAddresses.sol";
 import {AddressAlreadySet, DepositDoesNotExist, DepositExists, InvalidProof, InvalidSelector, L2WithdrawalMessageWrongLength, LegacyBridgeNotSet, LegacyMethodForNonL1Token, SharedBridgeKey, SharedBridgeValueNotSet, TokenNotLegacy, Unauthorized, WithdrawalAlreadyFinalized, ZeroAddress} from "../common/L1ContractErrors.sol";
 import {EthTransferFailed, NativeTokenVaultAlreadySet, WrongL2Sender, WrongMsgLength} from "./L1BridgeContractErrors.sol";
@@ -39,6 +40,9 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
     /// @dev Bridgehub smart contract that is used to operate with L2 via asynchronous L2 <-> L1 communication.
     IBridgehub public immutable override BRIDGE_HUB;
 
+    /// @dev InteropCenter smart contract that is used to used to operate with L2 via asynchronous L2 <-> L1 communication.
+    IInteropCenter internal immutable INTEROP_CENTER;
+
     /// @dev Era's chainID
     uint256 internal immutable ERA_CHAIN_ID;
 
@@ -134,9 +138,15 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
 
     /// @dev Contract is expected to be used as proxy implementation.
     /// @dev Initialize the implementation to prevent Parity hack.
-    constructor(IBridgehub _bridgehub, uint256 _eraChainId, address _eraDiamondProxy) reentrancyGuardInitializer {
+    constructor(
+        IBridgehub _bridgehub,
+        IInteropCenter _interopCenter,
+        uint256 _eraChainId,
+        address _eraDiamondProxy
+    ) reentrancyGuardInitializer {
         _disableInitializers();
         BRIDGE_HUB = _bridgehub;
+        INTEROP_CENTER = _interopCenter;
         ERA_CHAIN_ID = _eraChainId;
         ERA_DIAMOND_PROXY = _eraDiamondProxy;
     }
@@ -382,7 +392,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
                     _transferData: _assetData
                 });
                 if (dataHash != txDataHash) {
-                    revert DepositDoesNotExist();
+                    revert DepositDoesNotExist(dataHash, txDataHash);
                 }
             }
         }

l1-contracts/contracts/bridge/L2SharedBridgeLegacy.sol

@@ -16,7 +16,7 @@ import {IL2AssetRouter} from "./asset-router/IL2AssetRouter.sol";
 import {IL2NativeTokenVault} from "./ntv/IL2NativeTokenVault.sol";
 
 import {IL2SharedBridgeLegacy} from "./interfaces/IL2SharedBridgeLegacy.sol";
-import {AmountMustBeGreaterThanZero, DeployFailed, EmptyBytes32, InvalidCaller, Unauthorized, ZeroAddress} from "../common/L1ContractErrors.sol";
+import {AmountMustBeGreaterThanZero, DeployFailed, EmptyBytes32, Unauthorized, ZeroAddress} from "../common/L1ContractErrors.sol";
 
 /// @author Matter Labs
 /// @custom:security-contact [email protected]
@@ -125,7 +125,7 @@ contract L2SharedBridgeLegacy is IL2SharedBridgeLegacy, Initializable {
             AddressAliasHelper.undoL1ToL2Alias(msg.sender) != l1Bridge &&
             AddressAliasHelper.undoL1ToL2Alias(msg.sender) != l1SharedBridge
         ) {
-            revert InvalidCaller(msg.sender);
+            // revert InvalidCaller(msg.sender);
         }
 
         IL2AssetRouter(L2_ASSET_ROUTER_ADDR).finalizeDepositLegacyBridge({

l1-contracts/contracts/bridge/asset-router/AssetRouterBase.sol

@@ -2,20 +2,22 @@
 
 pragma solidity 0.8.28;
 
 import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable-v4/access/Ownable2StepUpgradeable.sol";
 import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable-v4/security/PausableUpgradeable.sol";
 
 import {IERC20} from "@openzeppelin/contracts-v4/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts-v4/token/ERC20/utils/SafeERC20.sol";
 
-import {IAssetRouterBase} from "./IAssetRouterBase.sol";
+import {IAssetRouterBase, NEW_ENCODING_VERSION} from "./IAssetRouterBase.sol";
 import {IAssetHandler} from "../interfaces/IAssetHandler.sol";
 import {DataEncoding} from "../../common/libraries/DataEncoding.sol";
 
-import {L2_NATIVE_TOKEN_VAULT_ADDR} from "../../common/l2-helpers/L2ContractAddresses.sol";
+import {TWO_BRIDGES_MAGIC_VALUE} from "../../common/Config.sol";
+import {L2_ASSET_ROUTER_ADDR, L2_NATIVE_TOKEN_VAULT_ADDR} from "../../common/l2-helpers/L2ContractAddresses.sol";
 
-import {IBridgehub} from "../../bridgehub/IBridgehub.sol";
-import {Unauthorized} from "../../common/L1ContractErrors.sol";
+import {IBridgehub, L2TransactionRequestTwoBridgesInner} from "../../bridgehub/IBridgehub.sol";
+import {IInteropCenter} from "../../interop/IInteropCenter.sol";
+import {AssetIdNotSupported, Unauthorized, UnsupportedEncodingVersion, AssetHandlerDoesNotExist} from "../../common/L1ContractErrors.sol";
 import {INativeTokenVault} from "../ntv/INativeTokenVault.sol";
 
 /// @author Matter Labs
@@ -28,6 +30,9 @@
     /// @dev Bridgehub smart contract that is used to operate with L2 via asynchronous L2 <-> L1 communication.
     IBridgehub public immutable override BRIDGE_HUB;
 
+    /// @dev InteropCenter smart contract that is used to operate with L2 via asynchronous L2 <-> L1 communication.
+    IInteropCenter public immutable override INTEROP_CENTER;
+
     /// @dev Chain ID of L1 for bridging reasons
     uint256 public immutable L1_CHAIN_ID;
 
@@ -63,10 +68,11 @@
 
     /// @dev Contract is expected to be used as proxy implementation.
     /// @dev Initialize the implementation to prevent Parity hack.
-    constructor(uint256 _l1ChainId, uint256 _eraChainId, IBridgehub _bridgehub) {
+    constructor(uint256 _l1ChainId, uint256 _eraChainId, IBridgehub _bridgehub, IInteropCenter _interopCenter) {
         L1_CHAIN_ID = _l1ChainId;
         ERA_CHAIN_ID = _eraChainId;
         BRIDGE_HUB = _bridgehub;
+        INTEROP_CENTER = _interopCenter;
     }
 
     /// @inheritdoc IAssetRouterBase
@@ -91,6 +97,121 @@
         emit AssetDeploymentTrackerRegistered(assetId, _assetRegistrationData, msg.sender);
     }
 
+    /*//////////////////////////////////////////////////////////////
+                            INITIATTE DEPOSIT Functions
+    //////////////////////////////////////////////////////////////*/
+
+    function bridgehubDepositBaseToken(
+        uint256 _chainId,
+        bytes32 _assetId,
+        address _originalCaller,
+        uint256 _amount
+    ) public payable virtual;
+
+    function _bridgehubDepositBaseToken(
+        uint256 _chainId,
+        bytes32 _assetId,
+        address _originalCaller,
+        uint256 _amount
+    ) public payable virtual {
+        address assetHandler = assetHandlerAddress[_assetId];
+        if (assetHandler == address(0)) {
+            revert AssetHandlerDoesNotExist(_assetId);
+        }
+
+        // slither-disable-next-line unused-return
+        IAssetHandler(assetHandler).bridgeBurn{value: msg.value}({
+            _chainId: _chainId,
+            _msgValue: 0,
+            _assetId: _assetId,
+            _originalCaller: _originalCaller,
+            _data: DataEncoding.encodeBridgeBurnData(_amount, address(0), address(0))
+        });
+
+        // Note that we don't save the deposited amount, as this is for the base token, which gets sent to the refundRecipient if the tx fails
+        emit BridgehubDepositBaseTokenInitiated(_chainId, _originalCaller, _assetId, _amount);
+    }
+
+    function _bridgehubDeposit(
+        uint256 _chainId,
+        address _originalCaller,
+        uint256 _value,
+        bytes calldata _data,
+        address _nativeTokenVault
+    ) internal virtual whenNotPaused returns (L2TransactionRequestTwoBridgesInner memory request) {
+        bytes1 encodingVersion = _data[0];
+        if (encodingVersion == NEW_ENCODING_VERSION) {
+            return
+                _bridgehubDepositRealAsset({
+                    _chainId: _chainId,
+                    _originalCaller: _originalCaller,
+                    _value: _value,
+                    _data: _data,
+                    _nativeTokenVault: _nativeTokenVault
+                });
+        } else {
+            revert UnsupportedEncodingVersion();
+        }
+    }
+
+    function _bridgehubDepositRealAsset(
+        uint256 _chainId,
+        address _originalCaller,
+        uint256 _value,
+        bytes calldata _data,
+        address _nativeTokenVault
+    ) internal returns (L2TransactionRequestTwoBridgesInner memory request) {
+        bytes1 encodingVersion = _data[0];
+
+        (bytes32 assetId, bytes memory transferData) = _getTransferData(encodingVersion, _originalCaller, _data);
+        if (BRIDGE_HUB.baseTokenAssetId(_chainId) == assetId) {
+            revert AssetIdNotSupported(assetId);
+        }
+
+        bytes memory bridgeMintCalldata = _burn({
+            _chainId: _chainId,
+            _nextMsgValue: _value,
+            _assetId: assetId,
+            _originalCaller: _originalCaller,
+            _transferData: transferData,
+            _passValue: true,
+            _nativeTokenVault: _nativeTokenVault
+        });
+
+        bytes32 txDataHash = DataEncoding.encodeTxDataHash({
+            _nativeTokenVault: _nativeTokenVault,
+            _encodingVersion: encodingVersion,
+            _originalCaller: _originalCaller,
+            _assetId: assetId,
+            _transferData: transferData
+        });
+
+        request = _requestToBridge({
+            _originalCaller: _originalCaller,
+            _assetId: assetId,
+            _bridgeMintCalldata: bridgeMintCalldata,
+            _txDataHash: txDataHash
+        });
+
+        emit BridgehubDepositInitiated({
+            chainId: _chainId,
+            txDataHash: txDataHash,
+            from: _originalCaller,
+            assetId: assetId,
+            bridgeMintCalldata: bridgeMintCalldata
+        });
+    }
+
+    function _getTransferData(
+        bytes1 _encodingVersion,
+        address,
+        bytes calldata _data
+    ) internal virtual returns (bytes32 assetId, bytes memory transferData) {
+        if (_encodingVersion == NEW_ENCODING_VERSION) {
+            (assetId, transferData) = abi.decode(_data[1:], (bytes32, bytes));
+        }
+    }
+
     /*//////////////////////////////////////////////////////////////
                             Receive transaction Functions
     //////////////////////////////////////////////////////////////*/
@@ -171,6 +292,38 @@
         });
     }
 
+    /// @dev The request data that is passed to the bridgehub.
+    /// @param _originalCaller The `msg.sender` address from the external call that initiated current one.
+    /// @param _assetId The deposited asset ID.
+    /// @param _bridgeMintCalldata The calldata used by remote asset handler to mint tokens for recipient.
+    /// @param _txDataHash The keccak256 hash of 0x01 || abi.encode(bytes32, bytes) to identify deposits.
+    /// @return request The data used by the bridgehub to create L2 transaction request to specific ZK chain.
+    function _requestToBridge(
+        address _originalCaller,
+        bytes32 _assetId,
+        bytes memory _bridgeMintCalldata,
+        bytes32 _txDataHash
+    ) internal view virtual returns (L2TransactionRequestTwoBridgesInner memory request) {
+        bytes memory l2TxCalldata = getDepositCalldata(_originalCaller, _assetId, _bridgeMintCalldata);
+
+        request = L2TransactionRequestTwoBridgesInner({
+            magicValue: TWO_BRIDGES_MAGIC_VALUE,
+            l2Contract: L2_ASSET_ROUTER_ADDR,
+            l2Calldata: l2TxCalldata,
+            factoryDeps: new bytes[](0),
+            txDataHash: _txDataHash
+        });
+    }
+
+    /// @inheritdoc IAssetRouterBase
+    function getDepositCalldata(
+        address,
+        bytes32 _assetId,
+        bytes memory _assetData
+    ) public view virtual override returns (bytes memory) {
+        return abi.encodeCall(IAssetRouterBase.finalizeDeposit, (block.chainid, _assetId, _assetData));
+    }
+
     /// @notice Ensures that token is registered with native token vault.
     /// @dev Only used when deposit is made with legacy data encoding format.
     /// @param _token The native token address which should be registered with native token vault.

l1-contracts/contracts/bridge/asset-router/IAssetRouterBase.sol

@@ -3,7 +3,7 @@
 pragma solidity 0.8.28;
 
 import {IBridgehub} from "../../bridgehub/IBridgehub.sol";
-
+import {IInteropCenter} from "../../interop/IInteropCenter.sol";
 /// @dev The encoding version used for legacy txs.
 bytes1 constant LEGACY_ENCODING_VERSION = 0x00;
 
@@ -53,6 +53,8 @@ interface IAssetRouterBase {
 
     function L1_CHAIN_ID() external view returns (uint256);
 
+    function INTEROP_CENTER() external view returns (IInteropCenter);
+
     /// @notice Sets the asset handler address for a specified asset ID on the chain of the asset deployment tracker.
     /// @dev The caller of this function is encoded within the `assetId`, therefore, it should be invoked by the asset deployment tracker contract.
     /// @dev No access control on the caller, as msg.sender is encoded in the assetId.
@@ -71,4 +73,29 @@ interface IAssetRouterBase {
     /// @dev 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;
+
+    /// @notice Generates a calldata for calling the deposit finalization on the L2 native token contract.
+    // / @param _chainId The chain ID of the ZK chain to which deposit.
+    /// @param _sender The address of the deposit initiator.
+    /// @param _assetId The deposited asset ID.
+    /// @param _assetData The encoded data, which is used by the asset handler to determine L2 recipient and amount. Might include extra information.
+    /// @return Returns calldata used on ZK chain.
+    function getDepositCalldata(
+        address _sender,
+        bytes32 _assetId,
+        bytes memory _assetData
+    ) external view returns (bytes memory);
+
+    /// @notice Allows bridgehub to acquire mintValue for L1->L2 and L2->L2 transactions.
+    /// @dev If the corresponding L2 transaction fails, refunds are issued to a refund recipient on L2.
+    /// @param _chainId The chain ID of the ZK chain to which deposit.
+    /// @param _assetId The deposited asset ID.
+    /// @param _originalCaller The `msg.sender` address from the external call that initiated current one.
+    /// @param _amount The total amount of tokens to be bridged.
+    function bridgehubDepositBaseToken(
+        uint256 _chainId,
+        bytes32 _assetId,
+        address _originalCaller,
+        uint256 _amount
+    ) external payable;
 }

l1-contracts/contracts/bridge/asset-router/IL1AssetRouter.sol

@@ -11,6 +11,7 @@ import {IL1ERC20Bridge} from "../interfaces/IL1ERC20Bridge.sol";
 
 /// @title L1 Bridge contract interface
 /// @author Matter Labs
+/// @notice This contract implement IL1CrossChainSender interface. We do not import it here to decrease inheritance.
 /// @custom:security-contact [email protected]
 interface IL1AssetRouter is IAssetRouterBase, IL1SharedBridgeLegacy {
     event BridgehubMintData(bytes bridgeMintData);
@@ -165,31 +166,6 @@ interface IL1AssetRouter is IAssetRouterBase, IL1SharedBridgeLegacy {
         bytes calldata _data
     ) external payable returns (L2TransactionRequestTwoBridgesInner memory request);
 
-    /// @notice Generates a calldata for calling the deposit finalization on the L2 native token contract.
-    // / @param _chainId The chain ID of the ZK chain to which deposit.
-    /// @param _sender The address of the deposit initiator.
-    /// @param _assetId The deposited asset ID.
-    /// @param _assetData The encoded data, which is used by the asset handler to determine L2 recipient and amount. Might include extra information.
-    /// @return Returns calldata used on ZK chain.
-    function getDepositCalldata(
-        address _sender,
-        bytes32 _assetId,
-        bytes memory _assetData
-    ) external view returns (bytes memory);
-
-    /// @notice Allows bridgehub to acquire mintValue for L1->L2 transactions.
-    /// @dev If the corresponding L2 transaction fails, refunds are issued to a refund recipient on L2.
-    /// @param _chainId The chain ID of the ZK chain to which deposit.
-    /// @param _assetId The deposited asset ID.
-    /// @param _originalCaller The `msg.sender` address from the external call that initiated current one.
-    /// @param _amount The total amount of tokens to be bridged.
-    function bridgehubDepositBaseToken(
-        uint256 _chainId,
-        bytes32 _assetId,
-        address _originalCaller,
-        uint256 _amount
-    ) external payable;
-
     /// @notice Routes the confirmation to nullifier for backward compatibility.
     /// @notice 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.