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

package/README.md

@@ -193,30 +193,46 @@ A `programId` that differs from the client's is rejected. Because the hash diffe
 
 ### Round timestamp
 
-The request body carries `authSig` and `authTimestamp` but no round timestamp. The gateway assigns the
-round's `timestamp` from its own clock, in unix **milliseconds**, on a tick grid
-(`floor(now / tickMs) * tickMs`, one second by default), and the result carries it in
-`payload.timestamp`. Committee selection reads only the timestamp's one-second window, so
+The request body carries `authSig` and `authTimestamp` but no round timestamp. The gateway stamps the
+round with its own clock, in unix **milliseconds**, floored to a fixed 100 ms tick
+(`floor(nowMs / 100) * 100`), and the result carries the stamp in `payload.timestamp`. The tick is a
+protocol constant, exported as `ROUND_TICK_MS`: it is the same on every gateway and node, it is not
+configurable, and `GET /v1/info` does not report it. Stamping does not wait for a tick boundary, so
+it adds no latency. Committee selection reads only the timestamp's one-second window (ten ticks), so
 nobody can pick a committee by picking a time.
 
+- One feed (a source, a quorum and a registry version) runs at most 10 rounds per second, whatever
+  the request rate.
+- Requests for the same feed inside one tick share one round: the nodes run it once and every caller
+  gets the result. Each caller still spends its own unit of round quota, or its own payment.
+- One consumer gets one round per tick per feed, so at most 10 per second. A second request by the
+  same consumer for the same source and quorum inside the tick is refused with HTTP 409; the SDK
+  retries it after one tick.
 - The message the nodes sign is `keccak256(MOLPHA_MESSAGE_V1 || value || sourceId || u32be(registryVersion) || u8(quorum) || u64be(timestamp) || signersBitmap)`.
 - Chain clocks, epochs and `maxAge`/staleness are in **seconds**: compare with
   `timestampSeconds(payload.timestamp)` (floored `ts / 1000`). `timestampAgeSeconds(ts, nowSeconds)` saturates at 0.
-- A round that was already reserved for this consumer, or dispatched to the nodes, cannot run again in the same tick (HTTP 409), so a retry waits for the next one. `tickMs` defaults to the gateway's advertised `tickMs` (read once, on the first retry, from `GET /v1/info`), else 1000.
+- The SDK returns `payload.timestamp` exactly as the gateway gave it. Nodes enforce the grid when
+  they sign; the on-chain verifiers do not check it.
 
 ### Retries and timeouts
 
-`requestSignedData` makes up to `maxRetries` attempts (default 6) and chooses the wait before each by why the last one failed (`retryDelayMs`). Every wait reaches at least the next tick, then adds jitter so clients that failed together do not retry together:
+`requestSignedData` makes up to `maxRetries` attempts (default 6) and chooses the wait before each by why the last one failed (`retryDelayMs`). Every wait carries jitter so clients that failed together do not retry together. The backoff step is a capped exponential: 250 ms, 500 ms, up to 5 s.
 
 | Last attempt | Wait before the next |
 | --- | --- |
-| 409 (this consumer already has a round for the source in this tick) | next tick, plus up to half a tick |
-| 503 or 429 (gateway at capacity, or nodes unavailable) | the later of the next tick and the gateway's `Retry-After`, plus up to a tick |
-| timeout, network error, other 5xx | capped exponential backoff (250 ms up to 5 s), half of it randomized |
+| 409 (this consumer already has a round for the source and quorum in the current tick) | one tick (`ROUND_TICK_MS`, 100 ms), plus up to 20 ms |
+| 503 or 429 (gateway at capacity, or too few nodes accepted the round) | the later of the gateway's `Retry-After` and the backoff step, plus up to one more step |
+| timeout, network error, other 5xx | the backoff step, half of it randomized |
 | 400, 401, 402, 403 | none: terminal. 403 means the subscription is inactive or its round quota for the term is spent |
 
 A 400 saying the `registryVersion` is not the current one (a cached context, or a registry roll between your read and the request) is the exception: the SDK reads the registry afresh and retries once, without spending an attempt.
 
