@thru/sdk 0.2.22

package/dist/abi/index.cjs

@@ -0,0 +1,946 @@
+'use strict';
+
+var yaml = require('yaml');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/abi/utils/bytes.ts
+function hexToBytes(hex) {
+  let normalized = hex.trim().replace(/[\s_]/g, "");
+  if (normalized.startsWith("0x") || normalized.startsWith("0X")) {
+    normalized = normalized.slice(2);
+  }
+  if (normalized.length === 0) return new Uint8Array();
+  if (normalized.length % 2 !== 0) {
+    throw new Error("Hex input 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 = Number.parseInt(normalized.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Hex input contains non-hexadecimal characters");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  if (Array.isArray(input)) {
+    return Uint8Array.from(input);
+  }
+  throw new TypeError("Unsupported buffer input");
+}
+
+// src/abi/utils/runtime.ts
+function isNodeRuntime() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+
+// src/abi/wasmBridge.ts
+var configuredWasmUrl;
+function configureWasm(url) {
+  if (cachedBindings) {
+    console.warn("configureWasm called after WASM was already loaded. Configuration ignored.");
+    return;
+  }
+  configuredWasmUrl = url;
+}
+var wasmDir = resolveWasmDir();
+var bindingsPromise;
+var cachedBindings;
+var dynamicImport = new Function("specifier", "return import(specifier)");
+var resolveModuleUrl = new Function("path", "base", "return new URL(path, base).href");
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function hasWasmBinding(value, name) {
+  return isObjectLike(value) && typeof value[name] === "function";
+}
+function isWasmReflectBindings(value) {
+  return hasWasmBinding(value, "reflect") && hasWasmBinding(value, "reflect_instruction") && hasWasmBinding(value, "format_reflection");
+}
+function describeImportedBindings(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function unwrapImportedBindings(imported, relativePath) {
+  const defaultExport = isObjectLike(imported) ? imported.default : void 0;
+  const candidate = defaultExport ?? imported;
+  if (isWasmReflectBindings(candidate)) {
+    return candidate;
+  }
+  if (isWasmReflectBindings(imported)) {
+    return imported;
+  }
+  throw new Error(
+    `WASM bindings import did not return a module object for ${relativePath} (received ${describeImportedBindings(imported)})`
+  );
+}
+function resolveImportMetaUrl() {
+  const url = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href));
+  if (typeof url === "string" && url.length > 0) return url;
+  const location = typeof globalThis.location === "object" && globalThis.location ? globalThis.location : void 0;
+  if (typeof location?.href === "string" && location.href.length > 0) {
+    return location.href;
+  }
+  return "file:///";
+}
+async function importModule(specifier) {
+  return dynamicImport(specifier);
+}
+function requireModule(moduleUrl) {
+  try {
+    const requireFn = typeof __require === "function" ? __require : void 0;
+    if (!requireFn) return void 0;
+    const specifier = moduleUrl.startsWith("file:") ? decodeURIComponent(new URL(moduleUrl).pathname) : moduleUrl;
+    return requireFn(specifier);
+  } catch {
+    return void 0;
+  }
+}
+function resolveWasmDir() {
+  const url = resolveImportMetaUrl();
+  if (url.includes("/src/abi/")) return "../../wasm/abi";
+  if (url.includes("/dist/")) return "./wasm";
+  return "./wasm";
+}
+async function loadBindings() {
+  if (cachedBindings) {
+    return cachedBindings;
+  }
+  if (!bindingsPromise) {
+    let loader;
+    if (isNodeRuntime()) {
+      loader = loadNodeBindings();
+    } else if (configuredWasmUrl) {
+      loader = loadWebBindings(configuredWasmUrl);
+    } else {
+      loader = loadBundlerBindings();
+    }
+    bindingsPromise = loader.then(
+      (bindings) => {
+        cachedBindings = bindings;
+        return bindings;
+      },
+      (err) => {
+        bindingsPromise = void 0;
+        throw err;
+      }
+    );
+  }
+  return bindingsPromise;
+}
+async function loadWebBindings(wasmUrl) {
+  const moduleUrl = resolveModuleUrl(`${wasmDir}/web/abi_reflect_wasm.js`, resolveImportMetaUrl());
+  const mod = await importModule(moduleUrl);
+  await mod.default(wasmUrl);
+  return mod;
+}
+async function loadBundlerBindings() {
+  const mod = await importBindings("bundler/abi_reflect_wasm.js");
+  return mod;
+}
+async function loadNodeBindings() {
+  const relativePath = "node/abi_reflect_wasm.js";
+  const moduleUrl = resolveModuleUrl(`${wasmDir}/${relativePath}`, resolveImportMetaUrl());
+  const imported = requireModule(moduleUrl) ?? await importModule(moduleUrl);
+  const mod = unwrapImportedBindings(imported, relativePath);
+  if (typeof mod.wasm_start === "function") {
+    mod.wasm_start();
+  }
+  return mod;
+}
+async function importBindings(relativePath) {
+  const moduleUrl = resolveModuleUrl(`${wasmDir}/${relativePath}`, resolveImportMetaUrl());
+  const imported = await importModule(moduleUrl);
+  return unwrapImportedBindings(imported, relativePath);
+}
+async function callReflect(abiYaml, typeName, buffer) {
+  const bindings = await loadBindings();
+  const result = bindings.reflect(abiYaml, typeName, buffer);
+  return JSON.parse(result);
+}
+async function callLayoutIr(abiYaml) {
+  const bindings = await loadBindings();
+  const result = bindings.build_layout_ir(abiYaml);
+  return JSON.parse(result);
+}
+async function callReflectInstruction(abiYaml, buffer) {
+  const bindings = await loadBindings();
+  const result = bindings.reflect_instruction(abiYaml, buffer);
+  return JSON.parse(result);
+}
+async function callReflectAccount(abiYaml, buffer) {
+  const bindings = await loadBindings();
+  const result = bindings.reflect_account(abiYaml, buffer);
+  return JSON.parse(result);
+}
+async function callReflectEvent(abiYaml, buffer) {
+  const bindings = await loadBindings();
+  const result = bindings.reflect_event(abiYaml, buffer);
+  return JSON.parse(result);
+}
+async function reflect(abiYaml, typeName, payload) {
+  if (payload.type === "binary") {
+    return callReflect(abiYaml, typeName, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflect(abiYaml, typeName, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function buildLayoutIr(abiYaml) {
+  return callLayoutIr(abiYaml);
+}
+async function reflectInstruction(abiYaml, payload) {
+  if (payload.type === "binary") {
+    return callReflectInstruction(abiYaml, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectInstruction(abiYaml, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function reflectAccount(abiYaml, payload) {
+  if (payload.type === "binary") {
+    return callReflectAccount(abiYaml, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectAccount(abiYaml, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function reflectEvent(abiYaml, payload) {
+  if (payload.type === "binary") {
+    return callReflectEvent(abiYaml, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectEvent(abiYaml, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function ensureWasmLoaded() {
+  await loadBindings();
+}
+function requireBindings() {
+  if (cachedBindings) {
+    return cachedBindings;
+  }
+  throw new Error("WASM bindings are not loaded. Call ensureWasmLoaded() first.");
+}
+function formatReflection(raw, options) {
+  const bindings = requireBindings();
+  const serialized = JSON.stringify(raw);
+  if (options && Object.keys(options).length > 0) {
+    const optionsJson = JSON.stringify(options);
+    const result2 = bindings.format_reflection_with_options(serialized, optionsJson);
+    return JSON.parse(result2);
+  }
+  const result = bindings.format_reflection(serialized);
+  return JSON.parse(result);
+}
+async function callReflectWithManifest(manifest, rootPackage, typeName, buffer) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.reflect_with_manifest(manifestJson, rootPackage, typeName, buffer);
+  return JSON.parse(result);
+}
+async function callReflectInstructionWithManifest(manifest, rootPackage, buffer) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.reflect_instruction_with_manifest(manifestJson, rootPackage, buffer);
+  return JSON.parse(result);
+}
+async function callReflectAccountWithManifest(manifest, rootPackage, buffer) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.reflect_account_with_manifest(manifestJson, rootPackage, buffer);
+  return JSON.parse(result);
+}
+async function callReflectEventWithManifest(manifest, rootPackage, buffer) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.reflect_event_with_manifest(manifestJson, rootPackage, buffer);
+  return JSON.parse(result);
+}
+async function reflectWithManifest(manifest, rootPackage, typeName, payload) {
+  if (payload.type === "binary") {
+    return callReflectWithManifest(manifest, rootPackage, typeName, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectWithManifest(manifest, rootPackage, typeName, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function reflectInstructionWithManifest(manifest, rootPackage, payload) {
+  if (payload.type === "binary") {
+    return callReflectInstructionWithManifest(manifest, rootPackage, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectInstructionWithManifest(manifest, rootPackage, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function reflectAccountWithManifest(manifest, rootPackage, payload) {
+  if (payload.type === "binary") {
+    return callReflectAccountWithManifest(manifest, rootPackage, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectAccountWithManifest(manifest, rootPackage, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function reflectEventWithManifest(manifest, rootPackage, payload) {
+  if (payload.type === "binary") {
+    return callReflectEventWithManifest(manifest, rootPackage, toUint8Array(payload.value));
+  }
+  if (payload.type === "hex") {
+    return callReflectEventWithManifest(manifest, rootPackage, hexToBytes(payload.value));
+  }
+  throw new Error(`Invalid payload type`);
+}
+async function buildLayoutIrWithManifest(manifest, rootPackage) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.build_layout_ir_with_manifest(manifestJson, rootPackage);
+  return JSON.parse(result);
+}
+async function getManifestPackages(manifest) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.get_manifest_packages(manifestJson);
+  return JSON.parse(result);
+}
+async function validateManifest(manifest) {
+  const bindings = await loadBindings();
+  const manifestJson = JSON.stringify(manifest);
+  const result = bindings.validate_manifest(manifestJson);
+  return JSON.parse(result);
+}
+
+// src/abi/imports/types.ts
+var ResolutionError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ResolutionError";
+  }
+};
+var ABI_ACCOUNT_HEADER_SIZE = 45;
+var ABI_STATE_OPEN = 0;
+var ABI_STATE_FINALIZED = 1;
+var DEFAULT_RPC_ENDPOINTS = {
+  mainnet: "https://rpc.thru.network",
+  testnet: "https://rpc-testnet.thru.network"
+};
+
+// src/abi/imports/onchainFetcher.ts
+var ABI_ACCOUNT_SUFFIX = "_abi_account";
+var ABI_ACCOUNT_SUFFIX_BYTES = new TextEncoder().encode(ABI_ACCOUNT_SUFFIX);
+var ABI_META_HEADER_SIZE = 4;
+var ABI_META_BODY_SIZE = 96;
+var ABI_META_ACCOUNT_SIZE = ABI_META_HEADER_SIZE + ABI_META_BODY_SIZE;
+var ABI_META_VERSION = 1;
+var ABI_META_KIND_OFFICIAL = 0;
+var ABI_META_KIND_EXTERNAL = 1;
+var DEFAULT_ABI_MANAGER_PROGRAM_ID = "taWqAAOSe9pavaaMpkc9VbSLBUMbuW6Mk59sZlSbcNHsJA";
+async function sha256Bytes(data) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return new Uint8Array(hashBuffer);
+}
+function concatBytes(...chunks) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function abiMetaBodyForProgram(program) {
+  const body = new Uint8Array(ABI_META_BODY_SIZE);
+  body.set(program.slice(0, 32), 0);
+  return body;
+}
+async function deriveAbiAccountSeed(kind, body) {
+  return sha256Bytes(concatBytes(new Uint8Array([kind]), body, ABI_ACCOUNT_SUFFIX_BYTES));
+}
+async function createProgramDefinedAccountAddress(owner, isEphemeral, seed) {
+  const flag = new Uint8Array([isEphemeral ? 1 : 0]);
+  return sha256Bytes(concatBytes(owner, flag, seed));
+}
+async function deriveAbiAccountAddress(kind, body, owner, isEphemeral) {
+  const seed = await deriveAbiAccountSeed(kind, body);
+  return createProgramDefinedAccountAddress(owner, isEphemeral, seed);
+}
+async function deriveOfficialAbiAddress(programAddress, abiManagerProgramId = DEFAULT_ABI_MANAGER_PROGRAM_ID) {
+  const programBytes = decodeAddress(programAddress);
+  const managerBytes = decodeAddress(abiManagerProgramId);
+  const body = abiMetaBodyForProgram(programBytes);
+  return deriveAbiAccountAddress(ABI_META_KIND_OFFICIAL, body, managerBytes, false);
+}
+function parseAbiMetaAccount(data) {
+  if (data.length < ABI_META_ACCOUNT_SIZE) {
+    throw new Error(
+      `ABI meta account data too short: ${data.length} bytes, expected at least ${ABI_META_ACCOUNT_SIZE}`
+    );
+  }
+  const version = data[0];
+  const kind = data[1];
+  const flags = data[2] | data[3] << 8;
+  const body = data.slice(ABI_META_HEADER_SIZE, ABI_META_HEADER_SIZE + ABI_META_BODY_SIZE);
+  if (version !== ABI_META_VERSION) {
+    throw new Error(`Unsupported ABI meta version: ${version}`);
+  }
+  if (kind !== ABI_META_KIND_OFFICIAL && kind !== ABI_META_KIND_EXTERNAL) {
+    throw new Error(`Unsupported ABI meta kind: ${kind}`);
+  }
+  return { version, kind, flags, body };
+}
+function parseAbiAccountData(data) {
+  if (data.length < ABI_ACCOUNT_HEADER_SIZE) {
+    throw new Error(
+      `ABI account data too short: ${data.length} bytes, expected at least ${ABI_ACCOUNT_HEADER_SIZE}`
+    );
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const abiMetaAccount = data.slice(0, 32);
+  const revision = view.getBigUint64(32, true);
+  const state = data[40];
+  const contentSize = view.getUint32(41, true);
+  if (state !== ABI_STATE_OPEN && state !== ABI_STATE_FINALIZED) {
+    throw new Error(`Invalid ABI account state: ${state}`);
+  }
+  const expectedSize = ABI_ACCOUNT_HEADER_SIZE + contentSize;
+  if (data.length < expectedSize) {
+    throw new Error(
+      `ABI account data truncated: ${data.length} bytes, expected ${expectedSize}`
+    );
+  }
+  const contentBytes = data.slice(ABI_ACCOUNT_HEADER_SIZE, expectedSize);
+  const content = new TextDecoder().decode(contentBytes);
+  return {
+    abiMetaAccount,
+    revision,
+    state,
+    content
+  };
+}
+function revisionMatches(revision, spec) {
+  switch (spec.type) {
+    case "latest":
+      return true;
+    case "exact":
+      return revision === BigInt(spec.value);
+    case "minimum":
+      return revision >= BigInt(spec.value);
+    case "atSlot":
+      return true;
+    default:
+      return false;
+  }
+}
+function versionContextForRevision(spec) {
+  if (spec.type === "atSlot") {
+    return { version: { case: "slot", value: spec.slot } };
+  }
+  return { version: { case: "current", value: {} } };
+}
+var OnchainFetcher = class {
+  constructor(config = {}) {
+    this.rpcEndpoints = { ...DEFAULT_RPC_ENDPOINTS, ...config.rpcEndpoints };
+    this.thruClient = config.thruClient;
+    const managerId = config.abiManagerProgramId ?? DEFAULT_ABI_MANAGER_PROGRAM_ID;
+    this.abiManagerProgramId = decodeAddress(managerId);
+    this.abiManagerIsEphemeral = config.abiManagerIsEphemeral ?? false;
+  }
+  /**
+   * Fetch ABI content from an on-chain account.
+   *
+   * The `revision` parameter controls both how the account is selected
+   * server-side (via version_context when `atSlot` is used) and whether the
+   * returned revision is validated against an expected value (`exact` /
+   * `minimum`). For `atSlot`, the returned `FetchResult.revision` reflects
+   * the revision that was active at that slot.
+   */
+  async fetch(address, target, network, revision) {
+    const addressBytes = this.parseAddress(address);
+    let abiAddress;
+    if (target === "program") {
+      const body = abiMetaBodyForProgram(addressBytes);
+      abiAddress = await deriveAbiAccountAddress(
+        ABI_META_KIND_OFFICIAL,
+        body,
+        this.abiManagerProgramId,
+        this.abiManagerIsEphemeral
+      );
+    } else if (target === "abi-meta") {
+      const metaData = await this.fetchAccountData(addressBytes, network, revision);
+      const meta = parseAbiMetaAccount(metaData);
+      abiAddress = await deriveAbiAccountAddress(
+        meta.kind,
+        meta.body,
+        this.abiManagerProgramId,
+        this.abiManagerIsEphemeral
+      );
+    } else {
+      abiAddress = addressBytes;
+    }
+    const accountData = await this.fetchAccountData(abiAddress, network, revision);
+    const parsed = parseAbiAccountData(accountData);
+    if (!revisionMatches(parsed.revision, revision)) {
+      const revisionStr = revision.type === "exact" ? `exactly ${revision.value}` : revision.type === "minimum" ? `at least ${revision.value}` : revision.type === "atSlot" ? `active at slot ${revision.slot}` : "latest";
+      throw new Error(
+        `ABI revision mismatch: got ${parsed.revision}, expected ${revisionStr}`
+      );
+    }
+    return {
+      abiYaml: parsed.content,
+      revision: parsed.revision,
+      isFinalized: parsed.state === ABI_STATE_FINALIZED
+    };
+  }
+  /**
+   * Get the RPC endpoint for a network.
+   */
+  getRpcEndpoint(network) {
+    const endpoint = this.rpcEndpoints[network];
+    if (!endpoint) {
+      throw new Error(
+        `Unknown network: ${network}. Configure rpcEndpoints for this network.`
+      );
+    }
+    return endpoint;
+  }
+  parseAddress(address) {
+    return decodeAddress(address);
+  }
+  async fetchAccountData(address, network, revision) {
+    if (this.thruClient) {
+      return this.fetchWithThruClient(address, revision);
+    }
+    if (revision.type === "atSlot") {
+      throw new Error(
+        "Slot-aware ABI fetch requires a ThruClient; the HTTP/JSON-RPC fallback does not support historical slot queries"
+      );
+    }
+    return this.fetchWithHttp(address, network);
+  }
+  async fetchWithThruClient(address, revision) {
+    if (!this.thruClient) {
+      throw new Error("ThruClient not configured");
+    }
+    const response = await this.thruClient.query.getRawAccount({
+      address: { value: address },
+      versionContext: versionContextForRevision(revision)
+    });
+    if (!response.rawData) {
+      throw new Error("Account not found or has no data");
+    }
+    return response.rawData;
+  }
+  async fetchWithHttp(address, network) {
+    const endpoint = this.getRpcEndpoint(network);
+    const addressStr = encodeThruAddress(address);
+    const response = await fetch(`${endpoint}/v1/accounts/${addressStr}:raw`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`ABI account not found: ${addressStr}`);
+      }
+      throw new Error(`Failed to fetch account: ${response.status} ${response.statusText}`);
+    }
+    const json = await response.json();
+    if (!json.rawData) {
+      throw new Error("Account has no data");
+    }
+    return base64Decode(json.rawData);
+  }
+};
+var BASE64_URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function decodeAddress(address) {
+  if (address.startsWith("ta") && address.length === 46) {
+    return decodeThruAddress(address);
+  }
+  throw new Error(`Invalid Thru address format: ${address} (expected 46-char ta-prefixed address)`);
+}
+function decodeThruAddress(address) {
+  if (address.length !== 46 || !address.startsWith("ta")) {
+    throw new Error(`Invalid Thru address: ${address}`);
+  }
+  const invlut = new Int16Array(256);
+  invlut.fill(-1);
+  for (let i = 0; i < BASE64_URL_ALPHABET.length; i += 1) {
+    invlut[BASE64_URL_ALPHABET.charCodeAt(i)] = i;
+  }
+  let inIdx = 2;
+  let inSz = 40;
+  let outIdx = 0;
+  let checksum = 0;
+  const out = new Uint8Array(32);
+  while (inSz >= 4) {
+    const a2 = invlut[address.charCodeAt(inIdx + 0)];
+    const b2 = invlut[address.charCodeAt(inIdx + 1)];
+    const c2 = invlut[address.charCodeAt(inIdx + 2)];
+    const d2 = invlut[address.charCodeAt(inIdx + 3)];
+    if (a2 < 0 || b2 < 0 || c2 < 0 || d2 < 0) {
+      throw new Error(`Invalid Thru address character at ${inIdx}`);
+    }
+    const triple2 = a2 << 18 | b2 << 12 | c2 << 6 | d2;
+    const temp12 = triple2 >> 16 & 255;
+    checksum += temp12;
+    out[outIdx++] = temp12;
+    const temp22 = triple2 >> 8 & 255;
+    checksum += temp22;
+    out[outIdx++] = temp22;
+    const temp3 = triple2 & 255;
+    checksum += temp3;
+    out[outIdx++] = temp3;
+    inIdx += 4;
+    inSz -= 4;
+  }
+  const a = invlut[address.charCodeAt(inIdx + 0)];
+  const b = invlut[address.charCodeAt(inIdx + 1)];
+  const c = invlut[address.charCodeAt(inIdx + 2)];
+  const d = invlut[address.charCodeAt(inIdx + 3)];
+  if (a < 0 || b < 0 || c < 0 || d < 0) {
+    throw new Error(`Invalid Thru address character at ${inIdx}`);
+  }
+  const triple = a << 18 | b << 12 | c << 6 | d;
+  const temp1 = triple >> 16 & 255;
+  checksum += temp1;
+  out[outIdx++] = temp1;
+  const temp2 = triple >> 8 & 255;
+  checksum += temp2;
+  out[outIdx++] = temp2;
+  const incomingChecksum = triple & 255;
+  if ((checksum & 255) !== incomingChecksum) {
+    throw new Error("Invalid Thru address checksum");
+  }
+  return out;
+}
+function encodeThruAddress(bytes) {
+  if (bytes.length !== 32) {
+    throw new Error(`Expected 32 bytes, got ${bytes.length}`);
+  }
+  function maskForBits(bits) {
+    return bits === 0 ? 0 : (1 << bits) - 1;
+  }
+  let output = "ta";
+  let checksum = 0;
+  let accumulator = 0;
+  let bitsCollected = 0;
+  for (let i = 0; i < 30; i++) {
+    const byte = bytes[i];
+    checksum += byte;
+    accumulator = accumulator << 8 | byte;
+    bitsCollected += 8;
+    while (bitsCollected >= 6) {
+      const index = accumulator >> bitsCollected - 6 & 63;
+      output += BASE64_URL_ALPHABET[index];
+      bitsCollected -= 6;
+      accumulator &= maskForBits(bitsCollected);
+    }
+  }
+  const secondLast = bytes[30];
+  checksum += secondLast;
+  accumulator = accumulator << 8 | secondLast;
+  bitsCollected += 8;
+  const last = bytes[31];
+  checksum += last;
+  accumulator = accumulator << 8 | last;
+  bitsCollected += 8;
+  accumulator = accumulator << 8 | checksum & 255;
+  bitsCollected += 8;
+  while (bitsCollected >= 6) {
+    const index = accumulator >> bitsCollected - 6 & 63;
+    output += BASE64_URL_ALPHABET[index];
+    bitsCollected -= 6;
+    accumulator &= maskForBits(bitsCollected);
+  }
+  return output;
+}
+function base64Decode(str) {
+  const binaryStr = atob(str);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+  return bytes;
+}
+async function resolveImports(rootAbiYaml, config = {}) {
+  const resolver = new ImportResolver(config);
+  return resolver.resolve(rootAbiYaml);
+}
+function createManifest(result) {
+  return result.manifest;
+}
+var ImportResolver = class {
+  constructor(config = {}) {
+    this.onchainFetcher = config.onchainFetcher ?? new OnchainFetcher({
+      rpcEndpoints: { ...DEFAULT_RPC_ENDPOINTS, ...config.rpcEndpoints }
+    });
+    this.maxDepth = config.maxDepth ?? 10;
+    this.visited = /* @__PURE__ */ new Map();
+    this.inProgress = /* @__PURE__ */ new Set();
+  }
+  async resolve(rootAbiYaml) {
+    this.visited.clear();
+    this.inProgress.clear();
+    const rootPackage = await this.resolvePackage(rootAbiYaml, false, 0);
+    const allPackages = Array.from(this.visited.values());
+    const manifest = {};
+    for (const pkg of allPackages) {
+      manifest[pkg.id.packageName] = pkg.abiYaml;
+    }
+    return {
+      root: rootPackage,
+      allPackages,
+      manifest
+    };
+  }
+  async resolvePackage(abiYaml, isRemote, depth) {
+    if (depth > this.maxDepth) {
+      throw new ResolutionError(
+        "CYCLIC_DEPENDENCY",
+        `Maximum resolution depth (${this.maxDepth}) exceeded`
+      );
+    }
+    const abiFile = this.parseAbiYaml(abiYaml);
+    const packageId = this.extractPackageId(abiFile);
+    const canonicalKey = `${packageId.packageName}@${packageId.version}`;
+    if (this.inProgress.has(canonicalKey)) {
+      throw new ResolutionError(
+        "CYCLIC_DEPENDENCY",
+        `Cyclic dependency detected: ${canonicalKey}`
+      );
+    }
+    const existing = this.visited.get(canonicalKey);
+    if (existing) {
+      return existing;
+    }
+    for (const [key, pkg] of this.visited) {
+      if (pkg.id.packageName === packageId.packageName && pkg.id.version !== packageId.version) {
+        throw new ResolutionError(
+          "VERSION_CONFLICT",
+          `Version conflict for ${packageId.packageName}: ${pkg.id.version} vs ${packageId.version}`,
+          { existing: pkg.id, conflicting: packageId }
+        );
+      }
+    }
+    this.inProgress.add(canonicalKey);
+    const imports = abiFile.abi.imports ?? [];
+    const dependencies = [];
+    for (const importYaml of imports) {
+      const importSource = this.normalizeImportSource(importYaml);
+      if (isRemote && importSource.type === "path") {
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `Remote package ${packageId.packageName} cannot import local path: ${importSource.path}`
+        );
+      }
+      const childIsRemote = importSource.type !== "path";
+      const depPackage = await this.resolveImport(importSource, childIsRemote, depth + 1);
+      dependencies.push(depPackage.id);
+    }
+    this.inProgress.delete(canonicalKey);
+    const resolvedPackage = {
+      id: packageId,
+      source: { type: "path", path: "<root>" },
+      abiYaml,
+      dependencies,
+      isRemote
+    };
+    this.visited.set(canonicalKey, resolvedPackage);
+    return resolvedPackage;
+  }
+  async resolveImport(source, parentIsRemote, depth) {
+    switch (source.type) {
+      case "path":
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `Path imports are not supported in browser. Use CLI 'bundle' command. Path: ${source.path}`
+        );
+      case "git":
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `Git imports are not supported in browser. Use CLI 'bundle' command. URL: ${source.url}`
+        );
+      case "http":
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `HTTP imports are not supported in browser. Use CLI 'bundle' command. URL: ${source.url}`
+        );
+      case "onchain":
+        return this.resolveOnchainImport(source, depth);
+      default:
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `Unknown import type: ${source.type}`
+        );
+    }
+  }
+  async resolveOnchainImport(source, depth) {
+    const result = await this.onchainFetcher.fetch(
+      source.address,
+      source.target,
+      source.network,
+      source.revision
+    );
+    const resolved = await this.resolvePackage(result.abiYaml, true, depth);
+    resolved.source = source;
+    resolved.isRemote = true;
+    return resolved;
+  }
+  parseAbiYaml(yamlContent) {
+    try {
+      const parsed = yaml__namespace.parse(yamlContent);
+      if (!parsed || typeof parsed !== "object") {
+        throw new Error("Invalid ABI YAML: not an object");
+      }
+      if (!parsed.abi || typeof parsed.abi !== "object") {
+        throw new Error("Invalid ABI YAML: missing 'abi' section");
+      }
+      return parsed;
+    } catch (error) {
+      throw new ResolutionError(
+        "PARSE_ERROR",
+        `Failed to parse ABI YAML: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  extractPackageId(abiFile) {
+    const metadata = abiFile.abi;
+    if (!metadata.package) {
+      throw new ResolutionError("PARSE_ERROR", "ABI missing 'package' field");
+    }
+    return {
+      packageName: metadata.package,
+      version: metadata["package-version"] ?? "0.0.0"
+    };
+  }
+  normalizeImportSource(source) {
+    switch (source.type) {
+      case "path":
+        return { type: "path", path: source.path };
+      case "git":
+        return {
+          type: "git",
+          url: source.url,
+          ref: source.ref,
+          path: source.path
+        };
+      case "http":
+        return { type: "http", url: source.url };
+      case "onchain": {
+        const revision = this.parseRevisionSpec(source.revision);
+        return {
+          type: "onchain",
+          address: source.address,
+          target: source.target ?? "program",
+          network: source.network,
+          revision
+        };
+      }
+      default:
+        throw new ResolutionError(
+          "UNSUPPORTED_IMPORT_TYPE",
+          `Unknown import type: ${source.type}`
+        );
+    }
+  }
+  parseRevisionSpec(revision) {
+    if (revision === void 0 || revision === "latest") {
+      return { type: "latest" };
+    }
+    if (typeof revision === "number") {
+      return { type: "exact", value: revision };
+    }
+    if (typeof revision === "string") {
+      if (revision.startsWith(">=")) {
+        const value2 = parseInt(revision.slice(2), 10);
+        if (isNaN(value2)) {
+          throw new Error(`Invalid minimum revision: ${revision}`);
+        }
+        return { type: "minimum", value: value2 };
+      }
+      const value = parseInt(revision, 10);
+      if (!isNaN(value)) {
+        return { type: "exact", value };
+      }
+    }
+    throw new Error(`Invalid revision specification: ${revision}`);
+  }
+};
+
+exports.ABI_ACCOUNT_HEADER_SIZE = ABI_ACCOUNT_HEADER_SIZE;
+exports.ABI_STATE_FINALIZED = ABI_STATE_FINALIZED;
+exports.ABI_STATE_OPEN = ABI_STATE_OPEN;
+exports.DEFAULT_RPC_ENDPOINTS = DEFAULT_RPC_ENDPOINTS;
+exports.OnchainFetcher = OnchainFetcher;
+exports.ResolutionError = ResolutionError;
+exports.buildLayoutIr = buildLayoutIr;
+exports.buildLayoutIrWithManifest = buildLayoutIrWithManifest;
+exports.configureWasm = configureWasm;
+exports.createManifest = createManifest;
+exports.deriveOfficialAbiAddress = deriveOfficialAbiAddress;
+exports.ensureWasmLoaded = ensureWasmLoaded;
+exports.formatReflection = formatReflection;
+exports.getManifestPackages = getManifestPackages;
+exports.parseAbiAccountData = parseAbiAccountData;
+exports.reflect = reflect;
+exports.reflectAccount = reflectAccount;
+exports.reflectAccountWithManifest = reflectAccountWithManifest;
+exports.reflectEvent = reflectEvent;
+exports.reflectEventWithManifest = reflectEventWithManifest;
+exports.reflectInstruction = reflectInstruction;
+exports.reflectInstructionWithManifest = reflectInstructionWithManifest;
+exports.reflectWithManifest = reflectWithManifest;
+exports.resolveImports = resolveImports;
+exports.revisionMatches = revisionMatches;
+exports.validateManifest = validateManifest;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map