Add wormhole bridge

contracts/common/LibWormholeGUID.sol

@@ -0,0 +1,29 @@
+pragma solidity >=0.7.6;
+pragma abicoder v2;
+
+struct WormholeGUID {
+  bytes32 sourceDomain;
+  bytes32 targetDomain;
+  address receiver;
+  address operator;
+  uint128 amount;
+  uint64 nonce;
+  uint64 timestamp;
+}
+
+library WormholeLib {
+  function getHash(WormholeGUID memory wormhole) public pure returns (bytes32) {
+    return
+      keccak256(
+        abi.encode(
+          wormhole.sourceDomain,
+          wormhole.targetDomain,
+          wormhole.receiver,
+          wormhole.operator,
+          wormhole.amount,
+          wormhole.nonce,
+          wormhole.timestamp
+        )
+      );
+  }
+}

contracts/l1/L1DAIWormholeBridge.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2021 Dai Foundation
+// @unsupported: ovm
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pragma solidity >=0.7.6;
+pragma abicoder v2;
+
+import {iOVM_L1ERC20Bridge} from "@eth-optimism/contracts/iOVM/bridge/tokens/iOVM_L1ERC20Bridge.sol";
+import {iOVM_L2ERC20Bridge} from "@eth-optimism/contracts/iOVM/bridge/tokens/iOVM_L2ERC20Bridge.sol";
+import {OVM_CrossDomainEnabled} from "@eth-optimism/contracts/libraries/bridge/OVM_CrossDomainEnabled.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {WormholeGUID, WormholeLib} from "../common/LibWormholeGUID.sol";
+
+interface TokenLike {
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  ) external returns (bool success);
+}
+
+interface WormholeRouter {
+  function registerWormhole(WormholeGUID memory wormholeGUID) external; // @todo what's the memory location?
+
+  function settle(bytes32 targetDomain, uint256 daiToFlush) external;
+}
+
+contract L1DAIWormholeBridge is OVM_CrossDomainEnabled {
+  using WormholeLib for WormholeGUID;
+  // --- Auth ---
+  mapping(address => uint256) public wards;
+
+  function rely(address usr) external auth {
+    wards[usr] = 1;
+    emit Rely(usr);
+  }
+
+  function deny(address usr) external auth {
+    wards[usr] = 0;
+    emit Deny(usr);
+  }
+
+  modifier auth() {
+    require(wards[msg.sender] == 1, "L1DAITokenBridge/not-authorized");
+    _;
+  }
+
+  event Rely(address indexed usr);
+  event Deny(address indexed usr);
+
+  address public immutable l1Token;
+  address public immutable l2DAITokenBridge;
+  address public immutable l2Token;
+  address public immutable escrow;
+  WormholeRouter public immutable wormholeRouter;
+
+  constructor(
+    address _l1Token,
+    address _l2DAITokenBridge,
+    address _l2Token,
+    address _l1messenger,
+    address _escrow,
+    address _wormholeRouter
+  ) OVM_CrossDomainEnabled(_l1messenger) {
+    wards[msg.sender] = 1;
+    emit Rely(msg.sender);
+
+    l1Token = _l1Token;
+    l2DAITokenBridge = _l2DAITokenBridge;
+    l2Token = _l2Token;
+    escrow = _escrow;
+    wormholeRouter = WormholeRouter(_wormholeRouter);
+  }
+
+  function finalizeFlush(bytes32 targetDomain, uint256 daiToFlush)
+    external
+    onlyFromCrossDomainAccount(l2DAITokenBridge)
+  {
+    wormholeRouter.settle(targetDomain, daiToFlush);
+  }
+
+  function finalizeRegisterInboundWormhole(WormholeGUID calldata wormhole)
+    external
+    onlyFromCrossDomainAccount(l2DAITokenBridge)
+  {
+    wormholeRouter.registerWormhole(wormhole);
+  }
+}

