@molpha/sdk 0.2.0 → 0.3.0-dev-20261022065307

package/dist/index.d.ts

@@ -1,21 +1,171 @@
 import { Address } from '@solana/kit';
 import { Wallet, Idl, AnchorProvider } from '@anchor-lang/core';
-import { U as UpstreamQuote, A as APIConfig, a as AssetDomain, b as UpstreamTerms, E as EvmSigner, S as Signer, c as SourcePaymentOptions, R as RegistrySelectionConfig, N as Node, d as NodeKeyVerifier, e as NodesInfo, f as Attestation, g as SolanaAccountMeta, h as SolanaConnection, i as SolanaAddress, j as NodeKeyVerifierArgs, k as AggregationConfig, M as MolphaWallet } from './wallet-DGe_pi93.js';
-export { l as AttestationPayload, m as EncKeyBundle, n as NumericConfig, o as RegistryInfo, p as SchnorrSignature, q as gatewaySignerFromWallet, s as signerFromKeypair } from './wallet-DGe_pi93.js';
+import { U as UpstreamQuote, A as AssetDomain, a as UpstreamTerms, E as EvmSigner, S as Signer, b as SourcePaymentOptions, R as RegistrySelectionConfig, N as Node, c as NodeKeyVerifier, d as NodesInfo, e as Attestation, f as SolanaAccountMeta, g as SolanaConnection, h as SolanaAddress, i as NodeKeyVerifierArgs, M as MolphaWallet } from './wallet-BAxBy7hR.js';
+export { j as AttestationPayload, k as EncKeyBundle, l as RegistryInfo, m as SchnorrSignature, n as gatewaySignerFromWallet, s as signerFromKeypair } from './wallet-BAxBy7hR.js';
 import BN from 'bn.js';
 
