@corpus-core/colibri-stateless 0.3.0 → 0.3.2

package/index.js

@@ -111,13 +111,15 @@ const default_config = {
         alias: ["mainnet", "eth", "0x1"],
         beacon_apis: ["https://lodestar-mainnet.chainsafe.io"],
         rpcs: ["https://rpc.ankr.com/eth"],
-        proofer: ["https://mainnet.colibri-proof.tech"],
+        proofer: ["https://mainnet1.colibri-proof.tech"],
+        pollingInterval: 12000,
     },
     '100': {
         alias: ["gnosis", "xdai", "0x64"],
         beacon_apis: ["https://gnosis.colibri-proof.tech"],
         rpcs: ["https://rpc.ankr.com/gnosis"],
         proofer: ["https://gnosis.colibri-proof.tech"],
+        pollingInterval: 5000,
     },
 };
 function get_chain_id(chain_id) {
@@ -130,6 +132,15 @@ function get_chain_id(chain_id) {
     }
     throw new Error("Invalid chain id: " + chain_id);
 }
+function chain_conf(config, chainId) {
+    const k = config?.chains?.[chainId];
+    if (k)
+        return k;
+    const k2 = default_config[chainId + ''];
+    if (k2)
+        return k2;
+    return undefined;
+}
 export default class C4Client {
     config;
     eventEmitter;
@@ -139,8 +150,8 @@ export default class C4Client {
         const chainId = config?.chainId ? get_chain_id(config?.chainId + '') : 1;
         const chain_config = { ...default_config[chainId + ''] };
         this.config = {
+            chains: {},
             trusted_block_hashes: [],
-            pollingInterval: 12000, // Default here, can be overridden by user config
             rpcs: chain_config.rpcs || [],
             beacon_apis: chain_config.beacon_apis || [],
             proofer: chain_config.proofer || [],
@@ -154,7 +165,10 @@ export default class C4Client {
         this.eventEmitter = new EventEmitter();
         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 });
+        this.subscriptionManager = new SubscriptionManager(async (method, params) => this.rpc(method, params), this.eventEmitter, {
+            debug: this.config.debug,
+            pollingInterval: this.config.pollingInterval || chain_conf(this.config, this.config.chainId)?.pollingInterval || 12000
+        });
     }
     async getProoferConfig() {
         const c4w = await getC4w();
@@ -297,7 +311,7 @@ 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 conf = chain_conf(this.config, this.config.chainId);
         let strategy = conf?.proofStrategy || this.config.proofStrategy;
         // If not handled by SubscriptionManager, proceed with standard RPC call logic
         try {
@@ -308,7 +322,7 @@ export default class C4Client {
             return result;
         }
         catch (error) {
-            const providerError = ProviderRpcError.createError(error);
+            const providerError = ProviderRpcError.createError(error, args);
             this.connectionState.processFailedRequest(providerError);
             throw providerError;
         }

package/package.json

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

@@ -159,8 +159,6 @@ export class SubscriptionManager {
                         sub.lastPolledBlockNumber = currentVerifiableBlockNumber;
                     if (currentVerifiableBlockNumber <= sub.lastPolledBlockNumber)
                         return []; // No new head yet for eth_subscribe('newHeads')
-                    // If new, target currentVerifiableBlockNumber for eth_getBlockByNumber
-                    fromBlock = currentVerifiableBlockNumber;
                 }
                 for (let blockNum = fromBlock; blockNum <= currentVerifiableBlockNumber; blockNum++) {
                     try {

package/types.d.ts

@@ -2,7 +2,7 @@ export declare class ProviderRpcError extends Error {
     code: number;
     data?: unknown;
     constructor(code: number, message: string, data?: unknown);
-    static createError(error: any): ProviderRpcError;
+    static createError(error: any, args?: RequestArguments): ProviderRpcError;
 }
 export interface ColibriClient {
     rpc(method: string, params: any[], method_type?: MethodType): Promise<any>;

package/types.js

@@ -12,14 +12,14 @@ export class ProviderRpcError extends Error {
         }
         Object.setPrototypeOf(this, ProviderRpcError.prototype);
     }
-    static createError(error) {
+    static createError(error, args) {
         let providerError;
         if (error instanceof ProviderRpcError) {
             providerError = error;
         }
         else {
             let code;
-            let message = error?.message || 'An unknown error occurred';
+            let message = (error?.message || 'An unknown error occurred');
             const originalData = error?.data;
             if (typeof message === 'string' && message.startsWith('Method ') && message.endsWith(' is not supported')) {
                 code = 4200;
@@ -30,7 +30,7 @@ export class ProviderRpcError extends Error {
             else {
                 code = (typeof error?.code === 'number') ? error.code : -32603;
             }
-            providerError = new ProviderRpcError(code, message, originalData);
+            providerError = new ProviderRpcError(code, 'Error in rpc call ' + (args?.method || '') + JSON.stringify(args?.params || []) + ' : ' + message, originalData);
         }
         return providerError;
     }