// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

interface IUniswapV3Pool {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);
}

interface Erc20Token {
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool success);

    function balanceOf(address account) external view returns (uint256 amount);
}

interface IUniswapV3SwapCallback {
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

contract TraderHelper is IUniswapV3SwapCallback {
    address private constant poolAdrs =
        0xC6962004f452bE9203591991D15f6b388e09E8D0;
    address private constant token0Adrs =
        0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
    address private constant token1Adrs =
        0xaf88d065e77c8cC2239327C5EDb3A432268e5831;

    address private constant walletAdrs =
        0xA4698b78b70addF1De25D38780272a4138109066;

    address private constant trader1 =
        0xD24C30244Bcb1B92F1ecA92bC6f84515227A6285;
    address private constant trader2 =
        0x2A536EC120Af6385f5116150AFB71aB3c3824D23;
    address private constant trader3 =
        0x2317655CDF4Ca824904DFAf035cf9b43e1d528D0;
    address private constant trader4 =
        0xdd0e37f10E24AE475bad5F39fa0ee92e93F779d4;
    address private constant trader5 =
        0xBbc0ab39DbD1F54495Cf1017e4c7676e9DF7f02a;
    address private constant trader6 =
        0xbd100a118c421Ac060e8cb97155CfC9Fd3eadacf;
    address private constant trader7 =
        0x28d51b5a63231dfC0fEDdc04CB727663DF073FB1;
    address private constant trader8 =
        0x3Aea69F5E3CCA9A40062Fd10A1f086185f84e295;
    address private constant trader9 =
        0xE481030deDFEd952FEa8409E385c89a9612C9497;
    address private constant trader10 =
        0x9E5A46aCeBB11D32ef3EB2A9A1Ba8a8f957669dE;
    address private constant trader11 =
        0x7EB22032b13a4ee6d9AE511bB98211EF06Fb81b7;
    address private constant trader12 =
        0xcD43fCE52D1275F750176F81E04c53E5eaA99bc1;
    address private constant trader13 =
        0x1ddF96F4271f03C88D0FbA053ee458f33f67618F;
    address private constant trader14 =
        0x388AfFa1fFD531185dB9967351683E4e2cAbFACc;
    address private constant trader15 =
        0xeE84e62663b6622A8131F1Eb0787eB5ff6A1ffF7;
    address private constant trader16 =
        0x4138D3eC5A2B0014D5CA5BC59379455D707b55D2;
    address private constant trader17 =
        0x44b09b85c1e6fb54Eb70F451C0ea6661a8755718;
    address private constant trader18 =
        0x9739EC35D5C80c8E99Fd3E0DF3d89f3D54d008B6;
    address private constant trader19 =
        0x9423854DDAa7dC458C1b0516a509a3149A4ec344;
    address private constant trader20 =
        0x4aa1ceec641776C0197ee714fd4cc784b0f8713d;

    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata _data
    ) external {
        require(
            ((msg.sender == poolAdrs) &&
                ((tx.origin == trader1) ||
                    (tx.origin == trader2) ||
                    (tx.origin == trader3) ||
                    (tx.origin == trader4) ||
                    (tx.origin == trader5) ||
                    (tx.origin == trader6) ||
                    (tx.origin == trader7) ||
                    (tx.origin == trader8) ||
                    (tx.origin == trader9) ||
                    (tx.origin == trader10) ||
                    (tx.origin == trader11) ||
                    (tx.origin == trader12) ||
                    (tx.origin == trader13) ||
                    (tx.origin == trader14) ||
                    (tx.origin == trader15) ||
                    (tx.origin == trader16) ||
                    (tx.origin == trader17) ||
                    (tx.origin == trader18) ||
                    (tx.origin == trader19) ||
                    (tx.origin == trader20) ||
                    (tx.origin == walletAdrs))),
            "???"
        );

        address transferTokenAddrss = amount0Delta > 0
            ? token0Adrs
            : token1Adrs;
        uint256 transferAmount = amount0Delta > 0
            ? uint256(amount0Delta)
            : uint256(amount1Delta);

        bool success = Erc20Token(transferTokenAddrss).transferFrom(
            walletAdrs,
            poolAdrs,
            transferAmount
        );
    }

    function mySwap() internal {
        require(msg.data.length == 6, "?");
        require(
            ((msg.sender == trader1) ||
                (msg.sender == trader2) ||
                (msg.sender == trader3) ||
                (msg.sender == trader4) ||
                (msg.sender == trader5) ||
                (msg.sender == trader6) ||
                (msg.sender == trader7) ||
                (msg.sender == trader8) ||
                (msg.sender == trader9) ||
                (msg.sender == trader10) ||
                (msg.sender == trader11) ||
                (msg.sender == trader12) ||
                (msg.sender == trader13) ||
                (msg.sender == trader14) ||
                (msg.sender == trader15) ||
                (msg.sender == trader16) ||
                (msg.sender == trader17) ||
                (msg.sender == trader18) ||
                (msg.sender == trader19) ||
                (msg.sender == trader20) ||
                (msg.sender == walletAdrs)),
            "??"
        );

        bool zeroForOne = uint8(bytes1(msg.data[0:1]) >> 4) == 9 ? true : false;

        bytes32 qty_hex = bytes32(
            bytes.concat(
                bytes29(0),
                (bytes1(msg.data[0:1]) << 4) >> 4,
                bytes1(msg.data[2:3]),
                bytes1(msg.data[1:2])
            )
        );
        int256 input_amount = zeroForOne
            ? (int256(uint256(qty_hex)) * (10 ** 14))
            : (int256(uint256(qty_hex)) * (10 ** 5));

        bytes20 px_hex = bytes20(
            bytes.concat(
                bytes17(0),
                bytes1(msg.data[5:6]),
                bytes2(msg.data[3:5])
            )
        );
        uint160 px_limit = (uint160(px_hex) * 79228162514264337593543950336) /
            (10 ** 10);

        uint256 balanceBefore = Erc20Token(zeroForOne ? token1Adrs : token0Adrs)
            .balanceOf(walletAdrs);
        (int256 amount0, int256 amount1) = IUniswapV3Pool(poolAdrs).swap(
            walletAdrs,
            zeroForOne,
            input_amount,
            px_limit,
            bytes("0")
        );
        uint256 balanceAfter = Erc20Token(zeroForOne ? token1Adrs : token0Adrs)
            .balanceOf(walletAdrs);

        require(
            balanceBefore + uint256(-(zeroForOne ? amount1 : amount0)) <=
                balanceAfter,
            "11A"
        );
    }

    fallback() external {
        mySwap();
    }
}

{
  "compilationTarget": {
    "src/TraderContract_ETHUSDC_3.sol": "TraderHelper"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200000
  },
  "remappings": [
    ":forge-std/=lib/forge-std/src/"
  ]
}