feat: basic third-party bridge app

Author: prestwich

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "lib/zenith"]
 	path = lib/zenith
 	url = https://github.com/init4tech/zenith
+[submodule "lib/simple-erc20"]
+	path = lib/simple-erc20
+	url = https://github.com/init4tech/simple-erc20

foundry.lock

@@ -1,10 +1,4 @@
 {
-  "lib/zenith": {
-    "tag": {
-      "name": "v0.1.55",
-      "rev": "914146a3904541192f2cb0906c0990cc6f90b1e3"
-    }
-  },
   "lib/forge-std": {
     "tag": {
       "name": "v1.10.0",
@@ -16,5 +10,14 @@
       "name": "v5.4.0",
       "rev": "c64a1edb67b6e3f4a15cca8909c9482ad33a02b0"
     }
+  },
+  "lib/simple-erc20": {
+    "rev": "f5c2597ec179ea13e219ccbca415dc59d5a33398"
+  },
+  "lib/zenith": {
+    "tag": {
+      "name": "v0.1.55",
+      "rev": "914146a3904541192f2cb0906c0990cc6f90b1e3"
+    }
   }
 }

lib/simple-erc20

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {RollupOrders} from "zenith/src/orders/RollupOrders.sol";
+import {SimpleERC20} from "simple-erc20/SimpleERC20.sol";
+
+import {SignetL2} from "../../l2/Signet.sol";
+
+abstract contract BridgeL2 is SignetL2, SimpleERC20 {
+    address immutable HOST_ASSET;
+    address immutable HOST_BANK;
+
+    constructor(
+        address _hostAsset,
+        address _hostBank,
+        address _initialOwner,
+        string memory _name,
+        string memory _symbol,
+        uint8 _decimals
+    ) SimpleERC20(_initialOwner, _name, _symbol, _decimals) {
+        HOST_ASSET = _hostAsset;
+        HOST_BANK = _hostBank;
+    }
+
+    function _bridgeIn(address recipient, uint256 amount, RollupOrders.Input[] memory inputs) internal virtual {
+        RollupOrders.Output[] memory outputs = new RollupOrders.Output[](1);
+        outputs[0] = makeHostOutput(HOST_ASSET, amount, HOST_BANK);
+
+        ORDERS.initiate(block.timestamp, inputs, outputs);
+
+        _mint(recipient, amount);
+    }
+
+    function bridgeIn(address recipient, uint256 amount) public virtual {
+        _bridgeIn(recipient, amount, new RollupOrders.Input[](0));
+    }
+
+    function _bridgeOut(address recipient, uint256 amount, RollupOrders.Input[] memory inputs) internal virtual {
+        RollupOrders.Output[] memory outputs = new RollupOrders.Output[](1);
+        outputs[0] = makeHostOutput(HOST_ASSET, amount, recipient);
+
+        ORDERS.initiate(block.timestamp, inputs, outputs);
+
+        _burn(msg.sender, amount);
+    }
+
+    function bridgeOut(address recipient, uint256 amount) public virtual {
+        _bridgeOut(recipient, amount, new RollupOrders.Input[](0));
+    }
+}

src/apps/bridge/BridgeL2.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {RollupOrders} from "zenith/src/orders/RollupOrders.sol";
+import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+import {SignetL2} from "../../l2/Signet.sol";
+import {BurnMintERC20} from "../../vendor/BurnMintERC20.sol";
+
+
+contract LidoL2 is SignetL2(), BurnMintERC20 {
+    using SafeERC20 for IERC20;
+
+    address public immutable HOST_WSTETH;
+
+    constructor(address _hostWsteth)
+        BurnMintERC20("Signet Lido Staked Ether", "stETH", 18, 0, 0)
+    {
+        HOST_WSTETH = _hostWsteth;
+        WETH.forceApprove(address(ORDERS), type(uint256).max);
+    }
+
+    function _bridgeIn(address recipient, uint256 amount, RollupOrders.Input[] memory inputs) internal {
+        RollupOrders.Output[] memory outputs = new RollupOrders.Output[](1);
+        outputs[0] = makeHostOutput(HOST_WSTETH, amount, address(HOST_PASSAGE));
+
+        ORDERS.initiate(block.timestamp, inputs, outputs);
+
+        _mint(recipient, amount);
+    }
+
+    function bridgeIn(address recipient, uint256 amount) external {
+        _bridgeIn(recipient, amount, new RollupOrders.Input[](0));
+    }
+
+    function bridgeOut(address recipient, uint256 amount) public {
+        _burn(msg.sender, amount);
+
+        RollupOrders.Output[] memory outputs = new RollupOrders.Output[](1);
+        outputs[0] = makeHostOutput(HOST_WSTETH, amount, recipient);
+
+        ORDERS.initiate(block.timestamp, new RollupOrders.Input[](0), outputs);
+    }
+
+    function enter(address funder, uint256 amountIn, address recipient, uint256 amountOut) external {
+        WETH.safeTransferFrom(funder, address(this), amountIn);
+
+        RollupOrders.Input[] memory inputs = new RollupOrders.Input[](1);
+        inputs[0] = makeWethInput(amountIn);
+
+        _bridgeIn(recipient, amountOut, inputs);
+    }
+}

