@somnia-chain/contracts-sdk 0.1.0 → 0.3.0

package/README.md

@@ -8,48 +8,111 @@ reconciled against.
 npm install @somnia-chain/contracts-sdk
 ```
 
+The package is split by delivery mechanism, deliberately. Addresses and chain
+information are small and change on every deploy — they live in the root
+entry, ~170 kB of data. ABIs are megabytes that change only when contracts
+change — they ship one module per contract, so a client bundle carries exactly
+the ABIs it imports and a bundle that needs only addresses carries none.
+
+## Addresses and networks — the root entry
+
 ```ts
-import { getAddress, getAbi, getContract, registry } from "@somnia-chain/contracts-sdk";
+import { address, tryAddress, contracts, identify } from "@somnia-chain/contracts-sdk";
+
+address("somnia-mainnet", "somnia-markets", "MarketsCore");
+// throws on unknown names — the "this must exist" form; every slug and
+// name is autocompleted and the address is a literal type
+
+tryAddress("hideki-testnet", "somnia-markets", "MarketsCore"); // Address | null
+// the "is it deployed here?" form — projects do not span every network
 
-getAddress("somnia-mainnet", "somnia-markets", "MarketsCore");
-// -> "0x…", typed as the literal, with every slug and name autocompleted
+contracts("somnia-mainnet", "somnia-markets"); // enumerate, for admin screens
+identify("somnia-mainnet", "0x1a47…");         // reverse lookup: project, name, kind
 
-const { address, abi } = getContract("somnia-mainnet", "somnia-markets", "MarketsCore");
-// abi is `as const` — viem infers function names and argument types from it
+allContracts();
+// every current deployment across every live network — the dashboard form.
+// Retired networks and superseded deployments are excluded by default, so a
+// wiped testnet's addresses cannot be rendered as current by forgetting to
+// filter: { includeRetiredNetworks, includeSuperseded, project } to widen it.
 ```
 
-The whole tree is also there as one constant, `registry`, keyed
-network → project → contract, plus one exported constant per network
-(`somniaMainnet`, …) and `networks` with every network's chain information.
+Entries carry `address`, `kind`, `status`, `version`, and `contract` — the
+Solidity contract name, where a source stated one. `kind` and `status` are
+unions (`DeploymentKind`, `ContractStatus`), not `string`.
 
-For viem, `toChain` builds a `Chain`-shaped object — the registry records no
-public RPC endpoint, so you bring your own:
+Networks: `networks` (all, retired included), `network(slug)`,
+`liveNetworks()`, and `toChain(slug, { rpcUrl })` for a viem-`Chain`-shaped
+object — you supply the RPC URL, the registry deliberately records no public
+endpoint. `registryVersion` says which commit the data came from.
+
+### Chain IDs are not unique
+
+Networks are keyed by **slug**, never by chain id: a testnet regenesis reuses
+the chain id with none of the state, so one id can name two networks with
+different contracts at identical addresses.
 
 ```ts
