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

package/dist/index.js

@@ -1,10 +1,10 @@
-import { toPublicKey, addressBytes, toSolanaAddress, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS, setComputeUnitLimit, setComputeUnitPrice, addressFromBytes, findProgramAddressSync } from './chunk-H77BBZOL.js';
+import { toPublicKey, addressBytes, setComputeUnitLimit, setComputeUnitPrice, SYSTEM_PROGRAM_ADDRESS, toSolanaAddress, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ADDRESS, 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, web3 } from '@anchor-lang/core';
+import { web3, AnchorProvider, Program } from '@anchor-lang/core';
 import BN from 'bn.js';
 import { ed25519 } from '@noble/curves/ed25519.js';
 
@@ -401,6 +401,17 @@ function deriveSelectionBitmap(sourceId, registryVersion, nodeCount, signaturesR
   const size = effectiveSelectionSize(signaturesRequired, redundancy, nodeCount);
   return deriveGroupBitmap(seed, nodeCount, size);
 }
+
+// src/core/timestamp.ts
+var ROUND_TICK_MS = 100;
+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));
+}
 var REQUEST_AUTH_DOMAIN = utf8("MOLPHA_REQAUTH_V1");
 function encodeRequestAuth(fields) {
   if (!Number.isInteger(fields.signaturesRequired) || fields.signaturesRequired < 1 || fields.signaturesRequired > 255) {
@@ -808,8 +819,6 @@ function parseGatewayInfo(data) {
   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);
@@ -820,26 +829,21 @@ function parseGatewayInfo(data) {
 // 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 timerSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var CONFLICT_JITTER_MS = 20;
 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);
+function retryDelayMs(cause, failures, random = Math.random) {
+  const backoff = Math.min(BACKOFF_BASE_MS * 2 ** Math.max(failures - 1, 0), BACKOFF_MAX_MS);
   switch (cause.kind) {
     case "conflict":
-      return nextTick + random() * (tickMs / 2);
+      return ROUND_TICK_MS + random() * CONFLICT_JITTER_MS;
     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));
-    }
+      return Math.max(cause.retryAfterMs ?? 0, backoff) + random() * backoff;
+    case "error":
+      return backoff / 2 + random() * (backoff / 2);
   }
 }
 function mergeCause(a, b) {
@@ -877,9 +881,8 @@ 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;
+  sleep;
   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())"
