char *iguana_APIrequest(struct iguana_info *coin,bits256 blockhash,bits256 txid,int32_t seconds) { int32_t i,len; char *retstr = 0; uint8_t serialized[1024]; char str[65]; coin->APIblockhash = blockhash; coin->APItxid = txid; printf("request block.(%s) txid.%llx\n",bits256_str(str,blockhash),(long long)txid.txid); if ( (len= iguana_getdata(coin,serialized,MSG_BLOCK,bits256_str(str,blockhash))) > 0 ) { for (i=0; i<seconds; i++) { if ( i == 0 ) iguana_send(coin,0,serialized,len); if ( coin->APIblockstr != 0 ) { retstr = coin->APIblockstr; coin->APIblockstr = 0; memset(&coin->APIblockhash,0,sizeof(coin->APIblockhash)); memset(&coin->APItxid,0,sizeof(coin->APItxid)); return(retstr); } sleep(1); } } return(0); }
char *gecko_headersarrived(struct supernet_info *myinfo,struct iguana_info *virt,char *remoteaddr,uint8_t *data,int32_t datalen,bits256 firsthash2) { bits256 hash2,prevhash2; struct iguana_block *block; int32_t height,firstheight,i,len=0,n,num; struct iguana_msgzblock zmsgB; char str[65],str2[65]; num = (int32_t)(datalen / 84); printf("headers.%s arrived.%d from %s\n",virt->symbol,num,bits256_str(str,firsthash2)); if ( (block= iguana_blockfind("geckohdrs",virt,firsthash2)) != 0 && (firstheight= block->height) >= 0 ) { gecko_blockhashupdate(virt,firsthash2,firstheight); prevhash2 = firsthash2; for (i=0; i<num; i++) { if ( (n= iguana_rwblock(myinfo,virt->symbol,virt->chain->zcash,virt->chain->auxpow,virt->chain->hashalgo,0,&hash2,&data[len],&zmsgB,datalen-len)) > 0 ) { if ( bits256_cmp(zmsgB.zH.prev_block,prevhash2) == 0 ) { height = (firstheight + i + 1); gecko_blockhashupdate(virt,hash2,height); printf("ht.%d %s\n",height,bits256_str(str,hash2)); } else printf("ht.%d non prevhash i.%d %s %s\n",height,i,bits256_str(str,prevhash2),bits256_str(str2,zmsgB.zH.prev_block)); len += n; prevhash2 = hash2; } } return(clonestr("{\"result\":\"gecko headers processed\"}")); } else return(clonestr("{\"error\":\"gecko headers couldnt find firsthash2\"}")); }
int32_t dpow_datahandler(struct supernet_info *myinfo,struct dpow_info *dp,struct dpow_block *bp,uint8_t nn_senderind,uint32_t channel,uint32_t height,uint8_t *data,int32_t datalen) { int32_t i,src_or_dest,myind = -1; bits256 txid,srchash; struct iguana_info *coin; char str[65],str2[65]; memset(srchash.bytes,0,sizeof(srchash)); dpow_notaryfind(myinfo,bp,height,&myind,dp->minerkey33); if ( myind < 0 ) { //printf("couldnt find myind height.%d | this means your pubkey for this node is not registered and needs to be ratified by majority vote of all notaries\n",height); return(-1); } for (i=0; i<32; i++) srchash.bytes[i] = dp->minerkey33[i+1]; if ( channel == DPOW_TXIDCHANNEL || channel == DPOW_BTCTXIDCHANNEL ) { src_or_dest = (channel == DPOW_BTCTXIDCHANNEL); coin = (src_or_dest != 0) ? bp->destcoin : bp->srccoin; //printf("bp.%p datalen.%d\n",bp,datalen); for (i=0; i<32; i++) srchash.bytes[i] = data[i]; txid = bits256_doublesha256(0,&data[32],datalen-32); init_hexbytes_noT(bp->signedtx,&data[32],datalen-32); if ( bits256_cmp(txid,srchash) == 0 ) { //printf("verify (%s) it is properly signed! set ht.%d signedtxid to %s\n",coin->symbol,height,bits256_str(str,txid)); /*if ( channel == DPOW_BTCTXIDCHANNEL ) { if ( bp->state < 1000 ) { bp->desttxid = txid; bp->state = 1000; dp->destupdated = 0; dpow_signedtxgen(myinfo,dp,bp->srccoin,bp,bp->bestk,bp->bestmask,myind,DPOW_SIGCHANNEL,0,bp->isratify); //dpow_sigscheck(myinfo,dp,bp,DPOW_SIGCHANNEL,myind,0); } } else { if ( bp->state != 0xffffffff ) { bp->srctxid = txid; printf("set state elapsed %d COMPLETED %s.(%s) %s.(%s)\n",(int32_t)(time(NULL) - bp->starttime),dp->symbol,bits256_str(str,bp->desttxid),dp->dest,bits256_str(str2,txid)); bp->state = 0xffffffff; } }*/ } else { init_hexbytes_noT(bp->signedtx,data,datalen); printf("txidchannel txid %s mismatch %s (%s)\n",bits256_str(str,txid),bits256_str(str2,srchash),bp->signedtx); bp->signedtx[0] = 0; } } //else printf("unhandled channel.%x\n",channel); return(0); }
void SuperNET_hexmsgadd(struct supernet_info *myinfo,bits256 categoryhash,bits256 subhash,char *hexmsg,struct tai now,char *remoteaddr) { char str[512],str2[65]; str[0] = 0; if ( memcmp(categoryhash.bytes,GENESIS_PUBKEY.bytes,sizeof(categoryhash)) == 0 ) strcpy(str,"BROADCAST."); else bits256_str(str+strlen(str),categoryhash); if ( memcmp(subhash.bytes,GENESIS_PUBKEY.bytes,sizeof(subhash)) != 0 ) { bits256_str(str2,subhash); strcat(str,str2); } category_posthexmsg(myinfo,categoryhash,subhash,hexmsg,now,remoteaddr); //printf("HEXMSG.(%s).%llx -> %s\n",hexmsg,(long long)subhash.txid,str); }
int32_t iguana_queueblock(struct iguana_info *coin,int32_t height,bits256 hash2,int32_t priority) { queue_t *Q; char *str; struct iguana_blockreq *req; if ( bits256_nonz(hash2) == 0 ) { printf("cant queue zerohash height.%d\n",height), getchar(); return(-1); } if ( height < 0 || (height >= coin->blocks.recvblocks && iguana_blockptr(coin,height) == 0) ) { if ( priority != 0 ) str = "priorityQ", Q = &coin->priorityQ; else //if ( GETBIT(coin->R.waitingbits,height) == 0 ) str = "blocksQ", Q = &coin->blocksQ; //else str = "already pending", Q = 0; if ( Q != 0 ) { req = mycalloc('r',1,sizeof(*req)); req->hash2 = hash2; req->height = height; if ( (height % 1000) == 0 ) printf("%s %d %s recv.%d numranked.%d\n",str,height,bits256_str(hash2),coin->blocks.recvblocks,coin->peers.numranked); queue_enqueue(str,Q,&req->DL,0); return(1); } } //printf("iguana_queueblock skip.%d %s recvblocks.%d %p GETBIT.%d\n",height,bits256_str(hash2),coin->blocks.recvblocks,iguana_recvblock(coin,height),GETBIT(coin->R.waitingbits,height)); return(0); }
uint32_t iguana_sparseadd(uint8_t *bits,uint32_t ind,int32_t width,uint32_t tablesize,uint8_t *key,int32_t keylen,uint32_t setind,void *refdata,int32_t refsize,struct iguana_ramchain *ramchain,uint32_t maxitems) { static uint8_t masks[8] = { 1, 2, 4, 8, 16, 32, 64, 128 }; struct iguana_ramchaindata *rdata; int32_t i,j,x,n,modval; int64_t bitoffset; uint8_t *ptr; uint32_t *table,retval = 0; if ( tablesize == 0 ) { printf("iguana_sparseadd tablesize zero illegal\n"); return(0); } if ( 0 && setind == 0 ) { char str[65]; for (i=n=0; i<tablesize; i++) { bitoffset = (i * width); ptr = &bits[bitoffset >> 3]; modval = (bitoffset & 7); for (x=j=0; j<width; j++,modval++) { if ( modval >= 8 ) ptr++, modval = 0; x <<= 1; x |= (*ptr & masks[modval]) >> modval; } if ( x != 0 ) printf("%s ",bits256_str(str,*(bits256 *)(refdata + x*refsize))), n++; } printf("tableentries.%d\n",n); }
int32_t iguana_rwblock(int32_t rwflag,bits256 *hash2p,uint8_t *serialized,struct iguana_msgblock *msg) { int32_t len = 0; char blockhash[65]; uint64_t x; 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); *hash2p = bits256_doublesha256(blockhash,serialized,len); //char str[65]; printf("len.%d: block version.%d timestamp.%u bits.%x nonce.%u prev.(%s) %llx blockhash.(%s) %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,blockhash,(long long)hash2p->txid); if ( rwflag != 0 ) x = msg->txn_count; len += iguana_rwvarint(rwflag,&serialized[len],&x); if ( rwflag == 0 ) { char str[65]; bits256_str(str,*hash2p); if ( x < 65536 ) msg->txn_count = (uint16_t)x; else printf("txn_count overflow.%lld for %s\n",(long long)x,str); } // ? txns tx[] Block transactions, in format of "tx" command return(len); }
void iguana_gotunconfirmedM(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_msgtx *tx,uint8_t *data,int32_t datalen) { struct iguana_bundlereq *req; printf("%s unconfirmed.%s\n",addr->ipaddr,bits256_str(tx->txid)); req = iguana_bundlereq(coin,addr,'U',datalen); req->n = datalen; memcpy(req->serialized,data,datalen); iguana_freetx(tx,1); queue_enqueue("bundlesQ",&coin->bundlesQ,&req->DL,0); }
void gecko_blockhashupdate(struct iguana_info *virt,bits256 hash2,int32_t height) { int32_t bundlei; struct iguana_bundle *bp; bits256 zero; char str[65]; printf("gecko_blockhashupdate height.%d %s\n",height,bits256_str(str,hash2)); memset(zero.bytes,0,sizeof(zero)); if ( (height % virt->chain->bundlesize) == 0 ) bp = iguana_bundlecreate(virt,&bundlei,height,hash2,zero,0); else if ( (bp= virt->bundles[height / virt->chain->bundlesize]) != 0 ) iguana_bundlehash2add(virt,0,bp,height % virt->chain->bundlesize,hash2); }
void SuperNET_MYINFOadd(struct supernet_info *myinfo) { int32_t num; if ( SuperNET_MYINFOfind(&num,myinfo->myaddr.persistent) == 0 ) { MYINFOS = realloc(MYINFOS,(num + 2) * sizeof(*MYINFOS)); char str[65]; printf("MYNFOadd[%d] <- %s\n",num,bits256_str(str,myinfo->myaddr.persistent)); MYINFOS[num] = calloc(1,sizeof(*myinfo)); *MYINFOS[num] = *myinfo; MYINFOS[++num] = 0; } }
int32_t iguana_pollQs(struct iguana_info *coin,struct iguana_peer *addr) { uint8_t serialized[sizeof(struct iguana_msghdr) + sizeof(uint32_t)*32 + sizeof(bits256)]; char *hashstr=0,hexstr[65]; bits256 hash2; int32_t height=-1,datalen,flag = 0; struct iguana_blockreq *req=0; if ( iguana_needhdrs(coin) != 0 && addr->pendhdrs == 0 && (hashstr= queue_dequeue(&coin->hdrsQ,1)) != 0 ) { if ( (datalen= iguana_gethdrs(coin,serialized,coin->chain->gethdrsmsg,hashstr)) > 0 ) { decode_hex(hash2.bytes,sizeof(hash2),hashstr); //printf("%s request hdr.(%s) %d pend.%d\n",addr->ipaddr,hashstr,iguana_itemheight(coin,hash2),addr->pendhdrs); iguana_send(coin,addr,serialized,datalen); addr->pendhdrs++; flag++; } else printf("datalen.%d from gethdrs\n",datalen); free_queueitem(hashstr); hashstr = 0; } if ( ((req= queue_dequeue(&coin->priorityQ,0)) != 0 || (req= queue_dequeue(&coin->blocksQ,0)) != 0) ) { hash2 = req->hash2; height = iguana_hash2height(coin,hash2); if ( req->height >= 0 && height != req->height ) { printf("blocksQ ht.%d vs %d dequeued.(%s) for %s\n",req->height,height,bits256_str(hash2),addr->ipaddr); myfree(req,sizeof(*req)); return(0); } if ( height >= 0 && (height < coin->blocks.recvblocks || iguana_blockptr(coin,height) != 0) ) { printf("skip.%d vs recvblocks.%d %p\n",height,coin->blocks.recvblocks,iguana_blockptr(coin,height)); myfree(req,sizeof(*req)); } else { init_hexbytes_noT(hexstr,hash2.bytes,sizeof(hash2)); if ( (datalen= iguana_getdata(coin,serialized,MSG_BLOCK,hexstr)) > 0 ) { //printf("%s %s REQ BLOCK.%d\n",addr->ipaddr,hexstr,iguana_blockheight(coin,hash2)); iguana_send(coin,addr,serialized,datalen); //if ( height >= 0 ) // iguana_setwaitstart(coin,height); addr->pendblocks++; addr->pendtime = (uint32_t)time(NULL); flag++; myfree(req,sizeof(*req)); } else printf("error constructing request %s.%d\n",hexstr,height); } } return(flag); }
int32_t bitcoin_priv2wiflong(char *wifstr,bits256 privkey,uint8_t addrtype) { uint8_t data[128]; int32_t len = 32; memcpy(data+1,privkey.bytes,sizeof(privkey)); len = base58encode_checkbuf(addrtype,data,len); if ( bitcoin_base58encode(wifstr,data,len) == 0 ) return(-1); if ( 1 ) { uint8_t checktype; bits256 checkpriv; char str[65],str2[65]; if ( bitcoin_wif2priv(&checktype,&checkpriv,wifstr) == sizeof(bits256) ) { if ( checktype != addrtype || bits256_cmp(checkpriv,privkey) != 0 ) printf("(%s) -> wif.(%s) addrtype.%02x -> %02x (%s)\n",bits256_str(str,privkey),wifstr,addrtype,checktype,bits256_str(str2,checkpriv)); } } return((int32_t)strlen(wifstr)); }
int32_t iguana_jsonQ() { struct iguana_jsonitem *ptr; if ( (ptr= queue_dequeue(&finishedQ,0)) != 0 ) { if ( ptr->expired != 0 ) { *ptr->retjsonstrp = clonestr("{\"error\":\"request timeout\"}"); printf("garbage collection: expired.(%s)\n",ptr->jsonstr); myfree(ptr,ptr->allocsize); } else queue_enqueue("finishedQ",&finishedQ,&ptr->DL,0); } if ( (ptr= queue_dequeue(&jsonQ,0)) != 0 ) { char str[65]; printf("ptr %p %s\n",&ptr->myinfo->privkey,bits256_str(str,ptr->myinfo->privkey)); if ( *ptr->retjsonstrp != 0 && (*ptr->retjsonstrp= SuperNET_jsonstr(ptr->myinfo,ptr->jsonstr,ptr->remoteaddr)) == 0 ) *ptr->retjsonstrp = clonestr("{\"error\":\"null return from iguana_jsonstr\"}"); //printf("finished.(%s) -> (%s)\n",ptr->jsonstr,*ptr->retjsonstrp!=0?*ptr->retjsonstrp:"null return"); queue_enqueue("finishedQ",&finishedQ,&ptr->DL,0); return(1); } return(0); }
char *iguana_inputaddress(struct iguana_info *coin,char *coinaddr,int16_t *spent_hdrsip,uint32_t *unspentindp,cJSON *vinobj) { bits256 txid; int32_t vout,checkind,height; *unspentindp = 0; *spent_hdrsip = -1; if ( jobj(vinobj,"txid") != 0 && jobj(vinobj,"vout") != 0 ) { txid = jbits256(vinobj,"txid"); vout = jint(vinobj,"vout"); if ( (checkind= iguana_unspentindfind(coin,coinaddr,0,0,0,&height,txid,vout,coin->bundlescount-1)) > 0 ) { *spent_hdrsip = (height / coin->chain->bundlesize); *unspentindp = checkind; return(coinaddr); } else { char str[65]; printf("error finding (%s/%d)\n",bits256_str(str,txid),vout); } } return(0); }
void jaddibits256(cJSON *json,bits256 hash) { char str[65]; bits256_str(str,hash), jaddistr(json,str); }
ZERO_ARGS(bitcoinrpc,getbestblockhash) { cJSON *retjson = cJSON_CreateObject(); char str[65]; jaddstr(retjson,"result",bits256_str(str,coin->blocks.hwmchain.RO.hash2)); return(jprint(retjson,1)); }
struct instantdex_msghdr *instantdex_msgcreate(struct supernet_info *myinfo,struct instantdex_msghdr *msg,int32_t datalen) { bits256 otherpubkey; uint64_t signerbits; uint32_t timestamp; uint8_t buf[sizeof(msg->sig)],*data; memset(&msg->sig,0,sizeof(msg->sig)); datalen += (int32_t)(sizeof(*msg) - sizeof(msg->sig)); data = (void *)((long)msg + sizeof(msg->sig)); otherpubkey = acct777_msgpubkey(data,datalen); timestamp = (uint32_t)time(NULL); acct777_sign(&msg->sig,myinfo->privkey,otherpubkey,timestamp,data,datalen); if ( (signerbits= acct777_validate(&msg->sig,acct777_msgprivkey(data,datalen),msg->sig.pubkey)) != 0 ) { int32_t i; char str[65],str2[65]; for (i=0; i<datalen; i++) printf("%02x",data[i]); printf(">>>>>>>>>>>>>>>> validated [%ld] len.%d (%s + %s)\n",(long)data-(long)msg,datalen,bits256_str(str,acct777_msgprivkey(data,datalen)),bits256_str(str2,msg->sig.pubkey)); memset(buf,0,sizeof(buf)); acct777_rwsig(1,buf,&msg->sig); memcpy(&msg->sig,buf,sizeof(buf)); return(msg); } else printf("error validating instantdex msg\n"); return(0); }
HASH_AND_INT(ramchain,getblock,blockhash,remoteonly) { int32_t len; char hexstr[(sizeof(uint32_t)+sizeof(struct iguana_msgblock))*2+1],*blockstr; uint8_t serialized[sizeof(uint32_t)+sizeof(struct iguana_msgblock)]; bits256 hash2,txid; struct iguana_msgblock msg; struct iguana_block *block; cJSON *retjson = cJSON_CreateObject(); memset(&msg,0,sizeof(msg)); if ( remoteonly == 0 && (block= iguana_blockfind(coin,blockhash)) != 0 ) { msg.H.version = block->RO.version; 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; msg.txn_count = block->RO.txn_count; len = iguana_rwblock(1,&hash2,serialized,&msg); char str[65]; printf("timestamp.%u bits.%u nonce.%u v.%d (%s) len.%d (%ld %ld)\n",block->RO.timestamp,block->RO.bits,block->RO.nonce,block->RO.version,bits256_str(str,hash2),len,sizeof(serialized),sizeof(hexstr)); init_hexbytes_noT(hexstr,serialized,len); jaddstr(retjson,"result",hexstr); } else if ( coin->APIblockstr != 0 ) jaddstr(retjson,"error","already have pending request"); else { memset(txid.bytes,0,sizeof(txid)); if ( (blockstr= iguana_APIrequest(coin,blockhash,txid,5)) != 0 ) { jaddstr(retjson,"result",blockstr); free(blockstr); } else jaddstr(retjson,"error","cant find blockhash"); } return(jprint(retjson,1)); }
void iguana_dPoWupdate(struct supernet_info *myinfo,struct dpow_info *dp) { int32_t height,num; uint32_t blocktime; bits256 blockhash; struct iguana_info *src,*dest; //fprintf(stderr,"dp.%p dPoWupdate (%s -> %s)\n",dp,dp!=0?dp->symbol:"",dp!=0?dp->dest:""); //if ( strcmp(dp->symbol,"KMD") == 0 ) { num = dpow_nanomsg_update(myinfo); //fprintf(stderr,"%d ",num); } src = iguana_coinfind(dp->symbol); dest = iguana_coinfind(dp->dest); if ( src != 0 && dest != 0 ) { dp->numdesttx = sizeof(dp->desttx)/sizeof(*dp->desttx); if ( (height= dpow_getchaintip(myinfo,&blockhash,&blocktime,dp->desttx,&dp->numdesttx,dest)) != dp->destchaintip.blockhash.height && height >= 0 ) { char str[65]; if ( strcmp(dp->symbol,"KMD") == 0 || height != dp->destchaintip.blockhash.height+1 ) printf("[%s].%d %s %s height.%d vs last.%d\n",dp->symbol,dp->SRCHEIGHT,dp->dest,bits256_str(str,blockhash),height,dp->destchaintip.blockhash.height); if ( height <= dp->destchaintip.blockhash.height ) { printf("iguana_dPoWupdate dest.%s reorg detected %d vs %d\n",dp->dest,height,dp->destchaintip.blockhash.height); if ( height == dp->destchaintip.blockhash.height && bits256_cmp(blockhash,dp->destchaintip.blockhash.hash) != 0 ) printf("UNEXPECTED ILLEGAL BLOCK in dest chaintip\n"); } else dpow_destupdate(myinfo,dp,height,blockhash,(uint32_t)time(NULL),blocktime); } // else printf("error getchaintip for %s\n",dp->dest); dp->numsrctx = sizeof(dp->srctx)/sizeof(*dp->srctx); if ( strcmp(dp->dest,"KMD") == 0 && dp->SRCHEIGHT < src->longestchain ) { //fprintf(stderr,"[I "); dp->SRCHEIGHT = dpow_issuer_iteration(dp,src,dp->SRCHEIGHT,&dp->SRCREALTIME); //fprintf(stderr," %d] ",dp->SRCHEIGHT); } if ( (height= dpow_getchaintip(myinfo,&blockhash,&blocktime,dp->srctx,&dp->numsrctx,src)) != dp->last.blockhash.height && height >= 0 ) { char str[65]; printf("[%s].%d %s %s height.%d vs last.%d\n",dp->dest,dp->SRCHEIGHT,dp->symbol,bits256_str(str,blockhash),height,dp->last.blockhash.height); if ( dp->lastheight == 0 ) dp->lastheight = height-1; if ( height < dp->last.blockhash.height ) { printf("iguana_dPoWupdate src.%s reorg detected %d vs %d approved.%d notarized.%d\n",dp->symbol,height,dp->last.blockhash.height,dp->approved[0].height,dp->notarized[0].height); if ( height <= dp->approved[0].height ) { if ( bits256_cmp(blockhash,dp->last.blockhash.hash) != 0 ) printf("UNEXPECTED ILLEGAL BLOCK in src chaintip\n"); } else { while ( dp->lastheight <= height ) { blockhash = dpow_getblockhash(myinfo,src,dp->lastheight); dpow_srcupdate(myinfo,dp,dp->lastheight++,blockhash,(uint32_t)time(NULL),blocktime); } } } else { while ( dp->lastheight <= height ) { blockhash = dpow_getblockhash(myinfo,src,dp->lastheight); dpow_srcupdate(myinfo,dp,dp->lastheight++,blockhash,(uint32_t)time(NULL),blocktime); } } } //else printf("error getchaintip for %s\n",dp->symbol); } else printf("iguana_dPoWupdate missing src.(%s) %p or dest.(%s) %p\n",dp->symbol,src,dp->dest,dest); }
char *gecko_blockconstruct(struct supernet_info *myinfo,struct iguana_info *virt,struct iguana_block *newblock,uint32_t *noncep,struct gecko_memtx **txptrs,int32_t txn_count,uint8_t *coinbase,int32_t coinbaselen,bits256 coinbasespend,double expiration,uint8_t *minerpubkey,int64_t blockreward) { struct iguana_info *btcd; uint8_t serialized[sizeof(*newblock)],space[16384]; int32_t i,n,len,totaltxlen=0; char *coinbasestr,str[65],str2[65],*blockstr=0; bits256 *txids=0,txspace[256],threshold,hash2; struct gecko_memtx *memtx; if ( (btcd= iguana_coinfind("BTCD")) == 0 ) { printf("basilisk needs BTCD\n"); return(0); } if ( txn_count+2 < sizeof(space)/sizeof(*space) ) { txids = txspace; memset(txids,0,sizeof(*txids) * (txn_count+2)); } else txids = calloc(txn_count+2,sizeof(*txids)); if ( txn_count > 0 ) { for (i=0; i<txn_count; i++) { if ( (memtx= txptrs[i]) != 0 ) { totaltxlen += memtx->datalen; txids[i + 1] = memtx->txid; printf("memtxid.%s\n",bits256_str(str,memtx->txid)); } } } if ( (coinbasestr= gecko_coinbasestr(myinfo,virt,&txids[0],newblock->RO.timestamp,minerpubkey,blockreward,coinbase,coinbaselen,coinbasespend)) != 0 ) { newblock->RO.merkle_root = iguana_merkle(txids,txn_count + 1); newblock->RO.txn_count = (txn_count + 1); if ( txn_count > 0 ) { printf("%s %s\n",bits256_str(str,txids[0]),bits256_str(str2,txids[1])); } if ( newblock->RO.bits >= GECKO_EASIESTDIFF ) newblock->RO.bits = GECKO_EASIESTDIFF; threshold = bits256_from_compact(newblock->RO.bits); if ( (newblock->RO.nonce= *noncep) == 0 ) { struct iguana_msgblock msg; memset(&msg,0,sizeof(msg)); msg.H.version = newblock->RO.version; msg.H.prev_block = newblock->RO.prev_block; msg.H.merkle_root = newblock->RO.merkle_root; msg.H.timestamp = newblock->RO.timestamp; msg.H.bits = newblock->RO.bits; for (i=0; i<GECKO_MAXMINERITERS; i++) { OS_randombytes((void *)noncep,sizeof(*noncep)); msg.H.nonce = *noncep; //n = iguana_serialize_block(virt->chain,&hash2,serialized,newblock); //char str[65]; printf("nonce.%08x %s\n",newblock->RO.nonce,bits256_str(str,newblock->RO.hash2)); len = iguana_rwblockhdr(1,virt->chain->zcash,serialized,&msg); hash2 = iguana_calcblockhash(virt->symbol,virt->chain->hashalgo,serialized,len); if ( bits256_cmp(threshold,hash2) > 0 ) { //printf("FOUND NONCE %d iterations\n",i+1); newblock->RO.hash2 = hash2; break; } if ( newblock->height != 0 && OS_milliseconds() > expiration ) { //printf("time limit exceeded %u %d iterations\n",virt->blocks.hwmchain.RO.timestamp,i+1); free(coinbasestr); if ( txids != txspace ) free(txids); return(0); } } } newblock->RO.nonce = *noncep; n = iguana_serialize_block(virt->chain,&newblock->RO.hash2,serialized,newblock); while ( 1 && time(NULL) <= newblock->RO.timestamp + GECKO_MAXFUTUREBLOCK ) { //printf("wait for block to be close enough to now: lag %ld\n",time(NULL) - newblock->RO.timestamp); sleep(1); } //if ( gecko_blocknonce_verify(virt,serialized,n,newblock->RO.bits,newblock->RO.timestamp,virt->blocks.hwmchain.RO.timestamp) >= 0 ) if ( bits256_cmp(threshold,newblock->RO.hash2) > 0 ) { blockstr = calloc(1,strlen(coinbasestr) + (totaltxlen+n)*2 + 1); init_hexbytes_noT(blockstr,serialized,n); printf("block.(%s) coinbase.(%s) lens.%ld\n",blockstr,coinbasestr,(strlen(blockstr)+strlen(coinbasestr))/2); strcat(blockstr,coinbasestr); len = (int32_t)strlen(blockstr); for (i=0; i<txn_count; i++) { if ( (memtx= txptrs[i]) != 0 ) { init_hexbytes_noT(&blockstr[len],gecko_txdata(memtx),memtx->datalen); len += memtx->datalen << 1; printf(" txi.%d (%s)\n",i,&blockstr[len]); } } } else printf("nonce failure\n"); free(coinbasestr); } if ( txids != txspace ) free(txids); return(blockstr); }
void dpow_srcupdate(struct supernet_info *myinfo,struct dpow_info *dp,int32_t height,bits256 hash,uint32_t timestamp,uint32_t blocktime) { void **ptrs; char str[65]; struct dpow_checkpoint checkpoint; int32_t freq,minsigs; //uint8_t pubkeys[64][33]; dpow_checkpointset(myinfo,&dp->last,height,hash,timestamp,blocktime); checkpoint = dp->srcfifo[dp->srcconfirms]; if ( strcmp("BTC",dp->dest) == 0 ) { freq = DPOW_CHECKPOINTFREQ; minsigs = DPOW_MINSIGS; } else { freq = 1; //minsigs = 7;//(komodo_notaries(dp->symbol,pubkeys,height) >> 1) + 1; //if ( minsigs < DPOW_MINSIGS ) minsigs = DPOW_MINSIGS; } printf("%s/%s src ht.%d dest.%u nonz.%d %s minsigs.%d\n",dp->symbol,dp->dest,checkpoint.blockhash.height,dp->destupdated,bits256_nonz(checkpoint.blockhash.hash),bits256_str(str,dp->last.blockhash.hash),minsigs); dpow_fifoupdate(myinfo,dp->srcfifo,dp->last); if ( dp->SRCREALTIME == 0 && strcmp(dp->dest,"KMD") == 0 ) return; if ( bits256_nonz(checkpoint.blockhash.hash) != 0 && (checkpoint.blockhash.height % freq) == 0 ) { dpow_heightfind(myinfo,dp,checkpoint.blockhash.height + 1000); ptrs = calloc(1,sizeof(void *)*5 + sizeof(struct dpow_checkpoint)); ptrs[0] = (void *)myinfo; ptrs[1] = (void *)dp; ptrs[2] = (void *)(uint64_t)minsigs; ptrs[3] = (void *)DPOW_DURATION; ptrs[4] = 0; memcpy(&ptrs[5],&checkpoint,sizeof(checkpoint)); if ( OS_thread_create(malloc(sizeof(pthread_t)),NULL,(void *)dpow_statemachinestart,(void *)ptrs) != 0 ) { } } }
void dpow_statemachinestart(void *ptr) { void **ptrs = ptr; struct supernet_info *myinfo; struct dpow_info *dp; struct dpow_checkpoint checkpoint; int32_t i,j,ht,extralen,destprevvout0,srcprevvout0,numratified=0,kmdheight,myind = -1; uint8_t extras[10000],pubkeys[64][33]; cJSON *ratified=0,*item; struct iguana_info *src,*dest; char *jsonstr,*handle,*hexstr,str[65],str2[65],srcaddr[64],destaddr[64]; bits256 zero,srchash,destprevtxid0,srcprevtxid0; struct dpow_block *bp; struct dpow_entry *ep = 0; uint32_t duration,minsigs,starttime,srctime; memset(&zero,0,sizeof(zero)); srcprevtxid0 = destprevtxid0 = zero; srcprevvout0 = destprevvout0 = -1; myinfo = ptrs[0]; dp = ptrs[1]; minsigs = (uint32_t)(long)ptrs[2]; duration = (uint32_t)(long)ptrs[3]; jsonstr = ptrs[4]; kmdheight = -1; memcpy(&checkpoint,&ptrs[5],sizeof(checkpoint)); src = iguana_coinfind(dp->symbol); dest = iguana_coinfind(dp->dest); dpow_getchaintip(myinfo,&srchash,&srctime,dp->srctx,&dp->numsrctx,src); dpow_getchaintip(myinfo,&srchash,&srctime,dp->desttx,&dp->numdesttx,dest); if ( src == 0 || dest == 0 ) { printf("null coin ptr? (%s %p or %s %p)\n",dp->symbol,src,dp->dest,dest); return; } if ( strcmp(src->symbol,"KMD") == 0 ) kmdheight = checkpoint.blockhash.height; else if ( strcmp(dest->symbol,"KMD") == 0 ) kmdheight = dest->longestchain; if ( (bp= dp->blocks[checkpoint.blockhash.height]) == 0 ) { bp = calloc(1,sizeof(*bp)); bp->minsigs = minsigs; bp->duration = duration; bp->srccoin = src; bp->destcoin = dest; bp->myind = -1; bp->opret_symbol = dp->symbol; if ( jsonstr != 0 && (ratified= cJSON_Parse(jsonstr)) != 0 ) { bp->isratify = 1; if ( (numratified= cJSON_GetArraySize(ratified)) > 0 ) { if ( numratified > 64 ) { fprintf(stderr,"cant ratify more than 64 notaries ratified has %d\n",numratified); return; } for (i=0; i<numratified; i++) { item = jitem(ratified,i); hexstr = handle = 0; if ( (hexstr= jstr(item,"pubkey")) != 0 && is_hexstr(hexstr,0) == 66 ) { decode_hex(bp->ratified_pubkeys[i],33,hexstr); for (j=0; j<i; j++) if ( memcmp(bp->ratified_pubkeys[j],bp->ratified_pubkeys[i],33) == 0 ) { printf("ratification.%d is the same as %d, reject this donkey\n",j,i); exit(-1); } if ( (handle= jstr(item,"handle")) != 0 ) safecopy(bp->handles[i],handle,sizeof(bp->handles[i])); if ( i == 0 ) { destprevtxid0 = jbits256(item,"destprevtxid0"); destprevvout0 = jint(item,"destprevvout0"); srcprevtxid0 = jbits256(item,"srcprevtxid0"); srcprevvout0 = jint(item,"srcprevvout0"); if ( bits256_nonz(destprevtxid0) != 0 && bits256_nonz(srcprevtxid0) != 0 ) bp->require0 = 1; } } else { printf("break loop hexstr.%p handle.%p\n",hexstr,handle); break; } } if ( i == numratified ) { bp->numratified = numratified; bp->ratified = ratified; printf("numratified.%d %s\n",numratified,jprint(ratified,0)); } else { printf("i.%d numratified.%d\n",i,numratified); free_json(ratified); } } } bp->bestk = -1; dp->blocks[checkpoint.blockhash.height] = bp; bp->beacon = rand256(0); vcalc_sha256(0,bp->commit.bytes,bp->beacon.bytes,sizeof(bp->beacon)); /*if ( checkpoint.blockhash.height >= DPOW_FIRSTRATIFY && dp->blocks[checkpoint.blockhash.height - DPOW_FIRSTRATIFY] != 0 ) { printf("purge %s.%d\n",dp->dest,checkpoint.blockhash.height - DPOW_FIRSTRATIFY); free(dp->blocks[checkpoint.blockhash.height - DPOW_FIRSTRATIFY]); dp->blocks[checkpoint.blockhash.height - DPOW_FIRSTRATIFY] = 0; }*/ } if ( bp->isratify != 0 && dp->ratifying != 0 ) { printf("new ratification starting dp->ratifying.%d\n",dp->ratifying); dp->ratifying++; while ( dp->ratifying > 1 ) sleep(3); printf("other ratifications stopped\n"); } if ( dp->ratifying != 0 && bp->isratify == 0 ) { printf("skip notarization ht.%d when ratifying\n",bp->height); free(ptr); return; } dp->ratifying += bp->isratify; bitcoin_address(srcaddr,src->chain->pubtype,dp->minerkey33,33); bitcoin_address(destaddr,dest->chain->pubtype,dp->minerkey33,33); if ( kmdheight >= 0 ) { ht = kmdheight;///strcmp("KMD",src->symbol) == 0 ? kmdheight : bp->height; if ( strcmp("KMD",dest->symbol) == 0 ) { bp->numnotaries = komodo_notaries(dest->symbol,pubkeys,ht); } else { if ( ht == 0 ) ht = strcmp("KMD",src->symbol) == 0 ? src->longestchain : dest->longestchain; bp->numnotaries = komodo_notaries(src->symbol,pubkeys,ht); } for (i=0; i<bp->numnotaries; i++) { //int32_t j; for (j=0; j<33; j++) // printf("%02x",pubkeys[i][j]); //printf(" <= pubkey[%d]\n",i); memcpy(bp->notaries[i].pubkey,pubkeys[i],33); if ( strcmp("KMD",src->symbol) == 0 ) memcpy(myinfo->notaries[i],pubkeys[i],33); if ( memcmp(bp->notaries[i].pubkey,dp->minerkey33,33) == 0 ) { myind = i; ep = &bp->notaries[myind]; for (j=0; j<33; j++) printf("%02x",dp->minerkey33[j]); printf(" MYIND.%d <<<<<<<<<<<<<<<<<<<<<<\n",myind); } } if ( strcmp("KMD",src->symbol) == 0 ) myinfo->numnotaries = bp->numnotaries; if ( myind < 0 || ep == 0 ) { printf("minerkey33-> "); for (i=0; i<33; i++) printf("%02x",dp->minerkey33[i]); printf(" statemachinestart this node %s %s is not official notary numnotaries.%d kmdht.%d bpht.%d\n",srcaddr,destaddr,bp->numnotaries,kmdheight,bp->height); free(ptr); dp->ratifying -= bp->isratify; return; } printf("myind.%d\n",myind); } else { printf("statemachinestart no kmdheight.%d\n",kmdheight); free(ptr); dp->ratifying -= bp->isratify; return; } bp->myind = myind; printf("[%d] notarize %s->%s %s ht.%d minsigs.%d duration.%d start.%u\n",bp->myind,dp->symbol,dp->dest,bits256_str(str,checkpoint.blockhash.hash),checkpoint.blockhash.height,minsigs,duration,checkpoint.timestamp); if ( bp->isratify != 0 && memcmp(bp->notaries[0].pubkey,bp->ratified_pubkeys[0],33) != 0 ) { for (i=0; i<33; i++) printf("%02x",bp->notaries[0].pubkey[i]); printf(" current vs "); for (i=0; i<33; i++) printf("%02x",bp->ratified_pubkeys[0][i]); printf(" new, cant change notary0\n"); dp->ratifying -= bp->isratify; return; } //printf(" myind.%d myaddr.(%s %s)\n",myind,srcaddr,destaddr); if ( myind == 0 && bits256_nonz(destprevtxid0) != 0 && bits256_nonz(srcprevtxid0) != 0 && destprevvout0 >= 0 && srcprevvout0 >= 0 ) { ep->dest.prev_hash = destprevtxid0; ep->dest.prev_vout = destprevvout0; ep->src.prev_hash = srcprevtxid0; ep->src.prev_vout = srcprevvout0; bp->notaries[myind].ratifysrcutxo = srcprevtxid0; bp->notaries[myind].ratifysrcvout = srcprevvout0; bp->notaries[myind].ratifydestutxo = destprevtxid0; bp->notaries[myind].ratifydestvout = destprevvout0; printf("Use override utxo %s/v%d %s/v%d\n",bits256_str(str,destprevtxid0),destprevvout0,bits256_str(str2,srcprevtxid0),srcprevvout0); } else { if ( dpow_checkutxo(myinfo,dp,bp,bp->destcoin,&ep->dest.prev_hash,&ep->dest.prev_vout,destaddr) < 0 ) { printf("dont have %s %s utxo, please send funds\n",dp->dest,destaddr); free(ptr); dp->ratifying -= bp->isratify; return; } if ( dpow_checkutxo(myinfo,dp,bp,bp->srccoin,&ep->src.prev_hash,&ep->src.prev_vout,srcaddr) < 0 ) { printf("dont have %s %s utxo, please send funds\n",dp->symbol,srcaddr); free(ptr); dp->ratifying -= bp->isratify; return; } if ( bp->isratify != 0 ) { bp->notaries[myind].ratifysrcutxo = ep->src.prev_hash; bp->notaries[myind].ratifysrcvout = ep->src.prev_vout; bp->notaries[myind].ratifydestutxo = ep->dest.prev_hash; bp->notaries[myind].ratifydestvout = ep->dest.prev_vout; } } bp->recvmask |= (1LL << myind); bp->notaries[myind].othermask |= (1LL << myind); dp->checkpoint = checkpoint; bp->height = checkpoint.blockhash.height; bp->timestamp = checkpoint.timestamp; bp->hashmsg = checkpoint.blockhash.hash; bp->myind = myind; while ( bp->isratify == 0 && dp->destupdated == 0 ) { if ( dp->checkpoint.blockhash.height > checkpoint.blockhash.height ) { printf("abort %s ht.%d due to new checkpoint.%d\n",dp->symbol,checkpoint.blockhash.height,dp->checkpoint.blockhash.height); dp->ratifying -= bp->isratify; return; } sleep(1); } starttime = (uint32_t)time(NULL); if ( bp->isratify == 0 ) { //if ( (starttime= checkpoint.timestamp) == 0 ) bp->starttime = starttime; extralen = dpow_paxpending(extras,&bp->paxwdcrc); bp->notaries[bp->myind].paxwdcrc = bp->paxwdcrc; } printf("PAXWDCRC.%x myind.%d isratify.%d DPOW.%s statemachine checkpoint.%d %s start.%u+dur.%d vs %ld\n",bp->paxwdcrc,bp->myind,bp->isratify,src->symbol,checkpoint.blockhash.height,bits256_str(str,checkpoint.blockhash.hash),starttime,bp->duration,time(NULL)); for (i=0; i<sizeof(srchash); i++) srchash.bytes[i] = dp->minerkey33[i+1]; //printf("start utxosync start.%u %u\n",starttime,(uint32_t)time(NULL)); //dpow_utxosync(myinfo,dp,bp,0,myind,srchash); //printf("done utxosync start.%u %u\n",starttime,(uint32_t)time(NULL)); while ( time(NULL) < starttime+bp->duration && src != 0 && dest != 0 && bp->state != 0xffffffff ) { if ( bp->isratify == 0 ) { if ( myinfo->DPOWS[0].ratifying != 0 ) { printf("break due to already ratifying\n"); break; } extralen = dpow_paxpending(extras,&bp->paxwdcrc); bp->notaries[bp->myind].paxwdcrc = bp->paxwdcrc; } sleep(13); if ( dp->checkpoint.blockhash.height > checkpoint.blockhash.height ) { if ( bp->isratify == 0 ) { printf("abort %s ht.%d due to new checkpoint.%d\n",dp->symbol,checkpoint.blockhash.height,dp->checkpoint.blockhash.height); break; } } if ( dp->ratifying > 1 ) { printf("new ratification started. abort ht.%d\n",bp->height); break; } if ( bp->isratify == 0 ) { bits256 checkhash; checkhash = dpow_getblockhash(myinfo,bp->srccoin,bp->height); if ( bits256_cmp(checkhash,bp->hashmsg) != 0 ) { printf("%s ht.%d %s got reorged to %s, abort notarization\n",bp->srccoin->symbol,bp->height,bits256_str(str,bp->hashmsg),bits256_str(str2,checkhash)); bp->state = 0xffffffff; } } if ( bp->state != 0xffffffff ) { dpow_send(myinfo,dp,bp,srchash,bp->hashmsg,0,bp->height,(void *)"ping",0); dpow_nanomsg_update(myinfo); } else { dp->lastnotarized = checkpoint.blockhash.hash; printf("notarized %s %s\n",dp->symbol,bits256_str(str,checkpoint.blockhash.hash)); } if ( 0 && dp->cancelratify != 0 && bp->isratify != 0 ) { printf("abort pending ratify\n"); break; } } printf("END isratify.%d:%d bestk.%d %llx sigs.%llx state.%x machine ht.%d completed state.%x %s.%s %s.%s recvmask.%llx paxwdcrc.%x %p %p\n",bp->isratify,dp->ratifying,bp->bestk,(long long)bp->bestmask,(long long)(bp->bestk>=0?bp->destsigsmasks[bp->bestk]:0),bp->state,bp->height,bp->state,dp->dest,bits256_str(str,bp->desttxid),dp->symbol,bits256_str(str2,bp->srctxid),(long long)bp->recvmask,bp->paxwdcrc,src,dest); bp->state = 0xffffffff; dp->lastrecvmask = bp->recvmask; dp->ratifying -= bp->isratify; dp->blocks[bp->height] = 0; free(ptr); }
int32_t gecko_blocknonce_verify(struct iguana_info *virt,uint8_t *serialized,int32_t datalen,uint32_t nBits,uint32_t timestamp,uint32_t prevtimestamp) { bits256 threshold,hash2; //printf("time.%u prev.%u\n",timestamp,prevtimestamp); if ( timestamp != 0 && prevtimestamp != 0 ) { if ( prevtimestamp != 0 && timestamp < gecko_earliest_blocktime(virt->chain->estblocktime,prevtimestamp) ) { printf("reject timestamp prev.%u %u earliest.%u\n",prevtimestamp,timestamp,gecko_earliest_blocktime(virt->chain->estblocktime,prevtimestamp)); return(-1); } if ( timestamp > time(NULL) + GECKO_MAXFUTUREBLOCK ) { printf("reject future timestamp.%u vs %u\n",timestamp,(uint32_t)time(NULL)); return(-1); } } if ( nBits >= GECKO_EASIESTDIFF ) nBits = GECKO_EASIESTDIFF; threshold = bits256_from_compact(nBits); hash2 = iguana_calcblockhash(virt->symbol,virt->chain->hashalgo,serialized,datalen); if ( bits256_cmp(threshold,hash2) > 0 ) { //printf("nonce worked crc.%x\n",calc_crc32(0,serialized,datalen)); return(1); } else { char str[65],str2[65]; printf("nonce failed crc.%x nBits.%08x %s vs %s\n",calc_crc32(0,serialized,datalen),nBits,bits256_str(str,threshold),bits256_str(str2,hash2)); } return(-1); }
void gecko_miner(struct supernet_info *myinfo,struct iguana_info *btcd,struct iguana_info *virt,int32_t maxmillis,uint8_t *minerpubkey33) { struct iguana_zblock newblock; uint32_t prevtimestamp,nBits; int64_t reward = 0; int32_t txn_count; char *blockstr,*space[256]; struct gecko_memtx **txptrs; void *ptr; //struct iguana_bundle *bp; #ifndef __APPLE__ int32_t i,gap; if ( virt->virtualchain == 0 || RELAYID < 0 || NUMRELAYS < 1 ) { //printf("skip non-virtual chain.%s\n",virt->symbol); return; } if ( virt->blocks.hwmchain.height < virt->longestchain-1 ) return; if ( (virt->blocks.hwmchain.height % NUMRELAYS) != RELAYID ) { //if ( NUMRELAYS < 3 ) // return; gap = (int32_t)(time(NULL) - virt->blocks.hwmchain.RO.timestamp) / 60;//virt->chain->estblocktime; for (i=0; i<gap; i++) { if ( ((virt->blocks.hwmchain.height+i) % NUMRELAYS) == RELAYID ) break; } if ( i == gap ) return; printf("backup block generator RELAYID.%d gap.%d ht.%d i.%d num.%d\n",RELAYID,gap,virt->blocks.hwmchain.height,i,NUMRELAYS); } #endif /*if ( virt->newblockstr != 0 ) { gecko_blocksubmit(myinfo,btcd,virt,virt->newblockstr,virt->newblock.RO.hash2,virt->newblock.height); memset(&virt->newblock,0,sizeof(virt->newblock)); free(virt->newblockstr); virt->newblockstr = 0; return; }*/ memset(&newblock,0,sizeof(newblock)); newblock.height = virt->blocks.hwmchain.height + 1; newblock.RO.prev_block = virt->blocks.hwmchain.RO.hash2; newblock.RO.version = GECKO_DEFAULTVERSION; newblock.RO.allocsize = iguana_ROallocsize(virt); if ( (nBits= gecko_nBits(virt,&prevtimestamp,(void *)&newblock,GECKO_DIFFITERS)) != 0 ) { if ( (newblock.RO.bits= nBits) > GECKO_EASIESTDIFF ) newblock.RO.bits = GECKO_EASIESTDIFF; char str[65]; printf("mine.%s %s nBits.%x ht.%d maxmillis.%d\n",virt->symbol,bits256_str(str,bits256_from_compact(newblock.RO.bits)),nBits,newblock.height,maxmillis); txptrs = gecko_mempool_txptrs(myinfo,virt,&reward,&txn_count,&ptr,space,(int32_t)(sizeof(space)/sizeof(*space)),newblock.height); //char str[65]; printf("HWM.%s %p\n",bits256_str(str,newblock.RO.prev_block),&newblock.RO.prev_block); if ( (blockstr= gecko_createblock(myinfo,virt->chain->estblocktime,prevtimestamp,btcd,virt->chain->isPoS,(void *)&newblock,virt->symbol,txptrs,txn_count,maxmillis,minerpubkey33,reward)) != 0 ) { char str[65]; printf("tx0.%s\n",bits256_str(str,newblock.RO.merkle_root)); printf(">>>>>>>>>>>>>>>>> MINED %s.%x %s %u %d %.8f %d\n",virt->symbol,newblock.RO.bits,bits256_str(str,newblock.RO.hash2),newblock.RO.timestamp,newblock.height,dstr(reward),newblock.RO.txn_count); if ( gecko_blocksubmit(myinfo,btcd,virt,blockstr,newblock.RO.hash2,newblock.height) == 0 ) free(blockstr); else { //virt->newblockstr = blockstr; //virt->newblock = newblock; free(blockstr); } } else printf("didnt find %s.block\n",virt->symbol); if ( txptrs != (void *)space ) free(txptrs); } }
int32_t iguana_headerget(struct iguana_info *coin,uint8_t *serialized,int32_t maxsize,struct iguana_block *block) { bits256 checkhash2; struct iguana_msgblock msgB; int32_t len = 0; iguana_blockunconv(coin->chain->zcash,coin->chain->auxpow,&msgB,block,1); if ( (len= iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&checkhash2,&serialized[sizeof(struct iguana_msghdr)],&msgB,(int32_t)(maxsize-sizeof(struct iguana_msghdr)))) < 0 ) return(-1); if ( bits256_cmp(checkhash2,block->RO.hash2) != 0 ) { char str[65],str2[65]; printf("iguana_peerhdrrequest blockhash.%d error (%s) vs (%s)\n",block->height,bits256_str(str,checkhash2),bits256_str(str2,block->RO.hash2)); return(-1); } return(len); }
char *basilisk_respond_OUT(struct supernet_info *myinfo,char *CMD,void *addr,char *remoteaddr,uint32_t basilisktag,cJSON *valsobj,uint8_t *data,int32_t datalen,bits256 hash,int32_t from_basilisk) { int32_t keylen; uint8_t key[64]; keylen = basilisk_messagekey(key,hash,valsobj); //printf("keylen.%d datalen.%d\n",keylen,datalen); char str[65]; printf("add message.[%d] channel.%u msgid.%x %s\n",datalen,juint(valsobj,"channel"),juint(valsobj,"msgid"),bits256_str(str,hash)); return(basilisk_respond_addmessage(myinfo,key,keylen,data,datalen,1)); }
int32_t bitcoin_addr2rmd160(uint8_t *addrtypep,uint8_t rmd160[20],char *coinaddr) { bits256 hash; uint8_t *buf,_buf[25]; int32_t len; memset(rmd160,0,20); *addrtypep = 0; buf = _buf; if ( (len= bitcoin_base58decode(buf,coinaddr)) >= 4 ) { // validate with trailing hash, then remove hash hash = bits256_doublesha256(0,buf,21); *addrtypep = *buf; memcpy(rmd160,buf+1,20); if ( (buf[21]&0xff) == hash.bytes[31] && (buf[22]&0xff) == hash.bytes[30] &&(buf[23]&0xff) == hash.bytes[29] && (buf[24]&0xff) == hash.bytes[28] ) { //printf("coinaddr.(%s) valid checksum addrtype.%02x\n",coinaddr,*addrtypep); return(20); } else { int32_t i; if ( len > 20 ) { hash = bits256_doublesha256(0,buf,len); } for (i=0; i<len; i++) printf("%02x ",buf[i]); char str[65]; printf("\nhex checkhash.(%s) len.%d mismatch %02x %02x %02x %02x vs %02x %02x %02x %02x (%s)\n",coinaddr,len,buf[len-1]&0xff,buf[len-2]&0xff,buf[len-3]&0xff,buf[len-4]&0xff,hash.bytes[31],hash.bytes[30],hash.bytes[29],hash.bytes[28],bits256_str(str,hash)); } } return(0); }
void jaddbits256(cJSON *json,char *field,bits256 hash) { char str[65]; bits256_str(str,hash), jaddstr(json,field,str); }
uint32_t basilisk_calcnonce(struct supernet_info *myinfo,uint8_t *data,int32_t datalen,uint32_t nBits) { int32_t i,numiters = 0; bits256 hash,hash2,threshold; uint32_t basilisktag; vcalc_sha256(0,hash.bytes,data,datalen); if ( nBits >= GECKO_EASIESTDIFF ) threshold = bits256_from_compact(GECKO_EASIESTDIFF); else threshold = bits256_from_compact(nBits); for (i=0; i<numiters; i++) { //OS_randombytes((void *)hash.uints,sizeof(basilisktag)); hash.uints[0] = rand(); vcalc_sha256(0,hash2.bytes,hash.bytes,sizeof(hash)); if ( bits256_cmp(threshold,hash2) > 0 ) break; } iguana_rwnum(0,(void *)hash.uints,sizeof(basilisktag),&basilisktag); iguana_rwnum(1,&data[-sizeof(basilisktag)],sizeof(basilisktag),&basilisktag); char str[65],str2[65]; printf("found hash after numiters.%d %s vs %s basilisktag.%u\n",numiters,bits256_str(str,threshold),bits256_str(str2,hash2),basilisktag); return(basilisktag); }
int32_t iguana_process_msgrequestQ(struct supernet_info *myinfo,struct iguana_info *coin) { struct iguana_peermsgrequest *msg; int32_t height,len,flag = 0; bits256 checktxid; struct iguana_txid *tx,T; struct iguana_peer *addr; if ( (msg= queue_dequeue(&coin->msgrequestQ,0)) != 0 ) { flag = 1; if ( msg->addr != 0 ) { //char str[65]; printf("send type.%d %s -> (%s)\n",msg->type,bits256_str(str,msg->hash2),msg->addr->ipaddr); if ( msg->type == MSG_BLOCK ) { if ( coin->RELAYNODE != 0 || coin->VALIDATENODE != 0 ) { if ( (addr= msg->addr) != 0 && (len= iguana_peerblockrequest(coin,coin->blockspace,(int32_t)(coin->blockspacesize - sizeof(struct iguana_msghdr)),0,msg->hash2,0)) > 0 ) { //char str[65]; printf("msg Sendlen.%d block %s to %s\n",len,bits256_str(str,msg->hash2),addr->ipaddr); iguana_queue_send(addr,0,coin->blockspace,"block",len); } } } else if ( msg->type == MSG_TX ) { if ( coin->RELAYNODE != 0 || coin->VALIDATENODE ) { if ( (tx= iguana_txidfind(coin,&height,&T,msg->hash2,coin->bundlescount-1)) != 0 ) { if ( (len= iguana_ramtxbytes(coin,&coin->blockspace[sizeof(struct iguana_msghdr)],coin->blockspacesize,&checktxid,tx,height,0,0,0)) > 0 ) { char str[65],str2[65]; if ( bits256_cmp(msg->hash2,checktxid) == 0 ) iguana_queue_send(msg->addr,0,coin->blockspace,"block",len); else printf("checktxid mismatch (%s) != (%s)\n",bits256_str(str,msg->hash2),bits256_str(str2,checktxid)); } } } } else if ( msg->type == MSG_FILTERED_BLOCK ) { } else if ( msg->type == MSG_BUNDLE_HEADERS ) { } else if ( msg->type == MSG_BUNDLE ) { } /*else if ( msg->type == MSG_QUOTE ) { if ( (len= instantdex_quoterequest(myinfo,coin,&coin->blockspace[sizeof(struct iguana_msghdr)],coin->blockspacesize,msg->addr,msg->hash2)) > 0 ) { //iguana_sethdr((void *)coin->blockspace,coin->chain->netmagic,"quote",&coin->blockspace[sizeof(struct iguana_msghdr)],len); //iguana_msgparser(coin,msg->addr,0,0,0,(void *)coin->blockspace,&coin->blockspace[sizeof(struct iguana_msghdr)],len); iguana_queue_send(msg->addr,0,coin->blockspace,"quote",len); } }*/ } free(msg); } return(flag); }