Initial commit

src/utils/walletGenerator.js

@@ -0,0 +1,148 @@
+import bip39 from 'bip39';
+import HDKey from 'hdkey';
+import { publicToAddress } from 'ethereumjs-util';
+import * as bitcoin from 'bitcoinjs-lib';
+import * as ecc from 'tiny-secp256k1';
+import { ECPairFactory } from 'ecpair';
+import CryptoJS from 'crypto-js';
+
+const ECPair = ECPairFactory(ecc);
+
+export default class WalletGenerator {
+  static async generateMnemonic() {
+    try {
+      return bip39.generateMnemonic(256); // 24 words for maximum security
+    } catch (error) {
+      console.error('Error generating mnemonic:', error);
+      throw new Error('Failed to generate mnemonic');
+    }
+  }
+
+  static async encryptMnemonic(mnemonic, userId) {
+    try {
+      const key = process.env.ENCRYPTION_KEY || 'default-key-12345';
+      return CryptoJS.AES.encrypt(mnemonic, key + userId.toString()).toString();
+    } catch (error) {
+      console.error('Error encrypting mnemonic:', error);
+      throw new Error('Failed to encrypt mnemonic');
+    }
+  }
+
+  static async decryptMnemonic(encryptedMnemonic, userId) {
+    try {
+      const key = process.env.ENCRYPTION_KEY || 'default-key-12345';
+      const bytes = CryptoJS.AES.decrypt(encryptedMnemonic, key + userId.toString());
+      return bytes.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+      console.error('Error decrypting mnemonic:', error);
+      throw new Error('Failed to decrypt mnemonic');
+    }
+  }
+
+  static async generateWallets(mnemonic) {
+    try {
+      const seed = await bip39.mnemonicToSeed(mnemonic);
+      const hdkey = HDKey.fromMasterSeed(Buffer.from(seed));
+
+      // Generate BTC wallet (BIP84 - Native SegWit)
+      const btcNode = hdkey.derive("m/84'/0'/0'/0/0");
+      const btcKeyPair = ECPair.fromPrivateKey(btcNode.privateKey);
+      const btcAddress = bitcoin.payments.p2wpkh({ 
+        pubkey: btcKeyPair.publicKey 
+      }).address;
+
+      // Generate ETH wallet (BIP44)
+      const ethNode = hdkey.derive("m/44'/60'/0'/0/0");
+      const ethAddress = '0x' + publicToAddress(ethNode.publicKey, true).toString('hex');
+
+      // Generate LTC wallet (BIP84 - Native SegWit)
+      const ltcNode = hdkey.derive("m/84'/2'/0'/0/0");
+      const ltcKeyPair = ECPair.fromPrivateKey(ltcNode.privateKey);
+      const ltcAddress = bitcoin.payments.p2wpkh({
+        pubkey: ltcKeyPair.publicKey,
+        network: {
+          messagePrefix: '\x19Litecoin Signed Message:\n',
+          bech32: 'ltc',
+          bip32: {
+            public: 0x019da462,
+            private: 0x019d9cfe
+          },
+          pubKeyHash: 0x30,
+          scriptHash: 0x32,
+          wif: 0xb0
+        }
+      }).address;
+
+      // Generate TRON address (BIP44)
+      const tronNode = hdkey.derive("m/44'/195'/0'/0/0");
+      const tronAddress = this.generateTronAddress(tronNode.publicKey);
+
+      return {
+        BTC: { 
+          address: btcAddress, 
+          path: "m/84'/0'/0'/0/0" 
+        },
+        ETH: { 
+          address: ethAddress, 
+          path: "m/44'/60'/0'/0/0" 
+        },
+        LTC: { 
+          address: ltcAddress, 
+          path: "m/84'/2'/0'/0/0" 
+        },
+        TRON: { 
+          address: tronAddress, 
+          path: "m/44'/195'/0'/0/0" 
+        }
+      };
+    } catch (error) {
+      console.error('Error in generateWallets:', error);
+      throw new Error('Failed to generate cryptocurrency wallets: ' + error.message);
+    }
+  }
+
+  static generateTronAddress(publicKey) {
+    try {
+      const addressPrefix = '41'; // TRON mainnet prefix
+      const pubKeyHash = CryptoJS.SHA256(
+        CryptoJS.lib.WordArray.create(publicKey)
+      ).toString();
+      
+      const address = addressPrefix + pubKeyHash.substring(0, 40);
+      return this.base58Encode(Buffer.from(address, 'hex'));
+    } catch (error) {
+      console.error('Error generating TRON address:', error);
+      throw new Error('Failed to generate TRON address: ' + error.message);
+    }
+  }
+
+  static base58Encode(buffer) {
+    try {
+      const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+      let digits = [0];
+
+      for (let i = 0; i < buffer.length; i++) {
+        let carry = buffer[i];
+        for (let j = 0; j < digits.length; j++) {
+          carry += digits[j] << 8;
+          digits[j] = carry % 58;
+          carry = (carry / 58) | 0;
+        }
+        while (carry > 0) {
+          digits.push(carry % 58);
+          carry = (carry / 58) | 0;
+        }
+      }
+
+      // Add leading zeros
+      for (let i = 0; buffer[i] === 0 && i < buffer.length - 1; i++) {
+        digits.push(0);
+      }
+
+      return digits.reverse().map(digit => ALPHABET[digit]).join('');
+    } catch (error) {
+      console.error('Error in base58Encode:', error);
+      throw new Error('Failed to encode address: ' + error.message);
+    }
+  }
+}