@corpus-core/colibri-stateless 1.1.1 → 1.1.3

package/cjs/subscriptionManager.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Copyright (c) 2025 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionManager = void 0;
+const types_js_1 = require("./types.js"); // Removed unused Config, DataRequest, RequestArguments
+const DEFAULT_POLLING_INTERVAL = 12000; // 12 seconds
+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 types_js_1.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 types_js_1.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 types_js_1.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 types_js_1.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 types_js_1.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 types_js_1.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 types_js_1.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)
+                        sub.lastPolledBlockNumber = currentVerifiableBlockNumber;
+                    if (currentVerifiableBlockNumber <= sub.lastPolledBlockNumber)
+                        return []; // No new head yet for eth_subscribe('newHeads')
+                }
+                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;
+    }
+}
+exports.SubscriptionManager = SubscriptionManager;

package/cjs/transactionVerifier.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Copyright (c) 2025 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionUtils = exports.PrototypeProtection = exports.TransactionVerifier = void 0;
+const types_js_1 = require("./types.js");
+class TransactionVerifier {
+    /**
+     * Verifizierte Ausführung von eth_sendTransaction
+     * 1. Transaction über fallbackProvider signieren lassen
+     * 2. Signierte Transaction mit colibri_decodeTransaction dekodieren
+     * 3. Dekodierte Parameter mit Original vergleichen
+     * 4. eth_sendRawTransaction ausführen
+     */
+    static async verifyAndSendTransaction(txObject, config, rpcMethod, fetchRpc) {
+        if (config.debug)
+            console.log('[TransactionVerifier] Verifying transaction before sending:', txObject);
+        if (!config.fallback_provider) {
+            throw new types_js_1.ProviderRpcError(4203, 'Transaction verification requires fallback_provider to be configured');
+        }
+        try {
+            // 1. Transaction über fallbackProvider signieren lassen
+            const signedRawTx = await config.fallback_provider.request({
+                method: 'eth_signTransaction',
+                params: [txObject]
+            });
+            // 2. Signierte Transaction dekodieren
+            const decodedTx = await rpcMethod('colibri_decodeTransaction', [signedRawTx], types_js_1.MethodType.LOCAL);
+            // 3. Dekodierte Parameter mit Original vergleichen
+            const isValid = this.compareTransactionParameters(txObject, decodedTx, config);
+            if (!isValid) {
+                throw new types_js_1.ProviderRpcError(4201, 'Signed transaction does not match original parameters');
+            }
+            // 4. Verifizierte Transaction senden
+            return await fetchRpc(config.rpcs, {
+                method: 'eth_sendRawTransaction',
+                params: [signedRawTx]
+            }, false);
+        }
+        catch (error) {
+            if (config.debug)
+                console.error('[TransactionVerifier] Transaction verification failed:', error);
+            throw new types_js_1.ProviderRpcError(4202, `Transaction verification failed: ${error.message}`);
+        }
+    }
+    /**
+     * Vergleicht die Parameter einer ursprünglichen Transaction mit einer dekodierten signierten Transaction
+     */
+    static compareTransactionParameters(original, decoded, config) {
+        if (config.debug) {
+            console.log('[TransactionVerifier] Comparing transaction parameters:');
+            console.log('Original:', original);
+            console.log('Decoded:', decoded);
+        }
+        // Kritische Parameter vergleichen
+        const criticalFields = ['to', 'value', 'data', 'gas', 'gasPrice', 'maxFeePerGas', 'maxPriorityFeePerGas', 'nonce'];
+        for (const field of criticalFields) {
+            if (original[field] !== undefined) {
+                // Normalisierung für Hex-Werte (0x-Prefix, Leading Zeros)
+                const originalValue = this.normalizeHexValue(original[field]);
+                const decodedValue = this.normalizeHexValue(decoded[field]);
+                if (originalValue !== decodedValue) {
+                    if (config.debug) {
+                        console.warn(`[TransactionVerifier] Transaction parameter mismatch in '${field}': original='${originalValue}', decoded='${decodedValue}'`);
+                    }
+                    return false;
+                }
+            }
+        }
+        // ChainId prüfen
+        if (decoded.chainId && parseInt(decoded.chainId, 16) !== parseInt(config.chainId)) {
+            if (config.debug) {
+                console.warn(`[TransactionVerifier] ChainId mismatch: expected=${config.chainId}, decoded=${parseInt(decoded.chainId, 16)}`);
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Normalisiert Hex-Werte für Vergleiche (entfernt führende Nullen, stellt 0x-Prefix sicher)
+     */
+    static normalizeHexValue(value) {
+        if (value === undefined || value === null)
+            return '';
+        if (typeof value === 'number')
+            return '0x' + value.toString(16);
+        const str = value.toString();
+        if (!str.startsWith('0x'))
+            return '0x' + str;
+        // Führende Nullen entfernen, aber mindestens eine Ziffer behalten
+        const withoutPrefix = str.slice(2);
+        const normalized = withoutPrefix.replace(/^0+/, '') || '0';
+        return '0x' + normalized;
+    }
+}
+exports.TransactionVerifier = TransactionVerifier;
+/**
+ * Prototype Protection - Schutz vor NPM Supply-Chain-Attacks
+ *
+ * Friert kritische Prototypen und Methoden ein, um Manipulation zu verhindern
+ */
+class PrototypeProtection {
+    /**
+     * Schützt eine Klasse vor Prototype Pollution
+     */
+    static protectClass(targetClass, criticalMethods = []) {
+        // Einfrieren des Prototypes
+        Object.freeze(targetClass.prototype);
+        // Kritische Methoden gegen Überschreibung schützen
+        criticalMethods.forEach(method => {
+            const descriptor = Object.getOwnPropertyDescriptor(targetClass.prototype, method);
+            if (descriptor) {
+                Object.defineProperty(targetClass.prototype, method, {
+                    ...descriptor,
+                    writable: false,
+                    configurable: false
+                });
+            }
+        });
+    }
+    /**
+     * Schützt ein Konfigurationsobjekt vor Manipulation
+     */
+    static protectConfig(config, criticalArrays = []) {
+        // Kritische Arrays einfrieren
+        criticalArrays.forEach(arrayName => {
+            if (config[arrayName] && Array.isArray(config[arrayName])) {
+                Object.freeze(config[arrayName]);
+            }
+        });
+    }
+}
+exports.PrototypeProtection = PrototypeProtection;
+/**
+ * Transaction Utilities - Hilfsfunktionen für Transaction-Handling
+ */
+class TransactionUtils {
+    /**
+     * Validiert ein Transaction-Objekt
+     */
+    static validateTransactionObject(txObject) {
+        if (!txObject || typeof txObject !== 'object')
+            return false;
+        // Mindestanforderungen
+        if (!txObject.to && !txObject.data)
+            return false; // Entweder to-Adresse oder data für Contract-Creation
+        return true;
+    }
+    /**
+     * Bereinigt Transaction-Parameter für verschiedene Standards
+     */
+    static cleanupTransactionParams(txObject) {
+        const cleaned = { ...txObject };
+        // EIP-1559 vs Legacy Gas-Handling
+        if (cleaned.maxFeePerGas || cleaned.maxPriorityFeePerGas) {
+            // EIP-1559 - gasPrice entfernen
+            delete cleaned.gasPrice;
+        }
+        else if (cleaned.gasPrice) {
+            // Legacy - EIP-1559 Felder entfernen
+            delete cleaned.maxFeePerGas;
+            delete cleaned.maxPriorityFeePerGas;
+        }
+        return cleaned;
+    }
+    /**
+     * Erstellt eine Zusammenfassung einer Transaction für Logging
+     */
+    static summarizeTransaction(txObject) {
+        const to = txObject.to || 'Contract Creation';
+        const value = txObject.value ? `${parseInt(txObject.value, 16)} wei` : '0 wei';
+        const gas = txObject.gas ? parseInt(txObject.gas, 16) : 'auto';
+        return `Transaction(to: ${to}, value: ${value}, gas: ${gas})`;
+    }
+}
+exports.TransactionUtils = TransactionUtils;
+// Export aller Klassen als Default
+exports.default = {
+    TransactionVerifier,
+    PrototypeProtection,
+    TransactionUtils
+};

package/cjs/types.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Copyright (c) 2025 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodType = exports.ProviderRpcError = void 0;
+// --- EIP-1193 & C4Client Specific Types ---
+// From EIP-1193: Error structure
+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, args) {
+        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, 'Error in rpc call ' + (args?.method || '') + JSON.stringify(args?.params || []) + ' : ' + message, originalData);
+        }
+        return providerError;
+    }
+}
+exports.ProviderRpcError = ProviderRpcError;
+// Enum for RPC method types
+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 || (exports.MethodType = MethodType = {}));

