@cheny56/node-client 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheny56/node-client",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Client library for Quorum blockchain with Post-Quantum Cryptography (PQC) and Zero-Knowledge Proof (ZK) support",
   "main": "./index.cjs",
   "module": "./src/index.js",
@@ -42,7 +42,7 @@
   "license": "LGPL-3.0",
   "dependencies": {
     "ethers": "^5.7.2",
-    "@noble/post-quantum": "^0.5.4"
+    "dilithium-crystals": "^1.0.0"
   },
   "peerDependencies": {},
   "devDependencies": {},

package/src/contract.js

@@ -160,6 +160,10 @@ 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({
@@ -172,7 +176,7 @@ export class ERC20Token extends Contract {
             data: data,
         });
 
-        tx.sign(wallet);
+        await tx.sign(wallet);
         const serialized = tx.getHex();
         return await provider.sendRawTransaction(serialized);
     }
@@ -188,7 +192,9 @@ export class ERC20Token extends Contract {
      */
     async transferHybrid(wallet, provider, to, amount, txOptions = {}) {
         const data = this.encodeFunctionData('transfer', [to, amount]);
-        const nonce = await provider.getTransactionCount(wallet.address, 'pending');
+        // Ensure wallet has address
+        const address = await wallet.getAddress();
+        const nonce = await provider.getTransactionCount(address, 'pending');
         
         const tx = new HybridLegacyTransaction({
             chainId: txOptions.chainId || 1337,
@@ -200,7 +206,7 @@ export class ERC20Token extends Contract {
             data: data,
         });
 
-        tx.sign(wallet.ecdsaWallet, wallet.pqcWallet);
+        await tx.sign(wallet.ecdsaWallet, wallet.pqcWallet);
         const serialized = tx.getHex();
         return await provider.sendRawTransaction(serialized);
     }

package/src/transaction.js

@@ -8,19 +8,62 @@ import { createRequire } from 'module';
 import { TX_TYPE, PQC_TYPE, DEFAULT_CHAIN_ID } from './constants.js';
 import { encodeUint64, encodeBigInt, encodeSignature } from './utils/rlp.js';
 
-// Get ml_dsa65 from @noble/post-quantum using createRequire
-// This works around ES module import issues with @noble/post-quantum
+// Import dilithium-crystals package
+// Use createRequire to handle both ES modules and CommonJS
 const require = createRequire(import.meta.url);
 
-let ml_dsa65;
-try {
-    // @noble/post-quantum uses CommonJS exports, so we use require
-    ml_dsa65 = require('@noble/post-quantum/ml-dsa').ml_dsa65;
-} catch (e) {
-    throw new Error(
-        `Failed to import @noble/post-quantum: ${e.message}\n` +
-        `Please ensure @noble/post-quantum is installed: npm install @noble/post-quantum`
-    );
+// 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');
+    }
 }
 
 /**
@@ -121,24 +164,22 @@ export class PQCLegacyTransaction extends BaseTransaction {
     /**
      * Sign with PQC wallet
      * @param {PQCWallet} wallet - PQC wallet
-     * @returns {PQCLegacyTransaction} This transaction
+     * @returns {Promise<PQCLegacyTransaction>} This transaction
      */
-    sign(wallet) {
+    async sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
-        this.pqcPubKey = wallet.publicKey;
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        this.pqcSig = ml_dsa65.sign(wallet.secretKey, hash, ctx);
+        this.pqcPubKey = wallet.publicKey || (await wallet._ensureKeyPair(), wallet.publicKey);
+        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
         this.v = Number(this.chainId) * 2 + 35;
         this.r = '0x0';
         this.s = '0x0';
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.verify(this.pqcPubKey, hash, this.pqcSig, ctx);
+        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
     }
 
     serialize() {
@@ -224,9 +265,9 @@ export class HybridLegacyTransaction extends BaseTransaction {
      * Sign with both ECDSA and PQC wallets
      * @param {ECDSAWallet} ecdsaWallet - ECDSA wallet
      * @param {PQCWallet} pqcWallet - PQC wallet
-     * @returns {HybridLegacyTransaction} This transaction
+     * @returns {Promise<HybridLegacyTransaction>} This transaction
      */
-    sign(ecdsaWallet, pqcWallet) {
+    async sign(ecdsaWallet, pqcWallet) {
         const hash = this.getSigningHash();
         const hashBytes = ethers.getBytes(hash);
 
@@ -238,18 +279,19 @@ export class HybridLegacyTransaction extends BaseTransaction {
         this.s = ecdsaSig.s;
 
         // PQC signature
-        const ctx = new TextEncoder().encode('ML-DSA-65');
+        if (!pqcWallet.publicKey) {
+            await pqcWallet._ensureKeyPair();
+        }
         this.pqcPubKey = pqcWallet.publicKey;
-        this.pqcSig = ml_dsa65.sign(pqcWallet.secretKey, hashBytes, ctx);
+        this.pqcSig = await signWithDilithium(pqcWallet.secretKey, hashBytes);
 
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.verify(this.pqcPubKey, hash, this.pqcSig, ctx);
+        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
     }
 
     serialize() {
@@ -368,19 +410,20 @@ export class PQCAccessListTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    sign(wallet) {
+    async sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
+        if (!wallet.publicKey) {
+            await wallet._ensureKeyPair();
+        }
         this.pqcPubKey = wallet.publicKey;
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        this.pqcSig = ml_dsa65.sign(wallet.secretKey, hash, ctx);
+        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.verify(this.pqcPubKey, hash, this.pqcSig, ctx);
+        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
     }
 
     serialize() {
@@ -515,19 +558,20 @@ export class PQCDynamicFeeTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    sign(wallet) {
+    async sign(wallet) {
         const hash = ethers.getBytes(this.getSigningHash());
+        if (!wallet.publicKey) {
+            await wallet._ensureKeyPair();
+        }
         this.pqcPubKey = wallet.publicKey;
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        this.pqcSig = ml_dsa65.sign(wallet.secretKey, hash, ctx);
+        this.pqcSig = await signWithDilithium(wallet.secretKey, hash);
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.verify(this.pqcPubKey, hash, this.pqcSig, ctx);
+        return await verifyWithDilithium(this.pqcPubKey, hash, this.pqcSig);
     }
 
     serialize() {

package/src/wallet.js

@@ -7,20 +7,37 @@ import { ethers } from 'ethers';
 import { createRequire } from 'module';
 import { derivePQCAddress, deriveHybridAddress } from './utils/address.js';
 
-// Get ml_dsa65 from @noble/post-quantum using createRequire
-// This works around ES module import issues with @noble/post-quantum
-// @noble/post-quantum uses CommonJS exports, so we use require() in ES modules
+// 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);
 
-let ml_dsa65;
-try {
-    // @noble/post-quantum uses CommonJS exports, so we use require
-    ml_dsa65 = require('@noble/post-quantum/ml-dsa').ml_dsa65;
-} catch (e) {
-    throw new Error(
-        `Failed to import @noble/post-quantum: ${e.message}\n` +
-        `Please ensure @noble/post-quantum is installed: npm install @noble/post-quantum`
-    );
+// 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;
 }
 
 /**
@@ -70,12 +87,29 @@ export class PQCWallet {
             this.secretKey = secretKey instanceof Uint8Array ? secretKey : new Uint8Array(secretKey);
             this.publicKey = publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey);
         } else {
-            // Generate new key pair
-            const keyPair = ml_dsa65.keygen();
-            this.secretKey = keyPair.secretKey;
-            this.publicKey = keyPair.publicKey;
+            // 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;
+        }
+        
+        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;
     }
 
     /**
@@ -92,43 +126,76 @@ export class PQCWallet {
         }
         const secret = secretKey instanceof Uint8Array ? secretKey : ethers.getBytes(secretKey);
         const pub = publicKey instanceof Uint8Array ? publicKey : ethers.getBytes(publicKey);
-        return new PQCWallet(secret, pub);
+        const wallet = new PQCWallet(secret, pub);
+        wallet.address = derivePQCAddress(wallet.publicKey);
+        wallet._keyPairGenerated = true;
+        return wallet;
     }
 
     /**
      * Sign a message hash
      * @param {Uint8Array} hash - Message hash (32 bytes)
-     * @returns {Uint8Array} Signature
+     * @returns {Promise<Uint8Array>} Signature
      */
-    sign(hash) {
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.sign(this.secretKey, hash, ctx);
+    async sign(hash) {
+        if (!this.secretKey) {
+            await this._ensureKeyPair();
+        }
+        
+        const dilithium = await getDilithium();
+        // dilithium-crystals API: sign(secretKey, message) or signWithContext(secretKey, message, ctx)
+        if (dilithium.sign) {
+            return dilithium.sign(this.secretKey, hash);
+        } else if (dilithium.signWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.signWithContext(this.secretKey, hash, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose sign method');
+        }
     }
 
     /**
      * Verify a signature
      * @param {Uint8Array} hash - Message hash
      * @param {Uint8Array} signature - Signature to verify
-     * @returns {boolean} True if signature is valid
+     * @returns {Promise<boolean>} True if signature is valid
      */
-    verify(hash, signature) {
-        const ctx = new TextEncoder().encode('ML-DSA-65');
-        return ml_dsa65.verify(this.publicKey, hash, signature, ctx);
+    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
+        if (dilithium.verify) {
+            return dilithium.verify(this.publicKey, hash, signature);
+        } else if (dilithium.verifyWithContext) {
+            const ctx = new TextEncoder().encode('ML-DSA-65');
+            return dilithium.verifyWithContext(this.publicKey, hash, signature, ctx);
+        } else {
+            throw new Error('dilithium-crystals does not expose verify method');
+        }
     }
 
     /**
      * Get public key as hex string
-     * @returns {string} Public key (hex)
+     * @returns {Promise<string>} Public key (hex)
      */
-    getPublicKeyHex() {
+    async getPublicKeyHex() {
+        if (!this.publicKey) {
+            await this._ensureKeyPair();
+        }
         return ethers.hexlify(this.publicKey);
     }
 
     /**
      * Get secret key as hex string (use with caution!)
-     * @returns {string} Secret key (hex)
+     * @returns {Promise<string>} Secret key (hex)
      */
-    getSecretKeyHex() {
+    async getSecretKeyHex() {
+        if (!this.secretKey) {
+            await this._ensureKeyPair();
+        }
         return ethers.hexlify(this.secretKey);
     }
 }
@@ -143,10 +210,29 @@ export class HybridWallet {
         }
         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;
     }
 
     /**
@@ -159,7 +245,12 @@ export class HybridWallet {
     static fromKeys(ecdsaPrivateKey, pqcSecretKey, pqcPublicKey) {
         const ecdsaWallet = new ECDSAWallet(ecdsaPrivateKey);
         const pqcWallet = new PQCWallet(pqcSecretKey, pqcPublicKey);
-        return new HybridWallet(ecdsaWallet, pqcWallet);
+        const wallet = new HybridWallet(ecdsaWallet, pqcWallet);
+        wallet.address = deriveHybridAddress(
+            ethers.getBytes(ecdsaWallet.getPublicKey()),
+            pqcWallet.publicKey
+        );
+        return wallet;
     }
 
     /**