0x317625234562b1526ea2fac4030ea499c5291de4

deployer: unknown relevance score: 0 status: partially_identified bytecode: 2491 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    0xcf7a1d77
    /// @custom:signature   Unresolved_cf7a1d77(address arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_cf7a1d77(address arg0, address arg1, uint256 arg2) public payable {
        require(!arg2 > 0x0100000000);
        uint256 var_a = var_a + (0x20 + (((0x1f + (arg2)) / 0x20) * 0x20));
        var_c = msg.data[36:36];
        require(address(store_a) == 0);
        require(address(store_a) == 0);
        require((keccak256(var_e) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, "Cannot set a proxy implementation to a non-contract address");
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash)), "Cannot set a proxy implementation to a non-contract address");
        store_a = address(arg0);
        require(!var_a.length);
        require(var_a.length < 0x20);
        require((var_a.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_(var_l); // delegatecall
        require(ret0.length == 0);
        require((keccak256(var_e) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103, "Cannot set a proxy implementation to a non-contract address");
        store_b = address(arg1);
        require(!(!address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
    }
    
    /// @custom:selector    0xd1f57894
    /// @custom:signature   Unresolved_d1f57894(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_d1f57894(address arg0, uint256 arg1) public payable {
        require(!arg1 > 0x0100000000);
        uint256 var_a = var_a + (0x20 + (((0x1f + (arg1)) / 0x20) * 0x20));
        var_c = msg.data[36:36];
        require(address(store_a) == 0);
        require((keccak256(var_e) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, "Cannot set a proxy implementation to a non-contract address");
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash)), "Cannot set a proxy implementation to a non-contract address");
        store_a = address(arg0);
        require(!var_a.length);
        require(var_a.length < 0x20);
        require((var_a.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_(var_l); // delegatecall
        require(ret0.length == 0);
        require(!(!address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
    }
    
    /// @custom:selector    0xf851a440
    /// @custom:signature   admin() public returns (uint256)
    function admin() public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_b)));
        require(!(address(msg.sender)) == (address(store_b)));
        (bool success, bytes memory ret0) = address(store_a).Unresolved_(var_b); // delegatecall
        return ;
        return address(store_b);
    }
    
    /// @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_b)));
        require(!(address(msg.sender)) == (address(store_b)));
        (bool success, bytes memory ret0) = address(store_a).Unresolved_(var_b); // delegatecall
        return ;
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash)), "Cannot set a proxy implementation to a non-contract address");
        store_a = address(arg0);
        emit Upgraded(address(arg0));
        require(!(!address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
        store_a = address(arg0);
        emit Upgraded(address(arg0));
    }
    
    /// @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_b)));
        require(!(address(msg.sender)) == (address(store_b)));
        (bool success, bytes memory ret0) = address(store_a).Unresolved_(var_b); // delegatecall
        return ;
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash)), "Cannot set a proxy implementation to a non-contract address");
        store_a = address(arg0);
        emit Upgraded(address(arg0));
        (bool success, bytes memory ret0) = address(arg0).Unresolved_(var_i); // delegatecall
        require(ret0.length == 0);
        require(!(!address(arg0).codehash), "Cannot set a proxy implementation to a non-contract address");
    }
    
    /// @custom:selector    0x5c60da1b
    /// @custom:signature   implementation() public returns (uint256)
    function implementation() public returns (uint256) {
        require(!(address(msg.sender)) == (address(store_b)));
        require(!(address(msg.sender)) == (address(store_b)));
        (bool success, bytes memory ret0) = address(store_a).Unresolved_(var_b); // delegatecall
        return ;
        return address(store_a);
    }
    
    /// @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_b)));
        require(!(address(msg.sender)) == (address(store_b)));
        (bool success, bytes memory ret0) = address(store_a).Unresolved_(var_b); // delegatecall
        return ;
        require(address(arg0), "Cannot change the admin of a proxy to the zero address");
        emit AdminChanged(address(store_b), address(arg0));
        store_b = 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": "Unresolved_cf7a1d77",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_d1f57894",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "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 (1)

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