Wallet Factory Determinista para Cadenas EVM con CreateX

mkdir wallet-factory-evm && cd wallet-factory-evm
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npm install @openzeppelin/contracts dotenv
npx hardhat init

# Llaves privadas (NUNCA las subas a git)
PRIVATE_KEY=0x_tu_llave_privada_del_relayer

# RPCs
RPC_URL_SEPOLIA=https://sepolia.infura.io/v3/TU_API_KEY
RPC_URL_AMOY=https://rpc-amoy.polygon.technology

# Direcciones
RELAYER_ADDRESS=0x_tu_direccion_de_relayer
TREASURY_ADDRESS=0x_tu_direccion_de_tesoreria

# Verificación
ETHER_SCAN_API=tu_etherscan_api_key

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "dotenv/config";

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.28",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200,
      },
      evmVersion: "paris",
    },
  },
  networks: {
    hardhat: {},
    amoy: {
      url: process.env.RPC_URL_AMOY,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
      chainId: 80002,
      timeout: 120000,
      gasPrice: 35000000000,
    },
    sepolia: {
      url: process.env.RPC_URL_SEPOLIA,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
      chainId: 11155111,
    }
  },
  etherscan: {
    apiKey: process.env.ETHER_SCAN_API || "",
  },
};

export default config;

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**
 * @title  WalletReceiver
 * @author Beltsys Labs
 * @notice Minimal contract that receives ERC20 or native tokens and allows
 *         the relayer to sweep funds to one or multiple destinations.
 * @dev    Deployed via CreateX (CREATE3), which guarantees the same address
 *         across all supported chains. All parameters are immutable to minimize
 *         gas usage and storage costs.
 * @custom:version 1.0.1
 * @custom:security-contact info@beltsys.com
 */
contract WalletReceiver is ReentrancyGuard {
    using SafeERC20 for IERC20;

    // ─── Constants ────────────────────────────────────────────────────────────

    /// @notice Maximum number of recipients allowed per sweep to prevent out-of-gas.
    ///         Each ERC20 transfer costs ~25,000 gas. With 5 recipients the sweep
    ///         loop stays well within safe gas limits (~125,000 gas for transfers alone).
    uint256 public constant MAX_RECIPIENTS = 5;

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

    /**
     * @notice Defines a fund recipient and their share of the total balance.
     * @param wallet  Destination address
     * @param bps     Share in basis points (10000 = 100%)
     */
    struct Recipient {
        address wallet;
        uint256 bps;
    }

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

    /// @notice The only address authorized to execute sweeps (backend EOA)
    address public immutable relayer;

    /// @notice The factory contract that deployed this receiver
    address public immutable factory;

    /// @notice Unique identifier for on-chain traceability
    bytes32 public immutable walletId;

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

    /**
     * @notice Emitted when an ERC20 sweep is executed successfully.
     * @param walletId        Unique identifier of the wallet
     * @param token           Address of the swept ERC20 token
     * @param totalAmount     Total amount swept
     * @param recipientCount  Number of recipients funds were distributed to
     */
    event Swept(
        bytes32 indexed walletId,
        address indexed token,
        uint256 totalAmount,
        uint256 recipientCount
    );

    /**
     * @notice Emitted when a native token sweep is executed successfully.
     * @param walletId        Unique identifier of the wallet
     * @param totalAmount     Total native amount swept
     * @param recipientCount  Number of recipients funds were distributed to
     */
    event NativeSwept(
        bytes32 indexed walletId,
        uint256 totalAmount,
        uint256 recipientCount
    );

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

    /// @notice Caller is not the relayer or factory
    error NotAuthorized();

    /// @notice Token or native balance is zero, nothing to sweep
    error NothingToSweep();

    /// @notice Native token transfer to a recipient failed
    error TransferFailed();

    /// @notice A required address parameter is the zero address
    error ZeroAddress();

    /// @notice Recipients array is empty
    error InvalidRecipients();

    /// @notice Recipients array exceeds MAX_RECIPIENTS limit
    error TooManyRecipients();

    /// @notice Sum of all recipient bps does not equal 10000
    error BpsDoNotSum();

    /// @notice A single recipient bps value exceeds 10000
    error BpsOverflow();

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

    /**
     * @notice Initializes the receiver with immutable references.
     * @param _relayer   Address of the authorized relayer (backend EOA)
     * @param _factory   Address of the WalletFactory that deployed this contract
     * @param _walletId  Unique identifier for this wallet instance
     */
    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 ────────────────────────────────────────────────────────────

    /// @dev Restricts access to the relayer or the factory contract
    modifier onlyAuthorized() {
        if (msg.sender != relayer && msg.sender != factory) revert NotAuthorized();
        _;
    }

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

    /**
     * @notice Transfers the entire ERC20 balance to one or multiple recipients.
     * @dev    The last recipient receives the remainder to avoid dust from rounding.
     *         All bps values must sum to exactly 10000.
     *         Maximum of MAX_RECIPIENTS recipients allowed to prevent out-of-gas.
     *         Examples:
     *           Single recipient:  [{ wallet: treasury, bps: 10000 }]
     *           98/2 split:        [{ wallet: A, bps: 9800 }, { wallet: B, bps: 200 }]
     * @param token       Address of the ERC20 token to sweep
     * @param recipients  Array of recipients with their basis point shares
     */
    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();

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

        uint256 distributed;

        for (uint256 i = 0; i < recipients.length; i++) {
            uint256 amount;

            // Last recipient gets the remainder to avoid dust from rounding
            if (i == recipients.length - 1) {
                amount = balance - distributed;
            } else {
                amount = (balance * recipients[i].bps) / 10_000;
            }

            if (amount > 0) {
                IERC20(token).safeTransfer(recipients[i].wallet, amount);
                distributed += amount;
            }
        }

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

    /**
     * @notice Transfers the entire native token balance (ETH, MATIC, BNB, etc.)
     *         to one or multiple recipients.
     * @dev    Protected against reentrancy attacks via the nonReentrant modifier.
     *         The last recipient receives the remainder to avoid dust from rounding.
     *         All bps values must sum to exactly 10000.
     *         Maximum of MAX_RECIPIENTS recipients allowed to prevent out-of-gas.
     * @param recipients  Array of recipients with their basis point shares
     */
    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);
    }

    /// @notice Allows the contract to receive native tokens (ETH, MATIC, BNB, etc.)
    receive() external payable {}
}

