diff --git a/README.md b/README.md
index c336033..939ad9b 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,9 @@ import "github.com/oraclize/ethereum-api/provableAPI.sol";
To learn more about the Provable technology, please refer to our __[documentation here](https://docs.oraclize.it)__.
+
+:black_nib: __Important Note:__ Currently only API versions `0.4.25` & `0.5` are actively maintained - please use the latest version wherever possible!
+
***
diff --git a/oraclizeAPI_0.4.25.sol b/oraclizeAPI_0.4.25.sol
index f7de511..2f299ed 100644
--- a/oraclizeAPI_0.4.25.sol
+++ b/oraclizeAPI_0.4.25.sol
@@ -1,10 +1,9 @@
//
-// Release targetted at solc 0.4.25 to silence compiler warning/error messages, compatible down to 0.4.22
+// Release targeted at solc 0.4.25 to silence compiler warning/error messages, compatible down to 0.4.22
/*
Copyright (c) 2015-2016 Oraclize SRL
-Copyright (c) 2016 Oraclize LTD
-
-
+Copyright (c) 2016-2019 Oraclize LTD
+Copyright (c) 2019 Provable Things Limited
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -13,13 +12,9 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
-
-
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
-
-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -31,21 +26,71 @@ THE SOFTWARE.
// This api is currently targeted at 0.4.22 to 0.4.25 (stable builds), please import oraclizeAPI_pre0.4.sol or oraclizeAPI_0.4 where necessary
-pragma solidity >= 0.4.22 < 0.5;// Incompatible compiler version... please select one stated within pragma solidity or use different oraclizeAPI version
+pragma solidity >= 0.4.22 < 0.5; // Incompatible compiler version... please select one stated within pragma solidity or use different oraclizeAPI version
+
+/**
+ * @notice A separate interface is used here for any queries that use type
+ * `bytes` to define the datasource due to the compiler not being able
+ * to differentiate the two function signatures if called via
+ * OraclizeI.query(...)
+ *
+ */
+contract OraclizeIBytes {
+
+ function queryN(uint _timestamp, bytes1 _datasource, bytes _argN) public payable returns (bytes32 _id);
+ function query(uint _timestamp, bytes1 _datasource, string _arg) external payable returns (bytes32 _id);
+ function query2(uint _timestamp, bytes1 _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
+ function query_withGasLimit(uint _timestamp, bytes1 _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
+ function queryN_withGasLimit(uint _timestamp, bytes1 _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
+ function query2_withGasLimit(uint _timestamp, bytes1 _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
+
+}
contract OraclizeI {
+
address public cbAddress;
- function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
- function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
- function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
- function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
- function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
- function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
- function getPrice(string _datasource) public returns (uint _dsprice);
- function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
+ mapping (bytes32 => uint256) public price;
+ mapping (address => address) public addressCustomPaymentToken;
+
+ function unsetCustomTokenPayment() external;
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
+ function requestQueryCaching(bytes32 _queryId) external;
+ function setCustomTokenPayment(address _tokenAddress) external;
+ function queryCached() payable external returns (bytes32 _queryId);
+ function getPrice(byte _datasource) public view returns (uint256 _dsprice);
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
+ function getPrice(string memory _datasource) public view returns (uint256 _dsprice);
+ function getPrice(byte _datasource, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getPrice(byte _datasource, uint256 _gasLimit) public view returns (uint256 _dsprice);
+ function getPrice(string memory _datasource, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getPrice(string memory _datasource, uint256 _gasLimit) public view returns (uint256 _dsprice);
+ function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
+ function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
+ function requestCallbackRebroadcast(bytes32 _queryId, uint256 _gasLimit, uint256 _gasPrice) payable external;
+ function getPrice(byte _datasource, uint256 _gasLimit, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getRebroadcastCost(uint256 _gasLimit, uint256 _gasPrice) public pure returns (uint256 _rebroadcastCost);
+ function convertToERC20Price(uint256 _queryPriceInWei, address _tokenAddress) public view returns (uint256 _price);
+ function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
+ function getPrice(string memory _datasource, uint256 _gasLimit, address _contractToQuery) public view returns (uint256 _dsprice);
+ function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
+ function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
+ function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
+
+}
+
+interface ERC20Interface {
+
+ event Transfer(address indexed _from, address indexed _to, uint _tokens);
+ event Approval(address indexed _tokenOwner, address indexed _spender, uint _tokens);
+
+ function totalSupply() external view returns (uint);
+ function transfer(address _to, uint _tokens) external returns (bool _success);
+ function balanceOf(address _tokenOwner) external view returns (uint _balance);
+ function approve(address _tokenSpender, uint256 _tokenAmount) external returns (bool);
+ function transferFrom(address _from, address _to, uint _tokens) external returns (bool _success);
+ function allowance(address _tokenOwner, address _spender) external view returns (uint _remaining);
+
}
contract OraclizeAddrResolverI {
@@ -285,9 +330,9 @@ End solidity-cborutils
*/
contract usingOraclize {
- uint constant day = 60*60*24;
- uint constant week = 60*60*24*7;
- uint constant month = 60*60*24*30;
+ uint constant day = 60 * 60 * 24;
+ uint constant week = 60 * 60 * 24 * 7;
+ uint constant month = 60 * 60 * 24 * 30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
@@ -303,26 +348,30 @@ contract usingOraclize {
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
+ OraclizeIBytes oraclizeBytes;
+
modifier oraclizeAPI {
- if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
+ if((address(OAR) == 0) || (getCodeSize(address(OAR)) == 0))
oraclize_setNetwork(networkID_auto);
- if(address(oraclize) != OAR.getAddress())
- oraclize = OraclizeI(OAR.getAddress());
-
+ address oraclizeConnector = OAR.getAddress();
+ if(address(oraclize) != oraclizeConnector)
+ oraclize = OraclizeI(oraclizeConnector);
+ oraclizeBytes = OraclizeIBytes(address(oraclizeConnector));
_;
}
+
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
- function oraclize_setNetwork(uint8 networkID) internal returns(bool){
- return oraclize_setNetwork();
- networkID; // silence the warning and remain backwards compatible
+ function oraclize_setNetwork(uint8 networkID) internal returns(bool) {
+ return oraclize_setNetwork();
+ networkID; // silence the warning and remain backwards compatible
}
- function oraclize_setNetwork() internal returns(bool){
- if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
+ function oraclize_setNetwork() internal returns(bool) {
+ if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed) > 0) { //mainnet
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
@@ -366,155 +415,1286 @@ contract usingOraclize {
* meant to be defined in child contract when proofs are used.
* The function bodies simply silence compiler warnings.
*/
- function __callback(bytes32 myid, string result) public {
+ function __callback(
+ bytes32 myid,
+ string result
+ )
+ public
+ {
__callback(myid, result, new bytes(0));
}
- function __callback(bytes32 myid, string result, bytes proof) public {
- return;
+ function __callback(
+ bytes32 myid,
+ string result,
+ bytes proof
+ )
+ public
+ {
myid; result; proof;
oraclize_randomDS_args[bytes32(0)] = bytes32(0);
}
+ /**
+ *
+ * @notice oraclize_getPrice(...) overloads follow...
+ *
+ */
+ function oraclize_getPrice(
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+ /**
+ *
+ * @notice oraclize_getPriceERC20(...) overloads follow...
+ *
+ */
+ function oraclize_getPriceERC20(
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
- function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
- return oraclize.getPrice(datasource);
+ function oraclize_getPriceERC20(
+ address _tokenAddress,
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ _tokenAddress
+ );
}
- function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
- return oraclize.getPrice(datasource, gaslimit);
+ function oraclize_getPriceERC20(
+ address _tokenAddress,
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ _tokenAddress
+ );
}
- function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using the STRING datasource follow...
+ *
+ */
+ function oraclize_query(
+ string datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return oraclize.query.value(price)(0, datasource, arg);
}
- function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return oraclize.query.value(price)(timestamp, datasource, arg);
}
- function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
- function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
- function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
- function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
- function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
- function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
- function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ string datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ 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);
}
- function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+
+ function oraclize_query(
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = oraclize.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ 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);
}
- function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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);
+ }
+
+ function oraclize_query(
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using the BYTE datasource follow...
+ *
+ */
+ function oraclize_query(
+ bytes1 datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query.value(price)(0, datasource, arg);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query.value(price)(timestamp, datasource, arg);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query2.value(price)(0, datasource, arg1, arg2);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query2.value(price)(timestamp, datasource, arg1, arg2);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN.value(price)(0, datasource, args);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN.value(price)(timestamp, datasource, args);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN.value(price)(0, datasource, args);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN.value(price)(timestamp, datasource, args);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic arguments and the
+ * STRING type datasource follow...
+ *
+ */
+ function oraclize_query(
+ string datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
+ function oraclize_query(
+ string datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -530,7 +1710,16 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -538,7 +1727,17 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -546,7 +1745,16 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -554,7 +1762,15 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -563,7 +1779,16 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -572,7 +1797,17 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -581,7 +1816,16 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -590,97 +1834,180 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
- uint 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);
- }
- function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
- uint 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);
- }
- function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
- uint 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);
- }
- function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
- uint 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);
- }
- function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
+ function oraclize_query(
+ string datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
}
- function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -688,7 +2015,14 @@ contract usingOraclize {
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
+ function oraclize_query(
+ string datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -696,7 +2030,16 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -704,7 +2047,17 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -712,7 +2065,16 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -720,7 +2082,15 @@ contract usingOraclize {
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -729,7 +2099,16 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -738,7 +2117,17 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -747,7 +2136,16 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
- function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+
+ function oraclize_query(
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -756,164 +2154,2827 @@ contract usingOraclize {
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic arguments and the
+ * BYTES1 datasource type follow...
+ *
+ */
+ function oraclize_query(
+ bytes1 datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(datasource, dynargs);
+ }
- function oraclize_cbAddress() oraclizeAPI internal returns (address){
- return oraclize.cbAddress();
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(timestamp, datasource, dynargs);
}
- function oraclize_setProof(byte proofP) oraclizeAPI internal {
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /*
+ *
+ * @notice `oraclize_query` overloads end.
+ *
+ * @notice `oraclize_token_query` overloads using the STRING datasource follow...
+ *
+ */
+ function oraclize_token_query(
+ string datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclize.query(0, datasource, arg);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclize.query(timestamp, datasource, arg);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclize.query_withGasLimit(timestamp, datasource, arg, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclize.query_withGasLimit(0, datasource, arg, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclize.query2(0, datasource, arg1, arg2);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclize.query2(timestamp, datasource, arg1, arg2);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclize.query2_withGasLimit(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclize.query2_withGasLimit(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclize.queryN(0, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclize.queryN(timestamp, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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(0, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclize.queryN(0, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclize.queryN(timestamp, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint 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(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using the BYTE datasource follow...
+ *
+ */
+ function oraclize_token_query(
+ bytes1 datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query(0, datasource, arg);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query(timestamp, datasource, arg);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query_withGasLimit(timestamp, datasource, arg, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query_withGasLimit(0, datasource, arg, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query2(0, datasource, arg1, arg2);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return oraclizeBytes.query2(timestamp, datasource, arg1, arg2);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query2_withGasLimit(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return oraclizeBytes.query2_withGasLimit(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN(0, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN(timestamp, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN(0, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN(timestamp, datasource, args);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = oraclize.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return oraclizeBytes.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic arguments and the
+ * STRING type datasource follow...
+ *
+ */
+ function oraclize_token_query(
+ string datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(string datasource, string[4] args) oraclizeAPI internal 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic arguments and the
+ * BYTES1 datasource type follow...
+ *
+ */
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return oraclize_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(datasource, dynargs, gaslimit);
+ }
+ /*
+ *
+ * @notice `oraclize_token_query` overloads end.
+ *
+ */
+ function oraclize_cbAddress()
+ oraclizeAPI
+ internal
+ returns (address)
+ {
+ return oraclize.cbAddress();
+ }
+
+ function oraclize_setProof(byte proofP)
+ oraclizeAPI
+ internal
+ {
return oraclize.setProofType(proofP);
}
- function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
+
+ function oraclize_setCustomGasPrice(
+ uint gasPrice
+ )
+ oraclizeAPI
+ internal
+ {
return oraclize.setCustomGasPrice(gasPrice);
}
- function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
+ function oraclize_randomDS_getSessionPubKeyHash()
+ oraclizeAPI
+ internal
+ returns (bytes32)
+ {
return oraclize.randomDS_getSessionPubKeyHash();
}
- function getCodeSize(address _addr) view internal returns(uint _size) {
+ function getCodeSize(address _addr)
+ internal
+ view
+ returns(uint _size)
+ {
assembly {
_size := extcodesize(_addr)
}
}
- function parseAddr(string _a) internal pure returns (address){
+ function oraclize_requestQueryCaching(bytes32 _queryId)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.requestQueryCaching(_queryId);
+ }
+
+ function oraclize_queryCached(uint256 _queryPrice)
+ oraclizeAPI
+ internal
+ returns (bytes32 _queryId)
+ {
+ return oraclize.queryCached.value(_queryPrice)();
+ }
+
+ function oraclize_getDatasourceByte(
+ string memory _datasourceString
+ )
+ internal
+ returns (byte _datasourceByte)
+ {
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('URL'))
+ return 0xFF;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Random'))
+ return 0xFE;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('computation'))
+ return 0xFD;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('WolframAlpha'))
+ return 0xFC;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('IPFS'))
+ return 0xFB;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('nested'))
+ return 0xFA;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Blockchain'))
+ return 0xF9;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('swarm'))
+ return 0xF8;
+ return 0x00;
+ }
+
+ function oraclize_getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _rebroadcastCost)
+ {
+ return oraclize.getRebroadcastCost(
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function oraclize_requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ uint256 _queryPrice
+ )
+ oraclizeAPI
+ internal
+ {
+ return oraclize
+ .requestCallbackRebroadcast
+ .value(_queryPrice)
+ (
+ _queryId,
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function oraclize_setCustomTokenPayment(address _tokenAddress)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.setCustomTokenPayment(_tokenAddress);
+ }
+
+ function oraclize_approveTokenAllowance(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ oraclizeAPI
+ internal
+ {
+ ERC20Interface(_tokenAddress)
+ .approve(address(oraclize), _tokenAmount);
+ }
+
+ function oraclize_setAndApproveCustomTokenPayment(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ oraclizeAPI
+ internal
+ {
+ oraclize_setCustomTokenPayment(_tokenAddress);
+ oraclize_approveTokenAllowance(_tokenAddress, _tokenAmount);
+ }
+
+ function oraclize_unsetAndRevokeCustomTokenPayment(address _tokenAddress)
+ oraclizeAPI
+ internal
+ {
+ oraclize_unsetCustomTokenPayment();
+ oraclize_approveTokenAllowance(_tokenAddress, 0);
+ }
+
+ function oraclize_unsetCustomTokenPayment()
+ oraclizeAPI
+ internal
+ {
+ return oraclize.unsetCustomTokenPayment();
+ }
+ /**
+ *
+ * @notice Oraclize helper functions follow.
+ *
+ */
+ function parseAddr(string memory _a)
+ internal
+ pure
+ returns (address _parsedAddress)
+ {
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
- for (uint i=2; i<2+2*20; i+=2){
+ 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);
+ b1 = uint160(uint8(tmp[i]));
+ b2 = uint160(uint8(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);
}
- function strCompare(string _a, string _b) internal pure returns (int) {
+ function strCompare(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
- uint minLength = a.length;
- if (b.length < minLength) minLength = b.length;
- for (uint i = 0; i < minLength; i ++)
- if (a[i] < b[i])
+ 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])
+ } else if (a[i] > b[i]) {
return 1;
- if (a.length < b.length)
+ }
+ }
+ if (a.length < b.length) {
return -1;
- else if (a.length > b.length)
+ } else if (a.length > b.length) {
return 1;
- else
+ } else {
return 0;
+ }
}
- function indexOf(string _haystack, string _needle) internal pure returns (int) {
+ function indexOf(
+ string memory _haystack,
+ string memory _needle
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
- if(h.length < 1 || n.length < 1 || (n.length > h.length))
+ if (h.length < 1 || n.length < 1 || (n.length > h.length)) {
return -1;
- else if(h.length > (2**128 -1))
+ } else if (h.length > (2 ** 128 - 1)) {
return -1;
- else
- {
- uint subindex = 0;
- for (uint i = 0; i < h.length; i ++)
- {
- if (h[i] == n[0])
- {
+ } 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])
- {
+ while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex]) {
subindex++;
}
- if(subindex == n.length)
+ if (subindex == n.length) {
return int(i);
+ }
}
}
return -1;
}
}
- function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
+ function strConcat(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, "", "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, _d, "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d,
+ string memory _e
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
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);
+ string memory abcde = new string(
+ _ba.length +
+ _bb.length +
+ _bc.length +
+ _bd.length +
+ _be.length
+ );
bytes memory babcde = bytes(abcde);
- uint k = 0;
- for (uint 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];
+ uint256 k = 0;
+ uint256 i = 0;
+ for (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);
}
- function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
- return strConcat(_a, _b, _c, _d, "");
- }
-
- function strConcat(string _a, string _b, string _c) internal pure returns (string) {
- return strConcat(_a, _b, _c, "", "");
- }
-
- function strConcat(string _a, string _b) internal pure returns (string) {
- return strConcat(_a, _b, "", "", "");
- }
-
- // parseInt
- function parseInt(string _a) internal pure returns (uint) {
+ function parseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
return parseInt(_a, 0);
}
- // parseInt(parseFloat*10^_b)
- function parseInt(string _a, uint _b) internal pure returns (uint) {
+ function parseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
bytes memory bresult = bytes(_a);
- uint mint = 0;
+ uint256 mint = 0;
bool decimals = false;
- for (uint i=0; i= 48)&&(bresult[i] <= 57)){
- if (decimals){
- if (_b == 0) break;
- else _b--;
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
+ if (decimals) {
+ if (_b == 0) {
+ break;
+ } else {
+ _b--;
+ }
}
mint *= 10;
- mint += uint(bresult[i]) - 48;
- } else if (bresult[i] == 46) decimals = true;
+ mint += uint(uint8(bresult[i])) - 48;
+ } else if (uint(uint8(bresult[i])) == 46) {
+ decimals = true;
+ }
+ }
+ if (_b > 0) {
+ mint *= 10 ** _b;
}
- if (_b > 0) mint *= 10**_b;
return mint;
}
- function uint2str(uint i) internal pure returns (string){
- if (i == 0) return "0";
- uint j = i;
- uint len;
- while (j != 0){
+ function uint2str(uint256 _i)
+ internal
+ pure
+ returns (string memory _uintAsString)
+ {
+ if (_i == 0) {
+ return "0";
+ }
+ uint256 j = _i;
+ uint256 len;
+ while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
- uint k = len - 1;
- while (i != 0){
- bstr[k--] = byte(48 + i % 10);
- i /= 10;
+ uint256 k = len - 1;
+ while (_i != 0) {
+ bstr[k--] = byte(uint8(48 + _i % 10));
+ _i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
- function stra2cbor(string[] arr) internal pure returns (bytes) {
+
+ function stra2cbor(string[] arr)
+ internal
+ pure
+ returns (bytes)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
@@ -925,7 +4986,11 @@ contract usingOraclize {
return buf.buf;
}
- function ba2cbor(bytes[] arr) internal pure returns (bytes) {
+ function ba2cbor(bytes[] arr)
+ internal
+ pure
+ returns (bytes)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
@@ -938,28 +5003,43 @@ contract usingOraclize {
}
string oraclize_network_name;
- function oraclize_setNetworkName(string _network_name) internal {
+
+ function oraclize_setNetworkName(string _network_name)
+ internal
+ {
oraclize_network_name = _network_name;
}
- function oraclize_getNetworkName() internal view returns (string) {
+ function oraclize_getNetworkName()
+ internal
+ view
+ returns (string)
+ {
return oraclize_network_name;
}
- function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
+ function oraclize_newRandomDSQuery(
+ uint256 _delay,
+ uint256 _nbytes,
+ uint256 _customGasLimit
+ )
+ internal
+ returns (bytes32 _queryId)
+ {
require((_nbytes > 0) && (_nbytes <= 32));
- // Convert from seconds to ledger timer ticks
- _delay *= 10;
+ _delay *= 10; // Convert from seconds to ledger timer ticks
bytes memory nbytes = new bytes(1);
- nbytes[0] = byte(_nbytes);
+ nbytes[0] = byte(uint8(_nbytes));
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
- // the following variables can be relaxed
- // check relaxed random contract under ethereum-examples repo
- // for an idea on how to override and replace comit hash vars
+ /*
+ The following variables can be relaxed.
+ Check the relaxed random contract at https://github.com/oraclize/ethereum-examples
+ for an idea on how to override and replace commit hash variables.
+ */
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
@@ -968,15 +5048,11 @@ contract usingOraclize {
assembly {
mstore(add(delay, 0x20), _delay)
}
-
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
-
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
-
bytes memory delay_bytes8_left = new bytes(8);
-
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
@@ -987,21 +5063,31 @@ contract usingOraclize {
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
-
}
-
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
- function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
+ function oraclize_randomDS_setCommitment(
+ bytes32 queryId,
+ bytes32 commitment
+ )
+ internal
+ {
oraclize_randomDS_args[queryId] = commitment;
}
- mapping(bytes32=>bytes32) oraclize_randomDS_args;
- mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
-
- function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
+ mapping(bytes32 => bytes32) oraclize_randomDS_args;
+ mapping(bytes32 => bool) oraclize_randomDS_sessionKeysHashVerified;
+
+ function verifySig(
+ bytes32 tosignh,
+ bytes dersig,
+ bytes pubkey
+ )
+ internal
+ returns (bool)
+ {
bool sigok;
address signer;
@@ -1029,7 +5115,13 @@ contract usingOraclize {
}
}
- function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
+ function oraclize_randomDS_proofVerify__sessionKeyValidity(
+ bytes proof,
+ uint sig2offset
+ )
+ internal
+ returns (bool)
+ {
bool sigok;
// Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
@@ -1064,7 +5156,11 @@ contract usingOraclize {
return sigok;
}
- modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
+ modifier oraclize_randomDS_proofVerify(
+ bytes32 _queryId,
+ string _result,
+ bytes _proof)
+ {
// Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
@@ -1074,72 +5170,102 @@ contract usingOraclize {
_;
}
- 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;
-
+ function oraclize_randomDS_proofVerify__returnCode(
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ internal
+ returns (uint8 _returnCode)
+ {
+ // Random DS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ if ((_proof[0] != "L") || (_proof[1] != "P") || (uint8(_proof[2]) != uint8(1))) {
+ return 1;
+ }
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
- if (proofVerified == false) return 2;
-
+ if (!proofVerified) {
+ return 2;
+ }
return 0;
}
- function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
+ function matchBytes32Prefix(
+ bytes32 _content,
+ bytes memory _prefix,
+ uint256 _nRandomBytes
+ )
+ internal
+ pure
+ returns (bool _matchesPrefix)
+ {
bool match_ = true;
-
- require(prefix.length == n_random_bytes);
-
- for (uint256 i=0; i< n_random_bytes; i++) {
- if (content[i] != prefix[i]) match_ = false;
+ require(_prefix.length == _nRandomBytes);
+ for (uint256 i = 0; i < _nRandomBytes; i++) {
+ if (_content[i] != _prefix[i]) {
+ match_ = false;
+ }
}
-
return match_;
}
- 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)
- uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
+ function oraclize_randomDS_proofVerify__main(
+ bytes memory _proof,
+ bytes32 _queryId,
+ bytes memory _result,
+ string memory _contextName
+ )
+ internal
+ returns (bool _proofVerified)
+ {
+ // Random DS Proof Step 2: The unique keyhash has to match with the sha256 of (context name + _queryId)
+ uint256 ledgerProofLength = 3 + 65 + (uint(uint8(_proof[3 + 65 + 1])) + 2) + 32;
bytes memory keyhash = new bytes(32);
- copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
- if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
-
- bytes memory sig1 = new bytes(uint(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, uint(proof[ledgerProofLength+32+8]))) return false;
-
- // Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
+ copyBytes(_proof, ledgerProofLength, 32, keyhash, 0);
+ if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(_contextName, _queryId)))))) {
+ return false;
+ }
+ bytes memory sig1 = new bytes(uint(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
+ copyBytes(_proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);
+ // Random DS Proof 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, uint(uint8(_proof[ledgerProofLength + 32 + 8])))) {
+ return false;
+ }
+ // Random DS Proof Step 4: Commitment match verification, keccak256(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 commitmentSlice1 = new bytes(8 + 1 + 32);
+ copyBytes(_proof, ledgerProofLength + 32, 8 + 1 + 32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
- uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
- copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
-
+ 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] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){ //unonce, nbytes and sessionKeyHash match
- delete oraclize_randomDS_args[queryId];
+ if (oraclize_randomDS_args[_queryId] == keccak256(abi.encodePacked(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);
+ // Random DS Proof 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]) {
+ oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(_proof, sig2offset);
}
-
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
- // the following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
- function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
+ function copyBytes(
+ bytes from,
+ uint fromOffset,
+ uint length,
+ bytes to,
+ uint toOffset
+ )
+ internal
+ pure
+ returns (bytes)
+ {
uint minLength = length + toOffset;
// Buffer too small
@@ -1161,9 +5287,17 @@ contract usingOraclize {
return to;
}
- // the following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
// Duplicate Solidity's ecrecover, but catching the CALL return value
- function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
+ 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
@@ -1189,15 +5323,20 @@ contract usingOraclize {
return (ret, addr);
}
-
- // the following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
- function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
+ function ecrecovery(
+ bytes32 hash,
+ bytes sig
+ )
+ internal
+ returns (bool, address)
+ {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
- return (false, 0);
+ return (false, 0);
// The signature format is a compact form of:
// {bytes32 r}{bytes32 s}{uint8 v}
@@ -1223,7 +5362,7 @@ contract usingOraclize {
// 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;
+ v += 27;
if (v != 27 && v != 28)
return (false, 0);
@@ -1231,12 +5370,14 @@ contract usingOraclize {
return safer_ecrecover(hash, v, r, s);
}
- function safeMemoryCleaner() internal pure {
+ function safeMemoryCleaner()
+ internal
+ pure
+ {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
-
}
//
diff --git a/oraclizeAPI_0.4.sol b/oraclizeAPI_0.4.sol
index 6e3e760..2adab71 100644
--- a/oraclizeAPI_0.4.sol
+++ b/oraclizeAPI_0.4.sol
@@ -1,9 +1,8 @@
//
/*
Copyright (c) 2015-2016 Oraclize SRL
-Copyright (c) 2016 Oraclize LTD
-
-
+Copyright (c) 2016-2019 Oraclize LTD
+Copyright (c) 2019 Provable Things Limited
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -12,13 +11,9 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
-
-
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
-
-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
diff --git a/oraclizeAPI_0.5.sol b/oraclizeAPI_0.5.sol
index 32dab8f..206df5b 100644
--- a/oraclizeAPI_0.5.sol
+++ b/oraclizeAPI_0.5.sol
@@ -1,1347 +1,6777 @@
-/*
-
-ORACLIZE_API
-
-Copyright (c) 2015-2016 Oraclize SRL
-Copyright (c) 2016 Oraclize LTD
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-*/
-pragma solidity >= 0.5.0 < 0.6.0; // Incompatible compiler version - please select a compiler within the stated pragma range, or use a different version of the oraclizeAPI!
-
-// Dummy contract only used to emit to end-user they are using wrong solc
-contract solcChecker {
-/* INCOMPATIBLE SOLC: import the following instead: "github.com/oraclize/ethereum-api/oraclizeAPI_0.4.sol" */ function f(bytes calldata x) external;
-}
-
-contract OraclizeI {
-
- address public cbAddress;
-
- function setProofType(byte _proofType) external;
- function setCustomGasPrice(uint _gasPrice) external;
- function getPrice(string memory _datasource) public returns (uint _dsprice);
- function randomDS_getSessionPubKeyHash() external view returns (bytes32 _sessionKeyHash);
- function getPrice(string memory _datasource, uint _gasLimit) public returns (uint _dsprice);
- function queryN(uint _timestamp, string memory _datasource, bytes memory _argN) public payable returns (bytes32 _id);
- function query(uint _timestamp, string calldata _datasource, string calldata _arg) external payable returns (bytes32 _id);
- function query2(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2) public payable returns (bytes32 _id);
- function query_withGasLimit(uint _timestamp, string calldata _datasource, string calldata _arg, uint _gasLimit) external payable returns (bytes32 _id);
- function queryN_withGasLimit(uint _timestamp, string calldata _datasource, bytes calldata _argN, uint _gasLimit) external payable returns (bytes32 _id);
- function query2_withGasLimit(uint _timestamp, string calldata _datasource, string calldata _arg1, string calldata _arg2, uint _gasLimit) external payable returns (bytes32 _id);
-}
-
-contract OraclizeAddrResolverI {
- function getAddress() public returns (address _address);
-}
-/*
-
-Begin solidity-cborutils
-
-https://github.com/smartcontractkit/solidity-cborutils
-
-MIT License
-
-Copyright (c) 2018 SmartContract ChainLink, Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-*/
-library Buffer {
-
- struct buffer {
- bytes buf;
- uint capacity;
- }
-
- function init(buffer memory _buf, uint _capacity) internal pure {
- uint capacity = _capacity;
- if (capacity % 32 != 0) {
- capacity += 32 - (capacity % 32);
- }
- _buf.capacity = capacity; // Allocate space for the buffer data
- assembly {
- let ptr := mload(0x40)
- mstore(_buf, ptr)
- mstore(ptr, 0)
- mstore(0x40, add(ptr, capacity))
- }
- }
-
- function resize(buffer memory _buf, uint _capacity) private pure {
- bytes memory oldbuf = _buf.buf;
- init(_buf, _capacity);
- append(_buf, oldbuf);
- }
-
- function max(uint _a, uint _b) private pure returns (uint _max) {
- if (_a > _b) {
- return _a;
- }
- return _b;
- }
- /**
- * @dev Appends a byte array to the end of the buffer. Resizes if doing so
- * would exceed the capacity of the buffer.
- * @param _buf The buffer to append to.
- * @param _data The data to append.
- * @return The original buffer.
- *
- */
- function append(buffer memory _buf, bytes memory _data) internal pure returns (buffer memory _buffer) {
- if (_data.length + _buf.buf.length > _buf.capacity) {
- resize(_buf, max(_buf.capacity, _data.length) * 2);
- }
- uint dest;
- uint src;
- uint len = _data.length;
- assembly {
- let bufptr := mload(_buf) // Memory address of the buffer data
- let buflen := mload(bufptr) // Length of existing buffer data
- dest := add(add(bufptr, buflen), 32) // Start address = buffer address + buffer length + sizeof(buffer length)
- mstore(bufptr, add(buflen, mload(_data))) // Update buffer length
- src := add(_data, 32)
- }
- for(; len >= 32; len -= 32) { // Copy word-length chunks while possible
- assembly {
- mstore(dest, mload(src))
- }
- dest += 32;
- src += 32;
- }
- uint mask = 256 ** (32 - len) - 1; // Copy remaining bytes
- assembly {
- let srcpart := and(mload(src), not(mask))
- let destpart := and(mload(dest), mask)
- mstore(dest, or(destpart, srcpart))
- }
- return _buf;
- }
- /**
- *
- * @dev Appends a byte to the end of the buffer. Resizes if doing so would
- * exceed the capacity of the buffer.
- * @param _buf The buffer to append to.
- * @param _data The data to append.
- * @return The original buffer.
- *
- */
- function append(buffer memory _buf, uint8 _data) internal pure {
- if (_buf.buf.length + 1 > _buf.capacity) {
- resize(_buf, _buf.capacity * 2);
- }
- assembly {
- let bufptr := mload(_buf) // Memory address of the buffer data
- let buflen := mload(bufptr) // Length of existing buffer data
- let dest := add(add(bufptr, buflen), 32) // Address = buffer address + buffer length + sizeof(buffer length)
- mstore8(dest, _data)
- mstore(bufptr, add(buflen, 1)) // Update buffer length
- }
- }
- /**
- *
- * @dev Appends a byte to the end of the buffer. Resizes if doing so would
- * exceed the capacity of the buffer.
- * @param _buf The buffer to append to.
- * @param _data The data to append.
- * @return The original buffer.
- *
- */
- function appendInt(buffer memory _buf, uint _data, uint _len) internal pure returns (buffer memory _buffer) {
- if (_len + _buf.buf.length > _buf.capacity) {
- resize(_buf, max(_buf.capacity, _len) * 2);
- }
- uint mask = 256 ** _len - 1;
- assembly {
- let bufptr := mload(_buf) // Memory address of the buffer data
- let buflen := mload(bufptr) // Length of existing buffer data
- let dest := add(add(bufptr, buflen), _len) // Address = buffer address + buffer length + sizeof(buffer length) + len
- mstore(dest, or(and(mload(dest), not(mask)), _data))
- mstore(bufptr, add(buflen, _len)) // Update buffer length
- }
- return _buf;
- }
-}
-
-library CBOR {
-
- using Buffer for Buffer.buffer;
-
- uint8 private constant MAJOR_TYPE_INT = 0;
- uint8 private constant MAJOR_TYPE_MAP = 5;
- uint8 private constant MAJOR_TYPE_BYTES = 2;
- uint8 private constant MAJOR_TYPE_ARRAY = 4;
- uint8 private constant MAJOR_TYPE_STRING = 3;
- uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
- uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
-
- function encodeType(Buffer.buffer memory _buf, uint8 _major, uint _value) private pure {
- if (_value <= 23) {
- _buf.append(uint8((_major << 5) | _value));
- } else if (_value <= 0xFF) {
- _buf.append(uint8((_major << 5) | 24));
- _buf.appendInt(_value, 1);
- } else if (_value <= 0xFFFF) {
- _buf.append(uint8((_major << 5) | 25));
- _buf.appendInt(_value, 2);
- } else if (_value <= 0xFFFFFFFF) {
- _buf.append(uint8((_major << 5) | 26));
- _buf.appendInt(_value, 4);
- } else if (_value <= 0xFFFFFFFFFFFFFFFF) {
- _buf.append(uint8((_major << 5) | 27));
- _buf.appendInt(_value, 8);
- }
- }
-
- function encodeIndefiniteLengthType(Buffer.buffer memory _buf, uint8 _major) private pure {
- _buf.append(uint8((_major << 5) | 31));
- }
-
- function encodeUInt(Buffer.buffer memory _buf, uint _value) internal pure {
- encodeType(_buf, MAJOR_TYPE_INT, _value);
- }
-
- function encodeInt(Buffer.buffer memory _buf, int _value) internal pure {
- if (_value >= 0) {
- encodeType(_buf, MAJOR_TYPE_INT, uint(_value));
- } else {
- encodeType(_buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - _value));
- }
- }
-
- function encodeBytes(Buffer.buffer memory _buf, bytes memory _value) internal pure {
- encodeType(_buf, MAJOR_TYPE_BYTES, _value.length);
- _buf.append(_value);
- }
-
- function encodeString(Buffer.buffer memory _buf, string memory _value) internal pure {
- encodeType(_buf, MAJOR_TYPE_STRING, bytes(_value).length);
- _buf.append(bytes(_value));
- }
-
- function startArray(Buffer.buffer memory _buf) internal pure {
- encodeIndefiniteLengthType(_buf, MAJOR_TYPE_ARRAY);
- }
-
- function startMap(Buffer.buffer memory _buf) internal pure {
- encodeIndefiniteLengthType(_buf, MAJOR_TYPE_MAP);
- }
-
- function endSequence(Buffer.buffer memory _buf) internal pure {
- encodeIndefiniteLengthType(_buf, MAJOR_TYPE_CONTENT_FREE);
- }
-}
-/*
-
-End solidity-cborutils
-
-*/
-contract usingOraclize {
-
- using CBOR for Buffer.buffer;
-
- OraclizeI oraclize;
- OraclizeAddrResolverI OAR;
-
- uint constant day = 60 * 60 * 24;
- uint constant week = 60 * 60 * 24 * 7;
- uint constant month = 60 * 60 * 24 * 30;
-
- byte constant proofType_NONE = 0x00;
- byte constant proofType_Ledger = 0x30;
- byte constant proofType_Native = 0xF0;
- byte constant proofStorage_IPFS = 0x01;
- byte constant proofType_Android = 0x40;
- byte constant proofType_TLSNotary = 0x10;
-
- string oraclize_network_name;
- uint8 constant networkID_auto = 0;
- uint8 constant networkID_morden = 2;
- uint8 constant networkID_mainnet = 1;
- uint8 constant networkID_testnet = 2;
- uint8 constant networkID_consensys = 161;
-
- mapping(bytes32 => bytes32) oraclize_randomDS_args;
- mapping(bytes32 => bool) oraclize_randomDS_sessionKeysHashVerified;
-
- modifier oraclizeAPI {
- if ((address(OAR) == address(0)) || (getCodeSize(address(OAR)) == 0)) {
- oraclize_setNetwork(networkID_auto);
- }
- if (address(oraclize) != OAR.getAddress()) {
- oraclize = OraclizeI(OAR.getAddress());
- }
- _;
- }
-
- modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string memory _result, bytes memory _proof) {
- // RandomDS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
- require((_proof[0] == "L") && (_proof[1] == "P") && (uint8(_proof[2]) == uint8(1)));
- bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
- require(proofVerified);
- _;
- }
-
- function oraclize_setNetwork(uint8 _networkID) internal returns (bool _networkSet) {
- _networkID; // NOTE: Silence the warning and remain backwards compatible
- return oraclize_setNetwork();
- }
-
- function oraclize_setNetworkName(string memory _network_name) internal {
- oraclize_network_name = _network_name;
- }
-
- function oraclize_getNetworkName() internal view returns (string memory _networkName) {
- return oraclize_network_name;
- }
-
- function oraclize_setNetwork() internal returns (bool _networkSet) {
- 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(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41) > 0) { //goerli testnet
- OAR = OraclizeAddrResolverI(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41);
- oraclize_setNetworkName("eth_goerli");
- 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;
- }
- /**
- * @dev The following `__callback` functions are just placeholders ideally
- * meant to be defined in child contract when proofs are used.
- * The function bodies simply silence compiler warnings.
- */
- function __callback(bytes32 _myid, string memory _result) public {
- __callback(_myid, _result, new bytes(0));
- }
-
- function __callback(bytes32 _myid, string memory _result, bytes memory _proof) public {
- _myid; _result; _proof;
- oraclize_randomDS_args[bytes32(0)] = bytes32(0);
- }
-
- function oraclize_getPrice(string memory _datasource) oraclizeAPI internal returns (uint _queryPrice) {
- return oraclize.getPrice(_datasource);
- }
-
- function oraclize_getPrice(string memory _datasource, uint _gasLimit) oraclizeAPI internal returns (uint _queryPrice) {
- return oraclize.getPrice(_datasource, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, string memory _arg) oraclizeAPI internal returns (bytes32 _id) {
- uint price = oraclize.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return oraclize.query.value(price)(0, _datasource, _arg);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string memory _arg) oraclizeAPI internal returns (bytes32 _id) {
- uint price = oraclize.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return oraclize.query.value(price)(_timestamp, _datasource, _arg);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string memory _arg, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string memory _arg, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string memory _arg1, string memory _arg2) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string memory _arg1, string memory _arg2, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string[] memory _argN) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[] memory _argN) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[] memory _argN, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string[] memory _argN, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, string[1] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[1] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_timestamp, _datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[1] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, string[1] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, string[2] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[2] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_timestamp, _datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[2] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, string[2] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- string[] memory dynargs = new string[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, string[3] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[3] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[3] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, string[3] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, string[4] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[4] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[4] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, string[4] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, string[5] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[5] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, string[5] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, string[5] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[] memory _argN) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[] memory _argN) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[] memory _argN, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[] memory _argN, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- uint 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[1] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[1] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_timestamp, _datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[1] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, bytes[1] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](1);
- dynargs[0] = _args[0];
- return oraclize_query(_datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, bytes[2] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[2] memory _args) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_timestamp, _datasource, dynargs);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[2] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, bytes[2] memory _args, uint _gasLimit) oraclizeAPI internal returns (bytes32 _id) {
- bytes[] memory dynargs = new bytes[](2);
- dynargs[0] = _args[0];
- dynargs[1] = _args[1];
- return oraclize_query(_datasource, dynargs, _gasLimit);
- }
-
- function oraclize_query(string memory _datasource, bytes[3] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[3] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[3] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[3] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[4] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[4] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[4] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[4] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[5] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[5] memory _args) oraclizeAPI internal 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);
- }
-
- function oraclize_query(uint _timestamp, string memory _datasource, bytes[5] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_query(string memory _datasource, bytes[5] memory _args, uint _gasLimit) oraclizeAPI internal 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);
- }
-
- function oraclize_setProof(byte _proofP) oraclizeAPI internal {
- return oraclize.setProofType(_proofP);
- }
-
-
- function oraclize_cbAddress() oraclizeAPI internal returns (address _callbackAddress) {
- return oraclize.cbAddress();
- }
-
- function getCodeSize(address _addr) view internal returns (uint _size) {
- assembly {
- _size := extcodesize(_addr)
- }
- }
-
- function oraclize_setCustomGasPrice(uint _gasPrice) oraclizeAPI internal {
- return oraclize.setCustomGasPrice(_gasPrice);
- }
-
- function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32 _sessionKeyHash) {
- return oraclize.randomDS_getSessionPubKeyHash();
- }
-
- function parseAddr(string memory _a) internal pure returns (address _parsedAddress) {
- bytes memory tmp = bytes(_a);
- uint160 iaddr = 0;
- uint160 b1;
- uint160 b2;
- for (uint i = 2; i < 2 + 2 * 20; i += 2) {
- iaddr *= 256;
- b1 = uint160(uint8(tmp[i]));
- b2 = uint160(uint8(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);
- }
-
- function strCompare(string memory _a, string memory _b) internal pure returns (int _returnCode) {
- bytes memory a = bytes(_a);
- bytes memory b = bytes(_b);
- uint minLength = a.length;
- if (b.length < minLength) {
- minLength = b.length;
- }
- for (uint 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;
- }
- }
-
- function indexOf(string memory _haystack, string memory _needle) internal pure returns (int _returnCode) {
- 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 {
- uint subindex = 0;
- for (uint 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 int(i);
- }
- }
- }
- return -1;
- }
- }
-
- function strConcat(string memory _a, string memory _b) internal pure returns (string memory _concatenatedString) {
- return strConcat(_a, _b, "", "", "");
- }
-
- function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory _concatenatedString) {
- return strConcat(_a, _b, _c, "", "");
- }
-
- function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory _concatenatedString) {
- return strConcat(_a, _b, _c, _d, "");
- }
-
- function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory _concatenatedString) {
- 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);
- uint k = 0;
- uint i = 0;
- for (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);
- }
-
- function safeParseInt(string memory _a) internal pure returns (uint _parsedInt) {
- return safeParseInt(_a, 0);
- }
-
- function safeParseInt(string memory _a, uint _b) internal pure returns (uint _parsedInt) {
- bytes memory bresult = bytes(_a);
- uint mint = 0;
- bool decimals = false;
- for (uint i = 0; i < bresult.length; i++) {
- if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
- if (decimals) {
- if (_b == 0) break;
- else _b--;
- }
- mint *= 10;
- mint += uint(uint8(bresult[i])) - 48;
- } else if (uint(uint8(bresult[i])) == 46) {
- require(!decimals, 'More than one decimal encountered in string!');
- decimals = true;
- } else {
- revert("Non-numeral character encountered in string!");
- }
- }
- if (_b > 0) {
- mint *= 10 ** _b;
- }
- return mint;
- }
-
- function parseInt(string memory _a) internal pure returns (uint _parsedInt) {
- return parseInt(_a, 0);
- }
-
- function parseInt(string memory _a, uint _b) internal pure returns (uint _parsedInt) {
- bytes memory bresult = bytes(_a);
- uint mint = 0;
- bool decimals = false;
- for (uint i = 0; i < bresult.length; i++) {
- if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
- if (decimals) {
- if (_b == 0) {
- break;
- } else {
- _b--;
- }
- }
- mint *= 10;
- mint += uint(uint8(bresult[i])) - 48;
- } else if (uint(uint8(bresult[i])) == 46) {
- decimals = true;
- }
- }
- if (_b > 0) {
- mint *= 10 ** _b;
- }
- return mint;
- }
-
- function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
- if (_i == 0) {
- return "0";
- }
- uint j = _i;
- uint len;
- while (j != 0) {
- len++;
- j /= 10;
- }
- bytes memory bstr = new bytes(len);
- uint k = len - 1;
- while (_i != 0) {
- bstr[k--] = byte(uint8(48 + _i % 10));
- _i /= 10;
- }
- return string(bstr);
- }
-
- function stra2cbor(string[] memory _arr) internal pure returns (bytes memory _cborEncoding) {
- safeMemoryCleaner();
- Buffer.buffer memory buf;
- Buffer.init(buf, 1024);
- buf.startArray();
- for (uint i = 0; i < _arr.length; i++) {
- buf.encodeString(_arr[i]);
- }
- buf.endSequence();
- return buf.buf;
- }
-
- function ba2cbor(bytes[] memory _arr) internal pure returns (bytes memory _cborEncoding) {
- safeMemoryCleaner();
- Buffer.buffer memory buf;
- Buffer.init(buf, 1024);
- buf.startArray();
- for (uint i = 0; i < _arr.length; i++) {
- buf.encodeBytes(_arr[i]);
- }
- buf.endSequence();
- return buf.buf;
- }
-
- function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32 _queryId) {
- require((_nbytes > 0) && (_nbytes <= 32));
- _delay *= 10; // Convert from seconds to ledger timer ticks
- bytes memory nbytes = new bytes(1);
- nbytes[0] = byte(uint8(_nbytes));
- bytes memory unonce = new bytes(32);
- bytes memory sessionKeyHash = new bytes(32);
- bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
- assembly {
- mstore(unonce, 0x20)
- /*
- The following variables can be relaxed.
- Check the relaxed random contract at https://github.com/oraclize/ethereum-examples
- for an idea on how to override and replace commit hash variables.
- */
- mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
- mstore(sessionKeyHash, 0x20)
- mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
- }
- bytes memory delay = new bytes(32);
- assembly {
- mstore(add(delay, 0x20), _delay)
- }
- bytes memory delay_bytes8 = new bytes(8);
- copyBytes(delay, 24, 8, delay_bytes8, 0);
- bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
- bytes32 queryId = oraclize_query("random", args, _customGasLimit);
- bytes memory delay_bytes8_left = new bytes(8);
- assembly {
- let x := mload(add(delay_bytes8, 0x20))
- mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
- }
- oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
- return queryId;
- }
-
- function oraclize_randomDS_setCommitment(bytes32 _queryId, bytes32 _commitment) internal {
- oraclize_randomDS_args[_queryId] = _commitment;
- }
-
- function verifySig(bytes32 _tosignh, bytes memory _dersig, bytes memory _pubkey) internal returns (bool _sigVerified) {
- bool sigok;
- address signer;
- bytes32 sigr;
- bytes32 sigs;
- bytes memory sigr_ = new bytes(32);
- uint offset = 4 + (uint(uint8(_dersig[3])) - 0x20);
- sigr_ = copyBytes(_dersig, offset, 32, sigr_, 0);
- bytes memory sigs_ = new bytes(32);
- offset += 32 + 2;
- sigs_ = copyBytes(_dersig, offset + (uint(uint8(_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(uint160(uint256(keccak256(_pubkey)))) == signer) {
- return true;
- } else {
- (sigok, signer) = safer_ecrecover(_tosignh, 28, sigr, sigs);
- return (address(uint160(uint256(keccak256(_pubkey)))) == signer);
- }
- }
-
- function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes memory _proof, uint _sig2offset) internal returns (bool _proofVerified) {
- bool sigok;
- // Random DS Proof Step 6: Verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
- bytes memory sig2 = new bytes(uint(uint8(_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] = byte(uint8(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) {
- return false;
- }
- // Random DS Proof 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(uint(uint8(_proof[3 + 65 + 1])) + 2);
- copyBytes(_proof, 3 + 65, sig3.length, sig3, 0);
- sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
- return sigok;
- }
-
- function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string memory _result, bytes memory _proof) internal returns (uint8 _returnCode) {
- // Random DS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
- if ((_proof[0] != "L") || (_proof[1] != "P") || (uint8(_proof[2]) != uint8(1))) {
- return 1;
- }
- bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
- if (!proofVerified) {
- return 2;
- }
- return 0;
- }
-
- function matchBytes32Prefix(bytes32 _content, bytes memory _prefix, uint _nRandomBytes) internal pure returns (bool _matchesPrefix) {
- bool match_ = true;
- require(_prefix.length == _nRandomBytes);
- for (uint256 i = 0; i< _nRandomBytes; i++) {
- if (_content[i] != _prefix[i]) {
- match_ = false;
- }
- }
- return match_;
- }
-
- function oraclize_randomDS_proofVerify__main(bytes memory _proof, bytes32 _queryId, bytes memory _result, string memory _contextName) internal returns (bool _proofVerified) {
- // Random DS Proof Step 2: The unique keyhash has to match with the sha256 of (context name + _queryId)
- uint ledgerProofLength = 3 + 65 + (uint(uint8(_proof[3 + 65 + 1])) + 2) + 32;
- bytes memory keyhash = new bytes(32);
- copyBytes(_proof, ledgerProofLength, 32, keyhash, 0);
- if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(_contextName, _queryId)))))) {
- return false;
- }
- bytes memory sig1 = new bytes(uint(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
- copyBytes(_proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);
- // Random DS Proof 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, uint(uint8(_proof[ledgerProofLength + 32 + 8])))) {
- return false;
- }
- // Random DS Proof Step 4: Commitment match verification, keccak256(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);
- uint 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] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))) { //unonce, nbytes and sessionKeyHash match
- delete oraclize_randomDS_args[_queryId];
- } else return false;
- // Random DS Proof 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]) {
- oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(_proof, sig2offset);
- }
- return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
- }
- /*
- The following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
- */
- function copyBytes(bytes memory _from, uint _fromOffset, uint _length, bytes memory _to, uint _toOffset) internal pure returns (bytes memory _copiedBytes) {
- uint minLength = _length + _toOffset;
- require(_to.length >= minLength); // Buffer too small. Should be a better way?
- uint i = 32 + _fromOffset; // NOTE: the offset 32 is added to skip the `size` field of both bytes variables
- uint 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;
- }
- /*
- The following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
- Duplicate Solidity's ecrecover, but catching the CALL return value
- */
- function safer_ecrecover(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) internal returns (bool _success, address _recoveredAddress) {
- /*
- 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)
- ret := call(3000, 1, 0, size, 128, size, 32) // NOTE: we can reuse the request memory because we deal with the return code.
- addr := mload(size)
- }
- return (ret, addr);
- }
- /*
- The following function has been written by Alex Beregszaszi, use it under the terms of the MIT license
- */
- function ecrecovery(bytes32 _hash, bytes memory _sig) internal returns (bool _success, address _recoveredAddress) {
- bytes32 r;
- bytes32 s;
- uint8 v;
- if (_sig.length != 65) {
- return (false, address(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, address(0));
- }
- return safer_ecrecover(_hash, v, r, s);
- }
-
- function safeMemoryCleaner() internal pure {
- assembly {
- let fmem := mload(0x40)
- codecopy(fmem, codesize, sub(msize, fmem))
- }
- }
-}
-/*
-
-END ORACLIZE_API
-
-*/
+/**
+ *
+ * ORACLIZE_API
+ *
+ * Copyright (c) 2015-2016 Oraclize SRL
+ * Copyright (c) 2016-2019 Oraclize LTD
+ * Copyright (c) 2019 Provable Things Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+pragma solidity >= 0.5.0 < 0.6.0; // Incompatible compiler version - please select a compiler within the stated pragma range, or use a different version of the oraclizeAPI!
+/**
+ *
+ * @notice The following is a dummy contract that is only used to emit a
+ * notification to the end-user they are using wrong solidity
+ * compiler version.
+ *
+ */
+contract solcChecker {
+/* INCOMPATIBLE SOLC: import the following instead: "github.com/oraclize/ethereum-api/oraclizeAPI_0.4.sol" */ function f(bytes calldata x) external;
+}
+
+contract OraclizeI {
+
+ address public cbAddress;
+ mapping (bytes32 => uint256) public price;
+ mapping (address => address) public addressCustomPaymentToken;
+
+ function unsetCustomTokenPayment()
+ external;
+
+ function convertToERC20Price(
+ uint256 _queryPriceInWei,
+ address _tokenAddress
+ )
+ public
+ view
+ returns(uint256 _price);
+
+ function queryCached()
+ payable
+ external
+ returns (bytes32 _queryId);
+
+ function randomDS_getSessionPubKeyHash()
+ external
+ view
+ returns (bytes32 _sessionKeyHash);
+
+ function setProofType(
+ byte _proofType
+ )
+ external;
+
+ function setCustomGasPrice(
+ uint256 _gasPrice
+ )
+ external;
+
+ function requestQueryCaching(
+ bytes32 _queryId
+ )
+ external;
+
+ function setCustomTokenPayment(
+ address _tokenAddress
+ )
+ external;
+
+ function getPrice(
+ bytes1 _datasource
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+
+ function getPrice(
+ bytes1 _datasource,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ bytes1 _datasource,
+ uint256 _gasLimit
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ payable
+ external;
+
+ function queryN(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes memory _argN
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function getPrice(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ public
+ pure
+ returns (uint256 _rebroadcastCost);
+
+ function query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes memory _argN
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function query(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function query2(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function query_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes calldata _argN,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ bytes calldata _argN,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg1,
+ string calldata _arg2,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg1,
+ string calldata _arg2,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+}
+
+interface ERC20Interface {
+
+ event Transfer(
+ address indexed _from,
+ address indexed _to,
+ uint256 tokens
+ );
+
+ event Approval(
+ address indexed _tokenOwner,
+ address indexed _spender,
+ uint256 tokens
+ );
+
+ function totalSupply()
+ external
+ view
+ returns (uint256);
+
+ function transfer(
+ address _to,
+ uint256 _tokens
+ )
+ external
+ returns (bool _success);
+
+ function balanceOf(
+ address _tokenOwner
+ )
+ external
+ view
+ returns (uint256 _balance);
+
+ function approve(
+ address _tokenSpender,
+ uint256 _tokenAmount
+ )
+ external
+ returns (bool);
+
+ function transferFrom(
+ address _from,
+ address _to,
+ uint256 _tokens
+ )
+ external
+ returns (bool _success);
+
+ function allowance(
+ address _tokenOwner,
+ address _spender
+ )
+ external
+ view
+ returns (uint256 _remaining);
+
+}
+
+contract OraclizeAddrResolverI {
+
+ function getAddress() public returns (address _address);
+
+}
+/**
+ *
+ * Begin solidity-cborutils
+ *
+ * https://github.com/smartcontractkit/solidity-cborutils
+ *
+ * MIT License
+ *
+ * Copyright (c) 2018 SmartContract ChainLink, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+library Buffer {
+
+ struct buffer {
+ bytes buf;
+ uint256 capacity;
+ }
+
+ function init(buffer memory _buf, uint256 _capacity) internal pure {
+ uint256 capacity = _capacity;
+ if (capacity % 32 != 0) {
+ capacity += 32 - (capacity % 32);
+ }
+ _buf.capacity = capacity; // Allocate space for the buffer data
+ assembly {
+ let ptr := mload(0x40)
+ mstore(_buf, ptr)
+ mstore(ptr, 0)
+ mstore(0x40, add(ptr, capacity))
+ }
+ }
+
+ function resize(buffer memory _buf, uint256 _capacity) private pure {
+ bytes memory oldbuf = _buf.buf;
+ init(_buf, _capacity);
+ append(_buf, oldbuf);
+ }
+
+ function max(uint256 _a, uint256 _b) private pure returns (uint256 _max) {
+ if (_a > _b) {
+ return _a;
+ }
+ return _b;
+ }
+ /**
+ * @dev Appends a byte array to the end of the buffer. Resizes if doing so
+ * would exceed the capacity of the buffer.
+ * @param _buf The buffer to append to.
+ * @param _data The data to append.
+ * @return The original buffer.
+ *
+ */
+ function append(
+ buffer memory _buf,
+ bytes memory _data
+ )
+ internal
+ pure
+ returns (buffer memory _buffer)
+ {
+ if (_data.length + _buf.buf.length > _buf.capacity) {
+ resize(_buf, max(_buf.capacity, _data.length) * 2);
+ }
+ uint256 dest;
+ uint256 src;
+ uint256 len = _data.length;
+ assembly {
+ let bufptr := mload(_buf) // Memory address of the buffer data
+ let buflen := mload(bufptr) // Length of existing buffer data
+ dest := add(add(bufptr, buflen), 32) // Start address = buffer address + buffer length + sizeof(buffer length)
+ mstore(bufptr, add(buflen, mload(_data))) // Update buffer length
+ src := add(_data, 32)
+ }
+ for(; len >= 32; len -= 32) { // Copy word-length chunks while possible
+ assembly {
+ mstore(dest, mload(src))
+ }
+ dest += 32;
+ src += 32;
+ }
+ uint256 mask = 256 ** (32 - len) - 1; // Copy remaining bytes
+ assembly {
+ let srcpart := and(mload(src), not(mask))
+ let destpart := and(mload(dest), mask)
+ mstore(dest, or(destpart, srcpart))
+ }
+ return _buf;
+ }
+ /**
+ *
+ * @dev Appends a byte to the end of the buffer. Resizes if doing so would
+ * exceed the capacity of the buffer.
+ * @param _buf The buffer to append to.
+ * @param _data The data to append.
+ * @return The original buffer.
+ *
+ */
+ function append(buffer memory _buf, uint8 _data) internal pure {
+ if (_buf.buf.length + 1 > _buf.capacity) {
+ resize(_buf, _buf.capacity * 2);
+ }
+ assembly {
+ let bufptr := mload(_buf) // Memory address of the buffer data
+ let buflen := mload(bufptr) // Length of existing buffer data
+ let dest := add(add(bufptr, buflen), 32) // Address = buffer address + buffer length + sizeof(buffer length)
+ mstore8(dest, _data)
+ mstore(bufptr, add(buflen, 1)) // Update buffer length
+ }
+ }
+ /**
+ *
+ * @dev Appends a byte to the end of the buffer. Resizes if doing so would
+ * exceed the capacity of the buffer.
+ * @param _buf The buffer to append to.
+ * @param _data The data to append.
+ * @return The original buffer.
+ *
+ */
+ function appendInt(
+ buffer memory _buf,
+ uint256 _data,
+ uint256 _len
+ )
+ internal
+ pure
+ returns (buffer memory _buffer)
+ {
+ if (_len + _buf.buf.length > _buf.capacity) {
+ resize(_buf, max(_buf.capacity, _len) * 2);
+ }
+ uint256 mask = 256 ** _len - 1;
+ assembly {
+ let bufptr := mload(_buf) // Memory address of the buffer data
+ let buflen := mload(bufptr) // Length of existing buffer data
+ let dest := add(add(bufptr, buflen), _len) // Address = buffer address + buffer length + sizeof(buffer length) + len
+ mstore(dest, or(and(mload(dest), not(mask)), _data))
+ mstore(bufptr, add(buflen, _len)) // Update buffer length
+ }
+ return _buf;
+ }
+}
+
+library CBOR {
+
+ using Buffer for Buffer.buffer;
+
+ uint8 private constant MAJOR_TYPE_INT = 0;
+ uint8 private constant MAJOR_TYPE_MAP = 5;
+ uint8 private constant MAJOR_TYPE_BYTES = 2;
+ uint8 private constant MAJOR_TYPE_ARRAY = 4;
+ uint8 private constant MAJOR_TYPE_STRING = 3;
+ uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
+ uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
+
+ function encodeType(
+ Buffer.buffer memory _buf,
+ uint8 _major,
+ uint256 _value
+ )
+ private
+ pure
+ {
+ if (_value <= 23) {
+ _buf.append(uint8((_major << 5) | _value));
+ } else if (_value <= 0xFF) {
+ _buf.append(uint8((_major << 5) | 24));
+ _buf.appendInt(_value, 1);
+ } else if (_value <= 0xFFFF) {
+ _buf.append(uint8((_major << 5) | 25));
+ _buf.appendInt(_value, 2);
+ } else if (_value <= 0xFFFFFFFF) {
+ _buf.append(uint8((_major << 5) | 26));
+ _buf.appendInt(_value, 4);
+ } else if (_value <= 0xFFFFFFFFFFFFFFFF) {
+ _buf.append(uint8((_major << 5) | 27));
+ _buf.appendInt(_value, 8);
+ }
+ }
+
+ function encodeIndefiniteLengthType(
+ Buffer.buffer memory _buf,
+ uint8 _major
+ )
+ private
+ pure
+ {
+ _buf.append(uint8((_major << 5) | 31));
+ }
+
+ function encodeUInt(
+ Buffer.buffer memory _buf,
+ uint256 _value
+ )
+ internal
+ pure
+ {
+ encodeType(_buf, MAJOR_TYPE_INT, _value);
+ }
+
+ function encodeInt(
+ Buffer.buffer memory _buf,
+ int _value
+ )
+ internal
+ pure
+ {
+ if (_value >= 0) {
+ encodeType(_buf, MAJOR_TYPE_INT, uint256(_value));
+ } else {
+ encodeType(_buf, MAJOR_TYPE_NEGATIVE_INT, uint256(-1 - _value));
+ }
+ }
+
+ function encodeBytes(
+ Buffer.buffer memory _buf,
+ bytes memory _value
+ )
+ internal
+ pure
+ {
+ encodeType(_buf, MAJOR_TYPE_BYTES, _value.length);
+ _buf.append(_value);
+ }
+
+ function encodeString(
+ Buffer.buffer memory _buf,
+ string memory _value
+ )
+ internal
+ pure
+ {
+ encodeType(_buf, MAJOR_TYPE_STRING, bytes(_value).length);
+ _buf.append(bytes(_value));
+ }
+
+ function startArray(
+ Buffer.buffer memory _buf
+ )
+ internal
+ pure
+ {
+ encodeIndefiniteLengthType(_buf, MAJOR_TYPE_ARRAY);
+ }
+
+ function startMap(Buffer.buffer memory _buf)
+ internal
+ pure
+ {
+ encodeIndefiniteLengthType(_buf, MAJOR_TYPE_MAP);
+ }
+
+ function endSequence(Buffer.buffer memory _buf)
+ internal
+ pure
+ {
+ encodeIndefiniteLengthType(_buf, MAJOR_TYPE_CONTENT_FREE);
+ }
+}
+/**
+ *
+ * End solidity-cborutils
+ *
+ */
+contract usingOraclize {
+
+ using CBOR for Buffer.buffer;
+
+ OraclizeI oraclize;
+ OraclizeAddrResolverI OAR;
+
+ uint256 constant day = 60 * 60 * 24;
+ uint256 constant week = 60 * 60 * 24 * 7;
+ uint256 constant month = 60 * 60 * 24 * 30;
+
+ byte constant proofType_NONE = 0x00;
+ byte constant proofType_Ledger = 0x30;
+ byte constant proofType_Native = 0xF0;
+ byte constant proofStorage_IPFS = 0x01;
+ byte constant proofType_Android = 0x40;
+ byte constant proofType_TLSNotary = 0x10;
+
+ string oraclize_network_name;
+ uint8 constant networkID_auto = 0;
+ uint8 constant networkID_morden = 2;
+ uint8 constant networkID_mainnet = 1;
+ uint8 constant networkID_testnet = 2;
+ uint8 constant networkID_consensys = 161;
+
+ mapping(bytes32 => bytes32) oraclize_randomDS_args;
+ mapping(bytes32 => bool) oraclize_randomDS_sessionKeysHashVerified;
+
+ modifier oraclizeAPI {
+ if ((address(OAR) == address(0)) || (getCodeSize(address(OAR)) == 0)) {
+ oraclize_setNetwork(networkID_auto);
+ }
+ address oraclizeConnector = OAR.getAddress();
+ if (address(oraclize) != oraclizeConnector) {
+ oraclize = OraclizeI(oraclizeConnector);
+ }
+
+ _;
+ }
+
+ modifier oraclize_randomDS_proofVerify (
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ {
+ // Note: RandomDS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ require(
+ (_proof[0] == "L") &&
+ (_proof[1] == "P") &&
+ (uint8(_proof[2]) == uint8(1))
+ );
+ bool proofVerified = oraclize_randomDS_proofVerify__main(
+ _proof,
+ _queryId,
+ bytes(_result),
+ oraclize_getNetworkName()
+ );
+ require(proofVerified);
+ _;
+ }
+
+ function oraclize_setNetwork(
+ uint8 _networkID
+ )
+ internal
+ returns (bool _networkSet)
+ {
+ _networkID; // NOTE: Silence the warning and remain backwards compatible
+ return oraclize_setNetwork();
+ }
+
+ function oraclize_setNetworkName(
+ string memory _network_name
+ )
+ internal
+ {
+ oraclize_network_name = _network_name;
+ }
+
+ function oraclize_getNetworkName()
+ internal
+ view
+ returns (string memory _networkName)
+ {
+ return oraclize_network_name;
+ }
+
+ function oraclize_setNetwork()
+ internal
+ returns (bool _networkSet)
+ {
+ // Note: Mainnet...
+ if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed) > 0) {
+ OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
+ oraclize_setNetworkName("eth_mainnet");
+ return true;
+ }
+ // Note: Ropsten testnet...
+ if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1) > 0) {
+ OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
+ oraclize_setNetworkName("eth_ropsten3");
+ return true;
+ }
+ // Note: Kovan testnet...
+ if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e) > 0) {
+ OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
+ oraclize_setNetworkName("eth_kovan");
+ return true;
+ }
+ // Note: Rinkeby testnet...
+ if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48) > 0) {
+ OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
+ oraclize_setNetworkName("eth_rinkeby");
+ return true;
+ }
+ // Note: Goerli testnet...
+ if (getCodeSize(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41) > 0) {
+ OAR = OraclizeAddrResolverI(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41);
+ oraclize_setNetworkName("eth_goerli");
+ return true;
+ }
+ // Note: Ethereum-bridge testnet...
+ if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475) > 0) {
+ OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
+ return true;
+ }
+ // Note: Ether.camp ide...
+ if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF) > 0) {
+ OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
+ return true;
+ }
+ // Note: Browser-solidity...
+ if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA) > 0) {
+ OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
+ return true;
+ }
+ return false;
+ }
+ /**
+ * @dev The following `__callback` functions are just placeholders ideally
+ * meant to be defined in child contract when proofs are used.
+ * The function bodies simply silence compiler warnings.
+ */
+ function __callback(
+ bytes32 _myid,
+ string memory _result
+ )
+ public
+ {
+ __callback(_myid, _result, new bytes(0));
+ }
+
+ function __callback(
+ bytes32 _myid,
+ string memory _result,
+ bytes memory _proof
+ )
+ public
+ {
+ _myid; _result; _proof;
+ oraclize_randomDS_args[bytes32(0)] = bytes32(0);
+ }
+ /**
+ *
+ * @notice oraclize_getPrice(...) overloads follow...
+ *
+ */
+ function oraclize_getPrice(
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function oraclize_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+ /**
+ *
+ * @notice oraclize_getPriceERC20(...) overloads follow...
+ *
+ */
+ function oraclize_getPriceERC20(
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ address _tokenAddress,
+ string memory _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ address _tokenAddress,
+ byte _datasource
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return oraclize.convertToERC20Price(
+ oraclize.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ oraclize.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function oraclize_getPriceERC20(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ oraclizeAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = oraclize.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return oraclize.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using STRING type datasource follow...
+ *
+ */
+ function oraclize_query(
+ string memory _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic string[] arguments and
+ * a datasource of type STRING follow...
+ *
+ */
+ function oraclize_query(
+ string memory _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic byte[] arguments and a
+ * datasource of type STRING follow...
+ *
+ */
+ function oraclize_query(
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic string[] arguments and
+ * a datasource of type BYTES1 follow...
+ *
+ */
+ function oraclize_query(
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads using dynamic byte[] arguments and a
+ * datasource of type BYTES1 follow...
+ *
+ */
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+
+ function oraclize_query(
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /**
+ *
+ * @notice `oraclize_query` overloads end.
+ *
+ * @notice `oraclize_token_query` overloads using STRING datasource follow...
+ *
+ */
+ function oraclize_token_query(
+ string memory _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = oraclize.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(oraclize)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic string[]
+ * arguments and a datasource of type string follow...
+ *
+ */
+ function oraclize_token_query(
+ string memory _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic byte[]
+ * arguments and a datasource of type string follow...
+ *
+ */
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic string[]
+ * arguments and a datasource of type bytes1 follow...
+ *
+ */
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads using dynamic byte[] arguments
+ * and a datasource of type bytes1 follow...
+ *
+ */
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return oraclize_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function oraclize_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function oraclize_token_query(
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ oraclizeAPI
+ internal
+ 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);
+ }
+ /**
+ *
+ * @notice `oraclize_token_query` overloads end.
+ *
+ */
+ function oraclize_setProof(byte _proofP)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.setProofType(_proofP);
+ }
+
+
+ function oraclize_cbAddress()
+ oraclizeAPI
+ internal
+ returns (address _callbackAddress)
+ {
+ return oraclize.cbAddress();
+ }
+
+ function getCodeSize(address _addr)
+ internal
+ view
+ returns (uint256 _size)
+ {
+ assembly {
+ _size := extcodesize(_addr)
+ }
+ }
+
+ function oraclize_setCustomGasPrice(uint256 _gasPrice)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.setCustomGasPrice(_gasPrice);
+ }
+
+ function oraclize_randomDS_getSessionPubKeyHash()
+ oraclizeAPI
+ internal
+ returns (bytes32 _sessionKeyHash)
+ {
+ return oraclize.randomDS_getSessionPubKeyHash();
+ }
+
+ function oraclize_requestQueryCaching(bytes32 _queryId)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.requestQueryCaching(_queryId);
+ }
+
+ function oraclize_queryCached(uint256 _queryPrice)
+ oraclizeAPI
+ internal
+ returns (bytes32 _queryId)
+ {
+ return oraclize.queryCached.value(_queryPrice)();
+ }
+
+ function oraclize_getDatasourceByte(
+ string memory _datasourceString
+ )
+ internal
+ pure
+ returns (byte _datasourceByte)
+ {
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('URL'))
+ return 0xFF;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Random'))
+ return 0xFE;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('computation'))
+ return 0xFD;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('WolframAlpha'))
+ return 0xFC;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('IPFS'))
+ return 0xFB;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('nested'))
+ return 0xFA;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Blockchain'))
+ return 0xF9;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('swarm'))
+ return 0xF8;
+ return 0x00;
+ }
+
+ function oraclize_getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ oraclizeAPI
+ internal
+ returns(uint256 _rebroadcastCost)
+ {
+ return oraclize.getRebroadcastCost(_gasLimit, _gasPrice);
+ }
+
+ function oraclize_requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ uint256 _queryPrice
+ )
+ oraclizeAPI
+ internal
+ {
+ return oraclize
+ .requestCallbackRebroadcast
+ .value(_queryPrice)
+ (
+ _queryId,
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function oraclize_setCustomTokenPayment(address _tokenAddress)
+ oraclizeAPI
+ internal
+ {
+ return oraclize.setCustomTokenPayment(_tokenAddress);
+ }
+
+ function oraclize_approveTokenAllowance(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ oraclizeAPI
+ internal
+ {
+ ERC20Interface(_tokenAddress)
+ .approve(address(oraclize), _tokenAmount);
+ }
+
+ function oraclize_setAndApproveCustomTokenPayment(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ oraclizeAPI
+ internal
+ {
+ oraclize_setCustomTokenPayment(_tokenAddress);
+ oraclize_approveTokenAllowance(_tokenAddress, _tokenAmount);
+ }
+
+ function oraclize_unsetAndRevokeCustomTokenPayment(address _tokenAddress)
+ oraclizeAPI
+ internal
+ {
+ oraclize_unsetCustomTokenPayment();
+ oraclize_approveTokenAllowance(_tokenAddress, 0);
+ }
+
+ function oraclize_unsetCustomTokenPayment()
+ oraclizeAPI
+ internal
+ {
+ return oraclize.unsetCustomTokenPayment();
+ }
+ /**
+ *
+ * @notice Oraclize helper functions follow...
+ *
+ */
+ function parseAddr(string memory _a)
+ internal
+ pure
+ returns (address _parsedAddress)
+ {
+ 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(uint8(tmp[i]));
+ b2 = uint160(uint8(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);
+ }
+
+ function strCompare(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
+ 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;
+ }
+ }
+
+ function indexOf(
+ string memory _haystack,
+ string memory _needle
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
+ 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 int(i);
+ }
+ }
+ }
+ return -1;
+ }
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, "", "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, _d, "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d,
+ string memory _e
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ 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;
+ uint256 i = 0;
+ for (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);
+ }
+
+ function safeParseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
+ return safeParseInt(_a, 0);
+ }
+
+ function safeParseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
+ bytes memory bresult = bytes(_a);
+ uint256 mint = 0;
+ bool decimals = false;
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if (
+ (uint256(uint8(bresult[i])) >= 48) &&
+ (uint256(uint8(bresult[i])) <= 57)
+ ) {
+ if (decimals) {
+ if (_b == 0) break;
+ else _b--;
+ }
+ mint *= 10;
+ mint += uint256(uint8(bresult[i])) - 48;
+ } else if (uint256(uint8(bresult[i])) == 46) {
+ require(
+ !decimals,
+ 'More than one decimal encountered in string!'
+ );
+ decimals = true;
+ } else {
+ revert("Non-numeral character encountered in string!");
+ }
+ }
+ if (_b > 0) {
+ mint *= 10 ** _b;
+ }
+ return mint;
+ }
+
+ function parseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
+ return parseInt(_a, 0);
+ }
+
+ function parseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
+ bytes memory bresult = bytes(_a);
+ uint256 mint = 0;
+ bool decimals = false;
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if (
+ (uint256(uint8(bresult[i])) >= 48) &&
+ (uint256(uint8(bresult[i])) <= 57)
+ ) {
+ if (decimals) {
+ if (_b == 0) {
+ break;
+ } else {
+ _b--;
+ }
+ }
+ mint *= 10;
+ mint += uint256(uint8(bresult[i])) - 48;
+ } else if (uint256(uint8(bresult[i])) == 46) {
+ decimals = true;
+ }
+ }
+ if (_b > 0) {
+ mint *= 10 ** _b;
+ }
+ return mint;
+ }
+
+ function uint2str(uint256 _i)
+ internal
+ pure
+ returns (string memory _uintAsString)
+ {
+ 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(uint8(48 + _i % 10));
+ _i /= 10;
+ }
+ return string(bstr);
+ }
+
+ function stra2cbor(string[] memory _arr)
+ internal
+ pure
+ returns (bytes memory _cborEncoding)
+ {
+ safeMemoryCleaner();
+ Buffer.buffer memory buf;
+ Buffer.init(buf, 1024);
+ buf.startArray();
+ for (uint256 i = 0; i < _arr.length; i++) {
+ buf.encodeString(_arr[i]);
+ }
+ buf.endSequence();
+ return buf.buf;
+ }
+
+ function ba2cbor(bytes[] memory _arr)
+ internal
+ pure
+ returns (bytes memory _cborEncoding)
+ {
+ safeMemoryCleaner();
+ Buffer.buffer memory buf;
+ Buffer.init(buf, 1024);
+ buf.startArray();
+ for (uint256 i = 0; i < _arr.length; i++) {
+ buf.encodeBytes(_arr[i]);
+ }
+ buf.endSequence();
+ return buf.buf;
+ }
+ /**
+ *
+ * Oraclize RandomDS Functions
+ *
+ */
+ function oraclize_newRandomDSQuery(
+ uint256 _delay,
+ uint256 _nbytes,
+ uint256 _customGasLimit
+ )
+ internal
+ returns (bytes32 _queryId)
+ {
+ require((_nbytes > 0) && (_nbytes <= 32));
+ _delay *= 10; // Note: Convert from seconds to ledger timer ticks
+ bytes memory nbytes = new bytes(1);
+ nbytes[0] = byte(uint8(_nbytes));
+ bytes memory unonce = new bytes(32);
+ bytes memory sessionKeyHash = new bytes(32);
+ bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
+ assembly {
+ mstore(unonce, 0x20)
+ /**
+ *
+ * The following variables can be relaxed.
+ * Check the relaxed random contract at https://github.com/oraclize/ethereum-examples
+ * for an idea on how to override and replace commit hash variables.
+ *
+ */
+ mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
+ mstore(sessionKeyHash, 0x20)
+ mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
+ }
+ bytes memory delay = new bytes(32);
+ assembly {
+ mstore(add(delay, 0x20), _delay)
+ }
+ bytes memory delay_bytes8 = new bytes(8);
+ copyBytes(delay, 24, 8, delay_bytes8, 0);
+ bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
+ bytes32 queryId = oraclize_query("random", args, _customGasLimit);
+ bytes memory delay_bytes8_left = new bytes(8);
+ assembly {
+ let x := mload(add(delay_bytes8, 0x20))
+ mstore8(
+ add(delay_bytes8_left, 0x27),
+ div(x, 0x100000000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x26),
+ div(x, 0x1000000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x25),
+ div(x, 0x10000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x24),
+ div(x, 0x100000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x23),
+ div(x, 0x1000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x22),
+ div(x, 0x10000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x21),
+ div(x, 0x100000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x20),
+ div(x, 0x1000000000000000000000000000000000000000000000000)
+ )
+ }
+ oraclize_randomDS_setCommitment(
+ queryId,
+ keccak256(
+ abi.encodePacked(
+ delay_bytes8_left,
+ args[1],
+ sha256(args[0]),
+ args[2]
+ )
+ )
+ );
+ return queryId;
+ }
+
+ function oraclize_randomDS_setCommitment(
+ bytes32 _queryId,
+ bytes32 _commitment
+ )
+ internal
+ {
+ oraclize_randomDS_args[_queryId] = _commitment;
+ }
+
+ function verifySig(
+ bytes32 _tosignh,
+ bytes memory _dersig,
+ bytes memory _pubkey
+ )
+ internal
+ returns (bool _sigVerified)
+ {
+ bool sigok;
+ address signer;
+ bytes32 sigr;
+ bytes32 sigs;
+ bytes memory sigr_ = new bytes(32);
+ uint256 offset = 4 + (uint256(uint8(_dersig[3])) - 0x20);
+ sigr_ = copyBytes(_dersig, offset, 32, sigr_, 0);
+ bytes memory sigs_ = new bytes(32);
+ offset += 32 + 2;
+ sigs_ = copyBytes(
+ _dersig,
+ offset + (uint256(uint8(_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(uint160(uint256(keccak256(_pubkey)))) == signer) {
+ return true;
+ } else {
+ (sigok, signer) = safer_ecrecover(_tosignh, 28, sigr, sigs);
+ return (address(uint160(uint256(keccak256(_pubkey)))) == signer);
+ }
+ }
+
+ function oraclize_randomDS_proofVerify__sessionKeyValidity(
+ bytes memory _proof,
+ uint256 _sig2offset
+ )
+ internal
+ returns (bool _proofVerified)
+ {
+ bool sigok;
+ /**
+ *
+ * Note - Random DS Proof Step 6:
+ * Verify the attestation signature, APPKEY1 must sign the sessionKey
+ * from the correct ledger app (CODEHASH)
+ *
+ */
+ bytes memory sig2 = new bytes(uint256(uint8(_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] = byte(uint8(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) {
+ return false;
+ }
+ /**
+ *
+ * Note - Random DS Proof 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(uint8(_proof[3 + 65 + 1])) + 2);
+ copyBytes(_proof, 3 + 65, sig3.length, sig3, 0);
+ sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
+ return sigok;
+ }
+
+ function oraclize_randomDS_proofVerify__returnCode(
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ internal
+ returns (uint8 _returnCode)
+ {
+ /**
+ *
+ * Note - Random DS Proof Step 1:
+ * The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ *
+ */
+ if (
+ (_proof[0] != "L") ||
+ (_proof[1] != "P") ||
+ (uint8(_proof[2]) != uint8(1))
+ ) {
+ return 1;
+ }
+ bool proofVerified = oraclize_randomDS_proofVerify__main(
+ _proof,
+ _queryId,
+ bytes(_result),
+ oraclize_getNetworkName()
+ );
+ if (!proofVerified) {
+ return 2;
+ }
+ return 0;
+ }
+
+ function matchBytes32Prefix(
+ bytes32 _content,
+ bytes memory _prefix,
+ uint256 _nRandomBytes
+ )
+ internal
+ pure
+ returns (bool _matchesPrefix)
+ {
+ bool match_ = true;
+ require(_prefix.length == _nRandomBytes);
+ for (uint256 i = 0; i < _nRandomBytes; i++) {
+ if (_content[i] != _prefix[i]) {
+ match_ = false;
+ }
+ }
+ return match_;
+ }
+
+ function oraclize_randomDS_proofVerify__main(
+ bytes memory _proof,
+ bytes32 _queryId,
+ bytes memory _result,
+ string memory _contextName
+ )
+ internal
+ returns (bool _proofVerified)
+ {
+ /**
+ *
+ * Note - Random DS Proof Step 2:
+ * The unique keyhash has to match with the sha256 of:
+ * (context name + _queryId)
+ *
+ */
+ uint256 ledgerProofLength = 3 + 65 + (uint256(uint8(_proof[3 + 65 + 1])) + 2) + 32;
+ bytes memory keyhash = new bytes(32);
+ copyBytes(_proof, ledgerProofLength, 32, keyhash, 0);
+ if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(_contextName, _queryId)))))) {
+ return false;
+ }
+ bytes memory sig1 = new bytes(uint256(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
+ copyBytes(_proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);
+ /**
+ *
+ * Note - Random DS Proof 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(uint8(_proof[ledgerProofLength + 32 + 8])))) {
+ return false;
+ }
+ /**
+ *
+ * Note - Random DS Proof Step 4:
+ * Commitment match verifying that
+ *
+ * keccak256(
+ * 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] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))) { //unonce, nbytes and sessionKeyHash match
+ delete oraclize_randomDS_args[_queryId];
+ } else return false;
+ /**
+ *
+ * Note - Random DS Proof 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;
+ }
+ /**
+ *
+ * Note: Verify if sessionPubkeyHash was verified already, if not...
+ * let's do it!
+ *
+ */
+ if (!oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash]) {
+ oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(_proof, sig2offset);
+ }
+ return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
+ }
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ *
+ */
+ function copyBytes(
+ bytes memory _from,
+ uint256 _fromOffset,
+ uint256 _length,
+ bytes memory _to,
+ uint256 _toOffset
+ )
+ internal
+ pure
+ returns (bytes memory _copiedBytes)
+ {
+ uint256 minLength = _length + _toOffset;
+ require(_to.length >= minLength); // Note: Buffer too small. Should be a better way?
+ uint256 i = 32 + _fromOffset; // Note: the offset 32 is added to skip the `size` field of both bytes variables
+ 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;
+ }
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ * It duplicates Solidity's ecrecover, but catching the CALL return value
+ *
+ */
+ function safer_ecrecover(
+ bytes32 _hash,
+ uint8 _v,
+ bytes32 _r,
+ bytes32 _s
+ )
+ internal
+ returns (bool _success, address _recoveredAddress)
+ {
+ /**
+ *
+ * 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)
+ ret := call(3000, 1, 0, size, 128, size, 32) // NOTE: we can reuse the request memory because we deal with the return code.
+ addr := mload(size)
+ }
+ return (ret, addr);
+ }
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ *
+ */
+ function ecrecovery(
+ bytes32 _hash,
+ bytes memory _sig
+ )
+ internal
+ returns (bool _success, address _recoveredAddress)
+ {
+ bytes32 r;
+ bytes32 s;
+ uint8 v;
+ if (_sig.length != 65) {
+ return (false, address(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, address(0));
+ }
+ return safer_ecrecover(_hash, v, r, s);
+ }
+
+ function safeMemoryCleaner()
+ internal
+ pure
+ {
+ assembly {
+ let fmem := mload(0x40)
+ codecopy(fmem, codesize, sub(msize, fmem))
+ }
+ }
+}
+/**
+ *
+ * END ORACLIZE_API
+ *
+ */
diff --git a/oraclizeAPI_pre0.4.sol b/oraclizeAPI_pre0.4.sol
index 0ae44f7..ac9ef46 100644
--- a/oraclizeAPI_pre0.4.sol
+++ b/oraclizeAPI_pre0.4.sol
@@ -9,9 +9,8 @@
/*
Copyright (c) 2015-2016 Oraclize SRL
-Copyright (c) 2016 Oraclize LTD
-
-
+Copyright (c) 2016-2019 Oraclize LTD
+Copyright (c) 2019 Provable Things Limited
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -20,13 +19,9 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
-
-
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
-
-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
diff --git a/provableAPI_0.4.25.sol b/provableAPI_0.4.25.sol
index 0c422c4..05fdec4 100644
--- a/provableAPI_0.4.25.sol
+++ b/provableAPI_0.4.25.sol
@@ -1,13 +1,10 @@
-//
-// Release targetted at solc 0.4.25 to silence compiler warning/error messages, compatible down to 0.4.22
-
+//
+// Release targeted at solc 0.4.25 to silence compiler warning/error messages, compatible down to 0.4.22
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016-2019 Oraclize LTD
Copyright (c) 2019 Provable Things Limited
-
-
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
@@ -15,13 +12,9 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
-
-
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
-
-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -31,21 +24,73 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
-pragma solidity >= 0.4.22 < 0.5;// Incompatible compiler version... please select one stated within pragma solidity or use different provableAPI version
+// This api is currently targeted at 0.4.22 to 0.4.25 (stable builds), please import provableAPI_pre0.4.sol or provableAPI_0.4 where necessary
+
+pragma solidity >= 0.4.22 < 0.5; // Incompatible compiler version... please select one stated within pragma solidity or use different provableAPI version
+
+/**
+ * @notice A separate interface is used here for any queries that use type
+ * `bytes` to define the datasource due to the compiler not being able
+ * to differentiate the two function signatures if called via
+ * ProvableI.query(...)
+ *
+ */
+contract ProvableIBytes {
+
+ function queryN(uint _timestamp, bytes1 _datasource, bytes _argN) public payable returns (bytes32 _id);
+ function query(uint _timestamp, bytes1 _datasource, string _arg) external payable returns (bytes32 _id);
+ function query2(uint _timestamp, bytes1 _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
+ function query_withGasLimit(uint _timestamp, bytes1 _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
+ function queryN_withGasLimit(uint _timestamp, bytes1 _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
+ function query2_withGasLimit(uint _timestamp, bytes1 _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
+
+}
contract ProvableI {
+
address public cbAddress;
- function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
- function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
- function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
- function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
- function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
- function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
- function getPrice(string _datasource) public returns (uint _dsprice);
- function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
+ mapping (bytes32 => uint256) public price;
+ mapping (address => address) public addressCustomPaymentToken;
+
+ function unsetCustomTokenPayment() external;
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
+ function requestQueryCaching(bytes32 _queryId) external;
+ function setCustomTokenPayment(address _tokenAddress) external;
+ function queryCached() payable external returns (bytes32 _queryId);
+ function getPrice(byte _datasource) public view returns (uint256 _dsprice);
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
+ function getPrice(string memory _datasource) public view returns (uint256 _dsprice);
+ function getPrice(byte _datasource, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getPrice(byte _datasource, uint256 _gasLimit) public view returns (uint256 _dsprice);
+ function getPrice(string memory _datasource, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getPrice(string memory _datasource, uint256 _gasLimit) public view returns (uint256 _dsprice);
+ function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
+ function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
+ function requestCallbackRebroadcast(bytes32 _queryId, uint256 _gasLimit, uint256 _gasPrice) payable external;
+ function getPrice(byte _datasource, uint256 _gasLimit, address _contractToQuery) public view returns (uint256 _dsprice);
+ function getRebroadcastCost(uint256 _gasLimit, uint256 _gasPrice) public pure returns (uint256 _rebroadcastCost);
+ function convertToERC20Price(uint256 _queryPriceInWei, address _tokenAddress) public view returns (uint256 _price);
+ function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
+ function getPrice(string memory _datasource, uint256 _gasLimit, address _contractToQuery) public view returns (uint256 _dsprice);
+ function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
+ function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
+ function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
+
+}
+
+interface ERC20Interface {
+
+ event Transfer(address indexed _from, address indexed _to, uint _tokens);
+ event Approval(address indexed _tokenOwner, address indexed _spender, uint _tokens);
+
+ function totalSupply() external view returns (uint);
+ function transfer(address _to, uint _tokens) external returns (bool _success);
+ function balanceOf(address _tokenOwner) external view returns (uint _balance);
+ function approve(address _tokenSpender, uint256 _tokenAmount) external returns (bool);
+ function transferFrom(address _from, address _to, uint _tokens) external returns (bool _success);
+ function allowance(address _tokenOwner, address _spender) external view returns (uint _remaining);
+
}
contract OracleAddrResolverI {
@@ -285,9 +330,9 @@ End solidity-cborutils
*/
contract usingProvable {
- uint constant day = 60*60*24;
- uint constant week = 60*60*24*7;
- uint constant month = 60*60*24*30;
+ uint constant day = 60 * 60 * 24;
+ uint constant week = 60 * 60 * 24 * 7;
+ uint constant month = 60 * 60 * 24 * 30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
@@ -303,23 +348,27 @@ contract usingProvable {
OracleAddrResolverI OAR;
ProvableI provable;
+ ProvableIBytes provableBytes;
+
modifier provableAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
provable_setNetwork(networkID_auto);
- if(address(provable) != OAR.getAddress())
- provable = ProvableI(OAR.getAddress());
-
+ address provableConnector = OAR.getAddress();
+ if(address(provable) != provableConnector)
+ provable = ProvableI(provableConnector);
+ provableBytes = ProvableIBytes(address(provableConnector));
_;
}
+
modifier coupon(string code){
provable = ProvableI(OAR.getAddress());
_;
}
function provable_setNetwork(uint8 networkID) internal returns(bool){
- return provable_setNetwork();
- networkID; // silence the warning and remain backwards compatible
+ return provable_setNetwork();
+ networkID; // silence the warning and remain backwards compatible
}
function provable_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
@@ -366,155 +415,1286 @@ contract usingProvable {
* meant to be defined in child contract when proofs are used.
* The function bodies simply silence compiler warnings.
*/
- function __callback(bytes32 myid, string result) public {
+ function __callback(
+ bytes32 myid,
+ string result
+ )
+ public
+ {
__callback(myid, result, new bytes(0));
}
- function __callback(bytes32 myid, string result, bytes proof) public {
- return;
+ function __callback(
+ bytes32 myid,
+ string result,
+ bytes proof
+ )
+ public
+ {
myid; result; proof;
provable_randomDS_args[bytes32(0)] = bytes32(0);
}
+ /**
+ *
+ * @notice provable_getPrice(...) overloads follow...
+ *
+ */
+ function provable_getPrice(
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource);
+ }
+
+ function provable_getPrice(
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+ /**
+ *
+ * @notice provable_getPriceERC20(...) overloads follow...
+ *
+ */
+ function provable_getPriceERC20(
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
- function provable_getPrice(string datasource) provableAPI internal returns (uint){
- return provable.getPrice(datasource);
+ function provable_getPriceERC20(
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ provable.addressCustomPaymentToken(address(this))
+ );
}
- function provable_getPrice(string datasource, uint gaslimit) provableAPI internal returns (uint){
- return provable.getPrice(datasource, gaslimit);
+ function provable_getPriceERC20(
+ address _tokenAddress,
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ _tokenAddress
+ );
}
- function provable_query(string datasource, string arg) provableAPI internal returns (bytes32 id){
+ function provable_getPriceERC20(
+ address _tokenAddress,
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using the STRING datasource follow...
+ *
+ */
+ function provable_query(
+ string datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return provable.query.value(price)(0, datasource, arg);
}
- function provable_query(uint timestamp, string datasource, string arg) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return provable.query.value(price)(timestamp, datasource, arg);
}
- function provable_query(uint timestamp, string datasource, string arg, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return provable.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
- function provable_query(string datasource, string arg, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return provable.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
- function provable_query(string datasource, string arg1, string arg2) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return provable.query2.value(price)(0, datasource, arg1, arg2);
}
- function provable_query(uint timestamp, string datasource, string arg1, string arg2) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
return provable.query2.value(price)(timestamp, datasource, arg1, arg2);
}
- function provable_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return provable.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
- function provable_query(string datasource, string arg1, string arg2, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
return provable.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
- function provable_query(string datasource, string[] argN) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ string datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return provable.queryN.value(price)(0, datasource, args);
}
- function provable_query(uint timestamp, string datasource, string[] argN) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return provable.queryN.value(price)(timestamp, datasource, args);
}
- function provable_query(uint timestamp, string datasource, string[] argN, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return provable.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
- function provable_query(string datasource, string[] argN, uint gaslimit) provableAPI internal returns (bytes32 id){
+
+ function provable_query(
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return provable.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
- function provable_query(string datasource, string[1] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN.value(price)(0, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN.value(price)(timestamp, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_query(
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using the BYTE datasource follow...
+ *
+ */
+ function provable_query(
+ bytes1 datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query.value(price)(0, datasource, arg);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query.value(price)(timestamp, datasource, arg);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query2.value(price)(0, datasource, arg1, arg2);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query2.value(price)(timestamp, datasource, arg1, arg2);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN.value(price)(0, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN.value(price)(timestamp, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN.value(price)(0, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN.value(price)(timestamp, datasource, args);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic arguments and the
+ * STRING type datasource follow...
+ *
+ */
+ function provable_query(
+ string datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[1] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[1] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[1] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[2] args) provableAPI internal returns (bytes32 id) {
+ function provable_query(
+ string datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[2] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[2] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[2] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[3] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[3] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[3] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[3] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -530,7 +1710,16 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[4] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -538,7 +1727,17 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[4] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -546,7 +1745,16 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[4] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -554,7 +1762,15 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[5] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -563,7 +1779,16 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[5] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -572,7 +1797,17 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, string[5] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -581,7 +1816,16 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, string[5] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -590,97 +1834,180 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[] argN) provableAPI internal returns (bytes32 id){
- uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
- bytes memory args = ba2cbor(argN);
- return provable.queryN.value(price)(0, datasource, args);
- }
- function provable_query(uint timestamp, string datasource, bytes[] argN) provableAPI internal returns (bytes32 id){
- uint price = provable.getPrice(datasource);
- if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
- bytes memory args = ba2cbor(argN);
- return provable.queryN.value(price)(timestamp, datasource, args);
- }
- function provable_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) provableAPI internal returns (bytes32 id){
- uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
- bytes memory args = ba2cbor(argN);
- return provable.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
- }
- function provable_query(string datasource, bytes[] argN, uint gaslimit) provableAPI internal returns (bytes32 id){
- uint price = provable.getPrice(datasource, gaslimit);
- if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
- bytes memory args = ba2cbor(argN);
- return provable.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
- }
- function provable_query(string datasource, bytes[1] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[1] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[1] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[2] args) provableAPI internal returns (bytes32 id) {
+ function provable_query(
+ string datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[2] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[2] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[3] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[3] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[3] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -688,7 +2015,14 @@ contract usingProvable {
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[4] args) provableAPI internal returns (bytes32 id) {
+ function provable_query(
+ string datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -696,7 +2030,16 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[4] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -704,7 +2047,17 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -712,7 +2065,16 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[4] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -720,7 +2082,15 @@ contract usingProvable {
dynargs[3] = args[3];
return provable_query(datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[5] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -729,7 +2099,16 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[5] args) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -738,7 +2117,17 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(timestamp, datasource, dynargs);
}
- function provable_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -747,7 +2136,16 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(timestamp, datasource, dynargs, gaslimit);
}
- function provable_query(string datasource, bytes[5] args, uint gaslimit) provableAPI internal returns (bytes32 id) {
+
+ function provable_query(
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
@@ -756,164 +2154,2827 @@ contract usingProvable {
dynargs[4] = args[4];
return provable_query(datasource, dynargs, gaslimit);
}
-
- function provable_cbAddress() provableAPI internal returns (address){
- return provable.cbAddress();
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic arguments and the
+ * BYTES1 datasource type follow...
+ *
+ */
+ function provable_query(
+ bytes1 datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_query(datasource, dynargs);
}
- function provable_setProof(byte proofP) provableAPI internal {
- return provable.setProofType(proofP);
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_query(
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(datasource, dynargs, gaslimit);
+ }
+ /*
+ *
+ * @notice `provable_query` overloads end.
+ *
+ * @notice `provable_token_query` overloads using the STRING datasource follow...
+ *
+ */
+ function provable_token_query(
+ string datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provable.query(0, datasource, arg);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provable.query(timestamp, datasource, arg);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provable.query_withGasLimit(timestamp, datasource, arg, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provable.query_withGasLimit(0, datasource, arg, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provable.query2(0, datasource, arg1, arg2);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provable.query2(timestamp, datasource, arg1, arg2);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provable.query2_withGasLimit(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provable.query2_withGasLimit(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provable.queryN(0, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provable.queryN(timestamp, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provable.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provable.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN(0, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN(timestamp, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provable.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `provable_token_query` overloads using the BYTE datasource follow...
+ *
+ */
+ function provable_token_query(
+ bytes1 datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query(0, datasource, arg);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query(timestamp, datasource, arg);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query_withGasLimit(timestamp, datasource, arg, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string arg,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query_withGasLimit(0, datasource, arg, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query2(0, datasource, arg1, arg2);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ return provableBytes.query2(timestamp, datasource, arg1, arg2);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query2_withGasLimit(timestamp, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string arg1,
+ string arg2,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ return provableBytes.query2_withGasLimit(0, datasource, arg1, arg2, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN(0, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN(timestamp, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = stra2cbor(argN);
+ return provableBytes.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN(0, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource);
+ if (price > 1 ether + tx.gasprice * 200000) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN(timestamp, datasource, args);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN_withGasLimit(timestamp, datasource, args, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[] argN,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ uint price = provable.getPrice(datasource, gaslimit);
+ if (price > 1 ether + tx.gasprice * gaslimit) return 0; // unexpectedly high price
+ bytes memory args = ba2cbor(argN);
+ return provableBytes.queryN_withGasLimit(0, datasource, args, gaslimit);
+ }
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic arguments and the
+ * STRING type datasource follow...
+ *
+ */
+ function provable_token_query(
+ string datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(string datasource, string[4] args) provableAPI internal 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ string datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic arguments and the
+ * BYTES1 datasource type follow...
+ *
+ */
+ function provable_token_query(
+ bytes1 datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ string[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[1] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = args[0];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[2] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[3] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = args[0];
+ dynargs[1] = args[1];
+ dynargs[2] = args[2];
+ return provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[4] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint timestamp,
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(timestamp, datasource, dynargs, gaslimit);
+ }
+
+ function provable_token_query(
+ bytes1 datasource,
+ bytes[5] args,
+ uint gaslimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(datasource, dynargs, gaslimit);
+ }
+ /*
+ *
+ * @notice `provable_token_query` overloads end.
+ *
+ */
+ function provable_cbAddress()
+ provableAPI
+ internal
+ returns (address)
+ {
+ return provable.cbAddress();
+ }
+
+ function provable_setProof(byte proofP)
+ provableAPI
+ internal
+ {
+ return provable.setProofType(proofP);
}
- function provable_setCustomGasPrice(uint gasPrice) provableAPI internal {
+
+ function provable_setCustomGasPrice(
+ uint gasPrice
+ )
+ provableAPI
+ internal
+ {
return provable.setCustomGasPrice(gasPrice);
}
- function provable_randomDS_getSessionPubKeyHash() provableAPI internal returns (bytes32){
+ function provable_randomDS_getSessionPubKeyHash()
+ provableAPI
+ internal
+ returns (bytes32)
+ {
return provable.randomDS_getSessionPubKeyHash();
}
- function getCodeSize(address _addr) view internal returns(uint _size) {
+ function getCodeSize(address _addr)
+ internal
+ view
+ returns(uint _size)
+ {
assembly {
_size := extcodesize(_addr)
}
}
- function parseAddr(string _a) internal pure returns (address){
+ function provable_requestQueryCaching(bytes32 _queryId)
+ provableAPI
+ internal
+ {
+ return provable.requestQueryCaching(_queryId);
+ }
+
+ function provable_queryCached(uint256 _queryPrice)
+ provableAPI
+ internal
+ returns (bytes32 _queryId)
+ {
+ return provable.queryCached.value(_queryPrice)();
+ }
+
+ function provable_getDatasourceByte(
+ string memory _datasourceString
+ )
+ internal
+ returns (byte _datasourceByte)
+ {
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('URL'))
+ return 0xFF;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Random'))
+ return 0xFE;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('computation'))
+ return 0xFD;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('WolframAlpha'))
+ return 0xFC;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('IPFS'))
+ return 0xFB;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('nested'))
+ return 0xFA;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Blockchain'))
+ return 0xF9;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('swarm'))
+ return 0xF8;
+ return 0x00;
+ }
+
+ function provable_getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _rebroadcastCost)
+ {
+ return provable.getRebroadcastCost(
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function provable_requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ uint256 _queryPrice
+ )
+ provableAPI
+ internal
+ {
+ return provable
+ .requestCallbackRebroadcast
+ .value(_queryPrice)
+ (
+ _queryId,
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function provable_setCustomTokenPayment(address _tokenAddress)
+ provableAPI
+ internal
+ {
+ return provable.setCustomTokenPayment(_tokenAddress);
+ }
+
+ function provable_approveTokenAllowance(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ provableAPI
+ internal
+ {
+ ERC20Interface(_tokenAddress)
+ .approve(address(provable), _tokenAmount);
+ }
+
+ function provable_setAndApproveCustomTokenPayment(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ provableAPI
+ internal
+ {
+ provable_setCustomTokenPayment(_tokenAddress);
+ provable_approveTokenAllowance(_tokenAddress, _tokenAmount);
+ }
+
+ function provable_unsetAndRevokeCustomTokenPayment(address _tokenAddress)
+ provableAPI
+ internal
+ {
+ provable_unsetCustomTokenPayment();
+ provable_approveTokenAllowance(_tokenAddress, 0);
+ }
+
+ function provable_unsetCustomTokenPayment()
+ provableAPI
+ internal
+ {
+ return provable.unsetCustomTokenPayment();
+ }
+ /**
+ *
+ * @notice Provable helper functions follow.
+ *
+ */
+ function parseAddr(string memory _a)
+ internal
+ pure
+ returns (address _parsedAddress)
+ {
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
- for (uint i=2; i<2+2*20; i+=2){
+ 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);
+ b1 = uint160(uint8(tmp[i]));
+ b2 = uint160(uint8(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);
}
- function strCompare(string _a, string _b) internal pure returns (int) {
+ function strCompare(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
- uint minLength = a.length;
- if (b.length < minLength) minLength = b.length;
- for (uint i = 0; i < minLength; i ++)
- if (a[i] < b[i])
+ 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])
+ } else if (a[i] > b[i]) {
return 1;
- if (a.length < b.length)
+ }
+ }
+ if (a.length < b.length) {
return -1;
- else if (a.length > b.length)
+ } else if (a.length > b.length) {
return 1;
- else
+ } else {
return 0;
+ }
}
- function indexOf(string _haystack, string _needle) internal pure returns (int) {
+ function indexOf(
+ string memory _haystack,
+ string memory _needle
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
- if(h.length < 1 || n.length < 1 || (n.length > h.length))
+ if (h.length < 1 || n.length < 1 || (n.length > h.length)) {
return -1;
- else if(h.length > (2**128 -1))
+ } else if (h.length > (2 ** 128 - 1)) {
return -1;
- else
- {
- uint subindex = 0;
- for (uint i = 0; i < h.length; i ++)
- {
- if (h[i] == n[0])
- {
+ } 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])
- {
+ while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex]) {
subindex++;
}
- if(subindex == n.length)
+ if (subindex == n.length) {
return int(i);
+ }
}
}
return -1;
}
}
- function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
+ function strConcat(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, "", "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, "", "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
+ return strConcat(_a, _b, _c, _d, "");
+ }
+
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d,
+ string memory _e
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
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);
+ string memory abcde = new string(
+ _ba.length +
+ _bb.length +
+ _bc.length +
+ _bd.length +
+ _be.length
+ );
bytes memory babcde = bytes(abcde);
- uint k = 0;
- for (uint 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];
+ uint256 k = 0;
+ uint256 i = 0;
+ for (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);
}
- function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
- return strConcat(_a, _b, _c, _d, "");
- }
-
- function strConcat(string _a, string _b, string _c) internal pure returns (string) {
- return strConcat(_a, _b, _c, "", "");
- }
-
- function strConcat(string _a, string _b) internal pure returns (string) {
- return strConcat(_a, _b, "", "", "");
- }
-
- // parseInt
- function parseInt(string _a) internal pure returns (uint) {
+ function parseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
return parseInt(_a, 0);
}
- // parseInt(parseFloat*10^_b)
- function parseInt(string _a, uint _b) internal pure returns (uint) {
+ function parseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
bytes memory bresult = bytes(_a);
- uint mint = 0;
+ uint256 mint = 0;
bool decimals = false;
- for (uint i=0; i= 48)&&(bresult[i] <= 57)){
- if (decimals){
- if (_b == 0) break;
- else _b--;
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
+ if (decimals) {
+ if (_b == 0) {
+ break;
+ } else {
+ _b--;
+ }
}
mint *= 10;
- mint += uint(bresult[i]) - 48;
- } else if (bresult[i] == 46) decimals = true;
+ mint += uint(uint8(bresult[i])) - 48;
+ } else if (uint(uint8(bresult[i])) == 46) {
+ decimals = true;
+ }
+ }
+ if (_b > 0) {
+ mint *= 10 ** _b;
}
- if (_b > 0) mint *= 10**_b;
return mint;
}
- function uint2str(uint i) internal pure returns (string){
- if (i == 0) return "0";
- uint j = i;
- uint len;
- while (j != 0){
+ function uint2str(uint256 _i)
+ internal
+ pure
+ returns (string memory _uintAsString)
+ {
+ if (_i == 0) {
+ return "0";
+ }
+ uint256 j = _i;
+ uint256 len;
+ while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
- uint k = len - 1;
- while (i != 0){
- bstr[k--] = byte(48 + i % 10);
- i /= 10;
+ uint256 k = len - 1;
+ while (_i != 0) {
+ bstr[k--] = byte(uint8(48 + _i % 10));
+ _i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
- function stra2cbor(string[] arr) internal pure returns (bytes) {
+
+ function stra2cbor(string[] arr)
+ internal
+ pure
+ returns (bytes)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
@@ -925,7 +4986,11 @@ contract usingProvable {
return buf.buf;
}
- function ba2cbor(bytes[] arr) internal pure returns (bytes) {
+ function ba2cbor(bytes[] arr)
+ internal
+ pure
+ returns (bytes)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
@@ -938,28 +5003,43 @@ contract usingProvable {
}
string provable_network_name;
- function provable_setNetworkName(string _network_name) internal {
+
+ function provable_setNetworkName(string _network_name)
+ internal
+ {
provable_network_name = _network_name;
}
- function provable_getNetworkName() internal view returns (string) {
+ function provable_getNetworkName()
+ internal
+ view
+ returns (string)
+ {
return provable_network_name;
}
- function provable_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
+ function provable_newRandomDSQuery(
+ uint256 _delay,
+ uint256 _nbytes,
+ uint256 _customGasLimit
+ )
+ internal
+ returns (bytes32 _queryId)
+ {
require((_nbytes > 0) && (_nbytes <= 32));
- // Convert from seconds to ledger timer ticks
- _delay *= 10;
+ _delay *= 10; // Convert from seconds to ledger timer ticks
bytes memory nbytes = new bytes(1);
- nbytes[0] = byte(_nbytes);
+ nbytes[0] = byte(uint8(_nbytes));
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = provable_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
- // the following variables can be relaxed
- // check relaxed random contract under ethereum-examples repo
- // for an idea on how to override and replace comit hash vars
+ /*
+ The following variables can be relaxed.
+ Check the relaxed random contract at https://github.com/provable-things/ethereum-examples
+ for an idea on how to override and replace commit hash variables.
+ */
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
@@ -968,15 +5048,11 @@ contract usingProvable {
assembly {
mstore(add(delay, 0x20), _delay)
}
-
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
-
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = provable_query("random", args, _customGasLimit);
-
bytes memory delay_bytes8_left = new bytes(8);
-
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
@@ -987,21 +5063,31 @@ contract usingProvable {
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
-
}
-
provable_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
- function provable_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
+ function provable_randomDS_setCommitment(
+ bytes32 queryId,
+ bytes32 commitment
+ )
+ internal
+ {
provable_randomDS_args[queryId] = commitment;
}
- mapping(bytes32=>bytes32) provable_randomDS_args;
- mapping(bytes32=>bool) provable_randomDS_sessionKeysHashVerified;
-
- function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
+ mapping(bytes32 => bytes32) provable_randomDS_args;
+ mapping(bytes32 => bool) provable_randomDS_sessionKeysHashVerified;
+
+ function verifySig(
+ bytes32 tosignh,
+ bytes dersig,
+ bytes pubkey
+ )
+ internal
+ returns (bool)
+ {
bool sigok;
address signer;
@@ -1029,7 +5115,13 @@ contract usingProvable {
}
}
- function provable_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
+ function provable_randomDS_proofVerify__sessionKeyValidity(
+ bytes proof,
+ uint sig2offset
+ )
+ internal
+ returns (bool)
+ {
bool sigok;
// Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
@@ -1064,7 +5156,11 @@ contract usingProvable {
return sigok;
}
- modifier provable_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
+ modifier provable_randomDS_proofVerify(
+ bytes32 _queryId,
+ string _result,
+ bytes _proof)
+ {
// Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
@@ -1074,72 +5170,102 @@ contract usingProvable {
_;
}
- function provable_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;
-
+ function provable_randomDS_proofVerify__returnCode(
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ internal
+ returns (uint8 _returnCode)
+ {
+ // Random DS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ if ((_proof[0] != "L") || (_proof[1] != "P") || (uint8(_proof[2]) != uint8(1))) {
+ return 1;
+ }
bool proofVerified = provable_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), provable_getNetworkName());
- if (proofVerified == false) return 2;
-
+ if (!proofVerified) {
+ return 2;
+ }
return 0;
}
- function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
+ function matchBytes32Prefix(
+ bytes32 _content,
+ bytes memory _prefix,
+ uint256 _nRandomBytes
+ )
+ internal
+ pure
+ returns (bool _matchesPrefix)
+ {
bool match_ = true;
-
- require(prefix.length == n_random_bytes);
-
- for (uint256 i=0; i< n_random_bytes; i++) {
- if (content[i] != prefix[i]) match_ = false;
+ require(_prefix.length == _nRandomBytes);
+ for (uint256 i = 0; i < _nRandomBytes; i++) {
+ if (_content[i] != _prefix[i]) {
+ match_ = false;
+ }
}
-
return match_;
}
- function provable_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)
- uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
+ function provable_randomDS_proofVerify__main(
+ bytes memory _proof,
+ bytes32 _queryId,
+ bytes memory _result,
+ string memory _contextName
+ )
+ internal
+ returns (bool _proofVerified)
+ {
+ // Random DS Proof Step 2: The unique keyhash has to match with the sha256 of (context name + _queryId)
+ uint256 ledgerProofLength = 3 + 65 + (uint(uint8(_proof[3 + 65 + 1])) + 2) + 32;
bytes memory keyhash = new bytes(32);
- copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
- if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
-
- bytes memory sig1 = new bytes(uint(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, uint(proof[ledgerProofLength+32+8]))) return false;
-
- // Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
+ copyBytes(_proof, ledgerProofLength, 32, keyhash, 0);
+ if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(_contextName, _queryId)))))) {
+ return false;
+ }
+ bytes memory sig1 = new bytes(uint(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
+ copyBytes(_proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);
+ // Random DS Proof 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, uint(uint8(_proof[ledgerProofLength + 32 + 8])))) {
+ return false;
+ }
+ // Random DS Proof Step 4: Commitment match verification, keccak256(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 commitmentSlice1 = new bytes(8 + 1 + 32);
+ copyBytes(_proof, ledgerProofLength + 32, 8 + 1 + 32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
- uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
- copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
-
+ uint256 sig2offset = ledgerProofLength + 32 + (8 + 1 + 32) + sig1.length + 65;
+ copyBytes(_proof, sig2offset - 64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
- if (provable_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){ //unonce, nbytes and sessionKeyHash match
- delete provable_randomDS_args[queryId];
+ if (provable_randomDS_args[_queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))) { //unonce, nbytes and sessionKeyHash match
+ delete provable_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 (provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
- provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = provable_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
+ // Random DS Proof 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 (!provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash]) {
+ provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = provable_randomDS_proofVerify__sessionKeyValidity(_proof, sig2offset);
}
-
return provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
- // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
- function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
+ function copyBytes(
+ bytes from,
+ uint fromOffset,
+ uint length,
+ bytes to,
+ uint toOffset
+ )
+ internal
+ pure
+ returns (bytes)
+ {
uint minLength = length + toOffset;
// Buffer too small
@@ -1161,9 +5287,17 @@ contract usingProvable {
return to;
}
- // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
// Duplicate Solidity's ecrecover, but catching the CALL return value
- function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
+ 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
@@ -1189,15 +5323,20 @@ contract usingProvable {
return (ret, addr);
}
-
- // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
- function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
+ // the following function has been written by Alex Beregszaszi (axic), use it under the terms of the MIT license
+ function ecrecovery(
+ bytes32 hash,
+ bytes sig
+ )
+ internal
+ returns (bool, address)
+ {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
- return (false, 0);
+ return (false, 0);
// The signature format is a compact form of:
// {bytes32 r}{bytes32 s}{uint8 v}
@@ -1223,7 +5362,7 @@ contract usingProvable {
// 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;
+ v += 27;
if (v != 27 && v != 28)
return (false, 0);
@@ -1231,12 +5370,14 @@ contract usingProvable {
return safer_ecrecover(hash, v, r, s);
}
- function safeMemoryCleaner() internal pure {
+ function safeMemoryCleaner()
+ internal
+ pure
+ {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
-
}
-//
+//
diff --git a/provableAPI_0.5.sol b/provableAPI_0.5.sol
index 5dfc47e..4fa6e0e 100644
--- a/provableAPI_0.5.sol
+++ b/provableAPI_0.5.sol
@@ -1,95 +1,390 @@
-//
-/*
-
-
-Copyright (c) 2015-2016 Oraclize SRL
-Copyright (c) 2016-2019 Oraclize LTD
-Copyright (c) 2019 Provable Things Limited
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-*/
+/**
+ *
+ * PROVABLE_API
+ *
+ * Copyright (c) 2015-2016 Oraclize SRL
+ * Copyright (c) 2016-2019 Oraclize LTD
+ * Copyright (c) 2019 Provable Things Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
pragma solidity >= 0.5.0 < 0.6.0; // Incompatible compiler version - please select a compiler within the stated pragma range, or use a different version of the provableAPI!
-
-// Dummy contract only used to emit to end-user they are using wrong solc
+/**
+ *
+ * @notice The following is a dummy contract that is only used to emit a
+ * notification to the end-user they are using wrong solidity
+ * compiler version.
+ *
+ */
contract solcChecker {
-/* INCOMPATIBLE SOLC: import the following instead: "github.com/oraclize/ethereum-api/oraclizeAPI_0.4.sol" */ function f(bytes calldata x) external;
+/* INCOMPATIBLE SOLC: import the following instead: "github.com/provable-things/ethereum-api/oraclizeAPI_0.4.sol" */ function f(bytes calldata x) external;
}
contract ProvableI {
address public cbAddress;
-
- function setProofType(byte _proofType) external;
- function setCustomGasPrice(uint _gasPrice) external;
- function getPrice(string memory _datasource) public returns (uint _dsprice);
- function randomDS_getSessionPubKeyHash() external view returns (bytes32 _sessionKeyHash);
- function getPrice(string memory _datasource, uint _gasLimit) public returns (uint _dsprice);
- function queryN(uint _timestamp, string memory _datasource, bytes memory _argN) public payable returns (bytes32 _id);
- function query(uint _timestamp, string calldata _datasource, string calldata _arg) external payable returns (bytes32 _id);
- function query2(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2) public payable returns (bytes32 _id);
- function query_withGasLimit(uint _timestamp, string calldata _datasource, string calldata _arg, uint _gasLimit) external payable returns (bytes32 _id);
- function queryN_withGasLimit(uint _timestamp, string calldata _datasource, bytes calldata _argN, uint _gasLimit) external payable returns (bytes32 _id);
- function query2_withGasLimit(uint _timestamp, string calldata _datasource, string calldata _arg1, string calldata _arg2, uint _gasLimit) external payable returns (bytes32 _id);
+ mapping (bytes32 => uint256) public price;
+ mapping (address => address) public addressCustomPaymentToken;
+
+ function unsetCustomTokenPayment()
+ external;
+
+ function convertToERC20Price(
+ uint256 _queryPriceInWei,
+ address _tokenAddress
+ )
+ public
+ view
+ returns(uint256 _price);
+
+ function queryCached()
+ payable
+ external
+ returns (bytes32 _queryId);
+
+ function randomDS_getSessionPubKeyHash()
+ external
+ view
+ returns (bytes32 _sessionKeyHash);
+
+ function setProofType(
+ byte _proofType
+ )
+ external;
+
+ function setCustomGasPrice(
+ uint256 _gasPrice
+ )
+ external;
+
+ function requestQueryCaching(
+ bytes32 _queryId
+ )
+ external;
+
+ function setCustomTokenPayment(
+ address _tokenAddress
+ )
+ external;
+
+ function getPrice(
+ bytes1 _datasource
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+
+ function getPrice(
+ bytes1 _datasource,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ bytes1 _datasource,
+ uint256 _gasLimit
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ payable
+ external;
+
+ function queryN(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes memory _argN
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function getPrice(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ public
+ pure
+ returns (uint256 _rebroadcastCost);
+
+ function query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes memory _argN
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _contractToQuery
+ )
+ public
+ view
+ returns (uint256 _dsprice);
+
+ function query(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function query2(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ public
+ payable
+ returns (bytes32 _id);
+
+ function query_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes calldata _argN,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function queryN_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ bytes calldata _argN,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2_withGasLimit(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string calldata _arg1,
+ string calldata _arg2,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
+
+ function query2_withGasLimit(
+ uint256 _timestamp,
+ string calldata _datasource,
+ string calldata _arg1,
+ string calldata _arg2,
+ uint256 _gasLimit
+ )
+ external
+ payable
+ returns (bytes32 _id);
}
-contract OracleAddrResolverI {
- function getAddress() public returns (address _address);
-}
-/*
-
-Begin solidity-cborutils
+interface ERC20Interface {
+
+ event Transfer(
+ address indexed _from,
+ address indexed _to,
+ uint256 tokens
+ );
+
+ event Approval(
+ address indexed _tokenOwner,
+ address indexed _spender,
+ uint256 tokens
+ );
+
+ function totalSupply()
+ external
+ view
+ returns (uint256);
+
+ function transfer(
+ address _to,
+ uint256 _tokens
+ )
+ external
+ returns (bool _success);
+
+ function balanceOf(
+ address _tokenOwner
+ )
+ external
+ view
+ returns (uint256 _balance);
+
+ function approve(
+ address _tokenSpender,
+ uint256 _tokenAmount
+ )
+ external
+ returns (bool);
+
+ function transferFrom(
+ address _from,
+ address _to,
+ uint256 _tokens
+ )
+ external
+ returns (bool _success);
+
+ function allowance(
+ address _tokenOwner,
+ address _spender
+ )
+ external
+ view
+ returns (uint256 _remaining);
-https://github.com/smartcontractkit/solidity-cborutils
-
-MIT License
-
-Copyright (c) 2018 SmartContract ChainLink, Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+}
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+contract OracleAddrResolverI {
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+ function getAddress() public returns (address _address);
-*/
+}
+/**
+ *
+ * Begin solidity-cborutils
+ *
+ * https://github.com/smartcontractkit/solidity-cborutils
+ *
+ * MIT License
+ *
+ * Copyright (c) 2018 SmartContract ChainLink, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
library Buffer {
struct buffer {
bytes buf;
- uint capacity;
+ uint256 capacity;
}
- function init(buffer memory _buf, uint _capacity) internal pure {
- uint capacity = _capacity;
+ function init(buffer memory _buf, uint256 _capacity) internal pure {
+ uint256 capacity = _capacity;
if (capacity % 32 != 0) {
capacity += 32 - (capacity % 32);
}
@@ -102,33 +397,40 @@ library Buffer {
}
}
- function resize(buffer memory _buf, uint _capacity) private pure {
+ function resize(buffer memory _buf, uint256 _capacity) private pure {
bytes memory oldbuf = _buf.buf;
init(_buf, _capacity);
append(_buf, oldbuf);
}
- function max(uint _a, uint _b) private pure returns (uint _max) {
+ function max(uint256 _a, uint256 _b) private pure returns (uint256 _max) {
if (_a > _b) {
return _a;
}
return _b;
}
/**
- * @dev Appends a byte array to the end of the buffer. Resizes if doing so
- * would exceed the capacity of the buffer.
- * @param _buf The buffer to append to.
- * @param _data The data to append.
- * @return The original buffer.
- *
- */
- function append(buffer memory _buf, bytes memory _data) internal pure returns (buffer memory _buffer) {
+ * @dev Appends a byte array to the end of the buffer. Resizes if doing so
+ * would exceed the capacity of the buffer.
+ * @param _buf The buffer to append to.
+ * @param _data The data to append.
+ * @return The original buffer.
+ *
+ */
+ function append(
+ buffer memory _buf,
+ bytes memory _data
+ )
+ internal
+ pure
+ returns (buffer memory _buffer)
+ {
if (_data.length + _buf.buf.length > _buf.capacity) {
resize(_buf, max(_buf.capacity, _data.length) * 2);
}
- uint dest;
- uint src;
- uint len = _data.length;
+ uint256 dest;
+ uint256 src;
+ uint256 len = _data.length;
assembly {
let bufptr := mload(_buf) // Memory address of the buffer data
let buflen := mload(bufptr) // Length of existing buffer data
@@ -143,7 +445,7 @@ library Buffer {
dest += 32;
src += 32;
}
- uint mask = 256 ** (32 - len) - 1; // Copy remaining bytes
+ uint256 mask = 256 ** (32 - len) - 1; // Copy remaining bytes
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
@@ -181,11 +483,19 @@ library Buffer {
* @return The original buffer.
*
*/
- function appendInt(buffer memory _buf, uint _data, uint _len) internal pure returns (buffer memory _buffer) {
+ function appendInt(
+ buffer memory _buf,
+ uint256 _data,
+ uint256 _len
+ )
+ internal
+ pure
+ returns (buffer memory _buffer)
+ {
if (_len + _buf.buf.length > _buf.capacity) {
resize(_buf, max(_buf.capacity, _len) * 2);
}
- uint mask = 256 ** _len - 1;
+ uint256 mask = 256 ** _len - 1;
assembly {
let bufptr := mload(_buf) // Memory address of the buffer data
let buflen := mload(bufptr) // Length of existing buffer data
@@ -209,7 +519,14 @@ library CBOR {
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
- function encodeType(Buffer.buffer memory _buf, uint8 _major, uint _value) private pure {
+ function encodeType(
+ Buffer.buffer memory _buf,
+ uint8 _major,
+ uint256 _value
+ )
+ private
+ pure
+ {
if (_value <= 23) {
_buf.append(uint8((_major << 5) | _value));
} else if (_value <= 0xFF) {
@@ -227,49 +544,90 @@ library CBOR {
}
}
- function encodeIndefiniteLengthType(Buffer.buffer memory _buf, uint8 _major) private pure {
+ function encodeIndefiniteLengthType(
+ Buffer.buffer memory _buf,
+ uint8 _major
+ )
+ private
+ pure
+ {
_buf.append(uint8((_major << 5) | 31));
}
- function encodeUInt(Buffer.buffer memory _buf, uint _value) internal pure {
+ function encodeUInt(
+ Buffer.buffer memory _buf,
+ uint256 _value
+ )
+ internal
+ pure
+ {
encodeType(_buf, MAJOR_TYPE_INT, _value);
}
- function encodeInt(Buffer.buffer memory _buf, int _value) internal pure {
+ function encodeInt(
+ Buffer.buffer memory _buf,
+ int _value
+ )
+ internal
+ pure
+ {
if (_value >= 0) {
- encodeType(_buf, MAJOR_TYPE_INT, uint(_value));
+ encodeType(_buf, MAJOR_TYPE_INT, uint256(_value));
} else {
- encodeType(_buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - _value));
+ encodeType(_buf, MAJOR_TYPE_NEGATIVE_INT, uint256(-1 - _value));
}
}
- function encodeBytes(Buffer.buffer memory _buf, bytes memory _value) internal pure {
+ function encodeBytes(
+ Buffer.buffer memory _buf,
+ bytes memory _value
+ )
+ internal
+ pure
+ {
encodeType(_buf, MAJOR_TYPE_BYTES, _value.length);
_buf.append(_value);
}
- function encodeString(Buffer.buffer memory _buf, string memory _value) internal pure {
+ function encodeString(
+ Buffer.buffer memory _buf,
+ string memory _value
+ )
+ internal
+ pure
+ {
encodeType(_buf, MAJOR_TYPE_STRING, bytes(_value).length);
_buf.append(bytes(_value));
}
- function startArray(Buffer.buffer memory _buf) internal pure {
+ function startArray(
+ Buffer.buffer memory _buf
+ )
+ internal
+ pure
+ {
encodeIndefiniteLengthType(_buf, MAJOR_TYPE_ARRAY);
}
- function startMap(Buffer.buffer memory _buf) internal pure {
+ function startMap(Buffer.buffer memory _buf)
+ internal
+ pure
+ {
encodeIndefiniteLengthType(_buf, MAJOR_TYPE_MAP);
}
- function endSequence(Buffer.buffer memory _buf) internal pure {
+ function endSequence(Buffer.buffer memory _buf)
+ internal
+ pure
+ {
encodeIndefiniteLengthType(_buf, MAJOR_TYPE_CONTENT_FREE);
}
}
-/*
-
-End solidity-cborutils
-
-*/
+/**
+ *
+ * End solidity-cborutils
+ *
+ */
contract usingProvable {
using CBOR for Buffer.buffer;
@@ -277,9 +635,9 @@ contract usingProvable {
ProvableI provable;
OracleAddrResolverI OAR;
- uint constant day = 60 * 60 * 24;
- uint constant week = 60 * 60 * 24 * 7;
- uint constant month = 60 * 60 * 24 * 30;
+ uint256 constant day = 60 * 60 * 24;
+ uint256 constant week = 60 * 60 * 24 * 7;
+ uint256 constant month = 60 * 60 * 24 * 30;
byte constant proofType_NONE = 0x00;
byte constant proofType_Ledger = 0x30;
@@ -302,542 +660,5165 @@ contract usingProvable {
if ((address(OAR) == address(0)) || (getCodeSize(address(OAR)) == 0)) {
provable_setNetwork(networkID_auto);
}
- if (address(provable) != OAR.getAddress()) {
- provable = ProvableI(OAR.getAddress());
+ address provableConnector = OAR.getAddress();
+ if (address(provable) != provableConnector) {
+ provable = ProvableI(provableConnector);
}
+
+ _;
+ }
+
+ modifier provable_randomDS_proofVerify (
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ {
+ // Note: RandomDS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ require(
+ (_proof[0] == "L") &&
+ (_proof[1] == "P") &&
+ (uint8(_proof[2]) == uint8(1))
+ );
+ bool proofVerified = provable_randomDS_proofVerify__main(
+ _proof,
+ _queryId,
+ bytes(_result),
+ provable_getNetworkName()
+ );
+ require(proofVerified);
_;
}
-
- modifier provable_randomDS_proofVerify(bytes32 _queryId, string memory _result, bytes memory _proof) {
- // RandomDS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
- require((_proof[0] == "L") && (_proof[1] == "P") && (uint8(_proof[2]) == uint8(1)));
- bool proofVerified = provable_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), provable_getNetworkName());
- require(proofVerified);
- _;
+
+ function provable_setNetwork(
+ uint8 _networkID
+ )
+ internal
+ returns (bool _networkSet)
+ {
+ _networkID; // NOTE: Silence the warning and remain backwards compatible
+ return provable_setNetwork();
+ }
+
+ function provable_setNetworkName(
+ string memory _network_name
+ )
+ internal
+ {
+ provable_network_name = _network_name;
+ }
+
+ function provable_getNetworkName()
+ internal
+ view
+ returns (string memory _networkName)
+ {
+ return provable_network_name;
+ }
+
+ function provable_setNetwork()
+ internal
+ returns (bool _networkSet)
+ {
+ // Note: Mainnet...
+ if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed) > 0) {
+ OAR = OracleAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
+ provable_setNetworkName("eth_mainnet");
+ return true;
+ }
+ // Note: Ropsten testnet...
+ if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1) > 0) {
+ OAR = OracleAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
+ provable_setNetworkName("eth_ropsten3");
+ return true;
+ }
+ // Note: Kovan testnet...
+ if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e) > 0) {
+ OAR = OracleAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
+ provable_setNetworkName("eth_kovan");
+ return true;
+ }
+ // Note: Rinkeby testnet...
+ if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48) > 0) {
+ OAR = OracleAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
+ provable_setNetworkName("eth_rinkeby");
+ return true;
+ }
+ // Note: Goerli testnet...
+ if (getCodeSize(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41) > 0) {
+ OAR = OracleAddrResolverI(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41);
+ provable_setNetworkName("eth_goerli");
+ return true;
+ }
+ // Note: Ethereum-bridge testnet...
+ if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475) > 0) {
+ OAR = OracleAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
+ return true;
+ }
+ // Note: Ether.camp ide...
+ if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF) > 0) {
+ OAR = OracleAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
+ return true;
+ }
+ // Note: Browser-solidity...
+ if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA) > 0) {
+ OAR = OracleAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
+ return true;
+ }
+ return false;
+ }
+ /**
+ * @dev The following `__callback` functions are just placeholders ideally
+ * meant to be defined in child contract when proofs are used.
+ * The function bodies simply silence compiler warnings.
+ */
+ function __callback(
+ bytes32 _myid,
+ string memory _result
+ )
+ public
+ {
+ __callback(_myid, _result, new bytes(0));
+ }
+
+ function __callback(
+ bytes32 _myid,
+ string memory _result,
+ bytes memory _proof
+ )
+ public
+ {
+ _myid; _result; _proof;
+ provable_randomDS_args[bytes32(0)] = bytes32(0);
+ }
+ /**
+ *
+ * @notice provable_getPrice(...) overloads follow...
+ *
+ */
+ function provable_getPrice(
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource);
+ }
+
+ function provable_getPrice(
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.getPrice(_datasource, _gasLimit, _contractToQuery);
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+
+ function provable_getPrice(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return _queryPrice += _gasLimit * _gasPrice;
+ }
+ /**
+ *
+ * @notice provable_getPriceERC20(...) overloads follow...
+ *
+ */
+ function provable_getPriceERC20(
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ address _tokenAddress,
+ string memory _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ address _tokenAddress,
+ byte _datasource
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ address _contractToQuery,
+ uint256 _gasLimit,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ return provable.convertToERC20Price(
+ provable.getPrice(_datasource, _gasLimit, _contractToQuery),
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ byte _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ proofType_NONE
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ provable.addressCustomPaymentToken(address(this))
+ );
+ }
+
+ function provable_getPriceERC20(
+ string memory _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+
+ function provable_getPriceERC20(
+ bytes1 _datasource,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ byte _proofType,
+ address _tokenAddress
+ )
+ provableAPI
+ internal
+ returns (uint256 _queryPrice)
+ {
+ _queryPrice = provable.price(
+ keccak256(
+ abi.encodePacked(
+ _datasource,
+ _proofType
+ )
+ )
+ );
+ return provable.convertToERC20Price(
+ _queryPrice + _gasLimit * _gasPrice,
+ _tokenAddress
+ );
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using STRING type datasource follow...
+ *
+ */
+ function provable_query(
+ string memory _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call.value(price)(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic string[] arguments and
+ * a datasource of type STRING follow...
+ *
+ */
+ function provable_query(
+ string memory _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic byte[] arguments and a
+ * datasource of type STRING follow...
+ *
+ */
+ function provable_query(
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic string[] arguments and
+ * a datasource of type BYTES1 follow...
+ *
+ */
+ function provable_query(
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads using dynamic byte[] arguments and a
+ * datasource of type BYTES1 follow...
+ *
+ */
+ function provable_query(
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_query(
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `provable_query` overloads end.
+ *
+ * @notice `provable_token_query` overloads using STRING datasource follow...
+ *
+ */
+ function provable_token_query(
+ string memory _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ 0,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string)",
+ _timestamp,
+ _datasource,
+ _arg
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource,_gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string memory _arg,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query(uint256,bytes1,string,uint256)",
+ 0,
+ _datasource,
+ _arg,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,string,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2(uint256,bytes1,string,string)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ _timestamp,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,string,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string memory _arg1,
+ string memory _arg2,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "query2_withGasLimit(uint256,bytes1,string,string,uint256)",
+ 0,
+ _datasource,
+ _arg1,
+ _arg2,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ string[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = stra2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ 0,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,string,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource);
+ if (price > 1 ether + tx.gasprice * 200000) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN(uint256,bytes1,bytes)",
+ _timestamp,
+ _datasource,
+ args
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ _timestamp,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,string,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[] memory _argN,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ uint256 price = provable.getPrice(_datasource, _gasLimit);
+ if (price > 1 ether + tx.gasprice * _gasLimit) {
+ return 0; // Note: Return 0 due to unexpectedly high price
+ }
+ bytes memory args = ba2cbor(_argN);
+ (bool success, bytes memory returnData) = address(provable)
+ .call(abi.encodeWithSignature(
+ "queryN_withGasLimit(uint256,bytes1,bytes,uint256)",
+ 0,
+ _datasource,
+ args,
+ _gasLimit
+ )
+ );
+ require(success);
+ bytes32 returnValue;
+ assembly { returnValue := mload(add(returnData, 0x20)) }
+ return returnValue;
+ }
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic string[]
+ * arguments and a datasource of type string follow...
+ *
+ */
+ function provable_token_query(
+ string memory _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ string[] memory dynargs = new string[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs);
+ }
+
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
+ }
+
+ function provable_token_query(
+ string memory _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs, _gasLimit);
+ }
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic byte[]
+ * arguments and a datasource of type string follow...
+ *
+ */
+ function provable_token_query(
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_datasource, dynargs);
}
- function provable_setNetwork(uint8 _networkID) internal returns (bool _networkSet) {
- _networkID; // NOTE: Silence the warning and remain backwards compatible
- return provable_setNetwork();
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_setNetworkName(string memory _network_name) internal {
- provable_network_name = _network_name;
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_getNetworkName() internal view returns (string memory _networkName) {
- return provable_network_name;
+ function provable_token_query(
+ string memory _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](1);
+ dynargs[0] = _args[0];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_setNetwork() internal returns (bool _networkSet) {
- if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed) > 0) { //mainnet
- OAR = OracleAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
- provable_setNetworkName("eth_mainnet");
- return true;
- }
- if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1) > 0) { //ropsten testnet
- OAR = OracleAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
- provable_setNetworkName("eth_ropsten3");
- return true;
- }
- if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e) > 0) { //kovan testnet
- OAR = OracleAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
- provable_setNetworkName("eth_kovan");
- return true;
- }
- if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48) > 0) { //rinkeby testnet
- OAR = OracleAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
- provable_setNetworkName("eth_rinkeby");
- return true;
- }
- if (getCodeSize(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41) > 0) { //goerli testnet
- OAR = OracleAddrResolverI(0xa2998EFD205FB9D4B4963aFb70778D6354ad3A41);
- provable_setNetworkName("eth_goerli");
- return true;
- }
- if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475) > 0) { //ethereum-bridge
- OAR = OracleAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
- return true;
- }
- if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF) > 0) { //ether.camp ide
- OAR = OracleAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
- return true;
- }
- if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA) > 0) { //browser-solidity
- OAR = OracleAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
- return true;
- }
- return false;
- }
- /**
- * @dev The following `__callback` functions are just placeholders ideally
- * meant to be defined in child contract when proofs are used.
- * The function bodies simply silence compiler warnings.
- */
- function __callback(bytes32 _myid, string memory _result) public {
- __callback(_myid, _result, new bytes(0));
+ function provable_token_query(
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_datasource, dynargs);
}
- function __callback(bytes32 _myid, string memory _result, bytes memory _proof) public {
- _myid; _result; _proof;
- provable_randomDS_args[bytes32(0)] = bytes32(0);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_getPrice(string memory _datasource) provableAPI internal returns (uint _queryPrice) {
- return provable.getPrice(_datasource);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_getPrice(string memory _datasource, uint _gasLimit) provableAPI internal returns (uint _queryPrice) {
- return provable.getPrice(_datasource, _gasLimit);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](2);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string memory _arg) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return provable.query.value(price)(0, _datasource, _arg);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string memory _arg) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return provable.query.value(price)(_timestamp, _datasource, _arg);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string memory _arg, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource,_gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- return provable.query_withGasLimit.value(price)(_timestamp, _datasource, _arg, _gasLimit);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string memory _arg, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- return provable.query_withGasLimit.value(price)(0, _datasource, _arg, _gasLimit);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
+ bytes[] memory dynargs = new bytes[](3);
+ dynargs[0] = _args[0];
+ dynargs[1] = _args[1];
+ dynargs[2] = _args[2];
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string memory _arg1, string memory _arg2) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return provable.query2.value(price)(0, _datasource, _arg1, _arg2);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- return provable.query2.value(price)(_timestamp, _datasource, _arg1, _arg2);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string memory _arg1, string memory _arg2, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- return provable.query2_withGasLimit.value(price)(_timestamp, _datasource, _arg1, _arg2, _gasLimit);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string memory _arg1, string memory _arg2, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- return provable.query2_withGasLimit.value(price)(0, _datasource, _arg1, _arg2, _gasLimit);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[] memory _argN) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = stra2cbor(_argN);
- return provable.queryN.value(price)(0, _datasource, args);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[] memory _argN) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = stra2cbor(_argN);
- return provable.queryN.value(price)(_timestamp, _datasource, args);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[] memory _argN, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = stra2cbor(_argN);
- return provable.queryN_withGasLimit.value(price)(_timestamp, _datasource, args, _gasLimit);
+ function provable_token_query(
+ uint256 _timestamp,
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[] memory _argN, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = stra2cbor(_argN);
- return provable.queryN_withGasLimit.value(price)(0, _datasource, args, _gasLimit);
+ function provable_token_query(
+ string memory _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_token_query(_datasource, dynargs, _gasLimit);
}
-
- function provable_query(string memory _datasource, string[1] memory _args) provableAPI internal returns (bytes32 _id) {
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic string[]
+ * arguments and a datasource of type bytes1 follow...
+ *
+ */
+ function provable_token_query(
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = _args[0];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[1] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = _args[0];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[1] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = _args[0];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[1] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](1);
dynargs[0] = _args[0];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[2] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[2] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[2] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[2] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[3] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[3] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[3] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[3] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
string[] memory dynargs = new string[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[4] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[4] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[4] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[4] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[5] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[5] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, string[5] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, string[5] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ string[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
- }
-
- function provable_query(string memory _datasource, bytes[] memory _argN) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = ba2cbor(_argN);
- return provable.queryN.value(price)(0, _datasource, args);
- }
-
- function provable_query(uint _timestamp, string memory _datasource, bytes[] memory _argN) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource);
- if (price > 1 ether + tx.gasprice * 200000) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = ba2cbor(_argN);
- return provable.queryN.value(price)(_timestamp, _datasource, args);
- }
-
- function provable_query(uint _timestamp, string memory _datasource, bytes[] memory _argN, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = ba2cbor(_argN);
- return provable.queryN_withGasLimit.value(price)(_timestamp, _datasource, args, _gasLimit);
- }
-
- function provable_query(string memory _datasource, bytes[] memory _argN, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
- uint price = provable.getPrice(_datasource, _gasLimit);
- if (price > 1 ether + tx.gasprice * _gasLimit) {
- return 0; // Unexpectedly high price
- }
- bytes memory args = ba2cbor(_argN);
- return provable.queryN_withGasLimit.value(price)(0, _datasource, args, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
-
- function provable_query(string memory _datasource, bytes[1] memory _args) provableAPI internal returns (bytes32 _id) {
+ /**
+ *
+ * @notice `provable_token_query` overloads using dynamic byte[] arguments
+ * and a datasource of type bytes1 follow...
+ *
+ */
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = _args[0];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[1] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = _args[0];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[1] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = _args[0];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[1] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[1] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = _args[0];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[2] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[2] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[2] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[2] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[2] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[3] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[3] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[3] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[3] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[3] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
dynargs[2] = _args[2];
- return provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[4] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[4] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[4] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[4] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[4] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs, _gasLimit);
+ return provable_token_query(_datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[5] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_datasource, dynargs);
+ return provable_token_query(_datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[5] memory _args) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs);
+ return provable_token_query(_timestamp, _datasource, dynargs);
}
- function provable_query(uint _timestamp, string memory _datasource, bytes[5] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ uint256 _timestamp,
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ 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 provable_query(_timestamp, _datasource, dynargs, _gasLimit);
+ return provable_token_query(_timestamp, _datasource, dynargs, _gasLimit);
}
- function provable_query(string memory _datasource, bytes[5] memory _args, uint _gasLimit) provableAPI internal returns (bytes32 _id) {
+ function provable_token_query(
+ bytes1 _datasource,
+ bytes[5] memory _args,
+ uint256 _gasLimit
+ )
+ provableAPI
+ internal
+ returns (bytes32 _id)
+ {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = _args[0];
dynargs[1] = _args[1];
@@ -846,36 +5827,181 @@ contract usingProvable {
dynargs[4] = _args[4];
return provable_query(_datasource, dynargs, _gasLimit);
}
-
- function provable_setProof(byte _proofP) provableAPI internal {
+ /**
+ *
+ * @notice `provable_token_query` overloads end.
+ *
+ */
+ function provable_setProof(byte _proofP)
+ provableAPI
+ internal
+ {
return provable.setProofType(_proofP);
}
- function provable_cbAddress() provableAPI internal returns (address _callbackAddress) {
+ function provable_cbAddress()
+ provableAPI
+ internal
+ returns (address _callbackAddress)
+ {
return provable.cbAddress();
}
- function getCodeSize(address _addr) view internal returns (uint _size) {
+ function getCodeSize(address _addr)
+ internal
+ view
+ returns (uint256 _size)
+ {
assembly {
_size := extcodesize(_addr)
}
}
- function provable_setCustomGasPrice(uint _gasPrice) provableAPI internal {
+ function provable_setCustomGasPrice(uint256 _gasPrice)
+ provableAPI
+ internal
+ {
return provable.setCustomGasPrice(_gasPrice);
}
- function provable_randomDS_getSessionPubKeyHash() provableAPI internal returns (bytes32 _sessionKeyHash) {
+ function provable_randomDS_getSessionPubKeyHash()
+ provableAPI
+ internal
+ returns (bytes32 _sessionKeyHash)
+ {
return provable.randomDS_getSessionPubKeyHash();
}
- function parseAddr(string memory _a) internal pure returns (address _parsedAddress) {
+ function provable_requestQueryCaching(bytes32 _queryId)
+ provableAPI
+ internal
+ {
+ return provable.requestQueryCaching(_queryId);
+ }
+
+ function provable_queryCached(uint256 _queryPrice)
+ provableAPI
+ internal
+ returns (bytes32 _queryId)
+ {
+ return provable.queryCached.value(_queryPrice)();
+ }
+
+ function provable_getDatasourceByte(
+ string memory _datasourceString
+ )
+ internal
+ pure
+ returns (byte _datasourceByte)
+ {
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('URL'))
+ return 0xFF;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Random'))
+ return 0xFE;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('computation'))
+ return 0xFD;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('WolframAlpha'))
+ return 0xFC;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('IPFS'))
+ return 0xFB;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('nested'))
+ return 0xFA;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('Blockchain'))
+ return 0xF9;
+ if (keccak256(abi.encodePacked(_datasourceString)) == keccak256('swarm'))
+ return 0xF8;
+ return 0x00;
+ }
+
+ function provable_getRebroadcastCost(
+ uint256 _gasLimit,
+ uint256 _gasPrice
+ )
+ provableAPI
+ internal
+ returns(uint256 _rebroadcastCost)
+ {
+ return provable.getRebroadcastCost(_gasLimit, _gasPrice);
+ }
+
+ function provable_requestCallbackRebroadcast(
+ bytes32 _queryId,
+ uint256 _gasLimit,
+ uint256 _gasPrice,
+ uint256 _queryPrice
+ )
+ provableAPI
+ internal
+ {
+ return provable
+ .requestCallbackRebroadcast
+ .value(_queryPrice)
+ (
+ _queryId,
+ _gasLimit,
+ _gasPrice
+ );
+ }
+
+ function provable_setCustomTokenPayment(address _tokenAddress)
+ provableAPI
+ internal
+ {
+ return provable.setCustomTokenPayment(_tokenAddress);
+ }
+
+ function provable_approveTokenAllowance(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ provableAPI
+ internal
+ {
+ ERC20Interface(_tokenAddress)
+ .approve(address(provable), _tokenAmount);
+ }
+
+ function provable_setAndApproveCustomTokenPayment(
+ address _tokenAddress,
+ uint256 _tokenAmount
+ )
+ provableAPI
+ internal
+ {
+ provable_setCustomTokenPayment(_tokenAddress);
+ provable_approveTokenAllowance(_tokenAddress, _tokenAmount);
+ }
+
+ function provable_unsetAndRevokeCustomTokenPayment(address _tokenAddress)
+ provableAPI
+ internal
+ {
+ provable_unsetCustomTokenPayment();
+ provable_approveTokenAllowance(_tokenAddress, 0);
+ }
+
+ function provable_unsetCustomTokenPayment()
+ provableAPI
+ internal
+ {
+ return provable.unsetCustomTokenPayment();
+ }
+ /**
+ *
+ * @notice Provable helper functions follow...
+ *
+ */
+ function parseAddr(string memory _a)
+ internal
+ pure
+ returns (address _parsedAddress)
+ {
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
- for (uint i = 2; i < 2 + 2 * 20; i += 2) {
+ for (uint256 i = 2; i < 2 + 2 * 20; i += 2) {
iaddr *= 256;
b1 = uint160(uint8(tmp[i]));
b2 = uint160(uint8(tmp[i + 1]));
@@ -898,14 +6024,21 @@ contract usingProvable {
return address(iaddr);
}
- function strCompare(string memory _a, string memory _b) internal pure returns (int _returnCode) {
+ function strCompare(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
- uint minLength = a.length;
+ uint256 minLength = a.length;
if (b.length < minLength) {
minLength = b.length;
}
- for (uint i = 0; i < minLength; i ++) {
+ for (uint256 i = 0; i < minLength; i ++) {
if (a[i] < b[i]) {
return -1;
} else if (a[i] > b[i]) {
@@ -921,7 +6054,14 @@ contract usingProvable {
}
}
- function indexOf(string memory _haystack, string memory _needle) internal pure returns (int _returnCode) {
+ function indexOf(
+ string memory _haystack,
+ string memory _needle
+ )
+ internal
+ pure
+ returns (int _returnCode)
+ {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if (h.length < 1 || n.length < 1 || (n.length > h.length)) {
@@ -929,11 +6069,15 @@ contract usingProvable {
} else if (h.length > (2 ** 128 - 1)) {
return -1;
} else {
- uint subindex = 0;
- for (uint i = 0; i < h.length; i++) {
+ 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]) {
+ while(
+ subindex < n.length &&
+ (i + subindex) < h.length &&
+ h[i + subindex] == n[subindex]
+ ) {
subindex++;
}
if (subindex == n.length) {
@@ -945,28 +6089,68 @@ contract usingProvable {
}
}
- function strConcat(string memory _a, string memory _b) internal pure returns (string memory _concatenatedString) {
+ function strConcat(
+ string memory _a,
+ string memory _b
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
return strConcat(_a, _b, "", "", "");
}
- function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory _concatenatedString) {
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
return strConcat(_a, _b, _c, "", "");
}
- function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory _concatenatedString) {
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
return strConcat(_a, _b, _c, _d, "");
}
- function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory _concatenatedString) {
+ function strConcat(
+ string memory _a,
+ string memory _b,
+ string memory _c,
+ string memory _d,
+ string memory _e
+ )
+ internal
+ pure
+ returns (string memory _concatenatedString)
+ {
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);
+ string memory abcde = new string(
+ _ba.length +
+ _bb.length +
+ _bc.length +
+ _bd.length +
+ _be.length
+ );
bytes memory babcde = bytes(abcde);
- uint k = 0;
- uint i = 0;
+ uint256 k = 0;
+ uint256 i = 0;
for (i = 0; i < _ba.length; i++) {
babcde[k++] = _ba[i];
}
@@ -985,24 +6169,41 @@ contract usingProvable {
return string(babcde);
}
- function safeParseInt(string memory _a) internal pure returns (uint _parsedInt) {
+ function safeParseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
return safeParseInt(_a, 0);
}
- function safeParseInt(string memory _a, uint _b) internal pure returns (uint _parsedInt) {
+ function safeParseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
bytes memory bresult = bytes(_a);
- uint mint = 0;
+ uint256 mint = 0;
bool decimals = false;
- for (uint i = 0; i < bresult.length; i++) {
- if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if (
+ (uint256(uint8(bresult[i])) >= 48) &&
+ (uint256(uint8(bresult[i])) <= 57)
+ ) {
if (decimals) {
if (_b == 0) break;
else _b--;
}
mint *= 10;
- mint += uint(uint8(bresult[i])) - 48;
- } else if (uint(uint8(bresult[i])) == 46) {
- require(!decimals, 'More than one decimal encountered in string!');
+ mint += uint256(uint8(bresult[i])) - 48;
+ } else if (uint256(uint8(bresult[i])) == 46) {
+ require(
+ !decimals,
+ 'More than one decimal encountered in string!'
+ );
decimals = true;
} else {
revert("Non-numeral character encountered in string!");
@@ -1014,16 +6215,30 @@ contract usingProvable {
return mint;
}
- function parseInt(string memory _a) internal pure returns (uint _parsedInt) {
+ function parseInt(string memory _a)
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
return parseInt(_a, 0);
}
- function parseInt(string memory _a, uint _b) internal pure returns (uint _parsedInt) {
+ function parseInt(
+ string memory _a,
+ uint256 _b
+ )
+ internal
+ pure
+ returns (uint256 _parsedInt)
+ {
bytes memory bresult = bytes(_a);
- uint mint = 0;
+ uint256 mint = 0;
bool decimals = false;
- for (uint i = 0; i < bresult.length; i++) {
- if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
+ for (uint256 i = 0; i < bresult.length; i++) {
+ if (
+ (uint256(uint8(bresult[i])) >= 48) &&
+ (uint256(uint8(bresult[i])) <= 57)
+ ) {
if (decimals) {
if (_b == 0) {
break;
@@ -1032,8 +6247,8 @@ contract usingProvable {
}
}
mint *= 10;
- mint += uint(uint8(bresult[i])) - 48;
- } else if (uint(uint8(bresult[i])) == 46) {
+ mint += uint256(uint8(bresult[i])) - 48;
+ } else if (uint256(uint8(bresult[i])) == 46) {
decimals = true;
}
}
@@ -1043,18 +6258,22 @@ contract usingProvable {
return mint;
}
- function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
+ function uint2str(uint256 _i)
+ internal
+ pure
+ returns (string memory _uintAsString)
+ {
if (_i == 0) {
return "0";
}
- uint j = _i;
- uint len;
+ uint256 j = _i;
+ uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
- uint k = len - 1;
+ uint256 k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
@@ -1062,33 +6281,52 @@ contract usingProvable {
return string(bstr);
}
- function stra2cbor(string[] memory _arr) internal pure returns (bytes memory _cborEncoding) {
+ function stra2cbor(string[] memory _arr)
+ internal
+ pure
+ returns (bytes memory _cborEncoding)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
- for (uint i = 0; i < _arr.length; i++) {
+ for (uint256 i = 0; i < _arr.length; i++) {
buf.encodeString(_arr[i]);
}
buf.endSequence();
return buf.buf;
}
- function ba2cbor(bytes[] memory _arr) internal pure returns (bytes memory _cborEncoding) {
+ function ba2cbor(bytes[] memory _arr)
+ internal
+ pure
+ returns (bytes memory _cborEncoding)
+ {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
- for (uint i = 0; i < _arr.length; i++) {
+ for (uint256 i = 0; i < _arr.length; i++) {
buf.encodeBytes(_arr[i]);
}
buf.endSequence();
return buf.buf;
}
-
- function provable_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32 _queryId) {
+ /**
+ *
+ * Provable RandomDS Functions
+ *
+ */
+ function provable_newRandomDSQuery(
+ uint256 _delay,
+ uint256 _nbytes,
+ uint256 _customGasLimit
+ )
+ internal
+ returns (bytes32 _queryId)
+ {
require((_nbytes > 0) && (_nbytes <= 32));
- _delay *= 10; // Convert from seconds to ledger timer ticks
+ _delay *= 10; // Note: Convert from seconds to ledger timer ticks
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(uint8(_nbytes));
bytes memory unonce = new bytes(32);
@@ -1096,11 +6334,13 @@ contract usingProvable {
bytes32 sessionKeyHash_bytes32 = provable_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
- /*
- The following variables can be relaxed.
- Check the relaxed random contract at https://github.com/oraclize/ethereum-examples
- for an idea on how to override and replace commit hash variables.
- */
+ /**
+ *
+ * The following variables can be relaxed.
+ * Check the relaxed random contract at https://github.com/provable-things/ethereum-examples
+ * for an idea on how to override and replace commit hash variables.
+ *
+ */
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
@@ -1116,34 +6356,86 @@ contract usingProvable {
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
- mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
- mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
- }
- provable_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
+ mstore8(
+ add(delay_bytes8_left, 0x27),
+ div(x, 0x100000000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x26),
+ div(x, 0x1000000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x25),
+ div(x, 0x10000000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x24),
+ div(x, 0x100000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x23),
+ div(x, 0x1000000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x22),
+ div(x, 0x10000000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x21),
+ div(x, 0x100000000000000000000000000000000000000000000000000)
+ )
+ mstore8(
+ add(delay_bytes8_left, 0x20),
+ div(x, 0x1000000000000000000000000000000000000000000000000)
+ )
+ }
+ provable_randomDS_setCommitment(
+ queryId,
+ keccak256(
+ abi.encodePacked(
+ delay_bytes8_left,
+ args[1],
+ sha256(args[0]),
+ args[2]
+ )
+ )
+ );
return queryId;
}
- function provable_randomDS_setCommitment(bytes32 _queryId, bytes32 _commitment) internal {
+ function provable_randomDS_setCommitment(
+ bytes32 _queryId,
+ bytes32 _commitment
+ )
+ internal
+ {
provable_randomDS_args[_queryId] = _commitment;
}
- function verifySig(bytes32 _tosignh, bytes memory _dersig, bytes memory _pubkey) internal returns (bool _sigVerified) {
+ function verifySig(
+ bytes32 _tosignh,
+ bytes memory _dersig,
+ bytes memory _pubkey
+ )
+ internal
+ returns (bool _sigVerified)
+ {
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
- uint offset = 4 + (uint(uint8(_dersig[3])) - 0x20);
+ uint256 offset = 4 + (uint256(uint8(_dersig[3])) - 0x20);
sigr_ = copyBytes(_dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
- sigs_ = copyBytes(_dersig, offset + (uint(uint8(_dersig[offset - 1])) - 0x20), 32, sigs_, 0);
+ sigs_ = copyBytes(
+ _dersig,
+ offset + (uint256(uint8(_dersig[offset - 1])) - 0x20),
+ 32,
+ sigs_,
+ 0
+ );
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
@@ -1157,10 +6449,22 @@ contract usingProvable {
}
}
- function provable_randomDS_proofVerify__sessionKeyValidity(bytes memory _proof, uint _sig2offset) internal returns (bool _proofVerified) {
+ function provable_randomDS_proofVerify__sessionKeyValidity(
+ bytes memory _proof,
+ uint256 _sig2offset
+ )
+ internal
+ returns (bool _proofVerified)
+ {
bool sigok;
- // Random DS Proof Step 6: Verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
- bytes memory sig2 = new bytes(uint(uint8(_proof[_sig2offset + 1])) + 2);
+ /**
+ *
+ * Note - Random DS Proof Step 6:
+ * Verify the attestation signature, APPKEY1 must sign the sessionKey
+ * from the correct ledger app (CODEHASH)
+ *
+ */
+ bytes memory sig2 = new bytes(uint256(uint8(_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);
@@ -1173,33 +6477,67 @@ contract usingProvable {
if (!sigok) {
return false;
}
- // Random DS Proof Step 7: Verify the APPKEY1 provenance (must be signed by Ledger)
+ /**
+ *
+ * Note - Random DS Proof 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(uint(uint8(_proof[3 + 65 + 1])) + 2);
+ bytes memory sig3 = new bytes(uint256(uint8(_proof[3 + 65 + 1])) + 2);
copyBytes(_proof, 3 + 65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
- function provable_randomDS_proofVerify__returnCode(bytes32 _queryId, string memory _result, bytes memory _proof) internal returns (uint8 _returnCode) {
- // Random DS Proof Step 1: The prefix has to match 'LP\x01' (Ledger Proof version 1)
- if ((_proof[0] != "L") || (_proof[1] != "P") || (uint8(_proof[2]) != uint8(1))) {
+ function provable_randomDS_proofVerify__returnCode(
+ bytes32 _queryId,
+ string memory _result,
+ bytes memory _proof
+ )
+ internal
+ returns (uint8 _returnCode)
+ {
+ /**
+ *
+ * Note - Random DS Proof Step 1:
+ * The prefix has to match 'LP\x01' (Ledger Proof version 1)
+ *
+ */
+ if (
+ (_proof[0] != "L") ||
+ (_proof[1] != "P") ||
+ (uint8(_proof[2]) != uint8(1))
+ ) {
return 1;
}
- bool proofVerified = provable_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), provable_getNetworkName());
+ bool proofVerified = provable_randomDS_proofVerify__main(
+ _proof,
+ _queryId,
+ bytes(_result),
+ provable_getNetworkName()
+ );
if (!proofVerified) {
return 2;
}
return 0;
}
- function matchBytes32Prefix(bytes32 _content, bytes memory _prefix, uint _nRandomBytes) internal pure returns (bool _matchesPrefix) {
+ function matchBytes32Prefix(
+ bytes32 _content,
+ bytes memory _prefix,
+ uint256 _nRandomBytes
+ )
+ internal
+ pure
+ returns (bool _matchesPrefix)
+ {
bool match_ = true;
require(_prefix.length == _nRandomBytes);
- for (uint256 i = 0; i< _nRandomBytes; i++) {
+ for (uint256 i = 0; i < _nRandomBytes; i++) {
if (_content[i] != _prefix[i]) {
match_ = false;
}
@@ -1207,51 +6545,109 @@ contract usingProvable {
return match_;
}
- function provable_randomDS_proofVerify__main(bytes memory _proof, bytes32 _queryId, bytes memory _result, string memory _contextName) internal returns (bool _proofVerified) {
- // Random DS Proof Step 2: The unique keyhash has to match with the sha256 of (context name + _queryId)
- uint ledgerProofLength = 3 + 65 + (uint(uint8(_proof[3 + 65 + 1])) + 2) + 32;
+ function provable_randomDS_proofVerify__main(
+ bytes memory _proof,
+ bytes32 _queryId,
+ bytes memory _result,
+ string memory _contextName
+ )
+ internal
+ returns (bool _proofVerified)
+ {
+ /**
+ *
+ * Note - Random DS Proof Step 2:
+ * The unique keyhash has to match with the sha256 of:
+ * (context name + _queryId)
+ *
+ */
+ uint256 ledgerProofLength = 3 + 65 + (uint256(uint8(_proof[3 + 65 + 1])) + 2) + 32;
bytes memory keyhash = new bytes(32);
copyBytes(_proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(_contextName, _queryId)))))) {
return false;
}
- bytes memory sig1 = new bytes(uint(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
+ bytes memory sig1 = new bytes(uint256(uint8(_proof[ledgerProofLength + (32 + 8 + 1 + 32) + 1])) + 2);
copyBytes(_proof, ledgerProofLength + (32 + 8 + 1 + 32), sig1.length, sig1, 0);
- // Random DS Proof 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, uint(uint8(_proof[ledgerProofLength + 32 + 8])))) {
+ /**
+ *
+ * Note - Random DS Proof 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(uint8(_proof[ledgerProofLength + 32 + 8])))) {
return false;
}
- // Random DS Proof Step 4: Commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
- // This is to verify that the computed args match with the ones specified in the query.
+ /**
+ *
+ * Note - Random DS Proof Step 4:
+ * Commitment match verifying that
+ *
+ * keccak256(
+ * 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);
- uint sig2offset = ledgerProofLength + 32 + (8 + 1 + 32) + sig1.length + 65;
+ uint256 sig2offset = ledgerProofLength + 32 + (8 + 1 + 32) + sig1.length + 65;
copyBytes(_proof, sig2offset - 64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (provable_randomDS_args[_queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))) { //unonce, nbytes and sessionKeyHash match
delete provable_randomDS_args[_queryId];
} else return false;
- // Random DS Proof Step 5: Validity verification for sig1 (keyhash and args signed with the sessionKey)
+ /**
+ *
+ * Note - Random DS Proof 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!
+ /**
+ *
+ * Note: Verify if sessionPubkeyHash was verified already, if not...
+ * let's do it!
+ *
+ */
if (!provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash]) {
provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = provable_randomDS_proofVerify__sessionKeyValidity(_proof, sig2offset);
}
return provable_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
- /*
- The following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
- */
- function copyBytes(bytes memory _from, uint _fromOffset, uint _length, bytes memory _to, uint _toOffset) internal pure returns (bytes memory _copiedBytes) {
- uint minLength = _length + _toOffset;
- require(_to.length >= minLength); // Buffer too small. Should be a better way?
- uint i = 32 + _fromOffset; // NOTE: the offset 32 is added to skip the `size` field of both bytes variables
- uint j = 32 + _toOffset;
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ *
+ */
+ function copyBytes(
+ bytes memory _from,
+ uint256 _fromOffset,
+ uint256 _length,
+ bytes memory _to,
+ uint256 _toOffset
+ )
+ internal
+ pure
+ returns (bytes memory _copiedBytes)
+ {
+ uint256 minLength = _length + _toOffset;
+ require(_to.length >= minLength); // Note: Buffer too small. Should be a better way?
+ uint256 i = 32 + _fromOffset; // Note: the offset 32 is added to skip the `size` field of both bytes variables
+ uint256 j = 32 + _toOffset;
while (i < (32 + _fromOffset + _length)) {
assembly {
let tmp := mload(add(_from, i))
@@ -1262,19 +6658,32 @@ contract usingProvable {
}
return _to;
}
- /*
- The following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
- Duplicate Solidity's ecrecover, but catching the CALL return value
- */
- function safer_ecrecover(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) internal returns (bool _success, address _recoveredAddress) {
- /*
- 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
- */
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ * It duplicates Solidity's ecrecover, but catching the CALL return value
+ *
+ */
+ function safer_ecrecover(
+ bytes32 _hash,
+ uint8 _v,
+ bytes32 _r,
+ bytes32 _s
+ )
+ internal
+ returns (bool _success, address _recoveredAddress)
+ {
+ /**
+ *
+ * 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 {
@@ -1288,43 +6697,60 @@ contract usingProvable {
}
return (ret, addr);
}
- /*
- The following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
- */
- function ecrecovery(bytes32 _hash, bytes memory _sig) internal returns (bool _success, address _recoveredAddress) {
+ /**
+ *
+ * The following function has been written by Alex Beregszaszi (axic)
+ * Use it under the terms of the MIT license
+ *
+ */
+ function ecrecovery(
+ bytes32 _hash,
+ bytes memory _sig
+ )
+ internal
+ returns (bool _success, address _recoveredAddress)
+ {
bytes32 r;
bytes32 s;
uint8 v;
if (_sig.length != 65) {
return (false, address(0));
}
- /*
- The signature format is a compact form of:
- {bytes32 r}{bytes32 s}{uint8 v}
- Compact means, uint8 is not padded to 32 bytes.
- */
+ /**
+ *
+ * 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.
- */
+ /**
+ *
+ * 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
- */
+ /**
+ *
+ * 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;
}
@@ -1334,11 +6760,18 @@ contract usingProvable {
return safer_ecrecover(_hash, v, r, s);
}
- function safeMemoryCleaner() internal pure {
+ function safeMemoryCleaner()
+ internal
+ pure
+ {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
-//
+/**
+ *
+ * END PROVABLE_API
+ *
+ */