fix: rename L2 migration to transfer in Staking

Author: pcarranzav

contracts/l2/staking/IL2Staking.sol

@@ -10,7 +10,7 @@ import { IL2StakingBase } from "./IL2StakingBase.sol";
  * @title Interface for the L2 Staking contract
  * @notice This is the interface that should be used when interacting with the L2 Staking contract.
  * It extends the IStaking interface with the functions that are specific to L2, adding the callhook receiver
- * to receive migrated stake and delegation from L1.
+ * to receive transferred stake and delegation from L1.
  * @dev Note that L2Staking doesn't actually inherit this interface. This is because of
  * the custom setup of the Staking contract where part of the functionality is implemented
  * in a separate contract (StakingExtension) to which calls are delegated through the fallback function.

contracts/l2/staking/IL2StakingBase.sol

@@ -10,7 +10,7 @@ import { ICallhookReceiver } from "../../gateway/ICallhookReceiver.sol";
  * @dev Note it includes only the L2-specific functionality, not the full IStaking interface.
  */
 interface IL2StakingBase is ICallhookReceiver {
-    event MigratedDelegationReturnedToDelegator(
+    event TransferredDelegationReturnedToDelegator(
         address indexed indexer,
         address indexed delegator,
         uint256 amount

contracts/l2/staking/L2Staking.sol

@@ -127,7 +127,7 @@ contract L2Staking is Staking, IL2StakingBase {
         if (shares == 0) {
             // If no shares would be issued (probably a rounding issue or attack), return the tokens to the delegator
             graphToken().transfer(_delegationData.delegator, _amount);
-            emit MigratedDelegationReturnedToDelegator(
+            emit TransferredDelegationReturnedToDelegator(
                 _delegationData.indexer,
                 _delegationData.delegator,
                 _amount

contracts/staking/IL1GraphTokenLockMigrator.sol renamed to contracts/staking/IL1GraphTokenLockTransferTool.sol

@@ -4,27 +4,27 @@ pragma solidity >=0.6.12 <0.8.0;
 pragma abicoder v2;
 
 /**
- * @title Interface for the L1GraphTokenLockMigrator contract
- * @dev This interface defines the function to get the migrated wallet address for a given L1 token lock wallet.
- * The migrator contract is implemented in the token-distribution repo: https://github.com/graphprotocol/token-distribution/pull/64
- * and is only included here to provide support in L1Staking for the migration of stake and delegation
- * owned by token lock contracts. See GIP-0046 for details: https://forum.thegraph.com/t/gip-0046-l2-migration-helpers/4023
+ * @title Interface for the L1GraphTokenLockTransferTool contract
+ * @dev This interface defines the function to get the L2 wallet address for a given L1 token lock wallet.
+ * The Transfer Tool contract is implemented in the token-distribution repo: https://github.com/graphprotocol/token-distribution/pull/64
+ * and is only included here to provide support in L1Staking for the transfer of stake and delegation
+ * owned by token lock contracts. See GIP-0046 for details: https://forum.thegraph.com/t/4023
  */
-interface IL1GraphTokenLockMigrator {
+interface IL1GraphTokenLockTransferTool {
     /**
      * @notice Pulls ETH from an L1 wallet's account to use for L2 ticket gas.
      * @dev This function is only callable by the staking contract.
      * @param _l1Wallet Address of the L1 token lock wallet
-     * @param _amount Amount of ETH to pull from the migrator contract
+     * @param _amount Amount of ETH to pull from the transfer tool contract
      */
     function pullETH(address _l1Wallet, uint256 _amount) external;
 
     /**
      * @notice Get the L2 token lock wallet address for a given L1 token lock wallet
-     * @dev In the actual L1GraphTokenLockMigrator contract, this is simply the default getter for a public mapping variable.
+     * @dev In the actual L1GraphTokenLockTransferTool contract, this is simply the default getter for a public mapping variable.
      * @param _l1Wallet Address of the L1 token lock wallet
      * @return Address of the L2 token lock wallet if the wallet has an L2 counterpart, or address zero if
      * the wallet doesn't have an L2 counterpart (or is not known to be a token lock wallet).
      */
-    function migratedWalletAddress(address _l1Wallet) external view returns (address);
+    function l2WalletAddress(address _l1Wallet) external view returns (address);
 }

contracts/staking/IL1Staking.sol

@@ -9,7 +9,7 @@ import { IL1StakingBase } from "./IL1StakingBase.sol";
 /**
  * @title Interface for the L1 Staking contract
  * @notice This is the interface that should be used when interacting with the L1 Staking contract.
- * It extends the IStaking interface with the functions that are specific to L1, adding the migration helpers
+ * It extends the IStaking interface with the functions that are specific to L1, adding the transfer tools
  * to send stake and delegation to L2.
  * @dev Note that L1Staking doesn't actually inherit this interface. This is because of
  * the custom setup of the Staking contract where part of the functionality is implemented

contracts/staking/IL1StakingBase.sol

@@ -3,62 +3,63 @@
 pragma solidity >=0.6.12 <0.8.0;
 pragma abicoder v2;
 
-import { IL1GraphTokenLockMigrator } from "./IL1GraphTokenLockMigrator.sol";
+import { IL1GraphTokenLockTransferTool } from "./IL1GraphTokenLockTransferTool.sol";
 
 /**
  * @title Base interface for the L1Staking contract.
- * @notice This interface is used to define the migration helpers that are implemented in L1Staking.
+ * @notice This interface is used to define the transfer tools that are implemented in L1Staking.
  * @dev Note it includes only the L1-specific functionality, not the full IStaking interface.
  */
 interface IL1StakingBase {
-    /// @dev Emitted when an indexer migrates their stake to L2.
-    /// This can happen several times as indexers can migrate partial stake.
-    event IndexerMigratedToL2(
+    /// @dev Emitted when an indexer transfers their stake to L2.
+    /// This can happen several times as indexers can transfer partial stake.
+    event IndexerStakeTransferredToL2(
         address indexed indexer,
         address indexed l2Indexer,
-        uint256 migratedStakeTokens
+        uint256 transferredStakeTokens
     );
 
-    /// @dev Emitted when a delegator migrates their delegation to L2
-    event DelegationMigratedToL2(
+    /// @dev Emitted when a delegator transfers their delegation to L2
+    event DelegationTransferredToL2(
         address indexed delegator,
         address indexed l2Delegator,
         address indexed indexer,
         address l2Indexer,
-        uint256 migratedDelegationTokens
+        uint256 transferredDelegationTokens
     );
 
-    /// @dev Emitted when the L1GraphTokenLockMigrator is set
-    event L1GraphTokenLockMigratorSet(address l1GraphTokenLockMigrator);
+    /// @dev Emitted when the L1GraphTokenLockTransferTool is set
+    event L1GraphTokenLockTransferToolSet(address l1GraphTokenLockTransferTool);
 
-    /// @dev Emitted when a delegator unlocks their tokens ahead of time because the indexer has migrated
-    event StakeDelegatedUnlockedDueToMigration(address indexed indexer, address indexed delegator);
+    /// @dev Emitted when a delegator unlocks their tokens ahead of time because the indexer has transferred to L2
+    event StakeDelegatedUnlockedDueToL2Transfer(address indexed indexer, address indexed delegator);
 
     /**
-     * @notice Set the L1GraphTokenLockMigrator contract address
+     * @notice Set the L1GraphTokenLockTransferTool contract address
      * @dev This function can only be called by the governor.
-     * @param _l1GraphTokenLockMigrator Address of the L1GraphTokenLockMigrator contract
+     * @param _l1GraphTokenLockTransferTool Address of the L1GraphTokenLockTransferTool contract
      */
-    function setL1GraphTokenLockMigrator(IL1GraphTokenLockMigrator _l1GraphTokenLockMigrator)
-        external;
+    function setL1GraphTokenLockTransferTool(
+        IL1GraphTokenLockTransferTool _l1GraphTokenLockTransferTool
+    ) external;
 
     /**
      * @notice Send an indexer's stake to L2.
      * @dev This function can only be called by the indexer (not an operator).
      * It will validate that the remaining stake is sufficient to cover all the allocated
-     * stake, so the indexer might have to close some allocations before migrating.
+     * stake, so the indexer might have to close some allocations before transferring.
      * It will also check that the indexer's stake is not locked for withdrawal.
      * Since the indexer address might be an L1-only contract, the function takes a beneficiary
      * address that will be the indexer's address in L2.
      * The caller must provide an amount of ETH to use for the L2 retryable ticket, that
      * must be at least `_maxSubmissionCost + _gasPriceBid * _maxGas`.
-     * @param _l2Beneficiary Address of the indexer in L2. If the indexer has previously migrated stake, this must match the previously-used value.
-     * @param _amount Amount of stake GRT to migrate to L2
+     * @param _l2Beneficiary Address of the indexer in L2. If the indexer has previously transferred stake, this must match the previously-used value.
+     * @param _amount Amount of stake GRT to transfer to L2
      * @param _maxGas Max gas to use for the L2 retryable ticket
      * @param _gasPriceBid Gas price bid for the L2 retryable ticket
      * @param _maxSubmissionCost Max submission cost for the L2 retryable ticket
      */
-    function migrateStakeToL2(
+    function transferStakeToL2(
         address _l2Beneficiary,
         uint256 _amount,
         uint256 _maxGas,
@@ -70,20 +71,20 @@ interface IL1StakingBase {
      * @notice Send an indexer's stake to L2, from a GraphTokenLockWallet vesting contract.
      * @dev This function can only be called by the indexer (not an operator).
      * It will validate that the remaining stake is sufficient to cover all the allocated
-     * stake, so the indexer might have to close some allocations before migrating.
+     * stake, so the indexer might have to close some allocations before transferring.
      * It will also check that the indexer's stake is not locked for withdrawal.
-     * The L2 beneficiary for the stake will be determined by calling the L1GraphTokenLockMigrator contract,
-     * so the caller must have previously migrated tokens through that first
-     * (see GIP-0046 for details: https://forum.thegraph.com/t/gip-0046-l2-migration-helpers/4023).
-     * The ETH for the L2 gas will be pulled from the L1GraphTokenLockMigrator, so the owner of
+     * The L2 beneficiary for the stake will be determined by calling the L1GraphTokenLockTransferTool contract,
+     * so the caller must have previously transferred tokens through that first
+     * (see GIP-0046 for details: https://forum.thegraph.com/t/4023).
+     * The ETH for the L2 gas will be pulled from the L1GraphTokenLockTransferTool, so the owner of
      * the GraphTokenLockWallet must have previously deposited at least `_maxSubmissionCost + _gasPriceBid * _maxGas`
-     * ETH into the L1GraphTokenLockMigrator contract (using its depositETH function).
-     * @param _amount Amount of stake GRT to migrate to L2
+     * ETH into the L1GraphTokenLockTransferTool contract (using its depositETH function).
+     * @param _amount Amount of stake GRT to transfer to L2
      * @param _maxGas Max gas to use for the L2 retryable ticket
      * @param _gasPriceBid Gas price bid for the L2 retryable ticket
      * @param _maxSubmissionCost Max submission cost for the L2 retryable ticket
      */
-    function migrateLockedStakeToL2(
+    function transferLockedStakeToL2(
         uint256 _amount,
         uint256 _maxGas,
         uint256 _gasPriceBid,
@@ -93,19 +94,19 @@ interface IL1StakingBase {
     /**
      * @notice Send a delegator's delegated tokens to L2
      * @dev This function can only be called by the delegator.
-     * This function will validate that the indexer has migrated their stake using migrateStakeToL2,
+     * This function will validate that the indexer has transferred their stake using transferStakeToL2,
      * and that the delegation is not locked for undelegation.
      * Since the delegator's address might be an L1-only contract, the function takes a beneficiary
      * address that will be the delegator's address in L2.
      * The caller must provide an amount of ETH to use for the L2 retryable ticket, that
      * must be at least `_maxSubmissionCost + _gasPriceBid * _maxGas`.
-     * @param _indexer Address of the indexer (in L1, before migrating)
+     * @param _indexer Address of the indexer (in L1, before transferring to L2)
      * @param _l2Beneficiary Address of the delegator in L2
      * @param _maxGas Max gas to use for the L2 retryable ticket
      * @param _gasPriceBid Gas price bid for the L2 retryable ticket
      * @param _maxSubmissionCost Max submission cost for the L2 retryable ticket
      */
-    function migrateDelegationToL2(
+    function transferDelegationToL2(
         address _indexer,
         address _l2Beneficiary,
         uint256 _maxGas,
@@ -116,34 +117,34 @@ interface IL1StakingBase {
     /**
      * @notice Send a delegator's delegated tokens to L2, for a GraphTokenLockWallet vesting contract
      * @dev This function can only be called by the delegator.
-     * This function will validate that the indexer has migrated their stake using migrateStakeToL2,
+     * This function will validate that the indexer has transferred their stake using transferStakeToL2,
      * and that the delegation is not locked for undelegation.
-     * The L2 beneficiary for the delegation will be determined by calling the L1GraphTokenLockMigrator contract,
-     * so the caller must have previously migrated tokens through that first
-     * (see GIP-0046 for details: https://forum.thegraph.com/t/gip-0046-l2-migration-helpers/4023).
-     * The ETH for the L2 gas will be pulled from the L1GraphTokenLockMigrator, so the owner of
+     * The L2 beneficiary for the delegation will be determined by calling the L1GraphTokenLockTransferTool contract,
+     * so the caller must have previously transferred tokens through that first
+     * (see GIP-0046 for details: https://forum.thegraph.com/t/4023).
+     * The ETH for the L2 gas will be pulled from the L1GraphTokenLockTransferTool, so the owner of
      * the GraphTokenLockWallet must have previously deposited at least `_maxSubmissionCost + _gasPriceBid * _maxGas`
-     * ETH into the L1GraphTokenLockMigrator contract (using its depositETH function).
-     * @param _indexer Address of the indexer (in L1, before migrating)
+     * ETH into the L1GraphTokenLockTransferTool contract (using its depositETH function).
+     * @param _indexer Address of the indexer (in L1, before transferring to L2)
      * @param _maxGas Max gas to use for the L2 retryable ticket
      * @param _gasPriceBid Gas price bid for the L2 retryable ticket
      * @param _maxSubmissionCost Max submission cost for the L2 retryable ticket
      */
-    function migrateLockedDelegationToL2(
+    function transferLockedDelegationToL2(
         address _indexer,
         uint256 _maxGas,
         uint256 _gasPriceBid,
         uint256 _maxSubmissionCost
     ) external;
 
     /**
-     * @notice Unlock a delegator's delegated tokens, if the indexer has migrated
+     * @notice Unlock a delegator's delegated tokens, if the indexer has transferred to L2
      * @dev This function can only be called by the delegator.
-     * This function will validate that the indexer has migrated their stake using migrateStakeToL2,
+     * This function will validate that the indexer has transferred their stake using transferStakeToL2,
      * and that the indexer has no remaining stake in L1.
      * The tokens must previously be locked for undelegation by calling `undelegate()`,
      * and can be withdrawn with `withdrawDelegated()` immediately after calling this.
-     * @param _indexer Address of the indexer (in L1, before migrating)
+     * @param _indexer Address of the indexer (in L1, before transferring to L2)
      */
-    function unlockDelegationToMigratedIndexer(address _indexer) external;
+    function unlockDelegationToTransferredIndexer(address _indexer) external;
 }