@somnia-chain/contracts-sdk 0.1.0 → 0.2.0

package/README.md

@@ -8,44 +8,76 @@ 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
 
-getAddress("somnia-mainnet", "somnia-markets", "MarketsCore");
-// -> "0x…", typed as the literal, with every slug and name autocompleted
+tryAddress("hideki-testnet", "somnia-markets", "MarketsCore"); // Address | null
+// the "is it deployed here?" form — projects do not span every network
 
-const { address, abi } = getContract("somnia-mainnet", "somnia-markets", "MarketsCore");
-// abi is `as const` — viem infers function names and argument types from it
+contracts("somnia-mainnet", "somnia-markets"); // enumerate, for admin screens
+identify("somnia-mainnet", "0x1a47…");         // reverse lookup: project, name, kind
 ```
 
-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.
+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.
 
-For viem, `toChain` builds a `Chain`-shaped object — the registry records no
-public RPC endpoint, so you bring your own:
+### Chain IDs are not unique
 
-```ts
-import { createPublicClient, http } from "viem";
-import { toChain } from "@somnia-chain/contracts-sdk";
+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.
 
-const chain = toChain("somnia-mainnet", { rpcUrl: "https://your-rpc" });
-const client = createPublicClient({ chain, transport: http() });
+```ts
+networksByChainId(50383); // -> both hideki testnets — an array, deliberately
 ```
 
-Exported types: `Registry`, `NetworkSlug`, `ProjectSlug`, `ContractName`,
-`ContractEntry`, `NetworkInfo`, `Address`.
+## ABIs — typed per contract, or the whole corpus
 
-## Chain IDs are not unique
+```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
+```
+
+## 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";
+
+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
 
