@corpus-core/colibri-stateless 2.0.4 → 2.0.5

package/cjs/runtime_wasm.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Copyright (c) 2026 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWasmRuntime = getWasmRuntime;
+const wasm_js_1 = require("./wasm.js");
+const wasm_shared_js_1 = require("./wasm_shared.js");
+// The WASM runtime wraps the pointer-level Emscripten API (`C4W`) behind the
+// value-level `C4Runtime` interface. The module is loaded once via `getC4w()`.
+// Note: the historical c4w_* exports say "proof_ctx" where the core C API
+// (and this interface) say "prover" (c4_prover_create etc.).
+function createRuntime(c4w) {
+    return {
+        kind: 'wasm',
+        getMethodType(chainId, method, paramsJson, flags) {
+            const free_buffers = [];
+            const type = c4w._c4w_get_method_type(chainId, (0, wasm_shared_js_1.as_char_ptr)(method, c4w, free_buffers), paramsJson ? (0, wasm_shared_js_1.as_char_ptr)(paramsJson, c4w, free_buffers) : 0, flags);
+            free_buffers.forEach(ptr => c4w._free(ptr));
+            return type;
+        },
+        createProverCtx(method, argsJson, chainId, flags) {
+            const free_buffers = [];
+            const ctx = c4w._c4w_create_proof_ctx((0, wasm_shared_js_1.as_char_ptr)(method, c4w, free_buffers), (0, wasm_shared_js_1.as_char_ptr)(argsJson, c4w, free_buffers), chainId, flags);
+            free_buffers.forEach(ptr => c4w._free(ptr));
+            return ctx;
+        },
+        executeProverCtx(ctx) {
+            const state = (0, wasm_shared_js_1.as_json)(c4w._c4w_execute_proof_ctx(ctx), c4w, true);
+            // On success the JSON carries the proof as heap pointer + length
+            // (owned by the prover ctx); materialize it as bytes.
+            if (state.status === 'success')
+                state.result = (0, wasm_shared_js_1.as_bytes)(state.result, state.result_len, c4w);
+            return state;
+        },
+        freeProverCtx(ctx) {
+            c4w._c4w_free_proof_ctx(ctx);
+        },
+        createVerifyCtx(proof, method, argsJson, chainId, trustedCheckpoint, witnessKeys, flags, minLatestBlockTs) {
+            const free_buffers = [];
+            const ctx = c4w._c4w_create_verify_ctx((0, wasm_shared_js_1.copy_to_c)(proof, c4w, free_buffers), proof.length, (0, wasm_shared_js_1.as_char_ptr)(method, c4w, free_buffers), (0, wasm_shared_js_1.as_char_ptr)(argsJson, c4w, free_buffers), chainId, trustedCheckpoint ? (0, wasm_shared_js_1.as_char_ptr)(trustedCheckpoint, c4w, free_buffers) : 0, witnessKeys ? (0, wasm_shared_js_1.as_char_ptr)(witnessKeys, c4w, free_buffers) : 0, flags, minLatestBlockTs);
+            free_buffers.forEach(ptr => c4w._free(ptr));
+            return ctx;
+        },
+        verifyProof(ctx) {
+            return (0, wasm_shared_js_1.as_json)(c4w._c4w_verify_proof(ctx), c4w, true);
+        },
+        freeVerifyCtx(ctx) {
+            c4w._c4w_free_verify_ctx(ctx);
+        },
+        createRpcCtx(method, paramsJson, chainId, proverFlags, verifyFlags, proverMode) {
+            const free_buffers = [];
+            const ctx = c4w._c4w_create_rpc_ctx((0, wasm_shared_js_1.as_char_ptr)(method, c4w, free_buffers), (0, wasm_shared_js_1.as_char_ptr)(paramsJson, c4w, free_buffers), chainId, proverFlags, verifyFlags, proverMode);
+            free_buffers.forEach(ptr => c4w._free(ptr));
+            return ctx;
+        },
+        executeRpcCtx(ctx) {
+            return (0, wasm_shared_js_1.as_json)(c4w._c4w_execute_rpc_ctx(ctx), c4w, true);
+        },
+        freeRpcCtx(ctx) {
+            c4w._c4w_free_rpc_ctx(ctx);
+        },
+        rpcCtxSetProxyUrls(ctx, rpcUrls, beaconUrls) {
+            const free_buffers = [];
+            c4w._c4w_rpc_ctx_set_proxy_urls(ctx, (0, wasm_shared_js_1.as_char_ptr)(rpcUrls, c4w, free_buffers), (0, wasm_shared_js_1.as_char_ptr)(beaconUrls, c4w, free_buffers));
+            free_buffers.forEach(ptr => c4w._free(ptr));
+        },
+        rpcCtxSetWitnessKeys(ctx, keys) {
+            const free_buffers = [];
+            c4w._c4w_rpc_ctx_set_witness_keys(ctx, (0, wasm_shared_js_1.as_char_ptr)(keys, c4w, free_buffers));
+            free_buffers.forEach(ptr => c4w._free(ptr));
+        },
+        rpcCtxSetMinLatestBlockTs(ctx, ts) {
+            c4w._c4w_rpc_ctx_set_min_latest_block_ts(ctx, ts);
+        },
+        setCheckpoint(chainId, checkpoint) {
+            const free_buffers = [];
+            c4w._c4w_set_checkpoint(chainId, (0, wasm_shared_js_1.as_char_ptr)(checkpoint, c4w, free_buffers));
+            free_buffers.forEach(ptr => c4w._free(ptr));
+        },
+        reqSetResponse(req, data, nodeIndex) {
+            // ownership of the copied bytes is transferred to the C context
+            c4w._c4w_req_set_response(req.req_ptr, (0, wasm_shared_js_1.copy_to_c)(data, c4w), data.length, nodeIndex);
+        },
+        reqSetError(req, error, nodeIndex) {
+            const free_buffers = [];
+            c4w._c4w_req_set_error(req.req_ptr, (0, wasm_shared_js_1.as_char_ptr)(error, c4w, free_buffers), nodeIndex);
+            free_buffers.forEach(ptr => c4w._free(ptr));
+        },
+        decodeProof(proof) {
+            const free_buffers = [];
+            const ptr = (0, wasm_shared_js_1.copy_to_c)(proof, c4w, free_buffers);
+            const resultPtr = c4w._c4w_decode_proof(ptr, proof.length);
+            free_buffers.forEach(p => c4w._free(p));
+            if (!resultPtr)
+                throw new Error('Unknown proof format');
+            return (0, wasm_shared_js_1.as_json)(resultPtr, c4w, true);
+        },
+        registerStorage(storage) {
+            c4w.storage = storage;
+        },
+    };
+}
+let runtime = null;
+/**
+ * Returns the (cached) WASM-backed runtime.
+ * @return Initialized WASM runtime
+ */
+function getWasmRuntime() {
+    if (!runtime)
+        runtime = (0, wasm_js_1.getC4w)().then(createRuntime);
+    return runtime;
+}

