@molpha/sdk 0.2.0-dev-20261008064918 → 0.2.0-dev-20261010184043

package/README.md

@@ -193,30 +193,46 @@ A `programId` that differs from the client's is rejected. Because the hash diffe
 
 ### Round timestamp
 
-The request body carries `authSig` and `authTimestamp` but no round timestamp. The gateway assigns the
-round's `timestamp` from its own clock, in unix **milliseconds**, on a tick grid
-(`floor(now / tickMs) * tickMs`, one second by default), and the result carries it in
-`payload.timestamp`. Committee selection reads only the timestamp's one-second window, so
+The request body carries `authSig` and `authTimestamp` but no round timestamp. The gateway stamps the
+round with its own clock, in unix **milliseconds**, floored to a fixed 100 ms tick
+(`floor(nowMs / 100) * 100`), and the result carries the stamp in `payload.timestamp`. The tick is a
+protocol constant, exported as `ROUND_TICK_MS`: it is the same on every gateway and node, it is not
+configurable, and `GET /v1/info` does not report it. Stamping does not wait for a tick boundary, so
+it adds no latency. Committee selection reads only the timestamp's one-second window (ten ticks), so
 nobody can pick a committee by picking a time.
 
+- One feed (a source, a quorum and a registry version) runs at most 10 rounds per second, whatever
+  the request rate.
+- Requests for the same feed inside one tick share one round: the nodes run it once and every caller
+  gets the result. Each caller still spends its own unit of round quota, or its own payment.
+- One consumer gets one round per tick per feed, so at most 10 per second. A second request by the
+  same consumer for the same source and quorum inside the tick is refused with HTTP 409; the SDK
+  retries it after one tick.
 - The message the nodes sign is `keccak256(MOLPHA_MESSAGE_V1 || value || sourceId || u32be(registryVersion) || u8(quorum) || u64be(timestamp) || signersBitmap)`.
 - Chain clocks, epochs and `maxAge`/staleness are in **seconds**: compare with
   `timestampSeconds(payload.timestamp)` (floored `ts / 1000`). `timestampAgeSeconds(ts, nowSeconds)` saturates at 0.
-- A round that was already reserved for this consumer, or dispatched to the nodes, cannot run again in the same tick (HTTP 409), so a retry waits for the next one. `tickMs` defaults to the gateway's advertised `tickMs` (read once, on the first retry, from `GET /v1/info`), else 1000.
+- The SDK returns `payload.timestamp` exactly as the gateway gave it. Nodes enforce the grid when
+  they sign; the on-chain verifiers do not check it.
 
 ### Retries and timeouts
 
-`requestSignedData` makes up to `maxRetries` attempts (default 6) and chooses the wait before each by why the last one failed (`retryDelayMs`). Every wait reaches at least the next tick, then adds jitter so clients that failed together do not retry together:
+`requestSignedData` makes up to `maxRetries` attempts (default 6) and chooses the wait before each by why the last one failed (`retryDelayMs`). Every wait carries jitter so clients that failed together do not retry together. The backoff step is a capped exponential: 250 ms, 500 ms, up to 5 s.
 
 | Last attempt | Wait before the next |
 | --- | --- |
-| 409 (this consumer already has a round for the source in this tick) | next tick, plus up to half a tick |
-| 503 or 429 (gateway at capacity, or nodes unavailable) | the later of the next tick and the gateway's `Retry-After`, plus up to a tick |
-| timeout, network error, other 5xx | capped exponential backoff (250 ms up to 5 s), half of it randomized |
+| 409 (this consumer already has a round for the source and quorum in the current tick) | one tick (`ROUND_TICK_MS`, 100 ms), plus up to 20 ms |
+| 503 or 429 (gateway at capacity, or too few nodes accepted the round) | the later of the gateway's `Retry-After` and the backoff step, plus up to one more step |
+| timeout, network error, other 5xx | the backoff step, half of it randomized |
 | 400, 401, 402, 403 | none: terminal. 403 means the subscription is inactive or its round quota for the term is spent |
 
 A 400 saying the `registryVersion` is not the current one (a cached context, or a registry roll between your read and the request) is the exception: the SDK reads the registry afresh and retries once, without spending an attempt.
 
