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
915 lines
35 KiB
/******************************************************************************
|
|
* 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. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#define DEFAULT_NXT_DEADLINE 720
|
|
#define issue_NXTPOST(cmdstr) bitcoind_RPC(0,"curl",myinfo->NXTAPIURL,0,0,cmdstr)
|
|
#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¤cy=%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¤cy=%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¤cy=%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¤cy=%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"
|
|
|