Wallet Factory Determinista en Tron con TronBox

// ERC20 standard
function transfer(address to, uint256 amount) external returns (bool);

// TRC20 on Tron — no return value
function transfer(address to, uint256 amount) external;

// SPDX-License-Identifier: MIT
pragma solidity 0.8.25;


/// @dev Tron-compatible TRC20 interface.
///      transfer does not return a bool — compatibility with native Tron TRC20 tokens.
interface ITRC20 {
    function transfer(address to, uint256 amount) external;
    function balanceOf(address account) external view returns (uint256);
}

mkdir wallet-factory-tron && cd wallet-factory-tron
npx tronbox init
npm install @openzeppelin/contracts@^5.0.0 dotenv minimist tronweb@^6.2.0
npm install --save-dev tronbox@^4.5.0

require('dotenv').config();
module.exports = {
  networks: {
    mainnet: {
      privateKey: process.env.PRIVATE_KEY_MAINNET,
      userFeePercentage: 100,
      feeLimit: 1000 * 1e6,
      fullHost: 'https://api.trongrid.io',
      network_id: '1'
    },
    shasta: {
      privateKey: process.env.PRIVATE_KEY_SHASTA,
      userFeePercentage: 50,
      feeLimit: 1000 * 1e6,
      fullHost: 'https://api.shasta.trongrid.io',
      network_id: '2'
    },
    nile: {
      privateKey: process.env.PRIVATE_KEY_NILE,
      userFeePercentage: 100,
      feeLimit: 1000 * 1e6,
      fullHost: 'https://nile.trongrid.io',
      network_id: '3'
    },
    development: {
      privateKey: '0000000000000000000000000000000000000000000000000000000000000001',
      userFeePercentage: 0,
      feeLimit: 1000 * 1e6,
      fullHost: 'http://127.0.0.1:9090',
      network_id: '9'
    }
  },
  compilers: {
    solc: {
      version: '0.8.25',
      settings: {
        optimizer: {
          enabled: true,
          runs: 200
        },
        evmVersion: 'cancun'
      }
    }
  }
};

# Private keys (without 0x prefix)
PRIVATE_KEY_NILE=your_private_key_here
PRIVATE_KEY_MAINNET=your_mainnet_key_here

# Relayer: the EOA authorized to trigger deploys and sweeps
RELAYER_ADDRESS=TYourRelayerBase58Address

# After deployment, set this:
WALLET_FACTORY_ADDRESS=TYourFactoryBase58Address

# Treasury: where swept funds go
TREASURY_ADDRESS=TYourTreasuryBase58Address

# Default TRC20 token for sweeps (e.g., USDT on Nile)
TRC20_TOKEN_ADDRESS=TXLAQ63Xg1NAzckPwKHvzw7CSEmLMEqcdj

# RPC endpoint
FULL_NODE_URL_TRON=https://nile.trongrid.io

