0x8fd46b27530eac8e6d0cfdf58bf3a380da63fea3

deployer: unknown relevance score: 0 status: partially_identified bytecode: 6013 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 {
    bytes public constant VERSION = 0xBytes([65, 110, 97, 103, 108, 121, 112, 104, 77, 105, 103, 114, 97, 116, 111, 114]);
    uint256 public constant OG = 756473191844672570399550113045089191317309896793;
    bytes public constant AUTHOR = 0xBytes([75, 49, 99, 107, 98, 48, 88, 68, 101, 118]);
    uint256 public constant DEAD = 57005;
    uint256 public constant MIN_DEADLINE_NOTICE = 2592000;
    uint256 public constant V2 = 791186199932729139797663288108164766030058484355;
    bytes public constant WEBSITE = 0xBytes([104, 116, 116, 112, 115, 58, 47, 47, 104, 97, 105, 114, 121, 108, 97, 98, 115, 46, 105, 111]);
    
    address public pendingOwner;
    address public owner;
    bytes32 store_d;
    bool public deadlineActive;
    mapping(bytes32 => bytes32) storage_map_f;
    bool public lockingPaused;
    uint256 public totalAdminBurned;
    uint256 public totalLocked;
    mapping(bytes32 => bytes32) storage_map_h;
    uint256 public totalReverted;
    mapping(bytes32 => bytes32) storage_map_l;
    uint256 public totalAdminRescued;
    uint256 public totalConfirmed;
    
    error LockingIsPaused();
    event Confirmed(address, uint256);
    event Locked(address, uint256, uint64);
    event BurnDeadlineSet(uint64);
    event LockingPausedChanged(bool);
    event Reverted(address, uint256);
    event OwnershipTransferStarted(address, address);
    event AutoConfirmed(address, uint256);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public payable returns (uint256)
    function renounceOwnership() public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        pendingOwner = uint96(pendingOwner);
        owner = uint96(owner);
        emit OwnershipTransferred(address(owner), 0);
        return ;
    }
    
    /// @custom:selector    0x103bbd4a
    /// @custom:signature   Unresolved_103bbd4a(uint256 arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_103bbd4a(uint256 arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(!(arg0 + 0x23) < msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((arg0 + (arg0 << 0x05)) + 0x24) > msg.data.length, CustomError_3ee5aeb5());
        require(store_d == 0x02, CustomError_3ee5aeb5());
        store_d = 0x02;
        require(!(arg0), CustomError_0b7d62e2());
        require(arg0 > 0x32, CustomError_0b7d62e2());
        require(0 < (arg0), CustomError_f0029e08());
        require(!(0 < (arg0)), CustomError_f0029e08());
        require(bytes1(lockingPaused), CustomError_f0029e08());
        uint256 var_b = msg.data[0 + (0x24 + arg0)];
        require(!(bytes1(storage_map_f[var_b] >> 0xe0) < 0x03), CustomError_5f0ccd7c());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(bytes1(storage_map_f[var_b] >> 0xe0), CustomError_5f0ccd7c());
        require(!address(0x84816e5ce7a0811307154d78c9b2427b80823859).code.length);
        address var_e = msg.sender;
        (bool success, bytes memory ret0) = address(0x84816e5ce7a0811307154d78c9b2427b80823859).{ value: 0 ether }Unresolved_23b872dd(var_e); // call
        require(((var_h + 0x60) > 0xffffffffffffffff) | ((var_h + 0x60) < var_h));
        uint256 var_h = var_h + 0x60;
        require(!(var_k) < 0x03);
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_f[var_b] = (uint24(storage_map_f[var_b]) | (address(var_h.length)) | (uint64(var_l << 0xa0))) | (bytes1(var_m << 0xe0));
        require(totalLocked > (totalLocked + 0x01));
        totalLocked = totalLocked + 0x01;
        require(!address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).code.length);
        address var_o = msg.sender;
        (bool success, bytes memory ret0) = address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).{ value: 0 ether }Unresolved_40c10f19(var_o); // call
        require(var_h > 0xffffffffffffffff);
        require(0);
        store_d = 0x01;
        return ;
    }
    
    /// @custom:selector    0xca067972
    /// @custom:signature   Unresolved_ca067972(uint256 arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_ca067972(uint256 arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(!(arg0 + 0x23) < msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((arg0 + (arg0 << 0x05)) + 0x24) > msg.data.length, CustomError_118cdaa7());
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        require(store_d == 0x02, CustomError_3ee5aeb5());
        store_d = 0x02;
        require(!(arg0), CustomError_0b7d62e2());
        require(arg0 > 0x32, CustomError_0b7d62e2());
        require(0 < (arg0));
        require(!0 < (arg0));
        require(((var_e + 0x60) > 0xffffffffffffffff) | ((var_e + 0x60) < var_e));
        var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        uint256 var_e = var_e + 0x60;
        require(!(bytes1(storage_map_h[var_c] >> 0xe0)) < 0x03);
        var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(var_i) < 0x03);
        require(var_i);
        var_c = msg.data[0 + (0x24 + arg0)];
        storage_map_h[var_c] = 0;
        require(totalAdminRescued > (totalAdminRescued + 0x01));
        var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        totalAdminRescued = totalAdminRescued + 0x01;
        require(!address(0x84816e5ce7a0811307154d78c9b2427b80823859).code.length);
        address var_k = address(this);
        (bool success, bytes memory ret0) = address(0x84816e5ce7a0811307154d78c9b2427b80823859).{ value: storage_map_h[var_c] ether }Unresolved_23b872dd(var_k); // call
        require(var_e > 0xffffffffffffffff, CustomError_c2e5347d());
        store_d = 0x01;
        return ;
    }
    
    /// @custom:selector    0x1072984a
    /// @custom:signature   Unresolved_1072984a(uint256 arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_1072984a(uint256 arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(!(arg0 + 0x23) < msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((arg0 + (arg0 << 0x05)) + 0x24) > msg.data.length, CustomError_2eb35430());
        require(!(uint64(deadlineActive)), CustomError_2eb35430());
        require(!(block.timestamp > (uint64(deadlineActive))), CustomError_2eb35430());
        require(!(arg0), CustomError_0b7d62e2());
        require(arg0 > 0x32, CustomError_0b7d62e2());
        require(0 < (arg0), CustomError_c2e5347d());
        require(!(0 < (arg0)), CustomError_c2e5347d());
        uint256 var_b = msg.data[0 + (0x24 + arg0)];
        require(!(bytes1(storage_map_f[var_b] >> 0xe0) < 0x03), CustomError_c2e5347d());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(bytes1(storage_map_f[var_b] >> 0xe0) == 0x01, CustomError_c2e5347d());
        var_b = msg.data[0 + (0x24 + arg0)];
        storage_map_f[var_b] = 0x0200000000000000000000000000000000000000000000000000000000 | (uint248(storage_map_f[var_b]));
        require((totalConfirmed + 0x01) < totalConfirmed, CustomError_c2e5347d());
        return ;
    }
    
    /// @custom:selector    0x184ffbfc
    /// @custom:signature   Unresolved_184ffbfc(uint256 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_184ffbfc(uint256 arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - arg0);
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        lockingPaused = (bytes1(arg0)) | (uint248(lockingPaused));
        emit LockingPausedChanged(arg0);
        return ;
    }
    
    /// @custom:selector    0xd66fe70e
    /// @custom:signature   Unresolved_d66fe70e(uint256 arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_d66fe70e(uint256 arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(!(arg0 + 0x23) < msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((arg0 + (arg0 << 0x05)) + 0x24) > msg.data.length, CustomError_118cdaa7());
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        require(store_d == 0x02, CustomError_3ee5aeb5());
        store_d = 0x02;
        require(!(arg0), CustomError_0b7d62e2());
        require(arg0 > 0x32, CustomError_0b7d62e2());
        require(0 < (arg0));
        require(!0 < (arg0));
        uint256 var_c = msg.data[0 + (0x24 + arg0)];
        require(!(bytes1(storage_map_h[var_c] >> 0xe0)) < 0x03);
        var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(0x02 == (bytes1(storage_map_h[var_c] >> 0xe0)));
        var_c = msg.data[0 + (0x24 + arg0)];
        storage_map_h[var_c] = 0;
        require(totalAdminBurned > (totalAdminBurned + 0x01));
        var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        totalAdminBurned = totalAdminBurned + 0x01;
        require(!address(0x84816e5ce7a0811307154d78c9b2427b80823859).code.length);
        var_b = address(this);
        (bool success, bytes memory ret0) = address(0x84816e5ce7a0811307154d78c9b2427b80823859).{ value: storage_map_h[var_c] ether }Unresolved_23b872dd(var_b); // call
        require(var_h > 0xffffffffffffffff, CustomError_c2e5347d());
        store_d = 0x01;
        return ;
    }
    
    /// @custom:selector    0xf4dadc61
    /// @custom:signature   locks(uint256 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function locks(uint256 arg0) public view returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_l[var_a] >> 0xe0)) < 0x03);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return abi.encodePacked(address(storage_map_l[var_a]), uint64(storage_map_l[var_a] >> 0xa0), bytes1(storage_map_l[var_a] >> 0xe0));
    }
    
    /// @custom:selector    0xcf677ba0
    /// @custom:signature   setBurnDeadline(uint64 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint64", "bytes8", "int64"]
    function setBurnDeadline(uint64 arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (uint64(arg0)));
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        require(uint64(arg0), CustomError_3eb27c13());
        require(!(uint64(arg0) > block.timestamp), CustomError_3eb27c13());
        require(block.timestamp > (block.timestamp + 0x278d00), CustomError_3eb27c13());
        require(!(uint64(arg0) < (block.timestamp + 0x278d00)), CustomError_3eb27c13());
        deadlineActive = (uint64(arg0)) | (uint192(deadlineActive));
        emit BurnDeadlineSet(uint64(arg0));
        return ;
        deadlineActive = (uint64(arg0)) | (uint192(deadlineActive));
        emit BurnDeadlineSet(uint64(arg0));
        return ;
    }
    
    /// @custom:selector    0x150b7a02
    /// @custom:signature   Unresolved_150b7a02(address arg0, address arg1, uint256 arg2) public pure returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_150b7a02(address arg0, address arg1, uint256 arg2) public pure returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x80);
        require(arg0 - (address(arg0)));
        require(address(arg1) - arg1);
        require(arg3 > 0xffffffffffffffff);
        require(!(arg3 + 0x23) < msg.data.length);
        require(arg3  > 0xffffffffffffffff);
        require((0x24 + (arg3 + (arg3 ))) > msg.data.length);
        return 0x150b7a0200000000000000000000000000000000000000000000000000000000;
    }
    
    /// @custom:selector    0x784547a7
    /// @custom:signature   isConfirmed(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function isConfirmed(uint256 arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_l[var_a] >> 0xe0)) < 0x03);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return (bytes1(storage_map_l[var_a] >> 0xe0)) == 0x02;
    }
    
    /// @custom:selector    0xf6aacfb1
    /// @custom:signature   isLocked(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function isLocked(uint256 arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_l[var_a] >> 0xe0)) < 0x03);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return !(!bytes1(storage_map_l[var_a] >> 0xe0));
    }
    
    /// @custom:selector    0x79ba5097
    /// @custom:signature   acceptOwnership() public payable returns (uint256)
    function acceptOwnership() public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(address(pendingOwner) - msg.sender, CustomError_118cdaa7());
        address var_b = msg.sender;
        pendingOwner = uint96(pendingOwner);
        owner = var_b | (uint96(owner));
        emit OwnershipTransferred(address(owner), msg.sender);
        return ;
    }
    
    /// @custom:selector    0xa4d320cc
    /// @custom:signature   isEscrowed(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function isEscrowed(uint256 arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_l[var_a] >> 0xe0)) < 0x03);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return (bytes1(storage_map_l[var_a] >> 0xe0)) == 0x01;
    }
    
    /// @custom:selector    0xdd467064
    /// @custom:signature   lock(uint256 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function lock(uint256 arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_3ee5aeb5());
        require(store_d == 0x02, CustomError_3ee5aeb5());
        store_d = 0x02;
        require(bytes1(lockingPaused), CustomError_f0029e08());
        uint256 var_b = arg0;
        require(!(bytes1(storage_map_f[var_b] >> 0xe0) < 0x03), CustomError_5f0ccd7c());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(bytes1(storage_map_f[var_b] >> 0xe0), CustomError_5f0ccd7c());
        require(!address(0x84816e5ce7a0811307154d78c9b2427b80823859).code.length);
        address var_e = msg.sender;
        (bool success, bytes memory ret0) = address(0x84816e5ce7a0811307154d78c9b2427b80823859).{ value: 0 ether }Unresolved_23b872dd(var_e); // call
        require(((var_h + 0x60) > 0xffffffffffffffff) | ((var_h + 0x60) < var_h));
        uint256 var_h = var_h + 0x60;
        require(!(var_k) < 0x03);
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_f[var_b] = (uint24(storage_map_f[var_b]) | (address(var_h.length)) | (uint64(var_l << 0xa0))) | (bytes1(var_m << 0xe0));
        require(totalLocked > (totalLocked + 0x01));
        totalLocked = totalLocked + 0x01;
        require(!address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).code.length);
        address var_o = msg.sender;
        (bool success, bytes memory ret0) = address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).{ value: 0 ether }Unresolved_40c10f19(var_o); // call
        emit Locked(msg.sender, arg0, uint64(block.timestamp));
        store_d = 0x01;
        return ;
        require(var_h > 0xffffffffffffffff);
        require(0);
        emit Locked(msg.sender, arg0, uint64(block.timestamp));
        store_d = 0x01;
        return ;
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        require(msg.sender - (address(owner)), CustomError_118cdaa7());
        pendingOwner = (address(arg0)) | (uint96(pendingOwner));
        emit OwnershipTransferStarted(address(owner), address(arg0));
        return ;
    }
    
    /// @custom:selector    0xa4630882
    /// @custom:signature   autoConfirm(uint256 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function autoConfirm(uint256 arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_2eb35430());
        require(!(uint64(deadlineActive)), CustomError_2eb35430());
        require(!(block.timestamp > (uint64(deadlineActive))), CustomError_2eb35430());
        require(((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d), CustomError_ff272902());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(bytes1(storage_map_f[var_b] >> 0xe0) < 0x03), CustomError_ff272902());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(var_h < 0x03), CustomError_ff272902());
        require(0x01 - (var_h), CustomError_ff272902());
        var_b = arg0;
        storage_map_f[var_b] = 0x0200000000000000000000000000000000000000000000000000000000 | (uint248(storage_map_f[var_b]));
        require((totalConfirmed + 0x01) < totalConfirmed, CustomError_ff272902());
        totalConfirmed = totalConfirmed + 0x01;
        emit AutoConfirmed(msg.sender, arg0);
        return ;
    }
    
    /// @custom:selector    0xf70d378c
    /// @custom:signature   revertMigration(uint256 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function revertMigration(uint256 arg0) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20, CustomError_3ee5aeb5());
        require(store_d == 0x02, CustomError_3ee5aeb5());
        store_d = 0x02;
        require(((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d), CustomError_8e5693a0());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        uint256 var_d = var_d + 0x60;
        require(!(bytes1(storage_map_f[var_b] >> 0xe0) < 0x03), CustomError_8e5693a0());
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(var_h < 0x03), CustomError_8e5693a0());
        require(0x01 - (var_h), CustomError_8e5693a0());
        require(msg.sender - (address(var_d.length)), CustomError_8e5693a0());
        require(uint64(deadlineActive));
        require(block.timestamp > (uint64(deadlineActive)));
        uint256 var_j = arg0;
        (bool success, bytes memory ret0) = address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).Unresolved_6352211e(var_j); // staticcall
        require(0 - msg.sender, CustomError_b3b250a1());
        var_b = arg0;
        storage_map_f[var_b] = 0;
        require(totalReverted > (totalReverted + 0x01));
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        totalReverted = totalReverted + 0x01;
        require(!address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).code.length);
        var_j = arg0;
        (bool success, bytes memory ret0) = address(0x8a9604272c76f32cdfc75bf12c28b2aee5dff283).{ value: storage_map_f[var_b] ether }Unresolved_42966c68(var_j); // call
        require(!address(0x84816e5ce7a0811307154d78c9b2427b80823859).code.length);
        var_j = address(this);
        (bool success, bytes memory ret0) = address(0x84816e5ce7a0811307154d78c9b2427b80823859).{ value: storage_map_f[var_b] ether }Unresolved_23b872dd(var_j); // call
        emit Reverted(msg.sender, arg0);
        store_d = 0x01;
        return ;
        require(var_d > 0xffffffffffffffff);
        var_d = var_d;
        emit Reverted(msg.sender, arg0);
        store_d = 0x01;
        return ;
        require(var_d > 0xffffffffffffffff);
        require(0x20 > ret0.length);
        require(((var_d + 0x20) < var_d) | ((var_d + 0x20) > 0xffffffffffffffff));
        var_d = var_d + 0x20;
        require(((var_d + 0x20) - var_d) < 0x20);
        require(var_d.length - (address(var_d.length)));
        require(!(!uint64(deadlineActive)), CustomError_70f65caa());
    }
    
    /// @custom:selector    0xa30deb0a
    /// @custom:signature   lockOwner(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function lockOwner(uint256 arg0) public view returns (address) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        return address(storage_map_l[var_a]);
    }
    
    /// @custom:selector    0xba0179b5
    /// @custom:signature   confirm(uint256 arg0) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function confirm(uint256 arg0) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_8e5693a0());
        require(((var_c + 0x60) > 0xffffffffffffffff) | ((var_c + 0x60) < var_c), CustomError_8e5693a0());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        uint256 var_c = var_c + 0x60;
        require(!(bytes1(storage_map_l[var_a] >> 0xe0) < 0x03), CustomError_8e5693a0());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(var_h < 0x03), CustomError_8e5693a0());
        require(0x01 - (var_h), CustomError_8e5693a0());
        require(msg.sender - (address(var_c.length)), CustomError_8e5693a0());
        var_a = arg0;
        storage_map_l[var_a] = 0x0200000000000000000000000000000000000000000000000000000000 | (uint248(storage_map_l[var_a]));
        require((totalConfirmed + 0x01) < totalConfirmed, CustomError_ff272902());
        totalConfirmed = totalConfirmed + 0x01;
        emit Confirmed(msg.sender, arg0);
        return ;
    }
}

