@arcanetech/privacy-sdk-stellar 0.4.1 → 0.5.0

package/dist/transact/index.js

@@ -701,6 +701,111 @@ function resolveZkConfigNonce(transactEnvironment) {
   return transactEnvironment.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
 }
 
+// src/transact/zk/browser-artifact-cache.ts
+import { ZK_SDK_PACKAGE_VERSION } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+var ZK_ARTIFACT_CACHE_NAME = `privacy-sdk-stellar-zk-artifacts:${ZK_SDK_PACKAGE_VERSION}`;
+function isBrowserCacheApiAvailable() {
+  return browserCacheStorage() !== void 0;
+}
+function readCaches() {
+  return globalThis.caches;
+}
+function browserCacheStorage() {
+  const cachesValue = readCaches();
+  if (cachesValue === void 0 || cachesValue === null) {
+    return void 0;
+  }
+  return cachesValue;
+}
+function absoluteArtifactUrl(url) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {
+    return url;
+  }
+  const href = globalThis.location?.href;
+  if (href === void 0) {
+    return url;
+  }
+  return new URL(url, href).href;
+}
+async function rememberResponse(url, response) {
+  const storage = browserCacheStorage();
+  if (storage === void 0) {
+    return;
+  }
+  try {
+    const cache = await storage.open(ZK_ARTIFACT_CACHE_NAME);
+    await cache.put(url, response.clone());
+  } catch {
+    return;
+  }
+}
+async function fetchNetworkArrayBuffer(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ZK artifact ${url}: ${String(response.status)}`);
+  }
+  await rememberResponse(url, response);
+  return response.arrayBuffer();
+}
+async function fetchArrayBufferWithBrowserCache(url) {
+  const requestUrl = absoluteArtifactUrl(url);
+  const storage = browserCacheStorage();
+  if (storage !== void 0) {
+    const cache = await storage.open(ZK_ARTIFACT_CACHE_NAME);
+    const cached = await cache.match(requestUrl);
+    if (cached?.ok === true) {
+      return cached.arrayBuffer();
+    }
+  }
+  return fetchNetworkArrayBuffer(requestUrl);
+}
+
+// src/transact/zk/prefetch-bundled-circuit.ts
+import {
+  bundledCircuitFileNames,
+  defaultZkArtifactBaseUrl
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+function resolveArtifactBaseUrl(explicit) {
+  const trimmed = explicit?.trim();
+  if (trimmed === void 0 || trimmed === "") {
+    return defaultZkArtifactBaseUrl();
+  }
+  let withoutSlash = trimmed;
+  while (withoutSlash.endsWith("/")) {
+    withoutSlash = withoutSlash.slice(0, -1);
+  }
+  return withoutSlash;
+}
+function artifactHref(base, fileName) {
+  const withSlash = `${base}/`;
+  if (/^https?:\/\//i.test(withSlash) || withSlash.startsWith("file:")) {
+    return new URL(fileName, withSlash).href;
+  }
+  const href = globalThis.location?.href;
+  if (href !== void 0) {
+    return new URL(fileName, new URL(withSlash, href)).href;
+  }
+  return `${withSlash}${fileName}`;
+}
+async function materializeBundledCircuitWithBrowserCache(definition, zkArtifactBaseUrl) {
+  const base = resolveArtifactBaseUrl(zkArtifactBaseUrl);
+  const names = bundledCircuitFileNames(definition.circuit);
+  const [circuitGraph, r1cs, provingKey] = await Promise.all([
+    fetchArrayBufferWithBrowserCache(artifactHref(base, names.graphFileName)),
+    fetchArrayBufferWithBrowserCache(artifactHref(base, names.r1csFileName)),
+    fetchArrayBufferWithBrowserCache(artifactHref(base, names.provingKeyFileName))
+  ]);
+  return {
+    nIns: definition.nIns,
+    nOuts: definition.nOuts,
+    publicNInputs: definition.publicNInputs,
+    publicNOutputs: definition.publicNOutputs,
+    circuitGraph,
+    r1cs,
+    provingKey
+  };
+}
+
 // src/transact/zk/circuit-config.ts
 import { BundledZkCircuit as BundledZkCircuit2 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 var DEFAULT_STELLAR_ZK_CIRCUITS = {
@@ -722,31 +827,23 @@ var DEFAULT_STELLAR_ZK_CIRCUITS = {
 function isBundledDefinition(definition) {
   return "circuit" in definition;
 }
-async function fetchBuffer(url) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ZK artifact ${url}: ${String(response.status)}`);
-  }
-  return response.arrayBuffer();
+function bundledConfig(definition) {
+  return {
+    nIns: definition.nIns,
+    nOuts: definition.nOuts,
+    publicNInputs: definition.publicNInputs,
+    publicNOutputs: definition.publicNOutputs,
+    circuit: definition.circuit
+  };
 }
