Contract 0x87ce5944fe7bbbe83220297bd478afe8e476db65

Contract Overview

Balance:
0 BNB
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x8007025d235d27bdcbff800bf264f15a15df76b0727e622c2ea9bd5edafd518a0x6080604067881432021-03-04 6:47:26202 days 19 hrs ago0x20000b9b01e93a39db9d286e9264eff7f2af16e9 IN  Contract Creation0 BNB0.01389308
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x1edfd358b9948fa35cef9569ed0b7013a1def5162046bca9728a00015de6820d87228062021-05-10 15:05:09135 days 11 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xc1609106e29836e18372aca5d111a46ff61552e42ba9b2f449ced129290cb04787227052021-05-10 15:00:06135 days 11 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x03e26b07ab48ba7117733f1d34068411b57cdebde55e746247a43a4374840e2387219872021-05-10 14:24:12135 days 11 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x8d4d8355e22a83f3aaaef751afb824be3661b040b4b1228b186ca53da0f8ee2487210652021-05-10 13:38:06135 days 12 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x1c0aac890cdf0e328dc514fbd7a6fcdaa26d07154ea4d988f28c8e693f4612bd87207052021-05-10 13:20:06135 days 12 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xd7da5803f0cc6ba8d28de31574cd5fde66e6ef6dd5d647e68a157ec91ef1f46287204852021-05-10 13:09:06135 days 13 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xd70e4e5a932b7e80911a665ebd88981980040d5e223b108754d4bc49ed79ff1387202852021-05-10 12:59:06135 days 13 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x1ca8cd964d4b9c8dcd8363667ebce11d386a09f6e16e48057790c119cffd88b387191472021-05-10 12:02:12135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xa32efa3deaffc30419033dff9f208e19bc202c452b7e4571a1c54535da090b9187191452021-05-10 12:02:06135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xe3f578f1fc185aa9d0a39d3b7dd595d47ee85411c1466b7b057e323215440e8387187072021-05-10 11:40:12135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x4a8205a291f8cf7dd4eff0c9e9338432200f63151a77762e0684794580bf016587187052021-05-10 11:40:06135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xd599676d9bec986dd36355cd607c7256370e1944fae25449ef38cbf0ba0d82f687185662021-05-10 11:33:09135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x349a902ad027e7c56bc6440bbfd7c9b40bd523879c41776445e6495111f5c68f87185662021-05-10 11:33:09135 days 14 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x4d1db0ddb9facbdede775ff705dc9648e98a8975f37170e92427a7e07154bcb587180852021-05-10 11:09:06135 days 15 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xcfe31f471017690d47a9b60c2f034b8a99fcbd88dc65e71b04074020edc06d8287178862021-05-10 10:59:09135 days 15 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x59da9b62048bc1861cc8925271dd770432466f1de3d483db75819ab9c767acdd87163852021-05-10 9:44:06135 days 16 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x683f3f233c54fc8e817a05a4c3b7657ba33c3a2a0c51a9b7dee577d94d31b79a87161462021-05-10 9:32:09135 days 16 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xa9bf543d98c4bedac4327e10713b863bb3b9a4e95ca46d7e5c3f32aaec000f0387157852021-05-10 9:14:06135 days 17 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x6244c681d2093dc7e3aa69064bebd8f0d4a8b2341e47e118d4b59ee8bca72cbe87149052021-05-10 8:30:06135 days 17 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x3c36980830e7c65592f001b8b759178d9f2ec9925585347d7b8662586adec89d87143862021-05-10 8:04:09135 days 18 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x06b579d6077d218b5350cac072ec7bc20e0b59e6c04214ee39ba61609139c6b787140452021-05-10 7:47:06135 days 18 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0xa9fe9c51bb7e87a2a414d27116b95e3e4eeef756eac84fcdc72245235bbe820187113682021-05-10 5:33:15135 days 20 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x68cc637d5bd359dfca76ee7ccc27345b003224ed7d4e9a151462c3d3dd55119487113662021-05-10 5:33:09135 days 20 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x1ef1bb18ede4a8e87fe8c32f0bf2abd6750a4e236f79fbfe3f0e021b881735ba87109262021-05-10 5:11:09135 days 21 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
0x83c122262dea26e93b64dc0397a1ca5c3c4c6b681ec359df79de4d73656d4b3287103072021-05-10 4:40:12135 days 21 hrs ago 0xe515b28bda1a24583c2870b65d698ad5afe0c989 0x87ce5944fe7bbbe83220297bd478afe8e476db650 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SystemSettings

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-04
*/

// File: @openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMathUpgradeable {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts-upgradeable/proxy/Initializable.sol


// solhint-disable-next-line compiler-version


/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 * 
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 * 
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {

    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        // solhint-disable-next-line no-inline-assembly
        assembly { cs := extcodesize(self) }
        return cs == 0;
    }
}

// File: @openzeppelin/contracts-upgradeable/GSN/ContextUpgradeable.sol




/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
    uint256[50] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol




/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
    uint256[49] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol



/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: contracts/utils/DecimalMath.sol



/// @dev Implements simple fixed point math add, sub, mul and div operations.
/// @author Alberto Cuesta Cañada
library DecimalMath {
    using SafeMathUpgradeable for uint256;

    /// @dev Returns 1 in the fixed point representation, with `decimals` decimals.
    function unit(uint8 decimals) internal pure returns (uint256) {
        return 10**uint256(decimals);
    }

    /// @dev Adds x and y, assuming they are both fixed point with 18 decimals.
    function addd(uint256 x, uint256 y) internal pure returns (uint256) {
        return x.add(y);
    }

    /// @dev Subtracts y from x, assuming they are both fixed point with 18 decimals.
    function subd(uint256 x, uint256 y) internal pure returns (uint256) {
        return x.sub(y);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with 18 digits.
    function muld(uint256 x, uint256 y) internal pure returns (uint256) {
        return muld(x, y, 18);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with `decimals` digits.
    function muld(
        uint256 x,
        uint256 y,
        uint8 decimals
    ) internal pure returns (uint256) {
        return x.mul(y).div(unit(decimals));
    }

    /// @dev Divides x between y, assuming they are both fixed point with 18 digits.
    function divd(uint256 x, uint256 y) internal pure returns (uint256) {
        return divd(x, y, 18);
    }

    /// @dev Divides x between y, assuming they are both fixed point with `decimals` digits.
    function divd(
        uint256 x,
        uint256 y,
        uint8 decimals
    ) internal pure returns (uint256) {
        return x.mul(unit(decimals)).div(y);
    }
}

// File: contracts/utils/Decimal.sol




library Decimal {
    using DecimalMath for uint256;
    using SafeMathUpgradeable for uint256;

    struct decimal {
        uint256 d;
    }

    function zero() internal pure returns (decimal memory) {
        return decimal(0);
    }

    function one() internal pure returns (decimal memory) {
        return decimal(DecimalMath.unit(18));
    }

    function toUint(decimal memory x) internal pure returns (uint256) {
        return x.d;
    }

    function modD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        return decimal(x.d.mul(DecimalMath.unit(18)) % y.d);
    }

    function cmp(decimal memory x, decimal memory y) internal pure returns (int8) {
        if (x.d > y.d) {
            return 1;
        } else if (x.d < y.d) {
            return -1;
        }
        return 0;
    }

    /// @dev add two decimals
    function addD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.add(y.d);
        return t;
    }

    /// @dev subtract two decimals
    function subD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.sub(y.d);
        return t;
    }

    /// @dev multiple two decimals
    function mulD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.muld(y.d);
        return t;
    }

    /// @dev multiple a decimal by a uint256
    function mulScalar(decimal memory x, uint256 y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.mul(y);
        return t;
    }

    /// @dev divide two decimals
    function divD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.divd(y.d);
        return t;
    }

    /// @dev divide a decimal by a uint256
    function divScalar(decimal memory x, uint256 y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.div(y);
        return t;
    }
}