+The wait after a 409 is a full tick rather than the time left to the next boundary: a full tick puts the retry in a later tick whatever the offset between the client's clock and the gateway's, so the SDK never computes a boundary from the local clock. A caller polling one feed gains nothing by asking more often than once per tick: space the requests at least `ROUND_TICK_MS` apart.
+
+A retry is a new request, and the gateway stamps it anew, so it is a **new round**: it spends another unit of round quota or needs another payment, and with a paywalled source another set of payment authorizations. Nothing ties a retry to the attempt before it; there is no idempotency key. Set `maxRetries: 1` to make a single attempt and decide about a retry yourself.
+
+The gateway limits the total load: at capacity it answers HTTP 503 with a `Retry-After`, and a consumer over its request rate gets HTTP 429. It also answers 503 when too few nodes accept a round. The SDK treats them alike: it backs off and retries, and throws a `GatewayError` with the status when the attempts run out.
+
 `timeoutMs` defaults to 35 s, above the gateway's own wait for a round (`roundTimeoutSeconds` in `/v1/info`, 30 s by default). A shorter timeout abandons a round the gateway is still running, and the retry then starts another. A source that cannot be fetched is reported as soon as enough nodes have failed (usually well under a second), not after the wait.
 
 ## Wallet
@@ -403,6 +419,34 @@ for (const r of results) {
 
 It reads the registry inputs once for the whole batch; bounds concurrency, starting from half the gateway's advertised `maxInflightRounds` (at most 64, else 32) and adapting (halving on a busy answer, growing back while requests succeed); runs Solana submits on their own smaller limiter (`submitConcurrency`, default 8); never discards the signed attestation of a round whose submit failed; and returns one result per feed in input order, so a failing feed does not stop the others. Pass `submit: false` to collect attestations only. Throughput is limited by the submit path (one transaction per attestation) long before it is limited by the gateway.
 
+### Batching attestations of one feed
+
+At a high update rate, submit several attestations of the same feed in one transaction:
+
+```ts
+const { signature, count } = await sdk.solana.submitAttestations([older, newer, newest]);
+```
+
+Each becomes its own `submit_attestation` instruction, sorted by timestamp, and instructions run in
+the order they are listed, so every attestation is applied, oldest first. Separate transactions give
+no such order. Sent a few hundred milliseconds apart they reach a leader in a different order often
+enough (about a third at 250 ms spacing in a devnet run) that the older one is refused with
+`FeedNotNewer`; a batch makes the spacing between transactions several times longer, and one
+transaction costs one fee.
+
+- All attestations must be for one feed (the same `sourceId` and `signaturesRequired`), with distinct
+  timestamps. They may differ in registry version and signer set.
+- The transaction is atomic. If a newer attestation of the feed has already landed, every
+  instruction is stale and none applies, so batch what is due together and send batches of one feed
+  in order.
+- A transaction holds 1232 bytes, which is about three attestations with three signers, two with
+  four or five. `maxAttestationsPerTransaction(signerCount, { distinctSigners })` estimates it, and a
+  batch that does not fit throws `BatchTooLargeError` before sending, with `fits` saying how many
+  go: submit those and the rest apart. A priority-fee instruction costs bytes too.
+- `rawValue` is not supported in a batch; use `submitAttestation` for values longer than 32 bytes.
+- An attestation waits for the others in its batch, so a batch of `n` made at an interval of `t`
+  delays the oldest by `(n - 1) * t`.
+
 ### Fast requests with a cached context
 
 By default every `requestSignedData` call reads the on-chain registry up front
@@ -917,7 +961,7 @@ Current scope:
 
 - Solana subscription and extend flow;
 - deterministic source id and attestation message hashing;
-- gateway signed-data requests (failover, tick-aware retries, per-gateway request auth, context cache);
+- gateway signed-data requests (failover, retries with backoff, per-gateway request auth, context cache);
 - Solana attestation submission and feed/registry reads;
 - private API encryption helpers (pre-production);
 - caller-funded x402 payments for paywalled API sources (Base USDC, pre-production);

package/dist/index.d.ts

@@ -40,8 +40,6 @@ interface GatewayInfo {
     gatewayAuthority: string;
     /** Program id the gateway settles against; must match the client's when present. */
     programId?: string;
-    /** The gateway's round timestamp grid in milliseconds (`round.tick_ms`), when advertised. */
-    tickMs?: number;
     /** Longest the gateway waits for a round, in seconds (`node.agg_wait_seconds`), when advertised. */
     roundTimeoutSeconds?: number;
     /** Rounds the gateway runs at once (`limits.max_inflight_rounds`); 0 or absent: not advertised. */
@@ -165,17 +163,12 @@ interface RequestSignedDataOptions {
     /** Max accepted value age in seconds. Default 60. */
     maxAge?: number;
     /**
-     * Max attempts. Each retry waits for a later gateway tick, plus jitter, and for longer after a
-     * busy answer (`Retry-After`) or a failure that is not a conflict (capped exponential backoff);
-     * see {@link retryDelayMs}. Default {@link DEFAULT_MAX_RETRIES}.
+     * Max attempts. The wait before each retry depends on why the last attempt failed: one round
+     * tick after a duplicate (HTTP 409), the gateway's `Retry-After` or a capped exponential backoff
+     * after a busy answer, the backoff after anything else; see {@link retryDelayMs}. Every attempt
+     * the gateway accepts spends another unit of round quota. Default {@link DEFAULT_MAX_RETRIES}.
      */
     maxRetries?: number;
-    /**
-     * The gateway's tick grid in milliseconds (its `round.tick_ms`). A retry waits for the start of
-     * the next tick so it is a new round, not a duplicate of the last. Default: the gateway's
-     * advertised `tickMs` (read once, on the first retry), else 1000.
-     */
-    tickMs?: number;
     /**
      * Per-request timeout in ms. Default {@link DEFAULT_ROUND_TIMEOUT_MS}, above the gateway's own
      * wait for a round: a shorter timeout abandons rounds the gateway is still running and the retry
@@ -228,6 +221,8 @@ interface MolphaGatewayOptions {
     allowUnverifiedNodeKeysForPrivateApi?: boolean;
     /** Source of randomness in [0, 1) for retry jitter; defaults to `Math.random` (tests only). */
     random?: () => number;
+    /** Waits `ms` before a retry; defaults to a `setTimeout` timer (tests only). */
+    sleep?: (ms: number) => Promise<void>;
 }
 /**
  * The slow-changing inputs a `requestSignedData` round binds to. Fetch once with
@@ -237,8 +232,6 @@ interface RoundContext extends RegistrySelectionConfig {
     /** Full registry node set: private API secrets are encrypted for every node in it. */
     nodes: Node[];
 }
-/** Milliseconds from `nowMs` to the start of the next tick, plus a millisecond of margin. */
-declare function msUntilNextTick(nowMs: number, tickMs: number): number;
 /**
  * Default per-request timeout: above the gateway's own wait for a round (`node.agg_wait_seconds`,
  * 30 s by default), so the client does not abandon a round the gateway is still running and then
@@ -249,9 +242,10 @@ declare const DEFAULT_ROUND_TIMEOUT_MS = 35000;
 declare const DEFAULT_MAX_RETRIES = 6;
 /**
  * Why an attempt failed, as far as it decides how long to wait before the next one:
- *  - `conflict`: HTTP 409, this consumer already has a round for the source in this tick;
- *  - `busy`: HTTP 503 or 429, the gateway is at capacity or a node set is unavailable, optionally
- *    with the gateway's `Retry-After`;
+ *  - `conflict`: HTTP 409, this consumer already has a round for the source and quorum in the
+ *    current round tick;
+ *  - `busy`: HTTP 503 or 429, the gateway is at capacity, or too few nodes accepted the round
+ *    (unavailable, or busy), optionally with the gateway's `Retry-After`;
  *  - `error`: anything else that may be transient (timeout, network, other 5xx).
  */
 type RetryCause = {
@@ -263,16 +257,17 @@ type RetryCause = {
     kind: "error";
 };
 /**
- * How long to wait before the next attempt, in ms. Every delay reaches at least the start of the
- * next tick (a retry inside the tick that just failed would be a duplicate round), then adds jitter
- * so clients that failed together do not retry together:
- *  - conflict: the next tick plus up to half a tick;
- *  - busy: the later of the next tick and the gateway's `Retry-After` (a tick if absent), plus up to
- *    a tick;
- *  - error: capped exponential backoff (250 ms, 500 ms, ... 5 s) with half of it randomized.
- * `failures` is the number of attempts that have failed so far (1 after the first).
+ * How long to wait before the next attempt, in ms. Each delay carries jitter, so clients that
+ * failed together do not retry together:
+ *  - conflict: one full round tick ({@link ROUND_TICK_MS}) plus up to 20 ms. The gateway stamps a
+ *    round with the tick it is in, so a retry a full tick later is in a later tick whatever the
+ *    offset between the two clocks: no boundary is computed from the local clock;
+ *  - busy: the later of the gateway's `Retry-After` and the backoff step, plus up to one more step;
+ *  - error: the backoff step, half of it randomized.
+ * The backoff step is a capped exponential (250 ms, 500 ms, ... 5 s). `failures` is the number of
+ * attempts that have failed so far (1 after the first).
  */
-declare function retryDelayMs(cause: RetryCause, failures: number, nowMs: number, tickMs: number, random?: () => number): number;
+declare function retryDelayMs(cause: RetryCause, failures: number, random?: () => number): number;
 
 /** Thrown for terminal gateway errors (400/401) — never retried. */
 declare class GatewayError extends Error {
@@ -292,9 +287,8 @@ declare class MolphaGateway {
     private readonly programIdBytes;
     /** Gateway PDA per endpoint URL; resolved once per client lifetime. */
     private readonly gatewayPdas;
-    /** Advertised timing per endpoint URL, read lazily on the first retry. */
-    private readonly advertisedInfo;
     private readonly random;
+    private readonly sleep;
     constructor(endpoints?: GatewayEndpointInput | GatewayEndpointInput[], getRegistrySelectionConfig?: () => Promise<RegistrySelectionConfig>, defaultSigner?: Signer, 
     /**
      * Either a default subscription owner (base58) or gateway options. A string is the
@@ -337,10 +331,13 @@ declare class MolphaGateway {
      * 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 gateway assigns the round's `timestamp` (unix milliseconds) from its own clock
-     * on a tick grid, and the committee follows from it. The result carries the assigned
-     * timestamp and the signers' bitmap. A retry waits for a later tick, because a round that was
-     * already reserved or dispatched cannot run again in the same one (HTTP 409).
+     * 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
+     * gateway gave it. Requests for the same source, quorum and registry version inside one tick
+     * share one round. One consumer gets one round per tick per source and quorum: a second request
+     * in the tick is refused (HTTP 409) and retried one tick later. A retry is stamped anew, so it
+     * is a new round that spends another unit of round quota.
      *
      * The request is authorized by a `RequestAuth` signature (`authSig`) over the program id, the
      * endpoint's Gateway PDA, the source id, the quorum and `authTimestamp` (unix seconds, read
@@ -370,12 +367,6 @@ declare class MolphaGateway {
      * encryption) or when nothing else can tell us the node count.
      */
     private resolveContext;
-    /**
-     * The gateway's advertised tick grid, read once per endpoint and only when a retry needs it. Any
-     * failure (an old gateway without `/v1/info`, a timeout) means "not advertised", so the caller
-     * falls back to the default; a failure is not cached.
-     */
-    private advertisedTickMs;
     /** Gateway PDA bytes for an endpoint, cached per URL. A failed lookup is not cached. */
     private resolveGatewayPda;
     private lookupGatewayPda;
@@ -479,6 +470,33 @@ declare function planIdFromVariant(variant: Record<string, unknown>): PlanId;
  * benchmark's, and a limit that is hit fails the transaction for good.
  */
 declare function estimateSubmitComputeUnits(signerCount: number): number;
+/**
+ * Compute-unit limit for one transaction that carries a `submit_attestation` per entry of
+ * `signerCounts`: the same margin as {@link estimateSubmitComputeUnits} on the sum, with the fixed
+ * 10k once for the transaction.
+ */
+declare function estimateSubmitBatchComputeUnits(signerCounts: number[]): number;
+/**
+ * Bytes of `submit_attestation` instruction data with no raw value: the 8 byte discriminator, the
+ * payload (32 + 32 + 4 + 1 + 8), the signature (32 + 20 + 32), the empty `Option` and the coalition
+ * key (32 + 32).
+ */
+declare const SUBMIT_INSTRUCTION_DATA_BYTES = 234;
+/**
+ * Serialized size of a transaction with `count` attestations of `signerCount` signers each, to plan
+ * a batch before there is one. The signer `Node` accounts are shared between attestations, so the
+ * size depends on how many distinct ones there are: `distinctSigners` (default `signerCount`, the
+ * best case; the registry's node count is the worst).
+ */
+declare function estimateSubmitTransactionSize(count: number, signerCount: number, opts?: {
+    distinctSigners?: number;
+    priorityFee?: boolean;
+}): number;
+/** The most attestations of `signerCount` signers that fit in one transaction; see {@link estimateSubmitTransactionSize}. */
+declare function maxAttestationsPerTransaction(signerCount: number, opts?: {
+    distinctSigners?: number;
+    priorityFee?: boolean;
+}): number;
 type Commitment$1 = NonNullable<ConstructorParameters<typeof AnchorProvider>[2]>["commitment"];
 interface SubscribeResult {
     signature: string;
@@ -516,6 +534,31 @@ interface SubmitResult {
     /** Feed PDA written by this submit (`["molpha_feed", sourceId, [signaturesRequired], submitter]`). */
     feed: Address;
 }
+/** What {@link MolphaSolanaClient.submitAttestations} returns. */
+interface SubmitAttestationsResult extends SubmitResult {
+    /** Attestations in the transaction. They were applied in timestamp order. */
+    count: number;
+}
+/**
+ * Thrown by {@link MolphaSolanaClient.submitAttestations} when the attestations do not fit in one
+ * transaction. Nothing was sent: submit the first `fits` of them (oldest first) and the rest apart.
+ */
+declare class BatchTooLargeError extends RangeError {
+    /** How many of the attestations, oldest first, do fit. */
+    readonly fits: number;
+    /** The serialized size of the whole batch, in bytes. */
+    readonly size: number;
+    /** The largest transaction the network accepts, in bytes. */
+    readonly limit: number;
+    readonly count: number;
+    constructor(
+    /** How many of the attestations, oldest first, do fit. */
+    fits: number, 
+    /** The serialized size of the whole batch, in bytes. */
+    size: number, 
+    /** The largest transaction the network accepts, in bytes. */
+    limit: number, count: number);
+}
 /**
  * On-chain `Feed` (Anchor-decoded). `value` is always the signed
  * `AttestationPayload.value` (32 bytes): the oracle value itself when `valueKind` is
@@ -586,6 +629,8 @@ interface SubmitAttestationOptions {
      */
     rawValue?: Uint8Array;
 }
+/** Options for {@link MolphaSolanaClient.submitAttestations}. */
+type SubmitAttestationsOptions = Pick<SubmitAttestationOptions, "computeUnitLimit" | "priorityFeeMicroLamports">;
 interface CreateClientOpts {
     connection: SolanaConnection;
     wallet: Wallet;
@@ -668,6 +713,33 @@ declare class MolphaSolanaClient {
      * `keccak256(rawValue)`; {@link buildSubmitAttestationArgs} validates that before send.
      */
     submitAttestation(attestation: Attestation, opts?: SubmitAttestationOptions): Promise<SubmitResult>;
+    /**
+     * Submit several attestations of one feed in one transaction.
+     *
+     * Each becomes its own `submit_attestation` instruction, in timestamp order, and instructions run
+     * in the order they are listed: all of them are applied, oldest first, whatever order other
+     * transactions reach the leader in. That is what separate submits cannot promise. Transactions sent
+     * milliseconds apart for one feed are overtaken by a newer one often enough (about a third at 250 ms
+     * spacing in a devnet run) that the older one fails with `FeedNotNewer`; a batch makes the spacing
+     * between transactions several times longer and spends one fee and one signature for them all.
+     *
+     * The transaction is atomic: if one instruction fails (typically because a newer attestation
+     * of the feed landed first, so every instruction is stale) none of them applies. Batch only what
+     * is due together, and keep batches of one feed in the order they were made.
+     *
+     * All attestations must be for one feed (the same `sourceId` and `signaturesRequired`) with
+     * distinct timestamps. They need not share a registry version or a signer set. Values longer than
+     * 32 bytes (`rawValue`) are not supported here: submit those with {@link submitAttestation}.
+     *
+     * @throws {BatchTooLargeError} when they do not fit in one transaction (about three do with
+     *   three signers; see {@link maxAttestationsPerTransaction}). Nothing is sent.
+     */
+    submitAttestations(attestations: Attestation[], opts?: SubmitAttestationsOptions): Promise<SubmitAttestationsResult>;
+    /**
+     * Everything one `submit_attestation` instruction needs: the arguments, the named accounts, the
+     * signer `Node` accounts (ascending bit order) and the feed address.
+     */
+    private prepareSubmit;
     /** The registry for `version`, reused for {@link REGISTRY_CACHE_MS}. */
     private fetchRegistryCached;
     private resolvePriorityFee;
@@ -877,6 +949,15 @@ declare function deriveSelectionBitmap(sourceId: Uint8Array, registryVersion: nu
  * EVM `block.timestamp`), epoch windows and `maxAge`/staleness are measured in SECONDS, so
  * anything that compares the two must go through {@link timestampSeconds}.
  */
+/**
+ * The round tick in milliseconds: the gateway stamps a round with its clock floored to this grid
+ * (`floor(nowMs / ROUND_TICK_MS) * ROUND_TICK_MS`) and nodes reject a round whose timestamp is off
+ * it. A feed (source, quorum, registry version) therefore runs at most ten rounds per second, and
+ * every selection window (`SELECTION_WINDOW_MS`, one second) holds exactly ten ticks. A
+ * protocol constant, the same in every gateway and node: not configuration, and not reported by
+ * `GET /v1/info`.
+ */
+declare const ROUND_TICK_MS = 100;
 /** `timestamp` (unix ms) as whole unix seconds, floored. */
 declare function timestampSeconds(timestamp: number | bigint): number;
 /**
@@ -1467,8 +1548,8 @@ interface BulkOptions {
      */
     concurrency?: number;
     /**
-     * Spread request starts over this many ms by a hash of the feed's source id. Feeds that are due on
-     * the same tick otherwise arrive together and queue at the gateway. Default 0 (no spreading).
+     * Spread request starts over this many ms by a hash of the feed's source id. Feeds that are due at
+     * the same moment otherwise arrive together and queue at the gateway. Default 0 (no spreading).
      */
     spreadMs?: number;
     /** Submit each attestation to Solana after its round. Default true. */
@@ -1592,4 +1673,4 @@ declare class MolphaSDK {
     }>;
 }
 
-export { APIConfig, AdaptiveLimiter, AggregationConfig, AggregationConfigError, AssetDomain, Attestation, type AttestationMessageFields, 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, RegistrySelectionConfig, type RegistryStateView, type RegistryView, type RequestAuthFields, type RequestSignedDataOptions, type RetryCause, type RoundContext, SELECTION_WINDOW_MS, type Secp256k1KeyInput, Signer, SourcePaymentOptions, type StarknetAttestation, type StarknetAttestationPayload, type StarknetFeltLike, type StarknetSchnorrSignature, type StarknetVerifierArgs, type StarknetVerifyResult, type SubmitAttestationArgs, type SubmitAttestationOptions, 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, estimateSubmitComputeUnits, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, msUntilNextTick, 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 { 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 };