ABI

[
  {
    "type": "function",
    "name": "AUTHOR",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "DEAD",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_DEADLINE_NOTICE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "OG",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_103bbd4a",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_1072984a",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_150b7a02",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_184ffbfc",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_ca067972",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_d66fe70e",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "V2",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "VERSION",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "WEBSITE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "acceptOwnership",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "autoConfirm",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "burnDeadline",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint64"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "confirm",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "deadlineActive",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "deadlinePassed",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isConfirmed",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isEscrowed",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isLocked",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "lock",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "lockOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "lockingPaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "locks",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pendingOwner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "revertMigration",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setBurnDeadline",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint64"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "totalAdminBurned",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalAdminRescued",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalConfirmed",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalLocked",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalReverted",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "AutoConfirmed",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "BurnDeadlineSet",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint64",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Confirmed",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Locked",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint64",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "LockingPausedChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "bool",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferStarted",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferred",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Reverted",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AlreadyLocked",
    "inputs": []
  },
  {
    "type": "error",
    "name": "BatchTooLarge",
    "inputs": []
  },
  {
    "type": "error",
    "name": "DeadlineInPast",
    "inputs": []
  },
  {
    "type": "error",
    "name": "DeadlineNotPassed",
    "inputs": []
  },
  {
    "type": "error",
    "name": "DeadlineNotSet",
    "inputs": []
  },
  {
    "type": "error",
    "name": "DeadlineNoticeTooShort",
    "inputs": []
  },
  {
    "type": "error",
    "name": "DeadlinePassed",
    "inputs": []
  },
  {
    "type": "error",
    "name": "EmptyBatch",
    "inputs": []
  },
  {
    "type": "error",
    "name": "LockingIsPaused",
    "inputs": []
  },
  {
    "type": "error",
    "name": "MustStillHoldV2",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NotEscrowed",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NotLockOwner",
    "inputs": []
  },
  {
    "type": "error",
    "name": "OwnableUnauthorizedAccount",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ReentrancyGuardReentrantCall",
    "inputs": []
  }
]

UNKNOWN SELECTORS (28)

0x0472b49dunknown
0xb2506133unknown
0x1072984aunknown
0x0a85bd01unknown
0x31a9108funknown
0x387b2e55unknown
0xcf677ba0unknown
0xa4d320ccunknown
0x123abb21unknown
0x4028a0f1unknown
0x1e0053c1unknown
0x02eb3543unknown
0xa4630882unknown
0x6555c1c7unknown
0x184ffbfcunknown
0xb3b250a1unknown
0xf3ed6cefunknown
0x17c3335funknown
0x05beb171unknown
0xca067972unknown
0x8615f427unknown
0xf8fd0c37unknown
0xf70d378cunknown
0x3eb27c13unknown
0x7e3f71d5unknown
0xc9850725unknown
0x017d800bunknown
0x0852cd8dunknown
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)