@@ -4,10 +4,10 @@ Read and follow @AGENTS.md.
 
 Deploy repo: a source change regenerates `src/generated/candidate/` and merges
 without deploying. Deploying and publishing happen together at a release
-(below). `LibRaindexDeploy` is the candidate. The start-block, `networks.json`
-and `subgraph.yaml` tests read the released RaindexV6 from the newest entry of
-the generated `LibRaindexV6Released`. Address/codehash churn is routine; don't
-stop to ask about it.
+(below). `LibRaindexDeploy` is the candidate. `subgraph.yaml` holds its
+RaindexV6 address; `networks.json` lists exactly the supported networks where it
+is live, at its deploy block (fork-tested). Address/codehash churn is routine;
+don't stop to ask about it.
 
 ## Merging a PR
 
@@ -34,7 +34,8 @@ stop to ask about it.
 
 Regenerate artifacts — run the `rainix-copy-artifacts` step sequence (see that
 workflow) in `nix develop github:rainlanguage/rainix#sol-shell`. Stage ALL
-changed artifacts or `git-clean` drifts red. Nothing is deployed.
+changed artifacts or `git-clean` drifts red. Nothing is deployed. If RaindexV6
+moved, run `script/build-start-blocks.sh` (`networks.json`, `subgraph.yaml`).
 
 ## Releasing (deploy + publish)
 
