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

package/README.md

@@ -84,7 +84,7 @@ Defaults are baked at publish time from `config/deployments.json` (`MOLPHA_SDK_P
 
 | npm dist-tag | Profile | Default gateway | Solana program | EVM / Starknet |
 |---|---|---|---|---|
-| `latest` | `stable` | `https://gateway.molpha.io/` | `MoLFGDpFoVnQgwbkTNScKPohCxhbfd61JjFrnotuwzh` | Documented CREATE2 / Sepolia addresses |
+| `latest` | `stable` | `https://gateway.molpha.io/` | `MoLF3pgVA9MENSuEujxNNSMaTo71aLyewaH5nrWfUZs` | Documented CREATE2 / Sepolia addresses |
 | `dev` | `dev` | `https://dev-gateway.molpha.io/` | `chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt` | Provisional until redeploy (`MOLPHA_DEV_VERIFIERS_PROVISIONAL`); falls back to stable addresses |
 
 Inspect the active profile via `MOLPHA_SDK_PROFILE` and `MOLPHA_DEV_VERIFIERS_PROVISIONAL`. Local builds: `MOLPHA_SDK_PROFILE=stable pnpm build` or `MOLPHA_SDK_PROFILE=dev pnpm build` (default `dev`).
@@ -419,6 +419,34 @@ for (const r of results) {
 
 It reads the registry inputs once for the whole batch; bounds concurrency, starting from half the gateway's advertised `maxInflightRounds` (at most 64, else 32) and adapting (halving on a busy answer, growing back while requests succeed); runs Solana submits on their own smaller limiter (`submitConcurrency`, default 8); never discards the signed attestation of a round whose submit failed; and returns one result per feed in input order, so a failing feed does not stop the others. Pass `submit: false` to collect attestations only. Throughput is limited by the submit path (one transaction per attestation) long before it is limited by the gateway.
 
+### Batching attestations of one feed
+
+At a high update rate, submit several attestations of the same feed in one transaction:
+
+```ts
+const { signature, count } = await sdk.solana.submitAttestations([older, newer, newest]);
+```
+
+Each becomes its own `submit_attestation` instruction, sorted by timestamp, and instructions run in
+the order they are listed, so every attestation is applied, oldest first. Separate transactions give
+no such order. Sent a few hundred milliseconds apart they reach a leader in a different order often
+enough (about a third at 250 ms spacing in a devnet run) that the older one is refused with
+`FeedNotNewer`; a batch makes the spacing between transactions several times longer, and one
+transaction costs one fee.
+
+- All attestations must be for one feed (the same `sourceId` and `signaturesRequired`), with distinct
+  timestamps. They may differ in registry version and signer set.
+- The transaction is atomic. If a newer attestation of the feed has already landed, every
+  instruction is stale and none applies, so batch what is due together and send batches of one feed
+  in order.
+- A transaction holds 1232 bytes, which is about three attestations with three signers, two with
+  four or five. `maxAttestationsPerTransaction(signerCount, { distinctSigners })` estimates it, and a
+  batch that does not fit throws `BatchTooLargeError` before sending, with `fits` saying how many
+  go: submit those and the rest apart. A priority-fee instruction costs bytes too.
+- `rawValue` is not supported in a batch; use `submitAttestation` for values longer than 32 bytes.
+- An attestation waits for the others in its batch, so a batch of `n` made at an interval of `t`
+  delays the oldest by `(n - 1) * t`.
+
 ### Fast requests with a cached context
 
 By default every `requestSignedData` call reads the on-chain registry up front

package/dist/index.d.ts

@@ -12,8 +12,8 @@ import BN from 'bn.js';
 declare const MOLPHA_SDK_PROFILE: "dev";
 declare const DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
 declare const MOLPHA_PROGRAM_ID = "chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt";
-declare const MOLPHA_VERIFIER_ADDRESS: "0xE1fd792b7E54e0C8F0Cd1c8055E446ff36d233eB";
-declare const MOLPHA_VERIFIER_STARKNET_SEPOLIA: "0x0378df4dbecf8f0c7daa801282932f7011c7a5e5773bab9eaf68f5fa5e7530ef";
+declare const MOLPHA_VERIFIER_ADDRESS: "0xA6e49A3A1caf3E110cC04765B934C8FF118C2568";
+declare const MOLPHA_VERIFIER_STARKNET_SEPOLIA: "0x032b9f47f12189668b94a5d62fb7d60f968ed0dbaf22090649d1d7a91d79cc38";
 /** True when the active profile has unset EVM/Starknet addresses (dev falls back to stable). */
 declare const MOLPHA_DEV_VERIFIERS_PROVISIONAL: true;
 
@@ -470,6 +470,33 @@ declare function planIdFromVariant(variant: Record<string, unknown>): PlanId;
  * benchmark's, and a limit that is hit fails the transaction for good.
  */
 declare function estimateSubmitComputeUnits(signerCount: number): number;
+/**
+ * Compute-unit limit for one transaction that carries a `submit_attestation` per entry of
+ * `signerCounts`: the same margin as {@link estimateSubmitComputeUnits} on the sum, with the fixed
+ * 10k once for the transaction.
+ */
+declare function estimateSubmitBatchComputeUnits(signerCounts: number[]): number;
+/**
+ * Bytes of `submit_attestation` instruction data with no raw value: the 8 byte discriminator, the
+ * payload (32 + 32 + 4 + 1 + 8), the signature (32 + 20 + 32), the empty `Option` and the coalition
+ * key (32 + 32).
+ */
+declare const SUBMIT_INSTRUCTION_DATA_BYTES = 234;
+/**
+ * Serialized size of a transaction with `count` attestations of `signerCount` signers each, to plan
+ * a batch before there is one. The signer `Node` accounts are shared between attestations, so the
+ * size depends on how many distinct ones there are: `distinctSigners` (default `signerCount`, the
+ * best case; the registry's node count is the worst).
+ */
+declare function estimateSubmitTransactionSize(count: number, signerCount: number, opts?: {
+    distinctSigners?: number;
+    priorityFee?: boolean;
+}): number;
+/** The most attestations of `signerCount` signers that fit in one transaction; see {@link estimateSubmitTransactionSize}. */
+declare function maxAttestationsPerTransaction(signerCount: number, opts?: {
+    distinctSigners?: number;
+    priorityFee?: boolean;
+}): number;
 type Commitment$1 = NonNullable<ConstructorParameters<typeof AnchorProvider>[2]>["commitment"];
 interface SubscribeResult {
     signature: string;
@@ -507,6 +534,31 @@ interface SubmitResult {
     /** Feed PDA written by this submit (`["molpha_feed", sourceId, [signaturesRequired], submitter]`). */
     feed: Address;
 }
+/** What {@link MolphaSolanaClient.submitAttestations} returns. */
+interface SubmitAttestationsResult extends SubmitResult {
+    /** Attestations in the transaction. They were applied in timestamp order. */
+    count: number;
+}
+/**
+ * Thrown by {@link MolphaSolanaClient.submitAttestations} when the attestations do not fit in one
+ * transaction. Nothing was sent: submit the first `fits` of them (oldest first) and the rest apart.
+ */
+declare class BatchTooLargeError extends RangeError {
+    /** How many of the attestations, oldest first, do fit. */
+    readonly fits: number;
+    /** The serialized size of the whole batch, in bytes. */
+    readonly size: number;
+    /** The largest transaction the network accepts, in bytes. */
+    readonly limit: number;
+    readonly count: number;
+    constructor(
+    /** How many of the attestations, oldest first, do fit. */
+    fits: number, 
+    /** The serialized size of the whole batch, in bytes. */
+    size: number, 
+    /** The largest transaction the network accepts, in bytes. */
+    limit: number, count: number);
+}
 /**
  * On-chain `Feed` (Anchor-decoded). `value` is always the signed
  * `AttestationPayload.value` (32 bytes): the oracle value itself when `valueKind` is
@@ -577,6 +629,8 @@ interface SubmitAttestationOptions {
      */
     rawValue?: Uint8Array;
 }
+/** Options for {@link MolphaSolanaClient.submitAttestations}. */
+type SubmitAttestationsOptions = Pick<SubmitAttestationOptions, "computeUnitLimit" | "priorityFeeMicroLamports">;
 interface CreateClientOpts {
     connection: SolanaConnection;
     wallet: Wallet;
@@ -659,6 +713,33 @@ declare class MolphaSolanaClient {
      * `keccak256(rawValue)`; {@link buildSubmitAttestationArgs} validates that before send.
      */
     submitAttestation(attestation: Attestation, opts?: SubmitAttestationOptions): Promise<SubmitResult>;
+    /**
+     * 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.
+     */
+    submitAttestations(attestations: Attestation[], opts?: SubmitAttestationsOptions): Promise<SubmitAttestationsResult>;
+    /**
+     * Everything one `submit_attestation` instruction needs: the arguments, the named accounts, the
+     * signer `Node` accounts (ascending bit order) and the feed address.
+     */
+    private prepareSubmit;
     /** The registry for `version`, reused for {@link REGISTRY_CACHE_MS}. */
     private fetchRegistryCached;
     private resolvePriorityFee;
@@ -1592,4 +1673,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, 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 };
+export { APIConfig, AdaptiveLimiter, AggregationConfig, AggregationConfigError, AssetDomain, Attestation, type AttestationMessageFields, BatchTooLargeError, 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, SUBMIT_INSTRUCTION_DATA_BYTES, type Secp256k1KeyInput, Signer, SourcePaymentOptions, type StarknetAttestation, type StarknetAttestationPayload, type StarknetFeltLike, type StarknetSchnorrSignature, type StarknetVerifierArgs, type StarknetVerifyResult, type SubmitAttestationArgs, type SubmitAttestationOptions, type SubmitAttestationsOptions, type SubmitAttestationsResult, 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, estimateSubmitBatchComputeUnits, estimateSubmitComputeUnits, estimateSubmitTransactionSize, evmAddressFromPrivateKey, feedPda, formatInt256Decimal, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, maxAttestationsPerTransaction, 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

@@ -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';
 
@@ -205,8 +205,8 @@ function deriveSourceIdString(apiConfig) {
 var MOLPHA_SDK_PROFILE = "dev";
 var DEFAULT_GATEWAY_ENDPOINT = "https://dev-gateway.molpha.io/";
 var MOLPHA_PROGRAM_ID = "chivcFQgxzwkpLvW41PV431HQ4dYpaW3povQH3AdpQt";
-var MOLPHA_VERIFIER_ADDRESS = "0xE1fd792b7E54e0C8F0Cd1c8055E446ff36d233eB";
-var MOLPHA_VERIFIER_STARKNET_SEPOLIA = "0x0378df4dbecf8f0c7daa801282932f7011c7a5e5773bab9eaf68f5fa5e7530ef";
+var MOLPHA_VERIFIER_ADDRESS = "0xA6e49A3A1caf3E110cC04765B934C8FF118C2568";
+var MOLPHA_VERIFIER_STARKNET_SEPOLIA = "0x032b9f47f12189668b94a5d62fb7d60f968ed0dbaf22090649d1d7a91d79cc38";
 var MOLPHA_DEV_VERIFIERS_PROVISIONAL = true;
 
 // src/core/int256.ts
@@ -9470,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;
@@ -9646,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;
@@ -9654,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) {
@@ -10591,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, 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 };
+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