@thru/sdk 0.2.22 → 0.2.23

package/README.abi.md

@@ -72,6 +72,16 @@ That script runs `wasm-pack build` three times (bundler + node + web targets) in
 `tsup` and copies those WASM folders into `dist/abi/wasm` so published packages
 resolve the dynamic imports automatically.
 
+Browser apps that cannot serve package-relative dynamic imports can publish the
+web target as static assets and configure both URLs before calling reflection:
+
+```ts
+configureWasm({
+  moduleUrl: "/wasm/abi/web/abi_reflect_wasm.js",
+  wasmUrl: "/wasm/abi/web/abi_reflect_wasm_bg.wasm",
+});
+```
+
 When developing inside the monorepo, Vitest loads the TypeScript sources
 directly. The runtime detects when it is executing from `src/` and reaches for
 `../wasm`, so make sure the synced artifacts exist before running the tests.

package/dist/abi/index.cjs

@@ -73,12 +73,19 @@ function isNodeRuntime() {
 
 // src/abi/wasmBridge.ts
 var configuredWasmUrl;
-function configureWasm(url) {
+var configuredWasmModuleUrl;
+function configureWasm(config) {
   if (cachedBindings) {
     console.warn("configureWasm called after WASM was already loaded. Configuration ignored.");
     return;
   }
-  configuredWasmUrl = url;
+  if (typeof config === "string") {
+    configuredWasmUrl = config;
+    configuredWasmModuleUrl = void 0;
+    return;
+  }
+  configuredWasmUrl = config.wasmUrl;
+  configuredWasmModuleUrl = config.moduleUrl;
 }
 var wasmDir = resolveWasmDir();
 var bindingsPromise;
@@ -124,6 +131,14 @@ function resolveImportMetaUrl() {
 async function importModule(specifier) {
   return dynamicImport(specifier);
 }
+function resolveRuntimeUrl(url) {
+  if (/^(?:[a-zA-Z][a-zA-Z\d+.-]*:|\/\/)/.test(url)) {
+    return url;
+  }
+  const location = typeof globalThis.location === "object" && globalThis.location ? globalThis.location : void 0;
+  const base = typeof location?.href === "string" && location.href.length > 0 ? location.href : resolveImportMetaUrl();
+  return resolveModuleUrl(url, base);
+}
 function requireModule(moduleUrl) {
   try {
     const requireFn = typeof __require === "function" ? __require : void 0;
@@ -140,6 +155,22 @@ function resolveWasmDir() {
   if (url.includes("/dist/")) return "./wasm";
   return "./wasm";
 }
+function resolveConfiguredWasmModuleUrl(wasmUrl) {
+  const base = typeof globalThis.location === "object" && typeof globalThis.location?.href === "string" ? globalThis.location.href : resolveImportMetaUrl();
+  const resolved = new URL(wasmUrl, base);
+  if (resolved.pathname.endsWith("_bg.wasm")) {
+    resolved.pathname = resolved.pathname.slice(0, -"_bg.wasm".length) + ".js";
+  } else if (resolved.pathname.endsWith(".wasm")) {
+    resolved.pathname = resolved.pathname.slice(0, -".wasm".length) + ".js";
+  } else {
+    throw new Error(
+      `Configured WASM URL must end in .wasm (received ${wasmUrl})`
+    );
+  }
+  resolved.search = "";
+  resolved.hash = "";
+  return resolved.href;
+}
 async function loadBindings() {
   if (cachedBindings) {
     return cachedBindings;
@@ -149,7 +180,7 @@ async function loadBindings() {
     if (isNodeRuntime()) {
       loader = loadNodeBindings();
     } else if (configuredWasmUrl) {
-      loader = loadWebBindings(configuredWasmUrl);
+      loader = loadWebBindings(configuredWasmUrl, configuredWasmModuleUrl);
     } else {
       loader = loadBundlerBindings();
     }
@@ -166,10 +197,15 @@ async function loadBindings() {
   }
   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);
+async function loadWebBindings(wasmUrl, moduleUrlOverride) {
+  const moduleUrl = moduleUrlOverride ? resolveRuntimeUrl(moduleUrlOverride) : resolveConfiguredWasmModuleUrl(wasmUrl);
+  const imported = await importModule(moduleUrl);
+  const mod = unwrapImportedBindings(imported, moduleUrl);
+  const initializer = isObjectLike(imported) ? imported.default : void 0;
+  if (typeof initializer !== "function") {
+    throw new Error(`WASM web module is missing default initializer for ${moduleUrl}`);
+  }
+  await initializer({ module_or_path: resolveRuntimeUrl(wasmUrl) });
   return mod;
 }
 async function loadBundlerBindings() {
@@ -354,6 +390,117 @@ async function validateManifest(manifest) {
   return JSON.parse(result);
 }
 
+// src/abi/nestedInstructionData.ts
+var MAX_NESTED_INSTRUCTION_DEPTH = 15;
+async function resolveNestedInstructionData(reflection, accountAddresses, decoder, options = {}) {
+  await resolveValue(
+    reflection.value,
+    0,
+    accountAddresses,
+    decoder,
+    options.maxDepth ?? MAX_NESTED_INSTRUCTION_DEPTH
+  );
+  return reflection;
+}
+async function resolveValue(value, instructionDepth, accountAddresses, decoder, maxDepth) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      await resolveValue(item, instructionDepth, accountAddresses, decoder, maxDepth);
+    }
+    return;
+  }
+  if (!isJsonObject(value)) return;
+  if (isInstructionDataValue(value)) {
+    await resolveInstructionDataValue(
+      value,
+      instructionDepth,
+      accountAddresses,
+      decoder,
+      maxDepth
+    );
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "decodedInstruction") continue;
+    await resolveValue(child, instructionDepth, accountAddresses, decoder, maxDepth);
+  }
+}
+async function resolveInstructionDataValue(value, instructionDepth, accountAddresses, decoder, maxDepth) {
+  delete value.decodeError;
+  delete value.decodedInstruction;
+  delete value.programAddress;
+  const programIndex = value.programIndex;
+  const dataHex = value.dataHex;
+  if (instructionDepth >= maxDepth) {
+    insertError(value, "Nested instruction depth limit reached");
+    return;
+  }
+  const programAddress = accountAddresses[programIndex];
+  if (!programAddress) {
+    insertError(value, `Invalid program index ${programIndex}`);
+    return;
+  }
+  value.programAddress = programAddress;
+  let data;
+  try {
+    data = parseHexBytes(dataHex);
+  } catch (err) {
+    insertError(value, `Nested instruction decode failed: ${errorMessage(err)}`);
+    return;
+  }
+  try {
+    const decoded = await decoder(programAddress, data);
+    if (!decoded) {
+      insertError(value, `ABI unavailable for program ${programAddress}`);
+      return;
+    }
+    await resolveValue(
+      decoded.value,
+      instructionDepth + 1,
+      accountAddresses,
+      decoder,
+      maxDepth
+    );
+    value.decodedInstruction = decoded;
+  } catch (err) {
+    insertError(value, `Nested instruction decode failed: ${errorMessage(err)}`);
+  }
+}
+function isInstructionDataValue(value) {
+  return value._pendingReflection === true && Number.isSafeInteger(value.programIndex) && value.programIndex >= 0 && typeof value.dataHex === "string";
+}
+function insertError(value, message) {
+  value.decodeError = message;
+}
+function parseHexBytes(value) {
+  const hex = value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+  if (hex.length % 2 !== 0) {
+    throw new Error("hex payload has an odd number of digits");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let idx = 0; idx < bytes.length; idx += 1) {
+    const high = decodeHexNibble(hex.charCodeAt(idx * 2));
+    const low = decodeHexNibble(hex.charCodeAt(idx * 2 + 1));
+    if (high === void 0 || low === void 0) {
+      throw new Error(`invalid hex payload at byte ${idx}`);
+    }
+    bytes[idx] = high << 4 | low;
+  }
+  return bytes;
+}
+function decodeHexNibble(value) {
+  if (value >= 48 && value <= 57) return value - 48;
+  if (value >= 97 && value <= 102) return value - 97 + 10;
+  if (value >= 65 && value <= 70) return value - 65 + 10;
+  return void 0;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/abi/imports/types.ts
 var ResolutionError = class extends Error {
   constructor(code, message, details) {
@@ -920,6 +1067,7 @@ 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.MAX_NESTED_INSTRUCTION_DEPTH = MAX_NESTED_INSTRUCTION_DEPTH;
 exports.OnchainFetcher = OnchainFetcher;
 exports.ResolutionError = ResolutionError;
 exports.buildLayoutIr = buildLayoutIr;
@@ -940,6 +1088,7 @@ exports.reflectInstruction = reflectInstruction;
 exports.reflectInstructionWithManifest = reflectInstructionWithManifest;
 exports.reflectWithManifest = reflectWithManifest;
 exports.resolveImports = resolveImports;
+exports.resolveNestedInstructionData = resolveNestedInstructionData;
 exports.revisionMatches = revisionMatches;
 exports.validateManifest = validateManifest;
 //# sourceMappingURL=index.cjs.map