@molpha/mcp 0.1.0

package/dist/src/tools/agent_status.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { getMolphaContext } from "../clients.js";
+import { toolHandler } from "../mcp.js";
+import { fetchAgentStatus } from "../x402.js";
+import {} from "./types.js";
+export function registerAgentStatusTool(server) {
+    server.registerTool("molpha_agent_status", {
+        title: "Get x402 agent escrow status",
+        description: "Read the caller's x402 agent escrow (advisory: USDC ATA balance, amount committed to unsettled rounds, unsettled round count) and the next round's quoted price for a given quorum. Escrow is derived server-side per (payer, gateway). A non-existent escrow is normal pre-first-round — it's created lazily. Call before payment: \"x402\" fetches to see whether the escrow is already funded, or to pre-fund it out of band.",
+        inputSchema: {
+            signaturesRequired: z.number().int().positive().max(255).default(1)
+        }
+    }, toolHandler(async ({ signaturesRequired }) => {
+        const { config, signer } = await getMolphaContext();
+        const status = await fetchAgentStatus(config, signer.publicKey, signaturesRequired);
+        return {
+            signaturesRequired,
+            caps: {
+                maxPriceUsdcAtomic: config.x402.maxPriceUsdcAtomic.toString(),
+                maxSpendPerDayUsdcAtomic: config.x402.maxSpendPerDayUsdcAtomic.toString()
+            },
+            ...status,
+            payer: signer.publicKey
+        };
+    }));
+}

package/dist/src/tools/derive_feed.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { deriveFeedId } from "../apiconfig.js";
+import { getMolphaContext } from "../clients.js";
+import { checkApiConfigDeterminism } from "../determinism.js";
+import { toolHandler } from "../mcp.js";
+import { requireSdkExport } from "../sdk.js";
+import { apiConfigSchema } from "./schemas.js";
+import {} from "./types.js";
+export function registerDeriveFeedTool(server) {
+    server.registerTool("molpha_derive_feed", {
+        title: "Derive Molpha feedId",
+        description: "Locally derive the feedId for a declarative spec (apiConfig + quorum) — no transaction, no subscription required. feedId = keccak256(owner || apiConfigHash || signaturesRequired); the feed itself is created lazily on-chain at first settle (subscription or x402 round). Call this to preview a feedId before molpha_fetch_verified, or to check what feedId a given spec resolves to for the current signer. Prefer settled/finalized data — independent nodes must converge on a byte-identical value to co-sign.",
+        inputSchema: {
+            apiConfig: apiConfigSchema,
+            signaturesRequired: z.number().int().positive().max(255),
+            rejectNonDeterministic: z.boolean().optional()
+        }
+    }, toolHandler(async ({ apiConfig, signaturesRequired, rejectNonDeterministic = false }) => {
+        const { signer } = await getMolphaContext();
+        const determinism = checkApiConfigDeterminism(apiConfig);
+        if (!determinism.ok && determinism.warnings.some((w) => w.includes("required"))) {
+            throw new Error(determinism.warnings.join("; "));
+        }
+        if (rejectNonDeterministic && determinism.warnings.length > 0) {
+            throw new Error(`Non-deterministic source rejected: ${determinism.warnings.join("; ")}`);
+        }
+        const bytesToHex = requireSdkExport("bytesToHex");
+        const { feedId, apiConfigHash, canonicalApiConfig } = deriveFeedId(apiConfig, signaturesRequired, signer.publicKey);
+        return {
+            feedId,
+            apiConfigHash: bytesToHex(apiConfigHash),
+            canonicalApiConfig,
+            signaturesRequired,
+            owner: signer.publicKey,
+            determinismWarnings: determinism.warnings.length > 0 ? determinism.warnings : undefined,
+            note: "No transaction was sent. The feed account is created lazily on first settle via molpha_fetch_verified (subscription or x402)."
+        };
+    }));
+}

