[Loopring_3.6] improve exchange staking (#1617)

dong77 · web-flow · commit ea59d99720c0 · 2020-08-15T19:29:06.000+08:00
diff --git a/packages/loopring_v3/DESIGN.md b/packages/loopring_v3/DESIGN.md
@@ -132,7 +132,7 @@ The operator contract can also be used to enforce an off-chain data-availability
 
 The operator creates a block and submits it on-chain by calling `submitBlocks`. Multiple blocks can be submitted at the same time. All blocks will be immediately verified. If possible, batch verification is used to verify multiple blocks of the same type.
 
-An operator can only submit new blocks when the the exchange owner has enough LRC staked. For an exchange with data-availability the exchange stake needs to be at least `minExchangeStakeRollup`LRC and for an exchange without data-availability the stake needs to be at least `minExchangeStakeValidium`LRC.
+An operator can only submit new blocks when the the exchange owner has enough LRC staked. For the first 10 thousand blocks, this check is skipped. Each exchange stake needs to be at least `stakePerThousandBlocks * numBlocks /1000` USD worth of LRC. The total staking requirement will be cappped at 1,000,000 blocks.
 
 #### Only Allow Off-chain Requests to be Used Once
 
diff --git a/packages/loopring_v3/contracts/aux/access/LoopringV3Owner.sol b/packages/loopring_v3/contracts/aux/access/LoopringV3Owner.sol
@@ -16,25 +16,25 @@ contract LoopringV3Owner is DelayedOwner
 
     struct Costs
     {
-        uint minExchangeStake;
+        uint stakePerThousandBlocks;
     }
 
     Costs public USD;
 
     event LRCValuesUpdated(
-        uint minExchangeStakeLRC
+        uint stakePerThousandBlocks
     );
 
     constructor(
         ILoopringV3                _loopringV3,
         ITokenPriceProvider        _provider,
-        uint                       _minExchangeStakeUSD
+        uint                       _stakePerThousandBlocksUSD
         )
         DelayedOwner(address(_loopringV3), 3 days)
     {
         loopringV3 = _loopringV3;
         provider = _provider;
-        USD.minExchangeStake = _minExchangeStakeUSD;
+        USD.stakePerThousandBlocks = _stakePerThousandBlocksUSD;
 
         setFunctionDelay(loopringV3.transferOwnership.selector, 7 days);
         setFunctionDelay(loopringV3.updateSettings.selector, 7 days);
@@ -49,7 +49,7 @@ contract LoopringV3Owner is DelayedOwner
     {
         // Get the current costs in LRC
         Costs memory lrcCosts = Costs(
-            provider.usd2lrc(USD.minExchangeStake)
+            provider.usd2lrc(USD.stakePerThousandBlocks)
         );
 
         // Set the new LRC values on the protocol contract immediately
@@ -58,11 +58,11 @@ contract LoopringV3Owner is DelayedOwner
             loopringV3.blockVerifierAddress(),
             loopringV3.exchangeCreationCostLRC(),
             loopringV3.forcedWithdrawalFee(),
-            lrcCosts.minExchangeStake
+            lrcCosts.stakePerThousandBlocks
         );
 
         emit LRCValuesUpdated(
-            lrcCosts.minExchangeStake
+            lrcCosts.stakePerThousandBlocks
         );
     }
 }
diff --git a/packages/loopring_v3/contracts/core/iface/ExchangeData.sol b/packages/loopring_v3/contracts/core/iface/ExchangeData.sol
@@ -120,12 +120,12 @@ library ExchangeData
     function TIMESTAMP_HALF_WINDOW_SIZE_IN_SECONDS() internal pure returns (uint32) { return 7 days; }
     function MAX_NUM_ACCOUNTS() internal pure returns (uint) { return 2 ** 32; }
     function MAX_NUM_TOKENS() internal pure returns (uint) { return 2 ** 16; }
-    function MIN_AGE_PROTOCOL_FEES_UNTIL_UPDATED() internal pure returns (uint32) { return 1 days; }
-    function MIN_TIME_IN_SHUTDOWN() internal pure returns (uint32) { return 28 days; }
+    function MIN_AGE_PROTOCOL_FEES_UNTIL_UPDATED() internal pure returns (uint32) { return 7 days; }
+    function MIN_TIME_IN_SHUTDOWN() internal pure returns (uint32) { return 30 days; }
     // The amount of bytes each rollup transaction uses in the block data for data-availability.
     // This is the maximum amount of bytes of all different transaction types.
     function TX_DATA_AVAILABILITY_SIZE() internal pure returns (uint32) { return 68; }
