Contract

0x8A8c01A4d5f542a8EFEF517768DC4887e973e847

Feature Tip: Add private address tag to any address under My Name Tag !

Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

PlotX: Deployer at txn 0x31fe9b1a2d1f5c35860134bf4aa99f0865b7bd24ccf952240f452a1fc40d4d12

Multichain Info

$0 (Multichain Portfolio)

	Transaction Hash	Method	Block		From		To
There are no matching entries Please try again later

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Contract Source Code Verified (Exact Match)

Contract Name:

MarketUtility

Compiler Version

v0.5.7+commit.6da8b019

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-10-29
*/

// File: contracts/external/uniswap/solidity-interface.sol

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
  event PairCreated(address indexed token0, address indexed token1, address pair, uint);

  function getPair(address tokenA, address tokenB) external view returns (address pair);
  function allPairs(uint) external view returns (address pair);
  function allPairsLength() external view returns (uint);

  function feeTo() external view returns (address);
  function feeToSetter() external view returns (address);

  function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);

}

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

interface IUniswapV2ERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}


interface IUniswapV2Callee {
    function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}

// File: contracts/external/uniswap/FixedPoint.sol

// SPDX-License-Identifier: GPL-3.0-or-later

// computes square roots using the babylonian method
// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
pragma solidity >=0.5.0;
library Babylonian {
    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
        // else z = 0
    }
}

library UQ112x112 {
    uint224 constant Q112 = 2**112;

    // encode a uint112 as a UQ112x112
    function encode(uint112 y) internal pure returns (uint224 z) {
        z = uint224(y) * Q112; // never overflows
    }

    // divide a UQ112x112 by a uint112, returning a UQ112x112
    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
        z = x / uint224(y);
    }
}

// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
library FixedPoint {
    // range: [0, 2**112 - 1]
    // resolution: 1 / 2**112
    struct uq112x112 {
        uint224 _x;
    }

    // range: [0, 2**144 - 1]
    // resolution: 1 / 2**112
    struct uq144x112 {
        uint _x;
    }

    uint8 private constant RESOLUTION = 112;
    uint private constant Q112 = uint(1) << RESOLUTION;
    uint private constant Q224 = Q112 << RESOLUTION;

    // encode a uint112 as a UQ112x112
    function encode(uint112 x) internal pure returns (uq112x112 memory) {
        return uq112x112(uint224(x) << RESOLUTION);
    }

    // encodes a uint144 as a UQ144x112
    function encode144(uint144 x) internal pure returns (uq144x112 memory) {
        return uq144x112(uint256(x) << RESOLUTION);
    }

    // divide a UQ112x112 by a uint112, returning a UQ112x112
    function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
        require(x != 0, 'FixedPoint: DIV_BY_ZERO');
        return uq112x112(self._x / uint224(x));
    }

    // multiply a UQ112x112 by a uint, returning a UQ144x112
    // reverts on overflow
    function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
        uint z;
        require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
        return uq144x112(z);
    }

    // returns a UQ112x112 which represents the ratio of the numerator to the denominator
    // equivalent to encode(numerator).div(denominator)
    function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
        require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
        return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
    }

    // decode a UQ112x112 into a uint112 by truncating after the radix point
    function decode(uq112x112 memory self) internal pure returns (uint112) {
        return uint112(self._x >> RESOLUTION);
    }

    // decode a UQ144x112 into a uint144 by truncating after the radix point
    function decode144(uq144x112 memory self) internal pure returns (uint144) {
        return uint144(self._x >> RESOLUTION);
    }

    // take the reciprocal of a UQ112x112
    function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
        require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
        return uq112x112(uint224(Q224 / self._x));
    }

    // square root of a UQ112x112
    function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
        return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
    }
}

// File: contracts/external/uniswap/oracleLibrary.sol

pragma solidity >=0.5.0;



// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
    using FixedPoint for *;

    // helper function that returns the current block timestamp within the range of uint32, i.e. [0, 2**32 - 1]
    function currentBlockTimestamp() internal view returns (uint32) {
        return uint32(block.timestamp % 2 ** 32);
    }

    // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
    function currentCumulativePrices(
        address pair
    ) internal view returns (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
        blockTimestamp = currentBlockTimestamp();
        price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
        price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

        // if time has elapsed since the last update on the pair, mock the accumulated price values
        (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
        if (blockTimestampLast != blockTimestamp) {
            // subtraction overflow is desired
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            // addition overflow is desired
            // counterfactual
            price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
            // counterfactual
            price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
        }
    }
}

// File: contracts/external/openzeppelin-solidity/math/SafeMath.sol

pragma solidity ^0.5.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 SafeMath {
    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @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.
     *
     * _Available since v2.4.0._
     */
    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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

library SafeMath64 {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint64 a, uint64 b) internal pure returns (uint64) {
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint64 c = a - b;

        return c;
    }

    /**
     * @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.
     *
     * _Available since v2.4.0._
     */
    function sub(uint64 a, uint64 b, string memory errorMessage) internal pure returns (uint64) {
        require(b <= a, errorMessage);
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        // 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;
        }

        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

// File: contracts/external/proxy/Proxy.sol

pragma solidity 0.5.7;


/**
 * @title Proxy
 * @dev Gives the possibility to delegate any call to a foreign implementation.
 */
contract Proxy {
    /**
    * @dev Fallback function allowing to perform a delegatecall to the given implementation.
    * This function will return whatever the implementation call returns
    */
    function () external payable {
        address _impl = implementation();
        require(_impl != address(0));

        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize)
            let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
            let size := returndatasize
            returndatacopy(ptr, 0, size)

            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
            }
    }

    /**
    * @dev Tells the address of the implementation where every call will be delegated.
    * @return address of the implementation to which it will be delegated
    */
    function implementation() public view returns (address);
}

// File: contracts/external/proxy/UpgradeabilityProxy.sol

pragma solidity 0.5.7;



/**
 * @title UpgradeabilityProxy
 * @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded
 */
contract UpgradeabilityProxy is Proxy {
    /**
    * @dev This event will be emitted every time the implementation gets upgraded
    * @param implementation representing the address of the upgraded implementation
    */
    event Upgraded(address indexed implementation);

    // Storage position of the address of the current implementation
    bytes32 private constant IMPLEMENTATION_POSITION = keccak256("org.govblocks.proxy.implementation");

    /**
    * @dev Constructor function
    */
    constructor() public {}

    /**
    * @dev Tells the address of the current implementation
    * @return address of the current implementation
    */
    function implementation() public view returns (address impl) {
        bytes32 position = IMPLEMENTATION_POSITION;
        assembly {
            impl := sload(position)
        }
    }

    /**
    * @dev Sets the address of the current implementation
    * @param _newImplementation address representing the new implementation to be set
    */
    function _setImplementation(address _newImplementation) internal {
        bytes32 position = IMPLEMENTATION_POSITION;
        assembly {
        sstore(position, _newImplementation)
        }
    }

    /**
    * @dev Upgrades the implementation address
    * @param _newImplementation representing the address of the new implementation to be set
    */
    function _upgradeTo(address _newImplementation) internal {
        address currentImplementation = implementation();
        require(currentImplementation != _newImplementation);
        _setImplementation(_newImplementation);
        emit Upgraded(_newImplementation);
    }
}

// File: contracts/external/proxy/OwnedUpgradeabilityProxy.sol

pragma solidity 0.5.7;



