Blockwell

Envion

ERC20

This contract is an ERC20 token.

Name Envion
Symbol EVN
Decimals 18
Total Supply 127,425,494 EVN

About

Stats

Public Functions 27
Event Types 10
Code Size 85,261 bytes

Events (10) keyboard_arrow_up

Approval Event

Parameters help
_owner
address help
_spender
address help
_value
uint256 help

LogCancelDelivery Event

Parameters help
_to
address help
_id
string help

LogCreateEVN Event

Parameters help
_to
address help
_value
uint256 help

LogDeliverEVN Event

Parameters help
_to
address help
_value
uint256 help

LogKycRefused Event

Parameters help
_user
address help
_value
uint256 help

LogRefund Event

Parameters help
_to
address help
_value
uint256 help

LogTeamTokensDelivered Event

Parameters help
distributor
address help
_value
uint256 help

Transfer Event

Parameters help
_from
address help
_to
address help
_value
uint256 help

newOraclizeQuery Event

Parameters help
description
string help

updatedPrice Event

Parameters help
price
string help

Purchase Struct

Members
buyer
address help
tokenAmount
uint256 help
active
bool help

name Constant

string help
Envion

symbol Constant

string help
EVN

decimals Constant

uint256 help
18

version Constant

string help
0.9

TOKEN_CREATION_CAP Constant

uint256 help
130 * UNKNOWN VALUE * UNKNOWN VALUE

TOKEN_CREATED_MIN Constant

uint256 help
1 * UNKNOWN VALUE * UNKNOWN VALUE

ETH_RECEIVED_CAP Constant

uint256 help
5333 * UNKNOWN VALUE * UNKNOWN VALUE

ETH_RECEIVED_MIN Constant

uint256 help
1 * UNKNOWN VALUE * UNKNOWN VALUE

TOKEN_MIN Constant

uint256 help
1 * UNKNOWN VALUE

TOKEN_FIRST_DISCOUNT_MULTIPLIER Constant

uint256 help
142857

TOKEN_SECOND_DISCOUNT_MULTIPLIER Constant

uint256 help
125000

TOKEN_THIRD_DISCOUNT_MULTIPLIER Constant

uint256 help
111111

day Constant

uint help
60 * 60 * 24

week Constant

uint help
60 * 60 * 24 * 7

month Constant

uint help
60 * 60 * 24 * 30

proofType_NONE Constant

byte help
0x00

proofType_TLSNotary Constant

byte help
0x10

proofType_Android Constant

byte help
0x20

proofType_Ledger Constant

byte help
0x30

proofType_Native Constant

byte help
0xF0

proofStorage_IPFS Constant

byte help
0x01

networkID_auto Constant

uint8 help
0

networkID_mainnet Constant

uint8 help
1

networkID_testnet Constant

uint8 help
2

networkID_morden Constant

uint8 help
2

networkID_consensys Constant

uint8 help
161

fundingStartBlock Variable

uint256 help

fundingEndBlock Variable

uint256 help

roundTwoBlock Variable

uint256 help

roundThreeBlock Variable

uint256 help

roundFourBlock Variable

uint256 help

ccReleaseBlock Variable

uint256 help

admin1 Variable

address help

admin2 Variable

address help

tokenVendor Variable

address help

state Variable

ContractState help

allReceivedEth Variable

uint256 help

allUnKycedEth Variable

uint256 help

teamTokensDelivered Variable

bool help

ETH_USD_EXCHANGE_RATE_IN_CENTS Variable

uint256 help

oraclizeQueryCost Variable

uint help

totalSupply Variable

uint256 help

ccLockedUpBalances Variable

mapping(address => uint256) help

isHolder Variable

mapping(address => bool) help

isKycTeam Variable

mapping(address => bool) help

kycVerified Variable

mapping(address => bool) help

savedState Variable

ContractState help
Internal Variable

purchases Variable

mapping(string => Purchase) help
Internal Variable

purchaseArray Variable

string[] help
Internal Variable

holders Variable

address[] help
Internal Variable

isIcoBuyer Variable

mapping(address => bool) help
Internal Variable

ethBalances Variable

mapping(address => uint256) help
Internal Variable

noKycEthBalances Variable

mapping(address => uint256) help
Internal Variable

multiSigHashes Variable

mapping(address => bytes32) help
Internal Variable

balances Variable

mapping(address => uint256) help
Internal Variable

allowed Variable

mapping(address => mapping(address => uint256)) help
Internal Variable

OAR Variable

OraclizeAddrResolverI help
Internal Variable

oraclize Variable

OraclizeI help
Internal Variable

oraclize_network_name Variable

string help
Internal Variable

oraclize_randomDS_args Variable

mapping(bytes32 => bytes32) help
Internal Variable

oraclize_randomDS_sessionKeysHashVerified Variable

mapping(bytes32 => bool) help
Internal Variable

Functions Expand All Collapse All

Parameters help

Name Type
myid
bytes32 help
result
string help

Properties

Visibility help public
Mutability help transaction

Requirements help

Source Code
function __callback(bytes32 myid, string result) {
  require(msg.sender == oraclize_cbAddress());

  // setting the token price here
  ETH_USD_EXCHANGE_RATE_IN_CENTS = SafeMath.parse(result);
  updatedPrice(result);

  // fetch the next price
  updatePrice();
}

Parameters help

Name Type
myid
bytes32 help
result
string help
proof
bytes help

Properties

Visibility help public
Mutability help transaction
Source Code
function __callback(
  bytes32 myid,
  string result,
  bytes proof
) {}

Parameters help

Name Type
_owner
address help

Properties

Visibility help public
Mutability help constant
Source Code
function balanceOf(address _owner) public constant returns (uint256 balance) {
  return balances[_owner];
}

Parameters help

Name Type
_to
address help
_value
uint256 help

Properties

Visibility help public
Mutability help transaction

Modifiers help

Source Code
function transfer(address _to, uint256 _value)
  public
  isFinalized // Only allow token transfer after the fundraising has ended
  isKycVerified(msg.sender)
  hasEnoughUnlockedTokens(msg.sender, _value)
  onlyPayloadSize(2)
  returns (bool success)
{
  bool result = super.transfer(_to, _value);
  if (result) {
    trackHolder(_to); // track the owner for later payouts
  }
  return result;
}

Parameters help

Name Type
_from
address help
_to
address help
_value
uint256 help

Properties

Visibility help public
Mutability help transaction

Modifiers help

