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.
516 lines
24 KiB
516 lines
24 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. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#include "iguana777.h"
|
|
|
|
#ifdef DEPRECATED_HHUTXO
|
|
|
|
struct iguana_hhaccount *iguana_hhaccountfind(struct iguana_info *coin,uint64_t pval)
|
|
{
|
|
struct iguana_hhaccount *hhacct;
|
|
HASH_FIND(hh,coin->accountstable,&pval,sizeof(pval),hhacct);
|
|
return(hhacct);
|
|
}
|
|
|
|
int32_t iguana_utxoupdate(struct iguana_info *coin,int16_t spent_hdrsi,uint32_t spent_unspentind,uint32_t spent_pkind,uint64_t spent_value,uint32_t spendind,uint32_t fromheight,uint8_t *rmd160)
|
|
{
|
|
struct iguana_hhutxo *hhutxo,*tmputxo; struct iguana_hhaccount *hhacct,*tmpacct; uint64_t uval,pval;
|
|
if ( spent_hdrsi < 0 )
|
|
{
|
|
printf(">>>>>>>>>> RESET UTXO HASH <<<<<<<<<\n");
|
|
if ( coin->utxotable != 0 )
|
|
{
|
|
HASH_ITER(hh,coin->utxotable,hhutxo,tmputxo)
|
|
{
|
|
hhutxo->u.lockedflag = 0;
|
|
hhutxo->u.spentflag = 0;
|
|
hhutxo->u.fromheight = 0;
|
|
hhutxo->u.prevunspentind = 0;
|
|
//free(hhutxo);
|
|
}
|
|
}
|
|
if ( coin->accountstable != 0 )
|
|
{
|
|
HASH_ITER(hh,coin->accountstable,hhacct,tmpacct)
|
|
{
|
|
hhacct->a.lastunspentind = 0;
|
|
hhacct->a.total = 0;
|
|
//free(hhacct);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
if ( coin->disableUTXO != 0 )
|
|
{
|
|
printf("skip utxoupdate when disabled\n");
|
|
return(0);
|
|
}
|
|
uval = ((uint64_t)spent_hdrsi << 32) | spent_unspentind;
|
|
pval = ((uint64_t)spent_hdrsi << 32) | spent_pkind;
|
|
if ( (hhutxo= iguana_hhutxofind(coin,uval)) != 0 )
|
|
{
|
|
if ( hhutxo->u.spentflag != 0 )
|
|
{
|
|
printf("hhutxo.%p spentflag.%d\n",hhutxo,hhutxo->u.spentflag);
|
|
return(-1);
|
|
}
|
|
else if ( spendind == hhutxo->u.spendind && fromheight == hhutxo->u.fromheight )
|
|
{
|
|
printf("redundant hhutxo ht.%d s%u\n",fromheight,spendind);
|
|
return(0);
|
|
}
|
|
}
|
|
hhutxo = calloc(1,sizeof(*hhutxo));
|
|
hhutxo->uval = uval;
|
|
HASH_ADD_KEYPTR(hh,coin->utxotable,&hhutxo->uval,sizeof(hhutxo->uval),hhutxo);
|
|
if ( (hhacct= iguana_hhaccountfind(coin,pval)) == 0 )
|
|
{
|
|
hhacct = calloc(1,sizeof(*hhacct));
|
|
hhacct->pval = pval;
|
|
HASH_ADD_KEYPTR(hh,coin->accountstable,&hhacct->pval,sizeof(hhacct->pval),hhacct);
|
|
}
|
|
//printf("create hhutxo.%p hhacct.%p from.%d\n",hhutxo,hhacct,fromheight);
|
|
hhutxo->u.spentflag = 1;
|
|
hhutxo->u.lockedflag = 0;
|
|
hhutxo->u.fromheight = fromheight;
|
|
hhutxo->u.spendind = spendind;
|
|
hhutxo->u.prevunspentind = hhacct->a.lastunspentind;
|
|
hhacct->a.lastunspentind = spent_unspentind;
|
|
hhacct->a.total += spent_value;
|
|
/*struct iguana_utxoaddr *utxoaddr;
|
|
if ( (utxoaddr= iguana_utxoaddrfind(1,coin,spent_hdrsi,spent_pkind,rmd160,&coin->RTprev)) != 0 )
|
|
{
|
|
utxoaddr->RTdebits += spent_value;
|
|
coin->RTdebits += spent_value;
|
|
//printf("from.%d [%d] u%u -= %.8f\n",fromheight,spent_hdrsi,spent_pkind,dstr(spent_value));
|
|
}*/
|
|
return(0);
|
|
}
|
|
#endif
|
|
|
|
void iguana_hhutxo_purge(struct iguana_info *coin)
|
|
{
|
|
struct iguana_hhutxo *hhutxo,*tmp;
|
|
HASH_ITER(hh,coin->utxotable,hhutxo,tmp)
|
|
{
|
|
HASH_DELETE(hh,coin->utxotable,hhutxo);
|
|
free(hhutxo);
|
|
}
|
|
}
|
|
|
|
struct iguana_hhutxo *iguana_hhutxofind(struct iguana_info *coin,uint64_t uval)
|
|
{
|
|
struct iguana_hhutxo *hhutxo;
|
|
HASH_FIND(hh,coin->utxotable,&uval,sizeof(uval),hhutxo);
|
|
return(hhutxo);
|
|
}
|
|
|
|
int32_t iguana_RTutxofunc(struct iguana_info *coin,int32_t *fromheightp,int32_t *lockedflagp,struct iguana_outpoint spentpt,int32_t *RTspendflagp,int32_t lockflag,int32_t fromheight)
|
|
{
|
|
uint64_t val; struct iguana_hhutxo *hhutxo; struct iguana_utxo utxo; struct iguana_ramchain *ramchain; struct iguana_bundle *bp; struct iguana_ramchaindata *rdata; struct iguana_RTunspent *unspent; int32_t spentflag = 0;
|
|
*RTspendflagp = *lockedflagp = *fromheightp = 0;
|
|
memset(&utxo,0,sizeof(utxo));
|
|
if ( coin->disableUTXO != 0 )
|
|
{
|
|
printf("skip utxofind when disabled\n");
|
|
return(1);
|
|
}
|
|
if ( spentpt.isptr != 0 )
|
|
{
|
|
if ( (unspent= spentpt.ptr) != 0 )
|
|
{
|
|
if ( lockflag == 0 && fromheight == 0 )
|
|
{
|
|
if ( unspent->spend != 0 )
|
|
spentflag = 1;
|
|
if ( unspent->locked != 0 )
|
|
*lockedflagp = 1;
|
|
*fromheightp = unspent->fromheight;
|
|
}
|
|
else if ( fromheight != 0 )
|
|
{
|
|
unspent->fromheight = fromheight;
|
|
if ( unspent->spend == 0 )
|
|
printf("unexpected null spend when fromheight.%d\n",fromheight);
|
|
}
|
|
else if ( lockflag != 0 )
|
|
unspent->locked = 1;
|
|
}
|
|
else
|
|
{
|
|
printf("missing spentpt ptr when isptr?\n");
|
|
return(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( (bp= coin->bundles[spentpt.hdrsi]) == 0 )
|
|
return(1);
|
|
ramchain = &bp->ramchain;//(bp == coin->current) ? &coin->RTramchain : &bp->ramchain;
|
|
if ( (rdata= ramchain->H.data) == 0 )
|
|
return(1);
|
|
val = ((uint64_t)spentpt.hdrsi << 32) | spentpt.unspentind;
|
|
if ( fromheight != 0 )
|
|
utxo.fromheight = fromheight, utxo.spentflag = 1;
|
|
if ( spentpt.unspentind > 0 && spentpt.unspentind < rdata->numunspents )
|
|
{
|
|
if ( ramchain->Uextras != 0 )
|
|
{
|
|
utxo = ramchain->Uextras[spentpt.unspentind];
|
|
if ( fromheight != 0 )
|
|
utxo.fromheight = fromheight, utxo.spentflag = 1;
|
|
if ( lockflag != 0 || fromheight != 0 )
|
|
{
|
|
if ( (hhutxo= iguana_hhutxofind(coin,val)) == 0 )
|
|
{
|
|
hhutxo = calloc(1,sizeof(*hhutxo));
|
|
hhutxo->uval = val;
|
|
hhutxo->u = utxo;
|
|
HASH_ADD_KEYPTR(hh,coin->utxotable,&hhutxo->uval,sizeof(hhutxo->uval),hhutxo);
|
|
}
|
|
//printf("iguana_utxofind: need to change to new RT lock method\n");
|
|
}
|
|
}
|
|
if ( ramchain->Uextras == 0 || utxo.spentflag == 0 )
|
|
{
|
|
if ( (hhutxo= iguana_hhutxofind(coin,val)) != 0 )
|
|
{
|
|
utxo = hhutxo->u;
|
|
if ( fromheight != 0 )
|
|
{
|
|
utxo.fromheight = fromheight, utxo.spentflag = 1;
|
|
hhutxo->u = utxo;
|
|
}
|
|
}
|
|
//printf("iguana_utxofind: need to change to new RT method\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("%s illegal unspentind.%u vs %u hdrs.%d\n",coin->symbol,spentpt.unspentind,rdata->numunspents,spentpt.hdrsi);
|
|
}
|
|
}
|
|
if ( lockflag != 0 )
|
|
{
|
|
if ( utxo.lockedflag == 0 )
|
|
utxo.lockedflag = 1;
|
|
else printf("iguana_hhutxofind warning: locking already locked [%d].%u\n",spentpt.hdrsi,spentpt.unspentind);
|
|
} else utxo.lockedflag = 0;
|
|
if ( utxo.spentflag != 0 || utxo.lockedflag != 0 )
|
|
*RTspendflagp = 1;
|
|
*fromheightp = utxo.fromheight;
|
|
return(utxo.spentflag);
|
|
}
|
|
|
|
int32_t iguana_RTspentflag(struct supernet_info *myinfo,struct iguana_info *coin,int64_t *RTspendp,int32_t *spentheightp,struct iguana_ramchain *ramchain,struct iguana_outpoint spentpt,int32_t height,int32_t minconf,int32_t maxconf,uint64_t amount)
|
|
{
|
|
uint32_t numunspents; int32_t RTspentflag,spentflag,lockedflag,fromheight=0; uint64_t confs;//,RTspend = 0;
|
|
struct iguana_ramchaindata *rdata; struct iguana_RTunspent *unspent;
|
|
*spentheightp = -1;
|
|
if ( coin->disableUTXO != 0 )
|
|
{
|
|
//printf("skip spentflag when disabled\n");
|
|
return(0);
|
|
}
|
|
if ( spentpt.isptr != 0 )
|
|
{
|
|
if ( (unspent= spentpt.ptr) != 0 )
|
|
{
|
|
*spentheightp = unspent->fromheight;
|
|
if ( unspent->spend != 0 )
|
|
{
|
|
*RTspendp += (amount == 0) ? coin->txfee : amount;
|
|
return(1);
|
|
}
|
|
else if ( unspent->locked != 0 )
|
|
return(-1);
|
|
} else printf("missing spentpt ptr when isptr?\n");
|
|
return(0);
|
|
}
|
|
if ( (rdata= ramchain->H.data) == 0 )
|
|
return(0);
|
|
numunspents = rdata->numunspents;
|
|
spentflag = iguana_RTutxofunc(coin,&fromheight,&lockedflag,spentpt,&RTspentflag,0,0);
|
|
if ( spentflag != 0 && fromheight == 0 )
|
|
{
|
|
if ( height == 0 )
|
|
{
|
|
//printf("%s illegal unspentind.%u vs %u hdrs.%d zero fromheight.%d?\n",coin->symbol,spentpt.unspentind,numunspents,spentpt.hdrsi,fromheight);
|
|
height = spentpt.hdrsi*coin->chain->bundlesize + 1;
|
|
}
|
|
fromheight = height;
|
|
}
|
|
if ( RTspentflag != 0 )
|
|
*RTspendp += (amount == 0) ? coin->txfee : amount;
|
|
//printf("[%d] u%u %.8f, spentheight.%d vs height.%d spentflag.%d\n",spent_hdrsi,spent_unspentind,dstr(amount),fromheight,height,spentflag);
|
|
*spentheightp = fromheight;
|
|
if ( (confs= coin->blocks.hwmchain.height - fromheight) >= minconf && confs < maxconf && (height <= 0 || fromheight < height) )
|
|
{
|
|
//(*RTspendp) += RTspend;
|
|
if ( spentflag != 0 )
|
|
return(1);
|
|
else if ( lockedflag != 0 )
|
|
return(-1);
|
|
else return(0);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
int32_t iguana_volatileupdate(struct iguana_info *coin,int32_t incremental,struct iguana_ramchain *spentchain,int16_t spent_hdrsi,uint32_t spent_unspentind,uint32_t spent_pkind,uint64_t spent_value,uint32_t spendind,uint32_t fromheight)
|
|
{
|
|
struct iguana_ramchaindata *rdata; struct iguana_utxo *utxo; struct iguana_account *A2; // struct iguana_unspent *spentU; struct iguana_pkhash *spentP;
|
|
if ( coin->disableUTXO != 0 )
|
|
{
|
|
printf("skip volatileupdate when disabled\n");
|
|
return(0);
|
|
}
|
|
if ( (rdata= spentchain->H.data) != 0 )
|
|
{
|
|
//portable_mutex_lock(&coin->RTmutex);
|
|
if ( incremental == 0 )
|
|
{
|
|
if ( spentchain->Uextras == 0 || spentchain->A2 == 0 )
|
|
iguana_volatilesalloc(coin,spentchain,1);
|
|
if ( spentchain->Uextras != 0 && (A2= spentchain->A2) != 0 )
|
|
{
|
|
utxo = &spentchain->Uextras[spent_unspentind];
|
|
if ( utxo->spentflag == 0 )
|
|
{
|
|
if ( 0 && fromheight/coin->chain->bundlesize >= coin->current->hdrsi )
|
|
printf("iguana_volatileupdate.%d: [%d] spent.(u%u %.8f pkind.%d) fromht.%d [%d] spendind.%d\n",incremental,spent_hdrsi,spent_unspentind,dstr(spent_value),spent_pkind,fromheight,fromheight/coin->chain->bundlesize,spendind);
|
|
utxo->prevunspentind = A2[spent_pkind].lastunspentind;
|
|
utxo->spendind = spendind;
|
|
utxo->spentflag = 1;
|
|
utxo->fromheight = fromheight;
|
|
A2[spent_pkind].total += spent_value;
|
|
A2[spent_pkind].lastunspentind = spent_unspentind;
|
|
//portable_mutex_unlock(&coin->RTmutex);
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
if ( spendind != utxo->spendind || fromheight != utxo->fromheight )
|
|
printf("from.%d spent_unspentind[%d] in hdrs.[%d] is spent fromht.%d %.8f\n",fromheight,spent_unspentind,spent_hdrsi,utxo->fromheight,dstr(spent_value));
|
|
else
|
|
{
|
|
//portable_mutex_unlock(&coin->RTmutex);
|
|
return(0);
|
|
}
|
|
}
|
|
} else printf("null ptrs.[%d] u.%u p.%u %.8f from ht.%d s.%u\n",spent_hdrsi,spent_unspentind,spent_pkind,dstr(spent_value),fromheight,spendind);
|
|
}
|
|
else // do the equivalent of historical, ie mark as spent, linked list, balance
|
|
{
|
|
//double startmillis = OS_milliseconds(); static double totalmillis; static int32_t utxon;
|
|
printf("hhutxo deprecated\n");
|
|
exit(-1);
|
|
/*spentP = RAMCHAIN_PTR(rdata,Poffset);
|
|
spentU = RAMCHAIN_PTR(rdata,Uoffset);
|
|
if ( iguana_utxoupdate(coin,spent_hdrsi,spent_unspentind,spent_pkind,spent_value,spendind,fromheight,spentP[spent_pkind].rmd160) == 0 )
|
|
{
|
|
//totalmillis += (OS_milliseconds() - startmillis);
|
|
// if ( (++utxon % 100000) == 0 )
|
|
// printf("ave utxo[%d] %.2f micros total %.2f seconds\n",utxon,(1000. * totalmillis)/utxon,totalmillis/1000.);
|
|
//portable_mutex_unlock(&coin->RTmutex);
|
|
return(0);
|
|
}*/
|
|
}
|
|
//portable_mutex_unlock(&coin->RTmutex);
|
|
printf("end iguana_volatileupdate.%d: [%d] spent.(u%u %.8f pkind.%d) double spend? at ht.%d [%d] spendind.%d (%p %p)\n",incremental,spent_hdrsi,spent_unspentind,dstr(spent_value),spent_pkind,fromheight,fromheight/coin->chain->bundlesize,spendind,spentchain->Uextras,spentchain->A2);
|
|
/*if ( coin->current != 0 && fromheight >= coin->current->bundleheight )
|
|
coin->RTdatabad = 1;
|
|
else
|
|
{
|
|
printf("from.%d vs current.%d\n",fromheight,coin->current->bundleheight);
|
|
iguana_bundleremove(coin,fromheight/coin->chain->bundlesize,0);
|
|
}
|
|
coin->spendvectorsaved = 0;
|
|
coin->started = 0;
|
|
coin->active = 0;*/
|
|
coin->RTdatabad = 1;
|
|
if ( coin->current != 0 && spent_hdrsi != coin->current->hdrsi && spent_hdrsi != fromheight/coin->chain->bundlesize )
|
|
{
|
|
printf("restart iguana\n");
|
|
struct iguana_bundle *bp;
|
|
portable_mutex_lock(&coin->special_mutex);
|
|
if ( (bp= coin->bundles[spent_hdrsi]) != 0 )
|
|
{
|
|
iguana_bundleremove(coin,spent_hdrsi,0);
|
|
bp->ramchain.H.data = 0;
|
|
}
|
|
if ( (bp= coin->bundles[fromheight/coin->chain->bundlesize]) != 0 )
|
|
{
|
|
iguana_bundleremove(coin,fromheight/coin->chain->bundlesize,0);
|
|
bp->ramchain.H.data = 0;
|
|
}
|
|
portable_mutex_unlock(&coin->special_mutex);
|
|
exit(-1);
|
|
}
|
|
}
|
|
else if ( coin->spendvectorsaved > 1 )
|
|
printf("volatileupdate skip null rdata [%d]\n",spentchain->height/coin->current->bundleheight);
|
|
return(-1);
|
|
}
|
|
|
|
void iguana_volatilesalloc(struct iguana_info *coin,struct iguana_ramchain *ramchain,int32_t copyflag)
|
|
{
|
|
int32_t i; struct iguana_utxo *U2; struct iguana_account *A2; struct iguana_ramchaindata *rdata = 0;
|
|
if ( ramchain != 0 && (rdata= ramchain->H.data) != 0 && (coin->current == 0 || coin->current->bundleheight > ramchain->height) )
|
|
{
|
|
//printf("volatilesalloc.[%d] %p %p\n",ramchain->height/coin->chain->bundlesize,ramchain->debitsfileptr,ramchain->lastspendsfileptr);
|
|
if ( ramchain->allocatedA2 == 0 )
|
|
{
|
|
ramchain->A2 = calloc(sizeof(*ramchain->A2),rdata->numpkinds + 16);
|
|
ramchain->allocatedA2 = sizeof(*ramchain->A2) * rdata->numpkinds;
|
|
}
|
|
if ( ramchain->allocatedU2 == 0 )
|
|
{
|
|
ramchain->Uextras = calloc(sizeof(*ramchain->Uextras),rdata->numunspents + 16);
|
|
ramchain->allocatedU2 = sizeof(*ramchain->Uextras) * rdata->numunspents;
|
|
}
|
|
if ( ramchain->debitsfileptr != 0 )
|
|
{
|
|
if ( copyflag != 0 )
|
|
{
|
|
A2 = (void *)((long)ramchain->debitsfileptr + sizeof(int32_t) + 2*sizeof(bits256));
|
|
if ( ramchain->debitsfilesize != sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*A2)*rdata->numpkinds )
|
|
printf("A2 size mismatch %ld != %d\n",ramchain->debitsfilesize,(int32_t)(sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*A2)*rdata->numpkinds));
|
|
for (i=0; i<rdata->numpkinds; i++)
|
|
ramchain->A2[i] = A2[i];
|
|
}
|
|
munmap(ramchain->debitsfileptr,ramchain->debitsfilesize);
|
|
ramchain->debitsfileptr = 0;
|
|
ramchain->debitsfilesize = 0;
|
|
}
|
|
if ( ramchain->lastspendsfileptr != 0 )
|
|
{
|
|
if ( copyflag != 0 )
|
|
{
|
|
U2 = (void *)((long)ramchain->lastspendsfileptr + sizeof(int32_t) + 2*sizeof(bits256));
|
|
if ( ramchain->lastspendsfilesize != sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*U2)*rdata->numunspents )
|
|
printf("U2 size mismatch %ld != %d\n",ramchain->lastspendsfilesize,(int32_t)(sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*U2)*rdata->numunspents));
|
|
for (i=0; i<rdata->numunspents; i++)
|
|
ramchain->Uextras[i] = U2[i];
|
|
}
|
|
munmap(ramchain->lastspendsfileptr,ramchain->lastspendsfilesize);
|
|
ramchain->lastspendsfileptr = 0;
|
|
ramchain->lastspendsfilesize = 0;
|
|
}
|
|
} else printf("illegal ramchain.%p rdata.%p\n",ramchain,rdata);
|
|
}
|
|
|
|
void iguana_volatilespurge(struct iguana_info *coin,struct iguana_ramchain *ramchain)
|
|
{
|
|
if ( ramchain != 0 )
|
|
{
|
|
//printf("volatilespurge.[%d] (%p %p) %p %p\n",ramchain->height/coin->chain->bundlesize,ramchain->A2,ramchain->Uextras,ramchain->debitsfileptr,ramchain->lastspendsfileptr);
|
|
if ( ramchain->allocatedA2 != 0 && ramchain->A2 != 0 && ramchain->A2 != ramchain->debitsfileptr+sizeof(bits256)*2+sizeof(int32_t) )
|
|
free(ramchain->A2);
|
|
if ( ramchain->allocatedU2 != 0 && ramchain->Uextras != 0 && ramchain->Uextras != ramchain->lastspendsfileptr+sizeof(bits256)*2+sizeof(int32_t) )
|
|
free(ramchain->Uextras);
|
|
ramchain->A2 = 0;
|
|
ramchain->Uextras = 0;
|
|
ramchain->allocatedA2 = ramchain->allocatedU2 = 0;
|
|
if ( ramchain->debitsfileptr != 0 )
|
|
{
|
|
munmap(ramchain->debitsfileptr,ramchain->debitsfilesize);
|
|
ramchain->debitsfileptr = 0;
|
|
ramchain->debitsfilesize = 0;
|
|
}
|
|
if ( ramchain->lastspendsfileptr != 0 )
|
|
{
|
|
munmap(ramchain->lastspendsfileptr,ramchain->lastspendsfilesize);
|
|
ramchain->lastspendsfileptr = 0;
|
|
ramchain->lastspendsfilesize = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t iguana_volatilesmap(struct iguana_info *coin,struct iguana_ramchain *ramchain)
|
|
{
|
|
int32_t iter,numhdrsi,err = -1; char fname[1024]; bits256 balancehash,allbundles; struct iguana_ramchaindata *rdata;
|
|
if ( (rdata= ramchain->H.data) == 0 )
|
|
{
|
|
if ( ramchain->height > 0 )
|
|
printf("volatilesmap.[%d] no rdata\n",ramchain->height/coin->chain->bundlesize);
|
|
return(-1);
|
|
}
|
|
if ( ramchain->debitsfileptr != 0 && ramchain->lastspendsfileptr != 0 )
|
|
{
|
|
//printf("volatilesmap.[%d] already mapped %p %p\n",ramchain->height,ramchain->debitsfileptr,ramchain->lastspendsfileptr);
|
|
return(0);
|
|
}
|
|
for (iter=0; iter<2; iter++)
|
|
{
|
|
sprintf(fname,"%s/%s%s/accounts/debits.%d",GLOBAL_DBDIR,iter==0?"ro/":"",coin->symbol,ramchain->height);
|
|
if ( (ramchain->debitsfileptr= OS_mapfile(fname,&ramchain->debitsfilesize,0)) != 0 && ramchain->debitsfilesize == sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*ramchain->A2) * rdata->numpkinds )
|
|
{
|
|
ramchain->from_roA = (iter == 0);
|
|
numhdrsi = *(int32_t *)ramchain->debitsfileptr;
|
|
memcpy(balancehash.bytes,(void *)((long)ramchain->debitsfileptr + sizeof(numhdrsi)),sizeof(balancehash));
|
|
memcpy(allbundles.bytes,(void *)((long)ramchain->debitsfileptr + sizeof(numhdrsi) + sizeof(balancehash)),sizeof(allbundles));
|
|
if ( coin->balanceswritten == 0 )
|
|
{
|
|
coin->balanceswritten = numhdrsi;
|
|
coin->balancehash = balancehash;
|
|
coin->allbundles = allbundles;
|
|
}
|
|
if ( numhdrsi >= coin->balanceswritten-1 && memcmp(balancehash.bytes,coin->balancehash.bytes,sizeof(balancehash)) == 0 && memcmp(allbundles.bytes,coin->allbundles.bytes,sizeof(allbundles)) == 0 )
|
|
{
|
|
ramchain->A2 = (void *)((long)ramchain->debitsfileptr + sizeof(numhdrsi) + 2*sizeof(bits256));
|
|
sprintf(fname,"%s/%s%s/accounts/lastspends.%d",GLOBAL_DBDIR,iter==0?"ro/":"",coin->symbol,ramchain->height);
|
|
if ( (ramchain->lastspendsfileptr= OS_mapfile(fname,&ramchain->lastspendsfilesize,0)) != 0 && ramchain->lastspendsfilesize == sizeof(int32_t) + 2*sizeof(bits256) + sizeof(*ramchain->Uextras) * rdata->numunspents )
|
|
{
|
|
numhdrsi = *(int32_t *)ramchain->lastspendsfileptr;
|
|
memcpy(balancehash.bytes,(void *)((long)ramchain->lastspendsfileptr + sizeof(numhdrsi)),sizeof(balancehash));
|
|
memcpy(allbundles.bytes,(void *)((long)ramchain->lastspendsfileptr + sizeof(numhdrsi) + sizeof(balancehash)),sizeof(allbundles));
|
|
if ( numhdrsi >= coin->balanceswritten-1 && memcmp(balancehash.bytes,coin->balancehash.bytes,sizeof(balancehash)) == 0 && memcmp(allbundles.bytes,coin->allbundles.bytes,sizeof(allbundles)) == 0 )
|
|
{
|
|
ramchain->Uextras = (void *)((long)ramchain->lastspendsfileptr + sizeof(numhdrsi) + 2*sizeof(bits256));
|
|
ramchain->from_roU = (iter == 0);
|
|
uint32_t unspentind,nonz=0; struct iguana_unspent *U; struct iguana_utxo *U2;
|
|
if ( iter == 1 && (ramchain->height % 100000) == 0 )
|
|
{
|
|
U2 = ramchain->Uextras;
|
|
U = RAMCHAIN_PTR(ramchain->H.data,Uoffset);
|
|
for (unspentind=1; unspentind<ramchain->H.data->numunspents; unspentind++)
|
|
{
|
|
if ( U2[unspentind].spentflag != 0 )
|
|
nonz++;
|
|
//printf("[%d] u%d: (p%u %.8f) from.%d lock.%d prev.%u spent.%d\n",ramchain->height/coin->chain->bundlesize,unspentind,U[unspentind].pkind,dstr(U[unspentind].value),U2[unspentind].fromheight,U2[unspentind].lockedflag,U2[unspentind].prevunspentind,U2[unspentind].spentflag);
|
|
}
|
|
//printf("iter.%d nonz.%d %s volatilesmap.[%d] %p %p\n",iter,nonz,fname,ramchain->height/coin->chain->bundlesize,ramchain->debitsfileptr,ramchain->lastspendsfileptr);
|
|
}
|
|
err = 0;
|
|
struct iguana_bundle *bp;
|
|
if ( (bp= coin->bundles[ramchain->height / coin->chain->bundlesize]) != 0 )
|
|
bp->balancefinish = (uint32_t)time(NULL);
|
|
} else printf("ramchain map error2 balanceswritten %d vs %d hashes %x %x\n",coin->balanceswritten,numhdrsi,coin->balancehash.uints[0],balancehash.uints[0]);
|
|
} else printf("ramchain map error3 %s\n",fname);
|
|
}
|
|
else
|
|
{
|
|
printf("ramchain.[%d] map error balanceswritten %d vs %d hashes %x %x\n",rdata->height,coin->balanceswritten,numhdrsi,coin->balancehash.uints[0],balancehash.uints[0]);
|
|
err++;
|
|
OS_removefile(fname,0);
|
|
}
|
|
}
|
|
if ( err == 0 )
|
|
return(0);
|
|
}
|
|
//printf("couldnt map [%d]\n",ramchain->height/coin->chain->bundlesize);
|
|
iguana_volatilespurge(coin,ramchain);
|
|
return(err);
|
|
}
|
|
|