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

/******************************************************************************
* 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\"}"));
}