Source Code
function transferFrom(
  address _from,
  address _to,
  uint256 _value
)
  public
  isFinalized // Only allow token transfer after the fundraising has ended
  isKycVerified(msg.sender)
  hasEnoughUnlockedTokens(msg.sender, _value)
  onlyPayloadSize(3)
  returns (bool success)
{
  bool result = super.transferFrom(_from, _to, _value);
  if (result) {
    trackHolder(_to); // track the owner for later payouts
  }
  return result;
}

Parameters help

Name Type
_spender
address help
_value
uint256 help

Properties

Visibility help public
Mutability help transaction

Modifiers help

Source Code
function approve(address _spender, uint256 _value)
  public
  onlyPayloadSize(2)
  returns (bool success)
{
  allowed[msg.sender][_spender] = _value;
  Approval(msg.sender, _spender, _value);
  return true;
}

Parameters help

Name Type
_owner
address help
_spender
address help

Properties

Visibility help public
Mutability help constant

Modifiers help

Source Code
function allowance(address _owner, address _spender)
  public
  constant
  onlyPayloadSize(2)
  returns (uint256 remaining)
{
  return allowed[_owner][_spender];
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help payable
Source Code
function updatePrice() payable {
  // can be left public as a way for replenishing contract's ETH balance, just in case
  if (msg.sender != oraclize_cbAddress()) {
    require(msg.value >= 200 finney);
  }
  if (oraclize_getPrice("URL") > this.balance) {
    newOraclizeQuery(
      "Oraclize query was NOT sent, please add some ETH to cover for the query fee"
    );
  } else {
    newOraclizeQuery("Oraclize sent, wait..");
    // Schedule query in 1 hour. Set the gas amount to 220000, as parsing in __callback takes around 70000 - we play it safe.
    oraclize_query(
      3600,
      "URL",
      "json(https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD).USD",
      220000
    );
  }
}

Parameters help

Name Type
_owner
address help

Properties

Visibility help public
Mutability help constant
Source Code
function getBalanceOf(address _owner) constant returns (uint256 _balance) {
  return balances[_owner];
}

Parameters help

Name Type
_id
string help

Properties

Visibility help public
Mutability help constant
Source Code
function getPurchaseById(string _id)
  constant
  returns (
    address _buyer,
    uint256 _tokenAmount,
    bool _active
  )
{
  _buyer = purchases[_id].buyer;
  _tokenAmount = purchases[_id].tokenAmount;
  _active = purchases[_id].active;
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help constant
Source Code
function getHolderCount() public constant returns (uint256 _holderCount) {
  return holders.length;
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help constant
Source Code
function getPurchaseCount() public constant returns (uint256 _purchaseCount) {
  return purchaseArray.length;
}

Parameters help

Name Type
_index
uint256 help

Properties

Visibility help public
Mutability help constant
Source Code
function getHolder(uint256 _index) public constant returns (address _holder) {
  return holders[_index];
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help payable

Requirements help

Source Code
function createTokens() external payable isFundraising {
  require(block.number >= fundingStartBlock);
  require(block.number <= fundingEndBlock);
  require(msg.value > 0);

  // First we check the ETH cap: would adding this amount to the total unKYCed eth and the already KYCed eth exceed the eth cap?
  // return the contribution if the cap has been reached already
  uint256 totalKycedAndUnKycEdEth = SafeMath.add(allUnKycedEth, allReceivedEth);
  uint256 checkedReceivedEth = SafeMath.add(totalKycedAndUnKycEdEth, msg.value);
  require(checkedReceivedEth <= ETH_RECEIVED_CAP);

  // If all is fine with the ETH cap, we continue to check the
  // minimum amount of tokens and the cap for how many tokens
  // have been generated so far

  // calculate the token amount
  uint256 tokens = SafeMath.mul(msg.value, ETH_USD_EXCHANGE_RATE_IN_CENTS);

  // divide by 100 to turn ETH_USD_EXCHANGE_RATE_IN_CENTS into full USD
  tokens = tokens / 100;

  // apply discount multiplier
  tokens = safeMulPercentage(tokens, getCurrentDiscountRate());

  require(tokens >= TOKEN_MIN);
  uint256 checkedSupply = SafeMath.add(totalSupply, tokens);
  require(checkedSupply <= TOKEN_CREATION_CAP);

  // Only when all the checks have passed, then we check if the address is already KYCEd and then
  // update the state (noKycEthBalances, allReceivedEth, totalSupply, and balances) of the contract

  if (kycVerified[msg.sender] == false) {
    // @dev The unKYCed eth balances are moved to ethBalances in unlockKyc()

    noKycEthBalances[msg.sender] = SafeMath.add(
      noKycEthBalances[msg.sender],
      msg.value
    );

    // add the contributed eth to the total unKYCed eth amount
    allUnKycedEth = SafeMath.add(allUnKycedEth, msg.value);
  } else {
    // if buyer is already KYC unlocked...
    ethBalances[msg.sender] = SafeMath.add(ethBalances[msg.sender], msg.value);
    allReceivedEth = SafeMath.add(allReceivedEth, msg.value);
  }

  totalSupply = checkedSupply;
  balances[msg.sender] += tokens; // safeAdd not needed; bad semantics to use here

  trackHolder(msg.sender);

  // to force the check for KYC Status upon the user when he tries transferring tokens
  // and exclude every later token owner
  isIcoBuyer[msg.sender] = true;

  // Log the creation of these tokens
  LogCreateEVN(msg.sender, tokens);
}

Parameters help

Name Type
_teamMember
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function addToKycTeam(address _teamMember) onlyOwner onlyPayloadSize(1) {
  isKycTeam[_teamMember] = true;
}

Parameters help

Name Type
_teamMember
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function removeFromKycTeam(address _teamMember) onlyOwner onlyPayloadSize(1) {
  isKycTeam[_teamMember] = false;
}

Parameters help

Name Type
_owner
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function unlockKyc(address _owner) external onlyKycTeam {
  require(kycVerified[_owner] == false);

  //unlock the owner to allow transfer of tokens
  kycVerified[_owner] = true;

  // we leave the ccLockedUpBalances[_owner] as is, because also KYCed users could cancel their CC payments

  if (noKycEthBalances[_owner] > 0) {
    // check if the user was an ETH buyer

    // now move the unKYCed eth balance to the regular ethBalance.
    ethBalances[_owner] = noKycEthBalances[_owner];

    // add the now KYCed eth to the total received eth
    allReceivedEth = SafeMath.add(allReceivedEth, noKycEthBalances[_owner]);

    // subtract the now KYCed eth from total amount of unKYCed eth
    allUnKycedEth = SafeMath.sub(allUnKycedEth, noKycEthBalances[_owner]);

    // and set the user's unKYCed eth balance to 0
    noKycEthBalances[_owner] = 0; // preventing replay attacks
  }
}

Parameters help

Name Type
_user
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function refuseKyc(address _user) external onlyKycTeam {
  // once a user is verified, you can't kick him out.
  require(kycVerified[_user] == false);

  // immediately stop, if a user has none or only CC contributions.
  // we're managing kyc refusing of CC contributors off-chain
  require(noKycEthBalances[_user] > 0);

  uint256 EVNVal = balances[_user];
  require(EVNVal > 0);

  uint256 ethVal = noKycEthBalances[_user]; // refund un-KYCd eth
  require(ethVal > 0);

  // Update the state only after all the checks have passed
  allUnKycedEth = SafeMath.sub(allUnKycedEth, noKycEthBalances[_user]); // or if there was any unKYCed Eth, subtract it from the total unKYCed eth balance.
  balances[_user] = ccLockedUpBalances[_user]; // assign user only the token amount he has bought through CC, if there are any.
  noKycEthBalances[_user] = 0;
  totalSupply = SafeMath.sub(totalSupply, EVNVal); // Extra safe

  // Log this refund
  LogKycRefused(_user, ethVal);

  // Send the contributions only after we have updated all the balances
  // If you're using a contract, make sure it works with .transfer() gas limits
  _user.transfer(ethVal);
}

Parameters help

Name Type
_purchaseID
string help

Properties

Visibility help public
Mutability help transaction
Source Code
function cancelDelivery(string _purchaseID) external onlyKycTeam {
  // CC payments are only cancelable until ccReleaseBlock
  require(block.number < ccReleaseBlock);

  // check if the purchase to cancel is still active
  require(purchases[_purchaseID].active == true);

  // now withdraw the canceled purchase's token amount from the user's balance
  balances[purchases[_purchaseID].buyer] = SafeMath.sub(
    balances[purchases[_purchaseID].buyer],
    purchases[_purchaseID].tokenAmount
  );

  // and withdraw the canceled purchase's token amount from the lockedUp token balance
  ccLockedUpBalances[purchases[_purchaseID].buyer] = SafeMath.sub(
    ccLockedUpBalances[purchases[_purchaseID].buyer],
    purchases[_purchaseID].tokenAmount
  );

  // set the purchase's status to inactive
  purchases[_purchaseID].active = false;

  //correct th amount of tokens generated
  totalSupply = SafeMath.sub(totalSupply, purchases[_purchaseID].tokenAmount);

  LogCancelDelivery(purchases[_purchaseID].buyer, _purchaseID);
}

Parameters help

Name Type
_to
address help
_tokens
uint256 help
_purchaseId
string help
_btcBuyer
bool help

Properties

Visibility help public
Mutability help transaction

Requirements help

Source Code
function deliverTokens(
  address _to,
  uint256 _tokens,
  string _purchaseId,
  bool _btcBuyer
) external isFundraising onlyVendor {
  require(_to != 0x0);
  require(_tokens > 0);
  require(bytes(_purchaseId).length > 0);
  require(block.number >= fundingStartBlock);
  require(block.number <= fundingEndBlock + 168000); // allow delivery of tokens sold for fiat for 28 days after end of ICO for safety reasons

  // calculate the total amount of tokens and cut out the extra two decimal units,
  // because _tokens was in cents.
  uint256 tokens = SafeMath.mul(_tokens, (10**(decimals) / 10**2));

  // continue to check for how many tokens
  // have been generated so far
  uint256 checkedSupply = SafeMath.add(totalSupply, tokens);
  require(checkedSupply <= TOKEN_CREATION_CAP);

  // Only when all the checks have passed, then we update the state (totalSupply, and balances) of the contract
  totalSupply = checkedSupply;

  // prevent from adding a delivery multiple times
  require(purchases[_purchaseId].buyer == 0x0);

  // Log this information in order to be able to cancel token deliveries (on CC refund) by the payment ID
  purchases[_purchaseId] = Purchase({
    buyer: _to,
    tokenAmount: tokens,
    active: true
  });
  purchaseArray.push(_purchaseId);

  // if tokens were not paid with BTC (but credit card), they need to be locked up
  if (_btcBuyer == false) {
    ccLockedUpBalances[_to] = SafeMath.add(ccLockedUpBalances[_to], tokens); // update user's locked up token balance
  }

  balances[_to] = SafeMath.add(balances[_to], tokens); // safeAdd not needed; bad semantics to use here
  trackHolder(_to); // log holder's address

  // to force the check for KYC Status upon the user when he tries transferring tokens
  // and exclude every later token owner
  isIcoBuyer[_to] = true;

  // Log the creation of these tokens
  LogDeliverEVN(_to, tokens);
}

Parameters help

Name Type
_value
uint256 help
_safe
address help

Properties

Visibility help public
Mutability help transaction

Modifiers help

Requirements help

Source Code
function retrieveEth(uint256 _value, address _safe)
  external
  minimumReached
  onlyOwner
{
  require(SafeMath.sub(this.balance, _value) >= allUnKycedEth); // make sure unKYCed eth cannot be withdrawn
  // make sure a recipient was defined !
  require(_safe != 0x0);

  // send the eth to where admins agree upon
  _safe.transfer(_value);
}

Parameters help

Name Type
_safe
address help

Properties

Visibility help public
Mutability help transaction

Modifiers help

Source Code
function finalize(address _safe)
  external
  isFundraising
  minimumReached
  onlyOwner // Only the admins calling this method exactly the same way can finalize the sale.
{
  // Only allow to finalize the contract before the ending block if we already reached any of the two caps
  require(
    block.number > fundingEndBlock ||
      totalSupply >= TOKEN_CREATED_MIN ||
      allReceivedEth >= ETH_RECEIVED_MIN
  );
  // make sure a recipient was defined !
  require(_safe != 0x0);

  // Move the contract to Finalized state
  state = ContractState.Finalized;
  savedState = ContractState.Finalized;

  // Send the KYCed ETH to where admins agree upon.
  _safe.transfer(allReceivedEth);
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help transaction
Source Code
function pause()
  external
  notPaused // Prevent the contract getting stuck in the Paused state
  onlyOwner // Only both admins calling this method can pause the contract
{
  // Move the contract to Paused state
  savedState = state;
  state = ContractState.Paused;
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help transaction
Source Code
function proceed()
  external
  isPaused
  onlyOwner // Only both admins calling this method can proceed with the contract
{
  // Move the contract to the previous state
  state = savedState;
}

Parameters help

This function has no parameters.

Properties

Visibility help public
Mutability help transaction

Requirements help

Source Code
function refund() external {
  // Allow refunds only a week after end of funding to give KYC-team time to verify contributors
  // and thereby move un-KYC-ed ETH over into allReceivedEth as well as deliver the tokens paid with CC
  require(block.number > (fundingEndBlock + 42000));

  // No refunds if the minimum has been reached or minimum of 1 Million Tokens have been generated
  require(allReceivedEth < ETH_RECEIVED_MIN || totalSupply < TOKEN_CREATED_MIN);

  // to prevent CC buyers from accidentally calling refund and burning their tokens
  require(ethBalances[msg.sender] > 0 || noKycEthBalances[msg.sender] > 0);

  // Only refund if there are EVN tokens
  uint256 EVNVal = balances[msg.sender];
  require(EVNVal > 0);

  // refunds either KYCed eth or un-KYCd eth
  uint256 ethVal = SafeMath.add(
    ethBalances[msg.sender],
    noKycEthBalances[msg.sender]
  );
  require(ethVal > 0);

  allReceivedEth = SafeMath.sub(allReceivedEth, ethBalances[msg.sender]); // subtract only the KYCed ETH from allReceivedEth, because the latter is what admins will only be able to withdraw
  allUnKycedEth = SafeMath.sub(allUnKycedEth, noKycEthBalances[msg.sender]); // or if there was any unKYCed Eth, subtract it from the total unKYCed eth balance.

  // Update the state only after all the checks have passed.
  // reset everything to zero, no replay attacks.
  balances[msg.sender] = 0;
  ethBalances[msg.sender] = 0;
  noKycEthBalances[msg.sender] = 0;
  totalSupply = SafeMath.sub(totalSupply, EVNVal); // Extra safe

  // Log this refund
  LogRefund(msg.sender, ethVal);

  // Send the contributions only after we have updated all the balances
  // If you're using a contract, make sure it works with .transfer() gas limits
  msg.sender.transfer(ethVal);
}

Parameters help

Name Type
_to
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function deliverTeamTokens(address _to) external isFinalized onlyOwner {
  require(teamTokensDelivered == false);
  require(_to != 0x0);

  // allow delivery of tokens for the company and supporters without vesting, team tokens will be supplied like a CC purchase.

  // company and supporters gets 7% of a whole final pie, meaning we have to add ~7,5% to the
  // current totalSupply now, basically stretching it and taking 7% from the result, so the 93% that remain equals the amount of tokens created right now.
  // e.g. (93 * x = 100, where x amounts to roughly about 1.07526 and 7 would be the team's part)
  uint256 newTotalSupply = safeMulPercentage(totalSupply, 107526);

  // give company and supporters their 7%
  uint256 tokens = SafeMath.sub(newTotalSupply, totalSupply);
  balances[_to] = tokens;

  //update state
  teamTokensDelivered = true;
  totalSupply = newTotalSupply;
  trackHolder(_to);

  // Log the creation of these tokens
  LogTeamTokensDelivered(_to, tokens);
}

Parameters help

Name Type
_option
uint256 help

Properties

Visibility help public
Mutability help transaction
Source Code
function setOraclizeGas(uint256 _option) external onlyOwner {
  if (_option <= 30) {
    oraclize_setCustomGasPrice(30000000000 wei);
  } else if (_option <= 50) {
    oraclize_setCustomGasPrice(50000000000 wei);
  } else if (_option <= 70) {
    oraclize_setCustomGasPrice(70000000000 wei);
  } else if (_option <= 100) {
    oraclize_setCustomGasPrice(100000000000 wei);
  }
}

Internal Functions Expand All Collapse All

Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.

internal EVNToken.safeMulPercentage keyboard_arrow_up

Parameters help

Name Type
value
uint256 help
percentage
uint256 help

Properties

Visibility help internal
Mutability help constant

Requirements help

Source Code
function safeMulPercentage(uint256 value, uint256 percentage)
  internal
  constant
  returns (uint256 resultValue)
{
  require(percentage >= 100000);
  require(percentage < 200000);

  // Multiply with percentage
  uint256 newValue = SafeMath.mul(value, percentage);
  // Remove the 5 extra decimals
  newValue = newValue / 10**5;
  return newValue;
}

internal usingOraclize.oraclize_setNetwork keyboard_arrow_up

Parameters help

Name Type
networkID
uint8 help

Properties

Visibility help internal
Mutability help transaction
Source Code
function oraclize_setNetwork(uint8 networkID) internal returns (bool) {
  if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed) > 0) {
    //mainnet
    OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
    oraclize_setNetworkName("eth_mainnet");
    return true;
  }
  if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1) > 0) {
    //ropsten testnet
    OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
    oraclize_setNetworkName("eth_ropsten3");
    return true;
  }
  if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e) > 0) {
    //kovan testnet
    OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
    oraclize_setNetworkName("eth_kovan");
    return true;
  }
  if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48) > 0) {
    //rinkeby testnet
    OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
    oraclize_setNetworkName("eth_rinkeby");
    return true;
  }
  if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475) > 0) {
    //ethereum-bridge
    OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
    return true;
  }
  if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF) > 0) {
    //ether.camp ide
    OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
    return true;
  }
  if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA) > 0) {
    //browser-solidity
    OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
    return true;
  }
  return false;
}

