@thru/sdk 0.2.22

package/dist/chunk-CVBQ4UPL.js

@@ -0,0 +1,3614 @@
+import { VersionContextSchema, CurrentVersionSchema, StateProofRequestSchema, GenerateStateProofRequestSchema, GetStateRootsRequestSchema, GetAccountRequestSchema, GetRawAccountRequestSchema, ListAccountsRequestSchema, GetBlockRequestSchema, GetRawBlockRequestSchema, ListBlocksRequestSchema, CurrentOrHistoricalVersionSchema, GetEventRequestSchema, ListEventsRequestSchema, GetHeightRequestSchema, GetChainInfoRequestSchema, GetNodeStatusRequestSchema, GetNodePubkeyRequestSchema, GetNodeRecordsRequestSchema, StreamBlocksRequestSchema, StreamAccountUpdatesRequestSchema, StreamTransactionsRequestSchema, StreamEventsRequestSchema, TrackTransactionRequestSchema, StreamHeightRequestSchema, StreamSlotMetricsRequestSchema, StreamNodeRecordsRequestSchema, GetSlotMetricsRequestSchema, ListSlotMetricsRequestSchema, GetTransactionRequestSchema, GetRawTransactionRequestSchema, GetTransactionStatusRequestSchema, ListTransactionsForAccountRequestSchema, ListTransactionsRequestSchema, BatchSendTransactionsRequestSchema, SendAndTrackTxnRequestSchema, SendTransactionRequestSchema, PubkeySchema, TaPubkeySchema, PageResponseSchema, BlockHashSchema, ConsensusStatus, FilterSchema, FilterParamValueSchema, SignatureSchema, TsSignatureSchema, PageRequestSchema, StreamingService, CommandService, QueryService, GetVersionRequestSchema } from './chunk-YQDWOMNO.js';
+import { ThruHDWallet } from './chunk-RL3Q6FDE.js';
+import { getWebCrypto, encodeSignature, encodeAddress, decodeAddress, isHexString, hexToBytes, ensureBytes, decodeSignature } from './chunk-UDIXYJXC.js';
+import { __export } from './chunk-NSBPE2FW.js';
+import { create } from '@bufbuild/protobuf';
+import { createClient } from '@connectrpc/connect';
+import { createGrpcWebTransport } from '@connectrpc/connect-web';
+import { hashes, getPublicKeyAsync, utils, Point, etc } from '@noble/ed25519';
+import { sha512, sha256 } from '@noble/hashes/sha2.js';
+
+// thru-ts-client-sdk/domain/primitives/byte-utils.ts
+function copyBytes(source) {
+  const bytes = new Uint8Array(source.length);
+  bytes.set(source);
+  return bytes;
+}
+function ensureExactLength(bytes, expected) {
+  if (bytes.length !== expected) {
+    throw new Error(`Must contain ${expected} bytes`);
+  }
+  return copyBytes(bytes);
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function bytesToHex(bytes) {
+  const hex = new Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    hex[i] = bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex.join("");
+}
+
+// thru-ts-client-sdk/domain/primitives/constants.ts
+var PUBKEY_LENGTH = 32;
+var SIGNATURE_LENGTH = 64;
+var TA_ADDRESS_LENGTH = 46;
+var TS_SIGNATURE_LENGTH = 90;
+
+// thru-ts-client-sdk/domain/primitives/Pubkey.ts
+var Pubkey = class _Pubkey {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  static from(value) {
+    if (value instanceof _Pubkey) {
+      return value;
+    }
+    if (value instanceof Uint8Array) {
+      return new _Pubkey(ensureExactLength(value, PUBKEY_LENGTH));
+    }
+    if (typeof value === "string") {
+      return new _Pubkey(_Pubkey.bytesFromString(value));
+    }
+    throw new Error(
+      `Must be provided as Uint8Array, hex string, or ta-address`
+    );
+  }
+  static isThruFmt(value) {
+    return value.startsWith("ta") && value.length === TA_ADDRESS_LENGTH;
+  }
+  toBytes() {
+    return copyBytes(this.bytes);
+  }
+  toBytesUnsafe() {
+    return this.bytes;
+  }
+  toThruFmt() {
+    return encodeAddress(this.bytes);
+  }
+  toHex() {
+    return bytesToHex(this.bytes);
+  }
+  equals(other) {
+    const candidate = _Pubkey.from(other);
+    return bytesEqual(this.bytes, candidate.bytes);
+  }
+  toProtoPubkey() {
+    return create(PubkeySchema, { value: this.toBytes() });
+  }
+  toProtoTaPubkey() {
+    return create(TaPubkeySchema, { value: this.toThruFmt() });
+  }
+  static fromProtoPubkey(proto) {
+    if (!proto?.value) {
+      throw new Error(`Proto is missing value`);
+    }
+    return new _Pubkey(ensureExactLength(proto.value, PUBKEY_LENGTH));
+  }
+  static fromProtoTaPubkey(proto) {
+    if (!proto?.value) {
+      throw new Error(`Proto is missing value`);
+    }
+    return new _Pubkey(ensureExactLength(decodeAddress(proto.value), PUBKEY_LENGTH));
+  }
+  static bytesFromString(value) {
+    if (_Pubkey.isThruFmt(value)) {
+      return ensureExactLength(decodeAddress(value), PUBKEY_LENGTH);
+    }
+    if (isHexString(value)) {
+      return ensureExactLength(hexToBytes(value), PUBKEY_LENGTH);
+    }
+    throw new Error(`Must be provided as hex string or ta-address`);
+  }
+};
+var Signature = class _Signature {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  static from(value) {
+    if (value instanceof _Signature) {
+      return value;
+    }
+    if (value instanceof Uint8Array) {
+      return new _Signature(ensureExactLength(value, SIGNATURE_LENGTH));
+    }
+    if (typeof value === "string") {
+      return new _Signature(_Signature.bytesFromString(value));
+    }
+    throw new Error(
+      `Must be provided as Uint8Array, ts-encoded string, hex string, or base64 string`
+    );
+  }
+  static fromProto(proto) {
+    if (!proto?.value) {
+      throw new Error(`Proto is missing value`);
+    }
+    return new _Signature(ensureExactLength(proto.value, SIGNATURE_LENGTH));
+  }
+  static isThruFmt(value) {
+    return value.startsWith("ts") && value.length === TS_SIGNATURE_LENGTH;
+  }
+  toBytes() {
+    return copyBytes(this.bytes);
+  }
+  toBytesUnsafe() {
+    return this.bytes;
+  }
+  toThruFmt() {
+    return encodeSignature(this.bytes);
+  }
+  toHex() {
+    return bytesToHex(this.bytes);
+  }
+  equals(other) {
+    const candidate = _Signature.from(other);
+    return bytesEqual(this.bytes, candidate.bytes);
+  }
+  toProtoSignature() {
+    return create(SignatureSchema, { value: this.toBytes() });
+  }
+  toProtoTsSignature() {
+    return create(TsSignatureSchema, { value: this.toThruFmt() });
+  }
+  static fromProtoTsSignature(proto) {
+    if (!proto?.value) {
+      throw new Error(`Proto is missing value`);
+    }
+    return new _Signature(ensureExactLength(decodeSignature(proto.value), SIGNATURE_LENGTH));
+  }
+  static fromProtoSignature(proto) {
+    if (!proto?.value) {
+      throw new Error(`Proto is missing value`);
+    }
+    return new _Signature(ensureExactLength(proto.value, SIGNATURE_LENGTH));
+  }
+  static bytesFromString(value) {
+    if (_Signature.isThruFmt(value)) {
+      return ensureExactLength(decodeSignature(value), SIGNATURE_LENGTH);
+    }
+    if (isHexString(value)) {
+      return ensureExactLength(hexToBytes(value), SIGNATURE_LENGTH);
+    }
+    throw new Error(`Must be provided as ts-encoded string or hex string`);
+  }
+};
+
+// thru-ts-client-sdk/modules/accounts.ts
+var accounts_exports = {};
+__export(accounts_exports, {
+  createAccount: () => createAccount,
+  getAccount: () => getAccount,
+  getRawAccount: () => getRawAccount,
+  listAccounts: () => listAccounts
+});
+var DEFAULT_HOST = "https://grpc-web.alphanet.thruput.org";
+var DEFAULT_ACCOUNT_VIEW = 4 /* FULL */;
+var DEFAULT_BLOCK_VIEW = 4 /* FULL */;
+var DEFAULT_TRANSACTION_VIEW = 4 /* FULL */;
+var DEFAULT_MIN_CONSENSUS = 0 /* UNSPECIFIED */;
+var DEFAULT_VERSION_CONTEXT = create(VersionContextSchema, {
+  version: {
+    case: "current",
+    value: create(CurrentVersionSchema, {})
+  }
+});
+var DEFAULT_FEE = 1n;
+var DEFAULT_COMPUTE_UNITS = 3e8;
+var DEFAULT_STATE_UNITS = 1e4;
+var DEFAULT_MEMORY_UNITS = 1e4;
+var DEFAULT_EXPIRY_AFTER = 100;
+
+// thru-ts-client-sdk/core/client.ts
+function createThruClientContext(config = {}) {
+  const transportOptions = config.transportOptions ?? {};
+  const { baseUrl: optionsBaseUrl, interceptors: optionInterceptors, ...restTransportOptions } = transportOptions;
+  const baseUrl = config.baseUrl ?? optionsBaseUrl ?? DEFAULT_HOST;
+  const mergedInterceptors = [
+    ...optionInterceptors ?? [],
+    ...config.interceptors ?? []
+  ];
+  const transport = config.transport ?? createGrpcWebTransport({
+    baseUrl,
+    ...restTransportOptions,
+    interceptors: mergedInterceptors.length > 0 ? mergedInterceptors : void 0
+  });
+  return {
+    baseUrl,
+    transport,
+    query: createClient(QueryService, transport),
+    command: createClient(CommandService, transport),
+    streaming: createClient(StreamingService, transport),
+    callOptions: config.callOptions
+  };
+}
+function withCallOptions(ctx, overrides) {
+  return mergeCallOptions(ctx.callOptions, overrides);
+}
+function mergeCallOptions(defaults, overrides) {
+  if (!defaults) {
+    return overrides;
+  }
+  if (!overrides) {
+    return defaults;
+  }
+  return {
+    ...defaults,
+    ...overrides,
+    headers: mergeHeaders(defaults.headers, overrides.headers),
+    contextValues: overrides.contextValues ?? defaults.contextValues,
+    onHeader: overrides.onHeader ?? defaults.onHeader,
+    onTrailer: overrides.onTrailer ?? defaults.onTrailer
+  };
+}
+function mergeHeaders(a, b) {
+  const entries = [];
+  const add = (init) => {
+    if (!init) {
+      return;
+    }
+    if (init instanceof Headers) {
+      init.forEach((value, key) => {
+        entries.push([key, value]);
+      });
+      return;
+    }
+    if (Array.isArray(init)) {
+      for (const [key, value] of init) {
+        entries.push([key, value]);
+      }
+      return;
+    }
+    for (const [key, value] of Object.entries(init)) {
+      if (value !== void 0) {
+        entries.push([key, String(value)]);
+      }
+    }
+  };
+  add(a);
+  add(b);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return entries;
+}
+
+// thru-ts-client-sdk/utils/utils.ts
+function isSlotSelector(selector) {
+  return "slot" in selector;
+}
+function mergeTransactionHeader(defaults, overrides) {
+  if (!overrides) {
+    return defaults;
+  }
+  const sanitized = Object.fromEntries(
+    Object.entries(overrides).filter(([, value]) => value !== void 0)
+  );
+  return {
+    ...defaults,
+    ...sanitized
+  };
+}
+function timestampToNanoseconds(timestamp) {
+  if (!timestamp) {
+    return 0n;
+  }
+  const seconds = BigInt(timestamp.seconds ?? 0);
+  const nanos = BigInt(timestamp.nanos ?? 0);
+  return seconds * 1000000000n + nanos;
+}
+function nanosecondsToTimestamp(ns) {
+  const seconds = ns / 1000000000n;
+  const nanos = Number(ns % 1000000000n);
+  return { seconds, nanos };
+}
+function consensusStatusToString(status) {
+  const lookup = ConsensusStatus;
+  return lookup[status] ?? `UNKNOWN(${status})`;
+}
+
+// thru-ts-client-sdk/domain/accounts/Account.ts
+var AccountFlags = class _AccountFlags {
+  constructor(flags) {
+    this.isProgram = flags?.isProgram ?? false;
+    this.isPrivileged = flags?.isPrivileged ?? false;
+    this.isUncompressable = flags?.isUncompressable ?? false;
+    this.isEphemeral = flags?.isEphemeral ?? false;
+    this.isDeleted = flags?.isDeleted ?? false;
+    this.isNew = flags?.isNew ?? false;
+    this.isCompressed = flags?.isCompressed ?? false;
+  }
+  static fromProto(flags) {
+    if (!flags) {
+      return new _AccountFlags();
+    }
+    return new _AccountFlags({
+      isProgram: flags.isProgram,
+      isPrivileged: flags.isPrivileged,
+      isUncompressable: flags.isUncompressable,
+      isEphemeral: flags.isEphemeral,
+      isDeleted: flags.isDeleted,
+      isNew: flags.isNew,
+      isCompressed: flags.isCompressed
+    });
+  }
+};
+var AccountMeta = class _AccountMeta {
+  constructor(params) {
+    this.version = params.version;
+    this.flags = params.flags ?? new AccountFlags();
+    this.dataSize = params.dataSize;
+    this.seq = params.seq;
+    this.owner = params.owner;
+    this.balance = params.balance;
+    this.nonce = params.nonce;
+  }
+  static fromProto(meta) {
+    if (!meta) {
+      return void 0;
+    }
+    return new _AccountMeta({
+      version: meta.version,
+      flags: AccountFlags.fromProto(meta.flags),
+      dataSize: meta.dataSize,
+      seq: meta.seq ?? 0n,
+      owner: meta.owner ? Pubkey.fromProtoPubkey(meta.owner) : void 0,
+      balance: meta.balance ?? 0n,
+      nonce: meta.nonce
+    });
+  }
+};
+var AccountData = class _AccountData {
+  constructor(params) {
+    this.data = params.data ? new Uint8Array(params.data) : void 0;
+    this.compressed = params.compressed ?? false;
+    this.compressionAlgorithm = params.compressionAlgorithm;
+  }
+  static fromProto(data) {
+    if (!data) {
+      return void 0;
+    }
+    return new _AccountData({
+      data: data.data ? new Uint8Array(data.data) : void 0,
+      compressed: data.compressed ?? false,
+      compressionAlgorithm: data.compressionAlgorithm
+    });
+  }
+};
+var Account = class _Account {
+  constructor(params) {
+    this.address = params.address;
+    this.meta = params.meta;
+    this.data = params.data;
+    this.versionContext = params.versionContext;
+    this.consensusStatus = params.consensusStatus;
+  }
+  static fromProto(proto) {
+    if (!proto.address) {
+      throw new Error("Account proto missing address");
+    }
+    return new _Account({
+      address: Pubkey.fromProtoPubkey(proto.address),
+      meta: AccountMeta.fromProto(proto.meta),
+      data: AccountData.fromProto(proto.data ?? void 0),
+      versionContext: convertVersionContext(proto.versionContext),
+      consensusStatus: proto.consensusStatus
+    });
+  }
+};
+function convertVersionContext(meta) {
+  if (!meta) {
+    return void 0;
+  }
+  return {
+    slot: meta.slot,
+    blockTimestampNs: timestampToNanoseconds(meta.blockTimestamp)
+  };
+}
+
+// thru-ts-client-sdk/domain/accounts/streaming.ts
+function toStreamAccountUpdate(response) {
+  if (!response.message) {
+    return void 0;
+  }
+  if (response.message.case === "snapshot") {
+    return {
+      kind: "snapshot",
+      snapshot: { account: Account.fromProto(response.message.value) }
+    };
+  }
+  if (response.message.case === "update") {
+    return {
+      kind: "update",
+      update: fromProtoUpdate(response.message.value)
+    };
+  }
+  return void 0;
+}
+function fromProtoUpdate(update) {
+  return {
+    slot: update.slot,
+    meta: AccountMeta.fromProto(update.meta),
+    page: update.page ? fromProtoPage(update.page) : void 0,
+    deleted: update.delete ?? false
+  };
+}
+function fromProtoPage(page) {
+  return {
+    pageIndex: page.pageIdx,
+    pageSize: page.pageSize,
+    data: new Uint8Array(page.pageData),
+    compressed: page.compressed ?? void 0,
+    compressionAlgorithm: page.compressionAlgorithm
+  };
+}
+var PageRequest = class _PageRequest {
+  constructor(params = {}) {
+    if (params.pageSize !== void 0) {
+      if (!Number.isInteger(params.pageSize) || params.pageSize < 0) {
+        throw new Error("PageRequest.pageSize must be a non-negative integer");
+      }
+    }
+    this.pageSize = params.pageSize;
+    this.pageToken = params.pageToken;
+    this.orderBy = params.orderBy;
+  }
+  static fromProto(proto) {
+    if (!proto) {
+      return void 0;
+    }
+    return new _PageRequest({
+      pageSize: proto.pageSize,
+      pageToken: proto.pageToken,
+      orderBy: proto.orderBy
+    });
+  }
+  toProto() {
+    return create(PageRequestSchema, {
+      pageSize: this.pageSize,
+      pageToken: this.pageToken,
+      orderBy: this.orderBy
+    });
+  }
+  withParams(params) {
+    return new _PageRequest({
+      pageSize: params.pageSize ?? this.pageSize,
+      pageToken: params.pageToken ?? this.pageToken,
+      orderBy: params.orderBy ?? this.orderBy
+    });
+  }
+};
+var PageResponse = class _PageResponse {
+  constructor(params = {}) {
+    this.nextPageToken = params.nextPageToken;
+    this.totalSize = params.totalSize;
+  }
+  static fromProto(proto) {
+    if (!proto) {
+      return void 0;
+    }
+    return new _PageResponse({
+      nextPageToken: proto.nextPageToken,
+      totalSize: proto.totalSize
+    });
+  }
+  toProto() {
+    return create(PageResponseSchema, {
+      nextPageToken: this.nextPageToken,
+      totalSize: this.totalSize
+    });
+  }
+  hasNextPage() {
+    return !!this.nextPageToken;
+  }
+};
+hashes.sha512 = sha512;
+var SignatureDomain = /* @__PURE__ */ ((SignatureDomain2) => {
+  SignatureDomain2[SignatureDomain2["TXN"] = 0] = "TXN";
+  SignatureDomain2[SignatureDomain2["BLOCK_HEADER"] = 1] = "BLOCK_HEADER";
+  SignatureDomain2[SignatureDomain2["BLOCK"] = 2] = "BLOCK";
+  SignatureDomain2[SignatureDomain2["GOSSIP"] = 3] = "GOSSIP";
+  return SignatureDomain2;
+})(SignatureDomain || {});
+var DOMAIN_TAGS = {
+  [0 /* TXN */]: 1n,
+  [1 /* BLOCK_HEADER */]: 2n,
+  [2 /* BLOCK */]: 3n,
+  [3 /* GOSSIP */]: 4n
+};
+var DOMAIN_BLOCK_SIZE = 128;
+var SIGNATURE_SIZE = 64;
+var PUBKEY_SIZE = 32;
+function createDomainBlock(domain) {
+  const block = new Uint8Array(DOMAIN_BLOCK_SIZE);
+  block.fill(0);
+  const tag = DOMAIN_TAGS[domain];
+  if (tag === void 0) {
+    throw new Error(`Invalid signature domain: ${domain}`);
+  }
+  const view = new DataView(block.buffer, block.byteOffset, block.byteLength);
+  view.setBigUint64(0, tag, false);
+  return block;
+}
+function copyBytes2(bytes) {
+  const out = new Uint8Array(bytes.length);
+  out.set(bytes);
+  return out;
+}
+function concatBytes(...arrays) {
+  return etc.concatBytes(...arrays);
+}
+function sha512Bytes(bytes) {
+  return new Uint8Array(sha512(bytes));
+}
+function bytesToNumberLE(bytes) {
+  let value = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    value += BigInt(bytes[i]) << 8n * BigInt(i);
+  }
+  return value;
+}
+function modOrder(value) {
+  const modulus = Point.CURVE().n;
+  const result = value % modulus;
+  return result >= 0n ? result : result + modulus;
+}
+function numberToBytesLE(value, length) {
+  const out = new Uint8Array(length);
+  let current = value;
+  for (let i = 0; i < length; i++) {
+    out[i] = Number(current & 0xffn);
+    current >>= 8n;
+  }
+  return out;
+}
+async function signWithDomain(message, privateKey, publicKey, domain = 0 /* TXN */) {
+  if (privateKey.length !== PUBKEY_SIZE) {
+    throw new Error("Private key must contain 32 bytes");
+  }
+  const domainBlock = createDomainBlock(domain);
+  const messageBytes = copyBytes2(message);
+  const extended = utils.getExtendedPublicKey(privateKey);
+  const publicKeyBytes = publicKey ? copyBytes2(publicKey) : extended.pointBytes;
+  if (publicKeyBytes.length !== PUBKEY_SIZE) {
+    throw new Error("Public key must contain 32 bytes");
+  }
+  const rInput = concatBytes(domainBlock, extended.prefix, messageBytes);
+  const r = modOrder(bytesToNumberLE(sha512Bytes(rInput)));
+  const R = Point.BASE.multiply(r).toBytes();
+  const kInput = concatBytes(domainBlock, R, publicKeyBytes, messageBytes);
+  const k = modOrder(bytesToNumberLE(sha512Bytes(kInput)));
+  const s = modOrder(r + k * extended.scalar);
+  const signature = new Uint8Array(SIGNATURE_SIZE);
+  signature.set(R, 0);
+  signature.set(numberToBytesLE(s, PUBKEY_SIZE), PUBKEY_SIZE);
+  return signature;
+}
+async function verifyWithDomain(signature, message, publicKey, domain = 0 /* TXN */) {
+  if (signature.length !== SIGNATURE_SIZE || publicKey.length !== PUBKEY_SIZE) {
+    return false;
+  }
+  const domainBlock = createDomainBlock(domain);
+  const messageBytes = copyBytes2(message);
+  const rBytes = signature.subarray(0, PUBKEY_SIZE);
+  const s = bytesToNumberLE(signature.subarray(PUBKEY_SIZE));
+  if (s >= Point.CURVE().n) {
+    return false;
+  }
+  let R;
+  let A;
+  try {
+    R = Point.fromBytes(rBytes);
+    A = Point.fromBytes(publicKey);
+  } catch {
+    return false;
+  }
+  const kInput = concatBytes(domainBlock, rBytes, publicKey, messageBytes);
+  const k = modOrder(bytesToNumberLE(sha512Bytes(kInput)));
+  const lhs = Point.BASE.multiply(s);
+  const rhs = R.add(A.multiply(k));
+  return lhs.add(rhs.negate()).clearCofactor().is0();
+}
+
+// thru-ts-client-sdk/wire-format.ts
+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_BODY_SIZE = 112;
+var TXN_VERSION_V1 = 1;
+var TXN_MAX_ACCOUNTS = 1024;
+var STATE_PROOF_HEADER_SIZE = 40;
+var ACCOUNT_META_FOOTPRINT = 64;
+var TXN_FLAG_HAS_FEE_PAYER_PROOF = 1 << 0;
+var STATE_PROOF_TYPE_EXISTING = 0;
+var STATE_PROOF_TYPE_UPDATING = 1;
+var STATE_PROOF_TYPE_CREATION = 2;
+
+// thru-ts-client-sdk/domain/transactions/Transaction.ts
+var DEFAULT_FLAGS = 0;
+var MAX_INSTRUCTION_DATA_LENGTH = 65535;
+var BYTE_POPCOUNT = new Uint8Array(256).map((_value, index) => {
+  let v = index;
+  let count = 0;
+  while (v !== 0) {
+    count += v & 1;
+    v >>= 1;
+  }
+  return count;
+});
+var Transaction = class _Transaction {
+  constructor(params) {
+    this.version = params.version ?? TXN_VERSION_V1;
+    this.feePayer = Pubkey.from(params.feePayer);
+    this.program = Pubkey.from(params.program);
+    this.fee = params.header.fee;
+    this.nonce = params.header.nonce;
+    this.startSlot = params.header.startSlot;
+    this.expiryAfter = params.header.expiryAfter ?? 0;
+    this.chainId = params.header.chainId ?? 1;
+    this.requestedComputeUnits = params.header.computeUnits ?? 0;
+    this.requestedStateUnits = params.header.stateUnits ?? 0;
+    this.requestedMemoryUnits = params.header.memoryUnits ?? 0;
+    this.flags = params.header.flags ?? DEFAULT_FLAGS;
+    this.readWriteAccounts = params.accounts?.readWriteAccounts ? params.accounts.readWriteAccounts.map(Pubkey.from) : [];
+    this.readOnlyAccounts = params.accounts?.readOnlyAccounts ? params.accounts.readOnlyAccounts.map(Pubkey.from) : [];
+    this.instructionData = params.instructionData ? new Uint8Array(params.instructionData) : void 0;
+    if (this.instructionData && this.instructionData.length > MAX_INSTRUCTION_DATA_LENGTH) {
+      throw new Error(`Instruction data exceeds maximum length (${MAX_INSTRUCTION_DATA_LENGTH} bytes)`);
+    }
+    this.instructionDataSize = params.instructionDataSize;
+    this.feePayerStateProof = params.proofs?.feePayerStateProof ? new Uint8Array(params.proofs.feePayerStateProof) : void 0;
+    this.feePayerAccountMetaRaw = params.proofs?.feePayerAccountMetaRaw ? new Uint8Array(params.proofs.feePayerAccountMetaRaw) : void 0;
+  }
+  static fromWire(data) {
+    const { transaction, size } = _Transaction.parseWire(data, { strict: true });
+    if (size !== data.length) {
+      throw new Error(
+        `Transaction body has trailing bytes: expected ${size} bytes but found ${data.length}`
+      );
+    }
+    return transaction;
+  }
+  static parseWire(data, options = {}) {
+    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;
+    if (strict && version !== TXN_VERSION_V1) {
+      throw new Error(`Unsupported transaction version: ${version}`);
+    }
+    const flags = view.getUint8(offset);
+    offset += 1;
+    const invalidFlags = flags & -4;
+    if (strict && invalidFlags !== 0) {
+      throw new Error(`Unsupported transaction flags: 0x${invalidFlags.toString(16).padStart(2, "0")}`);
+    }
+    const readwriteAccountsCount = view.getUint16(offset, true);
+    offset += 2;
+    const readonlyAccountsCount = view.getUint16(offset, true);
+    offset += 2;
+    const instructionDataSize = view.getUint16(offset, true);
+    offset += 2;
+    const requestedComputeUnits = view.getUint32(offset, true);
+    offset += 4;
+    const requestedStateUnits = view.getUint16(offset, true);
+    offset += 2;
+    const requestedMemoryUnits = view.getUint16(offset, true);
+    offset += 2;
+    const fee = view.getBigUint64(offset, true);
+    offset += 8;
+    const nonce = view.getBigUint64(offset, true);
+    offset += 8;
+    const startSlot = view.getBigUint64(offset, true);
+    offset += 8;
+    const expiryAfter = view.getUint32(offset, true);
+    offset += 4;
+    const chainId = view.getUint16(offset, true);
+    offset += 2;
+    offset += 2;
+    _Transaction.ensureAvailable(data.length, offset, PUBKEY_SIZE2, "fee payer account");
+    const feePayer = data.slice(offset, offset + PUBKEY_SIZE2);
+    offset += PUBKEY_SIZE2;
+    _Transaction.ensureAvailable(data.length, offset, PUBKEY_SIZE2, "program account");
+    const program = data.slice(offset, offset + PUBKEY_SIZE2);
+    offset += PUBKEY_SIZE2;
+    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) {
+      throw new Error(
+        `Transaction references ${totalAccountCount} accounts (maximum allowed ${TXN_MAX_ACCOUNTS})`
+      );
+    }
+    const accountsSize = totalAccountCount * PUBKEY_SIZE2;
+    let expectedBodySize = accountsSize + instructionDataSize;
+    if ((flags & TXN_FLAG_HAS_FEE_PAYER_PROOF) !== 0) {
+      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);
+      const proofType = Number(typeSlot >> 62n & 0x3n);
+      const pathBitset = data.subarray(proofOffset + 8, proofOffset + 40);
+      const siblingCount = countSetBits(pathBitset);
+      const bodyCount = proofType + siblingCount;
+      const proofFootprint = STATE_PROOF_HEADER_SIZE + bodyCount * HASH_SIZE;
+      expectedBodySize += proofFootprint;
+      if (proofType === STATE_PROOF_TYPE_EXISTING) {
+        expectedBodySize += ACCOUNT_META_FOOTPRINT;
+      }
+    }
+    const txnSize = TXN_HEADER_BODY_SIZE + expectedBodySize + SIGNATURE_SIZE2;
+    _Transaction.ensureAvailable(data.length, 0, txnSize, "full transaction");
+    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");
+      readWriteAccounts.push(data.slice(offset, offset + PUBKEY_SIZE2));
+      offset += PUBKEY_SIZE2;
+    }
+    const readOnlyAccounts = [];
+    for (let i = 0; i < readonlyAccountsCount; i++) {
+      _Transaction.ensureAvailable(sigStart, offset, PUBKEY_SIZE2, "read-only accounts");
+      readOnlyAccounts.push(data.slice(offset, offset + PUBKEY_SIZE2));
+      offset += PUBKEY_SIZE2;
+    }
+    let instructionData;
+    if (instructionDataSize > 0) {
+      _Transaction.ensureAvailable(sigStart, offset, instructionDataSize, "instruction data");
+      instructionData = data.slice(offset, offset + instructionDataSize);
+      offset += instructionDataSize;
+    }
+    let feePayerStateProof;
+    let feePayerAccountMetaRaw;
+    if ((flags & TXN_FLAG_HAS_FEE_PAYER_PROOF) !== 0) {
+      const { proofBytes, footprint, proofType } = _Transaction.parseStateProof(data.subarray(offset, sigStart));
+      feePayerStateProof = proofBytes;
+      offset += footprint;
+      if (proofType === STATE_PROOF_TYPE_EXISTING) {
+        _Transaction.ensureAvailable(sigStart, offset, ACCOUNT_META_FOOTPRINT, "fee payer account metadata");
+        feePayerAccountMetaRaw = data.slice(offset, offset + ACCOUNT_META_FOOTPRINT);
+        offset += ACCOUNT_META_FOOTPRINT;
+      }
+    }
+    if (offset !== sigStart) {
+      throw new Error(
+        `Transaction body has trailing bytes: expected ${sigStart} bytes consumed but found ${offset}`
+      );
+    }
+    const signatureBytes = data.slice(sigStart, sigStart + SIGNATURE_SIZE2);
+    const hasSignature = hasNonZeroBytes(signatureBytes);
+    const transaction = new _Transaction({
+      version,
+      feePayer: Pubkey.from(feePayer),
+      program: Pubkey.from(program),
+      header: {
+        fee,
+        nonce,
+        startSlot,
+        expiryAfter,
+        chainId,
+        computeUnits: requestedComputeUnits,
+        stateUnits: requestedStateUnits,
+        memoryUnits: requestedMemoryUnits,
+        flags
+      },
+      accounts: {
+        readWriteAccounts,
+        readOnlyAccounts
+      },
+      instructionData,
+      instructionDataSize,
+      proofs: feePayerStateProof || feePayerAccountMetaRaw ? {
+        feePayerStateProof,
+        feePayerAccountMetaRaw
+      } : void 0
+    });
+    if (hasSignature) {
+      transaction.setSignature(Signature.from(signatureBytes));
+    }
+    return { transaction, size: txnSize };
+  }
+  static fromProto(proto) {
+    if (!proto.header) {
+      throw new Error("Transaction proto missing header");
+    }
+    const header = proto.header;
+    const body = proto.body ? new Uint8Array(proto.body) : void 0;
+    let transaction;
+    if (body && body.length > 0) {
+      try {
+        const { transaction: parsed } = this.parseWire(body, { strict: false });
+        transaction = parsed;
+      } catch (err) {
+        transaction = void 0;
+      }
+    }
+    if (!transaction) {
+      let parsed;
+      if (body && body.length > 0) {
+        try {
+          parsed = this.parseBodySections(
+            body,
+            header.readwriteAccountsCount ?? 0,
+            header.readonlyAccountsCount ?? 0,
+            header.instructionDataSize ?? 0,
+            header.flags ?? DEFAULT_FLAGS
+          );
+        } catch (sectionErr) {
+          if (body.length >= TXN_HEADER_BODY_SIZE) {
+            parsed = this.parseBodySections(
+              body.slice(TXN_HEADER_BODY_SIZE),
+              header.readwriteAccountsCount ?? 0,
+              header.readonlyAccountsCount ?? 0,
+              header.instructionDataSize ?? 0,
+              header.flags ?? DEFAULT_FLAGS
+            );
+          } else {
+            throw sectionErr;
+          }
+        }
+      }
+      if (!parsed) {
+        parsed = {
+          readWriteAccounts: [],
+          readOnlyAccounts: [],
+          instructionData: void 0,
+          feePayerStateProof: void 0,
+          feePayerAccountMetaRaw: void 0
+        };
+      }
+      transaction = new _Transaction({
+        version: header.version ?? TXN_VERSION_V1,
+        feePayer: Pubkey.fromProtoPubkey(header.feePayerPubkey),
+        program: Pubkey.fromProtoPubkey(header.programPubkey),
+        header: {
+          fee: header.fee ?? 0n,
+          nonce: header.nonce ?? 0n,
+          startSlot: header.startSlot ?? 0n,
+          expiryAfter: header.expiryAfter ?? 0,
+          chainId: header.chainId ?? 1,
+          computeUnits: header.requestedComputeUnits ?? 0,
+          stateUnits: header.requestedStateUnits ?? 0,
+          memoryUnits: header.requestedMemoryUnits ?? 0,
+          flags: header.flags ?? DEFAULT_FLAGS
+        },
+        accounts: {
+          readWriteAccounts: parsed.readWriteAccounts,
+          readOnlyAccounts: parsed.readOnlyAccounts
+        },
+        instructionData: parsed.instructionData,
+        instructionDataSize: header.instructionDataSize,
+        proofs: parsed.feePayerStateProof || parsed.feePayerAccountMetaRaw ? {
+          feePayerStateProof: parsed.feePayerStateProof,
+          feePayerAccountMetaRaw: parsed.feePayerAccountMetaRaw
+        } : void 0
+      });
+    }
+    const signatureBytes = proto.signature?.value ?? header.feePayerSignature?.value ?? void 0;
+    if (signatureBytes && signatureBytes.length === SIGNATURE_SIZE2 && hasNonZeroBytes(signatureBytes)) {
+      transaction.setSignature(Signature.from(signatureBytes));
+    }
+    if (proto.executionResult) {
+      transaction.executionResult = _Transaction.executionResultFromProto(proto.executionResult);
+    }
+    if (proto.slot !== void 0) {
+      transaction.slot = proto.slot;
+    }
+    if (proto.blockOffset !== void 0) {
+      transaction.blockOffset = proto.blockOffset;
+    }
+    return transaction;
+  }
+  getSignature() {
+    return this.signature;
+  }
+  setSignature(signature) {
+    this.signature = signature;
+  }
+  async sign(privateKey) {
+    if (privateKey.length !== 32) {
+      throw new Error("Fee payer private key must contain 32 bytes");
+    }
+    const payload = this.toWireForSigning();
+    const publicKey = this.feePayer.toBytes();
+    const signature = await signWithDomain(
+      payload,
+      privateKey,
+      publicKey,
+      0 /* TXN */
+    );
+    if (signature.length !== SIGNATURE_SIZE2) {
+      throw new Error("ed25519 signing produced an invalid signature");
+    }
+    this.signature = Signature.from(signature);
+    return this.signature;
+  }
+  toWireForSigning() {
+    const header = this.createHeader();
+    return this.buildWirePayload(new Uint8Array(header), false);
+  }
+  toWire() {
+    const header = this.createHeader();
+    return this.buildWirePayload(new Uint8Array(header), true);
+  }
+  createHeader() {
+    const buffer = new ArrayBuffer(TXN_HEADER_BODY_SIZE);
+    const headerBytes = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    view.setUint8(offset, this.version & 255);
+    offset += 1;
+    view.setUint8(offset, this.flags & 255);
+    offset += 1;
+    view.setUint16(offset, this.readWriteAccounts.length, true);
+    offset += 2;
+    view.setUint16(offset, this.readOnlyAccounts.length, true);
+    offset += 2;
+    const instructionDataLength = this.instructionData?.length ?? 0;
+    if (instructionDataLength > MAX_INSTRUCTION_DATA_LENGTH) {
+      throw new Error(`Instruction data exceeds maximum length (${MAX_INSTRUCTION_DATA_LENGTH} bytes)`);
+    }
+    view.setUint16(offset, instructionDataLength, true);
+    offset += 2;
+    view.setUint32(offset, ensureUint32(this.requestedComputeUnits), true);
+    offset += 4;
+    view.setUint16(offset, ensureUint16(this.requestedStateUnits), true);
+    offset += 2;
+    view.setUint16(offset, ensureUint16(this.requestedMemoryUnits), true);
+    offset += 2;
+    view.setBigUint64(offset, ensureBigUint64(this.fee), true);
+    offset += 8;
+    view.setBigUint64(offset, ensureBigUint64(this.nonce), true);
+    offset += 8;
+    view.setBigUint64(offset, ensureBigUint64(this.startSlot), true);
+    offset += 8;
+    view.setUint32(offset, ensureUint32(this.expiryAfter), true);
+    offset += 4;
+    view.setUint16(offset, ensureUint16(this.chainId), true);
+    offset += 2;
+    offset += 2;
+    headerBytes.set(this.feePayer.toBytes(), offset);
+    offset += PUBKEY_SIZE2;
+    headerBytes.set(this.program.toBytes(), offset);
+    return buffer;
+  }
+  buildWirePayload(headerBytes, includeSignature) {
+    const dynamicLength = this.readWriteAccounts.length * PUBKEY_SIZE2 + this.readOnlyAccounts.length * PUBKEY_SIZE2 + (this.instructionData?.length ?? 0) + (this.feePayerStateProof?.length ?? 0) + (this.feePayerAccountMetaRaw?.length ?? 0);
+    const signatureLength = includeSignature ? SIGNATURE_SIZE2 : 0;
+    const result = new Uint8Array(headerBytes.length + dynamicLength + signatureLength);
+    result.set(headerBytes, 0);
+    let offset = headerBytes.length;
+    offset = appendAccountList(result, offset, this.readWriteAccounts.map((account) => account.toBytes()));
+    offset = appendAccountList(result, offset, this.readOnlyAccounts.map((account) => account.toBytes()));
+    if (this.instructionData) {
+      result.set(this.instructionData, offset);
+      offset += this.instructionData.length;
+    }
+    if (this.feePayerStateProof) {
+      result.set(this.feePayerStateProof, offset);
+      offset += this.feePayerStateProof.length;
+    }
+    if (this.feePayerAccountMetaRaw) {
+      result.set(this.feePayerAccountMetaRaw, offset);
+      offset += this.feePayerAccountMetaRaw.length;
+    }
+    if (includeSignature) {
+      if (this.signature) {
+        result.set(this.signature.toBytes(), offset);
+      }
+    }
+    return result;
+  }
+  static parseBodySections(body, readwriteCount, readonlyCount, instructionDataSize, flags) {
+    let offset = 0;
+    const readWriteAccounts = [];
+    for (let i = 0; i < readwriteCount; i++) {
+      this.ensureAvailable(body.length, offset, PUBKEY_SIZE2, "read-write accounts");
+      readWriteAccounts.push(body.slice(offset, offset + PUBKEY_SIZE2));
+      offset += PUBKEY_SIZE2;
+    }
+    const readOnlyAccounts = [];
+    for (let i = 0; i < readonlyCount; i++) {
+      this.ensureAvailable(body.length, offset, PUBKEY_SIZE2, "read-only accounts");
+      readOnlyAccounts.push(body.slice(offset, offset + PUBKEY_SIZE2));
+      offset += PUBKEY_SIZE2;
+    }
+    let instructionData;
+    if (instructionDataSize > 0) {
+      this.ensureAvailable(body.length, offset, instructionDataSize, "instruction data");
+      instructionData = body.slice(offset, offset + instructionDataSize);
+      offset += instructionDataSize;
+    }
+    let feePayerStateProof;
+    let feePayerAccountMetaRaw;
+    if ((flags & TXN_FLAG_HAS_FEE_PAYER_PROOF) !== 0) {
+      const { proofBytes, footprint, proofType } = this.parseStateProof(body.subarray(offset));
+      feePayerStateProof = proofBytes;
+      offset += footprint;
+      if (proofType === STATE_PROOF_TYPE_EXISTING) {
+        this.ensureAvailable(body.length, offset, ACCOUNT_META_FOOTPRINT, "fee payer account metadata");
+        feePayerAccountMetaRaw = body.slice(offset, offset + ACCOUNT_META_FOOTPRINT);
+        offset += ACCOUNT_META_FOOTPRINT;
+      }
+    }
+    if (offset !== body.length) {
+      throw new Error(
+        `Transaction body has trailing bytes: expected ${offset} bytes but found ${body.length}`
+      );
+    }
+    return {
+      readWriteAccounts,
+      readOnlyAccounts,
+      instructionData,
+      feePayerStateProof,
+      feePayerAccountMetaRaw
+    };
+  }
+  static ensureAvailable(totalLength, offset, required, context) {
+    if (offset + required > totalLength) {
+      throw new Error(`Transaction data truncated while parsing ${context}`);
+    }
+  }
+  static parseStateProof(data) {
+    if (data.length < STATE_PROOF_HEADER_SIZE) {
+      throw new Error("Transaction data truncated while parsing state proof header");
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const typeSlot = view.getBigUint64(0, true);
+    const proofType = Number(typeSlot >> 62n & 0x3n);
+    if (proofType !== STATE_PROOF_TYPE_EXISTING && proofType !== STATE_PROOF_TYPE_UPDATING && proofType !== STATE_PROOF_TYPE_CREATION) {
+      throw new Error(`Transaction state proof has unknown type: ${proofType}`);
+    }
+    const pathBitset = data.subarray(8, 40);
+    const siblingCount = countSetBits(pathBitset);
+    const bodyCount = proofType + siblingCount;
+    const totalSize = STATE_PROOF_HEADER_SIZE + bodyCount * HASH_SIZE;
+    if (proofType === STATE_PROOF_TYPE_CREATION && bodyCount < 2) {
+      throw new Error("Transaction state proof creation entry is truncated");
+    }
+    if (proofType === STATE_PROOF_TYPE_UPDATING && bodyCount < 1) {
+      throw new Error("Transaction state proof updating entry is truncated");
+    }
+    if (data.length < totalSize) {
+      throw new Error("Transaction data truncated while parsing state proof body");
+    }
+    return {
+      proofBytes: data.slice(0, totalSize),
+      footprint: totalSize,
+      proofType
+    };
+  }
+  static executionResultFromProto(proto) {
+    return {
+      consumedComputeUnits: proto.consumedComputeUnits ?? 0,
+      consumedMemoryUnits: proto.consumedMemoryUnits ?? 0,
+      consumedStateUnits: proto.consumedStateUnits ?? 0,
+      userErrorCode: proto.userErrorCode ?? 0n,
+      vmError: proto.vmError ?? 0 /* TRANSACTION_VM_EXECUTE_SUCCESS */,
+      executionResult: proto.executionResult ?? 0n,
+      pagesUsed: proto.pagesUsed ?? 0,
+      eventsCount: proto.eventsCount ?? 0,
+      eventsSize: proto.eventsSize ?? 0,
+      readwriteAccounts: proto.readwriteAccounts.map((account) => Pubkey.fromProtoPubkey(account)),
+      readonlyAccounts: proto.readonlyAccounts.map((account) => Pubkey.fromProtoPubkey(account)),
+      events: proto.events.length ? proto.events.map((event) => ({
+        eventId: event.eventId,
+        callIdx: event.callIdx,
+        programIdx: event.programIdx,
+        program: event.program ? Pubkey.fromProtoPubkey(event.program) : void 0,
+        payload: new Uint8Array(event.payload ?? new Uint8Array(0))
+      })) : void 0,
+      errorProgramAccIdx: proto.errorProgramAccIdx ?? 0
+    };
+  }
+};
+function appendAccountList(target, start, accounts) {
+  let offset = start;
+  for (const account of accounts) {
+    target.set(account, offset);
+    offset += PUBKEY_SIZE2;
+  }
+  return offset;
+}
+function ensureUint16(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    throw new Error("Value must fit within uint16 range");
+  }
+  return value;
+}
+function ensureUint32(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw new Error("Value must fit within uint32 range");
+  }
+  return value;
+}
+function ensureBigUint64(value) {
+  if (value < 0n || value > 0xffffffffffffffffn) {
+    throw new Error("Value must fit within uint64 range");
+  }
+  return value;
+}
+function countSetBits(bytes) {
+  let total = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    total += BYTE_POPCOUNT[bytes[i]];
+  }
+  return total;
+}
+function hasNonZeroBytes(value) {
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] !== 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// thru-ts-client-sdk/domain/transactions/utils.ts
+var ACCOUNT_LIMIT = 1024;
+function normalizeAccountList(accounts) {
+  if (accounts.length === 0) {
+    return [];
+  }
+  if (accounts.length > ACCOUNT_LIMIT) {
+    throw new Error(`Too many accounts provided: ${accounts.length} (max ${ACCOUNT_LIMIT})`);
+  }
+  const deduped = dedupeAccountList(accounts);
+  return deduped;
+}
+function dedupeAccountList(accounts) {
+  const pubkeys = accounts.map(Pubkey.from).map((pubkey) => pubkey.toBytes());
+  const seen = /* @__PURE__ */ new Map();
+  for (const pubkey of pubkeys) {
+    if (pubkey.length !== 32) {
+      throw new Error("Account addresses must contain 32 bytes");
+    }
+    const key = toHex(pubkey);
+    if (!seen.has(key)) {
+      seen.set(key, pubkey);
+    }
+  }
+  return Array.from(seen.values()).sort(compareAccounts);
+}
+function compareAccounts(a, b) {
+  for (let i = 0; i < 32; i++) {
+    if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+  }
+  return 0;
+}
+function toHex(bytes) {
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    const hex = bytes[i].toString(16).padStart(2, "0");
+    result += hex;
+  }
+  return result;
+}
+function parseInstructionData(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value);
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      return new Uint8Array();
+    }
+    if (isHexString(value)) {
+      return hexToBytes(value);
+    }
+  }
+  throw new Error("Instruction data must be provided as hex string or Uint8Array");
+}
+function createInstructionContext(feePayer, program, sortedReadWrite, sortedReadOnly) {
+  const accounts = [
+    feePayer,
+    program,
+    ...sortedReadWrite.map((bytes) => Pubkey.from(bytes)),
+    ...sortedReadOnly.map((bytes) => Pubkey.from(bytes))
+  ];
+  const indexMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < accounts.length; i++) {
+    const key = toHex(accounts[i].toBytes());
+    if (!indexMap.has(key)) {
+      indexMap.set(key, i);
+    }
+  }
+  return {
+    accounts,
+    getAccountIndex: (pubkey) => {
+      const bytes = Pubkey.from(pubkey).toBytes();
+      const key = toHex(bytes);
+      const index = indexMap.get(key);
+      if (index === void 0) {
+        throw new Error(`Account ${key} not found in transaction accounts`);
+      }
+      return index;
+    }
+  };
+}
+
+// thru-ts-client-sdk/domain/transactions/TransactionBuilder.ts
+var FLAG_HAS_FEE_PAYER_PROOF = 1 << 0;
+var TransactionBuilder = class {
+  build(params) {
+    const feePayer = Pubkey.from(params.feePayer.publicKey);
+    const program = Pubkey.from(params.program);
+    const sortedReadWrite = normalizeAccountList(params.accounts?.readWriteAccounts ?? []);
+    const sortedReadOnly = normalizeAccountList(params.accounts?.readOnlyAccounts ?? []);
+    let instructionData;
+    if (params.buildInstructionData) {
+      const context = createInstructionContext(feePayer, program, sortedReadWrite, sortedReadOnly);
+      const result = params.buildInstructionData(context);
+      instructionData = parseInstructionData(result);
+    } else {
+      instructionData = parseInstructionData(params.instructionData);
+    }
+    const baseFlags = params.header.flags ?? 0;
+    const flags = params.proofs?.feePayerStateProof ? baseFlags | FLAG_HAS_FEE_PAYER_PROOF : baseFlags;
+    const accounts = sortedReadWrite.length > 0 || sortedReadOnly.length > 0 ? { readWriteAccounts: sortedReadWrite, readOnlyAccounts: sortedReadOnly } : void 0;
+    return new Transaction({
+      feePayer,
+      program,
+      header: {
+        ...params.header,
+        flags
+      },
+      accounts,
+      instructionData,
+      proofs: params.proofs
+    });
+  }
+  async buildAndSign(params) {
+    if (!params.feePayer.privateKey) {
+      throw new Error("Fee payer private key is required to sign the transaction");
+    }
+    const transaction = this.build(params);
+    const signature = await transaction.sign(params.feePayer.privateKey);
+    const rawTransaction = transaction.toWire();
+    return { transaction, signature, rawTransaction };
+  }
+};
+
+// thru-ts-client-sdk/modules/proofs.ts
+var proofs_exports = {};
+__export(proofs_exports, {
+  generateStateProof: () => generateStateProof,
+  getStateRoots: () => getStateRoots
+});
+
+// thru-ts-client-sdk/domain/proofs/StateProof.ts
+var StateProof = class _StateProof {
+  constructor(params) {
+    this.proof = copyBytes3(params.proof);
+    this.slot = params.slot;
+  }
+  static fromProto(proto) {
+    return new _StateProof({
+      proof: proto.proof,
+      slot: proto.slot ?? 0n
+    });
+  }
+};
+function copyBytes3(bytes) {
+  const copy = new Uint8Array(bytes.length);
+  copy.set(bytes);
+  return copy;
+}
+
+// thru-ts-client-sdk/modules/proofs.ts
+async function generateStateProof(ctx, options) {
+  const targetSlot = options.targetSlot ?? 0n;
+  const request = create(StateProofRequestSchema, {
+    address: options.address ? Pubkey.from(options.address).toProtoPubkey() : void 0,
+    proofType: options.proofType,
+    targetSlot
+  });
+  const schemaRequest = create(GenerateStateProofRequestSchema, { request });
+  const response = await ctx.query.generateStateProof(
+    schemaRequest,
+    withCallOptions(ctx)
+  );
+  if (!response.proof) {
+    throw new Error("State proof response missing proof");
+  }
+  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
+function getAccount(ctx, address, options = {}) {
+  const request = create(GetAccountRequestSchema, {
+    address: Pubkey.from(address).toProtoPubkey(),
+    view: options.view ?? DEFAULT_ACCOUNT_VIEW,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
+    dataSlice: options.dataSlice
+  });
+  return ctx.query.getAccount(request, withCallOptions(ctx)).then(Account.fromProto);
+}
+function getRawAccount(ctx, address, options = {}) {
+  const request = create(GetRawAccountRequestSchema, {
+    address: Pubkey.from(address).toProtoPubkey(),
+    view: options.view ?? DEFAULT_ACCOUNT_VIEW,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  return ctx.query.getRawAccount(request, withCallOptions(ctx));
+}
+function listAccounts(ctx, options) {
+  const request = create(ListAccountsRequestSchema, {
+    view: options.view ?? DEFAULT_ACCOUNT_VIEW,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    filter: options.filter?.toProto(),
+    page: options.page?.toProto(),
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  return ctx.query.listAccounts(request, withCallOptions(ctx)).then((response) => ({
+    accounts: response.accounts.map((proto) => Account.fromProto(proto)),
+    page: PageResponse.fromProto(response.page)
+  }));
+}
+async function createAccount(ctx, options) {
+  const feePayer = Pubkey.from(options.publicKey).toBytes();
+  const proofResponse = await generateStateProof(ctx, {
+    address: options.publicKey,
+    proofType: 1 /* CREATING */
+    // targetSlot omitted - server will auto-select
+  });
+  const proofBytes = proofResponse.proof;
+  if (!proofBytes || proofBytes.length === 0) {
+    throw new Error("State proof generation returned empty proof");
+  }
+  const startSlot = proofResponse.slot;
+  const program = new Uint8Array(32);
+  program[31] = 3;
+  const builder = new TransactionBuilder();
+  const headerDefaults = {
+    fee: 0n,
+    nonce: 0n,
+    startSlot,
+    expiryAfter: 100,
+    computeUnits: 1e4,
+    memoryUnits: 1e4,
+    stateUnits: 1e4
+  };
+  const header = mergeTransactionHeader(headerDefaults, options.header);
+  const transaction = builder.build({
+    feePayer: { publicKey: feePayer },
+    program,
+    header,
+    proofs: { feePayerStateProof: proofBytes }
+  });
+  return transaction;
+}
+
+// thru-ts-client-sdk/modules/blocks.ts
+var blocks_exports = {};
+__export(blocks_exports, {
+  getBlock: () => getBlock,
+  getRawBlock: () => getRawBlock,
+  listBlocks: () => listBlocks
+});
+
+// thru-ts-client-sdk/domain/transactions/streaming.ts
+function toStreamTransactionUpdate(proto) {
+  const signatureBytes = proto.signature?.value ? new Uint8Array(proto.signature.value) : new Uint8Array();
+  const executionResult = proto.executionResult ? Transaction.executionResultFromProto(proto.executionResult) : void 0;
+  if (!proto.header) {
+    return {
+      kind: "partial",
+      signature: signatureBytes,
+      slot: proto.slot,
+      executionResult
+    };
+  }
+  return {
+    kind: "full",
+    transaction: Transaction.fromProto(proto)
+  };
+}
+function toTrackTransactionUpdate(response) {
+  const signatureBytes = response.signature?.value ? new Uint8Array(response.signature.value) : void 0;
+  const executionResult = response.executionResult ? Transaction.executionResultFromProto(response.executionResult) : void 0;
+  return {
+    signature: signatureBytes,
+    status: consensusStatusToString(response.consensusStatus),
+    statusCode: response.consensusStatus,
+    slot: response.slot !== 0n ? response.slot : void 0,
+    executionResult,
+    transaction: void 0
+  };
+}
+
+// thru-ts-client-sdk/domain/transactions/TransactionStatusSnapshot.ts
+var TransactionStatusSnapshot = class _TransactionStatusSnapshot {
+  constructor(params) {
+    this.signature = copyBytes4(params.signature);
+    this.statusCode = params.consensusStatus;
+    this.status = params.consensusStatus != null ? consensusStatusToString(params.consensusStatus) : void 0;
+    this.executionResult = params.executionResult;
+  }
+  static fromProto(proto) {
+    if (!proto.signature?.value) {
+      throw new Error("TransactionStatus proto missing signature");
+    }
+    return new _TransactionStatusSnapshot({
+      signature: proto.signature.value,
+      consensusStatus: proto.consensusStatus,
+      executionResult: proto.executionResult ? Transaction.executionResultFromProto(proto.executionResult) : void 0
+    });
+  }
+};
+function copyBytes4(bytes) {
+  const copy = new Uint8Array(bytes.length);
+  copy.set(bytes);
+  return copy;
+}
+
+// thru-ts-client-sdk/domain/blocks/BlockFooter.ts
+var BlockFooter = class _BlockFooter {
+  constructor(params) {
+    this.signature = copyBytes5(params.signature);
+    this.status = params.status;
+    this.consumedComputeUnits = params.consumedComputeUnits;
+    this.consumedStateUnits = params.consumedStateUnits;
+    this.attestorPayment = params.attestorPayment;
+  }
+  static fromProto(proto) {
+    return new _BlockFooter({
+      signature: proto.signature?.value,
+      status: proto.status ?? 0 /* UNSPECIFIED */,
+      consumedComputeUnits: proto.consumedComputeUnits ?? 0n,
+      consumedStateUnits: proto.consumedStateUnits ?? 0,
+      attestorPayment: proto.attestorPayment ?? 0n
+    });
+  }
+};
+function copyBytes5(bytes) {
+  if (!bytes) return void 0;
+  const out = new Uint8Array(bytes.length);
+  out.set(bytes);
+  return out;
+}
+
+// thru-ts-client-sdk/domain/blocks/BlockHeader.ts
+var BlockHeader = class _BlockHeader {
+  constructor(params) {
+    this.slot = params.slot;
+    this.version = params.version;
+    this.headerSignature = copyBytes6(params.headerSignature);
+    this.producer = copyBytes6(params.producer);
+    this.expiryTimestamp = params.expiryTimestamp;
+    this.startSlot = params.startSlot;
+    this.expiryAfter = params.expiryAfter;
+    this.maxBlockSize = params.maxBlockSize;
+    this.maxComputeUnits = params.maxComputeUnits;
+    this.maxStateUnits = params.maxStateUnits;
+    this.bondAmountLockUp = params.bondAmountLockUp;
+    this.weightSlot = params.weightSlot;
+    this.blockHash = copyBytes6(params.blockHash);
+    this.chainId = params.chainId;
+  }
+  static fromProto(proto) {
+    return new _BlockHeader({
+      slot: proto.slot ?? 0n,
+      version: proto.version ?? 0,
+      headerSignature: proto.headerSignature?.value,
+      producer: proto.producer?.value,
+      expiryTimestamp: proto.expiryTimestamp,
+      startSlot: proto.startSlot ?? 0n,
+      expiryAfter: proto.expiryAfter,
+      maxBlockSize: proto.maxBlockSize,
+      maxComputeUnits: proto.maxComputeUnits,
+      maxStateUnits: proto.maxStateUnits,
+      bondAmountLockUp: proto.bondAmountLockUp,
+      weightSlot: proto.weightSlot,
+      blockHash: proto.blockHash?.value,
+      chainId: proto.chainId
+    });
+  }
+  withBlockHash(blockHash) {
+    return new _BlockHeader({
+      slot: this.slot,
+      version: this.version,
+      headerSignature: this.headerSignature,
+      producer: this.producer,
+      expiryTimestamp: this.expiryTimestamp,
+      startSlot: this.startSlot,
+      expiryAfter: this.expiryAfter,
+      maxBlockSize: this.maxBlockSize,
+      maxComputeUnits: this.maxComputeUnits,
+      maxStateUnits: this.maxStateUnits,
+      bondAmountLockUp: this.bondAmountLockUp,
+      weightSlot: this.weightSlot,
+      blockHash,
+      chainId: this.chainId
+    });
+  }
+};
+function copyBytes6(bytes) {
+  if (!bytes) return void 0;
+  const out = new Uint8Array(bytes.length);
+  out.set(bytes);
+  return out;
+}
+
+// thru-ts-client-sdk/domain/blocks/Block.ts
+var BLOCK_HASH_SIZE = 32;
+var RESERVED_FOOTER_PADDING = 0n;
+var SIGNATURE_PREFIX_SIZE = SIGNATURE_SIZE2;
+var Block = class _Block {
+  constructor(params) {
+    this.header = params.header;
+    this.footer = params.footer;
+    this.body = params.body ? new Uint8Array(params.body) : void 0;
+    this.consensusStatus = params.consensusStatus;
+  }
+  static fromProto(proto) {
+    if (!proto.header) {
+      throw new Error("Block proto missing header");
+    }
+    const rawBody = proto.body ? new Uint8Array(proto.body) : void 0;
+    const transactionBody = _Block.extractTransactionBody(rawBody, !!proto.footer);
+    const block = new _Block({
+      header: BlockHeader.fromProto(proto.header),
+      footer: proto.footer ? BlockFooter.fromProto(proto.footer) : void 0,
+      body: transactionBody,
+      consensusStatus: proto.consensusStatus
+    });
+    block.attestorPayment = block.footer?.attestorPayment ?? 0n;
+    return block;
+  }
+  static fromWire(data) {
+    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;
+    }
+    if (header.version !== BLOCK_VERSION_V1) {
+      return null;
+    }
+    let finalHeader = header;
+    let footer;
+    let footerInfo;
+    let body;
+    if (data.length >= headerSize + BLOCK_FOOTER_SIZE) {
+      const footerOffset = data.length - BLOCK_FOOTER_SIZE;
+      const footerBytes = data.slice(footerOffset);
+      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 > 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;
+    block.attestorPayment = footerInfo?.attestorPayment ?? 0n;
+    return block;
+  }
+  toWire() {
+    const headerBytes = this.serializeHeader();
+    const bodyBytes = this.body ?? new Uint8Array(0);
+    const footerBytes = this.footer ? this.serializeFooter() : void 0;
+    const totalLength = headerBytes.length + bodyBytes.length + (footerBytes?.length ?? 0);
+    const result = new Uint8Array(totalLength);
+    result.set(headerBytes, 0);
+    result.set(bodyBytes, headerBytes.length);
+    if (footerBytes) {
+      result.set(footerBytes, headerBytes.length + bodyBytes.length);
+    }
+    return result;
+  }
+  getTransactions() {
+    if (!this.body || this.body.length === 0) {
+      return [];
+    }
+    return _Block.parseTransactionsFromBody(this.body);
+  }
+  static extractTransactionBody(raw, hasFooter) {
+    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 >= 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);
+    const view = new DataView(buffer);
+    const signature = normalizeBytes(this.header.headerSignature, SIGNATURE_SIZE2);
+    bytes.set(signature, 0);
+    let offset = SIGNATURE_PREFIX_SIZE;
+    const version = this.header.version ?? BLOCK_VERSION_V1;
+    view.setUint8(offset, version & 255);
+    offset += 1;
+    bytes.fill(0, offset, offset + 5);
+    offset += 5;
+    view.setUint16(offset, this.header.chainId ?? 0, true);
+    offset += 2;
+    const producer = normalizeBytes(this.header.producer, PUBKEY_SIZE2);
+    bytes.set(producer, offset);
+    offset += PUBKEY_SIZE2;
+    const bondAmountLockUp = this.header.bondAmountLockUp ?? 0n;
+    view.setBigUint64(offset, bondAmountLockUp, true);
+    offset += 8;
+    const expiryTimestampNs = timestampToNanoseconds(this.header.expiryTimestamp);
+    view.setBigUint64(offset, expiryTimestampNs, true);
+    offset += 8;
+    const startSlot = this.header.startSlot ?? 0n;
+    view.setBigUint64(offset, startSlot, true);
+    offset += 8;
+    view.setUint32(offset, this.header.expiryAfter ?? 0, true);
+    offset += 4;
+    view.setUint32(offset, this.header.maxBlockSize ?? 0, true);
+    offset += 4;
+    view.setBigUint64(offset, this.header.maxComputeUnits ?? 0n, true);
+    offset += 8;
+    view.setUint32(offset, this.header.maxStateUnits ?? 0, true);
+    offset += 4;
+    bytes.fill(0, offset, offset + 4);
+    offset += 4;
+    view.setBigUint64(offset, this.header.weightSlot ?? 0n, true);
+    offset += 8;
+    const blockTimeNs = this.blockTimeNs ?? 0n;
+    view.setBigUint64(offset, blockTimeNs, true);
+    return bytes;
+  }
+  serializeFooter() {
+    const buffer = new ArrayBuffer(BLOCK_FOOTER_SIZE);
+    const bytes = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    const attestorPayment = this.footer?.attestorPayment ?? this.attestorPayment ?? RESERVED_FOOTER_PADDING;
+    view.setBigUint64(0, attestorPayment, true);
+    const blockHash = normalizeBytes(this.header.blockHash, BLOCK_HASH_SIZE);
+    bytes.set(blockHash, 8);
+    const signature = normalizeBytes(this.footer?.signature, SIGNATURE_SIZE2);
+    bytes.set(signature, 8 + BLOCK_HASH_SIZE);
+    return bytes;
+  }
+  static parseHeader(bytes) {
+    if (bytes.length !== BLOCK_HEADER_SIZE) {
+      throw new Error(`Invalid block header size: ${bytes.length}`);
+    }
+    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;
+    const weightSlot = view.getBigUint64(offset, true);
+    offset += 8;
+    const 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 };
+  }
+  /**
+   * 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}`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 0;
+    const attestorPayment = view.getBigUint64(offset, true);
+    offset += 8;
+    const blockHash = bytes.slice(offset, offset + BLOCK_HASH_SIZE);
+    offset += BLOCK_HASH_SIZE;
+    const signature = bytes.slice(offset, offset + SIGNATURE_SIZE2);
+    const footer = new BlockFooter({
+      signature,
+      status: 0 /* UNSPECIFIED */,
+      consumedComputeUnits: 0n,
+      consumedStateUnits: 0,
+      attestorPayment
+    });
+    return { footer, blockHash, attestorPayment };
+  }
+  static parseTransactionsFromBody(body) {
+    const transactions = [];
+    let offset = 0;
+    while (offset < body.length) {
+      const slice = body.subarray(offset);
+      if (slice.length < 176) {
+        break;
+      }
+      try {
+        const { transaction, size } = Transaction.parseWire(slice);
+        transactions.push(transaction);
+        offset += size;
+      } catch {
+        break;
+      }
+    }
+    return transactions;
+  }
+};
+function normalizeBytes(bytes, size) {
+  if (!bytes || bytes.length !== size) {
+    return new Uint8Array(size);
+  }
+  return bytes;
+}
+function toBlockHash(value) {
+  return create(BlockHashSchema, { value: ensureBytes(value, "blockHash") });
+}
+function deriveProgramAddress(options) {
+  const programAddress = Pubkey.from(options.programAddress).toBytes();
+  const seed = normalizeSeed(options.seed);
+  const ephemeral = options.ephemeral === true;
+  const derivationInput = new Uint8Array(
+    programAddress.length + 1 + seed.length
+  );
+  derivationInput.set(programAddress, 0);
+  derivationInput[programAddress.length] = ephemeral ? 1 : 0;
+  derivationInput.set(seed, programAddress.length + 1);
+  const hash = sha256(derivationInput);
+  const derivedBytes = new Uint8Array(hash.slice(0, 32));
+  return {
+    bytes: derivedBytes,
+    address: encodeAddress(derivedBytes)
+  };
+}
+function deriveAddress(inputs) {
+  if (inputs.length === 0) {
+    throw new Error("At least one input is required");
+  }
+  const normalizedInputs = inputs.map((input) => normalizeToBytes(input));
+  const totalLength = normalizedInputs.reduce(
+    (sum, arr) => sum + arr.length,
+    0
+  );
+  const derivationInput = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const input of normalizedInputs) {
+    derivationInput.set(input, offset);
+    offset += input.length;
+  }
+  const hash = sha256(derivationInput);
+  const derivedBytes = new Uint8Array(hash.slice(0, 32));
+  return {
+    bytes: derivedBytes,
+    address: encodeAddress(derivedBytes)
+  };
+}
+function normalizeToBytes(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  return Pubkey.from(input).toBytes();
+}
+function normalizeSeed(value) {
+  if (value instanceof Uint8Array) {
+    if (value.length === 0) {
+      throw new Error("Seed cannot be empty");
+    }
+    if (value.length > 32) {
+      throw new Error("Seed cannot exceed 32 bytes");
+    }
+    const seed = new Uint8Array(32);
+    seed.set(value);
+    return seed;
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      throw new Error("Seed cannot be empty");
+    }
+    if (isHexString(value)) {
+      const bytes = hexToBytes(value);
+      if (bytes.length !== 32) {
+        throw new Error(
+          `Hex seed must decode to 32 bytes, got ${bytes.length}`
+        );
+      }
+      return bytes;
+    }
+    const encoder = new TextEncoder();
+    const utf8 = encoder.encode(value);
+    if (utf8.length > 32) {
+      throw new Error(`UTF-8 seed too long: ${utf8.length} bytes (max 32)`);
+    }
+    const seed = new Uint8Array(32);
+    seed.set(utf8);
+    return seed;
+  }
+  throw new Error("Seed must be provided as Uint8Array or string");
+}
+
+// thru-ts-client-sdk/modules/blocks.ts
+async function getBlock(ctx, selector, options = {}) {
+  const request = create(GetBlockRequestSchema, {
+    selector: isSlotSelector(selector) ? { case: "slot", value: typeof selector.slot === "bigint" ? selector.slot : BigInt(selector.slot) } : { case: "blockHash", value: toBlockHash(selector.blockHash) },
+    view: options.view ?? DEFAULT_BLOCK_VIEW,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const proto = await ctx.query.getBlock(request, withCallOptions(ctx));
+  const protoBlock = Block.fromProto(proto);
+  try {
+    const rawBlock = await getRawBlock(ctx, selector);
+    const rawBytes = rawBlock?.rawBlock;
+    if (rawBytes && rawBytes.length >= BLOCK_HEADER_SIZE) {
+      const rawBlockParsed = Block.fromWire(rawBytes);
+      if (rawBlockParsed.blockTimeNs !== void 0) {
+        protoBlock.blockTimeNs = rawBlockParsed.blockTimeNs;
+      }
+      if (rawBlockParsed.attestorPayment !== void 0) {
+        protoBlock.attestorPayment = rawBlockParsed.attestorPayment;
+      }
+    }
+  } catch (error) {
+    console.debug("blocks.getBlock: failed to enrich with raw block", error);
+  }
+  return protoBlock;
+}
+function getRawBlock(ctx, selector, options = {}) {
+  const request = create(GetRawBlockRequestSchema, {
+    selector: isSlotSelector(selector) ? { case: "slot", value: typeof selector.slot === "bigint" ? selector.slot : BigInt(selector.slot) } : { case: "blockHash", value: toBlockHash(selector.blockHash) },
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  return ctx.query.getRawBlock(request, withCallOptions(ctx));
+}
+async function listBlocks(ctx, options = {}) {
+  const request = create(ListBlocksRequestSchema, {
+    filter: options.filter?.toProto(),
+    page: options.page?.toProto(),
+    view: options.view ?? DEFAULT_BLOCK_VIEW,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const response = await ctx.query.listBlocks(request, withCallOptions(ctx));
+  return {
+    blocks: response.blocks.map((proto) => Block.fromProto(proto)),
+    page: PageResponse.fromProto(response.page)
+  };
+}
+
+// thru-ts-client-sdk/modules/consensus.ts
+var consensus_exports = {};
+__export(consensus_exports, {
+  consensusStatusToString: () => consensusStatusToString,
+  currentOrHistoricalVersionContext: () => currentOrHistoricalVersionContext,
+  currentVersionContext: () => currentVersionContext,
+  seqVersionContext: () => seqVersionContext,
+  slotVersionContext: () => slotVersionContext,
+  timestampVersionContext: () => timestampVersionContext,
+  versionContext: () => versionContext
+});
+function currentVersionContext() {
+  return create(VersionContextSchema, {
+    version: { case: "current", value: create(CurrentVersionSchema) }
+  });
+}
+function currentOrHistoricalVersionContext() {
+  return create(VersionContextSchema, {
+    version: { case: "currentOrHistorical", value: create(CurrentOrHistoricalVersionSchema) }
+  });
+}
+function slotVersionContext(slot) {
+  return create(VersionContextSchema, {
+    version: { case: "slot", value: toUint64(slot, "slot") }
+  });
+}
+function timestampVersionContext(value) {
+  return create(VersionContextSchema, {
+    version: { case: "timestamp", value: normalizeTimestamp(value) }
+  });
+}
+function seqVersionContext(seq) {
+  return create(VersionContextSchema, {
+    version: { case: "seq", value: toUint64(seq, "seq") }
+  });
+}
+function versionContext(input) {
+  if (!input) {
+    return currentVersionContext();
+  }
+  if ("version" in input) {
+    return input;
+  }
+  if ("current" in input) {
+    return currentVersionContext();
+  }
+  if ("currentOrHistorical" in input) {
+    return currentOrHistoricalVersionContext();
+  }
+  if ("slot" in input) {
+    return slotVersionContext(input.slot);
+  }
+  if ("timestamp" in input) {
+    return timestampVersionContext(input.timestamp);
+  }
+  if ("seq" in input) {
+    return seqVersionContext(input.seq);
+  }
+  throw new Error("Version context input must specify current, slot, timestamp, or seq");
+}
+function toUint64(value, field) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error(`${field} must be non-negative`);
+    }
+    return value;
+  }
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative integer`);
+  }
+  return BigInt(value);
+}
+function normalizeTimestamp(value) {
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return {
+      seconds: BigInt(Math.floor(ms / 1e3)),
+      nanos: ms % 1e3 * 1e6
+    };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("timestamp must be a finite number");
+    }
+    const ms = Math.trunc(value);
+    return {
+      seconds: BigInt(Math.floor(ms / 1e3)),
+      nanos: ms % 1e3 * 1e6
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  throw new Error("timestamp must be a Date, number, or protobuf Timestamp");
+}
+
+// thru-ts-client-sdk/modules/events.ts
+var events_exports = {};
+__export(events_exports, {
+  getEvent: () => getEvent,
+  listEvents: () => listEvents
+});
+
+// thru-ts-client-sdk/domain/events/ChainEvent.ts
+var ChainEvent = class _ChainEvent {
+  constructor(params) {
+    if (!params.id) {
+      throw new Error("ChainEvent id is required");
+    }
+    this.id = params.id;
+    this.transactionSignature = copyBytes7(params.transactionSignature);
+    this.program = copyBytes7(params.program);
+    this.payload = copyBytes7(params.payload);
+    this.slot = params.slot;
+    this.callIndex = params.callIndex;
+    this.programIndex = params.programIndex;
+    this.payloadSize = params.payloadSize;
+    this.timestampNs = params.timestampNs;
+  }
+  static fromQuery(proto) {
+    return new _ChainEvent({
+      id: proto.eventId,
+      transactionSignature: proto.transactionSignature?.value,
+      program: proto.program?.value,
+      payload: proto.payload,
+      slot: proto.slot,
+      callIndex: proto.callIdx,
+      programIndex: proto.programIdx,
+      payloadSize: proto.payloadSize
+    });
+  }
+  static fromStream(proto) {
+    const id = normalizeStreamEventId(proto.eventId);
+    return new _ChainEvent({
+      id,
+      transactionSignature: proto.signature?.value,
+      program: proto.program?.value,
+      payload: proto.payload,
+      slot: proto.slot,
+      callIndex: proto.callIdx,
+      timestampNs: timestampToNanoseconds(proto.timestamp)
+    });
+  }
+};
+function copyBytes7(input) {
+  if (!input) {
+    return void 0;
+  }
+  const copy = new Uint8Array(input.length);
+  copy.set(input);
+  return copy;
+}
+function normalizeStreamEventId(id) {
+  const parts = id.split(":");
+  if (parts.length >= 4) {
+    return parts.slice(0, 4).join(":");
+  }
+  return id;
+}
+
+// thru-ts-client-sdk/modules/events.ts
+function getEvent(ctx, eventId, options = {}) {
+  if (!eventId) {
+    throw new Error("eventId is required");
+  }
+  const request = create(GetEventRequestSchema, {
+    eventId,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT
+  });
+  return ctx.query.getEvent(request, withCallOptions(ctx)).then((proto) => ChainEvent.fromQuery(proto));
+}
+function listEvents(ctx, options = {}) {
+  const request = create(ListEventsRequestSchema, {
+    filter: options.filter?.toProto(),
+    page: options.page?.toProto(),
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  return ctx.query.listEvents(request, withCallOptions(ctx)).then((response) => ({
+    events: response.events.map((proto) => ChainEvent.fromQuery(proto)),
+    page: PageResponse.fromProto(response.page)
+  }));
+}
+
+// thru-ts-client-sdk/modules/height.ts
+var height_exports = {};
+__export(height_exports, {
+  getBlockHeight: () => getBlockHeight
+});
+
+// thru-ts-client-sdk/domain/height/HeightSnapshot.ts
+var HeightSnapshot = class _HeightSnapshot {
+  constructor(params) {
+    this.finalized = params.finalized;
+    this.locallyExecuted = params.locallyExecuted;
+    this.clusterExecuted = params.clusterExecuted;
+  }
+  static fromProto(proto) {
+    return new _HeightSnapshot({
+      finalized: proto.finalized ?? 0n,
+      locallyExecuted: proto.locallyExecuted ?? 0n,
+      clusterExecuted: proto.clusterExecuted ?? 0n
+    });
+  }
+  delta(other) {
+    return {
+      finalized: this.finalized - other.finalized,
+      locallyExecuted: this.locallyExecuted - other.locallyExecuted,
+      clusterExecuted: this.clusterExecuted - other.clusterExecuted
+    };
+  }
+};
+
+// thru-ts-client-sdk/modules/height.ts
+function getBlockHeight(ctx) {
+  const request = create(GetHeightRequestSchema);
+  return ctx.query.getHeight(request, withCallOptions(ctx)).then((proto) => HeightSnapshot.fromProto(proto));
+}
+
+// thru-ts-client-sdk/modules/chain.ts
+var chain_exports = {};
+__export(chain_exports, {
+  getChainId: () => getChainId,
+  getChainInfo: () => getChainInfo
+});
+async function getChainInfo(ctx) {
+  const request = create(GetChainInfoRequestSchema);
+  return ctx.query.getChainInfo(request, withCallOptions(ctx));
+}
+async function getChainId(ctx) {
+  const response = await getChainInfo(ctx);
+  return response.chainId;
+}
+
+// thru-ts-client-sdk/modules/keys.ts
+var keys_exports = {};
+__export(keys_exports, {
+  fromPrivateKey: () => fromPrivateKey,
+  generateKeyPair: () => generateKeyPair
+});
+async function generateKeyPair() {
+  const seed = generateSeed();
+  const account = await ThruHDWallet.getAccount(seed, 0);
+  seed.fill(0);
+  return {
+    address: account.address,
+    publicKey: account.publicKey,
+    privateKey: account.privateKey
+  };
+}
+async function fromPrivateKey(privateKey) {
+  return new Uint8Array(await getPublicKeyAsync(privateKey));
+}
+function generateSeed() {
+  const cryptoObj = getWebCrypto();
+  const bytes = new Uint8Array(64);
+  cryptoObj.getRandomValues(bytes);
+  return bytes;
+}
+
+// thru-ts-client-sdk/modules/node.ts
+var node_exports = {};
+__export(node_exports, {
+  getNodePubkey: () => getNodePubkey,
+  getNodeRecords: () => getNodeRecords,
+  getNodeStatus: () => getNodeStatus
+});
+async function getNodeStatus(ctx) {
+  const request = create(GetNodeStatusRequestSchema, {});
+  return ctx.query.getNodeStatus(request, withCallOptions(ctx));
+}
+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/nonce.ts
+var nonce_exports = {};
+__export(nonce_exports, {
+  AccountNonceObserver: () => AccountNonceObserver,
+  FeePayerNonceManager: () => FeePayerNonceManager
+});
+
+// thru-ts-client-sdk/modules/streaming.ts
+var streaming_exports = {};
+__export(streaming_exports, {
+  collectStream: () => collectStream,
+  firstStreamValue: () => firstStreamValue,
+  forEachStreamValue: () => forEachStreamValue,
+  streamAccountUpdates: () => streamAccountUpdates,
+  streamBlocks: () => streamBlocks,
+  streamEvents: () => streamEvents,
+  streamHeight: () => streamHeight,
+  streamNodeRecords: () => streamNodeRecords,
+  streamSlotMetrics: () => streamSlotMetrics,
+  streamTransactions: () => streamTransactions,
+  trackTransaction: () => trackTransaction
+});
+function copyBytes8(source) {
+  const bytes = new Uint8Array(source.length);
+  bytes.set(source);
+  return bytes;
+}
+function toUint(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error("FilterParamValue.uint requires a non-negative value");
+    }
+    return value;
+  }
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error("FilterParamValue.uint requires a non-negative integer");
+  }
+  return BigInt(value);
+}
+var FilterParamValue = class _FilterParamValue {
+  constructor(params) {
+    this.case = params.case;
+    if (!params.case) {
+      this.value = void 0;
+      return;
+    }
+    switch (params.case) {
+      case "stringValue":
+        if (typeof params.value !== "string") {
+          throw new Error("FilterParamValue.string requires a string value");
+        }
+        this.value = params.value;
+        return;
+      case "bytesValue":
+        if (!(params.value instanceof Uint8Array)) {
+          throw new Error("FilterParamValue.bytes requires a Uint8Array value");
+        }
+        this.value = copyBytes8(params.value);
+        return;
+      case "boolValue":
+        if (typeof params.value !== "boolean") {
+          throw new Error("FilterParamValue.bool requires a boolean value");
+        }
+        this.value = params.value;
+        return;
+      case "intValue":
+        if (typeof params.value !== "bigint") {
+          throw new Error("FilterParamValue.int requires a bigint value");
+        }
+        this.value = params.value;
+        return;
+      case "doubleValue":
+        if (typeof params.value !== "number") {
+          throw new Error("FilterParamValue.double requires a number value");
+        }
+        this.value = params.value;
+        return;
+      case "uintValue":
+        if (typeof params.value !== "bigint") {
+          throw new Error("FilterParamValue.uint requires a bigint value");
+        }
+        this.value = params.value;
+        return;
+      case "pubkeyValue":
+        if (!(params.value instanceof Uint8Array)) {
+          throw new Error("FilterParamValue.pubkey requires a Uint8Array value");
+        }
+        this.value = copyBytes8(params.value);
+        return;
+      case "signatureValue":
+        if (!(params.value instanceof Uint8Array)) {
+          throw new Error("FilterParamValue.signature requires a Uint8Array value");
+        }
+        this.value = copyBytes8(params.value);
+        return;
+      case "taPubkeyValue":
+        if (typeof params.value !== "string") {
+          throw new Error("FilterParamValue.taPubkey requires a string value");
+        }
+        this.value = params.value;
+        return;
+      case "tsSignatureValue":
+        if (typeof params.value !== "string") {
+          throw new Error("FilterParamValue.tsSignature requires a string value");
+        }
+        this.value = params.value;
+        return;
+      default:
+        this.value = void 0;
+    }
+  }
+  static none() {
+    return new _FilterParamValue({});
+  }
+  static string(value) {
+    return new _FilterParamValue({ case: "stringValue", value });
+  }
+  static bytes(value) {
+    return new _FilterParamValue({ case: "bytesValue", value });
+  }
+  static bool(value) {
+    return new _FilterParamValue({ case: "boolValue", value });
+  }
+  static int(value) {
+    return new _FilterParamValue({ case: "intValue", value });
+  }
+  static double(value) {
+    if (!Number.isFinite(value)) {
+      throw new Error("FilterParamValue.double requires a finite number");
+    }
+    return new _FilterParamValue({ case: "doubleValue", value });
+  }
+  static uint(value) {
+    return new _FilterParamValue({ case: "uintValue", value: toUint(value) });
+  }
+  static pubkey(value) {
+    return new _FilterParamValue({
+      case: "pubkeyValue",
+      value: Pubkey.from(value).toBytes()
+    });
+  }
+  static signature(value) {
+    return new _FilterParamValue({
+      case: "signatureValue",
+      value: Signature.from(value).toBytes()
+    });
+  }
+  static taPubkey(value) {
+    return new _FilterParamValue({
+      case: "taPubkeyValue",
+      value: Pubkey.from(value).toThruFmt()
+    });
+  }
+  static tsSignature(value) {
+    return new _FilterParamValue({
+      case: "tsSignatureValue",
+      value: Signature.from(value).toThruFmt()
+    });
+  }
+  static fromProto(proto) {
+    const kind = proto.kind;
+    if (!kind.case) {
+      return _FilterParamValue.none();
+    }
+    switch (kind.case) {
+      case "stringValue":
+        return _FilterParamValue.string(kind.value);
+      case "bytesValue":
+        return _FilterParamValue.bytes(kind.value);
+      case "boolValue":
+        return _FilterParamValue.bool(kind.value);
+      case "intValue":
+        return _FilterParamValue.int(kind.value);
+      case "doubleValue":
+        return _FilterParamValue.double(kind.value);
+      case "uintValue":
+        return _FilterParamValue.uint(kind.value);
+      case "pubkeyValue":
+        return _FilterParamValue.pubkey(Pubkey.fromProtoPubkey(kind.value).toBytes());
+      case "signatureValue":
+        return _FilterParamValue.signature(Signature.fromProtoSignature(kind.value).toBytes());
+      case "taPubkeyValue":
+        return _FilterParamValue.taPubkey(Pubkey.fromProtoTaPubkey(kind.value).toThruFmt());
+      case "tsSignatureValue":
+        return _FilterParamValue.tsSignature(Signature.fromProtoTsSignature(kind.value).toThruFmt());
+      default:
+        return _FilterParamValue.none();
+    }
+  }
+  toProto() {
+    if (!this.case) {
+      return create(FilterParamValueSchema);
+    }
+    switch (this.case) {
+      case "stringValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "stringValue",
+            value: this.value
+          }
+        });
+      case "bytesValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "bytesValue",
+            value: copyBytes8(this.value)
+          }
+        });
+      case "boolValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "boolValue",
+            value: this.value
+          }
+        });
+      case "intValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "intValue",
+            value: this.value
+          }
+        });
+      case "doubleValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "doubleValue",
+            value: this.value
+          }
+        });
+      case "uintValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "uintValue",
+            value: this.value
+          }
+        });
+      case "pubkeyValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "pubkeyValue",
+            value: Pubkey.from(this.value).toProtoPubkey()
+          }
+        });
+      case "signatureValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "signatureValue",
+            value: Signature.from(this.value).toProtoSignature()
+          }
+        });
+      case "taPubkeyValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "taPubkeyValue",
+            value: Pubkey.from(this.value).toProtoTaPubkey()
+          }
+        });
+      case "tsSignatureValue":
+        return create(FilterParamValueSchema, {
+          kind: {
+            case: "tsSignatureValue",
+            value: Signature.from(this.value).toProtoTsSignature()
+          }
+        });
+      default:
+        throw new Error("FilterParamValue has an unknown kind");
+    }
+  }
+  getCase() {
+    return this.case;
+  }
+  getString() {
+    return this.case === "stringValue" ? this.value : void 0;
+  }
+  getBytes() {
+    if (this.case !== "bytesValue" || !(this.value instanceof Uint8Array)) {
+      return void 0;
+    }
+    return copyBytes8(this.value);
+  }
+  getBool() {
+    return this.case === "boolValue" ? this.value : void 0;
+  }
+  getInt() {
+    return this.case === "intValue" ? this.value : void 0;
+  }
+  getUint() {
+    return this.case === "uintValue" ? this.value : void 0;
+  }
+  getDouble() {
+    return this.case === "doubleValue" ? this.value : void 0;
+  }
+  getPubkey() {
+    if (this.case !== "pubkeyValue") {
+      return void 0;
+    }
+    return copyBytes8(this.value);
+  }
+  getSignature() {
+    if (this.case !== "signatureValue") {
+      return void 0;
+    }
+    return copyBytes8(this.value);
+  }
+  getTaPubkey() {
+    return this.case === "taPubkeyValue" ? this.value : void 0;
+  }
+  getTsSignature() {
+    return this.case === "tsSignatureValue" ? this.value : void 0;
+  }
+};
+var Filter = class _Filter {
+  constructor(init = {}) {
+    this.expression = init.expression;
+    this.params = /* @__PURE__ */ new Map();
+    if (!init.params) {
+      return;
+    }
+    if (init.params instanceof Map) {
+      for (const [key, value] of init.params.entries()) {
+        this.setParamInternal(key, value);
+      }
+      return;
+    }
+    if (typeof init.params === "object" && !Array.isArray(init.params)) {
+      for (const [key, value] of Object.entries(init.params)) {
+        this.setParamInternal(key, value);
+      }
+      return;
+    }
+    for (const [key, value] of init.params) {
+      this.setParamInternal(key, value);
+    }
+  }
+  static fromProto(proto) {
+    const params = Object.entries(proto.params ?? {}).map(([key, value]) => [key, FilterParamValue.fromProto(value)]);
+    return new _Filter({
+      expression: proto.expression,
+      params
+    });
+  }
+  toProto() {
+    const protoParams = {};
+    for (const [key, value] of this.params.entries()) {
+      protoParams[key] = value.toProto();
+    }
+    return create(FilterSchema, {
+      expression: this.expression,
+      params: protoParams
+    });
+  }
+  hasParam(name) {
+    return this.params.has(name);
+  }
+  getParam(name) {
+    const param = this.params.get(name);
+    return param;
+  }
+  listParams() {
+    return Array.from(this.params.keys());
+  }
+  entries() {
+    return Array.from(this.params.entries());
+  }
+  withExpression(expression) {
+    return new _Filter({ expression, params: this.params });
+  }
+  withParam(name, value) {
+    const params = new Map(this.params);
+    params.set(name, value);
+    return new _Filter({ expression: this.expression, params });
+  }
+  withoutParam(name) {
+    if (!this.params.has(name)) {
+      return this;
+    }
+    const params = new Map(this.params);
+    params.delete(name);
+    return new _Filter({ expression: this.expression, params });
+  }
+  setParamInternal(name, value) {
+    if (!(value instanceof FilterParamValue)) {
+      throw new Error(`Filter parameter "${name}" must be a FilterParamValue`);
+    }
+    this.params.set(name, value);
+  }
+};
+
+// thru-ts-client-sdk/modules/streaming.ts
+function streamBlocks(ctx, options = {}) {
+  const request = create(StreamBlocksRequestSchema, {
+    startSlot: options.startSlot,
+    filter: options.filter?.toProto(),
+    view: options.view ?? DEFAULT_BLOCK_VIEW,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const iterable = ctx.streaming.streamBlocks(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      if (!response.block) {
+        continue;
+      }
+      yield { block: Block.fromProto(response.block) };
+    }
+  }
+  return mapper();
+}
+function streamAccountUpdates(ctx, address, options = {}) {
+  const addressBytes = Pubkey.from(address).toBytes();
+  const addressFilter = new Filter({
+    expression: "account_address.value == params.address",
+    params: {
+      address: FilterParamValue.bytes(addressBytes)
+    }
+  });
+  let mergedFilter = addressFilter;
+  if (options.filter) {
+    const combinedParams = {};
+    for (const [key, value] of addressFilter.entries()) {
+      combinedParams[key] = value;
+    }
+    for (const [key, value] of options.filter.entries()) {
+      combinedParams[key] = value;
+    }
+    mergedFilter = new Filter({
+      expression: `(${addressFilter.expression}) && (${options.filter.expression})`,
+      params: combinedParams
+    });
+  }
+  const request = create(StreamAccountUpdatesRequestSchema, {
+    view: options.view ?? DEFAULT_ACCOUNT_VIEW,
+    filter: mergedFilter.toProto()
+  });
+  const iterable = ctx.streaming.streamAccountUpdates(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      const update = toStreamAccountUpdate(response);
+      if (!update) {
+        continue;
+      }
+      yield { update };
+    }
+  }
+  return mapper();
+}
+function streamTransactions(ctx, options = {}) {
+  const request = create(StreamTransactionsRequestSchema, {
+    filter: options.filter?.toProto(),
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const iterable = ctx.streaming.streamTransactions(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      if (!response.transaction) {
+        continue;
+      }
+      try {
+        yield toStreamTransactionUpdate(response.transaction);
+      } catch (err) {
+        console.error("streamTransactions: failed to decode transaction update", err);
+      }
+    }
+  }
+  return mapper();
+}
+function streamEvents(ctx, options = {}) {
+  const request = create(StreamEventsRequestSchema, {
+    filter: options.filter?.toProto()
+  });
+  const iterable = ctx.streaming.streamEvents(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      yield { event: ChainEvent.fromStream(response) };
+    }
+  }
+  return mapper();
+}
+function trackTransaction(ctx, signature, options = {}) {
+  const timeoutMs = options.timeoutMs;
+  const request = create(TrackTransactionRequestSchema, {
+    signature: Signature.from(signature).toProtoSignature(),
+    timeout: timeoutMs != null ? {
+      seconds: BigInt(Math.floor(timeoutMs / 1e3)),
+      nanos: timeoutMs % 1e3 * 1e6
+    } : void 0
+  });
+  const iterable = ctx.streaming.trackTransaction(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      yield toTrackTransactionUpdate(response);
+    }
+  }
+  return mapper();
+}
+function streamHeight(ctx, options = {}) {
+  const request = create(StreamHeightRequestSchema, {});
+  const iterable = ctx.streaming.streamHeight(request, withCallOptions(ctx, { signal: options.signal }));
+  async function* mapper() {
+    for await (const response of iterable) {
+      yield { height: HeightSnapshot.fromProto(response) };
+    }
+  }
+  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);
+  if (limit != null && limit <= 0) {
+    return [];
+  }
+  const results = [];
+  let count = 0;
+  for await (const value of iterable) {
+    throwIfAborted(signal);
+    results.push(value);
+    count += 1;
+    if (limit != null && count >= limit) {
+      break;
+    }
+  }
+  return results;
+}
+async function firstStreamValue(iterable, options = {}) {
+  const values = await collectStream(iterable, { ...options, limit: 1 });
+  return values[0];
+}
+async function forEachStreamValue(iterable, handler, options = {}) {
+  let index = 0;
+  for await (const value of iterable) {
+    throwIfAborted(options.signal);
+    await handler(value, index++);
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal) {
+    return;
+  }
+  if (signal.aborted) {
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+      throw reason;
+    }
+    if (reason !== void 0) {
+      throw new Error(String(reason));
+    }
+    throw new DOMException("The operation was aborted.", "AbortError");
+  }
+}
+
+// thru-ts-client-sdk/modules/nonce.ts
+var DEFAULT_NONCE_WAIT_TIMEOUT_MS = 1e4;
+var AccountNonceObserver = class {
+  constructor(ctx, account, options = {}) {
+    this.abortController = new AbortController();
+    this.waiters = /* @__PURE__ */ new Set();
+    this.closed = false;
+    this.streamStarted = false;
+    this.ctx = ctx;
+    this.account = Pubkey.from(account);
+    this.versionContext = options.versionContext ?? currentVersionContext();
+    options.signal?.addEventListener("abort", () => this.close(), { once: true });
+  }
+  getLatestNonce() {
+    return this.latestNonce;
+  }
+  async refresh() {
+    const account = await getAccount(this.ctx, this.account, {
+      view: 4 /* FULL */,
+      versionContext: this.versionContext
+    });
+    this.observeNonce(account.meta?.nonce);
+    return this.latestNonce;
+  }
+  start() {
+    if (this.streamStarted || this.closed) {
+      return;
+    }
+    this.streamStarted = true;
+    void this.runStream();
+  }
+  async waitForNonceAtLeast(target, options = {}) {
+    if (this.closed) {
+      throw new Error("AccountNonceObserver is closed");
+    }
+    if (this.latestNonce === void 0 || this.latestNonce < target) {
+      this.start();
+      await this.refresh();
+    }
+    if (this.closed) {
+      throw new Error("AccountNonceObserver is closed");
+    }
+    if (this.latestNonce !== void 0 && this.latestNonce >= target) {
+      return this.latestNonce;
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutMs = options.timeoutMs ?? DEFAULT_NONCE_WAIT_TIMEOUT_MS;
+      const waiter = {
+        target,
+        resolve,
+        reject
+      };
+      waiter.timeoutId = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new Error(`Timed out waiting for nonce >= ${target.toString()} after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.waiters.add(waiter);
+    });
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.abortController.abort();
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutId) {
+        clearTimeout(waiter.timeoutId);
+      }
+      waiter.reject(new Error("AccountNonceObserver closed"));
+    }
+    this.waiters.clear();
+  }
+  async runStream() {
+    try {
+      for await (const { update } of streamAccountUpdates(this.ctx, this.account, {
+        view: 4 /* FULL */,
+        signal: this.abortController.signal
+      })) {
+        if (this.closed) {
+          return;
+        }
+        if (update.kind === "snapshot") {
+          this.observeNonce(update.snapshot.account.meta?.nonce);
+          continue;
+        }
+        this.observeNonce(update.update.meta?.nonce);
+      }
+    } catch (error) {
+      if (!this.closed) {
+        this.rejectWaiters(error instanceof Error ? error : new Error(String(error)));
+      }
+    } finally {
+      this.streamStarted = false;
+      if (!this.closed) {
+        this.rejectWaiters(new Error("Account nonce stream ended unexpectedly"));
+      }
+    }
+  }
+  observeNonce(nonce) {
+    if (nonce === void 0) {
+      return;
+    }
+    if (this.latestNonce === void 0 || nonce > this.latestNonce) {
+      this.latestNonce = nonce;
+    }
+    this.resolveReadyWaiters();
+  }
+  resolveReadyWaiters() {
+    if (this.latestNonce === void 0) {
+      return;
+    }
+    for (const waiter of Array.from(this.waiters)) {
+      if (this.latestNonce < waiter.target) {
+        continue;
+      }
+      this.waiters.delete(waiter);
+      if (waiter.timeoutId) {
+        clearTimeout(waiter.timeoutId);
+      }
+      waiter.resolve(this.latestNonce);
+    }
+  }
+  rejectWaiters(error) {
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutId) {
+        clearTimeout(waiter.timeoutId);
+      }
+      waiter.reject(error);
+    }
+    this.waiters.clear();
+  }
+};
+var FeePayerNonceManager = class {
+  constructor(ctx, feePayer, options = {}) {
+    this.allocationQueue = Promise.resolve();
+    this.observer = options.observer ?? new AccountNonceObserver(ctx, feePayer);
+  }
+  async allocate(count) {
+    return this.withAllocationLock(() => this.allocateUnsafe(count));
+  }
+  reset(nextNonce) {
+    this.nextNonce = nextNonce;
+  }
+  async sync() {
+    const latestNonce = await this.observer.refresh();
+    if (latestNonce === void 0) {
+      throw new Error("Unable to read fee payer nonce");
+    }
+    this.nextNonce = latestNonce;
+    return latestNonce;
+  }
+  async waitForNonceAtLeast(target, options) {
+    const nonce = await this.observer.waitForNonceAtLeast(target, options);
+    if (this.nextNonce === void 0 || nonce > this.nextNonce) {
+      this.nextNonce = nonce;
+    }
+    return nonce;
+  }
+  close() {
+    this.observer.close();
+  }
+  async allocateUnsafe(count) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error("Nonce allocation count must be a positive integer");
+    }
+    const latestNonce = await this.observer.refresh();
+    if (latestNonce === void 0) {
+      throw new Error("Unable to read fee payer nonce");
+    }
+    const baseNonce = this.nextNonce === void 0 || latestNonce > this.nextNonce ? latestNonce : this.nextNonce;
+    const barrierNonce = baseNonce + BigInt(count);
+    const nonces = Array.from({ length: count }, (_, index) => baseNonce + BigInt(index));
+    this.nextNonce = barrierNonce;
+    return {
+      baseNonce,
+      nonces,
+      barrierNonce
+    };
+  }
+  async withAllocationLock(work) {
+    const previous = this.allocationQueue;
+    let release;
+    this.allocationQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await work();
+    } finally {
+      release();
+    }
+  }
+};
+
+// 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));
+}
+
+// thru-ts-client-sdk/modules/transactions.ts
+var transactions_exports = {};
+__export(transactions_exports, {
+  batchSendAndTrack: () => batchSendAndTrack,
+  batchSendTransactions: () => batchSendTransactions,
+  buildAndSignTransaction: () => buildAndSignTransaction,
+  buildTransaction: () => buildTransaction,
+  getRawTransaction: () => getRawTransaction,
+  getTransaction: () => getTransaction,
+  getTransactionStatus: () => getTransactionStatus,
+  listTransactions: () => listTransactions,
+  listTransactionsForAccount: () => listTransactionsForAccount,
+  sendAndTrackTxn: () => sendAndTrackTxn,
+  sendTransaction: () => sendTransaction
+});
+async function getTransaction(ctx, signature, options = {}) {
+  const request = create(GetTransactionRequestSchema, {
+    signature: Signature.from(signature).toProtoSignature(),
+    view: options.view ?? DEFAULT_TRANSACTION_VIEW,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const proto = await ctx.query.getTransaction(request, withCallOptions(ctx));
+  return Transaction.fromProto(proto);
+}
+async function getRawTransaction(ctx, signature, options = {}) {
+  const request = create(GetRawTransactionRequestSchema, {
+    signature: Signature.from(signature).toProtoSignature(),
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  return ctx.query.getRawTransaction(request, withCallOptions(ctx));
+}
+async function getTransactionStatus(ctx, signature) {
+  const request = create(GetTransactionStatusRequestSchema, {
+    signature: Signature.from(signature).toProtoSignature()
+  });
+  const proto = await ctx.query.getTransactionStatus(request, withCallOptions(ctx));
+  return TransactionStatusSnapshot.fromProto(proto);
+}
+async function listTransactionsForAccount(ctx, account, options = {}) {
+  const request = create(ListTransactionsForAccountRequestSchema, {
+    account: Pubkey.from(account).toProtoPubkey(),
+    filter: options.filter?.toProto(),
+    page: options.page?.toProto()
+  });
+  const response = await ctx.query.listTransactionsForAccount(
+    request,
+    withCallOptions(ctx)
+  );
+  const protoTransactionSignatures = (response.transactions ?? []).map((transaction) => transaction.signature);
+  const transactions = await Promise.all(
+    protoTransactionSignatures.map((signature) => {
+      if (!signature) {
+        throw new Error("ListTransactionsForAccount returned an empty signature");
+      }
+      return getTransaction(ctx, signature.value, options.transactionOptions);
+    })
+  );
+  return {
+    transactions,
+    page: PageResponse.fromProto(response.page)
+  };
+}
+async function listTransactions(ctx, options = {}) {
+  const request = create(ListTransactionsRequestSchema, {
+    filter: options.filter?.toProto(),
+    page: options.page?.toProto(),
+    returnEvents: options.returnEvents,
+    versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
+    minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS
+  });
+  const response = await ctx.query.listTransactions(
+    request,
+    withCallOptions(ctx)
+  );
+  return {
+    transactions: response.transactions.map((proto) => Transaction.fromProto(proto)),
+    page: PageResponse.fromProto(response.page)
+  };
+}
+async function buildTransaction(ctx, options) {
+  const builder = createTransactionBuilder();
+  const params = await createBuildParams(ctx, options);
+  return builder.build(params);
+}
+async function buildAndSignTransaction(ctx, options) {
+  const builder = createTransactionBuilder();
+  const params = await createBuildParams(ctx, options);
+  if (!params.feePayer.privateKey) {
+    throw new Error("Fee payer private key is required to sign the transaction");
+  }
+  return builder.buildAndSign(params);
+}
+async function sendTransaction(ctx, transaction) {
+  const raw = transaction instanceof Uint8Array ? transaction : transaction.toWire();
+  return sendRawTransaction(ctx, raw);
+}
+async function batchSendTransactions(ctx, transactions, options = {}) {
+  const rawTransactions = transactions.map(
+    (tx) => tx instanceof Uint8Array ? tx : tx.toWire()
+  );
+  const request = create(BatchSendTransactionsRequestSchema, {
+    rawTransactions,
+    numRetries: options.numRetries ?? 0
+  });
+  return ctx.command.batchSendTransactions(request, withCallOptions(ctx));
+}
+async function batchSendAndTrack(ctx, transactions, options = {}) {
+  const rawTransactions = transactions.map(
+    (tx) => tx instanceof Uint8Array ? tx : tx.toWire()
+  );
+  const signatures = rawTransactions.map(extractSignature);
+  const trackControllers = rawTransactions.map(() => new AbortController());
+  const abortStatuses = rawTransactions.map(() => void 0);
+  const trackPromises = signatures.map(
+    (signature, index) => trackUntilExecution(ctx, signature, {
+      timeoutMs: options.trackTimeoutMs,
+      signal: trackControllers[index].signal,
+      getAbortStatus: () => abortStatuses[index]
+    })
+  );
+  options.signal?.addEventListener(
+    "abort",
+    () => {
+      for (let index = 0; index < trackControllers.length; index += 1) {
+        abortStatuses[index] ?? (abortStatuses[index] = "cancelled");
+        trackControllers[index].abort();
+      }
+    },
+    { once: true }
+  );
+  let response;
+  try {
+    response = await batchSendTransactions(ctx, rawTransactions, {
+      numRetries: options.numRetries ?? 0
+    });
+  } catch (error) {
+    for (const controller of trackControllers) {
+      controller.abort();
+    }
+    await Promise.allSettled(trackPromises);
+    throw error;
+  }
+  const accepted = signatures.map((_, index) => response.accepted[index] === true);
+  for (let index = 0; index < accepted.length; index += 1) {
+    if (!accepted[index]) {
+      abortStatuses[index] = "not_accepted";
+      trackControllers[index].abort();
+    }
+  }
+  const tracked = await Promise.all(trackPromises);
+  return signatures.map((signature, index) => ({
+    signature,
+    accepted: accepted[index],
+    ...tracked[index]
+  }));
+}
+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));
+  if (!response.signature?.value) {
+    throw new Error("No signature returned from sendTransaction");
+  }
+  return encodeSignature(response.signature.value);
+}
+function extractSignature(rawTransaction) {
+  if (rawTransaction.length < 64) {
+    throw new Error(`Raw transaction too short to contain a signature: ${rawTransaction.length} bytes`);
+  }
+  const signatureBytes = rawTransaction.slice(rawTransaction.length - 64);
+  return Signature.from(signatureBytes).toThruFmt();
+}
+async function trackUntilExecution(ctx, signature, options = {}) {
+  let finalizedSeen = false;
+  let latestUpdate;
+  try {
+    for await (const update of trackTransaction(ctx, signature, options)) {
+      latestUpdate = update;
+      if (update.statusCode === 3 /* FINALIZED */ || update.status === "finalized") {
+        finalizedSeen = true;
+      }
+      if (update.executionResult) {
+        return {
+          trackStatus: "executed",
+          update,
+          executionResult: update.executionResult
+        };
+      }
+    }
+  } catch (error) {
+    if (options.signal?.aborted) {
+      return {
+        trackStatus: options.getAbortStatus?.() ?? "cancelled",
+        error
+      };
+    }
+    if (finalizedSeen) {
+      return {
+        trackStatus: "finalized_without_execution",
+        update: latestUpdate,
+        error
+      };
+    }
+    return {
+      trackStatus: "track_error",
+      update: latestUpdate,
+      error
+    };
+  }
+  if (finalizedSeen) {
+    return {
+      trackStatus: "finalized_without_execution",
+      update: latestUpdate
+    };
+  }
+  return {
+    trackStatus: "timeout",
+    update: latestUpdate
+  };
+}
+function createTransactionBuilder() {
+  return new TransactionBuilder();
+}
+async function createBuildParams(ctx, options) {
+  const feePayerPublicKey = Pubkey.from(options.feePayer.publicKey).toBytes();
+  const program = Pubkey.from(options.program).toBytes();
+  const header = await createTransactionHeader(ctx, options.header ?? {}, feePayerPublicKey);
+  const accounts = parseAccounts(options.accounts);
+  const context = createInstructionContext2(feePayerPublicKey, program, accounts);
+  const instructionData = await resolveInstructionData(options.instructionData, context);
+  const proofs = createProofs(options);
+  return {
+    feePayer: {
+      publicKey: feePayerPublicKey,
+      privateKey: options.feePayer.privateKey
+    },
+    program: Pubkey.from(options.program).toBytes(),
+    header,
+    accounts,
+    instructionData,
+    proofs
+  };
+}
+async function createTransactionHeader(ctx, header, feePayerPublicKey) {
+  const nonce = header.nonce ?? await fetchFeePayerNonce(ctx, feePayerPublicKey);
+  const startSlot = header.startSlot ?? await fetchFinalizedSlot(ctx);
+  const chainId = header.chainId ?? await fetchChainId(ctx);
+  return {
+    fee: header.fee ?? DEFAULT_FEE,
+    nonce,
+    startSlot,
+    expiryAfter: header.expiryAfter ?? DEFAULT_EXPIRY_AFTER,
+    chainId,
+    computeUnits: header.computeUnits ?? DEFAULT_COMPUTE_UNITS,
+    stateUnits: header.stateUnits ?? DEFAULT_STATE_UNITS,
+    memoryUnits: header.memoryUnits ?? DEFAULT_MEMORY_UNITS,
+    flags: header.flags
+  };
+}
+function parseAccounts(accounts) {
+  if (!accounts) {
+    return void 0;
+  }
+  const readWrite = accounts.readWrite?.map(
+    (value, index) => Pubkey.from(value).toBytes()
+  );
+  const readOnly = accounts.readOnly?.map(
+    (value, index) => Pubkey.from(value).toBytes()
+  );
+  const result = {};
+  if (readWrite && readWrite.length > 0) {
+    result.readWriteAccounts = normalizeAccountList(readWrite);
+  }
+  if (readOnly && readOnly.length > 0) {
+    result.readOnlyAccounts = normalizeAccountList(readOnly);
+  }
+  if (!result.readWriteAccounts && !result.readOnlyAccounts) {
+    return void 0;
+  }
+  return result;
+}
+function createInstructionContext2(feePayer, program, accounts) {
+  const allAccounts = [
+    Pubkey.from(feePayer),
+    Pubkey.from(program),
+    ...accounts?.readWriteAccounts?.map((value) => Pubkey.from(value)) ?? [],
+    ...accounts?.readOnlyAccounts?.map((value) => Pubkey.from(value)) ?? []
+  ];
+  const getAccountIndex = (pubkey) => {
+    for (let i = 0; i < allAccounts.length; i++) {
+      if (allAccounts[i].equals(Pubkey.from(pubkey))) {
+        return i;
+      }
+    }
+    throw new Error("Account not found in transaction accounts");
+  };
+  return { accounts: allAccounts, getAccountIndex };
+}
+async function resolveInstructionData(value, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "function") {
+    return await value(context);
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  return parseInstructionData(value);
+}
+function createProofs(options) {
+  const proofs = {};
+  if (options.feePayerStateProof) {
+    proofs.feePayerStateProof = options.feePayerStateProof;
+  }
+  if (options.feePayerAccountMetaRaw) {
+    proofs.feePayerAccountMetaRaw = options.feePayerAccountMetaRaw;
+  }
+  const hasProofs = Boolean(proofs.feePayerStateProof || proofs.feePayerAccountMetaRaw);
+  return hasProofs ? proofs : void 0;
+}
+async function fetchFeePayerNonce(ctx, feePayer) {
+  const account = await getAccount(ctx, feePayer, { view: 4 /* FULL */ });
+  const nonce = account.meta?.nonce;
+  if (nonce === void 0) {
+    throw new Error("Fee payer account nonce is unavailable");
+  }
+  return nonce;
+}
+async function fetchFinalizedSlot(ctx) {
+  const height = await getBlockHeight(ctx);
+  return height.finalized;
+}
+async function fetchChainId(ctx) {
+  return getChainId(ctx);
+}
+
+// thru-ts-client-sdk/domain/version/VersionInfo.ts
+var VersionInfo = class _VersionInfo {
+  constructor(components) {
+    this.components = { ...components };
+  }
+  static fromProto(proto) {
+    return new _VersionInfo(proto.versions ?? {});
+  }
+  get(component) {
+    return this.components[component];
+  }
+};
+
+// thru-ts-client-sdk/modules/version.ts
+function getVersion(ctx) {
+  const request = create(GetVersionRequestSchema);
+  return ctx.query.getVersion(request, withCallOptions(ctx)).then((response) => VersionInfo.fromProto(response));
+}
+
+// thru-ts-client-sdk/core/bound-client.ts
+function bind(ctx, fn) {
+  return ((...args) => fn(ctx, ...args));
+}
+function createBoundThruClient(ctx) {
+  return {
+    ctx,
+    blocks: {
+      get: bind(ctx, getBlock),
+      getRaw: bind(ctx, getRawBlock),
+      list: bind(ctx, listBlocks),
+      stream: bind(ctx, streamBlocks),
+      getBlockHeight: bind(ctx, getBlockHeight),
+      streamHeight: bind(ctx, streamHeight)
+    },
+    accounts: {
+      get: bind(ctx, getAccount),
+      getRaw: bind(ctx, getRawAccount),
+      list: bind(ctx, listAccounts),
+      stream: bind(ctx, streamAccountUpdates),
+      create: bind(ctx, createAccount)
+    },
+    transactions: {
+      get: bind(ctx, getTransaction),
+      getRaw: bind(ctx, getRawTransaction),
+      getStatus: bind(ctx, getTransactionStatus),
+      list: bind(ctx, listTransactions),
+      listForAccount: bind(ctx, listTransactionsForAccount),
+      stream: bind(ctx, streamTransactions),
+      build: bind(ctx, buildTransaction),
+      buildAndSign: bind(ctx, buildAndSignTransaction),
+      send: bind(ctx, sendTransaction),
+      batchSend: bind(ctx, batchSendTransactions),
+      batchSendAndTrack: bind(ctx, batchSendAndTrack),
+      sendAndTrack: bind(ctx, sendAndTrackTxn),
+      track: bind(ctx, trackTransaction)
+    },
+    nonce: {
+      createObserver: (account, options) => new AccountNonceObserver(ctx, account, options),
+      createFeePayerManager: (feePayer, options) => new FeePayerNonceManager(ctx, feePayer, options)
+    },
+    helpers: {
+      createSignature: Signature.from,
+      createPubkey: Pubkey.from,
+      deriveProgramAddress,
+      deriveAddress
+    },
+    keys: {
+      generateKeyPair,
+      fromPrivateKey
+    },
+    events: {
+      get: bind(ctx, getEvent),
+      list: bind(ctx, listEvents),
+      stream: bind(ctx, streamEvents)
+    },
+    slots: {
+      getMetrics: bind(ctx, getSlotMetrics),
+      listMetrics: bind(ctx, listSlotMetrics),
+      streamMetrics: bind(ctx, streamSlotMetrics)
+    },
+    proofs: {
+      generate: bind(ctx, generateStateProof),
+      getStateRoots: bind(ctx, getStateRoots)
+    },
+    node: {
+      getStatus: bind(ctx, getNodeStatus),
+      getPubkey: bind(ctx, getNodePubkey),
+      getRecords: bind(ctx, getNodeRecords),
+      streamRecords: bind(ctx, streamNodeRecords)
+    },
+    chain: {
+      getChainInfo: bind(ctx, getChainInfo),
+      getChainId: bind(ctx, getChainId)
+    },
+    version: {
+      get: bind(ctx, getVersion)
+    },
+    consensus: {
+      statusToString: consensusStatusToString,
+      versionContext,
+      currentVersionContext,
+      currentOrHistoricalVersionContext,
+      slotVersionContext,
+      timestampVersionContext,
+      seqVersionContext
+    }
+  };
+}
+
+// thru-ts-client-sdk/client.ts
+function createThruClient(config = {}) {
+  const ctx = createThruClientContext(config);
+  return createBoundThruClient(ctx);
+}
+
+export { Account, AccountNonceObserver, Block, ChainEvent, FeePayerNonceManager, Filter, FilterParamValue, HeightSnapshot, PageRequest, PageResponse, Pubkey, Signature, SignatureDomain, StateProof, Transaction, TransactionBuilder, TransactionStatusSnapshot, VersionInfo, accounts_exports, blocks_exports, chain_exports, collectStream, consensus_exports, createThruClient, deriveAddress, deriveProgramAddress, events_exports, firstStreamValue, forEachStreamValue, height_exports, keys_exports, node_exports, nonce_exports, proofs_exports, signWithDomain, slots_exports, streaming_exports, transactions_exports, verifyWithDomain };
+//# sourceMappingURL=chunk-CVBQ4UPL.js.map
+//# sourceMappingURL=chunk-CVBQ4UPL.js.map