feat: Implement _initiateRelayerRefund and begin Optimism-specific SpokePool

contracts/HubPool.sol

@@ -163,6 +163,8 @@ contract HubPool is Testable, Lockable, MultiCaller, Ownable {
     ) public onlyOwner {
         whitelistedRoutes[originToken][destinationChainId] = destinationToken;
 
+        // TODO: Should relay message to L2 for destinationChainId and call setEnableRoute(originToken, destinationChainId, true)
+
         emit WhitelistRoute(originToken, destinationChainId, destinationToken);
     }
 

contracts/Optimism_SpokePool.sol

@@ -0,0 +1,80 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+import "@eth-optimism/contracts/libraries/bridge/CrossDomainEnabled.sol";
+import "@eth-optimism/contracts/libraries/constants/Lib_PredeployAddresses.sol";
+import "./SpokePool.sol";
+import "./SpokePoolInterface.sol";
+
+/**
+ * @notice OVM specific SpokePool.
+ * @dev Uses OVM cross-domain-enabled logic for access control.
+ */
+
+contract Optimism_SpokePool is CrossDomainEnabled, SpokePoolInterface, SpokePool {
+    // Address of the L1 contract that acts as the owner of this SpokePool.
+    address public override crossDomainAdmin;
+
+    event SetXDomainAdmin(address indexed newAdmin);
+
+    constructor(
+        address _crossDomainAdmin,
+        address _wethAddress,
+        uint64 _depositQuoteTimeBuffer,
+        address timerAddress
+    )
+        CrossDomainEnabled(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER)
+        SpokePool(_wethAddress, _depositQuoteTimeBuffer, timerAddress)
+    {
+        _setCrossDomainAdmin(_crossDomainAdmin);
+    }
+
+    /**************************************
+     *          ADMIN FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Changes the L1 contract that can trigger admin functions on this contract.
+     * @dev This should be set to the address of the L1 contract that ultimately relays a cross-domain message, which
+     * is expected to be the Optimism_Adapter.
+     * @dev Only callable by the existing admin via the Optimism cross domain messenger.
+     * @param newCrossDomainAdmin address of the new L1 admin contract.
+     */
+    function setCrossDomainAdmin(address newCrossDomainAdmin)
+        public
+        override
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _setCrossDomainAdmin(newCrossDomainAdmin);
+    }
+
+    function setEnableRoute(
+        address originToken,
+        uint256 destinationChainId,
+        bool enable
+    ) public override onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _setEnableRoute(originToken, destinationChainId, enable);
+    }
+
+    function setDepositQuoteTimeBuffer(uint64 buffer) public override onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _setDepositQuoteTimeBuffer(buffer);
+    }
+
+    function initializeRelayerRefund(bytes32 relayerRepaymentDistributionProof)
+        public
+        override
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _initializeRelayerRefund(relayerRepaymentDistributionProof);
+    }
+
+    /**************************************
+     *         INTERNAL FUNCTIONS         *
+     **************************************/
+
+    function _setCrossDomainAdmin(address newCrossDomainAdmin) internal {
+        require(newCrossDomainAdmin != address(0), "Bad bridge router address");
+        crossDomainAdmin = newCrossDomainAdmin;
+        emit SetXDomainAdmin(crossDomainAdmin);
+    }
+}

contracts/SpokePool.sol

@@ -7,6 +7,7 @@ import "@openzeppelin/contracts/utils/Address.sol";
 import "@uma/core/contracts/common/implementation/Testable.sol";
 import "@uma/core/contracts/common/implementation/Lockable.sol";
 import "@uma/core/contracts/common/implementation/MultiCaller.sol";