contracts/l2/L2DAIWormholeBridge.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2021 Dai Foundation
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pragma solidity >=0.7.6;
+pragma abicoder v2;
+
+import {iOVM_L1ERC20Bridge} from "@eth-optimism/contracts/iOVM/bridge/tokens/iOVM_L1ERC20Bridge.sol";
+import {iOVM_L2ERC20Bridge} from "@eth-optimism/contracts/iOVM/bridge/tokens/iOVM_L2ERC20Bridge.sol";
+import {OVM_CrossDomainEnabled} from "@eth-optimism/contracts/libraries/bridge/OVM_CrossDomainEnabled.sol";
+import {WormholeGUID, WormholeLib} from "../common/LibWormholeGUID.sol";
+import {L1DAIWormholeBridge} from "../l1/L1DAIWormholeBridge.sol";
+
+interface Mintable {
+  function mint(address usr, uint256 wad) external;
+
+  function burn(address usr, uint256 wad) external;
+}
+
+contract L2DAIWormholeBridge is OVM_CrossDomainEnabled {
+  using WormholeLib for WormholeGUID;
+
+  // --- Auth ---
+  mapping(address => uint256) public wards;
+
+  function rely(address usr) external auth {
+    wards[usr] = 1;
+    emit Rely(usr);
+  }
+
+  function deny(address usr) external auth {
+    wards[usr] = 0;
+    emit Deny(usr);
+  }
+
+  modifier auth() {
+    require(wards[msg.sender] == 1, "L2DAITokenBridge/not-authorized");
+    _;
+  }
+
+  event Rely(address indexed usr);
+  event Deny(address indexed usr);
+
+  address public immutable l1Token;
+  address public immutable l2Token;
+  address public immutable l1DAITokenBridge;
+  bytes32 public immutable sourceDomain;
+  uint64 public nonce = 0;
+  mapping(bytes32 => uint256) public batchedDaiToFlush;
+
+  event WormholeInitialized(WormholeGUID wormhole);
+  event Flushed(bytes32 targetDomain, uint256 dai);
+
+  constructor(
+    address _l2CrossDomainMessenger,
+    address _l2Token,
+    address _l1Token,
+    address _l1DAITokenBridge,
+    bytes32 _sourceDomain
+  ) public OVM_CrossDomainEnabled(_l2CrossDomainMessenger) {
+    wards[msg.sender] = 1;
+    emit Rely(msg.sender);
+
+    l2Token = _l2Token;
+    l1Token = _l1Token;
+    l1DAITokenBridge = _l1DAITokenBridge;
+    sourceDomain = _sourceDomain;
+  }
+
+  function initiateWormhole(
+    bytes32 targetDomain,
+    address receiver,
+    uint128 amount,
+    address operator
+  ) external {
+    WormholeGUID memory wormhole = WormholeGUID({
+      sourceDomain: sourceDomain,
+      targetDomain: targetDomain,
+      receiver: receiver,
+      operator: operator,
+      amount: amount,
+      nonce: nonce++,
+      timestamp: uint64(block.timestamp)
+    });
+
+    batchedDaiToFlush[targetDomain] += amount;
+    Mintable(l2Token).burn(msg.sender, amount);
+
+    uint32 l1Gas = 20000; // @todo: does it matter? messages need to be relied manually anyway
+    bytes memory message = abi.encodeWithSelector(
+      L1DAIWormholeBridge.finalizeRegisterInboundWormhole.selector,
+      wormhole
+    );
+    sendCrossDomainMessage(l1DAITokenBridge, l1Gas, message);
+
+    emit WormholeInitialized(wormhole);
+  }
+
+  function flush(bytes32 targetDomain) external {
+    uint256 daiToFlush = batchedDaiToFlush[targetDomain];
+
+    uint32 l1Gas = 20000; // @todo: does it matter? messages need to be relied manually anyway
+    bytes memory message = abi.encodeWithSelector(
+      L1DAIWormholeBridge.finalizeFlush.selector,
+      targetDomain,
+      daiToFlush
+    );
+    sendCrossDomainMessage(l1DAITokenBridge, l1Gas, message);
+
+    batchedDaiToFlush[targetDomain] = 0;
+    emit Flushed(targetDomain, daiToFlush);
+  }
+}

test/l2/L2DAIWormholeBridge.ts

