Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract ERC20Basic
•    - function totalSupply()
•    - function balanceOf(address _who)
•    - function transfer(address _to, uint25 ...
•  contract ERC20 is ERC20Basic
•    - function allowance(address _owner, ad ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•  contract EIP20 is ERC20
•  contract WETHInterface is EIP20
•    - function deposit()
•    - function withdraw(uint256 wad)
• library SafeMath
•    - function mul(uint256 _a, uint256 _b)
•    - function div(uint256 _a, uint256 _b)
•    - function divCeil(uint256 _a, uint256 ...
•    - function sub(uint256 _a, uint256 _b)
•    - function add(uint256 _a, uint256 _b)
•  contract Ownable
•    - function transferOwnership(address _n ...
•    - function _transferOwnership(address _ ...
•  contract ReentrancyGuard
•  contract LoanTokenization is Reent ...
•  contract PositionTokenStorage is L ... *
•  contract SplittableTokenStorage is ...
•    - function totalSupply()
•    - function balanceOf(
•    - function allowance(
•    - function normalize(
•    - function denormalize(
•  contract PositionToken is Splittab ... *
•    - function setTarget(
•    - function _setTarget(
•    - function _isContract(

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-05-31
*/

/**
 * Copyright 2017-2019, bZeroX, LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0.
 */
 
pragma solidity 0.5.8;


/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * See https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address _who) public view returns (uint256);
  function transfer(address _to, uint256 _value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address _owner, address _spender)
    public view returns (uint256);

  function transferFrom(address _from, address _to, uint256 _value)
    public returns (bool);

  function approve(address _spender, uint256 _value) public returns (bool);
  event Approval(
    address indexed owner,
    address indexed spender,
    uint256 value
  );
}

/**
 * @title EIP20/ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract EIP20 is ERC20 {
    string public name;
    uint8 public decimals;
    string public symbol;
}

contract WETHInterface is EIP20 {
    function deposit() external payable;
    function withdraw(uint256 wad) external;
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (_a == 0) {
      return 0;
    }

    c = _a * _b;
    assert(c / _a == _b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
    // assert(_b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = _a / _b;
    // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
    return _a / _b;
  }

  /**
  * @dev Integer division of two numbers, rounding up and truncating the quotient
  */
  function divCeil(uint256 _a, uint256 _b) internal pure returns (uint256) {
    if (_a == 0) {
      return 0;
    }

    return ((_a - 1) / _b) + 1;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
    assert(_b <= _a);
    return _a - _b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    c = _a + _b;
    assert(c >= _a);
    return c;
  }
}

/**
 * @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() public {
    owner = msg.sender;
  }

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

  /**
   * @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));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @author Remco Bloemen <remco@2π.com>, Eenae <[email protected]>
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {

  /// @dev Constant for unlocked guard state - non-zero to prevent extra gas costs.
  /// See: https://github.com/OpenZeppelin/openzeppelin-solidity/issues/1056
  uint256 internal constant REENTRANCY_GUARD_FREE = 1;

  /// @dev Constant for locked guard state
  uint256 internal constant REENTRANCY_GUARD_LOCKED = 2;

  /**
   * @dev We use a single lock for the whole contract.
   */
  uint256 internal reentrancyLock = REENTRANCY_GUARD_FREE;

  /**
   * @dev Prevents a contract from calling itself, directly or indirectly.
   * If you mark a function `nonReentrant`, you should also
   * mark it `external`. Calling one `nonReentrant` function from
   * another is not supported. Instead, you can implement a
   * `private` function doing the actual work, and an `external`
   * wrapper marked as `nonReentrant`.
   */
  modifier nonReentrant() {
    require(reentrancyLock == REENTRANCY_GUARD_FREE, "nonReentrant");
    reentrancyLock = REENTRANCY_GUARD_LOCKED;
    _;
    reentrancyLock = REENTRANCY_GUARD_FREE;
  }

}

contract LoanTokenization is ReentrancyGuard, Ownable {

    uint256 internal constant MAX_UINT = 2**256 - 1;

    string public name;
    string public symbol;
    uint8 public decimals;

    address public bZxContract;
    address public bZxVault;
    address public bZxOracle;
    address public wethContract;

    address public loanTokenAddress;

    // price of token at last user checkpoint
    mapping (address => uint256) internal checkpointPrices_;
}

contract PositionTokenStorage is LoanTokenization {

    bool internal isInitialized_ = false;

    address public loanTokenLender;
    address public tradeTokenAddress;

    uint256 public leverageAmount;
    bytes32 public loanOrderHash;

    uint256 public initialPrice;
}

contract SplittableTokenStorage is PositionTokenStorage {
    using SafeMath for uint256;

    event Transfer(
        address indexed from,
        address indexed to,
        uint256 value
    );
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Mint(
        address indexed minter,
        uint256 tokenAmount,
        uint256 assetAmount,
        uint256 price
    );
    event Burn(
        address indexed burner,
        uint256 tokenAmount,
        uint256 assetAmount,
        uint256 price
    );

    mapping(address => uint256) internal balances;
    mapping (address => mapping (address => uint256)) internal allowed;
    uint256 internal totalSupply_;

    uint256 public splitFactor = 10**18;

    function totalSupply()
        public
        view
        returns (uint256)
    {
        return denormalize(totalSupply_);
    }

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

    function allowance(
        address _owner,
        address _spender)
        public
        view
        returns (uint256)
    {
        return denormalize(allowed[_owner][_spender]);
    }

    function normalize(
        uint256 _value)
        internal
        view
        returns (uint256)
    {
        return _value
            .mul(splitFactor)
            .div(10**18);
    }

    function denormalize(
        uint256 _value)
        internal
        view
        returns (uint256)
    {
        return _value
            .mul(10**18)
            .div(splitFactor);
    }
}

contract PositionToken is SplittableTokenStorage {

    address internal target_;

    constructor(
        address _newTarget)
        public
    {
        _setTarget(_newTarget);
    }

    function()
        external
        payable
    {
        address target = target_;
        bytes memory data = msg.data;
        assembly {
            let result := delegatecall(gas, target, add(data, 0x20), mload(data), 0, 0)
            let size := returndatasize
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }

    function setTarget(
        address _newTarget)
        public
        onlyOwner
    {
        _setTarget(_newTarget);
    }

    function _setTarget(
        address _newTarget)
        internal
    {
        require(_isContract(_newTarget), "target not a contract");
        target_ = _newTarget;
    }

    function _isContract(
        address addr)
        internal
        view
        returns (bool)
    {
        uint256 size;
        assembly { size := extcodesize(addr) }
        return size > 0;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"initialPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"wethContract","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"loanTokenLender","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newTarget","type":"address"}],"name":"setTarget","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"loanTokenAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"bZxVault","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"bZxOracle","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"bZxContract","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"splitFactor","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"leverageAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tradeTokenAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"loanOrderHash","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_newTarget","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"minter","type":"address"},{"indexed":false,"name":"tokenAmount","type":"uint256"},{"indexed":false,"name":"assetAmount","type":"uint256"},{"indexed":false,"name":"price","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"burner","type":"address"},{"indexed":false,"name":"tokenAmount","type":"uint256"},{"indexed":false,"name":"assetAmount","type":"uint256"},{"indexed":false,"name":"price","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

8187:1234:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8469:7;;8487:28;;;;8507:8;8487:28;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8469:7:0;;;;8487:17;;-1:-1:-1;;8507:8:0;;8487:28;;-1:-1:-1;8507:8:0;;-1:-1:-1;8487:28:0;1:33:-1;99:1;81:16;;74:27;;;-1:-1;8607:11:0;;8487:28;;-1:-1:-1;99:1;;;-1:-1;8607:11:0;-1:-1:-1;;8600:4:0;8590:15;;8582:6;8577:3;8564:61;8651:14;8696:4;8690:11;8738:4;8735:1;8730:3;8715:28;8764:6;8784:28;;;;8848:4;8843:3;8836:17;8784:28;8805:4;8800:3;8793:17;5783:18;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5783:18:0;;;:::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;5783:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7254:136;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7254:136:0;;;:::i;:::-;;;;;;;;;;;;;;;;6400:27;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6400:27:0;;;:::i;5835:21::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5835:21:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5959:27;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5959:27:0;;;:::i;:::-;;;;-1:-1:-1;;;;;5959:27:0;;;;;;;;;;;;;;6249:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6249:30:0;;;:::i;7398:162::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7398:162:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7398:162:0;-1:-1:-1;;;;;7398:162:0;;:::i;8881:130::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8881:130:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8881:130:0;-1:-1:-1;;;;;8881:130:0;;:::i;:::-;;5995:31;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5995:31:0;;;:::i;5898:23::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5898:23:0;;;:::i;3292:20::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3292:20:0;;;:::i;5808:::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5808:20:0;;;:::i;5928:24::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5928:24:0;;;:::i;5865:26::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5865:26:0;;;:::i;7210:35::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7210:35:0;;;:::i;6327:29::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6327:29:0;;;:::i;6286:32::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6286:32:0;;;:::i;7568:198::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7568:198:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;7568:198:0;;;;;;;;;;:::i;3923:105::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3923:105:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3923:105:0;-1:-1:-1;;;;;3923:105:0;;:::i;6363:28::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6363:28:0;;;:::i;5783:18::-;;;;;;;;;;;;;;-1:-1:-1;;5783:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7254:136::-;7325:7;7357:25;7369:12;;7357:11;:25::i;:::-;7350:32;;7254:136;:::o;6400:27::-;;;;:::o;5835:21::-;;;;;;:::o;5959:27::-;;;-1:-1:-1;;;;;5959:27:0;;:::o;6249:30::-;;;;;;-1:-1:-1;;;;;6249:30:0;;:::o;7398:162::-;-1:-1:-1;;;;;7535:16:0;;7491:7;7535:16;;;:8;:16;;;;;;7523:29;;:11;:29::i;:::-;7516:36;7398:162;-1:-1:-1;;7398:162:0:o;8881:130::-;3735:5;;-1:-1:-1;;;;;3735:5:0;3721:10;:19;3713:28;;;;;;8981:22;8992:10;8981;:22::i;:::-;8881:130;:::o;5995:31::-;;;-1:-1:-1;;;;;5995:31:0;;:::o;5898:23::-;;;-1:-1:-1;;;;;5898:23:0;;:::o;3292:20::-;;;-1:-1:-1;;;;;3292:20:0;;:::o;5808:::-;;;;;;;;;;;;;;;-1:-1:-1;;5808:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5928:24;;;-1:-1:-1;;;;;5928:24:0;;:::o;5865:26::-;;;;;;-1:-1:-1;;;;;5865:26:0;;:::o;7210:35::-;;;;:::o;6327:29::-;;;;:::o;6286:32::-;;;-1:-1:-1;;;;;6286:32:0;;:::o;7568:198::-;-1:-1:-1;;;;;7732:15:0;;;7688:7;7732:15;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;7720:38;;:11;:38::i;:::-;7713:45;7568:198;-1:-1:-1;;;7568:198:0:o;3923:105::-;3735:5;;-1:-1:-1;;;;;3735:5:0;3721:10;:19;3713:28;;;;;;3993:29;4012:9;3993:18;:29::i;6363:28::-;;;;:::o;7980:200::-;8160:11;;8077:7;;8109:63;;:32;:6;8134;8109:32;:24;:32;:::i;:::-;:50;:63;:50;:63;:::i;9019:180::-;9111:23;9123:10;9111:11;:23::i;:::-;9103:57;;;;;-1:-1:-1;;;;;9103:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9171:7;:20;;-1:-1:-1;;;;;;9171:20:0;-1:-1:-1;;;;;9171:20:0;;;;;;;;;;9019:180::o;4169:175::-;-1:-1:-1;;;;;4240:23:0;;4232:32;;;;;;4297:5;;4276:38;;-1:-1:-1;;;;;4276:38:0;;;;4297:5;;4276:38;;4297:5;;4276:38;4321:5;:17;;-1:-1:-1;;;;;;4321:17:0;-1:-1:-1;;;;;4321:17:0;;;;;;;;;;4169:175::o;1607:391::-;1667:9;1897:7;1893:38;;-1:-1:-1;1922:1:0;1915:8;;1893:38;-1:-1:-1;1943:7:0;;;1948:2;1943;:7;:2;1964:6;;;;;:12;1957:20;;;2085:288;2145:7;2365:2;2360;:7;;;;;;;2085:288;-1:-1:-1;;;2085:288:0:o;9207:211::-;9366:17;9402:8;;;9207:211::o

bzzr://859a873bed5dffc8f8ac0a89a3704b0b0d1c32a51a5cda7f5c501764387dd22b