package/cjs/wasm.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode_proof = exports.set_trusted_checkpoint = exports.get_prover_config_hex = exports.getC4w = exports.loadC4WModule = exports.set_wasm_url = exports.get_default_storage = exports.copy_to_c = exports.as_json = exports.as_char_ptr = exports.as_bytes = void 0;
+exports.module_dir = module_dir;
 // This file is used only for the CommonJS build output. It must not use
 // `import.meta` because that is a parse error in CommonJS environments (e.g. Jest).
 const node_path_1 = require("node:path");
@@ -64,3 +65,12 @@ exports.getC4w = api.getC4w;
 exports.get_prover_config_hex = api.get_prover_config_hex;
 exports.set_trusted_checkpoint = api.set_trusted_checkpoint;
 exports.decode_proof = api.decode_proof;
+/**
+ * Returns the directory of the compiled module. Used in Node to locate
+ * packaged assets (e.g. native addon prebuilds) relative to the package root.
+ * This CJS variant replaces `wasm.ts` (ESM, `import.meta.url`) at build time.
+ * @return Absolute directory path of this module
+ */
+async function module_dir() {
+    return __dirname;
+}

package/cjs/wasm_cjs.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode_proof = exports.set_trusted_checkpoint = exports.get_prover_config_hex = exports.getC4w = exports.loadC4WModule = exports.set_wasm_url = exports.get_default_storage = exports.copy_to_c = exports.as_json = exports.as_char_ptr = exports.as_bytes = void 0;
+exports.module_dir = module_dir;
 // This file is used only for the CommonJS build output. It must not use
 // `import.meta` because that is a parse error in CommonJS environments (e.g. Jest).
 const node_path_1 = require("node:path");
