Split VaultRegistry from OneBtc For the Contract Size Issue

contract/bridge/contracts/Collateral.sol

@@ -4,7 +4,7 @@ pragma solidity 0.6.12;
 
 import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
 
-abstract contract ICollateral {
+contract ICollateral {
     using SafeMathUpgradeable for uint256;
 
     event LockCollateral(address sender, uint256 amount);
@@ -18,8 +18,8 @@ abstract contract ICollateral {
         return address(this).balance;
     }
 
-    function lockCollateral(address sender, uint256 amount) internal {
-        require(msg.value >= amount, "Invalid collateral");
+    function _lockCollateral(address sender, uint256 amount) internal virtual {
+        require(amount > 0, "Invalid collateral");
         CollateralBalances[sender] = CollateralBalances[sender].add(amount);
         emit LockCollateral(sender, amount);
     }
@@ -39,21 +39,21 @@ abstract contract ICollateral {
         require(sent, "Transfer failed.");
     }
 
-    function releaseCollateral(address sender, uint256 amount) internal {
+    function _releaseCollateral(address sender, uint256 amount) internal virtual {
         release(sender, sender, amount);
         emit ReleaseCollateral(sender, amount);
     }
 
-    function slashCollateral(
+    function _slashCollateral(
         address from,
         address to,
         uint256 amount
-    ) internal {
+    ) internal virtual {
         release(from, to, amount);
         emit SlashCollateral(from, to, amount);
     }
 
-    function getFreeCollateral(address vaultId)
+    function _getFreeCollateral(address vaultId)
         internal
         view
         returns (uint256)
@@ -65,15 +65,15 @@ abstract contract ICollateral {
         return CollateralBalances[vaultId];
     }
 
-    function useCollateralInc(address vaultId, uint256 amount) internal {
+    function _useCollateralInc(address vaultId, uint256 amount) internal virtual {
         CollateralUsed[vaultId] = CollateralUsed[vaultId].add(amount);
         require(
             CollateralBalances[vaultId] >= CollateralUsed[vaultId],
             "Insufficient collateral"
         );
     }
 
-    function useCollateralDec(address vaultId, uint256 amount) internal {
+    function _useCollateralDec(address vaultId, uint256 amount) internal virtual {
         require(CollateralUsed[vaultId] >= amount, "Insufficient collateral");
         CollateralUsed[vaultId] = CollateralUsed[vaultId].sub(amount);
     }

contract/bridge/contracts/ExchangeRateOracleV2.sol

@@ -1,9 +1,7 @@
 /**
 SPDX-License-Identifier: MIT
-
 Exchange Rate Oracle Module
 https://onebtc-dev.web.app/spec/oracle.html
-
 The Exchange Rate Oracle receives a continuous data feed on the exchange rate between BTC and ONE.
 */
 

contract/bridge/contracts/IVaultRegistry.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.12;
+
+interface IVaultRegistry {
+    // // set functions for Vault
+    // function setBtcPublicKeyX(address, uint256) external;
+    // function setBtcPublicKeyY(address, uint256) external;
+    // function setCollateral(address, uint256) external;
+    // function setIssued(address, uint256) external;
+    // function setToBeIssued(address, uint256) external;
+    // function setToBeRedeemed(address, uint256) external;
+    // function setReplaceCollateral(address, uint256) external;
+    // function setToBeReplaced(address, uint256) external;
+    // function setLiquidatedCollateral(address, uint256) external;
+
+    // // set function for vaultDepositAddress
+    // function setVaultDepositAddress(address, address, bool) external;
+
+    // interfaces used by VaultRegistry contract
+    function vaults(address) external returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256);
+    function vaultDepositAddress(address, address) external returns(bool);
+    function registerVault(uint256, uint256) external;
+    function registerDepositAddress(address, uint256) external returns(address);
+    function insertVaultDepositAddress(address, uint256, uint256, uint256) external returns(address);
+    function updatePublicKey(uint256, uint256) external;
+    function decreaseToBeIssuedTokens(address, uint256) external;
+    function tryIncreaseToBeIssuedTokens(address, uint256) external returns(bool);
+    function tryIncreaseToBeRedeemedTokens(address, uint256) external returns(bool);
+    function redeemTokens(address, uint256) external;
+    function issuableTokens(address) external view returns(uint256);
+    function issueTokens(address, uint256) external;
+    function calculateCollateral(uint256, uint256, uint256) external view returns(uint256);
+    function requestableToBeReplacedTokens(address) external returns(uint256);
+    function tryIncreaseToBeReplacedTokens(address, uint256, uint256) external returns(uint256, uint256);
+    function decreaseToBeReplacedTokens(address, uint256) external returns(uint256, uint256);
+    function replaceTokens(address, address, uint256, uint256) external;
+    function tryDepositCollateral(address, uint256) external;
+    function liquidateVaul(address, address) external;
+    function lockCollateral(address, uint256) external;
+    function releaseCollateral(address, uint256) external;
+    function slashCollateral(address, address, uint256) external;
+    function useCollateralInc(address, uint256) external;
+    function useCollateralDec(address, uint256) external;
+
+    // interface used by StakedRelayer contract
+    function liquidateTheftVault(address vaultId, address reporterId) external;
+}

contract/bridge/contracts/Issue.sol

@@ -7,10 +7,9 @@ import "@interlay/bitcoin-spv-sol/contracts/BTCUtils.sol";
 import "@interlay/bitcoin-spv-sol/contracts/BytesLib.sol";
 import "./Request.sol";
 import "./TxValidate.sol";
-import "./Collateral.sol";
-import "./VaultRegistry.sol";
+import "./IVaultRegistry.sol";
 
-abstract contract Issue is VaultRegistry, Request {
+abstract contract Issue is Request {
     using BTCUtils for bytes;
     using BytesLib for bytes;
     using SafeMathUpgradeable for uint256;
@@ -71,6 +70,7 @@ abstract contract Issue is VaultRegistry, Request {
 
     function getIssueGriefingCollateral(uint256 amountBtc)
         private
+        pure
         returns (uint256)
     {
         return amountBtc;
@@ -93,6 +93,7 @@ abstract contract Issue is VaultRegistry, Request {
     }
 
     function _requestIssue(
+        IVaultRegistry vaultRegistry,
         address payable requester,
         uint256 amountRequested,
         address vaultId,
@@ -103,11 +104,11 @@ abstract contract Issue is VaultRegistry, Request {
             "Insufficient collateral"
         );
         require(
-            VaultRegistry.tryIncreaseToBeIssuedTokens(vaultId, amountRequested),
+            vaultRegistry.tryIncreaseToBeIssuedTokens(vaultId, amountRequested),
             "Amount requested exceeds vault limit"
         );
         uint256 issueId = getIssueId(requester);
-        address btcAddress = VaultRegistry.registerDepositAddress(
+        address btcAddress = vaultRegistry.registerDepositAddress(
             vaultId,
             issueId
         );
@@ -127,7 +128,7 @@ abstract contract Issue is VaultRegistry, Request {
             request.btcHeight = 0;
             request.status = RequestStatus.Pending;
         }
-        ICollateral.lockCollateral(
+        vaultRegistry.lockCollateral(
             request.requester,
             request.griefingCollateral
         );
@@ -142,6 +143,7 @@ abstract contract Issue is VaultRegistry, Request {
     }
 
     function _executeIssue(
+        IVaultRegistry vaultRegistry,
         address requester,
         uint256 issueId,
         bytes memory _vout,
@@ -164,20 +166,20 @@ abstract contract Issue is VaultRegistry, Request {
             // only the requester of the issue can execute payments with different amounts
             require(msg.sender == request.requester, "Invalid executor");
             uint256 deficit = expectedTotalAmount - amountTransferred;
-            VaultRegistry.decreaseToBeIssuedTokens(request.vault, deficit);
-            uint256 releasedCollateral = VaultRegistry.calculateCollateral(
+            vaultRegistry.decreaseToBeIssuedTokens(request.vault, deficit);
+            uint256 releasedCollateral = vaultRegistry.calculateCollateral(
                 request.griefingCollateral,
                 amountTransferred,
                 expectedTotalAmount
             );
-            ICollateral.releaseCollateral(
+            vaultRegistry.releaseCollateral(
                 request.requester,
                 releasedCollateral
             );
             uint256 slashedCollateral = request.griefingCollateral.sub(
                 releasedCollateral
             );
-            ICollateral.slashCollateral(
+            vaultRegistry.slashCollateral(
                 request.requester,
                 request.vault,
                 slashedCollateral
@@ -189,14 +191,14 @@ abstract contract Issue is VaultRegistry, Request {
                 slashedCollateral
             );
         } else {
-            ICollateral.releaseCollateral(
+            vaultRegistry.releaseCollateral(
                 request.requester,
                 request.griefingCollateral
             );
             if (amountTransferred > expectedTotalAmount) {
                 uint256 surplusBtc = amountTransferred.sub(expectedTotalAmount);
                 if (
-                    VaultRegistry.tryIncreaseToBeIssuedTokens(
+                    vaultRegistry.tryIncreaseToBeIssuedTokens(
                         request.vault,
                         surplusBtc
                     )
@@ -210,7 +212,7 @@ abstract contract Issue is VaultRegistry, Request {
             }
         }
         uint256 total = request.amount.add(request.fee);
-        VaultRegistry.issueTokens(request.vault, total);
+        vaultRegistry.issueTokens(request.vault, total);
         issueOneBTC(request.vault, request.fee);
         issueOneBTC(request.requester, request.amount);
         request.status = RequestStatus.Completed;
@@ -226,7 +228,7 @@ abstract contract Issue is VaultRegistry, Request {
         );
     }
 
-    function _cancelIssue(address requester, uint256 issueId) internal {
+    function _cancelIssue(IVaultRegistry vaultRegistry, address requester, uint256 issueId) internal {
         IssueRequest storage request = issueRequests[requester][issueId];
         require(
             request.status == RequestStatus.Pending,
@@ -237,12 +239,12 @@ abstract contract Issue is VaultRegistry, Request {
             "Time not expired"
         );
         request.status = RequestStatus.Cancelled;
-        ICollateral.slashCollateral(
+        vaultRegistry.slashCollateral(
             request.requester,
             request.vault,
             request.griefingCollateral
         );
-        VaultRegistry.decreaseToBeIssuedTokens(
+        vaultRegistry.decreaseToBeIssuedTokens(
             request.vault,
             request.amount + request.fee
         );