+/**
+ * The published chain list: for each chain its CAIP-2 id, kind, block time, the finality modes (or
+ * commitments) it offers and their bounds. Generated from the node client's `new/source/chainlist.json`,
+ * which is the reference; the numbers are protocol estimates, not measurements of a live chain.
+ */
+interface Chain {
+    id: string;
+    kind: "evm" | "starknet" | "svm";
+    name: string;
+    /** evm and starknet only. */
+    blockTimeMs?: number;
+    /** evm and starknet: the finality modes offered, with their bounds. */
+    finality?: Record<string, {
+        minLagMs?: number;
+        maxN?: number;
+    }>;
+    maxLagMs?: number;
+    /** svm: the commitments offered. */
+    commitments?: Record<string, {
+        minMaxAgeMs: number;
+    }>;
+    maxMaxAgeMs?: number;
+}
+declare const CHAIN_LIST: Chain[];
+
+type SourceErrorClass = "syntax" | "utf8" | "surrogate" | "number" | "duplicate_key" | "depth" | "unknown_key" | "missing_key" | "type" | "value" | "limit" | "noncanonical" | "reference";
+/** A rejected source. `path` names the offending field; it never contains a secret. */
+declare class SourceError extends Error {
+    readonly path: string;
+    readonly errorClass: SourceErrorClass;
+    constructor(path: string, errorClass: SourceErrorClass, message: string);
+}
+declare const SOURCE_VERSION = "1";
+declare const MAX_CANONICAL_BYTES: number;
+declare const MAX_PRIVATE_BYTES: number;
+declare const MAX_INPUTS = 4;
+declare const MAX_EXPR_NODES = 64;
+declare const MAX_EXPR_DEPTH = 12;
+declare const MAX_ASSERTS = 8;
+declare const MAX_FIELDS = 16;
+declare const MAX_HEADERS = 16;
+declare const MAX_HEADER_VALUE = 1024;
+declare const MAX_BODY_TEXT = 4096;
+declare const MAX_RESPONSE_BYTES: number;
+declare const MAX_DECIMAL_SCALE = 36;
+declare const MAX_OUTPUT_DECIMALS = 36;
+/** A parsed JSON value. Objects are Maps, so a key such as `__proto__` is just a key. */
+type Json = null | boolean | string | Json[] | JObj;
+type JObj = Map<string, Json>;
+/** Convert plain JavaScript data to Json, refusing numbers and anything else the format forbids. */
+declare function fromPlain(value: unknown, path?: string, depth?: number): Json;
+/** Back to plain objects (insertion-ordered), for callers that want to read a validated source. */
+declare function toPlain(v: Json): unknown;
+/** Strictly parse source JSON: no numbers, no duplicate keys, no lone surrogates, no trailing data. */
+declare function parseStrict(input: string | Uint8Array): Json;
+/** The canonical serialization of a parsed value. */
+declare function canonicalJson(v: Json): string;
+/** The canonical bytes of a source document (any JSON text or plain object), without schema checks. */
+declare function canonicalize(input: string | Uint8Array | object): string;
+interface URLParts {
+    scheme: "http" | "https";
+    host: string;
+    port: string;
+    /** Path and query, verbatim. */
+    rest: string;
+    /** host or host:port as the URL spells it. */
+    hostPort: string;
+}
+/** Split a source URL. Scheme, host and port must be literal; throws on anything else. */
+declare function splitURL(u: string): URLParts;
+declare const OUTPUT_TYPES: readonly ["int256", "uint256", "bool", "bytes32", "string32", "keccak256"];
+type OutputType = (typeof OUTPUT_TYPES)[number];
+/** A validated source: its canonical form and ID, and the plain document. */
+interface ParsedSource {
+    /** The document, exactly as given (every key present). */
+    doc: SourceDoc;
+    /** Canonical JSON text; its UTF-8 bytes are what the ID hashes and what nodes receive. */
+    canonical: string;
+    bytes: Uint8Array;
+    /** keccak256 of `bytes`. */
+    id: Uint8Array;
+    /** `0x`-prefixed lowercase hex of `id`. */
+    idHex: string;
+    inputNames: string[];
+    output: {
+        type: OutputType;
+        decimals: number;
+    };
+    tolerance: boolean;
+}
+/** Validate a source given as JSON text, bytes or a plain object, in any key order and whitespace. */
+declare function parseSource(input: string | Uint8Array | object): ParsedSource;
+/** {@link parseSource} for a decrypted private source, whose filled-in secrets may make it longer. */
+declare function parsePrivateSource(input: string | Uint8Array | object): ParsedSource;
+/** Like {@link parseSource}, and also requires the input to be the canonical form already. */
+declare function parseCanonicalSource(input: string | Uint8Array): ParsedSource;
+/** The source ID of a source document: keccak256 of its canonical bytes. */
+declare function deriveSourceId(input: string | Uint8Array | object): Uint8Array;
+/** {@link deriveSourceId} as `0x`-prefixed hex. */
+declare function deriveSourceIdHex(input: string | Uint8Array | object): string;
+
+/**
+ * Check a source's chain inputs against the chain list: each chain must be listed, of the right
+ * kind, offer the finality mode or commitment, and keep `lagMs` or `maxAgeMs` within its bounds. A
+ * source that no node could ever satisfy is refused here, not as a failed round.
+ */
+declare function checkChains(src: ParsedSource, list?: Chain[], allow?: (chain: string) => boolean): void;
+/** An expression of the transform tree. */
+type Expr = {
+    ref: string;
+} | {
+    const: string;
+} | {
+    str: string;
+} | {
+    bytes: string;
+} | {
+    bool: boolean;
+} | {
+    op: string;
+    args: Expr[];
+    [param: string]: unknown;
+};
+interface OutputDoc {
+    type: OutputType;
+    decimals: string | null;
+}
+interface AggregationDoc {
+    mode: "tolerance";
+    rule: "median";
+    maxDeviationBps: string;
+    maxAgeMs: string;
+}
+/** A source document in its canonical shape: every key present, every number a string. */
+interface SourceDoc {
+    v: "1";
+    inputs: Record<string, any>;
+    transform: Expr;
+    assert: Expr[];
+    output: OutputDoc;
+    aggregation: AggregationDoc | null;
+}
+/** Whether the source declares keccak256 output (its signed value is a hash of a preimage). */
+declare const hasPreimage: (src: ParsedSource) => boolean;
+/** Everything {@link parseSource} computes, for a source that was already validated. */
+declare function encodeSourceBytes(src: ParsedSource): Uint8Array;
+/** The ID of canonical source bytes: keccak256. */
+declare function sourceIdOf(bytes: Uint8Array): Uint8Array;
+
 /**
  * GENERATED by `scripts/select-profile.ts` — do not edit.
- * Profile: stable
+ * Profile: dev
+ * EVM/Starknet verifier addresses are unset until the Attestation-interface redeploy. Codegen falls back to stable addresses and sets MOLPHA_DEV_VERIFIERS_PROVISIONAL.
  */
 type MolphaSdkProfile = "stable" | "dev";
 declare const MOLPHA_SDK_PROFILE: MolphaSdkProfile;
-declare const DEFAULT_GATEWAY_ENDPOINT = "https://gateway.molpha.io/";
-declare const MOLPHA_PROGRAM_ID = "MoLF3pgVA9MENSuEujxNNSMaTo71aLyewaH5nrWfUZs";
+declare const DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
+declare const MOLPHA_PROGRAM_ID = "chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt";
 declare const MOLPHA_VERIFIER_ADDRESS: "0xA6e49A3A1caf3E110cC04765B934C8FF118C2568";
 declare const MOLPHA_VERIFIER_STARKNET_SEPOLIA: "0x032b9f47f12189668b94a5d62fb7d60f968ed0dbaf22090649d1d7a91d79cc38";
 /** True when the active profile has unset EVM/Starknet addresses (dev falls back to stable). */
-declare const MOLPHA_DEV_VERIFIERS_PROVISIONAL: false;
+declare const MOLPHA_DEV_VERIFIERS_PROVISIONAL: true;
 
 /**
  * Gateway on-chain identity. The request-auth hash binds the Gateway PDA
@@ -100,7 +250,7 @@ declare function validateSuppliedTerms(terms: UpstreamTerms, resource: string, a
  * not a data fetch: nodes remain the only fetchers of the value itself.
  * Returns `null` when the source is not paywalled.
  */
