ETH Price: $3,509.53 (+0.65%)
Gas: 2 Gwei

Contract

0x6369c3DadfC00054A42BA8B2c09c48131dd4Aa38
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

TokenTracker

Morpher (MPH) (@$0.0244)

Multichain Info

1 address found via
Transaction Hash
Method
Block
From
To
0x1abea276d1173517d62383844782cd7d1b1e8ec250eb8e1a3c21c189065269cf Approve(pending)2024-07-21 0:06:4156 mins ago1721520401IN
Morpher: MPH Token
0 ETH(Pending)(Pending)
Approve203116582024-07-15 11:37:235 days ago1721043443IN
Morpher: MPH Token
0 ETH0.000153332.74117048
Approve202645902024-07-08 21:53:5912 days ago1720475639IN
Morpher: MPH Token
0 ETH0.000102891.83947416
Approve201457912024-06-22 7:35:4728 days ago1719041747IN
Morpher: MPH Token
0 ETH0.000119552.13719061
Transfer201456132024-06-22 6:59:5928 days ago1719039599IN
Morpher: MPH Token
0 ETH0.000164863.0787843
Transfer201456112024-06-22 6:59:3528 days ago1719039575IN
Morpher: MPH Token
0 ETH0.00015812.95259022
Transfer201456092024-06-22 6:59:1128 days ago1719039551IN
Morpher: MPH Token
0 ETH0.000158022.95100349
Transfer201456082024-06-22 6:58:5928 days ago1719039539IN
Morpher: MPH Token
0 ETH0.000157772.94643372
Transfer201456072024-06-22 6:58:4728 days ago1719039527IN
Morpher: MPH Token
0 ETH0.000165593.09247639
Transfer201456052024-06-22 6:58:2328 days ago1719039503IN
Morpher: MPH Token
0 ETH0.000234973.32606434
Approve201394282024-06-21 10:14:1129 days ago1718964851IN
Morpher: MPH Token
0 ETH0.000374656.7047043
Approve201381112024-06-21 5:49:4729 days ago1718948987IN
Morpher: MPH Token
0 ETH0.000189223.38277613
Approve201037432024-06-16 10:25:4734 days ago1718533547IN
Morpher: MPH Token
0 ETH0.000137094.07368563
Transfer201019242024-06-16 4:20:5934 days ago1718511659IN
Morpher: MPH Token
0 ETH0.000218524.07810571
Approve200403782024-06-07 13:54:2343 days ago1717768463IN
Morpher: MPH Token
0 ETH0.0005388516.01113074
Approve199878112024-05-31 5:45:1150 days ago1717134311IN
Morpher: MPH Token
0 ETH0.00044538
Transfer198899772024-05-17 13:25:5964 days ago1715952359IN
Morpher: MPH Token
0 ETH0.000457596.47709922
Transfer198677042024-05-14 10:38:4767 days ago1715683127IN
Morpher: MPH Token
0 ETH0.000608188.60873266
Approve198638182024-05-13 21:35:4768 days ago1715636147IN
Morpher: MPH Token
0 ETH0.000204215.3070839
Approve198638092024-05-13 21:33:5968 days ago1715636039IN
Morpher: MPH Token
0 ETH0.000297955.36088549
Transfer198558772024-05-12 18:58:2369 days ago1715540303IN
Morpher: MPH Token
0 ETH0.000474286.71337632
Approve198354112024-05-09 22:17:1172 days ago1715293031IN
Morpher: MPH Token
0 ETH0.000230964.13329228
Approve198323692024-05-09 12:04:4772 days ago1715256287IN
Morpher: MPH Token
0 ETH0.000231024.15678001
Approve197815732024-05-02 9:34:1179 days ago1714642451IN
Morpher: MPH Token
0 ETH0.00026187.77897126
Transfer197054252024-04-21 17:58:5990 days ago1713722339IN
Morpher: MPH Token
0 ETH0.0011672516.52218787
View all transactions

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MorpherToken

Compiler Version
v0.5.16+commit.9c3226ce

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv2 license

Contract Source Code (Solidity Multiple files format)

File 1 of 6: MorpherToken.sol
pragma solidity 0.5.16;