package/dist/src/tools/describe_feed.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { deriveFeedId } from "../apiconfig.js";
+import { getMolphaContext, requireMethod } from "../clients.js";
+import { settle } from "../errors.js";
+import { describeValueEncoding, presentFeed } from "../feed.js";
+import { normalizeFeedId } from "../hex.js";
+import { toolHandler } from "../mcp.js";
+import { apiConfigSchema } from "./schemas.js";
+import {} from "./types.js";
+export function registerDescribeFeedTool(server) {
+    server.registerTool("molpha_describe_feed", {
+        title: "Describe Molpha feed",
+        description: "Read a feed's on-chain state (last committed value, registryVersion, signaturesRequired) and the caller's subscription status. Pass feedId directly, or apiConfig + signaturesRequired to derive it first (see molpha_derive_feed). A missing feed account is normal pre-first-settle — feeds are created lazily. `feed.valueKind` is the attested encoding of the stored bytes (\"value\" = raw payload, \"hash\" = keccak digest), NOT a scale hint: Molpha attests no decimals on-chain. When apiConfig is supplied, `valueEncoding` reports the off-chain valueTransform that produced the number, explicitly flagged as unattested.",
+        inputSchema: {
+            feedId: z.string().min(1).optional(),
+            apiConfig: apiConfigSchema.optional(),
+            signaturesRequired: z.number().int().positive().max(255).optional()
+        }
+    }, toolHandler(async ({ feedId, apiConfig, signaturesRequired }) => {
+        const { config, solana, signer } = await getMolphaContext();
+        let resolvedFeedId = feedId;
+        if (!resolvedFeedId) {
+            if (!apiConfig || signaturesRequired === undefined) {
+                throw new Error("either feedId, or apiConfig + signaturesRequired, is required");
+            }
+            resolvedFeedId = deriveFeedId(apiConfig, signaturesRequired, signer.publicKey).feedId;
+        }
+        const [onChainFeed, subscription] = await Promise.all([
+            settle("solana.readFeed", async () => requireMethod(solana, "readFeed")(normalizeFeedId(resolvedFeedId))),
+            settle("solana.readSubscription", async () => requireMethod(solana, "readSubscription")())
+        ]);
+        return {
+            feedId: resolvedFeedId,
+            feed: onChainFeed.ok ? presentFeed(onChainFeed.value) : onChainFeed,
+            ...(apiConfig ? { valueEncoding: describeValueEncoding(apiConfig.valueTransform) } : {}),
+            subscription,
+            chains: {
+                solana: "devnet (canonical state)",
+                evm: config.evmNetworks,
+                starknet: config.starknetNetworks
+            }
+        };
+    }));
+}

package/dist/src/tools/execute.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { getMolphaContext } from "../clients.js";
+import { prepareSignedResult, previewSubmit, submitSignedResult } from "../submit.js";
+import { toolHandler } from "../mcp.js";
+import {} from "./types.js";
+/** The flat gateway/SDK shape. */
+const flatResultSchema = z.object({
+    feedId: z.string().min(1),
+    value: z.string().optional(),
+    valuePacked: z.string().optional(),
+    timestamp: z.number().int(),
+    registryVersion: z.number().int(),
+    signaturesRequired: z.number().int(),
+    signersBitmap: z.string().min(1),
+    s: z.string().min(1),
+    commitmentAddr: z.string().min(1),
+    fresh: z.boolean().optional()
+});
+/** The artifact shape `molpha_fetch_verified` returns, accepted verbatim. */
+const artifactResultSchema = z.object({
+    value: z.string().optional(),
+    fresh: z.boolean().optional(),
+    dataUpdate: z.object({
+        feedId: z.string().min(1),
+        registryVersion: z.number().int(),
+        signaturesRequired: z.number().int(),
+        value: z.string().optional(),
+        valuePacked: z.string().optional(),
+        canonicalTimestamp: z.number().int()
+    }),
+    signature: z.object({
+        signature: z.string().min(1),
+        commitment: z.string().min(1),
+        signersBitmap: z.string().min(1)
+    })
+});
+// Extra keys (`payment`, `trustAnchor`, `verifierArgs`) ride along on a pasted
+// fetch_verified response; passthrough keeps that from being a validation error.
+const signedResultSchema = z.union([
+    artifactResultSchema.passthrough(),
+    flatResultSchema.passthrough()
+]);
+export function registerExecuteTool(server) {
+    server.registerTool("molpha_execute", {
+        title: "Execute Molpha data update on Solana",
+        description: "Submit a signed DataUpdate to the Solana feed via submit_data_update. Pass the output of molpha_fetch_verified through unmodified — both the artifact shape ({ dataUpdate, signature }) and the flat shape ({ s, commitmentAddr, timestamp }) are accepted, and short hex fields are zero-padded server-side. Permissionless on-chain; the owner key pays SOL fees. EVM/Starknet execution is deliberately out of scope (see molpha_verify) — use the verifier args from molpha_fetch_verified and call verify() yourself.",
+        inputSchema: {
+            result: signedResultSchema,
+            dryRun: z.boolean().optional()
+        }
+    }, toolHandler(async ({ result, dryRun }) => {
+        const { config, signer } = await getMolphaContext();
+        const isDryRun = dryRun ?? config.guardrails.dryRunDefault;
+        const prepared = prepareSignedResult(result);
+        if (isDryRun) {
+            return previewSubmit("molpha_execute", prepared, String(signer.publicKey));
+        }
+        return submitSignedResult(prepared);
+    }));
+}

