@gurge/sdk 0.3.46 → 0.3.48

package/react-native/HinkalWebViewWorker.mjs

@@ -0,0 +1,174 @@
+import { WorkerFactory as e } from "../libs/shared/common/src/webworker/workerFactory.mjs";
+import { WORKER_CDN_URLS as t } from "../dist/libs/shared/workers-prebuild/viteWorkerURL.constant.es.mjs";
+import { bigIntReplacer as n, reviveBigInts as r } from "./bridge/serialization.utils.mjs";
+import { HinkalRNWorker as i } from "./bridge/HinkalRNWorker.mjs";
+import { DeviceEventEmitter as a, StyleSheet as o, View as s } from "react-native";
+import { useCallback as c, useEffect as l, useRef as u } from "react";
+import { WebView as d } from "react-native-webview";
+import { jsx as f } from "react/jsx-runtime";
+//#region libs/shared/sdk/src/react-native/HinkalWebViewWorker.tsx
+var p = `${new URL(Object.values(t)[0]).origin}/`;
+e.rnWorkerFactory = (e) => new i(e);
+var m = `
+if (!window.__hinkalPageBoot) (function(){
+  window.__hinkalPageBoot = true;
+  var URLS = ${JSON.stringify(t)};
+  var BLOBS = {};
+
+  function replacer(_key, value){
+    if (typeof value === 'bigint') return { __bigint: value.toString() };
+    if (value instanceof Set) return { __set: Array.from(value) };
+    if (value instanceof Map) return { __map: Array.from(value.entries()) };
+    return value;
+  }
+  function revive(value){
+    if (value === null || typeof value !== 'object') return value;
+    var keys = Object.keys(value);
+    if (keys.length === 1) {
+      if (typeof value.__bigint === 'string') return BigInt(value.__bigint);
+      if (Array.isArray(value.__set)) return new Set(value.__set.map(revive));
+      if (Array.isArray(value.__map)) return new Map(value.__map.map(function(entry){ return [revive(entry[0]), revive(entry[1])]; }));
+    }
+    if (Array.isArray(value)) return value.map(revive);
+    var out = {}; for (var i = 0; i < keys.length; i++) out[keys[i]] = revive(value[keys[i]]); return out;
+  }
+  function post(payload){ try { window.ReactNativeWebView.postMessage(JSON.stringify(payload, replacer)); } catch(_){} }
+  function describe(error){
+    if (!error) return 'worker error';
+    if (error.message) return error.message;
+    if (error.error && error.error.stack) return error.error.stack;
+    try { return JSON.stringify(error); } catch(_){ return String(error); }
+  }
+
+  async function blobUrl(url){
+    if (BLOBS[url]) return BLOBS[url];
+    var response = await fetch(url);
+    if (!response.ok) throw new Error('HTTP ' + response.status + ' ' + url);
+    var body = await response.text();
+    BLOBS[url] = URL.createObjectURL(new Blob([${JSON.stringify("(function(){\n  var post = self.postMessage.bind(self);\n  function describe(error){\n    if (!error) return 'unknown';\n    var parts = [];\n    if (error.message) parts.push(error.message);\n    if (error.error && error.error.stack) parts.push(error.error.stack);\n    if (!parts.length) { try { parts.push(JSON.stringify(error)); } catch(_) { parts.push(String(error)); } }\n    return parts.join(' | ');\n  }\n  self.addEventListener('error', function(event){ try { post({ __hinkalWorkerError: describe(event) }); } catch(_){} });\n  self.addEventListener('unhandledrejection', function(event){ try { post({ __hinkalWorkerError: 'unhandledrejection: ' + describe(event && event.reason) }); } catch(_){} });\n  try { post({ __hinkalWorkerReady: true }); } catch(_){}\n})();")}, body], { type: 'application/javascript' }));
+    return BLOBS[url];
+  }
+
+  function spawn(url){
+    try { return new Worker(url, { type: 'module' }); } catch(_){ return new Worker(url); }
+  }
+
+  window.handleMessage = async function(envelope){
+    var requestId = envelope && envelope.requestId;
+    var variant = envelope && envelope.variant;
+    var message = revive(envelope && envelope.message);
+    var url = URLS[variant];
+    if (!url) return post({ requestId: requestId, type: 'ERROR', error: 'Unknown variant: ' + variant });
+
+    var worker;
+    try { worker = spawn(await blobUrl(url)); }
+    catch (error) { return post({ requestId: requestId, type: 'ERROR', error: 'spawn failed: ' + describe(error) }); }
+
+    var done = false, ready = false, pending = message;
+    function finish(){ if (done) return; done = true; try { worker.terminate(); } catch(_){} }
+
+    worker.onmessage = function(event){
+      var data = event && event.data;
+      if (data && typeof data === 'object') {
+        if (data.__hinkalWorkerReady) {
+          ready = true;
+          try { worker.postMessage(pending); pending = null; }
+          catch (error) { post({ requestId: requestId, type: 'ERROR', error: 'postMessage failed: ' + describe(error) }); finish(); }
+          return;
+        }
+        if (typeof data.__hinkalWorkerError === 'string') {
+          post({ requestId: requestId, type: 'ERROR', error: data.__hinkalWorkerError });
+          finish();
+          return;
+        }
+      }
+      post({ requestId: requestId, type: 'RESULT', data: data });
+      finish();
+    };
+    worker.onerror = function(event){
+      post({ requestId: requestId, type: 'ERROR', error: (ready ? 'worker runtime: ' : 'worker startup: ') + describe(event) });
+      finish();
+    };
+  };
+
+  post({ type: 'READY' });
+})();
+true;`, h = `<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body><script>${m}<\/script></body></html>`, g = o.create({ hiddenHost: {
+	position: "absolute",
+	height: 1,
+	width: 1,
+	left: -9999,
+	top: -9999,
+	opacity: 0
+} }), _ = () => {
+	let e = u(null), t = u({
+		ready: !1,
+		queue: []
+	}), i = c((t, r, i) => {
+		let o;
+		try {
+			o = JSON.stringify({
+				requestId: t,
+				variant: r,
+				message: i
+			}, n);
+		} catch (e) {
+			a.emit("FROM_WEBVIEW_WORKER", {
+				requestId: t,
+				type: "ERROR",
+				error: `serialize failed: ${e?.message ?? e}`
+			});
+			return;
+		}
+		e.current?.injectJavaScript(`window.handleMessage && window.handleMessage(${o}); true;`);
+	}, []);
+	l(() => {
+		let e = a.addListener("TO_WEBVIEW_WORKER", (e) => {
+			let n = {
+				requestId: e?.__requestId ?? "",
+				variant: e?.variant ?? "",
+				message: e?.message
+			};
+			t.current.ready ? i(n.requestId, n.variant, n.message) : t.current.queue.push(n);
+		});
+		return () => e.remove();
+	}, [i]);
+	let o = c((e) => {
+		let n;
+		try {
+			n = r(JSON.parse(e.nativeEvent.data));
+		} catch (e) {
+			a.emit("FROM_WEBVIEW_WORKER", {
+				type: "ERROR",
+				error: e?.message ?? "parse error"
+			});
+			return;
+		}
+		if (n?.type === "READY") {
+			t.current.ready = !0;
+			let e = t.current.queue;
+			t.current.queue = [], e.forEach(({ requestId: e, variant: t, message: n }) => i(e, t, n));
+			return;
+		}
+		a.emit("FROM_WEBVIEW_WORKER", n);
+	}, [i]);
+	return /* @__PURE__ */ f(s, {
+		pointerEvents: "none",
+		style: g.hiddenHost,
+		children: /* @__PURE__ */ f(d, {
+			ref: e,
+			source: {
+				html: h,
+				baseUrl: p
+			},
+			originWhitelist: ["*"],
+			javaScriptEnabled: !0,
+			domStorageEnabled: !0,
+			androidLayerType: "hardware",
+			onMessage: o,
+			onLoad: () => e.current?.injectJavaScript(m)
+		})
+	});
+};
+//#endregion
+export { _ as default };

