generate TRON privateKey and address

devkudasov · devkudasov · commit ef29e29a6c85 · 2024-10-14T20:04:18.000+03:00
diff --git a/package.json b/package.json
@@ -32,8 +32,8 @@
     "@ledgerhq/hw-transport": "6.30.3",
     "@ledgerhq/react-native-hw-transport-ble": "6.30.0",
     "bech32-converting": "^1.0.9",
+    "bip32": "1.0.4",
     "bip39": "^3.1.0",
-    "ethereumjs-wallet": "^1.0.2",
     "ethers": "^5.7.2",
     "events": "^3.3.0",
     "rxjs": "^7.8.0"
diff --git a/src/providers/mnemonic/provider.ts b/src/providers/mnemonic/provider.ts
@@ -2,16 +2,16 @@ import {accountInfo, derive, seedFromEntropy} from '@haqq/provider-web3-utils';
 import {generateEntropy} from '@haqq/provider-web3-utils/src/native-modules';
 import {Share, encryptShare} from '@haqq/shared-react-native';
 import {entropyToMnemonic, mnemonicToEntropy, mnemonicToSeed} from 'bip39';
-import {hdkey} from 'ethereumjs-wallet';
 import EncryptedStorage from 'react-native-encrypted-storage';
 
 import {ProviderMnemonicBaseOptions} from './types';
 
 import {ITEM_KEYS, WalletType} from '../../constants';
+import {Multichain} from '../../services/multichain';
 import {compressPublicKey} from '../../utils';
 import {getMnemonic} from '../../utils/mnemonic/get-mnemonic';
 import {ProviderBase} from '../base-provider';
-import {ProviderBaseOptions, ProviderInterface} from '../types';
+import {NETWORK_TYPE, ProviderBaseOptions, ProviderInterface} from '../types';
 
 export class ProviderMnemonicBase
   extends ProviderBase<ProviderMnemonicBaseOptions>
