0x2260fac5e5542a773aa44fbcfedf7c193bc2c599

deployer: unknown relevance score: 0 status: partially_identified bytecode: 4582 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 {
    bytes32 store_d;
    bool public decimals;
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_b;
    address public pendingOwner;
    bytes32 store_g;
    mapping(bytes32 => bytes32) storage_map_e;
    
    event Event_8c5be1e5();
    event Transfer(address, address, uint256);
    event Pause();
    event Unpause();
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public returns (bool) {
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        var_a = address(arg0);
        storage_map_b[var_a] = arg1;
        emit Event_8c5be1e5(msg.sender, address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x66188463
    /// @custom:signature   decreaseApproval(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseApproval(address arg0, uint256 arg1) public returns (bool) {
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        var_a = address(arg0);
        if (arg1 < storage_map_b[var_a]) {
            if (!arg1 > storage_map_b[var_a]) {
                var_a = address(arg0);
                storage_map_b[var_a] = storage_map_b[var_a] - arg1;
                var_a = address(arg0);
                emit Event_8c5be1e5(msg.sender, address(arg0), storage_map_b[var_a]);
                return 0x01;
                var_a = address(arg0);
                storage_map_b[var_a] = 0;
                var_a = address(arg0);
                emit Event_8c5be1e5(msg.sender, address(arg0), storage_map_b[var_a]);
                return 0x01;
            }
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_d & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!bytes1(store_d)))) / 0x02) + 0x1f) / 0x20)));
        if (!(store_d & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_d)))) / 0x02) {
            if (0x1f < (store_d & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_d))) / 0x02)) {
                var_c = 0x04;
                if ((var_a + 0x20) + (store_d & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_d))) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!var_a.length) {
                        return abi.encodePacked(0x20, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public returns (bool) {
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        address var_a = msg.sender;
        require(!arg1 > storage_map_b[var_a]);
        require(address(arg0));
        var_a = msg.sender;
        require(!arg1 > storage_map_b[var_a]);
        var_a = msg.sender;
        storage_map_b[var_a] = storage_map_b[var_a] - arg1;
        var_a = address(arg0);
        require(!(arg1 + storage_map_b[var_a]) < storage_map_b[var_a]);
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 + storage_map_b[var_a];
        emit Transfer(msg.sender, address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public returns (bool) {
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        address var_a = address(arg0);
        require(!arg2 > storage_map_b[var_a]);
        var_a = msg.sender;
        require(!arg2 > storage_map_b[var_a]);
        require(address(arg1));
        var_a = address(arg0);
        require(!arg2 > storage_map_b[var_a]);
        var_a = address(arg0);
        storage_map_b[var_a] = storage_map_b[var_a] - arg2;
        var_a = address(arg1);
        require(!(arg2 + storage_map_b[var_a]) < storage_map_b[var_a]);
        var_a = address(arg1);
        storage_map_b[var_a] = arg2 + storage_map_b[var_a];
        var_a = msg.sender;
        require(!arg2 > storage_map_b[var_a]);
        var_a = msg.sender;
        storage_map_b[var_a] = storage_map_b[var_a] - arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        return 0x01;
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x3f4ba83a
    /// @custom:signature   unpause() public
    function unpause() public {
        require(msg.sender == (address(decimals / 0x0100)));
        require(bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        decimals = uint248(decimals);
        emit Unpause();
    }
    
    /// @custom:selector    0x4e71e0c8
    /// @custom:signature   claimOwnership() public
    function claimOwnership() public {
        require(msg.sender == (address(pendingOwner)));
        emit OwnershipTransferred(address(decimals / 0x0100), address(pendingOwner));
        decimals = (address(pendingOwner) * 0x0100) | (uint96(decimals));
        pendingOwner = uint96(pendingOwner);
    }
    
    /// @custom:selector    0x40c10f19
    /// @custom:signature   mint(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(address arg0, uint256 arg1) public view {
        require(msg.sender == (address(decimals / 0x0100)));
        require(!bytes1(decimals / 0x01000000000000000000000000000000000000000000));
        if (!(arg1 + unresolved_18160ddd) < unresolved_18160ddd) {
        }
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public {
        require(msg.sender == (address(decimals / 0x0100)));
        pendingOwner = (address(arg0)) | (uint96(pendingOwner));
    }
    
    /// @custom:selector    0x17ffc320
    /// @custom:signature   reclaimToken(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function reclaimToken(address arg0) public {
        require(msg.sender == (address(decimals / 0x0100)));
        address var_b = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_70a08231(var_b); // call
        require(!ret0.length < 0x20);
        var_b = address(decimals / 0x0100);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_a9059cbb(var_b); // call
        require(!ret0.length < 0x20);
        require(var_d.length);
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   Unresolved_42966c68(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_42966c68(uint256 arg0) public view {
        require(msg.sender == (address(decimals / 0x0100)));
        address var_a = address(msg.sender);
        require(!arg0 > storage_map_b[var_a]);
        var_a = address(msg.sender);
        if (!arg0 > storage_map_b[var_a]) {
        }
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256) {
        var_a = address(arg1);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x7d64bcb4
    /// @custom:signature   finishMinting() public view returns (bool)
    function finishMinting() public view returns (bool) {
        require(msg.sender == (address(decimals / 0x0100)));
        return 0;
    }
    
    /// @custom:selector    0x8456cb59
    /// @custom:signature   pause() public
    function pause() public {
        require(msg.sender == (address(decimals / 0x0100)));
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        decimals = 0x0100000000000000000000000000000000000000000000 | (uint248(decimals));
        emit Pause();
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_g & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!bytes1(store_g)))) / 0x02) + 0x1f) / 0x20)));
        if (!(store_g & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_g)))) / 0x02) {
            if (0x1f < (store_g & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_g))) / 0x02)) {
                var_c = 0x03;
                if ((var_a + 0x20) + (store_g & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_g))) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!var_a.length) {
                        return abi.encodePacked(0x20, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xd73dd623
    /// @custom:signature   increaseApproval(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseApproval(address arg0, uint256 arg1) public returns (bool) {
        require(!bytes1(decimals / 0x0100000000000000000000000000000000000000000000));
        var_a = address(arg0);
        require(!(arg1 + storage_map_b[var_a]) < storage_map_b[var_a]);
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 + storage_map_b[var_a];
        emit Event_8c5be1e5(msg.sender, address(arg0), arg1 + storage_map_b[var_a]);
        return 0x01;
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public view
    function renounceOwnership() public view {
        require(msg.sender == (address(decimals / 0x0100)));
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_42966c68",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_dd62ed3e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "claimOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decreaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "finishMinting",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "increaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mintingFinished",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "paused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pendingOwner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "reclaimToken",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "unpause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferred",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Pause",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Unpause",
    "inputs": [],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (1)

0xc4a11628unknown
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)