@thru/thru-sdk 0.2.0 → 0.2.1

package/dist/{VersionInfo-Cw5HUNrn.d.ts → VersionInfo-DaC9Se29.d.ts}

@@ -533,12 +533,27 @@ declare class Block {
     });
     static fromProto(proto: Block$1): Block;
     static fromWire(data: Uint8Array): Block;
+    private static tryParseWireWithHeaderSize;
     toWire(): Uint8Array;
     getTransactions(): Transaction[];
     private static extractTransactionBody;
+    private static extractWithHeaderSize;
+    /**
+     * 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.
+     */
+    private static looksLikeValidTransactionBody;
     private serializeHeader;
     private serializeFooter;
     private static parseHeader;
+    /**
+     * 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.
+     */
+    private static parseHeaderWithSize;
     private static parseFooter;
     private static parseTransactionsFromBody;
 }

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

@@ -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;
@@ -1558,28 +1559,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 +1633,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 footerSize = hasFooter && raw.length >= BLOCK_HEADER_SIZE + BLOCK_FOOTER_SIZE ? BLOCK_FOOTER_SIZE : 0;
-    const start = BLOCK_HEADER_SIZE;
+    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 >= 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 +1787,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 +1872,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;
   }
@@ -2932,5 +3065,5 @@ 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
+//# sourceMappingURL=chunk-BYQMY4EE.js.map
+//# sourceMappingURL=chunk-BYQMY4EE.js.map