// File: @openzeppelin/contracts-upgradeable/math/SignedSafeMathUpgradeable.sol



/**
 * @title SignedSafeMath
 * @dev Signed math operations with safety checks that revert on error.
 */
library SignedSafeMathUpgradeable {
    int256 constant private _INT256_MIN = -2**255;

    /**
     * @dev Returns the multiplication of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");

        int256 c = a * b;
        require(c / a == b, "SignedSafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two signed integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        require(b != 0, "SignedSafeMath: division by zero");
        require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");

        int256 c = a / b;

        return c;
    }

    /**
     * @dev Returns the subtraction of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");

        return c;
    }

    /**
     * @dev Returns the addition of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");

        return c;
    }
}

// File: contracts/utils/SignedDecimalMath.sol



/// @dev Implements simple signed fixed point math add, sub, mul and div operations.
library SignedDecimalMath {
    using SignedSafeMathUpgradeable for int256;

    /// @dev Returns 1 in the fixed point representation, with `decimals` decimals.
    function unit(uint8 decimals) internal pure returns (int256) {
        return int256(10**uint256(decimals));
    }

    /// @dev Adds x and y, assuming they are both fixed point with 18 decimals.
    function addd(int256 x, int256 y) internal pure returns (int256) {
        return x.add(y);
    }

    /// @dev Subtracts y from x, assuming they are both fixed point with 18 decimals.
    function subd(int256 x, int256 y) internal pure returns (int256) {
        return x.sub(y);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with 18 digits.
    function muld(int256 x, int256 y) internal pure returns (int256) {
        return muld(x, y, 18);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with `decimals` digits.
    function muld(
        int256 x,
        int256 y,
        uint8 decimals
    ) internal pure returns (int256) {
        return x.mul(y).div(unit(decimals));
    }

    /// @dev Divides x between y, assuming they are both fixed point with 18 digits.
    function divd(int256 x, int256 y) internal pure returns (int256) {
        return divd(x, y, 18);
    }

    /// @dev Divides x between y, assuming they are both fixed point with `decimals` digits.
    function divd(
        int256 x,
        int256 y,
        uint8 decimals
    ) internal pure returns (int256) {
        return x.mul(unit(decimals)).div(y);
    }
}

// File: contracts/utils/SignedDecimal.sol





library SignedDecimal {
    using SignedDecimalMath for int256;
    using SignedSafeMathUpgradeable for int256;

    struct signedDecimal {
        int256 d;
    }

    function zero() internal pure returns (signedDecimal memory) {
        return signedDecimal(0);
    }

    function toInt(signedDecimal memory x) internal pure returns (int256) {
        return x.d;
    }

    function isNegative(signedDecimal memory x) internal pure returns (bool) {
        if (x.d < 0) {
            return true;
        }
        return false;
    }

    function abs(signedDecimal memory x) internal pure returns (Decimal.decimal memory) {
        Decimal.decimal memory t;
        if (x.d < 0) {
            t.d = uint256(0 - x.d);
        } else {
            t.d = uint256(x.d);
        }
        return t;
    }

    /// @dev add two decimals
    function addD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.add(y.d);
        return t;
    }

    /// @dev subtract two decimals
    function subD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.sub(y.d);
        return t;
    }

    /// @dev multiple two decimals
    function mulD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.muld(y.d);
        return t;
    }

    /// @dev multiple a signedDecimal by a int256
    function mulScalar(signedDecimal memory x, int256 y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.mul(y);
        return t;
    }

    /// @dev divide two decimals
    function divD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.divd(y.d);
        return t;
    }

    /// @dev divide a signedDecimal by a int256
    function divScalar(signedDecimal memory x, int256 y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.div(y);
        return t;
    }
}

// File: contracts/interface/IExchange.sol

pragma experimental ABIEncoderV2;




interface IExchange {
    /**
     * @notice asset direction, used in getInputPrice, getOutputPrice, swapInput and swapOutput
     * @param ADD_TO_AMM add asset to Amm
     * @param REMOVE_FROM_AMM remove asset from Amm
     */
    enum Dir {ADD_TO_AMM, REMOVE_FROM_AMM}

    struct LiquidityChangedSnapshot {
        SignedDecimal.signedDecimal cumulativeNotional;
        // the base/quote reserve of amm right before liquidity changed
        Decimal.decimal quoteAssetReserve;
        Decimal.decimal baseAssetReserve;
        // total position size owned by amm after last snapshot taken
        // `totalPositionSize` = currentBaseAssetReserve - lastLiquidityChangedHistoryItem.baseAssetReserve + prevTotalPositionSize
        SignedDecimal.signedDecimal totalPositionSize;
    }

    function swapInput(
        Dir _dir,
        Decimal.decimal calldata _quoteAssetAmount,
        Decimal.decimal calldata _baseAssetAmountLimit
    ) external returns (Decimal.decimal memory);

    function swapOutput(
        Dir _dir,
        Decimal.decimal calldata _baseAssetAmount,
        Decimal.decimal calldata _quoteAssetAmountLimit,
        bool _skipFluctuationCheck
    ) external returns (Decimal.decimal memory);

    function migrateLiquidity(Decimal.decimal calldata _liquidityMultiplier, Decimal.decimal calldata _priceLimitRatio)
        external;

    function shutdown() external;

    function settleFunding() external returns (SignedDecimal.signedDecimal memory);

    function calcFee(Decimal.decimal calldata _quoteAssetAmount) external view returns (Decimal.decimal memory);

    function calcBaseAssetAfterLiquidityMigration(
        SignedDecimal.signedDecimal memory _baseAssetAmount,
        Decimal.decimal memory _fromQuoteReserve,
        Decimal.decimal memory _fromBaseReserve
    ) external view returns (SignedDecimal.signedDecimal memory);

    function getInputTwap(Dir _dir, Decimal.decimal calldata _quoteAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getOutputTwap(Dir _dir, Decimal.decimal calldata _baseAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getInputPrice(Dir _dir, Decimal.decimal calldata _quoteAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getOutputPrice(Dir _dir, Decimal.decimal calldata _baseAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getInputPriceWithReserves(
        Dir _dir,
        Decimal.decimal memory _quoteAssetAmount,
        Decimal.decimal memory _quoteAssetPoolAmount,
        Decimal.decimal memory _baseAssetPoolAmount
    ) external pure returns (Decimal.decimal memory);

    function getOutputPriceWithReserves(
        Dir _dir,
        Decimal.decimal memory _baseAssetAmount,
        Decimal.decimal memory _quoteAssetPoolAmount,
        Decimal.decimal memory _baseAssetPoolAmount
    ) external pure returns (Decimal.decimal memory);

    function getSpotPrice() external view returns (Decimal.decimal memory);

    function getLiquidityHistoryLength() external view returns (uint256);

    // overridden by state variable
    function quoteAsset() external view returns (IERC20Upgradeable);

    function open() external view returns (bool);

    // can not be overridden by state variable due to type `Deciaml.decimal`
    function getSettlementPrice() external view returns (Decimal.decimal memory);

    function getBaseAssetDeltaThisFundingPeriod() external view returns (SignedDecimal.signedDecimal memory);

    function getCumulativeNotional() external view returns (SignedDecimal.signedDecimal memory);

    function getMaxHoldingBaseAsset() external view returns (Decimal.decimal memory);

    function getOpenInterestNotionalCap() external view returns (Decimal.decimal memory);

    function getLiquidityChangedSnapshots(uint256 i) external view returns (LiquidityChangedSnapshot memory);

    function mint(address account, uint256 amount) external;

    function burn(address account, uint256 amount) external;

    function getPositionSize() external view returns (Decimal.decimal memory, Decimal.decimal memory);

    function getMMUnrealizedPNL(Decimal.decimal memory _baseAssetReserve, Decimal.decimal memory _quoteAssetReserve)
        external
        view
        returns (SignedDecimal.signedDecimal memory);

    function moveAMMPriceToOracle(uint256 _oraclePrice, bytes32 _priceFeedKey) external;

    function setPriceFeed(address _priceFeed) external;

    function getReserve() external view returns (Decimal.decimal memory, Decimal.decimal memory);
}

// File: contracts/interface/IInsuranceFund.sol




interface IInsuranceFund {
    function withdraw(Decimal.decimal calldata _amount)
        external
        returns (Decimal.decimal memory badDebt);

    function setExchange(IExchange _exchange) external;

    function setBeneficiary(address _beneficiary) external;
}

// File: contracts/interface/ISystemSettings.sol





interface ISystemSettings {
    function initMarginRatio() external view returns (Decimal.decimal memory);

    function maintenanceMarginRatio() external view returns (Decimal.decimal memory);

    function liquidationFeeRatio() external view returns (Decimal.decimal memory);

    function maxliquidationFee() external view returns (Decimal.decimal memory);

    function insuranceFundFeeRatio() external view returns (Decimal.decimal memory);

    function lpWithdrawFeeRatio() external view returns (Decimal.decimal memory);

    function overnightFeeRatio() external view returns (Decimal.decimal memory);

    function overnightFeeLpShareRatio() external view returns (Decimal.decimal memory);

    function fundingFeeLpShareRatio() external view returns (Decimal.decimal memory);

    function overnightFeePeriod() external view returns (uint256);

    function isExistedExchange(IExchange _exchange) external view returns (bool);

    function getAllExchanges() external view returns (IExchange[] memory);

    function getInsuranceFund(IExchange _exchange) external view returns (IInsuranceFund);

    function setNextOvernightFeeTime(IExchange _exchange) external;

    function nextOvernightFeeTime(address _exchange) external view returns (uint256);
}

// File: contracts/SystemSettings.sol


// Inheritance





// Libraries


contract SystemSettings is OwnableUpgradeable, ISystemSettings {
    using Decimal for Decimal.decimal;
    using SafeMathUpgradeable for uint256;
    //
    // EVENTS
    //
    event MarginRatioChanged(uint256 marginRatio);
    event LiquidationFeeRatioChanged(uint256 liquidationFeeRatio);
    event MaxLiquidationFeeChanged(uint256 maxliquidationFee);
    event InsuranceFundFeeRatioChanged(uint256 insuranceFundFeeRatio);
    event LpWithdrawFeeRatioChanged(uint256 lpWithdrawFeeRatio);
    event OvernightFeeRatioChanged(uint256 overnightFeeRatio);
    event OvernightFeeLpShareRatioChanged(uint256 overnightFeeLpShareRatio);
    event FundingFeeLpShareRatioChanged(uint256 fundingFeeLpShareRatio);
    event OvernightFeePeriodChanged(uint256 overnightFeePeriod);

    // only admin
    Decimal.decimal private _initMarginRatio;

    // only admin
    Decimal.decimal private _maintenanceMarginRatio;

    // only admin
    Decimal.decimal private _liquidationFeeRatio;

    // only admin
    Decimal.decimal private _maxliquidationFee;

    // only admin
    Decimal.decimal private _insuranceFundFeeRatio;

    // only admin
    Decimal.decimal private _lpWithdrawFeeRatio;

    // only admin
    Decimal.decimal private _overnightFeeRatio;

    // only admin
    Decimal.decimal private _overnightFeeLpShareRatio;

    // only admin
    Decimal.decimal private _fundingFeeLpShareRatio;

    // only admin
    bool public _paused;

    struct ExchangeMap {
        IInsuranceFund insuranceFund;
        bool existed;
        uint256 _nextOvernightFeeTime;
    }

    mapping(address => ExchangeMap) private exchangeMap;
    IExchange[] private exchanges;

    //only admin
    uint256 private _overnightFeePeriod;

    address public _cfd;
    //**********************************************************//
    //    Can not change the order of above state variables     //
    //**********************************************************//

    //◥◤◥◤◥◤◥◤◥◤◥◤◥◤◥◤ add state variables below ◥◤◥◤◥◤◥◤◥◤◥◤◥◤◥◤//

    //◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣ add state variables above ◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣//
    uint256[50] private __gap;

    //
    // MODIFIERS
    //
    modifier onlyCFD() {
        require(msg.sender == _cfd, "only cfd");
        _;
    }

    //
    // External
    //
    function initialize(
        address cfd,
        uint256 initMarginRatio,
        uint256 maintenanceMarginRatio,
        uint256 liquidationFeeRatio,
        uint256 maxliquidationFee,
        uint256 insuranceFundFeeRatio,
        uint256 lpWithdrawFeeRatio,
        uint256 overnightFeeRatio,
        uint256 overnightFeeLpShareRatio,
        uint256 fundingFeeLpShareRatio,
        uint256 overnightFeePeriod
    ) public initializer {
        __Ownable_init();

        _cfd = cfd;
        _initMarginRatio = Decimal.decimal(initMarginRatio);
        _maintenanceMarginRatio = Decimal.decimal(maintenanceMarginRatio);
        _liquidationFeeRatio = Decimal.decimal(liquidationFeeRatio);
        _maxliquidationFee = Decimal.decimal(maxliquidationFee);
        _insuranceFundFeeRatio = Decimal.decimal(insuranceFundFeeRatio);
        _lpWithdrawFeeRatio = Decimal.decimal(lpWithdrawFeeRatio);
        _overnightFeeRatio = Decimal.decimal(overnightFeeRatio);
        _overnightFeeLpShareRatio = Decimal.decimal(overnightFeeLpShareRatio);
        _fundingFeeLpShareRatio = Decimal.decimal(fundingFeeLpShareRatio);
        _overnightFeePeriod = overnightFeePeriod;
    }

    /**
     * @notice set CFD dependency
     * @dev only owner can call
     * @param cfd address
     */

    function setCFD(address cfd) external onlyOwner {
        require(cfd != address(0), "empty address");
        _cfd = cfd;
    }

    /**
     * @notice set liquidation fee ratio
     * @dev only owner can call
     * @param liquidationFeeRatio new liquidation fee ratio in 18 digits
     */
    function setLiquidationFeeRatio(Decimal.decimal memory liquidationFeeRatio) public onlyOwner {
        _liquidationFeeRatio = liquidationFeeRatio;
        emit LiquidationFeeRatioChanged(liquidationFeeRatio.toUint());
    }

    /**
     * @notice set max liqudiation fee
     * @dev only owner can call
     * @param maxliquidationFee new liquidation fee ratio in 18 digits
     */
    function setMaxLiquidationFee(Decimal.decimal memory maxliquidationFee) public onlyOwner {
        _maxliquidationFee = maxliquidationFee;
        emit MaxLiquidationFeeChanged(maxliquidationFee.toUint());
    }

    /**
     * @notice set init margin ratio
     * @dev only owner can call
     * @param initMarginRatio new init margin ratio in 18 digits
     */
    function setInitMarginRatio(Decimal.decimal memory initMarginRatio) public onlyOwner {
        _initMarginRatio = initMarginRatio;
    }

    /**
     * @notice set maintenance margin ratio
     * @dev only owner can call
     * @param maintenanceMarginRatio new maintenance margin ratio in 18 digits
     */
    function setMaintenanceMarginRatio(Decimal.decimal memory maintenanceMarginRatio) public onlyOwner {
        _maintenanceMarginRatio = maintenanceMarginRatio;
        emit MarginRatioChanged(maintenanceMarginRatio.toUint());
    }

    /**
     * @notice set insurancefund fee  ratio
     * @dev only owner can call
     * @param insuranceFundFeeRatio new insurance fund ratio in 18 digits
     */
    function setInsuranceFundFeeRatio(Decimal.decimal memory insuranceFundFeeRatio) public onlyOwner {
        _insuranceFundFeeRatio = insuranceFundFeeRatio;
        emit InsuranceFundFeeRatioChanged(_insuranceFundFeeRatio.toUint());
    }

    /**
     * @notice set lpwithdraw fee  ratio
     * @dev only owner can call
     * @param lpWithdrawFeeRatio new lp withdraw fee ratio in 18 digits
     */
    function setLpWithdrawFeeRatio(Decimal.decimal memory lpWithdrawFeeRatio) public onlyOwner {
        _lpWithdrawFeeRatio = lpWithdrawFeeRatio;
        emit LpWithdrawFeeRatioChanged(_lpWithdrawFeeRatio.toUint());
    }

    /**
     * @notice set overnight fee ratio
     * @dev only owner can call
     * @param overnightFeeRatio new overnight fee ratio in 18 digits
     */
    function setOvernightFeeRatio(Decimal.decimal memory overnightFeeRatio) public onlyOwner {
        _overnightFeeRatio = overnightFeeRatio;
        emit OvernightFeeRatioChanged(_overnightFeeRatio.toUint());
    }

    /**
     * @notice set overnight fee period
     * @dev only owner can call
     * @param overnightFeePeriod new overnight fee period
     */
    function setOvernightFeePeriod(uint256 overnightFeePeriod) public onlyOwner {
        _overnightFeePeriod = overnightFeePeriod;
        emit OvernightFeeLpShareRatioChanged(_overnightFeeLpShareRatio.toUint());
    }

    /**
     * @notice set overnight fee lp share ratio
     * @dev only owner can call
     * @param overnightFeeLpShareRatio new overnight fee ratio in 18 digits
     */
    function setOvernightFeeLpShareRatio(Decimal.decimal memory overnightFeeLpShareRatio) public onlyOwner {
        _overnightFeeLpShareRatio = overnightFeeLpShareRatio;
        emit OvernightFeeLpShareRatioChanged(_overnightFeeLpShareRatio.toUint());
    }

    /**
     * @notice set
     * @dev only owner can call
     * @param fundingFeeLpShareRatio new funding fee lp share ratio in 18 digits
     */
    function setFundingFeeLpShareRatio(Decimal.decimal memory fundingFeeLpShareRatio) public onlyOwner {
        _fundingFeeLpShareRatio = fundingFeeLpShareRatio;
        emit FundingFeeLpShareRatioChanged(_fundingFeeLpShareRatio.toUint());
    }

    /**
     * @notice set next overnight fee time
     * @param _exchange exchange address
     */
    function setNextOvernightFeeTime(IExchange _exchange) public override onlyCFD {
        require(
            _blockTimestamp() >= exchangeMap[address(_exchange)]._nextOvernightFeeTime,
            "pay overnight fee too early"
        );

        uint256 fundingPeriod = _overnightFeePeriod;
        uint256 fundingBufferPeriod = fundingPeriod.div(2);

        // in order to prevent multiple funding settlement during very short time after network congestion
        uint256 minNextValidOvernightFeeTime = _blockTimestamp().add(fundingBufferPeriod);

        // floor((nextFundingTime + fundingPeriod) / 3600) * 3600
        uint256 nextOvernightFeeTimeOnHourStart =
            exchangeMap[address(_exchange)]._nextOvernightFeeTime.add(fundingPeriod).div(1 hours).mul(1 hours);

        // max(nextFundingTimeOnHourStart, minNextValidFundingTime)
        exchangeMap[address(_exchange)]._nextOvernightFeeTime = nextOvernightFeeTimeOnHourStart >
            minNextValidOvernightFeeTime
            ? nextOvernightFeeTimeOnHourStart
            : minNextValidOvernightFeeTime;
    }

    /**
     * @dev only owner can call
     * @param _exchange IExchange address
     */
    function addExchange(IExchange _exchange, IInsuranceFund _insuranceFund) public onlyOwner {
        require(!isExistedExchange(_exchange), "exchange already added");
        exchangeMap[address(_exchange)].existed = true;
        exchangeMap[address(_exchange)].insuranceFund = _insuranceFund;
        exchanges.push(_exchange);

        exchangeMap[address(_exchange)]._nextOvernightFeeTime = _blockTimestamp()
            .add(_overnightFeePeriod)
            .div(1 hours)
            .mul(1 hours);
    }

    /**
     * @dev only owner can call. no need to call
     * @param _exchange IExchange address
     */
    function removeExchange(IExchange _exchange) external onlyOwner {
        require(isExistedExchange(_exchange), "amm not existed");
        exchangeMap[address(_exchange)].existed = false;
        exchangeMap[address(_exchange)].insuranceFund = IInsuranceFund(address(0));
        uint256 exchangeLength = exchanges.length;
        for (uint256 i = 0; i < exchangeLength; i++) {
            if (exchanges[i] == _exchange) {
                exchanges[i] = exchanges[exchangeLength - 1];
                exchanges.pop();
                break;
            }
        }
    }

    function isExistedExchange(IExchange _exchange) public view override returns (bool) {
        return exchangeMap[address(_exchange)].existed;
    }

    function getAllExchanges() external view override returns (IExchange[] memory) {
        return exchanges;
    }

    function getInsuranceFund(IExchange _exchange) public view override returns (IInsuranceFund) {
        return exchangeMap[address(_exchange)].insuranceFund;
    }

    /**
     * @notice get init margin ratio
     * @return init margin ratio in 18 digits
     */
    function initMarginRatio() external view override returns (Decimal.decimal memory) {
        return _initMarginRatio;
    }

    /**
     * @notice get maintenance margin ratio
     * @return maintenance margin ratio in 18 digits
     */
    function maintenanceMarginRatio() external view override returns (Decimal.decimal memory) {
        return _maintenanceMarginRatio;
    }

    function liquidationFeeRatio() external view override returns (Decimal.decimal memory) {
        return _liquidationFeeRatio;
    }

    function maxliquidationFee() external view override returns (Decimal.decimal memory) {
        return _maxliquidationFee;
    }

    function insuranceFundFeeRatio() external view override returns (Decimal.decimal memory) {
        return _insuranceFundFeeRatio;
    }

    /**
     * @notice get lp withdraw fee ratio
     * @return lp withdraw fee ratio in 18 digits
     */
    function lpWithdrawFeeRatio() external view override returns (Decimal.decimal memory) {
        return _lpWithdrawFeeRatio;
    }

    function overnightFeeRatio() external view override returns (Decimal.decimal memory) {
        return _overnightFeeRatio;
    }

    function overnightFeeLpShareRatio() external view override returns (Decimal.decimal memory) {
        return _overnightFeeLpShareRatio;
    }

    function fundingFeeLpShareRatio() external view override returns (Decimal.decimal memory) {
        return _fundingFeeLpShareRatio;
    }

    function overnightFeePeriod() external view override returns (uint256) {
        return _overnightFeePeriod;
    }

    function nextOvernightFeeTime(address _exchange) external view override returns (uint256) {
        return exchangeMap[address(_exchange)]._nextOvernightFeeTime;
    }

    function _blockTimestamp() internal view virtual returns (uint256) {
        return block.timestamp;
    }
}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fundingFeeLpShareRatio","type":"uint256"}],"name":"FundingFeeLpShareRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"insuranceFundFeeRatio","type":"uint256"}],"name":"InsuranceFundFeeRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"liquidationFeeRatio","type":"uint256"}],"name":"LiquidationFeeRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"lpWithdrawFeeRatio","type":"uint256"}],"name":"LpWithdrawFeeRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"marginRatio","type":"uint256"}],"name":"MarginRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxliquidationFee","type":"uint256"}],"name":"MaxLiquidationFeeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"overnightFeeLpShareRatio","type":"uint256"}],"name":"OvernightFeeLpShareRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"overnightFeePeriod","type":"uint256"}],"name":"OvernightFeePeriodChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"overnightFeeRatio","type":"uint256"}],"name":"OvernightFeeRatioChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"_cfd","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"internalType":"contract IInsuranceFund","name":"_insuranceFund","type":"address"}],"name":"addExchange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fundingFeeLpShareRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllExchanges","outputs":[{"internalType":"contract IExchange[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"getInsuranceFund","outputs":[{"internalType":"contract IInsuranceFund","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initMarginRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"cfd","type":"address"},{"internalType":"uint256","name":"initMarginRatio","type":"uint256"},{"internalType":"uint256","name":"maintenanceMarginRatio","type":"uint256"},{"internalType":"uint256","name":"liquidationFeeRatio","type":"uint256"},{"internalType":"uint256","name":"maxliquidationFee","type":"uint256"},{"internalType":"uint256","name":"insuranceFundFeeRatio","type":"uint256"},{"internalType":"uint256","name":"lpWithdrawFeeRatio","type":"uint256"},{"internalType":"uint256","name":"overnightFeeRatio","type":"uint256"},{"internalType":"uint256","name":"overnightFeeLpShareRatio","type":"uint256"},{"internalType":"uint256","name":"fundingFeeLpShareRatio","type":"uint256"},{"internalType":"uint256","name":"overnightFeePeriod","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"insuranceFundFeeRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"isExistedExchange","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidationFeeRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpWithdrawFeeRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maintenanceMarginRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxliquidationFee","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_exchange","type":"address"}],"name":"nextOvernightFeeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"overnightFeeLpShareRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"overnightFeePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"overnightFeeRatio","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"removeExchange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"cfd","type":"address"}],"name":"setCFD","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"fundingFeeLpShareRatio","type":"tuple"}],"name":"setFundingFeeLpShareRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"initMarginRatio","type":"tuple"}],"name":"setInitMarginRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"insuranceFundFeeRatio","type":"tuple"}],"name":"setInsuranceFundFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"liquidationFeeRatio","type":"tuple"}],"name":"setLiquidationFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"lpWithdrawFeeRatio","type":"tuple"}],"name":"setLpWithdrawFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"maintenanceMarginRatio","type":"tuple"}],"name":"setMaintenanceMarginRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"maxliquidationFee","type":"tuple"}],"name":"setMaxLiquidationFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"setNextOvernightFeeTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"overnightFeeLpShareRatio","type":"tuple"}],"name":"setOvernightFeeLpShareRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"overnightFeePeriod","type":"uint256"}],"name":"setOvernightFeePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"overnightFeeRatio","type":"tuple"}],"name":"setOvernightFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