@@ -64,3 +65,12 @@ exports.getC4w = api.getC4w;
 exports.get_prover_config_hex = api.get_prover_config_hex;
 exports.set_trusted_checkpoint = api.set_trusted_checkpoint;
 exports.decode_proof = api.decode_proof;
+/**
+ * Returns the directory of the compiled module. Used in Node to locate
+ * packaged assets (e.g. native addon prebuilds) relative to the package root.
+ * This CJS variant replaces `wasm.ts` (ESM, `import.meta.url`) at build time.
+ * @return Absolute directory path of this module
+ */
+async function module_dir() {
+    return __dirname;
+}

package/http.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Copyright (c) 2025 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+import type { C4Runtime } from './runtime.js';
 import { Config as C4Config, DataRequest } from './types.js';
 export type AcceptKind = 'json' | 'octet';
 /**
@@ -17,7 +40,8 @@ export declare function fetch_rpc(urls: string[], payload: any, as_proof?: boole
 /**
  * Handles a C4 data request by fetching from configured servers, setting the
  * response or error back into the C context, and leveraging cache if present.
+ * @param runtime The active runtime the request originated from
  * @param req DataRequest descriptor from C
  * @param conf Colibri configuration
  */
-export declare function handle_request(req: DataRequest, conf: C4Config): Promise<void>;
+export declare function handle_request(runtime: C4Runtime, req: DataRequest, conf: C4Config): Promise<void>;

package/http.js