package/react-native/bridge/HinkalRNWorker.cjs

@@ -0,0 +1 @@
+require(`../../_virtual/_rolldown/runtime.cjs`);const e=require(`./serialization.utils.cjs`);let t=require(`react-native`);var n=class{onmessage=null;onerror=null;requestId=e.nextRequestId();subscription;constructor(e){this.variant=e,this.subscription=t.DeviceEventEmitter.addListener(`FROM_WEBVIEW_WORKER`,e=>{!e||e.requestId!==this.requestId||(e.type===`RESULT`?this.onmessage?.({data:e.data}):e.type===`ERROR`&&this.onerror?.(Error(e.error??`WebView worker error`)))})}postMessage(e){t.DeviceEventEmitter.emit(`TO_WEBVIEW_WORKER`,{__requestId:this.requestId,variant:this.variant,message:e})}terminate(){this.subscription?.remove?.(),this.subscription=null}};exports.HinkalRNWorker=n;

package/react-native/bridge/HinkalRNWorker.d.ts

@@ -0,0 +1,13 @@
+import { WorkerVariant } from '../../common/src/webworker/worker.registry';
+export declare class HinkalRNWorker {
+    private variant;
+    onmessage: ((event: {
+        data: any;
+    }) => void) | null;
+    onerror: ((error: any) => void) | null;
+    private requestId;
+    private subscription;
+    constructor(variant: WorkerVariant);
+    postMessage(message: unknown): void;
+    terminate(): void;
+}

