crypto-wallet-xpub 1.0.0

package/bep20-wallet.js

@@ -0,0 +1,136 @@
+/**
+ * BEP20 Wallet Generator
+ * 
+ * Generates BEP20 (Binance Smart Chain) wallet addresses from Account Extended Public Key (XPUB).
+ * 
+ * @module bep20-wallet
+ */
+
+const { HDNodeWallet } = require('ethers');
+
+/**
+ * BEP20 Wallet Class
+ * 
+ * @class BEP20Wallet
+ * @example
+ * const { BEP20Wallet } = require('crypto-wallet-xpub');
+ * 
+ * const xpub = "xpub6Ce5wAYj54UjjC6T83tSoriMdebVzDJfNjB7ocoY9DJshVZsbciCgvLaKLJp38Zh7x8v2222Fob3Shqcum7g3Kg6Ja7igUo3LdrzNb9E93t";
+ * const wallet = new BEP20Wallet(xpub);
+ * 
+ * // Get single address
+ * const address = wallet.getAddress(0);
+ * console.log(address); // 0x9894A0B1863382F74DCe886C6Bf6817C604BEE52
+ * 
+ * // Get multiple addresses
+ * const addresses = wallet.getAddresses(0, 4);
+ * console.log(addresses);
+ */
+class BEP20Wallet {
+  /**
+   * Creates a new BEP20 wallet instance
+   * 
+   * @param {string} xpub - Account Extended Public Key (XPUB) derived from path m/44'/60'/0'
+   * @throws {Error} If XPUB is not provided or invalid
+   * 
+   * @example
+   * const wallet = new BEP20Wallet("xpub6Ce5wAYj54Ujj...");
+   */
+  constructor(xpub) {
+    if (!xpub) {
+      throw new Error('XPUB is required');
+    }
+    
+    if (typeof xpub !== 'string') {
+      throw new Error('XPUB must be a string');
+    }
+    
+    if (!xpub.startsWith('xpub')) {
+      throw new Error('Invalid XPUB format. Must start with "xpub"');
+    }
+    
+    try {
+      this.xpub = xpub;
+      this.root = HDNodeWallet.fromExtendedKey(xpub);
+    } catch (error) {
+      throw new Error(`Invalid XPUB: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get a single BEP20 address at specified index
+   * 
+   * @param {number} index - Derivation index (0, 1, 2, ...)
+   * @returns {string} BEP20 wallet address (0x...)
+   * @throws {Error} If index is invalid
+   * 
+   * @example
+   * const address = wallet.getAddress(0);
+   * console.log(address); // "0x9894A0B1863382F74DCe886C6Bf6817C604BEE52"
+   */
+  getAddress(index) {
+    if (typeof index !== 'number' || index < 0 || !Number.isInteger(index)) {
+      throw new Error('Index must be a non-negative integer');
+    }
+    
+    try {
+      const child = this.root.derivePath(`0/${index}`);
+      return child.address;
+    } catch (error) {
+      throw new Error(`Failed to derive address at index ${index}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get multiple BEP20 addresses in a range
+   * 
+   * @param {number} start - Start index (inclusive)
+   * @param {number} end - End index (inclusive)
+   * @returns {Array<{index: number, address: string}>} Array of address objects
+   * @throws {Error} If range is invalid
+   * 
+   * @example
+   * const addresses = wallet.getAddresses(0, 4);
+   * // [
+   * //   { index: 0, address: "0x9894A0B1863382F74DCe886C6Bf6817C604BEE52" },
+   * //   { index: 1, address: "0x50EC5410B937438C49fdFf2981166064E4dF95cB" },
+   * //   ...
+   * // ]
+   */
+  getAddresses(start, end) {
+    if (typeof start !== 'number' || typeof end !== 'number') {
+      throw new Error('Start and end must be numbers');
+    }
+    
+    if (start < 0 || end < 0 || !Number.isInteger(start) || !Number.isInteger(end)) {
+      throw new Error('Start and end must be non-negative integers');
+    }
+    
+    if (start > end) {
+      throw new Error('Start index must be less than or equal to end index');
+    }
+    
+    const addresses = [];
+    for (let i = start; i <= end; i++) {
+      addresses.push({
+        index: i,
+        address: this.getAddress(i)
+      });
+    }
+    return addresses;
+  }
+
+  /**
+   * Get the XPUB used by this wallet
+   * 
+   * @returns {string} The Account Extended Public Key
+   * 
+   * @example
+   * const xpub = wallet.getXPUB();
+   */
+  getXPUB() {
+    return this.xpub;
+  }
+}
+
+module.exports = { BEP20Wallet };

package/index.js

@@ -0,0 +1,14 @@
+/**
+ * crypto-wallet-xpub
+ * Generate BEP20 and TRC20 addresses from Account Extended Public Keys
+ * 
+ * @module crypto-wallet-xpub
+ */
+
+const { BEP20Wallet } = require('./bep20-wallet');
+const { TRC20Wallet } = require('./trc20-wallet');
+
+module.exports = {
+  BEP20Wallet,
+  TRC20Wallet
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "crypto-wallet-xpub",
+  "version": "1.0.0",
+  "description": "Generate BEP20 (BSC) and TRC20 (TRON) wallet addresses from Account Extended Public Keys (XPUB)",
+  "main": "index.js",
+  "scripts": {
+    "test": "node examples/bep20-example.js && node examples/trc20-example.js"
+  },
+  "keywords": [
+    "crypto",
+    "wallet",
+    "bep20",
+    "trc20",
+    "bsc",
+    "binance-smart-chain",
+    "tron",
+    "xpub",
+    "bip32",
+    "bip44",
+    "hdwallet",
+    "hierarchical-deterministic"
+  ],
+  "author": "offici5l>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/offici5l/crypto-wallet-xpub.git"
+  },
+  "bugs": {
+    "url": "https://github.com/offici5l/crypto-wallet-xpub/issues"
+  },
+  "homepage": "https://github.com/offici5l/crypto-wallet-xpub#readme",
+  "dependencies": {
+    "ethers": "^6.9.0",
+    "hdkey": "^2.1.0",
+    "secp256k1": "^5.0.0",
+    "keccak": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/trc20-wallet.js

@@ -0,0 +1,199 @@
+/**
+ * TRC20 Wallet Generator
+ * 
+ * Generates TRC20 (TRON) wallet addresses from Account Extended Public Key (XPUB).
+ * 
+ * @module trc20-wallet
+ */
+
+const HDKey = require('hdkey');
+const secp256k1 = require('secp256k1');
+const createKeccakHash = require('keccak');
+const crypto = require('crypto');
+
+/**
+ * TRC20 Wallet Class
+ * 
+ * @class TRC20Wallet
+ * @example
+ * const { TRC20Wallet } = require('crypto-wallet-xpub');
+ * 
+ * const xpub = "xpub6C5KYvkMHmGWqx3yDSqiwcrgQbhxzQFUFPURg7Tvw3dELngbRd1sAuajPT1NsCfohgJHojoBS7XaQgBCMj2eJmX9xYAD9TzCHPXhkrw2PMy";
+ * const wallet = new TRC20Wallet(xpub);
+ * 
+ * // Get single address
+ * const address = wallet.getAddress(0);
+ * console.log(address); // TFs5Wcs68CrmDG113bTJfKEUHvKUf9Vz6a
+ * 
+ * // Get multiple addresses
+ * const addresses = wallet.getAddresses(0, 4);
+ * console.log(addresses);
+ */
+class TRC20Wallet {
+  /**
+   * Creates a new TRC20 wallet instance
+   * 
+   * @param {string} xpub - Account Extended Public Key (XPUB) derived from path m/44'/195'/0'
+   * @throws {Error} If XPUB is not provided or invalid
+   * 
+   * @example
+   * const wallet = new TRC20Wallet("xpub6C5KYvkMHmGW...");
+   */
+  constructor(xpub) {
+    if (!xpub) {
+      throw new Error('XPUB is required');
+    }
+    
+    if (typeof xpub !== 'string') {
+      throw new Error('XPUB must be a string');
+    }
+    
+    if (!xpub.startsWith('xpub')) {
+      throw new Error('Invalid XPUB format. Must start with "xpub"');
+    }
+    
+    try {
+      this.xpub = xpub;
+      this.master = HDKey.fromExtendedKey(xpub);
+      this.changeNode = this.master.deriveChild(0);
+    } catch (error) {
+      throw new Error(`Invalid XPUB: ${error.message}`);
+    }
+  }
+
+  /**
+   * Encode address bytes to Base58Check format (TRON address format)
+   * 
+   * @private
+   * @param {Buffer} payload - Address bytes to encode
+   * @returns {string} Base58Check encoded address
+   */
+  base58CheckEncode(payload) {
+    const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+    const hash1 = crypto.createHash("sha256").update(buffer).digest();
+    const hash2 = crypto.createHash("sha256").update(hash1).digest();
+    const checksum = hash2.slice(0, 4);
+    const data = Buffer.concat([buffer, checksum]);
+    
+    const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let num = BigInt("0x" + data.toString("hex"));
+    let encoded = "";
+    
+    while (num > 0n) {
+      const mod = Number(num % 58n);
+      encoded = alphabet[mod] + encoded;
+      num = num / 58n;
+    }
+    
+    for (const byte of data) {
+      if (byte !== 0) break;
+      encoded = "1" + encoded;
+    }
+    
+    return encoded;
+  }
+
+  /**
+   * Generate TRON address from compressed public key
+   * 
+   * @private
+   * @param {Buffer} compressedPubKey - Compressed public key (33 bytes)
+   * @returns {string} TRON address (T...)
+   */
+  generateTronAddress(compressedPubKey) {
+    // Convert compressed public key to uncompressed format
+    const uncompressedPubKey = secp256k1.publicKeyConvert(
+      Buffer.isBuffer(compressedPubKey) ? compressedPubKey : Buffer.from(compressedPubKey),
+      false
+    );
+    
+    const uncompressedBuffer = Buffer.from(uncompressedPubKey);
+    
+    // Apply Keccak256 hash
+    const hash = createKeccakHash('keccak256').update(uncompressedBuffer.slice(1)).digest();
+    
+    // Take last 20 bytes and add TRON prefix (0x41)
+    const addressBytes = hash.slice(-20);
+    const addressHex = "41" + addressBytes.toString('hex');
+    
+    // Encode to Base58Check
+    return this.base58CheckEncode(Buffer.from(addressHex, "hex"));
+  }
+
+  /**
+   * Get a single TRC20 address at specified index
+   * 
+   * @param {number} index - Derivation index (0, 1, 2, ...)
+   * @returns {string} TRC20 wallet address (T...)
+   * @throws {Error} If index is invalid
+   * 
+   * @example
+   * const address = wallet.getAddress(0);
+   * console.log(address); // "TFs5Wcs68CrmDG113bTJfKEUHvKUf9Vz6a"
+   */
+  getAddress(index) {
+    if (typeof index !== 'number' || index < 0 || !Number.isInteger(index)) {
+      throw new Error('Index must be a non-negative integer');
+    }
+    
+    try {
+      const node = this.changeNode.deriveChild(index);
+      return this.generateTronAddress(node.publicKey);
+    } catch (error) {
+      throw new Error(`Failed to derive address at index ${index}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get multiple TRC20 addresses in a range
+   * 
+   * @param {number} start - Start index (inclusive)
+   * @param {number} end - End index (inclusive)
+   * @returns {Array<{index: number, address: string}>} Array of address objects
+   * @throws {Error} If range is invalid
+   * 
+   * @example
+   * const addresses = wallet.getAddresses(0, 4);
+   * // [
+   * //   { index: 0, address: "TFs5Wcs68CrmDG113bTJfKEUHvKUf9Vz6a" },
+   * //   { index: 1, address: "TEFosF8dnrgLYx4gAwYVq1sDpRTNUQ9br5" },
+   * //   ...
+   * // ]
+   */
+  getAddresses(start, end) {
+    if (typeof start !== 'number' || typeof end !== 'number') {
+      throw new Error('Start and end must be numbers');
+    }
+    
+    if (start < 0 || end < 0 || !Number.isInteger(start) || !Number.isInteger(end)) {
+      throw new Error('Start and end must be non-negative integers');
+    }
+    
+    if (start > end) {
+      throw new Error('Start index must be less than or equal to end index');
+    }
+    
+    const addresses = [];
+    for (let i = start; i <= end; i++) {
+      addresses.push({
+        index: i,
+        address: this.getAddress(i)
+      });
+    }
+    return addresses;
+  }
+
+  /**
+   * Get the XPUB used by this wallet
+   * 
+   * @returns {string} The Account Extended Public Key
+   * 
+   * @example
+   * const xpub = wallet.getXPUB();
+   */
+  getXPUB() {
+    return this.xpub;
+  }
+}
+
+module.exports = { TRC20Wallet };