@cheny56/node-client 1.0.0

package/src/wallet.js

@@ -0,0 +1,158 @@
+/**
+ * Wallet Classes
+ * Supports ECDSA, PQC (Dilithium), and Hybrid wallets
+ */
+
+import { ethers } from 'ethers';
+import { ml_dsa65 } from '@noble/post-quantum/ml-dsa';
+import { derivePQCAddress, deriveHybridAddress } from './utils/address.js';
+
+/**
+ * ECDSA Wallet (standard Ethereum wallet)
+ */
+export class ECDSAWallet {
+    constructor(privateKey, provider = null) {
+        this.wallet = new ethers.Wallet(privateKey, provider);
+        this.address = this.wallet.address;
+        this.privateKey = privateKey;
+        this.provider = provider;
+    }
+
+    /**
+     * Connect wallet to a provider
+     * @param {QuorumProvider} provider - Provider instance
+     * @returns {ECDSAWallet} New wallet instance connected to provider
+     */
+    connect(provider) {
+        return new ECDSAWallet(this.privateKey, provider);
+    }
+
+    /**
+     * Get public key
+     * @returns {string} Public key (hex)
+     */
+    getPublicKey() {
+        return this.wallet.publicKey;
+    }
+
+    /**
+     * Sign a message
+     * @param {string|Uint8Array} message - Message to sign
+     * @returns {Promise<string>} Signature
+     */
+    async signMessage(message) {
+        return await this.wallet.signMessage(message);
+    }
+}
+
+/**
+ * PQC Wallet (Dilithium/ML-DSA-65)
+ */
+export 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
+            const keyPair = ml_dsa65.keygen();
+            this.secretKey = keyPair.secretKey;
+            this.publicKey = keyPair.publicKey;
+        }
+        this.address = derivePQCAddress(this.publicKey);
+    }
+
+    /**
+     * Create wallet from secret key
+     * Note: In practice, you would derive the public key from the secret key.
+     * This is a placeholder - full implementation would use key derivation.
+     * @param {Uint8Array|string} secretKey - Secret key
+     * @param {Uint8Array|string} publicKey - Public key (required if secretKey provided)
+     * @returns {PQCWallet} Wallet instance
+     */
+    static fromSecretKey(secretKey, publicKey) {
+        if (!secretKey || !publicKey) {
+            throw new Error('Both secretKey and publicKey are required');
+        }
+        const secret = secretKey instanceof Uint8Array ? secretKey : ethers.getBytes(secretKey);
+        const pub = publicKey instanceof Uint8Array ? publicKey : ethers.getBytes(publicKey);
+        return new PQCWallet(secret, pub);
+    }
+
+    /**
+     * Sign a message hash
+     * @param {Uint8Array} hash - Message hash (32 bytes)
+     * @returns {Uint8Array} Signature
+     */
+    sign(hash) {
+        const ctx = new TextEncoder().encode('ML-DSA-65');
+        return ml_dsa65.sign(this.secretKey, hash, ctx);
+    }
+
+    /**
+     * Verify a signature
+     * @param {Uint8Array} hash - Message hash
+     * @param {Uint8Array} signature - Signature to verify
+     * @returns {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);
+    }
+
+    /**
+     * Get public key as hex string
+     * @returns {string} Public key (hex)
+     */
+    getPublicKeyHex() {
+        return ethers.hexlify(this.publicKey);
+    }
+
+    /**
+     * Get secret key as hex string (use with caution!)
+     * @returns {string} Secret key (hex)
+     */
+    getSecretKeyHex() {
+        return ethers.hexlify(this.secretKey);
+    }
+}
+
+/**
+ * Hybrid Wallet (ECDSA + PQC)
+ */
+export 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();
+        this.address = deriveHybridAddress(
+            ethers.getBytes(this.ecdsaWallet.getPublicKey()),
+            this.pqcWallet.publicKey
+        );
+    }
+
+    /**
+     * Create hybrid wallet from ECDSA private key and PQC key pair
+     * @param {string} ecdsaPrivateKey - ECDSA private key (hex)
+     * @param {Uint8Array} pqcSecretKey - PQC secret key
+     * @param {Uint8Array} pqcPublicKey - PQC public key
+     * @returns {HybridWallet} Hybrid wallet instance
+     */
+    static fromKeys(ecdsaPrivateKey, pqcSecretKey, pqcPublicKey) {
+        const ecdsaWallet = new ECDSAWallet(ecdsaPrivateKey);
+        const pqcWallet = new PQCWallet(pqcSecretKey, pqcPublicKey);
+        return new HybridWallet(ecdsaWallet, pqcWallet);
+    }
+
+    /**
+     * Connect wallet to a provider
+     * @param {QuorumProvider} provider - Provider instance
+     * @returns {HybridWallet} New wallet instance connected to provider
+     */
+    connect(provider) {
+        const connectedECDSA = this.ecdsaWallet.connect(provider);
+        return new HybridWallet(connectedECDSA, this.pqcWallet);
+    }
+}

