0x9522742d822606be208660c6504e9ee7d9cc47ac

deployer: unknown relevance score: 0 status: partially_identified bytecode: 2093 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 MAX_NAME = 40;
    
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_d;
    mapping(bytes32 => bytes32) storage_map_b;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_g;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event ProfileCleared(address);
    event NameSet(address, string);
    event Event_31d5a3b6();
    
    /// @custom:selector    0x0f53a470
    /// @custom:signature   getProfile(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getProfile(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        require(!bytes1(storage_map_a[var_a]));
        require(((storage_map_a[var_a] >> 0x01) < 0x20) == (bytes1(storage_map_a[var_a])));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        address var_d = storage_map_a[var_a] >> 0x01;
        require(!bytes1(storage_map_a[var_a]));
        require(0x01 == (bytes1(storage_map_a[var_a])));
        var_a = keccak256(var_a);
        require(0 < (storage_map_a[var_a] >> 0x01));
        require((0xa0 < 0x80) | (0xa0 > 0xffffffffffffffff));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(0 < var_d);
        return abi.encodePacked(0x80, address(storage_map_b[var_a]), storage_map_c[var_a], !(!bytes1(storage_map_d[var_a])), var_d);
        require((0 < 0x80) | (0 > 0xffffffffffffffff));
    }
    
    /// @custom:selector    0x6d97de1e
    /// @custom:signature   setPfp(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function setPfp(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        address var_a = msg.sender;
        storage_map_b[var_a] = (uint96(storage_map_b[var_a])) | (address(arg0));
        storage_map_c[var_a] = arg1;
        storage_map_d[var_a] = (uint248(storage_map_d[var_a])) | 0x01;
        emit Event_31d5a3b6(msg.sender, address(arg0), arg1);
        return ;
    }
    
    /// @custom:selector    0xc47f0027
    /// @custom:signature   Unresolved_c47f0027(uint256 arg0, uint0 arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint0", "bytes0", "int0"]
    function Unresolved_c47f0027(uint256 arg0, uint0 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(!(!(arg0) > 0x28), "name too long");
        require(arg0 > 0xffffffffffffffff);
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!bytes1(storage_map_e[var_e]));
        require(((storage_map_e[var_e] >> 0x01) < 0x20) == (bytes1(storage_map_e[var_e])));
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require((storage_map_e[var_e] >> 0x01) > 0x1f);
        var_e = keccak256(var_e);
        require(arg0 < 0x20);
        require(keccak256(var_e) + ((arg0 + 0x1f) >> 0x05) < (((0x1f + (storage_map_e[var_e] >> 0x01)) >> 0x05) + keccak256(var_e)));
        require(0x01 == (arg0 > 0x1f));
        require(0 < (uint248(arg0)));
        var_e = var_e;
        require(uint248(arg0) < (arg0));
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (bytes1(arg0 << 0x03)))) & ((arg0 + 0x20) + 0);
        storage_map_e[var_e] = (arg0 << 0x01) + 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        return ;
        storage_map_e[var_e] = (arg0 << 0x01) + 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        return ;
        var_e = var_e;
        require(arg0);
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & ((arg0 + 0x20) + 0)) | (arg0 << 0x01);
        emit NameSet(msg.sender, 0x20, (arg0));
        return ;
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0)) | (arg0 << 0x01);
        emit NameSet(msg.sender, 0x20, (arg0));
        return ;
    }
    
    /// @custom:selector    0x81336339
    /// @custom:signature   Unresolved_81336339(uint256 arg0, address arg1, uint256 arg2) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_81336339(uint256 arg0, address arg1, uint256 arg2) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x60);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - (address(arg1)));
        require(!(!(arg0) > 0x28), "name too long");
        require(arg0 > 0xffffffffffffffff);
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!bytes1(storage_map_e[var_e]));
        require(((storage_map_e[var_e] >> 0x01) < 0x20) == (bytes1(storage_map_e[var_e])));
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require((storage_map_e[var_e] >> 0x01) > 0x1f);
        var_e = keccak256(var_e);
        require(arg0 < 0x20);
        require(keccak256(var_e) + ((arg0 + 0x1f) >> 0x05) < (((0x1f + (storage_map_e[var_e] >> 0x01)) >> 0x05) + keccak256(var_e)));
        require(0x01 == (arg0 > 0x1f));
        require(0 < (uint248(arg0)));
        var_e = var_e;
        require(uint248(arg0) < (arg0));
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (bytes1(arg0 << 0x03)))) & ((arg0 + 0x20) + 0);
        storage_map_e[var_e] = (arg0 << 0x01) + 0x01;
        storage_map_f[var_e] = (uint96(storage_map_f[var_e])) | (address(arg1));
        storage_map_g[var_e] = arg2;
        storage_map_h[var_e] = (uint248(storage_map_h[var_e])) | 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        emit Event_31d5a3b6(msg.sender, address(arg1), arg2);
        return ;
        storage_map_e[var_e] = (arg0 << 0x01) + 0x01;
        storage_map_f[var_e] = (uint96(storage_map_f[var_e])) | (address(arg1));
        storage_map_g[var_e] = arg2;
        storage_map_h[var_e] = (uint248(storage_map_h[var_e])) | 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        emit Event_31d5a3b6(msg.sender, address(arg1), arg2);
        return ;
        var_e = var_e;
        require(arg0);
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & ((arg0 + 0x20) + 0)) | (arg0 << 0x01);
        storage_map_f[var_e] = (uint96(storage_map_f[var_e])) | (address(arg1));
        storage_map_g[var_e] = arg2;
        storage_map_h[var_e] = (uint248(storage_map_h[var_e])) | 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        emit Event_31d5a3b6(msg.sender, address(arg1), arg2);
        return ;
        storage_map_e[var_e] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0)) | (arg0 << 0x01);
        storage_map_f[var_e] = (uint96(storage_map_f[var_e])) | (address(arg1));
        storage_map_g[var_e] = arg2;
        storage_map_h[var_e] = (uint248(storage_map_h[var_e])) | 0x01;
        emit NameSet(msg.sender, 0x20, (arg0));
        emit Event_31d5a3b6(msg.sender, address(arg1), arg2);
        return ;
    }
    
    /// @custom:selector    0x8ccec7b6
    /// @custom:signature   clearProfile() public payable returns (uint256)
    function clearProfile() public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        address var_a = msg.sender;
        if (!storage_map_a[var_a]) {
            if (((storage_map_a[var_a] >> 0x01) < 0x20) == (storage_map_a[var_a])) {
                var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                if (storage_map_a[var_a] >> 0x01) {
                    if (0x01 == ((storage_map_a[var_a] >> 0x01) > 0x1f)) {
                        var_a = keccak256(var_a);
                        if ((keccak256(var_a) + 0x01) < (keccak256(var_a) + (((storage_map_a[var_a] >> 0x01) + 0x1f) >> 0x05))) {
                            storage_map_a[var_a] = 0;
                            storage_map_a[var_a] = 0;
                            storage_map_b[var_a] = 0;
                            storage_map_c[var_a] = 0;
                            storage_map_d[var_a] = 0;
                            emit ProfileCleared(msg.sender);
                            return ;
                            storage_map_a[var_a] = 0;
                            storage_map_b[var_a] = 0;
                            storage_map_c[var_a] = 0;
                            storage_map_d[var_a] = 0;
                            emit ProfileCleared(msg.sender);
                            return ;
                            storage_map_b[var_a] = 0;
                            storage_map_c[var_a] = 0;
                            storage_map_d[var_a] = 0;
                            emit ProfileCleared(msg.sender);
                            return ;
                        }
                    }
                }
            }
        }
    }
}

ABI

[
  {
    "type": "function",
    "name": "MAX_NAME",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_81336339",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_c47f0027",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint0"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "clearProfile",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getProfile",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setPfp",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Event_31d5a3b6122116aa38fd2e0a9153811df238e295ba5d5742288a52288d9f2c22",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "NameSet",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "string",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "ProfileCleared",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (4)

0x43000818unknown
0x756bf254unknown
0x6d97de1eunknown
0x8ccec7b6unknown
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)