Contract 0x8fc17ffddef41330b2d55e8266446a21f2e000b7

 

TxHash Block Age From To Value [TxFee]
0x9180124a1352bca82b5c851f16c4a0c0bd3628c415e4d576ad81cd748445dcde715406448 days 2 hrs ago0x4af74a76aa7b934c7397fdd0c2428762c8f7c550 IN  0x8fc17ffddef41330b2d55e8266446a21f2e000b70 Ether0.001258205
0x8d6a17f8c8e4609d68a3833ea52a23e1d1336c28c7d6210cd9fb3a17c28b6db0688439396 days 6 hrs ago0x4af013afbadb22d8a88c92d68fc96b033b9ebb8a IN  0x8fc17ffddef41330b2d55e8266446a21f2e000b70 Ether0.00251201
0xaef8a9409b0eb7f83587b9b10ac248ebafa0acfda9303d161cf76b4226544245687988197 days 11 mins ago0x6efba8fb2ac5b6730729a972ec224426a287c3ad IN  Contract Creation0 Ether0.02680843
[ Download CSV Export 

Latest 25 internal transaction, Click here to view more Internal Transactions as a result of Contract Execution

Parent TxHash Block Age From To Value
0x773cc5286c374e5e28eb1777456979097a01050bd9bdc2eabdfdab7d226dc5a4740034223 hrs 38 mins ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x57d0ce99446e9e742665231ad7dc99ff88f4fe1fb6a9d12c2e9a1dc27a5622bb73996701 day 2 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xf93d16bbadb51393560ada940b24343daddad0f30ab0b36ccaff6e57a8d8f86973995801 day 2 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x621f11fa865c9f9e0b8289006a0620173c57a1b1a8faeeddfd5eb1a2de93fa6373944431 day 21 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xad966ab63e3c67d85a008af352c4d855a1acfcbcb2dabe31048d1ea6fbd2aebf733664210 days 21 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xf549fff9efa2b2a558a06a23766b100b588536bfba439b8780cbd45bbd6c511e732212313 days 3 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x0a656d2613d1266905b7de38854814ff1a403fb17990ac926a0c9ea9747370d3731572514 days 3 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x8514409319f15aa33855825d847456d4cad1b292888cec3379774f999abab15e731550814 days 4 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xd0e7a4afa6f3758143f688b56982366ed73454c332a9e98d9e95bb03a7fee272731536514 days 5 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x488a595082a89fab35eafcaae4927a4e794ee84d10a2cf8f9349df71514d7f42731027014 days 23 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xd29b9ef812dbd789ad2212398d2382eb6f45c1e469d1a6638895e3a9dfb27908731025815 days 1 min ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x43b00b2f5253a98d17618d5d8a577115a90da4879022421a47de28bb50167b8b731023115 days 7 mins ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x6c4b15d765b0263bde33cad43b9b1cb82f8082e9bb65c92ffc5edc1ad173e011731020615 days 12 mins ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xb0fd58345a2266f136ded75259a1cf2548084b62c6d8386eff544bdf3af824c1731018915 days 15 mins ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x069de778d04ab14691235536a8c74650690e113194bf8e5a8c478f6d2c7aa81e730992615 days 1 hr ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x15e79b1e92612a74e7837645a5d0560955f56b4830830b8f3c1ff11d444bb5dc730986615 days 1 hr ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x54b967c3a83876a6898a5638316c8f05721a5e844c79b5826b387f31c16ccd92730611415 days 15 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xdbde34f2ff54e028587ef41c3087610270340b5dd496792ba7e65193c3081a4b730610315 days 15 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xe44614c1afdf6ea4f7917972eb96296f549cacb5a1e393889c7af65924791314730608115 days 15 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x2add90524e101865946d6ee617c8364e85ab5179e8281563827ef8ef4a827915730602215 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xcdf265065a3c746864b8058e68fa1e676211f4c7f968f5fce21d264be904ebd0730595715 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x9ae84081bbdd93499093c0c71d46dc5375878bca4e39176ee74aae4aa29f10d4730594215 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x2b4b79c4f65b09ed846c893115830400a4788da310d5f24bd14033501d2b6bbd730592515 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0xab2b345a8865dc9b2bfeb7f2b888fa95d896a588f135118882b4db396215a462730590915 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
0x1af368627fa4bb427e2cd0852d2098cd2973c5256bfc60c00db3d0a2250ac7b8730588915 days 16 hrs ago0x8fc17ffddef41330b2d55e8266446a21f2e000b7  Contract Creation0 Ether
[ Download CSV Export 

Contract Source Code Verified (Exact Match)

Contract Name:
Factory

Compiler Version
v0.4.25+commit.59dbf8f1

Optimization Enabled:
No

Runs (Optimizer):
200

Contract Source Code

pragma solidity ^0.4.25;

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
  function totalSupply() external view returns (uint256);

  function balanceOf(address who) external view returns (uint256);

  function allowance(address owner, address spender)
    external view returns (uint256);

  function transfer(address to, uint256 value) external returns (bool);

  function approve(address spender, uint256 value)
    external returns (bool);

  function transferFrom(address from, address to, uint256 value)
    external returns (bool);

  event Transfer(
    address indexed from,
    address indexed to,
    uint256 value
  );

  event Approval(
    address indexed owner,
    address indexed spender,
    uint256 value
  );
}

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

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

  /**
  * @dev Multiplies two numbers, reverts on 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-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b);

    return c;
  }

  /**
  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b > 0); // Solidity only automatically asserts 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 c;
  }

  /**
  * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a);
    uint256 c = a - b;

    return c;
  }

  /**
  * @dev Adds two numbers, reverts on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a);

    return c;
  }

  /**
  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
  * reverts when dividing by zero.
  */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
  }
}

// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {

  using SafeMath for uint256;

  function safeTransfer(
    IERC20 token,
    address to,
    uint256 value
  )
    internal
  {
    require(token.transfer(to, value));
  }

  function safeTransferFrom(
    IERC20 token,
    address from,
    address to,
    uint256 value
  )
    internal
  {
    require(token.transferFrom(from, to, value));
  }

  function safeApprove(
    IERC20 token,
    address spender,
    uint256 value
  )
    internal
  {
    // safeApprove should only be called when setting an initial allowance, 
    // or when resetting it to zero. To increase and decrease it, use 
    // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
    require((value == 0) || (token.allowance(msg.sender, spender) == 0));
    require(token.approve(spender, value));
  }

  function safeIncreaseAllowance(
    IERC20 token,
    address spender,
    uint256 value
  )
    internal
  {
    uint256 newAllowance = token.allowance(address(this), spender).add(value);
    require(token.approve(spender, newAllowance));
  }

  function safeDecreaseAllowance(
    IERC20 token,
    address spender,
    uint256 value
  )
    internal
  {
    uint256 newAllowance = token.allowance(address(this), spender).sub(value);
    require(token.approve(spender, newAllowance));
  }
}

