@corpus-core/colibri-stateless 0.2.2 → 0.2.3

package/subscriptionManager.js

@@ -0,0 +1,289 @@
+import { ProviderRpcError } from './types.js'; // Removed unused Config, DataRequest, RequestArguments
+const DEFAULT_POLLING_INTERVAL = 12000; // 12 seconds
+export class SubscriptionManager {
+    activeSubscriptions = new Map();
+    eventEmitter;
+    rpcCall;
+    config;
+    nextSubscriptionId = 0;
+    constructor(rpcCallCallback, eventEmitter, config = {}) {
+        this.rpcCall = rpcCallCallback;
+        this.eventEmitter = eventEmitter;
+        this.config = {
+            pollingInterval: DEFAULT_POLLING_INTERVAL,
+            ...config,
+        };
+    }
+    // New method to handle requests related to subscriptions and filters
+    handleRequest(method, paramsArray) {
+        switch (method) {
+            case 'eth_subscribe':
+                if (paramsArray.length < 1 || typeof paramsArray[0] !== 'string') {
+                    return Promise.reject(new ProviderRpcError(-32602, 'Invalid params for eth_subscribe: missing subscription type.'));
+                }
+                return this.subscribe(paramsArray[0], paramsArray.slice(1));
+            case 'eth_unsubscribe':
+                if (paramsArray.length < 1 || typeof paramsArray[0] !== 'string') {
+                    return Promise.reject(new ProviderRpcError(-32602, 'Invalid params for eth_unsubscribe: missing or invalid subscription ID.'));
+                }
+                return this.unsubscribe(paramsArray[0]);
+            case 'eth_newBlockFilter':
+                return this.newFilter('block');
+            case 'eth_newPendingTransactionFilter':
+                // This will internally throw, but we return the promise from newFilter
+                return this.newFilter('pendingTransaction');
+            case 'eth_newFilter': // For log filters
+                return this.newFilter('log', paramsArray);
+            case 'eth_getFilterChanges':
+                if (paramsArray.length < 1 || typeof paramsArray[0] !== 'string') {
+                    return Promise.reject(new ProviderRpcError(-32602, 'Invalid params for eth_getFilterChanges: missing or invalid filter ID.'));
+                }
+                return this.getFilterChanges(paramsArray[0]);
+            case 'eth_uninstallFilter':
+                if (paramsArray.length < 1 || typeof paramsArray[0] !== 'string') {
+                    return Promise.reject(new ProviderRpcError(-32602, 'Invalid params for eth_uninstallFilter: missing or invalid filter ID.'));
+                }
+                return this.uninstallFilter(paramsArray[0]);
+            default:
+                // Not a method handled by SubscriptionManager
+                return null;
+        }
+    }
+    generateSubscriptionId() {
+        this.nextSubscriptionId++;
+        // Simple hex string, similar to what nodes return
+        return `0x${this.nextSubscriptionId.toString(16)}`;
+    }
+    // For eth_subscribe
+    async subscribe(kind, params = []) {
+        if (this.config.debug) {
+            console.log(`[SubMan] eth_subscribe: kind=${kind}, params=`, params);
+        }
+        const subId = this.generateSubscriptionId();
+        let subscriptionDetails = {
+            id: subId,
+            subscriptionMethod: 'eth_subscribe',
+            kind: kind,
+        };
+        switch (kind) {
+            case 'newHeads':
+                // No specific params needed from client for newHeads
+                break;
+            case 'logs':
+                subscriptionDetails.params = params[0] || {};
+                break;
+            default:
+                // Should not happen if kind is correctly typed
+                throw new ProviderRpcError(4200, `Subscription kind "${kind}" is not supported by eth_subscribe.`);
+        }
+        const finalSubscription = subscriptionDetails;
+        this.activeSubscriptions.set(subId, finalSubscription);
+        this.schedulePoll(finalSubscription, 0); // Start active polling
+        if (this.config.debug) {
+            console.log(`[SubMan] Created eth_subscribe subscription: ${subId}`, finalSubscription);
+        }
+        return subId;
+    }
+    // For eth_newFilter, eth_newBlockFilter, eth_newPendingTransactionFilter
+    async newFilter(kind, params = []) {
+        if (this.config.debug) {
+            console.log(`[SubMan] eth_newFilter: kind=${kind}, params=`, params);
+        }
+        if (kind === 'pendingTransaction') {
+            if (this.config.debug)
+                console.warn('[SubMan] eth_newPendingTransactionFilter is not supported.');
+            throw new ProviderRpcError(4200, 'eth_newPendingTransactionFilter is not supported.');
+        }
+        const filterId = this.generateSubscriptionId();
+        const filterDetails = {
+            id: filterId,
+            subscriptionMethod: 'eth_newFilter',
+            kind: kind,
+            params: kind === 'log' ? (params[0] || {}) : undefined,
+            // No timeoutId as polling is manual via getFilterChanges
+        };
+        this.activeSubscriptions.set(filterId, filterDetails);
+        if (this.config.debug) {
+            console.log(`[SubMan] Created eth_newFilter filter: ${filterId}`, filterDetails);
+        }
+        return filterId;
+    }
+    // For eth_getFilterChanges
+    async getFilterChanges(filterId) {
+        const sub = this.activeSubscriptions.get(filterId);
+        if (!sub || sub.subscriptionMethod !== 'eth_newFilter') {
+            if (this.config.debug)
+                console.warn(`[SubMan] getFilterChanges: Filter not found or not a filter type for ID ${filterId}`);
+            throw new ProviderRpcError(-32000, 'Filter not found.'); // Standard Ethereum error for missing filter
+        }
+        if (this.config.debug) {
+            console.log(`[SubMan] getFilterChanges for filter: ${filterId}, kind: ${sub.kind}`);
+        }
+        // Perform a one-time poll based on the filter kind
+        return this.executePollLogic(sub, true); // Pass true to indicate results should be returned, not emitted
+    }
+    // For eth_uninstallFilter
+    async uninstallFilter(filterId) {
+        const sub = this.activeSubscriptions.get(filterId);
+        if (sub && sub.subscriptionMethod === 'eth_newFilter') {
+            this.activeSubscriptions.delete(filterId);
+            // No timeout to clear for filters
+            if (this.config.debug) {
+                console.log(`[SubMan] Uninstalled filter: ${filterId}`);
+            }
+            return true;
+        }
+        if (this.config.debug) {
+            console.warn(`[SubMan] UninstallFilter failed: Filter not found or not a filter type for ID ${filterId}`);
+        }
+        return false;
+    }
+    // Common polling logic, can return results or emit them via eventEmitter
+    async executePollLogic(sub, returnResults = false) {
+        let results = [];
+        let currentVerifiableBlockNumber = null;
+        try {
+            const blockNumberHex = await this.rpcCall('eth_blockNumber', []);
+            if (blockNumberHex)
+                currentVerifiableBlockNumber = BigInt(blockNumberHex);
+        }
+        catch (e) {
+            if (this.config.debug)
+                console.warn('[SubMan] Could not fetch eth_blockNumber for polling context:', e);
+        }
+        if (sub.kind === 'newHeads' || sub.kind === 'block') { // block is for eth_newBlockFilter
+            if (currentVerifiableBlockNumber) {
+                let fromBlock = sub.lastPolledBlockNumber ? sub.lastPolledBlockNumber + 1n : currentVerifiableBlockNumber;
+                if (sub.kind === 'newHeads') { // For newHeads, we only care if the latest is newer
+                    if (!sub.lastPolledBlockNumber || 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 {
+                        const block = await this.rpcCall('eth_getBlockByNumber', ['0x' + blockNum.toString(16), sub.kind === 'newHeads' /* full block for newHeads */]);
+                        if (block && this.activeSubscriptions.has(sub.id)) {
+                            if (sub.kind === 'newHeads')
+                                results.push(block);
+                            else if (sub.kind === 'block')
+                                results.push(block.hash); // eth_newBlockFilter returns block hashes
+                        }
+                    }
+                    catch (e) {
+                        if (this.config.debug)
+                            console.error(`[SubMan] Error fetching block ${blockNum} for sub/filter ${sub.id}:`, e);
+                        if (sub.kind === 'block')
+                            break; // For block filters, stop if a block in sequence fails
+                    }
+                }
+                if (results.length > 0 && sub.kind === 'newHeads' && !returnResults && this.activeSubscriptions.has(sub.id)) {
+                    // For newHeads subscription, emit each block individually or as an array?
+                    // EIP-1193 usually implies one result per message for newHeads
+                    results.forEach(blockResult => {
+                        this.eventEmitter.emit('message', {
+                            type: 'eth_subscription',
+                            data: { subscription: sub.id, result: blockResult }
+                        });
+                    });
+                    if (this.config.debug)
+                        console.log(`[SubMan] Emitted ${results.length} newHead(s) for sub ${sub.id}`);
+                }
+                sub.lastPolledBlockNumber = currentVerifiableBlockNumber;
+            }
+        }
+        else if (sub.kind === 'logs' || sub.kind === 'log') { // 'log' is for eth_newFilter(logs)
+            const filterParams = { ...(sub.params || {}) };
+            if (sub.lastPolledBlockNumber) {
+                filterParams.fromBlock = '0x' + (sub.lastPolledBlockNumber + 1n).toString(16);
+            }
+            else if (!filterParams.fromBlock && currentVerifiableBlockNumber) {
+                filterParams.fromBlock = '0x' + currentVerifiableBlockNumber.toString(16);
+            }
+            if (currentVerifiableBlockNumber) {
+                filterParams.toBlock = '0x' + currentVerifiableBlockNumber.toString(16);
+            }
+            else if (!filterParams.toBlock) {
+                filterParams.toBlock = 'latest';
+            }
+            if (filterParams.fromBlock && filterParams.toBlock && filterParams.toBlock !== 'latest' && BigInt(filterParams.fromBlock) > BigInt(filterParams.toBlock)) {
+                // Skip if fromBlock is ahead
+            }
+            else {
+                try {
+                    const logs = await this.rpcCall('eth_getLogs', [filterParams]);
+                    if (logs && logs.length > 0 && this.activeSubscriptions.has(sub.id)) {
+                        results = logs;
+                        if (!returnResults) { // For eth_subscribe('logs')
+                            this.eventEmitter.emit('message', {
+                                type: 'eth_subscription',
+                                data: { subscription: sub.id, result: logs } // Usually an array of logs
+                            });
+                            if (this.config.debug)
+                                console.log(`[SubMan] Emitted ${logs.length} logs for sub ${sub.id}`);
+                        }
+                    }
+                    if (filterParams.toBlock !== 'latest')
+                        sub.lastPolledBlockNumber = BigInt(filterParams.toBlock);
+                    else if (currentVerifiableBlockNumber)
+                        sub.lastPolledBlockNumber = currentVerifiableBlockNumber;
+                }
+                catch (e) {
+                    if (this.config.debug)
+                        console.error(`[SubMan] Error fetching logs for sub/filter ${sub.id}:`, e);
+                }
+            }
+        }
+        return results;
+    }
+    schedulePoll(sub, delay) {
+        if (!this.activeSubscriptions.has(sub.id) || sub.subscriptionMethod === 'eth_newFilter')
+            return;
+        sub.timeoutId = setTimeout(async () => {
+            try {
+                if (!this.activeSubscriptions.has(sub.id))
+                    return;
+                await this.pollSubscriptionAndEmit(sub); // Renamed from pollSubscription for clarity
+            }
+            catch (error) {
+                console.error(`[SubMan] Unexpected error in poll scheduling for subscription ${sub.id}:`, error);
+            }
+        }, delay);
+    }
+    // Wrapper for eth_subscribe polling that emits results and reschedules
+    async pollSubscriptionAndEmit(sub) {
+        if (!this.activeSubscriptions.has(sub.id)) {
+            if (this.config.debug)
+                console.log(`[SubMan] Subscription ${sub.id} was unsubscribed. Skipping poll.`);
+            if (sub.timeoutId)
+                clearTimeout(sub.timeoutId);
+            return;
+        }
+        if (this.config.debug) {
+            console.log(`[SubMan] Polling for eth_subscribe: ${sub.id}, kind: ${sub.kind}`);
+        }
+        await this.executePollLogic(sub, false); // false means emit results, don't return them
+        if (this.activeSubscriptions.has(sub.id)) {
+            this.schedulePoll(sub, this.config.pollingInterval || DEFAULT_POLLING_INTERVAL);
+        }
+    }
+    // For eth_unsubscribe (specific to eth_subscribe subscriptions)
+    async unsubscribe(subscriptionId) {
+        const sub = this.activeSubscriptions.get(subscriptionId);
+        if (sub && sub.subscriptionMethod === 'eth_subscribe') {
+            if (sub.timeoutId) {
+                clearTimeout(sub.timeoutId);
+            }
+            this.activeSubscriptions.delete(subscriptionId);
+            if (this.config.debug) {
+                console.log(`[SubMan] Unsubscribed (eth_subscribe): ${subscriptionId}`);
+            }
+            return true;
+        }
+        if (this.config.debug) {
+            console.warn(`[SubMan] Unsubscribe failed: Subscription not found or not an eth_subscribe type for ID ${subscriptionId}`);
+        }
+        return false;
+    }
+}

package/types.d.ts

@@ -0,0 +1,50 @@
+export declare class ProviderRpcError extends Error {
+    code: number;
+    data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+    static createError(error: any): ProviderRpcError;
+}
+export interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
+export interface ProviderConnectInfo {
+    readonly chainId: string;
+}
+export interface ProviderMessage {
+    readonly type: string;
+    readonly data: unknown;
+}
+export interface Cache {
+    cacheable(req: DataRequest): boolean;
+    get(req: DataRequest): Uint8Array | undefined;
+    set(req: DataRequest, data: Uint8Array): void;
+}
+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;
+    pollingInterval?: number;
+}
+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
+}

