fix: l2-native-token, bridge fixes

l1-contracts/.env

@@ -44,3 +44,4 @@ TOKENS_CONFIG=/script-config/config-deploy-erc20.toml
 ZK_CHAIN_CONFIG=/script-config/register-zk-chain.toml
 ZK_CHAIN_OUTPUT=/script-out/output-deploy-zk-chain-era.toml
 FORCE_DEPLOYMENTS_CONFIG=/script-config/generate-force-deployments-data.toml
+GATEWAY_PREPARATION_L1_CONFIG=/script-config/gateway-preparation-l1.toml

l1-contracts/contracts/bridge/BridgedStandardERC20.sol

@@ -10,6 +10,7 @@ import {IBridgedStandardToken} from "./interfaces/IBridgedStandardToken.sol";
 import {Unauthorized, NonSequentialVersion, ZeroAddress} from "../common/L1ContractErrors.sol";
 import {L2_NATIVE_TOKEN_VAULT_ADDR} from "../common/L2ContractAddresses.sol";
 import {DataEncoding} from "../common/libraries/DataEncoding.sol";
+import {INativeTokenVault} from "../bridge/ntv/INativeTokenVault.sol";
 
 /// @author Matter Labs
 /// @custom:security-contact [email protected]
@@ -43,13 +44,20 @@ contract BridgedStandardERC20 is ERC20PermitUpgradeable, IBridgedStandardToken,
  /// @dev Address of the native token vault that is used as trustee who can mint/burn tokens
  address public nativeTokenVault;
 