package/dist/src/tools/fetch_verified.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { deriveFeedId } from "../apiconfig.js";
+import { normalizeSignedResult, toDataUpdateArtifact } from "../artifacts.js";
+import { getMolphaContext, requireMethod } from "../clients.js";
+import {} from "../config.js";
+import { settle } from "../errors.js";
+import { normalizeFeedId } from "../hex.js";
+import { toolHandler } from "../mcp.js";
+import { prepareSignedResult, submitSignedResult } from "../submit.js";
+import { readSubscriptionStatus } from "../subscription.js";
+import { buildVerifierArgsForChains } from "../verifiers.js";
+import { agentFetch } from "../x402.js";
+import { apiConfigSchema } from "./schemas.js";
+import {} from "./types.js";
+const chainSchema = z.enum(["evm", "starknet", "solana"]);
+const paymentSchema = z.enum(["auto", "subscription", "x402"]);
+export function registerFetchVerifiedTool(server) {
+    server.registerTool("molpha_fetch_verified", {
+        title: "Fetch verified Molpha data",
+        description: "Trigger a signing round for a feed and return the self-contained signed payload PLUS prebuilt verifier arguments for each requested chain. The signed payload is the trust anchor — verify it or forward it to a contract; do not consume `value` alone. Only the `solana` leg can be settled from this server (via `autoSubmit`, or by passing this tool's output to molpha_execute unmodified); `evm` and `starknet` return contract-ready calldata only — executing verify() there is the agent's job by design (see molpha_verify). `payment` selects how the round is paid for: \"subscription\" uses the caller's active USDC subscription (fails if inactive), \"x402\" self-funds a per-request escrow (auto-funds up to the MOLPHA_X402_MAX_PRICE_USDC / MOLPHA_X402_MAX_SPEND_PER_DAY_USDC caps), and \"auto\" (default) uses the subscription when active and falls back to x402 otherwise. feedId is derived from apiConfig + signaturesRequired + the signer's pubkey when omitted (see molpha_derive_feed).",
+        inputSchema: {
+            apiConfig: apiConfigSchema,
+            signaturesRequired: z.number().int().positive().max(255).default(1),
+            feedId: z.string().min(1).optional(),
+            maxAge: z.number().int().nonnegative().optional(),
+            chains: z.array(chainSchema).min(1),
+            encryptSecrets: z.record(z.string()).optional(),
+            payment: paymentSchema.optional(),
+            autoSubmit: z
+                .boolean()
+                .optional()
+                .describe("Submit the signed DataUpdate to Solana in the same call, so a round-trip settle is one call instead of two. Requires \"solana\" in chains. Honours dryRun and the daily execute cap; a failed submit still returns the signed artifact so it can be retried via molpha_execute."),
+            dryRun: z.boolean().optional()
+        }
+    }, toolHandler(async ({ apiConfig, signaturesRequired, feedId, maxAge, chains, encryptSecrets, payment = "auto", autoSubmit = false, dryRun }) => {
+        const { config, gateway, solana, signer, connection } = await getMolphaContext();
+        const isDryRun = dryRun ?? config.guardrails.dryRunDefault;
+        const resolvedFeedId = resolveFeedId(feedId, apiConfig, signaturesRequired, signer.publicKey);
+        if (autoSubmit && !chains.includes("solana")) {
+            throw new Error("autoSubmit settles on Solana; include \"solana\" in chains (EVM/Starknet have no in-MCP execution path).");
+        }
+        const resolvedPayment = payment === "auto" ? (await readSubscriptionStatus(solana)).active ? "subscription" : "x402" : payment;
+        if (resolvedPayment === "x402" && encryptSecrets) {
+            throw new Error("encryptSecrets is not yet supported on the x402 payment path; use payment: \"subscription\", or omit encryptSecrets.");
+        }
+        if (resolvedPayment === "subscription") {
+            if (isDryRun) {
+                return {
+                    dryRun: true,
+                    action: "molpha_fetch_verified",
+                    payment: "subscription",
+                    feedId: resolvedFeedId,
+                    signaturesRequired,
+                    ...(autoSubmit ? { autoSubmit: "would submit the signed DataUpdate to Solana" } : {})
+                };
+            }
+            const requestSignedData = requireMethod(gateway, "requestSignedData");
+            const result = await requestSignedData({
+                feedId: normalizeFeedId(resolvedFeedId),
+                signaturesRequired,
+                apiConfig,
+                ...(maxAge !== undefined ? { maxAge } : {}),
+                ...(encryptSecrets ? { encrypt: { secrets: encryptSecrets } } : {})
+            });
+            return buildResult(result, chains, config, "subscription", autoSubmit);
+        }
+        const result = await agentFetch({ config, connection, signer, solana }, {
+            apiConfig,
+            signaturesRequired,
+            feedId: resolvedFeedId,
+            ...(maxAge !== undefined ? { maxAge } : {}),
+            ...(isDryRun ? { dryRun: true } : {})
+        });
+        if (isDryRun) {
+            return {
+                payment: "x402",
+                ...result,
+                ...(autoSubmit ? { autoSubmit: "would submit the signed DataUpdate to Solana" } : {})
+            };
+        }
+        return buildResult(result, chains, config, "x402", autoSubmit);
+    }));
+}
+async function buildResult(result, chains, config, payment, autoSubmit) {
+    // Canonicalize once: the gateway emits minimal hex (a one-signer bitmap comes
+    // back as "4"), which both the verifier-arg builders and submit_data_update
+    // reject at their fixed widths.
+    const normalized = normalizeSignedResult(result);
+    const artifact = toDataUpdateArtifact(normalized);
+    const out = {
+        payment,
+        ...artifact,
+        trustAnchor: "Consume the signed dataUpdate + signature (and verify or forward). Do not trust `value` alone.",
+        verifierArgs: buildVerifierArgsForChains(normalized, chains, config)
+    };
+    if (autoSubmit) {
+        // A failed submit must not discard the signed artifact — the caller can
+        // retry molpha_execute with the payload it is already holding.
+        const submitted = await settle("solana.submitDataUpdate", async () => submitSignedResult(prepareSignedResult(normalized)));
+        out.submitted = submitted.ok
+            ? submitted.value
+            : {
+                ok: false,
+                ...submitted.error,
+                retry: "Pass this response to molpha_execute unmodified to retry the Solana submit."
+            };
+    }
+    return out;
+}
+function resolveFeedId(feedId, apiConfig, signaturesRequired, owner) {
+    const derived = deriveFeedId(apiConfig, signaturesRequired, owner).feedId;
+    if (feedId !== undefined && normalizeFeedId(feedId) !== normalizeFeedId(derived)) {
+        throw new Error(`feedId does not match apiConfig + signaturesRequired for this signer: expected ${derived}, got ${feedId}`);
+    }
+    return derived;
+}