@@ -1,26 +1,3 @@
-/**
- * Copyright (c) 2025 corpus.core
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
- * the Software, and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
- * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * SPDX-License-Identifier: MIT
- */
-import { getC4w, as_char_ptr, copy_to_c } from './wasm.js';
 function joinPath(base, path) {
     if (!path)
         return base;
@@ -158,11 +135,11 @@ export async function fetch_rpc(urls, payload, as_proof = false, fetchFn = globa
 /**
  * Handles a C4 data request by fetching from configured servers, setting the
  * response or error back into the C context, and leveraging cache if present.
+ * @param runtime The active runtime the request originated from
  * @param req DataRequest descriptor from C
  * @param conf Colibri configuration
  */
-export async function handle_request(req, conf) {
-    const free_buffers = [];
+export async function handle_request(runtime, req, conf) {
     // Honor a requested delay before (re-)executing (e.g. oblivious-node retry backoff).
     if (req.delay && req.delay > 0)
         await new Promise(resolve => setTimeout(resolve, req.delay));
@@ -185,7 +162,6 @@ export async function handle_request(req, conf) {
                 servers = conf.rpcs || [...((conf.prover || []).map(p => p + (p.endsWith('/') ? '' : '/') + 'unverified_rpc'))];
                 break;
         }
-    const c4w = await getC4w();
     let path = (req.type == 'eth_rpc' && req.payload)
         ? `rpc: ${req.payload?.method}(${req.payload?.params.join(',')})`
         : req.url;
@@ -195,7 +171,7 @@ export async function handle_request(req, conf) {
         if (data) {
             if (conf.debug)
                 log(`::: ${path} (len=${data.length} bytes) CACHED`);
-            c4w._c4w_req_set_response(req.req_ptr, copy_to_c(data, c4w), data.length, 0);
+            runtime.reqSetResponse(req, data, 0);
             if (conf.onTransfer)
                 conf.onTransfer(data.length, req);
             return;
@@ -205,7 +181,7 @@ export async function handle_request(req, conf) {
         const accept = req.encoding == 'json' ? 'json' : 'octet';
         const fetchFn = conf.fetch || globalThis.fetch;
         const { data, nodeIndex } = await fetch_from_servers(servers, req.url || '', req.method, req.payload, accept, req.exclude_mask, fetchFn, req.ttl);
-        c4w._c4w_req_set_response(req.req_ptr, copy_to_c(data, c4w), data.length, nodeIndex);
+        runtime.reqSetResponse(req, data, nodeIndex);
         if (conf.onTransfer)
             conf.onTransfer(data.length, req);
         if (conf.debug)
@@ -215,11 +191,8 @@ export async function handle_request(req, conf) {
     }
     catch (e) {
         const last_error = (e instanceof Error) ? e.message : String(e);
-        c4w._c4w_req_set_error(req.req_ptr, as_char_ptr(last_error, c4w, free_buffers), 0);
+        runtime.reqSetError(req, last_error, 0);
         if (conf.debug)
             log(`::: ${path} (Error: ${last_error})`);
     }
-    finally {
-        free_buffers.forEach(ptr => c4w._free(ptr));
-    }
 }

package/index.d.ts

@@ -20,12 +20,19 @@
  *
  * SPDX-License-Identifier: MIT
  */
-import { Storage as C4Storage } from "./wasm.js";
+import { type Storage as C4Storage } from './runtime.js';
 import { ProviderRpcError, RequestArguments, Cache, Config as C4Config, DataRequest, MethodType as C4MethodType, ProviderMessage, ProverMode } from './types.js';
 import { EthSubscribeSubscriptionType, EthNewFilterType } from './subscriptionManager.js';
 import Strategy from './strategy.js';
 export { Strategy };
-export { set_wasm_url, decode_proof } from "./wasm.js";
+export { set_wasm_url } from "./wasm.js";
+export { getRuntime, type C4Runtime, type RuntimeStatus } from './runtime.js';
+/**
+ * Decodes a serialized proof into its JSON representation using the active runtime.
+ * @param proof The proof bytes
+ * @return The decoded proof as JSON
+ */
+export declare function decode_proof(proof: Uint8Array): Promise<any>;
 export { ProviderRpcError, RequestArguments, Cache, C4Config, DataRequest, C4MethodType as MethodType, ProviderMessage, EthSubscribeSubscriptionType, EthNewFilterType, ProverMode };
 export { TransactionVerifier, PrototypeProtection } from './transactionVerifier.js';
 export default class C4Client {

package/index.js

@@ -20,8 +20,8 @@
  *
  * SPDX-License-Identifier: MIT
  */
-// Import the Emscripten-generated module
-import { as_bytes, as_char_ptr, as_json, copy_to_c, getC4w } from "./wasm.js";
+// Runtime abstraction: WASM (browser/default) or native addon (Node.js entry)
+import { getRuntime } from './runtime.js';
 import { EventEmitter } from './eventEmitter.js';
 import { ConnectionState } from './connectionState.js';
 import { ProviderRpcError, MethodType as C4MethodType } from './types.js';
@@ -32,7 +32,17 @@ import { TransactionVerifier, PrototypeProtection } from './transactionVerifier.
 import { fetch_rpc, handle_request } from './http.js';
 export { Strategy };
 // Public helper for controlling WASM loading behavior in Node/bundlers.
-export { set_wasm_url, decode_proof } from "./wasm.js";
+export { set_wasm_url } from "./wasm.js";
+// Runtime introspection (e.g. to check whether the native addon is active in Node).
+export { getRuntime } from './runtime.js';
+/**
+ * Decodes a serialized proof into its JSON representation using the active runtime.
+ * @param proof The proof bytes
+ * @return The decoded proof as JSON
+ */
+export async function decode_proof(proof) {
+    return (await getRuntime()).decodeProof(proof);
+}
 // Re-export types needed by consumers of the C4Client module
 export { ProviderRpcError, C4MethodType as MethodType };
 // Re-export transaction verification utilities
@@ -126,12 +136,9 @@ class C4Client {
      * @returns The method type
      */
     async getMethodSupport(method, args) {
-        const c4w = await getC4w();
-        const free_buffers = [];
+        const runtime = await getRuntime();
         const paramsStr = args ? JSON.stringify(args) : null;
-        const method_type = c4w._c4w_get_method_type(BigInt(this.config.chainId), as_char_ptr(method, c4w, free_buffers), paramsStr ? as_char_ptr(paramsStr, c4w, free_buffers) : 0, this.verify_flags);
-        free_buffers.forEach(ptr => c4w._free(ptr));
-        return method_type;
+        return runtime.getMethodType(BigInt(this.config.chainId), method, paramsStr, this.verify_flags);
     }
     /**
      * Creates a proof for the given method and arguments.
@@ -140,30 +147,27 @@ class C4Client {
      * @returns The proof
      */
     async createProof(method, args) {
-        const c4w = await getC4w();
-        const free_buffers = [];
-        let ctx = 0;
+        const runtime = await getRuntime();
+        let ctx = null;
         try {
-            // Call the C function
-            ctx = c4w._c4w_create_proof_ctx(as_char_ptr(method, c4w, free_buffers), as_char_ptr(JSON.stringify(args), c4w, free_buffers), BigInt(this.config.chainId), this.flags);
+            ctx = runtime.createProverCtx(method, JSON.stringify(args), BigInt(this.config.chainId), this.flags);
             while (true) {
-                const state = as_json(c4w._c4w_execute_proof_ctx(ctx), c4w, true);
+                const state = runtime.executeProverCtx(ctx);
                 switch (state.status) {
                     case "success":
-                        return as_bytes(state.result, state.result_len, c4w);
+                        return state.result;
                     case "error":
                         throw new Error(state.error);
                     case "pending": {
-                        await Promise.all(state.requests.map((req) => handle_request(req, this.config)));
+                        await Promise.all(state.requests.map((req) => handle_request(runtime, req, this.config)));
                         break;
                     }
                 }
             }
         }
         finally {
-            free_buffers.forEach(ptr => c4w._free(ptr));
             if (ctx)
-                c4w._c4w_free_proof_ctx(ctx);
+                runtime.freeProverCtx(ctx);
         }
     }
     /**
@@ -174,20 +178,12 @@ class C4Client {
      * @returns The result
      */
     async verifyProof(method, args, proof) {
-        const c4w = await getC4w();
-        const free_buffers = [];
-        let ctx = 0;
+        const runtime = await getRuntime();
+        let ctx = null;
         try {
-            // Call the C function
-            const checkpoint_ptr = this.config.trusted_checkpoint
-                ? as_char_ptr(this.config.trusted_checkpoint, c4w, free_buffers)
-                : 0;
-            const witness_keys_ptr = this.config.checkpoint_witness_keys
-                ? as_char_ptr(this.config.checkpoint_witness_keys, c4w, free_buffers)
-                : 0;
-            ctx = c4w._c4w_create_verify_ctx(copy_to_c(proof, c4w, free_buffers), proof.length, as_char_ptr(method, c4w, free_buffers), as_char_ptr(JSON.stringify(args), c4w, free_buffers), BigInt(this.config.chainId), checkpoint_ptr, witness_keys_ptr, this.verify_flags, this.get_min_latest_block_ts());
+            ctx = runtime.createVerifyCtx(proof, method, JSON.stringify(args), BigInt(this.config.chainId), this.config.trusted_checkpoint || null, this.config.checkpoint_witness_keys || null, this.verify_flags, this.get_min_latest_block_ts());
             while (true) {
-                const state = as_json(c4w._c4w_verify_proof(ctx), c4w, true);
+                const state = runtime.verifyProof(ctx);
                 switch (state.status) {
                     case "success":
                         return state.result;
@@ -196,16 +192,15 @@ class C4Client {
                     case "error":
                         throw new Error(state.error);
                     case "pending": {
-                        await Promise.all(state.requests.map((req) => handle_request(req, this.config)));
+                        await Promise.all(state.requests.map((req) => handle_request(runtime, req, this.config)));
                         break;
                     }
                 }
             }
         }
         finally {
-            free_buffers.forEach(ptr => c4w._free(ptr));
             if (ctx)
-                c4w._c4w_free_verify_ctx(ctx);
+                runtime.freeVerifyCtx(ctx);
         }
     }
     /**
@@ -227,9 +222,8 @@ class C4Client {
             method_type = await this.getMethodSupport(method, args);
         if (method_type === C4MethodType.PROOFABLE && this.config.verify && !this.config.verify(method, args))
             return await fetch_rpc(this.config.rpcs, { method, params: args }, false, this.config.fetch);
-        const c4w = await getC4w();
-        const free_buffers = [];
-        let ctx = 0;
+        const runtime = await getRuntime();
+        let ctx = null;
         try {
             const prover_mode_map = { local: 0, remote: 1, hybrid: 2, proxy: 3, light_client: 4 };
             const resolved_mode = this.config.prover_mode ?? (this.config.prover?.length ? 'remote' : 'local');
@@ -237,19 +231,16 @@ class C4Client {
             let prover_flags = this.flags;
             if (this.config.zk_proof)
                 prover_flags |= (1 << 7);
-            ctx = c4w._c4w_create_rpc_ctx(as_char_ptr(method, c4w, free_buffers), as_char_ptr(JSON.stringify(args || []), c4w, free_buffers), BigInt(this.config.chainId), prover_flags, this.verify_flags, native_mode);
-            if (resolved_mode === 'proxy') {
-                const rpc_csv = this.config.rpcs.join(',');
-                const beacon_csv = this.config.beacon_apis.join(',');
-                c4w._c4w_rpc_ctx_set_proxy_urls(ctx, as_char_ptr(rpc_csv, c4w, free_buffers), as_char_ptr(beacon_csv, c4w, free_buffers));
-            }
+            ctx = runtime.createRpcCtx(method, JSON.stringify(args || []), BigInt(this.config.chainId), prover_flags, this.verify_flags, native_mode);
+            if (resolved_mode === 'proxy')
+                runtime.rpcCtxSetProxyUrls(ctx, this.config.rpcs.join(','), this.config.beacon_apis.join(','));
             if (this.config.trusted_checkpoint)
-                c4w._c4w_set_checkpoint(BigInt(this.config.chainId), as_char_ptr(this.config.trusted_checkpoint, c4w, free_buffers));
+                runtime.setCheckpoint(BigInt(this.config.chainId), this.config.trusted_checkpoint);
             if (this.config.checkpoint_witness_keys)
-                c4w._c4w_rpc_ctx_set_witness_keys(ctx, as_char_ptr(this.config.checkpoint_witness_keys, c4w, free_buffers));
-            c4w._c4w_rpc_ctx_set_min_latest_block_ts(ctx, this.get_min_latest_block_ts());
+                runtime.rpcCtxSetWitnessKeys(ctx, this.config.checkpoint_witness_keys);
+            runtime.rpcCtxSetMinLatestBlockTs(ctx, this.get_min_latest_block_ts());
             while (true) {
-                const state = as_json(c4w._c4w_execute_rpc_ctx(ctx), c4w, true);
+                const state = runtime.executeRpcCtx(ctx);
                 switch (state.status) {
                     case "success":
                         return state.result;
@@ -263,20 +254,18 @@ class C4Client {
                         }
                         throw new Error(state.error);
                     case "pending":
-                        await Promise.all(state.requests.map((req) => handle_request(req, this.config)));
+                        await Promise.all(state.requests.map((req) => handle_request(runtime, req, this.config)));
                         break;
                 }
             }
         }
         finally {
-            free_buffers.forEach(ptr => c4w._free(ptr));
             if (ctx)
-                c4w._c4w_free_rpc_ctx(ctx);
+                runtime.freeRpcCtx(ctx);
         }
     }
     static async register_storage(storage) {
-        const c4w = await getC4w();
-        c4w.storage = storage;
+        (await getRuntime()).registerStorage(storage);
     }
     async request(args) {
         if (!this.connectionState.initialConnectionAttempted) {

package/index.node.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+export * from './index.js';
+export { default } from './index.js';

package/index.node.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Node.js entry point (selected via `package.json` conditional exports).
+ *
+ * Uses the native N-API addon when a prebuild for the current platform is
+ * available (blst with platform-optimized assembly, ~10x faster BLS pairing)
+ * and transparently falls back to the WASM build otherwise. Browser bundlers
+ * never see this file.
+ */
+import { setRuntimeProvider } from './runtime.js';
+import { getNodeRuntime } from './runtime_node.js';
+setRuntimeProvider(getNodeRuntime);
+export * from './index.js';
+export { default } from './index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corpus-core/colibri-stateless",
-    "version": "2.0.4",
+    "version": "2.0.5",
     "description": "Colibri is a stateless and trustless ethereum client, which is optimized for the mobile apps or embedded devices, because it does not hols the state, but verifies on demand.",
     "main": "index.js",
     "type": "module",
@@ -8,13 +8,20 @@
     "exports": {
         ".": {
             "types": "./index.d.ts",
+            "browser": "./index.js",
+            "node": {
+                "import": "./index.node.js",
+                "require": "./cjs/index.node.js"
+            },
             "import": "./index.js",
             "require": "./cjs/index.js"
-        }
+        },
+        "./package.json": "./package.json"
     },
     "scripts": {
         "test": "npm run test:node && npm run test:webpack",
-        "test:node": "node --test test/rpc.test.mjs test/cjs_bridge.test.mjs",
+        "test:node": "node --test test/rpc.test.mjs test/cjs_bridge.test.mjs test/runtime_selection.test.mjs",
+        "test:node:native": "node --test test/native.test.mjs",
         "test:integration": "C4_RUN_INTEGRATION=1 node --test test/integration.test.mjs",
         "test:ccip": "C4_RUN_INTEGRATION=1 node --test test/ens_ccip.test.mjs",
         "test:webpack": "npm run webpack:install && npm run webpack:build",
@@ -57,6 +64,9 @@
     "devDependencies": {
         "ethers": "^6.16.0"
     },
+    "overrides": {
+        "ws": "^8.21.3"
+    },
     "publishConfig": {
         "access": "public"
     }