mirror of
https://github.com/status-im/github-oracle.git
synced 2026-08-31 03:41:16 +00:00
522 lines
22 KiB
Solidity
522 lines
22 KiB
Solidity
// <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.4.0;//please import oraclizeAPI_pre0.4.sol when solidity < 0.4.0
|
|
|
|
contract OraclizeI {
|
|
address public cbAddress;
|
|
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
|
|
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
|
|
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
|
|
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
|
|
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
|
|
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
|
|
function getPrice(string _datasource) returns (uint _dsprice);
|
|
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
|
|
function useCoupon(string _coupon);
|
|
function setProofType(byte _proofType);
|
|
function setConfig(bytes32 _config);
|
|
function setCustomGasPrice(uint _gasPrice);
|
|
}
|
|
contract OraclizeAddrResolverI {
|
|
function getAddress() returns (address _addr);
|
|
}
|
|
contract usingOraclize {
|
|
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 proofStorage_IPFS = 0x01;
|
|
uint8 constant networkID_auto = 0;
|
|
uint8 constant networkID_mainnet = 1;
|
|
uint8 constant networkID_testnet = 2;
|
|
uint8 constant networkID_morden = 2;
|
|
uint8 constant networkID_consensys = 161;
|
|
|
|
OraclizeAddrResolverI OAR;
|
|
|
|
OraclizeI oraclize;
|
|
modifier oraclizeAPI {
|
|
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
|
|
oraclize = OraclizeI(OAR.getAddress());
|
|
_;
|
|
}
|
|
modifier coupon(string code){
|
|
oraclize = OraclizeI(OAR.getAddress());
|
|
oraclize.useCoupon(code);
|
|
_;
|
|
}
|
|
|
|
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
|
|
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
|
|
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
|
|
return true;
|
|
}
|
|
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet
|
|
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
|
|
return true;
|
|
}
|
|
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet
|
|
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
|
|
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;
|
|
}
|
|
|
|
function __callback(bytes32 myid, string result) {
|
|
__callback(myid, result, new bytes(0));
|
|
}
|
|
function __callback(bytes32 myid, string result, bytes proof) {
|
|
}
|
|
|
|
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
|
|
return oraclize.getPrice(datasource);
|
|
}
|
|
|
|
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
|
|
return oraclize.getPrice(datasource, gaslimit);
|
|
}
|
|
|
|
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
|
|
return oraclize.query.value(price)(0, datasource, arg);
|
|
}
|
|
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
|
|
return oraclize.query.value(price)(timestamp, datasource, arg);
|
|
}
|
|
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
|
|
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
|
|
}
|
|
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
|
|
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
|
|
}
|
|
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
|
|
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){
|
|
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 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.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
|
|
}
|
|
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
|
|
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
|
|
}
|
|
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
|
|
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){
|
|
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 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.value(price)(timestamp, datasource, args, gaslimit);
|
|
}
|
|
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
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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 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, 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_query(timestamp, datasource, dynargs);
|
|
}
|
|
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];
|
|
dynargs[2] = args[2];
|
|
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) {
|
|
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 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, 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_query(timestamp, datasource, dynargs);
|
|
}
|
|
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];
|
|
dynargs[2] = args[2];
|
|
dynargs[3] = args[3];
|
|
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) {
|
|
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_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 {
|
|
return oraclize.setCustomGasPrice(gasPrice);
|
|
}
|
|
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
|
|
return oraclize.setConfig(config);
|
|
}
|
|
|
|
function getCodeSize(address _addr) constant internal returns(uint _size) {
|
|
assembly {
|
|
_size := extcodesize(_addr)
|
|
}
|
|
}
|
|
|
|
function parseAddr(string _a) internal returns (address){
|
|
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(tmp[i]);
|
|
b2 = uint160(tmp[i+1]);
|
|
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
|
|
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
|
|
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
|
|
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
|
|
iaddr += (b1*16+b2);
|
|
}
|
|
return address(iaddr);
|
|
}
|
|
|
|
function strCompare(string _a, string _b) internal returns (int) {
|
|
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 _haystack, string _needle) internal returns (int) {
|
|
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 _a, string _b, string _c, string _d, string _e) internal returns (string) {
|
|
bytes memory _ba = bytes(_a);
|
|
bytes memory _bb = bytes(_b);
|
|
bytes memory _bc = bytes(_c);
|
|
bytes memory _bd = bytes(_d);
|
|
bytes memory _be = bytes(_e);
|
|
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
|
|
bytes memory babcde = bytes(abcde);
|
|
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];
|
|
return string(babcde);
|
|
}
|
|
|
|
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
|
|
return strConcat(_a, _b, _c, _d, "");
|
|
}
|
|
|
|
function strConcat(string _a, string _b, string _c) internal returns (string) {
|
|
return strConcat(_a, _b, _c, "", "");
|
|
}
|
|
|
|
function strConcat(string _a, string _b) internal returns (string) {
|
|
return strConcat(_a, _b, "", "", "");
|
|
}
|
|
|
|
// parseInt
|
|
function parseInt(string _a) internal returns (uint) {
|
|
return parseInt(_a, 0);
|
|
}
|
|
|
|
// parseInt(parseFloat*10^_b)
|
|
function parseInt(string _a, uint _b) internal returns (uint) {
|
|
bytes memory bresult = bytes(_a);
|
|
uint mint = 0;
|
|
bool decimals = false;
|
|
for (uint i=0; i<bresult.length; i++){
|
|
if ((bresult[i] >= 48)&&(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;
|
|
}
|
|
if (_b > 0) mint *= 10**_b;
|
|
return mint;
|
|
}
|
|
|
|
function uint2str(uint i) internal returns (string){
|
|
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(48 + i % 10);
|
|
i /= 10;
|
|
}
|
|
return string(bstr);
|
|
}
|
|
|
|
function stra2cbor(string[] arr) internal returns (bytes) {
|
|
uint arrlen = arr.length;
|
|
|
|
// get correct cbor output length
|
|
uint outputlen = 0;
|
|
bytes[] memory elemArray = new bytes[](arrlen);
|
|
for (uint i = 0; i < arrlen; i++) {
|
|
elemArray[i] = (bytes(arr[i]));
|
|
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
|
|
}
|
|
uint ctr = 0;
|
|
uint cborlen = arrlen + 0x80;
|
|
outputlen += byte(cborlen).length;
|
|
bytes memory res = new bytes(outputlen);
|
|
|
|
while (byte(cborlen).length > ctr) {
|
|
res[ctr] = byte(cborlen)[ctr];
|
|
ctr++;
|
|
}
|
|
for (i = 0; i < arrlen; i++) {
|
|
res[ctr] = 0x5F;
|
|
ctr++;
|
|
for (uint x = 0; x < elemArray[i].length; x++) {
|
|
// if there's a bug with larger strings, this may be the culprit
|
|
if (x % 23 == 0) {
|
|
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
|
|
elemcborlen += 0x40;
|
|
uint lctr = ctr;
|
|
while (byte(elemcborlen).length > ctr - lctr) {
|
|
res[ctr] = byte(elemcborlen)[ctr - lctr];
|
|
ctr++;
|
|
}
|
|
}
|
|
res[ctr] = elemArray[i][x];
|
|
ctr++;
|
|
}
|
|
res[ctr] = 0xFF;
|
|
ctr++;
|
|
}
|
|
return res;
|
|
}
|
|
}
|
|
// </ORACLIZE_API>
|