jl777
9 years ago
19 changed files with 725 additions and 317 deletions
@ -0,0 +1,449 @@ |
|||
/******************************************************************************
|
|||
* Copyright © 2014-2016 The SuperNET Developers. * |
|||
* * |
|||
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * |
|||
* the top-level directory of this distribution for the individual copyright * |
|||
* holder information and the developer policies on copyright and licensing. * |
|||
* * |
|||
* Unless otherwise agreed in a custom licensing agreement, no part of the * |
|||
* SuperNET software, including this file may be copied, modified, propagated * |
|||
* or distributed except according to the terms contained in the LICENSE file * |
|||
* * |
|||
* Removal or modification of this copyright notice is prohibited. * |
|||
* * |
|||
******************************************************************************/ |
|||
|
|||
// included from basilisk.c
|
|||
|
|||
int32_t basilisk_rwDEXquote(int32_t rwflag,uint8_t *serialized,struct basilisk_request *rp) |
|||
{ |
|||
int32_t len = 0; |
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->crc),&rp->crc); // must be 1st
|
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->timestamp),&rp->timestamp); // must be 2nd
|
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->requestid),&rp->requestid); |
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->quoteid),&rp->quoteid); |
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->srcamount),&rp->srcamount); |
|||
len += iguana_rwnum(rwflag,&serialized[len],sizeof(rp->destamount),&rp->destamount); |
|||
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(rp->hash),rp->hash.bytes); |
|||
len += iguana_rwvarstr(rwflag,&serialized[len],sizeof(rp->src)-1,rp->src); |
|||
len += iguana_rwvarstr(rwflag,&serialized[len],sizeof(rp->src)-1,rp->dest); |
|||
len += iguana_rwvarstr(rwflag,&serialized[len],128,rp->message); |
|||
return(len); |
|||
} |
|||
|
|||
int32_t basilisk_request_enqueue(struct supernet_info *myinfo,bits256 hash,char *src,uint64_t srcamount,char *dest,uint64_t destamount,char *message,uint32_t requestid,uint32_t quoteid) |
|||
{ |
|||
uint8_t serialized[256]; int32_t len; struct queueitem *item; struct basilisk_request R; |
|||
memset(&R,0,sizeof(R)); |
|||
R.timestamp = (uint32_t)time(NULL); |
|||
R.hash = hash; |
|||
R.srcamount = srcamount; |
|||
R.destamount = destamount; |
|||
R.requestid = requestid; |
|||
R.quoteid = quoteid; |
|||
strncpy(R.src,src,sizeof(R.src)-1); |
|||
strncpy(R.dest,dest,sizeof(R.dest)-1); |
|||
if ( message != 0 ) |
|||
strncpy(R.message,message,sizeof(R.message)-1); |
|||
R.crc = calc_crc32(0,(void *)((long)&R + sizeof(R.crc)),sizeof(R) - sizeof(R.crc)); |
|||
len = basilisk_rwDEXquote(1,serialized+1,&R); |
|||
serialized[0] = len; |
|||
if ( (item= calloc(1,sizeof(*item) + len + 1)) != 0 ) |
|||
{ |
|||
memcpy(&item[1],serialized,len + 1); |
|||
portable_mutex_lock(&myinfo->DEX_mutex); |
|||
DL_APPEND(myinfo->DEX_quotes,item); |
|||
portable_mutex_unlock(&myinfo->DEX_mutex); |
|||
return(0); |
|||
} |
|||
return(-1); |
|||
} |
|||
|
|||
cJSON *basilisk_requestjson(uint32_t relaybits,struct basilisk_request *rp) |
|||
{ |
|||
char ipaddr[64]; cJSON *item = cJSON_CreateObject(); |
|||
expand_ipbits(ipaddr,relaybits); |
|||
jaddstr(item,"relay",ipaddr); |
|||
jaddbits256(item,"hash",rp->hash); |
|||
jaddstr(item,"src",rp->src); |
|||
if ( rp->srcamount != 0 ) |
|||
jaddnum(item,"srcamount",dstr(rp->srcamount)); |
|||
jaddstr(item,"dest",rp->dest); |
|||
if ( rp->destamount != 0 ) |
|||
jaddnum(item,"destamount",dstr(rp->destamount)); |
|||
jaddnum(item,"timestamp",rp->timestamp); |
|||
jaddnum(item,"requestid",rp->requestid); |
|||
jaddnum(item,"quoteid",rp->quoteid); |
|||
if ( rp->message[0] != 0 ) |
|||
jaddstr(item,"message",rp->message); |
|||
return(item); |
|||
} |
|||
|
|||
struct basilisk_request *basilisk_parsejson(struct basilisk_request *rp,cJSON *reqjson) |
|||
{ |
|||
memset(rp,0,sizeof(*rp)); |
|||
rp->hash = jbits256(reqjson,"hash"); |
|||
rp->srcamount = j64bits(reqjson,"srcamount"); |
|||
rp->destamount = j64bits(reqjson,"destamount"); |
|||
rp->requestid = juint(reqjson,"requestid"); |
|||
rp->quoteid = juint(reqjson,"quoteid"); |
|||
rp->timestamp = juint(reqjson,"timestamp"); |
|||
safecopy(rp->src,jstr(reqjson,"src"),sizeof(rp->src)); |
|||
safecopy(rp->dest,jstr(reqjson,"dest"),sizeof(rp->dest)); |
|||
safecopy(rp->message,jstr(reqjson,"message"),sizeof(rp->message)); |
|||
rp->crc = calc_crc32(0,(void *)((long)rp + sizeof(rp->crc)),sizeof(*rp) - sizeof(rp->crc)); |
|||
return(rp); |
|||
} |
|||
|
|||
char *basilisk_choose(struct supernet_info *myinfo,bits256 hash,struct basilisk_request *other,uint64_t destamount,uint32_t quoteid) |
|||
{ |
|||
cJSON *retjson; |
|||
if ( basilisk_request_enqueue(myinfo,hash,other->src,other->srcamount,other->dest,destamount,"start",other->requestid,quoteid) == 0 ) |
|||
{ |
|||
if ( bits256_cmp(hash,myinfo->myaddr.persistent) == 0 ) |
|||
{ |
|||
printf("START thread to complete %u/%u for (%s %.8f) <- (%s %.8f)\n",other->requestid,quoteid,other->src,dstr(other->srcamount),other->dest,dstr(other->destamount)); |
|||
// other, myinfo->myaddr.persistent, destamount, quoteid
|
|||
return(clonestr("{\"result\":\"started atomic thread\"}")); |
|||
} |
|||
else |
|||
{ |
|||
retjson = cJSON_CreateObject(); |
|||
jaddstr(retjson,"result","need to start atomic thread"); |
|||
jadd(retjson,"other",basilisk_requestjson(myinfo->myaddr.myipbits,other)); |
|||
return(jprint(retjson,1)); |
|||
} |
|||
} else return(clonestr("{\"error\":\"couldnt enqueue chosen\"}")); |
|||
} |
|||
|
|||
struct basilisk_relay *basilisk_request_ensure(struct supernet_info *myinfo,uint32_t senderipbits,int32_t numrequests) |
|||
{ |
|||
int32_t j; struct basilisk_relay *relay = 0; |
|||
if ( (j= basilisk_relayid(myinfo,senderipbits)) >= 0 ) |
|||
{ |
|||
relay = &myinfo->relays[j]; |
|||
if ( numrequests > relay->maxrequests ) |
|||
{ |
|||
relay->maxrequests = numrequests; |
|||
relay->requests = realloc(relay->requests,sizeof(*relay->requests) * numrequests); |
|||
} |
|||
relay->numrequests = 0; |
|||
} |
|||
return(relay); |
|||
} |
|||
|
|||
int32_t basilisk_ping_processDEX(struct supernet_info *myinfo,uint32_t senderipbits,uint8_t *data,int32_t datalen) |
|||
{ |
|||
int32_t i,len=0; struct basilisk_relay *relay; struct basilisk_request R; uint8_t clen,serialized[256]; uint16_t sn; uint32_t crc; |
|||
portable_mutex_lock(&myinfo->DEX_reqmutex); |
|||
len += iguana_rwnum(0,&data[len],sizeof(sn),&sn); |
|||
if ( (relay= basilisk_request_ensure(myinfo,senderipbits,sn)) != 0 ) |
|||
{ |
|||
for (i=0; i<sn; i++) |
|||
{ |
|||
clen = data[len++]; |
|||
if ( len+clen <= datalen ) |
|||
{ |
|||
if ( relay->numrequests < relay->maxrequests ) |
|||
{ |
|||
memcpy(serialized,&data[len],clen); |
|||
len += basilisk_rwDEXquote(0,serialized,&R); |
|||
crc = calc_crc32(0,(void *)((long)&R + sizeof(R.crc)),sizeof(R) - sizeof(R.crc)); |
|||
if ( crc == R.crc ) |
|||
{ |
|||
relay->requests[relay->numrequests++] = R; |
|||
printf("(%s (%s %.8f) -> (%s %.8f) r.%u q.%u) ",R.message,R.src,dstr(R.srcamount),R.dest,dstr(R.destamount),R.requestid,R.quoteid); |
|||
} else printf("crc.%08x error vs %08x\n",crc,R.crc); |
|||
} else printf("relay num.%d >= max.%d\n",relay->numrequests,relay->maxrequests); |
|||
} else len += clen; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
for (i=0; i<sn; i++) |
|||
{ |
|||
if ( len+clen <= datalen ) |
|||
{ |
|||
clen = data[len++]; |
|||
len += clen; |
|||
} |
|||
} |
|||
} |
|||
portable_mutex_unlock(&myinfo->DEX_reqmutex); |
|||
return(len); |
|||
} |
|||
|
|||
int32_t basilisk_ping_genDEX(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen) |
|||
{ |
|||
struct queueitem *item,*tmp; uint8_t clen; int32_t i,datalen = 0; uint16_t sn; uint32_t timestamp,now; |
|||
datalen += sizeof(uint16_t); |
|||
i = 0; |
|||
now = (uint32_t)time(NULL); |
|||
portable_mutex_lock(&myinfo->DEX_mutex); |
|||
DL_FOREACH_SAFE(myinfo->DEX_quotes,item,tmp) |
|||
{ |
|||
memcpy(&clen,&item[1],sizeof(clen)); |
|||
if ( datalen+clen < maxlen ) |
|||
{ |
|||
memcpy(&data[datalen],&item[1],clen+1), datalen += (clen + 1); |
|||
i++; |
|||
} |
|||
iguana_rwnum(0,(void *)((long)&item[1] + 1),sizeof(timestamp),×tamp); |
|||
if ( now > timestamp + BASILISK_DEXDURATION ) |
|||
{ |
|||
DL_DELETE(myinfo->DEX_quotes,item); |
|||
free(item); |
|||
} |
|||
} |
|||
portable_mutex_unlock(&myinfo->DEX_mutex); |
|||
sn = i; |
|||
iguana_rwnum(1,data,sizeof(sn),&sn); // fill in at beginning
|
|||
return(datalen); |
|||
} |
|||
|
|||
char *basilisk_respond_incoming(struct supernet_info *myinfo,bits256 hash,uint32_t requestid,uint32_t quoteid) |
|||
{ |
|||
int32_t i,j,n,k,m; struct basilisk_relay *relay; cJSON *retjson,*array; struct basilisk_request requests[BASILISK_MAXRELAYS],*rp; |
|||
array = cJSON_CreateArray(); |
|||
portable_mutex_lock(&myinfo->DEX_reqmutex); |
|||
for (j=m=0; j<myinfo->numrelays; j++) |
|||
{ |
|||
relay = &myinfo->relays[j]; |
|||
if ( (n= relay->numrequests) > 0 ) |
|||
{ |
|||
for (i=0; i<n; i++) |
|||
{ |
|||
rp = &relay->requests[i]; |
|||
if ( (requestid == 0 || rp->requestid == requestid) && ((quoteid == 0 && rp->quoteid != 0) || quoteid == rp->quoteid) ) |
|||
{ |
|||
for (k=0; k<m; k++) |
|||
if ( memcmp(&requests[k],rp,sizeof(requests[k])) == 0 ) |
|||
break; |
|||
if ( k == m ) |
|||
{ |
|||
requests[m++] = *rp; |
|||
jaddi(array,basilisk_requestjson(relay->ipbits,rp)); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
portable_mutex_unlock(&myinfo->DEX_reqmutex); |
|||
retjson = cJSON_CreateObject(); |
|||
jadd(retjson,"result",array); |
|||
return(jprint(retjson,1)); |
|||
} |
|||
|
|||
char *basilisk_respond_choose(struct supernet_info *myinfo,bits256 hash,uint32_t requestid,uint64_t destamount) |
|||
{ |
|||
int32_t i,n,j,alreadythere = 0; uint32_t quoteid; char *retstr; struct basilisk_relay *relay; struct basilisk_request *rp=0; |
|||
quoteid = (requestid ^ hash.uints[0]); |
|||
portable_mutex_lock(&myinfo->DEX_reqmutex); |
|||
for (j=0; j<myinfo->numrelays; j++) |
|||
{ |
|||
relay = &myinfo->relays[j]; |
|||
if ( (n= relay->numrequests) > 0 ) |
|||
{ |
|||
for (i=0; i<n; i++) |
|||
{ |
|||
if ( relay->requests[i].requestid == requestid ) |
|||
{ |
|||
if ( relay->requests[i].quoteid == 0 ) |
|||
rp = &relay->requests[i]; |
|||
else if ( relay->requests[i].quoteid == quoteid ) |
|||
{ |
|||
alreadythere = 1; |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ( alreadythere != 0 ) |
|||
break; |
|||
} |
|||
if ( alreadythere == 0 ) |
|||
{ |
|||
if ( rp == 0 ) |
|||
retstr = clonestr("{\"error\":\"couldnt find to requestid to choose\"}"); |
|||
else retstr = basilisk_choose(myinfo,hash,rp,destamount,quoteid); |
|||
} else retstr = clonestr("{\"result\":\"quoteid already there\"}"); |
|||
portable_mutex_unlock(&myinfo->DEX_reqmutex); |
|||
return(retstr); |
|||
} |
|||
|
|||
// respond to incoming RID, CHS, DEX, QST
|
|||
|
|||
char *basilisk_respond_RID(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 hash,int32_t from_basilisk) |
|||
{ |
|||
return(basilisk_respond_incoming(myinfo,hash,juint(valsobj,"requestid"),0)); |
|||
} |
|||
|
|||
char *basilisk_respond_QID(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 hash,int32_t from_basilisk) |
|||
{ |
|||
return(basilisk_respond_incoming(myinfo,hash,juint(valsobj,"requestid"),juint(valsobj,"quoteid"))); |
|||
} |
|||
|
|||
char *basilisk_respond_CHS(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 hash,int32_t from_basilisk) |
|||
{ |
|||
uint32_t requestid; uint64_t destamount; |
|||
if ( (requestid= juint(valsobj,"requestid")) != 0 && (destamount= j64bits(valsobj,"destamount")) != 0 ) |
|||
return(basilisk_respond_choose(myinfo,hash,requestid,destamount)); |
|||
return(clonestr("{\"error\":\"need nonzero requestid and quoteid\"}")); |
|||
} |
|||
|
|||
char *basilisk_respond_DEX(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 hash,int32_t from_basilisk) |
|||
{ |
|||
char *dest,*src,*retstr=0,buf[256]; uint32_t zero=0; uint64_t satoshis; |
|||
if ( (dest= jstr(valsobj,"dest")) != 0 && (src= jstr(valsobj,"src")) != 0 && (satoshis= j64bits(valsobj,"satoshis")) != 0 ) |
|||
{ |
|||
char str[65]; printf("DEX.(%s %.8f) -> %s %s\n",src,dstr(satoshis),dest,bits256_str(str,hash)); |
|||
if ( basilisk_request_enqueue(myinfo,hash,src,satoshis,dest,0,jstr(valsobj,"msg"),basilisktag,zero) == 0 ) |
|||
{ |
|||
sprintf(buf,"{\"result\":\"DEX request added\",\"request\":%u}",basilisktag); |
|||
retstr = clonestr(buf); |
|||
} else retstr = clonestr("{\"error\":\"DEX quote couldnt be created\"}"); |
|||
} |
|||
return(retstr); |
|||
} |
|||
|
|||
#include "../includes/iguana_apidefs.h" |
|||
#include "../includes/iguana_apideclares.h" |
|||
|
|||
ZERO_ARGS(InstantDEX,allcoins) |
|||
{ |
|||
struct iguana_info *tmp; cJSON *array,*retjson = cJSON_CreateObject(); |
|||
array = cJSON_CreateArray(); |
|||
HASH_ITER(hh,myinfo->allcoins,coin,tmp) |
|||
{ |
|||
jaddistr(array,coin->symbol); |
|||
} |
|||
jadd(retjson,"coins",array); |
|||
return(jprint(retjson,1)); |
|||
} |
|||
|
|||
STRING_ARG(InstantDEX,available,source) |
|||
{ |
|||
if ( (coin= iguana_coinfind(source)) != 0 ) |
|||
{ |
|||
if ( myinfo->expiration != 0 ) |
|||
return(bitcoinrpc_getbalance(myinfo,coin,json,remoteaddr,"*",coin->chain->minconfirms,1,1<<30)); |
|||
else return(clonestr("{\"error\":\"need to unlock wallet\"}")); |
|||
} else return(clonestr("{\"error\":\"specified coin is not active\"}")); |
|||
} |
|||
|
|||
THREE_STRINGS_AND_DOUBLE(InstantDEX,request,message,dest,source,amount) |
|||
{ |
|||
struct basilisk_request R; char *retstr; cJSON *vals = cJSON_CreateObject(); |
|||
jaddstr(vals,"dest",dest); |
|||
jaddstr(vals,"src",source); |
|||
if ( strlen(message) < sizeof(R.message) ) |
|||
jaddstr(vals,"msg",message); |
|||
jadd64bits(vals,"satoshis",amount * SATOSHIDEN); |
|||
retstr = basilisk_standardservice("DEX",myinfo,0,myinfo->myaddr.persistent,vals,"",1); |
|||
free_json(vals); |
|||
return(retstr); |
|||
} |
|||
|
|||
INT_ARG(InstantDEX,incoming,requestid) |
|||
{ |
|||
cJSON *vals; char *retstr; |
|||
if ( myinfo->RELAYID >= 0 ) |
|||
return(basilisk_respond_incoming(myinfo,myinfo->myaddr.persistent,requestid,0)); |
|||
else |
|||
{ |
|||
vals = cJSON_CreateObject(); |
|||
jaddnum(vals,"requestid",requestid); |
|||
jaddbits256(vals,"hash",myinfo->myaddr.persistent); |
|||
retstr = basilisk_standardservice("RID",myinfo,0,myinfo->myaddr.persistent,vals,"",1); |
|||
free_json(vals); |
|||
return(retstr); |
|||
} |
|||
} |
|||
|
|||
TWO_INTS(InstantDEX,qstatus,requestid,quoteid) |
|||
{ |
|||
cJSON *vals; char *retstr; |
|||
if ( myinfo->RELAYID >= 0 ) |
|||
return(basilisk_respond_incoming(myinfo,myinfo->myaddr.persistent,requestid,quoteid)); |
|||
else |
|||
{ |
|||
vals = cJSON_CreateObject(); |
|||
jaddnum(vals,"quoteid",quoteid); |
|||
jaddbits256(vals,"hash",myinfo->myaddr.persistent); |
|||
retstr = basilisk_standardservice("QST",myinfo,0,myinfo->myaddr.persistent,vals,"",1); |
|||
free_json(vals); |
|||
return(retstr); |
|||
} |
|||
} |
|||
|
|||
INT_AND_DOUBLE(InstantDEX,choose,requestid,destamount) |
|||
{ |
|||
cJSON *vals,*retjson; char *retstr; struct basilisk_request R,*other; uint32_t quoteid; |
|||
if ( myinfo->RELAYID >= 0 ) |
|||
return(basilisk_respond_choose(myinfo,myinfo->myaddr.persistent,requestid,destamount*SATOSHIDEN)); |
|||
else |
|||
{ |
|||
quoteid = (requestid ^ myinfo->myaddr.persistent.uints[0]); |
|||
vals = cJSON_CreateObject(); |
|||
jaddnum(vals,"requestid",requestid); |
|||
jaddnum(vals,"quoteid",quoteid); |
|||
jadd64bits(vals,"destamount",destamount*SATOSHIDEN); |
|||
jaddbits256(vals,"hash",myinfo->myaddr.persistent); |
|||
if ( (retstr= basilisk_standardservice("CHS",myinfo,0,myinfo->myaddr.persistent,vals,"",1)) != 0 ) |
|||
{ |
|||
if ( (retjson= cJSON_Parse(retstr)) != 0 ) |
|||
{ |
|||
other = basilisk_parsejson(&R,jobj(retjson,"other")); |
|||
// other, myinfo->myaddr.persistent, destamount, quoteid
|
|||
printf("START thread to complete %u/%u for (%s %.8f) <- (%s %.8f)\n",other->requestid,quoteid,other->src,dstr(other->srcamount),other->dest,dstr(other->destamount)); |
|||
free(retjson); |
|||
} |
|||
} |
|||
free_json(vals); |
|||
return(retstr); |
|||
} |
|||
} |
|||
|
|||
#include "../includes/iguana_apiundefs.h" |
|||
|
|||
|
|||
int32_t basilisk_request_pending(struct supernet_info *myinfo,struct basilisk_request *rp,uint32_t requestid) |
|||
{ |
|||
int32_t i,j,n,alreadystarted = 0; struct basilisk_relay *relay; uint32_t quoteid; |
|||
quoteid = (requestid ^ myinfo->myaddr.persistent.uints[0]); |
|||
portable_mutex_lock(&myinfo->DEX_reqmutex); |
|||
for (j=0; j<myinfo->numrelays; j++) |
|||
{ |
|||
relay = &myinfo->relays[j]; |
|||
if ( (n= relay->numrequests) > 0 ) |
|||
{ |
|||
for (i=0; i<n; i++) |
|||
{ |
|||
if ( relay->requests[i].requestid == requestid && relay->requests[i].quoteid == quoteid ) |
|||
{ |
|||
alreadystarted = 1; |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
portable_mutex_unlock(&myinfo->DEX_reqmutex); |
|||
return(alreadystarted); |
|||
} |
|||
|
|||
void basilisk_request_check(struct supernet_info *myinfo,struct basilisk_request *rp) |
|||
{ |
|||
double retvals[4],aveprice; struct basilisk_request R; struct iguana_info *src,*dest; char message[128]; uint32_t quoteid; |
|||
if ( (src= iguana_coinfind(rp->src)) != 0 && (dest= iguana_coinfind(rp->dest)) != 0 ) |
|||
{ |
|||
if ( basilisk_request_pending(myinfo,&R,rp->requestid) == 0 ) |
|||
{ |
|||
aveprice = instantdex_avehbla(myinfo,retvals,rp->src,rp->dest,dstr(rp->srcamount)); |
|||
quoteid = rp->requestid ^ myinfo->myaddr.persistent.uints[0]; |
|||
sprintf(message,"{\"price\":%.8f,\"requestid\":%u,\"quoteid\":%u}",aveprice,rp->requestid,quoteid); |
|||
if ( basilisk_request_enqueue(myinfo,myinfo->myaddr.persistent,rp->src,rp->srcamount*aveprice,rp->dest,rp->srcamount*aveprice,message,rp->requestid,quoteid) < 0 ) |
|||
printf("error creating quoteid\n"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,218 @@ |
|||
/******************************************************************************
|
|||
* Copyright © 2014-2016 The SuperNET Developers. * |
|||
* * |
|||
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * |
|||
* the top-level directory of this distribution for the individual copyright * |
|||
* holder information and the developer policies on copyright and licensing. * |
|||
* * |
|||
* Unless otherwise agreed in a custom licensing agreement, no part of the * |
|||
* SuperNET software, including this file may be copied, modified, propagated * |
|||
* or distributed except according to the terms contained in the LICENSE file * |
|||
* * |
|||
* Removal or modification of this copyright notice is prohibited. * |
|||
* * |
|||
******************************************************************************/ |
|||
|
|||
// included from basilisk.c
|
|||
|
|||
int32_t baslisk_relay_report(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen,struct basilisk_relaystatus *reported,uint8_t pingdelay) |
|||
{ |
|||
if ( reported != 0 ) |
|||
{ |
|||
reported->pingdelay = pingdelay; |
|||
} |
|||
return(0); |
|||
} |
|||
|
|||
int32_t basilisk_blocksend(struct supernet_info *myinfo,struct iguana_info *btcd,struct iguana_info *virt,struct iguana_peer *addr,int32_t height) |
|||
{ |
|||
int32_t blocklen; bits256 hash2; uint8_t *data = 0; char str[65],strbuf[8192],*blockstr,*allocptr = 0; struct iguana_block *block; |
|||
hash2 = iguana_blockhash(virt,height); |
|||
if ( (block= iguana_blockfind("bsend",virt,hash2)) != 0 ) |
|||
{ |
|||
if ( block->height != height ) |
|||
{ |
|||
printf("basilisk_blocksend: height.%d mismatch %d\n",block->height,height); |
|||
return(-1); |
|||
} |
|||
else if ( block->queued != 0 && block->req != 0 ) |
|||
{ |
|||
memcpy(&blocklen,block->req,sizeof(blocklen)); |
|||
data = (uint8_t *)(void *)((long)block->req + sizeof(blocklen)); |
|||
} |
|||
} |
|||
if ( data == 0 ) |
|||
{ |
|||
if ( (blocklen= iguana_peerblockrequest(virt,virt->blockspace,IGUANA_MAXPACKETSIZE,0,hash2,0)) > 0 ) |
|||
data = &virt->blockspace[sizeof(struct iguana_msghdr)]; |
|||
} |
|||
if ( data != 0 ) |
|||
{ |
|||
blockstr = basilisk_addhexstr(&allocptr,0,strbuf,sizeof(strbuf),data,blocklen); |
|||
printf("RELAYID.%d send block.%d %s -> (%s) %s\n",myinfo->RELAYID,height,blockstr,addr->ipaddr,bits256_str(str,hash2)); |
|||
basilisk_blocksubmit(myinfo,btcd,virt,addr,blockstr,hash2,height); |
|||
if ( allocptr != 0 ) |
|||
free(allocptr); |
|||
return(0); |
|||
} else printf("blocklen.%d for hwm.%d height.%d %s\n",blocklen,virt->blocks.hwmchain.height,height,bits256_str(str,hash2)); |
|||
return(-1); |
|||
} |
|||
|
|||
int32_t basilisk_ping_processvirts(struct supernet_info *myinfo,struct iguana_info *btcd,struct iguana_peer *addr,uint8_t *data,int32_t datalen) |
|||
{ |
|||
int32_t diff,i,j,len = 0; struct iguana_info *virt; char symbol[7]; uint32_t numvirts,height; |
|||
len += iguana_rwvarint32(0,&data[len],&numvirts); |
|||
symbol[6] = 0; |
|||
for (i=0; i<numvirts; i++) |
|||
{ |
|||
memcpy(symbol,&data[len],6), len += 6; |
|||
len += iguana_rwvarint32(0,&data[len],&height); |
|||
printf("(%s %d).%p ",symbol,height,addr); |
|||
if ( myinfo->numrelays > 0 && addr != 0 && (virt= iguana_coinfind(symbol)) != 0 ) |
|||
{ |
|||
if ( height > virt->longestchain ) |
|||
virt->longestchain = height; |
|||
if ( myinfo->numrelays > 0 && virt->blocks.hwmchain.height > height ) |
|||
{ |
|||
diff = ((height % myinfo->numrelays) - myinfo->RELAYID); |
|||
diff *= diff; |
|||
diff++; |
|||
if ( (rand() % diff) == 0 ) |
|||
{ |
|||
for (j=1; height+j<virt->blocks.hwmchain.height && j<3; j++) |
|||
basilisk_blocksend(myinfo,btcd,virt,addr,height+j); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
return(len); |
|||
} |
|||
|
|||
int32_t basilisk_ping_genvirts(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen) |
|||
{ |
|||
struct iguana_info *virt,*tmpcoin; int32_t iter,datalen = 0; uint32_t n; |
|||
for (iter=n=0; iter<2; iter++) |
|||
{ |
|||
HASH_ITER(hh,myinfo->allcoins,virt,tmpcoin) |
|||
{ |
|||
if ( virt != 0 && virt->virtualchain != 0 ) |
|||
{ |
|||
if ( iter == 0 ) |
|||
n++; |
|||
else |
|||
{ |
|||
memcpy(&data[datalen],virt->symbol,6), datalen += 6; |
|||
datalen += iguana_rwvarint32(1,&data[datalen],(uint32_t *)&virt->blocks.hwmchain.height); |
|||
} |
|||
} |
|||
} |
|||
if ( iter == 0 ) |
|||
datalen += iguana_rwvarint32(1,&data[datalen],&n); |
|||
} |
|||
return(datalen); |
|||
} |
|||
|
|||
int32_t basilisk_ping_genrelay(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen,struct basilisk_relay *rp) |
|||
{ |
|||
int32_t datalen = 0; |
|||
datalen = iguana_rwnum(1,&data[datalen],sizeof(rp->ipbits),&rp->ipbits); |
|||
data[datalen++] = rp->direct.pingdelay; |
|||
return(datalen); |
|||
} |
|||
|
|||
int32_t basilisk_ping_processrelay(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen,struct basilisk_relay *rp,int32_t i) |
|||
{ |
|||
uint8_t pingdelay; int32_t j,datalen = 0; uint32_t ipbits; |
|||
ipbits = rp->ipbits; |
|||
if ( maxlen < sizeof(ipbits)+1 ) |
|||
{ |
|||
printf("unping error maxlen.%d is too small\n",maxlen); |
|||
return(-1); |
|||
} |
|||
datalen = iguana_rwnum(1,&data[datalen],sizeof(ipbits),&ipbits); |
|||
pingdelay = data[datalen++]; |
|||
if ( (j= basilisk_relayid(myinfo,ipbits)) >= 0 ) |
|||
{ |
|||
datalen += baslisk_relay_report(myinfo,&data[datalen],maxlen-datalen,&rp->reported[j],pingdelay); |
|||
return(datalen); |
|||
} |
|||
printf("notified about unknown relay\n"); // parse it to match bytes sent
|
|||
datalen += baslisk_relay_report(myinfo,&data[datalen],maxlen-datalen,0,pingdelay); |
|||
return(datalen); |
|||
} |
|||
|
|||
void basilisk_ping_process(struct supernet_info *myinfo,struct iguana_peer *addr,uint32_t senderipbits,uint8_t *data,int32_t datalen) |
|||
{ |
|||
int32_t diff,i,n,len = 0; struct iguana_info *btcd; char ipbuf[64]; struct basilisk_relay *rp; uint8_t numrelays; uint16_t sn; uint32_t now = (uint32_t)time(NULL); |
|||
expand_ipbits(ipbuf,senderipbits); |
|||
btcd = iguana_coinfind("BTCD"); |
|||
for (i=0; i<myinfo->numrelays; i++) |
|||
{ |
|||
rp = &myinfo->relays[i]; |
|||
rp->direct.pingdelay = 0; |
|||
if ( rp->ipbits == senderipbits ) |
|||
rp->lastping = now; |
|||
if ( rp->lastping == now ) |
|||
rp->direct.pingdelay = 1; |
|||
else |
|||
{ |
|||
diff = (now - rp->lastping); |
|||
if ( diff < 0xff ) |
|||
rp->direct.pingdelay = diff; |
|||
} |
|||
} |
|||
numrelays = data[len++]; |
|||
len += basilisk_ping_processvirts(myinfo,btcd,addr,&data[len],datalen - len); |
|||
for (i=0; i<numrelays; i++) |
|||
{ |
|||
if ( len > datalen ) |
|||
break; |
|||
if ( (n= basilisk_ping_processrelay(myinfo,&data[len],datalen-len,rp,i)) < 0 ) |
|||
break; |
|||
len += n; |
|||
} |
|||
if ( len <= datalen-sizeof(sn) ) |
|||
len += basilisk_ping_processDEX(myinfo,senderipbits,&data[len],datalen-len); |
|||
if ( len != datalen ) |
|||
printf("PING got %d, processed.%d from (%s)\n",datalen,len,ipbuf); |
|||
else printf("\n"); |
|||
//for (i=0; i<datalen; i++)
|
|||
// printf("%02x",data[i]);
|
|||
//printf(" <- input ping from.(%s) numrelays.%d numvirts.%d\n",ipbuf,numrelays,numvirts);
|
|||
} |
|||
|
|||
int32_t basilisk_ping_gen(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen) |
|||
{ |
|||
int32_t i,datalen = 0; |
|||
data[datalen++] = myinfo->numrelays; |
|||
datalen += basilisk_ping_genvirts(myinfo,&data[datalen],maxlen - datalen); |
|||
for (i=0; i<myinfo->numrelays; i++) |
|||
datalen += basilisk_ping_genrelay(myinfo,&data[datalen],maxlen - datalen,&myinfo->relays[i]); |
|||
datalen += basilisk_ping_genDEX(myinfo,&data[datalen],maxlen - datalen); |
|||
//for (i=0; i<datalen; i++)
|
|||
// printf("%02x",data[i]);
|
|||
//printf(" <- output ping sn.%d\n",sn);
|
|||
return(datalen); |
|||
} |
|||
|
|||
void basilisk_ping_send(struct supernet_info *myinfo,struct iguana_info *btcd) |
|||
{ |
|||
struct iguana_peer *addr; struct basilisk_relay *rp; int32_t i,datalen=0; |
|||
if ( myinfo->pingbuf == 0 ) |
|||
myinfo->pingbuf = malloc(IGUANA_MAXPACKETSIZE); |
|||
datalen = basilisk_ping_gen(myinfo,&myinfo->pingbuf[sizeof(struct iguana_msghdr)],IGUANA_MAXPACKETSIZE-sizeof(struct iguana_msghdr)); |
|||
for (i=0; i<myinfo->numrelays; i++) |
|||
{ |
|||
rp = &myinfo->relays[i]; |
|||
addr = 0; |
|||
if ( rp->ipbits == myinfo->myaddr.myipbits ) |
|||
basilisk_ping_process(myinfo,0,myinfo->myaddr.myipbits,&myinfo->pingbuf[sizeof(struct iguana_msghdr)],datalen); |
|||
else if ( (addr= iguana_peerfindipbits(btcd,rp->ipbits,1)) != 0 && addr->usock >= 0 ) |
|||
{ |
|||
if ( iguana_queue_send(addr,0,myinfo->pingbuf,"SuperNETPIN",datalen) <= 0 ) |
|||
printf("error sending %d to (%s)\n",datalen,addr->ipaddr); |
|||
//else printf("sent %d to (%s)\n",datalen,addr->ipaddr);
|
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,2 @@ |
|||
curl --url "http://127.0.0.1:7778" --data "{\"agent\":\"tradebot\",\"method\":\"aveprice\",\"base\":\"BTCD\",\"rel\":\"BTC\",\"basevolume\":1.0}" |
|||
|
|||
Loading…
Reference in new issue