/**
 * @title OwnedUpgradeabilityProxy
 * @dev This contract combines an upgradeability proxy with basic authorization control functionalities
 */
contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
    /**
    * @dev Event to show ownership has been transferred
    * @param previousOwner representing the address of the previous owner
    * @param newOwner representing the address of the new owner
    */
    event ProxyOwnershipTransferred(address previousOwner, address newOwner);

    // Storage position of the owner of the contract
    bytes32 private constant PROXY_OWNER_POSITION = keccak256("org.govblocks.proxy.owner");

    /**
    * @dev the constructor sets the original owner of the contract to the sender account.
    */
    constructor(address _implementation) public {
        _setUpgradeabilityOwner(msg.sender);
        _upgradeTo(_implementation);
    }

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyProxyOwner() {
        require(msg.sender == proxyOwner());
        _;
    }

    /**
    * @dev Tells the address of the owner
    * @return the address of the owner
    */
    function proxyOwner() public view returns (address owner) {
        bytes32 position = PROXY_OWNER_POSITION;
        assembly {
            owner := sload(position)
        }
    }

    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param _newOwner The address to transfer ownership to.
    */
    function transferProxyOwnership(address _newOwner) public onlyProxyOwner {
        require(_newOwner != address(0));
        _setUpgradeabilityOwner(_newOwner);
        emit ProxyOwnershipTransferred(proxyOwner(), _newOwner);
    }

    /**
    * @dev Allows the proxy owner to upgrade the current version of the proxy.
    * @param _implementation representing the address of the new implementation to be set.
    */
    function upgradeTo(address _implementation) public onlyProxyOwner {
        _upgradeTo(_implementation);
    }

    /**
     * @dev Sets the address of the owner
    */
    function _setUpgradeabilityOwner(address _newProxyOwner) internal {
        bytes32 position = PROXY_OWNER_POSITION;
        assembly {
            sstore(position, _newProxyOwner)
        }
    }
}

// File: contracts/interfaces/ITokenController.sol

pragma solidity 0.5.7;

contract ITokenController {
	address public token;
    address public bLOTToken;

    /**
    * @dev Swap BLOT token.
    * account.
    * @param amount The amount that will be swapped.
    */
    function swapBLOT(address _of, address _to, uint256 amount) public;

    function totalBalanceOf(address _of)
        public
        view
        returns (uint256 amount);

    function transferFrom(address _token, address _of, address _to, uint256 amount) public;

    /**
     * @dev Returns tokens locked for a specified address for a
     *      specified reason at a specific time
     * @param _of The address whose tokens are locked
     * @param _reason The reason to query the lock tokens for
     * @param _time The timestamp to query the lock tokens for
     */
    function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time)
        public
        view
        returns (uint256 amount);

    /**
    * @dev burns an amount of the tokens of the message sender
    * account.
    * @param amount The amount that will be burnt.
    */
    function burnCommissionTokens(uint256 amount) external returns(bool);
 
    function initiateVesting(address _vesting) external;

    function lockForGovernanceVote(address _of, uint _days) public;

    function totalSupply() public view returns (uint256);

    function mint(address _member, uint _amount) public;

}

// File: contracts/interfaces/IMarketRegistry.sol

pragma solidity 0.5.7;

contract IMarketRegistry {

    enum MarketType {
      HourlyMarket,
      DailyMarket,
      WeeklyMarket
    }
    address public owner;
    address public tokenController;
    address public marketUtility;
    bool public marketCreationPaused;

    mapping(address => bool) public isMarket;
    function() external payable{}

    function marketDisputeStatus(address _marketAddress) public view returns(uint _status);

    function burnDisputedProposalTokens(uint _proposaId) external;

    function isWhitelistedSponsor(address _address) public view returns(bool);

    function transferAssets(address _asset, address _to, uint _amount) external;

    /**
    * @dev Initialize the PlotX.
    * @param _marketConfig The address of market config.
    * @param _plotToken The address of PLOT token.
    */
    function initiate(address _defaultAddress, address _marketConfig, address _plotToken, address payable[] memory _configParams) public;

    /**
    * @dev Create proposal if user wants to raise the dispute.
    * @param proposalTitle The title of proposal created by user.
    * @param description The description of dispute.
    * @param solutionHash The ipfs solution hash.
    * @param actionHash The action hash for solution.
    * @param stakeForDispute The token staked to raise the diospute.
    * @param user The address who raises the dispute.
    */
    function createGovernanceProposal(string memory proposalTitle, string memory description, string memory solutionHash, bytes memory actionHash, uint256 stakeForDispute, address user, uint256 ethSentToPool, uint256 tokenSentToPool, uint256 proposedValue) public {
    }

    /**
    * @dev Emits the PlacePrediction event and sets user data.
    * @param _user The address who placed prediction.
    * @param _value The amount of ether user staked.
    * @param _predictionPoints The positions user will get.
    * @param _predictionAsset The prediction assets user will get.
    * @param _prediction The option range on which user placed prediction.
    * @param _leverage The leverage selected by user at the time of place prediction.
    */
    function setUserGlobalPredictionData(address _user,uint _value, uint _predictionPoints, address _predictionAsset, uint _prediction,uint _leverage) public{
    }

    /**
    * @dev Emits the claimed event.
    * @param _user The address who claim their reward.
    * @param _reward The reward which is claimed by user.
    * @param incentives The incentives of user.
    * @param incentiveToken The incentive tokens of user.
    */
    function callClaimedEvent(address _user , uint[] memory _reward, address[] memory predictionAssets, uint incentives, address incentiveToken) public {
    }

        /**
    * @dev Emits the MarketResult event.
    * @param _totalReward The amount of reward to be distribute.
    * @param _winningOption The winning option of the market.
    * @param _closeValue The closing value of the market currency.
    */
    function callMarketResultEvent(uint[] memory _totalReward, uint _winningOption, uint _closeValue, uint roundId) public {
    }
}

// File: contracts/interfaces/IChainLinkOracle.sol

pragma solidity 0.5.7;

interface IChainLinkOracle
{
	/**
    * @dev Gets the latest answer of chainLink oracle.
    * @return int256 representing the latest answer of chainLink oracle.
    */
	function latestAnswer() external view returns (int256);
	function decimals() external view returns (uint8);
	function getRoundData(uint80 _roundId)
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  	function latestRoundData()
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    ); 
}

// File: contracts/interfaces/IToken.sol

pragma solidity 0.5.7;

contract IToken {

    function decimals() external view returns(uint8);

    /**
    * @dev Total number of tokens in existence
    */
    function totalSupply() external view returns (uint256);

    /**
    * @dev Gets the balance of the specified address.
    * @param account The address to query the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address account) external view returns (uint256);

    /**
    * @dev Transfer token for a specified address
    * @param recipient The address to transfer to.
    * @param amount The amount to be transferred.
    */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
    * @dev function that mints an amount of the token and assigns it to
    * an account.
    * @param account The account that will receive the created tokens.
    * @param amount The amount that will be created.
    */
    function mint(address account, uint256 amount) external returns (bool);
    
     /**
    * @dev burns an amount of the tokens of the message sender
    * account.
    * @param amount The amount that will be burnt.
    */
    function burn(uint256 amount) external;

    /**
     * @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.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
    * @dev Transfer tokens from one address to another
    * @param sender address The address which you want to send tokens from
    * @param recipient address The address which you want to transfer to
    * @param amount uint256 the amount of tokens to be transferred
    */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

}