@@ -22,19 +22,14 @@ export class ProviderMnemonicBase
     getPassword: () => Promise<string>,
     options: Omit<ProviderBaseOptions, 'getPassword'>,
   ): Promise<ProviderMnemonicBase> {
-    console.log('mnemonic', mnemonic);
-
     const password = await getPassword();
-    console.log('password', password);
 
     const entropy =
       mnemonic === null
         ? (await generateEntropy(16)).toString('hex')
         : mnemonicToEntropy(mnemonic);
-    console.log('entropy', entropy);
 
     const seed = await mnemonicToSeed(entropyToMnemonic(entropy));
-    console.log('seed', seed);
 
     const privateData = await encryptShare(
       {
@@ -44,34 +39,21 @@ export class ProviderMnemonicBase
       },
       password,
     );
-    console.log('privateData', privateData);
 
     const rootPrivateKey = await derive(seed.toString('hex'), 'm');
-    console.log('rootPrivateKey', rootPrivateKey);
     const {address} = await accountInfo(rootPrivateKey);
-    console.log('address', address);
 
     await EncryptedStorage.setItem(
       `${ITEM_KEYS[WalletType.mnemonic]}_${address.toLowerCase()}`,
       JSON.stringify(privateData),
     );
 
-    console.log(
-      `${ITEM_KEYS[WalletType.mnemonic]}_${address.toLowerCase()}`,
-      JSON.stringify(privateData),
-    );
-
     const accounts = await ProviderMnemonicBase.getAccounts();
-    console.log('accounts', accounts);
 
     await EncryptedStorage.setItem(
       `${ITEM_KEYS[WalletType.mnemonic]}_accounts`,
       JSON.stringify(accounts.concat(address.toLowerCase())),
     );
-    console.log(
-      `${ITEM_KEYS[WalletType.mnemonic]}_accounts`,
-      JSON.stringify(accounts.concat(address.toLowerCase())),
-    );
 
     return new ProviderMnemonicBase({
       ...options,
@@ -137,7 +119,7 @@ export class ProviderMnemonicBase
   }
 
   async getAccountInfo(hdPath: string) {
-    let resp = {publicKey: '', address: ''};
+    let resp = {publicKey: '', address: '', tronAddress: ''};
     try {
       const share = await getMnemonic(
         this._options.account,
@@ -150,28 +132,22 @@ export class ProviderMnemonicBase
 
       const seed = await ProviderMnemonicBase.shareToSeed(share);
 
-      const entropyLength = parseInt(share.shareIndex, 10);
-      const entropy = share.share
-        .slice(-1 * entropyLength)
-        .padStart(entropyLength, '0');
-
-      const hdwallet = hdkey.fromMasterSeed(Buffer.from(entropy, 'hex'));
-      const derivationPath = "m/44'/195'/0'/0/0";
-      const wallet = hdwallet.derivePath(derivationPath);
-      const tronPrivateKey = wallet.getWallet().getPrivateKeyString();
-      console.log('tronPrivateKey', tronPrivateKey);
-
-      const privateKey = await derive(seed, hdPath);
+      const ethPrivateKey = await derive(seed, hdPath);
 
-      if (!privateKey) {
+      if (!ethPrivateKey) {
         throw new Error('private_key_not_found');
       }
 
-      const account = await accountInfo(privateKey);
+      const account = await accountInfo(ethPrivateKey);
 
       resp = {
         publicKey: compressPublicKey(account.publicKey),
         address: account.address,
+        tronAddress: await Multichain.generateAddress(
+          NETWORK_TYPE.TRON,
+          hdPath,
+          await this.getMnemonicPhrase(),
+        ),
       };
       this.emit('getPublicKeyForHDPath', true);
     } catch (e) {
diff --git a/src/providers/sss/provider.ts b/src/providers/sss/provider.ts
@@ -14,14 +14,15 @@ import EncryptedStorage from 'react-native-encrypted-storage';
 import {ProviderSSSBaseOptions, StorageInterface} from './types';
 
 import {ITEM_KEYS, WalletType} from '../../constants';
+import {Multichain} from '../../services/multichain';
 import {
   Polynomial,
   compressPublicKey,
   getSeed,
   lagrangeInterpolation,
 } from '../../utils';
 import {ProviderBase} from '../base-provider';
-import {ProviderBaseOptions, ProviderInterface} from '../types';
+import {NETWORK_TYPE, ProviderBaseOptions, ProviderInterface} from '../types';
 
 export class ProviderSSSBase
   extends ProviderBase<ProviderSSSBaseOptions>
@@ -244,7 +245,7 @@ export class ProviderSSSBase
   }
 
   async getAccountInfo(hdPath: string) {
-    let resp = {publicKey: '', address: ''};
+    let resp = {publicKey: '', address: '', tronAddress: ''};
     try {
       const {seed} = await getSeed(
         this._options.account,
@@ -267,6 +268,11 @@ export class ProviderSSSBase
       resp = {
         publicKey: compressPublicKey(account.publicKey),
         address: account.address,
+        tronAddress: await Multichain.generateAddress(
+          NETWORK_TYPE.TRON,
+          hdPath,
+          await this.getMnemonicPhrase(),
+        ),
       };
       this.emit('getPublicKeyForHDPath', true);
     } catch (e) {
diff --git a/src/providers/types.ts b/src/providers/types.ts
@@ -111,3 +111,9 @@ export type ProviderBaseError = {
   error: Error;
   source: string;
 };
+
+export enum NETWORK_TYPE {
+  HAQQ,
+  ETH,
+  TRON,
+}
diff --git a/src/services/multichain.ts b/src/services/multichain.ts
@@ -0,0 +1,79 @@
+import * as bip32 from 'bip32';
+import {mnemonicToSeed} from 'bip39';
+import * as CryptoJS from 'crypto-js';
+import {ec} from 'elliptic';
+
+import {NETWORK_TYPE} from '../providers/types';
+import {encodeBase58} from '../utils';
+
+export class Multichain {
+  static async generatePrivateKey(
+    type: NETWORK_TYPE,
+    hdPath: string,
+    mnemonic: string,
+  ): Promise<string> {
+    switch (type) {
+      case NETWORK_TYPE.TRON:
+        return Multichain.generateTronPrivateKey(hdPath, mnemonic);
+      default:
+        return '';
+    }
+  }
+
+  private static async generateTronPrivateKey(
+    hdPath: string,
+    mnemonic: string,
+  ): Promise<string> {
+    const tronSeed = await mnemonicToSeed(mnemonic);
+    const root = bip32.fromSeed(tronSeed);
+    const child = root.derivePath(hdPath);
+    return child.privateKey.toString('hex');
+  }
+
+  static async generateAddress(
+    type: NETWORK_TYPE,
+    hdPath: string,
+    mnemonic: string,
+  ): Promise<string> {
+    switch (type) {
+      case NETWORK_TYPE.TRON:
+        return Multichain.generateTronAddress(
+          await this.generateTronPrivateKey(hdPath, mnemonic),
+        );
+      default:
+        return '';
+    }
+  }
+
+  private static async generateTronAddress(
+    privateKey: string,
+  ): Promise<string> {
+    const EC = new ec('secp256k1');
+
+    // Create key pair from private key
+    const keyPair = EC.keyFromPrivate(privateKey);
+
+    // Get public key and remove prefix 0x
+    const publicKey = keyPair.getPublic('hex').slice(2);
+
+    // Hashing public key with Keccak256
+    const publicKeyHash = CryptoJS.SHA3(publicKey, {
+      outputLength: 256,
+    }).toString();
+
+    // Get last 20 bites (40 hex symbols) from public key's hash
+    // Also add TRON prefix 41
+    const tronAddressHex = '41' + publicKeyHash.slice(-40);
+
+    // Convert hex-address to base58 which is TRON address format
+    const addressBuffer = Buffer.from(tronAddressHex, 'hex');
+    const addressHash = CryptoJS.SHA256(
+      CryptoJS.SHA256(addressBuffer).toString(CryptoJS.enc.Hex),
+    ).toString(CryptoJS.enc.Hex);
+    const checksum = addressHash.slice(0, 8);
+
+    return encodeBase58(
+      Buffer.concat([addressBuffer, Buffer.from(checksum, 'hex')]),
+    );
+  }
+}
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
@@ -30,3 +30,28 @@ export function hexBuffer(str: string | Buffer): Buffer {
 export function normalize0x(strWith0x: string): string {
   return strWith0x.replace(/^(0x)*/, '0x');
 }
+
+export function encodeBase58(buffer: Buffer): string {
+  const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+  const base = BigInt(58);
+
+  let result = '';
+  let num = BigInt('0x' + buffer.toString('hex'));
+
+  while (num > 0) {
+    const remainder = num % base;
+    num = num / base;
+    result = alphabet[Number(remainder)] + result;
+  }
+
+  // Добавляем ведущие нули
+  for (const byte of buffer) {
+    if (byte === 0x00) {
+      result = alphabet[0] + result;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+}
diff --git a/tsconfig.json b/tsconfig.json
@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "es2015",
     "module": "commonjs",
     "esModuleInterop": true,
     "skipLibCheck": true,
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"compilerOptions": {`
`3`		`- "target": "es5",`
	`3`	`+ "target": "es2015",`
`4`	`4`	`"module": "commonjs",`
`5`	`5`	`"esModuleInterop": true,`
`6`	`6`	`"skipLibCheck": true,`