@keep-network/tbtc-v2 1.3.0-dev.4 → 1.3.0-dev.5

package/build/contracts/vault/TBTCVault.sol/TBTCVault.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/d1d06b615610162a2e80a9362741427b.json"
+  "buildInfo": "../../../build-info/4dae352543b4d68232673fef698e9426.json"
 }

package/contracts/relay/LightRelayMaintainerProxy.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@keep-network/random-beacon/contracts/Reimbursable.sol";
+import "@keep-network/random-beacon/contracts/ReimbursementPool.sol";
+
+import "./LightRelay.sol";
+
+/// @title LightRelayMaintainerProxy
+/// @notice The proxy contract that allows the relay maintainers to be refunded
+///         for the spent gas from the `ReimbursementPool`. When proving the
+///         next Bitcoin difficulty epoch, the maintainer calls the
+///         `LightRelayMaintainerProxy` which in turn calls the actual `LightRelay`
+///         contract.
+contract LightRelayMaintainerProxy is Ownable, Reimbursable {
+    ILightRelay public lightRelay;
+
+    /// @notice Stores the addresses that can maintain the relay. Those
+    ///         addresses are attested by the DAO.
+    /// @dev The goal is to prevent a griefing attack by frontrunning relay
+    ///      maintainer which is responsible for retargetting the relay in the
+    ///      given round. The maintainer's transaction would revert with no gas
+    ///      refund. Having the ability to restrict maintainer addresses is also
+    ///      important in case the underlying relay contract has authorization
+    ///      requirements for callers.
+    mapping(address => bool) public isAuthorized;
+
+    /// @notice Gas that is meant to balance the retarget overall cost. Can be
+    //          updated by the governance based on the current market conditions.
+    uint256 public retargetGasOffset;
+
+    event LightRelayUpdated(address newRelay);
+
+    event MaintainerAuthorized(address indexed maintainer);
+
+    event MaintainerDeauthorized(address indexed maintainer);
+
+    event RetargetGasOffsetUpdated(uint256 retargetGasOffset);
+
+    modifier onlyRelayMaintainer() {
+        require(isAuthorized[msg.sender], "Caller is not authorized");
+        _;
+    }
+
+    modifier onlyReimbursableAdmin() override {
+        require(owner() == msg.sender, "Caller is not the owner");
+        _;
+    }
+
+    constructor(ILightRelay _lightRelay, ReimbursementPool _reimbursementPool) {
+        require(
+            address(_lightRelay) != address(0),
+            "Light relay must not be zero address"
+        );
+        require(
+            address(_reimbursementPool) != address(0),
+            "Reimbursement pool must not be zero address"
+        );
+
+        lightRelay = _lightRelay;
+        reimbursementPool = _reimbursementPool;
+
+        retargetGasOffset = 54000;
+    }
+
+    /// @notice Allows the governance to upgrade the `LightRelay` address.
+    /// @dev The function does not implement any governance delay and does not
+    ///      check the status of the `LightRelay`. The Governance implementation
+    ///      needs to ensure all requirements for the upgrade are satisfied
+    ///      before executing this function.
+    function updateLightRelay(ILightRelay _lightRelay) external onlyOwner {
+        require(
+            address(_lightRelay) != address(0),
+            "New light relay must not be zero address"
+        );
+
+        lightRelay = _lightRelay;
+        emit LightRelayUpdated(address(_lightRelay));
+    }
+
+    /// @notice Authorizes the given address as a maintainer. Can only be called
+    ///         by the owner and the address of the maintainer must not be
+    ///         already authorized.
+    /// @dev The function does not implement any governance delay.
+    /// @param maintainer The address of the maintainer to be authorized.
+    function authorize(address maintainer) external onlyOwner {
+        require(!isAuthorized[maintainer], "Maintainer is already authorized");
+
+        isAuthorized[maintainer] = true;
+        emit MaintainerAuthorized(maintainer);
+    }
+
+    /// @notice Deauthorizes the given address as a maintainer. Can only be
+    ///         called by the owner and the address of the maintainer must be
+    ///         authorized.
+    /// @dev The function does not implement any governance delay.
+    /// @param maintainer The address of the maintainer to be deauthorized.
+    function deauthorize(address maintainer) external onlyOwner {
+        require(isAuthorized[maintainer], "Maintainer is not authorized");
+
+        isAuthorized[maintainer] = false;
+        emit MaintainerDeauthorized(maintainer);
+    }
+
+    /// @notice Updates the values of retarget gas offset.
+    /// @dev Can be called only by the contract owner. The caller is responsible
+    ///      for validating the parameter. The function does not implement any
+    ///      governance delay.
+    /// @param newRetargetGasOffset New retarget gas offset.
+    function updateRetargetGasOffset(uint256 newRetargetGasOffset)
+        external
+        onlyOwner
+    {
+        retargetGasOffset = newRetargetGasOffset;
+        emit RetargetGasOffsetUpdated(retargetGasOffset);
+    }
+
+    /// @notice Wraps `LightRelay.retarget` call and reimburses the caller's
+    ///         transaction cost. Can only be called by an authorized relay
+    ///         maintainer.
+    /// @dev See `LightRelay.retarget` function documentation.
+    function retarget(bytes memory headers) external onlyRelayMaintainer {
+        uint256 gasStart = gasleft();
+
+        lightRelay.retarget(headers);
+
+        reimbursementPool.refund(
+            (gasStart - gasleft()) + retargetGasOffset,
+            msg.sender
+        );
+    }
+}

