0x03352d267951e96c6f7235037c5dfd2ab1466232

deployer: unknown relevance score: 10 status: identified bytecode: 2091 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 {
    address store_b;
    address store_a;
    
    event AdminChanged(address, address);
    event Upgraded(address);
    
    /// @custom:selector    0x5c60da1b
    /// @custom:signature   implementation() public returns (uint256)
    function implementation() public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_a)));
        require(!(address(msg.sender)) == (address(store_a)));
        (bool success, bytes memory ret0) = address(store_b).Unresolved_(var_b); // delegatecall
        return ;
        return address(store_b);
    }
    
    /// @custom:selector    0xf851a440
    /// @custom:signature   admin() public returns (uint256)
    function admin() public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_a)));
        require(!(address(msg.sender)) == (address(store_a)));
        (bool success, bytes memory ret0) = address(store_b).Unresolved_(var_b); // delegatecall
        return ;
        return address(store_a);
    }
    
    /// @custom:selector    0x4f1ef286
    /// @custom:signature   Unresolved_4f1ef286(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_4f1ef286(address arg0, uint256 arg1) public payable returns (uint256) {
        require(!arg1 > 0x0100000000);
        require(!(address(msg.sender)) == (address(store_a)));
        require(!(address(msg.sender)) == (address(store_a)));
        (bool success, bytes memory ret0) = address(store_b).Unresolved_(var_b); // delegatecall
        return ;
        require(!(!address(arg0).code.length), "UpgradeableProxy: new implementation is not a contract");
        store_b = address(arg0);
        emit Upgraded(address(arg0));
        var_e = 0x60 + var_e;
        var_h = this.code[1841:1880];
        require(!(!address(arg0).code.length), "Address: delegate call to non-contract");
        require(var_e.length < 0x20);
        require((var_e.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_(var_p); // delegatecall
        require(ret0.length == 0);
        require(!var_q);
        require(!(bytes1(var_e.length)), "");
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
    }
    
    /// @custom:selector    0x3659cfe6
    /// @custom:signature   upgradeTo(address arg0) public returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function upgradeTo(address arg0) public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_a)));
        require(!(address(msg.sender)) == (address(store_a)));
        (bool success, bytes memory ret0) = address(store_b).Unresolved_(var_b); // delegatecall
        return ;
        require(!(!address(arg0).code.length), "UpgradeableProxy: new implementation is not a contract");
        store_b = address(arg0);
        emit Upgraded(address(arg0));
    }
    
    /// @custom:selector    0x8f283970
    /// @custom:signature   changeAdmin(address arg0) public returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function changeAdmin(address arg0) public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_a)));
        require(!(address(msg.sender)) == (address(store_a)));
        (bool success, bytes memory ret0) = address(store_b).Unresolved_(var_b); // delegatecall
        return ;
        require(address(arg0), "TransparentUpgradeableProxy: new admin is the zero address");
        emit AdminChanged(address(store_a), address(arg0));
        store_a = address(arg0);
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_4f1ef286",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "admin",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "changeAdmin",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "implementation",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "upgradeTo",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "AdminChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Upgraded",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

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)