@@ -46,9 +47,8 @@ changed artifacts or `git-clean` drifts red. Nothing is deployed.
    `ONCHAIN EXECUTION COMPLETE & SUCCESSFUL` (only `--verify` failed).
 2. One PR: bump `foundry.toml [external.package].version`, run
    `forge script ./script/Build.sol --sig 'cutRelease()'` (freezes `candidate/`
-   as `src/generated/<tag>/`), and if RaindexV6 moved run
-   `script/build-start-blocks.sh` (`LibRaindexV6StartBlock`, `networks.json`,
-   `subgraph.yaml`).
+   as `src/generated/<tag>/`), and if RaindexV6 was deployed run
+   `script/build-start-blocks.sh`.
 3. Merge, then push tag `sol-v<version>`. Via rainix `rainix-tag-release.yaml`
    (`package-release.yaml`) it re-runs the fork suite and `release-guard`
    (version == tag, frozen dir byte-identical to `candidate/`, clean tree, no
 
@@ -58,6 +58,7 @@ fs_permissions = [
   # `src/generated/` and the generated released-suites libs under `src/lib/`.
   { access = "read-write", path = "./src" },
   { access = "read", path = "./subgraph" },
+  { access = "read-write", path = "./subgraph/networks.json" },
   # script/Build.sol reads `[external.package].version` to name the frozen
   # per-release snapshot dir.
   { access = "read", path = "foundry.toml" },
 
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity =0.8.25;
+
+import {Script} from "forge-std-1.17.0/src/Script.sol";
+import {LibRainDeploy, SupportedNetwork} from "rain-deploy-0.1.25/src/lib/LibRainDeploy.sol";
+import {RaindexDeploySuites} from "../src/abstract/RaindexDeploySuites.sol";
+import {LibRaindexDeploy} from "../src/lib/deploy/LibRaindexDeploy.sol";
+import {LibRaindexSubgraphNetwork} from "../src/lib/deploy/LibRaindexSubgraphNetwork.sol";
+
+/// @title BuildSubgraphNetworks
+/// @notice Writes `subgraph/networks.json`: one entry per supported network
+/// where the candidate RaindexV6 is live, at its deploy block.
+contract BuildSubgraphNetworks is Script, RaindexDeploySuites {
+    function run() external {
+        address raindex = LibRaindexDeploy.RAINDEX_DEPLOYED_ADDRESS;
+        bytes32 codehash = LibRaindexDeploy.RAINDEX_DEPLOYED_CODEHASH;
+        SupportedNetwork[] memory networks = LibRainDeploy.declaredNetworkConfigs(supportedNetworks());
+        string memory json = "{}";
+        for (uint256 i = 0; i < networks.length; i++) {
+            vm.createSelectFork(networks[i].name);
+            LibRainDeploy.checkNetworkChainId(networks[i]);
+            if (raindex.codehash != codehash) {
+                continue;
+            }
+            uint256 startBlock = deployBlock(raindex, codehash);
+            string memory entryKey = string.concat(networks[i].name, ".Raindex");
+            vm.serializeAddress(entryKey, "address", raindex);
+            string memory entry = vm.serializeUint(entryKey, "startBlock", startBlock);
+            string memory dataSources = vm.serializeString(networks[i].name, "Raindex", entry);
+            json = vm.serializeString(
+                "networks", LibRaindexSubgraphNetwork.subgraphNetwork(networks[i].name), dataSources
+            );
+        }
+        vm.writeJson(json, "subgraph/networks.json");
+        vm.writeLine("subgraph/networks.json", "");
+    }
+
+    /// Not `LibBlockSearch.findDeployBlock`: on Arbitrum chains `block.number`
+    /// is the L1 block, so the head comes from the RPC. Steps back
+    /// geometrically for bounded archives.
+    function deployBlock(address target, bytes32 codehash) internal returns (uint256) {
+        uint256 high = rpcBlockNumber();
+        uint256 delta = 250000;
+        uint256 low = high > delta ? high - delta : 0;
+        vm.rollFork(low);
+        while (target.codehash == codehash) {
+            if (low == 0) {
+                return 0;
+            }
+            high = low;
+            delta *= 4;
+            low = high > delta ? high - delta : 0;
+            vm.rollFork(low);
+        }
+        while (high - low > 1) {
+            uint256 mid = (low + high) / 2;
+            vm.rollFork(mid);
+            if (target.codehash == codehash) {
+                high = mid;
+            } else {
+                low = mid;
+            }
+        }
+        return high;
+    }
+
+    function rpcBlockNumber() internal returns (uint256) {
+        bytes memory result = vm.rpc("eth_blockNumber", "[]");
+        uint256 n = 0;
+        for (uint256 i = 0; i < result.length; i++) {
+            n = (n << 8) | uint8(result[i]);
+        }
+        return n;
+    }
+}
@@ -2,133 +2,13 @@
 # SPDX-License-Identifier: LicenseRef-DCL-1.0
 # SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
 
-# Refresh the RaindexV6 deploy-block bookkeeping after a release.
-#
-# Finds the exact block at which the newest released RaindexV6 (the last entry
-# of LibRaindexV6Released) was deployed on each mainnet by binary-searching
-# `eth_getCode` over an archive RPC, then rewrites the new per-chain blocks +
-# that address into:
-#   - the RAINDEX_START_BLOCK_* constants in src/lib/deploy/LibRaindexV6StartBlock.sol
-#   - subgraph/networks.json (address + startBlock per network)
-#   - subgraph/subgraph.yaml (data source address)
-#
-# RaindexV6 is CREATE2-deployed, so its address only ever holds the one bytecode
-# it was created with: the first block with code at that address IS the deploy
-# block. Per-chain RPCs come from the foundry rpc_endpoints env vars, falling
-# back to public archive endpoints. Set BUILD_START_BLOCKS_INPUT to a file of
-# `STARTBLOCK <network> <block>` lines to skip the (RPC-bound) search, e.g. for
-# tests.
+# Rewrites subgraph/networks.json from chain (script/BuildSubgraphNetworks.sol)
+# and points subgraph/subgraph.yaml at the candidate RaindexV6. Needs an
+# archive RPC per supported network in the `[rpc_endpoints]` env vars.
 set -euo pipefail
 
-LIB="src/lib/deploy/LibRaindexV6StartBlock.sol"
-RELEASED="src/lib/LibRaindexV6Released.sol"
-NET="subgraph/networks.json"
-YAML="subgraph/subgraph.yaml"
-TAG=$(grep -aoE 'storedDeployedAddress: RaindexV6_[A-Za-z0-9_]+_DEPLOYED_ADDRESS' "$RELEASED" | tail -1 \
-    | sed -E 's/.*RaindexV6_(.+)_DEPLOYED_ADDRESS/\1/' || true)
-PTR="src/generated/${TAG}/RaindexV6.sol"
-[ -n "$TAG" ] && [ -f "$PTR" ] || { echo "could not read the newest released RaindexV6 snapshot from $RELEASED" >&2; exit 1; }
+ADDR=$(grep -aoE 'DEPLOYED_ADDRESS = address\(0x[0-9a-fA-F]{40}' src/generated/candidate/RaindexV6.sol | grep -aoE '0x[0-9a-fA-F]{40}')
+[ -n "$ADDR" ] || { echo "could not read DEPLOYED_ADDRESS from src/generated/candidate/RaindexV6.sol" >&2; exit 1; }
 
-ARB_RPC="${ARBITRUM_RPC_URL:-https://arbitrum.drpc.org}"
-BASE_RPC="${BASE_RPC_URL:-https://mainnet.base.org}"
-FLARE_RPC="${FLARE_RPC_URL:-https://flare-api.flare.network/ext/C/rpc}"
-POLY_RPC="${POLYGON_RPC_URL:-https://polygon.drpc.org}"
-
-ADDR=$(grep -aoE 'DEPLOYED_ADDRESS = address\(0x[0-9a-fA-F]{40}' "$PTR" | grep -aoE '0x[0-9a-fA-F]{40}')
-[ -n "$ADDR" ] || { echo "could not read RAINDEX_DEPLOYED_ADDRESS from $PTR" >&2; exit 1; }
-
-# rpc_call <rpc> <method> <params-json> -> raw JSON (empty on transport error).
-rpc_call() {
-    curl -fsSL -m 25 -X POST "$1" -H 'Content-Type: application/json' \
-        -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"$2\",\"params\":$3}" 2>/dev/null || true
-}
-
-# code_at <rpc> <addr> <block-dec> -> yes | no | err. Distinguishes an RPC error
-# (retryable) from a genuinely empty account, so the search never mistakes an
-# archive-window/timeout boundary for the deploy block.
-code_at() {
-    local hex res
-    hex=$(printf '0x%x' "$3")
-    res=$(rpc_call "$1" eth_getCode "[\"$2\",\"$hex\"]")
-    case "$res" in
-    *'"result":"0x"'*) echo no ;;
-    *'"result":"0x'*) echo yes ;;
-    *) echo err ;;
-    esac
-}
-
-head_of() {
-    local res
-    res=$(rpc_call "$1" eth_blockNumber "[]")
-    printf '%d' "$(printf '%s' "$res" | grep -aoE '"result":"0x[0-9a-f]+"' | grep -aoE '0x[0-9a-f]+')"
-}
-
-# find_deploy_block <rpc> <addr> -> first block with code (the CREATE2 deploy).
-find_deploy_block() {
-    local rpc=$1 addr=$2 head delta floor lo hi mid errs=0
-    head=$(head_of "$rpc")
-    [ "${head:-0}" -gt 0 ] || { echo "could not read head block from $rpc" >&2; return 1; }
-    [ "$(code_at "$rpc" "$addr" "$head")" = "yes" ] || { echo "no code for $addr at head on $rpc" >&2; return 1; }
-
-    # Walk a lower bound back in growing steps until the address has no code,
-    # so the search holds however long ago the deploy happened.
-    delta=250000
-    floor=$(( head > delta ? head - delta : 1 ))
-    while [ "$floor" -gt 1 ] && [ "$(code_at "$rpc" "$addr" "$floor")" = "yes" ]; do
-        delta=$(( delta * 4 ))
-        floor=$(( head > delta ? head - delta : 1 ))
-    done
-
-    lo=$floor; hi=$head
-    while [ "$lo" -lt "$hi" ]; do
-        mid=$(( (lo + hi) / 2 ))
-        case "$(code_at "$rpc" "$addr" "$mid")" in
-        yes) hi=$mid ;;
-        no) lo=$(( mid + 1 )) ;;
-        err)
-            errs=$(( errs + 1 ))
-            [ "$errs" -gt 12 ] && { echo "too many RPC errors searching $rpc" >&2; return 1; }
-            sleep 2
-            ;;
-        esac
-    done
-
-    # Verify the boundary on a second, independent read to catch load-balanced
-    # archives that answer the same historical block inconsistently.
-    [ "$(code_at "$rpc" "$addr" "$lo")" = "yes" ] || { echo "boundary check failed: no code at $lo on $rpc" >&2; return 1; }
-    [ "$lo" -le 1 ] || [ "$(code_at "$rpc" "$addr" "$(( lo - 1 ))")" = "no" ] \
-        || { echo "boundary check failed: code already at $(( lo - 1 )) on $rpc" >&2; return 1; }
-    echo "$lo"
-}
-
-if [ -n "${BUILD_START_BLOCKS_INPUT:-}" ]; then
-    OUT=$(cat "$BUILD_START_BLOCKS_INPUT")
-else
-    echo "finding RaindexV6 ($ADDR) deploy block on each chain..." >&2
-    OUT="STARTBLOCK arbitrum $(find_deploy_block "$ARB_RPC" "$ADDR")
-STARTBLOCK base $(find_deploy_block "$BASE_RPC" "$ADDR")
-STARTBLOCK flare $(find_deploy_block "$FLARE_RPC" "$ADDR")
-STARTBLOCK polygon $(find_deploy_block "$POLY_RPC" "$ADDR")"
-fi
-
-get() { printf '%s\n' "$OUT" | grep -aoE "STARTBLOCK $1 [0-9]+" | grep -aoE '[0-9]+$' | head -1; }
-ARB=$(get arbitrum); BASE=$(get base); FLARE=$(get flare); POLY=$(get polygon)
-for pair in "arbitrum:$ARB" "base:$BASE" "flare:$FLARE" "polygon:$POLY"; do
-    [ -n "${pair#*:}" ] || { echo "missing start block for ${pair%%:*}; finder output:" >&2; printf '%s\n' "$OUT" >&2; exit 1; }
-done
-
-sed -i -E "s/(RAINDEX_START_BLOCK_ARBITRUM = )[0-9]+/\1${ARB}/" "$LIB"
-sed -i -E "s/(RAINDEX_START_BLOCK_BASE = )[0-9]+/\1${BASE}/" "$LIB"
-sed -i -E "s/(RAINDEX_START_BLOCK_FLARE = )[0-9]+/\1${FLARE}/" "$LIB"
-sed -i -E "s/(RAINDEX_START_BLOCK_POLYGON = )[0-9]+/\1${POLY}/" "$LIB"
-
-sed -i -E "s/(address: \")0x[0-9a-fA-F]+(\")/\1${ADDR}\2/" "$YAML"
-
-jq --arg addr "$ADDR" --argjson arb "$ARB" --argjson base "$BASE" --argjson flare "$FLARE" --argjson poly "$POLY" '
-    ."arbitrum-one".Raindex = {address: $addr, startBlock: $arb}
-    | .matic.Raindex = {address: $addr, startBlock: $poly}
-    | .base.Raindex = {address: $addr, startBlock: $base}
-    | .flare.Raindex = {address: $addr, startBlock: $flare}
-' "$NET" >"${NET}.tmp" && mv "${NET}.tmp" "$NET"
-
-echo "start blocks: arbitrum=${ARB} base=${BASE} flare=${FLARE} polygon=${POLY}  address=${ADDR}"
+forge script script/BuildSubgraphNetworks.sol
+sed -i -E "s/(address: \")0x[0-9a-fA-F]+(\")/\1${ADDR}\2/" subgraph/subgraph.yaml
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+import {LibRainDeploy} from "rain-deploy-0.1.25/src/lib/LibRainDeploy.sol";
+
+/// @title LibRaindexSubgraphNetwork
+/// @notice The subgraph network each deploy network is indexed under, as the
+/// `subgraph/networks.json` key and the Ormi network id
+/// (https://ormilabs.com/docs/supported-chains/subgraphs).
+library LibRaindexSubgraphNetwork {
+    /// @param network The deploy network with no subgraph network.
+    error NoSubgraphNetwork(string network);
+
+    /// @param network A deploy network, as an `[rpc_endpoints]` alias.
+    /// @return The subgraph network it is indexed under.
+    function subgraphNetwork(string memory network) internal pure returns (string memory) {
+        bytes32 name = keccak256(bytes(network));
+        if (name == keccak256(bytes(LibRainDeploy.ARBITRUM_ONE))) return "arbitrum-one";
+        if (name == keccak256(bytes(LibRainDeploy.BASE))) return "base";
+        if (name == keccak256(bytes(LibRainDeploy.BASE_SEPOLIA))) return "base-sepolia";
+        if (name == keccak256(bytes(LibRainDeploy.BSC))) return "bsc";
+        if (name == keccak256(bytes(LibRainDeploy.ETHEREUM))) return "mainnet";
+        if (name == keccak256(bytes(LibRainDeploy.FLARE))) return "flare";
+        if (name == keccak256(bytes(LibRainDeploy.HYPEREVM))) return "hyperevm";
+        if (name == keccak256(bytes(LibRainDeploy.POLYGON))) return "matic";
+        if (name == keccak256(bytes(LibRainDeploy.ROBINHOOD))) return "robinhood";
+        revert NoSubgraphNetwork(network);
+    }
+}
@@ -1,32 +1 @@
-{
-  "arbitrum-one": {
-    "Raindex": {
-      "address": "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20",
-      "startBlock": 473899359
-    }
-  },
-  "matic": {
-    "Raindex": {
-      "address": "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20",
-      "startBlock": 88573024
-    }
-  },
-  "base": {
-    "Raindex": {
-      "address": "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20",
-      "startBlock": 47387582
-    }
-  },
-  "flare": {
-    "Raindex": {
-      "address": "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20",
-      "startBlock": 63011168
-    }
-  },
-  "robinhood": {
-    "Raindex": {
-      "address": "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20",
-      "startBlock": 59557818
-    }
-  }
-}
+{}
@@ -6,7 +6,7 @@ dataSources:
     name: Raindex
     network: sepolia
     source:
