@molpha/sdk 0.2.0-dev-20261002062009 → 0.2.0-dev-20261005191253

package/dist/index.js

@@ -1,10 +1,10 @@
-import { toPublicKey, addressBytes, toSolanaAddress, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS, setComputeUnitLimit, addressFromBytes, findProgramAddressSync } from './chunk-2X22JY7Q.js';
+import { toPublicKey, addressBytes, toSolanaAddress, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS, setComputeUnitLimit, setComputeUnitPrice, addressFromBytes, findProgramAddressSync } from './chunk-H77BBZOL.js';
 import { getAddressEncoder, address, getProgramDerivedAddress } from '@solana/kit';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { utf8ToBytes, hexToBytes as hexToBytes$1, concatBytes as concatBytes$1, bytesToHex as bytesToHex$1, randomBytes } from '@noble/hashes/utils.js';
 import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { gcm } from '@noble/ciphers/aes.js';
-import { AnchorProvider, Program } from '@anchor-lang/core';
+import { AnchorProvider, Program, web3 } from '@anchor-lang/core';
 import BN from 'bn.js';
 import { ed25519 } from '@noble/curves/ed25519.js';
 
@@ -313,18 +313,19 @@ function secp256k1PublicKeyFromCoordinates(x, y, label = "secp256k1 public key c
 }
 var SELECTION_SEED_DOMAIN = keccak_256(utf8("MOLPHA_SELECTION_V1"));
 var SELECTION_DERIVE_DOMAIN = keccak_256(utf8("MOLPHA_SELECTION_DERIVE"));
+var SELECTION_WINDOW_MS = 1000n;
 var MAX_ROUNDS = 65536;
 var BITMAP_BYTES = 32;
 var MAX_NODES = BITMAP_BYTES * 8;
 var U32_MAX = 4294967295;
-function deriveSelectionSeed(sourceId, registryVersion, canonicalTimestamp) {
+function deriveSelectionSeed(sourceId, registryVersion, timestamp) {
   ensureLength(sourceId, 32, "sourceId");
   return keccak_256(
     concatBytes(
       SELECTION_SEED_DOMAIN,
       sourceId,
       u32be(registryVersion),
-      u64be(canonicalTimestamp)
+      u64be(BigInt(timestamp) / SELECTION_WINDOW_MS)
     )
   );
 }
@@ -390,7 +391,7 @@ function deriveGroupBitmap(seed, nodeCount, groupSize) {
   }
   return bitmap;
 }
