boundless-xyz · jonastheis · Jul 7, 2026 · May 8, 2026 · May 8, 2026 · May 8, 2026
@@ -39,6 +39,7 @@ jobs:
           filters: |
             src:
               - 'contracts/src/**'
+              - 'contracts/shanghai/**'
             foundry:
               - 'foundry.toml'
             test:
@@ -104,6 +105,18 @@ jobs:
       - name: Verify storage layout interop between src/ and src/legacy/
         run: python3 contracts/scripts/verify-storage-layout.py
 
+      - name: forge build (shanghai profile)
+        run: FOUNDRY_PROFILE=shanghai forge build --silent contracts/shanghai/variants/BoundlessMarket.sol contracts/shanghai/legacy/BoundlessMarketLegacy.sol
+
+      - name: Verify shanghai legacy/ bytecode matches deployed Taiko impl
+        run: BOUNDLESS_OUT_DIR=out-shanghai BOUNDLESS_LEGACY_SNAPSHOT_DIR=contracts/shanghai/legacy python3 contracts/scripts/verify-legacy-bytecode.py
+
+      - name: Verify shanghai market/legacy storage layout interop
+        run: BOUNDLESS_OUT_DIR=out-shanghai python3 contracts/scripts/verify-storage-layout.py
+
+      - name: Run the contract suite under the shanghai profile
+        run: FOUNDRY_PROFILE=shanghai forge test --isolate
+
   upgradability:
     runs-on: ubuntu-latest
     needs: contracts-changed

@@ -18,8 +18,8 @@ import {BoundlessRouter} from "../src/router/BoundlessRouter.sol";
 import {ControlID} from "../src/blake3-groth16/ControlID.sol";
 import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import {ConfigLoader, DeploymentConfig} from "./Config.s.sol";
-import {BoundlessMarket} from "../src/BoundlessMarket.sol";
-import {BoundlessMarket as BoundlessMarketLegacy} from "../src/legacy/BoundlessMarketLegacy.sol";
+import {BoundlessMarket} from "boundless-market/BoundlessMarket.sol";
+import {BoundlessMarket as BoundlessMarketLegacy} from "boundless-market-legacy/BoundlessMarketLegacy.sol";
 import {HitPoints} from "../src/HitPoints.sol";
 import {BoundlessScriptBase} from "./BoundlessScript.s.sol";
 

@@ -9,8 +9,8 @@ import {Script} from "forge-std/Script.sol";
 import {console2} from "forge-std/console2.sol";
 import {Strings} from "openzeppelin/contracts/utils/Strings.sol";
 import {IRiscZeroVerifier} from "risc0/IRiscZeroVerifier.sol";
-import {BoundlessMarket} from "../src/BoundlessMarket.sol";
-import {BoundlessMarket as BoundlessMarketLegacy} from "../src/legacy/BoundlessMarketLegacy.sol";
+import {BoundlessMarket} from "boundless-market/BoundlessMarket.sol";
+import {BoundlessMarket as BoundlessMarketLegacy} from "boundless-market-legacy/BoundlessMarketLegacy.sol";
 import {BoundlessRouter} from "../src/router/BoundlessRouter.sol";
 import {BoundlessMarketLib} from "../src/libraries/BoundlessMarketLib.sol";
 import {ConfigLoader, DeploymentConfig} from "./Config.s.sol";

@@ -24,14 +24,21 @@
 """
 
 import json
+import os
 import re
 import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
-ARTIFACT = REPO_ROOT / "out" / "BoundlessMarketLegacy.sol" / "BoundlessMarket.json"
-DEPLOYED_HEX = REPO_ROOT / "contracts" / "test" / "legacy" / "deployed-bytecode.hex"
-META_TOML = REPO_ROOT / "contracts" / "test" / "legacy" / "deployed-bytecode.meta.toml"
+# Defaults check the Cancun/Base legacy. Override via env to check the Taiko legacy compiled under
+# FOUNDRY_PROFILE=shanghai:
+#   BOUNDLESS_OUT_DIR=out-shanghai
+#   BOUNDLESS_LEGACY_SNAPSHOT_DIR=contracts/shanghai/legacy
+_OUT_DIR = REPO_ROOT / os.environ.get("BOUNDLESS_OUT_DIR", "out")
+_SNAPSHOT_DIR = REPO_ROOT / os.environ.get("BOUNDLESS_LEGACY_SNAPSHOT_DIR", "contracts/test/legacy")
+ARTIFACT = _OUT_DIR / "BoundlessMarketLegacy.sol" / "BoundlessMarket.json"
+DEPLOYED_HEX = _SNAPSHOT_DIR / "deployed-bytecode.hex"
+META_TOML = _SNAPSHOT_DIR / "deployed-bytecode.meta.toml"
 
 
 def strip0x(s: str) -> str:

@@ -25,13 +25,17 @@
 """
 
 import json
+import os
 import re
 import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
