fix: several fixes for owner-only subgraph migration

pcarranzav · pcarranzav · commit 4d5dc9ceedcb · 2022-12-15T12:02:50.000-03:00
diff --git a/contracts/discovery/L1GNS.sol b/contracts/discovery/L1GNS.sol
@@ -86,7 +86,7 @@ contract L1GNS is GNS, L1GNSV1Storage, L1ArbitrumMessenger {
 
         bytes memory extraData = abi.encode(
             uint8(IL2GNS.L1MessageCodes.RECEIVE_SUBGRAPH_CODE),
-            abi.encode(_subgraphID, _l2Owner, ownerNSignal)
+            abi.encode(_subgraphID, _l2Owner)
         );
 
         _sendTokensAndMessageToL2GNS(
@@ -136,7 +136,7 @@ contract L1GNS is GNS, L1GNSV1Storage, L1ArbitrumMessenger {
         );
         bytes memory extraData = abi.encode(
             uint8(IL2GNS.L1MessageCodes.RECEIVE_CURATOR_BALANCE_CODE),
-            abi.encode(_subgraphID, _beneficiary, tokensForL2)
+            abi.encode(_subgraphID, _beneficiary)
         );
 
         // Set the subgraph as if the curator had withdrawn their tokens
diff --git a/contracts/l2/curation/IL2Curation.sol b/contracts/l2/curation/IL2Curation.sol
@@ -12,14 +12,11 @@ interface IL2Curation {
      * only during an L1-L2 migration).
      * @param _subgraphDeploymentID Subgraph deployment pool from where to mint signal
      * @param _tokensIn Amount of Graph Tokens to deposit
-     * @param _signalOutMin Expected minimum amount of signal to receive
      * @return Signal minted
      */
-    function mintTaxFree(
-        bytes32 _subgraphDeploymentID,
-        uint256 _tokensIn,
-        uint256 _signalOutMin
-    ) external returns (uint256);
+    function mintTaxFree(bytes32 _subgraphDeploymentID, uint256 _tokensIn)
+        external
+        returns (uint256);
 
     /**
      * @notice Calculate amount of signal that can be bought with tokens in a curation pool,
diff --git a/contracts/l2/curation/L2Curation.sol b/contracts/l2/curation/L2Curation.sol
@@ -233,23 +233,21 @@ contract L2Curation is CurationV2Storage, GraphUpgradeable, IL2Curation {
      * only during an L1-L2 migration).
      * @param _subgraphDeploymentID Subgraph deployment pool from where to mint signal
      * @param _tokensIn Amount of Graph Tokens to deposit
-     * @param _signalOutMin Expected minimum amount of signal to receive
      * @return Signal minted
      */
-    function mintTaxFree(
-        bytes32 _subgraphDeploymentID,
-        uint256 _tokensIn,
-        uint256 _signalOutMin
-    ) external override notPartialPaused onlyGNS returns (uint256) {
+    function mintTaxFree(bytes32 _subgraphDeploymentID, uint256 _tokensIn)
+        external
+        override
+        notPartialPaused
+        onlyGNS
+        returns (uint256)
+    {
         // Need to deposit some funds
         require(_tokensIn != 0, "Cannot deposit zero tokens");
 
         // Exchange GRT tokens for GCS of the subgraph pool (no tax)
         uint256 signalOut = _tokensToSignal(_subgraphDeploymentID, _tokensIn);
 
-        // Slippage protection
-        require(signalOut >= _signalOutMin, "Slippage protection");
-
         address curator = msg.sender;
         CurationPool storage curationPool = _pools[_subgraphDeploymentID];
 
diff --git a/contracts/l2/discovery/IL2GNS.sol b/contracts/l2/discovery/IL2GNS.sol
@@ -28,13 +28,4 @@ interface IL2GNS is ICallhookReceiver {
         bytes32 _subgraphMetadata,
         bytes32 _versionMetadata
     ) external;
-
-    /**
-     * @notice Deprecate a subgraph that was migrated from L1, but for which
-     * the migration was never finished. Anyone can call this function after 50400 blocks
-     * (one day) have passed since the subgraph was migrated, if the subgraph owner didn't
-     * call finishSubgraphMigrationFromL1.
-     * @param _subgraphID Subgraph ID
-     */
-    function deprecateSubgraphMigratedFromL1(uint256 _subgraphID) external;
 }
diff --git a/contracts/l2/discovery/L2GNS.sol b/contracts/l2/discovery/L2GNS.sol
@@ -28,16 +28,19 @@ import { IL2Curation } from "../curation/IL2Curation.sol";
 contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
     using SafeMathUpgradeable for uint256;
 
-    /// The amount of time (in blocks) that a subgraph owner has to finish the migration
-    /// from L1 before the subgraph can be deprecated: 1 week
-    uint256 public constant FINISH_MIGRATION_TIMEOUT = 50400;
-
     /// @dev Emitted when a subgraph is received from L1 through the bridge
     event SubgraphReceivedFromL1(uint256 _subgraphID);
     /// @dev Emitted when a subgraph migration from L1 is finalized, so the subgraph is published
     event SubgraphMigrationFinalized(uint256 _subgraphID);
     /// @dev Emitted when the L1 balance for a curator has been claimed
     event CuratorBalanceReceived(uint256 _subgraphID, address _l2Curator, uint256 _tokens);
+    /// @dev Emitted when the L1 balance for a curator has been returned to the beneficiary.
+    /// This can happen if the subgraph migration was not finished when the curator's tokens arrived.
+    event CuratorBalanceReturnedToBeneficiary(
+        uint256 _subgraphID,
+        address _l2Curator,
+        uint256 _tokens
+    );
 
     /**
      * @dev Checks that the sender is the L2GraphTokenGateway as configured on the Controller.
@@ -63,18 +66,15 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
         (uint8 code, bytes memory functionData) = abi.decode(_data, (uint8, bytes));
 
         if (code == uint8(L1MessageCodes.RECEIVE_SUBGRAPH_CODE)) {
-            (uint256 subgraphID, address subgraphOwner, uint256 nSignal) = abi.decode(
+            (uint256 subgraphID, address subgraphOwner) = abi.decode(
                 functionData,
-                (uint256, address, uint256)
+                (uint256, address)
             );
 
-            _receiveSubgraphFromL1(subgraphID, subgraphOwner, _amount, nSignal);
+            _receiveSubgraphFromL1(subgraphID, subgraphOwner, _amount);
         } else if (code == uint8(L1MessageCodes.RECEIVE_CURATOR_BALANCE_CODE)) {
-            (uint256 subgraphID, address l2Curator, uint256 tokens) = abi.decode(
-                functionData,
-                (uint256, address, uint256)
-            );
-            _mintSignalFromL1(subgraphID, l2Curator, tokens);
+            (uint256 subgraphID, address l2Curator) = abi.decode(functionData, (uint256, address));
+            _mintSignalFromL1(subgraphID, l2Curator, _amount);
         } else {
             revert("INVALID_CODE");
         }
@@ -108,9 +108,14 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
         IL2Curation curation = IL2Curation(address(curation()));
         // Update pool: constant nSignal, vSignal can change (w/no slippage protection)
         // Buy all signal from the new deployment
-        subgraphData.vSignal = curation.mintTaxFree(_subgraphDeploymentID, migratedData.tokens, 0);
-        subgraphData.disabled = false;
+        uint256 vSignal = curation.mintTaxFree(_subgraphDeploymentID, migratedData.tokens);
+        uint256 nSignal = vSignalToNSignal(_subgraphID, vSignal);
 
+        subgraphData.disabled = false;
+        subgraphData.vSignal = vSignal;
+        subgraphData.nSignal = nSignal;
+        subgraphData.curatorNSignal[msg.sender] = nSignal;
+        subgraphData.subgraphDeploymentID = _subgraphDeploymentID;
         // Set the token metadata
         _setSubgraphMetadata(_subgraphID, _subgraphMetadata);
 
@@ -121,41 +126,10 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
             migratedData.tokens,
             _subgraphDeploymentID
         );
-        // Update target deployment
-        subgraphData.subgraphDeploymentID = _subgraphDeploymentID;
         emit SubgraphVersionUpdated(_subgraphID, _subgraphDeploymentID, _versionMetadata);
         emit SubgraphMigrationFinalized(_subgraphID);
     }
 
-    /**
-     * @notice Deprecate a subgraph that was migrated from L1, but for which
-     * the migration was never finished. Anyone can call this function after 50400 blocks
-     * (one day) have passed since the subgraph was migrated, if the subgraph owner didn't
-     * call finishSubgraphMigrationFromL1.
-     * @param _subgraphID Subgraph ID
-     */
-    function deprecateSubgraphMigratedFromL1(uint256 _subgraphID)
-        external
-        override
-        notPartialPaused
-    {
-        IGNS.SubgraphL2MigrationData storage migratedData = subgraphL2MigrationData[_subgraphID];
-        require(migratedData.subgraphReceivedOnL2BlockNumber != 0, "INVALID_SUBGRAPH");
-        require(!migratedData.l2Done, "ALREADY_FINISHED");
-        require(
-            block.number > migratedData.subgraphReceivedOnL2BlockNumber + FINISH_MIGRATION_TIMEOUT,
-            "TOO_EARLY"
-        );
-        SubgraphData storage subgraphData = _getSubgraphData(_subgraphID);
-
-        migratedData.l2Done = true;
-        uint256 withdrawableGRT = migratedData.tokens;
-        subgraphData.withdrawableGRT = withdrawableGRT;
-        subgraphData.reserveRatio = 0;
-        _burnNFT(_subgraphID);
-        emit SubgraphDeprecated(_subgraphID, withdrawableGRT);
-    }
-
     /**
      * @notice Publish a new version of an existing subgraph.
      * @dev This is the same as the one in the base GNS, but skips the check for
@@ -234,21 +208,18 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
      * @param _subgraphID Subgraph ID
      * @param _subgraphOwner Owner of the subgraph
      * @param _tokens Tokens to be deposited in the subgraph
-     * @param _nSignal Name signal for the subgraph in L1
      */
     function _receiveSubgraphFromL1(
         uint256 _subgraphID,
         address _subgraphOwner,
-        uint256 _tokens,
-        uint256 _nSignal
+        uint256 _tokens
     ) internal {
         IGNS.SubgraphL2MigrationData storage migratedData = subgraphL2MigrationData[_subgraphID];
         SubgraphData storage subgraphData = _getSubgraphData(_subgraphID);
 
         subgraphData.reserveRatio = fixedReserveRatio;
         // The subgraph will be disabled until finishSubgraphMigrationFromL1 is called
         subgraphData.disabled = true;
-        subgraphData.nSignal = _nSignal;
 
         migratedData.tokens = _tokens;
         migratedData.subgraphReceivedOnL2BlockNumber = block.number;
@@ -262,6 +233,7 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
 
     /**
      * @notice Deposit GRT into a subgraph and mint signal, using tokens received from L1.
+     * If the subgraph migration was never finished, the tokens will be sent to the curator.
      * @dev This looks a lot like GNS.mintSignal, but doesn't pull the tokens from the
      * curator and has no slippage protection.
      * @param _subgraphID Subgraph ID
@@ -273,21 +245,29 @@ contract L2GNS is GNS, L2GNSV1Storage, IL2GNS {
         address _curator,
         uint256 _tokensIn
     ) internal {
-        // Subgraph checks
-        SubgraphData storage subgraphData = _getSubgraphOrRevert(_subgraphID);
-
-        // Get name signal to mint for tokens deposited
-        IL2Curation curation = IL2Curation(address(curation()));
-        uint256 vSignal = curation.mintTaxFree(subgraphData.subgraphDeploymentID, _tokensIn, 0);
-        uint256 nSignal = vSignalToNSignal(_subgraphID, vSignal);
+        IGNS.SubgraphL2MigrationData storage migratedData = subgraphL2MigrationData[_subgraphID];
 
-        // Update pools
-        subgraphData.vSignal = subgraphData.vSignal.add(vSignal);
-        subgraphData.nSignal = subgraphData.nSignal.add(nSignal);
-        subgraphData.curatorNSignal[_curator] = subgraphData.curatorNSignal[_curator].add(nSignal);
+        // If subgraph migration wasn't finished, we should send the tokens to the curator
+        if (!migratedData.l2Done) {
+            graphToken().transfer(_curator, _tokensIn);
+            emit CuratorBalanceReturnedToBeneficiary(_subgraphID, _curator, _tokensIn);
+        } else {
+            SubgraphData storage subgraphData = _getSubgraphData(_subgraphID);
+            // Get name signal to mint for tokens deposited
+            IL2Curation curation = IL2Curation(address(curation()));
+            uint256 vSignal = curation.mintTaxFree(subgraphData.subgraphDeploymentID, _tokensIn);
+            uint256 nSignal = vSignalToNSignal(_subgraphID, vSignal);
+
+            // Update pools
+            subgraphData.vSignal = subgraphData.vSignal.add(vSignal);
+            subgraphData.nSignal = subgraphData.nSignal.add(nSignal);
+            subgraphData.curatorNSignal[_curator] = subgraphData.curatorNSignal[_curator].add(
+                nSignal
+            );
 
-        emit SignalMinted(_subgraphID, _curator, nSignal, vSignal, _tokensIn);
-        emit CuratorBalanceReceived(_subgraphID, _curator, _tokensIn);
+            emit SignalMinted(_subgraphID, _curator, nSignal, vSignal, _tokensIn);
+            emit CuratorBalanceReceived(_subgraphID, _curator, _tokensIn);
+        }
     }
 
     /**
diff --git a/test/gns.test.ts b/test/gns.test.ts
diff --git a/test/l2/l2Curation.test.ts b/test/l2/l2Curation.test.ts
