@corpus-core/colibri-stateless 0.2.1 → 0.2.3

package/connectionState.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from './eventEmitter.js';
+import { ProviderRpcError } from './types.js';
+interface ConnectionStateConfig {
+    chainId: number;
+    debug?: boolean;
+}
+export declare class ConnectionState {
+    private _isConnected;
+    private _currentChainId;
+    private _initialConnectionAttempted;
+    private config;
+    private fetchRpcChainIdCallback;
+    private eventEmitter;
+    private formatChainIdFunc;
+    constructor(config: ConnectionStateConfig, fetchRpcChainIdCallback: () => Promise<any>, eventEmitter: EventEmitter, formatChainIdFunc: (value: any, debug?: boolean) => string | null);
+    get isConnected(): boolean;
+    get currentChainId(): string | null;
+    get initialConnectionAttempted(): boolean;
+    attemptInitialConnection(): Promise<void>;
+    processSuccessfulRequest(requestMethod: string, requestResult: any): void;
+    processFailedRequest(error: ProviderRpcError): void;
+}
+export {};

package/connectionState.js

@@ -0,0 +1,109 @@
+import { ProviderRpcError } from './types.js';
+export class ConnectionState {
+    _isConnected = false;
+    _currentChainId = null;
+    _initialConnectionAttempted = false;
+    config;
+    fetchRpcChainIdCallback;
+    eventEmitter;
+    formatChainIdFunc;
+    constructor(config, fetchRpcChainIdCallback, eventEmitter, formatChainIdFunc) {
+        this.config = config;
+        this.fetchRpcChainIdCallback = fetchRpcChainIdCallback;
+        this.eventEmitter = eventEmitter;
+        this.formatChainIdFunc = formatChainIdFunc;
+        this._currentChainId = this.formatChainIdFunc(this.config.chainId, this.config.debug);
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    get currentChainId() {
+        return this._currentChainId;
+    }
+    get initialConnectionAttempted() {
+        return this._initialConnectionAttempted;
+    }
+    async attemptInitialConnection() {
+        if (this._initialConnectionAttempted)
+            return;
+        this._initialConnectionAttempted = true;
+        if (this.config.debug) {
+            console.log('[CS] Attempting initial connection...');
+        }
+        try {
+            const result = await this.fetchRpcChainIdCallback();
+            const formattedChainId = this.formatChainIdFunc(result, this.config.debug);
+            if (formattedChainId) {
+                this._isConnected = true;
+                this._currentChainId = formattedChainId;
+                if (this.config.debug) {
+                    console.log('[CS] Initial connection successful. ChainId:', this._currentChainId);
+                }
+                this.eventEmitter.emit('connect', { chainId: this._currentChainId });
+            }
+            else {
+                this._isConnected = false;
+                if (this.config.debug) {
+                    console.warn('[CS] Initial eth_chainId did not return a valid format or was null:', result, ". Client remains disconnected but uses configured chainId.");
+                }
+            }
+        }
+        catch (error) {
+            this._isConnected = false;
+            if (this.config.debug) {
+                console.error('[CS] Initial connection check failed:', error);
+                if (error instanceof ProviderRpcError) {
+                    console.error('[CS] ProviderRpcError during initial connection check:', error.code, error.message);
+                }
+            }
+        }
+    }
+    processSuccessfulRequest(requestMethod, requestResult) {
+        if (!this._isConnected) {
+            this._isConnected = true;
+            const updateAndEmitConnect = async () => {
+                let determinedChainId = null;
+                if (requestMethod === 'eth_chainId') {
+                    determinedChainId = this.formatChainIdFunc(requestResult, this.config.debug);
+                }
+                else {
+                    try {
+                        const chainIdResult = await this.fetchRpcChainIdCallback();
+                        determinedChainId = this.formatChainIdFunc(chainIdResult, this.config.debug);
+                    }
+                    catch (e) {
+                        if (this.config.debug)
+                            console.warn('[CS] Failed to fetch chainId for connect event, using current _currentChainId as fallback.', e);
+                        determinedChainId = this._currentChainId;
+                    }
+                }
+                this._currentChainId = determinedChainId || this.formatChainIdFunc(this.config.chainId, this.config.debug);
+                this.eventEmitter.emit('connect', { chainId: this._currentChainId });
+            };
+            updateAndEmitConnect().catch(err => {
+                if (this.config.debug)
+                    console.error("[CS] Error during background processing for connect event:", err);
+            });
+        }
+        else if (requestMethod === 'eth_chainId') {
+            const newChainId = this.formatChainIdFunc(requestResult, this.config.debug);
+            if (newChainId && this._currentChainId !== newChainId) {
+                const oldChainId = this._currentChainId;
+                this._currentChainId = newChainId;
+                if (this.config.debug) {
+                    console.log('[CS] ChainId changed from', oldChainId, 'to', this._currentChainId);
+                }
+                this.eventEmitter.emit('chainChanged', this._currentChainId);
+            }
+        }
+    }
+    processFailedRequest(error) {
+        if (error.code === 4900 && this._isConnected) {
+            this._isConnected = false;
+            if (this.config.debug) {
+                console.log('[CS] Disconnected due to error 4900.');
+            }
+            this.eventEmitter.emit('disconnect', error);
+        }
+    }
+}

package/eventEmitter.d.ts

@@ -0,0 +1,6 @@
+export declare class EventEmitter {
+    private listeners;
+    on(event: string, callback: (data: any) => void): this;
+    removeListener(event: string, callback: (data: any) => void): this;
+    emit(event: string, data?: any): void;
+}

package/eventEmitter.js

@@ -0,0 +1,28 @@
+export class EventEmitter {
+    listeners = {};
+    on(event, callback) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+        return this;
+    }
+    removeListener(event, callback) {
+        if (this.listeners[event]) {
+            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+        }
+        return this;
+    }
+    emit(event, data) {
+        if (this.listeners[event]) {
+            this.listeners[event].forEach(listener => {
+                try {
+                    listener(data);
+                }
+                catch (e) {
+                    console.error(`Error in event listener for ${event}:`, e);
+                }
+            });
+        }
+    }
+}