+The wait after a 409 is a full tick rather than the time left to the next boundary: a full tick puts the retry in a later tick whatever the offset between the client's clock and the gateway's, so the SDK never computes a boundary from the local clock. A caller polling one feed gains nothing by asking more often than once per tick: space the requests at least `ROUND_TICK_MS` apart.
+
+A retry is a new request, and the gateway stamps it anew, so it is a **new round**: it spends another unit of round quota or needs another payment, and with a paywalled source another set of payment authorizations. Nothing ties a retry to the attempt before it; there is no idempotency key. Set `maxRetries: 1` to make a single attempt and decide about a retry yourself.
+
+The gateway limits the total load: at capacity it answers HTTP 503 with a `Retry-After`, and a consumer over its request rate gets HTTP 429. It also answers 503 when too few nodes accept a round. The SDK treats them alike: it backs off and retries, and throws a `GatewayError` with the status when the attempts run out.
+
 `timeoutMs` defaults to 35 s, above the gateway's own wait for a round (`roundTimeoutSeconds` in `/v1/info`, 30 s by default). A shorter timeout abandons a round the gateway is still running, and the retry then starts another. A source that cannot be fetched is reported as soon as enough nodes have failed (usually well under a second), not after the wait.
 
 ## Wallet
@@ -917,7 +933,7 @@ Current scope:
 
 - Solana subscription and extend flow;
 - deterministic source id and attestation message hashing;
-- gateway signed-data requests (failover, tick-aware retries, per-gateway request auth, context cache);
+- gateway signed-data requests (failover, retries with backoff, per-gateway request auth, context cache);
 - Solana attestation submission and feed/registry reads;
 - private API encryption helpers (pre-production);
 - caller-funded x402 payments for paywalled API sources (Base USDC, pre-production);

package/dist/index.d.ts

@@ -40,8 +40,6 @@ interface GatewayInfo {
     gatewayAuthority: string;
     /** Program id the gateway settles against; must match the client's when present. */
     programId?: string;
-    /** The gateway's round timestamp grid in milliseconds (`round.tick_ms`), when advertised. */
-    tickMs?: number;
     /** Longest the gateway waits for a round, in seconds (`node.agg_wait_seconds`), when advertised. */
     roundTimeoutSeconds?: number;
     /** Rounds the gateway runs at once (`limits.max_inflight_rounds`); 0 or absent: not advertised. */
@@ -165,17 +163,12 @@ interface RequestSignedDataOptions {
     /** Max accepted value age in seconds. Default 60. */
     maxAge?: number;
     /**
-     * Max attempts. Each retry waits for a later gateway tick, plus jitter, and for longer after a
-     * busy answer (`Retry-After`) or a failure that is not a conflict (capped exponential backoff);
-     * see {@link retryDelayMs}. Default {@link DEFAULT_MAX_RETRIES}.
+     * Max attempts. The wait before each retry depends on why the last attempt failed: one round
+     * tick after a duplicate (HTTP 409), the gateway's `Retry-After` or a capped exponential backoff
+     * after a busy answer, the backoff after anything else; see {@link retryDelayMs}. Every attempt
+     * the gateway accepts spends another unit of round quota. Default {@link DEFAULT_MAX_RETRIES}.
      */
     maxRetries?: number;
-    /**
-     * The gateway's tick grid in milliseconds (its `round.tick_ms`). A retry waits for the start of
-     * the next tick so it is a new round, not a duplicate of the last. Default: the gateway's
-     * advertised `tickMs` (read once, on the first retry), else 1000.
-     */
-    tickMs?: number;
     /**
      * Per-request timeout in ms. Default {@link DEFAULT_ROUND_TIMEOUT_MS}, above the gateway's own
      * wait for a round: a shorter timeout abandons rounds the gateway is still running and the retry
@@ -228,6 +221,8 @@ interface MolphaGatewayOptions {
     allowUnverifiedNodeKeysForPrivateApi?: boolean;
     /** Source of randomness in [0, 1) for retry jitter; defaults to `Math.random` (tests only). */
     random?: () => number;
+    /** Waits `ms` before a retry; defaults to a `setTimeout` timer (tests only). */
+    sleep?: (ms: number) => Promise<void>;
 }
 /**
  * The slow-changing inputs a `requestSignedData` round binds to. Fetch once with
@@ -237,8 +232,6 @@ interface RoundContext extends RegistrySelectionConfig {
     /** Full registry node set: private API secrets are encrypted for every node in it. */
     nodes: Node[];
 }