-NEW_ARTIFACT = REPO_ROOT / "out" / "BoundlessMarket.sol" / "BoundlessMarket.json"
-LEGACY_ARTIFACT = REPO_ROOT / "out" / "BoundlessMarketLegacy.sol" / "BoundlessMarket.json"
+# Default profile writes to ./out; the shanghai profile writes to ./out-shanghai. Point the script
+# at the latter with `BOUNDLESS_OUT_DIR=out-shanghai` to verify the Taiko market/legacy pair.
+_OUT_DIR = REPO_ROOT / os.environ.get("BOUNDLESS_OUT_DIR", "out")
+NEW_ARTIFACT = _OUT_DIR / "BoundlessMarket.sol" / "BoundlessMarket.json"
+LEGACY_ARTIFACT = _OUT_DIR / "BoundlessMarketLegacy.sol" / "BoundlessMarket.json"
 
 # Top-level storage variables shared between the two contracts. Order +
 # expected slot are part of the contract — any change here is a real

@@ -24,8 +24,8 @@ import {
 } from "risc0/IRiscZeroVerifier.sol";
 import {IRiscZeroSetVerifier} from "risc0/IRiscZeroSetVerifier.sol";
 
-import {IBoundlessMarket} from "./IBoundlessMarket.sol";
-import {IBoundlessMarketCallback} from "./IBoundlessMarketCallback.sol";
+import {IBoundlessMarket} from "./IBoundlessMarketLegacy.sol";
+import {IBoundlessMarketCallback} from "./IBoundlessMarketCallbackLegacy.sol";
 import {Account} from "./types/Account.sol";
 import {AssessorJournal} from "./types/AssessorJournal.sol";
 import {AssessorCallback} from "./types/AssessorCallback.sol";