-function deriveSelectionBitmap(sourceId, registryVersion, nodeCount, signaturesRequired, redundancy = 0, ts = Math.floor(Date.now() / 1e3)) {
+function deriveSelectionBitmap(sourceId, registryVersion, nodeCount, signaturesRequired, redundancy = 0, ts = Date.now()) {
   const seed = deriveSelectionSeed(sourceId, registryVersion, ts);
   const size = effectiveSelectionSize(signaturesRequired, redundancy, nodeCount);
   return deriveGroupBitmap(seed, nodeCount, size);
@@ -405,7 +406,7 @@ function encodeRequestAuth(fields) {
     ensureLength(fields.gateway, 32, "gateway"),
     toFixedBytes(fields.sourceId, 32, "sourceId"),
     Uint8Array.of(fields.signaturesRequired),
-    u64le(fields.timestamp)
+    u64le(fields.authTimestamp)
   );
 }
 function hashRequestAuth(fields) {
@@ -774,11 +775,57 @@ function parseGatewayInfo(data) {
   if (programId !== void 0 && typeof programId !== "string") {
     throw new Error("GET /v1/info programId must be a base58 string");
   }
-  return programId === void 0 ? { gatewayAuthority } : { gatewayAuthority, programId };
+  const info = { gatewayAuthority };
+  if (programId !== void 0) info.programId = programId;
+  const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : void 0;
+  const tickMs = positive(record.tickMs);
+  if (tickMs !== void 0) info.tickMs = tickMs;
+  const roundTimeoutSeconds = positive(record.roundTimeoutSeconds);
+  if (roundTimeoutSeconds !== void 0) info.roundTimeoutSeconds = roundTimeoutSeconds;
+  const maxInflightRounds = positive(record.maxInflightRounds);
+  if (maxInflightRounds !== void 0) info.maxInflightRounds = maxInflightRounds;
+  return info;
 }
 
 // src/gateway/index.ts
 var ZERO_AUTH_SIG = new Uint8Array(64);
+var authTimestampNow = () => Math.floor(Date.now() / 1e3);
+var DEFAULT_TICK_MS = 1e3;
+function msUntilNextTick(nowMs, tickMs) {
+  return tickMs - nowMs % tickMs + 1;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var BACKOFF_BASE_MS = 250;
+var BACKOFF_MAX_MS = 5e3;
+var DEFAULT_ROUND_TIMEOUT_MS = 35e3;
+var DEFAULT_MAX_RETRIES = 6;
+function retryDelayMs(cause, failures, nowMs, tickMs, random = Math.random) {
+  const nextTick = msUntilNextTick(nowMs, tickMs);
+  switch (cause.kind) {
+    case "conflict":
+      return nextTick + random() * (tickMs / 2);
+    case "busy":
+      return Math.max(nextTick, cause.retryAfterMs ?? tickMs) + random() * tickMs;
+    case "error": {
+      const backoff = Math.min(BACKOFF_BASE_MS * 2 ** Math.max(failures - 1, 0), BACKOFF_MAX_MS);
+      return Math.max(nextTick, backoff / 2 + random() * (backoff / 2));
+    }
+  }
+}
+function mergeCause(a, b) {
+  if (a.kind === "busy" || b.kind === "busy") {
+    const waits = [a, b].flatMap((c) => c.kind === "busy" && c.retryAfterMs !== void 0 ? [c.retryAfterMs] : []);
+    return waits.length ? { kind: "busy", retryAfterMs: Math.max(...waits) } : { kind: "busy" };
+  }
+  if (a.kind === "conflict" || b.kind === "conflict") return { kind: "conflict" };
+  return { kind: "error" };
+}
+function retryAfterMs(res) {
+  const raw = res.headers.get("retry-after");
+  if (raw === null) return void 0;
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.min(seconds, 60) * 1e3 : void 0;
+}
 var DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
 var GatewayError = class extends Error {
   constructor(message, status) {
@@ -801,6 +848,9 @@ var MolphaGateway = class {
   programIdBytes;
   /** Gateway PDA per endpoint URL; resolved once per client lifetime. */
   gatewayPdas = /* @__PURE__ */ new Map();
+  /** Advertised timing per endpoint URL, read lazily on the first retry. */
+  advertisedInfo = /* @__PURE__ */ new Map();
+  random;
   constructor(endpoints, getRegistrySelectionConfig = async () => {
     throw new Error(
       "MolphaGateway requires getRegistrySelectionConfig to request signed data \u2014 pass the current on-chain registry version, redundancy buffer and node count (e.g. () => solana.getRegistrySelectionConfig())"
@@ -821,6 +871,11 @@ var MolphaGateway = class {
     this.allowUnverifiedNodeKeysForPrivateApi = options.allowUnverifiedNodeKeysForPrivateApi ?? false;
     this.programId = options.programId ?? MOLPHA_PROGRAM_ID;
     this.programIdBytes = addressToBytes(this.programId);
+    this.random = options.random ?? Math.random;
+  }
+  /** The configured gateway base URLs, in failover order. */
+  endpointUrls() {
+    return this.endpoints.map((e) => e.url);
   }
   /** Tries endpoints in order; returns the first node list it can fetch. */
   async getNodes() {
@@ -831,13 +886,12 @@ var MolphaGateway = class {
    * selection policy, which sizes the eligible set a paid source must fund.
    *
    * The `registry` block is advisory: it is whatever the gateway read from the
-   * chain, and is absent on older gateways or when that read failed. Prefer the
+   * chain, and is absent when that read failed. Prefer the
    * on-chain read (`MolphaSolanaClient.getRegistrySelectionConfig`) whenever a
    * Solana connection is available — `requestSignedData` already does.
    */
   async getNodesInfo() {
     const data = await this.firstReachableData("/v1/nodes");
-    if (Array.isArray(data)) return { nodes: data };
     return {
       nodes: data.nodes,
       ...data.registry ? { registry: data.registry } : {}
@@ -890,12 +944,23 @@ var MolphaGateway = class {
   }
   /**
    * Request a threshold-signed data update from the gateway, with retry +
-   * failover. Per attempt a fresh timestamp yields a fresh selection bitmap; the
-   * body is POSTed to each endpoint in order until one `completed`s.
+   * 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 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
+   * from the local clock for every attempt). It only proves the caller may spend the
+   * subscription's rounds; it is not part of the round, so the signature is recomputed for every
+   * endpoint tried.
    *
-   * The round's `sourceId` is derived from `apiConfig`. The request authorization
-   * binds the program id and each gateway's on-chain account, so the auth signature
-   * is recomputed for every endpoint tried.
+   * Because the committee is unknown until the gateway stamps the round, private API
+   * secrets are encrypted for **every** node of the registry; the gateway forwards only the
+   * selected nodes' envelopes.
    *
    * By default this fetches the registry selection config up front and the node
    * set only when the round needs it (private API encryption, or when the registry
@@ -914,8 +979,8 @@ var MolphaGateway = class {
       encrypt,
       sourcePayment,
       maxAge = 60,
-      maxRetries = 15,
-      timeoutMs = 5e3
+      maxRetries = DEFAULT_MAX_RETRIES,
+      timeoutMs = DEFAULT_ROUND_TIMEOUT_MS
     } = opts;
     const signaturesRequired = assertSignaturesRequired(opts.signaturesRequired);
     const verifyNodeKeys = opts.verifyNodeKeys ?? this.verifyNodeKeys;
@@ -937,17 +1002,19 @@ var MolphaGateway = class {
     }
     const consumerAuthority = opts.consumerAuthority ?? this.defaultConsumerAuthority ?? subscriptionOwner;
     const authSigner = signer ?? this.defaultSigner;
-    const round = await this.resolveContext(opts.context, encrypt !== void 0);
-    const { registryVersion, redundancyBuffer } = round;
-    if (round.nodeCount !== void 0 && round.nodes !== void 0 && round.nodes.length !== round.nodeCount) {
-      throw new Error(
-        `Gateway node list has ${round.nodes.length} nodes but registry ${registryVersion} has node_count ${round.nodeCount} \u2014 refresh the round context`
-      );
-    }
-    const nodeCount = round.nodeCount ?? round.nodes?.length;
-    if (nodeCount === void 0) {
-      throw new Error("Round context resolved neither nodeCount nor nodes");
-    }
+    let round = await this.resolveContext(opts.context, encrypt !== void 0);
+    let { registryVersion, redundancyBuffer } = round;
+    const nodeCountOf = (r) => {
+      if (r.nodeCount !== void 0 && r.nodes !== void 0 && r.nodes.length !== r.nodeCount) {
+        throw new Error(
+          `Gateway node list has ${r.nodes.length} nodes but registry ${r.registryVersion} has node_count ${r.nodeCount} \u2014 refresh the round context`
+        );
+      }
+      const n = r.nodeCount ?? r.nodes?.length;
+      if (n === void 0) throw new Error("Round context resolved neither nodeCount nor nodes");
+      return n;
+    };
+    let nodeCount = nodeCountOf(round);
     let terms = null;
     let authorizations = 0;
     let requoted = false;
@@ -970,28 +1037,31 @@ var MolphaGateway = class {
       }
     }
     let lastError;
-    let lastTimestamp = 0;
+    let tickMs = opts.tickMs;
+    let groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
+    let registryIndexes = Array.from({ length: nodeCount }, (_, index) => index);
+    let cause = { kind: "error" };
+    let refreshedOnce = false;
+    let retryNow = false;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
-      let timestamp = Math.floor(Date.now() / 1e3);
-      if (timestamp <= lastTimestamp) timestamp = lastTimestamp + 1;
-      lastTimestamp = timestamp;
-      const seed = deriveSelectionSeed(sourceIdBytes, registryVersion, timestamp);
-      const groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
-      const bitmap = deriveGroupBitmap(seed, nodeCount, groupSize);
-      const indices = selectedIndices(bitmap, nodeCount);
+      if (attempt > 0 && !retryNow) {
+        tickMs ??= await this.advertisedTickMs(timeoutMs) ?? DEFAULT_TICK_MS;
+        await sleep(retryDelayMs(cause, attempt, Date.now(), tickMs, this.random));
+      }
+      retryNow = false;
+      cause = { kind: "error" };
       let encKeyBundle;
       if (encrypt) {
-        const selected = selectedNodesForPrivateApiEncryption(round.nodes ?? [], indices);
+        const recipients = selectedNodesForPrivateApiEncryption(round.nodes ?? [], registryIndexes);
         if (verifyNodeKeys) {
           await verifyNodeKeys({
             sourceId,
             registryVersion,
-            timestamp,
-            selectedIndexes: [...indices],
-            selectedNodes: selected.map((node) => ({ ...node }))
+            nodeIndexes: [...registryIndexes],
+            nodes: recipients.map((node) => ({ ...node }))
           });
         }
-        encKeyBundle = encryptForNodes(requestApiConfig, encrypt.secrets, selected);
+        encKeyBundle = encryptForNodes(requestApiConfig, encrypt.secrets, recipients);
       }
       let sourcePayments;
       if (terms && sourcePayment && authorizations > 0) {
@@ -1004,7 +1074,6 @@ var MolphaGateway = class {
       const baseBody = {
         sourceId,
         registryVersion,
-        timestamp,
         maxAge,
         signaturesRequired,
         subscriptionOwner,
@@ -1014,22 +1083,25 @@ var MolphaGateway = class {
       if (encKeyBundle) baseBody.encKeyBundle = encKeyBundle;
       if (sourcePayments) baseBody.sourcePayments = sourcePayments;
       let requote = false;
+      let restartForRefresh = false;
       for (const endpoint of this.endpoints) {
         try {
           let authSig = ZERO_AUTH_SIG;
+          let authTimestamp = authTimestampNow();
           if (authSigner) {
             const gateway = await this.resolveGatewayPda(endpoint, timeoutMs);
+            authTimestamp = authTimestampNow();
             authSig = await authSigner(
               hashRequestAuth({
                 programId: this.programIdBytes,
                 gateway,
                 sourceId: sourceIdBytes,
                 signaturesRequired,
-                timestamp
+                authTimestamp
               })
             );
           }
-          const body = { ...baseBody, authSig: bytesToHex0x(authSig) };
+          const body = { ...baseBody, authSig: bytesToHex0x(authSig), authTimestamp };
           const res = await this.post(
             `${endpoint.url}/v1/round/execute`,
             body,
@@ -1085,17 +1157,27 @@ var MolphaGateway = class {
             break;
           }
           const errorDetail = !res.ok ? await parseGatewayErrorDetail(res) : void 0;
-          if (res.status === 400 || res.status === 401) {
+          if (res.status === 400 && !refreshedOnce && !restartForRefresh && /registryVersion.*current version/i.test(errorDetail ?? "")) {
+            restartForRefresh = true;
+            break;
+          }
+          if (res.status === 400 || res.status === 401 || res.status === 403) {
             throw new GatewayError(
               formatGatewayErrorMessage("Gateway rejected request", res.status, errorDetail),
               res.status
             );
           }
-          if (res.status === 503) {
+          if (res.status === 503 || res.status === 429) {
             lastError = new GatewayError(
-              formatGatewayErrorMessage("Gateway unavailable", 503, errorDetail),
-              503
+              formatGatewayErrorMessage(
+                res.status === 429 ? "Gateway rate limited" : "Gateway unavailable",
+                res.status,
+                errorDetail
+              ),
+              res.status
             );
+            const wait = retryAfterMs(res);
+            cause = mergeCause(cause, wait === void 0 ? { kind: "busy" } : { kind: "busy", retryAfterMs: wait });
             continue;
           }
           if (!res.ok) {
@@ -1103,29 +1185,37 @@ var MolphaGateway = class {
               formatGatewayErrorMessage("Gateway error", res.status, errorDetail),
               res.status
             );
+            if (res.status === 409) cause = mergeCause(cause, { kind: "conflict" });
             continue;
           }
           const json = await res.json();
-          const payload = json.data ?? (json.status === "completed" ? json : void 0);
-          if (json.status === "completed" && payload) {
-            return toResult(payload, {
+          if (json.status === "completed" && json.data) {
+            return toResult(json.data, {
               sourceId,
-              registryVersion,
-              timestamp,
               signaturesRequired,
-              bitmap,
               ...requestApiConfig.aggregation ? { aggregation: requestApiConfig.aggregation } : {}
             });
           }
           lastError = new Error(`Gateway returned status: ${json.status}`);
         } catch (err) {
           if (err instanceof UpstreamPaymentRequiredError) throw err;
-          if (err instanceof GatewayError && (err.status === 400 || err.status === 401 || err.status === 402)) {
+          if (err instanceof GatewayError && (err.status === 400 || err.status === 401 || err.status === 402 || err.status === 403)) {
             throw err;
           }
           lastError = err;
         }
       }
+      if (restartForRefresh) {
+        round = await this.resolveContext(void 0, encrypt !== void 0);
+        ({ registryVersion, redundancyBuffer } = round);
+        nodeCount = nodeCountOf(round);
+        groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
+        registryIndexes = Array.from({ length: nodeCount }, (_, index) => index);
+        refreshedOnce = true;
+        retryNow = true;
+        attempt--;
+        continue;
+      }
       if (requote) continue;
     }
     throw lastError instanceof Error ? lastError : new Error("Gateway round failed after retries");
@@ -1154,6 +1244,27 @@ var MolphaGateway = class {
     if (registry.nodeCount !== void 0) return registry;
     return { ...registry, nodes: await this.getNodes() };
   }
+  /**
+   * 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.
+   */
+  async advertisedTickMs(timeoutMs) {
+    for (const endpoint of this.endpoints) {
+      let pending = this.advertisedInfo.get(endpoint.url);
+      if (!pending) {
+        pending = this.fetchGatewayInfo(endpoint, Math.min(timeoutMs, 3e3)).catch(() => void 0);
+        this.advertisedInfo.set(endpoint.url, pending);
+      }
+      const info = await pending;
+      if (info === void 0) {
+        this.advertisedInfo.delete(endpoint.url);
+        continue;
+      }
+      if (info.tickMs !== void 0) return info.tickMs;
+    }
+    return void 0;
+  }
   /** Gateway PDA bytes for an endpoint, cached per URL. A failed lookup is not cached. */
   resolveGatewayPda(endpoint, timeoutMs) {
     let pending = this.gatewayPdas.get(endpoint.url);
@@ -1216,14 +1327,11 @@ function assertSignaturesRequired(value) {
   return value;
 }
 function unwrapEnvelope(json, path, status) {
-  if (json && typeof json === "object" && "data" in json) {
-    const wrapped = json;
-    if (wrapped.data === void 0) {
-      throw new GatewayError(`GET ${path} returned malformed payload`, status);
-    }
-    return wrapped.data;
+  const wrapped = json;
+  if (wrapped === null || typeof wrapped !== "object" || wrapped.data === void 0) {
+    throw new GatewayError(`GET ${path} returned malformed payload`, status);
   }
-  return json;
+  return wrapped.data;
 }
 function selectedNodesForPrivateApiEncryption(nodes, selectedIndexes) {
   if (!Array.isArray(nodes)) {
@@ -1309,11 +1417,12 @@ function flattenGatewayData(data) {
   if (!nested) return data;
   const { attestation: _nested, ...rest } = data;
   const { payload, signature } = nested;
+  const timestamp = payload?.timestamp ?? payload?.canonicalTimestamp;
   return {
     ...rest,
     ...payload?.sourceId !== void 0 ? { sourceId: payload.sourceId } : {},
     ...payload?.value !== void 0 ? { valuePacked: payload.value } : {},
-    ...payload?.canonicalTimestamp !== void 0 ? { timestamp: payload.canonicalTimestamp } : {},
+    ...timestamp !== void 0 ? { timestamp } : {},
     ...payload?.registryVersion !== void 0 ? { registryVersion: payload.registryVersion } : {},
     ...payload?.signaturesRequired !== void 0 ? { signaturesRequired: payload.signaturesRequired } : {},
     ...signature?.signersBitmap !== void 0 ? { signersBitmap: signature.signersBitmap } : {},
@@ -1322,6 +1431,12 @@ function flattenGatewayData(data) {
   };
 }
 function toResult(raw, ctx) {
+  if (raw.attestation) {
+    const { payload, signature } = raw.attestation;
+    if (!payload || !signature) {
+      throw new GatewayError("Gateway response is missing the attestation");
+    }
+  }
   const data = flattenGatewayData(raw);
   if (data.sourceId !== void 0 && normalizeHex(data.sourceId) !== ctx.sourceId) {
     throw new GatewayError(
@@ -1358,33 +1473,41 @@ function toResult(raw, ctx) {
       );
     }
   }
+  const fields = {
+    timestamp: data.timestamp,
+    registryVersion: data.registryVersion,
+    value: data.valuePacked,
+    signersBitmap: data.signersBitmap,
+    s: data.s,
+    commitmentAddr: data.commitmentAddr
+  };
+  for (const [name, field] of Object.entries(fields)) {
+    if (field === void 0 || field === "") {
+      throw new GatewayError(`Gateway response is missing ${name}`);
+    }
+  }
   let value = data.value ?? "";
   if (ctx.aggregation) {
-    for (const field of ["valuePacked", "signersBitmap", "s", "commitmentAddr"]) {
-      if (!data[field]) {
-        throw new GatewayError(`Gateway tolerance response is missing ${field}`);
-      }
-    }
     try {
-      value = formatInt256Decimal(data.valuePacked, ctx.aggregation.numeric.decimals);
+      value = formatInt256Decimal(fields.value, ctx.aggregation.numeric.decimals);
     } catch (err) {
       throw new GatewayError(
-        `Gateway tolerance response valuePacked is not an int256 word: ${err instanceof Error ? err.message : String(err)}`
+        `Gateway tolerance response value is not an int256 word: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
   return {
     payload: {
       sourceId: ctx.sourceId,
-      value: data.valuePacked ?? "",
-      canonicalTimestamp: data.timestamp ?? ctx.timestamp,
-      registryVersion: data.registryVersion ?? ctx.registryVersion,
+      value: fields.value,
+      timestamp: fields.timestamp,
+      registryVersion: fields.registryVersion,
       signaturesRequired: ctx.signaturesRequired
     },
     signature: {
-      signersBitmap: data.signersBitmap ?? bytesToHex(ctx.bitmap),
-      s: data.s ?? "",
-      commitmentAddr: data.commitmentAddr ?? ""
+      signersBitmap: fields.signersBitmap,
+      s: fields.s,
+      commitmentAddr: fields.commitmentAddr
     },
     value,
     fresh: data.fresh ?? true
@@ -6103,7 +6226,7 @@ var molpha_default = {
     {
       code: 6030,
       name: "FeedNotNewer",
-      msg: "canonical_timestamp <= feed.canonical_timestamp"
+      msg: "timestamp <= feed.timestamp"
     },
     {
       code: 6031,
@@ -6248,12 +6371,12 @@ var molpha_default = {
     {
       code: 6059,
       name: "AttestationTooStale",
-      msg: "canonical_timestamp is older than now - max_settlement_delay_seconds"
+      msg: "timestamp is older than now - max_settlement_delay_seconds"
     },
     {
       code: 6060,
       name: "AttestationInFuture",
-      msg: "canonical_timestamp is further ahead of cluster time than the allowed drift"
+      msg: "timestamp is further ahead of cluster time than the allowed drift"
     },
     {
       code: 6061,
@@ -6378,7 +6501,7 @@ var molpha_default = {
     {
       code: 6085,
       name: "RoundOutsideEpoch",
-      msg: "canonical_timestamp is outside the epoch window"
+      msg: "timestamp is outside the epoch window"
     },
     {
       code: 6086,
@@ -6454,6 +6577,11 @@ var molpha_default = {
       code: 6100,
       name: "InvalidRentReceiver",
       msg: "rent receiver must be the account that paid for the closed account"
+    },
+    {
+      code: 6101,
+      name: "InvalidInitialTau",
+      msg: "initial_tau is below the minimum ticket threshold"
     }
   ],
   types: [
@@ -6535,7 +6663,7 @@ var molpha_default = {
             type: "u8"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           }
         ]
@@ -7186,7 +7314,7 @@ var molpha_default = {
             type: "pubkey"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           },
           {
@@ -7232,7 +7360,7 @@ var molpha_default = {
             type: "u32"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           },
           {
@@ -7493,6 +7621,18 @@ var molpha_default = {
           {
             name: "protocol_fee_bps",
             type: "u16"
+          },
+          {
+            name: "initial_tau",
+            docs: [
+              "Ticket threshold of the two genesis epochs: a round is a ticket when the 64-bit prefix of its",
+              "ticket hash is below it, so the sampling probability is `initial_tau / 2^64`. Size it as",
+              "`2^64 * target_tickets_per_epoch / expected_rounds_per_epoch`. `u64::MAX` samples every round",
+              "(every round then costs a ticket transaction until the controller, which moves the",
+              "threshold at most 8x per epoch with a two-epoch lag, brings it down). Must be at least",
+              "`TAU_MIN`."
+            ],
+            type: "u64"
           }
         ]
       }
@@ -8287,7 +8427,7 @@ var molpha_default = {
           {
             name: "max_settlement_delay_seconds",
             docs: [
-              "Max age in seconds of `canonical_timestamp` relative to cluster time at attestation",
+              "Max age in seconds of `timestamp` relative to cluster time at attestation",
               "ingress, and the grace period of a superseded registry version."
             ],
             type: "u64"
@@ -9326,7 +9466,17 @@ function planIdFromVariant(variant) {
 }
 
 // src/solana/client.ts
-var DEFAULT_COMPUTE_UNIT_LIMIT = 14e5;
+var MAX_COMPUTE_UNIT_LIMIT = 14e5;
+function estimateSubmitComputeUnits(signerCount) {
+  if (!Number.isInteger(signerCount) || signerCount < 1) return MAX_COMPUTE_UNIT_LIMIT;
+  const measured = 43e3 + 9200 * signerCount;
+  return Math.min(Math.round(measured * 1.15) + 1e4, MAX_COMPUTE_UNIT_LIMIT);
+}
+var REGISTRY_CACHE_MS = 3e4;
+var KEY_CACHE_LIMIT = 8192;
+var PRIORITY_FEE_CACHE_MS = 5e3;
+var AUTO_FEE_PERCENTILE = 0.75;
+var AUTO_FEE_CAP_MICRO_LAMPORTS = 1e6;
 var MolphaSolanaClient = class _MolphaSolanaClient {
   constructor(program, provider, programId) {
     this.program = program;
@@ -9336,6 +9486,13 @@ var MolphaSolanaClient = class _MolphaSolanaClient {
   program;
   provider;
   programId;
+  // Registry reads and signer keys are shared by every submit that names the same registry
+  // version, so a fleet of feeds reads them once. Promises are cached, so concurrent submits
+  // coalesce; a failed read is dropped and retried by the next call.
+  registryCache = /* @__PURE__ */ new Map();
+  nodeKeyCache = /* @__PURE__ */ new Map();
+  coalitionCache = /* @__PURE__ */ new Map();
+  priorityFeeCache;
   static create(opts) {
     const programId = toSolanaAddress(opts.programId ?? MOLPHA_PROGRAM_ADDRESS);
     const provider = new AnchorProvider(opts.connection, opts.wallet, {
@@ -9494,12 +9651,16 @@ var MolphaSolanaClient = class _MolphaSolanaClient {
     const { payload, signature: schnorr } = attestation;
     const sourceId = toFixedBytes(payload.sourceId, 32, "sourceId");
     const submitter = this.wallet;
-    const registry = await this.fetchRegistry(payload.registryVersion);
+    const registry = await this.fetchRegistryCached(payload.registryVersion);
     const remaining = resolveRemainingAccounts(schnorr.signersBitmap, registry);
     assertSignerCount(remaining.length, payload.signaturesRequired, registry);
-    const coalitionKey = opts?.coalitionKey ?? await this.computeSignerCoalitionKey(remaining, registry);
+    const coalitionKey = opts?.coalitionKey ?? await this.computeSignerCoalitionKey(remaining, registry, schnorr.signersBitmap);
     const feed = feedPda(sourceId, payload.signaturesRequired, submitter, this.programId);
-    const cuIx = setComputeUnitLimit(opts?.computeUnitLimit ?? DEFAULT_COMPUTE_UNIT_LIMIT);
+    const preInstructions = [
+      setComputeUnitLimit(opts?.computeUnitLimit ?? estimateSubmitComputeUnits(remaining.length))
+    ];
+    const price = await this.resolvePriorityFee(opts?.priorityFeeMicroLamports, feed);
+    if (price > 0) preInstructions.push(setComputeUnitPrice(price));
     const signature = await this.methods.submitAttestation(
       buildSubmitAttestationArgs(attestation, coalitionKey, opts?.rawValue)
     ).accountsPartial({
@@ -9508,26 +9669,80 @@ var MolphaSolanaClient = class _MolphaSolanaClient {
       feed,
       protocolConfig: protocolConfigPda(this.programId),
       systemProgram: SYSTEM_PROGRAM_ADDRESS
-    }).remainingAccounts(remaining).preInstructions([cuIx]).rpc();
+    }).remainingAccounts(remaining).preInstructions(preInstructions).rpc();
     return { signature, feed };
   }
-  /** Sum of the signers' keys, read from their on-chain `Node` accounts (one batched fetch). */
-  async computeSignerCoalitionKey(remaining, registry) {
-    const accounts = await this.accounts.node.fetchMultiple(
-      remaining.map((meta) => meta.pubkey)
-    );
-    const keys = accounts.map((account, i) => {
-      if (!account) {
-        throw new Error(
-          `Node account ${remaining[i].pubkey.toBase58()} (registry ${registry.version}) does not exist`
-        );
+  /** The registry for `version`, reused for {@link REGISTRY_CACHE_MS}. */
+  fetchRegistryCached(version) {
+    const now = Date.now();
+    const hit = this.registryCache.get(version);
+    if (hit && now - hit.at < REGISTRY_CACHE_MS) return hit.value;
+    const value = this.fetchRegistry(version);
+    this.registryCache.set(version, { at: now, value });
+    value.catch(() => {
+      if (this.registryCache.get(version)?.value === value) this.registryCache.delete(version);
+    });
+    return value;
+  }
+  async resolvePriorityFee(option, feed) {
+    if (option === void 0) return 0;
+    if (option !== "auto") {
+      if (!Number.isFinite(option) || option < 0) {
+        throw new Error('priorityFeeMicroLamports must be a non-negative number or "auto"');
       }
-      return {
-        x: nodeCoordinate(account, "secp256k1PubkeyX", "secp256k1_pubkey_x"),
-        y: nodeCoordinate(account, "secp256k1PubkeyY", "secp256k1_pubkey_y")
-      };
+      return Math.floor(option);
+    }
+    const now = Date.now();
+    if (!this.priorityFeeCache || now - this.priorityFeeCache.at >= PRIORITY_FEE_CACHE_MS) {
+      const value = (async () => {
+        try {
+          const recent = await this.provider.connection.getRecentPrioritizationFees({
+            lockedWritableAccounts: [new web3.PublicKey(feed)]
+          });
+          const fees = recent.map((r) => r.prioritizationFee).sort((a, b) => a - b);
+          if (fees.length === 0) return 0;
+          const fee = fees[Math.min(fees.length - 1, Math.floor(fees.length * AUTO_FEE_PERCENTILE))];
+          return Math.min(fee, AUTO_FEE_CAP_MICRO_LAMPORTS);
+        } catch {
+          return 0;
+        }
+      })();
+      this.priorityFeeCache = { at: now, value };
+    }
+    return this.priorityFeeCache.value;
+  }
+  /** Sum of the signers' keys, read from their on-chain `Node` accounts (one batched fetch). */
+  computeSignerCoalitionKey(remaining, registry, signersBitmap) {
+    const setKey = `${registry.version}:${signersBitmap}`;
+    const known = this.coalitionCache.get(setKey);
+    if (known) return known;
+    if (this.coalitionCache.size >= KEY_CACHE_LIMIT) this.coalitionCache.clear();
+    const pending = this.sumSignerKeys(remaining, registry);
+    this.coalitionCache.set(setKey, pending);
+    pending.catch(() => {
+      if (this.coalitionCache.get(setKey) === pending) this.coalitionCache.delete(setKey);
     });
-    return computeCoalitionKey(keys);
+    return pending;
+  }
+  async sumSignerKeys(remaining, registry) {
+    const addresses = remaining.map((meta) => meta.pubkey);
+    const missing = addresses.filter((a) => !this.nodeKeyCache.has(a.toBase58()));
+    if (missing.length > 0) {
+      const accounts = await this.accounts.node.fetchMultiple(missing);
+      if (this.nodeKeyCache.size + missing.length > KEY_CACHE_LIMIT) this.nodeKeyCache.clear();
+      accounts.forEach((account, i) => {
+        if (!account) {
+          throw new Error(
+            `Node account ${missing[i].toBase58()} (registry ${registry.version}) does not exist`
+          );
+        }
+        this.nodeKeyCache.set(missing[i].toBase58(), {
+          x: nodeCoordinate(account, "secp256k1PubkeyX", "secp256k1_pubkey_x"),
+          y: nodeCoordinate(account, "secp256k1PubkeyY", "secp256k1_pubkey_y")
+        });
+      });
+    }
+    return computeCoalitionKey(addresses.map((a) => this.nodeKeyCache.get(a.toBase58())));
   }
   /**
    * Read the feed written by `submitter` (default: this wallet) for
@@ -9643,7 +9858,7 @@ function buildSubmitAttestationArgs(attestation, coalitionKey, rawValue) {
         sourceId: Array.from(toFixedBytes(payload.sourceId, 32, "sourceId")),
         registryVersion: payload.registryVersion,
         signaturesRequired: payload.signaturesRequired,
-        canonicalTimestamp: new BN(payload.canonicalTimestamp)
+        timestamp: new BN(payload.timestamp)
       },
       signature: {
         aggSigS: Array.from(toFixedBytes(signature.s, 32, "signature.s")),
@@ -9699,16 +9914,16 @@ function nodeCoordinate(account, camelCaseField, snakeCaseField) {
   return toFixedBytes(Uint8Array.from(value), 32, `Node.${camelCaseField}`);
 }
 function selectedNodesForVerifier(args) {
-  if (args.selectedIndexes.length === 0) {
+  if (args.nodeIndexes.length === 0) {
     throw new Error("Private API node-key verification requires at least one selected index");
   }
-  if (args.selectedNodes.length !== args.selectedIndexes.length) {
+  if (args.nodes.length !== args.nodeIndexes.length) {
     throw new Error(
-      `Private API node-key verification expected ${args.selectedIndexes.length} selected nodes, got ${args.selectedNodes.length}`
+      `Private API node-key verification expected ${args.nodeIndexes.length} selected nodes, got ${args.nodes.length}`
     );
   }
   const expected = /* @__PURE__ */ new Set();
-  for (const index of args.selectedIndexes) {
+  for (const index of args.nodeIndexes) {
     if (!Number.isInteger(index) || index < 0) {
       throw new Error(`Private API selected index must be a non-negative integer: ${index}`);
     }
@@ -9718,7 +9933,7 @@ function selectedNodesForVerifier(args) {
     expected.add(index);
   }
   const byIndex = /* @__PURE__ */ new Map();
-  for (const node of args.selectedNodes) {
+  for (const node of args.nodes) {
     if (!Number.isInteger(node.index) || node.index < 0) {
       throw new Error(
         `Private API selected node index must be a non-negative integer: ${node.index}`
@@ -9732,7 +9947,7 @@ function selectedNodesForVerifier(args) {
     }
     byIndex.set(node.index, node);
   }
-  return args.selectedIndexes.map((index) => {
+  return args.nodeIndexes.map((index) => {
     const node = byIndex.get(index);
     if (!node) {
       throw new Error(`Private API selected node is missing for index: ${index}`);
@@ -9763,7 +9978,7 @@ function attestationMessageHash(fields) {
       toFixedBytes(fields.sourceId, 32, "sourceId"),
       u32be(fields.registryVersion),
       u8(fields.signaturesRequired),
-      u64be(fields.canonicalTimestamp),
+      u64be(fields.timestamp),
       toFixedBytes(fields.signersBitmap, 32, "signersBitmap")
     )
   );
@@ -9776,10 +9991,20 @@ function attestationMessageHashFromAttestation(attestation) {
     signaturesRequired: payload.signaturesRequired,
     signersBitmap: signature.signersBitmap,
     value: payload.value,
-    canonicalTimestamp: payload.canonicalTimestamp
+    timestamp: payload.timestamp
   });
 }
 
+// src/core/timestamp.ts
+function timestampSeconds(timestamp) {
+  const ms = typeof timestamp === "bigint" ? timestamp : BigInt(timestamp);
+  if (ms < 0n) throw new RangeError("timestamp must not be negative");
+  return Number(ms / 1000n);
+}
+function timestampAgeSeconds(timestamp, nowSeconds) {
+  return Math.max(0, nowSeconds - timestampSeconds(timestamp));
+}
+
 // src/core/verifyCodes.ts
 var VERIFY_CODES = {
   OK: 0,
@@ -9787,11 +10012,11 @@ var VERIFY_CODES = {
   FEED_WITNESS: 1,
   /** The payload's `registryVersion` does not exist on this verifier. */
   BAD_REGISTRY_VERSION: 2,
-  /** Structurally invalid input, or a `canonicalTimestamp` in the future when `maxAge != 0`. */
+  /** Structurally invalid input, or a `timestamp` in the future when `maxAge != 0`. */
   MALFORMED: 3,
-  /** `canonicalTimestamp` predates the registry version's activation. */
+  /** `timestamp` predates the registry version's activation. */
   NOT_YET_ACTIVE: 4,
-  /** The registry version was superseded more than the grace window before `canonicalTimestamp`. */
+  /** The registry version was superseded more than the grace window before `timestamp`. */
   VERSION_EXPIRED: 5,
   /** Reserved. Never returned. */
   COMPROMISED_QUORUM: 6,
@@ -9835,7 +10060,7 @@ var MOLPHA_VERIFIER_ABI = [
               { name: "sourceId", type: "bytes32", internalType: "bytes32" },
               { name: "registryVersion", type: "uint32", internalType: "uint32" },
               { name: "signaturesRequired", type: "uint8", internalType: "uint8" },
-              { name: "canonicalTimestamp", type: "uint64", internalType: "uint64" }
+              { name: "timestamp", type: "uint64", internalType: "uint64" }
             ]
           },
           {
@@ -10008,7 +10233,7 @@ function buildEvmVerifierArgs(attestation, options) {
     sourceId: toFixedHex(signed.sourceId, 32, "sourceId"),
     registryVersion: assertUint2(signed.registryVersion, U32_MAX2, "registryVersion"),
     signaturesRequired: assertUint2(signed.signaturesRequired, U8_MAX, "signaturesRequired"),
-    canonicalTimestamp: assertBigUint(signed.canonicalTimestamp, U64_MAX, "canonicalTimestamp")
+    timestamp: assertBigUint(signed.timestamp, U64_MAX, "timestamp")
   };
   const signature = {
     signature: toFixedHex(sig.s, 32, "signature"),
@@ -10030,7 +10255,7 @@ function encodeEvmVerifyCalldata(args) {
     u256beFromBigInt(
       BigInt(assertUint2(payload.signaturesRequired, U8_MAX, "signaturesRequired"))
     ),
-    u256beFromBigInt(assertBigUint(payload.canonicalTimestamp, U64_MAX, "canonicalTimestamp")),
+    u256beFromBigInt(assertBigUint(payload.timestamp, U64_MAX, "timestamp")),
     word2(signature.signature, 32, "signature"),
     word2(signature.commitment, 20, "commitment"),
     u256beFromBigInt(assertBigUint(signature.signersBitmap, U256_MAX, "signersBitmap")),
@@ -10160,7 +10385,7 @@ function buildStarknetVerifierArgs(attestation, options) {
     source_id: fixedHexToBigInt(signed.sourceId, 32, "sourceId"),
     registry_version: assertUint3(signed.registryVersion, U32_MAX3, "registryVersion"),
     signatures_required: assertUint3(signed.signaturesRequired, U8_MAX2, "signaturesRequired"),
-    canonical_timestamp: assertUint3(signed.canonicalTimestamp, U64_MAX2, "canonicalTimestamp")
+    timestamp: assertUint3(signed.timestamp, U64_MAX2, "timestamp")
   };
   const signature = {
     signature: fixedHexToBigInt(sig.s, 32, "signature"),
@@ -10179,7 +10404,7 @@ function encodeStarknetVerifyCalldata(args) {
     ...u256Felts(payload.source_id, "source_id"),
     toFelt(assertUint3(payload.registry_version, U32_MAX3, "registry_version")),
     toFelt(assertUint3(payload.signatures_required, U8_MAX2, "signatures_required")),
-    toFelt(assertUint3(payload.canonical_timestamp, U64_MAX2, "canonical_timestamp")),
+    toFelt(assertUint3(payload.timestamp, U64_MAX2, "timestamp")),
     ...u256Felts(signature.signature, "signature"),
     // An Ethereum-style address, so it must fit 160 bits (the verifier reports a wider one
     // as `MALFORMED`; one past the field prime would not even deserialize).
@@ -10211,7 +10436,139 @@ function parseStarknetVerifyResult(result) {
   return { success, code, reason: verifyCodeName(code) ?? "UNKNOWN" };
 }
 
+// src/bulk.ts
+var DEFAULT_CONCURRENCY = 32;
+var MAX_DEFAULT_CONCURRENCY = 64;
+var DEFAULT_SUBMIT_CONCURRENCY = 8;
+var BACKOFF_COOLDOWN_MS = 1e3;
+var AdaptiveLimiter = class {
+  constructor(initial, max, now = Date.now) {
+    this.max = max;
+    this.now = now;
+    this.max = Math.max(1, max);
+    this.limit_ = Math.min(Math.max(1, Math.floor(initial)), this.max);
+  }
+  max;
+  now;
+  limit_;
+  inFlight = 0;
+  successes = 0;
+  lastCut = -Infinity;
+  waiters = [];
+  get limit() {
+    return this.limit_;
+  }
+  async acquire() {
+    if (this.inFlight < this.limit_) {
+      this.inFlight++;
+      return;
+    }
+    await new Promise((resolve) => this.waiters.push(resolve));
+  }
+  /** Release a slot. `busy` reports that the gateway answered at capacity. */
+  release(outcome) {
+    this.inFlight--;
+    if (outcome === "busy") {
+      this.successes = 0;
+      const t = this.now();
+      if (t - this.lastCut >= BACKOFF_COOLDOWN_MS) {
+        this.limit_ = Math.max(1, Math.floor(this.limit_ / 2));
+        this.lastCut = t;
+      }
+    } else if (outcome === "ok") {
+      if (++this.successes >= this.limit_ && this.limit_ < this.max) {
+        this.limit_++;
+        this.successes = 0;
+      }
+    }
+    while (this.waiters.length > 0 && this.inFlight < this.limit_) {
+      this.inFlight++;
+      this.waiters.shift()();
+    }
+  }
+};
+function spreadOffsetMs(sourceIdHex, spreadMs) {
+  if (spreadMs <= 0) return 0;
+  return Number.parseInt(sourceIdHex.slice(0, 8), 16) % spreadMs;
+}
+var isBusy = (err) => err instanceof GatewayError && (err.status === 503 || err.status === 429);
+async function requestMany(sdk, feeds, opts = {}) {
+  const results = new Array(feeds.length);
+  if (feeds.length === 0) return results;
+  const advertised = await sdk.gateway.fetchGatewayInfo(sdkFirstEndpoint(sdk)).catch(() => void 0);
+  const ceiling = opts.concurrency ?? (advertised?.maxInflightRounds ? Math.min(Math.max(1, Math.floor(advertised.maxInflightRounds / 2)), MAX_DEFAULT_CONCURRENCY) : DEFAULT_CONCURRENCY);
+  const requests = new AdaptiveLimiter(ceiling, ceiling);
+  const submits = new AdaptiveLimiter(
+    opts.submitConcurrency ?? DEFAULT_SUBMIT_CONCURRENCY,
+    opts.submitConcurrency ?? DEFAULT_SUBMIT_CONCURRENCY
+  );
+  const context = await sdk.gateway.prepareContext();
+  const submit = opts.submit ?? true;
+  const started = Date.now();
+  const one = async (index) => {
+    const feed = feeds[index];
+    const result = { index, ok: false, ...feed.label !== void 0 ? { label: feed.label } : {} };
+    results[index] = result;
+    try {
+      const wait = spreadOffsetMs(deriveSourceIdString(feed.apiConfig), opts.spreadMs ?? 0) - (Date.now() - started);
+      if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+      if (opts.signal?.aborted) {
+        result.error = new Error("aborted before the feed was started");
+        return;
+      }
+      await requests.acquire();
+      let outcome = "other";
+      try {
+        result.attestation = await sdk.gateway.requestSignedData({
+          ...opts.request,
+          apiConfig: feed.apiConfig,
+          signaturesRequired: feed.signaturesRequired,
+          context
+        });
+        result.ok = true;
+        outcome = "ok";
+      } catch (err) {
+        result.error = err;
+        outcome = isBusy(err) ? "busy" : "other";
+      } finally {
+        requests.release(outcome);
+      }
+      if (result.ok && submit && result.attestation) {
+        await submits.acquire();
+        try {
+          const sent = await sdk.solana.submitAttestation(result.attestation);
+          result.signature = sent.signature;
+          result.feedAddress = sent.feed;
+        } catch (err) {
+          result.submitError = err;
+        } finally {
+          submits.release("other");
+        }
+      }
+    } finally {
+      opts.onResult?.(result);
+    }
+  };
+  await Promise.all(feeds.map((_, index) => one(index)));
+  return results;
+}
+function sdkFirstEndpoint(sdk) {
+  return sdk.gateway.endpointUrls()[0];
+}
+
 // src/index.ts
+var SubmitFailedError = class extends Error {
+  constructor(result, cause) {
+    super(
+      `Gateway round succeeded but submitting the attestation failed: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+    this.result = result;
+    this.cause = cause;
+    this.name = "SubmitFailedError";
+  }
+  result;
+  cause;
+};
 var MolphaSDK = class {
   gateway;
   solana;
@@ -10241,11 +10598,15 @@ var MolphaSDK = class {
    */
   async requestAndSubmit(opts) {
     const result = await this.gateway.requestSignedData(opts);
-    const { signature, feed } = await this.solana.submitAttestation(result);
-    return { result, signature, feed };
+    try {
+      const { signature, feed } = await this.solana.submitAttestation(result);
+      return { result, signature, feed };
+    } catch (cause) {
+      throw new SubmitFailedError(result, cause);
+    }
   }
 };
 
-export { AggregationConfigError, DEFAULT_GATEWAY_ENDPOINT, EIP712_DOMAIN_TYPEHASH, GatewayError, INT256_MAX, INT256_MIN, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, MolphaGateway, MolphaSDK, MolphaSolanaClient, PlanType, REQUEST_AUTH_DOMAIN, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, UpstreamPaymentRequiredError, VERIFY_CODES, 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, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, gatewaySignerFromWallet, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, resolveRemainingAccounts, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signerFromKeypair, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, subscriptionPda, toChecksumAddress, toFixedBytes, toFixedHex, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName };
+export { AdaptiveLimiter, AggregationConfigError, DEFAULT_GATEWAY_ENDPOINT, DEFAULT_MAX_RETRIES, DEFAULT_ROUND_TIMEOUT_MS, EIP712_DOMAIN_TYPEHASH, GatewayError, INT256_MAX, INT256_MIN, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, MolphaGateway, MolphaSDK, MolphaSolanaClient, PlanType, REQUEST_AUTH_DOMAIN, SELECTION_WINDOW_MS, SubmitFailedError, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, UpstreamPaymentRequiredError, VERIFY_CODES, 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, gatewaySignerFromWallet, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, msUntilNextTick, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, requestMany, resolveRemainingAccounts, retryDelayMs, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signerFromKeypair, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, spreadOffsetMs, subscriptionPda, timestampAgeSeconds, timestampSeconds, toChecksumAddress, toFixedBytes, toFixedHex, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map