@thru/sdk 0.2.22

package/dist/client.cjs

@@ -0,0 +1,3791 @@
+'use strict';
+
+var protobuf = require('@bufbuild/protobuf');
+var codegenv2 = require('@bufbuild/protobuf/codegenv2');
+var wkt = require('@bufbuild/protobuf/wkt');
+var connect = require('@connectrpc/connect');
+var connectWeb = require('@connectrpc/connect-web');
+var ed25519 = require('@noble/ed25519');
+var sha2_js = require('@noble/hashes/sha2.js');
+var HDKey = require('micro-key-producer/slip10.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var HDKey__default = /*#__PURE__*/_interopDefault(HDKey);
+
+// thru-ts-client-sdk/domain/primitives/Pubkey.ts
+
+// src/helpers/constants.ts
+var BASE64_URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var tempMap = new Int16Array(256).fill(-1);
+for (let i = 0; i < BASE64_URL_ALPHABET.length; i++) {
+  tempMap[BASE64_URL_ALPHABET.charCodeAt(i)] = i;
+}
+var BASE64_URL_MAP = tempMap;
+
+// src/helpers/address.ts
+function encodeAddress(bytes) {
+  if (bytes.length !== 32) {
+    throw new Error("Expected 32-byte address");
+  }
+  let checksum = 0;
+  let accumulator = 0;
+  let bitsCollected = 0;
+  const output = ["t", "a"];
+  for (let i = 0; i < 30; i++) {
+    const byte = bytes[i];
+    checksum += byte;
+    accumulator = (accumulator << 8 | byte) >>> 0;
+    bitsCollected += 8;
+    while (bitsCollected >= 6) {
+      const index = accumulator >> bitsCollected - 6 & 63;
+      output.push(BASE64_URL_ALPHABET[index]);
+      bitsCollected -= 6;
+      accumulator &= maskForBits(bitsCollected);
+    }
+  }
+  const secondLast = bytes[30];
+  checksum += secondLast;
+  accumulator = (accumulator << 8 | secondLast) >>> 0;
+  bitsCollected += 8;
+  const last = bytes[31];
+  checksum += last;
+  accumulator = (accumulator << 8 | last) >>> 0;
+  bitsCollected += 8;
+  accumulator = (accumulator << 8 | checksum & 255) >>> 0;
+  bitsCollected += 8;
+  while (bitsCollected >= 6) {
+    const index = accumulator >> bitsCollected - 6 & 63;
+    output.push(BASE64_URL_ALPHABET[index]);
+    bitsCollected -= 6;
+    accumulator &= maskForBits(bitsCollected);
+  }
+  return output.join("");
+}
+function decodeAddress(value) {
+  if (value.length !== 46) {
+    throw new Error("Invalid address length");
+  }
+  if (!value.startsWith("ta")) {
+    throw new Error('Address must start with "ta"');
+  }
+  const output = new Uint8Array(32);
+  let checksum = 0;
+  let inIdx = 2;
+  let remaining = 40;
+  let outIdx = 0;
+  while (remaining >= 4) {
+    const a2 = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+    const b2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+    const c2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+    const d2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+    if (a2 < 0 || b2 < 0 || c2 < 0 || d2 < 0) {
+      throw new Error("Invalid address encoding");
+    }
+    const triple2 = a2 << 18 | b2 << 12 | c2 << 6 | d2;
+    const byte12 = triple2 >> 16 & 255;
+    const byte22 = triple2 >> 8 & 255;
+    const byte3 = triple2 & 255;
+    checksum += byte12;
+    checksum += byte22;
+    checksum += byte3;
+    output[outIdx++] = byte12;
+    output[outIdx++] = byte22;
+    output[outIdx++] = byte3;
+    inIdx += 4;
+    remaining -= 4;
+  }
+  const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+  const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+  const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+  const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+  if (a < 0 || b < 0 || c < 0 || d < 0) {
+    throw new Error("Invalid address encoding");
+  }
+  const triple = a << 18 | b << 12 | c << 6 | d;
+  const byte1 = triple >> 16 & 255;
+  const byte2 = triple >> 8 & 255;
+  const incomingChecksum = triple & 255;
+  checksum += byte1;
+  checksum += byte2;
+  output[outIdx++] = byte1;
+  output[outIdx++] = byte2;
+  checksum &= 255;
+  if (checksum !== incomingChecksum) {
+    throw new Error("Address checksum mismatch");
+  }
+  return output;
+}
+function maskForBits(bits) {
+  return bits === 0 ? 0 : (1 << bits) - 1;
+}
+
+// src/helpers/encoding.ts
+function decodeBase64(value) {
+  if (value.length === 0) {
+    return new Uint8Array();
+  }
+  const atobFn = globalThis.atob;
+  if (!atobFn) {
+    throw new Error("Base64 decoding requires globalThis.atob support");
+  }
+  const binary = atobFn(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function hexToBytes(value) {
+  const normalized = value.startsWith("0x") ? value.slice(2) : value;
+  if (normalized.length % 2 !== 0) {
+    throw new Error("Hex string must contain an even number of characters");
+  }
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let i = 0; i < normalized.length; i += 2) {
+    const byte = parseInt(normalized.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Hex string contains invalid characters");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+function isHexString(value) {
+  const normalized = value.startsWith("0x") ? value.slice(2) : value;
+  return normalized.length % 2 === 0 && normalized.length > 0 && /^[0-9a-fA-F]+$/.test(normalized);
+}
+
+// src/helpers/utils.ts
+function ensureBytes(value, field) {
+  if (value instanceof Uint8Array) {
+    if (value.length === 0) {
+      throw new Error(`${field} cannot be empty`);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      throw new Error(`${field} cannot be empty`);
+    }
+    return decodeBase64(value);
+  }
+  throw new Error(`${field} is required`);
+}
+function maskForBits2(bits) {
+  return bits === 0 ? 0 : (1 << bits) - 1;
+}
+
+// src/helpers/signature.ts
+function encodeSignature(bytes) {
+  if (bytes.length !== 64) {
+    throw new Error("Expected 64-byte signature");
+  }
+  let checksum = 0;
+  let accumulator = 0;
+  let bitsCollected = 0;
+  const output = ["t", "s"];
+  for (let i = 0; i < 63; i++) {
+    const byte = bytes[i];
+    checksum += byte;
+    accumulator = (accumulator << 8 | byte) >>> 0;
+    bitsCollected += 8;
+    while (bitsCollected >= 6) {
+      const index = accumulator >> bitsCollected - 6 & 63;
+      output.push(BASE64_URL_ALPHABET[index]);
+      bitsCollected -= 6;
+      accumulator &= maskForBits2(bitsCollected);
+    }
+  }
+  const lastByte = bytes[63];
+  checksum += lastByte;
+  accumulator = (accumulator << 8 | lastByte) >>> 0;
+  bitsCollected += 8;
+  accumulator = (accumulator << 16 | checksum & 65535) >>> 0;
+  bitsCollected += 16;
+  while (bitsCollected >= 6) {
+    const index = accumulator >> bitsCollected - 6 & 63;
+    output.push(BASE64_URL_ALPHABET[index]);
+    bitsCollected -= 6;
+    accumulator &= maskForBits2(bitsCollected);
+  }
+  return output.join("");
+}
+function decodeSignature(value) {
+  if (value.length !== 90) {
+    throw new Error("Invalid signature length");
+  }
+  if (!value.startsWith("ts")) {
+    throw new Error('Signature must start with "ts"');
+  }
+  const output = new Uint8Array(64);
+  let checksum = 0;
+  let inIdx = 2;
+  let remaining = 84;
+  let outIdx = 0;
+  while (remaining > 0) {
+    const a2 = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+    const b2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+    const c2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+    const d2 = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+    if (a2 < 0 || b2 < 0 || c2 < 0 || d2 < 0) {
+      throw new Error("Invalid signature encoding");
+    }
+    const triple2 = a2 << 18 | b2 << 12 | c2 << 6 | d2;
+    const byte1 = triple2 >> 16 & 255;
+    const byte2 = triple2 >> 8 & 255;
+    const byte3 = triple2 & 255;
+    checksum += byte1;
+    checksum += byte2;
+    checksum += byte3;
+    output[outIdx++] = byte1;
+    output[outIdx++] = byte2;
+    output[outIdx++] = byte3;
+    inIdx += 4;
+    remaining -= 4;
+  }
+  const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+  const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+  const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+  const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+  if (a < 0 || b < 0 || c < 0 || d < 0) {
+    throw new Error("Invalid signature encoding");
+  }
+  const triple = a << 18 | b << 12 | c << 6 | d;
+  const finalByte = triple >> 16 & 255;
+  checksum += finalByte;
+  output[outIdx] = finalByte;
+  const incomingChecksum = triple & 65535;
+  checksum &= 65535;
+  if (checksum !== incomingChecksum) {
+    throw new Error("Signature checksum mismatch");
+  }
+  return output;
+}
+
+// src/helpers/webcrypto.ts
+function getWebCrypto() {
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    return cryptoObj;
+  }
+  throw new Error("Web Crypto API is unavailable. Provide a polyfill exposing globalThis.crypto.");
+}
+var file_buf_validate_validate = /* @__PURE__ */ codegenv2.fileDesc("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", [wkt.file_google_protobuf_descriptor, wkt.file_google_protobuf_duration, wkt.file_google_protobuf_field_mask, wkt.file_google_protobuf_timestamp]);
+var file_google_api_field_behavior = /* @__PURE__ */ codegenv2.fileDesc("Ch9nb29nbGUvYXBpL2ZpZWxkX2JlaGF2aW9yLnByb3RvEgpnb29nbGUuYXBpKrYBCg1GaWVsZEJlaGF2aW9yEh4KGkZJRUxEX0JFSEFWSU9SX1VOU1BFQ0lGSUVEEAASDAoIT1BUSU9OQUwQARIMCghSRVFVSVJFRBACEg8KC09VVFBVVF9PTkxZEAMSDgoKSU5QVVRfT05MWRAEEg0KCUlNTVVUQUJMRRAFEhIKDlVOT1JERVJFRF9MSVNUEAYSFQoRTk9OX0VNUFRZX0RFRkFVTFQQBxIOCgpJREVOVElGSUVSEAg6ZAoOZmllbGRfYmVoYXZpb3ISHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGJwIIAMoDjIZLmdvb2dsZS5hcGkuRmllbGRCZWhhdmlvckICEABSDWZpZWxkQmVoYXZpb3JCsAEKDmNvbS5nb29nbGUuYXBpQhJGaWVsZEJlaGF2aW9yUHJvdG9QAVpBZ29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3RhdGlvbnOiAgNHQViqAgpHb29nbGUuQXBpygIKR29vZ2xlXEFwaeICFkdvb2dsZVxBcGlcR1BCTWV0YWRhdGHqAgtHb29nbGU6OkFwaWIGcHJvdG8z", [wkt.file_google_protobuf_descriptor]);
+var file_thru_common_v1_consensus = /* @__PURE__ */ codegenv2.fileDesc("Ch50aHJ1L2NvbW1vbi92MS9jb25zZW5zdXMucHJvdG8SDnRocnUuY29tbW9uLnYxIpYDCg5WZXJzaW9uQ29udGV4dBI2CgdjdXJyZW50GAEgASgLMh4udGhydS5jb21tb24udjEuQ3VycmVudFZlcnNpb25CA+BBAUgAEk4KE2N1cnJlbnRPckhpc3RvcmljYWwYAiABKAsyKi50aHJ1LmNvbW1vbi52MS5DdXJyZW50T3JIaXN0b3JpY2FsVmVyc2lvbkID4EEBSAASEwoEc2xvdBgDIAEoBEID4EEBSAASNAoJdGltZXN0YW1wGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEBSAASEgoDc2VxGAUgASgEQgPgQQFIADqRAbpIjQEaigEKHHZlcnNpb25fY29udGV4dF9oYXNfc2VsZWN0b3ISLm9uZSBvZiBjdXJyZW50LCBzbG90LCBvciB0aW1lc3RhbXAgbXVzdCBiZSBzZXQaOmhhcyh0aGlzLmN1cnJlbnQpIHx8IGhhcyh0aGlzLnNsb3QpIHx8IGhhcyh0aGlzLnRpbWVzdGFtcClCCQoHdmVyc2lvbiIQCg5DdXJyZW50VmVyc2lvbiIcChpDdXJyZW50T3JIaXN0b3JpY2FsVmVyc2lvbirfAQoPQ29uc2Vuc3VzU3RhdHVzEiAKHENPTlNFTlNVU19TVEFUVVNfVU5TUEVDSUZJRUQQABIdChlDT05TRU5TVVNfU1RBVFVTX09CU0VSVkVEEAESHQoZQ09OU0VOU1VTX1NUQVRVU19JTkNMVURFRBACEh4KGkNPTlNFTlNVU19TVEFUVVNfRklOQUxJWkVEEAMSJQohQ09OU0VOU1VTX1NUQVRVU19MT0NBTExZX0VYRUNVVEVEEAQSJQohQ09OU0VOU1VTX1NUQVRVU19DTFVTVEVSX0VYRUNVVEVEEAVCygEKEmNvbS50aHJ1LmNvbW1vbi52MUIOQ29uc2Vuc3VzUHJvdG9QAVpEZ2l0aHViLmNvbS9VbnRvLUxhYnMvdGhydS1uZXQvZ3JwYy9wa2cvcHJvdG8vdGhydS9jb21tb24vdjE7Y29tbW9udjGiAgNUQ1iqAg5UaHJ1LkNvbW1vbi5WMboCA1RIVcoCDlRocnVcQ29tbW9uXFYx4gIaVGhydVxDb21tb25cVjFcR1BCTWV0YWRhdGHqAhBUaHJ1OjpDb21tb246OlYxYgZwcm90bzM", [file_buf_validate_validate, file_google_api_field_behavior, wkt.file_google_protobuf_timestamp]);
+var VersionContextSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_consensus, 0);
+var CurrentVersionSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_consensus, 1);
+var CurrentOrHistoricalVersionSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_consensus, 2);
+var ConsensusStatus = /* @__PURE__ */ ((ConsensusStatus5) => {
+  ConsensusStatus5[ConsensusStatus5["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  ConsensusStatus5[ConsensusStatus5["OBSERVED"] = 1] = "OBSERVED";
+  ConsensusStatus5[ConsensusStatus5["INCLUDED"] = 2] = "INCLUDED";
+  ConsensusStatus5[ConsensusStatus5["FINALIZED"] = 3] = "FINALIZED";
+  ConsensusStatus5[ConsensusStatus5["LOCALLY_EXECUTED"] = 4] = "LOCALLY_EXECUTED";
+  ConsensusStatus5[ConsensusStatus5["CLUSTER_EXECUTED"] = 5] = "CLUSTER_EXECUTED";
+  return ConsensusStatus5;
+})(ConsensusStatus || {});
+var file_thru_common_v1_primitives = /* @__PURE__ */ codegenv2.fileDesc("Ch90aHJ1L2NvbW1vbi92MS9wcmltaXRpdmVzLnByb3RvEg50aHJ1LmNvbW1vbi52MSIjCgZQdWJrZXkSGQoFdmFsdWUYASABKAxCCuBBArpIBHoCaCAiJgoJU2lnbmF0dXJlEhkKBXZhbHVlGAEgASgMQgrgQQK6SAR6AmhAIiYKCFRhUHVia2V5EhoKBXZhbHVlGAEgASgJQgvgQQK6SAVyA5gBLiIpCgtUc1NpZ25hdHVyZRIaCgV2YWx1ZRgBIAEoCUIL4EECukgFcgOYAVpCywEKEmNvbS50aHJ1LmNvbW1vbi52MUIPUHJpbWl0aXZlc1Byb3RvUAFaRGdpdGh1Yi5jb20vVW50by1MYWJzL3RocnUtbmV0L2dycGMvcGtnL3Byb3RvL3RocnUvY29tbW9uL3YxO2NvbW1vbnYxogIDVENYqgIOVGhydS5Db21tb24uVjG6AgNUSFXKAg5UaHJ1XENvbW1vblxWMeICGlRocnVcQ29tbW9uXFYxXEdQQk1ldGFkYXRh6gIQVGhydTo6Q29tbW9uOjpWMWIGcHJvdG8z", [file_buf_validate_validate, file_google_api_field_behavior]);
+var PubkeySchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_primitives, 0);
+var SignatureSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_primitives, 1);
+var TaPubkeySchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_primitives, 2);
+var TsSignatureSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_primitives, 3);
+
+// src/proto/gen/thru/common/v1/filters_pb.ts
+var file_thru_common_v1_filters = /* @__PURE__ */ codegenv2.fileDesc("Chx0aHJ1L2NvbW1vbi92MS9maWx0ZXJzLnByb3RvEg50aHJ1LmNvbW1vbi52MSLHAQoGRmlsdGVyEiQKCmV4cHJlc3Npb24YASABKAlCC+BBAbpIBXIDGIAgSACIAQESNwoGcGFyYW1zGAIgAygLMiIudGhydS5jb21tb24udjEuRmlsdGVyLlBhcmFtc0VudHJ5QgPgQQEaTwoLUGFyYW1zRW50cnkSCwoDa2V5GAEgASgJEi8KBXZhbHVlGAIgASgLMiAudGhydS5jb21tb24udjEuRmlsdGVyUGFyYW1WYWx1ZToCOAFCDQoLX2V4cHJlc3Npb24ipAQKEEZpbHRlclBhcmFtVmFsdWUSGwoMc3RyaW5nX3ZhbHVlGAEgASgJQgPgQQFIABIaCgtieXRlc192YWx1ZRgCIAEoDEID4EEBSAASGQoKYm9vbF92YWx1ZRgDIAEoCEID4EEBSAASGAoJaW50X3ZhbHVlGAQgASgSQgPgQQFIABIZCgp1aW50X3ZhbHVlGAUgASgEQgPgQQFIABIbCgxkb3VibGVfdmFsdWUYBiABKAFCA+BBAUgAEjMKDHB1YmtleV92YWx1ZRgHIAEoCzIWLnRocnUuY29tbW9uLnYxLlB1YmtleUID4EEBSAASOQoPc2lnbmF0dXJlX3ZhbHVlGAggASgLMhkudGhydS5jb21tb24udjEuU2lnbmF0dXJlQgPgQQFIABI4Cg90YV9wdWJrZXlfdmFsdWUYCSABKAsyGC50aHJ1LmNvbW1vbi52MS5UYVB1YmtleUID4EEBSAASPgoSdHNfc2lnbmF0dXJlX3ZhbHVlGAogASgLMhsudGhydS5jb21tb24udjEuVHNTaWduYXR1cmVCA+BBAUgAEjoKEGJ5dGVzX2xpc3RfdmFsdWUYCyABKAsyGS50aHJ1LmNvbW1vbi52MS5CeXRlc0xpc3RCA+BBAUgAEjwKEXB1YmtleV9saXN0X3ZhbHVlGAwgASgLMhoudGhydS5jb21tb24udjEuUHVia2V5TGlzdEID4EEBSABCBgoEa2luZCIgCglCeXRlc0xpc3QSEwoGdmFsdWVzGAEgAygMQgPgQQEiOQoKUHVia2V5TGlzdBIrCgZ2YWx1ZXMYASADKAsyFi50aHJ1LmNvbW1vbi52MS5QdWJrZXlCA+BBASKhAQoTQ2VsRmlsdGVyVmFsaWRhdGlvbhInChFhbGxvd2VkX2Z1bmN0aW9ucxgBIAMoCUIM4EEBukgGkgEDEIABEiQKDmFsbG93ZWRfZmllbGRzGAIgAygJQgzgQQG6SAaSAQMQgAISKAoObWF4X2NvbXBsZXhpdHkYAyABKA1CC+BBAbpIBSoDGOgHSACIAQFCEQoPX21heF9jb21wbGV4aXR5QsgBChJjb20udGhydS5jb21tb24udjFCDEZpbHRlcnNQcm90b1ABWkRnaXRodWIuY29tL1VudG8tTGFicy90aHJ1LW5ldC9ncnBjL3BrZy9wcm90by90aHJ1L2NvbW1vbi92MTtjb21tb252MaICA1RDWKoCDlRocnUuQ29tbW9uLlYxugIDVEhVygIOVGhydVxDb21tb25cVjHiAhpUaHJ1XENvbW1vblxWMVxHUEJNZXRhZGF0YeoCEFRocnU6OkNvbW1vbjo6VjFiBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior, file_thru_common_v1_primitives]);
+var FilterSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_filters, 0);
+var FilterParamValueSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_filters, 1);
+var file_thru_common_v1_pagination = /* @__PURE__ */ codegenv2.fileDesc("Ch90aHJ1L2NvbW1vbi92MS9wYWdpbmF0aW9uLnByb3RvEg50aHJ1LmNvbW1vbi52MSKoAQoLUGFnZVJlcXVlc3QSJQoJcGFnZV9zaXplGAEgASgNQg3gQQG6SAcqBRjoBygBSACIAQESJAoKcGFnZV90b2tlbhgCIAEoCUIL4EEBukgFcgMYgARIAYgBARIiCghvcmRlcl9ieRgDIAEoCUIL4EEBukgFcgMYgAJIAogBAUIMCgpfcGFnZV9zaXplQg0KC19wYWdlX3Rva2VuQgsKCV9vcmRlcl9ieSJyCgxQYWdlUmVzcG9uc2USIQoPbmV4dF9wYWdlX3Rva2VuGAEgASgJQgPgQQFIAIgBARIcCgp0b3RhbF9zaXplGAIgASgEQgPgQQFIAYgBAUISChBfbmV4dF9wYWdlX3Rva2VuQg0KC190b3RhbF9zaXplQssBChJjb20udGhydS5jb21tb24udjFCD1BhZ2luYXRpb25Qcm90b1ABWkRnaXRodWIuY29tL1VudG8tTGFicy90aHJ1LW5ldC9ncnBjL3BrZy9wcm90by90aHJ1L2NvbW1vbi92MTtjb21tb252MaICA1RDWKoCDlRocnUuQ29tbW9uLlYxugIDVEhVygIOVGhydVxDb21tb25cVjHiAhpUaHJ1XENvbW1vblxWMVxHUEJNZXRhZGF0YeoCEFRocnU6OkNvbW1vbjo6VjFiBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior]);
+var PageResponseSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_common_v1_pagination, 1);
+var file_thru_core_v1_types = /* @__PURE__ */ codegenv2.fileDesc("Chh0aHJ1L2NvcmUvdjEvdHlwZXMucHJvdG8SDHRocnUuY29yZS52MSIhCgRIYXNoEhkKBXZhbHVlGAEgASgMQgrgQQK6SAR6AmggIiYKCUJsb2NrSGFzaBIZCgV2YWx1ZRgBIAEoDEIK4EECukgEegJoIEK5AQoQY29tLnRocnUuY29yZS52MUIKVHlwZXNQcm90b1ABWkBnaXRodWIuY29tL1VudG8tTGFicy90aHJ1LW5ldC9ncnBjL3BrZy9wcm90by90aHJ1L2NvcmUvdjE7Y29yZXYxogIDVENYqgIMVGhydS5Db3JlLlYxugIEVEhVQ8oCDFRocnVcQ29yZVxWMeICGFRocnVcQ29yZVxWMVxHUEJNZXRhZGF0YeoCDlRocnU6OkNvcmU6OlYxYgZwcm90bzM", [file_buf_validate_validate, file_google_api_field_behavior, file_thru_common_v1_primitives]);
+var BlockHashSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_core_v1_types, 1);
+
+// src/proto/gen/thru/core/v1/account_pb.ts
+var file_thru_core_v1_account = /* @__PURE__ */ codegenv2.fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, wkt.file_google_protobuf_timestamp, file_thru_common_v1_consensus, file_thru_common_v1_primitives, file_thru_core_v1_types]);
+var file_thru_core_v1_block = /* @__PURE__ */ codegenv2.fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, wkt.file_google_protobuf_timestamp, file_thru_common_v1_primitives, file_thru_common_v1_consensus, file_thru_core_v1_types]);
+var file_thru_core_v1_node = /* @__PURE__ */ codegenv2.fileDesc("Chd0aHJ1L2NvcmUvdjEvbm9kZS5wcm90bxIMdGhydS5jb3JlLnYxIjcKC05vZGVDb250YWN0EhUKCGlwNF9hZGRyGAEgASgNQgPgQQISEQoEcG9ydBgCIAEoDUID4EECIkIKDE5vZGVQcm90b2NvbBIYCgtjb250YWN0X2lkeBgBIAEoDUID4EECEhgKC3Byb3RvY29sX2lkGAIgASgNQgPgQQIijgIKCk5vZGVSZWNvcmQSFAoHdmVyc2lvbhgBIAEoDUID4EECEhUKCGNoYWluX2lkGAIgASgNQgPgQQISEwoGc2VxbnVtGAMgASgEQgPgQQISKwoGcHVia2V5GAQgASgLMhYudGhydS5jb21tb24udjEuUHVia2V5QgPgQQISMAoIY29udGFjdHMYBSADKAsyGS50aHJ1LmNvcmUudjEuTm9kZUNvbnRhY3RCA+BBARIyCglwcm90b2NvbHMYBiADKAsyGi50aHJ1LmNvcmUudjEuTm9kZVByb3RvY29sQgPgQQESFgoJc2lnbmF0dXJlGAcgASgMQgPgQQISEwoGaXNfb3duGAggASgIQgPgQQJCuAEKEGNvbS50aHJ1LmNvcmUudjFCCU5vZGVQcm90b1ABWkBnaXRodWIuY29tL1VudG8tTGFicy90aHJ1LW5ldC9ncnBjL3BrZy9wcm90by90aHJ1L2NvcmUvdjE7Y29yZXYxogIDVENYqgIMVGhydS5Db3JlLlYxugIEVEhVQ8oCDFRocnVcQ29yZVxWMeICGFRocnVcQ29yZVxWMVxHUEJNZXRhZGF0YeoCDlRocnU6OkNvcmU6OlYxYgZwcm90bzM", [file_google_api_field_behavior, file_thru_common_v1_primitives]);
+var file_thru_core_v1_state = /* @__PURE__ */ codegenv2.fileDesc("Chh0aHJ1L2NvcmUvdjEvc3RhdGUucHJvdG8SDHRocnUuY29yZS52MSKnAQoRU3RhdGVQcm9vZlJlcXVlc3QSLAoHYWRkcmVzcxgBIAEoCzIWLnRocnUuY29tbW9uLnYxLlB1YmtleUID4EECEjUKCnByb29mX3R5cGUYAiABKA4yHC50aHJ1LmNvcmUudjEuU3RhdGVQcm9vZlR5cGVCA+BBAhIdCgt0YXJnZXRfc2xvdBgDIAEoBEID4EEBSACIAQFCDgoMX3RhcmdldF9zbG90IjMKClN0YXRlUHJvb2YSEgoFcHJvb2YYASABKAxCA+BBAhIRCgRzbG90GAIgASgEQgPgQQIqjwEKDlN0YXRlUHJvb2ZUeXBlEiAKHFNUQVRFX1BST09GX1RZUEVfVU5TUEVDSUZJRUQQABIdChlTVEFURV9QUk9PRl9UWVBFX0NSRUFUSU5HEAESHQoZU1RBVEVfUFJPT0ZfVFlQRV9VUERBVElORxACEh0KGVNUQVRFX1BST09GX1RZUEVfRVhJU1RJTkcQA0K5AQoQY29tLnRocnUuY29yZS52MUIKU3RhdGVQcm90b1ABWkBnaXRodWIuY29tL1VudG8tTGFicy90aHJ1LW5ldC9ncnBjL3BrZy9wcm90by90aHJ1L2NvcmUvdjE7Y29yZXYxogIDVENYqgIMVGhydS5Db3JlLlYxugIEVEhVQ8oCDFRocnVcQ29yZVxWMeICGFRocnVcQ29yZVxWMVxHUEJNZXRhZGF0YeoCDlRocnU6OkNvcmU6OlYxYgZwcm90bzM", [file_google_api_field_behavior, file_thru_core_v1_types, file_thru_common_v1_primitives]);
+var StateProofRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_core_v1_state, 0);
+var file_thru_core_v1_transaction = /* @__PURE__ */ codegenv2.fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, file_thru_core_v1_types, file_thru_common_v1_primitives]);
+var file_google_api_http = /* @__PURE__ */ codegenv2.fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUKnAQoOY29tLmdvb2dsZS5hcGlCCUh0dHBQcm90b1ABWkFnb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29nbGVhcGlzL2FwaS9hbm5vdGF0aW9uczthbm5vdGF0aW9uc6ICA0dBWKoCCkdvb2dsZS5BcGnKAgpHb29nbGVcQXBp4gIWR29vZ2xlXEFwaVxHUEJNZXRhZGF0YeoCC0dvb2dsZTo6QXBpYgZwcm90bzM");
+var file_google_api_annotations = /* @__PURE__ */ codegenv2.fileDesc("Chxnb29nbGUvYXBpL2Fubm90YXRpb25zLnByb3RvEgpnb29nbGUuYXBpOksKBGh0dHASHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiwyrwiIAEoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGVSBGh0dHBCrgEKDmNvbS5nb29nbGUuYXBpQhBBbm5vdGF0aW9uc1Byb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25zogIDR0FYqgIKR29vZ2xlLkFwacoCCkdvb2dsZVxBcGniAhZHb29nbGVcQXBpXEdQQk1ldGFkYXRh6gILR29vZ2xlOjpBcGliBnByb3RvMw", [file_google_api_http, wkt.file_google_protobuf_descriptor]);
+var file_google_api_launch_stage = /* @__PURE__ */ codegenv2.fileDesc("Ch1nb29nbGUvYXBpL2xhdW5jaF9zdGFnZS5wcm90bxIKZ29vZ2xlLmFwaSqMAQoLTGF1bmNoU3RhZ2USHAoYTEFVTkNIX1NUQUdFX1VOU1BFQ0lGSUVEEAASEQoNVU5JTVBMRU1FTlRFRBAGEg0KCVBSRUxBVU5DSBAHEhAKDEVBUkxZX0FDQ0VTUxABEgkKBUFMUEhBEAISCAoEQkVUQRADEgYKAkdBEAQSDgoKREVQUkVDQVRFRBAFQpoBCg5jb20uZ29vZ2xlLmFwaUIQTGF1bmNoU3RhZ2VQcm90b1ABWi1nb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29nbGVhcGlzL2FwaTthcGmiAgNHQViqAgpHb29nbGUuQXBpygIKR29vZ2xlXEFwaeICFkdvb2dsZVxBcGlcR1BCTWV0YWRhdGHqAgtHb29nbGU6OkFwaWIGcHJvdG8z");
+var file_google_api_client = /* @__PURE__ */ codegenv2.fileDesc("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", [file_google_api_launch_stage, wkt.file_google_protobuf_descriptor, wkt.file_google_protobuf_duration]);
+var file_thru_services_v1_command_service = /* @__PURE__ */ codegenv2.fileDesc("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", [file_google_api_annotations, file_google_api_client, file_thru_common_v1_primitives, file_thru_common_v1_consensus, file_google_api_field_behavior, file_thru_core_v1_transaction, file_thru_core_v1_types, wkt.file_google_protobuf_duration]);
+var SendTransactionRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_command_service, 0);
+var BatchSendTransactionsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_command_service, 2);
+var SendAndTrackTxnRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_command_service, 4);
+var CommandService = /* @__PURE__ */ codegenv2.serviceDesc(file_thru_services_v1_command_service, 0);
+var file_thru_services_v1_query_service = /* @__PURE__ */ codegenv2.fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, wkt.file_google_protobuf_timestamp, file_thru_common_v1_consensus, file_thru_common_v1_filters, file_thru_common_v1_pagination, file_thru_common_v1_primitives, file_thru_core_v1_account, file_thru_core_v1_block, file_thru_core_v1_state, file_thru_core_v1_transaction, file_thru_core_v1_types, file_thru_core_v1_node]);
+var GetAccountRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 0);
+var GetRawAccountRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 1);
+var GetTransactionRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 2);
+var GetRawTransactionRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 3);
+var GenerateStateProofRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 4);
+var GetBlockRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 6);
+var GetRawBlockRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 7);
+var ListAccountsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 8);
+var ListBlocksRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 10);
+var ListTransactionsForAccountRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 12);
+var GetVersionRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 14);
+var GetEventRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 16);
+var ListEventsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 18);
+var ListTransactionsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 20);
+var GetTransactionStatusRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 22);
+var GetHeightRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 24);
+var GetChainInfoRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 26);
+var GetStateRootsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 28);
+var GetSlotMetricsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 34);
+var ListSlotMetricsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 36);
+var GetNodePubkeyRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 38);
+var GetNodeRecordsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 40);
+var GetNodeStatusRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_query_service, 42);
+var QueryService = /* @__PURE__ */ codegenv2.serviceDesc(file_thru_services_v1_query_service, 0);
+var file_thru_services_v1_streaming_service = /* @__PURE__ */ codegenv2.fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, file_thru_common_v1_primitives, wkt.file_google_protobuf_duration, wkt.file_google_protobuf_timestamp, file_thru_common_v1_consensus, file_thru_common_v1_filters, file_thru_core_v1_account, file_thru_core_v1_block, file_thru_core_v1_transaction, file_thru_core_v1_types, file_thru_core_v1_node]);
+var StreamBlocksRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 0);
+var StreamAccountUpdatesRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 2);
+var StreamTransactionsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 6);
+var StreamEventsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 8);
+var TrackTransactionRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 10);
+var StreamSlotMetricsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 12);
+var StreamHeightRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 14);
+var StreamNodeRecordsRequestSchema = /* @__PURE__ */ codegenv2.messageDesc(file_thru_services_v1_streaming_service, 16);
+var StreamingService = /* @__PURE__ */ codegenv2.serviceDesc(file_thru_services_v1_streaming_service, 0);
+
+// 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 protobuf.create(PubkeySchema, { value: this.toBytes() });
+  }
+  toProtoTaPubkey() {
+    return protobuf.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 protobuf.create(SignatureSchema, { value: this.toBytes() });
+  }
+  toProtoTsSignature() {
+    return protobuf.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`);
+  }
+};
+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 = protobuf.create(VersionContextSchema, {
+  version: {
+    case: "current",
+    value: protobuf.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 ?? connectWeb.createGrpcWebTransport({
+    baseUrl,
+    ...restTransportOptions,
+    interceptors: mergedInterceptors.length > 0 ? mergedInterceptors : void 0
+  });
+  return {
+    baseUrl,
+    transport,
+    query: connect.createClient(QueryService, transport),
+    command: connect.createClient(CommandService, transport),
+    streaming: connect.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 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 protobuf.create(PageResponseSchema, {
+      nextPageToken: this.nextPageToken,
+      totalSize: this.totalSize
+    });
+  }
+  hasNextPage() {
+    return !!this.nextPageToken;
+  }
+};
+ed25519.hashes.sha512 = sha2_js.sha512;
+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 ed25519.etc.concatBytes(...arrays);
+}
+function sha512Bytes(bytes) {
+  return new Uint8Array(sha2_js.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 = ed25519.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 = ed25519.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 = ed25519.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;
+}
+
+// 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/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 = protobuf.create(StateProofRequestSchema, {
+    address: options.address ? Pubkey.from(options.address).toProtoPubkey() : void 0,
+    proofType: options.proofType,
+    targetSlot
+  });
+  const schemaRequest = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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/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 protobuf.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 = sha2_js.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 = sha2_js.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 = protobuf.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 = protobuf.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 = protobuf.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)
+  };
+}
+function currentVersionContext() {
+  return protobuf.create(VersionContextSchema, {
+    version: { case: "current", value: protobuf.create(CurrentVersionSchema) }
+  });
+}
+function currentOrHistoricalVersionContext() {
+  return protobuf.create(VersionContextSchema, {
+    version: { case: "currentOrHistorical", value: protobuf.create(CurrentOrHistoricalVersionSchema) }
+  });
+}
+function slotVersionContext(slot) {
+  return protobuf.create(VersionContextSchema, {
+    version: { case: "slot", value: toUint64(slot, "slot") }
+  });
+}
+function timestampVersionContext(value) {
+  return protobuf.create(VersionContextSchema, {
+    version: { case: "timestamp", value: normalizeTimestamp(value) }
+  });
+}
+function seqVersionContext(seq) {
+  return protobuf.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/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 = protobuf.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 = protobuf.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/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 = protobuf.create(GetHeightRequestSchema);
+  return ctx.query.getHeight(request, withCallOptions(ctx)).then((proto) => HeightSnapshot.fromProto(proto));
+}
+async function getChainInfo(ctx) {
+  const request = protobuf.create(GetChainInfoRequestSchema);
+  return ctx.query.getChainInfo(request, withCallOptions(ctx));
+}
+async function getChainId(ctx) {
+  const response = await getChainInfo(ctx);
+  return response.chainId;
+}
+var _ThruHDWallet = class _ThruHDWallet {
+  static ensureSeed(seed) {
+    if (seed.length !== 64) {
+      throw new Error("Seed must be 64 bytes");
+    }
+  }
+  static deriveKeyPair(seed, path) {
+    _ThruHDWallet.ensureSeed(seed);
+    const hdkey = HDKey__default.default.fromMasterSeed(seed);
+    const derived = hdkey.derive(path);
+    if (!derived.privateKey || !derived.publicKey) {
+      throw new Error("Failed to derive key pair");
+    }
+    const privateKey = derived.privateKey;
+    const publicKey = derived.publicKeyRaw;
+    const secretKey = new Uint8Array(privateKey.length + publicKey.length);
+    secretKey.set(privateKey, 0);
+    secretKey.set(publicKey, privateKey.length);
+    return {
+      publicKey,
+      privateKey,
+      secretKey
+    };
+  }
+  static async getAccount(seed, accountIndex = 0, change = 0) {
+    if (accountIndex < 0) {
+      throw new Error("Account index must be non-negative");
+    }
+    const path = `${_ThruHDWallet.THRU_DERIVATION_PATH}/${accountIndex}'/${change}'`;
+    const { publicKey, privateKey, secretKey } = _ThruHDWallet.deriveKeyPair(seed, path);
+    return {
+      address: encodeAddress(publicKey),
+      publicKey,
+      privateKey,
+      secretKey,
+      path
+    };
+  }
+  static async deriveAccounts(seed, count) {
+    const accounts = [];
+    for (let i = 0; i < count; i++) {
+      const account = await _ThruHDWallet.getAccount(seed, i);
+      accounts.push({
+        index: i,
+        address: account.address,
+        path: account.path,
+        publicKey: account.publicKey
+      });
+    }
+    return accounts;
+  }
+  static isValidPath(path) {
+    const pathRegex = /^m(\/\d+')+$/;
+    return pathRegex.test(path);
+  }
+};
+_ThruHDWallet.THRU_COIN_TYPE = 9999;
+_ThruHDWallet.THRU_DERIVATION_PATH = `m/44'/${_ThruHDWallet.THRU_COIN_TYPE}'`;
+var ThruHDWallet = _ThruHDWallet;
+
+// thru-ts-client-sdk/modules/keys.ts
+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 ed25519.getPublicKeyAsync(privateKey));
+}
+function generateSeed() {
+  const cryptoObj = getWebCrypto();
+  const bytes = new Uint8Array(64);
+  cryptoObj.getRandomValues(bytes);
+  return bytes;
+}
+async function getNodeStatus(ctx) {
+  const request = protobuf.create(GetNodeStatusRequestSchema, {});
+  return ctx.query.getNodeStatus(request, withCallOptions(ctx));
+}
+async function getNodePubkey(ctx) {
+  const request = protobuf.create(GetNodePubkeyRequestSchema, {});
+  return ctx.query.getNodePubkey(request, withCallOptions(ctx));
+}
+async function getNodeRecords(ctx) {
+  const request = protobuf.create(GetNodeRecordsRequestSchema, {});
+  return ctx.query.getNodeRecords(request, withCallOptions(ctx));
+}
+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 protobuf.create(FilterParamValueSchema);
+    }
+    switch (this.case) {
+      case "stringValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "stringValue",
+            value: this.value
+          }
+        });
+      case "bytesValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "bytesValue",
+            value: copyBytes8(this.value)
+          }
+        });
+      case "boolValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "boolValue",
+            value: this.value
+          }
+        });
+      case "intValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "intValue",
+            value: this.value
+          }
+        });
+      case "doubleValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "doubleValue",
+            value: this.value
+          }
+        });
+      case "uintValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "uintValue",
+            value: this.value
+          }
+        });
+      case "pubkeyValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "pubkeyValue",
+            value: Pubkey.from(this.value).toProtoPubkey()
+          }
+        });
+      case "signatureValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "signatureValue",
+            value: Signature.from(this.value).toProtoSignature()
+          }
+        });
+      case "taPubkeyValue":
+        return protobuf.create(FilterParamValueSchema, {
+          kind: {
+            case: "taPubkeyValue",
+            value: Pubkey.from(this.value).toProtoTaPubkey()
+          }
+        });
+      case "tsSignatureValue":
+        return protobuf.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 protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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();
+}
+
+// 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();
+    }
+  }
+};
+async function getSlotMetrics(ctx, slot) {
+  const request = protobuf.create(GetSlotMetricsRequestSchema, { slot });
+  return ctx.query.getSlotMetrics(request, withCallOptions(ctx));
+}
+async function listSlotMetrics(ctx, options) {
+  const request = protobuf.create(ListSlotMetricsRequestSchema, {
+    startSlot: options.startSlot,
+    endSlot: options.endSlot,
+    limit: options.limit
+  });
+  return ctx.query.listSlotMetrics(request, withCallOptions(ctx));
+}
+async function getTransaction(ctx, signature, options = {}) {
+  const request = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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 = protobuf.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);
+}
+
+exports.createThruClient = createThruClient;
+//# sourceMappingURL=client.cjs.map
+//# sourceMappingURL=client.cjs.map