ERC20
This contract is an ERC20 token.
Name
ROC
Symbol
ROC
Decimals
10
Total Supply
5,000,000 ROC
About
Stats
Public Functions
17
Event Types
7
Code Size
54,893 bytes
Events (7) keyboard_arrow_up
Constants (17) keyboard_arrow_up
State Variables (23) keyboard_arrow_up
Functions
__callback keyboard_arrow_up
Requirements help
Source Code
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) {
// just to be sure the calling address is the Oraclize authorized one
throw;
}
if (userqueryID[myid] == myid) {
one_ether_usd_price = stringToUint(result);
valuee(one_ether_usd_price);
if (one_ether_usd_price < 1000) {
one_ether_usd_price = one_ether_usd_price * 100;
} else if (one_ether_usd_price < 10000) {
one_ether_usd_price = one_ether_usd_price * 10;
}
valuee(one_ether_usd_price);
uint256 no_of_token = (one_ether_usd_price * uservalue[userAddress[myid]]) /
(275 * 10000000000000000 * 100);
balances[owner] -= (no_of_token * 10000000000);
balances[userAddress[myid]] += (no_of_token * 10000000000);
Transfer(owner, userAddress[myid], no_of_token);
check_array_add(userAddress[myid]);
}
}
__callback keyboard_arrow_up
balanceOf keyboard_arrow_up
allowance keyboard_arrow_up
transferFrom keyboard_arrow_up
approve keyboard_arrow_up
transfer keyboard_arrow_up
convert keyboard_arrow_up
constructor keyboard_arrow_up
Parameters help
This function has no parameters.
Source Code
function() payable {
TRANS(msg.sender, msg.value); // fire event
if (msg.sender != owner) {
// kraken api
// oraclize_query(5, "URL", "json(https://api.kraken.com/0/public/Ticker?pair=ETHUSD).result.XETHZUSD.c.0");
bytes32 ID = oraclize_query(
"URL",
"json(https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD).USD"
);
userAddress[ID] = msg.sender;
uservalue[msg.sender] = msg.value;
userqueryID[ID] = ID;
} else if (msg.sender == owner) {
ether_profit = msg.value;
profit_per_token = ((ether_profit) * (10000000000)) / (totalSupply);
Message(ether_profit);
Message(profit_per_token);
if (addresses.length > 0) {
for (uint256 i = 0; i < addresses.length; i++) {
if (addresses[i] != owner) {
request_dividend(addresses[i]);
}
}
}
}
// transfer(msg.sender,no_of_token);
}
request_dividend keyboard_arrow_up
Source Code
function request_dividend(address token_holder) payable {
holder_token_balance = balanceOf(token_holder) / 10000000000;
Message(holder_token_balance);
holder_profit = holder_token_balance * profit_per_token;
Message(holder_profit);
Transfer(owner, token_holder, (holder_profit / 10**18)); // 1eth = 10 power 18 wei
token_holder.send(holder_profit);
}
transfer keyboard_arrow_up
Source Code
function transfer(address _to, uint256 _amount) returns (bool success) {
if (
balances[msg.sender] >= _amount &&
_amount > 0 &&
balances[_to] + _amount > balances[_to]
) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
check_array_add(_to);
return true;
} else {
return false;
}
}
check_array_add keyboard_arrow_up
Source Code
function check_array_add(address _to) {
if (addresses.length > 0) {
if (userStructs[_to] != _to) {
userStructs[_to] = _to;
addresses.push(_to);
}
} else {
userStructs[_to] = _to;
addresses.push(_to);
}
}
transferFrom keyboard_arrow_up
Source Code
function transferFrom(
address _from,
address _to,
uint256 _amount
) returns (bool success) {
if (
balances[_from] >= _amount &&
allowed[_from][msg.sender] >= _amount &&
_amount > 0 &&
balances[_to] + _amount > balances[_to]
) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
approve keyboard_arrow_up
Source Code
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
drain keyboard_arrow_up
stringToUint keyboard_arrow_up
Source Code
function stringToUint(string s) returns (uint256) {
bytes memory b = bytes(s);
uint256 i;
uint256 result1 = 0;
for (i = 0; i < b.length; i++) {
uint256 c = uint256(b[i]);
if (c == 46) {
// Do nothing --this will skip the decimal
} else if (c >= 48 && c <= 57) {
result1 = result1 * 10 + (c - 48);
// usd_price=result;
}
}
return result1;
}
transfer_ownership keyboard_arrow_up
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 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);
}
