@cheny56/node-client 1.0.0

package/README.md

@@ -0,0 +1,293 @@
+# Quorum Client Library
+
+A comprehensive JavaScript/TypeScript client library for interacting with Quorum blockchain nodes that support Post-Quantum Cryptography (PQC) and Zero-Knowledge Proofs (ZK).
+
+## Features
+
+- ✅ **Post-Quantum Cryptography (PQC)**: Full support for Dilithium/ML-DSA-65 signatures
+- ✅ **Zero-Knowledge Proofs (ZK)**: Support for ZK-enhanced transactions
+- ✅ **Hybrid Security**: ECDSA + PQC hybrid transactions for maximum security
+- ✅ **Multiple Transaction Types**: Legacy (Type 0), AccessList (Type 1), DynamicFee (Type 2)
+- ✅ **Token Support**: ERC20 token transfers with PQC and Hybrid signatures
+- ✅ **Ethers.js Compatible**: Built on top of ethers.js for familiar API
+
+## Installation
+
+```bash
+npm install @quorum/client
+```
+
+## Quick Start
+
+### Basic Setup
+
+```javascript
+import { QuorumProvider, ECDSAWallet, PQCWallet, HybridWallet } from '@quorum/client';
+
+// Connect to Quorum node
+const provider = new QuorumProvider('http://localhost:8545');
+
+// Create wallets
+const ecdsaWallet = new ECDSAWallet('0x...', provider);
+const pqcWallet = new PQCWallet(); // Generates new key pair
+const hybridWallet = new HybridWallet(ecdsaWallet, pqcWallet);
+```
+
+### Send Native Coin (ETH)
+
+#### ECDSA Transaction
+
+```javascript
+import { LegacyTransaction } from '@quorum/client';
+
+const tx = new LegacyTransaction({
+    to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+    value: ethers.utils.parseEther('1.0'),
+    gasPrice: 0n,
+    gasLimit: 21000n,
+});
+
+const signedTx = await tx.sign(ecdsaWallet);
+const txHash = await provider.sendRawTransaction(signedTx);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+#### PQC Transaction
+
+```javascript
+import { PQCLegacyTransaction } from '@quorum/client';
+
+// Get nonce first
+const nonce = await provider.getTransactionCount(pqcWallet.address, 'pending');
+
+const tx = new PQCLegacyTransaction({
+    chainId: 1337,
+    nonce: nonce,
+    to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+    value: ethers.utils.parseEther('1.0'),
+    gasPrice: 0n,
+    gasLimit: 21000n,
+});
+
+tx.sign(pqcWallet);
+const serialized = tx.getHex();
+const txHash = await provider.sendRawTransaction(serialized);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+#### Hybrid Transaction
+
+```javascript
+import { HybridLegacyTransaction } from '@quorum/client';
+
+const nonce = await provider.getTransactionCount(hybridWallet.address, 'pending');
+
+const tx = new HybridLegacyTransaction({
+    chainId: 1337,
+    nonce: nonce,
+    to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+    value: ethers.utils.parseEther('1.0'),
+    gasPrice: 0n,
+    gasLimit: 21000n,
+});
+
+tx.sign(hybridWallet.ecdsaWallet, hybridWallet.pqcWallet);
+const serialized = tx.getHex();
+const txHash = await provider.sendRawTransaction(serialized);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+### Send ERC20 Tokens
+
+#### Using ECDSA
+
+```javascript
+import { ERC20Token } from '@quorum/client';
+
+const token = new ERC20Token(tokenAddress, provider, ecdsaWallet);
+const tx = await token.transfer(recipientAddress, ethers.utils.parseEther('100'));
+await tx.wait();
+```
+
+#### Using PQC
+
+```javascript
+import { ERC20Token } from '@quorum/client';
+
+const token = new ERC20Token(tokenAddress, provider);
+const txHash = await token.transferPQC(
+    pqcWallet,
+    provider,
+    recipientAddress,
+    ethers.utils.parseEther('100'),
+    { chainId: 1337, gasPrice: 0n, gasLimit: 100000n }
+);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+#### Using Hybrid
+
+```javascript
+import { ERC20Token } from '@quorum/client';
+
+const token = new ERC20Token(tokenAddress, provider);
+const txHash = await token.transferHybrid(
+    hybridWallet,
+    provider,
+    recipientAddress,
+    ethers.utils.parseEther('100'),
+    { chainId: 1337, gasPrice: 0n, gasLimit: 100000n }
+);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+### Zero-Knowledge Proof Transactions
+
+```javascript
+import { ZKTransaction, ZK_PROOF_SYSTEM } from '@quorum/client';
+
+const zkTx = new ZKTransaction({
+    to: contractAddress,
+    value: 0n,
+    data: encodedFunctionData,
+    gasPrice: 0n,
+    gasLimit: 100000n,
+    zkProofSystem: ZK_PROOF_SYSTEM.GROTH16,
+    zkProof: proofBytes,
+    zkPublicInputs: [publicInput1, publicInput2],
+    zkVerificationKeyHash: vkHash,
+});
+
+const txHash = await zkTx.send(provider, senderAddress);
+const receipt = await provider.waitForTransaction(txHash);
+```
+
+## API Reference
+
+### Providers
+
+#### `QuorumProvider`
+
+```javascript
+const provider = new QuorumProvider(rpcUrl, network);
+```
+
+**Methods:**
+- `sendRawTransaction(signedTx)`: Send raw transaction
+- `getTransactionReceipt(txHash)`: Get transaction receipt
+- `waitForTransaction(txHash, confirmations)`: Wait for transaction
+- `getTransactionCount(address, blockTag)`: Get nonce
+- `getBalance(address, blockTag)`: Get balance
+- `estimateGas(transaction)`: Estimate gas
+- `getGasPrice()`: Get current gas price
+- `getBlockNumber()`: Get current block number
+
+### Wallets
+
+#### `ECDSAWallet`
+
+Standard Ethereum wallet using ECDSA signatures.
+
+```javascript
+const wallet = new ECDSAWallet(privateKey, provider);
+```
+
+#### `PQCWallet`
+
+Post-quantum wallet using Dilithium/ML-DSA-65 signatures.
+
+```javascript
+const wallet = new PQCWallet(); // Generates new key pair
+// or
+const wallet = new PQCWallet(secretKey, publicKey);
+```
+
+**Methods:**
+- `sign(hash)`: Sign a message hash
+- `verify(hash, signature)`: Verify a signature
+- `getPublicKeyHex()`: Get public key as hex
+- `getSecretKeyHex()`: Get secret key as hex (use with caution!)
+
+#### `HybridWallet`
+
+Hybrid wallet using both ECDSA and PQC signatures.
+
+```javascript
+const wallet = new HybridWallet(ecdsaWallet, pqcWallet);
+// or
+const wallet = HybridWallet.fromKeys(ecdsaPrivateKey, pqcSecretKey, pqcPublicKey);
+```
+
+### Transactions
+
+#### Transaction Types
+
+- `LegacyTransaction`: Type 0, ECDSA only
+- `PQCLegacyTransaction`: Type 0, PQC only
+- `HybridLegacyTransaction`: Type 0, ECDSA + PQC
+- `AccessListTransaction`: Type 1, ECDSA only
+- `PQCAccessListTransaction`: Type 1, PQC only
+- `DynamicFeeTransaction`: Type 2, ECDSA only
+- `PQCDynamicFeeTransaction`: Type 2, PQC only
+
+#### Common Transaction Methods
+
+- `sign(wallet)`: Sign transaction (for ECDSA)
+- `sign(wallet)` or `sign(ecdsaWallet, pqcWallet)`: Sign transaction (for PQC/Hybrid)
+- `getHex()`: Get serialized transaction as hex
+- `verify()`: Verify PQC signature (for PQC transactions)
+
+### Contracts
+
+#### `Contract`
+
+Generic contract interface.
+
+```javascript
+const contract = new Contract(address, abi, provider, wallet);
+```
+
+#### `ERC20Token`
+
+ERC20 token interface with PQC and Hybrid support.
+
+```javascript
+const token = new ERC20Token(address, provider, wallet);
+```
+
+**Methods:**
+- `transfer(to, amount, txOptions)`: Transfer tokens (ECDSA)
+- `transferPQC(wallet, provider, to, amount, txOptions)`: Transfer tokens (PQC)
+- `transferHybrid(wallet, provider, to, amount, txOptions)`: Transfer tokens (Hybrid)
+- `balanceOf(address)`: Get balance
+- `name()`, `symbol()`, `decimals()`, `totalSupply()`: Token info
+
+## Examples
+
+See the `examples/` directory for more comprehensive examples:
+
+- `send-coin.js`: Send native coin with different signature types
+- `send-token.js`: Send ERC20 tokens with PQC/Hybrid signatures
+- `zk-transaction.js`: Create and send ZK transactions
+
+## Requirements
+
+- Node.js 14+
+- Quorum node with PQC and ZK support enabled
+
+## Dependencies
+
+- `ethers`: ^5.7.2
+- `@noble/post-quantum`: ^1.0.0
+
+## License
+
+LGPL-3.0
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Support
+
+For issues and questions, please open an issue on the repository.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cheny56/node-client",
+  "version": "1.0.0",
+  "description": "Client library for Quorum blockchain with Post-Quantum Cryptography (PQC) and Zero-Knowledge Proof (ZK) support",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "quorum",
+    "blockchain",
+    "ethereum",
+    "post-quantum",
+    "cryptography",
+    "zero-knowledge",
+    "zk-proof",
+    "dilithium",
+    "pqc"
+  ],
+  "author": "",
+  "license": "LGPL-3.0",
+  "dependencies": {
+    "ethers": "^5.7.2",
+    "@noble/post-quantum": "^1.0.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {},
+  "directories": {
+    "example": "examples"
+  }
+}

package/src/constants.js

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

package/src/contract.js

@@ -0,0 +1,207 @@
+/**
+ * Contract Interaction
+ * Supports ERC20 token transfers and contract calls
+ */
+
+import { ethers } from 'ethers';
+import { LegacyTransaction, PQCLegacyTransaction, HybridLegacyTransaction } from './transaction.js';
+
+/**
+ * Contract class for interacting with smart contracts
+ */
+export class Contract {
+    constructor(address, abi, provider, wallet = null) {
+        this.address = address;
+        this.abi = abi;
+        this.provider = provider;
+        this.wallet = wallet;
+        this.contract = wallet 
+            ? new ethers.Contract(address, abi, wallet.wallet || wallet)
+            : new ethers.Contract(address, abi, provider);
+    }
+
+    /**
+     * Connect contract to a wallet
+     * @param {ECDSAWallet|PQCWallet|HybridWallet} wallet - Wallet instance
+     * @returns {Contract} New contract instance connected to wallet
+     */
+    connect(wallet) {
+        return new Contract(this.address, this.abi, this.provider, wallet);
+    }
+
+    /**
+     * Encode function call data
+     * @param {string} functionName - Function name
+     * @param {Array} params - Function parameters
+     * @returns {string} Encoded data (hex)
+     */
+    encodeFunctionData(functionName, params = []) {
+        const iface = new ethers.utils.Interface(this.abi);
+        return iface.encodeFunctionData(functionName, params);
+    }
+
+    /**
+     * Decode function result
+     * @param {string} functionName - Function name
+     * @param {string} data - Encoded data
+     * @returns {Array} Decoded parameters
+     */
+    decodeFunctionResult(functionName, data) {
+        const iface = new ethers.utils.Interface(this.abi);
+        return iface.decodeFunctionResult(functionName, data);
+    }
+
+    /**
+     * Call a view/pure function
+     * @param {string} functionName - Function name
+     * @param {Array} params - Function parameters
+     * @returns {Promise<any>} Function result
+     */
+    async call(functionName, ...params) {
+        return await this.contract[functionName](...params);
+    }
+
+    /**
+     * Send a transaction to a contract function (ECDSA)
+     * @param {string} functionName - Function name
+     * @param {Array} params - Function parameters
+     * @param {Object} txOptions - Transaction options (gasPrice, gasLimit, etc.)
+     * @returns {Promise<Object>} Transaction response
+     */
+    async sendTransaction(functionName, params = [], txOptions = {}) {
+        if (!this.wallet) {
+            throw new Error('Wallet required for sending transactions');
+        }
+        const tx = await this.contract[functionName](...params, txOptions);
+        return tx;
+    }
+}
+
+/**
+ * ERC20 Token Contract
+ * Simplified interface for ERC20 token operations
+ */
+export class ERC20Token extends Contract {
+    constructor(address, provider, wallet = null) {
+        const erc20Abi = [
+            'function name() view returns (string)',
+            'function symbol() view returns (string)',
+            'function decimals() view returns (uint8)',
+            'function totalSupply() view returns (uint256)',
+            'function balanceOf(address account) view returns (uint256)',
+            'function transfer(address to, uint256 amount) returns (bool)',
+            'function allowance(address owner, address spender) view returns (uint256)',
+            'function approve(address spender, uint256 amount) returns (bool)',
+            'function transferFrom(address from, address to, uint256 amount) returns (bool)',
+        ];
+        super(address, erc20Abi, provider, wallet);
+    }
+
+    /**
+     * Get token name
+     * @returns {Promise<string>} Token name
+     */
+    async name() {
+        return await this.call('name');
+    }
+
+    /**
+     * Get token symbol
+     * @returns {Promise<string>} Token symbol
+     */
+    async symbol() {
+        return await this.call('symbol');
+    }
+
+    /**
+     * Get token decimals
+     * @returns {Promise<number>} Token decimals
+     */
+    async decimals() {
+        return await this.call('decimals');
+    }
+
+    /**
+     * Get total supply
+     * @returns {Promise<ethers.BigNumber>} Total supply
+     */
+    async totalSupply() {
+        return await this.call('totalSupply');
+    }
+
+    /**
+     * Get balance of an address
+     * @param {string} address - Address to query
+     * @returns {Promise<ethers.BigNumber>} Balance
+     */
+    async balanceOf(address) {
+        return await this.call('balanceOf', address);
+    }
+
+    /**
+     * Transfer tokens (ECDSA)
+     * @param {string} to - Recipient address
+     * @param {string|ethers.BigNumber} amount - Amount to transfer
+     * @param {Object} txOptions - Transaction options
+     * @returns {Promise<Object>} Transaction response
+     */
+    async transfer(to, amount, txOptions = {}) {
+        return await this.sendTransaction('transfer', [to, amount], txOptions);
+    }
+
+    /**
+     * Transfer tokens using PQC transaction
+     * @param {PQCWallet} wallet - PQC wallet
+     * @param {QuorumProvider} provider - Provider instance
+     * @param {string} to - Recipient address
+     * @param {string|ethers.BigNumber} amount - Amount to transfer
+     * @param {Object} txOptions - Transaction options
+     * @returns {Promise<string>} Transaction hash
+     */
+    async transferPQC(wallet, provider, to, amount, txOptions = {}) {
+        const data = this.encodeFunctionData('transfer', [to, amount]);
+        const nonce = await provider.getTransactionCount(wallet.address, 'pending');
+        
+        const tx = new PQCLegacyTransaction({
+            chainId: txOptions.chainId || 1337,
+            nonce: nonce,
+            gasPrice: txOptions.gasPrice || 0n,
+            gasLimit: txOptions.gasLimit || 100000n,
+            to: this.address,
+            value: 0n,
+            data: data,
+        });
+
+        tx.sign(wallet);
+        const serialized = tx.getHex();
+        return await provider.sendRawTransaction(serialized);
+    }
+
+    /**
+     * Transfer tokens using Hybrid transaction
+     * @param {HybridWallet} wallet - Hybrid wallet
+     * @param {QuorumProvider} provider - Provider instance
+     * @param {string} to - Recipient address
+     * @param {string|ethers.BigNumber} amount - Amount to transfer
+     * @param {Object} txOptions - Transaction options
+     * @returns {Promise<string>} Transaction hash
+     */
+    async transferHybrid(wallet, provider, to, amount, txOptions = {}) {
+        const data = this.encodeFunctionData('transfer', [to, amount]);
+        const nonce = await provider.getTransactionCount(wallet.address, 'pending');
+        
+        const tx = new HybridLegacyTransaction({
+            chainId: txOptions.chainId || 1337,
+            nonce: nonce,
+            gasPrice: txOptions.gasPrice || 0n,
+            gasLimit: txOptions.gasLimit || 100000n,
+            to: this.address,
+            value: 0n,
+            data: data,
+        });
+
+        tx.sign(wallet.ecdsaWallet, wallet.pqcWallet);
+        const serialized = tx.getHex();
+        return await provider.sendRawTransaction(serialized);
+    }
+}

package/src/index.js

@@ -0,0 +1,37 @@
+/**
+ * Quorum Client Library
+ * Main entry point for the library
+ */
+
+// Providers
+export { QuorumProvider } from './provider.js';
+
+// Wallets
+export { ECDSAWallet, PQCWallet, HybridWallet } from './wallet.js';
+
+// Transactions
+export {
+    LegacyTransaction,
+    PQCLegacyTransaction,
+    HybridLegacyTransaction,
+    AccessListTransaction,
+    PQCAccessListTransaction,
+    DynamicFeeTransaction,
+    PQCDynamicFeeTransaction,
+} from './transaction.js';
+
+// ZK Transactions
+export { ZKTransaction } from './zk-transaction.js';
+
+// Contracts
+export { Contract, ERC20Token } from './contract.js';
+
+// Constants
+export { TX_TYPE, PQC_TYPE, ZK_PROOF_SYSTEM, DEFAULT_CHAIN_ID } from './constants.js';
+
+// Utilities
+export { derivePQCAddress, deriveHybridAddress, isValidAddress } from './utils/address.js';
+export { encodeUint64, encodeBigInt, encodeSignature } from './utils/rlp.js';
+
+// Re-export ethers utilities for convenience
+export { ethers } from 'ethers';

package/src/provider.js

@@ -0,0 +1,95 @@
+/**
+ * Provider for Quorum RPC connections
+ * Extends ethers.js JsonRpcProvider with Quorum-specific methods
+ */
+
+import { ethers } from 'ethers';
+
+export class QuorumProvider extends ethers.providers.JsonRpcProvider {
+    constructor(url, network) {
+        super(url, network);
+        this.url = url;
+    }
+
+    /**
+     * Send a raw transaction (for PQC/Hybrid transactions)
+     * @param {string} signedTx - Hex-encoded signed transaction
+     * @returns {Promise<string>} Transaction hash
+     */
+    async sendRawTransaction(signedTx) {
+        return await this.send('eth_sendRawTransaction', [signedTx]);
+    }
+
+    /**
+     * Get transaction receipt
+     * @param {string} txHash - Transaction hash
+     * @returns {Promise<Object>} Transaction receipt
+     */
+    async getTransactionReceipt(txHash) {
+        return await super.getTransactionReceipt(txHash);
+    }
+
+    /**
+     * Wait for transaction to be mined
+     * @param {string} txHash - Transaction hash
+     * @param {number} confirmations - Number of confirmations to wait for
+     * @returns {Promise<Object>} Transaction receipt
+     */
+    async waitForTransaction(txHash, confirmations = 1) {
+        return await super.waitForTransaction(txHash, confirmations);
+    }
+
+    /**
+     * Get transaction count (nonce) for an address
+     * @param {string} address - Address to query
+     * @param {string} blockTag - Block tag (default: 'pending')
+     * @returns {Promise<number>} Transaction count
+     */
+    async getTransactionCount(address, blockTag = 'pending') {
+        return await super.getTransactionCount(address, blockTag);
+    }
+
+    /**
+     * Get balance for an address
+     * @param {string} address - Address to query
+     * @param {string} blockTag - Block tag (default: 'latest')
+     * @returns {Promise<ethers.BigNumber>} Balance in Wei
+     */
+    async getBalance(address, blockTag = 'latest') {
+        return await super.getBalance(address, blockTag);
+    }
+
+    /**
+     * Estimate gas for a transaction
+     * @param {Object} transaction - Transaction object
+     * @returns {Promise<ethers.BigNumber>} Estimated gas
+     */
+    async estimateGas(transaction) {
+        return await super.estimateGas(transaction);
+    }
+
+    /**
+     * Get gas price
+     * @returns {Promise<ethers.BigNumber>} Gas price in Wei
+     */
+    async getGasPrice() {
+        return await super.getGasPrice();
+    }
+
+    /**
+     * Get current block number
+     * @returns {Promise<number>} Block number
+     */
+    async getBlockNumber() {
+        return await super.getBlockNumber();
+    }
+
+    /**
+     * Get block by number
+     * @param {number|string} blockNumber - Block number or tag
+     * @returns {Promise<Object>} Block object
+     */
+    async getBlock(blockNumber) {
+        return await super.getBlock(blockNumber);
+    }
+}