package/dist/src/tools/get_capabilities.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { getMolphaContext, requireMethod } from "../clients.js";
+import { settle } from "../errors.js";
+import { toolHandler } from "../mcp.js";
+import { getVerifierMetadata } from "../verifiers.js";
+import {} from "./types.js";
+export function registerGetCapabilitiesTool(server) {
+    server.registerTool("molpha_get_capabilities", {
+        title: "Get Molpha capabilities",
+        description: "Returns the current Molpha verification surface: active registryVersion, registered node set, gateway endpoints, supported chains, signing scheme, and x402 spend caps. Call first to learn where a signed result can be verified.",
+        inputSchema: {
+            includeAbi: z.boolean().optional().describe("Include the EVM verifier ABI in the response.")
+        }
+    }, toolHandler(async ({ includeAbi = false }) => {
+        const { config, gateway, solana } = await getMolphaContext();
+        const [nodesResult, registryVersionResult] = await Promise.all([
+            settle("gateway.getNodes", async () => requireMethod(gateway, "getNodes")()),
+            settle("solana.getRegistryVersion", async () => requireMethod(solana, "getRegistryVersion")())
+        ]);
+        const nodes = nodesResult.ok ? nodesResult.value : [];
+        const registryVersion = registryVersionResult.ok ? registryVersionResult.value : undefined;
+        const verifiers = getVerifierMetadata(config, includeAbi);
+        return {
+            registryVersion,
+            signingScheme: "PoP-Schnorr (secp256k1, two-nonce binding)",
+            chains: {
+                solana: "devnet (canonical state)",
+                evm: config.evmNetworks,
+                starknet: config.starknetNetworks
+            },
+            gateways: config.gatewayEndpoints,
+            nodeCount: Array.isArray(nodes) ? nodes.length : 0,
+            nodes: nodesResult.ok ? nodes : nodesResult,
+            solanaRpc: config.solanaRpc,
+            verifiers,
+            payment: {
+                modes: ["subscription", "x402", "auto"],
+                x402Caps: {
+                    maxPriceUsdcAtomic: config.x402.maxPriceUsdcAtomic.toString(),
+                    maxSpendPerDayUsdcAtomic: config.x402.maxSpendPerDayUsdcAtomic.toString()
+                }
+            }
+        };
+    }));
+}