internal usingOraclize.oraclize_useCoupon keyboard_arrow_up

Parameters help

Name Type
code
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_useCoupon(string code) internal oraclizeAPI {
  oraclize.useCoupon(code);
}

internal usingOraclize.oraclize_getPrice keyboard_arrow_up

Parameters help

Name Type
datasource
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_getPrice(string datasource)
  internal
  oraclizeAPI
  returns (uint256)
{
  return oraclize.getPrice(datasource);
}

internal usingOraclize.oraclize_getPrice keyboard_arrow_up

Parameters help

Name Type
datasource
string help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_getPrice(string datasource, uint256 gaslimit)
  internal
  oraclizeAPI
  returns (uint256)
{
  return oraclize.getPrice(datasource, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
arg
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string arg)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  return oraclize.query.value(price)(0, datasource, arg);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
arg
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string arg
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  return oraclize.query.value(price)(timestamp, datasource, arg);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
arg
string help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string arg,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  return
    oraclize.query_withGasLimit.value(price)(
      timestamp,
      datasource,
      arg,
      gaslimit
    );
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
arg
string help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string arg,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
arg1
string help
arg2
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string arg1,
  string arg2
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
arg1
string help
arg2
string help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string arg1,
  string arg2
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
arg1
string help
arg2
string help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string arg1,
  string arg2,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  return
    oraclize.query2_withGasLimit.value(price)(
      timestamp,
      datasource,
      arg1,
      arg2,
      gaslimit
    );
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
arg1
string help
arg2
string help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string arg1,
  string arg2,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  return
    oraclize.query2_withGasLimit.value(price)(
      0,
      datasource,
      arg1,
      arg2,
      gaslimit
    );
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
argN
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[] argN)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  bytes memory args = stra2cbor(argN);
  return oraclize.queryN.value(price)(0, datasource, args);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