package/react-native/bridge/HinkalRNWorker.mjs

@@ -0,0 +1,26 @@
+import { nextRequestId as e } from "./serialization.utils.mjs";
+import { DeviceEventEmitter as t } from "react-native";
+//#region libs/shared/sdk/src/react-native/bridge/HinkalRNWorker.ts
+var n = class {
+	onmessage = null;
+	onerror = null;
+	requestId = e();
+	subscription;
+	constructor(e) {
+		this.variant = e, this.subscription = t.addListener("FROM_WEBVIEW_WORKER", (e) => {
+			!e || e.requestId !== this.requestId || (e.type === "RESULT" ? this.onmessage?.({ data: e.data }) : e.type === "ERROR" && this.onerror?.(Error(e.error ?? "WebView worker error")));
+		});
+	}
+	postMessage(e) {
+		t.emit("TO_WEBVIEW_WORKER", {
+			__requestId: this.requestId,
+			variant: this.variant,
+			message: e
+		});
+	}
+	terminate() {
+		this.subscription?.remove?.(), this.subscription = null;
+	}
+};
+//#endregion
+export { n as HinkalRNWorker };

package/react-native/bridge/serialization.utils.cjs

@@ -0,0 +1 @@
+var e=(e,t)=>typeof t==`bigint`?{__bigint:t.toString()}:t instanceof Set?{__set:Array.from(t)}:t instanceof Map?{__map:Array.from(t.entries())}:t,t=e=>{if(typeof e!=`object`||!e)return e;let n=Object.keys(e);if(n.length===1){if(typeof e.__bigint==`string`)return BigInt(e.__bigint);if(Array.isArray(e.__set))return new Set(e.__set.map(t));if(Array.isArray(e.__map))return new Map(e.__map.map(e=>[t(e[0]),t(e[1])]))}return Array.isArray(e)?e.map(t):Object.fromEntries(n.map(n=>[n,t(e[n])]))},n=()=>`hinkal-rnw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2,10)}`;exports.bigIntReplacer=e,exports.nextRequestId=n,exports.reviveBigInts=t;

package/react-native/bridge/serialization.utils.d.ts

@@ -0,0 +1,3 @@
+export declare const bigIntReplacer: (_key: string, value: any) => any;
+export declare const reviveBigInts: (value: any) => any;
+export declare const nextRequestId: () => string;

package/react-native/bridge/serialization.utils.mjs