package/index.d.ts

@@ -1,44 +1,14 @@
 import { Storage as C4Storage } from "./wasm.js";
-export interface Cache {
-    cacheable(req: DataRequest): boolean;
-    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[];
-    rpcs: string[];
-    proofer?: string[];
-    trusted_block_hashes: string[];
-    cache?: Cache;
-    debug?: boolean;
-    include_code?: boolean;
-    verify?: (method: string, args: any[]) => boolean;
-}
-export interface DataRequest {
-    method: string;
-    chain_id: number;
-    encoding: string;
-    type: string;
-    exclude_mask: number;
-    url: string;
-    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>;
+import { ProviderRpcError, RequestArguments, Cache, Config as C4Config, DataRequest, MethodType as C4MethodType, ProviderMessage } from './types.js';
+import { EthSubscribeSubscriptionType, EthNewFilterType } from './subscriptionManager.js';
+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 {
-    config: Config;
-    constructor(config?: Partial<Config>);
+    config: C4Config;
+    private eventEmitter;
+    private connectionState;
+    private subscriptionManager;
+    constructor(config?: Partial<C4Config>);
     private getProoferConfig;
     private get flags();
     /**
@@ -46,7 +16,7 @@ export default class C4Client {
      * @param method - The method to check
      * @returns The method type
      */
-    getMethodSupport(method: string): Promise<MethodType>;
+    getMethodSupport(method: string): Promise<C4MethodType>;
     /**
      * creates a proof for the given method and arguments
      * @param method - The method to create a proof for
@@ -73,8 +43,7 @@ export default class C4Client {
      */
     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;
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: string, callback: (data: any) => void): this;
+    removeListener(event: string, callback: (data: any) => void): this;
 }
-export {};

package/index.js

@@ -1,19 +1,34 @@
 // Import the Emscripten-generated module
 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";