-getNetworksByChainId(50383); // -> both hideki testnets; filter on `status`
+decodeBySelector(data); // 4-byte fallback across every ABI the registry holds
 ```
 
 ## Versioning

package/dist/abis.d.ts

@@ -0,0 +1,32 @@
+import { abisByHash } from "./gen/abis-index.js";
+import { 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;
+/**
+ * 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,26 @@
+import { abisByHash } from "./gen/abis-index.js";
+import { 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;
+}
+/**
+ * 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/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";

package/dist/gen/abi/somnia-accounts/CompatibilityFallbackHandler.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_83cdff66efa0 as CompatibilityFallbackHandlerAbi } from "../../abis/83cdff66efa0.js";
+export const CompatibilityFallbackHandlerAbiDigest = "sha256:83cdff66efa0922471f2e14c996ffeb2e5d54d8e0f0a2a841cb8b07a1b1ef10f";

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

@@ -0,0 +1,2 @@
+export { abi_c84f8d0f9550 as MultiSendAbi } from "../../abis/c84f8d0f9550.js";
+export declare const MultiSendAbiDigest = "sha256:c84f8d0f9550a2f87ed8b80bc9d211c8ec2fc9a32a146a905b75b8a54c3d1782";

package/dist/gen/abi/somnia-accounts/MultiSend.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_c84f8d0f9550 as MultiSendAbi } from "../../abis/c84f8d0f9550.js";
+export const MultiSendAbiDigest = "sha256:c84f8d0f9550a2f87ed8b80bc9d211c8ec2fc9a32a146a905b75b8a54c3d1782";

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

@@ -0,0 +1,2 @@
+export { abi_0b3cd40e0bc8 as MultiSendCallOnlyAbi } from "../../abis/0b3cd40e0bc8.js";
+export declare const MultiSendCallOnlyAbiDigest = "sha256:0b3cd40e0bc8fe6ff365ad1eb3792ba5a06148a0701e837a9bfdf5d8e64e271b";

package/dist/gen/abi/somnia-accounts/MultiSendCallOnly.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_0b3cd40e0bc8 as MultiSendCallOnlyAbi } from "../../abis/0b3cd40e0bc8.js";
+export const MultiSendCallOnlyAbiDigest = "sha256:0b3cd40e0bc8fe6ff365ad1eb3792ba5a06148a0701e837a9bfdf5d8e64e271b";

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

@@ -0,0 +1,2 @@
+export { abi_fd1f15294d67 as SafeAbi } from "../../abis/fd1f15294d67.js";
+export declare const SafeAbiDigest = "sha256:fd1f15294d679f41f915a7963f3e46b5b6f6c5bc7d79d80c09a593ebf77f1303";

package/dist/gen/abi/somnia-accounts/Safe.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_fd1f15294d67 as SafeAbi } from "../../abis/fd1f15294d67.js";
+export const SafeAbiDigest = "sha256:fd1f15294d679f41f915a7963f3e46b5b6f6c5bc7d79d80c09a593ebf77f1303";

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

@@ -0,0 +1,2 @@
+export { abi_1a5696b34cbf as SomniaAccountFactoryAbi } from "../../abis/1a5696b34cbf.js";
+export declare const SomniaAccountFactoryAbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

package/dist/gen/abi/somnia-accounts/SomniaAccountFactory.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_1a5696b34cbf as SomniaAccountFactoryAbi } from "../../abis/1a5696b34cbf.js";
+export const SomniaAccountFactoryAbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

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

@@ -0,0 +1,2 @@
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplAbi } from "../../abis/1a5696b34cbf.js";
+export declare const SomniaAccountFactoryImplAbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

package/dist/gen/abi/somnia-accounts/SomniaAccountFactoryImpl.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplAbi } from "../../abis/1a5696b34cbf.js";
+export const SomniaAccountFactoryImplAbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

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

@@ -0,0 +1,2 @@
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplV2Abi } from "../../abis/1a5696b34cbf.js";
+export declare const SomniaAccountFactoryImplV2AbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

package/dist/gen/abi/somnia-accounts/SomniaAccountFactoryImplV2.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplV2Abi } from "../../abis/1a5696b34cbf.js";
+export const SomniaAccountFactoryImplV2AbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

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

@@ -0,0 +1,2 @@
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplV3Abi } from "../../abis/1a5696b34cbf.js";
+export declare const SomniaAccountFactoryImplV3AbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

package/dist/gen/abi/somnia-accounts/SomniaAccountFactoryImplV3.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_1a5696b34cbf as SomniaAccountFactoryImplV3Abi } from "../../abis/1a5696b34cbf.js";
+export const SomniaAccountFactoryImplV3AbiDigest = "sha256:1a5696b34cbfca5b274e5369ac92d345cab05ea79e7f60f16c9a46766955f02e";

package/dist/gen/abi/somnia-agents/agentRegistry.d.ts

@@ -0,0 +1,2 @@
+export { abi_2fc4ebdf8536 as agentRegistryAbi } from "../../abis/2fc4ebdf8536.js";
+export declare const agentRegistryAbiDigest = "sha256:2fc4ebdf8536a24df7c5b9e3eeafbf06c5469f9d0648da4761c7e2df158708ae";

package/dist/gen/abi/somnia-agents/agentRegistry.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_2fc4ebdf8536 as agentRegistryAbi } from "../../abis/2fc4ebdf8536.js";
+export const agentRegistryAbiDigest = "sha256:2fc4ebdf8536a24df7c5b9e3eeafbf06c5469f9d0648da4761c7e2df158708ae";

package/dist/gen/abi/somnia-agents/committee.d.ts

@@ -0,0 +1,2 @@
+export { abi_ecc4ba1d4404 as committeeAbi } from "../../abis/ecc4ba1d4404.js";
+export declare const committeeAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-agents/committee.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_ecc4ba1d4404 as committeeAbi } from "../../abis/ecc4ba1d4404.js";
+export const committeeAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-agents/somniaAgents.d.ts

@@ -0,0 +1,2 @@
+export { abi_ecc4ba1d4404 as somniaAgentsAbi } from "../../abis/ecc4ba1d4404.js";
+export declare const somniaAgentsAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-agents/somniaAgents.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_ecc4ba1d4404 as somniaAgentsAbi } from "../../abis/ecc4ba1d4404.js";
+export const somniaAgentsAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.SBTCD_reader.d.ts

@@ -0,0 +1,2 @@
+export { abi_be2135567d5c as agent_aggregate_oracle_SBTCD_readerAbi } from "../../abis/be2135567d5c.js";
+export declare const agent_aggregate_oracle_SBTCD_readerAbiDigest = "sha256:be2135567d5c10f0eb0aa30a9419672b2aac42121cc807e215cdbbaf6200770d";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.SBTCD_reader.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_be2135567d5c as agent_aggregate_oracle_SBTCD_readerAbi } from "../../abis/be2135567d5c.js";
+export const agent_aggregate_oracle_SBTCD_readerAbiDigest = "sha256:be2135567d5c10f0eb0aa30a9419672b2aac42121cc807e215cdbbaf6200770d";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.aggregateImplementation.d.ts

@@ -0,0 +1,2 @@
+export { abi_734133340224 as agent_aggregate_oracle_aggregateImplementationAbi } from "../../abis/734133340224.js";
+export declare const agent_aggregate_oracle_aggregateImplementationAbiDigest = "sha256:73413334022417d0cca9c2f0f7194bd77f0120e9de7849bdf83a188390f3cc4d";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.aggregateImplementation.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_734133340224 as agent_aggregate_oracle_aggregateImplementationAbi } from "../../abis/734133340224.js";
+export const agent_aggregate_oracle_aggregateImplementationAbiDigest = "sha256:73413334022417d0cca9c2f0f7194bd77f0120e9de7849bdf83a188390f3cc4d";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.aggregateOracle.d.ts

@@ -0,0 +1,2 @@
+export { abi_ecc4ba1d4404 as agent_aggregate_oracle_aggregateOracleAbi } from "../../abis/ecc4ba1d4404.js";
+export declare const agent_aggregate_oracle_aggregateOracleAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-dex-protocol/agent-aggregate-oracle.aggregateOracle.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_ecc4ba1d4404 as agent_aggregate_oracle_aggregateOracleAbi } from "../../abis/ecc4ba1d4404.js";
+export const agent_aggregate_oracle_aggregateOracleAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-dex-protocol/agent-oracles.factory.d.ts

@@ -0,0 +1,2 @@
+export { abi_ecc4ba1d4404 as agent_oracles_factoryAbi } from "../../abis/ecc4ba1d4404.js";
+export declare const agent_oracles_factoryAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-dex-protocol/agent-oracles.factory.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_ecc4ba1d4404 as agent_oracles_factoryAbi } from "../../abis/ecc4ba1d4404.js";
+export const agent_oracles_factoryAbiDigest = "sha256:ecc4ba1d4404f9487b4d5d3e2b34ef1b7a1d9d188dbc94925ee07cd57d02943e";

package/dist/gen/abi/somnia-dex-protocol/binary-market-makers.accessControl.d.ts

@@ -0,0 +1,2 @@
+export { abi_b60156cb0dcf as binary_market_makers_accessControlAbi } from "../../abis/b60156cb0dcf.js";
+export declare const binary_market_makers_accessControlAbiDigest = "sha256:b60156cb0dcfdbb0e67a06273fa9b87a47c11f341fac18eee0dfd0bb8e833221";

package/dist/gen/abi/somnia-dex-protocol/binary-market-makers.accessControl.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_b60156cb0dcf as binary_market_makers_accessControlAbi } from "../../abis/b60156cb0dcf.js";
+export const binary_market_makers_accessControlAbiDigest = "sha256:b60156cb0dcfdbb0e67a06273fa9b87a47c11f341fac18eee0dfd0bb8e833221";

package/dist/gen/abi/somnia-dex-protocol/binary-market-makers.upgradeableBeacon.d.ts

@@ -0,0 +1,2 @@
+export { abi_fea5d0628b94 as binary_market_makers_upgradeableBeaconAbi } from "../../abis/fea5d0628b94.js";
+export declare const binary_market_makers_upgradeableBeaconAbiDigest = "sha256:fea5d0628b949411003bc70ef6e2030085993c765fac2e77cd07f97bd8c6d366";

package/dist/gen/abi/somnia-dex-protocol/binary-market-makers.upgradeableBeacon.js

@@ -0,0 +1,3 @@
+// Generated by `registry sdk` from dist-public/ — do not edit.
+export { abi_fea5d0628b94 as binary_market_makers_upgradeableBeaconAbi } from "../../abis/fea5d0628b94.js";
+export const binary_market_makers_upgradeableBeaconAbiDigest = "sha256:fea5d0628b949411003bc70ef6e2030085993c765fac2e77cd07f97bd8c6d366";