// File: contracts/ens/AbstractENS.sol

contract AbstractENS {
    function owner(bytes32 _node) public view returns(address);
    function resolver(bytes32 _node) public view returns(address);
    function ttl(bytes32 _node) public view returns(uint64);
    function setOwner(bytes32 _node, address _owner) public;
    function setSubnodeOwner(bytes32 _node, bytes32 _label, address _owner) public;
    function setResolver(bytes32 _node, address _resolver) public;
    function setTTL(bytes32 _node, uint64 _ttl) public;

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);
}

// File: contracts/ens/AbstractResolver.sol

contract AbstractResolver {
    function supportsInterface(bytes4 _interfaceID) public view returns (bool);
    function addr(bytes32 _node) public view returns (address ret);
    function setAddr(bytes32 _node, address _addr) public;
    function hash(bytes32 _node) public view returns (bytes32 ret);
    function setHash(bytes32 _node, bytes32 _hash) public;
}

// File: contracts/misc/SingletonHash.sol

contract SingletonHash {
    event HashConsumed(bytes32 indexed hash);

    /**
     * @dev Used hash accounting
     */
    mapping(bytes32 => bool) public isHashConsumed;

    /**
     * @dev Parameter can be used only once
     * @param _hash Single usage hash
     */
    function singletonHash(bytes32 _hash) internal {
        require(!isHashConsumed[_hash]);
        isHashConsumed[_hash] = true;
        emit HashConsumed(_hash);
    }
}

// File: openzeppelin-solidity/contracts/access/Roles.sol

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
  struct Role {
    mapping (address => bool) bearer;
  }

  /**
   * @dev give an account access to this role
   */
  function add(Role storage role, address account) internal {
    require(account != address(0));
    require(!has(role, account));

    role.bearer[account] = true;
  }

  /**
   * @dev remove an account's access to this role
   */
  function remove(Role storage role, address account) internal {
    require(account != address(0));
    require(has(role, account));

    role.bearer[account] = false;
  }

  /**
   * @dev check if an account has this role
   * @return bool
   */
  function has(Role storage role, address account)
    internal
    view
    returns (bool)
  {
    require(account != address(0));
    return role.bearer[account];
  }
}

// File: openzeppelin-solidity/contracts/access/roles/SignerRole.sol

contract SignerRole {
  using Roles for Roles.Role;

  event SignerAdded(address indexed account);
  event SignerRemoved(address indexed account);

  Roles.Role private signers;

  constructor() internal {
    _addSigner(msg.sender);
  }

  modifier onlySigner() {
    require(isSigner(msg.sender));
    _;
  }

  function isSigner(address account) public view returns (bool) {
    return signers.has(account);
  }

  function addSigner(address account) public onlySigner {
    _addSigner(account);
  }

  function renounceSigner() public {
    _removeSigner(msg.sender);
  }

  function _addSigner(address account) internal {
    signers.add(account);
    emit SignerAdded(account);
  }

  function _removeSigner(address account) internal {
    signers.remove(account);
    emit SignerRemoved(account);
  }
}

// File: openzeppelin-solidity/contracts/cryptography/ECDSA.sol

/**
 * @title Elliptic curve signature operations
 * @dev Based on https://gist.github.com/axic/5b33912c6f61ae6fd96d6c4a47afde6d
 * TODO Remove this library once solidity supports passing a signature to ecrecover.
 * See https://github.com/ethereum/solidity/issues/864
 */

library ECDSA {

  /**
   * @dev Recover signer address from a message by using their signature
   * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
   * @param signature bytes signature, the signature is generated using web3.eth.sign()
   */
  function recover(bytes32 hash, bytes signature)
    internal
    pure
    returns (address)
  {
    bytes32 r;
    bytes32 s;
    uint8 v;

    // Check the signature length
    if (signature.length != 65) {
      return (address(0));
    }

    // Divide the signature in r, s and v variables
    // ecrecover takes the signature parameters, and the only way to get them
    // currently is to use assembly.
    // solium-disable-next-line security/no-inline-assembly
    assembly {
      r := mload(add(signature, 0x20))
      s := mload(add(signature, 0x40))
      v := byte(0, mload(add(signature, 0x60)))
    }

    // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
    if (v < 27) {
      v += 27;
    }

    // If the version is correct return the signer address
    if (v != 27 && v != 28) {
      return (address(0));
    } else {
      // solium-disable-next-line arg-overflow
      return ecrecover(hash, v, r, s);
    }
  }

  /**
   * toEthSignedMessageHash
   * @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
   * and hash the result
   */
  function toEthSignedMessageHash(bytes32 hash)
    internal
    pure
    returns (bytes32)
  {
    // 32 is the length in bytes of hash,
    // enforced by the type signature above
    return keccak256(
      abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
    );
  }
}

// File: openzeppelin-solidity/contracts/drafts/SignatureBouncer.sol

/**
 * @title SignatureBouncer
 * @author PhABC, Shrugs and aflesher
 * @dev SignatureBouncer allows users to submit a signature as a permission to
 * do an action.
 * If the signature is from one of the authorized signer addresses, the
 * signature is valid.
 * Note that SignatureBouncer offers no protection against replay attacks, users
 * must add this themselves!
 *
 * Signer addresses can be individual servers signing grants or different
 * users within a decentralized club that have permission to invite other
 * members. This technique is useful for whitelists and airdrops; instead of
 * putting all valid addresses on-chain, simply sign a grant of the form
 * keccak256(abi.encodePacked(`:contractAddress` + `:granteeAddress`)) using a
 * valid signer address.
 * Then restrict access to your crowdsale/whitelist/airdrop using the
 * `onlyValidSignature` modifier (or implement your own using _isValidSignature).
 * In addition to `onlyValidSignature`, `onlyValidSignatureAndMethod` and
 * `onlyValidSignatureAndData` can be used to restrict access to only a given
 * method or a given method with given parameters respectively.
 * See the tests in SignatureBouncer.test.js for specific usage examples.
 *
 * @notice A method that uses the `onlyValidSignatureAndData` modifier must make
 * the _signature parameter the "last" parameter. You cannot sign a message that
 * has its own signature in it so the last 128 bytes of msg.data (which
 * represents the length of the _signature data and the _signaature data itself)
 * is ignored when validating. Also non fixed sized parameters make constructing
 * the data in the signature much more complex.
 * See https://ethereum.stackexchange.com/a/50616 for more details.
 */