@@ -0,0 +1,13 @@
+//#region libs/shared/sdk/src/react-native/bridge/serialization.utils.ts
+var e = (e, t) => typeof t == "bigint" ? { __bigint: t.toString() } : t instanceof Set ? { __set: Array.from(t) } : t instanceof Map ? { __map: Array.from(t.entries()) } : t, t = (e) => {
+	if (typeof e != "object" || !e) return e;
+	let n = Object.keys(e);
+	if (n.length === 1) {
+		if (typeof e.__bigint == "string") return BigInt(e.__bigint);
+		if (Array.isArray(e.__set)) return new Set(e.__set.map(t));
+		if (Array.isArray(e.__map)) return new Map(e.__map.map((e) => [t(e[0]), t(e[1])]));
+	}
+	return Array.isArray(e) ? e.map(t) : Object.fromEntries(n.map((n) => [n, t(e[n])]));
+}, n = () => `hinkal-rnw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+//#endregion
+export { e as bigIntReplacer, n as nextRequestId, t as reviveBigInts };

package/react-native/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../_virtual/_rolldown/runtime.cjs`),t=require(`./HinkalProvider.cjs`);let n=require(`buffer`);require(`react-native-get-random-values`);let r=require(`react-native`);r=e.__toESM(r),global.Buffer=n.Buffer,globalThis.indexedDB===void 0&&(globalThis.indexedDB={}),global.require===void 0&&(global.require=e=>{if(e===`react-native`)return r;throw Error(`global.require shim: unsupported module "${e}"`)}),exports.HinkalProvider=t.HinkalProvider;

package/react-native/index.d.ts

@@ -0,0 +1 @@
+export { HinkalProvider } from './HinkalProvider';

package/react-native/index.mjs

@@ -0,0 +1,10 @@
+import { HinkalProvider as e } from "./HinkalProvider.mjs";
+import { Buffer as t } from "buffer";
+import "react-native-get-random-values";
+import * as n from "react-native";
+global.Buffer = t, globalThis.indexedDB === void 0 && (globalThis.indexedDB = {}), global.require === void 0 && (global.require = (e) => {
+	if (e === "react-native") return n;
+	throw Error(`global.require shim: unsupported module "${e}"`);
+});
+//#endregion
+export { e as HinkalProvider };

package/react-native/metro-config.js

@@ -0,0 +1,88 @@
+/**
+ * Hinkal SDK Metro config helper for React Native consumers.
+ *
+ * Usage in your app's `metro.config.js`:
+ *
+ *   const { getDefaultConfig } = require("expo/metro-config");
+ *   const { applyHinkalMetroConfig } = require("@hinkal/sdk/react-native/metro-config");
+ *
+ *   const config = getDefaultConfig(__dirname);
+ *   module.exports = applyHinkalMetroConfig(config);
+ */
+const path = require('path');
+
+const shimDir = path.join(__dirname, 'shims');
+const shim = (name) => ({
+  filePath: path.join(shimDir, `${name}.js`),
+  type: 'sourceFile',
+});
+
+const isFromHinkalSdk = (originPath) => !!originPath && originPath.includes('/@hinkal/sdk/');
+
+const applyHinkalMetroConfig = (config) => {
+  if (!config || !config.resolver) {
+    throw new Error('applyHinkalMetroConfig: pass a Metro config (e.g. from `getDefaultConfig(__dirname)`).');
+  }
+
+  config.resolver.unstable_enablePackageExports = true;
+  config.resolver.unstable_conditionNames = ['require', 'default', 'react-native'];
+  config.resolver.sourceExts = Array.from(new Set([...(config.resolver.sourceExts ?? []), 'mjs', 'cjs']));
+
+  config.resolver.extraNodeModules = {
+    ...(config.resolver.extraNodeModules ?? {}),
+    path: path.join(shimDir, 'path.js'),
+    os: path.join(shimDir, 'os.js'),
+    fs: path.join(shimDir, 'fs.js'),
+    crypto: path.join(shimDir, 'crypto.js'),
+    worker_threads: path.join(shimDir, 'worker_threads.js'),
+    readline: path.join(shimDir, 'readline.js'),
+    constants: path.join(shimDir, 'constants.js'),
+    'web-worker': path.join(shimDir, 'web-worker.js'),
+    url: path.join(shimDir, 'url.js'),
+  };
+
+  const prevGetTransformOptions = config.transformer && config.transformer.getTransformOptions;
+  config.transformer = {
+    ...(config.transformer || {}),
+    getTransformOptions: async (...args) => {
+      const upstream = prevGetTransformOptions ? await prevGetTransformOptions(...args) : {};
+      return {
+        ...upstream,
+        transform: {
+          ...(upstream.transform || {}),
+          experimentalImportSupport: false,
+          inlineRequires: true,
+        },
+      };
+    },
+  };
+
+  const upstreamResolve = config.resolver.resolveRequest;
+
+  config.resolver.resolveRequest = (context, moduleName, platform) => {
+    if (moduleName === 'url') return shim('url');
+    if (moduleName === 'web-worker' || moduleName.startsWith('web-worker/')) return shim('web-worker');
+    if (moduleName === 'ffjavascript') return shim('ffjavascript');
+    if (moduleName === 'circomlibjs') return shim('circomlibjs');
+    if (moduleName === 'circomlibjs-hinkal-fork') return shim('circomlibjs-hinkal-fork');
+    if (moduleName === 'idb-keyval') return shim('idb-keyval');
+
+    if (isFromHinkalSdk(context.originModulePath)) {
+      if (moduleName === 'multiformats' || moduleName.startsWith('multiformats/')) return shim('multiformats');
+      if (moduleName === 'snarkjs') return shim('snarkjs');
+    }
+
+    if (moduleName.startsWith('node:')) {
+      const stripped = moduleName.slice(5);
+      if (upstreamResolve) return upstreamResolve(context, stripped, platform);
+      return context.resolveRequest(context, stripped, platform);
+    }
+
+    if (upstreamResolve) return upstreamResolve(context, moduleName, platform);
+    return context.resolveRequest(context, moduleName, platform);
+  };
+
+  return config;
+};
+
+module.exports = { applyHinkalMetroConfig };