// File: contracts/MarketUtility.sol

/* Copyright (C) 2020 PlotX.io

  This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

  This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
    along with this program.  If not, see http://www.gnu.org/licenses/ */

pragma solidity 0.5.7;










contract MarketUtility {
    using SafeMath for uint256;
    using FixedPoint for *;

    address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    uint256 constant updatePeriod = 1 hours;

    uint256 internal STAKE_WEIGHTAGE;
    uint256 internal STAKE_WEIGHTAGE_MIN_AMOUNT;
    uint256 internal minTimeElapsedDivisor;
    uint256 internal minPredictionAmount;
    uint256 internal maxPredictionAmount;
    uint256 internal positionDecimals;
    uint256 internal minStakeForMultiplier;
    uint256 internal riskPercentage;
    uint256 internal tokenStakeForDispute;
    address internal plotToken;
    address internal plotETHpair;
    address internal weth;
    address internal initiater;
    address public authorizedAddress;
    bool public initialized;


    struct UniswapPriceData {
        FixedPoint.uq112x112 price0Average;
        uint256 price0CumulativeLast;
        FixedPoint.uq112x112 price1Average;
        uint256 price1CumulativeLast;
        uint32 blockTimestampLast;
        bool initialized;
    }

    mapping(address => UniswapPriceData) internal uniswapPairData;
    IUniswapV2Factory uniswapFactory;

    ITokenController internal tokenController;
    modifier onlyAuthorized() {
        require(msg.sender == authorizedAddress, "Not authorized");
        _;
    }

    /**
     * @dev Initiates the config contact with initial values
     **/
    function initialize(address payable[] memory _addressParams, address _initiater) public {
        OwnedUpgradeabilityProxy proxy = OwnedUpgradeabilityProxy(
            address(uint160(address(this)))
        );
        require(msg.sender == proxy.proxyOwner(), "Sender is not proxy owner.");
        require(!initialized, "Already initialized");
        initialized = true;
        _setInitialParameters();
        authorizedAddress = msg.sender;
        tokenController = ITokenController(IMarketRegistry(msg.sender).tokenController());
        plotToken = _addressParams[1];
        initiater = _initiater;
        weth = IUniswapV2Router02(_addressParams[0]).WETH();
        uniswapFactory = IUniswapV2Factory(_addressParams[2]);
    }

    /**
     * @dev Internal function to set initial value
     **/
    function _setInitialParameters() internal {
        STAKE_WEIGHTAGE = 40; //
        STAKE_WEIGHTAGE_MIN_AMOUNT = 20 ether;
        minTimeElapsedDivisor = 6;
        minPredictionAmount = 1e15;
        maxPredictionAmount = 28 ether;
        positionDecimals = 1e2;
        minStakeForMultiplier = 5e17;
        riskPercentage = 20;
        tokenStakeForDispute = 500 ether;
    }

    /**
    * @dev Check if user gets any multiplier on his positions
    * @param _asset The assets uses by user during prediction.
    * @param _predictionStake The amount staked by user at the time of prediction.
    * @param predictionPoints The actual positions user got during prediction.
    * @param _stakeValue The stake value of asset.
    * @return uint256 representing multiplied positions
    */
    function checkMultiplier(address _asset, address _user, uint _predictionStake, uint predictionPoints, uint _stakeValue) public view returns(uint, bool) {
      bool multiplierApplied;
      uint _stakedBalance = tokenController.tokensLockedAtTime(_user, "SM", now);
      uint _predictionValueInToken;
      (, _predictionValueInToken) = getValueAndMultiplierParameters(_asset, _predictionStake);
      if(_stakeValue < minStakeForMultiplier) {
        return (predictionPoints,multiplierApplied);
      }
      uint _muliplier = 100;
      if(_stakedBalance.div(_predictionValueInToken) > 0) {
        _muliplier = _muliplier + _stakedBalance.mul(100).div(_predictionValueInToken.mul(10));
        multiplierApplied = true;
      }
      return (predictionPoints.mul(_muliplier).div(100),multiplierApplied);
    }

    /**
     * @dev Updates integer parameters of config
     **/
    function updateUintParameters(bytes8 code, uint256 value)
        external
        onlyAuthorized
    {
        if (code == "SW") { // Stake weightage
            require(value <= 100, "Value must be less or equal to 100");
            STAKE_WEIGHTAGE = value;
        } else if (code == "SWMA") { // Minimum amount required for stake weightage
            STAKE_WEIGHTAGE_MIN_AMOUNT = value;
        } else if (code == "MTED") { // Minimum time elapsed divisor
            minTimeElapsedDivisor = value;
        } else if (code == "MINPRD") { // Minimum predictionamount
            minPredictionAmount = value;
        } else if (code == "MAXPRD") { // Minimum predictionamount
            maxPredictionAmount = value;
        } else if (code == "PDEC") { // Position's Decimals
            positionDecimals = value;
        } else if (code == "MINSTM") { // Min stake required for applying multiplier
            minStakeForMultiplier = value;
        } else if (code == "RPERC") { // Risk percentage
            riskPercentage = value;
        } else if (code == "TSDISP") { // Amount of tokens to be staked for raising a dispute
            tokenStakeForDispute = value;
        } else {
            revert("Invalid code");
        }
    }

    /**
     * @dev Updates address parameters of config
     **/
    function updateAddressParameters(bytes8 code, address payable value)
        external
        onlyAuthorized
    {
        require(value != address(0), "Value cannot be address(0)");
        if (code == "UNIFAC") { // Uniswap factory address
            uniswapFactory = IUniswapV2Factory(value);
            plotETHpair = uniswapFactory.getPair(plotToken, weth);
        } else {
            revert("Invalid code");
        }
    }

    /**
     * @dev Update cumulative price of token in uniswap
     **/
    function update() external onlyAuthorized {
        require(plotETHpair != address(0), "Uniswap pair not set");
        UniswapPriceData storage _priceData = uniswapPairData[plotETHpair];
        (
            uint256 price0Cumulative,
            uint256 price1Cumulative,
            uint32 blockTimestamp
        ) = UniswapV2OracleLibrary.currentCumulativePrices(plotETHpair);
        uint32 timeElapsed = blockTimestamp - _priceData.blockTimestampLast; // overflow is desired

        if (timeElapsed >= updatePeriod || !_priceData.initialized) {
            // overflow is desired, casting never truncates
            // cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed
            _priceData.price0Average = FixedPoint.uq112x112(
                uint224(
                    (price0Cumulative - _priceData.price0CumulativeLast) /
                        timeElapsed
                )
            );
            _priceData.price1Average = FixedPoint.uq112x112(
                uint224(
                    (price1Cumulative - _priceData.price1CumulativeLast) /
                        timeElapsed
                )
            );

            _priceData.price0CumulativeLast = price0Cumulative;
            _priceData.price1CumulativeLast = price1Cumulative;
            _priceData.blockTimestampLast = blockTimestamp;
            if(!_priceData.initialized) {
              _priceData.initialized = true;
            }
        }
    }

    /**
     * @dev Set initial PLOT/ETH pair cummulative price
     **/
    function setInitialCummulativePrice() public {
      require(msg.sender == initiater);
      require(plotETHpair == address(0),"Already initialised");
      plotETHpair = uniswapFactory.getPair(plotToken, weth);
      UniswapPriceData storage _priceData = uniswapPairData[plotETHpair];
      (
          uint256 price0Cumulative,
          uint256 price1Cumulative,
          uint32 blockTimestamp
      ) = UniswapV2OracleLibrary.currentCumulativePrices(plotETHpair);
      _priceData.price0CumulativeLast = price0Cumulative;
      _priceData.price1CumulativeLast = price1Cumulative;
      _priceData.blockTimestampLast = blockTimestamp;
    }

    /**
    * @dev Get decimals of given price feed address 
    */
    function getPriceFeedDecimals(address _priceFeed) public view returns(uint8) {
      return IChainLinkOracle(_priceFeed).decimals();
    }

    /**
     * @dev Get basic market details
     * @return Minimum amount required to predict in market
     * @return Percentage of users leveraged amount to deduct when placed in wrong prediction
     * @return Decimal points for prediction positions
     * @return Maximum prediction amount
     **/
    function getBasicMarketDetails()
        public
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        return (minPredictionAmount, riskPercentage, positionDecimals, maxPredictionAmount);
    }

    /**
     * @dev Get Parameter required for option price calculation
     * @param _marketFeedAddress  Feed Address of currency on which market options are based on
     * @return Stake weightage percentage for calculation option price
     * @return minimum amount of stake required to consider stake weightage
     * @return Current price of the market currency
     * @return Divisor to calculate minimum time elapsed for a market type
     **/
    function getPriceCalculationParams(
        address _marketFeedAddress
    )
        public
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        uint256 _currencyPrice = getAssetPriceUSD(
            _marketFeedAddress
        );
        return (
            STAKE_WEIGHTAGE,
            STAKE_WEIGHTAGE_MIN_AMOUNT,
            _currencyPrice,
            minTimeElapsedDivisor
        );
    }

    /**
     * @dev Get price of provided feed address
     * @param _currencyFeedAddress  Feed Address of currency on which market options are based on
     * @return Current price of the market currency
     **/
    function getAssetPriceUSD(
        address _currencyFeedAddress
    ) public view returns (uint256 latestAnswer) {
        return uint256(IChainLinkOracle(_currencyFeedAddress).latestAnswer());
    }

    /**
     * @dev Get price of provided feed address
     * @param _currencyFeedAddress  Feed Address of currency on which market options are based on
     * @return Current price of the market currency
     **/
    function getSettlemetPrice(
        address _currencyFeedAddress,
        uint256 _settleTime
    ) public view returns (uint256 latestAnswer, uint256 roundId) {
        uint80 currentRoundId;
        uint256 currentRoundTime;
        int256 currentRoundAnswer;
        (currentRoundId, currentRoundAnswer, , currentRoundTime, )= IChainLinkOracle(_currencyFeedAddress).latestRoundData();
        while(currentRoundTime > _settleTime) {
            currentRoundId--;
            (currentRoundId, currentRoundAnswer, , currentRoundTime, )= IChainLinkOracle(_currencyFeedAddress).getRoundData(currentRoundId);
            if(currentRoundTime <= _settleTime) {
                break;
            }
        }
        return
            (uint256(currentRoundAnswer), currentRoundId);
    }

    /**
     * @dev Get value of provided currency address in ETH
     * @param _currencyAddress Address of currency
     * @param _amount Amount of provided currency
     * @return Value of provided amount in ETH
     **/
    function getAssetValueETH(address _currencyAddress, uint256 _amount)
        public
        view
        returns (uint256 tokenEthValue)
    {
        tokenEthValue = _amount;
        if (_currencyAddress != ETH_ADDRESS) {
            tokenEthValue = getPrice(plotETHpair, _amount);
        }
    }

    /**
     * @dev Get price of provided currency address in ETH
     * @param _currencyAddress Address of currency
     * @return Price of provided currency in ETH
     * @return Decimals of the currency
     **/
    function getAssetPriceInETH(address _currencyAddress)
        public
        view
        returns (uint256 tokenEthValue, uint256 decimals)
    {
        tokenEthValue = 1;
        if (_currencyAddress != ETH_ADDRESS) {
            decimals = IToken(_currencyAddress).decimals();
            tokenEthValue = getPrice(plotETHpair, 10**decimals);
        }
    }

    /**
     * @dev Get amount of stake required to raise a dispute
     **/
    function getDisputeResolutionParams() public view returns (uint256) {
        return tokenStakeForDispute;
    }

    /**
     * @dev Get value of _asset in PLOT token and multiplier parameters
     * @param _asset Address of asset for which value is requested
     * @param _amount Amount of _asset
     * @return min prediction amount required for multiplier
     * @return value of given asset in PLOT tokens
     **/
    function getValueAndMultiplierParameters(address _asset, uint256 _amount)
        public
        view
        returns (uint256, uint256)
    {
        uint256 _value = _amount;
        if (_asset == ETH_ADDRESS) {
            _value = (uniswapPairData[plotETHpair].price1Average)
                .mul(_amount)
                .decode144();
        }
        return (minStakeForMultiplier, _value);
    }

    /**
     * @dev Get Market feed address
     * @return Uniswap factory address
     **/
    function getFeedAddresses() public view returns (address) {
        return (address(uniswapFactory));
    }

    /**
     * @dev Get value of token in pair
     **/
    function getPrice(address pair, uint256 amountIn)
        public
        view
        returns (uint256 amountOut)
    {
        amountOut = (uniswapPairData[pair].price0Average)
            .mul(amountIn)
            .decode144();
    }

    /**
    * @dev function to calculate square root of a number
    */
    function sqrt(uint x) internal pure returns (uint y) {
      uint z = (x + 1) / 2;
      y = x;
      while (z < y) {
          y = z;
          z = (x / z + z) / 2;
      }
    }

    /**
    * @dev Calculate the prediction value, passing all the required params
    * params index
    * 0 _prediction
    * 1 neutralMinValue
    * 2 neutralMaxValue
    * 3 startTime
    * 4 expireTime
    * 5 totalStakedETH
    * 6 totalStakedToken
    * 7 ethStakedOnOption
    * 8 plotStakedOnOption
    * 9 _stake
    * 10 _leverage
    */
    function calculatePredictionValue(uint[] memory params, address asset, address user, address marketFeedAddress, bool _checkMultiplier) public view returns(uint _predictionValue, bool _multiplierApplied) {
      uint _stakeValue = getAssetValueETH(asset, params[9]);
      if(_stakeValue < minPredictionAmount || _stakeValue > maxPredictionAmount) {
        return (_predictionValue, _multiplierApplied);
      }
      uint optionPrice;
      
      optionPrice = calculateOptionPrice(params, marketFeedAddress);
      _predictionValue = _calculatePredictionPoints(_stakeValue.mul(positionDecimals), optionPrice, params[10]);
      if(_checkMultiplier) {
        return checkMultiplier(asset, user, params[9],  _predictionValue, _stakeValue);
      }
      return (_predictionValue, _multiplierApplied);
    }

    function _calculatePredictionPoints(uint value, uint optionPrice, uint _leverage) internal pure returns(uint) {
      //leverageMultiplier = levergage + (leverage -1)*0.05; Raised by 3 decimals i.e 1000
      uint leverageMultiplier = 1000 + (_leverage-1)*50;
      value = value.mul(2500).div(1e18);
      // (amount*sqrt(amount*100)*leverage*100/(price*10*125000/1000));
      return value.mul(sqrt(value.mul(10000))).mul(_leverage*100*leverageMultiplier).div(optionPrice.mul(1250000000));
    }

    /**
    * @dev Calculate the option price for given params
    * params
    * 0 _option
    * 1 neutralMinValue
    * 2 neutralMaxValue
    * 3 startTime
    * 4 expireTime
    * 5 totalStakedETH
    * 6 totalStakedToken
    * 7 ethStakedOnOption
    * 8 plotStakedOnOption
    */
    function calculateOptionPrice(uint[] memory params, address marketFeedAddress) public view returns(uint _optionPrice) {
      uint _totalStaked = params[5].add(getAssetValueETH(plotToken, params[6]));
      uint _assetStakedOnOption = params[7]
                                .add(
                                  (getAssetValueETH(plotToken, params[8])));
      _optionPrice = 0;
      uint currentPriceOption = 0;
      uint256 currentPrice = getAssetPriceUSD(
          marketFeedAddress
      );
      uint stakeWeightage = STAKE_WEIGHTAGE;
      uint predictionWeightage = 100 - stakeWeightage;
      uint predictionTime = params[4].sub(params[3]);
      uint minTimeElapsed = (predictionTime).div(minTimeElapsedDivisor);
      if(now > params[4]) {
        return 0;
      }
      if(_totalStaked > STAKE_WEIGHTAGE_MIN_AMOUNT) {
        _optionPrice = (_assetStakedOnOption).mul(1000000).div(_totalStaked.mul(stakeWeightage));
      }

      uint maxDistance;
      if(currentPrice < params[1]) {
        currentPriceOption = 1;
        maxDistance = 2;
      } else if(currentPrice > params[2]) {
        currentPriceOption = 3;
        maxDistance = 2;
      } else {
        currentPriceOption = 2;
        maxDistance = 1;
      }
      uint distance = _getAbsoluteDifference(currentPriceOption, params[0]);
      uint timeElapsed = now > params[3] ? now.sub(params[3]) : 0;
      timeElapsed = timeElapsed > minTimeElapsed ? timeElapsed: minTimeElapsed;
      _optionPrice = _optionPrice.add((((maxDistance+1).sub(distance)).mul(1000000).mul(timeElapsed)).div((maxDistance+1).mul(predictionWeightage).mul(predictionTime)));
      _optionPrice = _optionPrice.div(100);
    }

    /**
    * @dev Internal function to get the absolute difference of two values
    */
    function _getAbsoluteDifference(uint value1, uint value2) internal pure returns(uint) {
      return value1 > value2 ? value1.sub(value2) : value2.sub(value1);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"constant":true,"inputs":[{"name":"_marketFeedAddress","type":"address"}],"name":"getPriceCalculationParams","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getDisputeResolutionParams","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"initialized","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_asset","type":"address"},{"name":"_user","type":"address"},{"name":"_predictionStake","type":"uint256"},{"name":"predictionPoints","type":"uint256"},{"name":"_stakeValue","type":"uint256"}],"name":"checkMultiplier","outputs":[{"name":"","type":"uint256"},{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"pair","type":"address"},{"name":"amountIn","type":"uint256"}],"name":"getPrice","outputs":[{"name":"amountOut","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_addressParams","type":"address[]"},{"name":"_initiater","type":"address"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_currencyAddress","type":"address"},{"name":"_amount","type":"uint256"}],"name":"getAssetValueETH","outputs":[{"name":"tokenEthValue","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"params","type":"uint256[]"},{"name":"marketFeedAddress","type":"address"}],"name":"calculateOptionPrice","outputs":[{"name":"_optionPrice","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"authorizedAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getFeedAddresses","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_priceFeed","type":"address"}],"name":"getPriceFeedDecimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"params","type":"uint256[]"},{"name":"asset","type":"address"},{"name":"user","type":"address"},{"name":"marketFeedAddress","type":"address"},{"name":"_checkMultiplier","type":"bool"}],"name":"calculatePredictionValue","outputs":[{"name":"_predictionValue","type":"uint256"},{"name":"_multiplierApplied","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"code","type":"bytes8"},{"name":"value","type":"uint256"}],"name":"updateUintParameters","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"setInitialCummulativePrice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"update","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_currencyFeedAddress","type":"address"}],"name":"getAssetPriceUSD","outputs":[{"name":"latestAnswer","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_asset","type":"address"},{"name":"_amount","type":"uint256"}],"name":"getValueAndMultiplierParameters","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"code","type":"bytes8"},{"name":"value","type":"address"}],"name":"updateAddressParameters","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getBasicMarketDetails","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_currencyAddress","type":"address"}],"name":"getAssetPriceInETH","outputs":[{"name":"tokenEthValue","type":"uint256"},{"name":"decimals","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_currencyFeedAddress","type":"address"},{"name":"_settleTime","type":"uint256"}],"name":"getSettlemetPrice","outputs":[{"name":"latestAnswer","type":"uint256"},{"name":"roundId","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

