0x04fa0d235c4abf4bcf4787af4cf447de572ef828

deployer: unknown relevance score: 0 status: partially_identified bytecode: 9881 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 decimals = 18;
    string public constant unresolved_06fdde03 = "UMA Voting Token v1";
    string public constant unresolved_95d89b41 = "UMA";
    
    bytes32 store_d;
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_j;
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_k;
    uint256 public snapshot;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_m;
    mapping(bytes32 => bytes32) storage_map_p;
    bytes32 store_g;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_l;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_o;
    
    event Event_8c5be1e5();
    event Snapshot(uint256);
    event Transfer(address, address, uint256);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public payable returns (bool) {
        require(!(address(msg.sender) == 0), "ERC20: approve to the zero address");
        require(!(address(arg0) == 0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_a[var_a] = arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x981b24d0
    /// @custom:signature   totalSupplyAt(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function totalSupplyAt(uint256 arg0) public view returns (uint256) {
        require(arg0 > 0, "ERC20Snapshot: nonexistent id");
        require(!(arg0 > snapshot), "ERC20Snapshot: nonexistent id");
        if (!store_d == 0) {
            if (!0 < store_d) {
                if (0x02) {
                    if (0x02) {
                        require(!(store_d == 0), "ERC20Snapshot: id is 0");
                        require(!(0 < store_d), "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                    }
                    require(0x02, "ERC20Snapshot: id is 0");
                    require(0x02, "ERC20Snapshot: id is 0");
                    var_f = 0x04;
                    require((0 + (store_d / 0x02)) + ((0 + (store_d % 0x02)) / 0x02) < store_d, "ERC20Snapshot: id is 0");
                    require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff < store_d, "ERC20Snapshot: id is 0");
                    require(!(storage_map_e[var_f] == arg0), "ERC20Snapshot: id is 0");
                    var_f = 0x05;
                    require(!(0 == store_d), "ERC20Snapshot: id is 0");
                    return unresolved_18160ddd;
                    return storage_map_f[var_f];
                    require(0 < store_g, "ERC20Snapshot: id is 0");
                    return 0;
                    return unresolved_18160ddd;
                    require(0x01, "ERC20Snapshot: id is 0");
                }
                require(0, "ERC20Snapshot: id is 0");
            }
        }
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(msg.sender);
        uint256 var_b = 0;
        require(!(storage_map_h[var_a] == 0), "");
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]), "");
        var_a = var_b + keccak256(var_a);
        require(!(storage_map_i[var_a] < snapshot), "");
        storage_map_h[var_a] = (storage_map_h[var_a]) + 0x01;
        var_a = var_b + keccak256(var_a);
        storage_map_j[var_a] = snapshot;
        storage_map_k[var_a] = (storage_map_k[var_a]) + 0x01;
        var_a = 0x01 + keccak256(var_a);
        storage_map_l[var_a] = storage_map_a[var_a];
        var_a = address(arg0);
        var_b = 0;
        require(!(storage_map_h[var_a] == 0), "");
        require(!(0 < snapshot), "");
        storage_map_h[var_a] = (storage_map_h[var_a]) + 0x01;
        var_a = var_b + keccak256(var_a);
        storage_map_j[var_a] = snapshot;
        storage_map_k[var_a] = (storage_map_k[var_a]) + 0x01;
        var_a = 0x01 + keccak256(var_a);
        storage_map_l[var_a] = storage_map_a[var_a];
        require(!(address(msg.sender) == 0), "");
        require(!(address(arg0) == 0), "");
        uint256 var_c = 0x60 + var_c;
        var_a = address(msg.sender);
        require(!(arg1 > storage_map_a[var_a]), "");
        require(!(bytes1(var_c.length)), "");
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!((storage_map_a[var_a] + arg1) < storage_map_a[var_a]), "SafeMath: addition overflow");
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]));
        var_a = address(arg0);
        require(!(storage_map_h[var_a]) == 0);
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]));
    }
    
    /// @custom:selector    0xd97c05be
    /// @custom:signature   resetMember(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function resetMember(uint256 arg0, address arg1) public payable {
        require(!(0x01 > 0x02), "Can only be called by a role manager");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(bytes1(storage_map_k[var_a] / 0x01) == 0x01, "Can only be called by a role manager");
        var_a = storage_map_h[var_a];
        require(!(0x01 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Can only be called by a role manager");
        require(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01) == (address(msg.sender)), "Can only be called by a role manager");
        var_a = arg0;
        require(!(address(arg1) == 0), "Cannot set an exclusive role to 0x0");
        storage_map_m[0x02 + keccak256(var_a)] = (address(arg1) * 0x01) | (uint96(storage_map_m[0x02 + keccak256(var_a)]));
        require(!(0x02 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Can only be called by a role manager");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a] / 0x01), "Can only be called by a role manager");
        require(0, "Invalid roleId");
    }
    
    /// @custom:selector    0x74d0a676
    /// @custom:signature   addMember(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function addMember(uint256 arg0, address arg1) public payable {
        require(!(0x02 > 0x02), "Can only be called by a role manager");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(bytes1(storage_map_k[var_a] / 0x01) == 0x02, "Can only be called by a role manager");
        var_a = storage_map_h[var_a];
        require(!(0x01 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Can only be called by a role manager");
        require(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01) == (address(msg.sender)), "Can only be called by a role manager");
        var_a = address(arg1);
        storage_map_a[var_a] = (0x01 * 0x01) | (uint248(storage_map_a[var_a]));
        require(!(0x02 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Can only be called by a role manager");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a] / 0x01), "Can only be called by a role manager");
        var_a = address(arg1);
        storage_map_a[var_a] = (0x01 * 0x01) | (uint248(storage_map_a[var_a]));
        require(0, "Invalid roleId");
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(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_23b872dd(address arg0, address arg1, uint256 arg2) public payable {
        var_a = address(arg0);
        uint256 var_b = 0;
        require(!(storage_map_h[var_a] == 0), "");
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]), "");
        var_a = var_b + keccak256(var_a);
        require(!(storage_map_i[var_a] < snapshot), "");
        storage_map_h[var_a] = (storage_map_h[var_a]) + 0x01;
        var_a = var_b + keccak256(var_a);
        storage_map_j[var_a] = snapshot;
        storage_map_k[var_a] = (storage_map_k[var_a]) + 0x01;
        var_a = 0x01 + keccak256(var_a);
        storage_map_l[var_a] = storage_map_a[var_a];
        var_a = address(arg1);
        var_b = 0;
        require(!(storage_map_h[var_a] == 0), "");
        require(!(0 < snapshot), "");
        storage_map_h[var_a] = (storage_map_h[var_a]) + 0x01;
        var_a = var_b + keccak256(var_a);
        storage_map_j[var_a] = snapshot;
        storage_map_k[var_a] = (storage_map_k[var_a]) + 0x01;
        var_a = 0x01 + keccak256(var_a);
        storage_map_l[var_a] = storage_map_a[var_a];
        require(!(address(arg0) == 0), "");
        require(!(address(arg1) == 0), "");
        uint256 var_c = 0x60 + var_c;
        var_a = address(arg0);
        require(!(arg2 > storage_map_a[var_a]), "");
        require(!(bytes1(var_c.length)), "");
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(!((storage_map_a[var_a] + arg2) < storage_map_a[var_a]), "SafeMath: addition overflow");
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]));
        var_a = address(arg1);
        require(!(storage_map_h[var_a]) == 0);
        require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]));
    }
    
    /// @custom:selector    0xab3545e5
    /// @custom:signature   getMember(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getMember(uint256 arg0) public view returns (address) {
        require(!(0x01 > 0x02), "Must be called on an initialized Exclusive role");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Must be called on an initialized Exclusive role");
        require(bytes1(storage_map_k[var_a] / 0x01) == 0x01, "Must be called on an initialized Exclusive role");
        var_a = arg0;
        return address(storage_map_m[0x02 + keccak256(var_a)] / 0x01);
    }
    
    /// @custom:selector    0x7cdc1cb9
    /// @custom:signature   holdsRole(uint256 arg0, address arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function holdsRole(uint256 arg0, address arg1) public view returns (bool) {
        uint256 var_a = arg0;
        require(!(0x01 > 0x02), "Invalid roleId");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Invalid roleId");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Invalid roleId");
        return !(!(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01)) == (address(arg1)));
        require(!(0x02 > 0x02), "Invalid roleId");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Invalid roleId");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Invalid roleId");
        var_a = address(arg1);
        return !(!bytes1(storage_map_a[var_a] / 0x01));
        require(0, "Invalid roleId");
        return 0;
    }
    
    /// @custom:selector    0x40c10f19
    /// @custom:signature   mint(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(address arg0, uint256 arg1) public view {
        require(!(0x01 > 0x02), "Sender does not hold required role");
        var_a = 0x01;
        require(!(0x01 > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Sender does not hold required role");
        require(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01) == (address(msg.sender)), "Sender does not hold required role");
        var_a = address(arg0);
        uint256 var_b = 0;
        if (!(storage_map_h[var_a]) == 0) {
            require(!(storage_map_h[var_a] == 0), "Sender does not hold required role");
            var_a = var_b + keccak256(var_a);
            require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]), "Sender does not hold required role");
        }
        require(!(0x02 > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Sender does not hold required role");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a] / 0x01), "Sender does not hold required role");
        require(0, "Invalid roleId");
    }
    
    /// @custom:selector    0xa457c2d7
    /// @custom:signature   decreaseAllowance(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseAllowance(address arg0, uint256 arg1) public payable returns (bool) {
        uint256 var_a = 0x60 + var_a;
        var_d = address(arg0);
        require(!(arg1 > storage_map_n[var_d]), "");
        require(!(bytes1(var_a.length)), "");
        require(!(address(msg.sender) == 0), "ERC20: approve to the zero address");
        require(!(address(arg0) == 0), "ERC20: approve to the zero address");
        var_d = address(arg0);
        storage_map_n[var_d] = storage_map_n[var_d] - arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), storage_map_n[var_d] - arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x4ee2cd7e
    /// @custom:signature   balanceOfAt(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function balanceOfAt(address arg0, uint256 arg1) public view returns (uint256) {
        address var_a = address(arg0);
        require(arg1 > 0, "ERC20Snapshot: nonexistent id");
        require(!(arg1 > snapshot), "ERC20Snapshot: nonexistent id");
        if (!(storage_map_h[var_a]) == 0) {
            if (!0 < (storage_map_h[var_a])) {
                if (0x02) {
                    if (0x02) {
                        require(!(storage_map_h[var_a] == 0), "ERC20Snapshot: id is 0");
                        require(!(0 < (storage_map_h[var_a])), "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                        require(0x02, "ERC20Snapshot: id is 0");
                    }
                    require(0x02, "ERC20Snapshot: id is 0");
                    require(0x02, "ERC20Snapshot: id is 0");
                    var_a = 0 + keccak256(var_a);
                    require((0 + (storage_map_h[var_a] / 0x02)) + ((0 + (storage_map_h[var_a] % 0x02)) / 0x02) < (storage_map_h[var_a]), "ERC20Snapshot: id is 0");
                    require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff < (storage_map_h[var_a]), "ERC20Snapshot: id is 0");
                    require(!(storage_map_o[var_a] == arg1), "ERC20Snapshot: id is 0");
                    var_a = 0x01 + keccak256(var_a);
                    require(!(0 == (storage_map_h[var_a])), "ERC20Snapshot: id is 0");
                    var_a = address(arg0);
                    return storage_map_a[var_a];
                    return storage_map_p[var_a];
                    require(0 < (storage_map_k[var_a]), "ERC20Snapshot: id is 0");
                    return 0;
                    var_a = address(arg0);
                    return storage_map_a[var_a];
                    require(0x01, "ERC20Snapshot: id is 0");
                }
                require(0, "ERC20Snapshot: id is 0");
            }
        }
    }
    
    /// @custom:selector    0x6be7658b
    /// @custom:signature   removeMember(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function removeMember(uint256 arg0, address arg1) public payable {
        require(!(0x02 > 0x02), "Can only be called by a role manager");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(bytes1(storage_map_k[var_a] / 0x01) == 0x02, "Can only be called by a role manager");
        var_a = storage_map_h[var_a];
        require(!(0x01 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Can only be called by a role manager");
        require(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01) == (address(msg.sender)), "Can only be called by a role manager");
        var_a = address(arg1);
        storage_map_a[var_a] = (0 * 0x01) | (uint248(storage_map_a[var_a]));
        require(!(0x02 > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Can only be called by a role manager");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Can only be called by a role manager");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a] / 0x01), "Can only be called by a role manager");
        var_a = address(arg1);
        storage_map_a[var_a] = (0 * 0x01) | (uint248(storage_map_a[var_a]));
        require(0, "Invalid roleId");
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   Unresolved_42966c68(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_42966c68(uint256 arg0) public view {
        require(!(0x02 > 0x02), "Sender does not hold required role");
        var_a = 0x02;
        require(!(0x01 > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x01), "Sender does not hold required role");
        require(address(storage_map_m[0x02 + keccak256(var_a)] / 0x01) == (address(msg.sender)), "Sender does not hold required role");
        var_a = address(msg.sender);
        uint256 var_b = 0;
        if (!(storage_map_h[var_a]) == 0) {
            require(!(storage_map_h[var_a] == 0), "Sender does not hold required role");
            var_a = var_b + keccak256(var_a);
            require((storage_map_h[var_a] - 0x01) < (storage_map_h[var_a]), "Sender does not hold required role");
        }
        require(!(0x02 > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) > 0x02), "Sender does not hold required role");
        require(!(bytes1(storage_map_k[var_a] / 0x01) == 0x02), "Sender does not hold required role");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a] / 0x01), "Sender does not hold required role");
        require(0, "Invalid roleId");
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256) {
        var_a = address(arg1);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x39509351
    /// @custom:signature   increaseAllowance(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseAllowance(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(arg0);
        require(!((storage_map_a[var_a] + arg1) < storage_map_a[var_a]), "SafeMath: addition overflow");
        require(!(address(msg.sender) == 0), "ERC20: approve to the zero address");
        require(!(address(arg0) == 0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), storage_map_a[var_a] + arg1);
        return 0x01;
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_42966c68",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_dd62ed3e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "addMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "balanceOfAt",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "decreaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "holdsRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "increaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "removeMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "resetMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "snapshot",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "totalSupplyAt",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Snapshot",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (1)

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