0x22c4180d0d4fe3967abd56038a3e2a925f3c6da2

deployer: unknown relevance score: 0 status: partially_identified bytecode: 4460 bytes

DECOMPILED SOLIDITY (Heimdall) 

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant unresolved_40df7b57 = 10000;
    uint256 public constant unresolved_cf72af38 = 9971;
    
    address store_b;
    bytes32 store_a;
    mapping(bytes32 => bytes32) storage_map_d;
    mapping(bytes32 => bytes32) storage_map_c;
    
    
    /// @custom:selector    0xb60c164c
    /// @custom:signature   Unresolved_b60c164c(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b60c164c(uint256 arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(!(msg.sender == (address(store_a))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require((0 + (arg0 + 0x20)) - (address(0 + (arg0 + 0x20))));
        address var_b = address(this);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_70a08231(var_b); // staticcall
        var_b = address(store_b);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_a9059cbb(var_b); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        uint256 var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        var_c = address(store_b);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_a9059cbb(var_c); // call
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x9d851408
    /// @custom:signature   Unresolved_9d851408(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_9d851408(uint256 arg0, uint256 arg1) public view {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - arg1);
        require(!(msg.sender == (address(store_a))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require((0 + (arg0 + 0x20)) - (address(0 + (arg0 + 0x20))));
    }
    
    /// @custom:selector    0x718da7ee
    /// @custom:signature   setReceiver(address arg0) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setReceiver(address arg0) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        require(!(msg.sender == (address(store_a))), "NA");
        store_b = (uint96(store_b)) | (address(arg0));
        return ;
    }
    
    /// @custom:selector    0x1e1bff3f
    /// @custom:signature   Unresolved_1e1bff3f(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_1e1bff3f(address arg0, uint256 arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - arg1);
        require(!(msg.sender == (address(store_a))), "NA");
        address var_e = address(arg0);
        storage_map_c[var_e] = (bytes1(arg1)) | (uint248(storage_map_c[var_e]));
    }
    
    /// @custom:selector    0x48c7e528
    /// @custom:signature   executor(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function executor(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return !(!bytes1(storage_map_d[var_a]));
    }
    
    /// @custom:selector    0xd76f529c
    /// @custom:signature   drain(address[] arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function drain(address[] arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - (address(arg1)));
        require(!(msg.sender == (address(store_a))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require((0 + (arg0 + 0x20)) - (address(0 + (arg0 + 0x20))));
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).token0(); // staticcall
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).token1(); // staticcall
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).getReserves(); // staticcall
        require(0 == (0 == (address(arg1))));
        address var_b = address(this);
        (bool success, bytes memory ret0) = address(0).Unresolved_70a08231(var_b); // staticcall
        require(!0);
        var_b = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_b); // call
        require(!address(0 + (arg0 + 0x20)).code.length);
        var_b = 0;
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_022c0d9f(var_b); // call
        require(((var_g + 0) > 0xffffffffffffffff) | ((var_g + 0) < var_g));
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        uint256 var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(!0 + (0x26f3 * var_g.length));
        var_c = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_c); // call
        require(!address(0 + (arg0 + 0x20)).code.length);
        var_c = 0;
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_022c0d9f(var_c); // call
        if (0x20 > ret0.length) {
        }
        var_b = address(this);
        (bool success, bytes memory ret0) = address(0).balanceOf(var_b); // staticcall
        require(!0);
        var_b = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).many_msg_babbage(var_b); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x60 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x8da3aba3
    /// @custom:signature   skimEth() public payable
    function skimEth() public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(!(msg.sender == (address(store_a))), "NA");
        (bool success, bytes memory ret0) = address(store_b).transfer(address(this).balance);
        require(!ret0.length, "ETH transfer failed");
        if (ret0.length > 0xffffffffffffffff) {
            if (((var_g + (uint248(((ret0.length + 0x1f) + 0x20) + 0x1f))) > 0xffffffffffffffff) | ((var_g + (uint248(((ret0.length + 0x1f) + 0x20) + 0x1f))) < var_g)) {
            }
        }
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_1e1bff3f",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_40df7b57",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_9d851408",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_b60c164c",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_cf72af38",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "drain",
    "inputs": [
      {
        "name": "arg0",
        "type": "address[]"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "executor",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setReceiver",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "skimEth",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  }
]

UNKNOWN SELECTORS (7)

0xd76f529cunknown
0x40df7b57unknown
0xe70ccf6dunknown
0x8da3aba3unknown
0xcf72af38unknown
0x48c7e528unknown
0x9d851408unknown
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)