0x8c758ca4ea6adf7caaab183b450d1f5181f99664

deployer: unknown relevance score: 10 status: identified bytecode: 1374 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 {
    mapping(bytes32 => bytes32) storage_map_b;
    bytes32 store_a;
    
    
    /// @custom:selector    0xaa841a89
    /// @custom:signature   callOneTime(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function callOneTime(address arg0) public payable {
        uint256 var_a = 0x40 + var_a;
        require(address(0x198a71e2e0f86829da6927fedc930c530175c9d9).code.length);
        (bool success, bytes memory ret0) = address(0x198a71e2e0f86829da6927fedc930c530175c9d9).getProxy(); // staticcall
        require(!ret0.length < 0x20);
        uint256 var_f = 0;
        var_a = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_a)))));
        uint256 var_k = (0x20 + (0x20 + (0x04 + var_a))) - (0x04 + var_a);
        require(!bytes1(var_a.length));
        require(!bytes1(var_a.length));
        require(address(msg.sender).code.length);
        (bool success, bytes memory ret0) = address(msg.sender).{ value: var_f ether }Unresolved_9e813f1f(var_k); // call
        var_a = var_a + (uint248(ret0.length + 0x1f));
        require(!ret0.length < 0x20);
        require(!var_a.length > 0x0100000000);
        require(!((var_a.length + var_a) + 0x20) > (var_a + ret0.length));
        require(!(var_q > 0x0100000000) | (((var_a.length + var_a) + 0x20) + (var_q * 0x01) > (var_a + ret0.length)));
        require(!0 < (var_q));
        require(!bytes1(var_q));
        require(address(msg.sender).code.length);
    }
    
    /// @custom:selector    0x3fdd4df2
    /// @custom:signature   getMetadataLink() public view returns (bytes memory)
    function getMetadataLink() public view returns (bytes memory) {
        bytes1 var_a = var_a + (0x20 + (((0x1f + (((0x0100 * (!bytes1(store_a))) - 0x01) & (store_a) / 0x02)) / 0x20) * 0x20));
        if (!(((0x0100 * (!store_a)) - 0x01) & (store_a)) / 0x02) {
            if (0x1f < (((0x0100 * (!store_a)) - 0x01) & (store_a) / 0x02)) {
                uint256 var_c = 0;
                if ((0x20 + var_a) + (((0x0100 * (!store_a)) - 0x01) & (store_a) / 0x02) > (0x20 + (0x20 + var_a))) {
                    if (!var_a.length) {
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length);
                    }
                }
            }
        }
    }
}

ABI

[
  {
    "type": "function",
    "name": "callOneTime",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getMetadataLink",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  }
]

UNKNOWN SELECTORS (0)

(none -- all recognized)
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)