package/src/zk-transaction.js

@@ -0,0 +1,95 @@
+/**
+ * Zero-Knowledge Proof Transaction Support
+ */
+
+import { ethers } from 'ethers';
+import { TX_TYPE, ZK_PROOF_SYSTEM } from './constants.js';
+
+/**
+ * ZK Transaction Builder
+ * Creates transactions with zero-knowledge proofs
+ */
+export class ZKTransaction {
+    constructor(params) {
+        this.type = TX_TYPE.ZK_PRIVATE;
+        this.chainId = params.chainId || 1337;
+        this.nonce = params.nonce || 0;
+        this.gasPrice = params.gasPrice || 0n;
+        this.gasLimit = params.gasLimit || 21000n;
+        this.to = params.to;
+        this.value = params.value || 0n;
+        this.data = params.data || '0x';
+        this.accessList = params.accessList || [];
+
+        // ZK-specific fields
+        this.zkProofSystem = params.zkProofSystem || ZK_PROOF_SYSTEM.GROTH16;
+        this.zkProof = params.zkProof || null;
+        this.zkPublicInputs = params.zkPublicInputs || [];
+        this.zkVerificationKeyHash = params.zkVerificationKeyHash || null;
+        this.encryptedPayload = params.encryptedPayload || null;
+        this.recipients = params.recipients || [];
+
+        // Private transaction fields (Quorum)
+        this.privateFrom = params.privateFrom || null;
+        this.privateFor = params.privateFor || null;
+    }
+
+    /**
+     * Create ZK transaction arguments for RPC call
+     * @param {string} from - Sender address
+     * @returns {Object} ZK transaction arguments
+     */
+    toZKTxArgs(from) {
+        if (!this.zkProof || !this.zkProofSystem) {
+            throw new Error('ZK proof and proof system are required');
+        }
+
+        const args = {
+            from: from,
+            zkProofSystem: this.zkProofSystem,
+            zkProof: this.zkProof,
+        };
+
+        if (this.to) args.to = this.to;
+        if (this.value) args.value = ethers.toBeHex(this.value);
+        if (this.gasLimit) args.gas = ethers.toBeHex(this.gasLimit);
+        if (this.gasPrice) args.gasPrice = ethers.toBeHex(this.gasPrice);
+        if (this.data) args.data = this.data;
+        if (this.nonce) args.nonce = ethers.toBeHex(this.nonce);
+        if (this.chainId) args.chainId = ethers.toBeHex(this.chainId);
+        if (this.accessList && this.accessList.length > 0) args.accessList = this.accessList;
+        if (this.zkPublicInputs && this.zkPublicInputs.length > 0) {
+            args.zkPublicInputs = this.zkPublicInputs.map(pi => 
+                typeof pi === 'string' ? pi : ethers.hexlify(pi)
+            );
+        }
+        if (this.zkVerificationKeyHash) {
+            args.zkVerificationKeyHash = typeof this.zkVerificationKeyHash === 'string' 
+                ? this.zkVerificationKeyHash 
+                : ethers.hexlify(this.zkVerificationKeyHash);
+        }
+        if (this.encryptedPayload) {
+            args.encryptedPayload = typeof this.encryptedPayload === 'string'
+                ? this.encryptedPayload
+                : ethers.hexlify(this.encryptedPayload);
+        }
+        if (this.recipients && this.recipients.length > 0) {
+            args.recipients = this.recipients;
+        }
+        if (this.privateFrom) args.privateFrom = this.privateFrom;
+        if (this.privateFor) args.privateFor = this.privateFor;
+
+        return args;
+    }
+
+    /**
+     * Send ZK transaction via RPC
+     * @param {QuorumProvider} provider - Provider instance
+     * @param {string} from - Sender address
+     * @returns {Promise<string>} Transaction hash
+     */
+    async send(provider, from) {
+        const args = this.toZKTxArgs(from);
+        return await provider.send('quorum_sendZKTransaction', [args]);
+    }
+}