@cheny56/node-client 1.0.8 → 1.0.9

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@cheny56/node-client",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Client library for Quorum blockchain with Post-Quantum Cryptography (PQC) and Zero-Knowledge Proof (ZK) support",
-  "main": "./index.cjs",
-  "module": "./src/index.js",
+  "main": "./src/index.js",
   "types": "src/index.d.ts",
-  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.cjs",
+      "require": "./src/index.js",
       "import": "./src/index.js",
       "types": "./src/index.d.ts",
       "default": "./src/index.js"
@@ -18,7 +16,6 @@
   "files": [
     "src/**/*.js",
     "src/**/*.d.ts",
-    "index.cjs",
     "package.json",
     "README.md",
     "README-COMMONJS.md",

package/src/constants.js

@@ -1,7 +1,7 @@
 /**
  * Transaction Type Constants
  */
-export const TX_TYPE = {
+const TX_TYPE = {
     LEGACY: 0,
     ACCESS_LIST: 1,
     DYNAMIC_FEE: 2,
@@ -11,7 +11,7 @@ export const TX_TYPE = {
 /**
  * PQC Signature Type Constants
  */
-export const PQC_TYPE = {
+const PQC_TYPE = {
     NONE: 0,
     DILITHIUM: 1,
 };
@@ -19,7 +19,7 @@ export const PQC_TYPE = {
 /**
  * ZK Proof System Constants
  */
-export const ZK_PROOF_SYSTEM = {
+const ZK_PROOF_SYSTEM = {
     GROTH16: 1,
     PLONK: 2,
     STARK: 3,
@@ -28,4 +28,11 @@ export const ZK_PROOF_SYSTEM = {
 /**
  * Default Chain ID for Quorum
  */
-export const DEFAULT_CHAIN_ID = 1337;
+const DEFAULT_CHAIN_ID = 1337;
+
+module.exports = {
+    TX_TYPE,
+    PQC_TYPE,
+    ZK_PROOF_SYSTEM,
+    DEFAULT_CHAIN_ID,
+};

package/src/contract.js

@@ -3,13 +3,13 @@
  * Supports ERC20 token transfers and contract calls
  */
 
-import { ethers } from 'ethers';
-import { LegacyTransaction, PQCLegacyTransaction, HybridLegacyTransaction } from './transaction.js';
+const { ethers } = require('ethers');
+const { LegacyTransaction, PQCLegacyTransaction, HybridLegacyTransaction } = require('./transaction.js');
 
 /**
  * Contract class for interacting with smart contracts
  */
-export class Contract {
+class Contract {
     constructor(address, abi, provider, wallet = null) {
         this.address = address;
         this.abi = abi;
@@ -81,7 +81,7 @@ export class Contract {
  * ERC20 Token Contract
  * Simplified interface for ERC20 token operations
  */
-export class ERC20Token extends Contract {
+class ERC20Token extends Contract {
     constructor(address, provider, wallet = null) {
         const erc20Abi = [
             'function name() view returns (string)',
@@ -160,10 +160,6 @@ export class ERC20Token extends Contract {
      */
     async transferPQC(wallet, provider, to, amount, txOptions = {}) {
         const data = this.encodeFunctionData('transfer', [to, amount]);
-        // Ensure wallet has address
-        if (!wallet.address) {
-            await wallet._ensureKeyPair();
-        }
         const nonce = await provider.getTransactionCount(wallet.address, 'pending');
         
         const tx = new PQCLegacyTransaction({
@@ -176,7 +172,7 @@ export class ERC20Token extends Contract {
             data: data,
         });
 
-        await tx.sign(wallet);
+        tx.sign(wallet);
         const serialized = tx.getHex();
         return await provider.sendRawTransaction(serialized);
     }
@@ -192,9 +188,7 @@ export class ERC20Token extends Contract {
      */
     async transferHybrid(wallet, provider, to, amount, txOptions = {}) {
         const data = this.encodeFunctionData('transfer', [to, amount]);
-        // Ensure wallet has address
-        const address = await wallet.getAddress();
-        const nonce = await provider.getTransactionCount(address, 'pending');
+        const nonce = await provider.getTransactionCount(wallet.address, 'pending');
         
         const tx = new HybridLegacyTransaction({
             chainId: txOptions.chainId || 1337,
@@ -206,8 +200,13 @@ export class ERC20Token extends Contract {
             data: data,
         });
 
-        await tx.sign(wallet.ecdsaWallet, wallet.pqcWallet);
+        tx.sign(wallet.ecdsaWallet, wallet.pqcWallet);
         const serialized = tx.getHex();
         return await provider.sendRawTransaction(serialized);
     }
 }
+
+module.exports = {
+    Contract,
+    ERC20Token,
+};

package/src/index.js

@@ -4,13 +4,13 @@
  */
 
 // Providers
-export { QuorumProvider } from './provider.js';
+const { QuorumProvider } = require('./provider.js');
 
 // Wallets
-export { ECDSAWallet, PQCWallet, HybridWallet } from './wallet.js';
+const { ECDSAWallet, PQCWallet, HybridWallet } = require('./wallet.js');
 
 // Transactions
-export {
+const {
     LegacyTransaction,
     PQCLegacyTransaction,
     HybridLegacyTransaction,
@@ -18,20 +18,63 @@ export {
     PQCAccessListTransaction,
     DynamicFeeTransaction,
     PQCDynamicFeeTransaction,
-} from './transaction.js';
+} = require('./transaction.js');
 
 // ZK Transactions
-export { ZKTransaction } from './zk-transaction.js';
+const { ZKTransaction } = require('./zk-transaction.js');
 
 // Contracts
-export { Contract, ERC20Token } from './contract.js';
+const { Contract, ERC20Token } = require('./contract.js');
 
 // Constants
-export { TX_TYPE, PQC_TYPE, ZK_PROOF_SYSTEM, DEFAULT_CHAIN_ID } from './constants.js';
+const { TX_TYPE, PQC_TYPE, ZK_PROOF_SYSTEM, DEFAULT_CHAIN_ID } = require('./constants.js');
 
 // Utilities
-export { derivePQCAddress, deriveHybridAddress, isValidAddress } from './utils/address.js';
-export { encodeUint64, encodeBigInt, encodeSignature } from './utils/rlp.js';
+const { derivePQCAddress, deriveHybridAddress, isValidAddress } = require('./utils/address.js');
+const { encodeUint64, encodeBigInt, encodeSignature } = require('./utils/rlp.js');
 
 // Re-export ethers utilities for convenience
-export { ethers } from 'ethers';
+const { ethers } = require('ethers');
+
+module.exports = {
+    // Providers
+    QuorumProvider,
+    
+    // Wallets
+    ECDSAWallet,
+    PQCWallet,
+    HybridWallet,
+    
+    // Transactions
+    LegacyTransaction,
+    PQCLegacyTransaction,
+    HybridLegacyTransaction,
+    AccessListTransaction,
+    PQCAccessListTransaction,
+    DynamicFeeTransaction,
+    PQCDynamicFeeTransaction,
+    
+    // ZK Transactions
+    ZKTransaction,
+    
+    // Contracts
+    Contract,
+    ERC20Token,
+    
+    // Constants
+    TX_TYPE,
+    PQC_TYPE,
+    ZK_PROOF_SYSTEM,
+    DEFAULT_CHAIN_ID,
+    
+    // Utilities
+    derivePQCAddress,
+    deriveHybridAddress,
+    isValidAddress,
+    encodeUint64,
+    encodeBigInt,
+    encodeSignature,
+    
+    // Ethers
+    ethers,
+};

package/src/provider.js

@@ -3,9 +3,9 @@
  * Extends ethers.js JsonRpcProvider with Quorum-specific methods
  */
 
-import { ethers } from 'ethers';
+const { ethers } = require('ethers');
 
-export class QuorumProvider extends ethers.providers.JsonRpcProvider {
+class QuorumProvider extends ethers.providers.JsonRpcProvider {
     constructor(url, network) {
         super(url, network);
         this.url = url;
@@ -93,3 +93,7 @@ export class QuorumProvider extends ethers.providers.JsonRpcProvider {
         return await super.getBlock(blockNumber);
     }
 }
+
+module.exports = {
+    QuorumProvider,
+};

package/src/transaction.js

@@ -3,67 +3,21 @@
  * Supports Legacy, AccessList, DynamicFee transactions with ECDSA, PQC, and Hybrid signatures
  */
 
-import { ethers } from 'ethers';
-import { createRequire } from 'module';
-import { TX_TYPE, PQC_TYPE, DEFAULT_CHAIN_ID } from './constants.js';
-import { encodeUint64, encodeBigInt, encodeSignature } from './utils/rlp.js';
+const { ethers } = require('ethers');
+const { TX_TYPE, PQC_TYPE, DEFAULT_CHAIN_ID } = require('./constants.js');
+const { encodeUint64, encodeBigInt, encodeSignature } = require('./utils/rlp.js');
 
 // Import dilithium-crystals package
-// Use createRequire to handle both ES modules and CommonJS
-const require = createRequire(import.meta.url);
-
-// Lazy load dilithium-crystals to avoid top-level await issues
-let dilithiumCache = null;
-
-async function getDilithium() {
-    if (dilithiumCache) {
-        return dilithiumCache;
-    }
-    
-    try {
-        // Try ES module import first
-        const dilithiumModule = await import('dilithium-crystals');
-        dilithiumCache = dilithiumModule.default || dilithiumModule;
-    } catch (e) {
-        // Fallback to CommonJS require
-        try {
-            dilithiumCache = require('dilithium-crystals');
-            dilithiumCache = dilithiumCache.default || dilithiumCache;
-        } catch (e2) {
-            throw new Error(
-                `Failed to import dilithium-crystals: ${e.message}\n` +
-                `Please ensure dilithium-crystals is installed: npm install dilithium-crystals`
-            );
-        }
-    }
-    
-    return dilithiumCache;
-}
-
-// Helper function to sign with dilithium
-async function signWithDilithium(secretKey, hash) {
-    const dilithium = await getDilithium();
-    if (dilithium.sign) {
-        return dilithium.sign(secretKey, hash);
-    } else if (dilithium.signWithContext) {
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return dilithium.signWithContext(secretKey, hash, ctx);
-    } else {
-        throw new Error('dilithium-crystals does not expose sign method');
-    }
-}
-
-// Helper function to verify with dilithium
-async function verifyWithDilithium(publicKey, hash, signature) {
-    const dilithium = await getDilithium();
-    if (dilithium.verify) {
-        return dilithium.verify(publicKey, hash, signature);
-    } else if (dilithium.verifyWithContext) {
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return dilithium.verifyWithContext(publicKey, hash, signature, ctx);
-    } else {
-        throw new Error('dilithium-crystals does not expose verify method');
-    }
+let dilithium;
+try {
+    dilithium = require('dilithium-crystals');
+    // Handle both default export and named export patterns
+    dilithium = dilithium.default || dilithium;
+} catch (e) {
+    throw new Error(
+        `Failed to import dilithium-crystals: ${e.message}\n` +
+        `Please ensure dilithium-crystals is installed: npm install dilithium-crystals`
+    );
 }
 
 /**
@@ -82,7 +36,7 @@ class BaseTransaction {
 /**
  * Legacy ECDSA Transaction (Type 0)
  */
-export class LegacyTransaction extends BaseTransaction {
+class LegacyTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.LEGACY;
@@ -122,7 +76,7 @@ export class LegacyTransaction extends BaseTransaction {
 /**
  * Legacy PQC-only Transaction (Type 0 with PQC)
  */
-export class PQCLegacyTransaction extends BaseTransaction {
+class PQCLegacyTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.LEGACY;
@@ -164,22 +118,38 @@ export class PQCLegacyTransaction extends BaseTransaction {
     /**
      * Sign with PQC wallet
      * @param {PQCWallet} wallet - PQC wallet
-     * @returns {Promise<PQCLegacyTransaction>} This transaction
+     * @returns {PQCLegacyTransaction} This transaction
      */
-    async sign(wallet) {
+    sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
-        this.pqcPubKey = wallet.publicKey || (await wallet._ensureKeyPair(), wallet.publicKey);
-        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
+        this.pqcPubKey = wallet.publicKey;
+        // dilithium-crystals API: sign(secretKey, message) or signWithContext(secretKey, message, ctx)
+        if (dilithium.sign) {
+            this.pqcSig = dilithium.sign(wallet.secretKey, hash);
+        } else if (dilithium.signWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            this.pqcSig = dilithium.signWithContext(wallet.secretKey, hash, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose sign method');
+        }
         this.v = Number(this.chainId) * 2 + 35;
         this.r = '0x0';
         this.s = '0x0';
         return this;
     }
 
-    async verify() {
+    verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
+        // dilithium-crystals API: verify(publicKey, message, signature) or verifyWithContext
+        if (dilithium.verify) {
+            return dilithium.verify(this.pqcPubKey, hash, this.pqcSig);
+        } else if (dilithium.verifyWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.verifyWithContext(this.pqcPubKey, hash, this.pqcSig, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose verify method');
+        }
     }
 
     serialize() {
@@ -222,7 +192,7 @@ export class PQCLegacyTransaction extends BaseTransaction {
 /**
  * Legacy Hybrid Transaction (Type 0 with ECDSA + PQC)
  */
-export class HybridLegacyTransaction extends BaseTransaction {
+class HybridLegacyTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.LEGACY;
@@ -265,9 +235,9 @@ export class HybridLegacyTransaction extends BaseTransaction {
      * Sign with both ECDSA and PQC wallets
      * @param {ECDSAWallet} ecdsaWallet - ECDSA wallet
      * @param {PQCWallet} pqcWallet - PQC wallet
-     * @returns {Promise<HybridLegacyTransaction>} This transaction
+     * @returns {HybridLegacyTransaction} This transaction
      */
-    async sign(ecdsaWallet, pqcWallet) {
+    sign(ecdsaWallet, pqcWallet) {
         const hash = this.getSigningHash();
         const hashBytes = ethers.getBytes(hash);
 
@@ -279,19 +249,30 @@ export class HybridLegacyTransaction extends BaseTransaction {
         this.s = ecdsaSig.s;
 
         // PQC signature
-        if (!pqcWallet.publicKey) {
-            await pqcWallet._ensureKeyPair();
-        }
         this.pqcPubKey = pqcWallet.publicKey;
-        this.pqcSig = await signWithDilithium(pqcWallet.secretKey, hashBytes);
+        if (dilithium.sign) {
+            this.pqcSig = dilithium.sign(pqcWallet.secretKey, hashBytes);
+        } else if (dilithium.signWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            this.pqcSig = dilithium.signWithContext(pqcWallet.secretKey, hashBytes, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose sign method');
+        }
 
         return this;
     }
 
-    async verify() {
+    verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
+        if (dilithium.verify) {
+            return dilithium.verify(this.pqcPubKey, hash, this.pqcSig);
+        } else if (dilithium.verifyWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.verifyWithContext(this.pqcPubKey, hash, this.pqcSig, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose verify method');
+        }
     }
 
     serialize() {
@@ -334,7 +315,7 @@ export class HybridLegacyTransaction extends BaseTransaction {
 /**
  * AccessList Transaction (Type 1) - ECDSA
  */
-export class AccessListTransaction extends BaseTransaction {
+class AccessListTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.ACCESS_LIST;
@@ -366,7 +347,7 @@ export class AccessListTransaction extends BaseTransaction {
 /**
  * AccessList PQC Transaction (Type 1 with PQC)
  */
-export class PQCAccessListTransaction extends BaseTransaction {
+class PQCAccessListTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.ACCESS_LIST;
@@ -410,20 +391,31 @@ export class PQCAccessListTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    async sign(wallet) {
+    sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
-        if (!wallet.publicKey) {
-            await wallet._ensureKeyPair();
-        }
         this.pqcPubKey = wallet.publicKey;
-        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
+        if (dilithium.sign) {
+            this.pqcSig = dilithium.sign(wallet.secretKey, hash);
+        } else if (dilithium.signWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            this.pqcSig = dilithium.signWithContext(wallet.secretKey, hash, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose sign method');
+        }
         return this;
     }
 
-    async verify() {
+    verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
+        if (dilithium.verify) {
+            return dilithium.verify(this.pqcPubKey, hash, this.pqcSig);
+        } else if (dilithium.verifyWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.verifyWithContext(this.pqcPubKey, hash, this.pqcSig, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose verify method');
+        }
     }
 
     serialize() {
@@ -477,7 +469,7 @@ export class PQCAccessListTransaction extends BaseTransaction {
 /**
  * DynamicFee Transaction (Type 2) - ECDSA
  */
-export class DynamicFeeTransaction extends BaseTransaction {
+class DynamicFeeTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.DYNAMIC_FEE;
@@ -511,7 +503,7 @@ export class DynamicFeeTransaction extends BaseTransaction {
 /**
  * DynamicFee PQC Transaction (Type 2 with PQC)
  */
-export class PQCDynamicFeeTransaction extends BaseTransaction {
+class PQCDynamicFeeTransaction extends BaseTransaction {
     constructor(params) {
         super(params);
         this.type = TX_TYPE.DYNAMIC_FEE;
@@ -558,20 +550,31 @@ export class PQCDynamicFeeTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    async sign(wallet) {
+    sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
-        if (!wallet.publicKey) {
-            await wallet._ensureKeyPair();
-        }
         this.pqcPubKey = wallet.publicKey;
-        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
+        if (dilithium.sign) {
+            this.pqcSig = dilithium.sign(wallet.secretKey, hash);
+        } else if (dilithium.signWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            this.pqcSig = dilithium.signWithContext(wallet.secretKey, hash, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose sign method');
+        }
         return this;
     }
 
-    async verify() {
+    verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
+        if (dilithium.verify) {
+            return dilithium.verify(this.pqcPubKey, hash, this.pqcSig);
+        } else if (dilithium.verifyWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.verifyWithContext(this.pqcPubKey, hash, this.pqcSig, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose verify method');
+        }
     }
 
     serialize() {
@@ -623,3 +626,13 @@ export class PQCDynamicFeeTransaction extends BaseTransaction {
         return ethers.hexlify(this.serialize());
     }
 }
+
+module.exports = {
+    LegacyTransaction,
+    PQCLegacyTransaction,
+    HybridLegacyTransaction,
+    AccessListTransaction,
+    PQCAccessListTransaction,
+    DynamicFeeTransaction,
+    PQCDynamicFeeTransaction,
+};

package/src/utils/address.js

@@ -3,14 +3,14 @@
  * Handles address derivation for PQC and Hybrid addresses
  */
 
-import { ethers } from 'ethers';
+const { ethers } = require('ethers');
 
 /**
  * Derive PQC address from Dilithium public key
  * @param {Uint8Array} publicKey - Dilithium public key
  * @returns {string} Ethereum address
  */
-export function derivePQCAddress(publicKey) {
+function derivePQCAddress(publicKey) {
     const hash = ethers.keccak256(publicKey);
     return ethers.getAddress('0x' + hash.slice(-40));
 }
@@ -21,7 +21,7 @@ export function derivePQCAddress(publicKey) {
  * @param {Uint8Array} dilithiumPublicKey - Dilithium public key
  * @returns {string} Hybrid Ethereum address
  */
-export function deriveHybridAddress(ecdsaPublicKey, dilithiumPublicKey) {
+function deriveHybridAddress(ecdsaPublicKey, dilithiumPublicKey) {
     // Remove 0x04 prefix from ECDSA public key if present
     let ecdsaBytes = ecdsaPublicKey;
     if (ecdsaBytes.length === 65 && ecdsaBytes[0] === 4) {
@@ -43,6 +43,12 @@ export function deriveHybridAddress(ecdsaPublicKey, dilithiumPublicKey) {
  * @param {string} address - Address to validate
  * @returns {boolean}
  */
-export function isValidAddress(address) {
+function isValidAddress(address) {
     return ethers.utils.isAddress(address);
 }
+
+module.exports = {
+    derivePQCAddress,
+    deriveHybridAddress,
+    isValidAddress,
+};

package/src/utils/rlp.js

@@ -3,13 +3,13 @@
  * Handles proper encoding for Go RLP compatibility
  */
 
-import { ethers } from 'ethers';
+const { ethers } = require('ethers');
 
 /**
  * Encode uint64 value for RLP as hex string
  * In Go RLP, uint64(0) encodes as empty bytes, non-zero as canonical bytes
  */
-export function encodeUint64(value) {
+function encodeUint64(value) {
     if (value === 0 || value === 0n || value === null || value === undefined) {
         return '0x';
     }
@@ -21,7 +21,7 @@ export function encodeUint64(value) {
  * Encode *big.Int value for RLP as hex string
  * Go RLP encodes *big.Int(0) as 0x80 (empty bytes), NOT 0x00!
  */
-export function encodeBigInt(value) {
+function encodeBigInt(value) {
     if (value === 0 || value === 0n || value === null || value === undefined) {
         return '0x';
     }
@@ -33,7 +33,7 @@ export function encodeBigInt(value) {
  * Encode signature value (R, S) for RLP as hex string
  * Removes leading zeros for canonical form (required for *big.Int in Go RLP)
  */
-export function encodeSignature(value) {
+function encodeSignature(value) {
     if (!value || value === '0x0' || value === '0x' || value === '0x00') {
         return '0x';
     }
@@ -54,3 +54,9 @@ export function encodeSignature(value) {
     bytes = bytes.slice(startIdx);
     return ethers.hexlify(bytes);
 }
+
+module.exports = {
+    encodeUint64,
+    encodeBigInt,
+    encodeSignature,
+};

package/src/wallet.js

@@ -3,47 +3,27 @@
  * Supports ECDSA, PQC (Dilithium), and Hybrid wallets
  */
 
-import { ethers } from 'ethers';
-import { createRequire } from 'module';
-import { derivePQCAddress, deriveHybridAddress } from './utils/address.js';
+const { ethers } = require('ethers');
+const { derivePQCAddress, deriveHybridAddress } = require('./utils/address.js');
 
 // Import dilithium-crystals package
 // This package provides Dilithium3 (ML-DSA-65 equivalent) implementation
-// Use createRequire to handle both ES modules and CommonJS
-const require = createRequire(import.meta.url);
-
-// Lazy load dilithium-crystals to avoid top-level await issues
-let dilithiumCache = null;
-
-async function getDilithium() {
-    if (dilithiumCache) {
-        return dilithiumCache;
-    }
-    
-    try {
-        // Try ES module import first
-        const dilithiumModule = await import('dilithium-crystals');
-        dilithiumCache = dilithiumModule.default || dilithiumModule;
-    } catch (e) {
-        // Fallback to CommonJS require
-        try {
-            dilithiumCache = require('dilithium-crystals');
-            dilithiumCache = dilithiumCache.default || dilithiumCache;
-        } catch (e2) {
-            throw new Error(
-                `Failed to import dilithium-crystals: ${e.message}\n` +
-                `Please ensure dilithium-crystals is installed: npm install dilithium-crystals`
-            );
-        }
-    }
-    
-    return dilithiumCache;
+let dilithium;
+try {
+    dilithium = require('dilithium-crystals');
+    // Handle both default export and named export patterns
+    dilithium = dilithium.default || dilithium;
+} catch (e) {
+    throw new Error(
+        `Failed to import dilithium-crystals: ${e.message}\n` +
+        `Please ensure dilithium-crystals is installed: npm install dilithium-crystals`
+    );
 }
 
 /**
  * ECDSA Wallet (standard Ethereum wallet)
  */
-export class ECDSAWallet {
+class ECDSAWallet {
     constructor(privateKey, provider = null) {
         this.wallet = new ethers.Wallet(privateKey, provider);
         this.address = this.wallet.address;
@@ -81,35 +61,19 @@ export class ECDSAWallet {
 /**
  * PQC Wallet (Dilithium/ML-DSA-65)
  */
-export class PQCWallet {
+class PQCWallet {
     constructor(secretKey = null, publicKey = null) {
         if (secretKey && publicKey) {
             this.secretKey = secretKey instanceof Uint8Array ? secretKey : new Uint8Array(secretKey);
             this.publicKey = publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey);
         } else {
-            // Generate new key pair - will be done lazily on first use
-            this.secretKey = null;
-            this.publicKey = null;
-            this._keyPairGenerated = false;
-        }
-        this.address = null; // Will be set after key generation
-    }
-
-    /**
-     * Initialize key pair if not already done
-     */
-    async _ensureKeyPair() {
-        if (this._keyPairGenerated) {
-            return;
+            // Generate new key pair using dilithium-crystals
+            // dilithium-crystals typically uses keygen() or generateKeyPair()
+            const keyPair = dilithium.keygen ? dilithium.keygen() : dilithium.generateKeyPair();
+            this.secretKey = keyPair.secretKey || keyPair.privateKey;
+            this.publicKey = keyPair.publicKey;
         }
-        
-        const dilithium = await getDilithium();
-        // dilithium-crystals typically uses keygen() or generateKeyPair()
-        const keyPair = dilithium.keygen ? dilithium.keygen() : dilithium.generateKeyPair();
-        this.secretKey = keyPair.secretKey || keyPair.privateKey;
-        this.publicKey = keyPair.publicKey;
         this.address = derivePQCAddress(this.publicKey);
-        this._keyPairGenerated = true;
     }
 
     /**
@@ -126,24 +90,17 @@ export class PQCWallet {
         }
         const secret = secretKey instanceof Uint8Array ? secretKey : ethers.getBytes(secretKey);
         const pub = publicKey instanceof Uint8Array ? publicKey : ethers.getBytes(publicKey);
-        const wallet = new PQCWallet(secret, pub);
-        wallet.address = derivePQCAddress(wallet.publicKey);
-        wallet._keyPairGenerated = true;
-        return wallet;
+        return new PQCWallet(secret, pub);
     }
 
     /**
      * Sign a message hash
      * @param {Uint8Array} hash - Message hash (32 bytes)
-     * @returns {Promise<Uint8Array>} Signature
+     * @returns {Uint8Array} Signature
      */
-    async sign(hash) {
-        if (!this.secretKey) {
-            await this._ensureKeyPair();
-        }
-        
-        const dilithium = await getDilithium();
-        // dilithium-crystals API: sign(secretKey, message) or signWithContext(secretKey, message, ctx)
+    sign(hash) {
+        // dilithium-crystals API: sign(secretKey, message)
+        // Some implementations may require context, but we'll try without first
         if (dilithium.sign) {
             return dilithium.sign(this.secretKey, hash);
         } else if (dilithium.signWithContext) {
@@ -158,15 +115,10 @@ export class PQCWallet {
      * Verify a signature
      * @param {Uint8Array} hash - Message hash
      * @param {Uint8Array} signature - Signature to verify
-     * @returns {Promise<boolean>} True if signature is valid
+     * @returns {boolean} True if signature is valid
      */
-    async verify(hash, signature) {
-        if (!this.publicKey) {
-            throw new Error('Public key not set');
-        }
-        
-        const dilithium = await getDilithium();
-        // dilithium-crystals API: verify(publicKey, message, signature) or verifyWithContext
+    verify(hash, signature) {
+        // dilithium-crystals API: verify(publicKey, message, signature)
         if (dilithium.verify) {
             return dilithium.verify(this.publicKey, hash, signature);
         } else if (dilithium.verifyWithContext) {
@@ -179,23 +131,17 @@ export class PQCWallet {
 
     /**
      * Get public key as hex string
-     * @returns {Promise<string>} Public key (hex)
+     * @returns {string} Public key (hex)
      */
-    async getPublicKeyHex() {
-        if (!this.publicKey) {
-            await this._ensureKeyPair();
-        }
+    getPublicKeyHex() {
         return ethers.hexlify(this.publicKey);
     }
 
     /**
      * Get secret key as hex string (use with caution!)
-     * @returns {Promise<string>} Secret key (hex)
+     * @returns {string} Secret key (hex)
      */
-    async getSecretKeyHex() {
-        if (!this.secretKey) {
-            await this._ensureKeyPair();
-        }
+    getSecretKeyHex() {
         return ethers.hexlify(this.secretKey);
     }
 }
@@ -203,36 +149,17 @@ export class PQCWallet {
 /**
  * Hybrid Wallet (ECDSA + PQC)
  */
-export class HybridWallet {
+class HybridWallet {
     constructor(ecdsaWallet, pqcWallet) {
         if (!ecdsaWallet || !pqcWallet) {
             throw new Error('Both ECDSA and PQC wallets are required for Hybrid wallet');
         }
         this.ecdsaWallet = ecdsaWallet instanceof ECDSAWallet ? ecdsaWallet : new ECDSAWallet(ecdsaWallet);
         this.pqcWallet = pqcWallet instanceof PQCWallet ? pqcWallet : new PQCWallet();
-        // Address will be computed when PQC wallet is ready
-        this.address = null;
-    }
-
-    /**
-     * Get the hybrid address (computed from ECDSA + PQC public keys)
-     * @returns {Promise<string>} Hybrid address
-     */
-    async getAddress() {
-        if (this.address) {
-            return this.address;
-        }
-        
-        // Ensure PQC wallet has keys
-        if (!this.pqcWallet.publicKey) {
-            await this.pqcWallet._ensureKeyPair();
-        }
-        
         this.address = deriveHybridAddress(
             ethers.getBytes(this.ecdsaWallet.getPublicKey()),
             this.pqcWallet.publicKey
         );
-        return this.address;
     }
 
     /**
@@ -245,12 +172,7 @@ export class HybridWallet {
     static fromKeys(ecdsaPrivateKey, pqcSecretKey, pqcPublicKey) {
         const ecdsaWallet = new ECDSAWallet(ecdsaPrivateKey);
         const pqcWallet = new PQCWallet(pqcSecretKey, pqcPublicKey);
-        const wallet = new HybridWallet(ecdsaWallet, pqcWallet);
-        wallet.address = deriveHybridAddress(
-            ethers.getBytes(ecdsaWallet.getPublicKey()),
-            pqcWallet.publicKey
-        );
-        return wallet;
+        return new HybridWallet(ecdsaWallet, pqcWallet);
     }
 
     /**
@@ -263,3 +185,9 @@ export class HybridWallet {
         return new HybridWallet(connectedECDSA, this.pqcWallet);
     }
 }
+
+module.exports = {
+    ECDSAWallet,
+    PQCWallet,
+    HybridWallet,
+};

package/src/zk-transaction.js

@@ -2,14 +2,14 @@
  * Zero-Knowledge Proof Transaction Support
  */
 
-import { ethers } from 'ethers';
-import { TX_TYPE, ZK_PROOF_SYSTEM } from './constants.js';
+const { ethers } = require('ethers');
+const { TX_TYPE, ZK_PROOF_SYSTEM } = require('./constants.js');
 
 /**
  * ZK Transaction Builder
  * Creates transactions with zero-knowledge proofs
  */
-export class ZKTransaction {
+class ZKTransaction {
     constructor(params) {
         this.type = TX_TYPE.ZK_PRIVATE;
         this.chainId = params.chainId || 1337;
@@ -93,3 +93,7 @@ export class ZKTransaction {
         return await provider.send('quorum_sendZKTransaction', [args]);
     }
 }
+
+module.exports = {
+    ZKTransaction,
+};

package/index.cjs

@@ -1,37 +0,0 @@
-/**
- * CommonJS entry point for @cheny56/node-client
- * 
- * NOTE: This library is built as ES modules. For CommonJS compatibility,
- * you need to use dynamic import() instead of require().
- * 
- * Example:
- *   const { QuorumProvider } = await import('@cheny56/node-client');
- * 
- * Or use ES modules in your project:
- *   import { QuorumProvider } from '@cheny56/node-client';
- */
-
-// Re-export using dynamic import
-// This allows require() to work, but returns a Promise
-const modPromise = import('./src/index.js');
-
-// For synchronous require(), we need to throw a helpful error
-// and suggest using import() or ES modules
-module.exports = new Proxy({}, {
-    get(target, prop) {
-        if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-            // Make it thenable so it works with await import()
-            return modPromise.then(mod => mod[prop]).bind(modPromise);
-        }
-        
-        throw new Error(
-            `Cannot access '${prop}' synchronously. ` +
-            `This package uses ES modules. Please use:\n` +
-            `  const { ${prop} } = await import('@cheny56/node-client');\n` +
-            `Or switch your project to ES modules by adding "type": "module" to package.json`
-        );
-    }
-});
-
-// Also export as a Promise for await import() usage
-module.exports.default = modPromise;