@thru/thru-sdk 0.2.0 → 0.2.3

package/dist/{chunk-YIQKZL4H.js → chunk-ZMDQDIE5.js}

@@ -1,7 +1,7 @@
 import { utils, etc, Point, CURVE, getPublicKeyAsync } from '@noble/ed25519';
 import { create } from '@bufbuild/protobuf';
 import { encodeAddress, decodeAddress, isHexString, hexToBytes, encodeSignature, decodeSignature, ensureBytes } from '@thru/helpers';
-import { AccountView, BlockView, TransactionView, ConsensusStatus, VersionContextSchema, CurrentVersionSchema, PubkeySchema, TaPubkeySchema, SignatureSchema, TsSignatureSchema, TransactionVmError, StreamingService, CommandService, QueryService, PageRequestSchema, PageResponseSchema, StateProofRequestSchema, GenerateStateProofRequestSchema, GetAccountRequestSchema, GetRawAccountRequestSchema, ListAccountsRequestSchema, StateProofType, ExecutionStatus, GetBlockRequestSchema, GetRawBlockRequestSchema, ListBlocksRequestSchema, GetChainInfoRequestSchema, CurrentOrHistoricalVersionSchema, GetEventRequestSchema, ListEventsRequestSchema, GetHeightRequestSchema, FilterParamValueSchema, FilterSchema, StreamBlocksRequestSchema, StreamAccountUpdatesRequestSchema, StreamTransactionsRequestSchema, StreamEventsRequestSchema, TrackTransactionRequestSchema, StreamHeightRequestSchema, GetTransactionRequestSchema, GetRawTransactionRequestSchema, GetTransactionStatusRequestSchema, ListTransactionsForAccountRequestSchema, ListTransactionsRequestSchema, BatchSendTransactionsRequestSchema, SendTransactionRequestSchema, BlockHashSchema } from '@thru/proto';
+import { AccountView, BlockView, TransactionView, ConsensusStatus, VersionContextSchema, CurrentVersionSchema, PubkeySchema, TaPubkeySchema, SignatureSchema, TsSignatureSchema, TransactionVmError, StreamingService, CommandService, QueryService, PageRequestSchema, PageResponseSchema, StateProofRequestSchema, GenerateStateProofRequestSchema, GetStateRootsRequestSchema, GetAccountRequestSchema, GetRawAccountRequestSchema, ListAccountsRequestSchema, StateProofType, ExecutionStatus, GetBlockRequestSchema, GetRawBlockRequestSchema, ListBlocksRequestSchema, GetChainInfoRequestSchema, CurrentOrHistoricalVersionSchema, GetEventRequestSchema, ListEventsRequestSchema, GetHeightRequestSchema, GetNodePubkeyRequestSchema, GetNodeRecordsRequestSchema, GetSlotMetricsRequestSchema, ListSlotMetricsRequestSchema, FilterParamValueSchema, FilterSchema, StreamBlocksRequestSchema, StreamAccountUpdatesRequestSchema, StreamTransactionsRequestSchema, StreamEventsRequestSchema, TrackTransactionRequestSchema, StreamHeightRequestSchema, StreamSlotMetricsRequestSchema, StreamNodeRecordsRequestSchema, GetTransactionRequestSchema, GetRawTransactionRequestSchema, GetTransactionStatusRequestSchema, ListTransactionsForAccountRequestSchema, ListTransactionsRequestSchema, BatchSendTransactionsRequestSchema, SendAndTrackTxnRequestSchema, SendTransactionRequestSchema, BlockHashSchema } from '@thru/proto';
 import { createClient } from '@connectrpc/connect';
 import { createGrpcWebTransport } from '@connectrpc/connect-web';
 import { sha256 } from '@noble/hashes/sha2';
@@ -296,9 +296,10 @@ var SIGNATURE_SIZE2 = 64;
 var PUBKEY_SIZE2 = 32;
 var HASH_SIZE = 32;
 var BLOCK_HEADER_SIZE = 168;
+var BLOCK_HEADER_SIZE_LEGACY = 160;
 var BLOCK_FOOTER_SIZE = 104;
 var BLOCK_VERSION_V1 = 1;
