Enable quota-based instant delegation with era restrictions (#447)

* Implement quota-based instant delegation feature

Add support for instant delegation with per-wallet, per-era quota limits to encourage delegation while preventing attacks:

- Add quota tracking with auto-reset on era change using storage-efficient struct
- Implement 70% era window restriction to prevent last-minute sniping
- Support automatic splitting of large delegations into instant + pending portions
- Reuse existing applyRedelegation() for instant rewards distribution
- Add configuration parameters for quota amount and era window percentage

Changes:
- Staking.sol: Add instant quota tracking, token transfer, and parameter configuration
- StakingManager.sol: Refactor delegate() with era progress calculation and quota logic
- IStaking.sol: Add new interface methods for instant delegation
- Test coverage for all instant delegation scenarios

* Refactor instant delegation implementation

- Move InstantQuotaUsage struct to IStaking interface for better organization
- Remove delegateToIndexer function, use transferDelegationTokens + addDelegation instead
- Extract common transferDelegationTokens call in delegate() to reduce code duplication

* clean up

* Run yarn dedupe to fix dependency resolution

Fix YN0078 invalid resolution warning for @ethersproject/abi and other packages

* Fix invalid resolution for @ethersproject/abi@npm:5.0.7

Remove invalid resolution entry that pointed 5.0.7 to 5.1.2, let yarn regenerate the correct resolution

* Add resolutions to fix @ethersproject version conflicts

Fix TypeScript compilation errors caused by multiple versions of @ethersproject packages.
Force all @ethersproject dependencies to use 5.5.x versions to match ethers 5.5.4

* fix vesting test

* fix per comment

* make test more robust

* upgrade to testnet
- make test more robust

* remove .only from Staking.test.ts

* fix per comment

* replace @nomiclabs/hardhat-etherscan with @nomicfoundation/hardhat-verify

Author: ianhe8x

.yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs

@@ -1,23 +1,15 @@
 changesetBaseRefs:
-    - main
-    - origin/main
+  - main
+  - origin/main
 
 enableImmutableInstalls: false
 
 enableProgressBars: false
 
 nodeLinker: node-modules
 
-npmAuthToken: '${NPM_TOKEN:-}'
+npmAuthToken: "${NPM_TOKEN:-}"
 
-npmPublishRegistry: 'https://registry.npmjs.org'
+npmPublishRegistry: "https://registry.npmjs.org"
 
-plugins:
-    - path: .yarn/plugins/@yarnpkg/plugin-typescript.cjs
-      spec: '@yarnpkg/plugin-typescript'
-    - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
-      spec: '@yarnpkg/plugin-version'
-    - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
-      spec: '@yarnpkg/plugin-interactive-tools'
-
-yarnPath: .yarn/releases/yarn-3.6.4.cjs
+yarnPath: .yarn/releases/yarn-4.10.3.cjs

.yarn/plugins/@yarnpkg/plugin-typescript.cjs

@@ -128,6 +128,17 @@ contract Staking is IStaking, Initializable, OwnableUpgradeable, SQParameter {
     // Staking runner lengths
     mapping(address => uint256) public stakingIndexerLengths;
 
+    // Instant delegation quota per era (per wallet)
+    uint256 public instantDelegationQuota;
+
+    // Era window percentage for instant delegation (in perMill, e.g., 700,000 = 70%)
+    uint256 public instantEraWindowPercent;
+
+    // Instant quota usage tracking
+
+    // Track instant quota used per delegator: delegator => QuotaUsage
+    mapping(address => InstantQuotaUsage) public instantQuotaUsed;
+
     // -- Events --
 
     /**
@@ -350,18 +361,20 @@ contract Staking is IStaking, Initializable, OwnableUpgradeable, SQParameter {
         emit DelegationAdded2(_source, _runner, _amount, instant);
     }
 
-    function delegateToIndexer(
+    /**
+     * @dev Transfer tokens from source to this contract (for instant delegation)
+     * @param _source The source address
+     * @param _amount The amount to transfer
+     */
+    function transferDelegationTokens(
         address _source,
-        address _runner,
         uint256 _amount
     ) external onlyStakingManager {
         IERC20(settings.getContractAddress(SQContracts.SQToken)).safeTransferFrom(
             _source,
             address(this),
             _amount
         );
-
-        this.addDelegation(_source, _runner, _amount, false);
     }
 
     function removeDelegation(address _source, address _runner, uint256 _amount) external {
@@ -492,11 +505,72 @@ contract Staking is IStaking, Initializable, OwnableUpgradeable, SQParameter {
         this.startUnbond(_runner, _runner, _amount, UnbondType.Commission);
     }
 
+    /**
+     * @notice Update instant quota used for a delegator in a specific era
+     * @param delegator The delegator address
+     * @param era The era number
+     * @param amount The amount to add to used quota
+     */
+    function updateInstantQuotaUsed(
+        address delegator,
+        uint256 era,
+        uint256 amount
+    ) external onlyStakingManager {
+        InstantQuotaUsage storage usage = instantQuotaUsed[delegator];
+
+        // If era changed, reset the quota usage
+        if (usage.era != era) {
+            usage.era = era;
+            usage.amount = amount;
+        } else {
+            // Same era, accumulate
+            usage.amount += amount;
+        }
+    }
+
+    /**
+     * @notice Set instant delegation parameters
+     * @param _perEraQuota The quota per era per wallet
+     * @param _windowPercent The era window percentage (in perMill)
+     */
+    function setInstantDelegationParams(
+        uint256 _perEraQuota,
+        uint256 _windowPercent
+    ) external onlyOwner {
+        require(_windowPercent <= PER_MILL, 'S015');
+        instantDelegationQuota = _perEraQuota;
+        instantEraWindowPercent = _windowPercent;
+
+        emit Parameter('instantDelegationQuota', abi.encode(_perEraQuota));
+        emit Parameter('instantEraWindowPercent', abi.encode(_windowPercent));
+    }
+
     // -- Views --
 
     function isEmptyDelegation(address _source, address _runner) external view returns (bool) {
         return
             delegation[_source][_runner].valueAt == 0 &&
             delegation[_source][_runner].valueAfter == 0;
     }
+
+    /**
+     * @notice Get remaining instant quota for a delegator in a specific era
+     * @param delegator The delegator address
+     * @param era The era number
+     * @return The remaining quota amount
+     */
+    function getInstantQuotaRemaining(
+        address delegator,
+        uint256 era
+    ) external view returns (uint256) {
+        InstantQuotaUsage memory usage = instantQuotaUsed[delegator];
+
+        // If different era or not yet used, full quota available
+        if (usage.era != era) {
+            return instantDelegationQuota;
+        }
+
+        // Same era, return remaining
+        return instantDelegationQuota > usage.amount ? instantDelegationQuota - usage.amount : 0;
+    }
 }

.yarn/plugins/@yarnpkg/plugin-version.cjs

@@ -11,13 +11,16 @@ import './interfaces/IIndexerRegistry.sol';
 import './interfaces/IStakingManager.sol';
 import './utils/MathUtil.sol';
 import './utils/StakingUtil.sol';
+import './Constants.sol';
 import '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
 import '@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol';
 
 /**
  * Split from Staking, to keep contract size under control
  */
 contract StakingManager is IStakingManager, Initializable, OwnableUpgradeable {
+    using MathUtil for uint256;
+
     ISettings public settings;
 
     /**
@@ -50,18 +53,59 @@ contract StakingManager is IStakingManager, Initializable, OwnableUpgradeable {
         } else {
             require(msg.sender == _runner, 'G002');
         }
-        staking.delegateToIndexer(_runner, _runner, _amount);
+        staking.transferDelegationTokens(_runner, _amount);
+        staking.addDelegation(_runner, _runner, _amount, false);
     }
 
     /**
      * @dev Delegator stake to Indexer, Indexer cannot call this.
+     * Supports instant delegation with quota-based limits and era window restrictions.
      */
     function delegate(address _runner, uint256 _amount) external {
         require(msg.sender != _runner, 'G004');
         Staking staking = Staking(settings.getContractAddress(SQContracts.Staking));
-        // delegation limit should not exceed
+
+        // Check delegation limitation
         staking.checkDelegateLimitation(_runner, _amount);
-        staking.delegateToIndexer(msg.sender, _runner, _amount);
+
+        // Transfer tokens first
+        staking.transferDelegationTokens(msg.sender, _amount);
+
+        // Check era progress (70% window by default)
+        uint256 eraProgress = _calculateEraProgress();
+        uint256 windowPercent = staking.instantEraWindowPercent();
+        bool inInstantWindow = windowPercent > 0 && eraProgress <= windowPercent;
+
+        if (!inInstantWindow) {
+            // After window: all delegation is pending
+            staking.addDelegation(msg.sender, _runner, _amount, false);
+            return;
+        }
+
+        // Within window: check quota
+        uint256 remainingQuota = _getRemainingQuota(msg.sender);
+
+        if (_amount <= remainingQuota) {
+            // Case A: Fully instant
+            staking.addDelegation(msg.sender, _runner, _amount, true);
+            _applyInstantDelegation(msg.sender, _runner);
+            _consumeInstantQuota(msg.sender, _amount);
+        } else if (remainingQuota > 0) {
+            // Case B: Split - instant + pending
+            uint256 instantAmount = remainingQuota;
+            uint256 pendingAmount = _amount - remainingQuota;
+
+            // Instant portion
+            staking.addDelegation(msg.sender, _runner, instantAmount, true);
+            _applyInstantDelegation(msg.sender, _runner);
+            _consumeInstantQuota(msg.sender, instantAmount);
+
+            // Pending portion
+            staking.addDelegation(msg.sender, _runner, pendingAmount, false);
+        } else {
+            // Case C: Quota exhausted - all pending
+            staking.addDelegation(msg.sender, _runner, _amount, false);
+        }
     }
 
     /**
@@ -214,6 +258,64 @@ contract StakingManager is IStakingManager, Initializable, OwnableUpgradeable {
         staking.slashRunner(_indexer, _amount);
     }
 
+    /**
+     * @dev Calculate current era progress as a percentage (in perMill)
+     * @return Progress value (0-PER_MILL, where PER_MILL = 100%)
+     */
+    function _calculateEraProgress() internal view returns (uint256) {
+        IEraManager eraManager = IEraManager(settings.getContractAddress(SQContracts.EraManager));
+
+        uint256 eraStartTime = eraManager.eraStartTime();
+        uint256 eraPeriod = eraManager.eraPeriod();
+
+        uint256 elapsed = block.timestamp - eraStartTime;
+
+        // Prevent overflow: if elapsed >= eraPeriod, return 100%
+        if (elapsed >= eraPeriod) {
+            return PER_MILL;
+        }
+
+        return MathUtil.mulDiv(elapsed, PER_MILL, eraPeriod);
+    }
+
+    /**
+     * @dev Get remaining instant delegation quota for a delegator
+     * @param delegator The delegator address
+     * @return Remaining quota amount
+     */
+    function _getRemainingQuota(address delegator) internal view returns (uint256) {
+        IEraManager eraManager = IEraManager(settings.getContractAddress(SQContracts.EraManager));
+        Staking staking = Staking(settings.getContractAddress(SQContracts.Staking));
+
+        uint256 currentEra = eraManager.eraNumber();
+        return staking.getInstantQuotaRemaining(delegator, currentEra);
+    }
+
+    /**
+     * @dev Apply instant delegation to rewards system
+     * @param delegator The delegator address
+     * @param runner The runner address
+     */
+    function _applyInstantDelegation(address delegator, address runner) internal {
+        IRewardsStaking rewardsStaking = IRewardsStaking(
+            settings.getContractAddress(SQContracts.RewardsStaking)
+        );
+        rewardsStaking.applyRedelegation(runner, delegator);
+    }
+
+    /**
+     * @dev Consume instant quota for a delegator
+     * @param delegator The delegator address
+     * @param amount The amount to consume
+     */
+    function _consumeInstantQuota(address delegator, uint256 amount) internal {
+        IEraManager eraManager = IEraManager(settings.getContractAddress(SQContracts.EraManager));
+        Staking staking = Staking(settings.getContractAddress(SQContracts.Staking));
+
+        uint256 currentEra = eraManager.eraNumber();
+        staking.updateInstantQuotaUsed(delegator, currentEra, amount);
+    }
+
     // -- Views --
 
     function _getCurrentDelegationAmount(

.yarn/releases/yarn-3.6.4.cjs

@@ -30,8 +30,39 @@ enum UnbondType {
     Merge
 }
 
+/**
+ * @dev Instant delegation quota tracking. One per Delegator.
+ * Tracks quota usage within current era, auto-resets on era change.
+ */
+struct InstantQuotaUsage {
+    uint256 era; // era of quota usage
+    uint256 amount; // quota used in this era
+}
+
 interface IStaking {
     function lockedAmount(address _delegator) external view returns (uint256);
 
     function unbondCommission(address _runner, uint256 _amount) external;
+
+    function addDelegation(
+        address _source,
+        address _runner,
+        uint256 _amount,
+        bool instant
+    ) external;
+
+    function transferDelegationTokens(address _source, uint256 _amount) external;
+
+    function updateInstantQuotaUsed(address delegator, uint256 era, uint256 amount) external;
+
+    function setInstantDelegationParams(uint256 _perEraQuota, uint256 _windowPercent) external;
+
+    function getInstantQuotaRemaining(
+        address delegator,
+        uint256 era
+    ) external view returns (uint256);
+
+    function instantDelegationQuota() external view returns (uint256);
+
+    function instantEraWindowPercent() external view returns (uint256);
 }

.yarn/releases/yarn-4.10.3.cjs

@@ -1,5 +1,5 @@
 import * as dotenv from 'dotenv';
-import '@nomiclabs/hardhat-etherscan';
+import '@nomicfoundation/hardhat-verify';
 import '@nomiclabs/hardhat-waffle';
 import '@typechain/hardhat';
 import 'hardhat-contract-sizer';
@@ -453,33 +453,7 @@ const config: HardhatUserConfig = {
         gasPrice: 21,
     },
     etherscan: {
-        apiKey: {
-            polygonMumbai: process.env.POLYGONSCAN_API_KEY,
-            goerli: process.env.ETHERSCAN_API_KEY,
-            sepolia: process.env.ETHERSCAN_API_KEY,
-            base: process.env.BASESCAN_API_KEY,
-            'base-sepolia': process.env.BASESCAN_API_KEY,
-            polygon: process.env.POLYGONSCAN_API_KEY,
-            mainnet: process.env.ETHERSCAN_API_KEY,
-        },
-        customChains: [
-            {
-                network: 'base-sepolia',
-                chainId: 84532,
-                urls: {
-                    apiURL: 'https://api-sepolia.basescan.org/api',
-                    browserURL: 'https://sepolia.basescan.org',
-                },
-            },
-            {
-                network: 'base',
-                chainId: 8453,
-                urls: {
-                    apiURL: 'https://api.basescan.org/api',
-                    browserURL: 'https://basescan.org',
-                },
-            },
-        ],
+        apiKey: process.env.ETHERSCAN_API_KEY,
     },
     typechain: {
         outDir: 'src/typechain',