contract SignatureBouncer is SignerRole {
  using ECDSA for bytes32;

  // Function selectors are 4 bytes long, as documented in
  // https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector
  uint256 private constant _METHOD_ID_SIZE = 4;
  // Signature size is 65 bytes (tightly packed v + r + s), but gets padded to 96 bytes
  uint256 private constant _SIGNATURE_SIZE = 96;

  constructor() internal {}

  /**
   * @dev requires that a valid signature of a signer was provided
   */
  modifier onlyValidSignature(bytes signature)
  {
    require(_isValidSignature(msg.sender, signature));
    _;
  }

  /**
   * @dev requires that a valid signature with a specifed method of a signer was provided
   */
  modifier onlyValidSignatureAndMethod(bytes signature)
  {
    require(_isValidSignatureAndMethod(msg.sender, signature));
    _;
  }

  /**
   * @dev requires that a valid signature with a specifed method and params of a signer was provided
   */
  modifier onlyValidSignatureAndData(bytes signature)
  {
    require(_isValidSignatureAndData(msg.sender, signature));
    _;
  }

  /**
   * @dev is the signature of `this + sender` from a signer?
   * @return bool
   */
  function _isValidSignature(address account, bytes signature)
    internal
    view
    returns (bool)
  {
    return _isValidDataHash(
      keccak256(abi.encodePacked(address(this), account)),
      signature
    );
  }

  /**
   * @dev is the signature of `this + sender + methodId` from a signer?
   * @return bool
   */
  function _isValidSignatureAndMethod(address account, bytes signature)
    internal
    view
    returns (bool)
  {
    bytes memory data = new bytes(_METHOD_ID_SIZE);
    for (uint i = 0; i < data.length; i++) {
      data[i] = msg.data[i];
    }
    return _isValidDataHash(
      keccak256(abi.encodePacked(address(this), account, data)),
      signature
    );
  }

  /**
    * @dev is the signature of `this + sender + methodId + params(s)` from a signer?
    * @notice the signature parameter of the method being validated must be the "last" parameter
    * @return bool
    */
  function _isValidSignatureAndData(address account, bytes signature)
    internal
    view
    returns (bool)
  {
    require(msg.data.length > _SIGNATURE_SIZE);
    bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
    for (uint i = 0; i < data.length; i++) {
      data[i] = msg.data[i];
    }
    return _isValidDataHash(
      keccak256(abi.encodePacked(address(this), account, data)),
      signature
    );
  }

  /**
   * @dev internal function to convert a hash to an eth signed message
   * and then recover the signature and check it against the signer role
   * @return bool
   */
  function _isValidDataHash(bytes32 hash, bytes signature)
    internal
    view
    returns (bool)
  {
    address signer = hash
      .toEthSignedMessageHash()
      .recover(signature);

    return signer != address(0) && isSigner(signer);
  }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract ERC20 is IERC20 {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;

  mapping (address => mapping (address => uint256)) private _allowed;

  uint256 private _totalSupply;

  /**
  * @dev Total number of tokens in existence
  */
  function totalSupply() public view returns (uint256) {
    return _totalSupply;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param owner The address to query the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address owner) public view returns (uint256) {
    return _balances[owner];
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param owner address The address which owns the funds.
   * @param spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(
    address owner,
    address spender
   )
    public
    view
    returns (uint256)
  {
    return _allowed[owner][spender];
  }

  /**
  * @dev Transfer token for a specified address
  * @param to The address to transfer to.
  * @param value The amount to be transferred.
  */
  function transfer(address to, uint256 value) public returns (bool) {
    _transfer(msg.sender, to, value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   * 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
   * @param spender The address which will spend the funds.
   * @param value The amount of tokens to be spent.
   */
  function approve(address spender, uint256 value) public returns (bool) {
    require(spender != address(0));

    _allowed[msg.sender][spender] = value;
    emit Approval(msg.sender, spender, value);
    return true;
  }

  /**
   * @dev Transfer tokens from one address to another
   * @param from address The address which you want to send tokens from
   * @param to address The address which you want to transfer to
   * @param value uint256 the amount of tokens to be transferred
   */
  function transferFrom(
    address from,
    address to,
    uint256 value
  )
    public
    returns (bool)
  {
    require(value <= _allowed[from][msg.sender]);

    _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
    _transfer(from, to, value);
    return true;
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param addedValue The amount of tokens to increase the allowance by.
   */
  function increaseAllowance(
    address spender,
    uint256 addedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].add(addedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseAllowance(
    address spender,
    uint256 subtractedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].sub(subtractedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
  * @dev Transfer token for a specified addresses
  * @param from The address to transfer from.
  * @param to The address to transfer to.
  * @param value The amount to be transferred.
  */
  function _transfer(address from, address to, uint256 value) internal {
    require(value <= _balances[from]);
    require(to != address(0));

    _balances[from] = _balances[from].sub(value);
    _balances[to] = _balances[to].add(value);
    emit Transfer(from, to, value);
  }

  /**
   * @dev Internal function that mints an amount of the token and assigns it to
   * an account. This encapsulates the modification of balances such that the
   * proper events are emitted.
   * @param account The account that will receive the created tokens.
   * @param value The amount that will be created.
   */
  function _mint(address account, uint256 value) internal {
    require(account != 0);
    _totalSupply = _totalSupply.add(value);
    _balances[account] = _balances[account].add(value);
    emit Transfer(address(0), account, value);
  }

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account.
   * @param account The account whose tokens will be burnt.
   * @param value The amount that will be burnt.
   */
  function _burn(address account, uint256 value) internal {
    require(account != 0);
    require(value <= _balances[account]);

    _totalSupply = _totalSupply.sub(value);
    _balances[account] = _balances[account].sub(value);
    emit Transfer(account, address(0), value);
  }

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account, deducting from the sender's allowance for said account. Uses the
   * internal burn function.
   * @param account The account whose tokens will be burnt.
   * @param value The amount that will be burnt.
   */
  function _burnFrom(address account, uint256 value) internal {
    require(value <= _allowed[account][msg.sender]);

    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
    // this function needs to emit an event with the updated approval.
    _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
      value);
    _burn(account, value);
  }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol

/**
 * @title Burnable Token
 * @dev Token that can be irreversibly burned (destroyed).
 */
contract ERC20Burnable is ERC20 {

  /**
   * @dev Burns a specific amount of tokens.
   * @param value The amount of token to be burned.
   */
  function burn(uint256 value) public {
    _burn(msg.sender, value);
  }

  /**
   * @dev Burns a specific amount of tokens from the target address and decrements allowance
   * @param from address The address which you want to send tokens from
   * @param value uint256 The amount of token to be burned
   */
  function burnFrom(address from, uint256 value) public {
    _burnFrom(from, value);
  }
}

// File: contracts/misc/DutchAuction.sol

/// @title Dutch auction contract - distribution of XRT tokens using an auction.
/// @author Stefan George - <[email protected]>
/// @author Airalab - <[email protected]> 
contract DutchAuction is SignatureBouncer {
    using SafeERC20 for ERC20Burnable;

    /*
     *  Events
     */
    event BidSubmission(address indexed sender, uint256 amount);

    /*
     *  Constants
     */
    uint constant public WAITING_PERIOD = 0; // 1 days;

    /*
     *  Storage
     */
    ERC20Burnable public token;
    address public ambix;
    address public wallet;
    address public owner;
    uint public maxTokenSold;
    uint public ceiling;
    uint public priceFactor;
    uint public startBlock;
    uint public endTime;
    uint public totalReceived;
    uint public finalPrice;
    mapping (address => uint) public bids;
    Stages public stage;

    /*
     *  Enums
     */
    enum Stages {
        AuctionDeployed,
        AuctionSetUp,
        AuctionStarted,
        AuctionEnded,
        TradingStarted
    }

    /*
     *  Modifiers
     */
    modifier atStage(Stages _stage) {
        // Contract on stage
        require(stage == _stage);
        _;
    }

    modifier isOwner() {
        // Only owner is allowed to proceed
        require(msg.sender == owner);
        _;
    }

    modifier isWallet() {
        // Only wallet is allowed to proceed
        require(msg.sender == wallet);
        _;
    }

    modifier isValidPayload() {
        require(msg.data.length == 4 || msg.data.length == 164);
        _;
    }

    modifier timedTransitions() {
        if (stage == Stages.AuctionStarted && calcTokenPrice() <= calcStopPrice())
            finalizeAuction();
        if (stage == Stages.AuctionEnded && now > endTime + WAITING_PERIOD)
            stage = Stages.TradingStarted;
        _;
    }

    /*
     *  Public functions
     */
    /// @dev Contract constructor function sets owner.
    /// @param _wallet Multisig wallet.
    /// @param _maxTokenSold Auction token balance.
    /// @param _ceiling Auction ceiling.
    /// @param _priceFactor Auction price factor.
    constructor(address _wallet, uint _maxTokenSold, uint _ceiling, uint _priceFactor)
        public
    {
        require(_wallet != 0 && _ceiling > 0 && _priceFactor > 0);

        owner = msg.sender;
        wallet = _wallet;
        maxTokenSold = _maxTokenSold;
        ceiling = _ceiling;
        priceFactor = _priceFactor;
        stage = Stages.AuctionDeployed;
    }

    /// @dev Setup function sets external contracts' addresses.
    /// @param _token Token address.
    /// @param _ambix Distillation cube address.
    function setup(ERC20Burnable _token, address _ambix)
        public
        isOwner
        atStage(Stages.AuctionDeployed)
    {
        // Validate argument
        require(address(_token) != 0 && _ambix != 0);

        token = _token;
        ambix = _ambix;

        // Validate token balance
        require(token.balanceOf(this) == maxTokenSold);

        stage = Stages.AuctionSetUp;
    }

    /// @dev Starts auction and sets startBlock.
    function startAuction()
        public
        isWallet
        atStage(Stages.AuctionSetUp)
    {
        stage = Stages.AuctionStarted;
        startBlock = block.number;
    }

    /// @dev Calculates current token price.
    /// @return Returns token price.
    function calcCurrentTokenPrice()
        public
        timedTransitions
        returns (uint)
    {
        if (stage == Stages.AuctionEnded || stage == Stages.TradingStarted)
            return finalPrice;
        return calcTokenPrice();
    }

    /// @dev Returns correct stage, even if a function with timedTransitions modifier has not yet been called yet.
    /// @return Returns current auction stage.
    function updateStage()
        public
        timedTransitions
        returns (Stages)
    {
        return stage;
    }

    /// @dev Allows to send a bid to the auction.
    /// @param signature KYC approvement
    function bid(bytes signature)
        public
        payable
        isValidPayload
        timedTransitions
        atStage(Stages.AuctionStarted)
        onlyValidSignature(signature)
        returns (uint amount)
    {
        require(msg.value > 0);
        amount = msg.value;

        address receiver = msg.sender;

        // Prevent that more than 90% of tokens are sold. Only relevant if cap not reached.
        uint maxWei = maxTokenSold * calcTokenPrice() / 10**9 - totalReceived;
        uint maxWeiBasedOnTotalReceived = ceiling - totalReceived;
        if (maxWeiBasedOnTotalReceived < maxWei)
            maxWei = maxWeiBasedOnTotalReceived;

        // Only invest maximum possible amount.
        if (amount > maxWei) {
            amount = maxWei;
            // Send change back to receiver address.
            receiver.transfer(msg.value - amount);
        }

        // Forward funding to ether wallet
        wallet.transfer(amount);

        bids[receiver] += amount;
        totalReceived += amount;
        emit BidSubmission(receiver, amount);

        // Finalize auction when maxWei reached
        if (amount == maxWei)
            finalizeAuction();
    }

    /// @dev Claims tokens for bidder after auction.
    function claimTokens()
        public
        isValidPayload
        timedTransitions
        atStage(Stages.TradingStarted)
    {
        address receiver = msg.sender;
        uint tokenCount = bids[receiver] * 10**9 / finalPrice;
        bids[receiver] = 0;
        token.safeTransfer(receiver, tokenCount);
    }

    /// @dev Calculates stop price.
    /// @return Returns stop price.
    function calcStopPrice()
        view
        public
        returns (uint)
    {
        return totalReceived * 10**9 / maxTokenSold + 1;
    }

    /// @dev Calculates token price.
    /// @return Returns token price.
    function calcTokenPrice()
        view
        public
        returns (uint)
    {
        return priceFactor * 10**18 / (block.number - startBlock + 7500) + 1;
    }

    /*
     *  Private functions
     */
    function finalizeAuction()
        private
    {
        stage = Stages.AuctionEnded;
        finalPrice = totalReceived == ceiling ? calcTokenPrice() : calcStopPrice();
        uint soldTokens = totalReceived * 10**9 / finalPrice;

        if (totalReceived == ceiling) {
            // Auction contract transfers all unsold tokens to Ambix contract
            token.safeTransfer(ambix, maxTokenSold - soldTokens);
        } else {
            // Auction contract burn all unsold tokens
            token.burn(maxTokenSold - soldTokens);
        }

        endTime = now;
    }
}

// File: contracts/misc/SharedCode.sol

// Inspired by https://github.com/GNSPS/2DProxy
library SharedCode {
    /**
     * @dev Create tiny proxy without constructor
     * @param _shared Shared code contract address
     */
    function proxy(address _shared) internal returns (address instance) {
        bytes memory code = abi.encodePacked(
            hex"603160008181600b9039f3600080808080368092803773",
            _shared, hex"5af43d828181803e808314603057f35bfd"
        );
        assembly {
            instance := create(0, add(code, 0x20), 60)
            if iszero(extcodesize(instance)) {
                revert(0, 0)
            }
        }
    }
}

// File: contracts/robonomics/interface/ILiability.sol

/**
 * @title Standard liability smart contract interface
 */
contract ILiability {
    /**
     * @dev Liability termination signal
     */
    event Finalized(bool indexed success, bytes result);

    /**
     * @dev Behaviour model multihash
     */
    bytes public model;

    /**
     * @dev Objective ROSBAG multihash
     * @notice ROSBAGv2 is used: http://wiki.ros.org/Bags/Format/2.0 
     */
    bytes public objective;

    /**
     * @dev Report ROSBAG multihash 
     * @notice ROSBAGv2 is used: http://wiki.ros.org/Bags/Format/2.0 
     */
    bytes public result;

    /**
     * @dev Payment token address
     */
    address public token;

    /**
     * @dev Liability cost
     */
    uint256 public cost;

    /**
     * @dev Lighthouse fee in wn
     */
    uint256 public lighthouseFee;

    /**
     * @dev Validator fee in wn
     */
    uint256 public validatorFee;

    /**
     * @dev Robonomics demand message hash
     */
    bytes32 public demandHash;

    /**
     * @dev Robonomics offer message hash
     */
    bytes32 public offerHash;

    /**
     * @dev Liability promisor address
     */
    address public promisor;

    /**
     * @dev Liability promisee address
     */
    address public promisee;

    /**
     * @dev Lighthouse assigned to this liability
     */
    address public lighthouse;

    /**
     * @dev Liability validator address
     */
    address public validator;

    /**
     * @dev Liability success flag
     */
    bool public isSuccess;

    /**
     * @dev Liability finalization status flag
     */
    bool public isFinalized;

    /**
     * @dev Deserialize robonomics demand message
     * @notice It can be called by factory only
     */
    function demand(
        bytes   _model,
        bytes   _objective,

        address _token,
        uint256 _cost,

        address _lighthouse,

        address _validator,
        uint256 _validator_fee,

        uint256 _deadline,
        bytes32 _nonce,
        bytes   _signature
    ) external returns (bool);

    /**
     * @dev Deserialize robonomics offer message
     * @notice It can be called by factory only
     */
    function offer(
        bytes   _model,
        bytes   _objective,
        
        address _token,
        uint256 _cost,

        address _validator,

        address _lighthouse,
        uint256 _lighthouse_fee,

        uint256 _deadline,
        bytes32 _nonce,
        bytes   _signature
    ) external returns (bool);

    /**
     * @dev Finalize liability contract
     * @param _result Result data hash
     * @param _success Set 'true' when liability has success result
     * @param _signature Result signature: liability address, result and success flag signed by promisor
     * @notice It can be called by assigned lighthouse only
     */
    function finalize(bytes _result, bool  _success, bytes _signature) external returns (bool);
}

// File: contracts/robonomics/interface/ILighthouse.sol

/**
 * @title Robonomics lighthouse contract interface
 */
contract ILighthouse {
    /**
     * @dev Provider going online
     */
    event Online(address indexed provider);

    /**
     * @dev Provider going offline
     */
    event Offline(address indexed provider);

    /**
     * @dev Active robonomics provider
     */
    event Current(address indexed provider, uint256 indexed quota);

    /**
     * @dev Robonomics providers list
     */
    address[] public providers;

    /**
     * @dev Count of robonomics providers on this lighthouse
     */
    function providersLength() public view returns (uint256)
    { return providers.length; }

    /**
     * @dev Provider stake distribution
     */
    mapping(address => uint256) public stakes;

    /**
     * @dev Minimal stake to get one quota
     */
    uint256 public minimalStake;

    /**
     * @dev Silence timeout for provider in blocks
     */
    uint256 public timeoutInBlocks;

    /**
     * @dev Block number of last transaction from current provider
     */
    uint256 public keepAliveBlock;

    /**
     * @dev Round robin provider list marker
     */
    uint256 public marker;

    /**
     * @dev Current provider quota
     */
    uint256 public quota;

    /**
     * @dev Get quota of provider
     */
    function quotaOf(address _provider) public view returns (uint256)
    { return stakes[_provider] / minimalStake; }

    /**
     * @dev Increase stake and get more quota,
     *      one quota - one transaction in round
     * @param _value in wn
     * @notice XRT should be approved before call this 
     */
    function refill(uint256 _value) external returns (bool);

    /**
     * @dev Decrease stake and get XRT back
     * @param _value in wn
     */
    function withdraw(uint256 _value) external returns (bool);

    /**
     * @dev Create liability smart contract assigned to this lighthouse
     * @param _demand ABI-encoded demand message
     * @param _offer ABI-encoded offer message
     * @notice Only current provider can call it
     */
    function createLiability(bytes _demand, bytes _offer) external returns (bool);

    /**
     * @dev Finalize liability smart contract assigned to this lighthouse
     * @param _liability smart contract address
     * @param _result report of work
     * @param _success work success flag
     * @param _signature work signature
     */
    function finalizeLiability(address _liability, bytes _result, bool _success, bytes _signature) external returns (bool);
}

// File: contracts/robonomics/interface/IFactory.sol

/**
 * @title Robonomics liability factory interface
 */
contract IFactory {
    /**
     * @dev New liability created 
     */
    event NewLiability(address indexed liability);

    /**
     * @dev New lighthouse created
     */
    event NewLighthouse(address indexed lighthouse, string name);

    /**
     * @dev Lighthouse address mapping
     */
    mapping(address => bool) public isLighthouse;

    /**
     * @dev Total GAS utilized by Robonomics network
     */
    uint256 public totalGasConsumed = 0;

    /**
     * @dev GAS utilized by liability contracts
     */
    mapping(address => uint256) public gasConsumedOf;

    /**
     * @dev The count of consumed gas for switch to next epoch 
     */
    uint256 public constant gasEpoch = 347 * 10**10;

    /**
     * @dev Current gas price in wei
     */
    uint256 public gasPrice = 10 * 10**9;

    /**
     * @dev XRT emission value for consumed gas
     * @param _gas Gas consumed by robonomics program
     */
    function wnFromGas(uint256 _gas) public view returns (uint256);

    /**
     * @dev Create lighthouse smart contract
     * @param _minimalStake Minimal stake value of XRT token (one quota price)
     * @param _timeoutInBlocks Max time of lighthouse silence in blocks
     * @param _name Lighthouse name,
     *              example: 'my-name' will create 'my-name.lighthouse.4.robonomics.eth' domain
     */
    function createLighthouse(uint256 _minimalStake, uint256 _timeoutInBlocks, string _name) external returns (ILighthouse);

    /**
     * @dev Create robot liability smart contract
     * @param _demand ABI-encoded demand message
     * @param _offer ABI-encoded offer message
     * @notice This method is for lighthouse contract use only
     */
    function createLiability(bytes _demand, bytes _offer) external returns (ILiability);

    /**
     * @dev Is called after liability creation
     * @param _liability Liability contract address
     * @param _start_gas Transaction start gas level
     * @notice This method is for lighthouse contract use only
     */
    function liabilityCreated(ILiability _liability, uint256 _start_gas) external returns (bool);

    /**
     * @dev Is called after liability finalization
     * @param _liability Liability contract address
     * @param _start_gas Transaction start gas level
     * @notice This method is for lighthouse contract use only
     */
    function liabilityFinalized(ILiability _liability, uint256 _start_gas) external returns (bool);
}

// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol

contract MinterRole {
  using Roles for Roles.Role;

  event MinterAdded(address indexed account);
  event MinterRemoved(address indexed account);

  Roles.Role private minters;

  constructor() internal {
    _addMinter(msg.sender);
  }

  modifier onlyMinter() {
    require(isMinter(msg.sender));
    _;
  }

  function isMinter(address account) public view returns (bool) {
    return minters.has(account);
  }

  function addMinter(address account) public onlyMinter {
    _addMinter(account);
  }

  function renounceMinter() public {
    _removeMinter(msg.sender);
  }

  function _addMinter(address account) internal {
    minters.add(account);
    emit MinterAdded(account);
  }

  function _removeMinter(address account) internal {
    minters.remove(account);
    emit MinterRemoved(account);
  }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol

/**
 * @title ERC20Mintable
 * @dev ERC20 minting logic
 */
contract ERC20Mintable is ERC20, MinterRole {
  /**
   * @dev Function to mint tokens
   * @param to The address that will receive the minted tokens.
   * @param value The amount of tokens to mint.
   * @return A boolean that indicates if the operation was successful.
   */
  function mint(
    address to,
    uint256 value
  )
    public
    onlyMinter
    returns (bool)
  {
    _mint(to, value);
    return true;
  }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol

/**
 * @title ERC20Detailed token
 * @dev The decimals are only for visualization purposes.
 * All the operations are done using the smallest and indivisible token unit,
 * just as on Ethereum all the operations are done in wei.
 */
contract ERC20Detailed is IERC20 {
  string private _name;
  string private _symbol;
  uint8 private _decimals;

  constructor(string name, string symbol, uint8 decimals) public {
    _name = name;
    _symbol = symbol;
    _decimals = decimals;
  }

  /**
   * @return the name of the token.
   */
  function name() public view returns(string) {
    return _name;
  }

  /**
   * @return the symbol of the token.
   */
  function symbol() public view returns(string) {
    return _symbol;
  }

  /**
   * @return the number of decimals of the token.
   */
  function decimals() public view returns(uint8) {
    return _decimals;
  }
}

// File: contracts/robonomics/XRT.sol

contract XRT is ERC20Mintable, ERC20Burnable, ERC20Detailed {
    constructor(uint256 _initial_supply) public ERC20Detailed("Robonomics Beta 4", "XRT", 9) {
        _mint(msg.sender, _initial_supply);
    }
}

// File: contracts/robonomics/Lighthouse.sol

contract Lighthouse is ILighthouse {
    using SafeERC20 for XRT;

    IFactory public factory;
    XRT      public xrt;

    function setup(XRT _xrt, uint256 _minimalStake, uint256 _timeoutInBlocks) external returns (bool) {
        require(address(factory) == 0 && _minimalStake > 0 && _timeoutInBlocks > 0);

        minimalStake    = _minimalStake;
        timeoutInBlocks = _timeoutInBlocks;
        factory         = IFactory(msg.sender);
        xrt             = _xrt;

        return true;
    }

    /**
     * @dev Providers index, started from 1
     */
    mapping(address => uint256) public indexOf;

    function refill(uint256 _value) external returns (bool) {
        xrt.safeTransferFrom(msg.sender, this, _value);

        if (stakes[msg.sender] == 0) {
            require(_value >= minimalStake);
            providers.push(msg.sender);
            indexOf[msg.sender] = providers.length;
            emit Online(msg.sender);
        }

        stakes[msg.sender] += _value;
        return true;
    }

    function withdraw(uint256 _value) external returns (bool) {
        require(stakes[msg.sender] >= _value);

        stakes[msg.sender] -= _value;
        xrt.safeTransfer(msg.sender, _value);

        // Drop member with zero quota
        if (quotaOf(msg.sender) == 0) {
            uint256 balance = stakes[msg.sender];
            stakes[msg.sender] = 0;
            xrt.safeTransfer(msg.sender, balance);
            
            uint256 senderIndex = indexOf[msg.sender] - 1;
            uint256 lastIndex = providers.length - 1;
            if (senderIndex < lastIndex)
                providers[senderIndex] = providers[lastIndex];

            providers.length -= 1;
            indexOf[msg.sender] = 0;

            emit Offline(msg.sender);
        }
        return true;
    }

    function keepAliveTransaction() internal {
        if (timeoutInBlocks < block.number - keepAliveBlock) {
            // Set up the marker according to provider index
            marker = indexOf[msg.sender];

            // Thransaction sender should be a registered provider
            require(marker > 0 && marker <= providers.length);

            // Allocate new quota
            quota = quotaOf(providers[marker - 1]);

            // Current provider signal
            emit Current(providers[marker - 1], quota);
        }

        // Store transaction sending block
        keepAliveBlock = block.number;
    }

    function quotedTransaction() internal {
        // Don't premit transactions without providers on board
        require(providers.length > 0);

        // Zero quota guard
        // XXX: When quota for some reasons is zero, DoS will be preverted by keepalive transaction
        require(quota > 0);

        // Only provider with marker can to send transaction
        require(msg.sender == providers[marker - 1]);

        // Consume one quota for transaction sending
        if (quota > 1) {
            quota -= 1;
        } else {
            // Step over marker
            marker = marker % providers.length + 1;

            // Allocate new quota
            quota = quotaOf(providers[marker - 1]);

            // Current provider signal
            emit Current(providers[marker - 1], quota);
        }
    }

    function startGas() internal view returns (uint256 gas) {
        // the total amount of gas the tx is DataFee + TxFee + ExecutionGas
        // ExecutionGas
        gas = gasleft();
        // TxFee
        gas += 21000;
        // DataFee
        for (uint256 i = 0; i < msg.data.length; ++i)
            gas += msg.data[i] == 0 ? 4 : 68;
    }

    function createLiability(
        bytes _demand,
        bytes _offer
    )
        external
        returns (bool)
    {
        // Gas with estimation error
        uint256 gas = startGas() + 20311;

        keepAliveTransaction();
        quotedTransaction();

        ILiability liability = factory.createLiability(_demand, _offer);
        require(address(liability) != 0);
        require(factory.liabilityCreated(liability, gas - gasleft()));
        return true;
    }

    function finalizeLiability(
        address _liability,
        bytes _result,
        bool _success,
        bytes _signature
    )
        external
        returns (bool)
    {
        // Gas with estimation error
        uint256 gas = startGas() + 23441;

        keepAliveTransaction();
        quotedTransaction();

        ILiability liability = ILiability(_liability);
        require(factory.gasConsumedOf(_liability) > 0);
        require(liability.finalize(_result, _success, _signature));
        require(factory.liabilityFinalized(liability, gas - gasleft()));
        return true;
    }
}

// File: contracts/robonomics/interface/IValidator.sol

/**
 * @dev Observing network contract interface
 */
contract IValidator {
    /**
     * @dev Final liability decision
     */
    event Decision(address indexed liability, bool indexed success);

    /**
     * @dev Decision availability marker 
     */
    mapping(address => bool) public hasDecision;

    /**
     * @dev Get decision of liability, is used by liability contract only
     * @notice Transaction will fail when have no decision
     */
    function decision() external returns (bool);
}

// File: contracts/robonomics/Liability.sol

contract Liability is ILiability {
    using ECDSA for bytes32;
    using SafeERC20 for XRT;
    using SafeERC20 for ERC20;

    address public factory;
    XRT     public xrt;

    function setup(XRT _xrt) external returns (bool) {
        require(factory == 0);

        factory = msg.sender;
        xrt     = _xrt;

        return true;
    }

    function demand(
        bytes   _model,
        bytes   _objective,

        address _token,
        uint256 _cost,

        address _lighthouse,

        address _validator,
        uint256 _validator_fee,

        uint256 _deadline,
        bytes32 _nonce,
        bytes   _signature
    )
        external
        returns (bool)
    {
        require(msg.sender == factory);
        require(block.number < _deadline);

        model        = _model;
        objective    = _objective;
        token        = _token;
        cost         = _cost;
        lighthouse   = _lighthouse;
        validator    = _validator;
        validatorFee = _validator_fee;

        demandHash = keccak256(abi.encodePacked(
            _model
          , _objective
          , _token
          , _cost
          , _lighthouse
          , _validator
          , _validator_fee
          , _deadline
          , _nonce
        ));

        promisee = demandHash
            .toEthSignedMessageHash()
            .recover(_signature);
        return true;
    }

    function offer(
        bytes   _model,
        bytes   _objective,
        
        address _token,
        uint256 _cost,

        address _validator,

        address _lighthouse,
        uint256 _lighthouse_fee,

        uint256 _deadline,
        bytes32 _nonce,
        bytes   _signature
    )
        external
        returns (bool)
    {
        require(msg.sender == factory);
        require(block.number < _deadline);
        require(keccak256(model) == keccak256(_model));
        require(keccak256(objective) == keccak256(_objective));
        require(_token == token);
        require(_cost == cost);
        require(_lighthouse == lighthouse);
        require(_validator == validator);

        lighthouseFee = _lighthouse_fee;

        offerHash = keccak256(abi.encodePacked(
            _model
          , _objective
          , _token
          , _cost
          , _validator
          , _lighthouse
          , _lighthouse_fee
          , _deadline
          , _nonce
        ));

        promisor = offerHash
            .toEthSignedMessageHash()
            .recover(_signature);
        return true;
    }

    function finalize(
        bytes _result,
        bool  _success,
        bytes _signature
    )
        external
        returns (bool)
    {
        require(msg.sender == lighthouse);
        require(!isFinalized);

        address resultSender = keccak256(abi.encodePacked(this, _result, _success))
            .toEthSignedMessageHash()
            .recover(_signature);
        require(resultSender == promisor);

        isFinalized = true;
        result      = _result;

        if (validator == 0) {
            // Set state of liability according promisor report only
            isSuccess = _success;
        } else {
            // Validator can take a fee for decision
            xrt.safeApprove(validator, validatorFee);
            // Set state of liability considering validator decision
            isSuccess = _success && IValidator(validator).decision();
        }

        if (cost > 0)
            ERC20(token).safeTransfer(isSuccess ? promisor : promisee, cost);

        emit Finalized(isSuccess, result);
        return true;
    }
}

// File: contracts/robonomics/Factory.sol

contract Factory is IFactory, SingletonHash {
    constructor(
        address _liability,
        address _lighthouse,
        DutchAuction _auction,
        AbstractENS _ens,
        XRT _xrt
    ) public {
        liabilityCode = _liability;
        lighthouseCode = _lighthouse;
        auction = _auction;
        ens = _ens;
        xrt = _xrt;
    }

    address public liabilityCode;
    address public lighthouseCode;

    using SafeERC20 for XRT;
    using SafeERC20 for ERC20;
    using SharedCode for address;

    /**
     * @dev Robonomics dutch auction contract
     */
    DutchAuction public auction;

    /**
     * @dev Ethereum name system
     */
    AbstractENS public ens;

    /**
     * @dev Robonomics network protocol token
     */
    XRT public xrt;

    /**
     * @dev SMMA filter with function: SMMA(i) = (SMMA(i-1)*(n-1) + PRICE(i)) / n
     * @param _prePrice PRICE[n-1]
     * @param _price PRICE[n]
     * @return filtered price
     */
    function smma(uint256 _prePrice, uint256 _price) internal pure returns (uint256) {
        return (_prePrice * (smmaPeriod - 1) + _price) / smmaPeriod;
    }

    /**
     * @dev SMMA filter period
     */
    uint256 private constant smmaPeriod = 100;

    /**
     * @dev XRT emission value for utilized gas
     */
    function wnFromGas(uint256 _gas) public view returns (uint256) {
        // Just return wn=gas when auction isn't finish
        if (auction.finalPrice() == 0)
            return _gas;

        // Current gas utilization epoch
        uint256 epoch = totalGasConsumed / gasEpoch;

        // XRT emission with addition coefficient by gas utilzation epoch
        uint256 wn = _gas * 10**9 * gasPrice * 2**epoch / 3**epoch / auction.finalPrice();

        // Check to not permit emission decrease below wn=gas
        return wn < _gas ? _gas : wn;
    }

    modifier onlyLighthouse {
        require(isLighthouse[msg.sender]);

        _;
    }

    modifier gasPriceEstimate {
        gasPrice = smma(gasPrice, tx.gasprice);

        _;
    }

    function createLighthouse(
        uint256 _minimalStake,
        uint256 _timeoutInBlocks,
        string  _name
    )
        external
        returns (ILighthouse lighthouse)
    {
        bytes32 LIGHTHOUSE_NODE
            // lighthouse.4.robonomics.eth
            = 0xbb02fe616f0926339902db4d17f52c2dfdb337f2a010da2743a8dbdac12d56f9;
        bytes32 hname = keccak256(bytes(_name));

        // Name reservation check
        bytes32 subnode = keccak256(abi.encodePacked(LIGHTHOUSE_NODE, hname));
        require(ens.resolver(subnode) == 0);

        // Create lighthouse
        lighthouse = ILighthouse(lighthouseCode.proxy());
        require(Lighthouse(lighthouse).setup(xrt, _minimalStake, _timeoutInBlocks));

        emit NewLighthouse(lighthouse, _name);
        isLighthouse[lighthouse] = true;

        // Register subnode
        ens.setSubnodeOwner(LIGHTHOUSE_NODE, hname, this);

        // Register lighthouse address
        AbstractResolver resolver = AbstractResolver(ens.resolver(LIGHTHOUSE_NODE));
        ens.setResolver(subnode, resolver);
        resolver.setAddr(subnode, lighthouse);
    }

    function createLiability(
        bytes _demand,
        bytes _offer
    )
        external
        onlyLighthouse
        returns (ILiability liability)
    {
        // Create liability
        liability = ILiability(liabilityCode.proxy());
        require(Liability(liability).setup(xrt));

        emit NewLiability(liability);

        // Parse messages
        require(address(liability).call(abi.encodePacked(bytes4(0xd9ff764a), _demand))); // liability.demand(...)
        singletonHash(liability.demandHash());

        require(address(liability).call(abi.encodePacked(bytes4(0xd5056962), _offer))); // liability.offer(...)
        singletonHash(liability.offerHash());

        // Check lighthouse
        require(isLighthouse[liability.lighthouse()]);

        // Transfer lighthouse fee to lighthouse worker directly
        if (liability.lighthouseFee() > 0)
            xrt.safeTransferFrom(liability.promisor(),
                                 tx.origin,
                                 liability.lighthouseFee());

        // Transfer liability security and hold on contract
        ERC20 token = ERC20(liability.token());
        if (liability.cost() > 0)
            token.safeTransferFrom(liability.promisee(),
                                   liability,
                                   liability.cost());

        // Transfer validator fee and hold on contract
        if (liability.validator() != 0 && liability.validatorFee() > 0)
            xrt.safeTransferFrom(liability.promisee(),
                                 liability,
                                 liability.validatorFee());
     }

    function liabilityCreated(
        ILiability _liability,
        uint256 _gas
    )
        external
        onlyLighthouse
        gasPriceEstimate
        returns (bool)
    {
        totalGasConsumed          += _gas;
        gasConsumedOf[_liability] += _gas;
        return true;
    }

    function liabilityFinalized(
        ILiability _liability,
        uint256 _gas
    )
        external
        onlyLighthouse
        gasPriceEstimate
        returns (bool)
    {
        totalGasConsumed          += _gas;
        gasConsumedOf[_liability] += _gas;
        require(xrt.mint(tx.origin, wnFromGas(gasConsumedOf[_liability])));
        return true;
    }
}

Contract ABI

[{"constant":true,"inputs":[],"name":"gasEpoch","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"xrt","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ens","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_minimalStake","type":"uint256"},{"name":"_timeoutInBlocks","type":"uint256"},{"name":"_name","type":"string"}],"name":"createLighthouse","outputs":[{"name":"lighthouse","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"liabilityCode","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lighthouseCode","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"auction","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"gasConsumedOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_liability","type":"address"},{"name":"_gas","type":"uint256"}],"name":"liabilityFinalized","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"isLighthouse","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_demand","type":"bytes"},{"name":"_offer","type":"bytes"}],"name":"createLiability","outputs":[{"name":"liability","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_gas","type":"uint256"}],"name":"wnFromGas","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalGasConsumed","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"isHashConsumed","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"gasPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_liability","type":"address"},{"name":"_gas","type":"uint256"}],"name":"liabilityCreated","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_liability","type":"address"},{"name":"_lighthouse","type":"address"},{"name":"_auction","type":"address"},{"name":"_ens","type":"address"},{"name":"_xrt","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"hash","type":"bytes32"}],"name":"HashConsumed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"liability","type":"address"}],"name":"NewLiability","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"lighthouse","type":"address"},{"indexed":false,"name":"name","type":"string"}],"name":"NewLighthouse","type":"event"}]

Contract Creation Code

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

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

000000000000000000000000ebe4a2835b2615c696491fa5dcf09c67bf870bb7000000000000000000000000780f2ae9cbd410e8b07a16011158ef11d4b2e7dd00000000000000000000000009f97189e9feac9ab61ef29b2553536805d369b1000000000000000000000000314159265dd8dbb310642f98f50c066173c1259b0000000000000000000000001664b2fa32448253b6d029aee6bd04d7978a7952

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000ebe4a2835b2615c696491fa5dcf09c67bf870bb7
Arg [1] : 000000000000000000000000780f2ae9cbd410e8b07a16011158ef11d4b2e7dd
Arg [2] : 00000000000000000000000009f97189e9feac9ab61ef29b2553536805d369b1
Arg [3] : 000000000000000000000000314159265dd8dbb310642f98f50c066173c1259b
Arg [4] : 0000000000000000000000001664b2fa32448253b6d029aee6bd04d7978a7952

Swarm Source

bzzr://839c80fe2efc56a343a144a6d1c12caffed129927787d9cb482df63ecc3a7f96
Block Age Transaction Difficulty GasUsed Reward
Block Age Uncle Number Difficulty GasUsed Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.