argN
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[] argN
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  bytes memory args = stra2cbor(argN);
  return oraclize.queryN.value(price)(timestamp, datasource, args);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
argN
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[] argN,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  bytes memory args = stra2cbor(argN);
  return
    oraclize.queryN_withGasLimit.value(price)(
      timestamp,
      datasource,
      args,
      gaslimit
    );
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
argN
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[] argN,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  bytes memory args = stra2cbor(argN);
  return
    oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[1] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  string[] memory dynargs = new string[](1);
  dynargs[0] = args[0];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[1] args
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](1);
  dynargs[0] = args[0];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[1] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](1);
  dynargs[0] = args[0];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[1] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](1);
  dynargs[0] = args[0];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[2] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  string[] memory dynargs = new string[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[2] args
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[2] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[2] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[3] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  string[] memory dynargs = new string[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[3] args
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[3] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[3] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[4] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  string[] memory dynargs = new string[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[4] args
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[4] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[4] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, string[5] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  string[] memory dynargs = new string[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[5] args
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  string[5] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
string[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  string[5] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  string[] memory dynargs = new string[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
argN
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[] argN)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  bytes memory args = ba2cbor(argN);
  return oraclize.queryN.value(price)(0, datasource, args);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
argN
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[] argN
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource);
  if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
  bytes memory args = ba2cbor(argN);
  return oraclize.queryN.value(price)(timestamp, datasource, args);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
argN
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[] argN,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  bytes memory args = ba2cbor(argN);
  return
    oraclize.queryN_withGasLimit.value(price)(
      timestamp,
      datasource,
      args,
      gaslimit
    );
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
argN
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[] argN,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  uint256 price = oraclize.getPrice(datasource, gaslimit);
  if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
  bytes memory args = ba2cbor(argN);
  return
    oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[1] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  bytes[] memory dynargs = new bytes[](1);
  dynargs[0] = args[0];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[1] args
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](1);
  dynargs[0] = args[0];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[1] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](1);
  dynargs[0] = args[0];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[1] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](1);
  dynargs[0] = args[0];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[2] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  bytes[] memory dynargs = new bytes[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[2] args
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[2] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[2] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](2);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[3] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  bytes[] memory dynargs = new bytes[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[3] args
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[3] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[3] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](3);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[4] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  bytes[] memory dynargs = new bytes[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[4] args
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[4] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[4] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](4);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(string datasource, bytes[5] args)
  internal
  oraclizeAPI
  returns (bytes32 id)
{
  bytes[] memory dynargs = new bytes[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[5] args
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(timestamp, datasource, dynargs);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
timestamp
uint help
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  uint256 timestamp,
  string datasource,
  bytes[5] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_query keyboard_arrow_up

Parameters help

Name Type
datasource
string help
args
bytes[] help
gaslimit
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_query(
  string datasource,
  bytes[5] args,
  uint256 gaslimit
) internal oraclizeAPI returns (bytes32 id) {
  bytes[] memory dynargs = new bytes[](5);
  dynargs[0] = args[0];
  dynargs[1] = args[1];
  dynargs[2] = args[2];
  dynargs[3] = args[3];
  dynargs[4] = args[4];
  return oraclize_query(datasource, dynargs, gaslimit);
}

internal usingOraclize.oraclize_cbAddress keyboard_arrow_up

Parameters help

This function has no parameters.

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_cbAddress() internal oraclizeAPI returns (address) {
  return oraclize.cbAddress();
}

internal usingOraclize.oraclize_setProof keyboard_arrow_up

Parameters help

Name Type
proofP
byte help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_setProof(byte proofP) internal oraclizeAPI {
  return oraclize.setProofType(proofP);
}

internal usingOraclize.oraclize_setCustomGasPrice keyboard_arrow_up

Parameters help

Name Type
gasPrice
uint help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_setCustomGasPrice(uint256 gasPrice) internal oraclizeAPI {
  return oraclize.setCustomGasPrice(gasPrice);
}

internal usingOraclize.oraclize_setConfig keyboard_arrow_up

Parameters help

Name Type
config
bytes32 help

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_setConfig(bytes32 config) internal oraclizeAPI {
  return oraclize.setConfig(config);
}

internal usingOraclize.oraclize_randomDS_getSessionPubKeyHash keyboard_arrow_up

Parameters help

This function has no parameters.

Properties

Visibility help internal
Mutability help transaction

Modifiers help

oraclizeAPI checks for the following:
Source Code
function oraclize_randomDS_getSessionPubKeyHash()
  internal
  oraclizeAPI
  returns (bytes32)
{
  return oraclize.randomDS_getSessionPubKeyHash();
}

internal usingOraclize.getCodeSize keyboard_arrow_up

Parameters help

Name Type
_addr
address help

Properties

Visibility help internal
Mutability help constant
Source Code
function getCodeSize(address _addr) internal constant returns (uint256 _size) {
  assembly {
    _size := extcodesize(_addr)
  }
}

internal usingOraclize.parseAddr keyboard_arrow_up

Parameters help

Name Type
_a
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function parseAddr(string _a) internal returns (address) {
  bytes memory tmp = bytes(_a);
  uint160 iaddr = 0;
  uint160 b1;
  uint160 b2;
  for (uint256 i = 2; i < 2 + 2 * 20; i += 2) {
    iaddr *= 256;
    b1 = uint160(tmp[i]);
    b2 = uint160(tmp[i + 1]);
    if ((b1 >= 97) && (b1 <= 102)) b1 -= 87;
    else if ((b1 >= 65) && (b1 <= 70)) b1 -= 55;
    else if ((b1 >= 48) && (b1 <= 57)) b1 -= 48;
    if ((b2 >= 97) && (b2 <= 102)) b2 -= 87;
    else if ((b2 >= 65) && (b2 <= 70)) b2 -= 55;
    else if ((b2 >= 48) && (b2 <= 57)) b2 -= 48;
    iaddr += (b1 * 16 + b2);
  }
  return address(iaddr);
}

internal usingOraclize.strCompare keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function strCompare(string _a, string _b) internal returns (int256) {
  bytes memory a = bytes(_a);
  bytes memory b = bytes(_b);
  uint256 minLength = a.length;
  if (b.length < minLength) minLength = b.length;
  for (uint256 i = 0; i < minLength; i++)
    if (a[i] < b[i]) return -1;
    else if (a[i] > b[i]) return 1;
  if (a.length < b.length) return -1;
  else if (a.length > b.length) return 1;
  else return 0;
}

internal usingOraclize.indexOf keyboard_arrow_up

Parameters help

Name Type
_haystack
string help
_needle
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function indexOf(string _haystack, string _needle) internal returns (int256) {
  bytes memory h = bytes(_haystack);
  bytes memory n = bytes(_needle);
  if (h.length < 1 || n.length < 1 || (n.length > h.length)) return -1;
  else if (h.length > (2**128 - 1)) return -1;
  else {
    uint256 subindex = 0;
    for (uint256 i = 0; i < h.length; i++) {
      if (h[i] == n[0]) {
        subindex = 1;
        while (
          subindex < n.length &&
          (i + subindex) < h.length &&
          h[i + subindex] == n[subindex]
        ) {
          subindex++;
        }
        if (subindex == n.length) return int256(i);
      }
    }
    return -1;
  }
}

internal usingOraclize.strConcat keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
string help
_c
string help
_d
string help
_e
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function strConcat(
  string _a,
  string _b,
  string _c,
  string _d,
  string _e
) internal returns (string) {
  bytes memory _ba = bytes(_a);
  bytes memory _bb = bytes(_b);
  bytes memory _bc = bytes(_c);
  bytes memory _bd = bytes(_d);
  bytes memory _be = bytes(_e);
  string memory abcde = new string(
    _ba.length + _bb.length + _bc.length + _bd.length + _be.length
  );
  bytes memory babcde = bytes(abcde);
  uint256 k = 0;
  for (uint256 i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
  for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
  for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
  for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
  for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
  return string(babcde);
}

internal usingOraclize.strConcat keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
string help
_c
string help
_d
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function strConcat(
  string _a,
  string _b,
  string _c,
  string _d
) internal returns (string) {
  return strConcat(_a, _b, _c, _d, "");
}

internal usingOraclize.strConcat keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
string help
_c
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function strConcat(
  string _a,
  string _b,
  string _c
) internal returns (string) {
  return strConcat(_a, _b, _c, "", "");
}

internal usingOraclize.strConcat keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function strConcat(string _a, string _b) internal returns (string) {
  return strConcat(_a, _b, "", "", "");
}

internal usingOraclize.parseInt keyboard_arrow_up

Parameters help

Name Type
_a
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function parseInt(string _a) internal returns (uint256) {
  return parseInt(_a, 0);
}

internal usingOraclize.parseInt keyboard_arrow_up

Parameters help

Name Type
_a
string help
_b
uint help

Properties

Visibility help internal
Mutability help transaction
Source Code
function parseInt(string _a, uint256 _b) internal returns (uint256) {
  bytes memory bresult = bytes(_a);
  uint256 mint = 0;
  bool decimals = false;
  for (uint256 i = 0; i < bresult.length; i++) {
    if ((bresult[i] >= 48) && (bresult[i] <= 57)) {
      if (decimals) {
        if (_b == 0) break;
        else _b--;
      }
      mint *= 10;
      mint += uint256(bresult[i]) - 48;
    } else if (bresult[i] == 46) decimals = true;
  }
  if (_b > 0) mint *= 10**_b;
  return mint;
}

internal usingOraclize.uint2str keyboard_arrow_up

Parameters help

Name Type
i
uint help

Properties

Visibility help internal
Mutability help transaction
Source Code
function uint2str(uint256 i) internal returns (string) {
  if (i == 0) return "0";
  uint256 j = i;
  uint256 len;
  while (j != 0) {
    len++;
    j /= 10;
  }
  bytes memory bstr = new bytes(len);
  uint256 k = len - 1;
  while (i != 0) {
    bstr[k--] = byte(48 + (i % 10));
    i /= 10;
  }
  return string(bstr);
}

internal usingOraclize.stra2cbor keyboard_arrow_up

Parameters help

Name Type
arr
string[] help

Properties

Visibility help internal
Mutability help transaction
Source Code
function stra2cbor(string[] arr) internal returns (bytes) {
  uint256 arrlen = arr.length;

  // get correct cbor output length
  uint256 outputlen = 0;
  bytes[] memory elemArray = new bytes[](arrlen);
  for (uint256 i = 0; i < arrlen; i++) {
    elemArray[i] = (bytes(arr[i]));
    outputlen += elemArray[i].length + (elemArray[i].length - 1) / 23 + 3; //+3 accounts for paired identifier types
  }
  uint256 ctr = 0;
  uint256 cborlen = arrlen + 0x80;
  outputlen += byte(cborlen).length;
  bytes memory res = new bytes(outputlen);

  while (byte(cborlen).length > ctr) {
    res[ctr] = byte(cborlen)[ctr];
    ctr++;
  }
  for (i = 0; i < arrlen; i++) {
    res[ctr] = 0x5F;
    ctr++;
    for (uint256 x = 0; x < elemArray[i].length; x++) {
      // if there's a bug with larger strings, this may be the culprit
      if (x % 23 == 0) {
        uint256 elemcborlen = elemArray[i].length - x >= 24
          ? 23
          : elemArray[i].length - x;
        elemcborlen += 0x40;
        uint256 lctr = ctr;
        while (byte(elemcborlen).length > ctr - lctr) {
          res[ctr] = byte(elemcborlen)[ctr - lctr];
          ctr++;
        }
      }
      res[ctr] = elemArray[i][x];
      ctr++;
    }
    res[ctr] = 0xFF;
    ctr++;
  }
  return res;
}

internal usingOraclize.ba2cbor keyboard_arrow_up

Parameters help

Name Type
arr
bytes[] help

Properties

Visibility help internal
Mutability help transaction
Source Code
function ba2cbor(bytes[] arr) internal returns (bytes) {
  uint256 arrlen = arr.length;

  // get correct cbor output length
  uint256 outputlen = 0;
  bytes[] memory elemArray = new bytes[](arrlen);
  for (uint256 i = 0; i < arrlen; i++) {
    elemArray[i] = (bytes(arr[i]));
    outputlen += elemArray[i].length + (elemArray[i].length - 1) / 23 + 3; //+3 accounts for paired identifier types
  }
  uint256 ctr = 0;
  uint256 cborlen = arrlen + 0x80;
  outputlen += byte(cborlen).length;
  bytes memory res = new bytes(outputlen);

  while (byte(cborlen).length > ctr) {
    res[ctr] = byte(cborlen)[ctr];
    ctr++;
  }
  for (i = 0; i < arrlen; i++) {
    res[ctr] = 0x5F;
    ctr++;
    for (uint256 x = 0; x < elemArray[i].length; x++) {
      // if there's a bug with larger strings, this may be the culprit
      if (x % 23 == 0) {
        uint256 elemcborlen = elemArray[i].length - x >= 24
          ? 23
          : elemArray[i].length - x;
        elemcborlen += 0x40;
        uint256 lctr = ctr;
        while (byte(elemcborlen).length > ctr - lctr) {
          res[ctr] = byte(elemcborlen)[ctr - lctr];
          ctr++;
        }
      }
      res[ctr] = elemArray[i][x];
      ctr++;
    }
    res[ctr] = 0xFF;
    ctr++;
  }
  return res;
}

internal usingOraclize.oraclize_setNetworkName keyboard_arrow_up

Parameters help

Name Type
_network_name
string help

Properties

Visibility help internal
Mutability help transaction
Source Code
function oraclize_setNetworkName(string _network_name) internal {
  oraclize_network_name = _network_name;
}

internal usingOraclize.oraclize_getNetworkName keyboard_arrow_up

Parameters help

This function has no parameters.

Properties

Visibility help internal
Mutability help transaction
Source Code
function oraclize_getNetworkName() internal returns (string) {
  return oraclize_network_name;
}

internal usingOraclize.oraclize_newRandomDSQuery keyboard_arrow_up

Parameters help

Name Type
_delay
uint help
_nbytes
uint help
_customGasLimit
uint help

Properties

Visibility help internal
Mutability help transaction
Source Code
function oraclize_newRandomDSQuery(
  uint256 _delay,
  uint256 _nbytes,
  uint256 _customGasLimit
) internal returns (bytes32) {
  if ((_nbytes == 0) || (_nbytes > 32)) throw;
  bytes memory nbytes = new bytes(1);
  nbytes[0] = byte(_nbytes);
  bytes memory unonce = new bytes(32);
  bytes memory sessionKeyHash = new bytes(32);
  bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
  assembly {
    mstore(unonce, 0x20)
    mstore(
      add(unonce, 0x20),
      xor(blockhash(sub(number, 1)), xor(coinbase, timestamp))
    )
    mstore(sessionKeyHash, 0x20)
    mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
  }
  bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
  bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
  oraclize_randomDS_setCommitment(
    queryId,
    sha3(bytes8(_delay), args[1], sha256(args[0]), args[2])
  );
  return queryId;
}

internal usingOraclize.oraclize_randomDS_setCommitment keyboard_arrow_up

Parameters help

Name Type
queryId
bytes32 help
commitment
bytes32 help

Properties

Visibility help internal
Mutability help transaction
Source Code
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment)
  internal
{
  oraclize_randomDS_args[queryId] = commitment;
}

internal usingOraclize.verifySig keyboard_arrow_up

Parameters help

Name Type
tosignh
bytes32 help
dersig
bytes help
pubkey
bytes help

Properties

Visibility help internal
Mutability help transaction
Source Code
function verifySig(
  bytes32 tosignh,
  bytes dersig,
  bytes pubkey
) internal returns (bool) {
  bool sigok;
  address signer;

  bytes32 sigr;
  bytes32 sigs;

  bytes memory sigr_ = new bytes(32);
  uint256 offset = 4 + (uint256(dersig[3]) - 0x20);
  sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
  bytes memory sigs_ = new bytes(32);
  offset += 32 + 2;
  sigs_ = copyBytes(
    dersig,
    offset + (uint256(dersig[offset - 1]) - 0x20),
    32,
    sigs_,
    0
  );

  assembly {
    sigr := mload(add(sigr_, 32))
    sigs := mload(add(sigs_, 32))
  }

  (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
  if (address(sha3(pubkey)) == signer) return true;
  else {
    (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
    return (address(sha3(pubkey)) == signer);
  }
}

internal usingOraclize.oraclize_randomDS_proofVerify__sessionKeyValidity keyboard_arrow_up

Parameters help

Name Type
proof
bytes help
sig2offset
uint help

Properties

Visibility help internal
Mutability help transaction

Requirements help

Source Code
function oraclize_randomDS_proofVerify__sessionKeyValidity(
  bytes proof,
  uint256 sig2offset
) internal returns (bool) {
  bool sigok;

  // Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
  bytes memory sig2 = new bytes(uint256(proof[sig2offset + 1]) + 2);
  copyBytes(proof, sig2offset, sig2.length, sig2, 0);

  bytes memory appkey1_pubkey = new bytes(64);
  copyBytes(proof, 3 + 1, 64, appkey1_pubkey, 0);

  bytes memory tosign2 = new bytes(1 + 65 + 32);
  tosign2[0] = 1; //role
  copyBytes(proof, sig2offset - 65, 65, tosign2, 1);

    bytes memory CODEHASH
   = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
  copyBytes(CODEHASH, 0, 32, tosign2, 1 + 65);
  sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);

  if (sigok == false) return false;

  // Step 7: verify the APPKEY1 provenance (must be signed by Ledger)

    bytes memory LEDGERKEY
   = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";

  bytes memory tosign3 = new bytes(1 + 65);
  tosign3[0] = 0xFE;
  copyBytes(proof, 3, 65, tosign3, 1);

  bytes memory sig3 = new bytes(uint256(proof[3 + 65 + 1]) + 2);
  copyBytes(proof, 3 + 65, sig3.length, sig3, 0);

  sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);

  return sigok;
}

internal usingOraclize.matchBytes32Prefix keyboard_arrow_up

Parameters help

Name Type
content
bytes32 help
prefix
bytes help

Properties

Visibility help internal
Mutability help transaction
Source Code
function matchBytes32Prefix(bytes32 content, bytes prefix)
  internal
  returns (bool)
{
  bool match_ = true;

  for (var i = 0; i < prefix.length; i++) {
    if (content[i] != prefix[i]) match_ = false;
  }

  return match_;
}

internal usingOraclize.oraclize_randomDS_proofVerify__main keyboard_arrow_up

Parameters help

Name Type
proof
bytes help
queryId
bytes32 help
result
bytes help
context_name
string help

Properties

Visibility help internal
Mutability help transaction

Requirements help

Source Code
function oraclize_randomDS_proofVerify__main(
  bytes proof,
  bytes32 queryId,
  bytes result,
  string context_name
) internal returns (bool) {
  bool checkok;

  // Step 2: the unique keyhash has to match with the sha256 of (context name + queryId)
  uint256 ledgerProofLength = 3 + 65 + (uint256(proof[3 + 65 + 1]) + 2) + 32;
  bytes memory keyhash = new bytes(32);
  copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
  checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
  if (checkok == false) return false;

  bytes memory sig1 = new bytes(
    uint256(proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1]) + 2
  );
  copyBytes(proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);

  // Step 3: we assume sig1 is valid (it will be verified during step 5) and we verify if 'result' is the prefix of sha256(sig1)
  checkok = matchBytes32Prefix(sha256(sig1), result);
  if (checkok == false) return false;

  // Step 4: commitment match verification, sha3(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
  // This is to verify that the computed args match with the ones specified in the query.
  bytes memory commitmentSlice1 = new bytes(8 + 1 + 32);
  copyBytes(proof, ledgerProofLength + 32, 8 + 1 + 32, commitmentSlice1, 0);

  bytes memory sessionPubkey = new bytes(64);
  uint256 sig2offset = ledgerProofLength + 32 + (8 + 1 + 32) + sig1.length + 65;
  copyBytes(proof, sig2offset - 64, 64, sessionPubkey, 0);

  bytes32 sessionPubkeyHash = sha256(sessionPubkey);
  if (
    oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)
  ) {
    //unonce, nbytes and sessionKeyHash match
    delete oraclize_randomDS_args[queryId];
  } else return false;

  // Step 5: validity verification for sig1 (keyhash and args signed with the sessionKey)
  bytes memory tosign1 = new bytes(32 + 8 + 1 + 32);
  copyBytes(proof, ledgerProofLength, 32 + 8 + 1 + 32, tosign1, 0);
  checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
  if (checkok == false) return false;

  // verify if sessionPubkeyHash was verified already, if not.. let's do it!
  if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false) {
    oraclize_randomDS_sessionKeysHashVerified[
      sessionPubkeyHash
    ] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
  }

  return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}

