lukechilds
/
SuperNET
mirror of https://github.com/lukechilds/SuperNET.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Proper bindings

etomic
jl777 8 years ago
parent
714821f15b
commit
8a63c46a4c
4 changed files with 236 additions and 105 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      crypto777/OS_portable.h
  2. 3
      iguana/exchanges/LP_nativeDEX.c
  3. 333
      iguana/exchanges/LP_socket.c
  4. 3
      iguana/exchanges/mm.c

2
crypto777/OS_portable.h
View File

@ -134,7 +134,7 @@ int32_t hseek(HUFF *hp,int32_t offset,int32_t mode);
struct allocitem { uint32_t allocsize,type; } PACKED;
struct queueitem { struct queueitem *next,*prev; uint32_t allocsize,type; } PACKED;
struct stritem { struct queueitem DL; char str[]; };
struct stritem { struct queueitem DL; void **retptrp; uint32_t expiration; char str[]; };
typedef struct queue
{

3
iguana/exchanges/LP_nativeDEX.c
View File

@ -32,7 +32,7 @@
#include <stdio.h>
#include "LP_include.h"
portable_mutex_t LP_peermutex,LP_UTXOmutex,LP_utxomutex,LP_commandmutex,LP_cachemutex,LP_swaplistmutex,LP_forwardmutex,LP_pubkeymutex,LP_networkmutex,LP_psockmutex,LP_coinmutex,LP_messagemutex,LP_portfoliomutex;
portable_mutex_t LP_peermutex,LP_UTXOmutex,LP_utxomutex,LP_commandmutex,LP_cachemutex,LP_swaplistmutex,LP_forwardmutex,LP_pubkeymutex,LP_networkmutex,LP_psockmutex,LP_coinmutex,LP_messagemutex,LP_portfoliomutex,LP_electrummutex;
int32_t LP_canbind;
struct LP_utxoinfo *LP_utxoinfos[2],*LP_utxoinfos2[2];
@ -607,6 +607,7 @@ void LPinit(uint16_t myport,uint16_t mypullport,uint16_t mypubport,uint16_t mybu
portable_mutex_init(&LP_psockmutex);
portable_mutex_init(&LP_coinmutex);
portable_mutex_init(&LP_pubkeymutex);
portable_mutex_init(&LP_electrummutex);
portable_mutex_init(&LP_messagemutex);
portable_mutex_init(&LP_portfoliomutex);
LP_sessionid = (uint32_t)time(NULL);

333
iguana/exchanges/LP_socket.c
View File

@ -26,6 +26,8 @@
#include <WinSock2.h>
#endif
#define ELECTRUM_TIMEOUT 2
int32_t LP_socket(int32_t bindflag,char *hostname,uint16_t port)
{
int32_t opt,sock,result; char ipaddr[64],checkipaddr[64]; struct timeval timeout;
@ -236,40 +238,158 @@ int32_t LP_socketrecv(int32_t sock,uint8_t *recvbuf,int32_t maxlen)
return(recvlen);
}
int32_t LP_electrum_maxlen; void *LP_electrum_buf;
struct electrum_info
{
queue_t sendQ,pendingQ;
int32_t bufsize,sock;
uint32_t stratumid,lasttime;
char ipaddr[64],symbol[16];
uint16_t port;
uint8_t buf[];
} *Electrums[8192];
int32_t Num_electrums;
// purge timedout
struct electrum_info *electrum_server(char *symbol,struct electrum_info *ep)
{
struct electrum_info *rbuf[128],*recent_ep; uint32_t recent,mostrecent = 0; int32_t i,n = 0;
portable_mutex_lock(&LP_electrummutex);
if ( ep != 0 )
{
memset(rbuf,0,sizeof(rbuf));
recent_ep = 0;
recent = (uint32_t)time(NULL) - 300;
for (i=0; i<Num_electrums; i++)
if ( strcmp(symbol,ep->symbol) == 0 && ep->sock >= 0 )
{
if ( ep->lasttime > recent )
{
rbuf[n++] = ep;
if ( n == sizeof(rbuf)/sizeof(*rbuf) )
break;
}
else if ( ep->lasttime > mostrecent )
{
mostrecent = ep->lasttime;
recent_ep = ep;
}
}
ep = recent_ep;
if ( n > 0 )
{
i = (rand() % n);
ep = rbuf[i];
}
}
else if ( Num_electrums < sizeof(Electrums)/sizeof(*Electrums) )
Electrums[Num_electrums++] = ep;
else printf("Electrum server pointer buf overflow %d\n",Num_electrums);
portable_mutex_unlock(&LP_electrummutex);
return(ep);
}
struct electrum_info *LP_electrum_info(char *symbol,char *ipaddr,uint16_t port,int32_t bufsize)
{
struct electrum_info *ep; struct stritem *sitem; char name[512],*str = "init string";
ep = calloc(1,sizeof(*ep) + bufsize);
ep->sock = LP_socket(0,ipaddr,port);
safecopy(ep->symbol,symbol,sizeof(ep->symbol));
safecopy(ep->ipaddr,ipaddr,sizeof(ep->ipaddr));
ep->port = port;
ep->bufsize = bufsize;
sprintf(name,"%s_%s_%u_electrum_sendQ",symbol,ipaddr,port);
queue_enqueue(name,&ep->sendQ,queueitem(str));
if ( (sitem= queue_dequeue(&ep->sendQ)) == 0 && strcmp(sitem->str,str) != 0 )
printf("error with string sendQ sitem.%p (%s)\n",sitem,sitem==0?0:sitem->str);
sprintf(name,"%s_%s_%u_electrum_pendingQ",symbol,ipaddr,port);
queue_enqueue(name,&ep->pendingQ,queueitem(str));
if ( (sitem= queue_dequeue(&ep->pendingQ)) == 0 && strcmp(sitem->str,str) != 0 )
printf("error with string pendingQ sitem.%p (%s)\n",sitem,sitem==0?0:sitem->str);
electrum_server(symbol,ep);
return(ep);
}
int32_t LP_recvfunc(struct electrum_info *ep,char *str,int32_t len)
{
cJSON *strjson; uint32_t idnum=0; struct stritem *stritem; struct queueitem *item = 0;
ep->lasttime = (uint32_t)time(NULL);
if ( (strjson= cJSON_Parse(str)) != 0 )
{
idnum = juint(strjson,"id");
portable_mutex_lock(&ep->pendingQ.mutex);
if ( ep->pendingQ.list != 0 )
{
DL_FOREACH(ep->pendingQ.list,item)
{
stritem = (struct stritem *)item;
if ( item->type == idnum )
{
printf("matched idnum.%d\n",idnum);
DL_DELETE(ep->pendingQ.list,item);
break;
}
if ( stritem->expiration < ep->lasttime )
{
DL_DELETE(ep->pendingQ.list,item);
printf("expired (%s)\n",stritem->str);
strjson = cJSON_CreateObject();
jaddnum(strjson,"id",item->type);
jaddstr(strjson,"error","timeout");
if ( stritem->retptrp != 0 )
*((cJSON **)stritem->retptrp) = strjson;
else free_json(strjson);
}
item = 0;
}
}
portable_mutex_unlock(&ep->pendingQ.mutex);
if ( item != 0 )
{
// do callback
stritem = (struct stritem *)item;
printf("callback (%s) -> (%s)\n",stritem->str,jprint(strjson,0));
if ( stritem->retptrp != 0 )
*((cJSON **)stritem->retptrp) = strjson;
else free_json(strjson);
free(item);
}
if ( strjson != 0 )
free_json(strjson);
}
return(item != 0);
}
void LP_dedicatedloop(int32_t (*recvfunc)(char *ipaddr,char *str,int32_t len),char **sendstrp,char *ipaddr,uint16_t port)
void LP_dedicatedloop(char *symbol,char *ipaddr,uint16_t port)
{
struct pollfd fds; uint8_t *buf; char *str; int32_t len,sock,bufsize,flag,timeout = 10;
LP_electrum_maxlen = bufsize = IGUANA_MAXPACKETSIZE * 10;
LP_electrum_buf = buf = malloc(bufsize);
sock = LP_socket(0,ipaddr,port);
while ( sock >= 0 )
struct pollfd fds; int32_t i,len,flag,timeout = 10; struct stritem *sitem; struct electrum_info *ep;
ep = LP_electrum_info(symbol,ipaddr,port,IGUANA_MAXPACKETSIZE * 10);
while ( ep->sock >= 0 )
{
flag = 0;
memset(&fds,0,sizeof(fds));
fds.fd = sock;
fds.fd = ep->sock;
fds.events |= (POLLOUT | POLLIN);
if ( poll(&fds,1,timeout) > 0 && (fds.revents & POLLOUT) != 0 && (str= *sendstrp) != 0 )
if ( poll(&fds,1,timeout) > 0 && (fds.revents & POLLOUT) != 0 && (sitem= queue_dequeue(&ep->sendQ)) != 0 )
{
*sendstrp = 0;
//printf("sending.(%s)\n",str);
if ( LP_socketsend(sock,(uint8_t *)str,(int32_t)strlen(str)) <= 0 )
if ( LP_socketsend(ep->sock,(uint8_t *)sitem->str,(int32_t)strlen(sitem->str)) <= 0 )
{
printf("%s:%u is dead\n",ipaddr,port);
closesocket(sock);
sock = -1;
closesocket(ep->sock);
ep->sock = -1;
break;
}
queue_enqueue("pendingQ",&ep->pendingQ,(struct queueitem *)sitem);
flag++;
}
if ( flag == 0 )
{
if ( (fds.revents & POLLIN) != 0 )
{
if ( (len= LP_socketrecv(sock,buf,bufsize)) > 0 )
if ( (len= LP_socketrecv(ep->sock,ep->buf,ep->bufsize)) > 0 )
{
(*recvfunc)(ipaddr,(char *)buf,len);
LP_recvfunc(ep,(char *)ep->buf,len);
flag++;
}
}
@ -277,161 +397,172 @@ void LP_dedicatedloop(int32_t (*recvfunc)(char *ipaddr,char *str,int32_t len),ch
usleep(100000);
}
}
free(buf);
}
// create new electrum server connection, add to list of electrum servers, sendstr, Q, etc.
int32_t LP_recvfunc(char *ipaddr,char *str,int32_t len)
if ( Num_electrums > 0 )
{
printf("RECV.(%s) from %s\n",str,ipaddr);
// get callback for id and callback
return(0);
portable_mutex_lock(&LP_electrummutex);
for (i=0; i<Num_electrums; i++)
{
if ( Electrums[i] == ep )
{
Electrums[i] = Electrums[--Num_electrums];
Electrums[Num_electrums] = 0;
break;
}
}
portable_mutex_unlock(&LP_electrummutex);
}
free(ep);
}
cJSON *electrum_submit(char *method,char *params,int32_t timeout)
/*
if ( (retjson= electrum_address_listunspent(symbol,ep,0,addr)) != 0 )
you can call it like the above, where symbol is the coin, ep is the electrum server info pointer, the 0 is a callback ptr where 0 means to block till it is done
all the API calls have the same three args
if the callback ptr is &retjson, then on completion it will put the cJSON *ptr into it, so to spawn a bunch of calls you need to call with symbol,ep,&retjsons[i],...
default timeout is set to 2 seconds, not sure if that is enough, on each receive from any server, requests that are timeout are purged (and if a callback set, will just return and "error" timeout JSON
a null value for ep will make it choose a random server for that coin
*/
cJSON *electrum_submit(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *method,char *params,int32_t timeout)
{
static uint32_t stratumid;
// queue id and string and callback
char stratumreq[16384]; cJSON *retjson = 0;
sprintf(stratumreq,"{ \"jsonrpc\":\"2.0\", \"id\": %u, \"method\":\"%s\", \"params\": %s }\n",stratumid++,method,params);
while ( LP_sendstr != 0 )
usleep(10000);
((char *)LP_electrum_buf)[0] = 0;
LP_sendstr = stratumreq;
while ( LP_sendstr != 0 )
usleep(10000);
while ( ((char *)LP_electrum_buf)[0] == 0 )
usleep(10000);
if ( ((char *)LP_electrum_buf)[0] != 0 )
{
retjson = cJSON_Parse(LP_electrum_buf);
memset(LP_electrum_buf,0,LP_electrum_maxlen);
char stratumreq[16384]; struct stritem *sitem; cJSON *retjson = 0;
if ( ep == 0 )
ep = electrum_server(symbol,0);
if ( ep != 0 )
{
sprintf(stratumreq,"{ \"jsonrpc\":\"2.0\", \"id\": %u, \"method\":\"%s\", \"params\": %s }\n",ep->stratumid,method,params);
ep->buf[0] = 0;
sitem = (struct stritem *)queueitem(stratumreq);
sitem->DL.type = ep->stratumid++;
if ( retjsonp != 0 )
sitem->retptrp = (void **)retjsonp;
else sitem->retptrp = (void **)&retjson;
queue_enqueue("sendQ",&ep->sendQ,&sitem->DL);
}
return(retjson);
}
cJSON *electrum_noargs(char *method,int32_t timeout)
cJSON *electrum_noargs(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *method,int32_t timeout)
{
return(electrum_submit(method,"[]",timeout));
return(electrum_submit(symbol,ep,retjsonp,method,"[]",timeout));
}
cJSON *electrum_strarg(char *method,char *arg,int32_t timeout)
cJSON *electrum_strarg(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *method,char *arg,int32_t timeout)
{
char params[16384];
if ( strlen(arg) < sizeof(params) )
{
sprintf(params,"[\"%s\"]",arg);
return(electrum_submit(method,params,timeout));
return(electrum_submit(symbol,ep,retjsonp,method,params,timeout));
} else return(0);
}
cJSON *electrum_intarg(char *method,int32_t arg,int32_t timeout)
cJSON *electrum_intarg(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *method,int32_t arg,int32_t timeout)
{
char params[64];
sprintf(params,"[\"%d\"]",arg);
return(electrum_submit(method,params,timeout));
return(electrum_submit(symbol,ep,retjsonp,method,params,timeout));
}
cJSON *electrum_hasharg(char *method,bits256 arg,int32_t timeout)
cJSON *electrum_hasharg(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *method,bits256 arg,int32_t timeout)
{
char params[128],str[65];
sprintf(params,"[\"%s\"]",bits256_str(str,arg));
return(electrum_submit(method,params,timeout));
return(electrum_submit(symbol,ep,retjsonp,method,params,timeout));
}
#define ELECTRUM_TIMEOUT 2
//" "--blockchain.numblocks.subscribe", "--blockchain.address.get_proof", "--blockchain.utxo.get_address",
cJSON *electrum_version() { return(electrum_noargs("server.version",ELECTRUM_TIMEOUT)); }
cJSON *electrum_banner() { return(electrum_noargs("server.banner",ELECTRUM_TIMEOUT)); }
cJSON *electrum_donation() { return(electrum_noargs("server.donation_address",ELECTRUM_TIMEOUT)); }
cJSON *electrum_peers() { return(electrum_noargs("server.peers.subscribe",ELECTRUM_TIMEOUT)); }
cJSON *electrum_features() { return(electrum_noargs("server.features",ELECTRUM_TIMEOUT)); }
cJSON *electrum_headers_subscribe() { return(electrum_noargs("blockchain.headers.subscribe",ELECTRUM_TIMEOUT)); }
cJSON *electrum_version(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"server.version",ELECTRUM_TIMEOUT)); }
cJSON *electrum_banner(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"server.banner",ELECTRUM_TIMEOUT)); }
cJSON *electrum_donation(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"server.donation_address",ELECTRUM_TIMEOUT)); }
cJSON *electrum_peers(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"server.peers.subscribe",ELECTRUM_TIMEOUT)); }
cJSON *electrum_features(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"server.features",ELECTRUM_TIMEOUT)); }
cJSON *electrum_headers_subscribe(char *symbol,struct electrum_info *ep,cJSON **retjsonp) { return(electrum_noargs(symbol,ep,retjsonp,"blockchain.headers.subscribe",ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_getbalance(char *script) { return(electrum_strarg("blockchain.scripthash.get_balance",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_gethistory(char *script) { return(electrum_strarg("blockchain.scripthash.get_history",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_getmempool(char *script) { return(electrum_strarg("blockchain.scripthash.get_mempool",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_listunspent(char *script) { return(electrum_strarg("blockchain.scripthash.listunspent",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_subscribe(char *script) { return(electrum_strarg("blockchain.scripthash.subscribe",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_getbalance(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *script) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.scripthash.get_balance",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_gethistory(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *script) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.scripthash.get_history",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_getmempool(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *script) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.scripthash.get_mempool",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_listunspent(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *script) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.scripthash.listunspent",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_script_subscribe(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *script) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.scripthash.subscribe",script,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_subscribe(char *addr) { return(electrum_strarg("blockchain.address.subscribe",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_gethistory(char *addr) { return(electrum_strarg("blockchain.address.get_history",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_getmempool(char *addr) { return(electrum_strarg("blockchain.address.get_mempool",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_getbalance(char *addr) { return(electrum_strarg("blockchain.address.get_balance",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_listunspent(char *addr) { return(electrum_strarg("blockchain.address.listunspent",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_subscribe(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *addr) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.address.subscribe",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_gethistory(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *addr) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.address.get_history",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_getmempool(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *addr) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.address.get_mempool",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_getbalance(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *addr) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.address.get_balance",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_address_listunspent(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *addr) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.address.listunspent",addr,ELECTRUM_TIMEOUT)); }
cJSON *electrum_addpeer(char *endpoint) { return(electrum_strarg("server.add_peer",endpoint,ELECTRUM_TIMEOUT)); }
cJSON *electrum_sendrawtransaction(char *rawtx) { return(electrum_strarg("blockchain.transaction.broadcast",rawtx,ELECTRUM_TIMEOUT)); }
cJSON *electrum_addpeer(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *endpoint) { return(electrum_strarg(symbol,ep,retjsonp,"server.add_peer",endpoint,ELECTRUM_TIMEOUT)); }
cJSON *electrum_sendrawtransaction(char *symbol,struct electrum_info *ep,cJSON **retjsonp,char *rawtx) { return(electrum_strarg(symbol,ep,retjsonp,"blockchain.transaction.broadcast",rawtx,ELECTRUM_TIMEOUT)); }
cJSON *electrum_estimatefee(int32_t numblocks) { return(electrum_intarg("blockchain.estimatefee",numblocks,ELECTRUM_TIMEOUT)); }
cJSON *electrum_getheader(int32_t n) { return(electrum_intarg("blockchain.block.get_header",n,ELECTRUM_TIMEOUT)); }
cJSON *electrum_getchunk(int32_t n) { return(electrum_intarg("blockchain.block.get_chunk",n,ELECTRUM_TIMEOUT)); }
cJSON *electrum_transaction(bits256 txid) { return(electrum_hasharg("blockchain.transaction.get",txid,ELECTRUM_TIMEOUT)); }
cJSON *electrum_estimatefee(char *symbol,struct electrum_info *ep,cJSON **retjsonp,int32_t numblocks) { return(electrum_intarg(symbol,ep,retjsonp,"blockchain.estimatefee",numblocks,ELECTRUM_TIMEOUT)); }
cJSON *electrum_getheader(char *symbol,struct electrum_info *ep,cJSON **retjsonp,int32_t n) { return(electrum_intarg(symbol,ep,retjsonp,"blockchain.block.get_header",n,ELECTRUM_TIMEOUT)); }
cJSON *electrum_getchunk(char *symbol,struct electrum_info *ep,cJSON **retjsonp,int32_t n) { return(electrum_intarg(symbol,ep,retjsonp,"blockchain.block.get_chunk",n,ELECTRUM_TIMEOUT)); }
cJSON *electrum_transaction(char *symbol,struct electrum_info *ep,cJSON **retjsonp,bits256 txid) { return(electrum_hasharg(symbol,ep,retjsonp,"blockchain.transaction.get",txid,ELECTRUM_TIMEOUT)); }
cJSON *electrum_getmerkle(bits256 txid,int32_t height)
cJSON *electrum_getmerkle(char *symbol,struct electrum_info *ep,cJSON **retjsonp,bits256 txid,int32_t height)
{
char params[128],str[65];
sprintf(params,"[\"%s\", %d]",bits256_str(str,txid),height);
return(electrum_submit("blockchain.transaction.get_merkle",params,ELECTRUM_TIMEOUT));
return(electrum_submit(symbol,ep,retjsonp,"blockchain.transaction.get_merkle",params,ELECTRUM_TIMEOUT));
}
void electrum_test()
{
cJSON *retjson; bits256 hash; char *addr,*script;
if ( (retjson= electrum_version()) != 0 )
cJSON *retjson; bits256 hash; struct electrum_info *ep = 0; char *addr,*script,*symbol = "BTC";
if ( (retjson= electrum_version(symbol,ep,0)) != 0 )
printf("electrum_version %s\n",jprint(retjson,1));
if ( (retjson= electrum_banner()) != 0 )
if ( (retjson= electrum_banner(symbol,ep,0)) != 0 )
printf("electrum_banner %s\n",jprint(retjson,1));
if ( (retjson= electrum_donation()) != 0 )
if ( (retjson= electrum_donation(symbol,ep,0)) != 0 )
printf("electrum_donation %s\n",jprint(retjson,1));
if ( (retjson= electrum_features()) != 0 )
if ( (retjson= electrum_features(symbol,ep,0)) != 0 )
printf("electrum_features %s\n",jprint(retjson,1));
if ( (retjson= electrum_estimatefee(6)) != 0 )
if ( (retjson= electrum_estimatefee(symbol,ep,0,6)) != 0 )
printf("electrum_estimatefee %s\n",jprint(retjson,1));
decode_hex(hash.bytes,sizeof(hash),"0000000000000000005087f8845f9ed0282559017e3c6344106de15e46c07acd");
if ( (retjson= electrum_getheader(3)) != 0 )
if ( (retjson= electrum_getheader(symbol,ep,0,3)) != 0 )
printf("electrum_getheader %s\n",jprint(retjson,1));
//if ( (retjson= electrum_getchunk(3)) != 0 )
//if ( (retjson= electrum_getchunk(symbol,ep,0,3)) != 0 )
// printf("electrum_getchunk %s\n",jprint(retjson,1));
decode_hex(hash.bytes,sizeof(hash),"b967a7d55889fe11e993430921574ec6379bc8ce712a652c3fcb66c6be6e925c");
if ( (retjson= electrum_getmerkle(hash,403000)) != 0 )
if ( (retjson= electrum_getmerkle(symbol,ep,0,hash,403000)) != 0 )
printf("electrum_getmerkle %s\n",jprint(retjson,1));
if ( (retjson= electrum_transaction(hash)) != 0 )
if ( (retjson= electrum_transaction(symbol,ep,0,hash)) != 0 )
printf("electrum_transaction %s\n",jprint(retjson,1));
addr = "14NeevLME8UAANiTCVNgvDrynUPk1VcQKb";
if ( (retjson= electrum_address_gethistory(addr)) != 0 )
if ( (retjson= electrum_address_gethistory(symbol,ep,0,addr)) != 0 )
printf("electrum_address_gethistory %s\n",jprint(retjson,1));
if ( (retjson= electrum_address_getmempool(addr)) != 0 )
if ( (retjson= electrum_address_getmempool(symbol,ep,0,addr)) != 0 )
printf("electrum_address_getmempool %s\n",jprint(retjson,1));
if ( (retjson= electrum_address_getbalance(addr)) != 0 )
if ( (retjson= electrum_address_getbalance(symbol,ep,0,addr)) != 0 )
printf("electrum_address_getbalance %s\n",jprint(retjson,1));
if ( (retjson= electrum_address_listunspent(addr)) != 0 )
if ( (retjson= electrum_address_listunspent(symbol,ep,0,addr)) != 0 )
printf("electrum_address_listunspent %s\n",jprint(retjson,1));
if ( (retjson= electrum_addpeer(symbol,ep,0,"electrum.be:50001")) != 0 )
printf("electrum_addpeer %s\n",jprint(retjson,1));
if ( (retjson= electrum_sendrawtransaction(symbol,ep,0,"0100000001b7e6d69a0fd650926bd5fbe63cc8578d976c25dbdda8dd61db5e05b0de4041fe000000006b483045022100de3ae8f43a2a026bb46f6b09b890861f8aadcb16821f0b01126d70fa9ae134e4022000925a842073484f1056c7fc97399f2bbddb9beb9e49aca76835cdf6e9c91ef3012103cf5ce3233e6d6e22291ebef454edff2b37a714aed685ce94a7eb4f83d8e4254dffffffff014c4eaa0b000000001976a914b598062b55362952720718e7da584a46a27bedee88ac00000000")) != 0 )
printf("electrum_sendrawtransaction %s\n",jprint(retjson,1));
if ( 0 )
{
script = "76a914b598062b55362952720718e7da584a46a27bedee88ac";
if ( (retjson= electrum_script_gethistory(script)) != 0 )
if ( (retjson= electrum_script_gethistory(symbol,ep,0,script)) != 0 )
printf("electrum_script_gethistory %s\n",jprint(retjson,1));
if ( (retjson= electrum_script_getmempool(script)) != 0 )
if ( (retjson= electrum_script_getmempool(symbol,ep,0,script)) != 0 )
printf("electrum_script_getmempool %s\n",jprint(retjson,1));
if ( (retjson= electrum_script_getbalance(script)) != 0 )
if ( (retjson= electrum_script_getbalance(symbol,ep,0,script)) != 0 )
printf("electrum_script_getbalance %s\n",jprint(retjson,1));
if ( (retjson= electrum_script_listunspent(script)) != 0 )
if ( (retjson= electrum_script_listunspent(symbol,ep,0,script)) != 0 )
printf("electrum_script_listunspent %s\n",jprint(retjson,1));
if ( (retjson= electrum_script_subscribe(symbol,ep,0,script)) != 0 )
printf("electrum_script_subscribe %s\n",jprint(retjson,1));
}
if ( (retjson= electrum_addpeer("electrum.be:50001")) != 0 )
printf("electrum_addpeer %s\n",jprint(retjson,1));
if ( (retjson= electrum_sendrawtransaction("0100000001b7e6d69a0fd650926bd5fbe63cc8578d976c25dbdda8dd61db5e05b0de4041fe000000006b483045022100de3ae8f43a2a026bb46f6b09b890861f8aadcb16821f0b01126d70fa9ae134e4022000925a842073484f1056c7fc97399f2bbddb9beb9e49aca76835cdf6e9c91ef3012103cf5ce3233e6d6e22291ebef454edff2b37a714aed685ce94a7eb4f83d8e4254dffffffff014c4eaa0b000000001976a914b598062b55362952720718e7da584a46a27bedee88ac00000000")) != 0 )
printf("electrum_sendrawtransaction %s\n",jprint(retjson,1));
if ( (retjson= electrum_headers_subscribe()) != 0 )
if ( (retjson= electrum_headers_subscribe(symbol,ep,0)) != 0 )
printf("electrum_headers %s\n",jprint(retjson,1));
if ( (retjson= electrum_peers()) != 0 )
if ( (retjson= electrum_peers(symbol,ep,0)) != 0 )
printf("electrum_peers %s\n",jprint(retjson,1));
if ( (retjson= electrum_address_subscribe(addr)) != 0 )
if ( (retjson= electrum_address_subscribe(symbol,ep,0,addr)) != 0 )
printf("electrum_address_subscribe %s\n",jprint(retjson,1));
if ( (retjson= electrum_script_subscribe(script)) != 0 )
printf("electrum_script_subscribe %s\n",jprint(retjson,1));
}

3
iguana/exchanges/mm.c
View File

@ -26,7 +26,6 @@
#define MAX(a,b) ((a) > (b) ? (a) : (b))
char *stats_JSON(void *ctx,char *myipaddr,int32_t pubsock,cJSON *argjson,char *remoteaddr,uint16_t port);
#include "stats.c"
char *LP_sendstr;
void LP_priceupdate(char *base,char *rel,double price,double avebid,double aveask,double highbid,double lowask,double PAXPRICES[32]);
//defined(__APPLE__) ||
@ -817,7 +816,7 @@ int main(int argc, const char * argv[])
exit(-1);
} else printf("(%s) launched.(%s)\n",argv[1],passphrase);
incr = 100.;
LP_dedicatedloop(LP_recvfunc,&LP_sendstr,"46.4.125.2",50001);//88.198.241.196",50001);
LP_dedicatedloop("BTC","46.4.125.2",50001);//88.198.241.196",50001);
while ( 1 )
sleep(1);
profitmargin = jdouble(retjson,"profitmargin");

Write Preview
Loading…
Cancel
Save