package/types.js

@@ -0,0 +1,45 @@
+// --- EIP-1193 & C4Client Specific Types ---
+// From EIP-1193: Error structure
+export class ProviderRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = 'ProviderRpcError';
+        this.code = code;
+        if (data !== undefined) {
+            this.data = data;
+        }
+        Object.setPrototypeOf(this, ProviderRpcError.prototype);
+    }
+    static createError(error) {
+        let providerError;
+        if (error instanceof ProviderRpcError) {
+            providerError = error;
+        }
+        else {
+            let code;
+            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;
+            }
+            else if (typeof message === 'string' && (message.includes('HTTP error!') || message.includes('All nodes failed') || message.includes('Failed to fetch'))) {
+                code = 4900;
+            }
+            else {
+                code = (typeof error?.code === 'number') ? error.code : -32603;
+            }
+            providerError = new ProviderRpcError(code, message, originalData);
+        }
+        return providerError;
+    }
+}
+// Enum for RPC method types
+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 = {}));

package/server.d.ts

@@ -1,8 +0,0 @@
-import Client, { Config } from "./index.js";
-export default class Server {
-    client: Client;
-    constructor(conf: Partial<Config>);
-    private toHexString;
-    private handleRequest;
-    start(port?: number): Promise<void>;
-}

package/server.js