internal usingOraclize.copyBytes keyboard_arrow_up

Parameters help

Name Type
from
bytes help
fromOffset
uint help
length
uint help
to
bytes help
toOffset
uint help

Properties

Visibility help internal
Mutability help transaction
Source Code
function copyBytes(
  bytes from,
  uint256 fromOffset,
  uint256 length,
  bytes to,
  uint256 toOffset
) internal returns (bytes) {
  uint256 minLength = length + toOffset;

  if (to.length < minLength) {
    // Buffer too small
    throw; // Should be a better way?
  }

  // NOTE: the offset 32 is added to skip the `size` field of both bytes variables
  uint256 i = 32 + fromOffset;
  uint256 j = 32 + toOffset;

  while (i < (32 + fromOffset + length)) {
    assembly {
      let tmp := mload(add(from, i))
      mstore(add(to, j), tmp)
    }
    i += 32;
    j += 32;
  }

  return to;
}

internal usingOraclize.safer_ecrecover keyboard_arrow_up

Parameters help

Name Type
hash
bytes32 help
v
uint8 help
r
bytes32 help
s
bytes32 help

Properties

Visibility help internal
Mutability help transaction
Source Code
function safer_ecrecover(
  bytes32 hash,
  uint8 v,
  bytes32 r,
  bytes32 s
) internal returns (bool, address) {
  // We do our own memory management here. Solidity uses memory offset
  // 0x40 to store the current end of memory. We write past it (as
  // writes are memory extensions), but don't update the offset so
  // Solidity will reuse it. The memory used here is only needed for
  // this context.

  // FIXME: inline assembly can't access return values
  bool ret;
  address addr;

  assembly {
    let size := mload(0x40)
    mstore(size, hash)
    mstore(add(size, 32), v)
    mstore(add(size, 64), r)
    mstore(add(size, 96), s)

    // NOTE: we can reuse the request memory because we deal with
    //       the return code
    ret := call(3000, 1, 0, size, 128, size, 32)
    addr := mload(size)
  }

  return (ret, addr);
}