+ /// @dev The assetId of the token.
+ bytes32 public assetId;
+
  /// @dev This also sets the native token vault to the default value if it is not set.
  /// It is not set only on the L2s for legacy tokens.
  modifier onlyNTV() {
  address ntv = nativeTokenVault;
  if (ntv == address(0)) {
  ntv = L2_NATIVE_TOKEN_VAULT_ADDR;
  nativeTokenVault = L2_NATIVE_TOKEN_VAULT_ADDR;
+ assetId = DataEncoding.encodeNTVAssetId(
+ INativeTokenVault(L2_NATIVE_TOKEN_VAULT_ADDR).L1_CHAIN_ID(),
+ originToken
+ );
  }
  if (msg.sender != ntv) {
  revert Unauthorized(msg.sender);
@@ -74,14 +82,20 @@ contract BridgedStandardERC20 is ERC20PermitUpgradeable, IBridgedStandardToken,
 
  /// @notice Initializes a contract token for later use. Expected to be used in the proxy.
  /// @dev Stores the L1 address of the bridge and set `name`/`symbol`/`decimals` getters that L1 token has.
+ /// @param _assetId The assetId of the token.
  /// @param _originToken Address of the origin token that can be deposited to mint this bridged token
  /// @param _data The additional data that the L1 bridge provide for initialization.
  /// In this case, it is packed `name`/`symbol`/`decimals` of the L1 token.
- function bridgeInitialize(address _originToken, bytes calldata _data) external initializer returns (uint256) {
+ function bridgeInitialize(
+ bytes32 _assetId,
+ address _originToken,
+ bytes calldata _data
+ ) external initializer returns (uint256) {
  if (_originToken == address(0)) {
  revert ZeroAddress();
  }
  originToken = _originToken;
+ assetId = _assetId;
 
  nativeTokenVault = msg.sender;
 

l1-contracts/contracts/bridge/L1Nullifier.sol

@@ -16,7 +16,6 @@ import {IL1NativeTokenVault} from "./ntv/IL1NativeTokenVault.sol";
 import {IL1ERC20Bridge} from "./interfaces/IL1ERC20Bridge.sol";
 import {IL1AssetRouter} from "./asset-router/IL1AssetRouter.sol";
 import {IAssetRouterBase} from "./asset-router/IAssetRouterBase.sol";
-import {INativeTokenVault} from "./ntv/INativeTokenVault.sol";
 
 import {IL1Nullifier, FinalizeL1DepositParams} from "./interfaces/IL1Nullifier.sol";
 
@@ -511,7 +510,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  /// @return transferData The transfer data used to finalize withdawal.
  function _verifyWithdrawal(
  FinalizeL1DepositParams calldata _finalizeWithdrawalParams
- ) internal view returns (bytes32 assetId, bytes memory transferData) {
+ ) internal returns (bytes32 assetId, bytes memory transferData) {
  (assetId, transferData) = _parseL2WithdrawalMessage(
  _finalizeWithdrawalParams.chainId,
  _finalizeWithdrawalParams.message
@@ -560,7 +559,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  function _parseL2WithdrawalMessage(
  uint256 _chainId,
  bytes memory _l2ToL1message
- ) internal view returns (bytes32 assetId, bytes memory transferData) {
+ ) internal returns (bytes32 assetId, bytes memory transferData) {
  // Please note that there are three versions of the message:
  // 1. The message that is sent from `L2BaseToken` to withdraw base token.
  // 2. The message that is sent from L2 Legacy Shared Bridge to withdraw ERC20 tokens or base token.
@@ -604,6 +603,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  // slither-disable-next-line unused-return
  (amount, ) = UnsafeBytes.readUint256(_l2ToL1message, offset);
 
+ l1NativeTokenVault.ensureTokenIsRegistered(l1Token);
  assetId = DataEncoding.encodeNTVAssetId(block.chainid, l1Token);
  transferData = DataEncoding.encodeBridgeMintData({
  _originalCaller: address(0),
@@ -616,7 +616,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  // The data is expected to be at least 36 bytes long to contain assetId.
  require(_l2ToL1message.length >= 36, "L1N: wrong msg len"); // wrong message length
  // slither-disable-next-line unused-return
- (, offset) = UnsafeBytes.readBytes32(_l2ToL1message, offset); // originChainId, not used for L2->L1 txs
+ (, offset) = UnsafeBytes.readUint256(_l2ToL1message, offset); // originChainId, not used for L2->L1 txs
  (assetId, offset) = UnsafeBytes.readBytes32(_l2ToL1message, offset);
  transferData = UnsafeBytes.readRemainingBytes(_l2ToL1message, offset);
  } else {
@@ -648,7 +648,10 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  uint16 _l2TxNumberInBatch,
  bytes32[] calldata _merkleProof
  ) external override {
- bytes32 assetId = INativeTokenVault(address(l1NativeTokenVault)).getAssetId(block.chainid, _l1Token);
+ bytes32 assetId = l1NativeTokenVault.assetId(_l1Token);
+ if (assetId == bytes32(0)) {
+ assetId = DataEncoding.encodeNTVAssetId(block.chainid, _l1Token);
+ }
  // For legacy deposits, the l2 receiver is not required to check tx data hash
  // bytes memory transferData = abi.encode(_amount, _depositSender);
  bytes memory assetData = abi.encode(_amount, address(0));
@@ -702,7 +705,7 @@ contract L1Nullifier is IL1Nullifier, ReentrancyGuard, Ownable2StepUpgradeable,
  ) external override onlyLegacyBridge {
  bytes memory assetData = abi.encode(_amount, _depositSender);
  /// the legacy bridge can only be used with L1 native tokens.
- bytes32 assetId = INativeTokenVault(address(l1NativeTokenVault)).getAssetId(block.chainid, _l1Asset);
+ bytes32 assetId = DataEncoding.encodeNTVAssetId(block.chainid, _l1Asset);
 
  _verifyAndClearFailedTransfer({
  _checkedInLegacyBridge: true,

l1-contracts/contracts/bridge/L2SharedBridgeLegacy.sol

@@ -190,8 +190,8 @@ contract L2SharedBridgeLegacy is IL2SharedBridgeLegacy, Initializable {
  proxy = abi.decode(returndata, (address));
  }
 
- function sendMessageToL1(bytes calldata _message) external override onlyAssetRouter {
+ function sendMessageToL1(bytes calldata _message) external override onlyAssetRouter returns (bytes32) {
  // slither-disable-next-line unused-return
- L2ContractHelper.sendMessageToL1(_message);
+ return L2ContractHelper.sendMessageToL1(_message);
  }
 }

l1-contracts/contracts/bridge/L2WrappedBaseToken.sol

@@ -6,6 +6,7 @@ import {ERC20PermitUpgradeable} from "@openzeppelin/contracts-upgradeable-v4/tok
 
 import {IL2WrappedBaseToken} from "./interfaces/IL2WrappedBaseToken.sol";
 import {IBridgedStandardToken} from "./interfaces/IBridgedStandardToken.sol";
+import {L2_NATIVE_TOKEN_VAULT_ADDR} from "../common/L2ContractAddresses.sol";
 
 import {ZeroAddress, Unauthorized, BridgeMintNotImplemented, WithdrawFailed} from "../common/L1ContractErrors.sol";
 
@@ -29,6 +30,12 @@ contract L2WrappedBaseToken is ERC20PermitUpgradeable, IL2WrappedBaseToken, IBri
  /// @dev Address of the L1 base token. It can be deposited to mint this L2 token.
  address public override l1Address;
 
+ /// @dev Address of the native token vault.
+ address public override nativeTokenVault;
+
+ /// @dev The assetId of the base token. The wrapped token does not have its own assetId.
+ bytes32 public baseTokenAssetId;
+
  modifier onlyBridge() {
  if (msg.sender != l2Bridge) {
  revert Unauthorized(msg.sender);
@@ -59,7 +66,8 @@ contract L2WrappedBaseToken is ERC20PermitUpgradeable, IL2WrappedBaseToken, IBri
  string calldata name_,
  string calldata symbol_,
  address _l2Bridge,
- address _l1Address
+ address _l1Address,
+ bytes32 _baseTokenAssetId
  ) external reinitializer(2) {
  if (_l2Bridge == address(0)) {
  revert ZeroAddress();
@@ -68,8 +76,13 @@ contract L2WrappedBaseToken is ERC20PermitUpgradeable, IL2WrappedBaseToken, IBri
  if (_l1Address == address(0)) {
  revert ZeroAddress();
  }
+ if (_baseTokenAssetId == bytes32(0)) {
+ revert ZeroAddress();
+ }
  l2Bridge = _l2Bridge;
  l1Address = _l1Address;
+ nativeTokenVault = L2_NATIVE_TOKEN_VAULT_ADDR;
+ baseTokenAssetId = _baseTokenAssetId;
 
  // Set decoded values for name and symbol.
  __ERC20_init_unchained(name_, symbol_);
@@ -131,4 +144,8 @@ contract L2WrappedBaseToken is ERC20PermitUpgradeable, IL2WrappedBaseToken, IBri
  function originToken() external view override returns (address) {
  return l1Address;
  }
+
+ function assetId() external view override returns (bytes32) {
+ return baseTokenAssetId;
+ }
 }

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

@@ -149,6 +149,12 @@ abstract contract AssetRouterBase is IAssetRouterBase, Ownable2StepUpgradeable,
  });
  }
 
+ /// @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.
+ /// @return assetId The asset ID of the token provided.
+ function _ensureTokenRegisteredWithNTV(address _token) internal virtual returns (bytes32 assetId);
+
  /*//////////////////////////////////////////////////////////////
  PAUSE
  //////////////////////////////////////////////////////////////*/

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

@@ -95,6 +95,29 @@ interface IL1AssetRouter is IAssetRouterBase, IL1SharedBridgeLegacy {
  bytes calldata _assetData
  ) external;
 
+ /// @dev Withdraw funds from the initiated deposit, that failed when finalizing on L2.
+ /// @param _chainId The ZK chain id to which deposit was initiated.
+ /// @param _depositSender The address of the entity that initiated the deposit.
+ /// @param _assetId The unique identifier of the deposited L1 token.
+ /// @param _assetData The encoded transfer data, which includes both the deposit amount and the address of the L2 receiver. Might include extra information.
+ /// @param _l2TxHash The L2 transaction hash of the failed deposit finalization.
+ /// @param _l2BatchNumber The L2 batch number where the deposit finalization was processed.
+ /// @param _l2MessageIndex The position in the L2 logs Merkle tree of the l2Log that was sent with the message.
+ /// @param _l2TxNumberInBatch The L2 transaction number in a batch, in which the log was sent.
+ /// @param _merkleProof The Merkle proof of the processing L1 -> L2 transaction with deposit finalization.
+ /// @dev 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;
+
  /// @notice Transfers funds to Native Token Vault, if the asset is registered with it. Does nothing for ETH or non-registered tokens.
  /// @dev assetId is not the padded address, but the correct encoded id (NTV stores respective format for IDs)
  /// @param _amount The asset amount to be transferred to native token vault.
@@ -169,4 +192,10 @@ interface IL1AssetRouter is IAssetRouterBase, IL1SharedBridgeLegacy {
  /// @param _txDataHash The keccak256 hash of 0x01 || abi.encode(bytes32, bytes) to identify deposits.
  /// @param _txHash The hash of the L1->L2 transaction to confirm the deposit.
  function bridgehubConfirmL2Transaction(uint256 _chainId, bytes32 _txDataHash, bytes32 _txHash) external;
+
+ function isWithdrawalFinalized(
+ uint256 _chainId,
+ uint256 _l2BatchNumber,
+ uint256 _l2MessageIndex
+ ) external view returns (bool);
 }

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

@@ -2,17 +2,19 @@
 
 pragma solidity ^0.8.20;
 
+import {IAssetRouterBase} from "./IAssetRouterBase.sol";
+
 /// @author Matter Labs
 /// @custom:security-contact [email protected]
-interface IL2AssetRouter {
+interface IL2AssetRouter is IAssetRouterBase {
  event WithdrawalInitiatedAssetRouter(
  uint256 chainId,
  address indexed l2Sender,
  bytes32 indexed assetId,
  bytes assetData
  );
 
- function withdraw(bytes32 _assetId, bytes calldata _transferData) external;
+ function withdraw(bytes32 _assetId, bytes calldata _transferData) external returns (bytes32);
 
  function l1AssetRouter() external view returns (address);
 

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

@@ -335,6 +335,31 @@ contract L1AssetRouter is AssetRouterBase, IL1AssetRouter, ReentrancyGuard {
 
  emit ClaimedFailedDepositAssetRouter(_chainId, _assetId, _assetData);
  }
+
+ function bridgeRecoverFailedTransfer(
+ uint256 _chainId,
+ address _depositSender,
+ bytes32 _assetId,
+ bytes calldata _assetData,
+ bytes32 _l2TxHash,
+ uint256 _l2BatchNumber,
+ uint256 _l2MessageIndex,
+ uint16 _l2TxNumberInBatch,
+ bytes32[] calldata _merkleProof
+ ) external {
+ L1_NULLIFIER.bridgeRecoverFailedTransfer({
+ _chainId: _chainId,
+ _depositSender: _depositSender,
+ _assetId: _assetId,
+ _assetData: _assetData,
+ _l2TxHash: _l2TxHash,
+ _l2BatchNumber: _l2BatchNumber,
+ _l2MessageIndex: _l2MessageIndex,
+ _l2TxNumberInBatch: _l2TxNumberInBatch,
+ _merkleProof: _merkleProof
+ });
+ }
+
  /*//////////////////////////////////////////////////////////////
  Internal & Helpers
  //////////////////////////////////////////////////////////////*/
@@ -354,13 +379,15 @@ contract L1AssetRouter is AssetRouterBase, IL1AssetRouter, ReentrancyGuard {
 
  /// @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 L1 token address which should be registered with native token vault.
+ /// @param _token The native token address which should be registered with native token vault.
  /// @return assetId The asset ID of the token provided.
- function _ensureTokenRegisteredWithNTV(address _token) internal returns (bytes32 assetId) {
- assetId = nativeTokenVault.getAssetId(block.chainid, _token);
- if (nativeTokenVault.tokenAddress(assetId) == address(0)) {
- nativeTokenVault.registerToken(_token);
+ function _ensureTokenRegisteredWithNTV(address _token) internal override returns (bytes32 assetId) {
+ assetId = nativeTokenVault.assetId(_token);
+ if (assetId != bytes32(0)) {
+ return assetId;
  }
+ nativeTokenVault.ensureTokenIsRegistered(_token);
+ assetId = nativeTokenVault.assetId(_token);
  }
 
  /// @inheritdoc IL1AssetRouter
@@ -586,6 +613,15 @@ contract L1AssetRouter is AssetRouterBase, IL1AssetRouter, ReentrancyGuard {
  });
  }
 
+ /// @notice Legacy read method, which forwards the call to L1Nullifier to check if withdrawal was finalized
+ function isWithdrawalFinalized(
+ uint256 _chainId,
+ uint256 _l2BatchNumber,
+ uint256 _l2MessageIndex
+ ) external view returns (bool) {
+ return L1_NULLIFIER.isWithdrawalFinalized(_chainId, _l2BatchNumber, _l2MessageIndex);
+ }
+
  /// @notice Legacy function to get the L2 shared bridge address for a chain.
  /// @dev In case the chain has been deployed after the gateway release,
  /// the returned value is 0.