-import { createPublicClient, http } from "viem";
-import { toChain } from "@somnia-chain/contracts-sdk";
+networksByChainId(50383); // -> both hideki testnets — an array, deliberately
+```
 
-const chain = toChain("somnia-mainnet", { rpcUrl: "https://your-rpc" });
-const client = createPublicClient({ chain, transport: http() });
+## ABIs — typed per contract, or the whole corpus
+
+```ts
+// Build-time, typed, tree-shakeable: one module per contract.
+import { SafeAbi } from "@somnia-chain/contracts-sdk/abi/somnia-accounts/Safe";
+// as-const literal — viem infers function names and argument types
+
+// Runtime, whole corpus (~1 MB — server/admin paths):
+import { abiFor, abiByHash, verifyAbi, writeFunctions } from "@somnia-chain/contracts-sdk/abis";
+
+abiFor("somnia-mainnet", "somnia-markets", "MarketsCore"); // Abi | null
+abiByHash("sha256:…");        // historical ABIs too — decode an old tx correctly
+verifyAbi("sha256:…", abi);   // sha256 over key-sorted compact JSON — verify, don't trust filenames
+writeFunctions("somnia-mainnet", "somnia-markets", "MarketsCore");
+// all state-changing functions — allowlists are application policy, not deployment facts
+
+allContractsWithAbi();
+// allContracts() with each ABI resolved to `abiJson` — addresses, networks and
+// ABIs in one call. Costs the whole corpus, which is why it lives here.
 ```
 
-Exported types: `Registry`, `NetworkSlug`, `ProjectSlug`, `ContractName`,
-`ContractEntry`, `NetworkInfo`, `Address`.
+### Not every deployment has an ABI
+
+`abiFor` returns `null`, and `abiJson` is `null`, for a real share of what the
+registry holds — around half, concentrated in the testnets. That is a fact
+about the records, not a gap in the package: the registry records a contract
+name only where a broadcast log stated it or the repo declared one, and an ABI
+is looked up by that name. Deployments created from a shared script as
+per-asset instances — `BTC_reader`, `ADA_oracle` — name a role rather than a
+contract, so they carry an address and no ABI. `contract` is set on exactly
+the entries that have one, so it is the field to branch on.
 
-## Chain IDs are not unique
+## Decoding calldata
 
-Somnia networks are keyed by **slug**, never by chain id: a testnet regenesis
-reuses the chain id with none of the state, so one id can name two networks
-with different contracts at identical addresses. If an id is all you have:
+Requires `viem` (optional peer dependency; only this entry needs it).
 
 ```ts
-import { getNetworksByChainId } from "@somnia-chain/contracts-sdk";
+import { decodeCall, decodeBySelector } from "@somnia-chain/contracts-sdk/decode";
 
-getNetworksByChainId(50383); // -> both hideki testnets; filter on `status`
+const call = decodeCall("somnia-mainnet", to, data);
+// identifies the target, decodes against its recorded ABI, and recurses
+// through Safe execTransaction / MultiSend, Multicall3 and upgradeToAndCall —
+// what a signer staring at hex actually needs
+
+if (call.status === "decoded") call.signature;   // "transfer(address,uint256)"
+else call.selector;                              // undecoded is a variant, not an error
+
+decodeBySelector(data); // 4-byte fallback across every ABI the registry holds
 ```
 
 ## Versioning
 
-The package is a snapshot of the registry, published when its data moves.
+The package is a snapshot of the registry, and it is published when that
+snapshot changes rather than when someone remembers to publish it. The
+reconciliation lane compares the surface it would generate against the one the
+last release shipped, and cuts a patch version whenever addresses, ABIs or
+chain information moved — so a contract deployed today reaches npm on the next
+lane run. Minor and major versions are cut by hand, for API changes.
+
 Update the dependency to pick up newly deployed contracts — nothing is fetched
 at runtime.

package/dist/abis.d.ts

@@ -0,0 +1,52 @@
+import { abisByHash } from "./gen/abis-index.js";
+import { type AllContractsOptions, type ListedContract, type NetworkSlug } from "./index.js";
+export { abisByHash };
+export { abiDigest, verifyAbi } from "./digest.js";
+/**
+ * Everything in this module drags the full ABI corpus (about a megabyte)
+ * into the importing bundle — that is its job; decoders need the whole
+ * corpus. A client bundle that needs one contract's ABI typed should import
+ * its `./abi/<project>/<Contract>` module instead, and one that needs only
+ * addresses should stay on the package root.
+ */
+export interface AbiItem {
+    type: string;
+    name?: string;
+    inputs?: readonly unknown[];
+    outputs?: readonly unknown[];
+    stateMutability?: string;
+    [key: string]: unknown;
+}
+export type AbiFunction = AbiItem & {
+    type: "function";
+};
+/** The recorded ABI for one deployment, or null where the registry has none — including an unknown name, because the decoder path treats absence as an answer. For literal types, import the contract's `./abi/*` module. */
+export declare function abiFor(net: NetworkSlug, project: string, name: string): readonly AbiItem[] | null;
+/** Resolve a digest — including a historical one no current deployment points at — to its ABI. */
+export declare function abiByHash(digest: string): readonly AbiItem[] | null;
+export interface ResolvedContract extends ListedContract {
+    /**
+     * The recorded ABI, or null where the registry has none. Null is common and
+     * is a fact about the registry, not an error: an ABI is recorded only where
+     * a source named the contract, so per-asset instances deployed from a shared
+     * script — `BTC_reader`, `ADA_router` — usually carry an address and no ABI.
+     */
+    abiJson: readonly AbiItem[] | null;
+}
+/**
+ * Every current deployment with its ABI already resolved — addresses,
+ * networks and ABIs in one call.
+ *
+ * This is the whole-corpus convenience, and it costs the whole corpus: it
+ * lives here rather than in the root entry so that importing it is a decision.
+ * A server or admin surface rendering every contract wants exactly this; a
+ * client bundle wants `allContracts()` from the root and a per-contract
+ * `./abi/*` module for the one ABI it actually needs.
+ */
+export declare function allContractsWithAbi(opts?: AllContractsOptions): ResolvedContract[];
+/**
+ * The state-changing functions of one deployment's ABI. Deliberately the
+ * whole set: trimming it to an allowlist is operational policy, and policy
+ * belongs to the application, not to a registry of deployment facts.
+ */
+export declare function writeFunctions(net: NetworkSlug, project: string, name: string): AbiFunction[];