32124:12878:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33586:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36234:226;;;;;;:::i;:::-;;:::i;:::-;;44714:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;44590:116::-;;;:::i;44016:131::-;;;:::i;:::-;;;;;;;:::i;42688:114::-;;;:::i;:::-;;;;;;;:::i;33909:19::-;;;:::i;:::-;;;;;;;:::i;44292:143::-;;;:::i;42531:149::-;;;;;;:::i;:::-;;:::i;43623:129::-;;;:::i;44443:139::-;;;:::i;37330:233::-;;;;;;:::i;:::-;;:::i;11195:148::-;;;:::i;34607:1198::-;;;;;;:::i;:::-;;:::i;42810:164::-;;;;;;:::i;:::-;;:::i;41303:518::-;;;;;;:::i;:::-;;:::i;43335:139::-;;;:::i;39322:257::-;;;;;;:::i;:::-;;:::i;39740:245::-;;;;;;:::i;:::-;;:::i;10553:79::-;;;:::i;41940:583::-;;;;;;:::i;:::-;;:::i;38155:221::-;;;;;;:::i;:::-;;:::i;38919:218::-;;;;;;:::i;:::-;;:::i;43760:137::-;;;:::i;36631:214::-;;;;;;:::i;:::-;;:::i;37008:138::-;;;;;;:::i;:::-;;:::i;37742:239::-;;;;;;:::i;:::-;;:::i;43482:133::-;;;:::i;44155:129::-;;;:::i;43085:125::-;;;:::i;35928:131::-;;;;;;:::i;:::-;;:::i;40097:1104::-;;;;;;:::i;:::-;;:::i;38545:215::-;;;;;;:::i;:::-;;:::i;11498:244::-;;;;;;:::i;:::-;;:::i;33586:19::-;;;;;;:::o;36234:226::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;;;;;;;;;36338:42;;:20:::1;:42:::0;36396:56:::1;36423:28;36361:19:::0;36423:26:::1;:28::i;:::-;36396:56;;;;;;:::i;:::-;;;;;;;;36234:226:::0;:::o;44714:169::-;-1:-1:-1;;;;;44822:31:0;44795:7;44822:31;;;:11;:31;;;;;:53;;;;44714:169::o;44590:116::-;44679:19;;44590:116;:::o;44016:131::-;44078:22;;:::i;:::-;-1:-1:-1;44113:26:0;;;;;;;;;44120:19;44113:26;;;44016:131;:::o;42688:114::-;42747:18;42785:9;42778:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42778:16:0;;;;;;;;;;;;;;;;;;;;;;;42688:114;:::o;33909:19::-;;;-1:-1:-1;;;;;33909:19:0;;:::o;44292:143::-;44360:22;;:::i;:::-;-1:-1:-1;44395:32:0;;;;;;;;;44402:25;44395:32;;;44292:143;:::o;42531:149::-;-1:-1:-1;;;;;42633:31:0;42609:4;42633:31;;;:11;:31;;;;;:39;-1:-1:-1;;;42633:39:0;;;;;42531:149::o;43623:129::-;43684:22;;:::i;:::-;-1:-1:-1;43719:25:0;;;;;;;;;43726:18;43719:25;;;43623:129;:::o;44443:139::-;44509:22;;:::i;:::-;-1:-1:-1;44544:30:0;;;;;;;;;44551:23;44544:30;;;44443:139;:::o;37330:233::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;37440:48;;:23:::1;:48:::0;37504:51:::1;37523:31;37466:22:::0;37523:29:::1;:31::i;11195:148::-:0;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;11286:6:::1;::::0;11265:40:::1;::::0;11302:1:::1;::::0;-1:-1:-1;;;;;11286:6:0::1;::::0;11265:40:::1;::::0;11302:1;;11265:40:::1;11316:6;:19:::0;;-1:-1:-1;;;;;;11316:19:0::1;::::0;;11195:148::o;34607:1198::-;6969:13;;;;;;;;:33;;;6986:16;:14;:16::i;:::-;6969:50;;;-1:-1:-1;7007:12:0;;;;7006:13;6969:50;6961:109;;;;-1:-1:-1;;;6961:109:0;;;;;;;:::i;:::-;7083:19;7106:13;;;;;;7105:14;7130:101;;;;7165:13;:20;;-1:-1:-1;;;;7165:20:0;;;;;7200:19;7181:4;7200:19;;;7130:101;35069:16:::1;:14;:16::i;:::-;35098:4;:10:::0;;-1:-1:-1;;;;;;35098:10:0::1;-1:-1:-1::0;;;;;35098:10:0;::::1;;::::0;;35138:32:::1;::::0;;::::1;::::0;;::::1;::::0;;;;;;35119:16:::1;:51:::0;;;35207:39;;;;::::1;::::0;;;;;35181:23:::1;:65:::0;;;35280:36;;;;::::1;::::0;;;;;35257:20:::1;:59:::0;;;35348:34;;;;::::1;::::0;;;;;35327:18:::1;:55:::0;;;35418:38;;;;::::1;::::0;;;;;35393:22:::1;:63:::0;;;35489:35;;;;::::1;::::0;;;;;35467:19:::1;:57:::0;;;35556:34;;;;::::1;::::0;;;;;35535:18:::1;:55:::0;;;35629:41;;;;::::1;::::0;;;;;35601:25:::1;:69:::0;;;35707:39;;;;::::1;::::0;;;;;;35681:23:::1;:65:::0;;;35757:19:::1;:40:::0;;;7257:68;;;;7308:5;7292:21;;-1:-1:-1;;7292:21:0;;;7257:68;34607:1198;;;;;;;;;;;;:::o;42810:164::-;-1:-1:-1;;;;;42921:31:0;;;42887:14;42921:31;;;:11;:31;;;;;:45;;;42810:164::o;41303:518::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;41413:28:::1;41431:9;41413:17;:28::i;:::-;41412:29;41404:64;;;;-1:-1:-1::0;;;41404:64:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;41479:31:0;;::::1;;::::0;;;:11:::1;:31;::::0;;;;:46;;41536:62;;::::1;-1:-1:-1::0;;;;;;;;;;41479:46:0;;::::1;-1:-1:-1::0;;;41479:46:0::1;41536:62:::0;::::1;;::::0;;41609:9:::1;:25:::0;;41521:4:::1;41609:25:::0;::::1;::::0;;;;;::::1;::::0;;;;::::1;;::::0;;41739:19:::1;::::0;41703:110:::1;::::0;41805:7:::1;::::0;41703:83:::1;::::0;41805:7;;41703:56:::1;::::0;:17:::1;:15;:17::i;:::-;:35:::0;::::1;:56::i;:::-;:74:::0;::::1;:83::i;:::-;:101:::0;::::1;:110::i;:::-;-1:-1:-1::0;;;;;41647:31:0;;::::1;;::::0;;;:11:::1;:31;::::0;;;;:53:::1;;:166:::0;;;;-1:-1:-1;41303:518:0:o;43335:139::-;43401:22;;:::i;:::-;-1:-1:-1;43436:30:0;;;;;;;;;43443:23;43436:30;;;43335:139;:::o;39322:257::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;39436:52;;:25:::1;:52:::0;;;39536:32:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;39504:67:::1;::::0;39536:34:::1;::::0;:32:::1;:34::i;39740:245::-:0;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;39850:48;;:23:::1;:48:::0;;;39944:30:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;39914:63:::1;::::0;39944:32:::1;::::0;:30:::1;:32::i;10553:79::-:0;10618:6;;-1:-1:-1;;;;;10618:6:0;10553:79;:::o;41940:583::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;42023:28:::1;42041:9;42023:17;:28::i;:::-;42015:56;;;;-1:-1:-1::0;;;42015:56:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;42082:31:0;::::1;42124:5;42082:31:::0;;;:11:::1;:31;::::0;;;;:47;;-1:-1:-1;;;;;;42140:74:0;;;42250:9:::1;:16:::0;;42277:239:::1;42301:14;42297:1;:18;42277:239;;;42357:9;-1:-1:-1::0;;;;;42341:25:0::1;:9;42351:1;42341:12;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;42341:12:0::1;:25;42337:168;;;42402:9;42429:1;42412:14;:18;42402:29;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;42387:9:::1;:12:::0;;-1:-1:-1;;;;;42402:29:0;;::::1;::::0;42397:1;;42387:12;::::1;;;;;;;;;;;;;:44;;;;;-1:-1:-1::0;;;;;42387:44:0::1;;;;;-1:-1:-1::0;;;;;42387:44:0::1;;;;;;42450:9;:15;;;;;;;;::::0;;;::::1;::::0;;;;-1:-1:-1;;42450:15:0;;;;;-1:-1:-1;;;;;;42450:15:0::1;::::0;;;;;42484:5:::1;;42337:168;42317:3;;42277:239;;;;10835:1;41940:583:::0;:::o;38155:221::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;38257:40;;:19:::1;:40:::0;;;38339:26:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;38313:55:::1;::::0;38339:28:::1;::::0;:26:::1;:28::i;38919:218::-:0;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;39006:19:::1;:40:::0;;;39094:32:::1;::::0;;::::1;::::0;::::1;::::0;;;:25:::1;:32:::0;;;39062:67:::1;::::0;39094:34:::1;::::0;:32:::1;:34::i;43760:137::-:0;43825:22;;:::i;:::-;-1:-1:-1;43860:29:0;;;;;;;;;43867:22;43860:29;;;43760:137;:::o;36631:214::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;36731:38;;:18:::1;:38:::0;36785:52:::1;36810:26;36752:17:::0;36810:24:::1;:26::i;37008:138::-:0;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;37104:34;:16:::1;:34:::0;37008:138::o;37742:239::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;37850:46;;:22:::1;:46:::0;;;37941:29:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;37912:61:::1;::::0;37941:31:::1;::::0;:29:::1;:31::i;43482:133::-:0;43545:22;;:::i;:::-;-1:-1:-1;43580:27:0;;;;;;;;;43587:20;43580:27;;;43482:133;:::o;44155:129::-;44216:22;;:::i;:::-;-1:-1:-1;44251:25:0;;;;;;;;;44258:18;44251:25;;;44155:129;:::o;43085:125::-;43144:22;;:::i;:::-;-1:-1:-1;43179:23:0;;;;;;;;;43186:16;43179:23;;;43085:125;:::o;35928:131::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;35995:17:0;::::1;35987:43;;;;-1:-1:-1::0;;;35987:43:0::1;;;;;;;:::i;:::-;36041:4;:10:::0;;-1:-1:-1;;;;;;36041:10:0::1;-1:-1:-1::0;;;;;36041:10:0;;;::::1;::::0;;;::::1;::::0;;35928:131::o;40097:1104::-;34529:4;;-1:-1:-1;;;;;34529:4:0;34515:10;:18;34507:39;;;;-1:-1:-1;;;34507:39:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;40229:31:0;::::1;;::::0;;;:11:::1;:31;::::0;;;;:53:::1;;::::0;40208:17:::1;:15;:17::i;:::-;:74;;40186:151;;;;-1:-1:-1::0;;;40186:151:0::1;;;;;;;:::i;:::-;40374:19;::::0;40350:21:::1;40434:20;40374:19:::0;40452:1:::1;40434:17;:20::i;:::-;40404:50;;40575:36;40614:42;40636:19;40614:17;:15;:17::i;:42::-;-1:-1:-1::0;;;;;40791:31:0;::::1;40736:39;40791:31:::0;;;:11:::1;:31;::::0;;;;:53:::1;;::::0;40575:81;;-1:-1:-1;40736:39:0;40791:98:::1;::::0;40881:7:::1;::::0;40791:85:::1;::::0;40881:7;;40791:72:::1;::::0;40849:13;40791:57:::1;:72::i;:98::-;40736:153;;41074:28;41027:31;:75;:166;;41165:28;41027:166;;;41118:31;41027:166;-1:-1:-1::0;;;;;40971:31:0;;::::1;;::::0;;;:11:::1;:31;::::0;;;;:53:::1;;:222:::0;;;;-1:-1:-1;;;;40097:1104:0:o;38545:215::-;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;38645:38;;:18:::1;:38:::0;;;38724:25:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;38699:53:::1;::::0;38724:27:::1;::::0;:25:::1;:27::i;11498:244::-:0;10775:12;:10;:12::i;:::-;10765:6;;-1:-1:-1;;;;;10765:6:0;;;:22;;;10757:67;;;;-1:-1:-1;;;10757:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;11587:22:0;::::1;11579:73;;;;-1:-1:-1::0;;;11579:73:0::1;;;;;;;:::i;:::-;11689:6;::::0;11668:38:::1;::::0;-1:-1:-1;;;;;11668:38:0;;::::1;::::0;11689:6:::1;::::0;11668:38:::1;::::0;11689:6:::1;::::0;11668:38:::1;11717:6;:17:::0;;-1:-1:-1;;;;;;11717:17:0::1;-1:-1:-1::0;;;;;11717:17:0;;;::::1;::::0;;;::::1;::::0;;11498:244::o;8859:106::-;8947:10;8859:106;:::o;16784:95::-;16868:3;;16784:95::o;7425:604::-;7867:4;7978:17;8014:7;7425:604;:::o;10139:129::-;6969:13;;;;;;;;:33;;;6986:16;:14;:16::i;:::-;6969:50;;;-1:-1:-1;7007:12:0;;;;7006:13;6969:50;6961:109;;;;-1:-1:-1;;;6961:109:0;;;;;;;:::i;:::-;7083:19;7106:13;;;;;;7105:14;7130:101;;;;7165:13;:20;;-1:-1:-1;;;;7165:20:0;;;;;7200:19;7181:4;7200:19;;;7130:101;10197:26:::1;:24;:26::i;:::-;10234;:24;:26::i;:::-;7261:14:::0;7257:68;;;7308:5;7292:21;;-1:-1:-1;;7292:21:0;;;7257:68;10139:129;:::o;44891:108::-;44976:15;44891:108;:::o;998:181::-;1056:7;1088:5;;;1112:6;;;;1104:46;;;;-1:-1:-1;;;1104:46:0;;;;;;;:::i;:::-;1170:1;-1:-1:-1;998:181:0;;;;;:::o;3299:132::-;3357:7;3384:39;3388:1;3391;3384:39;;;;;;;;;;;;;;;;;:3;:39::i;2352:471::-;2410:7;2655:6;2651:47;;-1:-1:-1;2685:1:0;2678:8;;2651:47;2722:5;;;2726:1;2722;:5;:1;2746:5;;;;;:10;2738:56;;;;-1:-1:-1;;;2738:56:0;;;;;;;:::i;8788:65::-;6969:13;;;;;;;;:33;;;6986:16;:14;:16::i;:::-;6969:50;;;-1:-1:-1;7007:12:0;;;;7006:13;6969:50;6961:109;;;;-1:-1:-1;;;6961:109:0;;;;;;;:::i;:::-;7083:19;7106:13;;;;;;7105:14;7130:101;;;;7165:13;:20;;-1:-1:-1;;;;7165:20:0;;;;;7200:19;7181:4;7200:19;;;7261:14;7257:68;;;7308:5;7292:21;;-1:-1:-1;;7292:21:0;;;8788:65;:::o;10276:196::-;6969:13;;;;;;;;:33;;;6986:16;:14;:16::i;:::-;6969:50;;;-1:-1:-1;7007:12:0;;;;7006:13;6969:50;6961:109;;;;-1:-1:-1;;;6961:109:0;;;;;;;:::i;:::-;7083:19;7106:13;;;;;;7105:14;7130:101;;;;7165:13;:20;;-1:-1:-1;;;;7165:20:0;;;;;7200:19;7181:4;7200:19;;;7130:101;10344:17:::1;10364:12;:10;:12::i;:::-;10387:6;:18:::0;;-1:-1:-1;;;;;;10387:18:0::1;-1:-1:-1::0;;;;;10387:18:0;::::1;::::0;;::::1;::::0;;;10421:43:::1;::::0;10387:18;;-1:-1:-1;10387:18:0;-1:-1:-1;;10421:43:0::1;::::0;-1:-1:-1;;10421:43:0::1;7243:1;7261:14:::0;7257:68;;;7308:5;7292:21;;-1:-1:-1;;7292:21:0;;;10276:196;:::o;3927:278::-;4013:7;4048:12;4041:5;4033:28;;;;-1:-1:-1;;;4033:28:0;;;;;;;;:::i;:::-;;4072:9;4088:1;4084;:5;;;;;;;3927:278;-1:-1:-1;;;;;3927:278:0:o;-1:-1:-1:-;;;;;;;;;;;;;;:::o;990:241::-;;1094:2;1082:9;1073:7;1069:23;1065:32;1062:2;;;-1:-1;;1100:12;1062:2;85:6;72:20;97:33;124:5;97:33;:::i;1238:1501::-;;;;;;;;;;;;1513:3;1501:9;1492:7;1488:23;1484:33;1481:2;;;-1:-1;;1520:12;1481:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1572:63;1672:2;1711:22;;920:20;;-1:-1;1780:2;1819:22;;920:20;;1888:2;1927:22;;920:20;;-1:-1;1996:3;2036:22;;920:20;;-1:-1;2105:3;2145:22;;920:20;;-1:-1;2214:3;2254:22;;920:20;;-1:-1;2323:3;2363:22;;920:20;;-1:-1;2432:3;2472:22;;920:20;;-1:-1;2541:3;2581:22;;920:20;;-1:-1;2650:3;2691:22;920:20;;-1:-1;1475:1264;-1:-1;;;1475:1264::o;3030:448::-;;;3192:2;3180:9;3171:7;3167:23;3163:32;3160:2;;;-1:-1;;3198:12;3160:2;240:6;227:20;252:51;297:5;252:51;:::i;:::-;3250:81;-1:-1;3368:2;3430:22;;405:20;430:56;405:20;430:56;:::i;:::-;3376:86;;;;3154:324;;;;;:::o;3485:289::-;;3613:2;3601:9;3592:7;3588:23;3584:32;3581:2;;;-1:-1;;3619:12;3581:2;16367;16361:9;3613:2;16397:6;16393:17;16504:6;16492:10;16489:22;16468:18;16456:10;16453:34;16450:62;16447:2;;;-1:-1;;16515:12;16447:2;16367;16534:22;920:20;;750:75;;-1:-1;757:16;3575:199;-1:-1;3575:199::o;3781:241::-;;3885:2;3873:9;3864:7;3860:23;3856:32;3853:2;;;-1:-1;;3891:12;3853:2;-1:-1;920:20;;3847:175;-1:-1;3847:175::o;10070:222::-;-1:-1;;;;;18016:54;;;;4318:37;;10197:2;10182:18;;10168:124::o;10299:406::-;10494:2;10508:47;;;16865:12;;10479:18;;;17287:19;;;10299:406;;10494:2;16701:14;;;;17327;;;;10299:406;4871:296;4896:6;4893:1;4890:13;4871:296;;;4957:13;;-1:-1;;;;;18016:54;5387:68;;17142:14;;;;4219;;;;16468:18;4911:9;4871:296;;;-1:-1;10561:134;;10465:240;-1:-1;;;;;;10465:240::o;10712:210::-;17691:13;;17684:21;5262:34;;10833:2;10818:18;;10804:118::o;11204:310::-;;11351:2;;11372:17;11365:47;5791:5;16865:12;17299:6;11351:2;11340:9;11336:18;17287:19;-1:-1;18843:101;18857:6;18854:1;18851:13;18843:101;;;18924:11;;;;;18918:18;18905:11;;;17327:14;18905:11;18898:39;18872:10;;18843:101;;;18959:6;18956:1;18953:13;18950:2;;;-1:-1;17327:14;19015:6;11340:9;19006:16;;18999:27;18950:2;-1:-1;19131:7;19115:14;-1:-1;;19111:28;5949:39;;;;17327:14;5949:39;;11322:192;-1:-1;;;11322:192::o;11521:416::-;11721:2;11735:47;;;6225:1;11706:18;;;17287:19;-1:-1;;;17327:14;;;6240:31;6290:12;;;11692:245::o;11944:416::-;12144:2;12158:47;;;6541:2;12129:18;;;17287:19;6577:34;17327:14;;;6557:55;-1:-1;;;6632:12;;;6625:30;6674:12;;;12115:245::o;12367:416::-;12567:2;12581:47;;;6925:2;12552:18;;;17287:19;6961:29;17327:14;;;6941:50;7010:12;;;12538:245::o;12790:416::-;12990:2;13004:47;;;7261:2;12975:18;;;17287:19;-1:-1;;;17327:14;;;7277:36;7332:12;;;12961:245::o;13213:416::-;13413:2;13427:47;;;7583:2;13398:18;;;17287:19;-1:-1;;;17327:14;;;7599:38;7656:12;;;13384:245::o;13636:416::-;13836:2;13850:47;;;7907:2;13821:18;;;17287:19;7943:34;17327:14;;;7923:55;-1:-1;;;7998:12;;;7991:38;8048:12;;;13807:245::o;14059:416::-;14259:2;14273:47;;;8299:2;14244:18;;;17287:19;8335:34;17327:14;;;8315:55;-1:-1;;;8390:12;;;8383:25;8427:12;;;14230:245::o;14482:416::-;14682:2;14696:47;;;14667:18;;;17287:19;8714:34;17327:14;;;8694:55;8768:12;;;14653:245::o;14905:416::-;15105:2;15119:47;;;9019:2;15090:18;;;17287:19;9055:29;17327:14;;;9035:50;9104:12;;;15076:245::o;15328:416::-;15528:2;15542:47;;;9355:2;15513:18;;;17287:19;-1:-1;;;17327:14;;;9371:45;9435:12;;;15499:245::o;15751:318::-;9720:23;;9901:37;;15926:2;15911:18;;15897:172::o;16076:222::-;9901:37;;;16203:2;16188:18;;16174:124::o;19152:117::-;-1:-1;;;;;18016:54;;19211:35;;19201:2;;19260:1;;19250:12

Swarm Source

ipfs://d15de46f60a433e43b2a55ceaa409e67974c2bfc0a06a8e34e08d120b3da7f58
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading