@corpus-core/colibri-stateless 0.1.20 → 0.2.1

package/index.d.ts

@@ -39,6 +39,7 @@ export declare function handle_request(req: DataRequest, conf: Config): Promise<
 export default class C4Client {
     config: Config;
     constructor(config?: Partial<Config>);
+    private getProoferConfig;
     private get flags();
     /**
      * checks, whether the rpc-method is supported or proofable.

package/index.js

@@ -1,5 +1,5 @@
 // Import the Emscripten-generated module
-import { getC4w, as_char_ptr, as_json, as_bytes, copy_to_c } from "./wasm.js";
+import { as_bytes, as_char_ptr, as_json, copy_to_c, getC4w } from "./wasm.js";
 export var MethodType;
 (function (MethodType) {
     MethodType[MethodType["PROOFABLE"] = 1] = "PROOFABLE";
@@ -11,12 +11,12 @@ async function initialize_storage(conf) {
     // TODO handle trusted_block_hashes
     const c4w = await getC4w();
 }
-async function fetch_rpc(urls, method, params, as_proof = false) {
+async function fetch_rpc(urls, payload, as_proof = false) {
     let last_error = "All nodes failed";
     for (const url of urls) {
         const response = await fetch(url, {
             method: 'POST',
-            body: JSON.stringify({ id: 1, jsonrpc: "2.0", method, params }),
+            body: JSON.stringify({ id: 1, jsonrpc: "2.0", ...payload }),
             headers: {
                 "Content-Type": "application/json",
                 "Accept": as_proof ? "application/octet-stream" : "application/json"
@@ -44,7 +44,7 @@ function log(msg) {
 }
 export async function handle_request(req, conf) {
     const free_buffers = [];
-    const servers = req.type == "beacon_api" ? conf.beacon_apis : conf.rpcs;
+    const servers = req.type == "beacon_api" ? ((conf.proofer && conf.proofer.length) ? conf.proofer : conf.beacon_apis) : conf.rpcs;
     const c4w = await getC4w();
     let path = (req.type == 'eth_rpc' && req.payload)
         ? `rpc: ${req.payload?.method}(${req.payload?.params.join(',')})`
@@ -96,6 +96,19 @@ export async function handle_request(req, conf) {
     if (conf.debug)
         log(`::: ${path} (Error: ${last_error})`);
 }
+function check_trusted_blockhashes(trusted_block_hashes, c4w, chainId) {
+    const blockhashes = new Uint8Array(32 * trusted_block_hashes.length);
+    for (let i = 0; i < trusted_block_hashes.length; i++) {
+        if (trusted_block_hashes[i].length != 66 || !trusted_block_hashes[i].startsWith("0x"))
+            throw new Error("Invalid trustedblockhash : " + trusted_block_hashes[i]);
+        for (let j = 0; j < 32; j++)
+            blockhashes[i * 32 + j] = parseInt(trusted_block_hashes[i].slice(2 + j * 2, 4 + j * 2), 16);
+    }
+    const ptr = copy_to_c(blockhashes, c4w);
+    c4w._c4w_set_trusted_blockhashes(BigInt(chainId), ptr, blockhashes.length);
+    c4w._free(ptr);
+    trusted_block_hashes.length = 0;
+}
 export default class C4Client {
     config;
     constructor(config) {
@@ -105,10 +118,18 @@ export default class C4Client {
                 beacon_apis: ["https://lodestar-mainnet.chainsafe.io"], // Default beacon API
                 rpcs: ["https://rpc.ankr.com/eth"], // Default RPC
                 trusted_block_hashes: [],
-                proofer: ["https://c4.incubed.net"],
-            }, ...config
+                proofer: ["https://mainnet.colibri-proof.tech"],
+            },
+            ...config
         };
     }
+    async getProoferConfig() {
+        const c4w = await getC4w();
+        if (!c4w.storage)
+            return '0x';
+        const state = c4w.storage.get('state_' + this.config.chainId);
+        return '0x' + (state ? Array.from(state).map(_ => _.toString(16).padStart(2, '0')).join('') : '');
+    }
     get flags() {
         return this.config.include_code ? 1 : 0;
     }
@@ -169,6 +190,8 @@ export default class C4Client {
         const free_buffers = [];
         let ctx = 0;
         try {
+            if (this.config.trusted_block_hashes && this.config.trusted_block_hashes.length > 0)
+                check_trusted_blockhashes(this.config.trusted_block_hashes, c4w, this.config.chainId);
             // Call the C function
             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));
             while (true) {
@@ -206,14 +229,14 @@ export default class C4Client {
         switch (method_type) {
             case MethodType.PROOFABLE: {
                 if (this.config.verify && !this.config.verify(method, args))
-                    return await fetch_rpc(this.config.rpcs, method, args, false);
+                    return await fetch_rpc(this.config.rpcs, { method, params: args }, false);
                 proof = this.config.proofer && this.config.proofer.length
-                    ? await fetch_rpc(this.config.proofer, method, args, true)
+                    ? await fetch_rpc(this.config.proofer, { method, params: args, c4: await this.getProoferConfig() }, true)
                     : await this.createProof(method, args);
                 break;
             }
             case MethodType.UNPROOFABLE:
-                return await fetch_rpc(this.config.rpcs, method, args, false);
+                return await fetch_rpc(this.config.rpcs, { method, params: args }, false);
             case MethodType.NOT_SUPPORTED:
                 throw new Error(`Method ${method} is not supported`);
             case MethodType.LOCAL:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corpus-core/colibri-stateless",
-    "version": "0.1.20",
+    "version": "0.2.1",
     "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",

package/wasm.d.ts

@@ -6,6 +6,7 @@ export interface C4W {
     _c4w_req_set_response: (reqPtr: number, data: number, len: number, node_index: number) => void;
     _c4w_req_set_error: (reqPtr: number, error: number, node_index: number) => void;
     _c4w_get_method_type: (chain_id: bigint, method: number) => number;
+    _c4w_set_trusted_blockhashes: (chain_id: bigint, blockhashes: number, len: number) => void;
     _c4w_create_verify_ctx: (proof: number, proof_len: number, method: number, args: number, chain_id: bigint) => number;
     _c4w_free_verify_ctx: (verifyCtx: number) => void;
     _c4w_verify_proof: (verifyCtx: number) => number;