package/react-native/shims/circomlibjs-hinkal-fork.js

@@ -0,0 +1,14 @@
+function notSupported(name) {
+  return () => {
+    throw new Error(
+      `[hinkal-rn] circomlibjs-hinkal-fork.${name} is not available on React Native. ` +
+        'The SDK uses poseidon-lite + an inline BabyJubJub instead.',
+    );
+  };
+}
+
+module.exports = {
+  buildPoseidon: notSupported('buildPoseidon'),
+  buildPoseidonReference: notSupported('buildPoseidonReference'),
+  buildBabyjub: notSupported('buildBabyjub'),
+};

package/react-native/shims/circomlibjs.js

@@ -0,0 +1,15 @@
+function notSupported(name) {
+  return () => {
+    throw new Error(
+      `[hinkal-rn] circomlibjs.${name} is not available on React Native. ` +
+        'The SDK uses poseidon-lite + an inline BabyJubJub instead.',
+    );
+  };
+}
+
+module.exports = {
+  buildPoseidon: notSupported('buildPoseidon'),
+  buildPoseidonReference: notSupported('buildPoseidonReference'),
+  buildPoseidonWasm: notSupported('buildPoseidonWasm'),
+  buildBabyjub: notSupported('buildBabyjub'),
+};

package/react-native/shims/constants.js

@@ -0,0 +1,7 @@
+module.exports = {
+  O_TRUNC: 512,
+  O_CREAT: 64,
+  O_RDWR: 2,
+  O_EXCL: 128,
+  O_RDONLY: 0,
+};

package/react-native/shims/crypto.js

