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);
}
int32_t bitcoin_wif2priv(uint8_t *addrtypep,bits256 *privkeyp,char *wifstr)
{
int32_t len = -1; bits256 hash; uint8_t buf[256];
memset(buf,0,sizeof(buf));
if ( (len= bitcoin_base58decode(buf,wifstr)) >= 4 )
{
// validate with trailing hash, then remove hash
if ( len < 38 )
len = 38;
hash = bits256_doublesha256(0,buf,len - 4);
*addrtypep = *buf;
memcpy(privkeyp,buf+1,32);
if ( (buf[len - 4]&0xff) == hash.bytes[31] && (buf[len - 3]&0xff) == hash.bytes[30] &&(buf[len - 2]&0xff) == hash.bytes[29] && (buf[len - 1]&0xff) == hash.bytes[28] )
{
//int32_t i; for (i=0; i<len; i++)
// printf("%02x ",buf[i]);
//printf(" buf, hash.%02x %02x %02x %02x ",hash.bytes[28],hash.bytes[29],hash.bytes[30],hash.bytes[31]);
//printf("wifstr.(%s) valid len.%d\n",wifstr,len);
return(32);
}
else
{
int32_t i; for (i=0; i<len; i++)
printf("%02x ",buf[i]);
printf(" buf, hash.%02x %02x %02x %02x\n",hash.bytes[28],hash.bytes[29],hash.bytes[30],hash.bytes[31]);
}
}
return(-1);
}
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);
}
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);
}
int32_t base58encode_checkbuf(uint8_t addrtype,uint8_t *data,int32_t data_len)
{
uint8_t i; bits256 hash;
data[0] = addrtype;
//for (i=0; i<data_len+1; i++)
// printf("%02x",data[i]);
//printf(" extpriv -> ");
hash = bits256_doublesha256(0,data,(int32_t)data_len+1);
//for (i=0; i<32; i++)
// printf("%02x",hash.bytes[i]);
//printf(" checkhash\n");
for (i=0; i<4; i++)
data[data_len+i+1] = hash.bytes[31-i];
return(data_len + 5);
}
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 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 ( msg->tx_in > 0 && msg->tx_out*100 < maxsize )
{
if ( rwflag == 0 )
msg->vins = iguana_memalloc(mem,msg->tx_in * sizeof(*msg->vins),1);
for (i=0; i<msg->tx_in; i++)
len += iguana_rwvin(rwflag,mem,&serialized[len],&msg->vins[i]);
//printf("numvins.%d\n",msg->tx_in);
}
else
{
printf("invalid tx_in.%d\n",msg->tx_in);
return(-1);
}
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->tx_out);
if ( msg->tx_out > 0 && msg->tx_out*32 < maxsize )
{
//printf("numvouts.%d ",msg->tx_out);
if ( rwflag == 0 )
msg->vouts = iguana_memalloc(mem,msg->tx_out * sizeof(*msg->vouts),1);
for (i=0; i<msg->tx_out; i++)
len += iguana_rwvout(rwflag,mem,&serialized[len],&msg->vouts[i]);
}
else
{
printf("invalid tx_out.%d\n",msg->tx_out);
return(-1);
}
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->lock_time),&msg->lock_time);
if ( isvpncoin != 0 )
{
uint16_t ddosflag=0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(ddosflag),&ddosflag);
for (; serialized[len]!=0&&len<maxsize; len++) // eat null terminated string
;
}
*txidp = bits256_doublesha256(txidstr,txstart,len);
msg->allocsize = len;
return(len);
}
int32_t iguana_sethdr(struct iguana_msghdr *H,const uint8_t netmagic[4],char *command,uint8_t *data,int32_t datalen)
{
bits256 hash2,tmp; int32_t i;
memset(H,0,sizeof(*H));
memcpy(H->netmagic,netmagic,4);
strncpy(H->command,command,12);
iguana_rwnum(1,H->serdatalen,sizeof(int32_t),&datalen);
if ( data != 0 && datalen != 0 )
{
hash2 = bits256_doublesha256(0,data,datalen);
iguana_rwbignum(1,tmp.bytes,sizeof(tmp),hash2.bytes);
for (i=0; i<4; i++)
H->hash[i] = tmp.bytes[i];
}
else H->hash[0] = 0x5d, H->hash[1] = 0xf6, H->hash[2] = 0xe0, H->hash[3] = 0xe2;
return(datalen + sizeof(*H));
}
int32_t iguana_rwtx(int32_t rwflag,uint8_t *serialized,struct iguana_msgtx *msg,int32_t maxsize,bits256 *txidp,int32_t height,int32_t hastimestamp)
{
int32_t i,len = 0; uint8_t *txstart = serialized; char txidstr[65]; uint32_t timestamp;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->version),&msg->version);
if ( hastimestamp != 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(timestamp),×tamp);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->tx_in);
//printf("version.%d ",msg->version);
if ( msg->tx_in > 0 && msg->tx_out*100 < maxsize )
{
if ( rwflag == 0 )
msg->vins = mycalloc('v',msg->tx_in,sizeof(*msg->vins));
for (i=0; i<msg->tx_in; i++)
len += iguana_rwvin(rwflag,&serialized[len],&msg->vins[i]);
//printf("numvins.%d\n",msg->tx_in);
}
else
{
printf("invalid tx_in.%d\n",msg->tx_in);
return(-1);
}
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->tx_out);
if ( msg->tx_out > 0 && msg->tx_out*32 < maxsize )
{
//printf("numvouts.%d ",msg->tx_out);
if ( rwflag == 0 )
msg->vouts = mycalloc('v',msg->tx_out,sizeof(*msg->vouts));
for (i=0; i<msg->tx_out; i++)
len += iguana_rwvout(rwflag,&serialized[len],&msg->vouts[i]);
}
else
{
printf("invalid tx_out.%d\n",msg->tx_out);
return(-1);
}
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->lock_time),&msg->lock_time);
*txidp = bits256_doublesha256(txidstr,txstart,len);
//printf("txid.(%s) len.%d\n",bits256_str(*txidp),len);
msg->allocsize = len;
Tx_allocated++, Tx_allocsize += len;
if ( ((Tx_allocated + Tx_freed) % 10000000) == 0 )
printf("h.%u len.%d (%llu - %llu) %lld (%llu - %llu)\n",height,len,(long long)Tx_allocated,(long long)Tx_freed,(long long)(Tx_allocated - Tx_freed),(long long)Tx_allocsize,(long long)Tx_freesize);
return(len);
}
char *bitcoin_address(char *coinaddr,uint8_t addrtype,uint8_t *pubkey_or_rmd160,int32_t len)
{
int32_t i; uint8_t data[25]; bits256 hash;// char checkaddr[65];
if ( len != 20 )
calc_rmd160_sha256(data+1,pubkey_or_rmd160,len);
else memcpy(data+1,pubkey_or_rmd160,20);
//btc_convrmd160(checkaddr,addrtype,data+1);
data[0] = addrtype;
hash = bits256_doublesha256(0,data,21);
for (i=0; i<4; i++)
data[21+i] = hash.bytes[31-i];
if ( (coinaddr= bitcoin_base58encode(coinaddr,data,25)) != 0 )
{
//uint8_t checktype,rmd160[20];
//bitcoin_addr2rmd160(&checktype,rmd160,coinaddr);
//if ( strcmp(checkaddr,coinaddr) != 0 )
// printf("checkaddr.(%s) vs coinaddr.(%s) %02x vs [%02x] memcmp.%d\n",checkaddr,coinaddr,addrtype,checktype,memcmp(rmd160,data+1,20));
}
return(coinaddr);
}
int32_t iguana_coinbase(int32_t isPoS,uint32_t txversion,uint8_t *serialized,uint32_t timestamp,bits256 prev_hash,uint8_t *coinbasescript,uint32_t coinbaselen,uint8_t *minerpayment,uint32_t minerpaymentlen,int64_t blockreward,bits256 *txidp)
{
int32_t len = 0,rwflag=1; uint32_t prev_vout,sequence,lock_time; char txidstr[65]; struct iguana_msgtx msg;
memset(&msg,0,sizeof(msg));
msg.tx_out = (blockreward > 0) ? 1 : 0;
msg.tx_in = 1;
sequence = prev_vout = -1;
lock_time = 0;
msg.version = txversion;
msg.timestamp = timestamp;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg.version),&msg.version);
if ( isPoS != 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg.timestamp),&msg.timestamp);
{
len += iguana_rwvarint32(rwflag,&serialized[len],&msg.tx_in);
// tx_in times
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(prev_hash),prev_hash.bytes);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(prev_vout),&prev_vout);
len += iguana_rwvarint32(rwflag,&serialized[len],&coinbaselen);
len += iguana_rwmem(rwflag,&serialized[len],coinbaselen,coinbasescript);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(sequence),&sequence);
}
{
len += iguana_rwvarint32(rwflag,&serialized[len],&msg.tx_out);
// tx_out times
if ( msg.tx_out > 0 )
{
len += iguana_rwnum(rwflag,&serialized[len],sizeof(blockreward),&blockreward);
len += iguana_rwvarint32(rwflag,&serialized[len],&minerpaymentlen);
len += iguana_rwmem(rwflag,&serialized[len],minerpaymentlen,minerpayment);
}
}
len += iguana_rwnum(rwflag,&serialized[len],sizeof(lock_time),&lock_time);
*txidp = bits256_doublesha256(txidstr,serialized,len);
return(len);
}
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)
{
int32_t i,rwflag=1,len = 0; char asmstr[512],txidstr[65];
uint32_t numvins,numvouts,version,locktime,timestamp=0; struct iguana_msgvin vin; struct iguana_msgvout vout; uint8_t space[IGUANA_MAXSCRIPTSIZE];
if ( rwflag != 0 )
{
version = tx->version;
locktime = tx->locktime;
timestamp = tx->timestamp;
numvins = tx->numvins;
numvouts = tx->numvouts;
}
len += iguana_rwnum(rwflag,&serialized[len],sizeof(version),&version);
if ( coin->chain->isPoS != 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(timestamp),×tamp);
len += iguana_rwvarint32(rwflag,&serialized[len],&numvins);
memset(&vin,0,sizeof(vin));
for (i=0; i<numvins; i++)
{
if ( vins == 0 )
{
if ( iguana_vinset(coin,space,height,&vin,tx,i) < 0 )
{
printf("iguana_ramtxbytes vinset error %d of %d\n",i,numvins);
return(0);
}
} else vin = vins[i];
len += iguana_rwvin(rwflag,coin,0,&serialized[len],&vin,i);
if ( len > maxlen )
break;
}
if ( len > maxlen )
{
printf("len.%d > maxlen.%d\n",len,maxlen);
return(0);
}
len += iguana_rwvarint32(rwflag,&serialized[len],&numvouts);
for (i=0; i<numvouts; i++)
{
if ( vouts == 0 )
{
if ( iguana_voutset(coin,space,asmstr,height,&vout,tx,i) < 0 )
{
static uint32_t counter;
if ( counter++ < 10 )
printf("iguana_ramtxbytes voutset error %d of %d\n",i,numvouts);
return(0);
}
} else vout = vouts[i];
len += iguana_rwvout(rwflag,0,&serialized[len],&vout);
if ( len > maxlen )
break;
}
if ( len > maxlen )
{
printf("len.%d > maxlenB.%d\n",len,maxlen);
return(0);
}
len += iguana_rwnum(rwflag,&serialized[len],sizeof(locktime),&locktime);
if ( rwflag == 0 )
{
tx->version = version;
tx->timestamp = timestamp;
tx->numvins = numvins;
tx->numvouts = numvouts;
tx->locktime = locktime;
}
*txidp = bits256_doublesha256(txidstr,serialized,len);
if ( memcmp(txidp,tx->txid.bytes,sizeof(*txidp)) != 0 )
{
for (i=0; i<len; i++)
printf("%02x",serialized[i]);
char str[65],str2[65]; printf("\nrw.%d numvins.%d numvouts.%d error generating txbytes txid %s vs %s\n",rwflag,numvins,numvouts,bits256_str(str,*txidp),bits256_str(str2,tx->txid));
return(-1);
}
return(len);
}
