lukechilds
/
SuperNET
mirror of https://github.com/lukechilds/SuperNET.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

variable blockheaded size

release/v0.1
jl777 9 years ago
parent
c707a12d5b
commit
eb99c7ad4b
18 changed files with 578 additions and 362 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      basilisk/basilisk.h
  2. 16
      basilisk/basilisk_CMD.c
  3. 6
      basilisk/basilisk_bitcoin.c
  4. 2
      iguana/coins/genzcash
  5. 12
      iguana/iguana777.c
  6. 80
      iguana/iguana777.h
  7. 4
      iguana/iguana_accept.c
  8. 175
      iguana/iguana_blocks.c
  9. 11
      iguana/iguana_chains.c
  10. 62
      iguana/iguana_init.c
  11. 232
      iguana/iguana_msg.c
  12. 2
      iguana/iguana_peers.c
  13. 169
      iguana/iguana_ramchain.c
  14. 2
      iguana/iguana_realtime.c
  15. 143
      iguana/iguana_recv.c
  16. 2
      iguana/iguana_spendvectors.c
  17. 14
      iguana/iguana_tx.c
  18. 6
      iguana/main.c

2
basilisk/basilisk.h
View File

@ -34,7 +34,7 @@
#define BASILISK_FIRSTPOSSIBLEBTC 414000
#define BASILISK_FIRSTPOSSIBLEBTCD 1100000
struct hashstamp { bits256 hash2; uint32_t timestamp; int32_t height; uint8_t RO[80]; };
struct hashstamp { bits256 hash2; uint32_t timestamp; int32_t height; };
struct basilisk_sequence { struct hashstamp *stamps; int32_t lastupdate,maxstamps,numstamps,lasti,longestchain; };
struct basilisk_sequences { struct basilisk_sequence BTC,BTCD; };

16
basilisk/basilisk_CMD.c
View File