-    function MAX_AGE_DEPOSIT_UNTIL_WITHDRAWABLE_UPPERBOUND() internal pure returns (uint32) { return 14 days; }
+    function MAX_AGE_DEPOSIT_UNTIL_WITHDRAWABLE_UPPERBOUND() internal pure returns (uint32) { return 15 days; }
     function ACCOUNTID_PROTOCOLFEE() internal pure returns (uint32) { return 0; }
 
     struct AccountLeaf
diff --git a/packages/loopring_v3/contracts/core/iface/IExchangeV3.sol b/packages/loopring_v3/contracts/core/iface/IExchangeV3.sol
@@ -183,6 +183,22 @@ abstract contract IExchangeV3 is IExchange
         view
         returns (bool);
 
+    /// @dev Returns the number of LRC token required as exchange stake.
+    /// @return The number of LRC token required as stake.
+    function getRequiredExchangeStake()
+        public
+        virtual
+        view
+        returns (uint);
+
+    /// @dev Returns whether the Exchange has staked enough to submit blocks.
+    /// @return True if the exchange has staked enough, else false
+    function canSubmitBlocks()
+        external
+        virtual
+        view
+        returns (bool);
+
     // -- Tokens --
     /// @dev Registers an ERC20 token for a token id. Note that different exchanges may have
     ///      different ids for the same ERC20 token.
diff --git a/packages/loopring_v3/contracts/core/iface/ILoopringV3.sol b/packages/loopring_v3/contracts/core/iface/ILoopringV3.sol
@@ -56,7 +56,7 @@ abstract contract ILoopringV3 is ILoopring
     uint    public forcedWithdrawalFee;
     uint    public tokenRegistrationFeeLRCBase;
     uint    public tokenRegistrationFeeLRCDelta;
-    uint    public minExchangeStake;
+    uint    public stakePerThousandBlocks;
     uint8   public minProtocolTakerFeeBips;
     uint8   public maxProtocolTakerFeeBips;
     uint8   public minProtocolMakerFeeBips;
@@ -86,7 +86,7 @@ abstract contract ILoopringV3 is ILoopring
         address _blockVerifierAddress,       // address(0) not allowed
         uint    _exchangeCreationCostLRC,
         uint    _forcedWithdrawalFee,
-        uint    _minExchangeStake
+        uint    _stakePerThousandBlocks
         )
         external
         virtual;
@@ -107,19 +107,6 @@ abstract contract ILoopringV3 is ILoopring
         external
         virtual;
 
-    /// @dev Returns whether the Exchange has staked enough to submit blocks
-    ///      Exchanges with on-chain data-availaiblity need to stake at least
-    ///      minExchangeStake.
-    /// @param exchangeId The id of the exchange
-    /// @return True if the exchange has staked enough, else false
-    function canExchangeSubmitBlocks(
-        uint exchangeId
-        )
-        external
-        virtual
-        view
-        returns (bool);
-
     /// @dev Gets the amount of staked LRC for an exchange.
     /// @param exchangeId The id of the exchange
     /// @return stakedLRC The amount of LRC
diff --git a/packages/loopring_v3/contracts/core/impl/ExchangeV3.sol b/packages/loopring_v3/contracts/core/impl/ExchangeV3.sol
@@ -170,6 +170,24 @@ contract ExchangeV3 is IExchangeV3
         return state.isShutdown();
     }
 
+    function getRequiredExchangeStake()
+        public
+        override
+        view
+        returns (uint)
+    {
+        return state.getRequiredExchangeStake();
+    }
+
+    function canSubmitBlocks()
+        external
+        override
+        view
+        returns (bool)
+    {
+        return state.canSubmitBlocks();
+    }
+
     // -- Tokens --
 
     function registerToken(
diff --git a/packages/loopring_v3/contracts/core/impl/LoopringV3.sol b/packages/loopring_v3/contracts/core/impl/LoopringV3.sol
@@ -91,7 +91,7 @@ contract LoopringV3 is ILoopringV3
         address _blockVerifierAddress,
         uint    _exchangeCreationCostLRC,
         uint    _forcedWithdrawalFee,
-        uint    _minExchangeStake
+        uint    _stakePerThousandBlocks
         )
         external
         override
@@ -103,7 +103,7 @@ contract LoopringV3 is ILoopringV3
             _blockVerifierAddress,
             _exchangeCreationCostLRC,
             _forcedWithdrawalFee,
-            _minExchangeStake
+            _stakePerThousandBlocks
         );
     }
 
@@ -130,18 +130,6 @@ contract LoopringV3 is ILoopringV3
         emit SettingsUpdated(block.timestamp);
     }
 