src/apps/lido/LidoL2.sol

@@ -25,10 +25,10 @@ library PecorinoConstants {
     HostOrders constant HOST_ORDERS = HostOrders(0x0A4f505364De0Aa46c66b15aBae44eBa12ab0380);
 
     /// @notice The Rollup Passage contract for the Pecorino testnet.
-    RollupPassage constant PECORINO_ROLLUP_PASSAGE = RollupPassage(payable(0x0000000000007369676E65742D70617373616765));
+    RollupPassage constant ROLLUP_PASSAGE = RollupPassage(payable(0x0000000000007369676E65742D70617373616765));
 
     /// @notice The Rollup Orders contract for the Pecorino testnet.
-    RollupOrders constant PECORINO_ROLLUP_ORDERS = RollupOrders(0x000000000000007369676E65742D6f7264657273);
+    RollupOrders constant ROLLUP_ORDERS = RollupOrders(0x000000000000007369676E65742D6f7264657273);
 
     /// USDC token for the Pecorino testnet host chain.
     address constant HOST_USDC = 0x65Fb255585458De1F9A246b476aa8d5C5516F6fd;

src/chains/Pecorino.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
+
+import {SignetL2} from "./Signet.sol";
+
+abstract contract SelfOwned is SignetL2(), Ownable {
+    constructor() {
+        Ownable(aliasedSelf());
+    }
+}

src/l2/SelfOwned.sol

@@ -6,6 +6,7 @@ import {RollupPassage} from "zenith/src/passage/RollupPassage.sol";
 import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 
 import {PecorinoConstants} from "../chains/Pecorino.sol";
+import {AddressAliasHelper} from "../vendor/AddressAliasHelper.sol";
 
 contract SignetL2 {
     /// @notice Sentinal value for the native asset in order inputs/outputs
@@ -19,6 +20,9 @@ contract SignetL2 {
     /// @notice The Rollup Orders contract.
     RollupOrders internal immutable ORDERS;
 
+    /// @notice The address of the Rollup Passage on the host network.
+    address immutable HOST_PASSAGE;
+
     /// @notice The WETH token address.
     IERC20 internal immutable WETH;
     /// @notice The WBTC token address.
@@ -43,8 +47,10 @@ contract SignetL2 {
         if (block.chainid == PecorinoConstants.ROLLUP_CHAIN_ID) {
             HOST_CHAIN_ID = PecorinoConstants.HOST_CHAIN_ID;
 
-            PASSAGE = PecorinoConstants.PECORINO_ROLLUP_PASSAGE;
-            ORDERS = PecorinoConstants.PECORINO_ROLLUP_ORDERS;
+            HOST_PASSAGE = address(PecorinoConstants.HOST_PASSAGE);
+
+            PASSAGE = PecorinoConstants.ROLLUP_PASSAGE;
+            ORDERS = PecorinoConstants.ROLLUP_ORDERS;
 
             WETH = PecorinoConstants.WETH;
             WBTC = PecorinoConstants.WBTC;
@@ -59,6 +65,12 @@ contract SignetL2 {
         }
     }
 
+    /// @notice Gets the aliased address of this contracat, representing itself
+    /// on L1. Use with caustion.
+    function aliasedSelf() internal view returns (address) {
+        return AddressAliasHelper.applyL1ToL2Alias(address(this));
+    }
+
     /// @notice Creates an Input struct for the RollupOrders.
     /// @param token The address of the token.
     /// @param amount The amount of the token.
@@ -68,14 +80,24 @@ contract SignetL2 {
         input.amount = amount;
     }
 
-    /// @notice Creates an Input struct for the native asset (ETH).
+    /// @notice Creates an Input struct for the native asset (USD).
     /// @param amount The amount of the native asset (in wei).
     /// @return input The created Input struct for the native asset.
-    function makeEthInput(uint256 amount) internal pure returns (RollupOrders.Input memory input) {
+    function makeUsdInput(uint256 amount) internal pure returns (RollupOrders.Input memory input) {
         input.token = address(0);
         input.amount = amount;
     }
 
+    function makeWethInput(uint256 amount) internal view returns (RollupOrders.Input memory input) {
+        input.token = address(WETH);
+        input.amount = amount;
+    }
+
+    function makeWbtcInput(uint256 amount) internal view returns (RollupOrders.Input memory input) {
+        input.token = address(WBTC);
+        input.amount = amount;
+    }
+
     /// @notice Creates an Output struct for the RollupOrders.
     /// @param token The address of the token.
     /// @param amount The amount of the token.

src/l2/Signet.sol

@@ -30,7 +30,7 @@ contract GetOut is SignetL2 {
         uint256 desired = msg.value * 995 / 1000; // 0.5% fee
 
         RollupOrders.Input[] memory inputs = new RollupOrders.Input[](1);
-        inputs[0] = makeEthInput(msg.value);
+        inputs[0] = makeUsdInput(msg.value);
 
         RollupOrders.Output[] memory outputs = new RollupOrders.Output[](1);
         outputs[0] = hostUsdcOutput(desired, msg.sender);