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

package/dist/index.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) {
@@ -779,6 +780,12 @@ 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 DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
 var GatewayError = class extends Error {
   constructor(message, status) {
@@ -831,13 +838,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 +896,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 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.
+   * 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.
+   *
+   * 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
@@ -970,28 +987,23 @@ var MolphaGateway = class {
       }
     }
     let lastError;
-    let lastTimestamp = 0;
+    const tickMs = opts.tickMs ?? DEFAULT_TICK_MS;
+    const groupSize = effectiveSelectionSize(signaturesRequired, redundancyBuffer, nodeCount);
+    const registryIndexes = Array.from({ length: nodeCount }, (_, index) => index);
     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) await sleep(msUntilNextTick(Date.now(), tickMs));
       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 +1016,6 @@ var MolphaGateway = class {
       const baseBody = {
         sourceId,
         registryVersion,
-        timestamp,
         maxAge,
         signaturesRequired,
         subscriptionOwner,
@@ -1017,19 +1028,21 @@ var MolphaGateway = class {
       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,
@@ -1106,14 +1119,10 @@ var MolphaGateway = class {
             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 } : {}
             });
           }
@@ -1216,14 +1225,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 +1315,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 +1329,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 +1371,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 +6124,7 @@ var molpha_default = {
     {
       code: 6030,
       name: "FeedNotNewer",
-      msg: "canonical_timestamp <= feed.canonical_timestamp"
+      msg: "timestamp <= feed.timestamp"
     },
     {
       code: 6031,
@@ -6248,12 +6269,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 +6399,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,
@@ -6535,7 +6556,7 @@ var molpha_default = {
             type: "u8"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           }
         ]
@@ -7186,7 +7207,7 @@ var molpha_default = {
             type: "pubkey"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           },
           {
@@ -7232,7 +7253,7 @@ var molpha_default = {
             type: "u32"
           },
           {
-            name: "canonical_timestamp",
+            name: "timestamp",
             type: "u64"
           },
           {
@@ -8287,7 +8308,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"
@@ -9643,7 +9664,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 +9720,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 +9739,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 +9753,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 +9784,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 +9797,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 +9818,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 +9866,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 +10039,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 +10061,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 +10191,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 +10210,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).
@@ -10246,6 +10277,6 @@ var MolphaSDK = class {
   }
 };
 
-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 { 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map