package/dist/abis.js

@@ -0,0 +1,42 @@
+import { abisByHash } from "./gen/abis-index.js";
+import { allContracts, registry, } from "./index.js";
+export { abisByHash };
+export { abiDigest, verifyAbi } from "./digest.js";
+/** The recorded ABI for one deployment, or null where the registry has none — including an unknown name, because the decoder path treats absence as an answer. For literal types, import the contract's `./abi/*` module. */
+export function abiFor(net, project, name) {
+    const book = registry[net]?.contracts;
+    const digest = book?.[project]?.[name]?.abi;
+    return digest ? abiByHash(digest) : null;
+}
+/** Resolve a digest — including a historical one no current deployment points at — to its ABI. */
+export function abiByHash(digest) {
+    return abisByHash[digest] ?? null;
+}
+/**
+ * Every current deployment with its ABI already resolved — addresses,
+ * networks and ABIs in one call.
+ *
+ * This is the whole-corpus convenience, and it costs the whole corpus: it
+ * lives here rather than in the root entry so that importing it is a decision.
+ * A server or admin surface rendering every contract wants exactly this; a
+ * client bundle wants `allContracts()` from the root and a per-contract
+ * `./abi/*` module for the one ABI it actually needs.
+ */
+export function allContractsWithAbi(opts = {}) {
+    return allContracts(opts).map((entry) => ({
+        ...entry,
+        abiJson: entry.abi ? abiByHash(entry.abi) : null,
+    }));
+}
+/**
+ * The state-changing functions of one deployment's ABI. Deliberately the
+ * whole set: trimming it to an allowlist is operational policy, and policy
+ * belongs to the application, not to a registry of deployment facts.
+ */
+export function writeFunctions(net, project, name) {
+    const abi = abiFor(net, project, name);
+    if (!abi)
+        return [];
+    return abi.filter((item) => item.type === "function" &&
+        (item.stateMutability === "nonpayable" || item.stateMutability === "payable"));
+}

package/dist/decode-core.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Calldata decoding against the registry's ABI corpus, engine only: the
+ * dependencies come in through `DecoderDeps`, so the engine is a pure
+ * function of them and testable without the generated data modules.
+ * `./decode` wires it to the real registry.
+ */
+export type Hex = `0x${string}`;
+export interface DecodedIdentity {
+    project: string;
+    name: string;
+    kind: string;
+}
+/**
+ * Undecoded is a variant, not an error: calldata to a contract the registry
+ * has never seen is normal on a permissionless chain, and the caller's UI
+ * has to render that state either way.
+ */
+export type DecodedCall = {
+    status: "decoded";
+    to?: Hex;
+    contract?: DecodedIdentity;
+    functionName: string;
+    signature: string;
+    args: readonly unknown[];
+    /** Other registry signatures sharing the selector; present when the match was by selector and ambiguous. */
+    alternatives?: string[];
+    /** Nested decodes: Safe execTransaction/multiSend, Multicall3, upgradeToAndCall. */
+    calls?: DecodedCall[];
+} | {
+    status: "undecoded";
+    to?: Hex;
+    selector: Hex | null;
+    data: Hex;
+};
+export interface DecoderDeps {
+    /** The recorded ABI for a deployment, or null. */
+    abiFor(net: string, project: string, name: string): readonly unknown[] | null;
+    /** Reverse lookup of an address on a network. */
+    identify(net: string, addr: string): {
+        project: string;
+        name: string;
+        kind: string;
+    } | null;
+    /** The whole ABI corpus, for the selector fallback. */
+    allAbis(): Iterable<readonly unknown[]>;
+}
+export interface Decoder {
+    decodeCall(net: string, to: Hex, data: Hex): DecodedCall;
+    decodeBySelector(data: Hex): DecodedCall;
+}
+export declare function createDecoder(deps: DecoderDeps): Decoder;