contract WalletReceiver is ReentrancyGuard {
    using SafeERC20 for IERC20;

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

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

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;
}

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

receive() external payable {}

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

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "./WalletReceiver.sol";

interface ICreateX {
    function deployCreate3(bytes32 salt, bytes memory initCode)
        external payable returns (address);

    function computeCreate3Address(bytes32 salt, address deployer)
        external view returns (address);
}

/**
 * @title  WalletFactory
 * @author Beltsys Labs
 * @notice Factory contract that wraps CreateX to deploy deterministic
 *         WalletReceiver instances with the same address across all supported chains.
 * @dev     Uses CREATE3 via CreateX for deterministic cross-chain addresses.
 *          Salt: [address(this)] [0x00] [11-byte hash of walletId].
 *
 * @custom:version 1.0.1
 * @custom:security-contact info@beltsys.com
 */
contract WalletFactory is Ownable2Step, Pausable {

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

    /// @notice CreateX factory deployed at the same address on 30+ chains
    ICreateX public constant CREATEX =
        ICreateX(0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed);

    /// @notice Maximum number of recipients allowed per sweep to bound gas usage
    /// @dev    Each ERC20 transfer costs ~25,000 gas. 5 recipients ≈ 125,000 gas for transfers.
    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
    /// @dev    Used to validate receivers in sweepExisting and emergencySweep
    mapping(address => bool) public isDeployedReceiver;

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

    /**
     * @notice Emitted when a new WalletReceiver is deployed.
     * @param walletId  Unique identifier of the wallet
     * @param receiver  Address of the deployed WalletReceiver
     * @param chainId   Chain ID where the deployment occurred
     */
    event WalletDeployed(
        bytes32 indexed walletId,
        address indexed receiver,
        uint256 indexed chainId
    );

    /**
     * @notice Emitted when a deploy and sweep are executed atomically.
     * @param walletId        Unique identifier of the wallet
     * @param receiver        Address of the deployed WalletReceiver
     * @param token           Address of the swept ERC20 token
     * @param totalAmount     Total amount swept
     * @param recipientCount  Number of recipients funds were distributed to
     */
    event DeployedAndSwept(
        bytes32 indexed walletId,
        address indexed receiver,
        address indexed token,
        uint256 totalAmount,
        uint256 recipientCount
    );

    /**
     * @notice Emitted when an emergency sweep is executed by the owner.
     * @param receiver     Address of the WalletReceiver holding the funds
     * @param token        Address of the recovered token (address(0) for native)
     * @param destination  Address that received the recovered funds
     */
    event EmergencySweep(
        address indexed receiver,
        address indexed token,
        address indexed destination
    );

    /**
     * @notice Emitted when the relayer address is updated.
     * @param oldRelayer  Previous relayer address
     * @param newRelayer  New relayer address
     */
    event RelayerUpdated(
        address indexed oldRelayer,
        address indexed newRelayer
    );

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

    /// @notice Caller is not the authorized relayer
    error NotRelayer();

    /// @notice A required address parameter is the zero address
    error ZeroAddress();

    /// @notice Token address is the zero address
    error InvalidToken();

    /// @notice Receiver was not deployed by this factory
    error InvalidReceiver();

    /// @notice Recipients array exceeds MAX_RECIPIENTS
    error TooManyRecipients();

    /// @notice Salt construction resulted in an invalid byte pattern
    error InvalidSaltConstruction();

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

    /**
     * @notice Initializes the factory with the authorized relayer address.
     * @param _relayer  Address of the backend EOA that will trigger deployments and sweeps
     */
    constructor(address _relayer) Ownable(msg.sender) {
        if (_relayer == address(0)) revert ZeroAddress();
        relayer = _relayer;
    }

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

    /// @dev Restricts access to the authorized relayer
    modifier onlyRelayer() {
        if (msg.sender != relayer) revert NotRelayer();
        _;
    }

    /// @dev Validates that a receiver was deployed by this factory
    modifier onlyValidReceiver(address receiver) {
        if (!isDeployedReceiver[receiver]) revert InvalidReceiver();
        _;
    }

    /// @dev Validates the recipients array length
    modifier validRecipients(uint256 count) {
        if (count > MAX_RECIPIENTS) revert TooManyRecipients();
        _;
    }

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

    /**
     * @notice Updates the authorized relayer address.
     * @dev    Only callable by the contract owner.
     *         Emits RelayerUpdated for full on-chain traceability.
     * @param _relayer  New relayer address
     */
    function setRelayer(address _relayer) external onlyOwner {
        if (_relayer == address(0)) revert ZeroAddress();
        emit RelayerUpdated(relayer, _relayer);
        relayer = _relayer;
    }

    /**
     * @notice Pauses all relayer-callable functions.
     * @dev    Use immediately if the relayer key is compromised.
     *         Only callable by the contract owner.
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @notice Unpauses all relayer-callable functions.
     * @dev    Only callable by the contract owner.
     */
    function unpause() external onlyOwner {
        _unpause();
    }

    // ─── Salt Helpers ───────────────────────────────────────────────────────── //

    /**
     * @notice Builds the salt in the exact format required by CreateX.
     * @dev    Format: [20 bytes: address(this)][0x00][11 bytes: keccak256(walletId)]
     *         The first 20 bytes enable permissioned protection so only this factory
     *         can deploy to the computed address.
     *         The 0x00 flag disables cross-chain redeploy protection, ensuring the
     *         same receiver address is generated on every chain.
     *         Exposed as public to allow off-chain salt computation.
     *         Ref: https://github.com/pcaversaccio/createx#special-salt-prefix
     * @return salt     Correctly formatted salt for CreateX
     */
    function buildSalt(bytes32 walletId) public view returns (bytes32 salt) {
        salt = bytes32(
            abi.encodePacked(
                address(this),                                                           // 20 bytes — permissioned protection (must equal msg.sender when calling CreateX)
                hex"00",                                                                 //  1 byte  — 0x00 = no cross-chain redeploy protection (same address on ALL chains)
                                                                                         //            0x01 = cross-chain redeploy protection (different address per chain)
                                                                                         //            >0x01 = CreateX reverts with InvalidSalt — never use!
                bytes11(uint88(uint256(keccak256(abi.encodePacked(walletId)))))          // 11 bytes — unique identifier derived from walletId
            )
        );
        // Byte 21 must be exactly 0x00 — any other value causes CreateX to revert
        // This assert guards against future refactors that might accidentally change the salt format
        assert(uint8(salt[20]) == 0x00);
    }

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

    /**
     * @notice Returns the deterministic address for a given walletId without deploying anything.
     * @dev    This call is free (view function). The same address will be returned
     *         on every chain where this factory is deployed at the same address.
     *
     *         IMPORTANT: CreateX applies an internal _guard() that re-hashes the salt
     *         when the first 20 bytes match msg.sender AND byte 21 is 0x00:
     *           guardedSalt = keccak256(abi.encode(msg.sender, salt))
     *         We replicate this here so computeWalletAddress matches the address
     *         that deployCreate3 will actually deploy to.
     *         Ref: https://github.com/pcaversaccio/createx/blob/main/src/CreateX.sol#L691
     *
     * @param walletId  Unique identifier of the wallet
     * @return walletAddress Precomputed address of the WalletReceiver
     */
    function computeWalletAddress(bytes32 walletId)
        external
        view
        returns (address walletAddress)
    {
        bytes32 salt = buildSalt(walletId);
        // We MUST manually apply the _guard logic here because CreateX's
        // computeCreate3Address (pure/view) does NOT apply it internally.
        // We use the 1-parameter version of computeCreate3Address which
        // correctly uses the CreateX factory address as the deployer.
        bytes32 guardedSalt = keccak256(
            abi.encodePacked(
                bytes32(uint256(uint160(address(this)))),
                salt
            )
        );
        return CREATEX.computeCreate3Address(guardedSalt, address(CREATEX));
    }

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

    /**
     * @notice Deploys a WalletReceiver without performing a sweep.
     * @dev    Useful for eager deployment on specific chains before a payment arrives.
     *         Registers the deployed address in isDeployedReceiver for future validation.
     *         Only callable by the relayer when not paused.
     * @param walletId  Unique identifier of the wallet
     * @return receiver Address of the deployed WalletReceiver
     */
    function deployWallet(bytes32 walletId)
        external
        onlyRelayer
        whenNotPaused
        returns (address receiver)
    {
        bytes memory initCode = _buildInitCode(walletId);
        receiver = CREATEX.deployCreate3(buildSalt(walletId), initCode);
        isDeployedReceiver[receiver] = true;
        emit WalletDeployed(walletId, receiver, block.chainid);
    }

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

    /**
     * @notice Deploys a WalletReceiver and sweeps funds in a single atomic transaction.
     * @dev    Implements a lazy deploy pattern: the contract is only deployed when
     *         a real payment is detected. If the token balance is zero at deploy time,
     *         the sweep is skipped without reverting.
     *         Registers the deployed address in isDeployedReceiver for future validation.
     *         Only callable by the relayer when not paused.
     *         Examples:
     *           Single recipient:  [{ wallet: treasury, bps: 10000 }]
     *           98/2 split:        [{ wallet: A, bps: 9800 }, { wallet: B, bps: 200 }]
     * @param walletId    Unique identifier of the wallet
     * @param token       Address of the ERC20 token to sweep (USDT, USDC, etc.)
     * @param recipients  Array of recipients with their basis point shares (must sum to 10000)
     * @return receiver   Address of the deployed WalletReceiver
     */
    function deployAndSweep(
        bytes32 walletId,
        address token,
        WalletReceiver.Recipient[] calldata recipients
    )
        external
        onlyRelayer
        whenNotPaused
        validRecipients(recipients.length)
        returns (address receiver)
    {
        bytes memory initCode = _buildInitCode(walletId);
        receiver = CREATEX.deployCreate3(buildSalt(walletId), initCode);
        isDeployedReceiver[receiver] = true;

        emit WalletDeployed(walletId, receiver, block.chainid);

        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 {
            uint256 balance = IERC20(token).balanceOf(receiver);
            if (balance > 0) {
                WalletReceiver(payable(receiver)).sweep(token, recipients);
                emit DeployedAndSwept(walletId, receiver, token, balance, recipients.length);
            }
        }
    }

    /**
     * @notice Sweeps funds from an already deployed WalletReceiver.
     * @dev    Used for subsequent payments to the same wallet after the initial deploy.
     *         Only accepts receivers deployed by this factory to prevent malicious input.
     *         Only callable by the relayer when not paused.
     * @param receiver    Address of the already deployed WalletReceiver
     * @param token       Address of the ERC20 token to sweep
     * @param recipients  Array of recipients with their basis point shares (must sum to 10000)
     */
    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 ──────────────────────────────────────────────────

    /**
     * @notice Recovers ERC20 funds from a WalletReceiver if the relayer fails.
     * @dev    Only callable by the contract owner.
     *         Only accepts receivers deployed by this factory to prevent malicious input.
     *         Use this if the backend goes down and the relayer cannot execute a normal sweep.
     * @param receiver    Address of the WalletReceiver holding the stuck funds
     * @param token       Address of the ERC20 token to recover
     * @param destination Address that will receive the recovered funds
     */
    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);
    }

    /**
     * @notice Recovers native tokens (ETH, MATIC, BNB, etc.) from a WalletReceiver
     *         if the relayer fails.
     * @dev    Only callable by the contract owner.
     *         Only accepts receivers deployed by this factory to prevent malicious input.
     * @param receiver    Address of the WalletReceiver holding the stuck native funds
     * @param destination Address that will receive the recovered native funds
     */
    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);
    }

    // ─── Internal ─────────────────────────────────────────────────────────────

    /**
     * @dev Builds the creation bytecode for a new WalletReceiver instance.
     * @param walletId  Unique identifier to embed in the receiver
     * @return initCode ABI-encoded creation bytecode with constructor arguments
     */
    function _buildInitCode(bytes32 walletId)
        internal
        view
        returns (bytes memory initCode)
    {
        return abi.encodePacked(
            type(WalletReceiver).creationCode,
            abi.encode(relayer, address(this), walletId)
        );
    }
}

