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.
366 lines
15 KiB
366 lines
15 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. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
// included from gecko.c
|
|
// struct gecko_memtx { bits256 txid; char *rawtx; int64_t txfee; int32_t pending; uint32_t ipbits; };
|
|
|
|
struct gecko_mempool *gecko_mempoolfind(struct supernet_info *myinfo,struct iguana_info *virt,int32_t *numotherp,uint32_t ipbits)
|
|
{
|
|
int32_t j,firstz,numother; bits256 *othertxids; struct gecko_mempool *otherpool = 0;
|
|
othertxids = 0;
|
|
numother = firstz = 0;
|
|
for (j=0; j<NUMRELAYS; j++)
|
|
{
|
|
if ( (otherpool= virt->mempools[j]) != 0 )
|
|
{
|
|
if ( otherpool->ipbits == ipbits )
|
|
{
|
|
othertxids = otherpool->txids;
|
|
numother = otherpool->numtx;
|
|
break;
|
|
}
|
|
} else firstz = j;
|
|
}
|
|
if ( otherpool == 0 )
|
|
{
|
|
virt->mempools[firstz] = otherpool = calloc(1,sizeof(struct gecko_mempool));
|
|
otherpool->ipbits = (uint32_t)ipbits;
|
|
}
|
|
return(otherpool);
|
|
}
|
|
|
|
void gecko_mempool_sync(struct supernet_info *myinfo,struct iguana_info *virt,bits256 *reftxids,int32_t numtx)
|
|
{
|
|
int32_t i,j,k,n,num,numother; struct iguana_peer *addr; bits256 txid,*txids; struct gecko_mempool *pool,*otherpool; struct iguana_info *coin;
|
|
if ( (pool= virt->mempool) == 0 || NUMRELAYS <= 0 )
|
|
return;
|
|
n = sqrt(NUMRELAYS) + 2;
|
|
if ( n > NUMRELAYS )
|
|
NUMRELAYS = n;
|
|
i = (myinfo->myaddr.myipbits % n);
|
|
txids = calloc(pool->numtx,sizeof(bits256));
|
|
if ( virt->peers == 0 )
|
|
coin = iguana_coinfind("BTCD");
|
|
else coin = virt;
|
|
for (; i<NUMRELAYS; i+=n)
|
|
{
|
|
printf("mempool_sync.%d\n",i);
|
|
if ( (addr= iguana_peerfindipbits(coin,RELAYS[i].ipbits,1)) != 0 )
|
|
{
|
|
if ( (otherpool= gecko_mempoolfind(myinfo,virt,&numother,RELAYS[i].ipbits)) != 0 )
|
|
{
|
|
for (j=num=0; j<pool->numtx; j++)
|
|
{
|
|
txid = reftxids[j];
|
|
if ( numother > 0 )
|
|
{
|
|
for (k=0; k<numother; k++)
|
|
if ( bits256_cmp(txid,otherpool->txids[k]) == 0 )
|
|
break;
|
|
if ( k != numother )
|
|
continue;
|
|
}
|
|
txids[num++] = txid;
|
|
}
|
|
if ( num > 0 )
|
|
basilisk_hashes_send(myinfo,virt,addr,"MEM",txids,num);
|
|
}
|
|
}
|
|
}
|
|
free(txids);
|
|
}
|
|
|
|
uint8_t *gecko_txdata(struct gecko_memtx *memtx)
|
|
{
|
|
return((void *)((long)memtx->data256 + memtx->numoutputs * sizeof(int64_t) + memtx->numinputs * sizeof(bits256)));
|
|
}
|
|
|
|
int64_t *gecko_valueptr(struct gecko_memtx *memtx,int32_t vout)
|
|
{
|
|
return((void *)((long)memtx->data256 + vout * sizeof(int64_t) + memtx->numinputs * sizeof(bits256)));
|
|
}
|
|
|
|
int32_t gecko_memtxcmp(struct gecko_memtx *memtxA,struct gecko_memtx *memtxB)
|
|
{
|
|
int32_t i,numdiff; int64_t valA,valB,diff;
|
|
if ( memtxA->numinputs == memtxB->numinputs && memtxA->numoutputs == memtxB->numoutputs )
|
|
{
|
|
for (i=0; i<memtxA->numinputs; i++)
|
|
{
|
|
if ( bits256_cmp(memtxA->data256[i],memtxB->data256[i]) != 0 )
|
|
return(-1 - 2*i);
|
|
}
|
|
for (i=numdiff=0; i<memtxA->numoutputs; i++)
|
|
{
|
|
memcpy(&valA,gecko_valueptr(memtxA,i),sizeof(valA));
|
|
memcpy(&valB,gecko_valueptr(memtxB,i),sizeof(valB));
|
|
if ( (diff= valA - valB) < 0 )
|
|
diff = -diff;
|
|
if ( diff > 100000 )
|
|
return(-1);
|
|
if ( valA != valB )
|
|
numdiff++;
|
|
}
|
|
if ( numdiff > 1 )
|
|
return(-memtxA->numinputs*2 - 2);
|
|
|
|
return(0);
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
struct gecko_memtx *gecko_unspentfind(struct gecko_memtx ***ptrpp,struct iguana_info *virt,bits256 txid)
|
|
{
|
|
struct gecko_mempool *pool; int32_t i; struct gecko_memtx *memtx;
|
|
if ( (pool= virt->mempool) != 0 )
|
|
{
|
|
for (i=0; i<pool->numtx; i++)
|
|
if ( (memtx= pool->txs[i]) != 0 && bits256_cmp(memtx->txid,txid) == 0 )
|
|
{
|
|
if ( ptrpp != 0 )
|
|
*ptrpp = &pool->txs[i];
|
|
return(memtx);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
struct gecko_memtx *gecko_mempool_txadd(struct supernet_info *myinfo,struct iguana_info *virt,int32_t height,char *rawtx,uint32_t senderbits,int32_t suppress_pubkeys)
|
|
{
|
|
struct gecko_memtx *spentmemtx,**ptrp,*memtx = 0; uint8_t *extraspace; char *str; struct iguana_msgtx msgtx; int32_t i,len,extralen = 65536; cJSON *retjson; int64_t value;
|
|
extraspace = calloc(1,extralen);
|
|
if ( (str= iguana_validaterawtx(myinfo,virt,height,&msgtx,extraspace,extralen,rawtx,1,suppress_pubkeys)) != 0 )
|
|
{
|
|
if ( (retjson= cJSON_Parse(str)) != 0 )
|
|
{
|
|
if ( jobj(retjson,"error") == 0 )
|
|
{
|
|
len = (int32_t)strlen(rawtx) >> 1;
|
|
memtx = calloc(1,sizeof(*memtx) + len + msgtx.numoutputs * sizeof(int64_t) + msgtx.numinputs * sizeof(bits256));
|
|
memtx->numinputs = msgtx.numinputs;
|
|
memtx->numoutputs = msgtx.numoutputs;
|
|
memtx->inputsum = msgtx.inputsum;
|
|
memtx->outputsum = msgtx.outputsum;
|
|
memtx->txfee = msgtx.txfee;
|
|
memtx->txid = msgtx.txid;
|
|
memtx->ipbits = senderbits;
|
|
memtx->datalen = len;
|
|
memtx->feeperkb = dstr(memtx->txfee) / (memtx->datalen / 1024.);
|
|
for (i=0; i<msgtx.numoutputs; i++)
|
|
memcpy(gecko_valueptr(memtx,i),&msgtx.vouts[i].value,sizeof(msgtx.vouts[i].value));
|
|
decode_hex(gecko_txdata(memtx),len,rawtx);
|
|
for (i=0; i<msgtx.numinputs; i++)
|
|
memtx->data256[i] = msgtx.vins[i].prev_hash;
|
|
for (i=0; i<msgtx.numinputs; i++)
|
|
{
|
|
if ( (spentmemtx= gecko_unspentfind(&ptrp,virt->mempool,msgtx.vins[i].prev_hash)) != 0 )
|
|
{
|
|
memcpy(&value,gecko_valueptr(spentmemtx,msgtx.vins[i].prev_vout),sizeof(value));
|
|
if ( value < 0 )
|
|
{
|
|
if ( gecko_memtxcmp(spentmemtx,memtx) != 0 || memtx->txfee <= spentmemtx->txfee )
|
|
{
|
|
printf("already spent mempool error\n"); // check for replacment!
|
|
free(memtx);
|
|
}
|
|
else
|
|
{
|
|
printf("replace identical vins/vouts with higher txfee\n");
|
|
free(spentmemtx);
|
|
*ptrp = memtx;
|
|
}
|
|
memtx = 0;
|
|
free_json(retjson);
|
|
free(extraspace);
|
|
free(str);
|
|
return(0);
|
|
}
|
|
}
|
|
}
|
|
for (i=0; i<msgtx.numinputs; i++)
|
|
{
|
|
if ( (spentmemtx= gecko_unspentfind(0,virt->mempool,msgtx.vins[i].prev_hash)) != 0 )
|
|
{
|
|
memcpy(&value,gecko_valueptr(spentmemtx,msgtx.vins[i].prev_vout),sizeof(value));
|
|
value = -value;
|
|
memcpy(gecko_valueptr(spentmemtx,msgtx.vins[i].prev_vout),&value,sizeof(value));
|
|
}
|
|
}
|
|
} else printf("gecko_mempool_txadd had error.(%s)\n",str);
|
|
free_json(retjson);
|
|
} else printf("gecko_mempool_txadd couldnt parse.(%s)\n",str);
|
|
free(str);
|
|
}
|
|
free(extraspace);
|
|
return(memtx);
|
|
}
|
|
|
|
struct gecko_mempool *gecko_mempool_alloc(int32_t otherflag)
|
|
{
|
|
struct gecko_mempool *pool;
|
|
pool = calloc(1,sizeof(*pool));
|
|
if ( otherflag == 0 )
|
|
pool->txs = calloc(0xffff,sizeof(*pool->txs));
|
|
return(pool);
|
|
}
|
|
|
|
int32_t basilisk_respond_geckogettx(struct supernet_info *myinfo,struct iguana_info *virt,uint8_t *serialized,int32_t maxsize,cJSON *valsobj,bits256 hash2)
|
|
{
|
|
int32_t datalen = 0;
|
|
char str[65]; printf("got request for GTX.%s\n",bits256_str(str,hash2));
|
|
// find txid and set serialized
|
|
return(datalen);
|
|
}
|
|
|
|
char *gecko_txarrived(struct supernet_info *myinfo,struct iguana_info *virt,char *remoteaddr,uint8_t *serialized,int32_t datalen,bits256 txid)
|
|
{
|
|
struct gecko_mempool *pool; int64_t txfee,vinstotal,voutstotal; uint64_t value; int32_t i,numvins,numvouts,txlen,spentheight,minconf,maxconf; struct iguana_msgtx msg; char *rawtx; struct gecko_memtx *memtx; struct iguana_info *btcd; struct iguana_outpoint outpt;
|
|
memset(&msg,0,sizeof(msg));
|
|
iguana_memreset(&virt->TXMEM);
|
|
txlen = iguana_rwtx(myinfo,virt->chain->zcash,0,virt,&virt->TXMEM,serialized,&msg,datalen,&txid,virt->chain->isPoS,strcmp("VPN",virt->symbol) == 0);
|
|
vinstotal = voutstotal = 0;
|
|
maxconf = virt->longestchain;
|
|
minconf = virt->chain->minconfirms;
|
|
if ( (numvins= msg.tx_in) > 0 )
|
|
{
|
|
for (i=0; i<numvins; i++)
|
|
{
|
|
if ( iguana_RTunspentindfind(myinfo,virt,&outpt,0,0,0,&value,&spentheight,msg.vins[i].prev_hash,msg.vins[i].prev_vout,virt->bundlescount-1,1) == 0 )
|
|
{
|
|
if ( iguana_unspentavail(myinfo,virt,outpt,minconf,maxconf) != value )
|
|
{
|
|
printf("vin.%d already spent\n",i);
|
|
return(clonestr("{\"error\":\"gecko tx has double spend\"}"));
|
|
}
|
|
vinstotal += value;
|
|
}
|
|
}
|
|
}
|
|
if ( (numvouts= msg.tx_out) > 0 )
|
|
for (i=0; i<numvouts; i++)
|
|
voutstotal += msg.vouts[i].value;
|
|
if ( (txfee= (vinstotal - voutstotal)) < 0 )
|
|
return(clonestr("{\"error\":\"gecko tx has more spends than inputs\"}"));
|
|
if ( txlen <= 0 )
|
|
return(clonestr("{\"error\":\"couldnt decode gecko tx\"}"));
|
|
if ( (pool= virt->mempool) == 0 )
|
|
pool = virt->mempool = gecko_mempool_alloc(0);
|
|
rawtx = calloc(1,datalen*2 + 1);
|
|
init_hexbytes_noT(rawtx,serialized,datalen);
|
|
if ( (memtx= gecko_mempool_txadd(myinfo,virt,virt->blocks.hwmchain.height,rawtx,(uint32_t)calc_ipbits(remoteaddr),0)) != 0 )
|
|
{
|
|
for (i=0; i<pool->numtx; i++)
|
|
{
|
|
if ( memtx->feeperkb >= pool->txs[i]->feeperkb )
|
|
break;
|
|
}
|
|
pool->txs[pool->numtx++] = pool->txs[i];
|
|
pool->txs[i] = memtx;
|
|
char str[65]; printf("add tx.%s to mempool i.%d numtx.%d\n",bits256_str(str,memtx->txid),i,pool->numtx);
|
|
for (i=0; i<pool->numtx; i++)
|
|
pool->txids[i] = pool->txs[i]->txid;
|
|
if ( (btcd= iguana_coinfind("BTCD")) != 0 && btcd->FULLNODE != 0 && myinfo->IAMRELAY != 0 )
|
|
gecko_mempool_sync(myinfo,virt,pool->txids,pool->numtx);
|
|
}
|
|
else
|
|
{
|
|
free(rawtx);
|
|
return(clonestr("{\"error\":\"geckotx invalid\"}"));
|
|
}
|
|
free(rawtx);
|
|
return(clonestr("{\"result\":\"gecko tx queued\"}"));
|
|
}
|
|
|
|
char *basilisk_respond_geckotx(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 txid,int32_t from_basilisk)
|
|
{
|
|
bits256 checktxid; char *symbol; struct iguana_info *virt;
|
|
if ( data != 0 && datalen != 0 && (symbol= jstr(valsobj,"symbol")) != 0 && (virt= iguana_coinfind(symbol)) != 0 )
|
|
{
|
|
checktxid = bits256_doublesha256(0,data,datalen);
|
|
if ( bits256_cmp(txid,checktxid) == 0 )
|
|
return(gecko_txarrived(myinfo,virt,addr,data,datalen,txid));
|
|
else return(clonestr("{\"error\":\"geckotx mismatched txid\"}"));
|
|
}
|
|
return(clonestr("{\"error\":\"no geckotx chain or missing tx data\"}"));
|
|
}
|
|
|
|
struct gecko_memtx **gecko_mempool_txptrs(struct supernet_info *myinfo,struct iguana_info *virt,int64_t *rewardp,int32_t *txn_countp,void **ptrp,void *space,int32_t max,int32_t height)
|
|
{
|
|
int32_t i,n; struct gecko_memtx **txptrs; struct gecko_mempool *pool; int64_t txfees = 0,reward = virt->chain->initialreward;
|
|
if ( virt->chain->halvingduration != 0 && (n= (height / virt->chain->halvingduration)) != 0 )
|
|
{
|
|
for (i=0; i<n; i++)
|
|
reward >>= 1;
|
|
}
|
|
*ptrp = 0;
|
|
*txn_countp = 0;
|
|
if ( (pool= virt->mempool) == 0 )
|
|
pool = virt->mempool = gecko_mempool_alloc(0);
|
|
if ( pool->numtx*sizeof(char *) <= max )
|
|
txptrs = space;
|
|
else
|
|
{
|
|
txptrs = calloc(pool->numtx,sizeof(char *));
|
|
*ptrp = (void *)txptrs;
|
|
}
|
|
for (i=n=0; i<pool->numtx; i++)
|
|
{
|
|
if ( pool->txs[i]->pending == 0 )
|
|
{
|
|
txfees += pool->txs[i]->txfee;
|
|
txptrs[n++] = pool->txs[i];
|
|
pool->txs[i]->pending = height;
|
|
}
|
|
}
|
|
*rewardp = (reward + txfees);
|
|
if ( n > 0 )
|
|
printf("reward %.8f n.%d numtx.%d\n",dstr(*rewardp),n,pool->numtx);
|
|
if ( (*txn_countp= n) != 0 )
|
|
return(txptrs);
|
|
else return(0);
|
|
}
|
|
|
|
char *gecko_mempoolarrived(struct supernet_info *myinfo,struct iguana_info *virt,char *remoteaddr,uint8_t *data,int32_t datalen,bits256 hash2)
|
|
{
|
|
int32_t i,j,numother,len = 0; struct gecko_mempool *otherpool; bits256 txid;
|
|
if ( (otherpool= gecko_mempoolfind(myinfo,virt,&numother,(uint32_t)calc_ipbits(remoteaddr))) != 0 )
|
|
{
|
|
if ( numother > 0 )
|
|
{
|
|
for (i=0; i<numother; i++)
|
|
{
|
|
len += iguana_rwbignum(0,&data[len],sizeof(txid),txid.bytes);
|
|
for (j=0; j<otherpool->numtx; j++)
|
|
if ( bits256_cmp(txid,otherpool->txids[j]) == 0 )
|
|
break;
|
|
if ( j == otherpool->numtx )
|
|
{
|
|
otherpool->txids[otherpool->numtx++] = txid;
|
|
printf("if first time, submit request for txid\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(clonestr("{\"result\":\"gecko mempool queued\"}"));
|
|
}
|
|
|
|
char *basilisk_respond_mempool(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 *symbol; struct iguana_info *virt;
|
|
printf("got getmempool request\n");
|
|
if ( (symbol= jstr(valsobj,"symbol")) != 0 && (virt= iguana_coinfind(symbol)) != 0 )
|
|
return(gecko_mempoolarrived(myinfo,virt,_addr,data,datalen,hash));
|
|
else return(clonestr("{\"error\":\"couldt find gecko chain\"}"));
|
|
}
|
|
|