@thru/abi 0.1.38 → 0.2.1

package/dist/index.js

@@ -1,3 +1,5 @@
+import * as yaml from 'yaml';
+
 // src/utils/bytes.ts
 function hexToBytes(hex) {
   let normalized = hex.trim().replace(/[\s_]/g, "");
@@ -192,7 +194,628 @@ function formatReflection(raw, options) {
   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/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/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);
+    default:
+      return false;
+  }
+}
+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.
+   */
+  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);
+      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);
+    const parsed = parseAbiAccountData(accountData);
+    if (!revisionMatches(parsed.revision, revision)) {
+      const revisionStr = revision.type === "exact" ? `exactly ${revision.value}` : revision.type === "minimum" ? `at least ${revision.value}` : "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) {
+    if (this.thruClient) {
+      return this.fetchWithThruClient(address);
+    }
+    return this.fetchWithHttp(address, network);
+  }
+  async fetchWithThruClient(address) {
+    if (!this.thruClient) {
+      throw new Error("ThruClient not configured");
+    }
+    const response = await this.thruClient.query.getRawAccount({
+      address: { value: address },
+      versionContext: {}
+    });
+    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.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}`);
+  }
+};
 
-export { buildLayoutIr, configureWasm, ensureWasmLoaded, formatReflection, reflect, reflectAccount, reflectEvent, reflectInstruction };
+export { ABI_ACCOUNT_HEADER_SIZE, ABI_STATE_FINALIZED, ABI_STATE_OPEN, DEFAULT_RPC_ENDPOINTS, OnchainFetcher, ResolutionError, buildLayoutIr, buildLayoutIrWithManifest, configureWasm, createManifest, deriveOfficialAbiAddress, ensureWasmLoaded, formatReflection, getManifestPackages, parseAbiAccountData, reflect, reflectAccount, reflectAccountWithManifest, reflectEvent, reflectEventWithManifest, reflectInstruction, reflectInstructionWithManifest, reflectWithManifest, resolveImports, revisionMatches, validateManifest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map