interface ICreateX {
    function deployCreate3(bytes32 salt, bytes memory initCode)
        external payable returns (address);

    function computeCreate3Address(bytes32 salt, address deployer)
        external view returns (address);
}

contract WalletFactory is Ownable2Step, Pausable {

ICreateX public constant CREATEX =
    ICreateX(0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed);

mapping(address => bool) public isDeployedReceiver;

function deployWallet(bytes32 walletId)
    external onlyRelayer whenNotPaused
    returns (address receiver)
{
    bytes memory initCode = _buildInitCode(walletId);
    receiver = CREATEX.deployCreate3(buildSalt(walletId), initCode);
    isDeployedReceiver[receiver] = true;
    emit WalletDeployed(walletId, receiver, block.chainid);
}

receiver = CREATEX.deployCreate3(buildSalt(walletId), initCode);
isDeployedReceiver[receiver] = true;

if (token == address(0)) {
    uint256 balance = receiver.balance;
    if (balance > 0) {
        WalletReceiver(payable(receiver)).sweepNative(recipients);
    }
} else {
    uint256 balance = IERC20(token).balanceOf(receiver);
    if (balance > 0) {
        WalletReceiver(payable(receiver)).sweep(token, recipients);
    }
}

function sweepExisting(
    address receiver, address token,
    WalletReceiver.Recipient[] calldata recipients
) external onlyRelayer whenNotPaused onlyValidReceiver(receiver) validRecipients(recipients.length)

function emergencySweep(address receiver, address token, address destination)
    external onlyOwner onlyValidReceiver(receiver)

function _buildInitCode(bytes32 walletId)
    internal view returns (bytes memory initCode)
{
    return abi.encodePacked(
        type(WalletReceiver).creationCode,
        abi.encode(relayer, address(this), walletId)
    );
}

bytes11(uint88(uint256(keccak256(abi.encodePacked(walletId)))))

function buildSalt(bytes32 walletId) public view returns (bytes32 salt) {
    salt = bytes32(
        abi.encodePacked(
            address(this),
            hex"00",
            bytes11(uint88(uint256(keccak256(abi.encodePacked(walletId)))))
        )
    );
    assert(uint8(salt[20]) == 0x00);
}

// Dentro de CreateX._guard():
guardedSalt = keccak256(abi.encodePacked(
    bytes32(uint256(uint160(msg.sender))),
    salt
));

function computeWalletAddress(bytes32 walletId)
    external view returns (address walletAddress)
{
    bytes32 salt = buildSalt(walletId);

    // Replicamos la lógica de _guard() de CreateX
    bytes32 guardedSalt = keccak256(
        abi.encodePacked(
            bytes32(uint256(uint160(address(this)))),
            salt
        )
    );

    return CREATEX.computeCreate3Address(guardedSalt, address(CREATEX));
}

import { ethers } from 'hardhat'
import * as fs from 'fs'
import * as path from 'path'
import { WalletFactory } from '../../typechain-types'

const CREATEX_ADDRESS = ethers.getAddress('0xba5ed099633d3b313e4d5f7bdc1305d3c28ba5ed')

async function main() {
  const [deployer] = await ethers.getSigners()
  const network = await ethers.provider.getNetwork()

  console.log(`\n🚀 Deploy en Chain ID: ${network.chainId}`)
  console.log(`   Deployer: ${deployer.address}`)
  console.log(`   Balance:  ${ethers.formatEther(await ethers.provider.getBalance(deployer.address))} ETH\n`)

  // Verificar CreateX
  const code = await ethers.provider.getCode(CREATEX_ADDRESS)
  if (code === '0x') throw new Error('❌ CreateX no está deployado en esta red')
  console.log(`✅ CreateX verificado en ${CREATEX_ADDRESS}`)

  const RELAYER_ADDRESS = process.env.RELAYER_ADDRESS
  if (!RELAYER_ADDRESS) throw new Error('❌ Falta RELAYER_ADDRESS en .env')

  console.log(`📋 Relayer: ${RELAYER_ADDRESS}`)

  // Deploy WalletFactory
  const Factory = await ethers.getContractFactory('WalletFactory')
  const factory = await Factory.deploy(RELAYER_ADDRESS) as unknown as WalletFactory
  await factory.waitForDeployment()

  const factoryAddress = await factory.getAddress()
  console.log(`\n✅ WalletFactory deployado en: ${factoryAddress}`)

  // Test precompute
  const testSalt = ethers.id('test-wallet-001')
  const testAddress = await factory.computeWalletAddress(testSalt)
  console.log(`🧪 Test precompute: ${testAddress}`)

  // Guardar deployments.json
  const deploymentsPath = 'deployments.json'
  const deployments: any = fs.existsSync(deploymentsPath)
    ? JSON.parse(fs.readFileSync(deploymentsPath, 'utf8'))
    : {}

  deployments[network.chainId.toString()] = {
    WalletFactory: factoryAddress,
    deployedAt: new Date().toISOString(),
    deployer: deployer.address,
    relayer: RELAYER_ADDRESS,
    chainId: network.chainId.toString(),
  }

  fs.writeFileSync(deploymentsPath, JSON.stringify(deployments, null, 2))
  console.log(`\n📁 Guardado en deployments.json`)
  console.log(`   Añadir al .env del backend: WALLET_FACTORY_ADDRESS=${factoryAddress}\n`)
}

main().catch(err => {
  console.error(err)
  process.exit(1)
})

const code = await ethers.provider.getCode(CREATEX_ADDRESS)
if (code === '0x') throw new Error('❌ CreateX no está deployado en esta red')

# En Sepolia (Ethereum testnet)
npx hardhat run scripts/deploy.ts --network sepolia

# En Amoy (Polygon testnet)
npx hardhat run scripts/deploy.ts --network amoy

import { ethers } from "ethers";
import * as fs from "fs";
import * as dotenv from "dotenv";
dotenv.config();

// ABI mínima necesaria de WalletFactory para computeWalletAddress
const FACTORY_ABI = [
    "function computeWalletAddress(bytes32 walletId) external view returns (address walletAddress)"
];

async function main() {
    // ID de Mongo que el usuario proporcionará
    // Por ahora usamos uno como ejemplo si no se pasa por argumento
    const mongoId = process.argv[2] || "65d4f1a2b3c4d5e6f7a8b9c0";

    console.log(`\n--- Generación de Wallet Limpia ---`);
    console.log(`ID de Mongo: ${mongoId}`);

    // Configurar provider
    const rpcUrl = process.env.RPC_URL_SEPOLIA;
    if (!rpcUrl) throw new Error("Falta RPC_URL_SEPOLIA en .env");
    const provider = new ethers.JsonRpcProvider(rpcUrl);

    const deployments = JSON.parse(fs.readFileSync("deployments.json", "utf8"));
    const factoryAddress = deployments["11155111"].WalletFactory;

    if (!factoryAddress) {
        throw new Error(`No se encontró WalletFactory para Sepolia en deployments.json`);
    }

    const factory = new ethers.Contract(factoryAddress, FACTORY_ABI, provider);

    // El walletId en el contrato es bytes32.
    let walletId = mongoId;
    if (!walletId.startsWith("0x")) {
        walletId = "0x" + walletId.padStart(64, "0");
    }

    console.log(`WalletId (bytes32): ${walletId}`);
    console.log(`Factory: ${factoryAddress}`);

    // Precomputar dirección
    const walletAddress = await factory.computeWalletAddress(walletId);

    // Guardar en archivo para evitar problemas de terminal
    fs.writeFileSync("generated_address.txt", walletAddress);

    console.log(`\n--- RESULTADO DE PRECOMPUTE ---`);
    console.log(`Valor retornado: ${walletAddress}`);
    console.log(`Tipo:            ${typeof walletAddress}`);
    if (typeof walletAddress === 'string') {
        console.log(`Longitud:        ${walletAddress.length} caracteres`);
    }

    console.log(`\n✅ Dirección de Wallet: ${walletAddress}`);
    console.log(`\nInstrucciones:`);
    console.log(`1. Deposita fondos (USDT/USDC o ETH) en esta dirección.`);
    console.log(`2. Avísame cuando el depósito esté confirmado.`);
    console.log(`3. Ejecutaremos el script de retiro.`);
}

main().catch(error => {
    console.error(error);
    process.exit(1);
});

let walletId = mongoId;
if (!walletId.startsWith("0x")) {
    walletId = "0x" + walletId.padStart(64, "0");
}

# Con un ID específico
npx ts-node scripts/generate_wallet.ts 65d4f1a2b3c4d5e6f7a8b9c0

# Con el ID por defecto
npx ts-node scripts/generate_wallet.ts

import { ethers } from "ethers";
import * as fs from "fs";
import * as dotenv from "dotenv";
dotenv.config();

const FACTORY_ABI = [
    "function deployAndSweep(bytes32 walletId, address token, tuple(address wallet, uint256 bps)[] recipients) external returns (address receiver)",
    "function sweepExisting(address receiver, address token, tuple(address wallet, uint256 bps)[] recipients) external",
    "function isDeployedReceiver(address receiver) external view returns (bool)",
    "function computeWalletAddress(bytes32 walletId) external view returns (address)"
];

async function main() {
    const mongoId = process.argv[2] || "69803138ebd1b9b38348c265"; // ID para prueba final unificada
    const tokenAddress = process.argv[3] || "0x0000000000000000000000000000000000000000"; // Default a nativo

    const rpcUrl = process.env.RPC_URL_SEPOLIA;
    const privateKey = process.env.PRIVATE_KEY;
    const treasury = process.env.TREASURY_ADDRESS;

    if (!rpcUrl || !privateKey || !treasury) {
        throw new Error("Faltan variables en .env (RPC_URL_SEPOLIA, PRIVATE_KEY, TREASURY_ADDRESS)");
    }

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const relayer = new ethers.Wallet(privateKey, provider);

    const deployments = JSON.parse(fs.readFileSync("deployments.json", "utf8"));
    const factoryAddress = deployments["11155111"].WalletFactory;

    const factory = new ethers.Contract(factoryAddress, FACTORY_ABI, relayer);

    let walletId = "0x" + mongoId.padStart(64, "0");

    // Calcular dirección esperada
    const walletAddress = await factory.computeWalletAddress(walletId);

    // 1. Verificar balance y despliegue
    const balance = await provider.getBalance(walletAddress);
    const isDeployed = await factory.isDeployedReceiver(walletAddress);

    console.log(`\n--- Retiro de Fondos (Flujo Estándar) ---`);
    console.log(`Wallet:   ${walletAddress}`);
    console.log(`Token:    ${tokenAddress === "0x0000000000000000000000000000000000000000" ? "ETH Nativo" : tokenAddress}`);
    console.log(`Balance:  ${ethers.formatEther(balance)} ETH (Solo si es Nativo)`);
    console.log(`Estado:   ${isDeployed ? "Desplegada" : "No desplegada"}`);

    const recipients = [{ wallet: treasury, bps: 10000 }];

    let tx;
    if (isDeployed) {
        console.log("Ejecutando sweepExisting (vía estándar)...");
        tx = await factory.sweepExisting(walletAddress, tokenAddress, recipients);
    } else {
        console.log("Ejecutando deployAndSweep (vía estándar)...");
        tx = await factory.deployAndSweep(walletId, tokenAddress, recipients);
    }

    console.log(`Transacción enviada: ${tx.hash}`);
    await tx.wait();
    console.log("✅ Retiro completado con éxito mediante el flujo estándar.");
}

main().catch(console.error);

const isDeployed = await factory.isDeployedReceiver(walletAddress);

if (isDeployed) {
    tx = await factory.sweepExisting(walletAddress, tokenAddress, recipients);
} else {
    tx = await factory.deployAndSweep(walletId, tokenAddress, recipients);
}

# Barrer ETH nativo
npx ts-node scripts/withdraw_funds.ts 65d4f1a2b3c4d5e6f7a8b9c0

# Barrer USDC (dirección en Sepolia)
npx ts-node scripts/withdraw_funds.ts 65d4f1a2b3c4d5e6f7a8b9c0 0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238

const recipients = [{ wallet: treasury, bps: 10000 }];

const recipients = [
    { wallet: merchantAddress, bps: 9700 },  // 97% al comerciante
    { wallet: platformFee, bps: 200 },        // 2% comisión plataforma
    { wallet: referralAddress, bps: 100 },     // 1% referido
];

# Verificar manualmente
cast code 0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed --rpc-url $RPC_URL

# Verificar nonce actual
cast nonce $DEPLOYER_ADDRESS --rpc-url $RPC_URL_ETHEREUM
cast nonce $DEPLOYER_ADDRESS --rpc-url $RPC_URL_POLYGON

# Ethereum mainnet
npx hardhat run scripts/deploy.ts --network mainnet

# Polygon
npx hardhat run scripts/deploy.ts --network polygon

# BSC
npx hardhat run scripts/deploy.ts --network bsc

# Arbitrum
npx hardhat run scripts/deploy.ts --network arbitrum

npx hardhat verify --network mainnet $FACTORY_ADDRESS $RELAYER_ADDRESS
npx hardhat verify --network polygon $FACTORY_ADDRESS $RELAYER_ADDRESS

// test-determinism.ts
import { ethers } from "ethers";

const FACTORY_ABI = [
    "function computeWalletAddress(bytes32 walletId) external view returns (address)"
];

const chains = [
    { name: "Ethereum", rpc: process.env.RPC_URL_ETHEREUM, factory: "0x..." },
    { name: "Polygon",  rpc: process.env.RPC_URL_POLYGON,  factory: "0x..." },
    { name: "BSC",      rpc: process.env.RPC_URL_BSC,      factory: "0x..." },
];

async function main() {
    const testWalletId = "0x" + "deadbeef".padStart(64, "0");
    const addresses: string[] = [];

    for (const chain of chains) {
        const provider = new ethers.JsonRpcProvider(chain.rpc);
        const factory = new ethers.Contract(chain.factory, FACTORY_ABI, provider);
        const addr = await factory.computeWalletAddress(testWalletId);
        addresses.push(addr);
        console.log(`${chain.name}: ${addr}`);
    }

    const allEqual = addresses.every(a => a === addresses[0]);
    console.log(`\nDeterminismo: ${allEqual ? "VERIFICADO" : "FALLIDO"}`);
}

main().catch(console.error);