package/dist/src/tools/get_latest.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { getMolphaContext, requireMethod } from "../clients.js";
+import { presentFeed } from "../feed.js";
+import { normalizeFeedId } from "../hex.js";
+import { toolHandler } from "../mcp.js";
+import {} from "./types.js";
+export function registerGetLatestTool(server) {
+    server.registerTool("molpha_get_latest", {
+        title: "Get latest Molpha feed",
+        description: "Read the latest on-chain feed account for a Molpha feedId. `valueKind` is the attested encoding of the stored bytes (\"value\" = raw payload, \"hash\" = keccak digest) — it is not a scale hint. Molpha does not attest decimals on-chain; see molpha_describe_feed's valueEncoding for the (unsigned) apiConfig provenance.",
+        inputSchema: {
+            feedId: z.string().min(1)
+        }
+    }, toolHandler(async ({ feedId }) => {
+        const { solana } = await getMolphaContext();
+        const readFeed = requireMethod(solana, "readFeed");
+        return {
+            feedId,
+            feed: presentFeed(await readFeed(normalizeFeedId(feedId)))
+        };
+    }));
+}

package/dist/src/tools/index.js

@@ -0,0 +1,19 @@
+import { registerAgentStatusTool } from "./agent_status.js";
+import { registerDeriveFeedTool } from "./derive_feed.js";
+import { registerDescribeFeedTool } from "./describe_feed.js";
+import { registerExecuteTool } from "./execute.js";
+import { registerFetchVerifiedTool } from "./fetch_verified.js";
+import { registerGetCapabilitiesTool } from "./get_capabilities.js";
+import { registerGetLatestTool } from "./get_latest.js";
+import { registerVerifyTool } from "./verify.js";
+import {} from "./types.js";
+export function registerTools(server) {
+    registerGetCapabilitiesTool(server);
+    registerDescribeFeedTool(server);
+    registerDeriveFeedTool(server);
+    registerAgentStatusTool(server);
+    registerFetchVerifiedTool(server);
+    registerGetLatestTool(server);
+    registerVerifyTool(server);
+    registerExecuteTool(server);
+}

package/dist/src/tools/schemas.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** Shared apiConfig input shape for tools that accept a declarative feed source. */
+export const apiConfigSchema = z.object({
+    url: z.string().min(1),
+    method: z.enum(["GET", "POST"]).optional(),
+    headers: z.record(z.string()).optional(),
+    responseParser: z.string().min(1),
+    valueTransform: z.string().optional()
+});

package/dist/src/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/verify.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { toSignedResult } from "../artifacts.js";
+import { getMolphaContext } from "../clients.js";
+import { toolHandler } from "../mcp.js";
+import { buildVerifierArgsForChains, getVerifierMetadata } from "../verifiers.js";
+import {} from "./types.js";
+const chainSchema = z.enum(["evm", "starknet"]);
+export function registerVerifyTool(server) {
+    server.registerTool("molpha_verify", {
+        title: "Verify Molpha result",
+        description: "Build the verifier address and call args for a signed DataUpdate on EVM or Starknet. This tool stops at calldata by design, not by omission: the Molpha verifier is stateless, so the agent (or its contract) executes verify() itself and the server never submits an EVM/Starknet transaction or vouches for a result it did not verify on-chain. There is no EVM/Starknet execution path anywhere in this MCP server. For Solana, submit the DataUpdate via molpha_execute (or molpha_fetch_verified autoSubmit) and read it back with molpha_get_latest — there is no separate simulate-verify path. Accepts the dataUpdate/signature objects from molpha_fetch_verified verbatim; short hex fields are zero-padded to their canonical widths server-side.",
+        inputSchema: {
+            dataUpdate: z.record(z.unknown()),
+            signature: z.record(z.unknown()),
+            chain: chainSchema,
+            includeAbi: z.boolean().optional()
+        }
+    }, toolHandler(async ({ dataUpdate, signature, chain, includeAbi = false }) => {
+        const { config } = await getMolphaContext();
+        const result = toSignedResult({ dataUpdate, signature });
+        return {
+            chain,
+            verifierArgs: buildVerifierArgsForChains(result, [chain], config),
+            note: "Execute verify() on-chain with the returned args; the MCP server does not assert validity.",
+            verifiers: getVerifierMetadata(config, includeAbi)
+        };
+    }));
+}

