@molpha/sdk 0.2.0-dev-20261005112114 → 0.2.0-dev-20261006113121

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';
 
@@ -201,8 +201,13 @@ function deriveSourceIdString(apiConfig) {
   return bytesToHex(deriveSourceId(apiConfig));
 }
 
-// src/core/constants.ts
+// src/deployment.generated.ts
+var MOLPHA_SDK_PROFILE = "dev";
+var DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
 var MOLPHA_PROGRAM_ID = "chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt";
+var MOLPHA_VERIFIER_ADDRESS = "0xE1fd792b7E54e0C8F0Cd1c8055E446ff36d233eB";
+var MOLPHA_VERIFIER_STARKNET_SEPOLIA = "0x0378df4dbecf8f0c7daa801282932f7011c7a5e5773bab9eaf68f5fa5e7530ef";
+var MOLPHA_DEV_VERIFIERS_PROVISIONAL = true;
 
 // src/core/int256.ts
 var INT256_MAX = (1n << 255n) - 1n;
@@ -775,7 +780,16 @@ 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
@@ -786,7 +800,37 @@ function msUntilNextTick(nowMs, tickMs) {
   return tickMs - nowMs % tickMs + 1;
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
+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 GatewayError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -808,6 +852,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())"
@@ -828,6 +875,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() {
@@ -931,8 +983,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;
@@ -954,17 +1006,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;
@@ -987,11 +1041,19 @@ var MolphaGateway = class {
       }
     }
     let lastError;
-    const tickMs = opts.tickMs ?? DEFAULT_TICK_MS;
-    const groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
-    const registryIndexes = Array.from({ length: nodeCount }, (_, index) => index);
+    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++) {
-      if (attempt > 0) await sleep(msUntilNextTick(Date.now(), tickMs));
+      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 recipients = selectedNodesForPrivateApiEncryption(round.nodes ?? [], registryIndexes);
@@ -1025,6 +1087,7 @@ 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;
@@ -1098,17 +1161,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) {
@@ -1116,6 +1189,7 @@ 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();
@@ -1129,12 +1203,23 @@ var MolphaGateway = class {
           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");
@@ -1163,6 +1248,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);
@@ -6475,6 +6581,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: [
@@ -7514,6 +7625,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"
           }
         ]
       }
@@ -9347,7 +9470,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;
@@ -9357,6 +9490,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, {
@@ -9515,12 +9655,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({
@@ -9529,26 +9673,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
@@ -9976,9 +10174,6 @@ var MOLPHA_VERIFIER_ABI = [
   { type: "error", name: "InvalidRegistryVersion", inputs: [] }
 ];
 
-// src/evm/constants.ts
-var MOLPHA_VERIFIER_ADDRESS = "0xE1fd792b7E54e0C8F0Cd1c8055E446ff36d233eB";
-
 // src/evm/helpers.ts
 var VERIFY_SELECTOR = hexToBytes("67e2907b");
 var U8_MAX = 0xffn;
@@ -10107,7 +10302,6 @@ function parseEvmVerifyResult(result) {
 }
 
 // src/starknet/constants.ts
-var MOLPHA_VERIFIER_STARKNET_SEPOLIA = "0x0378df4dbecf8f0c7daa801282932f7011c7a5e5773bab9eaf68f5fa5e7530ef";
 var MOLPHA_VERIFIER_STARKNET_ADDRESSES = {
   "starknet-sepolia": MOLPHA_VERIFIER_STARKNET_SEPOLIA
 };
@@ -10242,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;
@@ -10272,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, SELECTION_WINDOW_MS, 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, msUntilNextTick, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, resolveRemainingAccounts, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signerFromKeypair, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, subscriptionPda, timestampAgeSeconds, timestampSeconds, 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_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, 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