-declare function probeSource(apiConfig: APIConfig, options?: {
+declare function probeSource(source: ParsedSource | string | object, options?: {
     secrets?: Record<string, string>;
     assetDomain?: AssetDomain;
     timeoutMs?: number;
@@ -117,14 +267,16 @@ declare function signSourcePayments(terms: UpstreamTerms, signer: EvmSigner, cou
 
 interface RequestSignedDataOptions {
     /**
-     * The API definition to resolve. Its canonical form determines the round's
-     * `sourceId = keccak256(JSON.stringify(canonicalizeAPIConfig(apiConfig)))`, so pass the
-     * same config (including `{{secret.*}}` placeholders) every time.
+     * The source to run: what the nodes read, how the reads become one value, and how that value becomes
+     * the 32 signed bytes. A {@link ParsedSource} (from `defineSource`, `jsonPriceSource` or
+     * `parseSource`), or a source document (JSON text or a plain object) in its full form. The round's
+     * `sourceId` is the keccak256 of its canonical bytes, so pass the same source (including
+     * `{{secret.*}}` placeholders) every time.
      */
-    apiConfig: APIConfig;
+    source: ParsedSource | string | object;
     /**
      * Requested quorum (u8, ≥ the protocol `min_signers`). Median tolerance mode
-     * (`apiConfig.aggregation`) additionally requires `>= 3`; lower values are rejected
+     * (`source.aggregation`) additionally requires `>= 3`; lower values are rejected
      * before any request is made.
      */
     signaturesRequired: number;
@@ -330,7 +482,7 @@ declare class MolphaGateway {
      * Request a threshold-signed data update from the gateway, with retry +
      * failover. The body is POSTed to each endpoint in order until one `completed`s.
      *
-     * The round's `sourceId` is derived from `apiConfig`. The request carries no round timestamp:
+     * The round's `sourceId` is derived from `source`. The request carries no round timestamp:
      * the gateway stamps the round with its own clock floored to the round tick (`timestamp`, unix
      * milliseconds, a multiple of {@link ROUND_TICK_MS}), and the committee follows from it. The
      * result carries the assigned timestamp and the signers' bitmap; the timestamp is taken as the
@@ -770,63 +922,6 @@ declare class MolphaSolanaClient {
  */
 declare function buildSubmitAttestationArgs(attestation: Attestation, coalitionKey: CoalitionKey, rawValue?: Uint8Array | null): SubmitAttestationArgs;
 
-/**
- * Aggregation (tolerance mode) config validation and canonicalization.
- *
- * `aggregation` is part of the API config and therefore part of `sourceId`. It is OMITTED
- * for exact mode: a config carrying `mode: "exact"` would hash differently from the same
- * config without the key, so it is rejected rather than silently normalized. The node
- * (`new/tolerance.Validate`) is the reference.
- */
-
-/** Tolerance mode needs at least this many signers (`signaturesRequired >= 3`). */
-declare const MIN_TOLERANCE_SIGNATURES = 3;
-/** Thrown for an unusable `aggregation` config. */
-declare class AggregationConfigError extends Error {
-    constructor(message: string);
-}
-/**
- * Validate an `aggregation` config and return a fresh object with the canonical key order
- * (`mode`, `rule`, `maxDeviationBps`, `maxAgeMs`, `numeric{type, decimals}`) — the order
- * the source hash and the node's JSON blob use.
- *
- * The result is built field by field: unknown or reordered keys on the input can never
- * reach the hash or the wire. `undefined` / `null` mean exact mode and return `undefined`.
- *
- * @throws {AggregationConfigError} on `mode: "exact"`, an unsupported mode / rule / numeric
- *   type, or an out-of-range number.
- */
-declare function canonicalizeAggregation(aggregation: AggregationConfig | null | undefined): AggregationConfig | undefined;
-/**
- * Tolerance mode needs `signaturesRequired >= 3`; the node rejects anything lower.
- * A no-op for exact mode (`aggregation` omitted).
- *
- * @throws {AggregationConfigError}
- */
-declare function assertAggregationQuorum(aggregation: AggregationConfig | null | undefined, signaturesRequired: number): void;
-
-/**
- * Gateway wire shape — defaults applied before hash / encryption.
- *
- * Keys are emitted in the fixed order `url`, `method`, `headers`, `responseParser`,
- * `valueTransform`, `aggregation`; `aggregation` is present only for tolerance mode and its
- * nested keys are rebuilt in canonical order (`canonicalizeAggregation`), so no extra or
- * reordered input key can reach the hash. A config without `aggregation` hashes exactly as
- * before.
- *
- * @throws {AggregationConfigError} if `aggregation` is invalid (including `mode: "exact"`).
- */
-declare function canonicalizeAPIConfig(apiConfig: APIConfig): APIConfig;
-/**
- * `sourceId = keccak256(JSON.stringify(canonical apiConfig))` — the 32-byte identity of a
- * data source. Hash the same config (including `{{secret.*}}` placeholders) you send to
- * `MolphaGateway.requestSignedData`; the gateway and every verifier recompute it from
- * `apiConfig`.
- */
-declare function deriveSourceId(apiConfig: APIConfig): Uint8Array;
-/** Hex-encoded {@link deriveSourceId} (64 lowercase hex chars, no `0x`). */
-declare function deriveSourceIdString(apiConfig: APIConfig): string;
-
 declare const utf8: (s: string) => Uint8Array;
 declare const concatBytes: (...arrays: Uint8Array[]) => Uint8Array;
 /** Lower-case hex, no `0x` prefix. */
@@ -944,6 +1039,288 @@ declare function deriveGroupBitmap(seed: Uint8Array, nodeCount: number, groupSiz
  */
 declare function deriveSelectionBitmap(sourceId: Uint8Array, registryVersion: number, nodeCount: number, signaturesRequired: number, redundancy?: number, ts?: number | bigint): Uint8Array;
 
+type Num = number | bigint | string;
+type Round = "halfEven" | "down" | "up" | "halfUp";
+declare const ref: (name: string) => Expr;
+/** A decimal constant, e.g. `cst("0.5")`. */
+declare const cst: (x: Num) => Expr;
+declare const strLit: (s: string) => Expr;
+declare const bytesLit: (hex: string) => Expr;
+declare const boolLit: (b: boolean) => Expr;
+/** Parse a string into a decimal; the mode says which spelling is acceptable. */
+declare const num: (a: Expr, mode?: "dec" | "hex" | "sci") => Expr;
+declare const int: (a: Expr) => Expr;
+declare const str: (a: Expr) => Expr;
+declare const hexBytes: (a: Expr) => Expr;
+declare const add: (a: Expr, b: Expr) => Expr;
+declare const sub: (a: Expr, b: Expr) => Expr;
+/** Multiplies; scales add and must stay within 36, so `rescale` an operand first if needed. */
+declare const mul: (a: Expr, b: Expr) => Expr;
+declare const min: (a: Expr, b: Expr) => Expr;
+declare const max: (a: Expr, b: Expr) => Expr;
+declare const neg: (a: Expr) => Expr;
+declare const abs: (a: Expr) => Expr;
+/** `a / b` to `scale` fractional digits. */
+declare const div: (a: Expr, b: Expr, o: {
+    scale: Num;
+    round?: Round;
+}) => Expr;
+declare const rescale: (a: Expr, o: {
+    scale: Num;
+    round?: Round;
+}) => Expr;
+/** Multiply by 10^n, exactly. */
+declare const shift: (a: Expr, n: Num) => Expr;
+declare const eq: (a: Expr, b: Expr) => Expr;
+declare const ne: (a: Expr, b: Expr) => Expr;
+declare const lt: (a: Expr, b: Expr) => Expr;
+declare const lte: (a: Expr, b: Expr) => Expr;
+declare const gt: (a: Expr, b: Expr) => Expr;
+declare const gte: (a: Expr, b: Expr) => Expr;
+declare const iff: (cond: Expr, a: Expr, b: Expr) => Expr;
+declare const coalesce: (a: Expr, b: Expr) => Expr;
+declare const keccak256: (a: Expr) => Expr;
+declare const concat: (...args: Expr[]) => Expr;
+declare const slice: (a: Expr, o: {
+    off: Num;
+    len: Num;
+}) => Expr;
+declare const lower: (a: Expr) => Expr;
+declare const upper: (a: Expr) => Expr;
+type Decode = Record<string, unknown>;
+declare const rawDecode: () => Decode;
+/** `fields` maps a name to a JSON path such as `$.data.price`. */
+declare const jsonDecode: (fields: Record<string, string>) => Decode;
+declare const textDecode: (fields: Record<string, string>) => Decode;
+declare const xmlDecode: (fields: Record<string, string>, namespaces?: Record<string, string>) => Decode;
+declare const csvDecode: (o: {
+    header?: boolean;
+    delimiter?: string;
+    trim?: boolean;
+    fields: Record<string, {
+        col: Num;
+        row: {
+            index: Num;
+        } | {
+            match: {
+                col: Num;
+                eq: string;
+            };
+        };
+    }>;
+}) => Decode;
+declare const abiDecode: (types: string[], fields: Record<string, string>) => Decode;
+declare const feltsDecode: (fields: Record<string, {
+    at: Num;
+    view: "felt" | "u256" | "bool" | "shortString" | "i128";
+}>) => Decode;
+declare const layoutDecode: (fields: Record<string, {
+    offset: Num;
+    type: string;
+}>, discriminator?: string | null) => Decode;
+interface Finality {
+    mode: "finalized" | "safe" | "confirmations";
+    lagMs: Num;
+    n?: Num;
+}
+declare function httpInput(o: {
+    url: string;
+    method?: "GET" | "POST";
+    headers?: Record<string, string>;
+    body?: {
+        contentType: string;
+        text: string;
+    };
+    decode: Decode;
+}): Record<string, unknown>;
+declare function evmCall(o: {
+    chain: string;
+    to: string;
+    sig?: string;
+    args?: string[];
+    data?: string;
+    finality: Finality;
+    decode: Decode;
+}): Record<string, unknown>;
+declare function evmStorage(o: {
+    chain: string;
+    address: string;
+    slot: string;
+    finality: Finality;
+    decode: Decode;
+}): Record<string, unknown>;
+declare function evmBalance(o: {
+    chain: string;
+    address: string;
+    finality: Finality;
+    decode: Decode;
+}): Record<string, unknown>;
+declare function starknetCall(o: {
+    chain: string;
+    contract: string;
+    selector: string;
+    calldata?: string[];
+    finality: Finality;
+    decode: Decode;
+}): Record<string, unknown>;
+declare function svmAccount(o: {
+    chain: string;
+    address: string;
+    commitment?: "finalized" | "confirmed";
+    maxAgeMs: Num;
+    dataSlice?: {
+        offset: Num;
+        length: Num;
+    };
+    decode: Decode;
+}): Record<string, unknown>;
+declare function svmTokenSupply(o: {
+    chain: string;
+    mint: string;
+    commitment?: "finalized" | "confirmed";
+    maxAgeMs: Num;
+}): Record<string, unknown>;
+interface SourceInput {
+    inputs: Record<string, Record<string, any>>;
+    transform: Expr;
+    assert?: Expr[];
+    output: {
+        type: OutputType;
+        decimals?: Num | null;
+    };
+    /** Median tolerance. Omit or `null` for exact mode. */
+    aggregation?: {
+        maxDeviationBps: Num;
+        maxAgeMs: Num;
+        mode?: "tolerance";
+        rule?: "median";
+    } | null;
+}
+/** The full-form document a {@link SourceInput} stands for. */
+declare function sourceDocFor(input: SourceInput): SourceDoc;
+/** Fill in the defaults of a short-form source and validate it. Throws a `SourceError` with a path. */
+declare function defineSource(input: SourceInput): ParsedSource;
+/**
+ * The common case: GET `url`, read the JSON value at `path`, scale it to `decimals`, and encode it as an
+ * int256. `valueIs: "string"` parses a JSON string such as `"65000.12"`; `"number"` (the default) takes
+ * a JSON number as is. Add `tolerance` to aggregate by median instead of requiring identical values.
+ */
+declare function jsonPriceSource(o: {
+    url: string;
+    path: string;
+    decimals: Num;
+    valueIs?: "number" | "string";
+    headers?: Record<string, string>;
+    tolerance?: {
+        maxDeviationBps: Num;
+        maxAgeMs: Num;
+    };
+}): ParsedSource;
+/** Tolerance mode needs at least this many signers; nodes and the gateway reject fewer. */
+declare const MIN_TOLERANCE_SIGNATURES = 3;
+/** Throws unless a tolerance source is asked for at least 3 signatures. No-op for exact mode. */
+declare function assertToleranceQuorum(src: ParsedSource, signaturesRequired: number): void;
+/** A {@link ParsedSource} as is; a source document (text or object) parsed and validated. */
+declare function asParsedSource(source: ParsedSource | string | object): ParsedSource;
+/**
+ * Render a signed 32-byte value for people, according to the source's output: a scaled integer with
+ * its decimal point, a bool, a string32's text, or hex. It is display only; nothing here is signed.
+ */
+declare function formatValue(valuePacked: string, output: {
+    type: OutputType;
+    decimals: number;
+}): string;
+/** Whether `preimageHex` hashes (keccak256) to the signed value, as a `keccak256` output requires. */
+declare function verifyPreimage(valuePacked: string, preimageHex: string): boolean;
+/**
+ * Solana programs known to write their accounts every slot (AMM pools, order books). The list is
+ * not exhaustive: it is for catching the common mistake, not for proving a source safe.
+ */
+declare const PER_SLOT_WRITE_PROGRAMS: Record<string, string>;
+interface LintFinding {
+    severity: "error" | "warning";
+    /** The input the finding is about. */
+    input: string;
+    message: string;
+}
+/**
+ * Advisory checks that need more than the schema. An svm account read in exact mode works only if the
+ * account changes slowly: nodes land on slots a few hundred ms apart, and exact mode signs only when
+ * every node decodes the same bytes. With `ownerOf` (an RPC lookup of the account's owner program) a
+ * read of an account owned by a known per-slot-write program is an error; without it every svm account
+ * read in exact mode is a warning.
+ */
+declare function lintSource(src: ParsedSource, opts?: {
+    ownerOf?: (chain: string, address: string) => Promise<string | undefined>;
+}): Promise<LintFinding[]>;
+
+type sourcebuild_Decode = Decode;
+type sourcebuild_Finality = Finality;
+type sourcebuild_LintFinding = LintFinding;
+declare const sourcebuild_MIN_TOLERANCE_SIGNATURES: typeof MIN_TOLERANCE_SIGNATURES;
+declare const sourcebuild_PER_SLOT_WRITE_PROGRAMS: typeof PER_SLOT_WRITE_PROGRAMS;
+type sourcebuild_Round = Round;
+type sourcebuild_SourceInput = SourceInput;
+declare const sourcebuild_abiDecode: typeof abiDecode;
+declare const sourcebuild_abs: typeof abs;
+declare const sourcebuild_add: typeof add;
+declare const sourcebuild_asParsedSource: typeof asParsedSource;
+declare const sourcebuild_assertToleranceQuorum: typeof assertToleranceQuorum;
+declare const sourcebuild_boolLit: typeof boolLit;
+declare const sourcebuild_bytesLit: typeof bytesLit;
+declare const sourcebuild_coalesce: typeof coalesce;
+declare const sourcebuild_concat: typeof concat;
+declare const sourcebuild_cst: typeof cst;
+declare const sourcebuild_csvDecode: typeof csvDecode;
+declare const sourcebuild_defineSource: typeof defineSource;
+declare const sourcebuild_div: typeof div;
+declare const sourcebuild_eq: typeof eq;
+declare const sourcebuild_evmBalance: typeof evmBalance;
+declare const sourcebuild_evmCall: typeof evmCall;
+declare const sourcebuild_evmStorage: typeof evmStorage;
+declare const sourcebuild_feltsDecode: typeof feltsDecode;
+declare const sourcebuild_formatValue: typeof formatValue;
+declare const sourcebuild_gt: typeof gt;
+declare const sourcebuild_gte: typeof gte;
+declare const sourcebuild_hexBytes: typeof hexBytes;
+declare const sourcebuild_httpInput: typeof httpInput;
+declare const sourcebuild_iff: typeof iff;
+declare const sourcebuild_int: typeof int;
+declare const sourcebuild_jsonDecode: typeof jsonDecode;
+declare const sourcebuild_jsonPriceSource: typeof jsonPriceSource;
+declare const sourcebuild_keccak256: typeof keccak256;
+declare const sourcebuild_layoutDecode: typeof layoutDecode;
+declare const sourcebuild_lintSource: typeof lintSource;
+declare const sourcebuild_lower: typeof lower;
+declare const sourcebuild_lt: typeof lt;
+declare const sourcebuild_lte: typeof lte;
+declare const sourcebuild_max: typeof max;
+declare const sourcebuild_min: typeof min;
+declare const sourcebuild_mul: typeof mul;
+declare const sourcebuild_ne: typeof ne;
+declare const sourcebuild_neg: typeof neg;
+declare const sourcebuild_num: typeof num;
+declare const sourcebuild_rawDecode: typeof rawDecode;
+declare const sourcebuild_ref: typeof ref;
+declare const sourcebuild_rescale: typeof rescale;
+declare const sourcebuild_shift: typeof shift;
+declare const sourcebuild_slice: typeof slice;
+declare const sourcebuild_sourceDocFor: typeof sourceDocFor;
+declare const sourcebuild_starknetCall: typeof starknetCall;
+declare const sourcebuild_str: typeof str;
+declare const sourcebuild_strLit: typeof strLit;
+declare const sourcebuild_sub: typeof sub;
+declare const sourcebuild_svmAccount: typeof svmAccount;
+declare const sourcebuild_svmTokenSupply: typeof svmTokenSupply;
+declare const sourcebuild_textDecode: typeof textDecode;
+declare const sourcebuild_upper: typeof upper;
+declare const sourcebuild_verifyPreimage: typeof verifyPreimage;
+declare const sourcebuild_xmlDecode: typeof xmlDecode;
+declare namespace sourcebuild {
+  export { sourcebuild_MIN_TOLERANCE_SIGNATURES as MIN_TOLERANCE_SIGNATURES, sourcebuild_PER_SLOT_WRITE_PROGRAMS as PER_SLOT_WRITE_PROGRAMS, sourcebuild_abiDecode as abiDecode, sourcebuild_abs as abs, sourcebuild_add as add, sourcebuild_asParsedSource as asParsedSource, sourcebuild_assertToleranceQuorum as assertToleranceQuorum, sourcebuild_boolLit as boolLit, sourcebuild_bytesLit as bytesLit, sourcebuild_coalesce as coalesce, sourcebuild_concat as concat, sourcebuild_cst as cst, sourcebuild_csvDecode as csvDecode, sourcebuild_defineSource as defineSource, sourcebuild_div as div, sourcebuild_eq as eq, sourcebuild_evmBalance as evmBalance, sourcebuild_evmCall as evmCall, sourcebuild_evmStorage as evmStorage, sourcebuild_feltsDecode as feltsDecode, sourcebuild_formatValue as formatValue, sourcebuild_gt as gt, sourcebuild_gte as gte, sourcebuild_hexBytes as hexBytes, sourcebuild_httpInput as httpInput, sourcebuild_iff as iff, sourcebuild_int as int, sourcebuild_jsonDecode as jsonDecode, sourcebuild_jsonPriceSource as jsonPriceSource, sourcebuild_keccak256 as keccak256, sourcebuild_layoutDecode as layoutDecode, sourcebuild_lintSource as lintSource, sourcebuild_lower as lower, sourcebuild_lt as lt, sourcebuild_lte as lte, sourcebuild_max as max, sourcebuild_min as min, sourcebuild_mul as mul, sourcebuild_ne as ne, sourcebuild_neg as neg, sourcebuild_num as num, sourcebuild_rawDecode as rawDecode, sourcebuild_ref as ref, sourcebuild_rescale as rescale, sourcebuild_shift as shift, sourcebuild_slice as slice, sourcebuild_sourceDocFor as sourceDocFor, sourcebuild_starknetCall as starknetCall, sourcebuild_str as str, sourcebuild_strLit as strLit, sourcebuild_sub as sub, sourcebuild_svmAccount as svmAccount, sourcebuild_svmTokenSupply as svmTokenSupply, sourcebuild_textDecode as textDecode, sourcebuild_upper as upper, sourcebuild_verifyPreimage as verifyPreimage, sourcebuild_xmlDecode as xmlDecode };
+  export type { sourcebuild_Decode as Decode, sourcebuild_Finality as Finality, sourcebuild_LintFinding as LintFinding, sourcebuild_Round as Round, sourcebuild_SourceInput as SourceInput };
+}
+
 /**
  * `timestamp` is unix MILLISECONDS, assigned by the gateway. Chain clocks (Solana `Clock`,
  * EVM `block.timestamp`), epoch windows and `maxAge`/staleness are measured in SECONDS, so
@@ -1536,7 +1913,8 @@ declare function feedPda(sourceId: Uint8Array, signaturesRequired: number, submi
 
 /** One feed to update. */
 interface BulkFeed {
-    apiConfig: APIConfig;
+    /** The source to update; parse it once (`defineSource`, `parseSource`) when updating many feeds. */
+    source: ParsedSource | string | object;
     signaturesRequired: number;
     /** Echoed in the result; for the caller's own bookkeeping. */
     label?: string;
@@ -1558,9 +1936,9 @@ interface BulkOptions {
     submitConcurrency?: number;
     /**
      * Options applied to every request (subscription owner, signer, `maxRetries`, `timeoutMs`, ...).
-     * `apiConfig`, `signaturesRequired` and `context` are set per feed.
+     * `source`, `signaturesRequired` and `context` are set per feed.
      */
-    request?: Omit<RequestSignedDataOptions, "apiConfig" | "signaturesRequired" | "context">;
+    request?: Omit<RequestSignedDataOptions, "source" | "signaturesRequired" | "context">;
     /** Called as each feed finishes, in completion order. */
     onResult?: (result: BulkResult) => void;
     /** Stops starting new feeds; those already started finish. */
@@ -1673,4 +2051,5 @@ declare class MolphaSDK {
     }>;
 }
 
-export { APIConfig, AdaptiveLimiter, AggregationConfig, AggregationConfigError, AssetDomain, Attestation, type AttestationMessageFields, BatchTooLargeError, type BuildEvmVerifierArgsOptions, type BuildStarknetVerifierArgsOptions, type BulkFeed, type BulkOptions, type BulkResult, type CoalitionKey, DEFAULT_GATEWAY_ENDPOINT, DEFAULT_MAX_RETRIES, DEFAULT_ROUND_TIMEOUT_MS, EIP712_DOMAIN_TYPEHASH, type Eip712Domain, type EvmAttestation, type EvmAttestationPayload, type EvmSchnorrSignature, EvmSigner, type EvmVerifierArgs, type EvmVerifyResult, type FeedAccount, type GatewayEndpoint, type GatewayEndpointInput, GatewayError, type GatewayInfo, INT256_MAX, INT256_MIN, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_DEV_VERIFIERS_PROVISIONAL, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_SDK_PROFILE, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, type MolphaEvmNetwork, MolphaGateway, type MolphaGatewayOptions, MolphaSDK, type MolphaSDKOptions, MolphaSolanaClient, type MolphaStarknetNetwork, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, NodesInfo, type PlanId, type PlanInfo, PlanType, REQUEST_AUTH_DOMAIN, ROUND_TICK_MS, RegistrySelectionConfig, type RegistryStateView, type RegistryView, type RequestAuthFields, type RequestSignedDataOptions, type RetryCause, type RoundContext, SELECTION_WINDOW_MS, SUBMIT_INSTRUCTION_DATA_BYTES, type Secp256k1KeyInput, Signer, SourcePaymentOptions, type StarknetAttestation, type StarknetAttestationPayload, type StarknetFeltLike, type StarknetSchnorrSignature, type StarknetVerifierArgs, type StarknetVerifyResult, type SubmitAttestationArgs, type SubmitAttestationOptions, type SubmitAttestationsOptions, type SubmitAttestationsResult, SubmitFailedError, type SubmitResult, type SubscribeResult, type SubscriptionInfo, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, type TransferAuthorization, UpstreamPaymentRequiredError, UpstreamQuote, UpstreamTerms, VERIFY_CODES, type VerifyCode, type VerifyCodeName, addressToBytes, assertAggregationQuorum, attestationMessageHash, attestationMessageHashFromAttestation, base64ToBytes, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, buildSubmitAttestationArgs, bytesToBase64, bytesToHex, bytesToHex0x, canonicalizeAPIConfig, canonicalizeAggregation, commitmentAddressToStarknetFelt, computeCoalitionKey, concatBytes, createEvmSignerFromPrivateKey, decodeInt256, deriveGatewayPda, deriveGatewayPdaAddress, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, deriveSourceId, deriveSourceIdString, domainSeparator, effectiveSelectionSize, eligibleSetSize, encodeEvmVerifyCalldata, encodeInt256, encodeInt256Decimal, encodeRequestAuth, encodeStarknetVerifyCalldata, ensureLength, estimateSubmitBatchComputeUnits, estimateSubmitComputeUnits, estimateSubmitTransactionSize, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, maxAttestationsPerTransaction, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, requestMany, resolveRemainingAccounts, retryDelayMs, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, spreadOffsetMs, subscriptionPda, timestampAgeSeconds, timestampSeconds, toChecksumAddress, toFixedBytes, toFixedHex, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName };
+export { AdaptiveLimiter, AssetDomain, Attestation, BatchTooLargeError, CHAIN_LIST, DEFAULT_GATEWAY_ENDPOINT, DEFAULT_MAX_RETRIES, DEFAULT_ROUND_TIMEOUT_MS, EIP712_DOMAIN_TYPEHASH, EvmSigner, GatewayError, INT256_MAX, INT256_MIN, MAX_ASSERTS, MAX_BODY_TEXT, MAX_CANONICAL_BYTES, MAX_DECIMAL_SCALE, MAX_EXPR_DEPTH, MAX_EXPR_NODES, MAX_FIELDS, MAX_HEADERS, MAX_HEADER_VALUE, MAX_INPUTS, MAX_OUTPUT_DECIMALS, MAX_PRIVATE_BYTES, MAX_RESPONSE_BYTES, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_DEV_VERIFIERS_PROVISIONAL, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_SDK_PROFILE, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, MolphaGateway, MolphaSDK, MolphaSolanaClient, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, NodesInfo, OUTPUT_TYPES, PER_SLOT_WRITE_PROGRAMS, PlanType, REQUEST_AUTH_DOMAIN, ROUND_TICK_MS, RegistrySelectionConfig, SELECTION_WINDOW_MS, SOURCE_VERSION, SUBMIT_INSTRUCTION_DATA_BYTES, Signer, SourceError, SourcePaymentOptions, SubmitFailedError, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, UpstreamPaymentRequiredError, UpstreamQuote, UpstreamTerms, VERIFY_CODES, addressToBytes, asParsedSource, assertToleranceQuorum, attestationMessageHash, attestationMessageHashFromAttestation, base64ToBytes, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, buildSubmitAttestationArgs, bytesToBase64, bytesToHex, bytesToHex0x, canonicalJson, canonicalize, checkChains, commitmentAddressToStarknetFelt, computeCoalitionKey, concatBytes, createEvmSignerFromPrivateKey, decodeInt256, defineSource, deriveGatewayPda, deriveGatewayPdaAddress, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, deriveSourceId, deriveSourceIdHex, domainSeparator, effectiveSelectionSize, eligibleSetSize, encodeEvmVerifyCalldata, encodeInt256, encodeInt256Decimal, encodeRequestAuth, encodeSourceBytes, encodeStarknetVerifyCalldata, ensureLength, estimateSubmitBatchComputeUnits, estimateSubmitComputeUnits, estimateSubmitTransactionSize, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, formatValue, fromPlain, gatewayPda, getMolphaStarknetVerifierAddress, hasPreimage, hashRequestAuth, hexToBytes, jsonPriceSource, lintSource, maxAttestationsPerTransaction, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseCanonicalSource, parseEvmVerifyResult, parseGatewayInfo, parsePrivateSource, parseSource, parseStarknetVerifyResult, parseStrict, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, requestMany, resolveRemainingAccounts, retryDelayMs, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, sourceDocFor, sourceIdOf, splitURL, spreadOffsetMs, subscriptionPda, sourcebuild as sx, timestampAgeSeconds, timestampSeconds, toChecksumAddress, toFixedBytes, toFixedHex, toPlain, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName, verifyPreimage };
+export type { AggregationDoc, AttestationMessageFields, BuildEvmVerifierArgsOptions, BuildStarknetVerifierArgsOptions, BulkFeed, BulkOptions, BulkResult, Chain, CoalitionKey, Decode, Eip712Domain, EvmAttestation, EvmAttestationPayload, EvmSchnorrSignature, EvmVerifierArgs, EvmVerifyResult, Expr, FeedAccount, Finality, GatewayEndpoint, GatewayEndpointInput, GatewayInfo, JObj, Json, LintFinding, MolphaEvmNetwork, MolphaGatewayOptions, MolphaSDKOptions, MolphaStarknetNetwork, OutputDoc, OutputType, ParsedSource, PlanId, PlanInfo, RegistryStateView, RegistryView, RequestAuthFields, RequestSignedDataOptions, RetryCause, Round, RoundContext, Secp256k1KeyInput, SourceDoc, SourceErrorClass, SourceInput, StarknetAttestation, StarknetAttestationPayload, StarknetFeltLike, StarknetSchnorrSignature, StarknetVerifierArgs, StarknetVerifyResult, SubmitAttestationArgs, SubmitAttestationOptions, SubmitAttestationsOptions, SubmitAttestationsResult, SubmitResult, SubscribeResult, SubscriptionInfo, TransferAuthorization, URLParts, VerifyCode, VerifyCodeName };