package/dist/src/verifiers.js

@@ -0,0 +1,95 @@
+import {} from "./config.js";
+import { getSdkExport } from "./sdk.js";
+const EVM_NETWORK_CHAIN_IDS = {
+    "evm-sepolia": [11155111],
+    "arbitrum-sepolia": [421614],
+    "avalanche-fuji": [43113],
+    "bsc-testnet": [97]
+};
+export function getVerifierMetadata(config, includeAbi = false) {
+    return {
+        evm: config.evmNetworks.map((network) => resolveEvmVerifierAddress(network)),
+        starknet: config.starknetNetworks.map((network) => resolveVerifierAddress("getMolphaStarknetVerifierAddress", network)),
+        ...(includeAbi ? { evmAbi: getSdkExport("MOLPHA_VERIFIER_ABI") ?? null } : {})
+    };
+}
+export function buildVerifierArgs(result) {
+    const errors = [];
+    const evm = callBuilder("buildEvmVerifierArgs", result, errors);
+    const starknet = callBuilder("buildStarknetVerifierArgs", result, errors);
+    return {
+        ...(evm !== undefined ? { evm } : {}),
+        ...(starknet !== undefined ? { starknet } : {}),
+        errors
+    };
+}
+export function buildVerifierArgsForChains(result, chains, config) {
+    const built = buildVerifierArgs(result);
+    const out = {};
+    if (chains.includes("evm") && built.evm !== undefined) {
+        out.evm = {
+            verifier: config.evmNetworks.map((network) => ({
+                network,
+                address: resolveEvmVerifierAddress(network).address
+            })),
+            chainIds: config.evmNetworks.flatMap((network) => EVM_NETWORK_CHAIN_IDS[network] ?? []),
+            args: built.evm
+        };
+    }
+    if (chains.includes("starknet") && built.starknet !== undefined) {
+        const starknetMeta = config.starknetNetworks.map((network) => resolveVerifierAddress("getMolphaStarknetVerifierAddress", network));
+        out.starknet = {
+            verifier: starknetMeta[0]?.address,
+            args: built.starknet
+        };
+    }
+    if (built.errors.length > 0) {
+        out.errors = built.errors;
+    }
+    return out;
+}
+/**
+ * The EVM verifier is deployed via CREATE2 — the same address on every
+ * supported chain — so this is a single SDK constant rather than a
+ * per-network lookup.
+ */
+function resolveEvmVerifierAddress(network) {
+    const address = getSdkExport("MOLPHA_VERIFIER_ADDRESS");
+    if (!address) {
+        return { network, error: "MOLPHA_VERIFIER_ADDRESS is not exported by @molpha-oracle/sdk" };
+    }
+    return { network, address };
+}
+function resolveVerifierAddress(exportName, network) {
+    const resolver = getSdkExport(exportName);
+    if (typeof resolver !== "function") {
+        return { network, error: `${exportName} is not exported by @molpha-oracle/sdk` };
+    }
+    try {
+        const address = resolver(network);
+        return address ? { network, address } : { network, error: "no verifier address returned" };
+    }
+    catch (error) {
+        return {
+            network,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function callBuilder(exportName, result, errors) {
+    const builder = getSdkExport(exportName);
+    if (typeof builder !== "function") {
+        errors.push({ target: exportName, message: `${exportName} is not exported by @molpha-oracle/sdk` });
+        return undefined;
+    }
+    try {
+        return builder(result);
+    }
+    catch (error) {
+        errors.push({
+            target: exportName,
+            message: error instanceof Error ? error.message : String(error)
+        });
+        return undefined;
+    }
+}