import "./IERC20.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./MorpherState.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract MorpherToken is IERC20, Ownable {

    MorpherState state;
    using SafeMath for uint256;

    string public constant name     = "Morpher";
    string public constant symbol   = "MPH";
    uint8  public constant decimals = 18;
    
    modifier onlyState {
        require(msg.sender == address(state), "ERC20: caller must be MorpherState contract.");
        _;
    }

    modifier canTransfer {
        require(state.mainChain() == true || state.getCanTransfer(msg.sender), "ERC20: token transfers disabled on sidechain.");
        _;
    }
    
    event LinkState(address _address);

    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    constructor(address _stateAddress, address _coldStorageOwnerAddress) public {
        setMorpherState(_stateAddress);
        transferOwnership(_coldStorageOwnerAddress);
    }

    // ------------------------------------------------------------------------
    // Links Token Contract with State
    // ------------------------------------------------------------------------
    function setMorpherState(address _stateAddress) public onlyOwner {
        state = MorpherState(_stateAddress);
        emit LinkState(_stateAddress);
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return state.totalSupply();
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address _account) public view returns (uint256) {
        return state.balanceOf(_account);
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     * 
     * Emits a {Transfer} event via emitTransfer called by MorpherState
     */
    function transfer(address _recipient, uint256 _amount) public returns (bool) {
        _transfer(msg.sender, _recipient, _amount);
        return true;
    }

   /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address _owner, address _spender) public view returns (uint256) {
        return state.getAllowance(_owner, _spender);
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address _spender, uint256 _amount) public returns (bool) {
        _approve(msg.sender, _spender, _amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `_sender` and `_recipient` cannot be the zero address.
     * - `_sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `_sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address _sender, address _recipient, uint256 amount) public returns (bool) {
        _transfer(_sender, _recipient, amount);
        _approve(_sender, msg.sender, state.getAllowance(_sender, msg.sender).sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `_spender` cannot be the zero address.
     */
    function increaseAllowance(address _spender, uint256 _addedValue) public returns (bool) {
        _approve(msg.sender, _spender, state.getAllowance(msg.sender, _spender).add(_addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address _spender, uint256 _subtractedValue) public returns (bool) {
        _approve(msg.sender, _spender,  state.getAllowance(msg.sender, _spender).sub(_subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Caller destroys `_amount` tokens permanently
     *
     * Emits a {Transfer} event to zero address called by MorpherState via emitTransfer.
     *
     * Requirements:
     *
     * - Caller must have token balance of at least `_amount`
     * 
     */
     function burn(uint256 _amount) public returns (bool) {
        state.burn(msg.sender, _amount);
        return true;
    }

    /**
     * @dev Emits a {Transfer} event
     *
     * MorpherState emits a {Transfer} event.
     *
     * Requirements:
     *
     * - Caller must be MorpherState
     * 
     */
     function emitTransfer(address _from, address _to, uint256 _amount) public onlyState {
        emit Transfer(_from, _to, _amount);
    }

     /**
     * @dev Moves tokens `_amount` from `sender` to `_recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event via emitTransfer called by MorpherState
     *
     * Requirements:
     *
     * - `_sender` cannot be the zero address.
     * - `_recipient` cannot be the zero address.
     * - `_sender` must have a balance of at least `_amount`.
     */
    function _transfer(address _sender, address _recipient, uint256 _amount) canTransfer internal {
        require(_sender != address(0), "ERC20: transfer from the zero address");
        require(_recipient != address(0), "ERC20: transfer to the zero address");
        require(state.balanceOf(_sender) >= _amount, "ERC20: transfer amount exceeds balance");
        state.transfer(_sender, _recipient, _amount);
    }

    /**
     * @dev Sets `_amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address _owner, address _spender, uint256 _amount) internal {
        require(_owner != address(0), "ERC20: approve from the zero address");
        require(_spender != address(0), "ERC20: approve to the zero address");
        state.setAllowance(_owner, _spender, _amount);
        emit Approval(_owner, _spender, _amount);
    }

    // ------------------------------------------------------------------------
    // Don't accept ETH
    // ------------------------------------------------------------------------
    function () external payable {
        revert("ERC20: You can't deposit Ether here");
    }
}

File 2 of 6: IERC20.sol
pragma solidity 0.5.16;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @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 3 of 6: IMorpherToken.sol
pragma solidity 0.5.16;

interface IMorpherToken {
    /**
     * Emits a {Transfer} event in ERC-20 token contract.
     */
    function emitTransfer(address _from, address _to, uint256 _amount) external;
}

File 4 of 6: MorpherState.sol
pragma solidity 0.5.16;

import "./Ownable.sol";
import "./SafeMath.sol";
import "./IMorpherToken.sol";

// ----------------------------------------------------------------------------------
// Data and token balance storage of the Morpher platform
// Writing access is only granted to platform contracts. The contract can be paused
// by an elected platform administrator (see MorpherGovernance) to perform protocol updates.
// ----------------------------------------------------------------------------------

contract MorpherState is Ownable {
    using SafeMath for uint256;

    bool public mainChain;
    uint256 public totalSupply;
    uint256 public totalToken;
    uint256 public totalInPositions;
    uint256 public totalOnOtherChain;
    uint256 public maximumLeverage = 10**9; // Leverage precision is 1e8, maximum leverage set to 10 initially
    uint256 constant PRECISION = 10**8;
    uint256 constant DECIMALS = 18;
    uint256 constant REWARDPERIOD = 1 days;
    bool public paused = false;

    address public morpherGovernance;
    address public morpherRewards;
    address public administrator;
    address public oracleContract;
    address public sideChainOperator;
    address public morpherBridge;
    address public morpherToken;

    uint256 public rewardBasisPoints;
    uint256 public lastRewardTime;

    bytes32 public sideChainMerkleRoot;
    uint256 public sideChainMerkleRootWrittenAtTime;

    // Set initial withdraw limit from sidechain to 20m token or 2% of initial supply
    uint256 public mainChainWithdrawLimit24 = 2 * 10**25;

    mapping(address => bool) private stateAccess;
    mapping(address => bool) private transferAllowed;

    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowed;

    mapping(bytes32 => bool) private marketActive;

    // ----------------------------------------------------------------------------
    // Position struct records virtual futures
    // ----------------------------------------------------------------------------
    struct position {
        uint256 lastUpdated;
        uint256 longShares;
        uint256 shortShares;
        uint256 meanEntryPrice;
        uint256 meanEntrySpread;
        uint256 meanEntryLeverage;
        uint256 liquidationPrice;
        bytes32 positionHash;
    }

    // ----------------------------------------------------------------------------
    // A portfolio is an address specific collection of postions
    // ----------------------------------------------------------------------------
    mapping(address => mapping(bytes32 => position)) private portfolio;

    // ----------------------------------------------------------------------------
    // Record all addresses that hold a position of a market, needed for clean stock splits
    // ----------------------------------------------------------------------------
    struct hasExposure {
        uint256 maxMappingIndex;
        mapping(address => uint256) index;
        mapping(uint256 => address) addy;
    }

    mapping(bytes32 => hasExposure) private exposureByMarket;

    // ----------------------------------------------------------------------------
    // Bridge Variables
    // ----------------------------------------------------------------------------
    mapping (address => uint256) private tokenClaimedOnThisChain;
    mapping (address => uint256) private tokenSentToLinkedChain;
    mapping (address => uint256) private tokenSentToLinkedChainTime;
    mapping (bytes32 => bool) private positionClaimedOnMainChain;

    uint256 public lastWithdrawLimitReductionTime;
    uint256 public last24HoursAmountWithdrawn;
    uint256 public withdrawLimit24Hours;
    uint256 public inactivityPeriod = 3 days;
    uint256 public transferNonce;
    bool public fastTransfersEnabled;

    // ----------------------------------------------------------------------------
    // Sidechain spam protection
    // ----------------------------------------------------------------------------

    mapping(address => uint256) private lastRequestBlock;
    mapping(address => uint256) private numberOfRequests;
    uint256 public numberOfRequestsLimit;

    // ----------------------------------------------------------------------------
    // Events
    // ----------------------------------------------------------------------------
    event StateAccessGranted(address indexed whiteList, uint256 indexed blockNumber);
    event StateAccessDenied(address indexed blackList, uint256 indexed blockNumber);

    event TransfersEnabled(address indexed whiteList);
    event TransfersDisabled(address indexed blackList);

    event Transfer(address indexed sender, address indexed recipient, uint256 amount);
    event Mint(address indexed recipient, uint256 amount, uint256 totalToken);
    event Burn(address indexed recipient, uint256 amount, uint256 totalToken);
    event NewTotalSupply(uint256 newTotalSupply);
    event NewTotalOnOtherChain(uint256 newTotalOnOtherChain);
    event NewTotalInPositions(uint256 newTotalOnOtherChain);
    event OperatingRewardMinted(address indexed recipient, uint256 amount);

    event RewardsChange(address indexed rewardsAddress, uint256 indexed rewardsBasisPoints);
    event LastRewardTime(uint256 indexed rewardsTime);
    event GovernanceChange(address indexed governanceAddress);
    event TokenChange(address indexed tokenAddress);
    event AdministratorChange(address indexed administratorAddress);
    event OracleChange(address indexed oracleContract);
    event MaximumLeverageChange(uint256 maxLeverage);
    event MarketActivated(bytes32 indexed activateMarket);
    event MarketDeActivated(bytes32 indexed deActivateMarket);
    event BridgeChange(address _bridgeAddress);
    event SideChainMerkleRootUpdate(bytes32 indexed sideChainMerkleRoot);
    event NewSideChainOperator(address indexed sideChainOperator);
    event NumberOfRequestsLimitUpdate(uint256 _numberOfRequests);

    event MainChainWithdrawLimitUpdate(uint256 indexed mainChainWithdrawLimit24);
    event TokenSentToLinkedChain(address _address, uint256 _token, uint256 _totalTokenSent, bytes32 indexed _tokenSentToLinkedChainHash);
    event TransferredTokenClaimed(address _address, uint256 _token);
    event LastWithdrawAt();
    event RollingWithdrawnAmountUpdated(uint256 _last24HoursAmountWithdrawn, uint256 _lastWithdrawLimitReductionTime);
    event WithdrawLimitUpdated(uint256 _amount);
    event InactivityPeriodUpdated(uint256 _periodLength);
    event FastWithdrawsDisabled();
    event NewBridgeNonce(uint256 _transferNonce);
    event Last24HoursAmountWithdrawnReset();

    event StatePaused(address administrator, bool _paused);

    event SetAllowance(address indexed sender, address indexed spender, uint256 tokens);
    event SetPosition(bytes32 indexed positionHash,
        address indexed sender,
        bytes32 indexed marketId,
        uint256 timeStamp,
        uint256 longShares,
        uint256 shortShares,
        uint256 meanEntryPrice,
        uint256 meanEntrySpread,
        uint256 meanEntryLeverage,
        uint256 liquidationPrice
    );
    event SetBalance(address indexed account, uint256 balance, bytes32 indexed balanceHash);
    event TokenTransferredToOtherChain(address indexed account, uint256 tokenTransferredToOtherChain, bytes32 indexed transferHash);

    modifier notPaused {
        require(paused == false, "MorpherState: Contract paused, aborting");
        _;
    }

    modifier onlyPlatform {
        require(stateAccess[msg.sender] == true, "MorpherState: Only Platform is allowed to execute operation.");
        _;
    }

    modifier onlyGovernance {
        require(msg.sender == getGovernance(), "MorpherState: Calling contract not the Governance Contract. Aborting.");
        _;
    }

    modifier onlyAdministrator {
        require(msg.sender == getAdministrator(), "MorpherState: Caller is not the Administrator. Aborting.");
        _;
    }

    modifier onlySideChainOperator {
        require(msg.sender == sideChainOperator, "MorpherState: Caller is not the Sidechain Operator. Aborting.");
        _;
    }

    modifier canTransfer {
        require(getCanTransfer(msg.sender), "MorpherState: Caller may not transfer token. Aborting.");
        _;
    }

    modifier onlyBridge {
        require(msg.sender == getMorpherBridge(), "MorpherState: Caller is not the Bridge. Aborting.");
        _;
    }

    modifier onlyMainChain {
        require(mainChain == true, "MorpherState: Can only be called on mainchain.");
        _;
    }

    modifier onlySideChain {
        require(mainChain == false, "MorpherState: Can only be called on mainchain.");
        _;
    }

    constructor(bool _mainChain, address _sideChainOperator, address _morpherTreasury) public {
        // @Deployer: Transfer State Ownership to cold storage address after deploying protocol
        mainChain = _mainChain; // true for Ethereum, false for Morpher PoA sidechain
        setLastRewardTime(now);
        uint256 _sideChainMint = 575000000 * 10**(DECIMALS);
        uint256 _mainChainMint = 425000000 * 10**(DECIMALS);
        grantAccess(owner());
        setSideChainOperator(owner());
        if (mainChain == false) { // Create token only on sidechain
            balances[owner()] = _sideChainMint; // Create airdrop and team token on sidechain
            totalToken = _sideChainMint;
            emit Mint(owner(), balanceOf(owner()), _sideChainMint);
            setRewardBasisPoints(0); // Reward is minted on mainchain
            setRewardAddress(address(0));
            setTotalOnOtherChain(_mainChainMint);
        } else {
            balances[owner()] = _mainChainMint; // Create treasury and investor token on mainchain
            totalToken = _mainChainMint;
            emit Mint(owner(), balanceOf(owner()), _mainChainMint);
            setRewardBasisPoints(15000); // 15000 / PRECISION = 0.00015
            setRewardAddress(_morpherTreasury);
            setTotalOnOtherChain(_sideChainMint);
        }
        fastTransfersEnabled = true;
        setNumberOfRequestsLimit(3);
        setMainChainWithdrawLimit(totalSupply / 50);
        setSideChainOperator(_sideChainOperator);
        denyAccess(owner());
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for market wise exposure
    // ----------------------------------------------------------------------------

    function getMaxMappingIndex(bytes32 _marketId) public view returns(uint256 _maxMappingIndex) {
        return exposureByMarket[_marketId].maxMappingIndex;
    }

    function getExposureMappingIndex(bytes32 _marketId, address _address) public view returns(uint256 _mappingIndex) {
        return exposureByMarket[_marketId].index[_address];
    }

    function getExposureMappingAddress(bytes32 _marketId, uint256 _mappingIndex) public view returns(address _address) {
        return exposureByMarket[_marketId].addy[_mappingIndex];
    }

    function setMaxMappingIndex(bytes32 _marketId, uint256 _maxMappingIndex) public onlyPlatform {
        exposureByMarket[_marketId].maxMappingIndex = _maxMappingIndex;
    }

    function setExposureMapping(bytes32 _marketId, address _address, uint256 _index) public onlyPlatform  {
        setExposureMappingIndex(_marketId, _address, _index);
        setExposureMappingAddress(_marketId, _address, _index);
    }

    function setExposureMappingIndex(bytes32 _marketId, address _address, uint256 _index) public onlyPlatform {
        exposureByMarket[_marketId].index[_address] = _index;
    }

    function setExposureMappingAddress(bytes32 _marketId, address _address, uint256 _index) public onlyPlatform {
        exposureByMarket[_marketId].addy[_index] = _address;
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for bridge variables
    // ----------------------------------------------------------------------------
    function setTokenClaimedOnThisChain(address _address, uint256 _token) public onlyBridge {
        tokenClaimedOnThisChain[_address] = _token;
        emit TransferredTokenClaimed(_address, _token);
    }

    function getTokenClaimedOnThisChain(address _address) public view returns (uint256 _token) {
        return tokenClaimedOnThisChain[_address];
    }

    function setTokenSentToLinkedChain(address _address, uint256 _token) public onlyBridge {
        tokenSentToLinkedChain[_address] = _token;
        tokenSentToLinkedChainTime[_address] = now;
        emit TokenSentToLinkedChain(_address, _token, tokenSentToLinkedChain[_address], getBalanceHash(_address, tokenSentToLinkedChain[_address]));
    }

    function getTokenSentToLinkedChain(address _address) public view returns (uint256 _token) {
        return tokenSentToLinkedChain[_address];
    }

    function getTokenSentToLinkedChainTime(address _address) public view returns (uint256 _timeStamp) {
        return tokenSentToLinkedChainTime[_address];
    }

    function add24HoursWithdrawn(uint256 _amount) public onlyBridge {
        last24HoursAmountWithdrawn = last24HoursAmountWithdrawn.add(_amount);
        emit RollingWithdrawnAmountUpdated(last24HoursAmountWithdrawn, lastWithdrawLimitReductionTime);
    }

    function update24HoursWithdrawLimit(uint256 _amount) public onlyBridge {
        if (last24HoursAmountWithdrawn > _amount) {
            last24HoursAmountWithdrawn = last24HoursAmountWithdrawn.sub(_amount);
        } else {
            last24HoursAmountWithdrawn = 0;
        }
        lastWithdrawLimitReductionTime = now;
        emit RollingWithdrawnAmountUpdated(last24HoursAmountWithdrawn, lastWithdrawLimitReductionTime);
    }

    function set24HourWithdrawLimit(uint256 _limit) public onlyBridge {
        withdrawLimit24Hours = _limit;
        emit WithdrawLimitUpdated(_limit);
    }

    function resetLast24HoursAmountWithdrawn() public onlyBridge {
        last24HoursAmountWithdrawn = 0;
        emit Last24HoursAmountWithdrawnReset();
    }

    function setInactivityPeriod(uint256 _periodLength) public onlyBridge {
        inactivityPeriod = _periodLength;
        emit InactivityPeriodUpdated(_periodLength);
    }

    function getBridgeNonce() public onlyBridge returns (uint256 _nonce) {
        transferNonce++;
        emit NewBridgeNonce(transferNonce);
        return transferNonce;
    }

    function disableFastWithdraws() public onlyBridge {
        fastTransfersEnabled = false;
        emit FastWithdrawsDisabled();
    }

    function setPositionClaimedOnMainChain(bytes32 _positionHash) public onlyBridge {
        positionClaimedOnMainChain[_positionHash] = true;
    }

    function getPositionClaimedOnMainChain(bytes32 _positionHash) public view returns (bool _alreadyClaimed) {
        return positionClaimedOnMainChain[_positionHash];
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for spam protection
    // ----------------------------------------------------------------------------

    function setLastRequestBlock(address _address) public onlyPlatform {
        lastRequestBlock[_address] = block.number;
    }

    function getLastRequestBlock(address _address) public view returns(uint256 _lastRequestBlock) {
        return lastRequestBlock[_address];
    }

    function setNumberOfRequests(address _address, uint256 _numberOfRequests) public onlyPlatform {
        numberOfRequests[_address] = _numberOfRequests;
    }

    function increaseNumberOfRequests(address _address) public onlyPlatform{
        numberOfRequests[_address]++;
    }

    function getNumberOfRequests(address _address) public view returns(uint256 _numberOfRequests) {
        return numberOfRequests[_address];
    }

    function setNumberOfRequestsLimit(uint256 _numberOfRequestsLimit) public onlyPlatform {
        numberOfRequestsLimit = _numberOfRequestsLimit;
        emit NumberOfRequestsLimitUpdate(_numberOfRequestsLimit);
    }

    function getNumberOfRequestsLimit() public view returns (uint256 _numberOfRequestsLimit) {
        return numberOfRequestsLimit;
    }

    function setMainChainWithdrawLimit(uint256 _mainChainWithdrawLimit24) public onlyOwner {
        mainChainWithdrawLimit24 = _mainChainWithdrawLimit24;
        emit MainChainWithdrawLimitUpdate(_mainChainWithdrawLimit24);
    }

    function getMainChainWithdrawLimit() public view returns (uint256 _mainChainWithdrawLimit24) {
        return mainChainWithdrawLimit24;
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for state access
    // ----------------------------------------------------------------------------

    function grantAccess(address _address) public onlyOwner {
        stateAccess[_address] = true;
        emit StateAccessGranted(_address, block.number);
    }

    function denyAccess(address _address) public onlyOwner {
        stateAccess[_address] = false;
        emit StateAccessDenied(_address, block.number);
    }

    function getStateAccess(address _address) public view returns(bool _hasAccess) {
        return stateAccess[_address];
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for addresses that can transfer tokens (sidechain only)
    // ----------------------------------------------------------------------------

    function enableTransfers(address _address) public onlyOwner {
        transferAllowed[_address] = true;
        emit TransfersEnabled(_address);
    }

    function disableTransfers(address _address) public onlyOwner {
        transferAllowed[_address] = false;
        emit TransfersDisabled(_address);
    }

    function getCanTransfer(address _address) public view returns(bool _hasAccess) {
        return transferAllowed[_address];
    }

    // ----------------------------------------------------------------------------
    // Minting/burning/transfer of token
    // ----------------------------------------------------------------------------

    function transfer(address _from, address _to, uint256 _token) public onlyPlatform notPaused {
        require(balances[_from] >= _token, "MorpherState: Not enough token.");
        balances[_from] = balances[_from].sub(_token);
        balances[_to] = balances[_to].add(_token);
        IMorpherToken(morpherToken).emitTransfer(_from, _to, _token);
        emit Transfer(_from, _to, _token);
        emit SetBalance(_from, balances[_from], getBalanceHash(_from, balances[_from]));
        emit SetBalance(_to, balances[_to], getBalanceHash(_to, balances[_to]));
    }

    function mint(address _address, uint256 _token) public onlyPlatform notPaused {
        balances[_address] = balances[_address].add(_token);
        totalToken = totalToken.add(_token);
        updateTotalSupply();
        IMorpherToken(morpherToken).emitTransfer(address(0), _address, _token);
        emit Mint(_address, _token, totalToken);
        emit SetBalance(_address, balances[_address], getBalanceHash(_address, balances[_address]));
    }

    function burn(address _address, uint256 _token) public onlyPlatform notPaused {
        require(balances[_address] >= _token, "MorpherState: Not enough token.");
        balances[_address] = balances[_address].sub(_token);
        totalToken = totalToken.sub(_token);
        updateTotalSupply();
        IMorpherToken(morpherToken).emitTransfer(_address, address(0), _token);
        emit Burn(_address, _token, totalToken);
        emit SetBalance(_address, balances[_address], getBalanceHash(_address, balances[_address]));
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for balance and token functions (ERC20)
    // ----------------------------------------------------------------------------
    function updateTotalSupply() private {
        totalSupply = totalToken.add(totalInPositions).add(totalOnOtherChain);
        emit NewTotalSupply(totalSupply);
    }

    function setTotalInPositions(uint256 _totalInPositions) public onlyAdministrator {
        totalInPositions = _totalInPositions;
        updateTotalSupply();
        emit NewTotalInPositions(_totalInPositions);
    }

    function setTotalOnOtherChain(uint256 _newTotalOnOtherChain) public onlySideChainOperator {
        totalOnOtherChain = _newTotalOnOtherChain;
        updateTotalSupply();
        emit NewTotalOnOtherChain(_newTotalOnOtherChain);
    }

    function balanceOf(address _tokenOwner) public view returns (uint256 balance) {
        return balances[_tokenOwner];
    }

    function setAllowance(address _from, address _spender, uint256 _tokens) public onlyPlatform {
        allowed[_from][_spender] = _tokens;
        emit SetAllowance(_from, _spender, _tokens);
    }

    function getAllowance(address _tokenOwner, address spender) public view returns (uint256 remaining) {
        return allowed[_tokenOwner][spender];
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for platform roles
    // ----------------------------------------------------------------------------

    function setGovernanceContract(address _newGovernanceContractAddress) public onlyOwner {
        morpherGovernance = _newGovernanceContractAddress;
        emit GovernanceChange(_newGovernanceContractAddress);
    }

    function getGovernance() public view returns (address _governanceContract) {
        return morpherGovernance;
    }

    function setMorpherBridge(address _newBridge) public onlyOwner {
        morpherBridge = _newBridge;
        emit BridgeChange(_newBridge);
    }

    function getMorpherBridge() public view returns (address _currentBridge) {
        return morpherBridge;
    }

    function setOracleContract(address _newOracleContract) public onlyGovernance {
        oracleContract = _newOracleContract;
        emit OracleChange(_newOracleContract);
    }

    function getOracleContract() public view returns(address) {
        return oracleContract;
    }

    function setTokenContract(address _newTokenContract) public onlyOwner {
        morpherToken = _newTokenContract;
        emit TokenChange(_newTokenContract);
    }

    function getTokenContract() public view returns(address) {
        return morpherToken;
    }

    function setAdministrator(address _newAdministrator) public onlyGovernance {
        administrator = _newAdministrator;
        emit AdministratorChange(_newAdministrator);
    }

    function getAdministrator() public view returns(address) {
        return administrator;
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for platform operating rewards
    // ----------------------------------------------------------------------------

    function setRewardAddress(address _newRewardsAddress) public onlyOwner {
        morpherRewards = _newRewardsAddress;
        emit RewardsChange(_newRewardsAddress, rewardBasisPoints);
    }

    function setRewardBasisPoints(uint256 _newRewardBasisPoints) public onlyOwner {
        if (mainChain == true) {
            require(_newRewardBasisPoints <= 15000, "MorpherState: Reward basis points need to be less or equal to 15000.");
        } else {
            require(_newRewardBasisPoints == 0, "MorpherState: Reward basis points can only be set on Ethereum.");
        }
        rewardBasisPoints = _newRewardBasisPoints;
        emit RewardsChange(morpherRewards, _newRewardBasisPoints);
    }

    function setLastRewardTime(uint256 _lastRewardTime) private {
        lastRewardTime = _lastRewardTime;
        emit LastRewardTime(_lastRewardTime);
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for platform administration
    // ----------------------------------------------------------------------------

    function activateMarket(bytes32 _activateMarket) public onlyAdministrator {
        marketActive[_activateMarket] = true;
        emit MarketActivated(_activateMarket);
    }

    function deActivateMarket(bytes32 _deActivateMarket) public onlyAdministrator {
        marketActive[_deActivateMarket] = false;
        emit MarketDeActivated(_deActivateMarket);
    }

    function getMarketActive(bytes32 _marketId) public view returns(bool _active) {
        return marketActive[_marketId];
    }

    function setMaximumLeverage(uint256 _newMaximumLeverage) public onlyAdministrator {
        require(_newMaximumLeverage > PRECISION, "MorpherState: Leverage precision is 1e8");
        maximumLeverage = _newMaximumLeverage;
        emit MaximumLeverageChange(_newMaximumLeverage);
    }

    function getMaximumLeverage() public view returns(uint256 _maxLeverage) {
        return maximumLeverage;
    }

    function pauseState() public onlyAdministrator {
        paused = true;
        emit StatePaused(msg.sender, true);
    }

    function unPauseState() public onlyAdministrator {
        paused = false;
        emit StatePaused(msg.sender, false);
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter for side chain state
    // ----------------------------------------------------------------------------

    function setSideChainMerkleRoot(bytes32 _sideChainMerkleRoot) public onlyBridge {
        sideChainMerkleRoot = _sideChainMerkleRoot;
        sideChainMerkleRootWrittenAtTime = now;
        payOperatingReward;
        emit SideChainMerkleRootUpdate(_sideChainMerkleRoot);
    }

    function getSideChainMerkleRoot() public view returns(bytes32 _sideChainMerkleRoot) {
        return sideChainMerkleRoot;
    }

    function setSideChainOperator(address _address) public onlyOwner {
        sideChainOperator = _address;
        emit NewSideChainOperator(_address);
    }

    function getSideChainOperator() public view returns (address _address) {
        return sideChainOperator;
    }

    function getSideChainMerkleRootWrittenAtTime() public view returns(uint256 _sideChainMerkleRoot) {
        return sideChainMerkleRootWrittenAtTime;
    }

    // ----------------------------------------------------------------------------
    // Setter/Getter functions for portfolio
    // ----------------------------------------------------------------------------

    function setPosition(
        address _address,
        bytes32 _marketId,
        uint256 _timeStamp,
        uint256 _longShares,
        uint256 _shortShares,
        uint256 _meanEntryPrice,
        uint256 _meanEntrySpread,
        uint256 _meanEntryLeverage,
        uint256 _liquidationPrice
    ) public onlyPlatform {
        portfolio[_address][_marketId].lastUpdated = _timeStamp;
        portfolio[_address][_marketId].longShares = _longShares;
        portfolio[_address][_marketId].shortShares = _shortShares;
        portfolio[_address][_marketId].meanEntryPrice = _meanEntryPrice;
        portfolio[_address][_marketId].meanEntrySpread = _meanEntrySpread;
        portfolio[_address][_marketId].meanEntryLeverage = _meanEntryLeverage;
        portfolio[_address][_marketId].liquidationPrice = _liquidationPrice;
        portfolio[_address][_marketId].positionHash = getPositionHash(
            _address,
            _marketId,
            _timeStamp,
            _longShares,
            _shortShares,
            _meanEntryPrice,
            _meanEntrySpread,
            _meanEntryLeverage,
            _liquidationPrice
        );
        if (_longShares > 0 || _shortShares > 0) {
            addExposureByMarket(_marketId, _address);
        } else {
            deleteExposureByMarket(_marketId, _address);
        }
        emit SetPosition(
            portfolio[_address][_marketId].positionHash,
            _address,
            _marketId,
            _timeStamp,
            _longShares,
            _shortShares,
            _meanEntryPrice,
            _meanEntrySpread,
            _meanEntryLeverage,
            _liquidationPrice
        );
    }

    function getPosition(
        address _address,
        bytes32 _marketId
    ) public view returns (
        uint256 _longShares,
        uint256 _shortShares,
        uint256 _meanEntryPrice,
        uint256 _meanEntrySpread,
        uint256 _meanEntryLeverage,
        uint256 _liquidationPrice
    ) {
        return(
        portfolio[_address][_marketId].longShares,
        portfolio[_address][_marketId].shortShares,
        portfolio[_address][_marketId].meanEntryPrice,
        portfolio[_address][_marketId].meanEntrySpread,
        portfolio[_address][_marketId].meanEntryLeverage,
        portfolio[_address][_marketId].liquidationPrice
        );
    }

    function getPositionHash(
        address _address,
        bytes32 _marketId,
        uint256 _timeStamp,
        uint256 _longShares,
        uint256 _shortShares,
        uint256 _meanEntryPrice,
        uint256 _meanEntrySpread,
        uint256 _meanEntryLeverage,
        uint256 _liquidationPrice
    ) public pure returns (bytes32 _hash) {
        return keccak256(
            abi.encodePacked(
                _address,
                _marketId,
                _timeStamp,
                _longShares,
                _shortShares,
                _meanEntryPrice,
                _meanEntrySpread,
                _meanEntryLeverage,
                _liquidationPrice
            )
        );
    }

    function getBalanceHash(address _address, uint256 _balance) public pure returns (bytes32 _hash) {
        return keccak256(abi.encodePacked(_address, _balance));
    }

    function getLastUpdated(address _address, bytes32 _marketId) public view returns (uint256 _lastUpdated) {
        return(portfolio[_address][_marketId].lastUpdated);
    }

    function getLongShares(address _address, bytes32 _marketId) public view returns (uint256 _longShares) {
        return(portfolio[_address][_marketId].longShares);
    }

    function getShortShares(address _address, bytes32 _marketId) public view returns (uint256 _shortShares) {
        return(portfolio[_address][_marketId].shortShares);
    }

    function getMeanEntryPrice(address _address, bytes32 _marketId) public view returns (uint256 _meanEntryPrice) {
        return(portfolio[_address][_marketId].meanEntryPrice);
    }

    function getMeanEntrySpread(address _address, bytes32 _marketId) public view returns (uint256 _meanEntrySpread) {
        return(portfolio[_address][_marketId].meanEntrySpread);
    }

    function getMeanEntryLeverage(address _address, bytes32 _marketId) public view returns (uint256 _meanEntryLeverage) {
        return(portfolio[_address][_marketId].meanEntryLeverage);
    }

    function getLiquidationPrice(address _address, bytes32 _marketId) public view returns (uint256 _liquidationPrice) {
        return(portfolio[_address][_marketId].liquidationPrice);
    }

    // ----------------------------------------------------------------------------
    // Record positions by market by address. Needed for exposure aggregations
    // and spits and dividends.
    // ----------------------------------------------------------------------------
    function addExposureByMarket(bytes32 _symbol, address _address) private {
        // Address must not be already recored
        uint256 _myExposureIndex = getExposureMappingIndex(_symbol, _address);
        if (_myExposureIndex == 0) {
            uint256 _maxMappingIndex = getMaxMappingIndex(_symbol).add(1);
            setMaxMappingIndex(_symbol, _maxMappingIndex);
            setExposureMapping(_symbol, _address, _maxMappingIndex);
        }
    }

    function deleteExposureByMarket(bytes32 _symbol, address _address) private {
        // Get my index in mapping
        uint256 _myExposureIndex = getExposureMappingIndex(_symbol, _address);
        // Get last element of mapping
        uint256 _lastIndex = getMaxMappingIndex(_symbol);
        address _lastAddress = getExposureMappingAddress(_symbol, _lastIndex);
        // If _myExposureIndex is greater than 0 (i.e. there is an exposure of that address on that market) delete it
        if (_myExposureIndex > 0) {
            // If _myExposureIndex is less than _lastIndex overwrite element at _myExposureIndex with element at _lastIndex in
            // deleted elements position.
            if (_myExposureIndex < _lastIndex) {
                setExposureMappingAddress(_symbol, _lastAddress, _myExposureIndex);
                setExposureMappingIndex(_symbol, _lastAddress, _myExposureIndex);
            }
            // Delete _lastIndex and _lastAddress element and reduce maxExposureIndex
            setExposureMappingAddress(_symbol, address(0), _lastIndex);
            setExposureMappingIndex(_symbol, _address, 0);
            // Shouldn't happen, but check that not empty
            if (_lastIndex > 0) {
                setMaxMappingIndex(_symbol, _lastIndex.sub(1));
            }
        }
    }

    // ----------------------------------------------------------------------------
    // Calculate and send operating reward
    // Every 24 hours the protocol mints rewardBasisPoints/(PRECISION) percent of the total
    // supply as reward for the protocol operator. The amount can not exceed 0.015% per
    // day.
    // ----------------------------------------------------------------------------

    function payOperatingReward() public onlyMainChain {
        if (now > lastRewardTime.add(REWARDPERIOD)) {
            uint256 _reward = totalSupply.mul(rewardBasisPoints).div(PRECISION);
            setLastRewardTime(lastRewardTime.add(REWARDPERIOD));
            mint(morpherRewards, _reward);
            emit OperatingRewardMinted(morpherRewards, _reward);
        }
    }
}

File 5 of 6: Ownable.sol
pragma solidity 0.5.16;

import "./IERC20.sol";

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address public _owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller should be owner.");
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: use renounce ownership instead.");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
    // ------------------------------------------------------------------------
    // Owner can transfer out any accidentally sent ERC20 tokens
    // ------------------------------------------------------------------------
    function transferAnyERC20Token(address _tokenAddress, uint256 _tokens) public onlyOwner returns (bool _success) {
        return IERC20(_tokenAddress).transfer(owner(), _tokens);
    }
}

File 6 of 6: SafeMath.sol
pragma solidity 0.5.16;

/**
 * @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) {
        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.
     *
     * _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) {
        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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_stateAddress","type":"address"},{"internalType":"address","name":"_coldStorageOwnerAddress","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_address","type":"address"}],"name":"LinkState","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":true,"inputs":[],"name":"_owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emitTransfer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_stateAddress","type":"address"}],"name":"setMorpherState","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transferAnyERC20Token","outputs":[{"internalType":"bool","name":"_success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000001f426c51f0ef7655a6f4c3eb58017d2f1c381bff000000000000000000000000b7528959e991f949e02d27ef133b99cfc85d737e

-----Decoded View---------------
Arg [0] : _stateAddress (address): 0x1f426C51F0Ef7655A6f4c3Eb58017d2F1c381bfF
Arg [1] : _coldStorageOwnerAddress (address): 0xb7528959e991F949e02D27eF133B99cFc85d737e

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000001f426c51f0ef7655a6f4c3eb58017d2f1c381bff
Arg [1] : 000000000000000000000000b7528959e991f949e02d27ef133b99cfc85d737e


Deployed Bytecode Sourcemap

1311:7650:3:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8905:45;;-1:-1:-1;;;8905:45:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1421:43;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1421:43:3;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;1421:43:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3817:154;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3817:154:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3817:154:3;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;2729:98;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2729:98:3;;;:::i;:::-;;;;;;;;;;;;;;;;4447:313;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4447:313:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;4447:313:3;;;;;;;;;;;;;;;;;:::i;6784:137::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6784:137:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;6784:137:3;;;;;;;;;;;;;;;;;:::i;:::-;;1517:36;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1517:36:3;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5170:218;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5170:218:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;5170:218:3;;;;;;;;:::i;6454:125::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6454:125:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6454:125:3;;:::i;2890:118::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2890:118:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2890:118:3;-1:-1:-1;;;;;2890:118:3;;:::i;1534:140:4:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1534:140:4;;;:::i;2505:159:3:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2505:159:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2505:159:3;-1:-1:-1;;;;;2505:159:3;;:::i;708:79:4:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;708:79:4;;;:::i;:::-;;;;-1:-1:-1;;;;;708:79:4;;;;;;;;;;;;;;1079:92;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1079:92:4;;;:::i;1471:39:3:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1471:39:3;;;:::i;5891:270::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5891:270:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;5891:270:3;;;;;;;;:::i;3303:160::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3303:160:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3303:160:3;;;;;;;;:::i;272:21:4:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;272:21:4;;;:::i;2575:186::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2575:186:4;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;2575:186:4;;;;;;;;:::i;3525:145:3:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3525:145:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3525:145:3;;;;;;;;;;:::i;1851:109:4:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1851:109:4;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1851:109:4;-1:-1:-1;;;;;1851:109:4;;:::i;1421:43:3:-;;;;;;;;;;;;;;-1:-1:-1;;;1421:43:3;;;;:::o;3817:154::-;3885:4;3902:39;3911:10;3923:8;3933:7;3902:8;:39::i;:::-;-1:-1:-1;3959:4:3;3817:154;;;;:::o;2729:98::-;2800:5;;:19;;;-1:-1:-1;;;2800:19:3;;;;2773:7;;-1:-1:-1;;;;;2800:5:3;;:17;;:19;;;;;;;;;;;;;;:5;:19;;;5:2:-1;;;;30:1;27;20:12;5:2;2800:19:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;2800:19:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2800:19:3;;-1:-1:-1;2729:98:3;:::o;4447:313::-;4538:4;4555:38;4565:7;4574:10;4586:6;4555:9;:38::i;:::-;4604:126;4613:7;4622:10;4634:95;4678:6;4634:95;;;;;;;;;;;;;;;;;:5;;:39;;;-1:-1:-1;;;4634:39:3;;-1:-1:-1;;;;;4634:39:3;;;;;;;4662:10;4634:39;;;;;;:5;;;;;:18;;:39;;;;;;;;;;;;;;:5;:39;;;5:2:-1;;;;30:1;27;20:12;5:2;4634:39:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;4634:39:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4634:39:3;;:95;;:43;:95;:::i;:::-;4604:8;:126::i;:::-;-1:-1:-1;4748:4:3;4447:313;;;;;:::o;6784:137::-;1626:5;;-1:-1:-1;;;;;1626:5:3;1604:10;:28;1596:85;;;;-1:-1:-1;;;1596:85:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6900:3;-1:-1:-1;;;;;6884:29:3;6893:5;-1:-1:-1;;;;;6884:29:3;;6905:7;6884:29;;;;;;;;;;;;;;;;;;6784:137;;;:::o;1517:36::-;1551:2;1517:36;:::o;5170:218::-;5300:5;;:40;;;-1:-1:-1;;;5300:40:3;;5278:10;5300:40;;;;;;-1:-1:-1;;;;;5300:40:3;;;;;;;;;5252:4;;5269:89;;5278:10;;5290:8;;5300:57;;5345:11;;5300:5;;;;;:18;;:40;;;;;;;;;;;;;;:5;:40;;;5:2:-1;;;;30:1;27;20:12;5:2;5300:40:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;5300:40:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5300:40:3;;:57;:44;:57;:::i;6454:125::-;6518:5;;:31;;;-1:-1:-1;;;6518:31:3;;6529:10;6518:31;;;;;;;;;;;;6501:4;;-1:-1:-1;;;;;6518:5:3;;:10;;:31;;;;;6501:4;;6518:31;;;;;;;6501:4;6518:5;:31;;;5:2:-1;;;;30:1;27;20:12;5:2;6518:31:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;6567:4:3;;6454:125;-1:-1:-1;;;;;6454:125:3:o;2890:118::-;2975:5;;:25;;;-1:-1:-1;;;2975:25:3;;-1:-1:-1;;;;;2975:25:3;;;;;;;;;2948:7;;2975:5;;;;;:15;;:25;;;;;;;;;;;;;;;:5;:25;;;5:2:-1;;;;30:1;27;20:12;5:2;2975:25:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;2975:25:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2975:25:3;;2890:118;-1:-1:-1;;2890:118:3:o;1534:140:4:-;920:9;:7;:9::i;:::-;912:54;;;;;-1:-1:-1;;;912:54:4;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;912:54:4;;;;;;;;;;;;;;;1633:1;1617:6;;1596:40;;-1:-1:-1;;;;;1617:6:4;;;;1596:40;;1633:1;;1596:40;1664:1;1647:19;;-1:-1:-1;;;;;;1647:19:4;;;1534:140::o;2505:159:3:-;920:9:4;:7;:9::i;:::-;912:54;;;;;-1:-1:-1;;;912:54:4;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;912:54:4;;;;;;;;;;;;;;;2581:5:3;:35;;-1:-1:-1;;;;;2581:35:3;;-1:-1:-1;;;;;;2581:35:3;;;;;;;;2632:24;;;;;;;;;;;;;;;;2505:159;:::o;708:79:4:-;746:7;773:6;-1:-1:-1;;;;;773:6:4;708:79;:::o;1079:92::-;1119:4;1157:6;-1:-1:-1;;;;;1157:6:4;1143:10;:20;;1079:92::o;1471:39:3:-;;;;;;;;;;;;;;-1:-1:-1;;;1471:39:3;;;;:::o;5891:270::-;5978:4;5995:136;6004:10;6016:8;6027:103;6072:16;6027:103;;;;;;;;;;;;;;;;;:5;;:40;;;-1:-1:-1;;;6027:40:3;;6046:10;6027:40;;;;-1:-1:-1;;;;;6027:40:3;;;;;;;;;:5;;;;;:18;;:40;;;;;;;;;;;;;;:5;:40;;;5:2:-1;;;;30:1;27;20:12;3303:160:3;3374:4;3391:42;3401:10;3413;3425:7;3391:9;:42::i;272:21:4:-;;;-1:-1:-1;;;;;272:21:4;;:::o;2575:186::-;2672:13;920:9;:7;:9::i;:::-;912:54;;;;;-1:-1:-1;;;912:54:4;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;912:54:4;;;;;;;;;;;;;;;2712:13;-1:-1:-1;;;;;2705:30:4;;2736:7;:5;:7::i;:::-;2745;2705:48;;;;;;;;;;;;;-1:-1:-1;;;;;2705:48:4;-1:-1:-1;;;;;2705:48:4;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2705:48:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;2705:48:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2705:48:4;;2575:186;-1:-1:-1;;;2575:186:4:o;3525:145:3:-;3626:5;;:36;;;-1:-1:-1;;;3626:36:3;;-1:-1:-1;;;;;3626:36:3;;;;;;;;;;;;;;;;3599:7;;3626:5;;;;;:18;;:36;;;;;;;;;;;;;;;:5;:36;;;5:2:-1;;;;30:1;27;20:12;5:2;3626:36:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;1851:109:4;920:9;:7;:9::i;:::-;912:54;;;;;-1:-1:-1;;;912:54:4;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;912:54:4;;;;;;;;;;;;;;;1924:28;1943:8;1924:18;:28::i;:::-;1851:109;:::o;8317:353:3:-;-1:-1:-1;;;;;8414:20:3;;8406:69;;;;-1:-1:-1;;;8406:69:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8494:22:3;;8486:69;;;;-1:-1:-1;;;8486:69:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8566:5;;:45;;;-1:-1:-1;;;8566:45:3;;-1:-1:-1;;;;;8566:45:3;;;;;;;;;;;;;;;;;;;;;;:5;;;;;:18;;:45;;;;;:5;;:45;;;;;;;:5;;:45;;;5:2:-1;;;;30:1;27;20:12;5:2;8566:45:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;8627:35:3;;;;;;;;-1:-1:-1;;;;;8627:35:3;;;;-1:-1:-1;8627:35:3;;;-1:-1:-1;8627:35:3;;;;;;;;;8317:353;;;:::o;7457:419::-;1749:5;;;;;;;;;-1:-1:-1;;;;;1749:5:3;-1:-1:-1;;;;;1749:15:3;;:17;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1749:17:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1749:17:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1749:17:3;:25;;1770:4;1749:25;;:61;;-1:-1:-1;1778:5:3;;:32;;;-1:-1:-1;;;1778:32:3;;1799:10;1778:32;;;;;;-1:-1:-1;;;;;1778:5:3;;;;:20;;:32;;;;;;;;;;;;;;;:5;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;1778:32:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1778:32:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1778:32:3;1749:61;1741:119;;;;-1:-1:-1;;;1741:119:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7570:21:3;;7562:71;;;;-1:-1:-1;;;7562:71:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7652:24:3;;7644:72;;;;-1:-1:-1;;;7644:72:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7735:5;;:24;;;-1:-1:-1;;;7735:24:3;;-1:-1:-1;;;;;7735:24:3;;;;;;;;;7763:7;;7735:5;;;;;:15;;:24;;;;;;;;;;;;;;;:5;:24;;;5:2:-1;;;;30:1;27;20:12;5:2;7735:24:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7735:24:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7735:24:3;:35;;7727:86;;;;-1:-1:-1;;;7727:86:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7824:5;;:44;;;-1:-1:-1;;;7824:44:3;;-1:-1:-1;;;;;7824:44:3;;;;;;;;;;;;;;;;;;;;;;:5;;;;;:14;;:44;;;;;:5;;:44;;;;;;;:5;;:44;;;5:2:-1;;;;30:1;27;20:12;5:2;7824:44:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7824:44:3;;;;7457:419;;;:::o;1788:192:5:-;1874:7;1910:12;1902:6;;;;1894:29;;;;-1:-1:-1;;;1894:29:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;1894:29:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1946:5:5;;;1788:192::o;859:181::-;917:7;949:5;;;973:6;;;;965:46;;;;;-1:-1:-1;;;965:46:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;1031:1;859:181;-1:-1:-1;;;859:181:5:o;2110:231:4:-;-1:-1:-1;;;;;2184:22:4;;2176:75;;;;-1:-1:-1;;;2176:75:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2288:6;;;2267:38;;-1:-1:-1;;;;;2267:38:4;;;;2288:6;;;2267:38;;;2316:6;:17;;-1:-1:-1;;;;;;2316:17:4;-1:-1:-1;;;;;2316:17:4;;;;;;;;;;2110:231::o

Swarm Source

bzzr://a7de4f3b8e725261694d2debd3a506855f61f930ec7af26c0f1885d0f1f3329e

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

OVERVIEW

Morpher empowers trading of stocks, commodities, and currencies with zero fees and infinite liquidity via Virtual Futures on Ethereum. If MPH token is staked on a market, e.g. the Apple stock, the protocol mints/burns token proportionally to the price development of the market.

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

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.