feat: Permissioned Across-v2 bond token

contracts/BondToken.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+
+import "./HubPoolInterface.sol";
+import "./WETH9.sol";
+
+interface _HubPool is HubPoolInterface {
+    // Specify the automatically-implemented rootBundleProposer() getter.
+    function rootBundleProposal() external pure returns (HubPoolInterface.RootBundle memory);
+}
+
+/**
+ * @notice Across Bond Token (ABT).
+ * ABT is a simple deposit contract based on WETH9. ABT is issued proportionally to any address that deposits Ether. It
+ * imposes address-based permissioning on the WETH9 transferFrom() function in order to constrain the movement of ABT
+ * into the Across v2 HubPool contract. When configured as the required HubPool bond token, ABT can dramatically reduce
+ * the attack surface of the HubPool by requiring that addresses are explicitly approved before they can successfully
+ * submit a root bundle proposal. The address-based permissiong does not constrain transfers that are needed to dispute
+ * a root bundle proposal, so the ability of decentralised/unknown actors to dispute is unaffected.
+ */
+contract BondToken is WETH9, Ownable {
+    using Address for address;
+
+    _HubPool public immutable hubPool;
+
+    /**
+     * @notice Addresses that are permitted to make HubPool root bundle proposals.
+     */
+    mapping(address => bool) public proposers;
+
+    /**
+     * @notice Emitted on proposer permissions update.
+     */
+    event ProposerModified(address proposer, bool enabled);
+
+    /**
+     * @notice BondToken constructor.
+     * @param _hubPool Address of the target HubPool contract.
+     */
+    constructor(_HubPool _hubPool) {
+        name = "Across v2 Bond Token";
+        symbol = "ABT";
+        hubPool = _hubPool;
+    }
+
+    /**
+     * @notice Enable or disable an address as an allowed proposer. Emits a "ProposerModified" event on completion.
+     * @param proposer Proposer address to modify.
+     * @param enabled Boolean controlling whether the address is permitted to propose.
+     */
+    function setProposer(address proposer, bool enabled) external onlyOwner {
+        proposers[proposer] = enabled;
+        emit ProposerModified(proposer, enabled);
+    }
+
+    /**
+     * @notice Transfer amt from src to dst. Prevents unauthorised root bundle proposals by blocking transfers to the
+     * HubPool under the following conditions:
+     * - The src address is not a pre-approved proposer, *and*
+     * - The src address is the current proposer of a HubPool root bundle.
+     * Falls back to the base implementation after verifying that the transfer is permitted.
+     * @param src Source address.
+     * @param dst Destination address.
+     * @param amt Amount to transfer.
+     * @return True on success.
+     */
+    function transferFrom(
+        address src,
+        address dst,
+        uint256 amt
+    ) public override returns (bool) {
+        if (dst == address(hubPool)) {
+            require(proposers[src] || hubPool.rootBundleProposal().proposer != src, "Transfer not permitted");
+        }
+        return super.transferFrom(src, dst, amt);
+    }
+}

contracts/WETH9.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+// Copied from the verified code from Etherscan:
+// https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code
+// And then updated for Solidity version 0.6. Specific changes:
+// * Change `function() public` into `receive() external` and `fallback() external`
+// * Change `this.balance` to `address(this).balance`
+// * Ran prettier
+// * Marked transferFrom() as virtual
+contract WETH9 {
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8 public decimals = 18;
+
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    receive() external payable {
+        deposit();
+    }
+
+    fallback() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 wad) public {
+        require(balanceOf[msg.sender] >= wad);
+        balanceOf[msg.sender] -= wad;
+        payable(msg.sender).transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return address(this).balance;
+    }
+
+    function approve(address guy, uint256 wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint256 wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(
+        address src,
+        address dst,
+        uint256 wad
+    ) public virtual returns (bool) {
+        require(balanceOf[src] >= wad);
+
+        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
+            require(allowance[src][msg.sender] >= wad);
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        emit Transfer(src, dst, wad);
+
+        return true;
+    }
+}

deploy/019_deploy_bond_token.ts

@@ -0,0 +1,22 @@
+import "hardhat-deploy";
+import { HardhatRuntimeEnvironment } from "hardhat/types/runtime";
+
+const func = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts, getChainId } = hre;
+  const { deploy } = deployments;
+
+  const { deployer } = await getNamedAccounts();
+
+  const chainId = parseInt(await getChainId());
+  const hubPool = await deploy("HubPool", { from: deployer, log: true, skipIfAlreadyDeployed: true });
+
+  await deploy("BondToken", {
+    from: deployer,
+    log: true,
+    skipIfAlreadyDeployed: true,
+    args: [hubPool.address],
+    libraries: {},
+  });
+};
+module.exports = func;
+func.tags = ["BondToken", "mainnet"];