-    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();
+import { EventEmitter } from './eventEmitter.js';
+import { ConnectionState } from './connectionState.js';
+import { ProviderRpcError, MethodType as C4MethodType } from './types.js';
+import { SubscriptionManager } from './subscriptionManager.js';
+// 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 }),
@@ -111,23 +126,38 @@ function check_trusted_blockhashes(trusted_block_hashes, c4w, chainId) {
 }
 export default class C4Client {
     config;
+    eventEmitter;
+    connectionState;
+    subscriptionManager;
     constructor(config) {
         this.config = {
-            ...{
-                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: [],
-                proofer: ["https://mainnet.colibri-proof.tech"],
-            },
-            ...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
         };
+        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 });
     }
     async getProoferConfig() {
         const c4w = await getC4w();
         if (!c4w.storage)
             return '0x';
-        const state = c4w.storage.get('state_' + this.config.chainId);
+        const state = c4w.storage.get('states_' + this.config.chainId);
         return '0x' + (state ? Array.from(state).map(_ => _.toString(16).padStart(2, '0')).join('') : '');
     }
     get flags() {
@@ -224,36 +254,69 @@ export default class C4Client {
      * @returns The result
      */
     async rpc(method, args) {
+        // 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);
-        let proof = new Uint8Array();
         switch (method_type) {
-            case MethodType.PROOFABLE: {
-                if (this.config.verify && !this.config.verify(method, args))
+            case C4MethodType.PROOFABLE: {
+                if (this.config.verify && !this.config.verify(method, args)) {
                     return await fetch_rpc(this.config.rpcs, { method, params: args }, false);
-                proof = this.config.proofer && this.config.proofer.length
+                }
+                const proof = this.config.proofer && this.config.proofer.length
                     ? await fetch_rpc(this.config.proofer, { method, params: args, c4: await this.getProoferConfig() }, true)
                     : await this.createProof(method, args);
-                break;
+                return this.verifyProof(method, args, proof);
             }
-            case MethodType.UNPROOFABLE:
+            case C4MethodType.UNPROOFABLE:
                 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:
-                break;
+            case C4MethodType.NOT_SUPPORTED:
+                throw new ProviderRpcError(4200, `Method ${method} is not supported by C4Client.rpc core`);
+            case C4MethodType.LOCAL:
+                return this.verifyProof(method, args, new Uint8Array());
         }
-        return this.verifyProof(method, args, proof);
+        // Should be unreachable if MethodType enum is comprehensive and handled
+        throw new ProviderRpcError(-32603, `Internal error: Unhandled method type for ${method} in C4Client.rpc core`);
     }
     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;
+        if (!this.connectionState.initialConnectionAttempted) {
+            await this.connectionState.attemptInitialConnection();
+        }
+        const { method, params } = args;
+        const paramsArray = Array.isArray(params) ? params : (params ? [params] : []);
+        // Attempt to handle with SubscriptionManager first
+        const subscriptionResult = this.subscriptionManager.handleRequest(method, paramsArray);
+        if (subscriptionResult !== null) {
+            // If handleRequest returns a Promise, it means it's handling the request
+            return subscriptionResult;
+        }
+        // If not handled by SubscriptionManager, proceed with standard RPC call logic
+        try {
+            const result = await this.rpc(method, paramsArray);
+            this.connectionState.processSuccessfulRequest(method, result);
+            return result;
+        }
+        catch (error) {
+            const providerError = ProviderRpcError.createError(error);
+            this.connectionState.processFailedRequest(providerError);
+            throw providerError;
+        }
     }
     on(event, callback) {
+        this.eventEmitter.on(event, callback);
+        if ((event === 'connect' || event === 'disconnect') && !this.connectionState.initialConnectionAttempted) {
+            this.connectionState.attemptInitialConnection().catch(err => {
+                if (this.config.debug)
+                    console.error("[C4Client] Error during lazy initial connection attempt triggered by 'on':", err);
+            });
+        }
+        return this;
     }
     removeListener(event, callback) {
+        this.eventEmitter.removeListener(event, callback);
+        return this;
     }
 }

package/package.json

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

@@ -0,0 +1,35 @@
+import { EventEmitter } from './eventEmitter.js';
+export type EthSubscribeSubscriptionType = 'newHeads' | 'logs';
+export type EthNewFilterType = 'block' | 'pendingTransaction' | 'log';
+export interface Subscription {
+    id: string;
+    subscriptionMethod: 'eth_subscribe' | 'eth_newFilter';
+    kind: EthSubscribeSubscriptionType | EthNewFilterType;
+    params?: any;
+    lastPolledBlockNumber?: bigint;
+    timeoutId?: number;
+}
+interface SubscriptionManagerConfig {
+    debug?: boolean;
+    pollingInterval?: number;
+}
+export type RpcCaller = (method: string, params: any[]) => Promise<any>;
+export declare class SubscriptionManager {
+    private activeSubscriptions;
+    private eventEmitter;
+    private rpcCall;
+    private config;
+    private nextSubscriptionId;
+    constructor(rpcCallCallback: RpcCaller, eventEmitter: EventEmitter, config?: SubscriptionManagerConfig);
+    handleRequest(method: string, paramsArray: any[]): Promise<any> | null;
+    private generateSubscriptionId;
+    subscribe(kind: EthSubscribeSubscriptionType, params?: any[]): Promise<string>;
+    newFilter(kind: EthNewFilterType, params?: any[]): Promise<string>;
+    getFilterChanges(filterId: string): Promise<any[]>;
+    uninstallFilter(filterId: string): Promise<boolean>;
+    private executePollLogic;
+    private schedulePoll;
+    private pollSubscriptionAndEmit;
+    unsubscribe(subscriptionId: string): Promise<boolean>;
+}
+export {};