You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

915 lines
35 KiB

/******************************************************************************
* Copyright © 2014-2017 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. *
* *
******************************************************************************/
#define DEFAULT_NXT_DEADLINE 720
#define issue_NXTPOST(cmdstr) bitcoind_RPC(0,"curl",myinfo->NXTAPIURL,0,0,cmdstr,0)
#define NXT_MSTYPE 5
#define NXT_ASSETTYPE 2
#define NXT_GENESISTIME 1385294400
cJSON *_issue_NXTjson(struct supernet_info *myinfo,char *extra)
{
char cmd[4096],*jsonstr; cJSON *json = 0;
//sprintf(cmd,"requestType=getAsset&asset=%s",assetidstr);
sprintf(cmd,"requestType=%s",extra);
//printf("_cmd.(%s)\n",cmd);
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
json = cJSON_Parse(jsonstr);
free(jsonstr);
}
return(json);
}
char *_issue_getAsset(struct supernet_info *myinfo,char *assetidstr)
{
char cmd[4096],*jsonstr;
//sprintf(cmd,"requestType=getAsset&asset=%s",assetidstr);
sprintf(cmd,"requestType=getAsset&asset=%s",assetidstr);
//printf("_cmd.(%s)\n",cmd);
jsonstr = issue_NXTPOST(cmd);
//printf("(%s) -> (%s)\n",cmd,jsonstr);
return(jsonstr);
}
char *_issue_getCurrency(struct supernet_info *myinfo,char *assetidstr)
{
char cmd[4096];
//sprintf(cmd,"requestType=getAsset&asset=%s",assetidstr);
sprintf(cmd,"requestType=getCurrency&currency=%s",assetidstr);
//printf("_cmd.(%s)\n",cmd);
return(issue_NXTPOST(cmd));
}
char *_get_AEquotestr(struct supernet_info *myinfo,char *str,uint64_t orderid)
{
char cmd[256];
sprintf(cmd,"requestType=get%sOrder&order=%llu",str,(long long)orderid);
return(issue_NXTPOST(cmd));
}
uint64_t _get_AEquote(struct supernet_info *myinfo,char *str,uint64_t orderid)
{
char *jsonstr; cJSON *json; uint64_t nxt64bits = 0;
if ( (jsonstr= _get_AEquotestr(myinfo,str,orderid)) != 0 )
{
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
nxt64bits = j64bits(json,"account");
free_json(json);
}
free(jsonstr);
}
return(nxt64bits);
}
char *_get_MSoffers(struct supernet_info *myinfo,char *str)
{
char cmd[512];
sprintf(cmd,"requestType=get%sOffers&account=%s",str,myinfo->myaddr.NXTADDR);
return(issue_NXTPOST(cmd));
}
char *issue_startForging(struct supernet_info *myinfo,char *secret)
{
char cmd[4096];
sprintf(cmd,"requestType=startForging&secretPhrase=%s",secret);
return(issue_NXTPOST(cmd));
}
uint32_t get_blockutime(struct supernet_info *myinfo,uint32_t blocknum)
{
cJSON *json; uint32_t timestamp = 0; char cmd[4096],*jsonstr;
sprintf(cmd,"requestType=getBlock&height=%u",blocknum);
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
//printf("(%s) -> (%s)\n",cmd,jsonstr);
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
if ( (timestamp= juint(json,"timestamp")) != 0 )
timestamp += NXT_GENESISTIME;
free_json(json);
}
free(jsonstr);
}
return(timestamp);
}
uint32_t get_NXTheight(struct supernet_info *myinfo,uint32_t *firsttimep)
{
static uint32_t last,lastheight,lastNXTtime;
cJSON *json; uint32_t height = 0; char cmd[256],*jsonstr;
if ( time(NULL) > last+10 )
{
sprintf(cmd,"requestType=getState");
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
//printf("(%s) -> (%s)\n",cmd,jsonstr);
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
if ( firsttimep != 0 )
lastNXTtime = *firsttimep = (uint32_t)get_cJSON_int(json,"time");
height = (int32_t)get_cJSON_int(json,"numberOfBlocks");
if ( height > 0 )
height--;
lastheight = height;
free_json(json);
}
free(jsonstr);
}
last = (uint32_t)time(NULL);
}
else
{
height = lastheight;
if ( firsttimep != 0 )
*firsttimep = lastNXTtime;
}
return(height);
}
char *issue_approveTransaction(struct supernet_info *myinfo,char *fullhash,char *revealed,bits256 msghash,char *NXTACCTSECRET)
{
char cmd[4096],secret[8192],str[65];
escape_code(secret,NXTACCTSECRET);
sprintf(cmd,"requestType=approveTransaction&secretPhrase=%s&transactionFullHash=%s&revealedSecret=%s&revealedSecretIsText=false&messageIsText=false&feeNQT=%d&deadline=%d&message=%s",secret,fullhash,revealed,0,DEFAULT_NXT_DEADLINE,bits256_str(str,msghash));
printf("submit approve.(%s)\n",cmd);
return(issue_NXTPOST(cmd));
}
char *MGWassets[][3] =
{
{ "12659653638116877017", "BTC", "8" },
{ "17554243582654188572", "BTC", "8" }, // assetid, name, decimals
{ "4551058913252105307", "BTC", "8" },
{ "6918149200730574743", "BTCD", "4" },
{ "11060861818140490423", "BTCD", "4" },
{ "16344939950195952527", "DOGE", "4" },
{ "2303962892272487643", "DOGE", "4" },
{ "6775076774325697454", "OPAL", "8" },
{ "7734432159113182240", "VPN", "4" },
{ "9037144112883608562", "VRC", "8" },
{ "2881764795164526882", "LTC", "4" },
};
uint64_t is_MGWcoin(char *name)
{
int32_t i;
for (i=0; i<(int32_t)(sizeof(MGWassets)/sizeof(*MGWassets)); i++)
if ( strcmp(MGWassets[i][1],name) == 0 )
return(calc_nxt64bits(MGWassets[i][0]));
return(0);
}
char *is_MGWasset(uint64_t assetid)
{
int32_t i; char assetidstr[64];
expand_nxt64bits(assetidstr,assetid);
for (i=0; i<(int32_t)(sizeof(MGWassets)/sizeof(*MGWassets)); i++)
if ( strcmp(MGWassets[i][0],assetidstr) == 0 )
return(MGWassets[i][1]);
return(0);
}
uint64_t NXT_assetid(char *name)
{
uint64_t assetid;
if ( (assetid= is_MGWcoin(name)) != 0 )
return(assetid);
else if ( is_decimalstr(name) > 0 )
return(calc_nxt64bits(name));
else return(0);
}
double NXT_price_volume(double *volumep,uint64_t baseamount,uint64_t relamount)
{
*volumep = (((double)baseamount + 0.000000009999999) / SATOSHIDEN);
if ( baseamount > 0. )
return((double)relamount / (double)baseamount);
else return(0.);
}
int32_t is_native_crypto(char *name)
{
int32_t i,n;
if ( (n= (int32_t)strlen(name)) > 0 && n < 6 )
{
for (i=0; i<n; i++)
{
if ( (name[i] >= '0' && name[i] <= '9') || (name[i] >= 'A' && name[i] <= 'Z') ) continue;
printf("(%s) is not native crypto\n",name);
return(0);
}
printf("(%s) is native crypto\n",name);
return(1);
}
return(0);
}
int32_t get_assettype(struct supernet_info *myinfo,int32_t *numdecimalsp,char *assetidstr)
{
cJSON *json; char name[64],*jsonstr; uint64_t assetid; int32_t ap_type = -1; //struct assethash *ap,A;
*numdecimalsp = -1;
name[0] = 0;
if ( is_native_crypto(assetidstr) > 0 )
{
//printf("found native crypto.(%s) name.(%s)\n",assetidstr,name);
ap_type = 0;
*numdecimalsp = 8;
return(0);
}
if ( is_decimalstr(assetidstr) > 0 && (assetid= calc_nxt64bits(assetidstr)) == NXT_ASSETID )
{
//printf("found NXT_ASSETID.(%s)\n",assetidstr);
ap_type = 0;
*numdecimalsp = 8;
return(0);
}
/*if ( (ap= find_asset(assetid)) != 0 )
{
*numdecimalsp = ap->decimals;
return(ap->type);
}*/
memset(name,0,sizeof(name));
if ( (jsonstr= _issue_getAsset(myinfo,assetidstr)) != 0 )
{
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
if ( get_cJSON_int(json,"errorCode") == 0 )
{
//printf("assetstr.(%s)\n",jsonstr);
if ( extract_cJSON_str(name,16,json,"name") <= 0 )
*numdecimalsp = -1;
else *numdecimalsp = (int32_t)get_cJSON_int(json,"decimals");
ap_type = NXT_ASSETTYPE;
} //else printf("errorcode.%lld (%s)\n",(long long)get_cJSON_int(json,"errorCode"),jsonstr);
free_json(json);
} else printf("cant parse.(%s)\n",jsonstr);
free(jsonstr);
} else printf("couldnt getAsset.(%s)\n",assetidstr);
if ( ap_type < 0 )
{
if ( (jsonstr= _issue_getCurrency(myinfo,assetidstr)) != 0 )
{
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
if ( get_cJSON_int(json,"errorCode") == 0 )
{
if ( extract_cJSON_str(name,16,json,"name") <= 0 )
*numdecimalsp = -1;
else *numdecimalsp = (int32_t)get_cJSON_int(json,"decimals");
ap_type = NXT_MSTYPE;
}
free_json(json);
}
free(jsonstr);
}
}
/*memset(&A,0,sizeof(A));
A.assetid = assetid;
A.minvol = A.mult = calc_decimals_mult(*numdecimalsp);
A.decimals = *numdecimalsp;
A.type = ap_type;
strcpy(A.name,name);
create_asset(assetid,&A);*/
return(ap_type);
}
uint64_t calc_decimals_mult(int32_t decimals)
{
int32_t i; uint64_t mult = 1;
for (i=7-decimals; i>=0; i--)
mult *= 10;
return(mult);
}
uint64_t assetmult(struct supernet_info *myinfo,int32_t *is_MSp,char *assetidstr)
{
int32_t ap_type,decimals; uint64_t mult = 0;
ap_type = get_assettype(myinfo,&decimals,assetidstr);
if ( decimals >= 0 && decimals <= 8 )
mult = calc_decimals_mult(decimals);
*is_MSp = (ap_type == NXT_MSTYPE);
return(mult);
}
int32_t assetdecimals(struct supernet_info *myinfo,char *assetidstr)
{
int32_t ap_type,decimals = 0;
ap_type = get_assettype(myinfo,&decimals,assetidstr);
if ( ap_type == 0 )
return(8);
return(decimals);
}
uint64_t min_asset_amount(struct supernet_info *myinfo,uint64_t assetid)
{
char assetidstr[64]; int32_t tmp;
if ( assetid == NXT_ASSETID )
return(1);
expand_nxt64bits(assetidstr,assetid);
return(assetmult(myinfo,&tmp,assetidstr));
}
int32_t get_assetdecimals(struct supernet_info *myinfo,uint64_t assetid)
{
char assetidstr[64];
if ( assetid == NXT_ASSETID )
return(8);
expand_nxt64bits(assetidstr,assetid);
return(assetdecimals(myinfo,assetidstr));
}
uint64_t get_assetmult(struct supernet_info *myinfo,int32_t *is_MSp,uint64_t assetid)
{
char assetidstr[64];
expand_nxt64bits(assetidstr,assetid);
return(assetmult(myinfo,is_MSp,assetidstr));
}
double get_minvolume(struct supernet_info *myinfo,uint64_t assetid)
{
int32_t tmp;
return(dstr(get_assetmult(myinfo,&tmp,assetid)));
}
int64_t get_asset_quantity(struct supernet_info *myinfo,int64_t *unconfirmedp,char *NXTaddr,char *assetidstr)
{
char cmd[2*MAX_JSON_FIELD],*jsonstr; struct destbuf assetid; int32_t i,n,iter; cJSON *array,*item,*obj,*json; int64_t quantity,qty = 0;
uint64_t assetidbits;
quantity = *unconfirmedp = 0;
if ( is_decimalstr(assetidstr) > 0 )
assetidbits = calc_nxt64bits(assetidstr);
else return(0);
if ( assetidbits == NXT_ASSETID )
{
sprintf(cmd,"requestType=getBalance&account=%s",NXTaddr);
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
//printf("(%s) -> (%s)\n",cmd,jsonstr);
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
qty = get_API_nxt64bits(cJSON_GetObjectItem(json,"balanceNQT"));
*unconfirmedp = get_API_nxt64bits(cJSON_GetObjectItem(json,"unconfirmedBalanceNQT"));
printf("(%s)\n",jsonstr);
free_json(json);
}
free(jsonstr);
}
return(qty);
}
sprintf(cmd,"requestType=getAccount&account=%s",NXTaddr);
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
//printf("(%s) -> (%s)\n",cmd,jsonstr);
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
for (iter=0; iter<2; iter++)
{
qty = 0;
array = cJSON_GetObjectItem(json,iter==0?"assetBalances":"unconfirmedAssetBalances");
if ( is_cJSON_Array(array) != 0 )
{
n = cJSON_GetArraySize(array);
for (i=0; i<n; i++)
{
item = cJSON_GetArrayItem(array,i);
if ( (obj = cJSON_GetObjectItem(item,"asset")) == 0 )
printf("check for mscoin\n"), getchar();
copy_cJSON(&assetid,obj);
//printf("i.%d of %d: %s(%s)\n",i,n,assetid,cJSON_Print(item));
if ( strcmp(assetid.buf,assetidstr) == 0 )
{
qty = get_cJSON_int(item,iter==0?"balanceQNT":"unconfirmedBalanceQNT");
break;
}
}
}
if ( iter == 0 )
quantity = qty;
else *unconfirmedp = qty;
}
free_json(json);
}
free(jsonstr);
}
return(quantity);
}
uint64_t calc_asset_qty(struct supernet_info *myinfo,int32_t *is_MSp,uint64_t *availp,uint64_t *priceNQTp,int32_t checkflag,uint64_t assetid,double price,double vol)
{
char assetidstr[64];
uint64_t ap_mult,priceNQT,quantityQNT = 0;
int64_t unconfirmed,balance;
*priceNQTp = *availp = 0;
if ( assetid != NXT_ASSETID )
{
expand_nxt64bits(assetidstr,assetid);
if ( (ap_mult= get_assetmult(myinfo,is_MSp,assetid)) != 0 )
{
//price = (double)get_satoshi_obj(srcitem,"priceNQT") / ap_mult;
//vol = (double)get_satoshi_obj(srcitem,"quantityQNT") * ((double)ap_mult / SATOSHIDEN);
priceNQT = (price * ap_mult + (ap_mult/2)/SATOSHIDEN);
quantityQNT = (vol * SATOSHIDEN) / ap_mult;
balance = get_asset_quantity(myinfo,&unconfirmed,myinfo->myaddr.NXTADDR,assetidstr);
//printf("%s balance %.8f unconfirmed %.8f vs price %llu qty %llu for asset.%s | price_vol.(%f * %f) * (%lld / %llu)\n",NXTaddr,dstr(balance),dstr(unconfirmed),(long long)priceNQT,(long long)quantityQNT,assetidstr,price,vol,(long long)SATOSHIDEN,(long long)ap_mult);
//getchar();
if ( checkflag != 0 && (balance < quantityQNT || unconfirmed < quantityQNT) )
{
printf("balance %.8f < qty %.8f || unconfirmed %.8f < qty %llu\n",dstr(balance),dstr(quantityQNT),dstr(unconfirmed),(long long)quantityQNT);
return(0);
}
*priceNQTp = priceNQT;
*availp = unconfirmed;
} else printf("%llu null apmult\n",(long long)assetid);
}
else
{
*is_MSp = 0;
*priceNQTp = price * SATOSHIDEN;
quantityQNT = vol;
}
return(quantityQNT);
}
int32_t NXT_assetpolarity(struct supernet_info *myinfo,char *name)
{
int32_t ap_type,decimals;
if ( (ap_type= get_assettype(myinfo,&decimals,name)) == NXT_ASSETTYPE || ap_type == NXT_MSTYPE )
return(1);
else return(0);
}
uint64_t set_NXTtx(struct supernet_info *myinfo,struct NXT_tx *tx,uint64_t assetidbits,int64_t amount,uint64_t other64bits,int32_t feebits)
{
char assetidstr[64]; int32_t decimals; uint64_t fee = 0; struct NXT_tx U;
memset(&U,0,sizeof(U));
U.senderbits = myinfo->myaddr.nxt64bits;
U.recipientbits = other64bits;
U.assetidbits = assetidbits;
if ( feebits >= 0 )
{
fee = (amount >> feebits);
if ( fee == 0 )
fee = 1;
}
if ( assetidbits != NXT_ASSETID )
{
expand_nxt64bits(assetidstr,assetidbits);
U.type = get_assettype(myinfo,&decimals,assetidstr);
//U.subtype = ap->subtype;
U.U.quantityQNT = amount - fee;
} else U.U.amountNQT = amount - fee;
U.feeNQT = 0;
U.deadline = DEFAULT_NXT_DEADLINE;
printf("set_NXTtx(%llu -> %llu) %.8f of %llu\n",(long long)U.senderbits,(long long)U.recipientbits,dstr(amount),(long long)assetidbits);
*tx = U;
return(fee);
}
cJSON *gen_NXT_tx_json(struct supernet_info *myinfo,char *fullhash,struct NXT_tx *utx,char *reftxid,double myshare)
{
cJSON *json = 0; char secret[8192],cmd[MAX_JSON_FIELD],destNXTaddr[64],assetidstr[64],*retstr;
if ( utx->senderbits == myinfo->myaddr.nxt64bits )
{
expand_nxt64bits(destNXTaddr,utx->recipientbits);
cmd[0] = 0;
if ( utx->type == 0 && utx->subtype == 0 )
sprintf(cmd,"requestType=sendMoney&amountNQT=%lld",(long long)(utx->U.amountNQT*myshare));
else
{
expand_nxt64bits(assetidstr,utx->assetidbits);
if ( utx->type == 2 && utx->subtype == 1 )
sprintf(cmd,"requestType=transferAsset&asset=%s&quantityQNT=%lld",assetidstr,(long long)(utx->U.quantityQNT*myshare));
else if ( utx->type == 5 && utx->subtype == 3 )
sprintf(cmd,"requestType=transferCurrency&currency=%s&units=%lld",assetidstr,(long long)(utx->U.quantityQNT*myshare));
else
{
printf("unsupported type.%d subtype.%d\n",utx->type,utx->subtype);
return(0);
}
}
if ( utx->comment[0] != 0 )
strcat(cmd,"&messageIsText=true&message="),strcat(cmd,utx->comment);
if ( reftxid != 0 && reftxid[0] != 0 && cmd[0] != 0 )
strcat(cmd,"&referencedTransactionFullHash="),strcat(cmd,reftxid);
if ( cmd[0] != 0 )
{
escape_code(secret,myinfo->secret);
sprintf(cmd+strlen(cmd),"&deadline=%u&feeNQT=%lld&secretPhrase=%s&recipient=%s&broadcast=false",utx->deadline,(long long)utx->feeNQT,secret,destNXTaddr);
if ( reftxid != 0 && reftxid[0] != 0 )
sprintf(cmd+strlen(cmd),"&referencedTransactionFullHash=%s",reftxid);
//printf("generated cmd.(%s) reftxid.(%s)\n",cmd,reftxid);
retstr = issue_NXTPOST(cmd);
if ( retstr != 0 )
{
json = cJSON_Parse(retstr);
if ( (json= cJSON_Parse(retstr)) != 0 )
{
if ( jstr(json,"fullHash") != 0 )
strcpy(fullhash,jstr(json,"fullHash"));
// printf("Parsed.(%s)\n",cJSON_Print(json));
}
free(retstr);
}
}
} else printf("cant gen_NXT_txjson when sender.%llu is not me.%llu\n",(long long)utx->senderbits,(long long)myinfo->myaddr.nxt64bits);
return(json);
}
int32_t calc_raw_NXTtx(struct supernet_info *myinfo,char *fullhash,char *utxbytes,char *sighash,uint64_t assetidbits,int64_t amount,uint64_t other64bits)
{
int32_t retval = -1; struct NXT_tx U; cJSON *json;
utxbytes[0] = sighash[0] = 0;
set_NXTtx(myinfo,&U,assetidbits,amount,other64bits,0);
json = gen_NXT_tx_json(myinfo,fullhash,&U,0,1.);
if ( json != 0 )
{
if ( extract_cJSON_str(utxbytes,1024,json,"transactionBytes") > 0 && extract_cJSON_str(sighash,1024,json,"signatureHash") > 0 )
{
retval = 0;
printf("generated utx.(%s) sighash.(%s)\n",utxbytes,sighash);
}
free_json(json);
}
return(retval);
}
#define EXCHANGE_NAME "nxtae"
#define UPDATE nxtae ## _price
#define SUPPORTS nxtae ## _supports
#define SIGNPOST nxtae ## _signpost
#define TRADE nxtae ## _trade
#define ORDERSTATUS nxtae ## _orderstatus
#define CANCELORDER nxtae ## _cancelorder
#define OPENORDERS nxtae ## _openorders
#define TRADEHISTORY nxtae ## _tradehistory
#define BALANCES nxtae ## _balances
#define PARSEBALANCE nxtae ## _parsebalance
#define WITHDRAW nxtae ## _withdraw
#define CHECKBALANCE nxtae ## _checkbalance
#define ALLPAIRS nxtae ## _allpairs
#define FUNCS nxtae ## _funcs
#define BASERELS nxtae ## _baserels
static char *BASERELS[][2] = { {"btc","nxt"}, {"btcd","nxt"}, {"ltc","nxt"}, {"vrc","nxt"}, {"doge","nxt"}, {"opal","nxt"} };
char *ALLPAIRS(struct exchange_info *exchange,cJSON *argjson)
{
return(jprint(exchanges777_allpairs(BASERELS,(int32_t)(sizeof(BASERELS)/sizeof(*BASERELS))),1));
}
int32_t SUPPORTS(struct exchange_info *exchange,char *base,char *rel,cJSON *argjson)
{
int32_t polarity; struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (polarity= baserel_polarity(BASERELS,(int32_t)(sizeof(BASERELS)/sizeof(*BASERELS)),base,rel)) == 0 )
{
if ( strcmp(rel,"NXT") == 0 || strcmp(rel,"nxt") == 0 || (is_decimalstr(rel) != 0 && calc_nxt64bits(rel) == NXT_ASSETID) )
return(NXT_assetpolarity(myinfo,base));
else if ( strcmp(base,"NXT") == 0 || strcmp(base,"nxt") == 0 || (is_decimalstr(base) != 0 && calc_nxt64bits(rel) == NXT_ASSETID) )
return(-NXT_assetpolarity(myinfo,rel));
}
return(polarity);
}
cJSON *inner_json(double price,double vol,uint32_t timestamp,uint64_t quoteid,uint64_t nxt64bits,uint64_t qty,uint64_t pqt,uint64_t baseamount,uint64_t relamount)
{
cJSON *inner = cJSON_CreateArray();
jaddnum(inner,"price",price);
jaddnum(inner,"volume",vol);
jadd64bits(inner,"quoteid",quoteid);
jadd64bits(inner,"offerNXT",nxt64bits);
jaddnum(inner,"timestamp",timestamp);
jadd64bits(inner,"quantityQNT",qty);
jadd64bits(inner,"priceNQT",pqt);
jadd64bits(inner,"baseamount",baseamount);
jadd64bits(inner,"relamount",relamount);
return(inner);
}
double UPDATE(struct exchange_info *exchange,char *base,char *rel,struct exchange_quote *bidasks,int32_t maxdepth,double commission,cJSON *argjson,int32_t invert)
{
int32_t flip,i,n,is_MS; uint64_t baseamount,relamount,qty,pqt,ap_mult,baseid;
char url[1024],*str,*cmd,*field; struct supernet_info *myinfo = SuperNET_MYINFO(0);
uint32_t timestamp; cJSON *json,*bids,*asks,*srcobj,*item,*array; double price,vol,hbla = 0.;
if ( NXT_ASSETID != stringbits("NXT") || (strcmp(rel,"nxt") != 0 && strcmp(rel,"NXT") != 0 && strcmp(rel,"5527630") != 0) )
{
printf("NXT_ASSETID.%llu != %llu stringbits rel.%s\n",(long long)NXT_ASSETID,(long long)stringbits("NXT"),rel);//, getchar();
return(0);
}
baseid = NXT_assetid(base);
ap_mult = get_assetmult(myinfo,&is_MS,baseid);
bids = cJSON_CreateArray(), asks = cJSON_CreateArray();
for (flip=0; flip<2; flip++)
{
/*{
"offer": "16959774565785265980",
"expirationHeight": 1000000,
"accountRS": "NXT-QFAF-GR4F-RBSR-AXW2G",
"limit": "9000000",
"currency": "5775213290661997199",
"supply": "0",
"account": "9728792749189838093",
"height": 348856,
"rateNQT": "650"
}*/
if ( is_MS == 0 )
{
if ( flip == 0 )
cmd = "getBidOrders", field = "bidOrders", array = bids;
else cmd = "getAskOrders", field = "askOrders", array = asks;
sprintf(url,"requestType=%s&asset=%llu&limit=%d",cmd,(long long)baseid,maxdepth);
}
else
{
if ( flip == 0 )
cmd = "getBuyOffers", field = "offers", array = bids;
else cmd = "getSellOffers", field = "offers", array = asks;
sprintf(url,"requestType=%s&currency=%llu&limit=%d",cmd,(long long)baseid,maxdepth);
}
if ( (str= issue_NXTPOST(url)) != 0 )
{
//printf("{%s}\n",str);
if ( (json= cJSON_Parse(str)) != 0 )
{
if ( (srcobj= jarray(&n,json,field)) != 0 )
{
for (i=0; i<n && i<maxdepth; i++)
{
/*
"quantityQNT": "79",
"priceNQT": "13499000000",
"transactionHeight": 480173,
"accountRS": "NXT-FJQN-8QL2-BMY3-64VLK",
"transactionIndex": 1,
"asset": "15344649963748848799",
"type": "ask",
"account": "5245394173527769812",
"order": "17926122097022414596",
"height": 480173
*/
item = cJSON_GetArrayItem(srcobj,i);
if ( is_MS == 0 )
qty = j64bits(item,"quantityQNT"), pqt = j64bits(item,"priceNQT");
else qty = j64bits(item,"limit"), pqt = j64bits(item,"rateNQT");
baseamount = (qty * ap_mult), relamount = (qty * pqt);
price = NXT_price_volume(&vol,baseamount,relamount);
//printf("(%llu %llu) %f %f mult.%llu qty.%llu pqt.%llu baseamount.%lld relamount.%lld\n",(long long)prices->baseid,(long long)prices->relid,price,vol,(long long)prices->ap_mult,(long long)qty,(long long)pqt,(long long)baseamount,(long long)relamount);
timestamp = get_blockutime(myinfo,juint(item,"height"));
item = inner_json(price,vol,timestamp,j64bits(item,is_MS == 0 ? "order" : "offer"),j64bits(item,"account"),qty,pqt,baseamount,relamount);
cJSON_AddItemToArray(array,item);
}
}
free_json(json);
}
free(str);
} else printf("cant get.(%s)\n",url);
}
json = cJSON_CreateObject();
cJSON_AddItemToObject(json,"bids",bids);
cJSON_AddItemToObject(json,"asks",asks);
if ( Debuglevel > 2 )
printf("invert.%d NXTAE.(%s)\n",invert,jprint(json,0));
hbla = exchanges777_json_orderbook(exchange,commission,base,rel,bidasks,maxdepth,json,0,"bids","asks",0,0,invert);
free_json(json);
return(hbla);
}
uint64_t submit_triggered_nxtae(struct supernet_info *myinfo,int32_t dotrade,char **retjsonstrp,int32_t is_MS,char *bidask,uint64_t assetid,uint64_t qty,uint64_t NXTprice,char *triggerhash,char *comment,char *otherNXT,uint32_t triggerheight,char *refhash)
{
int32_t deadline = 1 + 20; uint64_t txid = 0; struct destbuf errstr; char cmd[4096],secret[8192],*jsonstr; cJSON *json;
if ( retjsonstrp != 0 )
*retjsonstrp = 0;
if ( triggerheight != 0 )
deadline = DEFAULT_NXT_DEADLINE;
escape_code(secret,myinfo->secret);
if ( dotrade == 0 )
strcpy(secret,"<secret>");
sprintf(cmd,"requestType=%s&secretPhrase=%s&feeNQT=%u&deadline=%d",bidask,secret,0,deadline);
sprintf(cmd+strlen(cmd),"&%s=%llu&%s=%llu",is_MS!=0?"units":"quantityQNT",(long long)qty,is_MS!=0?"currency":"asset",(long long)assetid);
if ( NXTprice != 0 )
{
if ( is_MS != 0 )
sprintf(cmd+strlen(cmd),"&rateNQT=%llu",(long long)NXTprice);
else sprintf(cmd+strlen(cmd),"&priceNQT=%llu",(long long)NXTprice);
}
if ( otherNXT != 0 )
sprintf(cmd+strlen(cmd),"&recipient=%s",otherNXT);
if ( refhash != 0 )
sprintf(cmd+strlen(cmd),"&referencedTransactionFullHash=%s",refhash);
if ( triggerhash != 0 && triggerhash[0] != 0 )
sprintf(cmd+strlen(cmd),"&phased=true&phasingFinishHeight=%u&phasingVotingModel=4&phasingQuorum=1&phasingLinkedFullHash=%s",triggerheight,triggerhash);
if ( comment != 0 && comment[0] != 0 )
sprintf(cmd+strlen(cmd),"&message=%s",comment);
if ( dotrade == 0 )
{
if ( retjsonstrp != 0 )
{
strcat(cmd,"&broadcast=false");
*retjsonstrp = issue_NXTPOST(cmd);
}
return(0);
}
if ( (jsonstr= issue_NXTPOST(cmd)) != 0 )
{
printf("NXT.(%s) -> (%s)\n",cmd,jsonstr);
_stripwhite(jsonstr,' ');
if ( (json= cJSON_Parse(jsonstr)) != 0 )
{
copy_cJSON(&errstr,cJSON_GetObjectItem(json,"error"));
if ( errstr.buf[0] == 0 )
copy_cJSON(&errstr,cJSON_GetObjectItem(json,"errorDescription"));
if ( errstr.buf[0] != 0 )
{
printf("submit_triggered_bidask.(%s) -> (%s)\n",cmd,jsonstr);
if ( retjsonstrp != 0 )
*retjsonstrp = clonestr(errstr.buf);
}
else txid = get_API_nxt64bits(cJSON_GetObjectItem(json,"transaction"));
}
free(jsonstr);
}
return(txid);
}
char *NXT_phasedxfer(struct supernet_info *myinfo,char *othercoin,char *othercoinaddr,char *otherNXT,uint64_t assetid,double volume,char *comment)
{
uint8_t NXT_rmd160[20],addrtype; int32_t is_MS,triggerheight,dotrade = 0;
char onetimecoinaddr[64],triggerhash[41],*cmd,*signedtx = 0; uint64_t ap_mult;
if ( (triggerheight= get_NXTheight(myinfo,0)) != 0 )
{
bitcoin_addr2rmd160(&addrtype,NXT_rmd160,onetimecoinaddr);
init_hexbytes_noT(triggerhash,NXT_rmd160,20);
triggerheight += DEFAULT_NXT_DEADLINE;
if ( (ap_mult= get_assetmult(myinfo,&is_MS,assetid)) == 0 )
return(0);
else
{
if ( assetid == 0 || assetid == NXT_ASSETID )
cmd = "sendMoney";
else if ( is_MS == 0 )
cmd = "transferAsset";
else cmd = "transferCurrency";
submit_triggered_nxtae(myinfo,dotrade,&signedtx,is_MS,cmd,assetid,(volume * SATOSHIDEN) / ap_mult,0,triggerhash,comment,otherNXT,triggerheight,0);
return(signedtx);
}
} else return(0);
}
char *fill_nxtae(struct supernet_info *myinfo,int32_t dotrade,uint64_t *txidp,int32_t dir,double price,double volume,uint64_t baseid,uint64_t relid)
{
uint64_t txid,assetid,avail,qty,priceNQT,ap_mult; int32_t is_MS; char retbuf[512],*errstr,*cmdstr;
if ( baseid == NXT_ASSETID )
dir = -dir, assetid = relid;
else if ( relid == NXT_ASSETID )
assetid = baseid;
else return(clonestr("{\"error\":\"NXT AE order without NXT\"}"));
if ( (ap_mult= get_assetmult(myinfo,&is_MS,assetid)) == 0 )
return(clonestr("{\"error\":\"assetid not found\"}"));
qty = calc_asset_qty(myinfo,&is_MS,&avail,&priceNQT,0,assetid,price,volume);
if ( is_MS == 0 )
cmdstr = dir > 0 ? "placeBidOrder" : "placeAskOrder";
else cmdstr = dir > 0 ? "currencyBuy" : "currencySell";
txid = submit_triggered_nxtae(myinfo,dotrade,&errstr,is_MS,cmdstr,assetid,qty,priceNQT,0,0,0,0,0);
if ( errstr != 0 )
sprintf(retbuf,"{\"error\":\"%s\"}",errstr), free(errstr);
else sprintf(retbuf,"{\"result\":\"success\",\"txid\":\"%llu\"}",(long long)txid);
if ( txidp != 0 )
*txidp = txid;
return(clonestr(retbuf));
}
uint64_t TRADE(int32_t dotrade,char **retstrp,struct exchange_info *exchange,char *base,char *rel,int32_t dir,double price,double volume,cJSON *argjson)
{
uint64_t baseid,relid; char *retstr; uint64_t txid = 0; struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (baseid= NXT_assetid(base)) != 0 && (relid= NXT_assetid(rel)) != 0 )
{
retstr = fill_nxtae(myinfo,dotrade,&txid,dir,price,volume,baseid,relid);
if ( retstrp != 0 )
*retstrp = retstr;
else free(retstr);
}
return(txid);
}
char *PARSEBALANCE(struct exchange_info *exchange,double *balancep,char *coinstr,cJSON *argjson)
{
cJSON *item; char extra[256]; struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( strcmp(coinstr,"NXT") == 0 )
{
if ( (item= _issue_NXTjson(myinfo,"getAccount")) != 0 )
{
jadd(item,"NXT",item);
jaddstr(item,"result","success");
*balancep = dstr(j64bits(item,"balanceNQT"));
return(jprint(item,1));
}
}
else if ( NXT_assetpolarity(myinfo,coinstr) != 0 )
{
sprintf(extra,"getAccountAssets&asset=%s",coinstr);
if ( (item= _issue_NXTjson(myinfo,extra)) != 0 )
{
if ( jstr(item,"assetid") != 0 )
{
jaddstr(item,"result","success");
return(jprint(item,1));
}
free_json(item);
}
}
else
{
sprintf(extra,"getAccountCurrencies&currency=%s",coinstr);
if ( (item= _issue_NXTjson(myinfo,extra)) != 0 )
{
if ( jstr(item,"currency") != 0 )
{
jaddstr(item,"result","success");
return(jprint(item,1));
}
free_json(item);
}
}
return(clonestr("{\"error\":\"cant get coin balance\"}"));
}
cJSON *BALANCES(struct exchange_info *exchange,cJSON *argjson)
{
cJSON *item,*retjson = cJSON_CreateObject(); struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (item= _issue_NXTjson(myinfo,"getAccountAssets")) != 0 )
jadd(retjson,"assets",item);
if ( (item= _issue_NXTjson(myinfo,"getAccountCurrencies")) != 0 )
jadd(retjson,"currencies",item);
if ( (item= _issue_NXTjson(myinfo,"getAccount")) != 0 )
jadd(retjson,"NXT",item);
jaddstr(retjson,"result","success");
return(retjson);
}
char *ORDERSTATUS(struct exchange_info *exchange,uint64_t quoteid,cJSON *argjson)
{
uint64_t nxt64bits; struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (nxt64bits= _get_AEquote(myinfo,"Bid",quoteid)) == 0 )
return(_get_AEquotestr(myinfo,"Ask",quoteid));
else return(_get_AEquotestr(myinfo,"Bid",quoteid));
}
char *CANCELORDER(struct exchange_info *exchange,uint64_t orderid,cJSON *argjson)
{
uint64_t nxt64bits; char cmd[4096],secret[8192],*str = "Bid",*retstr = 0; struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (nxt64bits= _get_AEquote(myinfo,str,orderid)) == 0 )
str = "Ask", nxt64bits = _get_AEquote(myinfo,str,orderid);
if ( nxt64bits == myinfo->myaddr.nxt64bits )
{
escape_code(secret,myinfo->secret);
sprintf(cmd,"requestType=cancel%sOrder&secretPhrase=%s&feeNQT=%d&deadline=%d&order=%llu",str,secret,0,DEFAULT_NXT_DEADLINE,(long long)orderid);
retstr = issue_NXTPOST(cmd);
//printf("(%s) -> (%s)\n",cmd,retstr);
}
else retstr = clonestr("{\"error\":\"cant cancel orderid\"}");
return(retstr);
}
char *OPENORDERS(struct exchange_info *exchange,cJSON *argjson)
{
cJSON *item,*retjson = cJSON_CreateObject(); struct supernet_info *myinfo = SuperNET_MYINFO(0);
if ( (item= _issue_NXTjson(myinfo,"getBuyOffers")) != 0 )
jadd(retjson,"buyoffers",item);
if ( (item= _issue_NXTjson(myinfo,"getSellOffers")) != 0 )
jadd(retjson,"selloffers",item);
if ( (item= _issue_NXTjson(myinfo,"getAccountCurrentBidOrders")) != 0 )
jadd(retjson,"bidorders",item);
if ( (item= _issue_NXTjson(myinfo,"getAccountCurrentAskOrders")) != 0 )
jadd(retjson,"sellorders",item);
jaddstr(retjson,"result","success");
return(jprint(retjson,1));
}
char *TRADEHISTORY(struct exchange_info *exchange,cJSON *argjson)
{
return(clonestr("{\"error\":\"nxtae tradehistory here\"}"));
}
char *WITHDRAW(struct exchange_info *exchange,char *base,double amount,char *destaddr,cJSON *argjson)
{
return(clonestr("{\"error\":\"MGW withdraw here\"}"));
}
struct exchange_funcs nxtae_funcs = EXCHANGE_FUNCS(nxtae,EXCHANGE_NAME);
#include "exchange_undefs.h"