@@ -1,177 +0,0 @@
-import Client from "./index.js";
-import * as http from 'http';
-import * as fs from 'fs';
-// ensure cache_dir
-let cache_memory_limit = parseInt(process.env.CACHE_RAM_LIMIT || '100'); // in MB
-let cache_dir = process.env.CACHE_DIR || '.cache';
-if (!fs.existsSync(cache_dir))
-    fs.mkdirSync(cache_dir, { recursive: true });
-function cache_key(req) {
-    if (req.type == 'eth_rpc' && req.payload)
-        return `rpc_${req.payload?.method}_${req.payload?.params?.join('_')}`;
-    return req.url;
-}
-const cached_methods = ["eth_getBlockByNumber", "eth_getBlockByHash", "eth_getBlockReceipts"];
-const memory_cache = new Map();
-function check_limit() {
-    let total_size = 0;
-    for (const [k, v] of memory_cache.entries()) {
-        total_size += v.data.length;
-    }
-    while (total_size > cache_memory_limit * 1024 * 1024) {
-        // find the oldest entry
-        let oldest_k = null;
-        let oldest_v = null;
-        for (const [k, v] of memory_cache.entries()) {
-            if (oldest_v == null || v.timestamp < oldest_v.timestamp) {
-                oldest_k = k;
-                oldest_v = v;
-            }
-        }
-        if (oldest_k)
-            memory_cache.delete(oldest_k);
-    }
-}
-function is_timeout(key, entry) {
-    if (key.endsWith('latest') || key.endsWith('head')) {
-        if (!entry)
-            return true;
-        return entry.timestamp < Date.now() - 1000 * 6;
-    }
-    return false;
-}
-const cache = {
-    cacheable: (req) => !!(req.encoding == "ssz" || (req.type == 'eth_rpc' && req.payload && cached_methods.includes(req.payload?.method))),
-    get: (req) => {
-        const key = cache_key(req);
-        let entry = memory_cache.get(key);
-        if (is_timeout(key, entry))
-            entry = undefined;
-        if (!entry && !is_timeout(key)) {
-            const file_path = cache_dir + '/' + key;
-            if (fs.existsSync(file_path)) {
-                let data = fs.readFileSync(file_path);
-                memory_cache.set(key, { data, timestamp: fs.statSync(file_path).mtime.getTime() });
-                setTimeout(check_limit, 0);
-            }
-        }
-        return entry?.data;
-    },
-    set: (req, data) => {
-        const key = cache_key(req);
-        memory_cache.set(key, { data, timestamp: Date.now() });
-        if (!is_timeout(key))
-            fs.writeFile(cache_dir + '/' + key, Buffer.from(data), () => { });
-        check_limit();
-    }
-};
-export default class Server {
-    client;
-    constructor(conf) {
-        conf = conf || {};
-        if (process.env.CHAIN_ID)
-            conf.chainId = parseInt(process.env.CHAIN_ID);
-        if (process.env.BEACON_API)
-            conf.beacon_apis = process.env.BEACON_API.split(",");
-        if (process.env.RPC)
-            conf.rpcs = process.env.RPC.split(",");
-        conf.cache = cache;
-        conf.debug = true;
-        this.client = new Client(conf);
-    }
-    toHexString(bytes) {
-        return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-    async handleRequest(req, res) {
-        // Only accept POST requests
-        if (req.method !== 'POST') {
-            const error = 'Method not allowed';
-            console.error(`[${new Date().toISOString()}] Error: ${error}`);
-            res.writeHead(405, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error }));
-            return;
-        }
-        // Read request body
-        let body = '';
-        req.on('data', (chunk) => {
-            body += chunk.toString();
-        });
-        req.on('end', async () => {
-            try {
-                const jsonRpc = JSON.parse(body);
-                if (!jsonRpc.method || !jsonRpc.params || !Array.isArray(jsonRpc.params)) {
-                    throw new Error('Invalid JSON-RPC request');
-                }
-                let start = Date.now();
-                console.log(` ==> ${jsonRpc.method} (${jsonRpc.params.join(',')}) ...`);
-                // Create proof using the client
-                const proof = await this.client.createProof(jsonRpc.method, jsonRpc.params);
-                let end = Date.now();
-                console.log(` <== ${jsonRpc.method} (${jsonRpc.params.join(',')}) ... ${end - start}ms (${proof.length} bytes)`);
-                // Check Accept header to determine response format
-                const acceptHeader = req.headers.accept;
-                if (acceptHeader === 'application/octet-stream') {
-                    res.writeHead(200, {
-                        'Content-Type': 'application/octet-stream',
-                        'Content-Length': proof.length
-                    });
-                    res.end(Buffer.from(proof));
-                }
-                else {
-                    const response = {
-                        jsonrpc: '2.0',
-                        id: jsonRpc.id,
-                        result: this.toHexString(proof)
-                    };
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(response));
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'Internal error';
-                console.error(`[${new Date().toISOString()}] Error processing request:`, errorMessage);
-                if (error instanceof Error && error.stack) {
-                    console.error(`Stack trace:`, error.stack);
-                }
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                const errorResponse = {
-                    jsonrpc: '2.0',
-                    id: JSON.parse(body)?.id,
-                    error: {
-                        code: -32603,
-                        message: errorMessage
-                    }
-                };
-                res.end(JSON.stringify(errorResponse));
-                console.log(`[${new Date().toISOString()}] Sent error response:`, errorResponse);
-            }
-        });
-        req.on('error', (error) => {
-            console.error(`[${new Date().toISOString()}] Request error:`, error);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32603,
-                    message: 'Internal server error'
-                }
-            }));
-        });
-    }
-    async start(port = 8545) {
-        const server = http.createServer((req, res) => this.handleRequest(req, res));
-        return new Promise((resolve, reject) => {
-            server.listen(port, () => {
-                console.log(`[${new Date().toISOString()}] Server running at http://localhost:${port}/`);
-                resolve();
-            });
-            server.on('error', (error) => {
-                console.error(`[${new Date().toISOString()}] Server error:`, error);
-                reject(error);
-            });
-        });
-    }
-}
-// Start the server directly
-const server = new Server({});
-server.start(parseInt(process.env.PORT || '8545'));