0x6b1acb7ec9af6109975aa28f42e811885e5e6250

DECOMPILED SOLIDITY (Heimdall) VERIFY

// 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 DEFAULT_ADMIN_ROLE = 0;
    
    mapping(bytes32 => bytes32) storage_map_q;
    address store_m;
    mapping(bytes32 => bytes32) storage_map_s;
    uint256 public bonus_rate;
    uint256 public buyback_fee;
    mapping(bytes32 => bytes32) storage_map_af;
    mapping(bytes32 => bytes32) storage_map_ac;
    address store_b;
    bool public recollateralizePaused;
    address store_c;
    bytes32 store_e;
    bytes32 store_f;
    uint256 public unclaimedPoolCollateral;
    uint256 public pool_ceiling;
    uint256 public getCollateralPrice;
    mapping(bytes32 => bytes32) storage_map_ae;
    bytes32 recollateralizePausedi;
    mapping(bytes32 => bytes32) storage_map_o;
    uint256 public minting_fee;
    mapping(bytes32 => bytes32) storage_map_ah;
    mapping(bytes32 => bytes32) storage_map_v;
    bytes32 store_k;
    uint256 public redemption_fee;
    uint256 storage_map_ae[storage_map_ac[var_f] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff];
    address public collat_eth_oracle_address;
    mapping(bytes32 => bytes32) storage_map_ad;
    mapping(bytes32 => bytes32) storage_map_t;
    mapping(bytes32 => bytes32) storage_map_r;
    bytes32 store_j;
    uint256 public redemption_delay;
    mapping(bytes32 => bytes32) storage_map_p;
    uint256 public unclaimedPoolSTS;
    mapping(bytes32 => bytes32) storage_map_ag;
    mapping(bytes32 => bytes32) storage_map_u;
    mapping(bytes32 => bytes32) storage_map_l;
    uint256 public recollat_fee;
    mapping(bytes32 => bytes32) storage_map_aj;
    uint256 storage_map_q[storage_map_l[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff];
    
    event RoleRevoked(bytes32, address, address);
    event CollectRedemption(address, uint256);
    event RecollateralizeSTC(address, uint256);
    event RoleGranted(bytes32, address, address);
    
    /// @custom:selector    0x42d15aec
    /// @custom:signature   toggleRecollateralize() public payable
    function toggleRecollateralize() public payable {
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        recollateralizePaused = (0x010000 * (!bytes1(recollateralizePaused / 0x010000))) | (uint248(recollateralizePaused));
    }
    
    /// @custom:selector    0xf6da1af5
    /// @custom:signature   mintFractionalSTC(uint256 arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function mintFractionalSTC(uint256 arg0, uint256 arg1, uint256 arg2) public payable {
        require(!(bytes1(recollateralizePaused)), "Minting is paused");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).stc_price(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).sts_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).global_collateral_ratio(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Collateral ratio needs to be between .000001 and .999999");
        require(!(var_e.length < 0x0f4240), "Collateral ratio needs to be between .000001 and .999999");
        require(var_e.length > 0, "Collateral ratio needs to be between .000001 and .999999");
        address var_i = address(this);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).Unresolved_70a08231(var_i); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        var_e = 0x40 + var_e;
        require(!(unclaimedPoolCollateral > var_e.length), "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: subtraction overflow");
        require(!((arg0 + (var_e.length - unclaimedPoolCollateral)) < (var_e.length - unclaimedPoolCollateral)), "SafeMath: addition overflow");
        require(!(arg0 + (var_e.length - unclaimedPoolCollateral)) > pool_ceiling);
        var_e = 0x0120 + var_e;
        require(!0x01 == (bytes1(recollateralizePaused / 0x0100000000)));
        address var_ai = address(this);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).Unresolved_70a08231(var_ai); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        var_e = 0x40 + var_e;
        require(!(unclaimedPoolCollateral > var_e.length), "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: subtraction overflow");
        require(var_at, "");
        require(var_at, "");
        require(var_au * (var_at) / (var_at) == (var_au), "");
        var_e = 0x40 + var_e;
        require(0x0f4240, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(0x0f4240, "SafeMath: multiplication overflow");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        address var_ba = address(store_j);
        var_bb = 0x0f4240;
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).consult(var_ba, var_bb); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(var_e.length < 0x0f4240, "Collateral ratio needs to be between .000001 and .999999");
    }
    
    /// @custom:selector    0x7d55094d
    /// @custom:signature   toggleMinting() public payable
    function toggleMinting() public payable {
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        recollateralizePaused = (!bytes1(recollateralizePaused)) | (uint248(recollateralizePaused));
    }
    
    /// @custom:selector    0xca15c873
    /// @custom:signature   getRoleMemberCount(bytes32 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getRoleMemberCount(bytes32 arg0) public view returns (uint256) {
        uint256 var_a = arg0;
        return storage_map_l[var_a];
    }
    
    /// @custom:selector    0x8705fcd4
    /// @custom:signature   setFeeAddress(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setFeeAddress(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        store_m = (address(arg0)) | (uint96(store_m));
    }
    
    /// @custom:selector    0x91d14854
    /// @custom:signature   hasRole(bytes32 arg0, address arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function hasRole(bytes32 arg0, address arg1) public view returns (bool) {
        require(arg1 == (address(arg1)));
        var_a = address(arg1);
        return storage_map_l[var_a];
    }
    
    /// @custom:selector    0x248a9ca3
    /// @custom:signature   getRoleAdmin(bytes32 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getRoleAdmin(bytes32 arg0) public view returns (uint256) {
        uint256 var_a = arg0;
        return storage_map_o[var_a];
    }
    
    /// @custom:selector    0x13af4035
    /// @custom:signature   setOwner(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setOwner(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        store_c = (address(arg0)) | (uint96(store_c));
    }
    
    /// @custom:selector    0xd547741f
    /// @custom:signature   revokeRole(bytes32 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function revokeRole(bytes32 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        var_a = address(msg.sender);
        require(storage_map_l[var_a], "AccessControl: sender must be an admin to revoke");
        var_a = address(arg1);
        require(!storage_map_l[var_a], "AccessControl: sender must be an admin to revoke");
        require((storage_map_l[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < storage_map_l[var_a], "AccessControl: sender must be an admin to revoke");
        var_a = keccak256(var_a);
        require((storage_map_l[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (storage_map_p[var_a]), "AccessControl: sender must be an admin to revoke");
        var_a = 0 + keccak256(var_a);
        storage_map_q[storage_map_l[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff] = storage_map_r[var_a];
        var_a = storage_map_s[var_a];
        storage_map_l[var_a] = (storage_map_l[var_a] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 0x01;
        require(storage_map_l[var_a], "AccessControl: sender must be an admin to revoke");
        var_a = keccak256(var_a);
        storage_map_t[var_a] = 0;
        storage_map_l[var_a] = storage_map_l[var_a] - 0x01;
        var_a = address(arg1);
        storage_map_l[var_a] = 0;
        require(!0x01, "AccessControl: sender must be an admin to revoke");
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
        require(!0, "AccessControl: sender must be an admin to revoke");
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
    }
    
    /// @custom:selector    0x2f2ff15d
    /// @custom:signature   grantRole(bytes32 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function grantRole(bytes32 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        var_a = address(msg.sender);
        require(storage_map_l[var_a], "AccessControl: sender must be an admin to grant");
        var_a = address(arg1);
        require(storage_map_l[var_a], "AccessControl: sender must be an admin to grant");
        require(!0, "AccessControl: sender must be an admin to grant");
        emit RoleGranted(arg0, address(arg1), address(msg.sender));
        storage_map_l[var_a] = 0x01 + storage_map_l[var_a];
        var_a = keccak256(var_a);
        storage_map_u[var_a] = address(arg1);
        var_a = address(arg1);
        storage_map_l[var_a] = storage_map_l[var_a];
        require(!0x01, "AccessControl: sender must be an admin to grant");
        emit RoleGranted(arg0, address(arg1), address(msg.sender));
    }
    
    /// @custom:selector    0x08a7493d
    /// @custom:signature   redeemCollateralBalances(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function redeemCollateralBalances(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return storage_map_v[var_b];
    }
    
    /// @custom:selector    0x88d42cf2
    /// @custom:signature   Unresolved_88d42cf2(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_88d42cf2(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xbdacb303
    /// @custom:signature   setTimelock(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setTimelock(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        store_b = (address(arg0)) | (uint96(store_b));
    }
    
    /// @custom:selector    0x163dbc2b
    /// @custom:signature   redeemFractionalSTC(uint256 arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function redeemFractionalSTC(uint256 arg0, uint256 arg1, uint256 arg2) public payable {
        require(!(bytes1(recollateralizePaused / 0x0100)), "Redeeming is paused");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).global_collateral_ratio(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Collateral ratio needs to be between .000001 and .999999");
        require(!(var_e.length < 0x0f4240), "Collateral ratio needs to be between .000001 and .999999");
        require(var_e.length > 0, "Collateral ratio needs to be between .000001 and .999999");
        require(arg0, "SafeMath: multiplication overflow");
        require(arg0, "SafeMath: multiplication overflow");
        require(((0 * arg0) / arg0) == 0, "SafeMath: multiplication overflow");
        var_e = 0x40 + var_e;
        require(0x0f4240, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(0x0f4240);
        require(!((0 * arg0) / 0x0f4240) > arg0);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).sts_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(arg0 - ((0 * arg0) / 0x0f4240), "");
        require(arg0 - ((0 * arg0) / 0x0f4240), "");
        require((var_e.length * (arg0 - ((0 * arg0) / 0x0f4240))) / (arg0 - ((0 * arg0) / 0x0f4240)) == var_e.length, "");
        var_e = 0x40 + var_e;
        require(0x0f4240, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        if (0x0f4240) {
            var_e = 0x40 + var_e;
            require(0x0f4240, "SafeMath: multiplication overflow");
        }
        require(var_e.length < 0x0f4240, "Collateral ratio needs to be between .000001 and .999999");
    }
    
    /// @custom:selector    0x4ebbe762
    /// @custom:signature   setPoolParameters(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function setPoolParameters(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public payable {
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        pool_ceiling = arg0;
        bonus_rate = arg1;
        redemption_delay = arg2;
        minting_fee = arg3;
        redemption_fee = arg4;
        recollateralizePauseda = arg5;
        recollateralizePausedb = arg6;
    }
    
    /// @custom:selector    0x17284c94
    /// @custom:signature   collatDollarBalance() public payable
    function collatDollarBalance() public payable {
        require(!0x01 == (bytes1(recollateralizePaused / 0x0100000000)));
        address var_b = address(this);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).Unresolved_70a08231(var_b); // staticcall
        uint256 var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!(((var_c + ret0.length) - var_c) < 0x20), "");
        var_c = 0x40 + var_c;
        require(!(unclaimedPoolCollateral > var_c.length), "");
        require(!(0 > var_c.length), "");
        require(!(0x20 > var_c.length), "SafeMath: subtraction overflow");
        require(var_c.length - unclaimedPoolCollateral, "SafeMath: multiplication overflow");
        require(var_c.length - unclaimedPoolCollateral, "SafeMath: multiplication overflow");
        require((0x01 * (var_c.length - unclaimedPoolCollateral)) / (var_c.length - unclaimedPoolCollateral) == 0x01, "SafeMath: multiplication overflow");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
    }
    
    /// @custom:selector    0x7ad1f61b
    /// @custom:signature   toggleCollateralPrice(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function toggleCollateralPrice(uint256 arg0) public payable {
        address var_b = address(msg.sender);
        require(storage_map_v[var_b]);
        require(bytes1(recollateralizePaused / 0x0100000000));
        getCollateralPrice = 0;
        recollateralizePaused = (0x0100000000 * (!bytes1(recollateralizePaused / 0x0100000000))) | (uint248(recollateralizePaused));
        getCollateralPrice = arg0;
        recollateralizePaused = (0x0100000000 * (!bytes1(recollateralizePaused / 0x0100000000))) | (uint248(recollateralizePaused));
    }
    
    /// @custom:selector    0x36568abe
    /// @custom:signature   renounceRole(bytes32 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function renounceRole(bytes32 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(address(arg1) == (address(msg.sender)), "AccessControl: can only renounce roles for self");
        var_f = address(arg1);
        require(!storage_map_ac[var_f]);
        require((storage_map_ac[var_f] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < storage_map_ac[var_f]);
        var_f = keccak256(var_f);
        require((storage_map_ac[var_f] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (storage_map_ad[var_f]));
        var_f = 0 + keccak256(var_f);
        storage_map_ae[storage_map_ac[var_f] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff] = storage_map_af[var_f];
        var_f = storage_map_ag[var_f];
        storage_map_ac[var_f] = (storage_map_ac[var_f] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 0x01;
        require(storage_map_ac[var_f]);
        var_f = keccak256(var_f);
        storage_map_ah[var_f] = 0;
        storage_map_ac[var_f] = storage_map_ac[var_f] - 0x01;
        var_f = address(arg1);
        storage_map_ac[var_f] = 0;
        require(!0x01);
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
        require(!0);
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
    }
    
    /// @custom:selector    0x5a72cf5f
    /// @custom:signature   recollateralizeSTC(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function recollateralizeSTC(uint256 arg0, uint256 arg1) public payable {
        require(!(bytes1(recollateralizePaused / 0x010000)), "Recollateralize is paused");
        var_c = 0x19;
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).sts_price(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).Unresolved_18160ddd(var_c); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).global_collateral_ratio(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).globalCollateralValue(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(!0x01 == (bytes1(recollateralizePaused / 0x0100000000)));
        uint256 var_j = arg0 * 0x01;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_a02f6c89(var_j); // delegatecall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x40), "");
        var_e = 0x40 + var_e;
        require(0x01, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        var_r = 0;
        require(0x01, "SafeMath: addition overflow");
        require(!((bonus_rate + 0x0f4240) < 0x0f4240), "SafeMath: addition overflow");
        var_e = 0x40 + var_e;
        require(!(recollateralizePausedb > (bonus_rate + 0x0f4240)), "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: subtraction overflow");
        require(var_z, "Slippage limit reached");
        require(var_z, "Slippage limit reached");
        require(((bonus_rate + 0x0f4240) - recollateralizePausedb) * (var_z) / (var_z) == ((bonus_rate + 0x0f4240) - recollateralizePausedb), "Slippage limit reached");
        var_e = 0x40 + var_e;
        require(var_e.length, "Slippage limit reached");
        require(var_e.length, "Slippage limit reached");
        require(!(arg1 > (((bonus_rate + 0x0f4240) - recollateralizePausedb) * (var_z) / var_e.length)), "Slippage limit reached");
        address var_y = address(msg.sender);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).{ value: var_r ether }Unresolved_23b872dd(var_y); // call
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(var_e.length == var_e.length);
        var_ac = address(msg.sender);
        require(address(recollateralizePausedi).code.length);
        (bool success, bytes memory ret0) = address(recollateralizePausedi).{ value: var_r ether }Unresolved_b4f56b26(var_ac); // call
        emit RecollateralizeSTC(address(msg.sender), var_e.length / 0x01);
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        address var_k = address(store_j);
        var_l = 0x0f4240;
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).consult(var_k, var_l); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(var_e.length, "");
        var_e = 0x40 + var_e;
        require(var_e.length, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(var_e.length);
        var_n = arg0 * 0x01;
        var_s = var_r / var_e.length;
        var_w = var_e.length;
        var_y = var_e.length;
        var_ac = var_e.length;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_a02f6c89(var_n, var_s, var_w, var_y, var_ac); // delegatecall
        require(var_e.length, "SafeMath: multiplication overflow");
        require(((0x0f4240 * var_e.length) / var_e.length) == 0x0f4240, "SafeMath: multiplication overflow");
    }
    
    /// @custom:selector    0x12ace5a2
    /// @custom:signature   collectRedemption() public payable
    function collectRedemption() public payable {
        address var_a = msg.sender;
        require(!((redemption_delay + storage_map_l[var_a]) < storage_map_l[var_a]), "SafeMath: addition overflow");
        require(!((redemption_delay + storage_map_l[var_a]) > block.number), "Must wait for redemption_delay blocks before collecting redemption");
        var_a = msg.sender;
        require(!storage_map_l[var_a], "");
        var_a = msg.sender;
        storage_map_l[var_a] = 0;
        uint256 var_i = 0x40 + var_i;
        require(!(storage_map_l[var_a] > unclaimedPoolSTS), "");
        require(!(0 > var_i.length), "");
        require(!(0x20 > var_i.length), "SafeMath: subtraction overflow");
        unclaimedPoolSTS = unclaimedPoolSTS - storage_map_l[var_a];
        var_a = msg.sender;
        require(!storage_map_l[var_a]);
        require(!0x01 == 0x01);
        require(!0 == 0x01);
        address var_f = address(msg.sender);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).{ value: storage_map_l[var_a] ether }Unresolved_a9059cbb(var_f); // call
        var_i = var_i + (uint248(ret0.length + 0x1f));
        require(!((var_i + ret0.length) - var_i) < 0x20);
        require(var_i.length == var_i.length);
        emit CollectRedemption(address(msg.sender), 0);
        emit CollectRedemption(address(msg.sender), 0);
        var_f = address(msg.sender);
        require(address(recollateralizePausedi).code.length);
        (bool success, bytes memory ret0) = address(recollateralizePausedi).{ value: storage_map_l[var_a] ether }many_msg_babbage(var_f); // call
        var_i = var_i + (uint248(ret0.length + 0x1f));
        require(!((var_i + ret0.length) - var_i) < 0x20);
        require(var_i.length == var_i.length);
    }
    
    /// @custom:selector    0xb965bf6b
    /// @custom:signature   mint1t1STC(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint1t1STC(uint256 arg0, uint256 arg1) public payable {
        require(!(bytes1(recollateralizePaused)), "Minting is paused");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).global_collateral_ratio(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Collateral ratio must be >= 1");
        require(!(var_e.length < 0x0f4240), "Collateral ratio must be >= 1");
        address var_c = address(this);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).Unresolved_70a08231(var_c); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        var_e = 0x40 + var_e;
        require(!(unclaimedPoolCollateral > var_e.length), "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: subtraction overflow");
        var_m = 0;
        require(!((arg0 + (var_e.length - unclaimedPoolCollateral)) < (var_e.length - unclaimedPoolCollateral)), "SafeMath: addition overflow");
        require(!(arg0 + (var_e.length - unclaimedPoolCollateral)) > pool_ceiling);
        require(!0x01 == (bytes1(recollateralizePaused / 0x0100000000)));
        var_k = getCollateralPrice;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_7e55a929(var_k); // delegatecall
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        var_l = address(store_j);
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).Unresolved_3ddac953(var_l); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(var_e.length, "");
        var_e = 0x40 + var_e;
        require(var_e.length, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(var_e.length);
        uint256 var_t = var_m / var_e.length;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_7e55a929(var_t); // delegatecall
        require(var_e.length, "SafeMath: multiplication overflow");
        require(((0x0f4240 * var_e.length) / var_e.length) == 0x0f4240, "SafeMath: multiplication overflow");
    }
    
    /// @custom:selector    0xf61adab2
    /// @custom:signature   availableExcessCollatDV() public payable returns (uint256)
    function availableExcessCollatDV() public payable returns (uint256) {
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).Unresolved_18160ddd(var_b); // staticcall
        uint256 var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).global_collateral_ratio(); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).globalCollateralValue(); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!(((var_c + ret0.length) - var_c) < 0x20), "");
        require(!(var_c.length > 0x0f4240), "");
        require(var_c.length, "");
        var_c = 0x40 + var_c;
        require(0x0f4240, "");
        require(!(0 > var_c.length), "");
        require(!(0x20 > var_c.length), "SafeMath: division by zero");
        require(0x0f4240, "SafeMath: multiplication overflow");
        require(!(var_c.length > 0), "SafeMath: multiplication overflow");
        return 0;
        var_c = 0x40 + var_c;
        require(!(0 > var_c.length), "SafeMath: multiplication overflow");
        return var_c.length - 0;
        require(var_c.length, "SafeMath: multiplication overflow");
        require(((var_c.length * var_c.length) / var_c.length) == var_c.length, "SafeMath: multiplication overflow");
        var_c = 0x40 + var_c;
        require(0x0f4240, "SafeMath: multiplication overflow");
        require(0x0f4240, "SafeMath: multiplication overflow");
        if (var_c.length) {
        }
    }
    
    /// @custom:selector    0xdaa50485
    /// @custom:signature   toggleRedeeming() public payable
    function toggleRedeeming() public payable {
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        recollateralizePaused = (0x0100 * (!bytes1(recollateralizePaused / 0x0100))) | (uint248(recollateralizePaused));
    }
    
    /// @custom:selector    0x50c9ecd9
    /// @custom:signature   toggleBuyBack() public payable
    function toggleBuyBack() public payable {
        require(msg.sender == (address(store_b)), "You are not the owner or the governance timelock");
        require(msg.sender == (address(store_c)), "You are not the owner or the governance timelock");
        recollateralizePaused = (0x01000000 * (!bytes1(recollateralizePaused / 0x01000000))) | (uint248(recollateralizePaused));
    }
    
    /// @custom:selector    0x9010d07c
    /// @custom:signature   getRoleMember(bytes32 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getRoleMember(bytes32 arg0, uint256 arg1) public view returns (address) {
        uint256 var_a = arg0;
        uint256 var_b = 0;
        require(arg1 < storage_map_l[var_a], "EnumerableSet: index out of bounds");
        require(arg1 < (storage_map_p[var_a]), "EnumerableSet: index out of bounds");
        var_a = var_b + keccak256(var_a);
        return address(storage_map_aj[var_a]);
    }
    
    /// @custom:selector    0x129dbe7f
    /// @custom:signature   redeem1t1STC(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function redeem1t1STC(uint256 arg0, uint256 arg1) public payable {
        require(!(bytes1(recollateralizePaused / 0x0100)), "Redeeming is paused");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).global_collateral_ratio(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(var_e.length == 0x0f4240, "");
        var_e = 0x40 + var_e;
        require(0x01, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(0x01);
        require(!0x01 == (bytes1(recollateralizePaused / 0x0100000000)));
        var_i = getCollateralPrice;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_39572e0b(var_i); // delegatecall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        var_j = address(this);
        require(address(store_f).code.length);
        (bool success, bytes memory ret0) = address(store_f).Unresolved_70a08231(var_j); // staticcall
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        var_j = address(store_j);
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).Unresolved_3ddac953(var_j); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(var_e.length, "");
        var_e = 0x40 + var_e;
        require(var_e.length, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        var_t = 0;
        require(var_e.length);
        uint256 var_r = var_t / var_e.length;
        require(address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).code.length);
        (bool success, bytes memory ret0) = address(0x6830ec5b246a23a8057328aa351c1ce62bfdb9c5).Unresolved_39572e0b(var_r); // delegatecall
        require(var_e.length, "SafeMath: multiplication overflow");
        require(((0x0f4240 * var_e.length) / var_e.length) == 0x0f4240, "SafeMath: multiplication overflow");
    }
    
    /// @custom:selector    0x01b80621
    /// @custom:signature   buyBackSTS(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function buyBackSTS(uint256 arg0, uint256 arg1) public payable {
        require(!(bytes1(recollateralizePaused / 0x01000000)), "Buyback is paused");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).sts_price(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).Unresolved_18160ddd(var_k); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).global_collateral_ratio(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(address(store_e / 0x01).code.length);
        (bool success, bytes memory ret0) = address(store_e / 0x01).globalCollateralValue(); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "");
        require(!(var_e.length > 0x0f4240), "");
        require(var_e.length, "");
        var_e = 0x40 + var_e;
        require(0x0f4240, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(0x0f4240, "");
        require(!(var_e.length > 0), "");
        require(!(0x01 == (bytes1(recollateralizePaused / 0x0100000000))), "");
        var_e = 0x40 + var_e;
        require(!(recollateralizePauseda > 0x0f4240), "");
        require(var_e.length, "");
        require(var_aa, "");
        require(var_aa, "");
        require(var_ab * (var_aa) / (var_aa) == (var_ab), "");
        var_e = 0x40 + var_e;
        require(0x0f4240, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(0x0f4240, "You are trying to buy back more than the excess!");
        require(!((var_ab * (var_aa) / 0x0f4240) > var_e.length), "You are trying to buy back more than the excess!");
        require(var_ab * (var_aa) / 0x0f4240, "");
        require(var_ab * (var_aa) / 0x0f4240, "");
        require((0x0f4240 * (var_ab * (var_aa) / 0x0f4240)) / (var_ab * (var_aa) / 0x0f4240) == 0x0f4240, "");
        var_e = 0x40 + var_e;
        require(var_al, "");
        require(var_al, "");
        require(!(0 > var_e.length), "");
        require(!(0x20 > var_e.length), "SafeMath: division by zero");
        require(address(store_e).code.length);
        (bool success, bytes memory ret0) = address(store_e).eth_usd_price(); // staticcall
        var_e = 0x40 + var_e;
        if (!0 > var_e.length) {
        }
    }
    
    /// @custom:selector    0x1d0a7ea7
    /// @custom:signature   redeemSTSBalances(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function redeemSTSBalances(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return storage_map_v[var_b];
    }
    
    /// @custom:selector    0xabae2c4c
    /// @custom:signature   lastRedeemed(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function lastRedeemed(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return storage_map_v[var_b];
    }
}

ABI

[
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_88d42cf2",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "availableExcessCollatDV",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "bonus_rate",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "buyBackPaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "buyBackSTS",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "buyback_fee",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "collatDollarBalance",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "collat_eth_oracle_address",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "collateralPricePaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "collectRedemption",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getCollateralPrice",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleMemberCount",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "grantRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "lastRedeemed",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint1t1STC",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "mintFractionalSTC",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "mintPaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "minting_fee",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pausedPrice",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pool_ceiling",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "recollat_fee",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "recollateralizePaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "recollateralizeSTC",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "redeem1t1STC",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "redeemCollateralBalances",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "redeemFractionalSTC",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "redeemPaused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "redeemSTSBalances",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "redemption_delay",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "redemption_fee",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "revokeRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setFeeAddress",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setPoolParameters",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      },
      {
        "name": "arg6",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setTimelock",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "toggleBuyBack",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "toggleCollateralPrice",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "toggleMinting",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "toggleRecollateralize",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "toggleRedeeming",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "unclaimedPoolCollateral",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "unclaimedPoolSTS",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "CollectRedemption",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RecollateralizeSTC",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (18)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)