test/BondToken.Admin.ts

@@ -0,0 +1,34 @@
+import { bondTokenFixture } from "./fixtures/BondToken.Fixture";
+import { Contract, ethers, getContractFactory, randomAddress, SignerWithAddress, expect } from "./utils";
+
+let bondToken: Contract;
+let owner: SignerWithAddress, other: SignerWithAddress;
+
+describe("BondToken Admin functions", function () {
+  beforeEach(async function () {
+    [owner, other] = await ethers.getSigners();
+    ({ bondToken } = await bondTokenFixture());
+  });
+
+  it("Owner can manage proposers", async function () {
+    expect(await bondToken.proposers(owner.address)).to.be.false;
+
+    expect(await bondToken.proposers(other.address)).to.be.false;
+    expect(await bondToken.connect(owner).setProposer(other.address, true)).to.emit(bondToken, "ProposerModified");
+    expect(await bondToken.proposers(other.address)).to.be.true;
+
+    expect(await bondToken.proposers(other.address)).to.be.true;
+    expect(await bondToken.connect(owner).setProposer(other.address, false)).to.emit(bondToken, "ProposerModified");
+    expect(await bondToken.proposers(other.address)).to.be.false;
+  });
+
+  it("Non-owners can not manage proposers", async function () {
+    expect(await bondToken.proposers(other.address)).to.be.false;
+    for (const enabled of [true, false, true, false]) {
+      await expect(bondToken.connect(other).setProposer(other.address, enabled)).to.be.revertedWith(
+        "Ownable: caller is not the owner"
+      );
+      expect(await bondToken.proposers(other.address)).to.be.false;
+    }
+  });
+});

test/BondToken.Transfer.ts

@@ -0,0 +1,60 @@
+import { bondTokenFixture } from "./fixtures/BondToken.Fixture";
+import { Contract, ethers, getContractFactory, randomAddress, seedWallet, SignerWithAddress, expect } from "./utils";
+import { bondAmount } from "./constants";
+
+const bondTokenName = "Across v2 Bond Token";
+const bondTokenSymbol = "ABT";
+const bondTokenDecimals = 18;
+
+let bondToken: Contract;
+let hubPool: Contract;
+let owner: SignerWithAddress, other: SignerWithAddress, rando: SignerWithAddress;
+
+// Most of this functionality falls through to the underlying WETH9 implementation.
+// Testing here just demonstrates that ABT doesn't break anything.
+describe("BondToken ERC20 functions", function () {
+  beforeEach(async function () {
+    [owner, other, rando] = await ethers.getSigners();
+    ({ bondToken, hubPool } = await bondTokenFixture());
+  });
+
+  it("Verify name, symbol and decimals", async function () {
+    expect(await bondToken.name()).to.equal(bondTokenName);
+    expect(await bondToken.symbol()).to.equal(bondTokenSymbol);
+    expect(await bondToken.decimals()).to.equal(bondTokenDecimals);
+  });
+
+  it("Anyone can deposit into ABT", async function () {
+    for (const signer of [owner, other]) {
+      const abt = bondToken.connect(signer);
+      await expect(abt.deposit({ value: bondAmount }))
+        .to.emit(bondToken, "Deposit")
+        .withArgs(signer.address, bondAmount);
+      expect((await abt.balanceOf(signer.address)).eq(bondAmount)).to.be.true;
+    }
+  });
+
+  it("ABT holders can withdraw", async function () {
+    for (const signer of [owner, other, rando]) {
+      await seedWallet(signer, [], bondToken, bondAmount);
+
+      expect((await bondToken.balanceOf(signer.address)).eq(bondAmount)).to.be.true;
+      await expect(bondToken.connect(signer).withdraw(bondAmount))
+        .to.emit(bondToken, "Withdrawal")
+        .withArgs(signer.address, bondAmount);
+      expect((await bondToken.balanceOf(signer.address)).eq("0")).to.be.true;
+    }
+  });
+
+  it("ABT holders can transfer", async function () {
+    await seedWallet(other, [], bondToken, bondAmount);
+
+    expect((await bondToken.balanceOf(other.address)).eq(bondAmount)).to.be.true;
+    expect((await bondToken.balanceOf(rando.address)).eq("0")).to.be.true;
+    await expect(bondToken.connect(other).transfer(rando.address, bondAmount))
+      .to.emit(bondToken, "Transfer")
+      .withArgs(other.address, rando.address, bondAmount);
+    expect((await bondToken.balanceOf(other.address)).eq("0")).to.be.true;
+    expect((await bondToken.balanceOf(rando.address)).eq(bondAmount)).to.be.true;
+  });
+});