package/deploy/36_deploy_light_relay_maintainer_proxy.ts

@@ -0,0 +1,35 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts, helpers } = hre
+  const { deploy } = deployments
+  const { deployer } = await getNamedAccounts()
+
+  const ReimbursementPool = await deployments.get("ReimbursementPool")
+  const LightRelay = await deployments.get("LightRelay")
+
+  const lightRelayMaintainerProxy = await deploy("LightRelayMaintainerProxy", {
+    contract: "LightRelayMaintainerProxy",
+    from: deployer,
+    args: [LightRelay.address, ReimbursementPool.address],
+    log: true,
+    waitConfirmations: 1,
+  })
+
+  if (hre.network.tags.etherscan) {
+    await helpers.etherscan.verify(lightRelayMaintainerProxy)
+  }
+
+  if (hre.network.tags.tenderly) {
+    await hre.tenderly.verify({
+      name: "LightRelayMaintainerProxy",
+      address: lightRelayMaintainerProxy.address,
+    })
+  }
+}
+
+export default func
+
+func.tags = ["LightRelayMaintainerProxy"]
+func.dependencies = ["LightRelay", "ReimbursementPool"]

package/deploy/37_transfer_light_relay_maintainer_proxy_ownership.ts

@@ -0,0 +1,19 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts, helpers } = hre
+  const { deployer, governance } = await getNamedAccounts()
+
+  await helpers.ownable.transferOwnership(
+    "LightRelayMaintainerProxy",
+    governance,
+    deployer
+  )
+}
+
+export default func
+
+func.tags = ["TransferLightRelayMaintainerProxyOwnership"]
+func.dependencies = ["LightRelayMaintainerProxy"]
+func.runAtTheEnd = true

package/deploy/38_authorize_light_relay_maintainer_proxy_in_reimbursement_pool.ts

@@ -0,0 +1,31 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts, deployments } = hre
+  const { execute } = deployments
+  const { governance } = await getNamedAccounts()
+
+  const LightRelayMaintainerProxy = await deployments.get(
+    "LightRelayMaintainerProxy"
+  )
+
+  await execute(
+    "ReimbursementPool",
+    { from: governance, log: true, waitConfirmations: 1 },
+    "authorize",
+    LightRelayMaintainerProxy.address
+  )
+}
+
+export default func
+
+func.tags = ["AuthorizeLightRelayMaintainerProxyInReimbursementPool"]
+func.dependencies = ["ReimbursementPool", "LightRelayMaintainerProxy"]
+
+// On mainnet, the ReimbursementPool ownership is passed to the Threshold
+// Council / DAO and that address is not controlled by the dev team.
+// Hence, this step can be executed only for non-mainnet networks such as
+// Hardhat (unit tests) and Goerli (testnet).
+func.skip = async (hre: HardhatRuntimeEnvironment): Promise<boolean> =>
+  hre.network.name === "mainnet"

package/deploy/39_authorize_light_relay_maintainer_proxy_in_light_relay.ts

@@ -0,0 +1,24 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts, deployments } = hre
+  const { execute } = deployments
+  const { deployer } = await getNamedAccounts()
+
+  const LightRelayMaintainerProxy = await deployments.get(
+    "LightRelayMaintainerProxy"
+  )
+
+  await execute(
+    "LightRelay",
+    { from: deployer, log: true, waitConfirmations: 1 },
+    "authorize",
+    LightRelayMaintainerProxy.address
+  )
+}
+
+export default func
+
+func.tags = ["AuthorizeLightRelayMaintainerProxyInLightRelay"]
+func.dependencies = ["LightRelay", "LightRelayMaintainerProxy"]

package/deploy/94_transfer_relay_ownership.ts

@@ -0,0 +1,19 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts, helpers } = hre
+  const { deployer, governance } = await getNamedAccounts()
+
+  await helpers.ownable.transferOwnership("LightRelay", governance, deployer)
+}
+
+export default func
+
+func.tags = ["TransferLightRelayOwnership"]
+func.dependencies = ["LightRelay"]
+func.runAtTheEnd = true
+
+// Only execute for mainnet.
+func.skip = async (hre: HardhatRuntimeEnvironment): Promise<boolean> =>
+  hre.network.name !== "mainnet"

package/export/artifacts/@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol/BTCUtils.json

