la Tierra es un dado roído y ya redondo a fuerza de rodar a la aventura

Author: prestwich

.github/workflows/test.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    name: Foundry project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Show Forge version
+        run: |
+          forge --version
+
+      - name: Run Forge fmt
+        run: |
+          forge fmt --check
+        id: fmt
+
+      - name: Run Forge build
+        run: |
+          forge build --sizes
+        id: build
+
+      - name: Run Forge tests
+        run: |
+          forge test -vvv
+        id: test

.gitignore

@@ -0,0 +1,14 @@
+# Compiler files
+cache/
+out/
+
+# Ignores development broadcast logs
+!/broadcast
+/broadcast/*/31337/
+/broadcast/**/dry-run/
+
+# Docs
+docs/
+
+# Dotenv file
+.env

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "lib/zenith"]
+	path = lib/zenith
+	url = https://github.com/init4tech/zenith

README.md

@@ -0,0 +1,52 @@
+# Signet Solidity Examples
+
+This repo contains solidity examples using the [Signet Orders] system to do
+some fun and suprising things 🎀
+
+Signet Orders are cross-chain, instant, atomic, and composable. Because Outputs
+are effectively MEV, you can do some really interesting things with them. Like
+[MevWallet], Signet Orders allow you to leverage MEV Searchers to:
+
+- Move assets across chains
+- Invoke functions on other chains
+- Schedule transactions or function invocations
+- Capture MEV produced by your application
+- Impress your friends
+- And more!
+
+[MevWallet]: https://github.com/blunt-instruments/MevWallet
+[Signet Orders]: https://signet.sh/docs/learn-about-signet/cross-chain-transfers/
+
+## Main Examples
+
+- [`SignetStd.sol`](./src/SignetStd.sol) - A simple contract that
+  auto-configures Signet system parameters, based on the chain id.
+- [`Flash.sol`](./src/examples/Flash.sol) - Allows your contract to flash borrow
+  any asset (provided some searcher will provide it). Flash loans work by having an input and output of the same asset. The Output is then used as the Input to its own Order. This is pretty neat 🎀
+- [`GetOut.sol`](./src/examples/GetOut.sol) - A shortcut contract for
+  exiting Signet (by offering searchers a 50 bps fee).
+- [`PayMe.sol`](./src/examples/PayMe.sol) - Payment gating for smart contracts,
+  using a Signet Order with no inputs. These ensures that contract execution is invalid unless SOMEONE has filled the Order. Unlike traditional payment gates that check `msg.value`, this does NOT require the calling contract to manage cash flow. Instead _any third party_ can fill the order. The calling contract can be blind to the payment. This greatly simplifies contract logic required
+  to implement payment gates.
+- [`PayYou.sol`](./src/examples/PayYou.sol) - The opposite of payment gating,
+  this allows a contract to generate MEV by offering a Signet Order with no outputs. This payment becomes a bounty for calling the contract, and functions as an incentivized scheduling system.
+
+## Basic Repo Instructions
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```

foundry.lock

@@ -0,0 +1,20 @@
+{
+  "lib/zenith": {
+    "tag": {
+      "name": "v0.1.55",
+      "rev": "914146a3904541192f2cb0906c0990cc6f90b1e3"
+    }
+  },
+  "lib/forge-std": {
+    "tag": {
+      "name": "v1.10.0",
+      "rev": "8bbcf6e3f8f62f419e5429a0bd89331c85c37824"
+    }
+  },
+  "lib/openzeppelin-contracts": {
+    "tag": {
+      "name": "v5.4.0",
+      "rev": "c64a1edb67b6e3f4a15cca8909c9482ad33a02b0"
+    }
+  }
+}

foundry.toml

@@ -0,0 +1,8 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+
+via-ir = true
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

lib/forge-std

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {RollupOrders} from "zenith/src/orders/RollupOrders.sol";
+import {RollupPassage} from "zenith/src/passage/RollupPassage.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+import {PecorinoConstants} from "./chains/Pecorino.sol";
+
+contract SignetStd {
+    /// @notice The native asset address, used as a sentinel for native USD on
+    ///         the rollup, or native ETH on the host.
+    address constant NATIVE_ASSET = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+    /// @notice The chain ID of the host network.
+    uint32 internal immutable HOST_CHAIN_ID;
+
+    /// @notice The Rollup Passage contract.
+    RollupPassage internal immutable PASSAGE;
+    /// @notice The Rollup Orders contract.
+    RollupOrders internal immutable ORDERS;
+
+    /// @notice The WETH token address.
+    IERC20 internal immutable WETH;
+    /// @notice The WBTC token address.
+    IERC20 internal immutable WBTC;
+    /// @notice The WUSD token address.
+    IERC20 internal immutable WUSD;
+
+    /// @notice The USDC token address on the host network.
+    address internal immutable HOST_USDC;
+    /// @notice The USDT token address on the host network.
+    address internal immutable HOST_USDT;
+    /// @notice The WBTC token address on the host network.
+    address internal immutable HOST_WBTC;
+    /// @notice The WETH token address on the host network.
+    address internal immutable HOST_WETH;
+
+    constructor() {
+        // Auto-configure based on the chain ID.
+        if (block.chainid == PecorinoConstants.ROLLUP_CHAIN_ID) {
+            HOST_CHAIN_ID = PecorinoConstants.HOST_CHAIN_ID;
+
+            PASSAGE = PecorinoConstants.PECORINO_ROLLUP_PASSAGE;
+            ORDERS = PecorinoConstants.PECORINO_ROLLUP_ORDERS;
+
+            WETH = PecorinoConstants.WETH;
+            WBTC = PecorinoConstants.WBTC;
+            WUSD = PecorinoConstants.WUSD;
+
+            HOST_USDC = PecorinoConstants.HOST_USDC;
+            HOST_USDT = PecorinoConstants.HOST_USDT;
+            HOST_WBTC = PecorinoConstants.HOST_WBTC;
+            HOST_WETH = PecorinoConstants.HOST_WETH;
+        } else {
+            revert("Unsupported chain");
+        }
+    }
+
+    /// @notice Creates an Input struct for the RollupOrders.
+    /// @param token The address of the token.
+    /// @param amount The amount of the token.
+    /// @return input The created Input struct.
+    function makeInput(address token, uint256 amount) internal pure returns (RollupOrders.Input memory input) {
+        input.token = token;
+        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.
+    /// @param recipient The address to receive the output tokens.
+    /// @param chainId The chain ID for the output.
+    /// @return output The created Output struct.
+    function makeOutput(address token, uint256 amount, address recipient, uint32 chainId)
+        private
+        pure
+        returns (RollupOrders.Output memory output)
+    {
+        output.token = token;
+        output.amount = amount;
+        output.recipient = recipient;
+        output.chainId = chainId;
+    }
+
+    /// @notice Creates an Output struct for the host network.
+    /// @param token The address of the token.
+    /// @param amount The amount of the token.
+    /// @param recipient The address to receive the output tokens.
+    /// @return output The created Output struct for the host network.
+    function makeHostOutput(address token, uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeOutput(token, amount, recipient, HOST_CHAIN_ID);
+    }
+
+    /// @notice Creates an Output struct for the rollup network.
+    /// @param token The address of the token.
+    /// @param amount The amount of the token.
+    /// @param recipient The address to receive the output tokens.
+    /// @return output The created Output struct for the rollup network.
+    function makeRollupOutput(address token, uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeOutput(token, amount, recipient, uint32(block.chainid));
+    }
+
+    /// @notice Creates an Output struct for the host USDC token.
+    /// @param amount The amount of USDC to receive.
+    /// @param recipient The address to receive the USDC tokens.
+    /// @return output The created Output struct for the host USDC token.
+    function hostUsdcOutput(uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeHostOutput(HOST_USDC, amount, recipient);
+    }
+
+    /// @notice Creates an Output struct for the host USDT token.
+    /// @param amount The amount of USDT to receive.
+    /// @param recipient The address to receive the USDT tokens.
+    /// @return output The created Output struct for the host USDT token.
+    function hostUsdtOutput(uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeHostOutput(HOST_USDT, amount, recipient);
+    }
+
+    /// @notice Creates an Output struct for the host WBTC token.
+    /// @param amount The amount of WBTC to receive.
+    /// @param recipient The address to receive the WBTC tokens.
+    /// @return output The created Output struct for the host WBTC token.
+    function hostWbtcOutput(uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeHostOutput(HOST_WBTC, amount, recipient);
+    }
+
+    /// @notice Creates an Output struct for the host WETH token.
+    /// @param amount The amount of WETH to receive.
+    /// @param recipient The address to receive the WETH tokens.
+    /// @return output The created Output struct for the host WETH token.
+    function hostWethOutput(uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeHostOutput(HOST_WETH, amount, recipient);
+    }
+
+    /// @notice Creates an Output struct for the host native asset (ETH).
+    /// @param amount The amount of native asset to receive.
+    /// @param recipient The address to receive the native asset.
+    /// @return output The created Output struct for the host native asset.
+    function hostEthOutput(uint256 amount, address recipient)
+        internal
+        view
+        returns (RollupOrders.Output memory output)
+    {
+        return makeHostOutput(NATIVE_ASSET, amount, recipient);
+    }
+}