{
  "dependencies": {
    "@openzeppelin/contracts": "^5.0.0",
    "dotenv": "^17.3.1",
    "minimist": "^1.2.8",
    "tronweb": "^6.2.0"
  },
  "devDependencies": {
    "tronbox": "^4.5.0"
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.25;


/// @dev Tron-compatible TRC20 interface.
///      transfer does not return a bool — compatibility with native Tron TRC20 tokens.
interface ITRC20 {
    function transfer(address to, uint256 amount) external;
    function balanceOf(address account) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.25;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./ITRC20.sol";

/**
 * @title  WalletReceiver
 * @author Beltsys Labs
 * @notice Minimal contract that receives TRC20 tokens or TRX and allows
 *         the relayer to sweep funds to one or multiple destinations.
 * @dev    Deployed via native CREATE2 on Tron. Parameters are
 *         immutable to minimize energy consumption.
 *         Uses ITRC20 instead of SafeERC20 for compatibility with
 *         native Tron TRC20 tokens that do not return a bool on transfer.
 * @custom:version 1.0.2-tron
 * @custom:security-contact info@beltsys.com
 */

contract WalletReceiver is ReentrancyGuard {
    // ─── Constants ────────────────────────────────────────────────────────────

    uint256 public constant MAX_RECIPIENTS = 5;

    // ─── Structs ──────────────────────────────────────────────────────────────

    struct Recipient {
        address wallet;
        uint256 bps;
    }

    // ─── Immutables ───────────────────────────────────────────────────────────

    address public immutable relayer;
    address public immutable factory;
    bytes32 public immutable walletId;

    // ─── Events ───────────────────────────────────────────────────────────────

    event Swept(
        bytes32 indexed walletId,
        address indexed token,
        uint256 totalAmount,
        uint256 recipientCount
    );

    event NativeSwept(
        bytes32 indexed walletId,
        uint256 totalAmount,
        uint256 recipientCount
    );

    // ─── Errors ───────────────────────────────────────────────────────────────

    error NotAuthorized();
    error NothingToSweep();
    error TransferFailed();
    error ZeroAddress();
    error InvalidRecipients();
    error TooManyRecipients();
    error BpsDoNotSum();
    error BpsOverflow();

    // ─── Constructor ──────────────────────────────────────────────────────────

    constructor(
        address _relayer,
        address _factory,
        bytes32 _walletId
    ) {
        if (_relayer == address(0)) revert ZeroAddress();
        if (_factory == address(0)) revert ZeroAddress();
        relayer  = _relayer;
        factory  = _factory;
        walletId = _walletId;
    }

    // ─── Modifiers ────────────────────────────────────────────────────────────

    modifier onlyAuthorized() {
        if (msg.sender != relayer && msg.sender != factory) revert NotAuthorized();
        _;
    }

    // ─── Main Functions ───────────────────────────────────────────────────────

    function sweep(
        address token,
        Recipient[] calldata recipients
    ) external onlyAuthorized nonReentrant {
        if (recipients.length == 0)             revert InvalidRecipients();
        if (recipients.length > MAX_RECIPIENTS) revert TooManyRecipients();

        uint256 totalBps;
        for (uint256 i = 0; i < recipients.length; i++) {
            if (recipients[i].wallet == address(0)) revert ZeroAddress();
            if (recipients[i].bps > 10_000)         revert BpsOverflow();
            totalBps += recipients[i].bps;
        }
        if (totalBps != 10_000) revert BpsDoNotSum();

        ITRC20 _token = ITRC20(token);
        uint256 balance = _token.balanceOf(address(this));
        if (balance == 0) revert NothingToSweep();

        uint256 distributed;
        for (uint256 i = 0; i < recipients.length; i++) {
            uint256 amount = i == recipients.length - 1
                ? balance - distributed
                : (balance * recipients[i].bps) / 10_000;

            if (amount > 0) {
                // Direct call without checking return value —
                // native Tron TRC20 tokens do not return a bool
                _token.transfer(recipients[i].wallet, amount);
                distributed += amount;
            }
        }

        emit Swept(walletId, token, balance, recipients.length);
    }

    function sweepNative(
        Recipient[] calldata recipients
    ) external onlyAuthorized nonReentrant {
        if (recipients.length == 0)             revert InvalidRecipients();
        if (recipients.length > MAX_RECIPIENTS) revert TooManyRecipients();

        uint256 totalBps;
        for (uint256 i = 0; i < recipients.length; i++) {
            if (recipients[i].wallet == address(0)) revert ZeroAddress();
            if (recipients[i].bps > 10_000)         revert BpsOverflow();
            totalBps += recipients[i].bps;
        }
        if (totalBps != 10_000) revert BpsDoNotSum();

        uint256 bal = address(this).balance;
        if (bal == 0) revert NothingToSweep();

        uint256 distributed;
        for (uint256 i = 0; i < recipients.length; i++) {
            uint256 amount = i == recipients.length - 1
                ? bal - distributed
                : (bal * recipients[i].bps) / 10_000;

            if (amount > 0) {
                distributed += amount;
                (bool ok, ) = recipients[i].wallet.call{value: amount}("");
                if (!ok) revert TransferFailed();
            }
        }

        emit NativeSwept(walletId, bal, recipients.length);
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.25;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "./ITRC20.sol";
import "./WalletReceiver.sol";


/**
 * @title  WalletFactory
 * @author Beltsys Labs
 * @notice Factory contract that deploys deterministic WalletReceiver instances on Tron.
 * @dev    Uses native CREATE2 for deterministic addresses within the Tron network.
 *         Salt: keccak256(abi.encodePacked(walletId)).
 *         Uses ITRC20 instead of IERC20 for compatibility with native Tron TRC20
 *         tokens that do not return a bool on transfer.
 * @custom:version 1.0.2-tron
 * @custom:security-contact info@beltsys.com
 */

contract WalletFactory is Ownable, Pausable {

    // ─── State ────────────────────────────────────────────────────────────────

    /// @notice Maximum number of recipients allowed per sweep to bound energy usage
    uint256 public constant MAX_RECIPIENTS = 5;

    /// @notice Backend EOA authorized to trigger deployments and sweeps
    address public relayer;

    /// @notice Tracks all WalletReceiver addresses deployed by this factory
    mapping(address => bool) public isDeployedReceiver;

    // ─── Events ───────────────────────────────────────────────────────────────

    event WalletDeployed(
        bytes32 indexed walletId,
        address indexed receiver,
        uint256 indexed chainId
    );

    event DeployedAndSwept(
        bytes32 indexed walletId,
        address indexed receiver,
        address indexed token,
        uint256 totalAmount,
        uint256 recipientCount
    );

    event EmergencySweep(
        address indexed receiver,
        address indexed token,
        address indexed destination
    );

    event RelayerUpdated(
        address indexed oldRelayer,
        address indexed newRelayer
    );

    // ─── Errors ───────────────────────────────────────────────────────────────

    error NotRelayer();
    error ZeroAddress();
    error InvalidToken();
    error InvalidReceiver();
    error TooManyRecipients();

    // ─── Constructor ──────────────────────────────────────────────────────────

    constructor(address _relayer) Ownable(msg.sender) {
        if (_relayer == address(0)) revert ZeroAddress();
        relayer = _relayer;
    }

    // ─── Modifiers ────────────────────────────────────────────────────────────

    modifier onlyRelayer() {
        if (msg.sender != relayer) revert NotRelayer();
        _;
    }

    modifier onlyValidReceiver(address receiver) {
        if (!isDeployedReceiver[receiver]) revert InvalidReceiver();
        _;
    }

    modifier validRecipients(uint256 count) {
        if (count > MAX_RECIPIENTS) revert TooManyRecipients();
        _;
    }

    // ─── Admin Functions ──────────────────────────────────────────────────────

    function setRelayer(address _relayer) external onlyOwner {
        if (_relayer == address(0)) revert ZeroAddress();
        emit RelayerUpdated(relayer, _relayer);
        relayer = _relayer;
    }

    function pause() external onlyOwner {
        _pause();
    }

    function unpause() external onlyOwner {
        _unpause();
    }

    // ─── Precompute ───────────────────────────────────────────────────────────

    /**
     * @notice Returns the deterministic address for a given walletId.
     * @dev    Uses the same formula as `new WalletReceiver{salt: salt}(...)`.
     *         Formula: keccak256(0x41 ++ address(this) ++ salt ++ keccak256(bytecode))
     */
    function computeWalletAddress(bytes32 walletId)
        external
        view
        returns (address walletAddress)
    {
        bytes32 salt = keccak256(abi.encodePacked(walletId));
        bytes memory bytecode = abi.encodePacked(
            type(WalletReceiver).creationCode,
            abi.encode(relayer, address(this), walletId)
        );

        // Tron/TVM CREATE2 address calculation (simplified for view)
        // Note: off-chain scripts should use the 0x41 prefix for exact matching
        return address(uint160(uint256(keccak256(abi.encodePacked(
            bytes1(0x41),
            address(this),
            salt,
            keccak256(bytecode)
        )))));
    }

    // ─── Deploy Standalone ────────────────────────────────────────────────────

    function deployWallet(bytes32 walletId)
        external
        onlyRelayer
        whenNotPaused
        returns (address receiver)
    {
        bytes32 salt = keccak256(abi.encodePacked(walletId));
        receiver = address(new WalletReceiver{salt: salt}(relayer, address(this), walletId));
        isDeployedReceiver[receiver] = true;
        emit WalletDeployed(walletId, receiver, 728126428);
    }

    // ─── Deploy + Sweep ───────────────────────────────────────────────────────

    function deployAndSweep(
        bytes32 walletId,
        address token,
        WalletReceiver.Recipient[] calldata recipients
    )
        external
        onlyRelayer
        whenNotPaused
        validRecipients(recipients.length)
        returns (address receiver)
    {
        bytes32 salt = keccak256(abi.encodePacked(walletId));
        receiver = address(new WalletReceiver{salt: salt}(relayer, address(this), walletId));
        isDeployedReceiver[receiver] = true;

        emit WalletDeployed(walletId, receiver, 728126428);

        if (token == address(0)) {
            uint256 balance = receiver.balance;
            if (balance > 0) {
                WalletReceiver(payable(receiver)).sweepNative(recipients);
                emit DeployedAndSwept(walletId, receiver, address(0), balance, recipients.length);
            }
        } else {
            // Use ITRC20 instead of IERC20 — compatible with native Tron TRC20 tokens
            uint256 balance = ITRC20(token).balanceOf(receiver);
            if (balance > 0) {
                WalletReceiver(payable(receiver)).sweep(token, recipients);
                emit DeployedAndSwept(walletId, receiver, token, balance, recipients.length);
            }
        }
    }

    function sweepExisting(
        address receiver,
        address token,
        WalletReceiver.Recipient[] calldata recipients
    )
        external
        onlyRelayer
        whenNotPaused
        onlyValidReceiver(receiver)
        validRecipients(recipients.length)
    {
        if (token == address(0)) {
            WalletReceiver(payable(receiver)).sweepNative(recipients);
        } else {
            WalletReceiver(payable(receiver)).sweep(token, recipients);
        }
    }

    // ─── Emergency Functions ──────────────────────────────────────────────────

    function emergencySweep(
        address receiver,
        address token,
        address destination
    )
        external
        onlyOwner
        onlyValidReceiver(receiver)
    {
        if (destination == address(0)) revert ZeroAddress();
        if (token == address(0))       revert InvalidToken();

        WalletReceiver.Recipient[] memory recipients = new WalletReceiver.Recipient[](1);
        recipients[0] = WalletReceiver.Recipient({
            wallet: destination,
            bps: 10_000
        });

        WalletReceiver(payable(receiver)).sweep(token, recipients);
        emit EmergencySweep(receiver, token, destination);
    }

    function emergencySweepNative(
        address receiver,
        address destination
    )
        external
        onlyOwner
        onlyValidReceiver(receiver)
    {
        if (destination == address(0)) revert ZeroAddress();

        WalletReceiver.Recipient[] memory recipients = new WalletReceiver.Recipient[](1);
        recipients[0] = WalletReceiver.Recipient({
            wallet: destination,
            bps: 10_000
        });

        WalletReceiver(payable(receiver)).sweepNative(recipients);
        emit EmergencySweep(receiver, address(0), destination);
    }
}

require('dotenv').config();
const WalletFactory = artifacts.require("WalletFactory");
const crypto = require('crypto');

// Converts a hex Tron address (41...) to base58check format (T...)
function hexToBase58(hexAddr) {
    const BASE58_CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    const payload = Buffer.from(hexAddr, 'hex');
    const h1 = crypto.createHash('sha256').update(payload).digest();
    const h2 = crypto.createHash('sha256').update(h1).digest();
    const checksum = h2.slice(0, 4);
    const full = Buffer.concat([payload, checksum]);

    let num = BigInt('0x' + full.toString('hex'));
    let result = '';
    const base = BigInt(58);
    while (num > 0n) {
        result = BASE58_CHARS[Number(num % base)] + result;
        num = num / base;
    }
    for (const byte of full) {
        if (byte !== 0) break;
        result = '1' + result;
    }
    return result;
}

module.exports = async function (deployer, network) {
    const relayer = process.env.RELAYER_ADDRESS;

    if (!relayer) {
        throw new Error("RELAYER_ADDRESS is not defined in .env");
    }

    console.log(">> Deploying WalletFactory with Relayer:", relayer);

    await deployer.deploy(WalletFactory, relayer);

    const instance = await WalletFactory.deployed();
    const hexAddress = instance.address;                 // 41...
    const base58Address = hexToBase58(hexAddress);       // T...

    console.log("\n╔══════════════════════════════════════════════════════╗");
    console.log("║         WalletFactory — Deploy successful            ║");
    console.log("╠══════════════════════════════════════════════════════╣");
    console.log("║ Network  :", network.padEnd(43), "║");
    console.log("║ Hex      :", hexAddress.padEnd(43), "║");
    console.log("║ Tron     :", base58Address.padEnd(43), "║");
    console.log("║ Relayer  :", relayer.padEnd(43), "║");
    console.log("╚══════════════════════════════════════════════════════╝\n");
    console.log(">> Update WALLET_FACTORY_ADDRESS in .env with:", base58Address);
};

# Compile contracts
npx tronbox compile

# Deploy to Nile testnet
npx tronbox migrate --network nile

# Deploy to mainnet
npx tronbox migrate --network mainnet

#!/usr/bin/env node
/**
 * scripts/compute-wallet.js
 * ─────────────────────────────────────────────────────────────────────────────
 * Pre-computes the CREATE2 address of a WalletReceiver on Tron,
 * reproducing exactly the formula from the WalletFactory contract:
 *
 *   salt    = keccak256(abi.encodePacked(walletId))
 *   address = keccak256(0x41 ++ factory ++ salt ++ keccak256(initCode))
 *
 * Usage:
 *   node scripts/compute-wallet.js <walletId>
 *   node scripts/compute-wallet.js user_123
 *   node scripts/compute-wallet.js 0xabc...  (bytes32 hex)
 *
 * Required environment variables (.env):
 *   WALLET_FACTORY_ADDRESS   T... address of the deployed WalletFactory
 *   RELAYER_ADDRESS          T... address of the relayer
 */

require('dotenv').config();
const crypto = require('crypto');
const path = require('path');

// ─── Helpers ──────────────────────────────────────────────────────────────────

/** keccak256 of a Buffer → Buffer */
function keccak256(buf) {
    const { createKeccakHash } = require('crypto');
    // Node does not have native keccak — use ethers (available via TronBox)
    try {
        const ethers = require('ethers');
        return Buffer.from(ethers.keccak256(buf).slice(2), 'hex');
    } catch {
        throw new Error(
            'Install ethers: npm install ethers\n' +
            'Or use: npx tronbox exec scripts/compute-wallet.js (has access to web3)'
        );
    }
}

/** Converts a hex Tron address (41...) to base58check (T...) */
function hexToBase58(hexAddr) {
    const CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    const payload = Buffer.from(hexAddr, 'hex');
    const h1 = crypto.createHash('sha256').update(payload).digest();
    const h2 = crypto.createHash('sha256').update(h1).digest();
    const full = Buffer.concat([payload, h2.slice(0, 4)]);
    let num = BigInt('0x' + full.toString('hex'));
    let result = '';
    while (num > 0n) { result = CHARS[Number(num % 58n)] + result; num /= 58n; }
    for (const b of full) { if (b !== 0) break; result = '1' + result; }
    return result;
}

/** Converts a Tron base58 address (T...) to hex without prefix (40 chars) */
function base58ToHex(addr) {
    const CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    let num = 0n;
    for (const c of addr) {
        const idx = CHARS.indexOf(c);
        if (idx < 0) throw new Error(`Invalid character in address: ${c}`);
        num = num * 58n + BigInt(idx);
    }
    // Convert BigInt to hex padded to 50 chars (25 bytes = 21 payload + 4 checksum)
    let hex = num.toString(16).padStart(50, '0');
    // Last 8 hex chars (4 bytes) are the checksum — take first 42 (21 bytes)
    const payload = hex.slice(0, 42);  // 21 bytes: prefix 41 + 20 address bytes
    return payload;                     // e.g., "41adc7832321..."
}

/** Converts a Tron address (T... or 41...) to a 20-byte EVM Buffer */
function addressToBytes20(addr) {
    let hex;
    if (addr.startsWith('T')) {
        hex = base58ToHex(addr); // 42 hex chars: "41" + 40 address chars
        hex = hex.slice(2);      // remove Tron prefix "41" → 40 chars
    } else if (addr.startsWith('0x')) {
        hex = addr.slice(2);                            // remove "0x"
        if (hex.startsWith('41')) hex = hex.slice(2);  // remove Tron prefix if present
    } else if (addr.startsWith('41')) {
        hex = addr.slice(2);    // remove Tron prefix
    } else {
        hex = addr;
    }
    if (hex.length !== 40) throw new Error(`Invalid address (expected 40 hex chars): ${addr}`);
    return Buffer.from(hex, 'hex');
}

/** walletId string → bytes32 Buffer (right-padded with zeros) */
function walletIdToBytes32(id) {
    if (id.startsWith('0x') && id.length === 66) {
        return Buffer.from(id.slice(2), 'hex');
    }
    // Plain text → UTF-8 → right-pad to 32 bytes
    const buf = Buffer.alloc(32, 0);
    const src = Buffer.from(id, 'utf8');
    if (src.length > 32) throw new Error('walletId exceeds 32 bytes in UTF-8');
    src.copy(buf, 0);
    return buf;
}

// ─── Main CREATE2 logic ─────────────────────────────────────────────────────

async function computeWalletAddress(walletIdStr) {
    // 1. Load bytecode from compiled artifact
    const artifactPath = path.join(__dirname, '..', 'build', 'contracts', 'WalletReceiver.json');
    const artifact = require(artifactPath);
    const creationBytecode = Buffer.from(artifact.bytecode.replace('0x', ''), 'hex');

    // 2. Read configuration from .env
    const factoryAddrRaw = process.env.WALLET_FACTORY_ADDRESS;
    const relayerAddrRaw = process.env.RELAYER_ADDRESS;

    if (!factoryAddrRaw) throw new Error('WALLET_FACTORY_ADDRESS not defined in .env');
    if (!relayerAddrRaw) throw new Error('RELAYER_ADDRESS not defined in .env');

    const factoryBytes = addressToBytes20(factoryAddrRaw);  // 20 bytes
    const relayerBytes = addressToBytes20(relayerAddrRaw);  // 20 bytes

    // 3. Prepare walletId as bytes32
    const walletIdBytes32 = walletIdToBytes32(walletIdStr); // 32 bytes

    // 4. Constructor args encoded (ABI encode: address, address, bytes32)
    //    ABI encoding: each value is a 32-byte word, addresses are left-padded
    const relayerPadded = Buffer.concat([Buffer.alloc(12, 0), relayerBytes]);  // 32 bytes
    const factoryPadded = Buffer.concat([Buffer.alloc(12, 0), factoryBytes]);  // 32 bytes
    const constructorArgs = Buffer.concat([relayerPadded, factoryPadded, walletIdBytes32]);

    // 5. initCode = creationBytecode + constructorArgs
    const initCode = Buffer.concat([creationBytecode, constructorArgs]);

    // 6. salt = keccak256(abi.encodePacked(walletId)) = keccak256(walletId)
    const salt = keccak256(walletIdBytes32);

    // 7. Tron CREATE2 formula:
    //    keccak256(0x41 ++ factory(20bytes) ++ salt(32bytes) ++ keccak256(initCode))
    const initCodeHash = keccak256(initCode);
    const preimage = Buffer.concat([
        Buffer.from([0x41]),   // Tron prefix (vs 0xff on EVM)
        factoryBytes,          // 20 bytes
        salt,                  // 32 bytes
        initCodeHash           // 32 bytes
    ]);
    const addressHash = keccak256(preimage);

    // 8. Take the last 20 bytes → EVM address
    const addressBytes = addressHash.slice(-20);
    const hexWithPrefix = '41' + addressBytes.toString('hex');
    const base58Addr = hexToBase58(hexWithPrefix);

    return { walletIdBytes32, salt, hexWithPrefix, base58Addr };
}

// ─── Entry point ──────────────────────────────────────────────────────────────

(async () => {
    const walletIdStr = process.argv[2];
    if (!walletIdStr) {
        console.error('Usage: node scripts/compute-wallet.js <walletId>');
        console.error('Example: node scripts/compute-wallet.js user_123');
        process.exit(1);
    }

    try {
        const { walletIdBytes32, salt, hexWithPrefix, base58Addr } =
            await computeWalletAddress(walletIdStr);

        console.log('\n════════════════════════════════════════════════════════');
        console.log('  WalletReceiver — Pre-computed address');
        console.log('════════════════════════════════════════════════════════');
        console.log('  WalletId (input) :', walletIdStr);
        console.log('  WalletId (bytes32):', '0x' + walletIdBytes32.toString('hex'));
        console.log('  Salt (keccak256)  :', '0x' + salt.toString('hex'));
        console.log('  Address (hex)     :', hexWithPrefix);
        console.log('  Address (Tron)    :', base58Addr);
        console.log('════════════════════════════════════════════════════════\n');

    } catch (err) {
        console.error('Error:', err.message);
        process.exit(1);
    }
})();

# Pre-compute address for walletId "user_123"
node scripts/compute-wallet.js user_123

# Pre-compute address for a hex bytes32 walletId
node scripts/compute-wallet.js 0x757365725f31323300000000000000000000000000000000000000000000000000

// compute.js — TronBox exec script
require('dotenv').config();
const WalletFactory = artifacts.require("WalletFactory");

module.exports = async function (callback) {
    try {
        const factory = await WalletFactory.deployed();
        const walletId = web3.utils.fromAscii("user_123").padEnd(66, '0');

        console.log("Computing address for walletId:", walletId);

        const predictedAddr = await factory.computeWalletAddress(walletId);

        console.log("-----------------------------------------");
        console.log("Address computed by contract:", predictedAddr);
        console.log("-----------------------------------------");

        callback();
    } catch (e) {
        console.error(e);
        callback(e);
    }
};

npx tronbox exec compute.js --network nile

#!/usr/bin/env node
/**
 * scripts/sweep.js
 * ─────────────────────────────────────────────────────────────────────────────
 * Sweeps funds from a WalletReceiver on Tron.
 *
 * Based on triggerSmartContract to avoid struct encoding issues
 * in TronWeb v6.
 */

require('dotenv').config();
const _TronWeb = require('tronweb');
const TronWeb = _TronWeb.TronWeb || _TronWeb;
const { ethers } = require('ethers');
const crypto = require('crypto');

// ─── Configuration ────────────────────────────────────────────────────────────

const FULL_NODE = process.env.FULL_NODE_URL_TRON || 'https://api.nileex.io';
const PRIVATE_KEY = process.env.PRIVATE_KEY_NILE;
const FACTORY_ADDRESS = process.env.WALLET_FACTORY_ADDRESS;
const TREASURY_ADDRESS = process.env.TREASURY_ADDRESS;
const TRC20_TOKEN_DEFAULT = process.env.TRC20_TOKEN_ADDRESS;

const TRON_ZERO_ADDRESS_HEX = '0000000000000000000000000000000000000000';

const tronWeb = new TronWeb({
    fullHost: FULL_NODE,
    privateKey: PRIVATE_KEY
});

// ─── Helpers ──────────────────────────────────────────────────────────────────

function base58ToHex20(base58) {
    if (!base58 || base58 === 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb') return TRON_ZERO_ADDRESS_HEX;
    const hex = tronWeb.address.toHex(base58); // Returns '41...' (21 bytes)
    return hex.slice(2); // Return the 20 bytes (40 chars)
}

function hex20ToBase58(hex20) {
    return tronWeb.address.fromHex('41' + hex20);
}

function resultToHex20(raw) {
    return raw.replace(/^0x/, '').slice(-40);
}

/** Send transaction using triggerSmartContract */
async function sendTx(functionSignature, params) {
    console.log(`Sending TX: ${functionSignature}`);
    const transaction = await tronWeb.transactionBuilder.triggerSmartContract(
        FACTORY_ADDRESS,
        functionSignature,
        { feeLimit: 400_000_000 }, // 400 TRX
        params
    );

    const signed = await tronWeb.trx.sign(transaction.transaction);
    const result = await tronWeb.trx.sendRawTransaction(signed);

    if (!result.result) {
        throw new Error(result.message || JSON.stringify(result));
    }
    return result.txid;
}

// ─── Main ─────────────────────────────────────────────────────────────────────

async function main() {
    const args = require('minimist')(process.argv.slice(2));
    const walletIdRaw = args.wallet;
    const tokenType = args.token; // 'native' or 'trc20' or address
    const customTo = args.to;

    if (!walletIdRaw) {
        console.error('Missing --wallet <walletId>');
        process.exit(1);
    }

    const treasuryBase58 = customTo || TREASURY_ADDRESS;
    if (!PRIVATE_KEY || !FACTORY_ADDRESS || !treasuryBase58) {
        console.error('Incomplete configuration in .env');
        process.exit(1);
    }

    // Resolve Token
    let tokenAddressHex20 = TRON_ZERO_ADDRESS_HEX;
    let tokenLabel = 'Native TRX';

    if (tokenType === 'trc20') {
        if (!TRC20_TOKEN_DEFAULT) {
            console.error('TRC20_TOKEN_ADDRESS not defined in .env');
            process.exit(1);
        }
        tokenAddressHex20 = base58ToHex20(TRC20_TOKEN_DEFAULT);
        tokenLabel = `TRC20 (${TRC20_TOKEN_DEFAULT})`;
    } else if (tokenType && tokenType.startsWith('T')) {
        tokenAddressHex20 = base58ToHex20(tokenType);
        tokenLabel = `TRC20 (${tokenType})`;
    }

    // Convert walletId to bytes32
    let walletIdHex;
    if (walletIdRaw.startsWith('0x') && walletIdRaw.length === 66) {
        walletIdHex = walletIdRaw;
    } else {
        const buf = Buffer.alloc(32, 0);
        const src = Buffer.from(walletIdRaw, 'utf8');
        if (src.length > 32) throw new Error('walletId exceeds 32 bytes');
        src.copy(buf, 0);
        walletIdHex = '0x' + buf.toString('hex');
    }

    const treasuryHex20 = base58ToHex20(treasuryBase58);

    console.log('\n════════════════════════════════════════════════════════');
    console.log('  Sweep — Tron');
    console.log('════════════════════════════════════════════════════════');
    console.log(`  Wallet ID: ${walletIdRaw}`);
    console.log(`  Token:     ${tokenLabel}`);
    console.log(`  Dest:      ${treasuryBase58} (${treasuryHex20})`);
    console.log('════════════════════════════════════════════════════════\n');

    // 1. Pre-compute receiver by calling the contract
    console.log('Pre-computing address on-chain...');
    const computeResult = await tronWeb.transactionBuilder.triggerConstantContract(
        FACTORY_ADDRESS,
        'computeWalletAddress(bytes32)',
        {},
        [{ type: 'bytes32', value: walletIdHex }]
    );
    const receiverHex20 = resultToHex20(computeResult.constant_result[0]);
    const receiverBase58 = hex20ToBase58(receiverHex20);
    console.log(`Receiver: ${receiverBase58} (${receiverHex20})`);

    // 2. Check balance if native
    if (tokenAddressHex20 === TRON_ZERO_ADDRESS_HEX) {
        const balanceSun = await tronWeb.trx.getBalance(receiverBase58);
        console.log(`TRX Balance: ${balanceSun / 1_000_000} TRX`);
    } else {
        console.log('TRC20 sweep requested.');
    }

    // 3. Check if already deployed
    const isDeployedResult = await tronWeb.transactionBuilder.triggerConstantContract(
        FACTORY_ADDRESS,
        'isDeployedReceiver(address)',
        {},
        [{ type: 'address', value: receiverHex20 }]
    );
    const isDeployed = parseInt(isDeployedResult.constant_result[0], 16) !== 0;
    console.log(`Already deployed?: ${isDeployed ? 'YES' : 'NO'}`);

    const recipients = [[treasuryHex20, 10000]]; // 10000 bps = 100%

    // 4. Estimate energy
    console.log('Estimating energy consumption...');
    try {
        const functionSelector = isDeployed
            ? 'sweepExisting(address,address,(address,uint256)[])'
            : 'deployAndSweep(bytes32,address,(address,uint256)[])';

        const params = isDeployed
            ? [
                { type: 'address', value: receiverHex20 },
                { type: 'address', value: tokenAddressHex20 },
                { type: '(address,uint256)[]', value: recipients }
            ]
            : [
                { type: 'bytes32', value: walletIdHex },
                { type: 'address', value: tokenAddressHex20 },
                { type: '(address,uint256)[]', value: recipients }
            ];

        const estimation = await tronWeb.transactionBuilder.triggerConstantContract(
            FACTORY_ADDRESS,
            functionSelector,
            {},
            params
        );

        if (estimation.result && estimation.result.result) {
            const energyUsed = estimation.energy_used || 0;
            // Current approximate price: 420 Sun per energy unit
            const estTrx = (energyUsed * 420) / 1_000_000;
            console.log(`   Energy estimated: ${energyUsed.toLocaleString()}`);
            console.log(`   Estimated cost (burning TRX): ~${estTrx.toFixed(2)} TRX`);
        }
    } catch (e) {
        console.log('   Could not estimate energy (can be ignored if wallet has no funds yet)');
    }

    // 5. Execute
    try {
        let txId;
        if (isDeployed) {
            console.log('\nCalling sweepExisting...');
            txId = await sendTx(
                'sweepExisting(address,address,(address,uint256)[])',
                [
                    { type: 'address', value: receiverHex20 },
                    { type: 'address', value: tokenAddressHex20 },
                    { type: '(address,uint256)[]', value: recipients }
                ]
            );
            console.log('sweepExisting sent');
        } else {
            console.log('\nCalling deployAndSweep...');
            txId = await sendTx(
                'deployAndSweep(bytes32,address,(address,uint256)[])',
                [
                    { type: 'bytes32', value: walletIdHex },
                    { type: 'address', value: tokenAddressHex20 },
                    { type: '(address,uint256)[]', value: recipients }
                ]
            );
            console.log('deployAndSweep sent');
        }

        console.log('   Tx hash:', txId);
        console.log('Waiting for confirmation and cost report...');

        // Wait for the network to process the Transaction Info
        await new Promise(r => setTimeout(r, 5000));

        const info = await tronWeb.trx.getTransactionInfo(txId);
        if (info && info.id) {
            console.log('\nReal Cost Report:');
            console.log('════════════════════════════════════════════════════════');
            const energyUsed = info.receipt ? (info.receipt.energy_usage_total || 0) : 0;
            const netUsed = info.net_usage || 0;
            const feePaid = info.fee || 0;

            console.log(`  Energy consumed  : ${energyUsed.toLocaleString()}`);
            console.log(`  Bandwidth used   : ${netUsed.toLocaleString()}`);
            console.log(`  TRX consumed     : ${feePaid / 1_000_000} TRX`);
            console.log('════════════════════════════════════════════════════════');
        }

    } catch (err) {
        console.error('\nTransaction error:');
        console.error(err?.output ? JSON.stringify(err.output) : err?.message || JSON.stringify(err));
        throw err;
    }
}

main().catch(err => {
    console.error('\nError:', err);
    process.exit(1);
});

# Sweep TRC20 tokens (uses TRC20_TOKEN_ADDRESS from .env)
node scripts/sweep.js --wallet user_123 --token trc20

# Sweep native TRX
node scripts/sweep.js --wallet user_123 --token native

# Sweep a specific TRC20 token to a custom address
node scripts/sweep.js --wallet user_123 --token TTokenBase58Address --to TCustomDestination

const estimation = await tronWeb.transactionBuilder.triggerConstantContract(
    FACTORY_ADDRESS,
    'deployAndSweep(bytes32,address,(address,uint256)[])',
    {},
    params
);

if (estimation.result && estimation.result.result) {
    const energyUsed = estimation.energy_used || 0;
    const estTrx = (energyUsed * 420) / 1_000_000; // Approximate
    console.log(`Estimated energy: ${energyUsed}`);
    console.log(`Estimated cost: ~${estTrx.toFixed(2)} TRX`);
}