32345:18273:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;32345:18273:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41782:500;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;41782:500:0;-1:-1:-1;;;;;41782:500:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44970:114;;;:::i;:::-;;;;;;;;;;;;;;;;33122:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;35436:828;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;35436:828:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;46101:244;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;46101:244:0;;;;;;;;:::i;33788:753::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;33788:753:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;33788:753:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;33788:753:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;33788:753:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;33788:753:0;;-1:-1:-1;;;33788:753:0;;-1:-1:-1;;;;;33788:753:0;;-1:-1:-1;33788:753:0;;-1:-1:-1;33788:753:0:i;:::-;;43976:307;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;43976:307:0;;;;;;;;:::i;48624:1724::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;48624:1724:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;48624:1724:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;48624:1724:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;48624:1724:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;48624:1724:0;;-1:-1:-1;;;48624:1724:0;;-1:-1:-1;;;;;48624:1724:0;;-1:-1:-1;48624:1724:0;;-1:-1:-1;48624:1724:0:i;33083:32::-;;;:::i;:::-;;;;-1:-1:-1;;;;;33083:32:0;;;;;;;;;;;;;;45925:109;;;:::i;40569:140::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;40569:140:0;-1:-1:-1;;;;;40569:140:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;46986:821;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;46986:821:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;46986:821:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;46986:821:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;46986:821:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;46986:821:0;;-1:-1:-1;;;;;;;46986:821:0;;;;;-1:-1:-1;46986:821:0;;;;;;;;;;;;;;;-1:-1:-1;46986:821:0;;;;;;-1:-1:-1;46986:821:0;:::i;36341:1270::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;;36341:1270:0;;;;;;;;:::i;39833:657::-;;;:::i;38215:1534::-;;;:::i;42509:203::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42509:203:0;-1:-1:-1;;;;;42509:203:0;;:::i;45406:415::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;45406:415:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;37688:443;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;37688:443:0;;-1:-1:-1;;;;;;37688:443:0;;;;;-1:-1:-1;;;;;37688:443:0;;:::i;41028:287::-;;;:::i;44512:370::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44512:370:0;-1:-1:-1;;;;;44512:370:0;;:::i;42939:800::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;42939:800:0;;;;;;;;:::i;41782:500::-;41923:7;41945;41967;41989;42024:22;42049:60;42080:18;42049:16;:60::i;:::-;42142:15;;42172:26;;42242:21;;42142:15;;42172:26;;-1:-1:-1;42024:85:0;;-1:-1:-1;42242:21:0;-1:-1:-1;41782:500:0;-1:-1:-1;;;41782:500:0:o;44970:114::-;45056:20;;44970:114;:::o;33122:23::-;;;-1:-1:-1;;;33122:23:0;;;;;:::o;35436:828::-;35650:15;;:52;;;-1:-1:-1;;;;;35650:52:0;;-1:-1:-1;;;;;35650:52:0;;;;;;;-1:-1:-1;;;;;35650:52:0;;;;35698:3;35650:52;;;;;;35576:4;;;;;;;;35650:15;;;;;:34;;:52;;;;;;;;;;;;;;:15;:52;;;5:2:-1;;;;30:1;27;20:12;5:2;35650:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35650:52:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35650:52:0;;-1:-1:-1;35711:28:0;35778:57;35810:6;35818:16;35778:31;:57::i;:::-;35861:21;;35748:87;;-1:-1:-1;35847:35:0;;35844:104;;-1:-1:-1;35844:104:0;;35903:16;35920:17;35895:43;;;;;;;;;35844:104;35974:3;35956:15;35989:43;:14;36008:23;35989:43;:18;:43;:::i;:::-;:47;35986:194;;;36075:60;36103:31;:23;36131:2;36103:31;:27;:31;:::i;:::-;36075:23;:14;36094:3;36075:23;:18;:23;:::i;:::-;:27;:60;:27;:60;:::i;:::-;36166:4;;-1:-1:-1;36062:73:0;35986:194;36196:41;36233:3;36196:32;:16;36217:10;36196:32;:20;:32;:::i;:41::-;36188:68;-1:-1:-1;36238:17:0;;-1:-1:-1;;;;35436:828:0;;;;;;;;;:::o;46101:244::-;-1:-1:-1;;;;;46247:21:0;;46199:17;46247:21;;;:15;:21;;;;;;;;46246:55;;;;;;;;;-1:-1:-1;;;;;46246:55:0;;;:91;;:65;;46302:8;46246:65;:55;:65;:::i;:::-;:89;:91::i;:::-;-1:-1:-1;;;;;46234:103:0;;46101:244;-1:-1:-1;;;46101:244:0:o;33788:753::-;33887:30;33983:4;33887:114;;34034:5;-1:-1:-1;;;;;34034:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34034:18:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34034:18:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34034:18:0;-1:-1:-1;;;;;34020:32:0;:10;:32;34012:71;;;;;-1:-1:-1;;;;;34012:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;34103:11;;-1:-1:-1;;;34103:11:0;;;;34102:12;34094:44;;;;;-1:-1:-1;;;;;34094:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;34149:11;:18;;-1:-1:-1;;34149:18:0;-1:-1:-1;;;34149:18:0;;;34178:23;:21;:23::i;:::-;34212:17;:30;;-1:-1:-1;;;;;;34212:30:0;34232:10;34212:30;;;;;;34288:45;;;-1:-1:-1;;;;;34288:45:0;;;;:43;;:45;;;;;;;;;;;;;;;34232:10;34288:45;;;5:2:-1;;;;30:1;27;20:12;5:2;34288:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34288:45:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34288:45:0;34253:15;:81;;-1:-1:-1;;;;;;34253:81:0;-1:-1:-1;;;;;34253:81:0;;;;;;;;;34357:17;;;;-1:-1:-1;;34357:17:0;;;;;;;;;;;;;;;;34345:9;:29;;-1:-1:-1;;;;;;34345:29:0;;;-1:-1:-1;;;;;34345:29:0;;;;;;;34385:9;:22;;;;;;;;;;;;;;34444:17;;;;-1:-1:-1;;34444:17:0;;;;;;;;;;-1:-1:-1;;;;;34425:42:0;;:44;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34425:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34425:44:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34425:44:0;34418:4;:51;;-1:-1:-1;;;;;;34418:51:0;-1:-1:-1;;;;;34418:51:0;;;;;;;;;34515:17;;;;34530:1;;34515:17;;;;;;;;;;;;34480:14;;:53;;;;;-1:-1:-1;;;;;34480:53:0;;;;;-1:-1:-1;;;;;34480:53:0;;;;;;33788:753;;;:::o;43976:307::-;44148:7;-1:-1:-1;;;;;44170:31:0;;32470:42;44170:31;44166:110;;44243:11;;44234:30;;-1:-1:-1;;;;;44243:11:0;44256:7;44234:8;:30::i;:::-;44218:46;;44166:110;43976:307;;;;:::o;48624:1724::-;48723:17;48751;48771:53;48785:38;48802:9;;;;;;;;;-1:-1:-1;;;;;48802:9:0;48813:6;48820:1;48813:9;;;;;;;;;;;;;;48785:16;:38::i;:::-;48771:6;48778:1;48771:9;;;;;;;;;;;;;;:13;;:53;;;;:::i;:::-;48751:73;;48833:25;48861:125;48946:38;48963:9;;;;;;;;;-1:-1:-1;;;;;48963:9:0;48974:6;48981:1;48974:9;;;;;;;48946:38;48861:6;48868:1;48861:9;;;;;;;:125;49010:1;;-1:-1:-1;48833:153:0;-1:-1:-1;49010:1:0;;49079:55;49108:17;49079:16;:55::i;:::-;49056:78;;49143:19;49165:15;;49143:37;;49189:24;49222:14;49216:3;:20;49189:47;;49245:19;49267:24;49281:6;49288:1;49281:9;;;;;;;;;;;;;;49267:6;49274:1;49267:9;;;;;;;;;;;;;;:13;;:24;;;;:::i;:::-;49245:46;;49300:19;49322:43;49343:21;;49323:14;49322:20;;:43;;;;:::i;:::-;49300:65;;49383:6;49390:1;49383:9;;;;;;;;;;;;;;49377:3;:15;49374:49;;;49412:1;49405:8;;;;;;;;;;;;49374:49;49449:26;;49434:12;:41;49431:155;;;49503:73;49543:32;:12;49560:14;49543:32;:16;:32;:::i;:::-;49503:35;49504:20;49530:7;49503:35;:26;:35;:::i;:73::-;49488:88;;49431:155;49596:16;49639:6;49646:1;49639:9;;;;;;;;;;;;;;49624:12;:24;49621:277;;;-1:-1:-1;49682:1:0;;-1:-1:-1;49708:1:0;49621:277;;;49743:6;49750:1;49743:9;;;;;;;;;;;;;;49728:12;:24;49725:173;;;-1:-1:-1;49786:1:0;;-1:-1:-1;49812:1:0;49725:173;;;-1:-1:-1;49861:1:0;;-1:-1:-1;49887:1:0;49725:173;49906:13;49922:53;49945:18;49965:6;49972:1;49965:9;;;;;;;;;;;;;;49922:22;:53::i;:::-;49906:69;;49984:16;50009:6;50016:1;50009:9;;;;;;;;;;;;;;50003:3;:15;:40;;50042:1;50003:40;;;50021:18;50029:6;50036:1;50029:9;;;;;;;;;;;;;;50021:3;:7;;:18;;;;:::i;:::-;49984:59;;50080:14;50066:11;:28;:58;;50110:14;50066:58;;;50097:11;50066:58;50052:72;-1:-1:-1;50148:147:0;50165:129;50233:60;50278:14;50233:40;50246:1;50234:13;;50253:19;50233:40;:19;:40;:::i;:::-;:44;:60;:44;:60;:::i;:::-;50166:61;50215:11;50166:44;50202:7;50166:44;50180:1;50168:13;;50187:8;50167:29;:19;:29;:::i;50165:129::-;50148:12;;:147;:16;:147;:::i;:::-;50133:162;-1:-1:-1;50319:21:0;50133:162;50336:3;50319:21;:16;:21;:::i;:::-;50304:36;48624:1724;-1:-1:-1;;;;;;;;;;;;;;48624:1724:0:o;33083:32::-;;;-1:-1:-1;;;;;33083:32:0;;:::o;45925:109::-;46010:14;;-1:-1:-1;;;;;46010:14:0;45925:109;:::o;40569:140::-;40639:5;40679:10;-1:-1:-1;;;;;40662:37:0;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;40662:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;40662:39:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;40662:39:0;;40569:140;-1:-1:-1;;40569:140:0:o;46986:821::-;47141:21;47164:23;47198:16;47217:34;47234:5;47241:6;47248:1;47241:9;;;;;;;47217:34;47198:53;;47277:19;;47263:11;:33;:70;;;;47314:19;;47300:11;:33;47263:70;47260:141;;;-1:-1:-1;47346:45:0;;47260:141;47409:16;47456:47;47477:6;47485:17;47456:20;:47::i;:::-;47442:61;;47531:86;47558:33;47574:16;;47558:11;:15;;:33;;;;:::i;:::-;47593:11;47606:6;47613:2;47606:10;;;;;;;;;;;;;;47531:26;:86::i;:::-;47512:105;;47629:16;47626:120;;;47665:71;47681:5;47688:4;47694:6;47701:1;47694:9;;;;;;;;;;;;;;47706:16;47724:11;47665:15;:71::i;:::-;47658:78;;;;;;;;47626:120;-1:-1:-1;;46986:821:0;;;;;;;;:::o;36341:1270::-;33643:17;;-1:-1:-1;;;;;33643:17:0;33629:10;:31;33621:58;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;36461:12:0;;;36457:1147;;;36526:3;36517:5;:12;;36509:59;;;;-1:-1:-1;;;;;36509:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36583:15;:23;;;36457:1147;;;-1:-1:-1;;;;;;;;;;;36628:14:0;;;36624:980;;;36706:26;:34;;;36624:980;;;-1:-1:-1;;;;;;;;;;;36762:14:0;;;36758:846;;;36825:21;:29;;;36758:846;;;-1:-1:-1;;;;;;;;;;;36876:16:0;;;36872:732;;;36937:19;:27;;;36872:732;;;-1:-1:-1;;;;;;;;;;;36986:16:0;;;36982:622;;;37047:19;:27;;;36982:622;;;-1:-1:-1;;;;;;;;;;;37096:14:0;;;37092:512;;;37150:16;:24;;;37092:512;;;-1:-1:-1;;;;;;;;;;;37196:16:0;;;37192:412;;;37275:21;:29;;;37192:412;;;-1:-1:-1;;;;;;;;;;;37326:15:0;;;37322:282;;;37377:14;:22;;;37322:282;;;-1:-1:-1;;;;;;;;;;;37421:16:0;;;37417:187;;;37509:20;:28;;;37417:187;;;37570:22;;;-1:-1:-1;;;;;37570:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;37417:187;36341:1270;;:::o;39833:657::-;39909:9;;-1:-1:-1;;;;;39909:9:0;39895:10;:23;39887:32;;;;;;39936:11;;-1:-1:-1;;;;;39936:11:0;:25;39928:56;;;;;-1:-1:-1;;;;;39928:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;40007:14;;40030:9;;40041:4;;40007:39;;;-1:-1:-1;;;;;40007:39:0;;-1:-1:-1;;;;;40030:9:0;;;40007:39;;;;40041:4;;;40007:39;;;;;:14;;;;;:22;;:39;;;;;;;;;;;;;;:14;:39;;;5:2:-1;;;;30:1;27;20:12;5:2;40007:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;40007:39:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;40007:39:0;39993:11;:53;;-1:-1:-1;;;;;;39993:53:0;-1:-1:-1;;;;;39993:53:0;;;;;;;;40109:11;-1:-1:-1;40093:28:0;;;:15;40007:39;40093:28;;;;;-1:-1:-1;;;;40250:59:0;;:46;:59::i;:::-;40318:31;;;:50;;;;40377:31;;;:50;40436:29;;;;:46;;-1:-1:-1;;40436:46:0;;;;;;;;;;;;-1:-1:-1;;;39833:657:0:o;38215:1534::-;33643:17;;-1:-1:-1;;;;;33643:17:0;33629:10;:31;33621:58;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;;;;38276:11;;-1:-1:-1;;;;;38276:11:0;38268:58;;;;;-1:-1:-1;;;;;38268:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38391:11;;-1:-1:-1;;;;;38391:11:0;38337:35;38375:28;;;:15;:28;;;;;;38337:35;;;;38542:59;;:46;:59::i;:::-;38650:29;;;;38414:187;;-1:-1:-1;38414:187:0;;-1:-1:-1;38414:187:0;-1:-1:-1;38650:29:0;;;;38633:46;;;32551:7;38719:27;;;;;;:54;;-1:-1:-1;38751:22:0;;;;-1:-1:-1;;;38751:22:0;;;;38750:23;38719:54;38715:1027;;;39003:194;;;;;;;;39152:11;39072:91;;39092:10;:31;;;39073:16;:50;39072:91;;;;;;-1:-1:-1;;;;;39003:194:0;;;;;;38976:221;;;;-1:-1:-1;;;;;;38976:221:0;;;;;;39239:194;;;;;;;;;39328:31;;;;39239:194;;39308:91;;;;39309:50;;39308:91;;;;;;-1:-1:-1;;;;;39239:194:0;;;;;;39212:221;;:24;;;:221;;-1:-1:-1;;;;;;39212:221:0;;;;;;;;-1:-1:-1;39450:31:0;;:50;;;39515:31;;;:50;;;39580:29;;;:46;;-1:-1:-1;;39580:46:0;;;;;;;;;-1:-1:-1;;;39645:22:0;;;;39641:90;;39686:22;;;:29;;-1:-1:-1;;39686:29:0;-1:-1:-1;;;39686:29:0;;;39641:90;33690:1;;;;;38215:1534::o;42509:203::-;42602:20;42667;-1:-1:-1;;;;;42650:51:0;;:53;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;45406:415:0;45528:7;;45579;-1:-1:-1;;;;;45601:21:0;;32470:42;45601:21;45597:168;;;45665:11;;-1:-1:-1;;;;;45665:11:0;45649:28;;;;:15;:28;;;;;;;;;45648:66;;;;;;;;45649:42;;;;45648:66;-1:-1:-1;;;;;45648:66:0;;;:105;;:75;;45715:7;45648:75;:66;:75;:::i;:105::-;-1:-1:-1;;;;;45639:114:0;;;45597:168;45783:21;;;45806:6;;-1:-1:-1;45406:415:0;-1:-1:-1;;;45406:415:0:o;37688:443::-;33643:17;;-1:-1:-1;;;;;33643:17:0;33629:10;:31;33621:58;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;-1:-1:-1;;;;;33621:58:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;37823:19:0;;37815:58;;;;;-1:-1:-1;;;;;37815:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;37888:16:0;;;37884:240;;;37948:14;:41;;-1:-1:-1;;;;;;37948:41:0;-1:-1:-1;;;;;37948:41:0;;;;;;;;;;;38041:9;;38052:4;;38018:39;;;-1:-1:-1;;;;;38018:39:0;;38041:9;;;38018:39;;;;38052:4;;;38018:39;;;;;:14;;;;;:22;;:39;;;;;;;;;;;;;;;:14;:39;;;5:2:-1;;;;30:1;27;20:12;5:2;38018:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38018:39:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;38018:39:0;38004:11;:53;;-1:-1:-1;;;;;;38004:53:0;-1:-1:-1;;;;;38004:53:0;;;;;;;;;37884:240;;41028:287;41232:19;;41253:14;;41269:16;;41287:19;;41028:287;;;;:::o;44512:370::-;44687:1;44614:21;-1:-1:-1;;;;;44703:31:0;;32470:42;44703:31;44699:176;;44769:16;-1:-1:-1;;;;;44762:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44762:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44762:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44762:35:0;44837:11;;;44751:46;;;;;-1:-1:-1;44828:35:0;;-1:-1:-1;;;;;44837:11:0;;44850:12;;;44828:8;:35::i;:::-;44812:51;;44699:176;44512:370;;;:::o;42939:800::-;43063:20;43085:15;43113:21;43145:24;43180:25;43293:20;-1:-1:-1;;;;;43276:54:0;;:56;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43276:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43276:56:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;43276:56:0;;;;;;;;;;;;;-1:-1:-1;43276:56:0;-1:-1:-1;43276:56:0;-1:-1:-1;43343:313:0;43368:11;43349:16;:30;43343:313;;;43487:67;;;-1:-1:-1;;;;;43487:67:0;;;-1:-1:-1;;43396:16:0;;;43487:67;;;;;;;;;-1:-1:-1;;;;;43487:51:0;;;;;:67;;;;;;;;;;;;;;:51;:67;;;5:2:-1;;;;30:1;27;20:12;5:2;43487:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43487:67:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;43487:67:0;;;;;;;;;;;;;-1:-1:-1;43487:67:0;-1:-1:-1;43487:67:0;-1:-1:-1;43572:31:0;;;43569:76;;43624:5;;43569:76;43343:313;;;43695:18;-1:-1:-1;;43666:65:0;;;-1:-1:-1;42939:800:0;;;;;:::o;13598:333::-;13656:7;13755:1;13751;:5;13743:44;;;;;-1:-1:-1;;;;;13743:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13798:9;13814:1;13810;:5;;;;;;;13598:333;-1:-1:-1;;;;13598:333:0:o;12659:471::-;12717:7;12962:6;12958:47;;-1:-1:-1;12992:1:0;12985:8;;12958:47;13029:5;;;13033:1;13029;:5;:1;13053:5;;;;;:10;13045:56;;;;-1:-1:-1;;;;;13045:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7096:253;7163:16;;:::i;:::-;7192:6;7217;;;:54;;-1:-1:-1;;7263:7:0;;-1:-1:-1;;;;;7258:13:0;7232:17;;;;7253:1;7232:17;7253:1;7227:27;;;;;:44;7217:54;7209:102;;;;-1:-1:-1;;;;;7209:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7329:12;;;;;;;;;;;;;7096:253;-1:-1:-1;;;7096:253:0:o;8050:130::-;8150:7;6256:3;8150:21;;8050:130::o;34620:391::-;34691:2;34673:15;:20;34736:8;34707:26;:37;34779:1;34755:21;:25;;;34813:4;34791:19;:26;34850:8;34828:19;:30;34888:3;34869:16;:22;34926:4;34902:28;;34958:2;34941:14;:19;34994:9;34971:20;:32;34620:391::o;11239:181::-;11297:7;11329:5;;;11353:6;;;;11345:46;;;;;-1:-1:-1;;;;;11345:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;11695:184;11753:7;11786:1;11781;:6;;11773:49;;;;;-1:-1:-1;;;;;11773:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11845:5:0;;;11695:184::o;50448:167::-;50528:4;50559:6;50550;:15;:57;;50589:18;:6;50600;50589:18;:10;:18;:::i;:::-;50550:57;;;50568:18;:6;50579;50568:18;:10;:18;:::i;47815:503::-;47919:4;48052;48073:2;-1:-1:-1;;48060:11:0;;48059:16;48052:23;48092:25;48112:4;48092:15;:5;48102:4;48092:15;:9;:15;:::i;:25::-;48084:33;-1:-1:-1;48206:104:0;48282:27;:11;48298:10;48282:27;:15;:27;:::i;:::-;48206:71;48244:32;;;48254:3;48244:32;48206:33;48216:22;48221:16;:5;48231;48221:16;:9;:16;:::i;:::-;48216:4;:22::i;:::-;48206:5;;:33;:9;:33;:::i;:104::-;48199:111;47815:503;-1:-1:-1;;;;;47815:503:0:o;9244:1058::-;9330:21;9353;9376;9427:23;:21;:23::i;:::-;9410:40;;9495:4;-1:-1:-1;;;;;9480:41:0;;:43;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9480:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;9480:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9480:43:0;9553;;;-1:-1:-1;;;;;9553:43:0;;;;9480;;-1:-1:-1;;;;;;9553:41:0;;;;;:43;;;;;9480;;9553;;;;;;;;:41;:43;;;5:2:-1;;;;30:1;27;20:12;5:2;9553:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;9553:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9553:43:0;9776:34;;;-1:-1:-1;;;;;9776:34:0;;;;9553:43;;-1:-1:-1;9711:16:0;;;;;;-1:-1:-1;;;;;9776:32:0;;;;;:34;;;;;;;;;;;;;;:32;:34;;;5:2:-1;;;;30:1;27;20:12;5:2;9776:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;9776:34:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9776:34:0;;;;;;;;;;;;;-1:-1:-1;9776:34:0;;-1:-1:-1;9776:34:0;-1:-1:-1;9825:36:0;;;;;;;;9821:474;;9947:35;;;10093:62;;;10098:39;10118:8;10128;10098:19;:39::i;:::-;:42;-1:-1:-1;;;;;10093:48:0;:62;10073:82;;;;;10221:62;;;10226:39;10246:8;10256;10226:19;:39::i;:::-;:42;-1:-1:-1;;;;;10221:48:0;:62;10201:82;;;;;-1:-1:-1;9821:474:0;9244:1058;;;;;;;;:::o;46428:186::-;46500:5;46509:1;46504;46500:5;;46499:11;46533:74;46544:1;46540;:5;46533:74;;;46564:1;46560:5;;46596:1;46591;46587;46583;:5;;;;;;:9;46582:15;;;;;;46578:19;;46533:74;;;46428:186;;;;:::o;9015:123::-;9104:25;:15;:25;;9015:123::o;7505:246::-;7586:16;;:::i;:::-;7637:1;7623:11;-1:-1:-1;;;;;7623:15:0;;7615:51;;;;;-1:-1:-1;;;;;7615:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7684:59;;;;;;;;;;-1:-1:-1;;;;;7694:48:0;;;;7695:18;;6256:3;7695:32;-1:-1:-1;;;;;7694:48:0;;;;;;;-1:-1:-1;;;;;7684:59:0;;;;7677:66;;7505:246;;;;:::o;32345:18273::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;32345:18273:0;;;:::o

Swarm Source

bzzr://2c9a63c6bce24180f46218d241cf22d0fec2239ec78eb35e1c5c15768d50c163

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 30 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.

Tools & Services