DigitexFutures
ERC20
This contract is an ERC20 token.
Name
DigitexFutures
Symbol
DGTX
Decimals
18
Total Supply
1,000,000,000 DGTX
About
Stats
Public Functions
23
Event Types
12
Code Size
67,433 bytes
Events (12) keyboard_arrow_up
Constants (20) keyboard_arrow_up
State Variables (23) keyboard_arrow_up
Functions
balanceOf keyboard_arrow_up
transfer keyboard_arrow_up
Requirements help
Source Code
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
allowance keyboard_arrow_up
transferFrom keyboard_arrow_up
Requirements help
Source Code
function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
approve keyboard_arrow_up
Source Code
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
increaseApproval keyboard_arrow_up
Source Code
function increaseApproval(address _spender, uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(
_addedValue
);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
decreaseApproval keyboard_arrow_up
Source Code
function decreaseApproval(address _spender, uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
transfer keyboard_arrow_up
Source Code
function transfer(
address _to,
uint256 _value,
bytes _data
) returns (bool success) {
//filtering if the target is a contract with bytecode inside it
if (!super.transfer(_to, _value)) throw; // do a normal token transfer
if (isContract(_to)) contractFallback(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
transferFrom keyboard_arrow_up
Source Code
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) returns (bool success) {
if (!super.transferFrom(_from, _to, _value)) throw; // do a normal token transfer
if (isContract(_to)) contractFallback(_from, _to, _value, _data);
Transfer(_from, _to, _value, _data);
return true;
}
transfer keyboard_arrow_up
Source Code
function transfer(address _to, uint256 _value) returns (bool success) {
return transfer(_to, _value, new bytes(0));
}
transferFrom keyboard_arrow_up
Source Code
function transferFrom(
address _from,
address _to,
uint256 _value
) returns (bool success) {
return transferFrom(_from, _to, _value, new bytes(0));
}
burn keyboard_arrow_up
Requirements help
Source Code
function burn(uint256 _value) public {
require(0 != _value);
super.burn(_value);
Transfer(msg.sender, 0, _value);
}
transferOwnership keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
Requirements help
Source Code
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
uint256 localOwnerBalance = balances[owner];
balances[newOwner] = balances[newOwner].add(localOwnerBalance);
balances[owner] = 0;
vault_wallet = newOwner;
Transfer(owner, newOwner, localOwnerBalance);
super.transferOwnership(newOwner);
}
__callback keyboard_arrow_up
Requirements help
Source Code
function __callback(bytes32 myid, string result) {
require(msg.sender == oraclize_cbAddress());
newETHUSDPrice(result);
USDETH = parseInt(result, 0);
if ((now < ICOendtime) && (totaltokensold < hardcapInTokens)) {
UpdateUSDETHPriceAfter(day); //update every 24 hours
}
}
__callback keyboard_arrow_up
increaseSupply keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
Source Code
function increaseSupply(uint256 value, address to)
public
onlyOwner
returns (bool)
{
totalSupply = totalSupply.add(value);
balances[to] = balances[to].add(value);
Transfer(0, to, value);
return true;
}
finalize keyboard_arrow_up
claimRefund keyboard_arrow_up
Parameters help
This function has no parameters.
Requirements help
isFinalized must be true
Source Code
function claimRefund() public {
require(isFinalized);
require(!goalReached());
uint256 refundedTokens = balances[msg.sender];
balances[owner] = balances[owner].add(refundedTokens);
totaltokensold = totaltokensold.sub(refundedTokens);
balances[msg.sender] = 0;
Transfer(msg.sender, owner, refundedTokens);
vault_refund(msg.sender);
}
releaseUnclaimedFunds keyboard_arrow_up
goalReached keyboard_arrow_up
constructor keyboard_arrow_up
ICOactive keyboard_arrow_up
buy keyboard_arrow_up
Parameters help
This function has no parameters.
Requirements help
null
Source Code
function buy() payable {
require(
msg.value >= minimumInvestmentInWei && msg.value <= maximumInvestmentInWei
);
require(ICOactive());
uint256 NumberOfTokensToGive = msg.value.mul(USDETH).mul(
NumberOfTokensIn1USD
);
if (now <= ICOstarttime + week) {
NumberOfTokensToGive = NumberOfTokensToGive.mul(120).div(100);
} else if (now <= ICOstarttime + 2 * week) {
NumberOfTokensToGive = NumberOfTokensToGive.mul(115).div(100);
} else if (now <= ICOstarttime + 3 * week) {
NumberOfTokensToGive = NumberOfTokensToGive.mul(110).div(100);
} else {
NumberOfTokensToGive = NumberOfTokensToGive.mul(105).div(100);
}
uint256 localTotaltokensold = totaltokensold;
require(localTotaltokensold + NumberOfTokensToGive <= hardcapInTokens);
totaltokensold = localTotaltokensold.add(NumberOfTokensToGive);
address localOwner = owner;
balances[msg.sender] = balances[msg.sender].add(NumberOfTokensToGive);
balances[localOwner] = balances[localOwner].sub(NumberOfTokensToGive);
Transfer(localOwner, msg.sender, NumberOfTokensToGive);
saleWalletAddress.transfer(msg.value - (msg.value * 96) / 100);
if (!goalReached() && (RefundVault.State.Active == vault_state)) {
depositFunds();
} else {
if (RefundVault.State.Active == vault_state) {
vault_releaseDeposit();
}
localOwner.transfer((msg.value * 96) / 100);
}
}
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 DGTX.depositFunds keyboard_arrow_up
internal DGTX.finalization keyboard_arrow_up
internal DGTX.UpdateUSDETHPriceAfter keyboard_arrow_up
Source Code
function UpdateUSDETHPriceAfter(uint256 delay) private {
newOraclizeQuery("Update of USD/ETH price requested");
oraclize_query(
delay,
"URL",
"json(https://api.etherscan.io/api?module=stats&action=ethprice&apikey=YourApiKeyToken).result.ethusd"
);
}
internal DGTX.initializeSaleWalletAddress keyboard_arrow_up
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.oraclize_randomDS_proofVerify__returnCode keyboard_arrow_up
Source Code
function oraclize_randomDS_proofVerify__returnCode(
bytes32 _queryId,
string _result,
bytes _proof
) internal returns (uint8) {
// Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
if ((_proof[0] != "L") || (_proof[1] != "P") || (_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(
_proof,
_queryId,
bytes(_result),
oraclize_getNetworkName()
);
if (proofVerified == false) return 2;
return 0;
}
internal usingOraclize.matchBytes32Prefix keyboard_arrow_up
Source Code
function matchBytes32Prefix(
bytes32 content,
bytes prefix,
uint256 n_random_bytes
) internal returns (bool) {
bool match_ = true;
for (uint256 i = 0; i < n_random_bytes; 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) {
// 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);
if (!(sha3(keyhash) == sha3(sha256(context_name, queryId)))) 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)
if (
!matchBytes32Prefix(
sha256(sig1),
result,
uint256(proof[ledgerProofLength + 32 + 8])
)
) 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);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) 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);
}
internal RefundVault.vault_deposit keyboard_arrow_up
Requirements help
Source Code
function vault_deposit(address investor, uint256 _value) internal {
require(vault_state == State.Active);
vault_deposited[investor] = vault_deposited[investor].add(_value);
totalDeposited = totalDeposited.add(_value);
}
internal RefundVault.vault_releaseDeposit keyboard_arrow_up
Parameters help
This function has no parameters.
Source Code
function vault_releaseDeposit() internal {
vault_state = State.Released;
DepositReleased();
if (totalDeposited > 0) {
vault_wallet.transfer(totalDeposited);
}
totalDeposited = 0;
}
internal RefundVault.vault_enableRefunds keyboard_arrow_up
internal RefundVault.vault_refund keyboard_arrow_up
Requirements help
Source Code
function vault_refund(address investor) internal {
require(vault_state == State.Refunding);
uint256 depositedValue = vault_deposited[investor];
vault_deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
totalDeposited = totalDeposited.sub(depositedValue);
}
internal Standard223Token.contractFallback keyboard_arrow_up
Source Code
function contractFallback(
address _origin,
address _to,
uint256 _value,
bytes _data
) private {
ERC223Receiver reciever = ERC223Receiver(_to);
reciever.tokenFallback(_origin, _value, _data);
}
internal Standard223Token.isContract keyboard_arrow_up
Source Code
function isContract(address _addr) private returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint256 length;
assembly {
length := extcodesize(_addr)
}
return length > 0;
}
