@cheny56/node-client 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheny56/node-client",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Client library for Quorum blockchain with Post-Quantum Cryptography (PQC) and Zero-Knowledge Proof (ZK) support",
   "main": "./src/index.js",
   "types": "src/index.d.ts",

package/src/contract.js

@@ -160,6 +160,8 @@ class ERC20Token extends Contract {
      */
     async transferPQC(wallet, provider, to, amount, txOptions = {}) {
         const data = this.encodeFunctionData('transfer', [to, amount]);
+        // Ensure wallet is initialized
+        await wallet._initPromise;
         const nonce = await provider.getTransactionCount(wallet.address, 'pending');
         
         const tx = new PQCLegacyTransaction({
@@ -172,7 +174,7 @@ class ERC20Token extends Contract {
             data: data,
         });
 
-        tx.sign(wallet);
+        await tx.sign(wallet);
         const serialized = tx.getHex();
         return await provider.sendRawTransaction(serialized);
     }
@@ -188,7 +190,9 @@ 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 is initialized
+        const address = await wallet.getAddress();
+        const nonce = await provider.getTransactionCount(address, 'pending');
         
         const tx = new HybridLegacyTransaction({
             chainId: txOptions.chainId || 1337,
@@ -200,7 +204,7 @@ 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

@@ -118,30 +118,26 @@ 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) {
+        // Ensure wallet is initialized
+        await wallet._initPromise;
+        
         const hash = ethers.getBytes(this.getSigningHash());
         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');
-        }
+        // Use wallet's sign method which handles the async properly
+        this.pqcSig = await wallet.sign(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());
-        // dilithium-crystals API: verify(publicKey, message, signature) or verifyWithContext
+        // Use dilithium verify directly
         if (dilithium.verify) {
             return dilithium.verify(this.pqcPubKey, hash, this.pqcSig);
         } else if (dilithium.verifyWithContext) {
@@ -235,9 +231,12 @@ 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) {
+        // Ensure PQC wallet is initialized
+        await pqcWallet._initPromise;
+        
         const hash = this.getSigningHash();
         const hashBytes = ethers.getBytes(hash);
 
@@ -248,16 +247,9 @@ class HybridLegacyTransaction extends BaseTransaction {
         this.r = ecdsaSig.r;
         this.s = ecdsaSig.s;
 
-        // PQC signature
+        // PQC signature - use wallet's sign method
         this.pqcPubKey = pqcWallet.publicKey;
-        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');
-        }
+        this.pqcSig = await pqcWallet.sign(hashBytes);
 
         return this;
     }
@@ -391,21 +383,17 @@ class PQCAccessListTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    sign(wallet) {
+    async sign(wallet) {
+        // Ensure wallet is initialized
+        await wallet._initPromise;
+        
         const hash = ethers.getBytes(this.getSigningHash());
         this.pqcPubKey = wallet.publicKey;
-        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.pqcSig = await wallet.sign(hash);
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
         if (dilithium.verify) {
@@ -550,21 +538,17 @@ class PQCDynamicFeeTransaction extends BaseTransaction {
         return ethers.keccak256(ethers.hexlify(prefixed));
     }
 
-    sign(wallet) {
+    async sign(wallet) {
+        // Ensure wallet is initialized
+        await wallet._initPromise;
+        
         const hash = ethers.getBytes(this.getSigningHash());
         this.pqcPubKey = wallet.publicKey;
-        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.pqcSig = await wallet.sign(hash);
         return this;
     }
 
-    verify() {
+    async verify() {
         if (!this.pqcSig || !this.pqcPubKey) return false;
         const hash = ethers.getBytes(this.getSigningHash());
         if (dilithium.verify) {

package/src/wallet.js

@@ -66,17 +66,58 @@ class PQCWallet {
         if (secretKey && publicKey) {
             this.secretKey = secretKey instanceof Uint8Array ? secretKey : new Uint8Array(secretKey);
             this.publicKey = publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey);
+            this.address = derivePQCAddress(this.publicKey);
+            this._initialized = true;
+            this._initPromise = Promise.resolve();
         } else {
             // Generate new key pair using dilithium-crystals
-            // dilithium-crystals uses keygen() which returns { publicKey, secretKey }
-            if (!dilithium.keygen) {
-                throw new Error('dilithium-crystals does not expose keygen method. Please check the package API.');
-            }
-            const keyPair = dilithium.keygen();
-            this.secretKey = keyPair.secretKey;
-            this.publicKey = keyPair.publicKey;
+            // dilithium-crystals uses keyPair() which is async and returns { publicKey, secretKey }
+            this.secretKey = null;
+            this.publicKey = null;
+            this.address = null;
+            this._initialized = false;
+            // Start initialization immediately
+            this._initPromise = this._ensureKeyPair();
         }
+    }
+
+    /**
+     * Create a new PQC wallet with initialized keys (static factory method)
+     * @returns {Promise<PQCWallet>} Initialized wallet
+     */
+    static async create() {
+        const wallet = new PQCWallet();
+        await wallet._initPromise;
+        return wallet;
+    }
+
+    /**
+     * Initialize key pair if not already done (async)
+     * @private
+     */
+    async _ensureKeyPair() {
+        if (this._initialized) {
+            return;
+        }
+        
+        if (!dilithium.keyPair) {
+            throw new Error('dilithium-crystals does not expose keyPair method. Please check the package API.');
+        }
+        
+        const keyPair = await dilithium.keyPair();
+        this.secretKey = keyPair.secretKey;
+        this.publicKey = keyPair.publicKey;
         this.address = derivePQCAddress(this.publicKey);
+        this._initialized = true;
+    }
+
+    /**
+     * Get address (will initialize keys if needed)
+     * @returns {Promise<string>} Wallet address
+     */
+    async getAddress() {
+        await this._initPromise;
+        return this.address;
     }
 
     /**
@@ -99,9 +140,12 @@ class PQCWallet {
     /**
      * Sign a message hash
      * @param {Uint8Array} hash - Message hash (32 bytes)
-     * @returns {Uint8Array} Signature
+     * @returns {Promise<Uint8Array>} Signature
      */
-    sign(hash) {
+    async sign(hash) {
+        // Ensure key pair is initialized
+        await this._initPromise;
+        
         // dilithium-crystals API: sign(secretKey, message)
         // Some implementations may require context, but we'll try without first
         if (dilithium.sign) {
@@ -118,9 +162,12 @@ class PQCWallet {
      * 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) {
+    async verify(hash, signature) {
+        // Ensure key pair is initialized
+        await this._initPromise;
+        
         // dilithium-crystals API: verify(publicKey, message, signature)
         if (dilithium.verify) {
             return dilithium.verify(this.publicKey, hash, signature);
@@ -134,17 +181,19 @@ class PQCWallet {
 
     /**
      * Get public key as hex string
-     * @returns {string} Public key (hex)
+     * @returns {Promise<string>} Public key (hex)
      */
-    getPublicKeyHex() {
+    async getPublicKeyHex() {
+        await this._initPromise;
         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() {
+        await this._initPromise;
         return ethers.hexlify(this.secretKey);
     }
 }
@@ -159,10 +208,46 @@ class HybridWallet {
         }
         this.ecdsaWallet = ecdsaWallet instanceof ECDSAWallet ? ecdsaWallet : new ECDSAWallet(ecdsaWallet);
         this.pqcWallet = pqcWallet instanceof PQCWallet ? pqcWallet : new PQCWallet();
+        this.address = null; // Will be computed when PQC wallet is initialized
+        this._initialized = false;
+    }
+
+    /**
+     * Create a new Hybrid wallet with initialized keys (static factory method)
+     * @param {ECDSAWallet|string} ecdsaWallet - ECDSA wallet or private key
+     * @returns {Promise<HybridWallet>} Initialized hybrid wallet
+     */
+    static async create(ecdsaWallet) {
+        const ecdsa = ecdsaWallet instanceof ECDSAWallet ? ecdsaWallet : new ECDSAWallet(ecdsaWallet);
+        const pqc = new PQCWallet();
+        await pqc._initPromise; // Wait for PQC keys to be generated
+        const wallet = new HybridWallet(ecdsa, pqc);
+        wallet.address = deriveHybridAddress(
+            ethers.getBytes(ecdsa.getPublicKey()),
+            pqc.publicKey
+        );
+        wallet._initialized = true;
+        return wallet;
+    }
+
+    /**
+     * Get the hybrid address (computed from ECDSA + PQC public keys)
+     * @returns {Promise<string>} Hybrid address
+     */
+    async getAddress() {
+        if (this._initialized && this.address) {
+            return this.address;
+        }
+        
+        // Ensure PQC wallet has keys
+        await this.pqcWallet._initPromise;
+        
         this.address = deriveHybridAddress(
             ethers.getBytes(this.ecdsaWallet.getPublicKey()),
             this.pqcWallet.publicKey
         );
+        this._initialized = true;
+        return this.address;
     }
 
     /**
@@ -175,7 +260,13 @@ 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
+        );
+        wallet._initialized = true;
+        return wallet;
     }
 
     /**