resolve issues

Author: StanislavBreadless

l1-contracts/contracts/bridge/asset-tracker/GWAssetTracker.sol

@@ -575,7 +575,6 @@ contract GWAssetTracker is AssetTrackerBase, IGWAssetTracker {
         SavedTotalSupply memory tokenSavedTotalSupply = savedChainBalance[_chainId][_migrationNumber][_assetId];
         if (!tokenSavedTotalSupply.isSaved) {
             // First time accessing this balance for this migration number
-            // Save the current balance and reset the chainBalance to 0
             tokenSavedTotalSupply.amount = chainBalance[_chainId][_assetId];
             // Persist the saved balance for this specific migration
             savedChainBalance[_chainId][_migrationNumber][_assetId] = SavedTotalSupply({

l1-contracts/contracts/bridge/asset-tracker/IL1AssetTracker.sol

@@ -23,7 +23,7 @@ interface IL1AssetTracker {
 
     function receiveGatewayToL1MigrationOnL1(FinalizeL1DepositParams calldata _finalizeWithdrawalParams) external;
 
-    function migrateTokenBalanceFromNTVV31(bytes32 _assetId) external;
+    function registerLegacyToken(bytes32 _assetId) external;
 
     function consumeBalanceChange(
         uint256 _callerChainId,

l1-contracts/contracts/bridge/asset-tracker/IL2AssetTracker.sol

@@ -11,7 +11,11 @@ interface IL2AssetTracker {
     /// @param amount The amount being migrated
     event L1ToGatewayMigrationInitiated(bytes32 indexed assetId, uint256 chainId, uint256 amount);
 
-    function setAddresses(uint256 _l1ChainId, bytes32 _baseTokenAssetId) external;
+    function initL2(
+        uint256 _l1ChainId, 
+        bytes32 _baseTokenAssetId,
+        bool _needBasewTokenTotalSupplyBackfill
+    ) external;
 
     function handleInitiateBridgingOnL2(
         uint256 _toChainId,

l1-contracts/contracts/bridge/asset-tracker/L1AssetTracker.sol

@@ -53,14 +53,21 @@ import {IChainAssetHandlerBase} from "../../core/chain-asset-handler/IChainAsset
 import {IL1MessageRoot} from "../../core/message-root/IL1MessageRoot.sol";
 
 contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
-    /// @dev Per-(chainId, assetId) migration accounting stored on L1.
+    /// @notice Per-(chainId, assetId) migration accounting stored on L1.
     /// @param preV31ChainBalance  Chain balance right before the v31 migration.
     /// - For non-native tokens it is exactly equal to chainBalance before the *ecosystem* upgraded to v31 (0 for new tokens).
     /// - For tokens native to the chain, we imagine that it received 2^256-1 token deposit at the inception point and so 
     /// all the balances that are not present on the chain are from claimed withdrawals, i.e. for a token that was bridged
     /// before v31 it is equal to `2^256-1 - <sum of other chainBalances, including l1>`. For new tokens it is exactly `2^256-1`. 
-    /// @param totalDepositedFromL1 Total amount deposited from L1 to the chain since v31 accounting started.
-    /// @param totalClaimedOnL1 Total amount claimed on L1 (withdrawals and failed deposits) since v31 accounting started.
+    /// @param totalDepositedFromL1 Total amount deposited from L1 to the chain since v31 accounting started. Note, that it is not 
+    /// just about any L1->L2 deposit, but only those that debited the chainBalance on L1 directly and it is assumed that every such
+    /// deposit will be processed while the chain is still settling on L1. It is the responsbility of the chain admin to ensure that.
+    /// @param totalClaimedOnL1 Total amount claimed on L1 (withdrawals and failed deposits) since v31 accounting started. Note, that it is not just
+    /// about claim, but claims that affect `chainBalance` of the chain (i.e. the respective failed deposits or withdrawals were submitted
+    /// while the chain was settling on L1)).
+    /// @dev It is the responsibility of the *chain* and its admin to ensure that all deposits are processed before the migration to Gateway is complete
+    /// and vice versa, i.e. all deposits are either fully processed on L1 or fully processed while it settles on ZK Gateway. In case the chain violates 
+    /// this rule, invalid migration amount can be migrated, but it must only affect the chain and its users.
     struct InteropL1Info {
         uint256 preV31ChainBalance;
         uint256 totalDepositedFromL1;
@@ -135,14 +142,13 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
     /// @dev Note, that this function performs O(number of chains) calls to NTV. It relies on the fact
     /// that the max number of chains is bound by 100, so this function should be always processable.
     /// @param _assetId The asset id of the token to migrate the token balance for.
-    function migrateTokenBalanceFromNTVV31(bytes32 _assetId) public {
+    function registerLegacyToken(bytes32 _assetId) public {
         IL1NativeTokenVault l1NTV = IL1NativeTokenVault(address(NATIVE_TOKEN_VAULT));
         uint256 originChainId = NATIVE_TOKEN_VAULT.originChainId(_assetId);
         require(originChainId != 0, InvalidChainId());
 
         // This function is only intended to be used for legacy tokens that have not yet been registered.
         require(!isTokenRegistered[_assetId], "Max chain balance already assigned");
-        isTokenRegistered[_assetId] = true;
 
         uint256[] memory allZKChainIds = BRIDGE_HUB.getAllZKChainChainIDs();
 
@@ -154,7 +160,7 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
             // chainBalance inside the L1AT should never be incremented until the token is registered.
             require(chainBalance[chainId][_assetId] == 0, "Chain balance already set");
 
-            // Origin chain id will be handled later.
+            // Origin chain id will be handled later in this function.
             if (chainId == originChainId) {
                 continue;
             }
@@ -172,8 +178,10 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
         if (originChainId != block.chainid) {
             address tokenAddress = NATIVE_TOKEN_VAULT.tokenAddress(_assetId);
             // Note, that here we have an implicit invariant that the token's total supply
-            // can never be changed before this migration happens.
-            // So until a token is registered, all withdrawals must fail.
+            // can never be changed before this migration happens. So until a token is registered, all withdrawals must fail.
+            // Note, that if a token is a bridged token native to L2, its representation on L1
+            // is deployed by NativeTokenVault as `BridgedStandardERC20`, so we can safely assume the returned value 
+            // will be correct.
             uint256 migratedBalance = IERC20(tokenAddress).totalSupply();
             chainBalance[block.chainid][_assetId] = migratedBalance;
             interopInfo[block.chainid][_assetId].preV31ChainBalance = migratedBalance;
@@ -360,7 +368,7 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
 
         // We check the assetId to make sure the chain is not lying about it.
         DataEncoding.assetIdCheck(data.tokenOriginChainId, data.assetId, data.originToken);
-        _requireMigratedFromNTV(data.chainId, data.assetId);
+        _autoRegisterTokenFromMigration(data.tokenOriginChainId, data.assetId);
 
         uint256 currentSettlementLayer = BRIDGE_HUB.settlementLayer(data.chainId);
         require(currentSettlementLayer != block.chainid, NotMigratedChain());
@@ -389,7 +397,6 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
         require(fromChainBalance >= amountToKeep, InvalidMigrationAmount(fromChainBalance, amountToKeep));
         uint256 amountToMigrate = fromChainBalance - amountToKeep;
 
-        _autoRegisterTokenFromMigration(data.tokenOriginChainId, data.assetId);
         _migrateFunds({
             _fromChainId: data.chainId,
             _toChainId: currentSettlementLayer,
@@ -467,7 +474,7 @@ contract L1AssetTracker is AssetTrackerBase, IL1AssetTracker {
     /// @notice used to pause deposits on Gateway from L1 for migration back to L1.
     function requestPauseDepositsForChainOnGateway(uint256 _chainId) external onlyChain(_chainId) {
         uint256 settlementLayer = BRIDGE_HUB.settlementLayer(_chainId);
-        require(settlementLayer != 0, InvalidSettlementLayer());
+        require(settlementLayer != block.chainid, InvalidSettlementLayer());
         _sendToChain(
             settlementLayer,
             GW_ASSET_TRACKER_ADDR,

l1-contracts/contracts/bridge/asset-tracker/L2AssetTracker.sol

@@ -35,6 +35,11 @@ import {
 import {AssetTrackerBase} from "./AssetTrackerBase.sol";
 import {IL2AssetTracker} from "./IL2AssetTracker.sol";
 
+struct ZKsyncOSBaseTokenV31MigrationStatus {
+    bool needsBackFill;
+    uint256 totalSupply;
+}
+
 contract L2AssetTracker is AssetTrackerBase, IL2AssetTracker {
     struct InteropL2Info {
         uint256 totalWithdrawalsToL1;
@@ -60,8 +65,14 @@ contract L2AssetTracker is AssetTrackerBase, IL2AssetTracker {
     /// could image there was a big successful deposit at the inception time of 2^256-1 and then the withdrawals behaved the same way as for
     /// the bridged L2 tokens. 
     /// @dev For native tokens, it is expected to be populated atomatically with `isTokenRegistered[block.chainid]`.
+    /// @dev IMPORTANT: for base token this value may not be correct for zksync os chains until the totalSupply for the base
+    /// token has been backfilled, so before using this value for the base token, one should check that it was set (`zkSyncOSBaseTokenV31MigrationStatus.needsBackFill = false`).
     mapping(bytes32 assetId => SavedTotalSupply snapshot) internal totalPreV31TotalSupply;
 
+    /// @dev On zkSync os chains, the `totalSupply()` of the base token is not available by default,
+    /// so before we ever use it to do any migrations, we need to backfill it.
+    bool public needBasewTokenTotalSupplyBackfill;
+
     modifier onlyUpgrader() {
         if (msg.sender != L2_COMPLEX_UPGRADER_ADDR) {
             revert Unauthorized(msg.sender);
@@ -90,13 +101,42 @@ contract L2AssetTracker is AssetTrackerBase, IL2AssetTracker {
         _;
     }
 
+    // FIXME: this function will have to be called by the chain admin after the v31 upgrade to backfill the data.
+    // It will be fixed in a separate PR with the base token holder PR.
+    function backFillZKSyncOSBaseTokenV31MigrationData(
+        uint256 _amount
+    ) external onlyUpgrader {
+        require(needBasewTokenTotalSupplyBackfill, "Backfill not needed");
+
+        // We expect that method to be called after the `totalSupply()` has been already updated 
+        // to the correct one, so we can just register the token.
+        if (!isTokenRegistered[BASE_TOKEN_ASSET_ID]) {
+            registerLegacyToken(BASE_TOKEN_ASSET_ID);
+            return;
+        }
+
+        // We expect that for all registered tokens, the zero `totalPreV31TotalSupply` should be saved.
+
+        // The requires below should never be hit, these are just invariant checks.
+        require(totalPreV31TotalSupply[BASE_TOKEN_ASSET_ID].isSaved, "Total supply should be saved for registered token");
+        require(totalPreV31TotalSupply[BASE_TOKEN_ASSET_ID].amount == 0, "Total supply should be 0 before backfill");
+        totalPreV31TotalSupply[BASE_TOKEN_ASSET_ID].amount = _amount;
+
+        needBasewTokenTotalSupplyBackfill = false;
+    }
+
     /// @notice Sets the L1 chain ID and base token asset ID for this L2 chain.
     /// @dev This function is called during contract initialization or upgrades.
     /// @param _l1ChainId The chain ID of the L1 network.
     /// @param _baseTokenAssetId The asset ID of the base token used for gas fees on this chain.
-    function setAddresses(uint256 _l1ChainId, bytes32 _baseTokenAssetId) external onlyUpgrader {
+    function initL2(
+        uint256 _l1ChainId, 
+        bytes32 _baseTokenAssetId,
+        bool _needBasewTokenTotalSupplyBackfill
+    ) external onlyUpgrader {
         L1_CHAIN_ID = _l1ChainId;
         BASE_TOKEN_ASSET_ID = _baseTokenAssetId;
+        needBasewTokenTotalSupplyBackfill = _needBasewTokenTotalSupplyBackfill;
     }
 
     function _l1ChainId() internal view returns (uint256) {
@@ -136,11 +176,7 @@ contract L2AssetTracker is AssetTrackerBase, IL2AssetTracker {
 
     /// @notice Stores token total supply snapshot used for pre-v31 migration accounting.
     /// @dev Anyone can call this to eagerly initialize the snapshot before the first bridge operation.
-    function registerLegacyToken(bytes32 _assetId) external override {
-        _registerLegacyTokenEntry(_assetId);
-    }
-
-    function _registerLegacyTokenEntry(bytes32 _assetId) internal {
+    function registerLegacyToken(bytes32 _assetId) public override {
         if (isTokenRegistered[_assetId]) {
             return;
         }
@@ -346,6 +382,7 @@ contract L2AssetTracker is AssetTrackerBase, IL2AssetTracker {
 
         address tokenAddress = _tryGetTokenAddress(_assetId);
         uint256 readTotalPreV31TotalSupply = _registerLegacyTokenIfNeeded(_assetId, tokenAddress);
+        require(!needBasewTokenTotalSupplyBackfill, "The base token total supply needs to be backfilled");
 
         uint256 originChainId = L2_NATIVE_TOKEN_VAULT.originChainId(_assetId);
         address originalToken = L2_NATIVE_TOKEN_VAULT.originToken(_assetId);

l1-contracts/contracts/bridge/ntv/NativeTokenVaultBase.sol

@@ -422,20 +422,21 @@ abstract contract NativeTokenVaultBase is
         bytes32 _assetId,
         address _originalCaller
     ) internal {
+        // Note, that in order to track `totalPreV31TotalSupply` correctly in L2AssetTracker,
+        // we have to call it before the any balance changes will be perforemd.
+        _handleBridgeToChain(_chainId, _assetId, _depositAmount);
+
         if (_assetId == _baseTokenAssetId()) {
             require(_depositAmount == msg.value, ValueMismatch(_depositAmount, msg.value));
             if (_isBridgedToken) {
                 // slither-disable-next-line arbitrary-send-eth
                 L2_BASE_TOKEN_SYSTEM_CONTRACT.burnMsgValue{value: msg.value}();
             }
-            _handleBridgeToChain(_chainId, _assetId, _depositAmount);
         } else {
             require(msg.value == 0, NonEmptyMsgValue());
             if (_isBridgedToken) {
                 IBridgedStandardToken(_tokenAddress).bridgeBurn(_originalCaller, _depositAmount);
-                _handleBridgeToChain(_chainId, _assetId, _depositAmount);
             } else {
-                _handleBridgeToChain(_chainId, _assetId, _depositAmount);
                 if (!_depositChecked) {
                     uint256 expectedDepositAmount = _depositFunds(
                         _originalCaller,

l1-contracts/contracts/l2-upgrades/L2GenesisForceDeploymentsHelper.sol

@@ -265,7 +265,13 @@ library L2GenesisForceDeploymentsHelper {
             _isGenesisUpgrade: _isGenesisUpgrade,
             _isZKsyncOS: _isZKsyncOS
         });
-        _finalizeDeployments(_ctmDeployer, fixedForceDeploymentsData, additionalForceDeploymentsData);
+        _finalizeDeployments(
+            _ctmDeployer,
+            fixedForceDeploymentsData,
+            additionalForceDeploymentsData,
+            _isZKsyncOS,
+            _isGenesisUpgrade
+        );
     }
 
     function _setupProxyAdmin() private {
@@ -506,7 +512,9 @@ library L2GenesisForceDeploymentsHelper {
     function _finalizeDeployments(
         address _ctmDeployer,
         FixedForceDeploymentsData memory fixedForceDeploymentsData,
-        ZKChainSpecificForceDeploymentsData memory additionalForceDeploymentsData
+        ZKChainSpecificForceDeploymentsData memory additionalForceDeploymentsData,
+        bool _isZKsyncOS,
+        bool _isGenesisUpgrade
     ) private {
         // It is expected that either through the force deployments above
         // or upon initialization, both the L2 deployment of BridgeHub, AssetRouter, and MessageRoot are deployed.
@@ -521,9 +529,12 @@ library L2GenesisForceDeploymentsHelper {
             _chainRegistrationSender: fixedForceDeploymentsData.aliasedChainRegistrationSender
         });
 
-        L2AssetTracker(L2_ASSET_TRACKER_ADDR).setAddresses(
+        L2AssetTracker(L2_ASSET_TRACKER_ADDR).initL2(
             fixedForceDeploymentsData.l1ChainId,
-            additionalForceDeploymentsData.baseTokenBridgingData.assetId
+            additionalForceDeploymentsData.baseTokenBridgingData.assetId,
+            // The only chains that need backfill for the base token's total supply are zksync os
+            // chains that existing before the v31 upgrade (i.e. isGenesis is false).
+            _isZKsyncOS && !_isGenesisUpgrade
         );
 
         GWAssetTracker(GW_ASSET_TRACKER_ADDR).setAddresses(fixedForceDeploymentsData.l1ChainId);

l1-contracts/deploy-scripts/upgrade/v31/ChainUpgrade_v31.s.sol

@@ -37,7 +37,7 @@ contract ChainUpgrade_v31 is DefaultChainUpgrade {
         uint256 bridgedTokensCount = ntv.bridgedTokensCount();
         for (uint256 i = 0; i < bridgedTokensCount; ++i) {
             bytes32 assetId = ntv.bridgedTokens(i);
-            l1AssetTracker.migrateTokenBalanceFromNTVV31(assetId);
+            l1AssetTracker.registerLegacyToken(assetId);
         }
     }
 

l1-contracts/deploy-scripts/upgrade/v31/EcosystemUpgrade_v31.s.sol

@@ -153,7 +153,7 @@ contract EcosystemUpgrade_v31 is DefaultEcosystemUpgrade {
 
                 // Call AssetTracker to migrate the balance
                 vm.broadcast(getBroadcasterAddress());
-                assetTracker.migrateTokenBalanceFromNTVV31(assetId);
+                assetTracker.registerLegacyToken(assetId);
 
                 console.log("  Migration successful");
             }