@@ -0,0 +1,54 @@
+# `contracts/shanghai/legacy/` — frozen audited tree (Taiko)
+
+This subtree is a frozen copy of the pre-router `BoundlessMarket` and its transitive dependencies
+**as deployed on Taiko mainnet**, compiled under the Shanghai EVM (`FOUNDRY_PROFILE=shanghai`). It
+exists so the new router-based shanghai market can forward its pre-router legacy ABI to the audited
+bytecode at the existing implementation address via a `fallback() + delegatecall` shim, without
+re-introducing the legacy bodies into the new market's bytecode.
+
+It is the Taiko/Shanghai counterpart of `contracts/src/legacy/` (which freezes the Base/Cancun
+deployment). The two are separate because they reproduce different deployed bytecode: Taiko's impl
+was compiled for the Shanghai EVM (no `tstore`/`mcopy`), so it uses the `sstore`/`sload`
+`FulfillmentContext` and the `compat/Bytes` shim rather than the Cancun originals.
+
+## Provenance
+
+The sources here mirror the pre-router shanghai market suite (`contracts/shanghai/src/`) as it was
+at the Taiko deployment. The only diffs from those sources are file-basename + import renames
+(`BoundlessMarket.sol` → `BoundlessMarketLegacy.sol`, `IBoundlessMarket*.sol` →
+`IBoundlessMarket*Legacy.sol`) so Forge writes artifacts to distinct `out-shanghai/` directories; the
+contract **symbols** stay `BoundlessMarket` / `IBoundlessMarket*` so the build (with
+`bytecode_hash = none`) is byte-identical to the deployed audited code.
+
+The on-chain identity that ultimately matters is the deployed bytecode at the Taiko mainnet
+`BoundlessMarket` proxy's pre-upgrade implementation address:
+
+- proxy: `0xb3f5c7b4379052eade8c7f3fa6da37fb871da28b`
+- impl: `0x6c2d2c33e9a7cd0e1b39dc218f472e4bf534523b`
+
+The bytecode-parity invariant under `deployed-bytecode.hex` + `deployed-bytecode.meta.toml` (in this
+directory) is the load-bearing check.
+
+## Verification
+
+```bash
+# Bytecode parity: this tree compiles to the deployed Taiko impl (modulo immutables).
+FOUNDRY_PROFILE=shanghai forge build contracts/shanghai/legacy/BoundlessMarketLegacy.sol
+BOUNDLESS_OUT_DIR=out-shanghai BOUNDLESS_LEGACY_SNAPSHOT_DIR=contracts/shanghai/legacy \
+    uv run contracts/scripts/verify-legacy-bytecode.py
+
+# Storage-layout interop: the new shanghai market can safely delegatecall this legacy impl.
+FOUNDRY_PROFILE=shanghai forge build \
+    contracts/shanghai/variants/BoundlessMarket.sol contracts/shanghai/legacy/BoundlessMarketLegacy.sol
+BOUNDLESS_OUT_DIR=out-shanghai uv run contracts/scripts/verify-storage-layout.py
+```
+
+(Each command is a single line; the `\` continuations above are for documentation only — paste them
+as one line.)
+
+## Freeze policy
+
+Do not modify any file in this tree. Any drift between the frozen source and the deployed audited
+bytecode is a real issue — fix the drift, do not edit the verification script or this snapshot to
+mask it. The deployed implementation is reused directly as the new market's `LEGACY_IMPL`; this tree
+is the source-of-record + the interop safety check, not a redeployment target.
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+// Shanghai-compatible replacement for OpenZeppelin's Bytes.sol (v5.4.0)
+// Replaces mcopy with a manual memory copy loop for pre-Cancun EVM compatibility.
+pragma solidity ^0.8.24;
+
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+
+library Bytes {
+    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {
+        return indexOf(buffer, s, 0);
+    }
+
+    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {
+        uint256 length = buffer.length;
+        for (uint256 i = pos; i < length; ++i) {
+            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {
+                return i;
+            }
+        }
+        return type(uint256).max;
+    }
+
+    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {
+        return lastIndexOf(buffer, s, type(uint256).max);
+    }
+
+    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {
+        unchecked {
+            uint256 length = buffer.length;
+            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {
+                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {
+                    return i - 1;
+                }
+            }
+            return type(uint256).max;
+        }
+    }
+
+    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {
+        return slice(buffer, start, buffer.length);
+    }
+
+    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {
+        uint256 length = buffer.length;
+        end = Math.min(end, length);
+        start = Math.min(start, end);
+
+        uint256 len = end - start;
+        bytes memory result = new bytes(len);
+        // Manual word-by-word copy (Shanghai-compatible, no mcopy)
+        assembly ("memory-safe") {
+            let src := add(add(buffer, 0x20), start)
+            let dst := add(result, 0x20)
+            let remaining := len
+            for {} iszero(lt(remaining, 0x20)) {} {
+                mstore(dst, mload(src))
+                src := add(src, 0x20)
+                dst := add(dst, 0x20)
+                remaining := sub(remaining, 0x20)
+            }
+            if remaining {
+                let mask := sub(shl(shl(3, remaining), 1), 1)
+                mstore(dst, or(and(mload(dst), mask), and(mload(src), not(mask))))
+            }
+        }
+        return result;
+    }
+
+    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {
+        assembly ("memory-safe") {
+            value := mload(add(add(buffer, 0x20), offset))
+        }
+    }
+}
@@ -0,0 +1,29 @@
+# Reference snapshot of the BoundlessMarket implementation deployed at the Taiko
+# mainnet proxy (the pre-router market, compiled under FOUNDRY_PROFILE=shanghai).
+# Used by scripts/verify-legacy-bytecode.py to assert that contracts/shanghai/legacy/
+# compiles to the same bytecode (modulo immutable slots baked in at deploy time).
+#
+# Refresh procedure:
+#   cast code 0x6c2d2c33e9a7cd0e1b39dc218f472e4bf534523b \
+#     --rpc-url https://rpc.mainnet.taiko.xyz \
+#     > contracts/shanghai/legacy/deployed-bytecode.hex
+# and update `fetched_at_block` below.
+
+network = "taiko-mainnet"
+chain_id = 167000
+proxy = "0xb3f5c7b4379052eade8c7f3fa6da37fb871da28b"
+impl = "0x6c2d2c33e9a7cd0e1b39dc218f472e4bf534523b"
+fetched_at_block = 7982471
+
+# Constructor immutables baked into the deployed bytecode. The compiled
+# shanghai/legacy/ artifact has zeros at these positions; the verification
+# script masks them out for the body-match check and then re-extracts each
+# baked-in value and asserts it matches the expected value below.
+
+[immutables]
+VERIFIER = "0x607d196b43abc5d9BE3c7Fb8e336Ca82fec18C45"
+ASSESSOR_ID = "0x6c5a03c0785e91bc0ad0db486004116010680a03af4e712bcca3188e56694100"
+COLLATERAL_TOKEN_CONTRACT = "0xC284A781072442cc1882a8Db4573990B7B49DaC4"
+DEPRECATED_ASSESSOR_ID = "0x0000000000000000000000000000000000000000000000000000000000000000"
+DEPRECATED_ASSESSOR_EXPIRES_AT = 1773868771
+APPLICATION_VERIFIER = "0x607d196b43abc5d9BE3c7Fb8e336Ca82fec18C45"
@@ -4,7 +4,7 @@
 // as found in the LICENSE-BSL file.
 pragma solidity ^0.8.26;
 
-import {IBoundlessMarket} from "../IBoundlessMarket.sol";
+import {IBoundlessMarket} from "../IBoundlessMarketLegacy.sol";
 
 library MerkleProofish {
     // Compute the root of the Merkle tree given all of its leaves.

@@ -6,7 +6,7 @@ pragma solidity ^0.8.26;
 
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
-import {IBoundlessMarket} from "../IBoundlessMarket.sol";
+import {IBoundlessMarket} from "../IBoundlessMarketLegacy.sol";
 
 using OfferLibrary for Offer global;
 

@@ -4,7 +4,7 @@
 // as found in the LICENSE-BSL file.
 pragma solidity ^0.8.26;
 
-import {IBoundlessMarket} from "../IBoundlessMarket.sol";
+import {IBoundlessMarket} from "../IBoundlessMarketLegacy.sol";
 
 type RequestId is uint256;