@@ -109,32 +109,32 @@
         {
           "ast": {
             "nodeType": "YulBlock",
-            "src": "0:201:124",
+            "src": "0:201:125",
             "statements": [
               {
                 "nodeType": "YulBlock",
-                "src": "6:3:124",
+                "src": "6:3:125",
                 "statements": []
               },
               {
                 "body": {
                   "nodeType": "YulBlock",
-                  "src": "123:76:124",
+                  "src": "123:76:125",
                   "statements": [
                     {
                       "nodeType": "YulAssignment",
-                      "src": "133:26:124",
+                      "src": "133:26:125",
                       "value": {
                         "arguments": [
                           {
                             "name": "headStart",
                             "nodeType": "YulIdentifier",
-                            "src": "145:9:124"
+                            "src": "145:9:125"
                           },
                           {
                             "kind": "number",
                             "nodeType": "YulLiteral",
-                            "src": "156:2:124",
+                            "src": "156:2:125",
                             "type": "",
                             "value": "32"
                           }
@@ -142,16 +142,16 @@
                         "functionName": {
                           "name": "add",
                           "nodeType": "YulIdentifier",
-                          "src": "141:3:124"
+                          "src": "141:3:125"
                         },
                         "nodeType": "YulFunctionCall",
-                        "src": "141:18:124"
+                        "src": "141:18:125"
                       },
                       "variableNames": [
                         {
                           "name": "tail",
                           "nodeType": "YulIdentifier",
-                          "src": "133:4:124"
+                          "src": "133:4:125"
                         }
                       ]
                     },
@@ -161,24 +161,24 @@
                           {
                             "name": "headStart",
                             "nodeType": "YulIdentifier",
-                            "src": "175:9:124"
+                            "src": "175:9:125"
                           },
                           {
                             "name": "value0",
                             "nodeType": "YulIdentifier",
-                            "src": "186:6:124"
+                            "src": "186:6:125"
                           }
                         ],
                         "functionName": {
                           "name": "mstore",
                           "nodeType": "YulIdentifier",
-                          "src": "168:6:124"
+                          "src": "168:6:125"
                         },
                         "nodeType": "YulFunctionCall",
-                        "src": "168:25:124"
+                        "src": "168:25:125"
                       },
                       "nodeType": "YulExpressionStatement",
-                      "src": "168:25:124"
+                      "src": "168:25:125"
                     }
                   ]
                 },
@@ -188,13 +188,13 @@
                   {
                     "name": "headStart",
                     "nodeType": "YulTypedName",
-                    "src": "92:9:124",
+                    "src": "92:9:125",
                     "type": ""
                   },
                   {
                     "name": "value0",
                     "nodeType": "YulTypedName",
-                    "src": "103:6:124",
+                    "src": "103:6:125",
                     "type": ""
                   }
                 ],
@@ -202,16 +202,16 @@
                   {
                     "name": "tail",
                     "nodeType": "YulTypedName",
-                    "src": "114:4:124",
+                    "src": "114:4:125",
                     "type": ""
                   }
                 ],
-                "src": "14:185:124"
+                "src": "14:185:125"
               }
             ]
           },
           "contents": "{\n    { }\n    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_library_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n}",
-          "id": 124,
+          "id": 125,
           "language": "Yul",
           "name": "#utility.yul"
         }
@@ -219,7 +219,7 @@
       "immutableReferences": {},
       "linkReferences": {},
       "opcodes": "PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH1 0x51 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x56E04EC EQ PUSH1 0x56 JUMPI DUP1 PUSH4 0x8CC71569 EQ PUSH1 0x71 JUMPI DUP1 PUSH4 0x8DB69E60 EQ PUSH1 0x79 JUMPI DUP1 PUSH4 0xD4258CA7 EQ PUSH1 0x81 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH1 0x5F PUSH3 0x127500 DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD SWAP1 DUP2 MSTORE PUSH1 0x20 ADD PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST PUSH1 0x5F PUSH2 0x7E0 DUP2 JUMP JUMPDEST PUSH1 0x5F PUSH1 0x0 NOT DUP2 JUMP JUMPDEST PUSH1 0x5F PUSH28 0xFFFF0000000000000000000000000000000000000000000000000000 DUP2 JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0x21 0xD8 0x5F GT 0xF6 0x4E 0xD4 0x4F 0xFB 0xA5 SWAP12 0xFC PUSH12 0x4A327F00D51E8E91CA784A04 DUP14 CALLDATACOPY 0x29 0xDB ADD 0xB3 PUSH32 0x64736F6C63430008110033000000000000000000000000000000000000000000 ",
-      "sourceMap": "175:38691:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;443:62;;485:20;443:62;;;;;168:25:124;;;156:2;141:18;443:62:0;;;;;;;534:53;;583:4;534:53;;616:104;;-1:-1:-1;;616:104:0;;339:97;;378:58;339:97;"
+      "sourceMap": "175:38691:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;443:62;;485:20;443:62;;;;;168:25:125;;;156:2;141:18;443:62:0;;;;;;;534:53;;583:4;534:53;;616:104;;-1:-1:-1;;616:104:0;;339:97;;378:58;339:97;"
     },
     "gasEstimates": {
       "creation": {