0x3b94440c8c4f69d5c9f47bab9c5a93064df460f5

deployer: unknown relevance score: 10 status: identified bytecode: 7820 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;
    uint256 public constant DOMAIN_TYPEHASH = 63630494520926674092677056046569304749177344945028501797992170511073678501990;
    uint256 public constant unresolved_30adf81f = 49955707469362902507454157297736832118868343942642399513960811609542965143241;
    uint256 public constant DELEGATION_TYPEHASH = 103359069561928152843793640083012950350530901667116492021891118459870908603103;
    string public constant unresolved_06fdde03 = "Ring.Exchange";
    string public constant unresolved_95d89b41 = "RNG";
    
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_d;
    address public minter;
    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 MinterChanged(address, address);
    event DelegateVotesChanged(address, uint256, uint256);
    event DelegateChanged(address, address, address);
    event Transfer(address, address, uint256);
    event Event_8c5be1e5();
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint96 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint96", "bytes12", "int96"]
    function Unresolved_095ea7b3(address arg0, uint96 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        require(!(arg1 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "");
        var_a = address(arg0);
        storage_map_a[var_a] = 0xffffffffffffffffffffffff | (address(storage_map_a[var_a]));
        emit Event_8c5be1e5(msg.sender, address(arg0), 0xffffffffffffffffffffffff);
        return 0x01;
        uint256 var_d = 0x40 + var_d;
        var_a = var_a;
        require(arg1 < 0x01000000000000000000000000, "");
        require(!(0 > var_d.length), "");
        require(!(0x20 > var_d.length), "Ring: amount exceeds 96 bits");
        var_a = address(arg0);
        storage_map_a[var_a] = (uint96(arg1)) | (address(storage_map_a[var_a]));
        emit Event_8c5be1e5(msg.sender, address(arg0), uint96(arg1));
        return 0x01;
    }
    
    /// @custom:selector    0xc3cda520
    /// @custom:signature   delegateBySig(address arg0, uint256 arg1, uint256 arg2, uint8 arg3, bytes32 arg4, bytes32 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function delegateBySig(address arg0, uint256 arg1, uint256 arg2, uint8 arg3, bytes32 arg4, bytes32 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        uint256 var_a = 0x40 + var_a;
        var_a = 0x80 + (0x20 + var_a);
        var_a = 0x80 + (0x20 + var_a);
        require(var_y);
        require(address(var_z), "Ring: invalid nonce");
        uint256 var_aa = address(var_z);
        storage_map_c[var_aa] = storage_map_c[var_aa] + 0x01;
        require(arg1 == storage_map_c[var_aa], "Ring: invalid nonce");
        require(!(block.timestamp > arg2), "");
        var_aa = address(var_z);
        storage_map_c[var_aa] = (address(arg0)) | (uint96(storage_map_c[var_aa]));
        emit DelegateChanged(address(var_z), address(storage_map_c[var_aa]), address(arg0));
        require(!(!(address(storage_map_c[var_aa])) == (address(arg0))), "");
        require(!(uint96(storage_map_c[var_aa]) > 0), "");
        require(!(address(storage_map_c[var_aa])), "");
        var_aa = address(storage_map_c[var_aa]);
        require(uint32(storage_map_c[var_aa]), "");
        var_aa = uint32(storage_map_c[var_aa] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = 0x40 + var_a;
        require(!(uint96(storage_map_c[var_aa]) > (uint96(storage_map_c[var_aa] / 0x0100000000))), "");
        require(!(0 > var_a.length), "");
        require(!(0x20 > var_a.length), "Ring: vote amount underflows");
        var_a = 0x60 + var_a;
        require(block.number < 0x0100000000, "");
        require(!(0 > var_a.length), "");
        if (!(uint32(storage_map_c[var_aa])) > 0) {
            var_aa = uint32(storage_map_c[var_aa] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(!(uint32(storage_map_c[var_aa]) > 0), "Ring: signature expired");
            var_aa = uint32(storage_map_c[var_aa] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            storage_map_c[var_aa] = (uint96((storage_map_c[var_aa] / 0x0100000000) - (storage_map_c[var_aa])) * 0x0100000000) | (address(storage_map_c[var_aa]));
            emit DelegateVotesChanged(address(storage_map_c[var_aa]), uint96(storage_map_c[var_aa] / 0x0100000000), uint96((storage_map_c[var_aa] / 0x0100000000) - (storage_map_c[var_aa])));
            require(!(uint32(storage_map_c[var_aa]) == (uint32(block.number))), "Ring: signature expired");
            require(!(address(arg0)), "Ring: signature expired");
            var_aa = uint32(storage_map_c[var_aa] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(uint32(storage_map_c[var_aa]), "Ring: signature expired");
            require(!(uint96(storage_map_c[var_aa] + (storage_map_c[var_aa] / 0x0100000000)) < (uint96(storage_map_c[var_aa] / 0x0100000000))), "Ring: signature expired");
        }
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   Unresolved_a9059cbb(address arg0, uint96 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint96", "bytes12", "int96"]
    function Unresolved_a9059cbb(address arg0, uint96 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        uint256 var_a = 0x40 + var_a;
        var_c = var_c;
        require(arg1 < 0x01000000000000000000000000, "");
        require(!(0 > var_a.length), "");
        require(!(0x20 > var_a.length), "Ring: amount exceeds 96 bits");
        require(address(msg.sender), "");
        require(address(arg0), "");
        address var_c = address(msg.sender);
        var_a = var_a + 0x60;
        require(!(uint96(arg1) > (uint96(storage_map_d[var_c]))), "");
        require(!(0 > var_a.length), "");
        var_c = address(msg.sender);
        storage_map_d[var_c] = (uint96(storage_map_d[var_c] - arg1)) | (address(storage_map_d[var_c]));
        var_c = address(arg0);
        var_a = 0x40 + var_a;
        require(!(uint96(arg1 + (storage_map_d[var_c])) < (uint96(storage_map_d[var_c]))), "");
        require(!(0 > var_a.length), "");
        require(!(0x20 > var_a.length), "Ring: transfer amount overflows");
        var_c = address(arg0);
        storage_map_d[var_c] = (uint96(arg1 + (storage_map_d[var_c]))) | (address(storage_map_d[var_c]));
        emit Transfer(address(msg.sender), address(arg0), uint96(arg1));
        var_c = address(arg0);
        require(!(!(address(storage_map_d[var_c])) == (address(storage_map_d[var_c]))), "");
        require(!(uint96(arg1) > 0), "");
        require(!(address(storage_map_d[var_c])), "");
        var_c = address(storage_map_d[var_c]);
        require(uint32(storage_map_d[var_c]), "");
        var_c = uint32(storage_map_d[var_c] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = 0x40 + var_a;
        require(!(uint96(arg1) > (uint96(storage_map_d[var_c] / 0x0100000000))), "");
        require(!(0 > var_a.length), "");
        require(!(0x20 > var_a.length), "Ring: vote amount underflows");
        var_a = 0x60 + var_a;
        require(block.number < 0x0100000000, "");
        require(!(0 > var_a.length), "");
        if (!(uint32(storage_map_d[var_c])) > 0) {
            var_c = uint32(storage_map_d[var_c] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(!(uint32(storage_map_d[var_c]) > 0), "Ring: cannot transfer to the zero address");
            var_c = uint32(storage_map_d[var_c] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            storage_map_d[var_c] = (uint96((storage_map_d[var_c] / 0x0100000000) - arg1) * 0x0100000000) | (address(storage_map_d[var_c]));
            emit DelegateVotesChanged(address(storage_map_d[var_c]), uint96(storage_map_d[var_c] / 0x0100000000), uint96((storage_map_d[var_c] / 0x0100000000) - arg1));
            require(!(uint32(storage_map_d[var_c]) == (uint32(block.number))), "Ring: cannot transfer to the zero address");
            var_c = address(storage_map_d[var_c]);
            require(!(address(storage_map_d[var_c])), "Ring: cannot transfer to the zero address");
            var_c = uint32(storage_map_d[var_c] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(uint32(storage_map_d[var_c]), "Ring: cannot transfer to the zero address");
            require(!(uint96(arg1 + (storage_map_d[var_c] / 0x0100000000)) < (uint96(storage_map_d[var_c] / 0x0100000000))), "Ring: cannot transfer to the zero address");
        }
        return 0x01;
        return 0x01;
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_23b872dd(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint96)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint96) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        return uint96(storage_map_a[var_a]);
    }
    
    /// @custom:selector    0x7ecebe00
    /// @custom:signature   nonces(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function nonces(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return storage_map_e[var_b];
    }
    
    /// @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(arg0 == (address(arg0)));
        require(msg.sender == (address(minter)), "Ring: only the minter can mint");
        require(address(arg0), "");
        uint256 var_e = 0x40 + var_e;
        var_f = var_f;
        require(arg1 < 0x01000000000000000000000000, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "Ring: amount exceeds 96 bits");
        var_e = 0x60 + var_e;
        require(unresolved_18160ddd < 0x01000000000000000000000000, "");
        require(!(0 > var_e.length), "");
        var_e = 0x60 + var_e;
        require(!(uint96(arg1 + unresolved_18160ddd) < (uint96(unresolved_18160ddd))), "");
        require(!(0 > var_e.length), "");
    }
    
    /// @custom:selector    0x6fcfff45
    /// @custom:signature   numCheckpoints(address arg0) public view returns (uint32)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function numCheckpoints(address arg0) public view returns (uint32) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return uint32(storage_map_e[var_b]);
    }
    
    /// @custom:selector    0x5c19a95c
    /// @custom:signature   delegate(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function delegate(address arg0) public payable {
        require(arg0 == (address(arg0)));
        address var_a = address(msg.sender);
        storage_map_a[var_a] = (address(arg0)) | (uint96(storage_map_a[var_a]));
        emit DelegateChanged(address(msg.sender), address(storage_map_a[var_a]), address(arg0));
        require(!(!(address(storage_map_a[var_a])) == (address(arg0))), "");
        require(!(uint96(storage_map_a[var_a]) > 0), "");
        require(!(address(storage_map_a[var_a])), "");
        var_a = address(storage_map_a[var_a]);
        require(uint32(storage_map_a[var_a]), "");
        var_a = uint32(storage_map_a[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint256 var_c = 0x40 + var_c;
        require(!(uint96(storage_map_a[var_a]) > (uint96(storage_map_a[var_a] / 0x0100000000))), "");
        require(!(0 > var_c.length), "");
        require(!(0x20 > var_c.length), "Ring: vote amount underflows");
        var_c = 0x60 + var_c;
        require(block.number < 0x0100000000, "");
        require(!(0 > var_c.length), "");
        if (!(uint32(storage_map_a[var_a])) > 0) {
            var_a = uint32(storage_map_a[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(!(uint32(storage_map_a[var_a])) > 0);
            var_a = uint32(storage_map_a[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            storage_map_a[var_a] = (uint96((storage_map_a[var_a] / 0x0100000000) - (storage_map_a[var_a])) * 0x0100000000) | (address(storage_map_a[var_a]));
            emit DelegateVotesChanged(address(storage_map_a[var_a]), uint96(storage_map_a[var_a] / 0x0100000000), uint96((storage_map_a[var_a] / 0x0100000000) - (storage_map_a[var_a])));
            require(!(uint32(storage_map_a[var_a])) == (uint32(block.number)));
            require(!address(arg0));
            var_a = uint32(storage_map_a[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(uint32(storage_map_a[var_a]));
            require(!(uint96(storage_map_a[var_a] + (storage_map_a[var_a] / 0x0100000000))) < (uint96(storage_map_a[var_a] / 0x0100000000)));
        }
    }
    
    /// @custom:selector    0xf1127ed8
    /// @custom:signature   checkpoints(address arg0, uint32 arg1) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint32", "bytes4", "int32"]
    function checkpoints(address arg0, uint32 arg1) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        require(arg1 == (uint32(arg1)));
        address var_b = arg0;
        var_b = arg1;
        return abi.encodePacked(uint32(storage_map_e[var_b]), uint96(storage_map_e[var_b] / 0x0100000000));
    }
    
    /// @custom:selector    0xb4b5ea57
    /// @custom:signature   getCurrentVotes(address arg0) public view returns (uint96)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getCurrentVotes(address arg0) public view returns (uint96) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        require(uint32(storage_map_a[var_a]));
        var_a = uint32(storage_map_a[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        return uint96(storage_map_a[var_a] / 0x0100000000);
        return 0;
    }
    
    /// @custom:selector    0xd505accf
    /// @custom:signature   Unresolved_d505accf(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_d505accf(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x587cde1e
    /// @custom:signature   delegates(address arg0) public view returns (address)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function delegates(address arg0) public view returns (address) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return address(storage_map_e[var_b]);
    }
    
    /// @custom:selector    0xfca3b5aa
    /// @custom:signature   setMinter(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setMinter(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(minter)), "Ring: only the minter can change the minter address");
        emit MinterChanged(address(minter), address(arg0));
        minter = (address(arg0)) | (uint96(minter));
    }
    
    /// @custom:selector    0x782d6fe1
    /// @custom:signature   getPriorVotes(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getPriorVotes(address arg0, uint256 arg1) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(arg1 < block.number, "Ring: not yet determined");
        address var_e = address(arg0);
        if (uint32(storage_map_g[var_e])) {
            var_e = uint32(storage_map_g[var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            require(uint32(storage_map_g[var_e]));
            var_e = 0;
            require(arg1 < (uint32(storage_map_g[var_e])));
            return 0;
            require(!arg1 < (uint32(storage_map_g[var_e])));
            var_e = 0;
            return uint96(storage_map_g[var_e] / 0x0100000000);
            var_e = uint32((storage_map_g[var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (((storage_map_g[var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - 0) / 0x02));
            require(!(uint32(storage_map_g[var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) > 0);
            require(!arg1 == (uint32(storage_map_g[var_e])));
        }
        return uint96(var_j);
        var_e = uint32(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (storage_map_g[var_e]));
        return uint96(storage_map_g[var_e] / 0x0100000000);
        return 0;
    }
}

ABI

[
  {
    "type": "function",
    "name": "DELEGATION_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "DOMAIN_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "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": "uint96"
      }
    ],
    "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"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_30adf81f",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint96"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_a9059cbb",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint96"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_d505accf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_dd62ed3e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "checkpoints",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "delegate",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "delegateBySig",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint8"
      },
      {
        "name": "arg4",
        "type": "bytes32"
      },
      {
        "name": "arg5",
        "type": "bytes32"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "delegates",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getCurrentVotes",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint96"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPriorVotes",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "minter",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "nonces",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "numCheckpoints",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setMinter",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "DelegateChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "DelegateVotesChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "MinterChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "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 (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)