-async function materializeDefinition(definition) {
-  if (isBundledDefinition(definition)) {
-    const bundled = {
-      nIns: definition.nIns,
-      nOuts: definition.nOuts,
-      publicNInputs: definition.publicNInputs,
-      publicNOutputs: definition.publicNOutputs,
-      circuit: definition.circuit
-    };
-    return bundled;
-  }
+async function materializeCustomDefinition(definition) {
   const [zkey, circuitGraph, r1cs, provingKey] = await Promise.all([
-    fetchBuffer(definition.zkeyUrl),
-    fetchBuffer(definition.circuitGraphUrl),
-    fetchBuffer(definition.r1csUrl),
-    fetchBuffer(definition.provingKeyUrl)
+    fetchArrayBufferWithBrowserCache(definition.zkeyUrl),
+    fetchArrayBufferWithBrowserCache(definition.circuitGraphUrl),
+    fetchArrayBufferWithBrowserCache(definition.r1csUrl),
+    fetchArrayBufferWithBrowserCache(definition.provingKeyUrl)
   ]);
-  const custom = {
+  return {
     nIns: definition.nIns,
     nOuts: definition.nOuts,
     publicNInputs: definition.publicNInputs,
@@ -756,16 +853,24 @@ async function materializeDefinition(definition) {
     r1cs,
     provingKey
   };
-  return custom;
 }
-async function materializeSelectedZkCircuit(circuits, nonce) {
+async function materializeDefinition(definition, zkArtifactBaseUrl) {
+  if (!isBundledDefinition(definition)) {
+    return materializeCustomDefinition(definition);
+  }
+  if (isBrowserCacheApiAvailable()) {
+    return materializeBundledCircuitWithBrowserCache(definition, zkArtifactBaseUrl);
+  }
+  return bundledConfig(definition);
+}
+async function materializeSelectedZkCircuit(circuits, nonce, zkArtifactBaseUrl) {
   const map = stellarCircuitsOrDefault(circuits);
   const key = nonce.toString();
   const definition = Object.entries(map).find(([nonceKey]) => nonceKey === key)?.[1];
   if (!definition) {
     throw new Error(`no zk circuit configured for nonce ${key}`);
   }
-  return { [key]: await materializeDefinition(definition) };
+  return { [key]: await materializeDefinition(definition, zkArtifactBaseUrl) };
 }
 function stellarCircuitsOrDefault(circuits) {
   return circuits ?? DEFAULT_STELLAR_ZK_CIRCUITS;
@@ -881,7 +986,8 @@ var PrivacyPoolService = class {
       const zkConfigNonce = this.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
       const zkCircuits = await materializeSelectedZkCircuit(
         this.zkCircuits,
-        zkConfigNonce
+        zkConfigNonce,
+        this.zkArtifactBaseUrl
       );
       this.sdk = await PrivacyPoolSDK2.init({
         wasmBinary: this.assets.sdkWasm,