package/dist/decode-core.js

@@ -0,0 +1,145 @@
+import { decodeFunctionData, toFunctionSelector } from "viem";
+export function createDecoder(deps) {
+    let selectorIndex = null;
+    function bySelector() {
+        if (selectorIndex)
+            return selectorIndex;
+        selectorIndex = new Map();
+        const seen = new Set();
+        for (const abi of deps.allAbis()) {
+            for (const item of abi) {
+                if (item.type !== "function")
+                    continue;
+                let selector;
+                let signature;
+                try {
+                    selector = toFunctionSelector(item);
+                    signature = fnSignature(item);
+                }
+                catch {
+                    continue;
+                }
+                const key = `${selector} ${signature}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const list = selectorIndex.get(selector) ?? [];
+                list.push(item);
+                selectorIndex.set(selector, list);
+            }
+        }
+        return selectorIndex;
+    }
+    function tryDecode(abi, data) {
+        try {
+            const { functionName, args } = decodeFunctionData({ abi: abi, data });
+            const item = abi.find((i) => i.type === "function" && i.name === functionName && toFunctionSelector(i) === data.slice(0, 10));
+            return item ? { functionName, args: args ?? [], item } : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    function nested(net, decoded) {
+        const { functionName, args } = decoded;
+        // Safe execTransaction(to, value, data, operation, …) — one wrapped call.
+        if (functionName === "execTransaction" && args.length >= 4) {
+            return [decodeCall(net, args[0], args[2])];
+        }
+        // Safe MultiSend multiSend(bytes) — packed (operation, to, value, dataLength, data)*.
+        if (functionName === "multiSend" && typeof args[0] === "string") {
+            return decodeMultiSendBlob(net, args[0]);
+        }
+        // Multicall3: aggregate((address,bytes)[]), tryAggregate(bool,(address,bytes)[]), aggregate3((address,bool,bytes)[]), aggregate3Value(…).
+        if (/^(aggregate3?(Value)?|tryAggregate(3)?|tryBlockAndAggregate|blockAndAggregate)$/.test(functionName)) {
+            const calls = args.find(Array.isArray);
+            if (calls) {
+                return calls
+                    .filter((c) => c.target !== undefined && c.callData !== undefined)
+                    .map((c) => decodeCall(net, c.target, c.callData));
+            }
+        }
+        // ERC-1967 upgradeToAndCall(newImplementation, data) — the payload runs against the new implementation.
+        if (functionName === "upgradeToAndCall" && args.length >= 2 && typeof args[1] === "string" && args[1].length > 2) {
+            return [decodeCall(net, args[0], args[1])];
+        }
+        return undefined;
+    }
+    function decodeMultiSendBlob(net, blob) {
+        const out = [];
+        const hex = blob.slice(2);
+        let i = 0;
+        // operation: 1 byte, to: 20, value: 32, dataLength: 32, data: dataLength.
+        while (i + 170 <= hex.length) {
+            const to = `0x${hex.slice(i + 2, i + 42)}`;
+            const dataLength = parseInt(hex.slice(i + 106, i + 170), 16);
+            if (!Number.isFinite(dataLength) || i + 170 + dataLength * 2 > hex.length)
+                break;
+            const data = `0x${hex.slice(i + 170, i + 170 + dataLength * 2)}`;
+            out.push(decodeCall(net, to, data));
+            i += 170 + dataLength * 2;
+        }
+        return out;
+    }
+    function decodeCall(net, to, data) {
+        const selector = data.length >= 10 ? data.slice(0, 10) : null;
+        const identity = deps.identify(net, to);
+        if (identity) {
+            const abi = deps.abiFor(net, identity.project, identity.name);
+            if (abi) {
+                const decoded = tryDecode(abi, data);
+                if (decoded) {
+                    const calls = nested(net, decoded);
+                    return {
+                        status: "decoded",
+                        to,
+                        contract: { project: identity.project, name: identity.name, kind: identity.kind },
+                        functionName: decoded.functionName,
+                        signature: fnSignature(decoded.item),
+                        args: decoded.args,
+                        ...(calls ? { calls } : {}),
+                    };
+                }
+            }
+        }
+        const fallback = decodeBySelector(data);
+        if (fallback.status === "decoded") {
+            return { ...fallback, to, ...(identity ? { contract: identity } : {}) };
+        }
+        return { status: "undecoded", to, selector, data };
+    }
+    function decodeBySelector(data) {
+        const selector = data.length >= 10 ? data.slice(0, 10) : null;
+        if (!selector)
+            return { status: "undecoded", selector: null, data };
+        const candidates = bySelector().get(selector) ?? [];
+        for (const item of candidates) {
+            const decoded = tryDecode([item], data);
+            if (!decoded)
+                continue;
+            const alternatives = candidates.filter((c) => c !== item).map(fnSignature);
+            const calls = nested("", decoded);
+            return {
+                status: "decoded",
+                functionName: decoded.functionName,
+                signature: fnSignature(item),
+                args: decoded.args,
+                ...(alternatives.length > 0 ? { alternatives } : {}),
+                ...(calls ? { calls } : {}),
+            };
+        }
+        return { status: "undecoded", selector, data };
+    }
+    return { decodeCall, decodeBySelector };
+}
+function fnSignature(item) {
+    const inputs = (item.inputs ?? []).map((input) => formatParam(input));
+    return `${item.name}(${inputs.join(",")})`;
+}
+function formatParam(param) {
+    if (param.type.startsWith("tuple") && param.components) {
+        const inner = param.components.map((c) => formatParam(c)).join(",");
+        return `(${inner})${param.type.slice(5)}`;
+    }
+    return param.type;
+}

package/dist/decode.d.ts

@@ -0,0 +1,15 @@
+import { type NetworkSlug } from "./index.js";
+import { createDecoder, type DecodedCall, type Decoder, type Hex } from "./decode-core.js";
+export { createDecoder };
+export type { DecodedCall, Decoder, Hex };
+/**
+ * Decode calldata sent to an address on a network: reverse-lookup the
+ * contract, decode against its recorded ABI, and recurse through the
+ * wrappers a signer actually meets — Safe execTransaction and MultiSend,
+ * Multicall3 aggregates, upgradeToAndCall payloads. Falls back to a
+ * selector search across every registry ABI; an `undecoded` result is a
+ * normal variant, not an error.
+ */
+export declare function decodeCall(net: NetworkSlug, to: Hex, data: Hex): DecodedCall;
+/** Decode calldata by selector alone, against every ABI the registry holds. */
+export declare function decodeBySelector(data: Hex): DecodedCall;

package/dist/decode.js

@@ -0,0 +1,30 @@
+import { abisByHash } from "./gen/abis-index.js";
+import { abiFor } from "./abis.js";
+import { identify, registry } from "./index.js";
+import { createDecoder } from "./decode-core.js";
+export { createDecoder };
+/**
+ * The registry-wired decoder. Importing this module pulls the full ABI
+ * corpus into the bundle and requires `viem` (an optional peer dependency
+ * everywhere else in the package).
+ */
+const decoder = createDecoder({
+    abiFor: (net, project, name) => abiFor(net, project, name),
+    identify: (net, addr) => (net in registry ? identify(net, addr) : null),
+    allAbis: () => Object.values(abisByHash),
+});
+/**
+ * Decode calldata sent to an address on a network: reverse-lookup the
+ * contract, decode against its recorded ABI, and recurse through the
+ * wrappers a signer actually meets — Safe execTransaction and MultiSend,
+ * Multicall3 aggregates, upgradeToAndCall payloads. Falls back to a
+ * selector search across every registry ABI; an `undecoded` result is a
+ * normal variant, not an error.
+ */
+export function decodeCall(net, to, data) {
+    return decoder.decodeCall(net, to, data);
+}
+/** Decode calldata by selector alone, against every ABI the registry holds. */
+export function decodeBySelector(data) {
+    return decoder.decodeBySelector(data);
+}

package/dist/digest.d.ts

@@ -0,0 +1,11 @@
+import type { AbiDigest } from "./index.js";
+/**
+ * The registry's canonical ABI digest: sha256 over the ABI's canonical JSON —
+ * keys recursively sorted, compact separators, UTF-8. This mirrors the
+ * registry's own `abiDigest` exactly; the sorting is the part a consumer
+ * cannot guess from the digest alone, which is why the function is exported
+ * instead of being something everyone reverse-engineers.
+ */
+export declare function abiDigest(abi: readonly unknown[]): AbiDigest;
+/** Does this ABI hash to this digest? Verify instead of trusting a filename. */
+export declare function verifyAbi(digest: string, abi: readonly unknown[]): boolean;

package/dist/digest.js

@@ -0,0 +1,33 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+/**
+ * The registry's canonical ABI digest: sha256 over the ABI's canonical JSON —
+ * keys recursively sorted, compact separators, UTF-8. This mirrors the
+ * registry's own `abiDigest` exactly; the sorting is the part a consumer
+ * cannot guess from the digest alone, which is why the function is exported
+ * instead of being something everyone reverse-engineers.
+ */
+export function abiDigest(abi) {
+    const canonical = JSON.stringify(sortKeys(abi));
+    const bytes = sha256(new TextEncoder().encode(canonical));
+    let hex = "";
+    for (const b of bytes)
+        hex += b.toString(16).padStart(2, "0");
+    return `sha256:${hex}`;
+}
+/** Does this ABI hash to this digest? Verify instead of trusting a filename. */
+export function verifyAbi(digest, abi) {
+    return abiDigest(abi) === digest;
+}
+// Arrays keep their order — in an ABI, parameter order is meaning.
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === "object" && value.constructor === Object) {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            out[key] = sortKeys(value[key]);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/enumerate.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Enumeration over the address books, with no generated data in sight.
+ *
+ * Split out for the same reason `decode-core.ts` is: the generated modules are
+ * a build product, so anything that imports them cannot be tested until they
+ * exist — and the filtering here is precisely what a dashboard relies on to
+ * not render a wiped testnet's addresses as current. Structural types rather
+ * than the package's public ones, so this file depends on nothing.
+ */
+export interface BookEntry {
+    address: string;
+    kind: string;
+    status: string;
+    version: string;
+    contract?: string;
+    implementation?: string;
+    startBlock?: number;
+    abi?: string;
+}
+export interface NetworkBook {
+    status: string;
+    contracts: Record<string, Record<string, BookEntry>>;
+}
+export type Books = Record<string, NetworkBook>;
+export interface Listed extends BookEntry {
+    network: string;
+    project: string;
+    name: string;
+}
+export interface EnumerateOptions {
+    includeRetiredNetworks?: boolean;
+    includeSuperseded?: boolean;
+    project?: string;
+}
+/** One network's deployments, optionally one project's. Throws on an unknown slug. */
+export declare function listContracts(books: Books, net: string, project?: string): Listed[];
+/**
+ * Every current deployment across every live network.
+ *
+ * Both exclusions are defaults rather than the caller's job on purpose: a
+ * retired network's addresses answer on a chain that was wiped, and a
+ * superseded deployment is one a later release replaced. Requiring each call
+ * site to remember that is how one of them forgets.
+ */
+export declare function listAll(books: Books, opts?: EnumerateOptions): Listed[];
+/**
+ * Address -> deployment, for one network.
+ *
+ * Proxy implementations resolve to their proxy's identity so that a signer
+ * looking at an implementation address learns which proxy it serves. The
+ * proxy's own entry always wins: `set` runs for every deployment first, and
+ * an implementation only claims an address nothing has claimed already.
+ */
+export declare function buildIdentityIndex(books: Books, net: string): Map<string, Listed & {
+    matchedBy: "address" | "implementation";
+}>;

package/dist/enumerate.js

@@ -0,0 +1,70 @@
+/**
+ * Enumeration over the address books, with no generated data in sight.
+ *
+ * Split out for the same reason `decode-core.ts` is: the generated modules are
+ * a build product, so anything that imports them cannot be tested until they
+ * exist — and the filtering here is precisely what a dashboard relies on to
+ * not render a wiped testnet's addresses as current. Structural types rather
+ * than the package's public ones, so this file depends on nothing.
+ */
+/** One network's deployments, optionally one project's. Throws on an unknown slug. */
+export function listContracts(books, net, project) {
+    const book = books[net];
+    if (!book)
+        throw new Error(`unknown network: ${net}`);
+    const out = [];
+    for (const [proj, entries] of Object.entries(book.contracts)) {
+        if (project !== undefined && proj !== project)
+            continue;
+        for (const [name, entry] of Object.entries(entries)) {
+            out.push({ network: net, project: proj, name, ...entry });
+        }
+    }
+    return out;
+}
+/**
+ * Every current deployment across every live network.
+ *
+ * Both exclusions are defaults rather than the caller's job on purpose: a
+ * retired network's addresses answer on a chain that was wiped, and a
+ * superseded deployment is one a later release replaced. Requiring each call
+ * site to remember that is how one of them forgets.
+ */
+export function listAll(books, opts = {}) {
+    const out = [];
+    for (const net of Object.keys(books).sort()) {
+        if (!opts.includeRetiredNetworks && books[net].status !== "live")
+            continue;
+        for (const entry of listContracts(books, net, opts.project)) {
+            if (!opts.includeSuperseded && entry.status !== "active")
+                continue;
+            out.push(entry);
+        }
+    }
+    return out.sort((a, b) => a.network.localeCompare(b.network) ||
+        a.project.localeCompare(b.project) ||
+        a.name.localeCompare(b.name));
+}
+/**
+ * Address -> deployment, for one network.
+ *
+ * Proxy implementations resolve to their proxy's identity so that a signer
+ * looking at an implementation address learns which proxy it serves. The
+ * proxy's own entry always wins: `set` runs for every deployment first, and
+ * an implementation only claims an address nothing has claimed already.
+ */
+export function buildIdentityIndex(books, net) {
+    const index = new Map();
+    const entries = listContracts(books, net);
+    for (const entry of entries) {
+        index.set(entry.address.toLowerCase(), { ...entry, matchedBy: "address" });
+    }
+    for (const entry of entries) {
+        if (!entry.implementation)
+            continue;
+        const key = entry.implementation.toLowerCase();
+        if (!index.has(key))
+            index.set(key, { ...entry, matchedBy: "implementation" });
+    }
+    return index;
+}

package/dist/gen/abi/deployer-contract/ProtocolDeployer.d.ts

@@ -0,0 +1,2 @@
+export { abi_d407c410234a as ProtocolDeployerAbi } from "../../abis/d407c410234a.js";
+export declare const ProtocolDeployerAbiDigest = "sha256:d407c410234ab956d2e27c73379269aeeb640dda07ad92687312da893af03888";

package/dist/gen/abi/deployer-contract/ProtocolDeployer.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_d407c410234a as ProtocolDeployerAbi } from "../../abis/d407c410234a.js";
+export const ProtocolDeployerAbiDigest = "sha256:d407c410234ab956d2e27c73379269aeeb640dda07ad92687312da893af03888";

package/dist/gen/abi/somnia-accounts/CompatibilityFallbackHandler.d.ts

@@ -0,0 +1,2 @@
+export { abi_83cdff66efa0 as CompatibilityFallbackHandlerAbi } from "../../abis/83cdff66efa0.js";
+export declare const CompatibilityFallbackHandlerAbiDigest = "sha256:83cdff66efa0922471f2e14c996ffeb2e5d54d8e0f0a2a841cb8b07a1b1ef10f";