@@ -0,0 +1,102 @@
+// Node `crypto` shim for React Native.
+
+const { sha256, sha512, keccak256 } = require("ethers");
+const { Buffer } = require("buffer");
+
+function ensureRng() {
+  if (!global.crypto || typeof global.crypto.getRandomValues !== "function") {
+    throw new Error(
+      "[hinkal-rn] global.crypto.getRandomValues is not available. " +
+        "Import @hinkal/sdk/react-native (HinkalProvider) before other SDK code.",
+    );
+  }
+}
+
+function randomBytes(size) {
+  ensureRng();
+  const arr = new Uint8Array(size);
+  global.crypto.getRandomValues(arr);
+  return Buffer.from(arr);
+}
+
+function randomFillSync(buf, offset, size) {
+  ensureRng();
+  const start = offset ?? 0;
+  const end = size != null ? start + size : buf.length;
+  const view = new Uint8Array(buf.buffer || buf, buf.byteOffset || 0, buf.length);
+  const tmp = new Uint8Array(end - start);
+  global.crypto.getRandomValues(tmp);
+  view.set(tmp, start);
+  return buf;
+}
+
+function randomUUID() {
+  // RFC 4122 v4 UUID via crypto-secure bytes.
+  const b = randomBytes(16);
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  const hex = b.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+function toBytesLike(input) {
+  if (input == null) return new Uint8Array(0);
+  if (typeof input === "string") return Buffer.from(input, "utf8");
+  if (input instanceof Uint8Array) return input;
+  if (Buffer.isBuffer(input)) return input;
+  if (input.buffer) return new Uint8Array(input.buffer, input.byteOffset || 0, input.byteLength || input.length);
+  return Buffer.from(input);
+}
+
+function hexToBuffer(hex) {
+  return Buffer.from(hex.replace(/^0x/, ""), "hex");
+}
+
+function createHash(algorithm) {
+  const alg = String(algorithm).toLowerCase().replace("-", "");
+  const chunks = [];
+  return {
+    update(chunk) {
+      chunks.push(toBytesLike(chunk));
+      return this;
+    },
+    digest(encoding) {
+      const total = chunks.reduce((acc, c) => acc + c.length, 0);
+      const merged = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) {
+        merged.set(c, off);
+        off += c.length;
+      }
+      let hex;
+      if (alg === "sha256") hex = sha256(merged);
+      else if (alg === "sha512") hex = sha512(merged);
+      else if (alg === "keccak256") hex = keccak256(merged);
+      else throw new Error(`[hinkal-rn] unsupported hash algorithm: ${algorithm}`);
+      const buf = hexToBuffer(hex);
+      if (!encoding) return buf;
+      if (encoding === "hex") return buf.toString("hex");
+      if (encoding === "base64") return buf.toString("base64");
+      return buf.toString(encoding);
+    },
+  };
+}
+
+function createHmac() {
+  throw new Error("[hinkal-rn] crypto.createHmac is not implemented in the RN shim. Use a JS implementation.");
+}
+
+module.exports = {
+  randomBytes,
+  randomFillSync,
+  randomUUID,
+  createHash,
+  createHmac,
+  webcrypto: typeof global.crypto !== "undefined" ? global.crypto : undefined,
+  getRandomValues: (arr) => {
+    ensureRng();
+    global.crypto.getRandomValues(arr);
+    return arr;
+  },
+};
+module.exports.default = module.exports;

package/react-native/shims/ffjavascript.js

@@ -0,0 +1,5 @@
+module.exports = {
+  Scalar: {},
+  F1Field: class {},
+  getCurveFromName: () => { throw new Error("not supported") },
+}

package/react-native/shims/fs.js

@@ -0,0 +1,5 @@
+module.exports = {
+  existsSync: () => false,
+  readFileSync: () => '',
+  writeFileSync: () => {},
+};

package/react-native/shims/globals.js

@@ -0,0 +1,15 @@
+import { Buffer } from "buffer";
+import * as ReactNative from "react-native";
+global.Buffer = Buffer;
+
+// key-val-store probes indexedDB; without it the SDK falls back to FileKeyValStore (process.cwd).
+if (typeof globalThis.indexedDB === "undefined") {
+  globalThis.indexedDB = {};
+}
+
+if (typeof global.require === "undefined") {
+  global.require = (m) => {
+    if (m === "react-native") return ReactNative;
+    throw new Error(`global.require shim: unsupported module "${m}"`);
+  };
+}

package/react-native/shims/idb-keyval.js