@@ -901,6 +904,7 @@ var MolphaGateway = class {
     this.programId = options.programId ?? MOLPHA_PROGRAM_ID;
     this.programIdBytes = addressToBytes(this.programId);
     this.random = options.random ?? Math.random;
+    this.sleep = options.sleep ?? timerSleep;
   }
   /** The configured gateway base URLs, in failover order. */
   endpointUrls() {
@@ -976,10 +980,13 @@ var MolphaGateway = class {
    * 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
@@ -1066,7 +1073,6 @@ var MolphaGateway = class {
       }
     }
     let lastError;
-    let tickMs = opts.tickMs;
     let groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
     let registryIndexes = Array.from({ length: nodeCount }, (_, index) => index);
     let cause = { kind: "error" };
@@ -1074,8 +1080,7 @@ var MolphaGateway = class {
     let retryNow = false;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       if (attempt > 0 && !retryNow) {
-        tickMs ??= await this.advertisedTickMs(timeoutMs) ?? DEFAULT_TICK_MS;
-        await sleep(retryDelayMs(cause, attempt, Date.now(), tickMs, this.random));
+        await this.sleep(retryDelayMs(cause, attempt, this.random));
       }
       retryNow = false;
       cause = { kind: "error" };
@@ -1273,27 +1278,6 @@ 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);
@@ -1630,7 +1614,7 @@ var molpha_default = {
     name: "molpha",
     version: "0.1.0",
     spec: "0.1.0",
-    description: "Molpha Oracle Solana Program - Merged from molpha-solana and molpha-feed"
+    description: "Molpha Oracle Solana Program"
   },
   instructions: [
     {
@@ -3089,6 +3073,16 @@ var molpha_default = {
           writable: true,
           signer: true
         },
+        {
+          name: "program",
+          docs: [
+            "This program. Its account names the ProgramData account holding the upgrade authority."
+          ],
+          address: "chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt"
+        },
+        {
+          name: "program_data"
+        },
         {
           name: "token_program",
           address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
@@ -5736,19 +5730,6 @@ var molpha_default = {
         84
       ]
     },
-    {
-      name: "DelegateStatusChanged",
-      discriminator: [
-        188,
-        202,
-        137,
-        41,
-        54,
-        213,
-        14,
-        92
-      ]
-    },
     {
       name: "EpochClosed",
       discriminator: [
@@ -6611,6 +6592,16 @@ var molpha_default = {
       code: 6101,
       name: "InvalidInitialTau",
       msg: "initial_tau is below the minimum ticket threshold"
+    },
+    {
+      code: 6102,
+      name: "InvalidProgramData",
+      msg: "program data account is not this program's"
+    },
+    {
+      code: 6103,
+      name: "NotUpgradeAuthority",
+      msg: "initialize must be signed by the program's upgrade authority"
     }
   ],
   types: [
@@ -6693,6 +6684,9 @@ var molpha_default = {
           },
           {
             name: "timestamp",
+            docs: [
+              "Gateway-assigned round time in unix **milliseconds**."
+            ],
             type: "u64"
           }
         ]
@@ -6908,34 +6902,6 @@ var molpha_default = {
         ]
       }
     },
-    {
-      name: "DelegateStatusChanged",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "delegate",
-            type: "pubkey"
-          },
-          {
-            name: "owner",
-            type: "pubkey"
-          },
-          {
-            name: "old_status",
-            type: "u8"
-          },
-          {
-            name: "new_status",
-            type: "u8"
-          },
-          {
-            name: "updated_at",
-            type: "i64"
-          }
-        ]
-      }
-    },
     {
       name: "EpochClosed",
       type: {
@@ -7344,6 +7310,9 @@ var molpha_default = {
           },
           {
             name: "timestamp",
+            docs: [
+              "Unix milliseconds. Updates are strictly ordered on it, so two rounds in one second order."
+            ],
             type: "u64"
           },
           {
@@ -9501,11 +9470,85 @@ function estimateSubmitComputeUnits(signerCount) {
   const measured = 43e3 + 9200 * signerCount;
   return Math.min(Math.round(measured * 1.15) + 1e4, MAX_COMPUTE_UNIT_LIMIT);
 }
+function estimateSubmitBatchComputeUnits(signerCounts) {
+  if (signerCounts.length === 0 || signerCounts.some((n) => !Number.isInteger(n) || n < 1)) {
+    return MAX_COMPUTE_UNIT_LIMIT;
+  }
+  const measured = signerCounts.reduce((sum, n) => sum + 43e3 + 9200 * n, 0);
+  return Math.min(Math.round(measured * 1.15) + 1e4, MAX_COMPUTE_UNIT_LIMIT);
+}
+var SUBMIT_INSTRUCTION_DATA_BYTES = 234;
+var PLACEHOLDER_BLOCKHASH = "11111111111111111111111111111111";
+var shortVecBytes = (n) => n < 128 ? 1 : n < 16384 ? 2 : 3;
+function transactionSize(payer, instructions) {
+  const tx = new web3.Transaction();
+  tx.feePayer = payer;
+  tx.recentBlockhash = PLACEHOLDER_BLOCKHASH;
+  tx.add(...instructions);
+  const message = tx.compileMessage();
+  const keys = message.accountKeys.length;
+  let size = 1 + 64 + 3 + shortVecBytes(keys) + 32 * keys + 32 + shortVecBytes(message.instructions.length);
+  message.instructions.forEach((compiled, i) => {
+    const dataBytes = instructions[i].data.length;
+    size += 1 + shortVecBytes(compiled.accounts.length) + compiled.accounts.length + shortVecBytes(dataBytes) + dataBytes;
+  });
+  return size;
+}
+function estimateSubmitTransactionSize(count, signerCount, opts = {}) {
+  const key = () => web3.Keypair.generate().publicKey;
+  const [payer, registry, feed, protocolConfig, program] = [key(), key(), key(), key(), key()];
+  const distinct = Math.max(signerCount, opts.distinctSigners ?? signerCount);
+  const nodes = Array.from({ length: distinct }, key);
+  const instructions = [setComputeUnitLimit(1)];
+  if (opts.priorityFee) instructions.push(setComputeUnitPrice(1));
+  for (let i = 0; i < count; i++) {
+    instructions.push(
+      new web3.TransactionInstruction({
+        programId: program,
+        keys: [
+          { pubkey: payer, isSigner: true, isWritable: true },
+          { pubkey: registry, isSigner: false, isWritable: false },
+          { pubkey: feed, isSigner: false, isWritable: true },
+          { pubkey: protocolConfig, isSigner: false, isWritable: false },
+          { pubkey: new web3.PublicKey(SYSTEM_PROGRAM_ADDRESS), isSigner: false, isWritable: false },
+          ...Array.from({ length: signerCount }, (_, j) => ({
+            pubkey: nodes[(i * signerCount + j) % distinct],
+            isSigner: false,
+            isWritable: false
+          }))
+        ],
+        data: Buffer.alloc(SUBMIT_INSTRUCTION_DATA_BYTES)
+      })
+    );
+  }
+  return transactionSize(payer, instructions);
+}
+function maxAttestationsPerTransaction(signerCount, opts = {}) {
+  let count = 0;
+  while (estimateSubmitTransactionSize(count + 1, signerCount, opts) <= web3.PACKET_DATA_SIZE) count++;
+  return count;
+}
 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 BatchTooLargeError = class extends RangeError {
+  constructor(fits, size, limit, count) {
+    super(
+      `${count} attestations need a ${size} byte transaction, over the ${limit} byte limit; ${fits} fit`
+    );
+    this.fits = fits;
+    this.size = size;
+    this.limit = limit;
+    this.count = count;
+    this.name = "BatchTooLargeError";
+  }
+  fits;
+  size;
+  limit;
+  count;
+};
 var MolphaSolanaClient = class _MolphaSolanaClient {
   constructor(program, provider, programId) {
     this.program = program;
@@ -9677,6 +9720,87 @@ var MolphaSolanaClient = class _MolphaSolanaClient {
    * `keccak256(rawValue)`; {@link buildSubmitAttestationArgs} validates that before send.
    */
   async submitAttestation(attestation, opts) {
+    const { args, accounts, remaining, feed } = await this.prepareSubmit(attestation, opts);
+    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(args).accountsPartial(accounts).remainingAccounts(remaining).preInstructions(preInstructions).rpc();
+    return { signature, feed };
+  }
+  /**
+   * 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.
+   */
+  async submitAttestations(attestations, opts) {
+    if (attestations.length === 0) {
+      throw new RangeError("submitAttestations needs at least one attestation");
+    }
+    const sorted = [...attestations].sort((a, b) => a.payload.timestamp - b.payload.timestamp);
+    const feedKey = (a) => `${bytesToHex(toFixedBytes(a.payload.sourceId, 32, "sourceId"))}:${a.payload.signaturesRequired}`;
+    const first = feedKey(sorted[0]);
+    sorted.forEach((a, i) => {
+      if (feedKey(a) !== first) {
+        throw new RangeError(
+          "submitAttestations: every attestation must be for the same feed (sourceId and signaturesRequired)"
+        );
+      }
+      if (i > 0 && a.payload.timestamp === sorted[i - 1].payload.timestamp) {
+        throw new RangeError(
+          `submitAttestations: two attestations have timestamp ${a.payload.timestamp}; the second would be refused as not newer`
+        );
+      }
+    });
+    if (sorted.length === 1) return { ...await this.submitAttestation(sorted[0], opts), count: 1 };
+    const prepared = await Promise.all(sorted.map((a) => this.prepareSubmit(a)));
+    const instructions = await Promise.all(
+      prepared.map(
+        (p) => this.methods.submitAttestation(p.args).accountsPartial(p.accounts).remainingAccounts(p.remaining).instruction()
+      )
+    );
+    const feed = prepared[0].feed;
+    const budget = [
+      setComputeUnitLimit(
+        opts?.computeUnitLimit ?? estimateSubmitBatchComputeUnits(prepared.map((p) => p.remaining.length))
+      )
+    ];
+    const price = await this.resolvePriorityFee(opts?.priorityFeeMicroLamports, feed);
+    if (price > 0) budget.push(setComputeUnitPrice(price));
+    const payer = this.provider.wallet.publicKey;
+    const size = transactionSize(payer, [...budget, ...instructions]);
+    if (size > web3.PACKET_DATA_SIZE) {
+      let fits = 0;
+      while (fits < instructions.length && transactionSize(payer, [...budget, ...instructions.slice(0, fits + 1)]) <= web3.PACKET_DATA_SIZE) {
+        fits++;
+      }
+      throw new BatchTooLargeError(fits, size, web3.PACKET_DATA_SIZE, instructions.length);
+    }
+    const signature = await this.provider.sendAndConfirm(new web3.Transaction().add(...budget, ...instructions));
+    return { signature, feed, count: instructions.length };
+  }
+  /**
+   * Everything one `submit_attestation` instruction needs: the arguments, the named accounts, the
+   * signer `Node` accounts (ascending bit order) and the feed address.
+   */
+  async prepareSubmit(attestation, opts) {
     const { payload, signature: schnorr } = attestation;
     const sourceId = toFixedBytes(payload.sourceId, 32, "sourceId");
     const submitter = this.wallet;
@@ -9685,21 +9809,18 @@ var MolphaSolanaClient = class _MolphaSolanaClient {
     assertSignerCount(remaining.length, payload.signaturesRequired, registry);
     const coalitionKey = opts?.coalitionKey ?? await this.computeSignerCoalitionKey(remaining, registry, schnorr.signersBitmap);
     const feed = feedPda(sourceId, payload.signaturesRequired, submitter, this.programId);
-    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({
-      submitter,
-      registry: registryPda(payload.registryVersion, this.programId),
-      feed,
-      protocolConfig: protocolConfigPda(this.programId),
-      systemProgram: SYSTEM_PROGRAM_ADDRESS
-    }).remainingAccounts(remaining).preInstructions(preInstructions).rpc();
-    return { signature, feed };
+    return {
+      args: buildSubmitAttestationArgs(attestation, coalitionKey, opts?.rawValue),
+      accounts: {
+        submitter,
+        registry: registryPda(payload.registryVersion, this.programId),
+        feed,
+        protocolConfig: protocolConfigPda(this.programId),
+        systemProgram: SYSTEM_PROGRAM_ADDRESS
+      },
+      remaining,
+      feed
+    };
   }
   /** The registry for `version`, reused for {@link REGISTRY_CACHE_MS}. */
   fetchRegistryCached(version) {
@@ -10024,16 +10145,6 @@ function attestationMessageHashFromAttestation(attestation) {
   });
 }
 
-// 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,
@@ -10632,6 +10743,6 @@ var MolphaSDK = class {
   }
 };
 
-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 };
+export { AdaptiveLimiter, AggregationConfigError, BatchTooLargeError, 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, ROUND_TICK_MS, SELECTION_WINDOW_MS, SUBMIT_INSTRUCTION_DATA_BYTES, 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, estimateSubmitBatchComputeUnits, estimateSubmitComputeUnits, estimateSubmitTransactionSize, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, gatewaySignerFromWallet, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, maxAttestationsPerTransaction, 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