-      address: "0x37FC0EFec37D19f8A221aa4F8F7600C9ba2AcD20"
+      address: "0x91b95120D085Aa99C05167f3767eB63460c1dCaC"
       abi: Raindex
       startBlock: 0
     mapping:
 
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity =0.8.25;
+
+import {Test} from "forge-std-1.17.0/src/Test.sol";
+import {RaindexDeploySuites} from "src/abstract/RaindexDeploySuites.sol";
+import {LibRaindexSubgraphNetwork} from "src/lib/deploy/LibRaindexSubgraphNetwork.sol";
+
+/// @title LibRaindexSubgraphNetworkSubgraphNetworkTest
+/// @notice Every supported network has its own subgraph network, and any other
+/// name is refused.
+contract LibRaindexSubgraphNetworkSubgraphNetworkTest is Test, RaindexDeploySuites {
+    function subgraphNetworkExternal(string memory network) external pure returns (string memory) {
+        return LibRaindexSubgraphNetwork.subgraphNetwork(network);
+    }
+
+    function testSubgraphNetworkDistinctPerSupportedNetwork() external view {
+        string[] memory networks = supportedNetworks();
+        for (uint256 i = 0; i < networks.length; i++) {
+            string memory a = LibRaindexSubgraphNetwork.subgraphNetwork(networks[i]);
+            for (uint256 j = i + 1; j < networks.length; j++) {
+                assertNotEq(a, LibRaindexSubgraphNetwork.subgraphNetwork(networks[j]), networks[i]);
+            }
+        }
+    }
+
+    function testSubgraphNetworkUnknown(string memory network) external {
+        string[] memory networks = supportedNetworks();
+        for (uint256 i = 0; i < networks.length; i++) {
+            vm.assume(keccak256(bytes(network)) != keccak256(bytes(networks[i])));
+        }
+        vm.expectRevert(abi.encodeWithSelector(LibRaindexSubgraphNetwork.NoSubgraphNetwork.selector, network));
+        this.subgraphNetworkExternal(network);
+    }
+}