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 iguana_send_ConnectTo(struct iguana_info *coin,struct iguana_peer *addr)
{
int32_t len; uint32_t r; uint16_t port = 1920; uint8_t serialized[sizeof(struct iguana_msghdr) + 6];
r = rand();
len = iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)],sizeof(uint32_t),&r);
len += iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)+len],sizeof(port),&port);
return(iguana_queue_send(coin,addr,0,serialized,"ConnectTo",len,0,0));
}
int32_t basilisk_messagekey(uint8_t *key,bits256 hash,cJSON *valsobj)
{
uint32_t channel,msgid; int32_t keylen = 0;
channel = juint(valsobj,"channel");
msgid = juint(valsobj,"msgid");
keylen += iguana_rwbignum(1,&key[keylen],sizeof(hash),hash.bytes);
keylen += iguana_rwnum(1,&key[keylen],sizeof(uint32_t),&channel);
keylen += iguana_rwnum(1,&key[keylen],sizeof(uint32_t),&msgid);
return(keylen);
}
void iguana_gotaddr(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_msgaddress *A)
{
char ipaddr[64],ipport[64]; uint32_t ipbits; uint16_t port;
iguana_rwnum(0,&A->ip[12],sizeof(uint32_t),&ipbits);
iguana_rwnum(0,(void *)&A->port,sizeof(uint16_t),&port);
expand_ipbits(ipaddr,ipbits);
if ( port != 0 )
sprintf(ipport,"%s:%d",ipaddr,port);
iguana_possible_peer(coin,ipport);
//printf("gotaddr.(%s:%d)\n",ipaddr,port);
}
int32_t iguana_peergetrequest(struct iguana_info *coin,struct iguana_peer *addr,uint8_t *data,int32_t recvlen,int32_t getblock)
{
int32_t i,reqvers,len,n,flag = 0;
bits256 hash2;
if ( getblock != 0 )
addr->msgcounts.getblocks++;
else addr->msgcounts.getheaders++;
len = iguana_rwnum(0,&data[0],sizeof(uint32_t),&reqvers);
len += iguana_rwvarint32(0,&data[len],(uint32_t *)&n);
for (i=0; i<n&&len<=recvlen-sizeof(bits256)*2; i++)
{
len += iguana_rwbignum(0,&data[len],sizeof(bits256),hash2.bytes);
if ( bits256_nonz(hash2) == 0 )
break;
if ( flag == 0 )
{
if ( getblock != 0 && iguana_peerblockrequest(coin,addr->blockspace,IGUANA_MAXPACKETSIZE,addr,hash2,0) > 0 )
flag = 1;
else if ( getblock == 0 && iguana_peerhdrrequest(coin,addr->blockspace,IGUANA_MAXPACKETSIZE,addr,hash2) > 0 )
flag = 1;
}
}
len += iguana_rwbignum(0,&data[len],sizeof(bits256),hash2.bytes);
//for (i=0; i<69; i++)
// printf("%02x ",data[i]);
//printf("version.%d num blocks.%d recvlen.%d len.%d\n",reqvers,n,recvlen,len);
return(len);
}
int32_t iguana_rwaddr(int32_t rwflag,uint8_t *serialized,struct iguana_msgaddress *addr,int32_t protover)
{
int32_t len = 0;
if ( protover >= CADDR_TIME_VERSION )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(addr->nTime),&addr->nTime);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(addr->nServices),&addr->nServices);
len += iguana_rwmem(rwflag,&serialized[len],sizeof(addr->ip),&addr->ip);
if ( rwflag != 0 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(addr->port),&addr->port);
else
{
addr->port = (uint16_t)serialized[len++] << 8;
addr->port += (uint16_t)serialized[len++];
}
return(len);
}
int32_t basilisk_ping_genMSG(struct supernet_info *myinfo,uint8_t *data,int32_t maxlen)
{
struct basilisk_message *msg; int32_t datalen = 0;
if ( maxlen > sizeof(msg->key) && (msg= queue_dequeue(&myinfo->msgQ,0)) != 0 ) // oneshot ping
{
data[datalen++] = 1;
data[datalen++] = msg->keylen;
memcpy(&data[datalen],msg->key,msg->keylen), datalen += msg->keylen;
datalen += iguana_rwnum(1,&data[datalen],sizeof(msg->datalen),&msg->datalen);
if ( maxlen > datalen+msg->datalen )
{
//printf("SEND keylen.%d msglen.%d\n",msg->keylen,msg->datalen);
memcpy(&data[datalen],msg->data,msg->datalen), datalen += msg->datalen;
}
else
{
printf("basilisk_ping_genMSG message doesnt fit %d vs %d\n",maxlen,datalen+msg->datalen);
datalen = 0;
}
//printf("\n-> ");
//int32_t i;
//for (i=0; i<datalen; i++)
// printf("%02x",data[i]);
//printf(" <- genMSG\n");
} else data[datalen++] = 0;
return(datalen);
}
int32_t iguana_rwvin(int32_t rwflag,struct OS_memspace *mem,uint8_t *serialized,struct iguana_msgvin *msg)
{
int32_t len = 0;
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->prev_hash),msg->prev_hash.bytes);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->prev_vout),&msg->prev_vout);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->scriptlen);
if ( rwflag == 0 )
msg->script = iguana_memalloc(mem,msg->scriptlen,1);
len += iguana_rwmem(rwflag,&serialized[len],msg->scriptlen,msg->script);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->sequence),&msg->sequence);
//char str[65]; printf("MSGvin.(%s/v%d) script[%d]\n",bits256_str(str,msg->prev_hash),msg->prev_vout,msg->scriptlen);
//int i; for (i=0; i<msg->scriptlen; i++)
// printf("%02x ",msg->script[i]);
//printf(" inscriptlen.%d, prevhash.%llx prev_vout.%d | ",msg->scriptlen,(long long)msg->prev_hash.txid,msg->prev_vout);
return(len);
}
// two passes to check data size
int32_t iguana_rwvin(int32_t rwflag,uint8_t *serialized,struct iguana_msgvin *msg)
{
int32_t len = 0;
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(msg->prev_hash),msg->prev_hash.bytes);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->prev_vout),&msg->prev_vout);
//printf("vin.(%s) %d\n",bits256_str(msg->prev_hash),msg->prev_vout);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->scriptlen);
if ( rwflag == 0 )
msg->script = mycalloc('s',1,msg->scriptlen);
len += iguana_rwmem(rwflag,&serialized[len],msg->scriptlen,msg->script);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->sequence),&msg->sequence);
//int i; for (i=0; i<msg->scriptlen; i++)
// printf("%02x ",msg->script[i]);
//printf(" inscriptlen.%d, prevhash.%llx prev_vout.%d | ",msg->scriptlen,(long long)msg->prev_hash.txid,msg->prev_vout);
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 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);
}
void iguana_gotaddr(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_msgaddress *A)
{
char ipaddr[64]; uint32_t ipbits;
iguana_rwnum(0,&A->ip[12],sizeof(uint32_t),&ipbits);
expand_ipbits(ipaddr,ipbits);
iguana_possible_peer(coin,ipaddr);
//printf("gotaddr.(%s)\n",ipaddr);
}
void iguana_gotping(struct iguana_info *coin,struct iguana_peer *addr,uint64_t nonce,uint8_t *data)
{
int32_t len; uint8_t serialized[sizeof(struct iguana_msghdr) + sizeof(nonce)];
len = iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)],sizeof(uint64_t),&nonce);
if ( memcmp(data,&serialized[sizeof(struct iguana_msghdr)],sizeof(nonce)) != 0 )
printf("ping ser error %llx != %llx\n",(long long)nonce,*(long long *)data);
iguana_queue_send(coin,addr,serialized,"pong",len,0,0);
//iguana_queue_send(coin,addr,serialized,"getaddr",0,0,0);
}
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);
}
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_getdata(struct iguana_info *coin,uint8_t *serialized,int32_t type,char *hashstr)
{
uint32_t len,i,n=1; bits256 hash2;
decode_hex(hash2.bytes,sizeof(hash2),hashstr);
len = iguana_rwvarint32(1,&serialized[sizeof(struct iguana_msghdr)],(uint32_t *)&n);
for (i=0; i<n; i++)
{
len += iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr) + len],sizeof(uint32_t),&type);
len += iguana_rwbignum(1,&serialized[sizeof(struct iguana_msghdr) + len],sizeof(bits256),hash2.bytes);
}
return(iguana_sethdr((void *)serialized,coin->chain->netmagic,"getdata",&serialized[sizeof(struct iguana_msghdr)],len));
}
int32_t iguana_gethdrs(struct iguana_info *coin,uint8_t *serialized,char *cmd,char *hashstr)
{
uint32_t len,n; bits256 hash2;
decode_hex(hash2.bytes,sizeof(hash2),hashstr);
n = 0;
len = iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)],sizeof(uint32_t),&n);
n++;
len += iguana_rwvarint32(1,&serialized[sizeof(struct iguana_msghdr) + len],(uint32_t *)&n);
len += iguana_rwbignum(1,&serialized[sizeof(struct iguana_msghdr) + len],sizeof(bits256),hash2.bytes);
len += iguana_rwbignum(1,&serialized[sizeof(struct iguana_msghdr) + len],sizeof(bits256),(uint8_t *)bits256_zero.bytes);
return(iguana_sethdr((void *)serialized,coin->chain->netmagic,cmd,&serialized[sizeof(struct iguana_msghdr)],len));
}
void iguana_gotping(struct iguana_info *coin,struct iguana_peer *addr,uint64_t nonce,uint8_t *data)
{
int32_t len; uint8_t serialized[sizeof(struct iguana_msghdr) + sizeof(nonce)];
len = iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)],sizeof(uint64_t),&nonce);
if ( memcmp(data,&serialized[sizeof(struct iguana_msghdr)],sizeof(nonce)) != 0 )
printf("ping ser error %llx != %llx\n",(long long)nonce,*(long long *)data);
iguana_queue_send(coin,addr,0,serialized,"pong",len,0,0);
if ( addr->supernet != 0 )
{
printf("send getpeers to %s\n",addr->ipaddr);
iguana_send_supernet(coin,addr,SUPERNET_GETPEERSTR,0);
}
}
int32_t iguana_send_ping(struct iguana_info *coin,struct iguana_peer *addr)
{
int32_t len; uint64_t nonce; uint8_t serialized[sizeof(struct iguana_msghdr) + sizeof(nonce)];
if ( (nonce= addr->pingnonce) == 0 )
{
randombytes((uint8_t *)&nonce,sizeof(nonce));
addr->pingnonce = nonce;
addr->pingtime = (uint32_t)time(NULL);
}
printf("pingnonce.%llx\n",(long long)nonce);
len = iguana_rwnum(1,&serialized[sizeof(struct iguana_msghdr)],sizeof(uint64_t),&nonce);
return(iguana_queue_send(coin,addr,serialized,"ping",len,0,0));
}
int32_t iguana_rwvout(int32_t rwflag,uint8_t *serialized,struct iguana_msgvout *msg)
{
int32_t len = 0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->value),&msg->value);
len += iguana_rwvarint32(rwflag,&serialized[len],&msg->pk_scriptlen);
if ( rwflag == 0 )
msg->pk_script = mycalloc('s',1,msg->pk_scriptlen);
len += iguana_rwmem(rwflag,&serialized[len],msg->pk_scriptlen,msg->pk_script);
//printf("(%.8f scriptlen.%d) ",dstr(msg->value),msg->pk_scriptlen);
//int i; for (i=0; i<msg->pk_scriptlen; i++)
// printf("%02x",msg->pk_script[i]);
//printf("\n");
return(len);
}
int32_t iguana_rwblockhash(int32_t rwflag,uint8_t *serialized,uint32_t *nVersionp,uint32_t *varintp,bits256 *hashes,bits256 *stophash)
{
int32_t i,len = 0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(*nVersionp),nVersionp);
len += iguana_rwvarint32(rwflag,&serialized[len],varintp);
if ( *varintp < IGUANA_MAXLOCATORS-1 )
{
for (i=0; i<*varintp; i++)
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(hashes[i]),hashes[i].bytes);
len += iguana_rwbignum(rwflag,&serialized[len],sizeof(*stophash),stophash->bytes);
//for (i=0; i<len; i++)
// printf("%02x ",serialized[i]);
//printf("rwblockhash len.%d\n",len);
} else printf("iguana_rwblockhash: illegal varint.%d\n",*varintp);
return(len);
}
int32_t iguana_validatehdr(char *symbol,struct iguana_msghdr *H)
{
int32_t i = 0,len = -1;
if ( strcmp(symbol,"VPN") != 0 )
{
for (i=0; Iguana_validcommands[i]!=0&&Iguana_validcommands[i][0]!=0; i++)
if ( strcmp(H->command,Iguana_validcommands[i]) == 0 )
break;
}
if ( Iguana_validcommands[i][0] != 0 )
{
iguana_rwnum(0,H->serdatalen,sizeof(H->serdatalen),(uint32_t *)&len);
if ( len > IGUANA_MAXPACKETSIZE )
return(-1);
}
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_validatehdr(struct iguana_info *coin,struct iguana_msghdr *H)
{
int32_t i,len; char *validcommands[] =
{
"version", "verack", "getaddr", "addr", "inv", "getdata", "notfound", "getblocks", "getheaders",
"headers", "tx", "block", "mempool", "ping", "pong", "reject", "filterload", "filteradd", "filterclear", "merkleblock", "alert"
};
for (i=0; i<sizeof(validcommands)/sizeof(*validcommands); i++)
if ( strcmp(H->command,validcommands[i]) == 0 )
{
iguana_rwnum(0,H->serdatalen,sizeof(H->serdatalen),(uint32_t *)&len);
if ( len > IGUANA_MAXPACKETSIZE )
return(-1);
return(len);
}
return(-1);
}
int32_t gecko_delayedPoW(struct supernet_info *myinfo,struct iguana_info *btcd,int32_t isPoS,uint8_t *coinbase,bits256 *btcdhashp,uint32_t timestamp,int32_t height)
{
int32_t len = 0; //bits256 btchash;
memset(btcdhashp,0,sizeof(*btcdhashp));
len += iguana_rwnum(1,&coinbase[len],sizeof(height),(void *)&height);
coinbase[len++] = 0;
if ( (isPoS & 7) != 0 )
{
/**btcdhashp = gecko_hashstampscalc(myinfo,btcd,&btchash,timestamp);
if ( (isPoS & 2) != 0 && (bits256_cmp(*btcdhashp,GENESIS_PUBKEY) == 0 || bits256_nonz(*btcdhashp) == 0) )
return(-1);
if ( (isPoS & 4) != 0 && (bits256_cmp(btchash,GENESIS_PUBKEY) == 0 || bits256_nonz(btchash) == 0) )
return(-1);*/
//len += iguana_rwbignum(1,&coinbase[len],sizeof(*btcdhashp),btcdhashp->bytes);
//len += iguana_rwbignum(1,&coinbase[len],sizeof(btchash),btchash.bytes);
}
return(len);
}
int32_t iguana_peerdatarequest(struct iguana_info *coin,struct iguana_peer *addr,uint8_t *data,int32_t recvlen)
{
int32_t i,type,len = 0; uint64_t x; bits256 hash2;
len += iguana_rwvarint(0,data,&x);
//for (i=0; i<10; i++)
// printf("%02x ",data[i]);
//printf("x.%d recvlen.%d\n",(int32_t)x,recvlen);
if ( x < IGUANA_MAXINV )
{
for (i=0; i<x; i++)
{
len += iguana_rwnum(0,&data[len],sizeof(uint32_t),&type);
len += iguana_rwbignum(0,&data[len],sizeof(bits256),hash2.bytes);
iguana_msgrequestQ(coin,addr,type,hash2);
}
}
return(len);
}
int32_t iguana_peeraddrrequest(struct iguana_info *coin,struct iguana_peer *addr,uint8_t *space,int32_t spacesize)
{
int32_t i,iter,n,max,sendlen;
uint64_t x;
struct iguana_peer *tmpaddr,tmp;
char ipaddr[65];
if ( coin->peers == 0 )
return(0);
sendlen = 0;
max = (IGUANA_MINPEERS + IGUANA_MAXPEERS) / 2;
if ( max > coin->peers->numranked )
max = coin->peers->numranked;
x = 0;
sendlen = iguana_rwvarint(1,&space[sendlen],&x);
for (iter=0; iter<2; iter++)
{
for (i=n=0; i<max; i++)
{
if ( (tmpaddr= coin->peers->ranked[i]) != 0 && ((iter == 0 && tmpaddr->supernet != 0) || (iter == 1 && tmpaddr->supernet == 0)) && tmpaddr->ipbits != 0 )
{
tmp = *tmpaddr;
iguana_rwnum(1,&tmp.A.ip[12],sizeof(uint32_t),&tmp.ipbits);
expand_ipbits(ipaddr,tmp.ipbits);
if ( tmp.A.port == 0 )
{
((uint8_t *)&tmp.A.port)[0] = ((uint8_t *)&coin->chain->portp2p)[1];
((uint8_t *)&tmp.A.port)[1] = ((uint8_t *)&coin->chain->portp2p)[0];
}
//printf("(%s:%02x%02x).%04x ",ipaddr,((uint8_t *)&tmp.A.port)[0],((uint8_t *)&tmp.A.port)[1],(int32_t)tmp.protover);
sendlen += iguana_rwaddr(1,&space[sendlen],&tmp.A,CADDR_TIME_VERSION);
x++;
if ( x == 0xf8 )
break;
}
}
}
iguana_rwvarint(1,space,&x);
//for (i=0; i<sendlen; i++)
// printf("%02x",space[i]);
//printf(" %p addrrequest: sendlen.%d x.%d\n",space,sendlen,(int32_t)x);
if ( x == 0 )
return(-1);
return(sendlen);
}
int32_t iguana_inv2packet(uint8_t *serialized,int32_t maxsize,int32_t type,bits256 *hashes,int32_t n)
{
int32_t i,len = sizeof(struct iguana_msghdr); uint64_t x = n;
memset(serialized,0,len);
len += iguana_rwvarint(1,&serialized[len],&x);
//for (i=0; i<10; i++)
// printf("%02x ",data[i]);
//printf("x.%d recvlen.%d\n",(int32_t)x,recvlen);
if ( x < IGUANA_MAXINV )
{
for (i=0; i<x; i++)
{
len += iguana_rwnum(1,&serialized[len],sizeof(uint32_t),&type);
len += iguana_rwbignum(1,&serialized[len],sizeof(bits256),hashes[i].bytes);
}
}
if ( len > maxsize )
return(-1);
return(len - sizeof(struct iguana_msghdr));
}
int32_t iguana_rwversion(int32_t rwflag,uint8_t *serialized,struct iguana_msgversion *msg,char *ipaddr)
{
int32_t len = 0;
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->nVersion),&msg->nVersion);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->nServices),&msg->nServices);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->nTime),&msg->nTime);
len += iguana_rwaddr(rwflag,&serialized[len],&msg->addrTo,MIN_PROTO_VERSION);
len += iguana_rwaddr(rwflag,&serialized[len],&msg->addrFrom,MIN_PROTO_VERSION);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->nonce),&msg->nonce);
len += iguana_rwstr(rwflag,&serialized[len],sizeof(msg->strSubVer),msg->strSubVer);
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->nStartingHeight),&msg->nStartingHeight);
if ( msg->nVersion > 70000 )
len += iguana_rwnum(rwflag,&serialized[len],sizeof(msg->relayflag),&msg->relayflag);
if ( rwflag == 0 )
printf("%-15s v.%llu srv.%llx %u ht.%llu [%s].R%d nonce.%llx\n",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);
return(len);
}
int32_t basilisk_ping_processMSG(struct supernet_info *myinfo,uint32_t senderipbits,uint8_t *data,int32_t datalen)
{
int32_t i,msglen,len=0; uint8_t num,keylen,*msg,*key;
if ( (num= data[len++]) > 0 )
{
printf("processMSG num.%d datalen.%d\n",num,datalen);
for (i=0; i<num; i++)
{
keylen = data[len++];
if ( keylen != sizeof(bits256)+sizeof(uint32_t)*2 )
return(0);
key = &data[len], len += keylen;
if ( len+sizeof(msglen) > datalen )
return(0);
len += iguana_rwnum(0,&data[len],sizeof(msglen),&msglen);
msg = &data[len], len += msglen;
if ( msglen <= 0 || len > datalen )
return(0);
//printf("i.%d: keylen.%d msglen.%d\n",i,keylen,msglen);
basilisk_respond_addmessage(myinfo,key,keylen,msg,msglen,0);
}
}
return(len);
}
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);
}