-    function canExchangeSubmitBlocks(
-        uint exchangeId
-        )
-        external
-        override
-        view
-        returns (bool)
-    {
-        uint amountStaked = getExchangeStake(exchangeId);
-        return amountStaked >= minExchangeStake;
-    }
-
     function getExchangeStake(
         uint exchangeId
         )
@@ -292,11 +280,12 @@ contract LoopringV3 is ILoopringV3
         require(exchange.exchangeAddress != address(0), "INVALID_EXCHANGE_ID");
 
         // Subtract the minimum exchange stake, this amount cannot be used to reduce the protocol fees
-        uint stake = exchange.exchangeStake - minExchangeStake;
-
         // The total stake used here is the exchange stake + the protocol fee stake, but
         // the protocol fee stake has a reduced weight of 50%.
-        uint protocolFeeStake = stake.add(exchange.protocolFeeStake / 2);
+
+        uint protocolFeeStake = exchange.exchangeStake
+            .add(exchange.protocolFeeStake / 2)
+            .sub(IExchangeV3(exchange.exchangeAddress).getRequiredExchangeStake());
 
         takerFeeBips = calculateProtocolFee(
             minProtocolTakerFeeBips, maxProtocolTakerFeeBips, protocolFeeStake, targetProtocolTakerFeeStake
@@ -325,7 +314,7 @@ contract LoopringV3 is ILoopringV3
         address _blockVerifierAddress,
         uint    _exchangeCreationCostLRC,
         uint    _forcedWithdrawalFee,
-        uint    _minExchangeStake
+        uint    _stakePerThousandBlocks
         )
         private
     {
@@ -336,7 +325,7 @@ contract LoopringV3 is ILoopringV3
         blockVerifierAddress = _blockVerifierAddress;
         exchangeCreationCostLRC = _exchangeCreationCostLRC;
         forcedWithdrawalFee = _forcedWithdrawalFee;
-        minExchangeStake = _minExchangeStake;
+        stakePerThousandBlocks = _stakePerThousandBlocks;
 
         emit SettingsUpdated(block.timestamp);
     }
diff --git a/packages/loopring_v3/contracts/core/impl/libexchange/ExchangeBlocks.sol b/packages/loopring_v3/contracts/core/impl/libexchange/ExchangeBlocks.sol
@@ -43,6 +43,50 @@ library ExchangeBlocks
         uint8 previousMakerFeeBips
     );
 
+    function getRequiredExchangeStake(
+        ExchangeData.State   storage S
+        )
+        public
+        view
+        returns (uint)
+    {
+        uint numStakingUnit = S.numBlocks / 1000;
+
+        // waive fee for the first 10K blocks.
+        if (numStakingUnit <= 10) {
+            return 0;
+        }
+
+        // Cap at 1 million blocks
+        if (numStakingUnit > 1000) {
+            numStakingUnit = 1000;
+        }
+
+        return numStakingUnit.mul(S.loopring.stakePerThousandBlocks());
+    }
+
+    function canSubmitBlocks(
+        ExchangeData.State   storage S
+        )
+        public
+        view
+        returns (bool)
+    {
+        uint numStakingUnit = S.numBlocks / 1000;
+
+        // waive fee for the first 10K blocks.
+        if (numStakingUnit <= 10) {
+            return true;
+        }
+
+        // Cap at 1 million blocks
+        if (numStakingUnit > 1000) {
+            numStakingUnit = 1000;
+        }
+
+        return S.loopring.getExchangeStake(S.id) >= getRequiredExchangeStake(S);
+    }
+
     function submitBlocks(
         ExchangeData.State   storage S,
         ExchangeData.Block[] memory  blocks,
@@ -53,11 +97,7 @@ library ExchangeBlocks
         // Exchange cannot be in withdrawal mode
         require(!S.isInWithdrawalMode(), "INVALID_MODE");
 
-        // Check if this exchange has a minimal amount of LRC staked
-        require(
-            S.loopring.canExchangeSubmitBlocks(S.id),
-            "INSUFFICIENT_EXCHANGE_STAKE"
-        );
+        require(canSubmitBlocks(S), "INSUFFICIENT_EXCHANGE_STAKE");
 
         // Commit the blocks
         bytes32[] memory publicDataHashes = new bytes32[](blocks.length);
diff --git a/packages/loopring_v3/test/testExchangeUtil.ts b/packages/loopring_v3/test/testExchangeUtil.ts
diff --git a/packages/loopring_v3/test/testLoopringV3Owner.ts b/packages/loopring_v3/test/testLoopringV3Owner.ts