-var TXN_HEADER_SIZE = 112;
+var TXN_HEADER_BODY_SIZE = 112;
 var TXN_VERSION_V1 = 1;
 var TXN_MAX_ACCOUNTS = 1024;
 var STATE_PROOF_HEADER_SIZE = 40;
@@ -354,11 +355,11 @@ var Transaction = class _Transaction {
     return transaction;
   }
   static parseWire(data, options = {}) {
-    if (data.length < TXN_HEADER_SIZE + SIGNATURE_SIZE2) {
-      throw new Error(`Transaction data too short: ${data.length} bytes (expected at least ${TXN_HEADER_SIZE + SIGNATURE_SIZE2})`);
-    }
     const strict = options.strict ?? false;
     const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (data.length < TXN_HEADER_BODY_SIZE) {
+      throw new Error(`Transaction data too short: ${data.length} bytes (minimum ${TXN_HEADER_BODY_SIZE})`);
+    }
     let offset = 0;
     const version = view.getUint8(offset);
     offset += 1;
@@ -400,8 +401,8 @@ var Transaction = class _Transaction {
     _Transaction.ensureAvailable(data.length, offset, PUBKEY_SIZE2, "program account");
     const program = data.slice(offset, offset + PUBKEY_SIZE2);
     offset += PUBKEY_SIZE2;
-    if (offset !== TXN_HEADER_SIZE) {
-      throw new Error(`Transaction header parsing mismatch (expected offset ${TXN_HEADER_SIZE}, got ${offset})`);
+    if (offset !== TXN_HEADER_BODY_SIZE) {
+      throw new Error(`Transaction header parsing mismatch (expected offset ${TXN_HEADER_BODY_SIZE}, got ${offset})`);
     }
     const totalAccountCount = Number(readwriteAccountsCount + readonlyAccountsCount);
     if (strict && totalAccountCount > TXN_MAX_ACCOUNTS) {
@@ -412,7 +413,7 @@ var Transaction = class _Transaction {
     const accountsSize = totalAccountCount * PUBKEY_SIZE2;
     let expectedBodySize = accountsSize + instructionDataSize;
     if ((flags & TXN_FLAG_HAS_FEE_PAYER_PROOF) !== 0) {
-      const proofOffset = TXN_HEADER_SIZE + accountsSize + instructionDataSize;
+      const proofOffset = TXN_HEADER_BODY_SIZE + accountsSize + instructionDataSize;
       _Transaction.ensureAvailable(data.length, proofOffset, STATE_PROOF_HEADER_SIZE, "state proof header");
       const proofView = new DataView(data.buffer, data.byteOffset + proofOffset, STATE_PROOF_HEADER_SIZE);
       const typeSlot = proofView.getBigUint64(0, true);
@@ -426,9 +427,9 @@ var Transaction = class _Transaction {
         expectedBodySize += ACCOUNT_META_FOOTPRINT;
       }
     }
-    const txnSize = TXN_HEADER_SIZE + expectedBodySize + SIGNATURE_SIZE2;
+    const txnSize = TXN_HEADER_BODY_SIZE + expectedBodySize + SIGNATURE_SIZE2;
     _Transaction.ensureAvailable(data.length, 0, txnSize, "full transaction");
-    const sigStart = TXN_HEADER_SIZE + expectedBodySize;
+    const sigStart = TXN_HEADER_BODY_SIZE + expectedBodySize;
     const readWriteAccounts = [];
     for (let i = 0; i < readwriteAccountsCount; i++) {
       _Transaction.ensureAvailable(sigStart, offset, PUBKEY_SIZE2, "read-write accounts");
@@ -461,7 +462,7 @@ var Transaction = class _Transaction {
     }
     if (offset !== sigStart) {
       throw new Error(
-        `Transaction body has trailing bytes: expected ${offset + SIGNATURE_SIZE2} bytes but found ${txnSize}`
+        `Transaction body has trailing bytes: expected ${sigStart} bytes consumed but found ${offset}`
       );
     }
     const signatureBytes = data.slice(sigStart, sigStart + SIGNATURE_SIZE2);
@@ -495,7 +496,7 @@ var Transaction = class _Transaction {
     if (hasSignature) {
       transaction.setSignature(Signature.from(signatureBytes));
     }
-    return { transaction, size: offset + SIGNATURE_SIZE2 };
+    return { transaction, size: txnSize };
   }
   static fromProto(proto) {
     if (!proto.header) {
@@ -524,9 +525,9 @@ var Transaction = class _Transaction {
             header.flags ?? DEFAULT_FLAGS
           );
         } catch (sectionErr) {
-          if (body.length >= TXN_HEADER_SIZE) {
+          if (body.length >= TXN_HEADER_BODY_SIZE) {
             parsed = this.parseBodySections(
-              body.slice(TXN_HEADER_SIZE),
+              body.slice(TXN_HEADER_BODY_SIZE),
               header.readwriteAccountsCount ?? 0,
               header.readonlyAccountsCount ?? 0,
               header.instructionDataSize ?? 0,
@@ -621,7 +622,7 @@ var Transaction = class _Transaction {
     return this.buildWirePayload(new Uint8Array(header), true);
   }
   createHeader() {
-    const buffer = new ArrayBuffer(TXN_HEADER_SIZE);
+    const buffer = new ArrayBuffer(TXN_HEADER_BODY_SIZE);
     const headerBytes = new Uint8Array(buffer);
     const view = new DataView(buffer);
     let offset = 0;
@@ -1322,7 +1323,8 @@ function copyBytes4(bytes) {
 // thru-ts-client-sdk/modules/proofs.ts
 var proofs_exports = {};
 __export(proofs_exports, {
-  generateStateProof: () => generateStateProof
+  generateStateProof: () => generateStateProof,
+  getStateRoots: () => getStateRoots
 });
 async function generateStateProof(ctx, options) {
   const targetSlot = options.targetSlot ?? 0n;
@@ -1341,6 +1343,12 @@ async function generateStateProof(ctx, options) {
   }
   return StateProof.fromProto(response.proof);
 }
+async function getStateRoots(ctx, options = {}) {
+  const request = create(GetStateRootsRequestSchema, {
+    slot: options.slot
+  });
+  return ctx.query.getStateRoots(request, withCallOptions(ctx));
+}
 
 // thru-ts-client-sdk/modules/accounts.ts
 var accounts_exports = {};
@@ -1558,28 +1566,54 @@ var Block = class _Block {
     return block;
   }
   static fromWire(data) {
-    if (data.length < BLOCK_HEADER_SIZE) {
-      throw new Error(`Block data too short: ${data.length} bytes (expected at least ${BLOCK_HEADER_SIZE})`);
+    const result = _Block.tryParseWireWithHeaderSize(data, BLOCK_HEADER_SIZE);
+    if (result) {
+      return result;
+    }
+    const legacyResult = _Block.tryParseWireWithHeaderSize(data, BLOCK_HEADER_SIZE_LEGACY);
+    if (legacyResult) {
+      return legacyResult;
+    }
+    throw new Error(`Block data too short: ${data.length} bytes (expected at least ${BLOCK_HEADER_SIZE})`);
+  }
+  static tryParseWireWithHeaderSize(data, headerSize) {
+    if (data.length < headerSize) {
+      return null;
+    }
+    const headerBytes = data.slice(0, headerSize);
+    let header;
+    let blockTimeNs;
+    try {
+      const parsed = this.parseHeaderWithSize(headerBytes, headerSize);
+      header = parsed.header;
+      blockTimeNs = parsed.blockTimeNs;
+    } catch {
+      return null;
     }
-    const headerBytes = data.slice(0, BLOCK_HEADER_SIZE);
-    const { header, blockTimeNs } = this.parseHeader(headerBytes);
     if (header.version !== BLOCK_VERSION_V1) {
-      throw new Error(`Unsupported block version: ${header.version}`);
+      return null;
     }
     let finalHeader = header;
     let footer;
     let footerInfo;
     let body;
-    if (data.length >= BLOCK_HEADER_SIZE + BLOCK_FOOTER_SIZE) {
+    if (data.length >= headerSize + BLOCK_FOOTER_SIZE) {
       const footerOffset = data.length - BLOCK_FOOTER_SIZE;
       const footerBytes = data.slice(footerOffset);
-      const parsedFooter = this.parseFooter(footerBytes);
-      footer = parsedFooter.footer;
-      footerInfo = { blockHash: parsedFooter.blockHash, attestorPayment: parsedFooter.attestorPayment };
-      finalHeader = header.withBlockHash(parsedFooter.blockHash);
-      body = footerOffset > BLOCK_HEADER_SIZE ? data.slice(BLOCK_HEADER_SIZE, footerOffset) : void 0;
+      try {
+        const parsedFooter = this.parseFooter(footerBytes);
+        footer = parsedFooter.footer;
+        footerInfo = { blockHash: parsedFooter.blockHash, attestorPayment: parsedFooter.attestorPayment };
+        finalHeader = header.withBlockHash(parsedFooter.blockHash);
+      } catch {
+        return null;
+      }
+      body = footerOffset > headerSize ? data.slice(headerSize, footerOffset) : void 0;
     } else {
-      body = data.length > BLOCK_HEADER_SIZE ? data.slice(BLOCK_HEADER_SIZE) : void 0;
+      body = data.length > headerSize ? data.slice(headerSize) : void 0;
+    }
+    if (body && body.length > 0 && !_Block.looksLikeValidTransactionBody(body)) {
+      return null;
     }
     const block = new _Block({ header: finalHeader, footer, body });
     block.blockTimeNs = blockTimeNs;
@@ -1606,17 +1640,56 @@ var Block = class _Block {
     return _Block.parseTransactionsFromBody(this.body);
   }
   static extractTransactionBody(raw, hasFooter) {
-    if (!raw || raw.length <= BLOCK_HEADER_SIZE) {
-      return raw && raw.length > BLOCK_HEADER_SIZE ? raw.slice(BLOCK_HEADER_SIZE) : void 0;
+    if (!raw || raw.length === 0) {
+      return void 0;
+    }
+    const bodyWithCurrentHeader = _Block.extractWithHeaderSize(raw, hasFooter, BLOCK_HEADER_SIZE);
+    if (bodyWithCurrentHeader && bodyWithCurrentHeader.length > 0 && _Block.looksLikeValidTransactionBody(bodyWithCurrentHeader)) {
+      return bodyWithCurrentHeader;
+    }
+    const bodyWithLegacyHeader = _Block.extractWithHeaderSize(raw, hasFooter, BLOCK_HEADER_SIZE_LEGACY);
+    if (bodyWithLegacyHeader && bodyWithLegacyHeader.length > 0 && _Block.looksLikeValidTransactionBody(bodyWithLegacyHeader)) {
+      return bodyWithLegacyHeader;
+    }
+    return void 0;
+  }
+  static extractWithHeaderSize(raw, hasFooter, headerSize) {
+    if (raw.length <= headerSize) {
+      return void 0;
     }
-    const footerSize = hasFooter && raw.length >= BLOCK_HEADER_SIZE + BLOCK_FOOTER_SIZE ? BLOCK_FOOTER_SIZE : 0;
-    const start = BLOCK_HEADER_SIZE;
+    const footerSize = hasFooter && raw.length >= headerSize + BLOCK_FOOTER_SIZE ? BLOCK_FOOTER_SIZE : 0;
+    const start = headerSize;
     const end = Math.max(start, raw.length - footerSize);
     if (end <= start) {
       return void 0;
     }
     return raw.slice(start, end);
   }
+  /**
+   * Checks if the data looks like a valid transaction body.
+   * Uses heuristics to detect if we've correctly offset into the block data.
+   * Wire format: header (112 bytes) + body + signature (64 bytes at end)
+   * This is a lenient heuristic for format detection - version/flag validation
+   * happens in Transaction.parseWire.
+   */
+  static looksLikeValidTransactionBody(data) {
+    const MIN_TXN_SIZE = TXN_HEADER_BODY_SIZE + SIGNATURE_SIZE2;
+    if (data.length < MIN_TXN_SIZE) {
+      return false;
+    }
+    const readwriteCount = data[2] | data[3] << 8;
+    const readonlyCount = data[4] | data[5] << 8;
+    const totalAccounts = readwriteCount + readonlyCount;
+    if (totalAccounts > 1024) {
+      return false;
+    }
+    const instrDataSize = data[6] | data[7] << 8;
+    const expectedMinSize = TXN_HEADER_BODY_SIZE + totalAccounts * PUBKEY_SIZE2 + instrDataSize + SIGNATURE_SIZE2;
+    if (data.length < expectedMinSize) {
+      return false;
+    }
+    return true;
+  }
   serializeHeader() {
     const buffer = new ArrayBuffer(BLOCK_HEADER_SIZE);
     const bytes = new Uint8Array(buffer);
@@ -1721,6 +1794,66 @@ var Block = class _Block {
     });
     return { header, blockTimeNs };
   }
+  /**
+   * Parses a block header with a specific expected size.
+   * Handles both current (168 bytes with weight_slot) and legacy (160 bytes without weight_slot) formats.
+   */
+  static parseHeaderWithSize(bytes, expectedSize) {
+    if (bytes.length !== expectedSize) {
+      throw new Error(`Invalid block header size: ${bytes.length}, expected ${expectedSize}`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 0;
+    const signature = bytes.slice(offset, offset + SIGNATURE_SIZE2);
+    offset += SIGNATURE_SIZE2;
+    const version = view.getUint8(offset);
+    offset += 1;
+    offset += 5;
+    const chainId = view.getUint16(offset, true);
+    offset += 2;
+    const producer = bytes.slice(offset, offset + PUBKEY_SIZE2);
+    offset += PUBKEY_SIZE2;
+    const bondAmountLockUp = view.getBigUint64(offset, true);
+    offset += 8;
+    const expiryTimestampNs = view.getBigUint64(offset, true);
+    offset += 8;
+    const startSlot = view.getBigUint64(offset, true);
+    offset += 8;
+    const expiryAfter = view.getUint32(offset, true);
+    offset += 4;
+    const maxBlockSize = view.getUint32(offset, true);
+    offset += 4;
+    const maxComputeUnits = view.getBigUint64(offset, true);
+    offset += 8;
+    const maxStateUnits = view.getUint32(offset, true);
+    offset += 4;
+    offset += 4;
+    let weightSlot;
+    let blockTimeNs;
+    if (expectedSize === BLOCK_HEADER_SIZE) {
+      weightSlot = view.getBigUint64(offset, true);
+      offset += 8;
+      blockTimeNs = view.getBigUint64(offset, true);
+    } else {
+      blockTimeNs = view.getBigUint64(offset, true);
+    }
+    const header = new BlockHeader({
+      slot: startSlot,
+      version,
+      headerSignature: signature,
+      producer,
+      expiryTimestamp: nanosecondsToTimestamp(expiryTimestampNs),
+      startSlot,
+      expiryAfter,
+      maxBlockSize,
+      maxComputeUnits,
+      maxStateUnits,
+      bondAmountLockUp,
+      weightSlot,
+      chainId
+    });
+    return { header, blockTimeNs };
+  }
   static parseFooter(bytes) {
     if (bytes.length !== BLOCK_FOOTER_SIZE) {
       throw new Error(`Invalid block footer size: ${bytes.length}`);
@@ -1746,9 +1879,16 @@ var Block = class _Block {
     let offset = 0;
     while (offset < body.length) {
       const slice = body.subarray(offset);
-      const { transaction, size } = Transaction.parseWire(slice);
-      transactions.push(transaction);
-      offset += size;
+      if (slice.length < 176) {
+        break;
+      }
+      try {
+        const { transaction, size } = Transaction.parseWire(slice);
+        transactions.push(transaction);
+        offset += size;
+      } catch {
+        break;
+      }
     }
     return transactions;
   }
@@ -1900,11 +2040,15 @@ async function listBlocks(ctx, options = {}) {
 // thru-ts-client-sdk/modules/chain.ts
 var chain_exports = {};
 __export(chain_exports, {
-  getChainId: () => getChainId
+  getChainId: () => getChainId,
+  getChainInfo: () => getChainInfo
 });
-async function getChainId(ctx) {
+async function getChainInfo(ctx) {
   const request = create(GetChainInfoRequestSchema);
-  const response = await ctx.query.getChainInfo(request, withCallOptions(ctx));
+  return ctx.query.getChainInfo(request, withCallOptions(ctx));
+}
+async function getChainId(ctx) {
+  const response = await getChainInfo(ctx);
   return response.chainId;
 }
 
@@ -2148,6 +2292,40 @@ function generateSeed() {
   cryptoObj.getRandomValues(bytes);
   return bytes;
 }
+
+// thru-ts-client-sdk/modules/node.ts
+var node_exports = {};
+__export(node_exports, {
+  getNodePubkey: () => getNodePubkey,
+  getNodeRecords: () => getNodeRecords
+});
+async function getNodePubkey(ctx) {
+  const request = create(GetNodePubkeyRequestSchema, {});
+  return ctx.query.getNodePubkey(request, withCallOptions(ctx));
+}
+async function getNodeRecords(ctx) {
+  const request = create(GetNodeRecordsRequestSchema, {});
+  return ctx.query.getNodeRecords(request, withCallOptions(ctx));
+}
+
+// thru-ts-client-sdk/modules/slots.ts
+var slots_exports = {};
+__export(slots_exports, {
+  getSlotMetrics: () => getSlotMetrics,
+  listSlotMetrics: () => listSlotMetrics
+});
+async function getSlotMetrics(ctx, slot) {
+  const request = create(GetSlotMetricsRequestSchema, { slot });
+  return ctx.query.getSlotMetrics(request, withCallOptions(ctx));
+}
+async function listSlotMetrics(ctx, options) {
+  const request = create(ListSlotMetricsRequestSchema, {
+    startSlot: options.startSlot,
+    endSlot: options.endSlot,
+    limit: options.limit
+  });
+  return ctx.query.listSlotMetrics(request, withCallOptions(ctx));
+}
 function copyBytes8(source) {
   const bytes = new Uint8Array(source.length);
   bytes.set(source);
@@ -2524,6 +2702,8 @@ __export(streaming_exports, {
   streamBlocks: () => streamBlocks,
   streamEvents: () => streamEvents,
   streamHeight: () => streamHeight,
+  streamNodeRecords: () => streamNodeRecords,
+  streamSlotMetrics: () => streamSlotMetrics,
   streamTransactions: () => streamTransactions,
   trackTransaction: () => trackTransaction
 });
@@ -2548,7 +2728,7 @@ function streamBlocks(ctx, options = {}) {
 function streamAccountUpdates(ctx, address, options = {}) {
   const addressBytes = Pubkey.from(address).toBytes();
   const addressFilter = new Filter({
-    expression: "snapshot.address.value == params.address || account_update.address.value == params.address",
+    expression: "account_address.value == params.address",
     params: {
       address: FilterParamValue.bytes(addressBytes)
     }
@@ -2642,6 +2822,38 @@ function streamHeight(ctx, options = {}) {
   }
   return mapper();
 }
+function streamSlotMetrics(ctx, options = {}) {
+  const request = create(StreamSlotMetricsRequestSchema, {
+    startSlot: options.startSlot
+  });
+  const iterable = ctx.streaming.streamSlotMetrics(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      yield {
+        slot: response.slot,
+        collectedFees: response.collectedFees,
+        globalActivatedStateCounter: response.globalActivatedStateCounter,
+        globalDeactivatedStateCounter: response.globalDeactivatedStateCounter,
+        blockTimestamp: response.blockTimestamp
+      };
+    }
+  }
+  return mapper();
+}
+function streamNodeRecords(ctx, options = {}) {
+  const request = create(StreamNodeRecordsRequestSchema, {});
+  const iterable = ctx.streaming.streamNodeRecords(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      if (response.message.case === "record") {
+        yield { type: "record", record: response.message.value };
+      } else if (response.message.case === "finished") {
+        yield { type: "finished" };
+      }
+    }
+  }
+  return mapper();
+}
 async function collectStream(iterable, options = {}) {
   const { limit, signal } = options;
   throwIfAborted(signal);
@@ -2698,6 +2910,7 @@ __export(transactions_exports, {
   getTransactionStatus: () => getTransactionStatus,
   listTransactions: () => listTransactions,
   listTransactionsForAccount: () => listTransactionsForAccount,
+  sendAndTrackTxn: () => sendAndTrackTxn,
   sendTransaction: () => sendTransaction
 });
 async function getTransaction(ctx, signature, options = {}) {
@@ -2793,6 +3006,35 @@ async function batchSendTransactions(ctx, transactions, options = {}) {
   });
   return ctx.command.batchSendTransactions(request, withCallOptions(ctx));
 }
+function sendAndTrackTxn(ctx, transaction, options = {}) {
+  const raw = transaction instanceof Uint8Array ? transaction : transaction.toWire();
+  const request = create(SendAndTrackTxnRequestSchema, {
+    transaction: raw,
+    timeout: options.timeoutMs != null ? {
+      seconds: BigInt(Math.floor(options.timeoutMs / 1e3)),
+      nanos: options.timeoutMs % 1e3 * 1e6
+    } : void 0
+  });
+  const iterable = ctx.command.sendAndTrackTxn(request, {
+    ...withCallOptions(ctx),
+    signal: options.signal
+  });
+  async function* mapper() {
+    for await (const response of iterable) {
+      yield {
+        status: response.status,
+        signature: response.signature ? { value: response.signature.value } : void 0,
+        consensusStatus: response.consensusStatus,
+        executionResult: response.executionResult ? {
+          vmError: response.executionResult.vmError,
+          consumedComputeUnits: response.executionResult.consumedComputeUnits,
+          userErrorCode: response.executionResult.userErrorCode
+        } : void 0
+      };
+    }
+  }
+  return mapper();
+}
 async function sendRawTransaction(ctx, rawTransaction) {
   const request = create(SendTransactionRequestSchema, { rawTransaction });
   const response = await ctx.command.sendTransaction(request, withCallOptions(ctx));
@@ -2931,6 +3173,6 @@ var VersionInfo = class _VersionInfo {
   }
 };
 
-export { Account, Block, ChainEvent, Filter, FilterParamValue, HeightSnapshot, PageRequest, PageResponse, Pubkey, Signature, SignatureDomain, StateProof, Transaction, TransactionBuilder, TransactionStatusSnapshot, VersionInfo, accounts_exports, batchSendTransactions, blocks_exports, buildAndSignTransaction, buildTransaction, chain_exports, collectStream, consensusStatusToString, consensus_exports, createAccount, createThruClientContext, currentOrHistoricalVersionContext, currentVersionContext, deriveAddress, deriveProgramAddress, events_exports, firstStreamValue, forEachStreamValue, fromPrivateKey, generateKeyPair, generateStateProof, getAccount, getBlock, getBlockHeight, getEvent, getRawAccount, getRawBlock, getRawTransaction, getTransaction, getTransactionStatus, height_exports, keys_exports, listAccounts, listBlocks, listEvents, listTransactions, listTransactionsForAccount, proofs_exports, sendTransaction, seqVersionContext, signWithDomain, slotVersionContext, streamAccountUpdates, streamBlocks, streamEvents, streamHeight, streamTransactions, streaming_exports, timestampVersionContext, trackTransaction, transactions_exports, verifyWithDomain, versionContext, withCallOptions };
-//# sourceMappingURL=chunk-YIQKZL4H.js.map
-//# sourceMappingURL=chunk-YIQKZL4H.js.map
+export { Account, Block, ChainEvent, Filter, FilterParamValue, HeightSnapshot, PageRequest, PageResponse, Pubkey, Signature, SignatureDomain, StateProof, Transaction, TransactionBuilder, TransactionStatusSnapshot, VersionInfo, accounts_exports, batchSendTransactions, blocks_exports, buildAndSignTransaction, buildTransaction, chain_exports, collectStream, consensusStatusToString, consensus_exports, createAccount, createThruClientContext, currentOrHistoricalVersionContext, currentVersionContext, deriveAddress, deriveProgramAddress, events_exports, firstStreamValue, forEachStreamValue, fromPrivateKey, generateKeyPair, generateStateProof, getAccount, getBlock, getBlockHeight, getChainId, getChainInfo, getEvent, getNodePubkey, getNodeRecords, getRawAccount, getRawBlock, getRawTransaction, getSlotMetrics, getStateRoots, getTransaction, getTransactionStatus, height_exports, keys_exports, listAccounts, listBlocks, listEvents, listSlotMetrics, listTransactions, listTransactionsForAccount, node_exports, proofs_exports, sendAndTrackTxn, sendTransaction, seqVersionContext, signWithDomain, slotVersionContext, slots_exports, streamAccountUpdates, streamBlocks, streamEvents, streamHeight, streamNodeRecords, streamSlotMetrics, streamTransactions, streaming_exports, timestampVersionContext, trackTransaction, transactions_exports, verifyWithDomain, versionContext, withCallOptions };
+//# sourceMappingURL=chunk-ZMDQDIE5.js.map
+//# sourceMappingURL=chunk-ZMDQDIE5.js.map