@ -31,17 +31,17 @@ void basilisk_request_goodbye(struct supernet_info *myinfo)
free_json(valsobj);
}
int32_t iguana_rwhashstamp(int32_t rwflag,uint8_t *serialized,struct hashstamp *stamp)
int32_t iguana_rwhashstamp(int32_t rwflag,uint8_t zcash,uint8_t *serialized,struct hashstamp *stamp)
{
int32_t len = 0;
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(stamp->hash2),stamp->hash2.bytes);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(stamp->timestamp),&stamp->timestamp);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(stamp->height),&stamp->height);
len += iguana_rwblock80(rwflag,&serialized[len],(void *)stamp->RO);
//len += iguana_rwblockhdr(rwflag,zcash,&serialized[len],(void *)stamp->RO);
return(len);
}
cJSON *basilisk_sequencejson(struct basilisk_sequence *seq,int32_t startheight,int32_t firstpossible)
cJSON *basilisk_sequencejson(uint8_t zcash,struct basilisk_sequence *seq,int32_t startheight,int32_t firstpossible)
{
int32_t i,n,len=0,datalen,num = 0; cJSON *item; uint8_t *data; char strbuf[8192],*hexstr=0;
if ( startheight < firstpossible )
@ -56,7 +56,7 @@ cJSON *basilisk_sequencejson(struct basilisk_sequence *seq,int32_t startheight,i
{
if ( seq->stamps[i].timestamp == 0 )
break;
len += iguana_rwhashstamp(1,&data[len],&seq->stamps[i]);
len += iguana_rwhashstamp(1,zcash,&data[len],&seq->stamps[i]);
}
jaddnum(item,"start",startheight);
jaddnum(item,"num",num);
@ -95,7 +95,7 @@ void basilisk_seqresult(struct supernet_info *myinfo,char *retstr)
basilisk_ensure(seq,ind + num);
for (i=0; i<num; i++,ind++)
{
len += iguana_rwhashstamp(0,&data[len],&stamp);
len += iguana_rwhashstamp(0,btcd->chain->zcash,&data[len],&stamp);
// verify blockheader
seq->stamps[ind] = stamp;
}
@ -113,9 +113,9 @@ char *basilisk_respond_hashstamps(struct supernet_info *myinfo,char *CMD,struct
if ( (btcd= iguana_coinfind("BTCD")) != 0 )
{
if ( (startheight= juint(valsobj,"BTCD")) != 0 )
jadd(retjson,"BTCD",basilisk_sequencejson(&btcd->SEQ.BTCD,startheight,BASILISK_FIRSTPOSSIBLEBTCD));
jadd(retjson,"BTCD",basilisk_sequencejson(btcd->chain->zcash,&btcd->SEQ.BTCD,startheight,BASILISK_FIRSTPOSSIBLEBTCD));
else if ( (startheight= juint(valsobj,"BTC")) != 0 )
jadd(retjson,"BTC",basilisk_sequencejson(&btcd->SEQ.BTC,startheight,BASILISK_FIRSTPOSSIBLEBTC));
jadd(retjson,"BTC",basilisk_sequencejson(btcd->chain->zcash,&btcd->SEQ.BTC,startheight,BASILISK_FIRSTPOSSIBLEBTC));
}
return(jprint(retjson,1));
}
@ -136,7 +136,7 @@ char *basilisk_respond_setfield(struct supernet_info *myinfo,char *CMD,struct ig
return(clonestr("{\"error\":\"couldnt find prevhash2\"}"));
timestamp = juint(valsobj,"timestamp");
nonce = juint(valsobj,"nonce");
nBits = iguana_targetbits(coin,&coin->blocks.hwmchain,prevblock,prev2,1,coin->chain->targetspacing,coin->chain->targettimespan);
nBits = iguana_targetbits(coin,(struct iguana_block *)&coin->blocks.hwmchain,prevblock,prev2,1,coin->chain->targetspacing,coin->chain->targettimespan);
blocktx = basilisk_block(myinfo,coin,&block,1,timestamp,&nonce,prevhash,nBits,prevblock->height+1,0,0,data,datalen,btcdhash,jobj(valsobj,"coinbase"));
retjson = cJSON_CreateObject();
jaddbits256(retjson,"hash",block.RO.hash2);

6
basilisk/basilisk_bitcoin.c
View File

@ -216,14 +216,12 @@ int32_t basilisk_bitcoinscan(struct iguana_info *coin,uint8_t origblockspace[IGU
bitsbuf[i] = revbits[3 - i];
memcpy(&B.RO.bits,bitsbuf,sizeof(B.RO.bits));
}
printf("need to handle zcash/auxpow\n");
B.RO.nonce = juint(blockjson,"nonce");
//char str[65],str2[65];
//printf("v.%d t.%u bits.%08x nonce.%x %s %s\n",B.RO.version,B.RO.timestamp,B.RO.bits,B.RO.nonce,bits256_str(str,B.RO.prev_block),bits256_str(str2,B.RO.merkle_root));
iguana_serialize_block(coin->chain,&checkhash2,blockspace,&B);
//for (i=0; i<80; i++)
// printf("%02x",blockspace[i]);
//printf(" B.%s\n",bits256_str(str,checkhash2));
msg = (void *)blockspace;
msg = (void *)blockspace;
//printf("(%s)\n",jprint(blockjson,0));
checkhash2 = iguana_calcblockhash(coin->symbol,coin->chain->hashalgo,blockspace,sizeof(*msg)-4);
if ( jstr(blockjson,"hash") != 0 )

2
iguana/coins/genzcash
View File

@ -1,2 +1,2 @@
curl --url "http://127.0.0.1:7778" --data "{\"RELAY\":1,\"VALIDATE\":1,\"prefetchlag\":-1,\"poll\":10,\"active\":1,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":8,\"endpend\":8,\"services\":129,\"maxpeers\":256,\"newcoin\":\"ZEC\",\"name\":\"Zcash\",\"hasheaders\":1,\"useaddmultisig\":0,\"netmagic\":\"6df6e755\",\"p2p\":18333,\"rpc\":18332,\"pubval\":111,\"p2shval\":196,\"wifval\":239,\"txfee_satoshis\":\"10000\",\"isPoS\":0,\"minoutput\":10000,\"minconfirms\":2,\"genesishash\":\"27d1f4ce03fc473c9dd6e1e307c682c8f802eae1f5a2f61402aa1ae8702ed3b6\",\"protover\":70002,\"genesisblock\":\"0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f2000000000\"}"
curl --url "http://127.0.0.1:7778" --data "{\"unitval\":\"20\",\"zcash\":1,\"RELAY\":1,\"VALIDATE\":1,\"prefetchlag\":-1,\"poll\":10,\"active\":1,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":8,\"endpend\":8,\"services\":129,\"maxpeers\":32,\"newcoin\":\"ZEC\",\"name\":\"Zcash\",\"hasheaders\":0,\"useaddmultisig\":0,\"netmagic\":\"6df6e755\",\"p2p\":18333,\"rpc\":18332,\"pubval\":111,\"p2shval\":196,\"wifval\":239,\"txfee_satoshis\":\"10000\",\"isPoS\":0,\"minoutput\":10000,\"minconfirms\":2,\"genesishash\":\"27d1f4ce03fc473c9dd6e1e307c682c8f802eae1f5a2f61402aa1ae8702ed3b6\",\"protover\":70002,\"genesisblock\":\"0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f200000000000000000000000000000000000000000000000000000000000000000209d0900001dc600004fba000024e20100e5660000778100007e190100222f0100720e000056e50100eb12010089920100583d00002e660000844e01001bfe0100cf0c0000892a0000f5230000f9680000976e00009b7b000046770000afd80100bd0d000057650000048f000082b100006a2500004e0601006fef000048410100\"}"

12
iguana/iguana777.c
View File

@ -45,7 +45,7 @@ struct iguana_info *iguana_coinadd(const char *symbol,cJSON *argjson)
{
if ( Coins[i] == 0 )
{
Coins[i] = mycalloc('C',1,sizeof(*Coins[i]));
Coins[i] = mycalloc('C',1,sizeof(*Coins[i]) + sizeof(struct iguana_zcashRO));
printf("iguana_coin.(new) -> %p\n",Coins[i]);
basilisk_functions(Coins[i],IGUANA_PROTOCOL_BITCOIN);
return(Coins[i]);
@ -66,7 +66,7 @@ struct iguana_info *iguana_coinadd(const char *symbol,cJSON *argjson)
{
if ( Coins[i] == 0 )
{
Coins[i] = mycalloc('C',1,sizeof(*Coins[i]));
Coins[i] = mycalloc('C',1,sizeof(*Coins[i]) + sizeof(struct iguana_zcashRO));
basilisk_functions(Coins[i],IGUANA_PROTOCOL_BITCOIN);
}
coin = Coins[i];
@ -110,9 +110,9 @@ struct iguana_info *iguana_coinselect()
void iguana_recvalloc(struct iguana_info *coin,int32_t numitems)
{
//coin->blocks.ptrs = myrealloc('W',coin->blocks.ptrs,coin->blocks.ptrs==0?0:coin->blocks.maxbits * sizeof(*coin->blocks.ptrs),numitems * sizeof(*coin->blocks.ptrs));
coin->blocks.RO = myrealloc('W',coin->blocks.RO,coin->blocks.RO==0?0:coin->blocks.maxbits * sizeof(*coin->blocks.RO),numitems * sizeof(*coin->blocks.RO));
//coin->blocks.RO = myrealloc('W',coin->blocks.RO,coin->blocks.RO==0?0:coin->blocks.maxbits * sizeof(*coin->blocks.RO),numitems * sizeof(*coin->blocks.RO));
//printf("realloc waitingbits.%d -> %d\n",coin->blocks.maxbits,numitems);
coin->blocks.maxbits = numitems;
//coin->blocks.maxbits = numitems;
}
static int _decreasing_double(const void *a,const void *b)
@ -759,8 +759,8 @@ void iguana_coinloop(void *arg)
//fprintf(stderr,"metrics\n");
coin->peers->lastmetrics = iguana_updatemetrics(myinfo,coin); // ranks peers
}
if ( coin->longestchain+10000 > coin->blocks.maxbits )
iguana_recvalloc(coin,coin->longestchain + 100000);
//if ( coin->longestchain+10000 > coin->blocks.maxbits )
// iguana_recvalloc(coin,coin->longestchain + 100000);
if ( coin->RELAYNODE != 0 || coin->VALIDATENODE != 0 || coin->MAXPEERS == 1 )
flag += iguana_processrecv(myinfo,coin);
iguana_jsonQ();

80
iguana/iguana777.h
View File

@ -228,7 +228,7 @@ struct iguana_chain
char use_addmultisig,do_opreturn;
int32_t estblocktime,protover;
bits256 PoWtarget,PoStargets[16]; int32_t numPoStargets,PoSheights[16];
uint8_t auxpow,alertpubkey[65];
uint8_t zcash,auxpow,alertpubkey[65];
int32_t targetspacing,targettimespan;
};
@ -279,6 +279,17 @@ struct iguana_msgblockhdr
uint32_t timestamp,bits,nonce;
} __attribute__((packed));
#define ZKSNARK_PROOF_SIZE 584
#define ZCASH_SOLUTION_ELEMENTS 32
struct iguana_msgblockhdr_zcash
{
bits256 bignonce;
uint8_t numelements;
uint32_t solution[ZCASH_SOLUTION_ELEMENTS];
//bits256 reserved; // only here if auxpow is set
} __attribute__((packed));
struct iguana_msgmerkle
{
uint32_t branch_length;
@ -289,6 +300,7 @@ struct iguana_msgmerkle
struct iguana_msgblock
{
struct iguana_msgblockhdr H; // double hashed for blockhash
struct iguana_msgblockhdr_zcash zH;
uint32_t txn_count;
} __attribute__((packed));
@ -305,6 +317,15 @@ struct iguana_msgtx
int32_t allocsize,timestamp;
} __attribute__((packed));
struct iguana_msgjoinsplit
{
uint64_t vpub_old,vpub_new;
bits256 anchor,nullifiers[2],commitments[2],ephemeralkey;
uint8_t ciphertexts[2][217];
bits256 randomseed,vmacs[2];
uint8_t zkproof[ZKSNARK_PROOF_SIZE-1];
} __attribute__((packed));
struct iguana_packet { struct queueitem DL; struct iguana_peer *addr; struct tai embargo; int32_t datalen,getdatablock; uint8_t serialized[]; };
struct msgcounts { uint32_t version,verack,getaddr,addr,inv,getdata,notfound,getblocks,getheaders,headers,tx,block,mempool,ping,pong,reject,filterload,filteradd,filterclear,merkleblock,alert; };
@ -328,18 +349,28 @@ struct iguana_blockRO
bits256 hash2,prev_block,merkle_root;
uint32_t timestamp,nonce,bits,version;
uint32_t firsttxidind,firstvin,firstvout,firstpkind,firstexternalind,recvlen:24,tbd:8;
uint16_t txn_count,numvouts,numvins,extra;
uint16_t txn_count,numvouts,numvins,allocsize;
};
struct iguana_zcashRO { bits256 bignonce; uint32_t solution[ZCASH_SOLUTION_ELEMENTS]; };
#define iguana_blockfields double PoW; \
int32_t height,fpos; uint32_t fpipbits,issued,lag:20,peerid:12; \
uint16_t hdrsi:15,mainchain:1,bundlei:11,valid:1,queued:1,txvalid:1,newtx:1,processed:1; \
UT_hash_handle hh; struct iguana_bundlereq *req; \
struct iguana_blockRO RO
struct iguana_block
{
struct iguana_blockRO RO;
double PoW; // NOT consensus safe, for estimation purposes only
int32_t height,fpos; uint32_t fpipbits,issued,lag:20,peerid:12;
uint16_t hdrsi:15,mainchain:1,bundlei:11,valid:1,queued:1,txvalid:1,newtx:1,processed:1;
UT_hash_handle hh; struct iguana_bundlereq *req; //void *serdata;
} __attribute__((packed));
iguana_blockfields;
struct iguana_zcashRO zRO[];
};
struct iguana_zblock // mu
{
iguana_blockfields;
struct iguana_zcashRO zRO;
};
#define IGUANA_LHASH_BLOCKS 0
#define IGUANA_LHASH_TXIDS 1 //
@ -364,9 +395,9 @@ struct iguana_blocks
{
char coin[8];
struct iguanakv *db;
struct iguana_block *hash; struct iguana_blockRO *RO; int32_t maxbits;
struct iguana_block *hash; //struct iguana_blockRO *RO; int32_t maxbits;
int32_t maxblocks,initblocks,hashblocks,pending,issuedblocks,recvblocks,emitblocks,parsedblocks,dirty;
struct iguana_block hwmchain;
struct iguana_zblock hwmchain;
};
struct iguana_ledger
@ -404,7 +435,7 @@ struct iguana_txblock
// following set during second pass (still in peer context)
uint32_t numpkinds,numexternaltxids,datalen,pkoffset;
uint8_t space[256]; // order: extra[], T, U, S, P, external txids
struct iguana_block block;
struct iguana_zblock zblock;
};
#define RAMCHAIN_PTR(rdata,offset) ((void *)(long)((long)(rdata) + (long)(rdata)->offset))
@ -497,11 +528,12 @@ struct iguana_bundle
struct iguana_bundlereq
{
struct queueitem DL; struct iguana_info *coin; int32_t type;
struct iguana_peer *addr; struct iguana_block *blocks,block; bits256 *hashes,txid;
struct iguana_peer *addr; struct iguana_zblock *blocks; bits256 *hashes,txid;
struct iguana_txdatabits txdatabits;
struct iguana_msghdr H;
int32_t allocsize,datalen,n,recvlen,numtx; uint32_t ipbits;
uint8_t copyflag,serialized[];
uint8_t copyflag,*serializeddata;
struct iguana_zblock zblock;
};
struct iguana_bitmap { int32_t width,height,amplitude; char name[52]; uint8_t data[IGUANA_WIDTH*IGUANA_HEIGHT*3]; };
@ -551,11 +583,12 @@ struct iguana_info
void *launched,*started,*rpcloop;
uint64_t bloomsearches,bloomhits,bloomfalse,collisions,txfee_perkb,txfee;
uint8_t blockspace[IGUANA_MAXPACKETSIZE + 8192]; struct OS_memspace blockMEM;
struct iguana_blocks blocks; bits256 APIblockhash,APItxid; char *APIblockstr;
bits256 APIblockhash,APItxid; char *APIblockstr;
struct iguana_hhutxo *utxotable; struct iguana_hhaccount *accountstable; char lastdispstr[2048];
double txidfind_totalmillis,txidfind_num,spendtxid_totalmillis,spendtxid_num;
struct iguana_monitorinfo monitoring[256];
struct basilisk_sequences SEQ;
struct iguana_blocks blocks;
};
struct vin_signer { bits256 privkey; char coinaddr[64]; uint8_t siglen,sig[80],rmd160[20],pubkey[66]; };
@ -608,9 +641,9 @@ int32_t iguana_rwmem(int32_t rwflag,uint8_t *serialized,int32_t len,void *endian
int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
int32_t iguana_rwvarint32(int32_t rwflag,uint8_t *serialized,uint32_t *int32p);
int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
int32_t iguana_rwblock(char *symbol,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),int32_t rwflag,bits256 *hash2p,uint8_t *serialized,struct iguana_msgblock *msg);
int32_t iguana_rwblock(char *symbol,uint8_t zcash,uint8_t auxpow,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),int32_t rwflag,bits256 *hash2p,uint8_t *serialized,struct iguana_msgblock *msg,int32_t maxlen);
int32_t iguana_serialize_block(struct iguana_chain *chain,bits256 *hash2p,uint8_t serialized[sizeof(struct iguana_msgblock)],struct iguana_block *block);
void iguana_blockconv(struct iguana_block *dest,struct iguana_msgblock *msg,bits256 hash2,int32_t height);
void iguana_blockconv(uint8_t zcash,uint8_t auxpow,struct iguana_block *dest,struct iguana_msgblock *msg,bits256 hash2,int32_t height);
//void iguana_freetx(struct iguana_msgtx *tx,int32_t n);
int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struct OS_memspace *rawmem,struct OS_memspace *txmem,struct OS_memspace *hashmem,struct iguana_msghdr *H,uint8_t *data,int32_t datalen);
@ -621,7 +654,7 @@ int32_t iguana_send_version(struct iguana_info *coin,struct iguana_peer *addr,ui
int32_t iguana_gentxarray(struct iguana_info *coin,struct OS_memspace *mem,struct iguana_txblock *txblock,int32_t *lenp,uint8_t *data,int32_t datalen);
int32_t iguana_gethdrs(struct iguana_info *coin,uint8_t *serialized,char *cmd,char *hashstr);
int32_t iguana_getdata(struct iguana_info *coin,uint8_t *serialized,int32_t type,bits256 *hashes,int32_t n);
void iguana_blockunconv(struct iguana_msgblock *msg,struct iguana_block *src,int32_t cleartxn_count);
void iguana_blockunconv(uint8_t zcash,uint8_t auxpow,struct iguana_msgblock *msg,struct iguana_block *src,int32_t cleartxn_count);
int32_t iguana_peerblockrequest(struct iguana_info *coin,uint8_t *blockspace,int32_t max,struct iguana_peer *addr,bits256 hash2,int32_t validatesigs);
int32_t iguana_validatesigs(struct iguana_info *coin,struct iguana_msgvin *vin);
@ -646,7 +679,7 @@ int32_t iguana_chainextend(struct iguana_info *coin,struct iguana_block *newbloc
uint64_t iguana_miningreward(struct iguana_info *coin,uint32_t blocknum);
// tx
int32_t iguana_rwtx(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,struct iguana_msgtx *msg,int32_t maxsize,bits256 *txidp,int32_t hastimestamp,int32_t isvpncoin);
int32_t iguana_rwtx(uint8_t zcash,int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,struct iguana_msgtx *msg,int32_t maxsize,bits256 *txidp,int32_t hastimestamp,int32_t isvpncoin);
void iguana_gottxidsM(struct iguana_info *coin,struct iguana_peer *addr,bits256 *txids,int32_t n);
void iguana_gotquotesM(struct iguana_info *coin,struct iguana_peer *addr,bits256 *quotes,int32_t n);
void iguana_gotunconfirmedM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_msgtx *tx,uint8_t *data,int32_t datalen);
@ -672,7 +705,7 @@ int32_t ramcoder_compress(uint8_t *bits,int32_t maxlen,uint8_t *data,int32_t dat
uint64_t hconv_bitlen(uint64_t bitlen);
struct iguana_block *iguana_blockptr(char *debugstr,struct iguana_info *coin,int32_t height);
int32_t iguana_processrecv(struct supernet_info *myinfo,struct iguana_info *coin); // single threaded
void iguana_recvalloc(struct iguana_info *coin,int32_t numitems);
//void iguana_recvalloc(struct iguana_info *coin,int32_t numitems);
void iguana_coins(void *arg);
int32_t iguana_savehdrs(struct iguana_info *coin);
@ -680,7 +713,7 @@ int32_t iguana_savehdrs(struct iguana_info *coin);
struct iguana_bundle *iguana_bundlecreate(struct iguana_info *coin,int32_t *bundleip,int32_t bundleheight,bits256 bundlehash2,bits256 allhash,int32_t issueflag);
struct iguana_block *iguana_updatehdrs(struct iguana_info *coin,int32_t *newhwmp,struct iguana_block *block,bits256 prevhash2,bits256 hash2);
void iguana_parseline(struct iguana_info *coin,int32_t iter,FILE *fp);
void iguana_gotheadersM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_block *blocks,int32_t n);
void iguana_gotheadersM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_zblock *zblocks,int32_t n);
void iguana_emittxdata(struct iguana_info *coin,struct iguana_bundle *bp);
int32_t iguana_pollQsPT(struct iguana_info *coin,struct iguana_peer *addr);
int32_t iguana_avail(struct iguana_info *coin,int32_t height,int32_t n);
@ -744,7 +777,7 @@ struct iguana_ramchain *iguana_ramchainmergeHT(struct iguana_info *coin,struct O
void iguana_ramchainmerge(struct iguana_info *coin);
int32_t iguana_blockQ(char *argstr,struct iguana_info *coin,struct iguana_bundle *bp,int32_t bundlei,bits256 hash2,int32_t priority);
void iguana_blockcopy(struct iguana_info *coin,struct iguana_block *block,struct iguana_block *origblock);
void iguana_blockcopy(uint8_t zcash,uint8_t auxpow,struct iguana_info *coin,struct iguana_block *block,struct iguana_block *origblock);
int32_t iguana_rpctest(struct iguana_info *coin);
extern queue_t helperQ;
extern const char *Hardcoded_coins[][3];
@ -839,7 +872,7 @@ int32_t SuperNET_sendmsg(struct supernet_info *myinfo,struct iguana_info *coin,s
int32_t category_peer(struct supernet_info *myinfo,struct iguana_peer *addr,bits256 category,bits256 subhash);
int32_t bitcoin_wif2priv(uint8_t *addrtypep,bits256 *privkeyp,char *wifstr);
int32_t bitcoin_priv2wif(char *wifstr,bits256 privkey,uint8_t addrtype);
bits256 iguana_chaingenesis(char *symbol,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),bits256 genesishash,char *genesisblock,char *hashalgostr,int32_t version,uint32_t timestamp,uint32_t bits,uint32_t nonce,bits256 merkle_root);
bits256 iguana_chaingenesis(char *symbol,uint8_t zcash,uint8_t auxpow,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),bits256 genesishash,char *genesisblock,char *hashalgostr,int32_t version,uint32_t timestamp,uint32_t bits,uint32_t nonce,bits256 merkle_root);
int32_t iguana_send_ConnectTo(struct iguana_info *coin,struct iguana_peer *addr);
cJSON *iguana_txjson(struct iguana_info *coin,struct iguana_txid *tx,int32_t height,struct vin_info *V);
char *iguana_txscan(struct iguana_info *coin,cJSON *json,uint8_t *data,int32_t recvlen,bits256 txid);
@ -852,6 +885,7 @@ int32_t iguana_rwmsgtx(struct iguana_info *coin,int32_t rwflag,cJSON *json,uint8
int32_t iguana_ramtxbytes(struct iguana_info *coin,uint8_t *serialized,int32_t maxlen,bits256 *txidp,struct iguana_txid *tx,int32_t height,struct iguana_msgvin *vins,struct iguana_msgvout *vouts,int32_t validatesigs);
cJSON *bitcoin_txtest(struct iguana_info *coin,char *rawtxstr,bits256 txid);
cJSON *iguana_blockjson(struct iguana_info *coin,struct iguana_block *block,int32_t txidsflag);
int32_t iguana_rwblockhdr(int32_t rwflag,uint8_t zcash,uint8_t *serialized,struct iguana_msgblock *msg);
//int32_t iguana_sig(uint8_t *sig,int32_t maxsize,uint8_t *data,int32_t datalen,bits256 privkey);
//int32_t iguana_ver(uint8_t *sig,int32_t siglen,uint8_t *data,int32_t datalen,bits256 pubkey);
//int32_t iguana_ver(uint8_t *sig,int32_t siglen,uint8_t *data,int32_t datalen,uint8_t *pubkey);
@ -1039,7 +1073,7 @@ bits256 basilisk_blockhash(struct iguana_info *coin,bits256 prevhash2);
void calc_scrypthash(uint32_t *hash,void *data);
int32_t iguana_rwvarstr(int32_t rwflag,uint8_t *serialized,int32_t maxlen,char *endianedp);
bits256 bitcoin_sharedsecret(void *ctx,bits256 privkey,uint8_t *pubkey,int32_t plen);
int32_t iguana_rwblock80(int32_t rwflag,uint8_t *serialized,struct iguana_msgblock *msg);
int32_t iguana_blockhdrsize(char *symbol,uint8_t zcash,uint8_t auxpow);//,uint8_t *serialized,int32_t maxlen);
extern int32_t HDRnet,netBLOCKS;

4
iguana/iguana_accept.c
View File

@ -300,8 +300,8 @@ int32_t iguana_peerhdrrequest(struct iguana_info *coin,uint8_t *serialized,int32
{
if ( (block= bp->blocks[i]) != 0 )
{
iguana_blockunconv(&msgB,block,1);
len += iguana_rwblock(coin->symbol,coin->chain->hashalgo,1,&checkhash2,&serialized[sizeof(struct iguana_msghdr) + len],&msgB);
iguana_blockunconv(coin->chain->zcash,coin->chain->auxpow,&msgB,block,1);
len += iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&checkhash2,&serialized[sizeof(struct iguana_msghdr) + len],&msgB,(int32_t)(maxsize-len-sizeof(struct iguana_msghdr)));
flag++;
if ( bits256_cmp(checkhash2,block->RO.hash2) != 0 )
{

175
iguana/iguana_blocks.c
View File

@ -15,6 +15,98 @@
#include "iguana777.h"
#define iguana_blockfind(str,coin,hash2) iguana_blockhashset(str,coin,-1,hash2,0)
void iguana_blockconv(uint8_t zcash,uint8_t auxpow,struct iguana_block *dest,struct iguana_msgblock *msg,bits256 hash2,int32_t height) //uint32_t numtxids,uint32_t numunspents,uint32_t numspends,double PoW)
{
int32_t i;
memset(dest,0,sizeof(*dest));
dest->RO.version = msg->H.version;
dest->RO.prev_block = msg->H.prev_block;
dest->RO.merkle_root = msg->H.merkle_root;
dest->RO.timestamp = msg->H.timestamp;
dest->RO.bits = msg->H.bits;
dest->RO.txn_count = msg->txn_count;
dest->height = height;
dest->RO.hash2 = hash2;
if ( zcash == 0 )
dest->RO.nonce = msg->H.nonce;
else
{
dest->RO.allocsize = (int32_t)(sizeof(*dest) + sizeof(*dest->zRO));
dest->zRO[0].bignonce = msg->zH.bignonce;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
dest->zRO[0].solution[i] = msg->zH.solution[i];
}
}
void iguana_blockunconv(uint8_t zcash,uint8_t auxpow,struct iguana_msgblock *msg,struct iguana_block *src,int32_t cleartxn_count)
{
int32_t i;
memset(msg,0,sizeof(*msg));
msg->H.version = src->RO.version;
msg->H.prev_block = src->RO.prev_block;
msg->H.merkle_root = src->RO.merkle_root;
msg->H.timestamp = src->RO.timestamp;
msg->H.bits = src->RO.bits;
if ( zcash == 0 )
msg->H.nonce = src->RO.nonce;
else
{
msg->zH.bignonce = src->zRO[0].bignonce;
msg->zH.numelements = ZCASH_SOLUTION_ELEMENTS;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
msg->zH.solution[i] = src->zRO[0].solution[i];
}
if ( cleartxn_count == 0 )
msg->txn_count = src->RO.txn_count;
}
void iguana_blockcopy(uint8_t zcash,uint8_t auxpow,struct iguana_info *coin,struct iguana_block *block,struct iguana_block *origblock)
{
int32_t i;
block->RO.hash2 = origblock->RO.hash2;
block->RO.merkle_root = origblock->RO.merkle_root;
if ( bits256_nonz(block->RO.prev_block) == 0 )
block->RO.prev_block = origblock->RO.prev_block;
if ( block->mainchain == 0 )
block->mainchain = origblock->mainchain;
if ( block->fpos < 0 )
block->fpos = origblock->fpos;
if ( block->fpipbits == 0 )
block->fpipbits = origblock->fpipbits;
if ( block->RO.timestamp == 0 )
block->RO.timestamp = origblock->RO.timestamp;
if ( block->RO.bits == 0 )
block->RO.bits = origblock->RO.bits;
if ( block->RO.txn_count == 0 )
block->RO.txn_count = origblock->RO.txn_count;
if ( block->RO.version == 0 )
block->RO.version = origblock->RO.version;
if ( block->mainchain == 0 )
block->mainchain = origblock->mainchain;
if ( block->valid == 0 )
block->valid = origblock->valid;
if ( block->RO.recvlen == 0 )
block->RO.recvlen = origblock->RO.recvlen;
if ( zcash == 0 )
{
if ( block->RO.nonce == 0 )
block->RO.nonce = origblock->RO.nonce;
}
else
{
if ( block->RO.allocsize != origblock->RO.allocsize || block->RO.allocsize != sizeof(*block) + sizeof(*block->zRO) )
printf("missing space for zcash block.%d origblock.%d\n",block->RO.allocsize,origblock->RO.allocsize);
else
{
block->zRO[0].bignonce = origblock->zRO[0].bignonce;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
block->zRO[0].solution[i] = origblock->zRO[0].solution[i];
}
}
}
bits256 iguana_merkle(bits256 *tree,int32_t txn_count)
{
int32_t i,n=0,prev; uint8_t serialized[sizeof(bits256) * 2];
@ -38,8 +130,6 @@ bits256 iguana_merkle(bits256 *tree,int32_t txn_count)
return(tree[n]);
}
#define iguana_blockfind(str,coin,hash2) iguana_blockhashset(str,coin,-1,hash2,0)
struct iguana_block *iguana_prevblock(struct iguana_info *coin,struct iguana_block *block,int32_t PoSflag)
{
int32_t hdrsi,bundlei,height; struct iguana_bundle *bp;
@ -83,12 +173,12 @@ void _iguana_blocklink(struct iguana_info *coin,struct iguana_block *prev,struct
struct iguana_block *iguana_blockhashset(char *debugstr,struct iguana_info *coin,int32_t height,bits256 hash2,int32_t createflag)
{
struct iguana_block *block,*prev;
if ( height > 0 && height > coin->blocks.maxbits )
/*if ( height > 0 && height > coin->blocks.maxbits )
{
printf("%s: illegal height.%d when max.%d, or nonz depth.%d\n",debugstr,height,coin->blocks.maxbits,coin->blockdepth);
//getchar();
return(0);
}
}*/
while ( coin->blockdepth > 0 )
{
sleep(1);
@ -116,8 +206,9 @@ struct iguana_block *iguana_blockhashset(char *debugstr,struct iguana_info *coin
if ( createflag > 0 )
{
portable_mutex_lock(&coin->blocks_mutex);
block = calloc(1,sizeof(*block));
block = calloc(1,sizeof(*block) + coin->chain->zcash*sizeof(*block->zRO));
block->RO.hash2 = hash2;
block->RO.allocsize = (int32_t)(sizeof(*block) + coin->chain->zcash*sizeof(*block->zRO));
block->hh.itemind = height, block->height = -1;
HASH_ADD(hh,coin->blocks.hash,RO.hash2,sizeof(hash2),block);
block->hh.next = block->hh.prev = 0;
@ -232,72 +323,15 @@ void iguana_blockmerge(struct iguana_block *dest,struct iguana_prevdep *destlp,s
iguana_mergeprevdep(destlp,srclp);
}*/
void iguana_blockconv(struct iguana_block *dest,struct iguana_msgblock *msg,bits256 hash2,int32_t height) //uint32_t numtxids,uint32_t numunspents,uint32_t numspends,double PoW)
{
memset(dest,0,sizeof(*dest));
dest->RO.version = msg->H.version;
dest->RO.prev_block = msg->H.prev_block;
dest->RO.merkle_root = msg->H.merkle_root;
dest->RO.timestamp = msg->H.timestamp;
dest->RO.bits = msg->H.bits;
dest->RO.nonce = msg->H.nonce;
dest->RO.txn_count = msg->txn_count;
dest->height = height;
dest->RO.hash2 = hash2;
}
void iguana_blockunconv(struct iguana_msgblock *msg,struct iguana_block *src,int32_t cleartxn_count)
{
memset(msg,0,sizeof(*msg));
msg->H.version = src->RO.version;
msg->H.prev_block = src->RO.prev_block;
msg->H.merkle_root = src->RO.merkle_root;
msg->H.timestamp = src->RO.timestamp;
msg->H.bits = src->RO.bits;
msg->H.nonce = src->RO.nonce;
if ( cleartxn_count == 0 )
msg->txn_count = src->RO.txn_count;
}
void iguana_blockcopy(struct iguana_info *coin,struct iguana_block *block,struct iguana_block *origblock)
{
block->RO.hash2 = origblock->RO.hash2;
block->RO.merkle_root = origblock->RO.merkle_root;
if ( bits256_nonz(block->RO.prev_block) == 0 )
block->RO.prev_block = origblock->RO.prev_block;
if ( block->mainchain == 0 )
block->mainchain = origblock->mainchain;
if ( block->fpos < 0 )
block->fpos = origblock->fpos;
if ( block->fpipbits == 0 )
block->fpipbits = origblock->fpipbits;
if ( block->RO.timestamp == 0 )
block->RO.timestamp = origblock->RO.timestamp;
if ( block->RO.nonce == 0 )
block->RO.nonce = origblock->RO.nonce;
if ( block->RO.bits == 0 )
block->RO.bits = origblock->RO.bits;
if ( block->RO.txn_count == 0 )
block->RO.txn_count = origblock->RO.txn_count;
if ( block->RO.version == 0 )
block->RO.version = origblock->RO.version;
if ( block->mainchain == 0 )
block->mainchain = origblock->mainchain;
if ( block->valid == 0 )
block->valid = origblock->valid;
if ( block->RO.recvlen == 0 )
block->RO.recvlen = origblock->RO.recvlen;
}
double PoW_from_compact(uint32_t nBits,uint8_t unitval) // NOT consensus safe, but most of the time will be correct
{
uint32_t nbytes,nbits,i,n; double PoW; uint64_t mult;
nbytes = (nBits >> 24) & 0xFF;
nbits = (8 * (nbytes - 3));
PoW = (nBits & 0xFFFFFF);
if ( nbytes > unitval )
if ( 1 && nbytes > unitval )
{
printf("illegal nBits.%x\n",nBits);
printf("illegal nBits.%x unitval.%02x\n",nBits,unitval);
return(0.);
}
if ( (n= ((8 * (unitval-3)) - nbits)) != 0 ) // 0x1d00ffff is genesis nBits so we map that to 1.
@ -312,7 +346,7 @@ double PoW_from_compact(uint32_t nBits,uint8_t unitval) // NOT consensus safe, b
}
}
mult = 1;
while ( nbytes++ < 30 )
while ( nbytes++ < unitval )
mult <<= 8;
PoW = (PoW * mult) / (nBits & 0xffffff);
//printf("nBits.%x -> %.15f diff %.15f | n.%d unitval.%d nbytes.%d\n",nBits,PoW,1./PoW,n,unitval,nbytes);
@ -414,7 +448,7 @@ struct iguana_block *iguana_fastlink(struct iguana_info *coin,int32_t hwmheight)
coin->blocks.maxblocks = (block->height + 1);
if ( coin->blocks.maxblocks > coin->longestchain )
coin->longestchain = coin->blocks.maxblocks;
coin->blocks.hwmchain = *block;
memcpy(&coin->blocks.hwmchain,block,block->RO.allocsize);
block->valid = block->mainchain = 1;
block->hdrsi = hdrsi, block->bundlei = bundlei;
block->height = height;
@ -450,7 +484,7 @@ struct iguana_block *_iguana_chainlink(struct iguana_info *coin,struct iguana_bl
bits256 *hash2p=0; double prevPoW = 0.; struct iguana_bundle *bp;
if ( newblock == 0 )
return(0);
hwmchain = &coin->blocks.hwmchain;
hwmchain = (struct iguana_block *)&coin->blocks.hwmchain;
if ( 0 && hwmchain->height > 0 && ((bp= coin->current) == 0 || hwmchain->height/coin->chain->bundlesize > bp->hdrsi+0*bp->isRT) )
return(0);
if ( (block= iguana_blockfind("chainlink",coin,newblock->RO.hash2)) != 0 )
@ -467,6 +501,7 @@ struct iguana_block *_iguana_chainlink(struct iguana_info *coin,struct iguana_bl
block->PoW = PoW_from_compact(block->RO.bits,coin->chain->unitval) + prevPoW;
if ( (next= prev->hh.next) != 0 )
{
//printf("block->PoW %f next %f\n",block->PoW,next->PoW);
if ( next->mainchain != 0 && block->PoW < next->PoW )
return(0);
hwmchain = next;
@ -506,8 +541,8 @@ struct iguana_block *_iguana_chainlink(struct iguana_info *coin,struct iguana_bl
if ( coin->isRT != 0 || block->height == hwmchain->height )
{
coin->blocks.maxblocks = (block->height + 1);
coin->blocks.hwmchain = *block;
//printf("[%s] <- ht.%d\n",bits256_str(str,block->hash2),coin->blocks.hwmheight);
memcpy(&coin->blocks.hwmchain,block,block->RO.allocsize);
//printf("[%s] <- ht.%d %f\n",bits256_str(str,block->RO.hash2),coin->blocks.hwmchain.height,coin->blocks.hwmchain.PoW);
char str[65],str2[65]; bits256 zero;
memset(&zero,0,sizeof(zero));
bits256_str(str,newblock->RO.hash2);
@ -611,7 +646,7 @@ int32_t iguana_chainextend(struct iguana_info *coin,struct iguana_block *newbloc
{
block = iguana_blockhashset("chainextend",coin,-1,newblock->RO.hash2,1);
if ( block != newblock )
iguana_blockcopy(coin,block,newblock);
iguana_blockcopy(coin->chain->zcash,coin->chain->auxpow,coin,block,newblock);
block->valid = 1;
if ( block->hh.prev == 0 && (prev= iguana_blockfind("extendprev",coin,block->RO.prev_block)) != 0 )
{

11
iguana/iguana_chains.c
View File

@ -160,19 +160,21 @@ bits256 iguana_calcblockhash(char *symbol,int32_t (*hashalgo)(uint8_t *blockhash
return(hash2);
}
bits256 iguana_chaingenesis(char *symbol,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),bits256 genesishash,char *genesisblock,char *hashalgostr,int32_t version,uint32_t timestamp,uint32_t nBits,uint32_t nonce,bits256 merkle_root)
bits256 iguana_chaingenesis(char *symbol,uint8_t zcash,uint8_t auxpow,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),bits256 genesishash,char *genesisblock,char *hashalgostr,int32_t version,uint32_t timestamp,uint32_t nBits,uint32_t nonce,bits256 merkle_root)
{
struct iguana_msgblock msg; int32_t len; bits256 hash2; char blockhashstr[256],str3[65]; uint8_t serialized[1024];
struct iguana_msgblock msg; int32_t len; bits256 hash2; char blockhashstr[256],str3[65]; uint8_t serialized[8192];
memset(&msg,0,sizeof(msg));
msg.H.version = version;
msg.H.merkle_root = merkle_root;
msg.H.timestamp = timestamp;
msg.H.bits = nBits;
msg.H.nonce = nonce;
if ( zcash != 0 )
printf("need to handle zcash genesis\n");
if ( hashalgostr != 0 && strcmp(hashalgostr,"sha256") != 0 )
hashalgo = iguana_hashalgo(hashalgostr);
else hashalgo = blockhash_sha256;
len = iguana_rwblock(symbol,hashalgo,1,&hash2,serialized,&msg);
len = iguana_rwblock(symbol,zcash,auxpow,hashalgo,1,&hash2,serialized,&msg,sizeof(1024));
blockhashstr[0] = 0;
init_hexbytes_noT(blockhashstr,hash2.bytes,sizeof(hash2));
char str[65],str2[65];
@ -325,6 +327,7 @@ void iguana_chainparms(struct iguana_chain *chain,cJSON *argjson)
chain->ramchainport = chain->portp2p - 1;
if ( (chain->rpcport= juint(argjson,"rpc")) == 0 )
chain->rpcport = chain->portp2p - 1;
chain->zcash = juint(argjson,"zcash");
if ( jobj(argjson,"isPoS") != 0 )
chain->txhastimestamp = juint(argjson,"isPoS");
else if ( jobj(argjson,"oldtx_format") != 0 )
@ -380,7 +383,7 @@ void iguana_chainparms(struct iguana_chain *chain,cJSON *argjson)
((uint8_t *)&nBits)[3] = tmp[0];
}
else nBits = 0x1e00ffff;
hash = iguana_chaingenesis(chain->symbol,chain->hashalgo,hash,genesisblock,jstr(genesis,"hashalgo"),juint(genesis,"version"),juint(genesis,"timestamp"),nBits,juint(genesis,"nonce"),jbits256(genesis,"merkle_root"));
hash = iguana_chaingenesis(chain->symbol,chain->zcash,chain->auxpow,chain->hashalgo,hash,genesisblock,jstr(genesis,"hashalgo"),juint(genesis,"version"),juint(genesis,"timestamp"),nBits,juint(genesis,"nonce"),jbits256(genesis,"merkle_root"));
memcpy(chain->genesis_hashdata,hash.bytes,32);
char str[65]; init_hexbytes_noT(str,chain->genesis_hashdata,32);
chain->genesis_hash = clonestr(str);

62
iguana/iguana_init.c
View File

@ -83,7 +83,10 @@ void iguana_initcoin(struct iguana_info *coin,cJSON *argjson)
bits256 iguana_genesis(struct iguana_info *coin,struct iguana_chain *chain)
{
struct iguana_block block,*ptr; struct iguana_msgblock msg; bits256 hash2; char str[65],str2[65]; uint8_t buf[1024]; int32_t height,auxback;
struct iguana_block *block,*ptr; struct iguana_msgblock msg; bits256 hash2; char str[65],str2[65]; uint8_t buf[8192],blockspace[sizeof(*block)+sizeof(*block->zRO)]; int32_t height,auxback;
block = (void *)blockspace;
memset(block,0,sizeof(blockspace));
block->RO.allocsize = (int32_t)(sizeof(*block) + coin->chain->zcash*sizeof(*block->zRO));
if ( chain->genesis_hex == 0 )
{
printf("no genesis_hex for %s\n",coin->symbol);
@ -93,45 +96,47 @@ bits256 iguana_genesis(struct iguana_info *coin,struct iguana_chain *chain)
decode_hex(buf,(int32_t)strlen(chain->genesis_hex)/2,(char *)chain->genesis_hex);
hash2 = iguana_calcblockhash(coin->symbol,coin->chain->hashalgo,buf,sizeof(struct iguana_msgblockhdr));
auxback = coin->chain->auxpow, coin->chain->auxpow = 0;
iguana_rwblock(coin->symbol,coin->chain->hashalgo,0,&hash2,buf,&msg);
iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,0,&hash2,buf,&msg,sizeof(buf));
coin->chain->auxpow = auxback;
if ( coin->MAXPEERS > 1 && memcmp(hash2.bytes,chain->genesis_hashdata,sizeof(hash2)) != 0 )
if ( coin->MAXPEERS > 1 )
{
bits256_str(str,hash2);
printf("genesis mismatch? calculated %s vs %s\n",str,bits256_str(str2,*(bits256 *)chain->genesis_hashdata));
//hash2 = bits256_conv("00000ac7d764e7119da60d3c832b1d4458da9bc9ef9d5dd0d91a15f690a46d99");
//memset(hash2.bytes,0,sizeof(hash2));
//return(hash2);
if ( memcmp(hash2.bytes,chain->genesis_hashdata,sizeof(hash2)) != 0 )
{
bits256_str(str,hash2);
printf("genesis mismatch? zcash.%d calculated %s vs %s\n",coin->chain->zcash,str,bits256_str(str2,*(bits256 *)chain->genesis_hashdata));
memcpy(hash2.bytes,chain->genesis_hashdata,sizeof(hash2));
}
} else memcpy(hash2.bytes,chain->genesis_hashdata,sizeof(hash2));
bits256_str(str,hash2);
printf("genesis.(%s) len.%d hash.%s\n",chain->genesis_hex,(int32_t)sizeof(msg.H),str);
iguana_blockconv(&block,&msg,hash2,0);
block.RO.txn_count = 1;
block.RO.numvouts = 1;
printf("genesis.(%s) zcash.%d len.%d hash.%s\n",chain->genesis_hex,coin->chain->zcash,(int32_t)sizeof(msg.H),str);
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,block,&msg,hash2,0);
block->RO.txn_count = 1;
block->RO.numvouts = 1;
block->RO.allocsize = (int32_t)(sizeof(*block) + coin->chain->zcash*sizeof(*block->zRO));
iguana_gotdata(coin,0,0);
if ( (ptr= iguana_blockhashset("genesis0",coin,0,hash2,1)) != 0 )
{
iguana_blockcopy(coin,ptr,&block);
iguana_blockcopy(coin->chain->zcash,coin->chain->auxpow,coin,ptr,block);
ptr->mainchain = 1;
ptr->height = 0;
coin->blocks.RO[0] = block.RO;
//coin->blocks.RO[0] = block.RO;
if ( (height= iguana_chainextend(coin,ptr)) == 0 )
{
block = *ptr;
memcpy(block,ptr,block->RO.allocsize);
printf("size.%d genesis block PoW %f ptr %f\n",block->RO.allocsize,block->PoW,ptr->PoW);
coin->blocks.recvblocks = coin->blocks.issuedblocks = 1;
}
else printf("genesis block doesnt validate for %s ht.%d\n",coin->symbol,height);
} else printf("couldnt hashset genesis\n");
if ( coin->blocks.hwmchain.height != 0 || fabs(coin->blocks.hwmchain.PoW - block.PoW) > SMALLVAL || memcmp(coin->blocks.hwmchain.RO.hash2.bytes,hash2.bytes,sizeof(hash2)) != 0 )
{
printf("%s genesis values mismatch hwmheight.%d %.15f %.15f %s\n",coin->name,coin->blocks.hwmchain.height,coin->blocks.hwmchain.PoW,block.PoW,bits256_str(str,coin->blocks.hwmchain.RO.hash2));
getchar();
}
int32_t bundlei = -2;
static const bits256 zero;
iguana_bundlecreate(coin,&bundlei,0,hash2,zero,1);
_iguana_chainlink(coin,iguana_blockfind("genesis",coin,hash2));
if ( coin->blocks.hwmchain.height != 0 || fabs(coin->blocks.hwmchain.PoW - block->PoW) > SMALLVAL || memcmp(coin->blocks.hwmchain.RO.hash2.bytes,hash2.bytes,sizeof(hash2)) != 0 )
{
printf("%s genesis values mismatch hwmheight.%d %.15f %.15f %s\n",coin->name,coin->blocks.hwmchain.height,coin->blocks.hwmchain.PoW,block->PoW,bits256_str(str,coin->blocks.hwmchain.RO.hash2));
getchar();
}
return(hash2);
}
@ -246,6 +251,7 @@ void iguana_parseline(struct iguana_info *coin,int32_t iter,FILE *fp)
lastbundle = zero;
if ( coin->MAXPEERS > IGUANA_MAXPEERS )
coin->MAXPEERS = IGUANA_MAXPEERS;
#ifdef oldway
if ( iter == 1 && 0 )
{
int32_t i; FILE *fp; char fname[512]; struct iguana_blockRO blockRO;
@ -267,6 +273,7 @@ void iguana_parseline(struct iguana_info *coin,int32_t iter,FILE *fp)
printf("validate.%d blocks that were read in\n",i);
}
}
#endif
m = flag = 0;
allhash = zero;
memset(line,0,sizeof(line));
@ -321,8 +328,8 @@ void iguana_parseline(struct iguana_info *coin,int32_t iter,FILE *fp)
}
if ( line[k + 65] != 0 && line[k+65] != '\n' && line[k+65] != '\r' )
{
if ( height > (coin->blocks.maxbits - 1000) )
iguana_recvalloc(coin,height + 100000);
//if ( height > (coin->blocks.maxbits - 1000) )
// iguana_recvalloc(coin,height + 100000);
decode_hex(allhash.bytes,sizeof(allhash),line+k+1 + 64 + 1);
init_hexbytes_noT(checkstr,allhash.bytes,sizeof(allhash));
//printf("parseline: k.%d %d height.%d m.%d bundlesize.%d (%s) check.(%s)\n",k,line[k],height,m,coin->chain->bundlesize,&line[k+1+65],checkstr);// + strlen(line+k+1)]);
@ -407,12 +414,13 @@ void iguana_blockspurge(struct iguana_info *coin)
}
coin->blocks.hash = 0;
}
if ( coin->blocks.RO != 0 )
/*if ( coin->blocks.RO != 0 )
{
printf("deprecated coin->blocks.RO used??\n");
myfree(coin->blocks.RO,coin->blocks.maxbits * sizeof(*coin->blocks.RO));
coin->blocks.RO = 0;
}
coin->blocks.maxbits = coin->blocks.maxblocks = coin->blocks.initblocks = coin->blocks.hashblocks = coin->blocks.issuedblocks = coin->blocks.recvblocks = coin->blocks.emitblocks = coin->blocks.parsedblocks = coin->blocks.dirty = 0;
coin->blocks.maxbits = */coin->blocks.maxblocks = coin->blocks.initblocks = coin->blocks.hashblocks = coin->blocks.issuedblocks = coin->blocks.recvblocks = coin->blocks.emitblocks = coin->blocks.parsedblocks = coin->blocks.dirty = 0;
memset(&coin->blocks.hwmchain,0,sizeof(coin->blocks.hwmchain));
}
@ -476,7 +484,7 @@ struct iguana_info *iguana_coinstart(struct iguana_info *coin,int32_t initialhei
}
if ( initialheight < coin->chain->bundlesize*10 )
initialheight = coin->chain->bundlesize*10;
iguana_recvalloc(coin,initialheight);
//iguana_recvalloc(coin,initialheight);
if ( coin->longestchain == 0 )
coin->longestchain = 1;
memset(&coin->blocks.hwmchain,0,sizeof(coin->blocks.hwmchain));
@ -495,7 +503,7 @@ struct iguana_info *iguana_coinstart(struct iguana_info *coin,int32_t initialhei
}
}
}
if ( (coin->myservices & 0x80) == 0x80 && coin->rpcloop == 0 )
if ( coin->RELAYNODE != 0 && coin->rpcloop == 0 )
{
myinfo->argport = coin->chain->rpcport;
coin->rpcloop = malloc(sizeof(pthread_t));

232
iguana/iguana_msg.c
View File

@ -72,14 +72,9 @@ int32_t iguana_rwversion(int32_t rwflag,uint8_t *serialized,struct iguana_msgver
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->relayflag),&msg->relayflag);
//if ( rwflag == 0 )
//printf("readsize.%d %-15s v.%llu srv.%llx %u ht.%llu [%s].R%d nonce.%llx\n",readsize,ipaddr,(long long)msg->nVersion,(long long)msg->nServices,(uint32_t)msg->nTime,(long long)msg->nStartingHeight,msg->strSubVer,msg->relayflag,(long long)msg->nonce);
// 6e ea 00 00 01 00 00 00 00 00 00 00 86 5f a8 56 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff b5 2f b7 bc c6 83 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff 67 e5 7e c2 07 80 00 00 00 00 00 00 00 00 10 2f 42 69 74 4e 65 74 3a 31 2e 31 2e 33 2e 32 2f 92 d0 09 00 6c 04 00 00 01 00 00 00 80 07 01 9a 03 9b 03 01
return(len);
}
// 06000000996da490f6151ad9d05d9defc99bda58441d2b833c0da69d11e764d7c70a00003378a650b506a66b41097a0b513f2fee899788711bc6643ff976ce6dbb0b620c5f800854ffff0f1e0004de0301010000005e800854010000000000000000000000000000000000000000000000000000000000000000ffffffff03510102ffffffff0100008a5d784563011976a9145166e6e52de58dfacb18670c0030aedcf295233988ac000000000000
//000007000000940daac77c87ab323a76b7ebb1ba6b9044e3add7108f867be4782925768bffe9b7023b7343cb1b7c8523cbf446f31648616b8500040681140ada6bad40ad8f6ee5c10954ffff0f1e0000
int32_t iguana_rwmerklebranch(int32_t rwflag,uint8_t *serialized,struct iguana_msgmerkle *msg)
{
int32_t i,len = 0;
@ -96,48 +91,105 @@ int32_t iguana_rwmerklebranch(int32_t rwflag,uint8_t *serialized,struct iguana_m
return(len);
}
int32_t iguana_rwblock80(int32_t rwflag,uint8_t *serialized,struct iguana_msgblock *msg)
int32_t iguana_rwzsolution(int32_t rwflag,uint8_t *serialized,uint32_t *solution,int32_t n)
{
int32_t len = 0;
int32_t i,len = 0;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
len += iguana_rwnum(rwflag,&serialized[len],sizeof(solution[i]),&solution[i]);
return(len);
}
int32_t iguana_rwblockhdr(int32_t rwflag,uint8_t zcash,uint8_t *serialized,struct iguana_msgblock *msg)
{
uint32_t tmp; int32_t len = 0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->H.version),&msg->H.version);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->H.prev_block),msg->H.prev_block.bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->H.merkle_root),msg->H.merkle_root.bytes);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->H.timestamp),&msg->H.timestamp);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->H.bits),&msg->H.bits);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->H.nonce),&msg->H.nonce);
if ( zcash == 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->H.nonce),&msg->H.nonce);
else
{
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->zH.bignonce),msg->zH.bignonce.bytes);
//char str[65]; printf("prev.(%s) len.%d [%d %d %d]\n",bits256_str(str,msg->H.prev_block),len,serialized[len],serialized[len+1],serialized[len+2]);
if ( rwflag != 0 )
tmp = msg->zH.numelements;
len += iguana_rwvarint32(rwflag,&serialized[len],(uint32_t *)&tmp);
if ( rwflag == 0 )
msg->zH.numelements = tmp;
if ( msg->zH.numelements != ZCASH_SOLUTION_ELEMENTS )
{
int32_t i; for (i=0; i<157; i++)
printf("%02x",serialized[i]);
printf(" unexpected ZCASH_SOLUTION_ELEMENTS, got %d vs %d len.%d\n",msg->zH.numelements,ZCASH_SOLUTION_ELEMENTS,len);
return(-1);
}
len += iguana_rwzsolution(rwflag,&serialized[len],msg->zH.solution,ZCASH_SOLUTION_ELEMENTS);
}
return(len);
}
int32_t iguana_eatauxpow(int32_t rwflag,char *symbol,uint8_t *serialized)
int32_t iguana_eatauxpow(int32_t rwflag,char *symbol,uint8_t zcash,uint8_t *serialized,int32_t maxlen)
{
int32_t len = 0; void *ptr; struct iguana_msgtx msg; struct OS_memspace MEM; bits256 auxhash2,coinbasetxid; struct iguana_msgmerkle coinbase_branch,blockchain_branch; struct iguana_msgblock parentblock; struct iguana_info *coin;
int32_t len = 0; void *ptr; struct iguana_msgtx msg; struct OS_memspace MEM; bits256 auxhash2,coinbasetxid; struct iguana_msgmerkle *coinbase_branch,*blockchain_branch; struct iguana_msgblock parentblock; struct iguana_info *coin;
if ( rwflag == 0 && (coin= iguana_coinfind(symbol)) != 0 && coin->chain->auxpow != 0 )
{
memset(&msg,0,sizeof(msg));
memset(&coinbase_branch,0,sizeof(coinbase_branch));
memset(&blockchain_branch,0,sizeof(blockchain_branch));
coinbase_branch = calloc(1,sizeof(*coinbase_branch));
blockchain_branch = calloc(1,sizeof(*blockchain_branch));
memset(&parentblock,0,sizeof(parentblock));
memset(&MEM,0,sizeof(MEM));
ptr = calloc(1,1000000);
iguana_meminit(&MEM,"auxpow",ptr,1000000,0);
len += iguana_rwtx(rwflag,&MEM,&serialized[len],&msg,(int32_t)MEM.totalsize,&coinbasetxid,coin->chain->txhastimestamp,0);
len += iguana_rwtx(coin->chain->zcash,rwflag,&MEM,&serialized[len],&msg,(int32_t)MEM.totalsize,&coinbasetxid,coin->chain->txhastimestamp,0);
if ( len > maxlen )
return(-1);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(auxhash2),auxhash2.bytes);
len += iguana_rwmerklebranch(rwflag,&serialized[len],&coinbase_branch);
len += iguana_rwmerklebranch(rwflag,&serialized[len],&blockchain_branch);
len += iguana_rwblock80(rwflag,&serialized[len],&parentblock);
if ( len > maxlen )
return(-1);
len += iguana_rwmerklebranch(rwflag,&serialized[len],coinbase_branch);
if ( len > maxlen )
return(-1);
len += iguana_rwmerklebranch(rwflag,&serialized[len],blockchain_branch);
if ( len > maxlen )
return(-1);
len += iguana_rwblockhdr(rwflag,zcash,&serialized[len],&parentblock);
if ( len > maxlen )
return(-1);
free(ptr);
free(coinbase_branch);
free(blockchain_branch);
}
return(len);
}
int32_t iguana_rwblock(char *symbol,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),int32_t rwflag,bits256 *hash2p,uint8_t *serialized,struct iguana_msgblock *msg)
int32_t iguana_blockhdrsize(char *symbol,uint8_t zcash,uint8_t auxpow)//,uint8_t *serialized,int32_t maxlen)
{
int32_t len = 0;
if ( zcash == 0 )
{
if ( auxpow == 0 )
return(sizeof(struct iguana_msgblockhdr));
//if ( (len= iguana_eatauxpow(0,symbol,&serialized[sizeof(struct iguana_msgblockhdr)],(int32_t)(maxlen-sizeof(struct iguana_msgblockhdr)))) > 0 )
return(sizeof(struct iguana_msgblockhdr) + len);
//else
return(-1);
} else return((int32_t)(sizeof(struct iguana_msgblockhdr) - sizeof(uint32_t) + sizeof(struct iguana_msgblockhdr_zcash) + auxpow*sizeof(bits256)));
}
int32_t iguana_rwblock(char *symbol,uint8_t zcash,uint8_t auxpow,int32_t (*hashalgo)(uint8_t *blockhashp,uint8_t *serialized,int32_t len),int32_t rwflag,bits256 *hash2p,uint8_t *serialized,struct iguana_msgblock *msg,int32_t maxlen)
{
int32_t len = 0; uint64_t x;
len = iguana_rwblock80(rwflag,serialized,msg);
if ( (len= iguana_rwblockhdr(rwflag,zcash,serialized,msg)) < 0 )
{
printf("error rw.%d blockhdr zcash.%d\n",rwflag,zcash);
return(-1);
}
*hash2p = iguana_calcblockhash(symbol,hashalgo,serialized,len);
//char str[65]; printf("len.%d: block version.%d timestamp.%u bits.%x nonce.%u prev.(%s) %llx %llx\n",len,msg->H.version,msg->H.timestamp,msg->H.bits,msg->H.nonce,bits256_str(str,msg->H.prev_block),(long long)msg->H.merkle_root.txid,(long long)hash2p->txid);
if ( rwflag == 0 && (msg->H.version & 0x100) != 0 )
len += iguana_eatauxpow(rwflag,symbol,&serialized[len]);
//char str[65],str2[65]; printf("zcash.%d len.%d: block version.%d timestamp.%u bits.%x nonce.%u prev.(%s) %llx hash2.%s\n",zcash,len,msg->H.version,msg->H.timestamp,msg->H.bits,msg->H.nonce,bits256_str(str,msg->H.prev_block),(long long)msg->H.merkle_root.txid,bits256_str(str2,*hash2p));
if ( rwflag == 0 && auxpow != 0 && (msg->H.version & 0x100) != 0 )
len += iguana_eatauxpow(rwflag,symbol,zcash,&serialized[len],maxlen-len);
else x = msg->txn_count;
len += iguana_rwvarint(rwflag,&serialized[len],&x);
if ( rwflag == 0 )
@ -154,16 +206,27 @@ int32_t iguana_rwblock(char *symbol,int32_t (*hashalgo)(uint8_t *blockhashp,uint
int32_t iguana_serialize_block(struct iguana_chain *chain,bits256 *hash2p,uint8_t serialized[sizeof(struct iguana_msgblock)],struct iguana_block *block)
{
struct iguana_msgblock msg; int32_t len;
struct iguana_msgblock msg; int32_t i,len;
memset(&msg,0,sizeof(msg));
msg.H.version = block->RO.version;
msg.H.prev_block = block->RO.prev_block;
msg.H.merkle_root = block->RO.merkle_root;
msg.H.timestamp = block->RO.timestamp;
msg.H.bits = block->RO.bits;
msg.H.nonce = block->RO.nonce;
if ( chain->zcash == 0 )
msg.H.nonce = block->RO.nonce;
else
{
if ( block->RO.allocsize == sizeof(*block)+sizeof(*block->zRO) )
{
msg.zH.bignonce = block->zRO[0].bignonce;
msg.zH.numelements = ZCASH_SOLUTION_ELEMENTS;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
msg.zH.solution[i] = block->zRO[0].solution[i];
} else printf("iguana_serialize_block has missing zRO\n");
}
msg.txn_count = block->RO.txn_count;
len = iguana_rwblock(chain->symbol,chain->hashalgo,1,hash2p,serialized,&msg);
len = iguana_rwblock(chain->symbol,chain->zcash,chain->auxpow,chain->hashalgo,1,hash2p,serialized,&msg,IGUANA_MAXPACKETSIZE);
return(len);
}
@ -266,14 +329,14 @@ void iguana_gotversion(struct iguana_info *coin,struct iguana_peer *addr,struct
else if ( 0 && addr->supernet == 0 && addr->basilisk == 0 )//|| (addr->basilisk != 0 && myinfo->IAMRELAY == 0) )
addr->dead = (uint32_t)time(NULL);
//if ( addr->supernet != 0 || addr->basilisk != 0 )
// printf("height.%d nServices.%lld nonce.%llu %srelay node.(%s) supernet.%d basilisk.%d\n",vers->nStartingHeight,(long long)vers->nServices,(long long)vers->nonce,addr->relayflag==0?"non-":"",addr->ipaddr,addr->supernet,addr->basilisk);
printf("height.%d nServices.%lld nonce.%llu %srelay node.(%s) supernet.%d basilisk.%d longest.%u\n",vers->nStartingHeight,(long long)vers->nServices,(long long)vers->nonce,addr->relayflag==0?"non-":"",addr->ipaddr,addr->supernet,addr->basilisk,vers->nStartingHeight);
if ( (int32_t)vers->nStartingHeight > coin->longestchain )
{
if ( coin->badlongestchain != 0 && (int32_t)vers->nStartingHeight >= coin->badlongestchain )
{
printf("peer.(%s) gives badlongestchain.%d\n",addr->ipaddr,vers->nStartingHeight);
addr->dead = 1;
} else coin->longestchain = vers->nStartingHeight;
} //else coin->longestchain = vers->nStartingHeight;
}
iguana_queue_send(addr,0,serialized,"getaddr",0);
}
@ -475,14 +538,38 @@ int32_t iguana_rwvout(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized
return(len);
}
int32_t iguana_rwtx(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,struct iguana_msgtx *msg,int32_t maxsize,bits256 *txidp,int32_t hastimestamp,int32_t isvpncoin)
int32_t iguana_rwjoinsplit(int32_t rwflag,uint8_t *serialized,struct iguana_msgjoinsplit *msg)
{
int32_t len = 0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->vpub_old),&msg->vpub_old);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->vpub_new),&msg->vpub_new);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->anchor),msg->anchor.bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->nullifiers[0]),msg->nullifiers[0].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->nullifiers[1]),msg->nullifiers[1].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->commitments[0]),msg->commitments[0].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->commitments[1]),msg->commitments[1].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->ephemeralkey),msg->ephemeralkey.bytes);
if ( rwflag == 1 )
memcpy(&serialized[len],msg->ciphertexts,sizeof(msg->ciphertexts));
else memcpy(msg->ciphertexts,&serialized[len],sizeof(msg->ciphertexts));
len += sizeof(msg->ciphertexts);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->randomseed),msg->randomseed.bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->vmacs[0]),msg->vmacs[0].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->vmacs[1]),msg->vmacs[1].bytes);
if ( rwflag == 1 )
memcpy(&serialized[len],msg->zkproof,sizeof(msg->zkproof));
else memcpy(msg->zkproof,&serialized[len],sizeof(msg->zkproof));
len += sizeof(msg->zkproof);
return(len);
}
int32_t iguana_rwtx(uint8_t zcash,int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,struct iguana_msgtx *msg,int32_t maxsize,bits256 *txidp,int32_t hastimestamp,int32_t isvpncoin)
{
int32_t i,len = 0; uint8_t *txstart = serialized; char txidstr[65];
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->version),&msg->version);
if ( hastimestamp != 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->timestamp),&msg->timestamp);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->tx_in);
//printf("version.%d ",msg->version);
if ( rwflag == 0 )
msg->vins = iguana_memalloc(mem,msg->tx_in * sizeof(*msg->vins),1);
for (i=0; i<msg->tx_in; i++)
@ -494,7 +581,6 @@ int32_t iguana_rwtx(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,s
return(-1);
}
}
//printf("numvins.%d\n",msg->tx_in);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->tx_out);
//printf("numvouts.%d ",msg->tx_out);
if ( rwflag == 0 )
@ -516,6 +602,28 @@ int32_t iguana_rwtx(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,s
for (; serialized[len]!=0&&len<maxsize; len++) // eat null terminated string
;
}
if ( zcash != 0 && msg->version == 2 )
{
uint32_t numjoinsplits; struct iguana_msgjoinsplit joinsplit; uint8_t joinsplitpubkey[33],joinsplitsig[64];
len += iguana_rwvarint32(rwflag,&serialized[len],&numjoinsplits);
char str[65];
printf("numjoinsplits.%d version.%d numvins.%d numvouts.%d locktime.%u %s\n",numjoinsplits,msg->version,msg->tx_in,msg->tx_out,msg->lock_time,bits256_str(str,*txidp));
if ( numjoinsplits > 0 )
{
for (i=0; i<numjoinsplits; i++)
len += iguana_rwjoinsplit(rwflag,&serialized[len],&joinsplit);
}
if ( rwflag != 0 )
{
memcpy(&serialized[len],joinsplitpubkey,33), len += 33;
memcpy(&serialized[len],joinsplitsig,64), len += 64;
}
else
{
memcpy(joinsplitpubkey,&serialized[len],33), len += 33;
memcpy(joinsplitsig,&serialized[len],64), len += 64;
}
}
*txidp = bits256_doublesha256(txidstr,txstart,len);
msg->allocsize = len;
return(len);
@ -523,18 +631,19 @@ int32_t iguana_rwtx(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,s
char *iguana_txscan(struct iguana_info *coin,cJSON *json,uint8_t *data,int32_t recvlen,bits256 txid)
{
struct iguana_msgtx tx; bits256 hash2; struct iguana_block block; struct iguana_msgblock msg;
int32_t i,n,len,extralen = 65356; char *txbytes,vpnstr[64]; uint8_t *extraspace;
struct iguana_msgtx tx; bits256 hash2; struct iguana_block *block; struct iguana_msgblock msg;
int32_t i,n,len,extralen = 65356; char *txbytes,vpnstr[64]; uint8_t *extraspace,blockspace[sizeof(*block)+sizeof(*block->zRO)];
block = (void *)blockspace;
memset(&msg,0,sizeof(msg));
vpnstr[0] = 0;
extraspace = calloc(1,extralen);
len = iguana_rwblock(coin->symbol,coin->chain->hashalgo,0,&hash2,data,&msg);
iguana_blockconv(&block,&msg,hash2,-1);
len = iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,0,&hash2,data,&msg,recvlen);
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,block,&msg,hash2,-1);
for (i=0; i<msg.txn_count; i++)
{
if ( (n= iguana_rwmsgtx(coin,0,0,&data[len],recvlen - len,&tx,&tx.txid,vpnstr,extraspace,extralen,0)) < 0 )
break;
//char str[65]; printf("%d of %d: %s\n",i,msg.txn_count,bits256_str(str,tx.txid));
char str[65]; printf("%d of %d: %s len.%d\n",i,msg.txn_count,bits256_str(str,tx.txid),len);
if ( bits256_cmp(txid,tx.txid) == 0 )
{
if ( (n= iguana_rwmsgtx(coin,0,json,&data[len],recvlen - len,&tx,&tx.txid,vpnstr,extraspace,extralen,0)) > 0 )
@ -554,20 +663,27 @@ int32_t iguana_gentxarray(struct iguana_info *coin,struct OS_memspace *mem,struc
{
struct iguana_msgtx *tx; bits256 hash2; struct iguana_msgblock msg; int32_t i,n,hdrlen,len,numvouts,numvins; char str[65];
memset(&msg,0,sizeof(msg));
len = iguana_rwblock(coin->symbol,coin->chain->hashalgo,0,&hash2,data,&msg);
if ( 0 && coin->chain->auxpow != 0 )
printf("version.%d\n",msg.H.version);
len = iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,0,&hash2,data,&msg,recvlen);
hdrlen = len;
if ( len > recvlen )
{
printf("gentxarray error len.%d > recvlen.%d\n",len,recvlen);
return(-1);
iguana_blockconv(&txdata->block,&msg,hash2,-1);
}
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,(struct iguana_block *)&txdata->zblock,&msg,hash2,-1);
tx = iguana_memalloc(mem,msg.txn_count*sizeof(*tx),1);
for (i=numvins=numvouts=0; i<msg.txn_count; i++)
{
if ( len > recvlen )
{
printf("gentxarray error len.%d > recvlen.%d\n",len,recvlen);
break;
if ( (n= iguana_rwtx(0,mem,&data[len],&tx[i],recvlen - len,&tx[i].txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0)) < 0 )
}
if ( (n= iguana_rwtx(coin->chain->zcash,0,mem,&data[len],&tx[i],recvlen - len,&tx[i].txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0)) < 0 )
{
printf("gentxarray error len.%d > recvlen.%d\n",len,recvlen);
break;
}
numvouts += tx[i].tx_out;
numvins += tx[i].tx_in;
len += n;
@ -580,7 +696,7 @@ int32_t iguana_gentxarray(struct iguana_info *coin,struct OS_memspace *mem,struc
txdata->extralen = (recvlen - len);
} else txdata->extralen = 0;
if ( coin->chain->auxpow != 0 && len != recvlen )
printf("%s hdrlen.%d len.%d vs recvlen.%d v.%08x\n",bits256_str(str,hash2),hdrlen,len,recvlen,txdata->block.RO.version);
printf("numtx.%d %s hdrlen.%d len.%d vs recvlen.%d v.%08x\n",msg.txn_count,bits256_str(str,hash2),hdrlen,len,recvlen,txdata->zblock.RO.version);
txdata->recvlen = len;
txdata->numtxids = msg.txn_count;
txdata->numunspents = numvouts;
@ -727,7 +843,7 @@ int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struc
{
//for (i=0; i<recvlen; i++)
// printf("%02x",data[i]);
printf(" parse error block txn_count.%d, n.%d len.%d vs recvlen.%d from.(%s)\n",txdata.block.RO.txn_count,n,len,recvlen,addr->ipaddr);
printf(" parse error block txn_count.%d, n.%d len.%d vs recvlen.%d from.(%s)\n",txdata.zblock.RO.txn_count,n,len,recvlen,addr->ipaddr);
}
}
else
@ -756,7 +872,7 @@ int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struc
}
else if ( (ishost= (strcmp(H->command,"getheaders") == 0)) || strcmp(H->command,"headers") == 0 )
{
struct iguana_msgblock msg; struct iguana_block *blocks; uint32_t tmp,n=0;
struct iguana_msgblock msg; struct iguana_zblock *zblocks; uint32_t tmp,n=0;
len = 0;
if ( addr != 0 )
{
@ -765,44 +881,42 @@ int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struc
len = iguana_rwvarint32(0,data,&n);
if ( n <= IGUANA_MAXINV )
{
bits256 auxhash2,prevhash2; struct iguana_msgtx *tx; struct iguana_msgmerkle coinbase_branch,blockchain_branch; struct iguana_msgblock parentblock;
bits256 auxhash2,prevhash2; struct iguana_msgtx *tx; struct iguana_msgmerkle *coinbase_branch,*blockchain_branch; struct iguana_msgblock parentblock;
coinbase_branch = calloc(1,sizeof(*coinbase_branch));
blockchain_branch = calloc(1,sizeof(*blockchain_branch));
if ( rawmem->totalsize == 0 )
iguana_meminit(rawmem,"bighdrs",0,IGUANA_MAXPACKETSIZE * 2,0);
memset(prevhash2.bytes,0,sizeof(prevhash2));
blocks = mycalloc('i',1,sizeof(*blocks) * n);
zblocks = mycalloc('i',1,(int32_t)(sizeof(struct iguana_zblock) * n));
//printf("%s got %d headers len.%d\n",coin->symbol,n,recvlen);
for (i=0; i<n; i++)
{
if ( coin->chain->auxpow != 0 )
{
tmp = iguana_rwblock80(0,&data[len],&msg);
tmp = iguana_rwblockhdr(0,coin->chain->zcash,&data[len],&msg);
hash2 = iguana_calcblockhash(coin->symbol,coin->chain->hashalgo,&data[len],tmp);
len += tmp;
if ( (msg.H.version & 0x100) != 0 )
{
iguana_memreset(rawmem);
tx = iguana_memalloc(rawmem,sizeof(*tx),1);
len += iguana_rwtx(0,rawmem,&data[len],tx,recvlen-len,&tx->txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0);
len += iguana_rwtx(coin->chain->zcash,0,rawmem,&data[len],tx,recvlen-len,&tx->txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0);
len += iguana_rwbignum(0,&data[len],sizeof(auxhash2),auxhash2.bytes);
len += iguana_rwmerklebranch(0,&data[len],&coinbase_branch);
len += iguana_rwmerklebranch(0,&data[len],&blockchain_branch);
len += iguana_rwblock80(0,&data[len],&parentblock);
len += iguana_rwmerklebranch(0,&data[len],coinbase_branch);
len += iguana_rwmerklebranch(0,&data[len],blockchain_branch);
len += iguana_rwblockhdr(0,coin->chain->zcash,&data[len],&parentblock);
}
len += iguana_rwvarint32(0,&data[len],&tmp);
char str[65],str2[65];
if ( 0 && coin->chain->auxpow != 0 )
printf("%d %d of %d: %s %s v.%08x numtx.%d cmp.%d\n",len,i,n,bits256_str(str,hash2),bits256_str(str2,msg.H.prev_block),msg.H.version,tmp,bits256_cmp(prevhash2,msg.H.prev_block));
} else len += iguana_rwblock(coin->chain->symbol,coin->chain->hashalgo,0,&hash2,&data[len],&msg);
iguana_blockconv(&blocks[i],&msg,hash2,-1);
} else len += iguana_rwblock(coin->chain->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,0,&hash2,&data[len],&msg,recvlen);
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,(struct iguana_block *)&zblocks[i],&msg,hash2,-1);
prevhash2 = hash2;
}
if ( 0 && coin->chain->auxpow != 0 )
{
len += iguana_rwvarint32(0,&data[len],&n);
for (i=0; i<n; i++)
len += iguana_eatauxpow(0,coin->symbol,&data[len]);
}
iguana_gotheadersM(coin,addr,blocks,n);
free(coinbase_branch);
free(blockchain_branch);
iguana_gotheadersM(coin,addr,zblocks,n);
//myfree(blocks,sizeof(*blocks) * n);
if ( len == recvlen && addr != 0 )
addr->msgcounts.headers++;
@ -931,7 +1045,7 @@ int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struc
struct iguana_msgtx *tx;
iguana_memreset(rawmem);
tx = iguana_memalloc(rawmem,sizeof(*tx),1);//mycalloc('u',1,sizeof(*tx));
len = iguana_rwtx(0,rawmem,data,tx,recvlen,&tx->txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0);
len = iguana_rwtx(coin->chain->zcash,0,rawmem,data,tx,recvlen,&tx->txid,coin->chain->txhastimestamp,strcmp(coin->symbol,"VPN")==0);
if ( addr != 0 )
{
iguana_gotunconfirmedM(coin,addr,tx,data,recvlen);

2
iguana/iguana_peers.c
View File

@ -1111,7 +1111,7 @@ void iguana_dedicatedloop(struct supernet_info *myinfo,struct iguana_info *coin,
if ( req->datalen != 0 )
{
//char str[65]; printf("CACHE.%p parse[%d] %s %s\n",req,req->recvlen,req->H.command,bits256_str(str,req->block.RO.hash2));
iguana_parsebuf(coin,addr,&req->H,req->serialized,req->recvlen);
iguana_parsebuf(coin,addr,&req->H,req->serializeddata,req->recvlen);
} else printf("CACHE error no datalen\n");
coin->cachefreed++;
myfree(req,req->allocsize);

169
iguana/iguana_ramchain.c
View File

@ -785,10 +785,10 @@ int32_t iguana_ramchain_prefetch(struct iguana_info *coin,struct iguana_ramchain
return(nonz);
}
int64_t _iguana_rdata_action(char *fname,FILE *fp,bits256 lhashes[IGUANA_NUMLHASHES],void *destptr,uint64_t fpos,uint32_t expanded,uint32_t numtxids,uint32_t numunspents,uint32_t numspends,uint32_t numpkinds,uint32_t numexternaltxids,uint32_t scriptspace,uint32_t txsparsebits,uint64_t numtxsparse,uint32_t pksparsebits,uint64_t numpksparse,uint64_t srcsize,RAMCHAIN_FUNC,int32_t numblocks)
int64_t _iguana_rdata_action(char *fname,FILE *fp,bits256 lhashes[IGUANA_NUMLHASHES],void *destptr,uint64_t fpos,uint32_t expanded,uint32_t numtxids,uint32_t numunspents,uint32_t numspends,uint32_t numpkinds,uint32_t numexternaltxids,uint32_t scriptspace,uint32_t txsparsebits,uint64_t numtxsparse,uint32_t pksparsebits,uint64_t numpksparse,uint64_t srcsize,RAMCHAIN_FUNC,int32_t numblocks,uint8_t zcash)
{
#define RAMCHAIN_LARG(ind) ((lhashes == 0) ? 0 : lhashes[ind].bytes)
FILE *fparg = 0; int32_t iter; uint64_t txbits,pkbits,offset = 0; struct iguana_ramchaindata *rdata = destptr;
FILE *fparg = 0; int32_t bROsize,iter; uint64_t txbits,pkbits,offset = 0; struct iguana_ramchaindata *rdata = destptr;
if ( expanded != 0 )
{
if( txsparsebits == 0 || numtxsparse == 0 )
@ -823,16 +823,9 @@ int64_t _iguana_rdata_action(char *fname,FILE *fp,bits256 lhashes[IGUANA_NUMLHAS
continue;
}
offset = sizeof(struct iguana_ramchaindata);
char str[65];
//if ( fparg != 0 && numblocks > 1 )
// printf("%p B[0] %s -> ",B,bits256_str(str,B[0].hash2));
B = iguana_ramchain_offset(fname,rdata,RAMCHAIN_LARG(IGUANA_LHASH_BLOCKS),fparg,fpos,B,&offset,(sizeof(struct iguana_blockRO) * numblocks),srcsize);
if ( 0 && fparg != 0 && numblocks > 1 )
{
printf("%s %p\n",bits256_str(str,B[0].hash2),B);
//if ( bits256_nonz(B[0].hash2) == 0 )
// getchar();
}
bROsize = (int32_t)(sizeof(struct iguana_blockRO) + zcash*sizeof(struct iguana_msgblockhdr_zcash));
//printf("bROsize.%d\n",bROsize);
B = iguana_ramchain_offset(fname,rdata,RAMCHAIN_LARG(IGUANA_LHASH_BLOCKS),fparg,fpos,B,&offset,(bROsize * numblocks),srcsize);
T = iguana_ramchain_offset(fname,rdata,RAMCHAIN_LARG(IGUANA_LHASH_TXIDS),fparg,fpos,T,&offset,(sizeof(struct iguana_txid) * numtxids),srcsize);
if ( expanded != 0 )
{
@ -900,23 +893,23 @@ int64_t _iguana_rdata_action(char *fname,FILE *fp,bits256 lhashes[IGUANA_NUMLHAS
#undef SPARSECOUNT
}
int64_t iguana_ramchain_action(char *fname,RAMCHAIN_FUNC,FILE *fp,bits256 lhashes[IGUANA_NUMLHASHES],struct iguana_ramchaindata *destdata,uint64_t fpos,struct iguana_ramchaindata *srcdata,int32_t numblocks,int32_t scriptspace)
int64_t iguana_ramchain_action(char *fname,RAMCHAIN_FUNC,FILE *fp,bits256 lhashes[IGUANA_NUMLHASHES],struct iguana_ramchaindata *destdata,uint64_t fpos,struct iguana_ramchaindata *srcdata,int32_t numblocks,int32_t scriptspace,uint8_t zcash)
{
if ( 0 && ramchain->expanded == 0 )
printf("action.%p (%p %p %p) %ld allocated.%ld [%d:%d %d:%d]\n",srcdata,fp,lhashes,destdata,(long)fpos,(long)srcdata->allocsize,srcdata->txsparsebits,srcdata->numtxsparse,srcdata->pksparsebits,srcdata->numpksparse);
return(_iguana_rdata_action(fname,fp,lhashes,destdata,fpos,ramchain->expanded,srcdata->numtxids,srcdata->numunspents,srcdata->numspends,srcdata->numpkinds,srcdata->numexternaltxids,scriptspace,srcdata->txsparsebits,srcdata->numtxsparse,srcdata->pksparsebits,srcdata->numpksparse,srcdata->allocsize,RAMCHAIN_ARG,numblocks));
return(_iguana_rdata_action(fname,fp,lhashes,destdata,fpos,ramchain->expanded,srcdata->numtxids,srcdata->numunspents,srcdata->numspends,srcdata->numpkinds,srcdata->numexternaltxids,scriptspace,srcdata->txsparsebits,srcdata->numtxsparse,srcdata->pksparsebits,srcdata->numpksparse,srcdata->allocsize,RAMCHAIN_ARG,numblocks,zcash));
}
int64_t iguana_ramchain_size(char *fname,RAMCHAIN_FUNC,int32_t numblocks,int32_t scriptspace)
int64_t iguana_ramchain_size(char *fname,RAMCHAIN_FUNC,int32_t numblocks,int32_t scriptspace,uint8_t zcash)
{
int64_t allocsize;
allocsize = iguana_ramchain_action(fname,RAMCHAIN_ARG,0,0,0,0,ramchain->H.data,numblocks,scriptspace);
allocsize = iguana_ramchain_action(fname,RAMCHAIN_ARG,0,0,0,0,ramchain->H.data,numblocks,scriptspace,zcash);
if ( 0 && ramchain->expanded != 0 )
printf("%p iguana_ramchain_size.expanded.%d %u: Koffset.%u scriptoffset.%u stacksize.%u stackspace.%u [%u]\n",ramchain,ramchain->expanded,(int32_t)allocsize,(int32_t)ramchain->H.data->Koffset,(int32_t)ramchain->H.scriptoffset,(int32_t)ramchain->H.stacksize,(int32_t)ramchain->H.data->stackspace,scriptspace);
return(allocsize);
}
long iguana_ramchain_setsize(char *fname,struct iguana_ramchain *ramchain,struct iguana_ramchaindata *srcdata,int32_t numblocks)
long iguana_ramchain_setsize(char *fname,struct iguana_ramchain *ramchain,struct iguana_ramchaindata *srcdata,int32_t numblocks,uint8_t zcash)
{
RAMCHAIN_DECLARE; RAMCHAIN_ZEROES; struct iguana_ramchaindata *rdata = ramchain->H.data;
//B = 0, Ux = 0, Sx = 0, P = 0, A = 0, X = 0, Kspace = TXbits = PKbits = 0, U = 0, S = 0, T = 0; //U2 = 0, P2 = 0,
@ -927,44 +920,44 @@ long iguana_ramchain_setsize(char *fname,struct iguana_ramchain *ramchain,struct
rdata->numexternaltxids = ramchain->externalind;
rdata->scriptspace = ramchain->H.scriptoffset;
rdata->stackspace = ramchain->H.stacksize;
rdata->allocsize = iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,rdata->scriptspace);
rdata->allocsize = iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,rdata->scriptspace,zcash);
if ( 0 && rdata->scriptspace != 0 )
printf("iguana_ramchain_setsize: Koffset.%d scriptspace.%d stackspace.%d (scriptoffset.%d stacksize.%d) allocsize.%d\n",(int32_t)rdata->Koffset,(int32_t)rdata->scriptspace,(int32_t)rdata->stackspace,(int32_t)ramchain->H.scriptoffset,(int32_t)ramchain->H.stacksize,(int32_t)rdata->allocsize);
ramchain->datasize = rdata->allocsize;
return((long)rdata->allocsize);
}
int64_t iguana_ramchain_compact(char *fname,RAMCHAIN_FUNC,struct iguana_ramchaindata *destdata,struct iguana_ramchaindata *srcdata,int32_t numblocks)
int64_t iguana_ramchain_compact(char *fname,RAMCHAIN_FUNC,struct iguana_ramchaindata *destdata,struct iguana_ramchaindata *srcdata,int32_t numblocks,uint8_t zcash)
{
//iguana_ramchain_setsize(ramchain,srcdata);
return(iguana_ramchain_action(fname,RAMCHAIN_ARG,0,0,destdata,0,srcdata,numblocks,ramchain->H.scriptoffset));
return(iguana_ramchain_action(fname,RAMCHAIN_ARG,0,0,destdata,0,srcdata,numblocks,ramchain->H.scriptoffset,zcash));
}
bits256 iguana_ramchain_lhashes(char *fname,RAMCHAIN_FUNC,struct iguana_ramchaindata *destdata,struct iguana_ramchaindata *srcdata,int32_t numblocks,int32_t scriptspace)
bits256 iguana_ramchain_lhashes(char *fname,RAMCHAIN_FUNC,struct iguana_ramchaindata *destdata,struct iguana_ramchaindata *srcdata,int32_t numblocks,int32_t scriptspace,uint8_t zcash)
{
iguana_ramchain_action(fname,RAMCHAIN_ARG,0,destdata->lhashes,0,0,srcdata,numblocks,scriptspace);
iguana_ramchain_action(fname,RAMCHAIN_ARG,0,destdata->lhashes,0,0,srcdata,numblocks,scriptspace,zcash);
memset(&destdata->sha256,0,sizeof(destdata->sha256));
vcalc_sha256(0,destdata->sha256.bytes,(void *)destdata,sizeof(*destdata));
return(destdata->sha256);
}
int64_t iguana_ramchain_saveaction(char *fname,RAMCHAIN_FUNC,FILE *fp,struct iguana_ramchaindata *rdata,int32_t numblocks,int32_t scriptspace)
int64_t iguana_ramchain_saveaction(char *fname,RAMCHAIN_FUNC,FILE *fp,struct iguana_ramchaindata *rdata,int32_t numblocks,int32_t scriptspace,uint8_t zcash)
{
long before,after;
before = ftell(fp);
iguana_ramchain_action(fname,RAMCHAIN_ARG,fp,0,rdata,0,rdata,numblocks,scriptspace);
iguana_ramchain_action(fname,RAMCHAIN_ARG,fp,0,rdata,0,rdata,numblocks,scriptspace,zcash);
after = ftell(fp);
if ( 0 && ramchain->expanded == 0 )
{
int32_t i; for (i=0; i<scriptspace&&i<25; i++)
printf("%02x",Kspace[i]);
printf(" SAVEACTION: K.%d:%ld rdata.%d DEST T.%d U.%d S.%d P.%d X.%d -> size.%ld %ld vs %ld %u\n",(int32_t)rdata->Koffset,(long)Kspace-(long)rdata,(int32_t)sizeof(*rdata),rdata->numtxids,rdata->numunspents,rdata->numspends,rdata->numpkinds,rdata->numexternaltxids,(long)rdata->allocsize,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace),after-before+sizeof(*rdata),scriptspace);
printf(" SAVEACTION: K.%d:%ld rdata.%d DEST T.%d U.%d S.%d P.%d X.%d -> size.%ld %ld vs %ld %u\n",(int32_t)rdata->Koffset,(long)Kspace-(long)rdata,(int32_t)sizeof(*rdata),rdata->numtxids,rdata->numunspents,rdata->numspends,rdata->numpkinds,rdata->numexternaltxids,(long)rdata->allocsize,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace,zcash),after-before+sizeof(*rdata),scriptspace);
}
//printf("before.%ld after.%ld allocsize.%ld [%ld] %ld expanded.%d\n",before,after,(long)srcdata->allocsize,(long)ramchain->H.data->allocsize,(long)iguana_ramchain_size(ramchain),ramchain->expanded);
return(after - before);
}
int64_t iguana_ramchain_init(char *fname,struct iguana_ramchain *ramchain,struct OS_memspace *mem,struct OS_memspace *hashmem,int32_t firsti,int32_t numtxids,int32_t numunspents,int32_t numspends,int32_t numpkinds,int32_t numexternaltxids,int32_t scriptspace,int32_t expanded,int32_t numblocks)
int64_t iguana_ramchain_init(char *fname,struct iguana_ramchain *ramchain,struct OS_memspace *mem,struct OS_memspace *hashmem,int32_t firsti,int32_t numtxids,int32_t numunspents,int32_t numspends,int32_t numpkinds,int32_t numexternaltxids,int32_t scriptspace,int32_t expanded,int32_t numblocks,uint8_t zcash)
{
RAMCHAIN_DECLARE; RAMCHAIN_ZEROES; int64_t offset = 0; struct iguana_ramchaindata *rdata;
//B = 0, Ux = 0, Sx = 0, P = 0, A = 0, X = 0, Kspace = TXbits = PKbits = 0, U = 0, S = 0, T = 0;
@ -985,13 +978,13 @@ int64_t iguana_ramchain_init(char *fname,struct iguana_ramchain *ramchain,struct
numexternaltxids = numspends;
if ( numpkinds == 0 )
numpkinds = numunspents;
_iguana_rdata_action(fname,0,0,rdata,0,expanded,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks);
_iguana_rdata_action(fname,0,0,rdata,0,expanded,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks,zcash);
offset += rdata->allocsize;
if ( 0 && expanded != 0 )
printf("init T.%d U.%d S.%d P.%d X.%d -> %ld\n",numtxids,numunspents,numspends,numpkinds,numexternaltxids,(long)offset);
if ( rdata->allocsize != iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace) )
if ( rdata->allocsize != iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace,zcash) )
{
printf("offset.%ld scriptspace.%d allocsize.%ld vs memsize.%ld\n",(long)offset,scriptspace,(long)rdata->allocsize,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace));
printf("offset.%ld scriptspace.%d allocsize.%ld vs memsize.%ld\n",(long)offset,scriptspace,(long)rdata->allocsize,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace,zcash));
exit(-1);
}
if ( offset <= mem->totalsize )
@ -999,7 +992,7 @@ int64_t iguana_ramchain_init(char *fname,struct iguana_ramchain *ramchain,struct
else
{
printf("offset.%ld vs memsize.%ld\n",(long)offset,(long)mem->totalsize);
printf("NEED %ld realloc for totalsize %ld\n",(long)offset,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace));
printf("NEED %ld realloc for totalsize %ld\n",(long)offset,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,numblocks,scriptspace,zcash));
getchar();
//exit(-1);
iguana_mempurge(mem);
@ -1013,13 +1006,13 @@ int64_t iguana_ramchain_init(char *fname,struct iguana_ramchain *ramchain,struct
return(offset);
}
int32_t iguana_ramchain_alloc(char *fname,struct iguana_info *coin,struct iguana_ramchain *ramchain,struct OS_memspace *mem,struct OS_memspace *hashmem,uint32_t numtxids,uint32_t numunspents,uint32_t numspends,uint32_t numpkinds,uint32_t numexternaltxids,uint32_t scriptspace,int32_t height,int32_t numblocks)
int32_t iguana_ramchain_alloc(char *fname,struct iguana_info *coin,struct iguana_ramchain *ramchain,struct OS_memspace *mem,struct OS_memspace *hashmem,uint32_t numtxids,uint32_t numunspents,uint32_t numspends,uint32_t numpkinds,uint32_t numexternaltxids,uint32_t scriptspace,int32_t height,int32_t numblocks,uint8_t zcash)
{
RAMCHAIN_DECLARE; RAMCHAIN_ZEROES; int64_t hashsize,allocsize,x;
//B = 0, Ux = 0, Sx = 0, P = 0, A = 0, X = 0, Kspace = TXbits = PKbits = 0, U = 0, S = 0, T = 0;
memset(ramchain,0,sizeof(*ramchain));
ramchain->height = height;
allocsize = _iguana_rdata_action(fname,0,0,0,0,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks);
allocsize = _iguana_rdata_action(fname,0,0,0,0,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks,zcash);
if ( 0 && ramchain->expanded != 0 )
printf("T.%d U.%d S.%d P.%d X.%d -> %ld\n",numtxids,numunspents,numspends,numpkinds,numexternaltxids,(long)allocsize);
memset(mem,0,sizeof(*mem));
@ -1034,12 +1027,12 @@ int32_t iguana_ramchain_alloc(char *fname,struct iguana_info *coin,struct iguana
iguana_meminit(mem,"ramchain",0,allocsize + 65536,0);
mem->alignflag = sizeof(uint32_t);
hashmem->alignflag = sizeof(uint32_t);
if ( iguana_ramchain_init(fname,ramchain,mem,hashmem,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,1,numblocks) == 0 )
if ( iguana_ramchain_init(fname,ramchain,mem,hashmem,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,1,numblocks,zcash) == 0 )
return(-1);
return(0);
}
long iguana_ramchain_save(struct iguana_info *coin,RAMCHAIN_FUNC,uint32_t ipbits,bits256 hash2,bits256 prevhash2,int32_t bundlei,struct iguana_bundle *bp)
long iguana_ramchain_save(struct iguana_info *coin,RAMCHAIN_FUNC,uint32_t ipbits,bits256 hash2,bits256 prevhash2,int32_t bundlei,struct iguana_bundle *bp,uint8_t zcash)
{
struct iguana_ramchaindata *rdata,tmp; char fname[1024]; long fpos = -1; int32_t hdrsi,checki; FILE *fp;
if ( (rdata= ramchain->H.data) == 0 )
@ -1064,16 +1057,16 @@ long iguana_ramchain_save(struct iguana_info *coin,RAMCHAIN_FUNC,uint32_t ipbits
{
fpos = ftell(fp);
if ( ramchain->expanded != 0 )
iguana_ramchain_lhashes(fname,RAMCHAIN_ARG,rdata,rdata,bp!=0?bp->n:1,ramchain->H.scriptoffset);
iguana_ramchain_lhashes(fname,RAMCHAIN_ARG,rdata,rdata,bp!=0?bp->n:1,ramchain->H.scriptoffset,zcash);
tmp = *rdata;
iguana_ramchain_compact(fname,RAMCHAIN_ARG,&tmp,rdata,bp!=0?bp->n:1);
iguana_ramchain_compact(fname,RAMCHAIN_ARG,&tmp,rdata,bp!=0?bp->n:1,zcash);
if ( 0 && ramchain->expanded != 0 )
printf("compact.%s: Koffset.%d scriptoffset.%d stacksize.%d allocsize.%d\n",fname,(int32_t)ramchain->H.data->Koffset,ramchain->H.scriptoffset,ramchain->H.stacksize,(int32_t)ramchain->H.data->allocsize);
if ( fwrite(&tmp,1,sizeof(tmp),fp) != sizeof(tmp) )
{
printf("ramchain_save error writing header.%s\n",fname);
fpos = -1;
} else iguana_ramchain_saveaction(fname,RAMCHAIN_ARG,fp,rdata,bp!=0?bp->n:1,ramchain->H.scriptoffset);
} else iguana_ramchain_saveaction(fname,RAMCHAIN_ARG,fp,rdata,bp!=0?bp->n:1,ramchain->H.scriptoffset,zcash);
*rdata = tmp;
fclose(fp);
}
@ -1373,10 +1366,10 @@ int32_t iguana_Xspendmap(struct iguana_info *coin,struct iguana_ramchain *ramcha
return(ramchain->numXspends);
}
struct iguana_ramchain *_iguana_ramchain_map(struct iguana_info *coin,char *fname,struct iguana_bundle *bp,int32_t numblocks,struct iguana_ramchain *ramchain,struct OS_memspace *hashmem,uint32_t ipbits,bits256 hash2,bits256 prevhash2,int32_t bundlei,long fpos,int32_t allocextras,int32_t expanded)
struct iguana_ramchain *_iguana_ramchain_map(struct iguana_info *coin,char *fname,struct iguana_bundle *bp,int32_t numblocks,struct iguana_ramchain *ramchain,struct OS_memspace *hashmem,uint32_t ipbits,bits256 hash2,bits256 prevhash2,int32_t bundlei,long fpos,int32_t allocextras,int32_t expanded,uint8_t zcash)
{
RAMCHAIN_DECLARE; int32_t valid,iter,i,checki,hdrsi;
char str[65],str2[65],dirstr[64]; long filesize; void *ptr; struct iguana_block *block;
RAMCHAIN_DECLARE; int32_t valid,iter,i,checki,hdrsi; long filesize; void *ptr;
char str[65],str2[65],dirstr[64]; struct iguana_block *block; struct iguana_blockRO *bRO;
/*if ( ramchain->expanded != 0 && (ramchain->sigsfileptr == 0 || ramchain->sigsfilesize == 0) )
{
sprintf(sigsfname,"sigs/%s/%s",coin->symbol,bits256_str(str,hash2));
@ -1452,9 +1445,9 @@ struct iguana_ramchain *_iguana_ramchain_map(struct iguana_info *coin,char *fnam
}
}
_iguana_ramchain_setptrs(RAMCHAIN_PTRS,ramchain->H.data);
if ( iguana_ramchain_size(fname,RAMCHAIN_ARG,ramchain->numblocks,ramchain->H.data->scriptspace) != ramchain->H.data->allocsize || fpos+ramchain->H.data->allocsize > filesize )
if ( iguana_ramchain_size(fname,RAMCHAIN_ARG,ramchain->numblocks,ramchain->H.data->scriptspace,zcash) != ramchain->H.data->allocsize || fpos+ramchain->H.data->allocsize > filesize )
{
printf("iguana_ramchain_map.(%s) size mismatch %ld vs %ld vs filesize.%ld numblocks.%d expanded.%d fpos.%d sum %ld\n",fname,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,ramchain->numblocks,ramchain->H.data->scriptspace),(long)ramchain->H.data->allocsize,(long)filesize,ramchain->numblocks,expanded,(int32_t)fpos,(long)(fpos+ramchain->H.data->allocsize));
printf("iguana_ramchain_map.(%s) size mismatch %ld vs %ld vs filesize.%ld numblocks.%d expanded.%d fpos.%d sum %ld\n",fname,(long)iguana_ramchain_size(fname,RAMCHAIN_ARG,ramchain->numblocks,ramchain->H.data->scriptspace,zcash),(long)ramchain->H.data->allocsize,(long)filesize,ramchain->numblocks,expanded,(int32_t)fpos,(long)(fpos+ramchain->H.data->allocsize));
//exit(-1);
munmap(ramchain->fileptr,ramchain->filesize);
OS_removefile(fname,0);
@ -1480,16 +1473,18 @@ struct iguana_ramchain *_iguana_ramchain_map(struct iguana_info *coin,char *fnam
}
if ( B != 0 && bp != 0 )
{
int32_t bROsize = (int32_t)(sizeof(struct iguana_blockRO) + coin->chain->zcash*sizeof(struct iguana_msgblockhdr_zcash));
for (i=0; i<bp->n; i++)
{
if ( bp->blocks[i] == 0 && (bp->blocks[i]= iguana_blockhashset("mapchain",coin,-1,B[i].hash2,1)) == 0 )
bRO = (void *)((long)B + i*bROsize);
if ( bp->blocks[i] == 0 && (bp->blocks[i]= iguana_blockhashset("mapchain",coin,-1,bRO->hash2,1)) == 0 )
{
printf("Error getting blockptr\n");
return(0);
}
bp->blocks[i]->RO = B[i];//coin->blocks.RO[bp->bundleheight + i];
coin->blocks.RO[bp->bundleheight+i] = B[i];
bp->hashes[i] = B[i].hash2;
memcpy(&bp->blocks[i]->RO,bRO,bROsize);//coin->blocks.RO[bp->bundleheight + i];
//coin->blocks.RO[bp->bundleheight+i] = B[i];
bp->hashes[i] = bRO->hash2;
}
}
//printf("iguana_ramchain_map.(%s) size %ld vs %ld vs filesize.%ld numblocks.%d expanded.%d fpos.%d sum %ld\n",fname,(long)iguana_ramchain_size(RAMCHAIN_ARG,ramchain->numblocks,ramchain->H.data->scriptspace),(long)ramchain->H.data->allocsize,(long)filesize,ramchain->numblocks,expanded,(int32_t)fpos,(long)(fpos+ramchain->H.data->allocsize));
@ -1508,7 +1503,7 @@ struct iguana_ramchain *iguana_ramchain_map(struct iguana_info *coin,char *fname
//portable_mutex_lock(&mutex);
#endif
ramchain->height = bp->bundleheight;
retptr = _iguana_ramchain_map(coin,fname,bp,numblocks,ramchain,hashmem,ipbits,hash2,prevhash2,bundlei,fpos,allocextras,expanded);
retptr = _iguana_ramchain_map(coin,fname,bp,numblocks,ramchain,hashmem,ipbits,hash2,prevhash2,bundlei,fpos,allocextras,expanded,coin->chain->zcash);
#ifdef __PNACL__
//portable_mutex_unlock(&mutex);
#endif
@ -1823,11 +1818,11 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
#endif
if ( (addr_ipbits= (uint32_t)addr->ipbits) == 0 )
addr_ipbits = 1;
if ( bits256_nonz(origtxdata->block.RO.merkle_root) == 0 )
if ( bits256_nonz(origtxdata->zblock.RO.merkle_root) == 0 )
{
memset(&origtxdata->block.RO.prev_block,0,sizeof(bits256));
origtxdata->block.RO.recvlen = 0;
origtxdata->block.issued = 0;
memset(&origtxdata->zblock.RO.prev_block,0,sizeof(bits256));
origtxdata->zblock.RO.recvlen = 0;
origtxdata->zblock.issued = 0;
return(-1);
}
for (i=0; i<sizeof(addr->dirty)/sizeof(*addr->dirty); i++)
@ -1840,40 +1835,40 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
for (i=0; i<txn_count; i++)
tree[i] = txarray[i].txid;
merkle_root = iguana_merkle(tree,txn_count);
if ( bits256_cmp(merkle_root,origtxdata->block.RO.merkle_root) != 0 )
if ( bits256_cmp(merkle_root,origtxdata->zblock.RO.merkle_root) != 0 )
{
char str[65],str2[65];
printf(">>>>>>>>>> merkle mismatch.[%d] calc.(%s) vs (%s)\n",txn_count,bits256_str(str,merkle_root),bits256_str(str2,origtxdata->block.RO.merkle_root));
origtxdata->block.RO.recvlen = 0;
origtxdata->block.issued = 0;
printf(">>>>>>>>>> merkle mismatch.[%d] calc.(%s) vs (%s)\n",txn_count,bits256_str(str,merkle_root),bits256_str(str2,origtxdata->zblock.RO.merkle_root));
origtxdata->zblock.RO.recvlen = 0;
origtxdata->zblock.issued = 0;
return(-1);
} //else printf("matched merkle.%d\n",txn_count);
} else printf("not enough memory for merkle verify %d vs %lu\n",(int32_t)(sizeof(bits256)*(txn_count+1)),(long)addr->TXDATA.totalsize);
bp = 0, bundlei = -2;
if ( iguana_bundlefind(coin,&bp,&bundlei,origtxdata->block.RO.hash2) == 0 )
if ( iguana_bundlefind(coin,&bp,&bundlei,origtxdata->zblock.RO.hash2) == 0 )
{
bp = 0, bundlei = -2;
if ( iguana_bundlefind(coin,&bp,&bundlei,origtxdata->block.RO.prev_block) == 0 )
if ( iguana_bundlefind(coin,&bp,&bundlei,origtxdata->zblock.RO.prev_block) == 0 )
{
origtxdata->block.RO.recvlen = 0;
origtxdata->block.issued = 0;
origtxdata->zblock.RO.recvlen = 0;
origtxdata->zblock.issued = 0;
return(-1);
}
else if ( bundlei < coin->chain->bundlesize-1 )
bundlei++;
else
{
origtxdata->block.issued = 0;
origtxdata->block.RO.recvlen = 0;
char str[65]; printf("ramchain data: error finding block %s\n",bits256_str(str,origtxdata->block.RO.hash2));
origtxdata->zblock.issued = 0;
origtxdata->zblock.RO.recvlen = 0;
char str[65]; printf("ramchain data: error finding block %s\n",bits256_str(str,origtxdata->zblock.RO.hash2));
return(-1);
}
}
if ( (block= bp->blocks[bundlei]) == 0 || bits256_cmp(block->RO.hash2,origtxdata->block.RO.hash2) != 0 || bits256_cmp(bp->hashes[bundlei],origtxdata->block.RO.hash2) != 0 )
if ( (block= bp->blocks[bundlei]) == 0 || bits256_cmp(block->RO.hash2,origtxdata->zblock.RO.hash2) != 0 || bits256_cmp(bp->hashes[bundlei],origtxdata->zblock.RO.hash2) != 0 )
{
char str[65];
if ( 0 && block != 0 )
printf("%d:%d has no block ptr.%p %s or wrong hash\n",bp->hdrsi,bundlei,block,bits256_str(str,origtxdata->block.RO.hash2));
printf("%d:%d has no block ptr.%p %s or wrong hash\n",bp->hdrsi,bundlei,block,bits256_str(str,origtxdata->zblock.RO.hash2));
return(-1);
}
block->txvalid = 1;
@ -1891,7 +1886,7 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
}
sigsize = pubkeysize = 0;
scriptspace = 1;//iguana_scriptspaceraw(coin,&scriptsize,&sigsize,&pubkeysize,txarray,txn_count);
if ( iguana_ramchain_init(fname,ramchain,&addr->TXDATA,&addr->HASHMEM,1,txn_count,origtxdata->numunspents,origtxdata->numspends,0,0,(scriptspace+sigsize+pubkeysize)*1.1,0,1) == 0 )
if ( iguana_ramchain_init(fname,ramchain,&addr->TXDATA,&addr->HASHMEM,1,txn_count,origtxdata->numunspents,origtxdata->numspends,0,0,(scriptspace+sigsize+pubkeysize)*1.1,0,1,coin->chain->zcash) == 0 )
{
if ( block->fpipbits == 0 )
block->issued = block->RO.recvlen = 0, block->fpos = -1;
@ -1937,7 +1932,7 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
ramchain->H.data->prevhash2 = block->RO.prev_block;
ramchain->H.data->scriptspace = scriptspace = ramchain->H.scriptoffset;
ramchain->H.data->stackspace = stackspace = ramchain->H.stacksize;
iguana_ramchain_setsize(fname,ramchain,ramchain->H.data,1);
iguana_ramchain_setsize(fname,ramchain,ramchain->H.data,1,coin->chain->zcash);
flag = 0;
if ( ramchain->H.txidind != ramchain->H.data->numtxids || ramchain->H.unspentind != ramchain->H.data->numunspents || ramchain->H.spendind != ramchain->H.data->numspends )
{
@ -1950,13 +1945,14 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
{
if ( (err= iguana_ramchain_verify(coin,ramchain)) == 0 )
{
B[0] = block->RO;
int32_t bROsize = (int32_t)(sizeof(struct iguana_blockRO) + coin->chain->zcash*sizeof(struct iguana_msgblockhdr_zcash));
memcpy(B,&block->RO,bROsize);
ramchain->H.data->scriptspace = ramchain->H.scriptoffset = scriptspace;
ramchain->H.data->stackspace = ramchain->H.stacksize = stackspace;
if ( (fpos= (int32_t)iguana_ramchain_save(coin,RAMCHAIN_ARG,addr_ipbits,block->RO.hash2,block->RO.prev_block,bundlei,0)) >= 0 )
if ( (fpos= (int32_t)iguana_ramchain_save(coin,RAMCHAIN_ARG,addr_ipbits,block->RO.hash2,block->RO.prev_block,bundlei,0,coin->chain->zcash)) >= 0 )
{
//char str[65]; printf("saved.%s [%d:%d]\n",bits256_str(str,block->RO.hash2),bp->hdrsi,bundlei);
origtxdata->datalen = (int32_t)ramchain->H.data->allocsize;
//char str[65]; printf("saved.%s [%d:%d] fpos.%d datalen.%d\n",bits256_str(str,block->RO.hash2),bp->hdrsi,bundlei,fpos,origtxdata->datalen);
ramchain->H.ROflag = 0;
flag = 1;
if ( addr->dirty[0] != 0 && addr->voutsfp != 0 )
@ -2016,7 +2012,7 @@ long iguana_ramchain_data(struct iguana_info *coin,struct iguana_peer *addr,stru
}
if ( fpos >= 0 )
block->fpos = fpos, block->fpipbits = addr_ipbits;
}
} else printf("save error\n");
}
else
{
@ -2225,7 +2221,7 @@ int32_t iguana_ramchain_expandedsave(struct iguana_info *coin,RAMCHAIN_FUNC,stru
ramchain->H.data->prevhash2 = block->RO.prev_block;
ramchain->H.data->scriptspace = scriptoffset;
ramchain->H.stacksize = ramchain->H.data->stackspace = stacksize;
iguana_ramchain_setsize(fname,ramchain,ramchain->H.data,bp->n);
iguana_ramchain_setsize(fname,ramchain,ramchain->H.data,bp->n,coin->chain->zcash);
//printf("Apresave T.%d U.%d S.%d P.%d X.%d -> size.%ld firsti.%d scriptoffset.%d stacksize.%d\n",ramchain->H.data->numtxids,ramchain->H.data->numunspents,ramchain->H.data->numspends,ramchain->H.data->numpkinds,ramchain->H.data->numexternaltxids,(long)ramchain->H.data->allocsize,firsti,ramchain->H.scriptoffset,ramchain->H.stacksize);
*newchain = *ramchain;
//memcpy(ramchain->roU2,ramchain->U2,sizeof(*ramchain->U2) * ramchain->H.data->numunspents);
@ -2249,7 +2245,7 @@ int32_t iguana_ramchain_expandedsave(struct iguana_info *coin,RAMCHAIN_FUNC,stru
ramchain->H.scriptoffset = scriptoffset;
ramchain->H.data->scriptspace = scriptoffset;
ramchain->H.stacksize = ramchain->H.data->stackspace = stacksize;
if ( iguana_ramchain_save(coin,RAMCHAIN_ARG,0,firsthash2,zero,0,bp) < 0 )
if ( iguana_ramchain_save(coin,RAMCHAIN_ARG,0,firsthash2,zero,0,bp,coin->chain->zcash) < 0 )
{
printf("ERROR saving ramchain hdrsi.%d, deleting and will regenerate\n",hdrsi);
iguana_mempurge(hashmem);
@ -2297,9 +2293,10 @@ int32_t iguana_ramchain_expandedsave(struct iguana_info *coin,RAMCHAIN_FUNC,stru
struct iguana_ramchain *iguana_bundleload(struct iguana_info *coin,struct iguana_ramchain *ramchain,struct iguana_bundle *bp,int32_t extraflag)
{
static const bits256 zero;
struct iguana_blockRO *B; struct iguana_txid *T; int32_t i,firsti = 1; char fname[512];
struct iguana_blockRO *B; struct iguana_txid *T; int32_t i,bROsize,firsti = 1; char fname[512];
struct iguana_block *block,*prev,*prev2; struct iguana_ramchain *mapchain;
memset(ramchain,0,sizeof(*ramchain));
bROsize = (int32_t)(sizeof(struct iguana_blockRO) + coin->chain->zcash*sizeof(struct iguana_msgblockhdr_zcash));
if ( (mapchain= iguana_ramchain_map(coin,fname,bp,bp->n,ramchain,0,0,bp->hashes[0],zero,0,0,extraflag,1)) != 0 )
{
iguana_ramchain_link(mapchain,bp->hashes[0],bp->hdrsi,bp->bundleheight,0,bp->n,firsti,1);
@ -2323,12 +2320,12 @@ struct iguana_ramchain *iguana_bundleload(struct iguana_info *coin,struct iguana
block->hdrsi = bp->hdrsi;
block->bundlei = i;
block->fpipbits = (uint32_t)calc_ipbits("127.0.0.1");
block->RO = B[i];
memcpy(&block->RO,(void *)((long)B + i*bROsize),bROsize);
//printf("%x ",(int32_t)B[i].hash2.ulongs[3]);
iguana_hash2set(coin,"bundleload",bp,i,block->RO.hash2);
bp->blocks[i] = block;
//if ( bits256_nonz(bp->hashes[i]) == 0 )
// bp->hashes[i] = B[i].hash2;
// bp->hashes[i] = bRO->hash2;
if ( (prev= block->hh.prev) != 0 )
prev2 = prev->hh.prev;
if ( strcmp(coin->symbol,"BTCD") == 0 && bp->bundleheight > 20000 && prev != 0 && iguana_targetbits(coin,block,prev,prev2,1,coin->chain->targetspacing,coin->chain->targettimespan) != block->RO.bits )
@ -2390,7 +2387,7 @@ int64_t iguana_ramchainopen(char *fname,struct iguana_info *coin,struct iguana_r
#endif
if ( mem->ptr == 0 )
{
while ( (allocsize= _iguana_rdata_action(fname,0,0,0,0,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks)) > 2*1024LL*1024L*1024L )
while ( (allocsize= _iguana_rdata_action(fname,0,0,0,0,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,0,0,0,0,0,RAMCHAIN_ARG,numblocks,coin->chain->zcash)) > 2*1024LL*1024L*1024L )
{
numtxids *= .9;
numunspents *= .9;
@ -2405,7 +2402,7 @@ int64_t iguana_ramchainopen(char *fname,struct iguana_info *coin,struct iguana_r
hashsize = iguana_hashmemsize(numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace);
iguana_meminit(hashmem,coin->symbol,0,hashsize + 65536*3,0);
}
if ( iguana_ramchain_init(fname,ramchain,mem,hashmem,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,1,numblocks) > 0 )
if ( iguana_ramchain_init(fname,ramchain,mem,hashmem,1,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace,1,numblocks,coin->chain->zcash) > 0 )
{
iguana_ramchain_link(ramchain,hash2,bundleheight/coin->chain->bundlesize,bundleheight,0,0,1,0);
ramchain->expanded = 1;
@ -2432,9 +2429,9 @@ int32_t iguana_mapchaininit(char *fname,struct iguana_info *coin,struct iguana_r
return(-1);
}
_iguana_ramchain_setptrs(MAPCHAIN_PTRS,mapchain->H.data);
if ( block->fpos+mapchain->H.data->allocsize > filesize || iguana_ramchain_size(fname,MAPCHAIN_ARG,1,mapchain->H.data->scriptspace) != mapchain->H.data->allocsize )
if ( block->fpos+mapchain->H.data->allocsize > filesize || iguana_ramchain_size(fname,MAPCHAIN_ARG,1,mapchain->H.data->scriptspace,coin->chain->zcash) != mapchain->H.data->allocsize )
{
printf("iguana_mapchaininit.%d ipbits.%x size mismatch %ld vs %ld vs filesize.%ld fpos.%ld bundlei.%d expanded.%d soff.%d\n",bp->bundleheight,block->fpipbits,(long)iguana_ramchain_size(fname,MAPCHAIN_ARG,1,mapchain->H.data->scriptspace),(long)mapchain->H.data->allocsize,(long)filesize,(long)block->fpos,bundlei,mapchain->expanded,mapchain->H.data->scriptspace);
printf("iguana_mapchaininit.%d ipbits.%x size mismatch %ld vs %ld vs filesize.%ld fpos.%ld bundlei.%d expanded.%d soff.%d\n",bp->bundleheight,block->fpipbits,(long)iguana_ramchain_size(fname,MAPCHAIN_ARG,1,mapchain->H.data->scriptspace,coin->chain->zcash),(long)mapchain->H.data->allocsize,(long)filesize,(long)block->fpos,bundlei,mapchain->expanded,mapchain->H.data->scriptspace);
//getchar();
return(-1);
}
@ -2456,7 +2453,7 @@ int32_t iguana_bundlesaveHT(struct iguana_info *coin,struct OS_memspace *mem,str
RAMCHAIN_DESTDECLARE; RAMCHAIN_DECLARE; RAMCHAIN_ZEROES;
void **ptrs; long *filesizes; uint32_t *ipbits; char fname[1024];
struct iguana_ramchain *R,*mapchain,*dest,newchain; uint32_t fpipbits; bits256 prevhash2;
int32_t i,starti,endi,bp_n,numtxids,valid,sigspace,pubkeyspace,numunspents,numspends,numpkinds,numexternaltxids,scriptspace; struct iguana_block *block; long fpos;
int32_t i,starti,bROsize,endi,bp_n,numtxids,valid,sigspace,pubkeyspace,numunspents,numspends,numpkinds,numexternaltxids,scriptspace; struct iguana_block *block; long fpos;
struct OS_memspace HASHMEM; int32_t err,j,num,hdrsi,bundlei,firsti= 1,retval = -1;
memset(&HASHMEM,0,sizeof(HASHMEM));
starti = 0, endi = bp->n - 1;
@ -2536,7 +2533,7 @@ int32_t iguana_bundlesaveHT(struct iguana_info *coin,struct OS_memspace *mem,str
numexternaltxids = numspends;
//printf("E.%d depth.%d start bundle ramchain %d at %u started.%u lag.%d\n",coin->numemitted,depth,bp->bundleheight,now,starttime,now-starttime);
depth++;
if ( iguana_ramchain_alloc(fname,coin,dest,mem,&HASHMEM,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace+sigspace,bp->bundleheight+starti,bp_n) < 0 )
if ( iguana_ramchain_alloc(fname,coin,dest,mem,&HASHMEM,numtxids,numunspents,numspends,numpkinds,numexternaltxids,scriptspace+sigspace,bp->bundleheight+starti,bp_n,coin->chain->zcash) < 0 )
{
printf("error iguana_ramchain_alloc for bundleheight.%d\n",bp->bundleheight);
iguana_bundlemapfree(coin,mem,&HASHMEM,ipbits,ptrs,filesizes,num,R,starti,endi);
@ -2547,6 +2544,7 @@ int32_t iguana_bundlesaveHT(struct iguana_info *coin,struct OS_memspace *mem,str
dest->H.scriptoffset = 1;
_iguana_ramchain_setptrs(RAMCHAIN_DESTPTRS,dest->H.data);
iguana_ramchain_extras(coin,dest,&HASHMEM,0);
bROsize = (int32_t)(sizeof(struct iguana_blockRO) + coin->chain->zcash*sizeof(struct iguana_msgblockhdr_zcash));
for (i=starti; i<=endi; i++)
{
if ( coin->active == 0 )
@ -2565,7 +2563,7 @@ int32_t iguana_bundlesaveHT(struct iguana_info *coin,struct OS_memspace *mem,str
iguana_blockunmark(coin,block,bp,i,1);
return(-1);
}
destB[i] = block->RO;
memcpy((void *)((long)destB + i*bROsize),&block->RO,bROsize);
} else printf("error getting block (%d:%d) %p vs %p\n",bp->hdrsi,i,block,bp->blocks[i]);
}
dest->H.txidind = dest->H.unspentind = dest->H.spendind = dest->pkind = dest->H.data->firsti;
@ -2578,8 +2576,9 @@ int32_t iguana_bundlesaveHT(struct iguana_info *coin,struct OS_memspace *mem,str
if ( (block= bp->blocks[bundlei]) != 0 )
{
iguana_blocksetcounters(coin,block,dest);
coin->blocks.RO[bp->bundleheight+bundlei] = block->RO;
destB[bundlei] = block->RO;
//coin->blocks.RO[bp->bundleheight+bundlei] = block->RO;
//memcpy((void *)((long)B + bundlei*bROsize),&block->RO,bROsize);//[bundlei] = block->RO;
//B[bundlei] = block->RO;
//fprintf(stderr,"(%d %d).%d ",R[bundlei].H.data->numtxids,dest->H.txidind,bundlei);
if ( (err= iguana_ramchain_iterate(coin,dest,&R[bundlei],bp,bundlei)) != 0 )
{
@ -2685,7 +2684,7 @@ int32_t iguana_bundlemergeHT(char *fname,struct iguana_info *coin,struct OS_mems
}
if ( A->H.data != 0 && B->H.data != 0 && B->height == A->height+A->numblocks )
{
if ( iguana_ramchain_alloc(fname,coin,dest,mem,&HASHMEM,(A->H.data->numtxids+B->H.data->numtxids),(A->H.data->numunspents+B->H.data->numunspents),(A->H.data->numspends+B->H.data->numspends),(A->H.data->numpkinds+B->H.data->numpkinds),(A->H.data->numexternaltxids+B->H.data->numexternaltxids),A->H.data->scriptspace,A->height,A->numblocks + B->numblocks) < 0 )
if ( iguana_ramchain_alloc(fname,coin,dest,mem,&HASHMEM,(A->H.data->numtxids+B->H.data->numtxids),(A->H.data->numunspents+B->H.data->numunspents),(A->H.data->numspends+B->H.data->numspends),(A->H.data->numpkinds+B->H.data->numpkinds),(A->H.data->numexternaltxids+B->H.data->numexternaltxids),A->H.data->scriptspace,A->height,A->numblocks + B->numblocks,coin->chain->zcash) < 0 )
{
printf("depth.%d ht.%d fsize.%s ERROR alloc lag.%d elapsed.%ld\n",depth,dest->height,mbstr(str,dest->H.data->allocsize),now-starttime,time(NULL)-now);
iguana_mergefree(coin,mem,A,B,&HASHMEM,&HASHMEMA,&HASHMEMB);

2
iguana/iguana_realtime.c
View File

@ -327,7 +327,7 @@ int32_t iguana_realtime_update(struct iguana_info *coin)
totalmillis0 += (OS_milliseconds() - startmillis0);
num0++;
flag++;
coin->blocks.RO[bp->bundleheight+bundlei] = block->RO;
//coin->blocks.RO[bp->bundleheight+bundlei] = block->RO;
coin->RTheight++;
//printf(">>>> RT.%d hwm.%d L.%d T.%d U.%d S.%d P.%d X.%d -> size.%ld\n",coin->RTheight,coin->blocks.hwmchain.height,coin->longestchain,dest->H.txidind,dest->H.unspentind,dest->H.spendind,dest->pkind,dest->externalind,(long)dest->H.data->allocsize);
if ( coin->RTramchain.H.data != 0 )

143
iguana/iguana_recv.c
View File

@ -22,14 +22,16 @@ static int64_t sizeDuplicates,sizeAfteremit;
struct iguana_bundlereq *iguana_bundlereq(struct iguana_info *coin,struct iguana_peer *addr,int32_t type,int32_t datalen)
{
struct iguana_bundlereq *req; int32_t allocsize;
allocsize = (uint32_t)sizeof(*req) + datalen;
struct iguana_bundlereq *req; int32_t allocsize,bsize;
bsize = (int32_t)(sizeof(struct iguana_block) + coin->chain->zcash*sizeof(struct iguana_zcashRO));
allocsize = (uint32_t)sizeof(*req) + datalen + bsize;
req = mycalloc(type,1,allocsize);
req->allocsize = allocsize;
req->datalen = datalen;
req->addr = addr;
req->coin = coin;
req->type = type;
req->serializeddata = (void *)((long)req + bsize);
return(req);
}
@ -159,7 +161,7 @@ void iguana_gotunconfirmedM(struct iguana_info *coin,struct iguana_peer *addr,st
req = iguana_bundlereq(coin,addr,'U',datalen);
req->datalen = datalen;
req->txid = tx->txid;
memcpy(req->serialized,data,datalen);
memcpy(req->serializeddata,data,datalen);
queue_enqueue("recvQ",&coin->recvQ,&req->DL,0);
}
@ -314,7 +316,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
}
if ( coin->numreqtxids > 0 )
{
for (i=0; i<origtxdata->block.RO.txn_count; i++)
for (i=0; i<origtxdata->zblock.RO.txn_count; i++)
{
for (j=0; j<coin->numreqtxids; j++)
{
@ -325,14 +327,14 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
}
}
}
if ( iguana_blockvalidate(coin,&valid,&origtxdata->block,1) < 0 )
if ( iguana_blockvalidate(coin,&valid,(struct iguana_block *)&origtxdata->zblock,1) < 0 )
{
printf("got block that doesnt validate? %s\n",bits256_str(str,origtxdata->block.RO.hash2));
printf("got block that doesnt validate? %s\n",bits256_str(str,origtxdata->zblock.RO.hash2));
return;
}
else if ( 0 && coin->enableCACHE != 0 )
printf("cache.%d validated.(%s)\n",coin->enableCACHE,bits256_str(str,origtxdata->block.RO.hash2));
origtxdata->block.txvalid = 1;
printf("cache.%d validated.(%s)\n",coin->enableCACHE,bits256_str(str,origtxdata->zblock.RO.hash2));
origtxdata->zblock.txvalid = 1;
if ( addr != 0 && addr != &coin->internaladdr )
{
static uint64_t received[IGUANA_MAXPEERS],count[IGUANA_MAXPEERS],lastcount,lastreceived,last;
@ -365,7 +367,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
}
copyflag = 0;//(coin->enableCACHE != 0) && (strcmp(coin->symbol,"BTC") != 0);
bp = 0, bundlei = -2;
bp = iguana_bundlefind(coin,&bp,&bundlei,origtxdata->block.RO.hash2);
bp = iguana_bundlefind(coin,&bp,&bundlei,origtxdata->zblock.RO.hash2);
if ( bp != 0 && bundlei >= 0 && bundlei < bp->n )
{
block = bp->blocks[bundlei];
@ -387,7 +389,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
sizeDuplicates += recvlen;
iguana_bundletime(coin,bp,bundlei,block,1);
//printf("duplicate [%d:%d] %s\n",bp->hdrsi,bundlei,bits256_str(str,block->RO.hash2));
if ( bits256_cmp(origtxdata->block.RO.hash2,block->RO.hash2) == 0 )
if ( bits256_cmp(origtxdata->zblock.RO.hash2,block->RO.hash2) == 0 )
return;
else printf("mismatched tx received? mainchain.%d\n",block->mainchain);
if ( block->mainchain != 0 )
@ -399,7 +401,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
if ( 0 && bp == coin->current )
printf("recv [%d:%d] %s\n",bp->hdrsi,bundlei,bits256_str(str,block->RO.hash2));
}
block->RO = origtxdata->block.RO;
block->RO = origtxdata->zblock.RO;
block->txvalid = 1;
/*if ( block->serdata == 0 )
{
@ -417,7 +419,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
{
if ( (bp= coin->bundles[i]) != 0 && bp->emitfinish == 0 && bp->speculative != 0 && bp->numhashes < bp->n )
{
if ( (j= iguana_speculativefind(coin,bp,&origtxdata->block,data,recvlen)) >= 0 )
if ( (j= iguana_speculativefind(coin,bp,(struct iguana_block *)&origtxdata->zblock,data,recvlen)) >= 0 )
{
copyflag = 0;
speculative = 1;
@ -433,8 +435,8 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
{
req = iguana_bundlereq(coin,addr,'B',copyflag * recvlen);
req->copyflag = 1;
//printf("copy %p serialized[%d]\n",req,req->recvlen);
memcpy(req->serialized,data,recvlen);
printf("copy %p serialized[%d]\n",req,req->recvlen);
memcpy(req->serializeddata,data,recvlen);
}
else
{
@ -443,7 +445,7 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
}
req->recvlen = recvlen;
req->H = *H;
if ( bits256_cmp(origtxdata->block.RO.hash2,coin->APIblockhash) == 0 )
if ( bits256_cmp(origtxdata->zblock.RO.hash2,coin->APIblockhash) == 0 )
{
printf("MATCHED APIblockhash\n");
coin->APIblockstr = calloc(1,recvlen*2+1);
@ -457,13 +459,13 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
addr->lastblockrecv = (uint32_t)time(NULL);
addr->recvblocks += 1.;
addr->recvtotal += recvlen;
if ( speculative == 0 && iguana_ramchain_data(coin,addr,origtxdata,txarray,origtxdata->block.RO.txn_count,data,recvlen) > 0 )
if ( speculative == 0 && iguana_ramchain_data(coin,addr,origtxdata,txarray,origtxdata->zblock.RO.txn_count,data,recvlen) >= 0 )
{
txdata->block.fpipbits = (uint32_t)addr->ipbits;
txdata->block.RO.recvlen = recvlen;
txdata->block.fpos = 0;
txdata->zblock.fpipbits = (uint32_t)addr->ipbits;
txdata->zblock.RO.recvlen = recvlen;
txdata->zblock.fpos = 0;
req->datalen = txdata->datalen;
req->ipbits = txdata->block.fpipbits;
req->ipbits = txdata->zblock.fpipbits;
/*if ( 0 )
{
struct iguana_txblock *checktxdata; struct OS_memspace checkmem; int32_t checkbundlei;
@ -475,11 +477,11 @@ void iguana_gotblockM(struct iguana_info *coin,struct iguana_peer *addr,struct i
}
iguana_mempurge(&checkmem);
}*/
}
} //else printf("cant save block\n");
}
req->block = txdata->block;
//printf("recvlen.%d ipbits.%x prev.(%s)\n",req->block.RO.recvlen,req->block.fpipbits,bits256_str(str,txdata->block.RO.prev_block));
req->block.RO.txn_count = req->numtx = txdata->block.RO.txn_count;
req->zblock = txdata->zblock;
//printf("recvlen.%d ipbits.%x prev.(%s)\n",req->zblock.RO.recvlen,req->zblock.fpipbits,bits256_str(str,txdata->zblock.RO.prev_block));
req->zblock.RO.txn_count = req->numtx = txdata->zblock.RO.txn_count;
coin->recvcount++;
coin->recvtime = (uint32_t)time(NULL);
req->addr = addr;
@ -496,7 +498,7 @@ void iguana_gottxidsM(struct iguana_info *coin,struct iguana_peer *addr,bits256
queue_enqueue("recvQ",&coin->recvQ,&req->DL,0);
}
void iguana_gotheadersM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_block *blocks,int32_t n)
void iguana_gotheadersM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_zblock *zblocks,int32_t n)
{
struct iguana_bundlereq *req; int32_t i,num;
if ( addr != 0 )
@ -515,18 +517,17 @@ void iguana_gotheadersM(struct iguana_info *coin,struct iguana_peer *addr,struct
if ( addr->pendhdrs > 0 )
addr->pendhdrs--;
//printf("%s blocks[%d] ht.%d gotheaders pend.%d %.0f\n",addr->ipaddr,n,blocks[0].height,addr->pendhdrs,milliseconds());
if ( bits256_cmp(blocks[1].RO.hash2,coin->RThash1) == 0 )
if ( bits256_cmp(zblocks[1].RO.hash2,coin->RThash1) == 0 )
{
num = (n < coin->chain->bundlesize ? n : coin->chain->bundlesize);
for (i=0; i<num; i++)
addr->RThashes[i] = blocks[i].RO.hash2;
addr->RThashes[i] = zblocks[i].RO.hash2;
addr->numRThashes = num;
}
}
req = iguana_bundlereq(coin,addr,'H',0);
req->blocks = blocks, req->n = n;
req->blocks = zblocks, req->n = n;
HDRnet++;
//char str[65]; printf("PTblockhdrs.%s net.%d blocks.%d\n",bits256_str(str,blocks[0].RO.hash2),HDRnet,netBLOCKS);
queue_enqueue("recvQ",&coin->recvQ,&req->DL,0);
}
@ -699,7 +700,7 @@ struct iguana_bundle *iguana_bundleset(struct iguana_info *coin,struct iguana_bl
prevhash2 = origblock->RO.prev_block;
if ( block != origblock )
{
iguana_blockcopy(coin,block,origblock);
iguana_blockcopy(coin->chain->zcash,coin->chain->auxpow,coin,block,origblock);
//fprintf(stderr,"bundleset block.%p vs origblock.%p prev.%d bits.%x fpos.%ld\n",block,origblock,bits256_nonz(prevhash2),block->fpipbits,block->fpos);
}
*blockp = block;
@ -764,7 +765,7 @@ void iguana_checklongestchain(struct iguana_info *coin,struct iguana_bundle *bp,
{
if ( coin->longestchain > bp->bundleheight+num+10*coin->chain->minconfirms )
{
//printf("strange.%d suspicious longestchain.%d vs [%d:%d] %d bp->n %d\n",coin->longestchain_strange,coin->longestchain,bp->hdrsi,num,bp->bundleheight+num,bp->n);
printf("strange.%d suspicious longestchain.%d vs [%d:%d] %d bp->n %d\n",coin->longestchain_strange,coin->longestchain,bp->hdrsi,num,bp->bundleheight+num,bp->n);
if ( coin->longestchain_strange++ > 10 )
{
coin->badlongestchain = coin->longestchain;
@ -781,52 +782,63 @@ void iguana_checklongestchain(struct iguana_info *coin,struct iguana_bundle *bp,
}
else if ( coin->longestchain_strange > 0 )
{
//printf("not strange.%d suspicious longestchain.%d vs [%d:%d] %d bp->n %d\n",coin->longestchain_strange,coin->longestchain,bp->hdrsi,num,bp->bundleheight+num,bp->n);
printf("not strange.%d suspicious longestchain.%d vs [%d:%d] %d bp->n %d\n",coin->longestchain_strange,coin->longestchain,bp->hdrsi,num,bp->bundleheight+num,bp->n);
coin->longestchain_strange--;
}
}
}
struct iguana_bundlereq *iguana_recvblockhdrs(struct iguana_info *coin,struct iguana_bundlereq *req,struct iguana_block *blocks,int32_t n,int32_t *newhwmp)
struct iguana_bundlereq *iguana_recvblockhdrs(struct iguana_info *coin,struct iguana_bundlereq *req,struct iguana_zblock *zblocks,int32_t n,int32_t *newhwmp)
{
int32_t i,bundlei,match; struct iguana_block *block; struct iguana_peer *addr; struct iguana_bundle *bp,*firstbp = 0;
if ( blocks == 0 )
char str[65],str2[65]; int32_t i,bundlei,match; struct iguana_block *block; bits256 prevhash2; uint8_t serialized[sizeof(struct iguana_msgblock) + sizeof(struct iguana_msgblockhdr_zcash)]; struct iguana_peer *addr; struct iguana_bundle *bp,*firstbp = 0;
if ( zblocks == 0 )
{
printf("iguana_recvblockhdrs null blocks?\n");
return(req);
}
if ( blocks != 0 && n > 0 )
//bsize = 1 + iguana_blockhdrsize(coin->symbol,coin->chain->zcash,coin->chain->auxpow);
if ( zblocks != 0 && n > 0 )
{
memset(prevhash2.bytes,0,sizeof(prevhash2));
for (i=match=0; i<n; i++)
{
//fprintf(stderr,"i.%d of %d bundleset\n",i,n);
bp = 0, bundlei = -1;
if ( (bp= iguana_bundleset(coin,&block,&bundlei,&blocks[i])) != 0 )
/*src = (void *)((long)blocks + bsize*i);
memset(&zblock,0,sizeof(zblock));
zblock.RO.allocsize = sizeof(zblock);
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,(struct iguana_block *)&zblock,src,zblock.RO.hash2,zblock.height);
iguana_serialize_block(coin->chain,&zblock.RO.hash2,serialized,(struct iguana_block *)&zblock);*/
if ( i > 0 && bits256_cmp(prevhash2,zblocks[i].RO.prev_block) == 0 )
{
bp->dirty++;
if ( 0 && bp->issued[bundlei] == 0 && bp->hdrsi < coin->MAXBUNDLES )
iguana_blockQ("recvhdr",coin,bp,bundlei,blocks[i].RO.hash2,1);
//printf("{%d:%d} ",bp->hdrsi,bundlei);
if ( i == 0 )
{
firstbp = bp;
iguana_checklongestchain(coin,bp,n);
}
if ( bundlei == i+1 && bp == firstbp )
match++;
else
if ( (bp= iguana_bundleset(coin,&block,&bundlei,(struct iguana_block *)&zblocks[i])) != 0 )
{
if ( bp != coin->current && i != n-1 )
fprintf(stderr,"recvhdr: ht.%d[%d] vs i.%d\n",bp->bundleheight,bundlei,i);
bp->dirty++;
if ( 0 && bp->issued[bundlei] == 0 && bp->hdrsi < coin->MAXBUNDLES )
iguana_blockQ("recvhdr",coin,bp,bundlei,block->RO.hash2,1);
//printf("{%d:%d} ",bp->hdrsi,bundlei);
if ( i == 0 )
{
firstbp = bp;
iguana_checklongestchain(coin,bp,n);
}
if ( bundlei == i+1 && bp == firstbp )
match++;
else
{
if ( 0 && bp != coin->current && i != n-1 )
fprintf(stderr,"recvhdr: ht.%d[%d] vs i.%d\n",bp->bundleheight,bundlei,i);
}
}
}
//char str[65],str2[65]; printf("%d bp.%p [%d] bundlei.%d %s prev.%s\n",i,bp,bp!=0?bp->hdrsi:-1,bundlei,bits256_str(str,blocks[i].RO.hash2),bits256_str(str2,blocks[i].RO.prev_block));
} else printf("unexpected prevblock at %d %s vs %s\n",i,bits256_str(str,prevhash2),bits256_str(str2,zblocks[i].RO.hash2));
prevhash2 = zblocks[i].RO.hash2;
//printf("%d bp.%p [%d] bundlei.%d %s prev.%s\n",i,bp,bp!=0?bp->hdrsi:-1,bundlei,bits256_str(str,zblocks[i].RO.hash2),bits256_str(str2,zblocks[i].RO.prev_block));
//else if ( bp != firstbp )
// printf("blockhash[%d] cant be found n.%d\n",i,n);
}
char str[65];
if ( 0 && bp == coin->current )
printf("i.%d n.%d match.%d blockhdrs.%s hdrsi.%d\n",i,n,match,bits256_str(str,blocks[0].RO.hash2),firstbp!=0?firstbp->hdrsi:-1);
printf("i.%d n.%d match.%d blockhdrs.%s hdrsi.%d\n",i,n,match,bits256_str(str,zblocks[0].RO.hash2),firstbp!=0?firstbp->hdrsi:-1);
if ( firstbp != 0 && match == coin->chain->bundlesize-1 && n == firstbp->n )
{
if ( firstbp->queued == 0 )
@ -839,7 +851,13 @@ struct iguana_bundlereq *iguana_recvblockhdrs(struct iguana_info *coin,struct ig
{
addr->RThashes[i] = firstbp->hashes[0];
for (i=1; i<n; i++)
addr->RThashes[i] = blocks[i].RO.hash2;
{
/*src = (void *)((long)blocks + bsize*i);
memset(&zblock,0,sizeof(zblock));
zblock.RO.allocsize = sizeof(zblock);
iguana_blockconv(coin->chain->zcash,coin->chain->auxpow,(struct iguana_block *)&zblock,src,zblock.RO.hash2,zblock.height);*/
iguana_serialize_block(coin->chain,&addr->RThashes[i],serialized,(struct iguana_block *)&zblocks[i]);
}
//memcpy(addr->RThashes,blockhashes,bp->numspec * sizeof(*addr->RThashes));
addr->numRThashes = n;
}
@ -1003,12 +1021,13 @@ struct iguana_bundlereq *iguana_recvblockhashes(struct iguana_info *coin,struct
return(req);
}
struct iguana_bundlereq *iguana_recvblock(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_bundlereq *req,struct iguana_block *origblock,int32_t numtx,int32_t datalen,int32_t recvlen,int32_t *newhwmp)
struct iguana_bundlereq *iguana_recvblock(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_bundlereq *req,struct iguana_zblock *origblock,int32_t numtx,int32_t datalen,int32_t recvlen,int32_t *newhwmp)
{
struct iguana_bundle *bp=0,*prev; int32_t n,bundlei = -2; struct iguana_block *block,*next; char str[65]; bits256 hash2;
//printf("received.%s\n",bits256_str(str,origblock->RO.hash2));
if ( bits256_nonz(origblock->RO.prev_block) != 0 )
iguana_blockQ("prev",coin,0,-1,origblock->RO.prev_block,1);
if ( (bp= iguana_bundleset(coin,&block,&bundlei,origblock)) != 0 && bp == coin->current && block != 0 && bp->speculative != 0 && bundlei >= 0 )
if ( (bp= iguana_bundleset(coin,&block,&bundlei,(struct iguana_block *)origblock)) != 0 && bp == coin->current && block != 0 && bp->speculative != 0 && bundlei >= 0 )
{
if ( bp->speculative != 0 && bp->numspec <= bundlei )
{
@ -1069,8 +1088,8 @@ struct iguana_bundlereq *iguana_recvblock(struct iguana_info *coin,struct iguana
}
if ( (block= iguana_blockhashset("recvblock",coin,-1,origblock->RO.hash2,1)) != 0 )
{
if ( block != origblock )
iguana_blockcopy(coin,block,origblock);
if ( block != (struct iguana_block *)origblock )
iguana_blockcopy(coin->chain->zcash,coin->chain->auxpow,coin,block,(struct iguana_block *)origblock);
if ( block->lag != 0 && block->issued != 0 )
block->lag = (uint32_t)time(NULL) - block->issued;
if ( req->copyflag != 0 )
@ -1278,7 +1297,7 @@ int32_t iguana_processrecvQ(struct iguana_info *coin,int32_t *newhwmp) // single
if ( req->type == 'B' ) // one block with all txdata
{
netBLOCKS--;
req = iguana_recvblock(coin,req->addr,req,&req->block,req->numtx,req->datalen,req->recvlen,newhwmp);
req = iguana_recvblock(coin,req->addr,req,&req->zblock,req->numtx,req->datalen,req->recvlen,newhwmp);
}
else if ( req->type == 'H' ) // blockhdrs (doesnt have txn_count!)
{
@ -1286,7 +1305,7 @@ int32_t iguana_processrecvQ(struct iguana_info *coin,int32_t *newhwmp) // single
if ( (req= iguana_recvblockhdrs(coin,req,req->blocks,req->n,newhwmp)) != 0 )
{
if ( req->blocks != 0 )
myfree(req->blocks,sizeof(*req->blocks) * req->n), req->blocks = 0;
myfree(req->blocks,sizeof(struct iguana_zblock) * req->n), req->blocks = 0;
}
}
else if ( req->type == 'S' ) // blockhashes
@ -1295,7 +1314,7 @@ int32_t iguana_processrecvQ(struct iguana_info *coin,int32_t *newhwmp) // single
myfree(req->hashes,sizeof(*req->hashes) * req->n), req->hashes = 0;
}
else if ( req->type == 'U' ) // unconfirmed tx
req = iguana_recvunconfirmed(coin,req,req->serialized,req->datalen);
req = iguana_recvunconfirmed(coin,req,req->serializeddata,req->datalen);
else if ( req->type == 'T' ) // txids from inv
{
if ( (req= iguana_recvtxids(coin,req,req->hashes,req->n)) != 0 )

2
iguana/iguana_spendvectors.c
View File

@ -696,7 +696,7 @@ int32_t iguana_volatilesinit(struct iguana_info *coin)
//char str[65];
//printf("set hwmchain.%d <- %s %p\n",bp->bundleheight+bp->n-1,bits256_str(str,bp->hashes[bp->n-1]),block);
if ( block->height > coin->blocks.hwmchain.height )
coin->blocks.hwmchain = *block;
memcpy(&coin->blocks.hwmchain,block,block->RO.allocsize);
}
//printf("end volatilesinit\n");
if ( iguana_fastfindinit(coin) == 0 )//&& coin->PREFETCHLAG >= 0 )

14
iguana/iguana_tx.c
View File

@ -228,9 +228,9 @@ int32_t iguana_peerblockrequest(struct iguana_info *coin,uint8_t *blockspace,int
{
if ( (block= bp->blocks[bundlei]) != 0 )
{
iguana_blockunconv(&msgB,block,0);
iguana_blockunconv(coin->chain->zcash,coin->chain->auxpow,&msgB,block,0);
msgB.txn_count = block->RO.txn_count;
total = iguana_rwblock(coin->symbol,coin->chain->hashalgo,1,&checkhash2,&blockspace[sizeof(struct iguana_msghdr) + 0],&msgB);
total = iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&checkhash2,&blockspace[sizeof(struct iguana_msghdr) + 0],&msgB,max);
if ( bits256_cmp(checkhash2,block->RO.hash2) != 0 )
{
static int counter;
@ -366,9 +366,15 @@ cJSON *iguana_blockjson(struct iguana_info *coin,struct iguana_block *block,int3
msg.H.merkle_root = block->RO.merkle_root;
msg.H.timestamp = block->RO.timestamp;
msg.H.bits = block->RO.bits;
msg.H.nonce = block->RO.nonce;
if ( block->RO.allocsize == sizeof(*block)+sizeof(*block->zRO) )
{
msg.zH.bignonce = block->zRO[0].bignonce;
msg.zH.numelements = ZCASH_SOLUTION_ELEMENTS;
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
msg.zH.solution[i] = block->zRO[0].solution[i];
} else msg.H.nonce = block->RO.nonce;
msg.txn_count = 0;//block->RO.txn_count;
len = iguana_rwblock(coin->symbol,coin->chain->hashalgo,1,&hash2,serialized,&msg);
len = iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&hash2,serialized,&msg,IGUANA_MAXPACKETSIZE*2);
init_hexbytes_noT(hexstr,serialized,len);
jaddstr(json,"blockheader",hexstr);
if ( txidsflag != 0 )

6
iguana/main.c
View File

@ -1154,7 +1154,7 @@ void iguana_appletests(struct supernet_info *myinfo)
char genesisblock[1024];
//iguana_chaingenesis("VPN",0,bits256_conv("00000ac7d764e7119da60d3c832b1d4458da9bc9ef9d5dd0d91a15f690a46d99"),genesisblock,"scrypt",1,1409839200,0x1e0fffff,64881664,bits256_conv("698a93a1cacd495a7a4fb3864ad8d06ed4421dedbc57f9aaad733ea53b1b5828")); // VPN
iguana_chaingenesis("LTC",0,bits256_conv("12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2"),genesisblock,"sha256",1,1317972665,0x1e0ffff0,2084524493,bits256_conv("97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9")); // LTC
iguana_chaingenesis("LTC",0,0,0,bits256_conv("12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2"),genesisblock,"sha256",1,1317972665,0x1e0ffff0,2084524493,bits256_conv("97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9")); // LTC
//char *Str = "01000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f279fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4ea78e011d012d59d4";
// https://litecoin.info/Scrypt 0000000110c8357966576df46f3b802ca897deb7ad18b12f1c24ecff6386ebd9
//uint8_t buf[1000]; bits256 shash,hash2; char str[65],str2[65];
@ -1177,10 +1177,10 @@ void iguana_appletests(struct supernet_info *myinfo)
bitcoin_sharedsecret(myinfo->ctx,hash2,pubkey,33);
printf("secp256k1 elapsed %.3f for %d iterations\n",OS_milliseconds() - startmillis,i);
getchar();**/
if ( 1 && (str= SuperNET_JSON(myinfo,cJSON_Parse("{\"protover\":70002,\"RELAY\":0,\"VALIDATE\":0,\"portp2p\":14631,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":4,\"endpend\":4,\"services\":128,\"maxpeers\":128,\"newcoin\":\"BTCD\",\"active\":1,\"numhelpers\":4,\"poll\":100}"),0,myinfo->rpcport)) != 0 )
if ( 0 && (str= SuperNET_JSON(myinfo,cJSON_Parse("{\"protover\":70002,\"RELAY\":1,\"VALIDATE\":1,\"portp2p\":14631,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":4,\"endpend\":4,\"services\":128,\"maxpeers\":128,\"newcoin\":\"BTCD\",\"active\":1,\"numhelpers\":4,\"poll\":100}"),0,myinfo->rpcport)) != 0 )
{
free(str);
if ( 1 && (str= SuperNET_JSON(myinfo,cJSON_Parse("{\"portp2p\":8333,\"RELAY\":0,\"VALIDATE\":0,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":1,\"endpend\":1,\"services\":128,\"maxpeers\":64,\"newcoin\":\"BTC\",\"active\":0,\"numhelpers\":4,\"poll\":100}"),0,myinfo->rpcport)) != 0 )
if ( 0 && (str= SuperNET_JSON(myinfo,cJSON_Parse("{\"portp2p\":8333,\"RELAY\":0,\"VALIDATE\":0,\"agent\":\"iguana\",\"method\":\"addcoin\",\"startpend\":1,\"endpend\":1,\"services\":128,\"maxpeers\":64,\"newcoin\":\"BTC\",\"active\":0,\"numhelpers\":4,\"poll\":100}"),0,myinfo->rpcport)) != 0 )
{
free(str);
if ( 0 && (str= SuperNET_JSON(myinfo,cJSON_Parse("{\"agent\":\"SuperNET\",\"method\":\"login\",\"handle\":\"alice\",\"password\":\"alice\",\"passphrase\":\"alice\"}"),0,myinfo->rpcport)) != 0 )

Write Preview
Loading…
Cancel
Save