internal usingOraclize.ecrecovery keyboard_arrow_up

Parameters help

Name Type
hash
bytes32 help
sig
bytes help

Properties

Visibility help internal
Mutability help transaction
Source Code
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
  bytes32 r;
  bytes32 s;
  uint8 v;

  if (sig.length != 65) return (false, 0);

  // The signature format is a compact form of:
  //   {bytes32 r}{bytes32 s}{uint8 v}
  // Compact means, uint8 is not padded to 32 bytes.
  assembly {
    r := mload(add(sig, 32))
    s := mload(add(sig, 64))

    // Here we are loading the last 32 bytes. We exploit the fact that
    // 'mload' will pad with zeroes if we overread.
    // There is no 'mload8' to do this, but that would be nicer.
    v := byte(0, mload(add(sig, 96)))

    // Alternative solution:
    // 'byte' is not working due to the Solidity parser, so lets
    // use the second best option, 'and'
    // v := and(mload(add(sig, 65)), 255)
  }

  // albeit non-transactional signatures are not specified by the YP, one would expect it
  // to match the YP range of [27, 28]
  //
  // geth uses [0, 1] and some clients have followed. This might change, see:
  //  https://github.com/ethereum/go-ethereum/issues/2053
  if (v < 27) v += 27;

  if (v != 27 && v != 28) return (false, 0);

  return safer_ecrecover(hash, v, r, s);
}