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
Constants (26) keyboard_arrow_up
State Variables (35) keyboard_arrow_up
Functions
__callback keyboard_arrow_up
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();
}
__callback keyboard_arrow_up
balanceOf keyboard_arrow_up
transfer keyboard_arrow_up
Modifiers help
isFinalized checks for the following:
isKycVerified checks for the following:
hasEnoughUnlockedTokens checks for the following:
onlyPayloadSize checks for the following:
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;
}
transferFrom keyboard_arrow_up
Modifiers help
isFinalized checks for the following:
isKycVerified checks for the following:
hasEnoughUnlockedTokens checks for the following:
onlyPayloadSize checks for the following:
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;
}
approve keyboard_arrow_up
Modifiers help
onlyPayloadSize checks for the following:
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;
}
allowance keyboard_arrow_up
Modifiers help
onlyPayloadSize checks for the following:
Source Code
function allowance(address _owner, address _spender)
public
constant
onlyPayloadSize(2)
returns (uint256 remaining)
{
return allowed[_owner][_spender];
}
updatePrice keyboard_arrow_up
Parameters help
This function has no parameters.
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
);
}
}
getBalanceOf keyboard_arrow_up
getPurchaseById keyboard_arrow_up
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;
}
getHolderCount keyboard_arrow_up
getPurchaseCount keyboard_arrow_up
getHolder keyboard_arrow_up
createTokens keyboard_arrow_up
Parameters help
This function has no parameters.
Modifiers help
isFundraising checks for the following:
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);
}
addToKycTeam keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
onlyPayloadSize checks for the following:
Source Code
function addToKycTeam(address _teamMember) onlyOwner onlyPayloadSize(1) {
isKycTeam[_teamMember] = true;
}
removeFromKycTeam keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
onlyPayloadSize checks for the following:
Source Code
function removeFromKycTeam(address _teamMember) onlyOwner onlyPayloadSize(1) {
isKycTeam[_teamMember] = false;
}
unlockKyc keyboard_arrow_up
Modifiers help
onlyKycTeam checks for the following:
Requirements help
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
}
}
refuseKyc keyboard_arrow_up
Modifiers help
onlyKycTeam checks for the following:
Requirements help
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);
}
cancelDelivery keyboard_arrow_up
Modifiers help
onlyKycTeam checks for the following:
Requirements help
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);
}
deliverTokens keyboard_arrow_up
Parameters help
Modifiers help
isFundraising checks for the following:
onlyVendor checks for the following:
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);
}
retrieveEth keyboard_arrow_up
Modifiers help
minimumReached checks for the following:
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
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);
}
finalize keyboard_arrow_up
Modifiers help
isFundraising checks for the following:
minimumReached checks for the following:
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
Requirements help
One or more of the following:
-
allReceivedEth
must be greater than or equal to
ETH_RECEIVED_MIN
- OR
totalSupply
must be greater than or equal to
TOKEN_CREATED_MIN
- OR
fundingEndBlock
must be less than
block.number
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);
}
pause keyboard_arrow_up
Parameters help
This function has no parameters.
Modifiers help
notPaused checks for the following:
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
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;
}
proceed keyboard_arrow_up
Parameters help
This function has no parameters.
Modifiers help
isPaused checks for the following:
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
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;
}
refund keyboard_arrow_up
Parameters help
This function has no parameters.
Requirements help
One or more of the following:
-
totalSupply
must be less than
TOKEN_CREATED_MIN
- OR
allReceivedEth
must be less than
ETH_RECEIVED_MIN
One or more of the following:
-
noKycEthBalances for the sender's address
must be greater than
0
- OR
ethBalances for the sender's address
must be greater than
0
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);
}
deliverTeamTokens keyboard_arrow_up
Modifiers help
isFinalized checks for the following:
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
Requirements help
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);
}
setOraclizeGas keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
One or more of the following:
-
admin2
must be equal to
the sender's address
- OR
admin1
must be equal to
the sender's address
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
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.trackHolder keyboard_arrow_up
Source Code
function trackHolder(address _to) private returns (bool success) {
// Check if the recipient is a known token holder
if (isHolder[_to] == false) {
// if not, add him to the holders array and mark him as a known holder
holders.push(_to);
isHolder[_to] = true;
}
return true;
}
internal EVNToken.getCurrentDiscountRate keyboard_arrow_up
Parameters help
This function has no parameters.
Source Code
function getCurrentDiscountRate()
private
constant
returns (uint256 currentDiscountRate)
{
// determine which discount to apply
if (block.number < roundTwoBlock) {
// first round
return TOKEN_FIRST_DISCOUNT_MULTIPLIER;
} else if (block.number < roundThreeBlock) {
// second round
return TOKEN_SECOND_DISCOUNT_MULTIPLIER;
} else if (block.number < roundFourBlock) {
// third round
return TOKEN_THIRD_DISCOUNT_MULTIPLIER;
} else {
// fourth round, no discount
return 100000;
}
}
internal EVNToken.safeMulPercentage keyboard_arrow_up
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
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
internal usingOraclize.oraclize_getPrice keyboard_arrow_up
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
internal usingOraclize.oraclize_setProof keyboard_arrow_up
internal usingOraclize.oraclize_setCustomGasPrice keyboard_arrow_up
internal usingOraclize.oraclize_setConfig keyboard_arrow_up
internal usingOraclize.oraclize_randomDS_getSessionPubKeyHash keyboard_arrow_up
internal usingOraclize.getCodeSize keyboard_arrow_up
internal usingOraclize.parseAddr keyboard_arrow_up
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
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
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
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
internal usingOraclize.strConcat keyboard_arrow_up
internal usingOraclize.strConcat keyboard_arrow_up
internal usingOraclize.parseInt keyboard_arrow_up
internal usingOraclize.parseInt keyboard_arrow_up
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
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
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
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
internal usingOraclize.oraclize_getNetworkName keyboard_arrow_up
internal usingOraclize.oraclize_newRandomDSQuery keyboard_arrow_up
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
internal usingOraclize.verifySig keyboard_arrow_up
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
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
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
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
Requirements help
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
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
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);
}