@corpus-core/colibri-stateless 0.2.5 → 0.3.0

package/connectionState.d.ts

@@ -11,8 +11,7 @@ export declare class ConnectionState {
     private config;
     private fetchRpcChainIdCallback;
     private eventEmitter;
-    private formatChainIdFunc;
-    constructor(config: ConnectionStateConfig, fetchRpcChainIdCallback: () => Promise<any>, eventEmitter: EventEmitter, formatChainIdFunc: (value: any, debug?: boolean) => string | null);
+    constructor(config: ConnectionStateConfig, fetchRpcChainIdCallback: () => Promise<any>, eventEmitter: EventEmitter);
     get isConnected(): boolean;
     get currentChainId(): string | null;
     get initialConnectionAttempted(): boolean;

package/connectionState.js

@@ -1,4 +1,27 @@
 import { ProviderRpcError } from './types.js';
+// Helper function for chain ID formatting - intentionally kept separate for now
+// If this function is *only* used by ConnectionState, it could be moved inside or made local.
+// However, C4Client.rpc also uses it for its LOCAL eth_chainId case, so it might need broader access.
+// For this refactoring, we assume it's passed in or globally accessible if needed elsewhere.
+// Helper function for chain ID formatting (can be used by ConnectionManager and C4Client)
+function formatChainId(value, debug) {
+    if (typeof value === 'string') {
+        if (value.startsWith('0x')) {
+            return value.toLowerCase();
+        }
+        const parsed = parseInt(value, 10);
+        if (!isNaN(parsed)) {
+            return '0x' + parsed.toString(16);
+        }
+    }
+    else if (typeof value === 'number') {
+        return '0x' + value.toString(16);
+    }
+    if (debug) {
+        console.warn('Could not format chainId:', value);
+    }
+    return null;
+}
 export class ConnectionState {
     _isConnected = false;
     _currentChainId = null;
@@ -6,13 +29,11 @@ export class ConnectionState {
     config;
     fetchRpcChainIdCallback;
     eventEmitter;
-    formatChainIdFunc;
-    constructor(config, fetchRpcChainIdCallback, eventEmitter, formatChainIdFunc) {
+    constructor(config, fetchRpcChainIdCallback, eventEmitter) {
         this.config = config;
         this.fetchRpcChainIdCallback = fetchRpcChainIdCallback;
         this.eventEmitter = eventEmitter;
-        this.formatChainIdFunc = formatChainIdFunc;
-        this._currentChainId = this.formatChainIdFunc(this.config.chainId, this.config.debug);
+        this._currentChainId = formatChainId(this.config.chainId, this.config.debug);
     }
     get isConnected() {
         return this._isConnected;
@@ -32,7 +53,7 @@ export class ConnectionState {
         }
         try {
             const result = await this.fetchRpcChainIdCallback();
-            const formattedChainId = this.formatChainIdFunc(result, this.config.debug);
+            const formattedChainId = formatChainId(result, this.config.debug);
             if (formattedChainId) {
                 this._isConnected = true;
                 this._currentChainId = formattedChainId;
@@ -64,12 +85,12 @@ export class ConnectionState {
             const updateAndEmitConnect = async () => {
                 let determinedChainId = null;
                 if (requestMethod === 'eth_chainId') {
-                    determinedChainId = this.formatChainIdFunc(requestResult, this.config.debug);
+                    determinedChainId = formatChainId(requestResult, this.config.debug);
                 }
                 else {
                     try {
                         const chainIdResult = await this.fetchRpcChainIdCallback();
-                        determinedChainId = this.formatChainIdFunc(chainIdResult, this.config.debug);
+                        determinedChainId = formatChainId(chainIdResult, this.config.debug);
                     }
                     catch (e) {
                         if (this.config.debug)
@@ -77,7 +98,7 @@ export class ConnectionState {
                         determinedChainId = this._currentChainId;
                     }
                 }
-                this._currentChainId = determinedChainId || this.formatChainIdFunc(this.config.chainId, this.config.debug);
+                this._currentChainId = determinedChainId || formatChainId(this.config.chainId, this.config.debug);
                 this.eventEmitter.emit('connect', { chainId: this._currentChainId });
             };
             updateAndEmitConnect().catch(err => {
@@ -86,7 +107,7 @@ export class ConnectionState {
             });
         }
         else if (requestMethod === 'eth_chainId') {
-            const newChainId = this.formatChainIdFunc(requestResult, this.config.debug);
+            const newChainId = formatChainId(requestResult, this.config.debug);
             if (newChainId && this._currentChainId !== newChainId) {
                 const oldChainId = this._currentChainId;
                 this._currentChainId = newChainId;

package/index.d.ts

@@ -1,6 +1,8 @@
 import { Storage as C4Storage } from "./wasm.js";
 import { ProviderRpcError, RequestArguments, Cache, Config as C4Config, DataRequest, MethodType as C4MethodType, ProviderMessage } from './types.js';
 import { EthSubscribeSubscriptionType, EthNewFilterType } from './subscriptionManager.js';
+import Strategy from './strategy.js';
+export { Strategy };
 export { ProviderRpcError, RequestArguments, Cache, C4Config, DataRequest, C4MethodType as MethodType, ProviderMessage, EthSubscribeSubscriptionType, EthNewFilterType };
 export declare function handle_request(req: DataRequest, conf: C4Config): Promise<void>;
 export default class C4Client {
@@ -41,7 +43,7 @@ export default class C4Client {
      * @param args - The arguments to execute the method with
      * @returns The result
      */
-    rpc(method: string, args: any[]): Promise<any>;
+    rpc(method: string, args: any[], method_type?: C4MethodType): Promise<any>;
     static register_storage(storage: C4Storage): Promise<void>;
     request(args: RequestArguments): Promise<unknown>;
     on(event: string, callback: (data: any) => void): this;

package/index.js

@@ -4,31 +4,13 @@ import { EventEmitter } from './eventEmitter.js';
 import { ConnectionState } from './connectionState.js';
 import { ProviderRpcError, MethodType as C4MethodType } from './types.js';
 import { SubscriptionManager } from './subscriptionManager.js';
+import Strategy from './strategy.js';
+export { Strategy };
 // Re-export types needed by consumers of the C4Client module
 export { ProviderRpcError, C4MethodType as MethodType };
-// Helper function for chain ID formatting (can be used by ConnectionManager and C4Client)
-function formatChainId(value, debug) {
-    if (typeof value === 'string') {
-        if (value.startsWith('0x')) {
-            return value.toLowerCase();
-        }
-        const parsed = parseInt(value, 10);
-        if (!isNaN(parsed)) {
-            return '0x' + parsed.toString(16);
-        }
-    }
-    else if (typeof value === 'number') {
-        return '0x' + value.toString(16);
-    }
-    if (debug) {
-        console.warn('Could not format chainId:', value);
-    }
-    return null;
-}
 async function fetch_rpc(urls, payload, as_proof = false) {
     let last_error = "All nodes failed";
     for (const url of urls) {
-        console.log({ url, payload });
         const response = await fetch(url, {
             method: 'POST',
             body: JSON.stringify({ id: 1, jsonrpc: "2.0", ...payload }),
@@ -124,34 +106,55 @@ function check_trusted_blockhashes(trusted_block_hashes, c4w, chainId) {
     c4w._free(ptr);
     trusted_block_hashes.length = 0;
 }
+const default_config = {
+    '1': {
+        alias: ["mainnet", "eth", "0x1"],
+        beacon_apis: ["https://lodestar-mainnet.chainsafe.io"],
+        rpcs: ["https://rpc.ankr.com/eth"],
+        proofer: ["https://mainnet.colibri-proof.tech"],
+    },
+    '100': {
+        alias: ["gnosis", "xdai", "0x64"],
+        beacon_apis: ["https://gnosis.colibri-proof.tech"],
+        rpcs: ["https://rpc.ankr.com/gnosis"],
+        proofer: ["https://gnosis.colibri-proof.tech"],
+    },
+};
+function get_chain_id(chain_id) {
+    const chain_id_num = parseInt(chain_id);
+    if (!isNaN(chain_id_num))
+        return chain_id_num;
+    for (const chain in default_config) {
+        if (default_config[chain].alias.includes(chain_id))
+            return parseInt(chain);
+    }
+    throw new Error("Invalid chain id: " + chain_id);
+}
 export default class C4Client {
     config;
     eventEmitter;
     connectionState;
     subscriptionManager;
     constructor(config) {
+        const chainId = config?.chainId ? get_chain_id(config?.chainId + '') : 1;
+        const chain_config = { ...default_config[chainId + ''] };
         this.config = {
-            // Defaults including pollingInterval if not provided
-            chainId: 1,
-            beacon_apis: ["https://lodestar-mainnet.chainsafe.io"],
-            rpcs: ["https://rpc.ankr.com/eth"],
             trusted_block_hashes: [],
-            proofer: ["https://mainnet.colibri-proof.tech"],
             pollingInterval: 12000, // Default here, can be overridden by user config
-            // ... other defaults like debug: false etc. might be useful
-            ...config // User config overrides defaults
+            rpcs: chain_config.rpcs || [],
+            beacon_apis: chain_config.beacon_apis || [],
+            proofer: chain_config.proofer || [],
+            ...config, // User config overrides defaults
+            chainId,
         };
+        if (!this.config.warningHandler)
+            this.config.warningHandler = async (req, message) => console.warn(message);
+        if (!this.config.proofStrategy)
+            this.config.proofStrategy = Strategy.VerifyIfPossible;
         this.eventEmitter = new EventEmitter();
-        // Specific callback for ConnectionState for eth_chainId
-        const fetchChainIdForConnectionState = async () => this.rpc('eth_chainId', []);
-        // General RpcCaller for SubscriptionManager
-        const generalRpcCaller = async (method, params) => {
-            return this.rpc(method, params);
-        };
-        this.connectionState = new ConnectionState({ chainId: this.config.chainId, debug: this.config.debug }, fetchChainIdForConnectionState, // Use the specific callback
-        this.eventEmitter, formatChainId);
-        this.subscriptionManager = new SubscriptionManager(generalRpcCaller, // Use the general rpc caller
-        this.eventEmitter, { debug: this.config.debug, pollingInterval: this.config.pollingInterval });
+        this.connectionState = new ConnectionState({ chainId: parseInt(this.config.chainId + ''), debug: this.config.debug }, async () => this.rpc('eth_chainId', [], C4MethodType.LOCAL), // Use the specific callback
+        this.eventEmitter);
+        this.subscriptionManager = new SubscriptionManager(async (method, params) => this.rpc(method, params), this.eventEmitter, { debug: this.config.debug, pollingInterval: this.config.pollingInterval });
     }
     async getProoferConfig() {
         const c4w = await getC4w();
@@ -221,7 +224,7 @@ export default class C4Client {
         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);
+                check_trusted_blockhashes(this.config.trusted_block_hashes, c4w, parseInt(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) {
@@ -253,10 +256,11 @@ export default class C4Client {
      * @param args - The arguments to execute the method with
      * @returns The result
      */
-    async rpc(method, args) {
+    async rpc(method, args, method_type) {
         // eth_subscribe and eth_unsubscribe are handled by C4Client.request before this method is called.
         // This rpc method is for the underlying data fetching/proving.
-        const method_type = await this.getMethodSupport(method);
+        if (method_type === undefined)
+            method_type = await this.getMethodSupport(method);
         switch (method_type) {
             case C4MethodType.PROOFABLE: {
                 if (this.config.verify && !this.config.verify(method, args)) {
@@ -293,9 +297,13 @@ export default class C4Client {
             // If handleRequest returns a Promise, it means it's handling the request
             return subscriptionResult;
         }
+        let conf = this.config.chains[this.config.chainId];
+        let strategy = conf?.proofStrategy || this.config.proofStrategy;
         // If not handled by SubscriptionManager, proceed with standard RPC call logic
         try {
-            const result = await this.rpc(method, paramsArray);
+            const result = strategy
+                ? await strategy(this, args, this.config, fetch_rpc)
+                : await this.rpc(method, paramsArray);
             this.connectionState.processSuccessfulRequest(method, result);
             return result;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corpus-core/colibri-stateless",
-    "version": "0.2.5",
+    "version": "0.3.0",
     "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/strategy.d.ts

@@ -0,0 +1,10 @@
+import { ColibriClient, RequestArguments, Config, FetchRpc } from './types.js';
+declare function OnlyProofStrategy(client: ColibriClient, req: RequestArguments, config: Config, fetch_rpc: FetchRpc): Promise<any>;
+declare function ProofIfPossibleStrategy(client: ColibriClient, req: RequestArguments, config: Config, fetch_rpc: FetchRpc): Promise<any>;
+declare function WarningStrategy(client: ColibriClient, req: RequestArguments, config: Config, fetch_rpc: FetchRpc): Promise<any>;
+declare const _default: {
+    VerifiedOnly: typeof OnlyProofStrategy;
+    VerifyIfPossible: typeof ProofIfPossibleStrategy;
+    WarningWithFallback: typeof WarningStrategy;
+};
+export default _default;

package/strategy.js

@@ -0,0 +1,90 @@
+import { MethodType } from './types.js';
+function argsToArray(args) {
+    return Array.isArray(args) ? args : (args ? [args] : []);
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (a.constructor !== b.constructor)
+        return false;
+    if (a instanceof Date)
+        return a.getTime() === b.getTime();
+    if (a instanceof RegExp)
+        return a.source === b.source && a.flags === b.flags;
+    if (a instanceof Uint8Array)
+        return a.length === b.length && a.every((value, index) => value === b[index]);
+    if (a instanceof Array)
+        return a.length === b.length && a.every((value, index) => deepEqual(value, b[index]));
+    if (a instanceof Object)
+        return Object.keys(a).every(key => b[key] === undefined || deepEqual(a[key], b[key]));
+    if (a instanceof String)
+        return a.toLowerCase() === b.toLowerCase();
+    if (a instanceof Number)
+        return a.toFixed(10) === b.toFixed(10);
+    if (a instanceof Boolean)
+        return a === b;
+    if (a instanceof BigInt)
+        return a.toString() === b.toString();
+    if (a instanceof Buffer)
+        return a.equals(b);
+    if (a instanceof Map)
+        return a.size === b.size && Array.from(a.entries()).every(([key, value]) => deepEqual(value, b.get(key)));
+    if (a instanceof Set)
+        return a.size === b.size && Array.from(a).every(value => b.has(value));
+    if (a instanceof Date)
+        return a.getTime() === b.getTime();
+    return a == b;
+}
+function fetch_unverified_rpc(config, req, fetch_rpc) {
+    const fallback_provider = config.fallback_provider;
+    if (fallback_provider)
+        return fallback_provider.request(req);
+    let conf = config.chains[config.chainId];
+    let rpcs = conf?.rpcs || config.rpcs;
+    if (!rpcs || !Array.isArray(rpcs) || rpcs.length === 0)
+        throw new Error("No RPC- Endpoint configured");
+    return fetch_rpc(rpcs, req, false);
+}
+function OnlyProofStrategy(client, req, config, fetch_rpc) {
+    return client.rpc(req.method, argsToArray(req.params));
+}
+async function ProofIfPossibleStrategy(client, req, config, fetch_rpc) {
+    const method_type = await client.getMethodSupport(req.method);
+    switch (method_type) {
+        case MethodType.PROOFABLE:
+        case MethodType.LOCAL:
+            return client.rpc(req.method, argsToArray(req.params), method_type);
+        default:
+            return fetch_unverified_rpc(config, req, fetch_rpc);
+    }
+}
+async function WarningStrategy(client, req, config, fetch_rpc) {
+    const method_type = await client.getMethodSupport(req.method);
+    switch (method_type) {
+        case MethodType.LOCAL:
+            return client.rpc(req.method, argsToArray(req.params), method_type);
+        case MethodType.UNPROOFABLE:
+        case MethodType.NOT_SUPPORTED:
+            return fetch_unverified_rpc(config, req, fetch_rpc);
+        case MethodType.PROOFABLE: {
+            const [verified_result, unverified_result] = await Promise.all([
+                client.rpc(req.method, argsToArray(req.params), MethodType.PROOFABLE)
+                    .catch(async (err) => {
+                    await config.warningHandler(req, `[Warning] ${req.method} failed to be verfiy: ${err.message}, falling back to Default`);
+                    return undefined;
+                }),
+                fetch_unverified_rpc(config, req, fetch_rpc)
+            ]);
+            if (verified_result !== undefined && !deepEqual(verified_result, unverified_result))
+                await config.warningHandler(req, `[Warning] ${req.method} does not match the rpc-result`);
+            return unverified_result;
+        }
+    }
+}
+export default {
+    VerifiedOnly: OnlyProofStrategy,
+    VerifyIfPossible: ProofIfPossibleStrategy,
+    WarningWithFallback: WarningStrategy
+};

package/types.d.ts

@@ -4,6 +4,13 @@ export declare class ProviderRpcError extends Error {
     constructor(code: number, message: string, data?: unknown);
     static createError(error: any): ProviderRpcError;
 }
+export interface ColibriClient {
+    rpc(method: string, params: any[], method_type?: MethodType): Promise<any>;
+    getMethodSupport(method: string): Promise<MethodType>;
+}
+export type FetchRpc = (urls: string[], payload: any, as_proof: boolean) => Promise<any>;
+export type ProofStrategy = (client: ColibriClient, req: RequestArguments, config: Config, fetch_rpc: FetchRpc) => Promise<any>;
+export type WarningHandler = (req: RequestArguments, message: string) => Promise<any>;
 export interface RequestArguments {
     readonly method: string;
     readonly params?: readonly unknown[] | object;
@@ -20,17 +27,30 @@ export interface Cache {
     get(req: DataRequest): Uint8Array | undefined;
     set(req: DataRequest, data: Uint8Array): void;
 }
-export interface Config {
-    chainId: number;
+export interface ChainConfig {
     beacon_apis: string[];
     rpcs: string[];
     proofer?: string[];
     trusted_block_hashes: string[];
+    verify?: (method: string, args: any[]) => boolean;
+    pollingInterval?: number;
+    proofStrategy?: ProofStrategy;
+}
+export interface EIP1193Client {
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: string, callback: (data: any) => void): this;
+    removeListener(event: string, callback: (data: any) => void): this;
+}
+export interface Config extends ChainConfig {
+    chainId: number | string;
     cache?: Cache;
     debug?: boolean;
     include_code?: boolean;
-    verify?: (method: string, args: any[]) => boolean;
-    pollingInterval?: number;
+    chains: {
+        [chainId: number]: ChainConfig;
+    };
+    fallback_provider?: EIP1193Client;
+    warningHandler: WarningHandler;
 }
 export interface DataRequest {
     method: string;