feat: SignetL1

Author: prestwich

foundry.toml

@@ -5,8 +5,6 @@ libs = ["lib"]
 
 via-ir = true
 
-# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
-
-
 [lint]
+ignore = ["src/vendor/*"]
 exclude_lints = ["unwrapped-modifier-logic"]

src/apps/Morpho.sol

@@ -249,9 +249,11 @@ contract HosyMorphoBorrow is HostMorphoUser {
         // borrow some amount of loanToken
         MORPHO.borrow(loadParams(), amount, 0, onBehalf, address(this));
 
+        // TODO: complete implementation
         // User logic to use the tokens goes here.
         // Could send the tokens to the rollup via Passage, or do something
         // else :)
+        filler;
 
         return true;
     }

src/chains/Pecorino.sol

@@ -3,6 +3,8 @@ pragma solidity ^0.8.13;
 
 import {RollupOrders} from "zenith/src/orders/RollupOrders.sol";
 import {RollupPassage} from "zenith/src/passage/RollupPassage.sol";
+import {HostOrders} from "zenith/src/orders/HostOrders.sol";
+import {Passage} from "zenith/src/passage/Passage.sol";
 import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 
 /// @title PecorinoConstants
@@ -16,6 +18,12 @@ library PecorinoConstants {
     /// @notice The Pecorino Rollup chain ID.
     uint32 constant ROLLUP_CHAIN_ID = 14174;
 
+    /// @notice The Passage contract for the Pecorino testnet host chain.
+    Passage constant HOST_PASSAGE = Passage(payable(0x12585352AA1057443D6163B539EfD4487f023182));
+
+    /// @notice The HostOrders contract for the Pecorino testnet host chain.
+    HostOrders constant HOST_ORDERS = HostOrders(0x0A4f505364De0Aa46c66b15aBae44eBa12ab0380);
+
     /// @notice The Rollup Passage contract for the Pecorino testnet.
     RollupPassage constant PECORINO_ROLLUP_PASSAGE = RollupPassage(payable(0x0000000000007369676E65742D70617373616765));
 

src/l1/Signet.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {HostOrders} from "zenith/src/orders/HostOrders.sol";
+import {Passage} from "zenith/src/passage/Passage.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+import {AddressAliasHelper} from "../vendor/AddressAliasHelper.sol";
+import {PecorinoConstants} from "../chains/Pecorino.sol";
+
+abstract contract SignetL1 {
+    /// @notice Sentinal value for the native asset in order inputs/outputs
+    address constant NATIVE_ASSET = address(0);
+
+    /// @notice The Passage address
+    Passage internal immutable PASSAGE;
+    /// @notice The Host Orders address
+    HostOrders internal immutable ORDERS;
+
+    /// @notice The WETH token address.
+    IERC20 internal immutable WETH;
+    /// @notice The WBTC token address.
+    IERC20 internal immutable WBTC;
+    /// @notice The USDC token address.
+    IERC20 internal immutable USDC;
+    /// @notice The USDT token address.
+    IERC20 internal immutable USDT;
+
+    /// @notice The Rollup WUSD token address.
+    address internal immutable RU_WUSD;
+    /// @notice The Rollup WBTC token address.
+    address internal immutable RU_WBTC;
+    /// @notice The Rollup WETH token address.
+    address internal immutable RU_WETH;
+
+    /// @notice Error for unsupported chain IDs.
+    error UnsupportedChain(uint256);
+
+    constructor() {
+        if (block.chainid == PecorinoConstants.HOST_CHAIN_ID) {
+            PASSAGE = PecorinoConstants.HOST_PASSAGE;
+            ORDERS = PecorinoConstants.HOST_ORDERS;
+
+            WETH = IERC20(PecorinoConstants.HOST_WETH);
+            WBTC = IERC20(PecorinoConstants.HOST_WBTC);
+            USDC = IERC20(PecorinoConstants.HOST_USDC);
+            USDT = IERC20(PecorinoConstants.HOST_USDT);
+
+            RU_WUSD = address(PecorinoConstants.WUSD);
+            RU_WBTC = address(PecorinoConstants.WBTC);
+            RU_WETH = address(PecorinoConstants.WETH);
+        } else {
+            revert UnsupportedChain(block.chainid);
+        }
+    }
+
+    /// @notice This is used to know whether to alias. It should generally
+    /// return false. If writing an ephemeral contract, override to return true.
+    function isEphemeral() internal pure virtual returns (bool) {
+        return false;
+    }
+
+    /// @notice Returns
+    function selfOnL2() internal view returns (address) {
+        if (isEphemeral()) {
+            return address(this);
+        }
+        if (address(this).code.length == 23) {
+            bool is7702;
+            assembly {
+                let ptr := mload(0x40)
+                extcodecopy(caller(), ptr, 0, 0x20)
+                is7702 := eq(shr(232, mload(ptr)), 0xEF0100)
+                // clean the memory we used. Unnecessary, but good hygiene
+                mstore(ptr, 0x0)
+            }
+            if (is7702) {
+                return address(this);
+            }
+        }
+        return AddressAliasHelper.applyL1ToL2Alias(address(this));
+    }
+
+    function makeOutput(address token, uint256 amount, address recipient)
+        internal
+        pure
+        returns (HostOrders.Output memory output)
+    {
+        output.token = token;
+        output.amount = amount;
+        output.recipient = recipient;
+        output.chainId = PecorinoConstants.HOST_CHAIN_ID;
+    }
+
+    function usdcOutput(uint256 amount, address recipient) internal view returns (HostOrders.Output memory output) {
+        return makeOutput(address(USDC), amount, recipient);
+    }
+
+    function usdtOutput(uint256 amount, address recipient) internal view returns (HostOrders.Output memory output) {
+        return makeOutput(address(USDT), amount, recipient);
+    }
+
+    function wbtcOutput(uint256 amount, address recipient) internal view returns (HostOrders.Output memory output) {
+        return makeOutput(address(WBTC), amount, recipient);
+    }
+
+    function wethOutput(uint256 amount, address recipient) internal view returns (HostOrders.Output memory output) {
+        return makeOutput(address(WETH), amount, recipient);
+    }
+
+    function ethOutput(uint256 amount, address recipient) internal pure returns (HostOrders.Output memory output) {
+        return makeOutput(NATIVE_ASSET, amount, recipient);
+    }
+
+    function enterSignetToken(address token, uint256 amount) internal {
+        if (token == NATIVE_ASSET) {
+            enterSignetEth(amount);
+            return;
+        }
+        IERC20(token).approve(address(PASSAGE), amount);
+        PASSAGE.enterToken(selfOnL2(), token, amount);
+    }
+
+    function enterSignetEth(uint256 amount) internal {
+        PASSAGE.enter{value: amount}(selfOnL2());
+    }
+}

src/l2/Signet.sol

@@ -55,7 +55,7 @@ contract SignetL2 {
             HOST_WBTC = PecorinoConstants.HOST_WBTC;
             HOST_WETH = PecorinoConstants.HOST_WETH;
         } else {
-            revert("Unsupported chain");
+            revert UnsupportedChain(block.chainid);
         }
     }
 

src/vendor/AddressAliasHelper.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * Copyright 2019-2021, Offchain Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+pragma solidity ^0.8.0;
+
+library AddressAliasHelper {
+    uint160 constant offset = uint160(0x1111000000000000000000000000000000001111);
+
+    /// @notice Utility function that converts the address in the L1 that submitted a tx to
+    /// the inbox to the msg.sender viewed in the L2
+    /// @param l1Address the address in the L1 that triggered the tx to L2
+    /// @return l2Address L2 address as viewed in msg.sender
+    function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
+        unchecked {
+            l2Address = address(uint160(l1Address) + offset);
+        }
+    }
+
+    /// @notice Utility function that converts the msg.sender viewed in the L2 to the
+    /// address in the L1 that submitted a tx to the inbox
+    /// @param l2Address L2 address as viewed in msg.sender
+    /// @return l1Address the address in the L1 that triggered the tx to L2
+    function undoL1ToL2Alias(address l2Address) internal pure returns (address l1Address) {
+        unchecked {
+            l1Address = address(uint160(l2Address) - offset);
+        }
+    }
+}