@@ -0,0 +1,83 @@
+import { simpleDeploy } from '@makerdao/hardhat-utils'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-with-address'
+import { expect } from 'chai'
+import { ethers } from 'hardhat'
+
+import { Dai__factory, L2DAIWormholeBridge__factory } from '../../typechain-types'
+import { deployMock, deployOptimismContractMock } from '../helpers'
+
+const INITIAL_TOTAL_L2_SUPPLY = 3000
+const WORMHOLE_AMOUNT = 100
+const DEFAULT_XDOMAIN_GAS = 20000
+const SOURCE_DOMAIN_NAME = ethers.utils.formatBytes32String('optimism-a')
+const TARGET_DOMAIN_NAME = ethers.utils.formatBytes32String('arbitrum-a')
+
+describe('L2DAIWormholeBridge', () => {
+  describe('initiateWormhole()', () => {
+    it('burns DAI immediately and marks it for future flush', async () => {
+      const [_, l2MessengerImpersonator, user1] = await ethers.getSigners()
+      const { l2Dai, l2DAIWormholeBridge } = await setupTest({ l2MessengerImpersonator, user1 })
+
+      await l2DAIWormholeBridge
+        .connect(user1)
+        .initiateWormhole(TARGET_DOMAIN_NAME, user1.address, WORMHOLE_AMOUNT, user1.address)
+
+      expect(await l2Dai.balanceOf(user1.address)).to.eq(INITIAL_TOTAL_L2_SUPPLY - WORMHOLE_AMOUNT)
+      expect(await l2DAIWormholeBridge.batchedDaiToFlush(TARGET_DOMAIN_NAME)).to.eq(WORMHOLE_AMOUNT)
+    })
+  })
+
+  describe('flush()', () => {
+    it('flushes batched debt', async () => {
+      const [_, l2MessengerImpersonator, user1] = await ethers.getSigners()
+      const { l2DAIWormholeBridge, l2CrossDomainMessengerMock, l1DAIWormholeBridgeMock } = await setupTest({
+        l2MessengerImpersonator,
+        user1,
+      })
+
+      // init two wormholes
+      await l2DAIWormholeBridge
+        .connect(user1)
+        .initiateWormhole(TARGET_DOMAIN_NAME, user1.address, WORMHOLE_AMOUNT, user1.address)
+      await l2DAIWormholeBridge
+        .connect(user1)
+        .initiateWormhole(TARGET_DOMAIN_NAME, user1.address, WORMHOLE_AMOUNT, user1.address)
+      expect(await l2DAIWormholeBridge.batchedDaiToFlush(TARGET_DOMAIN_NAME)).to.eq(WORMHOLE_AMOUNT * 2)
+
+      await l2DAIWormholeBridge.flush(TARGET_DOMAIN_NAME)
+      const xDomainMessengerCall = l2CrossDomainMessengerMock.smocked.sendMessage.calls[0]
+      expect(await l2DAIWormholeBridge.batchedDaiToFlush(TARGET_DOMAIN_NAME)).to.eq(0)
+
+      expect(xDomainMessengerCall._target).to.equal(l1DAIWormholeBridgeMock.address)
+      expect(xDomainMessengerCall._message).to.equal(
+        l1DAIWormholeBridgeMock.interface.encodeFunctionData('finalizeFlush', [
+          TARGET_DOMAIN_NAME,
+          WORMHOLE_AMOUNT * 2,
+        ]),
+      )
+      expect(xDomainMessengerCall._gasLimit).to.equal(DEFAULT_XDOMAIN_GAS)
+    })
+  })
+})
+
+async function setupTest(signers: { l2MessengerImpersonator: SignerWithAddress; user1: SignerWithAddress }) {
+  const l2CrossDomainMessengerMock = await deployOptimismContractMock(
+    'OVM_L2CrossDomainMessenger',
+    { address: await signers.l2MessengerImpersonator.getAddress() }, // This allows us to use an ethers override {from: Mock__OVM_L2CrossDomainMessenger.address} to mock calls
+  )
+  const l1Dai = await simpleDeploy<Dai__factory>('Dai', [])
+  const l2Dai = await simpleDeploy<Dai__factory>('Dai', [])
+  const l1DAIWormholeBridgeMock = await deployMock('L1DAIWormholeBridge')
+  const l2DAIWormholeBridge = await simpleDeploy<L2DAIWormholeBridge__factory>('L2DAIWormholeBridge', [
+    l2CrossDomainMessengerMock.address,
+    l2Dai.address,
+    l1Dai.address,
+    l1DAIWormholeBridgeMock.address,
+    SOURCE_DOMAIN_NAME,
+  ])
+
+  await l2Dai.rely(l2DAIWormholeBridge.address)
+  await l2Dai.mint(signers.user1.address, INITIAL_TOTAL_L2_SUPPLY)
+
+  return { l2Dai, l1DAIWormholeBridgeMock, l2CrossDomainMessengerMock, l2DAIWormholeBridge, l1Dai }
+}