chroid 1.0.0

package/utils/const.js

@@ -0,0 +1,8 @@
+const ExplorerURIs = {
+  bitcoin: "https://mempool.space/tx/",
+  tron: "https://tronscan.org/#/transaction/"
+}
+
+module.exports = {
+  ExplorerURIs
+}

package/utils/evm.js

@@ -0,0 +1,425 @@
+const bip39 = require('bip39');
+const hdkey = require('hdkey');
+const crypto = require('crypto');
+const ethers = require('ethers')
+const networks = {
+  ETH: {
+    chainId: 1,
+    rpcUrl: "https://ethereum-rpc.publicnode.com",
+    explorerUrl: "https://etherscan.io",
+    symbol: "ETH",
+    name: "Ethereum Mainnet",
+    USDT_CONTRACT_ADDRESS: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    USDC_CONTRACT_ADDRESS: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  },
+  BSC: {
+    chainId: 56,
+    rpcUrl: "https://bsc-dataseed.binance.org",
+    explorerUrl: "https://bscscan.com",
+    symbol: "BNB",
+    name: "Binance Smart Chain",
+    USDT_CONTRACT_ADDRESS: "0x55d398326f99059fF775485246999027B3197955",
+    USDC_CONTRACT_ADDRESS: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+  },
+  OP: {
+    chainId: 10,
+    rpcUrl: "https://optimism-rpc.publicnode.com",
+    explorerUrl: "https://optimistic.etherscan.io",
+    symbol: "ETH",
+    name: "Optimism Mainnet",
+    USDT_CONTRACT_ADDRESS: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
+    USDC_CONTRACT_ADDRESS: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    OP_CONTRACT_ADDRESS: "0x4200000000000000000000000000000000000042",
+  },
+  AVA: {
+    chainId: 43114,
+    rpcUrl: "https://avalanche-c-chain-rpc.publicnode.com",
+    explorerUrl: "https://snowtrace.io",
+    symbol: "AVAX",
+    name: "Avalanche C-Chain",
+    USDT_CONTRACT_ADDRESS: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+    USDC_CONTRACT_ADDRESS: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  },
+  POL: {
+    chainId: 137,
+    rpcUrl: "https://polygon-rpc.com",
+    explorerUrl: "https://polygonscan.com",
+    symbol: "MATIC",
+    name: "Polygon Mainnet",
+    USDT_CONTRACT_ADDRESS: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+    USDC_CONTRACT_ADDRESS: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  },
+  ARB: {
+    chainId: 42161,
+    rpcUrl: "https://arbitrum-one-rpc.publicnode.com",
+    explorerUrl: "https://arbiscan.io",
+    symbol: "ETH",
+    name: "Arbitrum One",
+    USDT_CONTRACT_ADDRESS: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    USDC_CONTRACT_ADDRESS: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  },
+  BASE: {
+    chainId: 8453,
+    rpcUrl: "https://mainnet.base.org",
+    explorerUrl: "https://basescan.org",
+    symbol: "ETH",
+    name: "Base Mainnet",
+    USDT_CONTRACT_ADDRESS: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    USDC_CONTRACT_ADDRESS: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  }
+};
+
+function generateHash(input) {
+  return crypto.createHash('sha256') // Use SHA-256 algorithm
+    .update(input)        // Hash the input string
+    .digest('hex');       // Output the hash in hex format
+}
+
+function generateMnemonicFromPassword (pwd) {
+  const hash = generateHash(pwd)
+  const mnemonic = bip39.entropyToMnemonic(hash)
+  if (!bip39.validateMnemonic(mnemonic)) {
+    return null
+  }
+  return mnemonic
+}
+
+async function generatePrivateKeyHexFromMnemonic(seedPhrase) {
+
+  const derivationPath = "m/88'/1'/9'/9/8"
+  const seed = await bip39.mnemonicToSeed(seedPhrase);
+  const hdwallet = hdkey.fromMasterSeed(seed);
+  const wallet = hdwallet.derive(derivationPath);
+
+  const privateKey = wallet.privateKey;
+
+  return Buffer.from(privateKey, "binary").toString("hex")
+}
+
+async function generateWalletFromPassword (pwd) {
+  const { Wallet } = ethers
+  const mnemonic = generateMnemonicFromPassword(pwd)
+  const privateKeyHex = await generatePrivateKeyHexFromMnemonic(mnemonic)
+  const account = new Wallet(privateKeyHex);
+  return {
+    privateKeyHex,
+    address: account.address
+  }
+}
+
+async function getCustomBalanceFromAddress(address, tokenAddress, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    throw new Error(`Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`);
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    
+    // Check native balance
+    const nativeBalance = await provider.getBalance(address);
+    
+    // Check token balance
+    const tokenContract = new ethers.Contract(
+      tokenAddress,
+      ['function balanceOf(address) view returns (uint256)', 'function decimals() view returns (uint8)'],
+      provider
+    );
+    
+    const [tokenBalance, decimals] = await Promise.all([
+      tokenContract.balanceOf(address),
+      tokenContract.decimals()
+    ]);
+    
+    return {
+      native_balance: ethers.formatEther(nativeBalance),
+      token_balance: ethers.formatUnits(tokenBalance, decimals)
+    };
+  } catch (error) {
+    throw new Error(`Error checking balances: ${error.message}`);
+  }
+}
+
+async function getBalanceFromAddress(address, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    throw new Error(`Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`);
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    
+    // Check native balance
+    const nativeBalance = await provider.getBalance(address);
+    
+    // Check USDT balance
+    const usdtContract = new ethers.Contract(
+      networkConfig.USDT_CONTRACT_ADDRESS,
+      ['function balanceOf(address) view returns (uint256)', 'function decimals() view returns (uint8)'],
+      provider
+    );
+    
+    // Check USDT balance
+    const usdcContract = new ethers.Contract(
+      networkConfig.USDC_CONTRACT_ADDRESS,
+      ['function balanceOf(address) view returns (uint256)', 'function decimals() view returns (uint8)'],
+      provider
+    );
+
+    const [usdtBalance, usdtDecimals, usdcBalance, usdcDecimals] = await Promise.all([
+      usdtContract.balanceOf(address),
+      usdtContract.decimals(),
+      usdcContract.balanceOf(address),
+      usdcContract.decimals()
+    ]);
+    
+    return {
+      native_balance: ethers.formatEther(nativeBalance),
+      usdt_balance: ethers.formatUnits(usdtBalance, usdtDecimals),
+      usdc_balance: ethers.formatUnits(usdcBalance, usdcDecimals)
+    };
+  } catch (error) {
+    throw new Error(`Error checking balances: ${error.message}`);
+  }
+}
+
+async function transferNative({ address, privateKeyHex }, destination, amount, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    return {
+      success: false,
+      error: `Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`
+    }
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    const wallet = new ethers.Wallet(privateKeyHex, provider);
+
+    // Check if we have enough balance
+    const balance = await provider.getBalance(address);
+    const amountWei = ethers.parseEther(amount);
+    
+    if (balance < amountWei) {
+      return {
+        success: false,
+        error: `Insufficient ${networkConfig.symbol} balance. You have ${ethers.formatEther(balance)} but trying to send ${amount}`
+      };
+    }
+
+    // Get gas price and estimate gas
+    const gasPrice = await provider.getFeeData();
+    const gasLimit = await provider.estimateGas({
+      from: address,
+      to: destination,
+      value: amountWei
+    });
+
+    // Create and send transaction
+    const tx = await wallet.sendTransaction({
+      to: destination,
+      value: amountWei,
+      gasLimit: gasLimit,
+      maxFeePerGas: gasPrice.maxFeePerGas,
+      maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas
+    });
+
+    const receipt = await tx.wait();
+
+    return {
+      success: true,
+      txUrl: `${networkConfig.explorerUrl}/tx/${receipt.hash}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+async function transferUSDT({ address, privateKeyHex }, destination, amount, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    return {
+      success: false,
+      error: `Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`
+    }
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    const wallet = new ethers.Wallet(privateKeyHex, provider);
+
+    // USDT contract interface - only including functions we need
+    const usdtAbi = [
+      'function balanceOf(address) view returns (uint256)',
+      'function decimals() view returns (uint8)',
+      'function transfer(address, uint256) returns (bool)'
+    ];
+
+    const usdtContract = new ethers.Contract(
+      networkConfig.USDT_CONTRACT_ADDRESS,
+      usdtAbi,
+      wallet  // Use wallet as signer
+    );
+
+    // Get USDT decimals
+    const decimals = await usdtContract.decimals();
+    
+    // Convert amount to USDT units
+    const amountInUnits = ethers.parseUnits(amount, decimals);
+    
+    // Check USDT balance
+    const balance = await usdtContract.balanceOf(address);
+    if (balance < amountInUnits) {
+      return {
+        success: false,
+        error: `Insufficient USDT balance. You are trying to send ${amount}`
+      };
+    }
+
+    // Send USDT
+    const tx = await usdtContract.transfer(destination, amountInUnits);
+    const receipt = await tx.wait();
+
+    return {
+      success: true,
+      txUrl: `${networkConfig.explorerUrl}/tx/${receipt.hash}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+async function transferUSDC({ address, privateKeyHex }, destination, amount, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    return {
+      success: false,
+      error: `Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`
+    }
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    const wallet = new ethers.Wallet(privateKeyHex, provider);
+
+    // USDC contract interface - only including functions we need
+    const usdcAbi = [
+      'function balanceOf(address) view returns (uint256)',
+      'function decimals() view returns (uint8)',
+      'function transfer(address, uint256) returns (bool)'
+    ];
+
+    const usdcContract = new ethers.Contract(
+      networkConfig.USDC_CONTRACT_ADDRESS,
+      usdcAbi,
+      wallet  // Use wallet as signer
+    );
+
+    // Get USDC decimals
+    const decimals = await usdtContract.decimals();
+    
+    // Convert amount to USDC units
+    const amountInUnits = ethers.parseUnits(amount, decimals);
+    
+    // Check USDC balance
+    const balance = await usdcContract.balanceOf(address);
+    if (balance < amountInUnits) {
+      return {
+        success: false,
+        error: `Insufficient USDC balance. You are trying to send ${amount}`
+      };
+    }
+
+    // Send USDC
+    const tx = await usdcContract.transfer(destination, amountInUnits);
+    const receipt = await tx.wait();
+
+    return {
+      success: true,
+      txUrl: `${networkConfig.explorerUrl}/tx/${receipt.hash}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+async function transferCustomToken({ address, privateKeyHex }, destination, tokenAddress, amount, network) {
+  const networkConfig = networks[network.toUpperCase()];
+  if (!networkConfig) {
+    return {
+      success: false,
+      error: `Network ${network} not found. Available networks: ${Object.keys(networks).join(", ")}`
+    }
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    const wallet = new ethers.Wallet(privateKeyHex, provider);
+
+    // USDT contract interface - only including functions we need
+    const tokenAbi = [
+      'function balanceOf(address) view returns (uint256)',
+      'function decimals() view returns (uint8)',
+      'function transfer(address, uint256) returns (bool)'
+    ];
+
+    const tokenContract = new ethers.Contract(
+      tokenAddress,
+      tokenAbi,
+      wallet  // Use wallet as signer
+    );
+
+    // Get USDT decimals
+    const decimals = await tokenContract.decimals();
+    
+    // Convert amount to USDT units
+    const amountInUnits = ethers.parseUnits(amount, decimals);
+    
+    // Check USDT balance
+    const balance = await tokenContract.balanceOf(address);
+    if (balance < amountInUnits) {
+      return {
+        success: false,
+        error: `Insufficient token balance. You are trying to send ${amount}`
+      };
+    }
+
+    // Send token
+    const tx = await tokenContract.transfer(destination, amountInUnits);
+    const receipt = await tx.wait();
+
+    return {
+      success: true,
+      txUrl: `${networkConfig.explorerUrl}/tx/${receipt.hash}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  generateMnemonicFromPassword,
+  generateWalletFromPassword,
+  getBalanceFromAddress,
+  getCustomBalanceFromAddress,
+  transferNative,
+  transferUSDT,
+  transferUSDC,
+  transferCustomToken
+}

package/utils/tron.js

@@ -0,0 +1,163 @@
+const bip39 = require('bip39');
+const hdkey = require('hdkey');
+const crypto = require('crypto');
+const { TronWeb } = require('tronweb');
+
+// mainnet
+const hostURI = "https://api.trongrid.io"
+const usdtContract = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+
+// testnet
+// const hostURI = "https://api.shasta.trongrid.io"
+// const usdtContract = 'TG3XXyExBkPp9nzdajDZsozEu4BkaSJozs';
+
+const USDT_CONTRACT_ABI = [
+  {
+    'outputs': [{ 'type': 'uint256' }],
+    'constant': true,
+    'inputs': [{ 'name': 'who', 'type': 'address' }],
+    'name': 'balanceOf',
+    'stateMutability': 'View',
+    'type': 'Function'
+  },
+  {
+    'outputs': [{ 'type': 'bool' }],
+    'inputs': [
+      { 'name': '_to', 'type': 'address' },
+      { 'name': '_value', 'type': 'uint256' }
+    ],
+    'name': 'transfer',
+    'stateMutability': 'Nonpayable',
+    'type': 'Function'
+  }
+];
+
+function generateHash(input) {
+  return crypto.createHash('sha256') // Use SHA-256 algorithm
+    .update(input)        // Hash the input string
+    .digest('hex');       // Output the hash in hex format
+}
+
+function generateMnemonicFromPassword (pwd) {
+  const hash = generateHash(pwd)
+  const mnemonic = bip39.entropyToMnemonic(hash)
+  if (!bip39.validateMnemonic(mnemonic)) {
+    return null
+  }
+  return mnemonic
+}
+
+async function generatePrivateKeyHexFromMnemonic(seedPhrase) {
+
+  const derivationPath = "m/44'/1'/9'/9/8"
+  const seed = await bip39.mnemonicToSeed(seedPhrase);
+  const hdwallet = hdkey.fromMasterSeed(seed);
+  const wallet = hdwallet.derive(derivationPath);
+
+  const privateKey = wallet.privateKey;
+
+  return Buffer.from(privateKey, "binary").toString("hex")
+}
+
+async function generateWalletFromPassword (pwd) {
+  const mnemonic = generateMnemonicFromPassword(pwd)
+  const privateKeyHex = await generatePrivateKeyHexFromMnemonic(mnemonic)
+  const tronWeb = new TronWeb({
+    fullHost: hostURI
+  });
+  const address = tronWeb.address.fromPrivateKey(privateKeyHex);
+  return {
+    privateKeyHex,
+    address
+  }
+}
+
+async function getTRXBalance(address) {
+  try {
+    const tronWeb = new TronWeb({
+      fullHost: hostURI
+    });
+    const balanceInSun = await tronWeb.trx.getBalance(address); // Balance in SUN (1 TRX = 1,000,000 SUN)
+    const balanceInTRX = tronWeb.fromSun(balanceInSun);         // Convert to TRX
+    return balanceInTRX
+  } catch (error) {
+    console.error('Error fetching TRX balance:', error);
+    return -1
+  }
+}
+
+async function getUSDTBalance(address) {
+  try {
+    const tronWeb = new TronWeb({
+      fullHost: hostURI
+    });
+    tronWeb.setAddress(usdtContract)
+
+    const contract = await tronWeb.contract(USDT_CONTRACT_ABI, usdtContract);
+    const balance = await contract.balanceOf(address).call();
+
+    const usdtBalance = tronWeb.toDecimal(balance) / Math.pow(10, 6);
+    return usdtBalance
+  } catch (error) {
+    console.error('Error fetching USDT balance:', error);
+    return -1;
+  }
+}
+
+async function getBalanceFromAddress (address) {
+  const trx_balance = await getTRXBalance(address)
+  const usdt_balance = await getUSDTBalance(address)
+  return {
+    trx_balance,
+    usdt_balance
+  }
+}
+
+async function transferTRX (creds, destination, amountInTRX) {
+
+  const { privateKeyHex } = creds;
+
+  const tronWeb = new TronWeb({
+    fullHost: hostURI,
+    privateKey: privateKeyHex
+  });
+
+  try {
+    const transaction = await tronWeb.trx.sendTransaction(destination, tronWeb.toSun(amountInTRX));
+    const { result, txid } = transaction
+    if (result)
+      return { success: true, result: txid }
+    console.log(transaction)
+    return { success: false, result: "error" };
+  } catch (error) {
+    console.error('Error transferring TRX:', error);
+    return { success: false, result: "error" };
+  }
+}
+
+async function transferUSDT (creds, destination, amountInUSDT) {
+
+  const { privateKeyHex, address } = creds;
+
+  const tronWeb = new TronWeb({
+    fullHost: hostURI,
+    privateKey: privateKeyHex
+  });
+
+  try {
+    const contract = await tronWeb.contract().at(usdtContract);
+    const transaction = await contract.methods.transfer(destination, tronWeb.toSun(amountInUSDT)).send({ from: address });
+    return { success: true, result: transaction }
+  } catch (error) {
+    console.error('Error transferring USDT:', error);
+    return { success: false, result: "error" };
+  }
+}
+
+module.exports = {
+  generateMnemonicFromPassword,
+  generateWalletFromPassword,
+  getBalanceFromAddress,
+  transferTRX,
+  transferUSDT
+}