package/cjs/wasm.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Copyright (c) 2025 corpus.core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set_trusted_checkpoint = exports.get_prover_config_hex = exports.getC4w = exports.loadC4WModule = exports.set_wasm_url = exports.get_default_storage = exports.copy_to_c = exports.as_json = exports.as_char_ptr = exports.as_bytes = void 0;
+// This file is used only for the CommonJS build output. It must not use
+// `import.meta` because that is a parse error in CommonJS environments (e.g. Jest).
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const wasm_shared_js_1 = require("./wasm_shared.js");
+Object.defineProperty(exports, "as_bytes", { enumerable: true, get: function () { return wasm_shared_js_1.as_bytes; } });
+Object.defineProperty(exports, "as_char_ptr", { enumerable: true, get: function () { return wasm_shared_js_1.as_char_ptr; } });
+Object.defineProperty(exports, "as_json", { enumerable: true, get: function () { return wasm_shared_js_1.as_json; } });
+Object.defineProperty(exports, "copy_to_c", { enumerable: true, get: function () { return wasm_shared_js_1.copy_to_c; } });
+Object.defineProperty(exports, "get_default_storage", { enumerable: true, get: function () { return wasm_shared_js_1.get_default_storage; } });
+async function dynamicImport(specifier) {
+    // Prevent TypeScript from transforming `import()` into `require()` in CJS output.
+    // Node supports dynamic import in CommonJS.
+    const importer = new Function('p', 'return import(p)');
+    return importer(specifier);
+}
+const api = (0, wasm_shared_js_1.createC4wApi)({
+    importC4wModule: async () => {
+        const pkgRoot = (0, node_path_1.join)(__dirname, '..');
+        const glueUrl = (0, node_url_1.pathToFileURL)((0, node_path_1.join)(pkgRoot, 'c4w.js')).href;
+        return await dynamicImport(glueUrl);
+    },
+    resolveWasmLocation: (override) => {
+        // In CJS/Node we provide wasmBinary, so we don't need locateFile here.
+        // Keep override support for browser-like loaders (if someone uses it).
+        if (override)
+            return override;
+        return null;
+    },
+    getWasmBinary: async (override) => {
+        const fs = await dynamicImport('node:fs');
+        const wasmPath = override ?? (0, node_path_1.join)(__dirname, '..', 'c4w.wasm');
+        return fs.readFileSync(wasmPath);
+    },
+});
+exports.set_wasm_url = api.set_wasm_url;
+exports.loadC4WModule = api.loadC4WModule;
+exports.getC4w = api.getC4w;
+exports.get_prover_config_hex = api.get_prover_config_hex;
+exports.set_trusted_checkpoint = api.set_trusted_checkpoint;