-/** Milliseconds from `nowMs` to the start of the next tick, plus a millisecond of margin. */
-declare function msUntilNextTick(nowMs: number, tickMs: number): number;
 /**
  * Default per-request timeout: above the gateway's own wait for a round (`node.agg_wait_seconds`,
  * 30 s by default), so the client does not abandon a round the gateway is still running and then
@@ -249,9 +242,10 @@ declare const DEFAULT_ROUND_TIMEOUT_MS = 35000;
 declare const DEFAULT_MAX_RETRIES = 6;
 /**
  * Why an attempt failed, as far as it decides how long to wait before the next one:
- *  - `conflict`: HTTP 409, this consumer already has a round for the source in this tick;
- *  - `busy`: HTTP 503 or 429, the gateway is at capacity or a node set is unavailable, optionally
- *    with the gateway's `Retry-After`;
+ *  - `conflict`: HTTP 409, this consumer already has a round for the source and quorum in the
+ *    current round tick;
+ *  - `busy`: HTTP 503 or 429, the gateway is at capacity, or too few nodes accepted the round
+ *    (unavailable, or busy), optionally with the gateway's `Retry-After`;
  *  - `error`: anything else that may be transient (timeout, network, other 5xx).
  */
 type RetryCause = {
@@ -263,16 +257,17 @@ type RetryCause = {
     kind: "error";
 };
 /**
- * How long to wait before the next attempt, in ms. Every delay reaches at least the start of the
- * next tick (a retry inside the tick that just failed would be a duplicate round), then adds jitter
- * so clients that failed together do not retry together:
- *  - conflict: the next tick plus up to half a tick;
- *  - busy: the later of the next tick and the gateway's `Retry-After` (a tick if absent), plus up to
- *    a tick;
- *  - error: capped exponential backoff (250 ms, 500 ms, ... 5 s) with half of it randomized.
- * `failures` is the number of attempts that have failed so far (1 after the first).
+ * How long to wait before the next attempt, in ms. Each delay carries jitter, so clients that
+ * failed together do not retry together:
+ *  - conflict: one full round tick ({@link ROUND_TICK_MS}) plus up to 20 ms. The gateway stamps a
+ *    round with the tick it is in, so a retry a full tick later is in a later tick whatever the
+ *    offset between the two clocks: no boundary is computed from the local clock;
+ *  - busy: the later of the gateway's `Retry-After` and the backoff step, plus up to one more step;
+ *  - error: the backoff step, half of it randomized.
+ * The backoff step is a capped exponential (250 ms, 500 ms, ... 5 s). `failures` is the number of
+ * attempts that have failed so far (1 after the first).
  */
-declare function retryDelayMs(cause: RetryCause, failures: number, nowMs: number, tickMs: number, random?: () => number): number;
+declare function retryDelayMs(cause: RetryCause, failures: number, random?: () => number): number;
 
 /** Thrown for terminal gateway errors (400/401) — never retried. */
 declare class GatewayError extends Error {
@@ -292,9 +287,8 @@ declare class MolphaGateway {
     private readonly programIdBytes;
     /** Gateway PDA per endpoint URL; resolved once per client lifetime. */
     private readonly gatewayPdas;
-    /** Advertised timing per endpoint URL, read lazily on the first retry. */
-    private readonly advertisedInfo;
     private readonly random;
+    private readonly sleep;
     constructor(endpoints?: GatewayEndpointInput | GatewayEndpointInput[], getRegistrySelectionConfig?: () => Promise<RegistrySelectionConfig>, defaultSigner?: Signer, 
     /**
      * Either a default subscription owner (base58) or gateway options. A string is the
@@ -337,10 +331,13 @@ declare class MolphaGateway {
      * failover. The body is POSTed to each endpoint in order until one `completed`s.
      *
      * The round's `sourceId` is derived from `apiConfig`. The request carries no round timestamp:
-     * the gateway assigns the round's `timestamp` (unix milliseconds) from its own clock
-     * on a tick grid, and the committee follows from it. The result carries the assigned
-     * timestamp and the signers' bitmap. A retry waits for a later tick, because a round that was
-     * already reserved or dispatched cannot run again in the same one (HTTP 409).
+     * the gateway stamps the round with its own clock floored to the round tick (`timestamp`, unix
+     * milliseconds, a multiple of {@link ROUND_TICK_MS}), and the committee follows from it. The
+     * result carries the assigned timestamp and the signers' bitmap; the timestamp is taken as the
+     * gateway gave it. Requests for the same source, quorum and registry version inside one tick
+     * share one round. One consumer gets one round per tick per source and quorum: a second request
+     * in the tick is refused (HTTP 409) and retried one tick later. A retry is stamped anew, so it
+     * is a new round that spends another unit of round quota.
      *
      * The request is authorized by a `RequestAuth` signature (`authSig`) over the program id, the
      * endpoint's Gateway PDA, the source id, the quorum and `authTimestamp` (unix seconds, read
@@ -370,12 +367,6 @@ declare class MolphaGateway {
      * encryption) or when nothing else can tell us the node count.
      */
     private resolveContext;
-    /**
-     * The gateway's advertised tick grid, read once per endpoint and only when a retry needs it. Any
-     * failure (an old gateway without `/v1/info`, a timeout) means "not advertised", so the caller
-     * falls back to the default; a failure is not cached.
-     */
-    private advertisedTickMs;
     /** Gateway PDA bytes for an endpoint, cached per URL. A failed lookup is not cached. */
     private resolveGatewayPda;
     private lookupGatewayPda;
@@ -877,6 +868,15 @@ declare function deriveSelectionBitmap(sourceId: Uint8Array, registryVersion: nu
  * EVM `block.timestamp`), epoch windows and `maxAge`/staleness are measured in SECONDS, so
  * anything that compares the two must go through {@link timestampSeconds}.
  */
+/**
+ * The round tick in milliseconds: the gateway stamps a round with its clock floored to this grid
+ * (`floor(nowMs / ROUND_TICK_MS) * ROUND_TICK_MS`) and nodes reject a round whose timestamp is off
+ * it. A feed (source, quorum, registry version) therefore runs at most ten rounds per second, and
+ * every selection window (`SELECTION_WINDOW_MS`, one second) holds exactly ten ticks. A
+ * protocol constant, the same in every gateway and node: not configuration, and not reported by
+ * `GET /v1/info`.
+ */
+declare const ROUND_TICK_MS = 100;
 /** `timestamp` (unix ms) as whole unix seconds, floored. */
 declare function timestampSeconds(timestamp: number | bigint): number;
 /**
@@ -1467,8 +1467,8 @@ interface BulkOptions {
      */
     concurrency?: number;
     /**
-     * Spread request starts over this many ms by a hash of the feed's source id. Feeds that are due on
-     * the same tick otherwise arrive together and queue at the gateway. Default 0 (no spreading).
+     * Spread request starts over this many ms by a hash of the feed's source id. Feeds that are due at
+     * the same moment otherwise arrive together and queue at the gateway. Default 0 (no spreading).
      */
     spreadMs?: number;
     /** Submit each attestation to Solana after its round. Default true. */
@@ -1592,4 +1592,4 @@ declare class MolphaSDK {
     }>;
 }
 
-export { APIConfig, AdaptiveLimiter, AggregationConfig, AggregationConfigError, AssetDomain, Attestation, type AttestationMessageFields, type BuildEvmVerifierArgsOptions, type BuildStarknetVerifierArgsOptions, type BulkFeed, type BulkOptions, type BulkResult, type CoalitionKey, DEFAULT_GATEWAY_ENDPOINT, DEFAULT_MAX_RETRIES, DEFAULT_ROUND_TIMEOUT_MS, EIP712_DOMAIN_TYPEHASH, type Eip712Domain, type EvmAttestation, type EvmAttestationPayload, type EvmSchnorrSignature, EvmSigner, type EvmVerifierArgs, type EvmVerifyResult, type FeedAccount, type GatewayEndpoint, type GatewayEndpointInput, GatewayError, type GatewayInfo, INT256_MAX, INT256_MIN, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_DEV_VERIFIERS_PROVISIONAL, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_SDK_PROFILE, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, type MolphaEvmNetwork, MolphaGateway, type MolphaGatewayOptions, MolphaSDK, type MolphaSDKOptions, MolphaSolanaClient, type MolphaStarknetNetwork, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, NodesInfo, type PlanId, type PlanInfo, PlanType, REQUEST_AUTH_DOMAIN, RegistrySelectionConfig, type RegistryStateView, type RegistryView, type RequestAuthFields, type RequestSignedDataOptions, type RetryCause, type RoundContext, SELECTION_WINDOW_MS, type Secp256k1KeyInput, Signer, SourcePaymentOptions, type StarknetAttestation, type StarknetAttestationPayload, type StarknetFeltLike, type StarknetSchnorrSignature, type StarknetVerifierArgs, type StarknetVerifyResult, type SubmitAttestationArgs, type SubmitAttestationOptions, SubmitFailedError, type SubmitResult, type SubscribeResult, type SubscriptionInfo, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, type TransferAuthorization, UpstreamPaymentRequiredError, UpstreamQuote, UpstreamTerms, VERIFY_CODES, type VerifyCode, type VerifyCodeName, addressToBytes, assertAggregationQuorum, attestationMessageHash, attestationMessageHashFromAttestation, base64ToBytes, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, buildSubmitAttestationArgs, bytesToBase64, bytesToHex, bytesToHex0x, canonicalizeAPIConfig, canonicalizeAggregation, commitmentAddressToStarknetFelt, computeCoalitionKey, concatBytes, createEvmSignerFromPrivateKey, decodeInt256, deriveGatewayPda, deriveGatewayPdaAddress, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, deriveSourceId, deriveSourceIdString, domainSeparator, effectiveSelectionSize, eligibleSetSize, encodeEvmVerifyCalldata, encodeInt256, encodeInt256Decimal, encodeRequestAuth, encodeStarknetVerifyCalldata, ensureLength, estimateSubmitComputeUnits, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, msUntilNextTick, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, requestMany, resolveRemainingAccounts, retryDelayMs, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, spreadOffsetMs, subscriptionPda, timestampAgeSeconds, timestampSeconds, toChecksumAddress, toFixedBytes, toFixedHex, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName };
+export { APIConfig, AdaptiveLimiter, AggregationConfig, AggregationConfigError, AssetDomain, Attestation, type AttestationMessageFields, type BuildEvmVerifierArgsOptions, type BuildStarknetVerifierArgsOptions, type BulkFeed, type BulkOptions, type BulkResult, type CoalitionKey, DEFAULT_GATEWAY_ENDPOINT, DEFAULT_MAX_RETRIES, DEFAULT_ROUND_TIMEOUT_MS, EIP712_DOMAIN_TYPEHASH, type Eip712Domain, type EvmAttestation, type EvmAttestationPayload, type EvmSchnorrSignature, EvmSigner, type EvmVerifierArgs, type EvmVerifyResult, type FeedAccount, type GatewayEndpoint, type GatewayEndpointInput, GatewayError, type GatewayInfo, INT256_MAX, INT256_MIN, MESSAGE_PREFIX, MIN_TOLERANCE_SIGNATURES, MOLPHA_DEV_VERIFIERS_PROVISIONAL, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_SDK_PROFILE, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, type MolphaEvmNetwork, MolphaGateway, type MolphaGatewayOptions, MolphaSDK, type MolphaSDKOptions, MolphaSolanaClient, type MolphaStarknetNetwork, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, NodesInfo, type PlanId, type PlanInfo, PlanType, REQUEST_AUTH_DOMAIN, ROUND_TICK_MS, RegistrySelectionConfig, type RegistryStateView, type RegistryView, type RequestAuthFields, type RequestSignedDataOptions, type RetryCause, type RoundContext, SELECTION_WINDOW_MS, type Secp256k1KeyInput, Signer, SourcePaymentOptions, type StarknetAttestation, type StarknetAttestationPayload, type StarknetFeltLike, type StarknetSchnorrSignature, type StarknetVerifierArgs, type StarknetVerifyResult, type SubmitAttestationArgs, type SubmitAttestationOptions, SubmitFailedError, type SubmitResult, type SubscribeResult, type SubscriptionInfo, TRANSFER_WITH_AUTHORIZATION_TYPEHASH, type TransferAuthorization, UpstreamPaymentRequiredError, UpstreamQuote, UpstreamTerms, VERIFY_CODES, type VerifyCode, type VerifyCodeName, addressToBytes, assertAggregationQuorum, attestationMessageHash, attestationMessageHashFromAttestation, base64ToBytes, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, buildSubmitAttestationArgs, bytesToBase64, bytesToHex, bytesToHex0x, canonicalizeAPIConfig, canonicalizeAggregation, commitmentAddressToStarknetFelt, computeCoalitionKey, concatBytes, createEvmSignerFromPrivateKey, decodeInt256, deriveGatewayPda, deriveGatewayPdaAddress, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, deriveSourceId, deriveSourceIdString, domainSeparator, effectiveSelectionSize, eligibleSetSize, encodeEvmVerifyCalldata, encodeInt256, encodeInt256Decimal, encodeRequestAuth, encodeStarknetVerifyCalldata, ensureLength, estimateSubmitComputeUnits, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseEvmVerifyResult, parseGatewayInfo, parseStarknetVerifyResult, parseUpstreamQuote, planIdFromVariant, planPda, planVariant, probeSource, protocolConfigPda, registryPda, registryStatePda, requestMany, resolveRemainingAccounts, retryDelayMs, secp256k1PublicKeyFromCoordinates, selectedIndices, signSourcePayments, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, spreadOffsetMs, subscriptionPda, timestampAgeSeconds, timestampSeconds, toChecksumAddress, toFixedBytes, toFixedHex, transferWithAuthorizationDigest, transferWithAuthorizationHash, u256beFromBigInt, u32be, u32le, u64be, u64le, u8, utf8, validateSuppliedTerms, verifyCodeName };

package/dist/index.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"
           },
           {
@@ -10024,16 +9993,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 +10591,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, 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, 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, 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