+import "./MerkleLib.sol";
 
 interface WETH9Like {
     function withdraw(uint256 wad) external;
@@ -43,6 +44,15 @@ abstract contract SpokePool is Testable, Lockable, MultiCaller {
     // Origin token to destination token routings can be turned on or off.
     mapping(address => mapping(uint256 => bool)) public enabledDepositRoutes;
 
+    struct RelayerRefund {
+        // Merkle root of relayer refunds.
+        bytes32 distributionRoot;
+        // This is a 2D bitmap tracking which leafs in the relayer refund root have been claimed, with max size of
+        // 256x256 leaves per root.
+        mapping(uint256 => uint256) claimsBitmap;
+    }
+    RelayerRefund[] public relayerRefunds;
+
     struct RelayData {
         address depositor;
         address recipient;
@@ -89,6 +99,7 @@ abstract contract SpokePool is Testable, Lockable, MultiCaller {
         address depositor,
         address recipient
     );
+    event InitializedRelayerRefund(uint256 indexed relayerRefundId, bytes32 relayerRepaymentDistributionProof);
 
     constructor(
         address _wethAddress,
@@ -257,17 +268,23 @@ abstract contract SpokePool is Testable, Lockable, MultiCaller {
         );
     }
 
-    function initializeRelayerRefund(bytes32 relayerRepaymentDistributionProof) public virtual {
-        return;
+    // This internal method should be called by an external "initializeRelayerRefund" function that validates the
+    // cross domain sender is the HubPool. This validation step differs for each L2, which is why the implementation
+    // specifics are left to the implementor of this abstract contract.
+    // Once this method is executed and a distribution root is stored in this contract, then `distributeRelayerRefund`
+    // can be called to execute each leaf in the root.
+    function _initializeRelayerRefund(bytes32 relayerRepaymentDistributionProof) internal {
+        uint256 relayerRefundId = relayerRefunds.length;
+        relayerRefunds.push().distributionRoot = relayerRepaymentDistributionProof;
+        emit InitializedRelayerRefund(relayerRefundId, relayerRepaymentDistributionProof);
     }
 
+    // Call this method to execute a leaf within the `distributionRoot` stored on this contract. Caller must include a
+    // valid `inclusionProof` to verify that the leaf is contained within the root. The `relayerRefundId` is the index
+    // of the specific distribution root containing the passed in leaf.
     function distributeRelayerRefund(
         uint256 relayerRefundId,
-        uint256 leafId,
-        address l2TokenAddress,
-        uint256 netSendAmount,
-        address[] memory relayerRefundAddresses,
-        uint256[] memory relayerRefundAmounts,
+        MerkleLib.DestinationDistribution memory distributionLeaf,
         bytes32[] memory inclusionProof
     ) public {}
 

contracts/SpokePoolInterface.sol

@@ -0,0 +1,18 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+interface SpokePoolInterface {
+    function crossDomainAdmin() external returns (address);
+
+    function setCrossDomainAdmin(address newCrossDomainAdmin) external;
+
+    function setEnableRoute(
+        address originToken,
+        uint256 destinationChainId,
+        bool enable
+    ) external;
+
+    function setDepositQuoteTimeBuffer(uint64 buffer) external;
+
+    function initializeRelayerRefund(bytes32 relayerRepaymentDistributionProof) external;
+}

contracts/test/MockSpokePool.sol

@@ -2,12 +2,15 @@
 pragma solidity ^0.8.0;
 
 import "../SpokePool.sol";
+import "../SpokePoolInterface.sol";
 
 /**
  * @title MockSpokePool
  * @notice Implements admin internal methods to test internal logic.
  */
-contract MockSpokePool is SpokePool {
+contract MockSpokePool is SpokePoolInterface, SpokePool {
+    address public override crossDomainAdmin;
+
     constructor(
         address _wethAddress,
         uint64 _depositQuoteTimeBuffer,
@@ -18,15 +21,19 @@ contract MockSpokePool is SpokePool {
         address originToken,
         uint256 destinationChainId,
         bool enable
-    ) public {
+    ) public override {
         _setEnableRoute(originToken, destinationChainId, enable);
     }
 
-    function setDepositQuoteTimeBuffer(uint64 buffer) public {
+    function setDepositQuoteTimeBuffer(uint64 buffer) public override {
         _setDepositQuoteTimeBuffer(buffer);
     }
 
     function initializeRelayerRefund(bytes32 relayerRepaymentDistributionProof) public override {
-        return;
+        _initializeRelayerRefund(relayerRepaymentDistributionProof);
+    }
+
+    function setCrossDomainAdmin(address newCrossDomainAdmin) public override {
+        crossDomainAdmin = newCrossDomainAdmin;
     }
 }

package.json

@@ -15,6 +15,7 @@
     "test": "yarn hardhat test"
   },
   "dependencies": {
+    "@eth-optimism/contracts": "^0.5.11",
     "@openzeppelin/contracts": "^4.4.2",
     "@uma/common": "^2.17.0",
     "@uma/contracts-node": "^0.2.0",

test/Optimism_SpokePool.ts

@@ -0,0 +1 @@
+// TODO: Test OVM specific functionality and implementation of SpokePool internal methods.

test/SpokePool.RefundInitialization.ts

@@ -0,0 +1,22 @@
+import { expect } from "chai";
+import { Contract } from "ethers";
+import { ethers } from "hardhat";
+import { SignerWithAddress } from "./utils";
+import { spokePoolFixture } from "./SpokePool.Fixture";
+import { mockDestinationDistributionRoot } from "./constants";
+
+let spokePool: Contract;
+let caller: SignerWithAddress;
+
+describe("SpokePool Initialize Relayer Refund Logic", async function () {
+  beforeEach(async function () {
+    [caller] = await ethers.getSigners();
+    ({ spokePool } = await spokePoolFixture());
+  });
+  it("Initializing root stores root and emits event", async function () {
+    await expect(spokePool.connect(caller).initializeRelayerRefund(mockDestinationDistributionRoot))
+      .to.emit(spokePool, "InitializedRelayerRefund")
+      .withArgs(0, mockDestinationDistributionRoot);
+    expect(await spokePool.relayerRefunds(0)).to.equal(mockDestinationDistributionRoot);
+  });
+});