@corpus-core/colibri-stateless 0.1.17 → 0.1.20

package/index.d.ts

@@ -4,6 +4,10 @@ export interface Cache {
     get(req: DataRequest): Uint8Array | undefined;
     set(req: DataRequest, data: Uint8Array): void;
 }
+interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
 export interface Config {
     chainId: number;
     beacon_apis: string[];
@@ -25,13 +29,51 @@ export interface DataRequest {
     payload: any;
     req_ptr: number;
 }
+export declare enum MethodType {
+    PROOFABLE = 1,
+    UNPROOFABLE = 2,
+    NOT_SUPPORTED = 3,
+    LOCAL = 4
+}
 export declare function handle_request(req: DataRequest, conf: Config): Promise<void>;
 export default class C4Client {
     config: Config;
     constructor(config?: Partial<Config>);
     private get flags();
+    /**
+     * checks, whether the rpc-method is supported or proofable.
+     * @param method - The method to check
+     * @returns The method type
+     */
+    getMethodSupport(method: string): Promise<MethodType>;
+    /**
+     * creates a proof for the given method and arguments
+     * @param method - The method to create a proof for
+     * @param args - The arguments to create a proof for
+     * @returns The proof
+     */
     createProof(method: string, args: any[]): Promise<Uint8Array>;
+    /**
+     * verifies a proof for the given method and arguments
+     * @param method - The method to verify the proof for
+     * @param args - The arguments to verify the proof for
+     * @param proof - The proof to verify
+     * @returns The result
+     */
     verifyProof(method: string, args: any[], proof: Uint8Array): Promise<any>;
+    /**
+     * executes a rpc-method, which includes
+     * -creating or fetching the proof
+     * -verifying the proof
+     * -returning the result
+     * @param method - The method to execute
+     * @param args - The arguments to execute the method with
+     * @returns The result
+     */
     rpc(method: string, args: any[]): Promise<any>;
     static register_storage(storage: C4Storage): Promise<void>;
+    request(args: RequestArguments): Promise<any>;
+    on(event: string, callback: (data: any) => void): void;
+    removeListener(event: string, callback: (data: any) => void): void;
 }
+export {};

package/index.js

@@ -1,5 +1,12 @@
 // Import the Emscripten-generated module
 import { getC4w, as_char_ptr, as_json, as_bytes, copy_to_c } from "./wasm.js";
+export var MethodType;
+(function (MethodType) {
+    MethodType[MethodType["PROOFABLE"] = 1] = "PROOFABLE";
+    MethodType[MethodType["UNPROOFABLE"] = 2] = "UNPROOFABLE";
+    MethodType[MethodType["NOT_SUPPORTED"] = 3] = "NOT_SUPPORTED";
+    MethodType[MethodType["LOCAL"] = 4] = "LOCAL";
+})(MethodType || (MethodType = {}));
 async function initialize_storage(conf) {
     // TODO handle trusted_block_hashes
     const c4w = await getC4w();
@@ -97,13 +104,32 @@ export default class C4Client {
                 chainId: 1, // Default chainId
                 beacon_apis: ["https://lodestar-mainnet.chainsafe.io"], // Default beacon API
                 rpcs: ["https://rpc.ankr.com/eth"], // Default RPC
-                trusted_block_hashes: []
+                trusted_block_hashes: [],
+                proofer: ["https://c4.incubed.net"],
             }, ...config
         };
     }
     get flags() {
         return this.config.include_code ? 1 : 0;
     }
+    /**
+     * checks, whether the rpc-method is supported or proofable.
+     * @param method - The method to check
+     * @returns The method type
+     */
+    async getMethodSupport(method) {
+        const c4w = await getC4w();
+        const free_buffers = [];
+        const method_type = c4w._c4w_get_method_type(BigInt(this.config.chainId), as_char_ptr(method, c4w, free_buffers));
+        free_buffers.forEach(ptr => c4w._free(ptr));
+        return method_type;
+    }
+    /**
+     * creates a proof for the given method and arguments
+     * @param method - The method to create a proof for
+     * @param args - The arguments to create a proof for
+     * @returns The proof
+     */
     async createProof(method, args) {
         const c4w = await getC4w();
         const free_buffers = [];
@@ -131,6 +157,13 @@ export default class C4Client {
                 c4w._c4w_free_proof_ctx(ctx);
         }
     }
+    /**
+     * verifies a proof for the given method and arguments
+     * @param method - The method to verify the proof for
+     * @param args - The arguments to verify the proof for
+     * @param proof - The proof to verify
+     * @returns The result
+     */
     async verifyProof(method, args, proof) {
         const c4w = await getC4w();
         const free_buffers = [];
@@ -158,17 +191,46 @@ export default class C4Client {
                 c4w._c4w_free_verify_ctx(ctx);
         }
     }
+    /**
+     * executes a rpc-method, which includes
+     * -creating or fetching the proof
+     * -verifying the proof
+     * -returning the result
+     * @param method - The method to execute
+     * @param args - The arguments to execute the method with
+     * @returns The result
+     */
     async rpc(method, args) {
-        // skip verify
-        if (this.config.verify && !this.config.verify(method, args))
-            return await fetch_rpc(this.config.rpcs, method, args, false);
-        let proof = this.config.proofer && this.config.proofer.length
-            ? await fetch_rpc(this.config.proofer, method, args, true)
-            : await this.createProof(method, args);
+        const method_type = await this.getMethodSupport(method);
+        let proof = new Uint8Array();
+        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);
+                proof = this.config.proofer && this.config.proofer.length
+                    ? await fetch_rpc(this.config.proofer, method, args, true)
+                    : await this.createProof(method, args);
+                break;
+            }
+            case MethodType.UNPROOFABLE:
+                return await fetch_rpc(this.config.rpcs, method, args, false);
+            case MethodType.NOT_SUPPORTED:
+                throw new Error(`Method ${method} is not supported`);
+            case MethodType.LOCAL:
+                break;
+        }
         return this.verifyProof(method, args, proof);
     }
     static async register_storage(storage) {
         const c4w = await getC4w();
         c4w.storage = storage;
     }
+    async request(args) {
+        const res = await this.rpc(args.method, args.params || []);
+        return res;
+    }
+    on(event, callback) {
+    }
+    removeListener(event, callback) {
+    }
 }

package/package.json

@@ -1,9 +1,17 @@
 {
     "name": "@corpus-core/colibri-stateless",
-    "version": "0.1.17",
+    "version": "0.1.20",
     "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",
-    "scripts": {},
+    "type": "module",
+    "scripts": {
+        "test": "npm run test:node && npm run test:webpack",
+        "test:node": "node --test test/*.test.mjs",
+        "test:webpack": "npm run webpack:install && npm run webpack:build",
+        "webpack:install": "cd webpack && npm install --legacy-peer-deps",
+        "webpack:build": "cd webpack && npm run build",
+        "webpack:start": "cd webpack && npm run start"
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/corpus-core/c4.git"

package/wasm.d.ts

@@ -5,6 +5,7 @@ export interface C4W {
     _c4w_get_pending_data_request: (proofCtx: number) => number;
     _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_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;

package/wasm.js

@@ -84,7 +84,14 @@ export function as_json(ptr, c4w, free_ptrs) {
         else
             c4w._free(ptr);
     }
-    return JSON.parse(str);
+    try {
+        return JSON.parse(str);
+    }
+    catch (e) {
+        console.error(e);
+        console.error(str);
+        return null;
+    }
 }
 export function as_bytes(ptr, len, c4w, free_ptrs) {
     const bytes = new Uint8Array(len);