@@ -0,0 +1,75 @@
+// idb-keyval shim for React Native 
+const AsyncStorage =
+  require("@react-native-async-storage/async-storage").default;
+
+const PREFIX = "@hinkal/idb-keyval:";
+const key = (k) => `${PREFIX}${typeof k === "string" ? k : JSON.stringify(k)}`;
+
+async function get(k) {
+  const raw = await AsyncStorage.getItem(key(k));
+  if (raw == null) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+}
+
+async function set(k, value) {
+  if (value === undefined) {
+    await AsyncStorage.removeItem(key(k));
+    return;
+  }
+  await AsyncStorage.setItem(key(k), JSON.stringify(value));
+}
+
+async function update(k, updater) {
+  const current = await get(k);
+  const next = updater(current);
+  await set(k, next);
+  return next;
+}
+
+async function del(k) {
+  await AsyncStorage.removeItem(key(k));
+}
+
+async function clear() {
+  const all = await AsyncStorage.getAllKeys();
+  const ours = all.filter((x) => x.startsWith(PREFIX));
+  if (ours.length) await AsyncStorage.multiRemove(ours);
+}
+
+async function keys() {
+  const all = await AsyncStorage.getAllKeys();
+  return all.filter((x) => x.startsWith(PREFIX)).map((x) => x.slice(PREFIX.length));
+}
+
+async function values() {
+  const ks = await keys();
+  return Promise.all(ks.map(get));
+}
+
+async function entries() {
+  const ks = await keys();
+  const vs = await Promise.all(ks.map(get));
+  return ks.map((k, i) => [k, vs[i]]);
+}
+
+function createStore() {
+  // idb-keyval lets callers create a store with a custom DB name; we ignore it
+  return undefined;
+}
+
+module.exports = {
+  get,
+  set,
+  update,
+  del,
+  clear,
+  keys,
+  values,
+  entries,
+  createStore,
+};
+module.exports.default = module.exports;

package/react-native/shims/multiformats.js

@@ -0,0 +1 @@
+module.exports = {};

package/react-native/shims/os.js

@@ -0,0 +1,7 @@
+module.exports = {
+  hostname: () => 'localhost',
+  platform: () => 'linux',
+  arch: () => 'arm64',
+  EOL: '\n',
+  tmpdir: () => '/tmp',
+};

package/react-native/shims/path.js

@@ -0,0 +1,11 @@
+module.exports = {
+  join: (...args) => args.join("/"),
+  resolve: (...args) => args.join("/"),
+  dirname: (p) => p.split("/").slice(0, -1).join("/"),
+  basename: (p) => p.split("/").pop(),
+  extname: (p) => {
+    const base = p.split("/").pop();
+    const idx = base.lastIndexOf(".");
+    return idx < 0 ? "" : base.slice(idx);
+  },
+};

package/react-native/shims/readline.js

@@ -0,0 +1,6 @@
+module.exports = {
+  createInterface: () => ({
+    on: () => {},
+    close: () => {},
+  }),
+};

package/react-native/shims/snarkjs.js

@@ -0,0 +1,21 @@
+function notSupported(name) {
+  return () => {
+    throw new Error(
+      `[hinkal-rn] snarkjs.${name} is not available on the React Native JS thread. ` +
+        "All proof generation must go through the SnarkJS WebView bridge.",
+    );
+  };
+}
+
+module.exports = {
+  groth16: {
+    fullProve: notSupported("groth16.fullProve"),
+    prove: notSupported("groth16.prove"),
+    verify: notSupported("groth16.verify"),
+    exportSolidityCallData: notSupported("groth16.exportSolidityCallData"),
+  },
+  zKey: {
+    exportVerificationKey: notSupported("zKey.exportVerificationKey"),
+  },
+};
+module.exports.default = module.exports;

package/react-native/shims/url.js

@@ -0,0 +1,5 @@
+module.exports = {
+  pathToFileURL: (p) => ({ href: p }),
+  fileURLToPath: (u) => u,
+  URL: typeof URL !== "undefined" ? URL : null,
+};

package/react-native/shims/web-worker.js

@@ -0,0 +1,7 @@
+module.exports = class Worker {
+  constructor() {}
+  postMessage() {}
+  terminate() {}
+  addEventListener() {}
+  removeEventListener() {}
+};