You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
195 lines
11 KiB
195 lines
11 KiB
/******************************************************************************
|
|
* Copyright © 2014-2016 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
// included from datachain.c
|
|
|
|
int32_t datachain_rwgenesis(int32_t rwflag,uint8_t *serialized,struct gecko_genesis_opreturn *opret)
|
|
{
|
|
int32_t len = 0;
|
|
if ( rwflag == 0 )
|
|
{
|
|
memcpy(opret->type,&serialized[len],sizeof(opret->type)), len += sizeof(opret->type);
|
|
memcpy(opret->symbol,&serialized[len],sizeof(opret->symbol)), len += sizeof(opret->symbol);
|
|
memcpy(opret->name,&serialized[len],sizeof(opret->name)), len += sizeof(opret->name);
|
|
}
|
|
else
|
|
{
|
|
memcpy(&serialized[len],opret->type,sizeof(opret->type)), len += sizeof(opret->type);
|
|
memcpy(&serialized[len],opret->symbol,sizeof(opret->symbol)), len += sizeof(opret->symbol);
|
|
memcpy(&serialized[len],opret->name,sizeof(opret->name)), len += sizeof(opret->name);
|
|
}
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->PoSvalue),&opret->PoSvalue);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->netmagic),&opret->netmagic);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->timestamp),&opret->timestamp);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->nBits),&opret->nBits);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->nonce),&opret->nonce);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->blocktime),&opret->blocktime);
|
|
len += iguana_rwnum(rwflag,&serialized[len],sizeof(opret->port),&opret->port);
|
|
if ( rwflag == 0 )
|
|
{
|
|
opret->version = serialized[len++];
|
|
opret->pubval = serialized[len++];
|
|
opret->p2shval = serialized[len++];
|
|
opret->wifval = serialized[len++];
|
|
memcpy(opret->rmd160,&serialized[len],20), len += 20;
|
|
}
|
|
else
|
|
{
|
|
serialized[len++] = opret->version;
|
|
serialized[len++] = opret->pubval;
|
|
serialized[len++] = opret->p2shval;
|
|
serialized[len++] = opret->wifval;
|
|
memcpy(&serialized[len],opret->rmd160,20), len += 20;
|
|
}
|
|
//printf("opreturn len.%d\n",len);
|
|
return(len);
|
|
}
|
|
|
|
bits256 datachain_opreturn_convert(uint8_t *txidbytes,int32_t *txlenp,struct iguana_msgblock *msg,struct gecko_genesis_opreturn *opret)
|
|
{
|
|
bits256 txid,zero; int32_t minerpaymentlen=0; uint8_t minerpayment[512]; char coinbasestr[128],name[64],symbol[64];
|
|
if ( opret->PoSvalue > 0 )
|
|
minerpaymentlen = bitcoin_standardspend(minerpayment,0,opret->rmd160);
|
|
memset(zero.bytes,0,sizeof(zero));
|
|
memset(symbol,0,sizeof(symbol)), memcpy(symbol,opret->symbol,sizeof(opret->symbol));
|
|
memset(name,0,sizeof(name)), memcpy(name,opret->name,sizeof(opret->name));
|
|
sprintf(coinbasestr,"%s_%s",symbol,name);
|
|
*txlenp = iguana_coinbase(1,GECKO_DEFAULTVERSION,txidbytes,opret->timestamp,zero,(uint8_t *)coinbasestr,(int32_t)strlen(coinbasestr)+1,minerpayment,minerpaymentlen,opret->PoSvalue,&txid);
|
|
memset(msg,0,sizeof(*msg));
|
|
msg->H.version = opret->version;
|
|
msg->H.merkle_root = txid;
|
|
msg->H.timestamp = opret->timestamp;
|
|
msg->H.bits = opret->nBits;
|
|
msg->H.nonce = opret->nonce;
|
|
return(txid);
|
|
}
|
|
|
|
int32_t datachain_genesis_verify(struct gecko_genesis_opreturn *opret)
|
|
{
|
|
int32_t txlen,datalen; bits256 txid,threshold,hash2; uint8_t serialized[1024],txidbytes[1024]; struct iguana_msgzblock zmsg; char str[65],str2[65];
|
|
txid = datachain_opreturn_convert(txidbytes,&txlen,(void *)&zmsg,opret);
|
|
if ( opret->nBits >= GECKO_EASIESTDIFF )
|
|
threshold = bits256_from_compact(GECKO_EASIESTDIFF);
|
|
else threshold = bits256_from_compact(opret->nBits);
|
|
datalen = iguana_rwblockhdr(1,0,serialized,&zmsg);
|
|
hash2 = iguana_calcblockhash("virtual",blockhash_sha256,serialized,datalen);
|
|
//for (i=0; i<datalen; i++)
|
|
// printf("%02x",serialized[i]);
|
|
if ( bits256_cmp(threshold,hash2) > 0 )
|
|
{
|
|
//printf(" valid blockhash!\n");
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
printf(" ERROR invalid blockhash! txid.%s %s\n",bits256_str(str2,txid),bits256_str(str,hash2));
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
int32_t datachain_opreturn_create(uint8_t *serialized,char *symbol,char *name,char *coinaddr,int64_t PoSvalue,uint32_t nBits,uint16_t blocktime,uint16_t port,uint8_t p2shval,uint8_t wifval)
|
|
{
|
|
int32_t i,len,datalen,txlen; struct gecko_genesis_opreturn opret; bits256 threshold,txid,hash2; struct iguana_info *btcd; struct iguana_msgzblock zmsg; struct iguana_msgblock *msg = (void *)&zmsg; uint8_t txidbytes[1024];
|
|
btcd = iguana_coinfind("BTCD");
|
|
memset(&opret,0,sizeof(opret));
|
|
opret.type[0] = 'N', opret.type[1] = 'E', opret.type[2] = 'W';
|
|
memcpy(opret.symbol,symbol,sizeof(opret.symbol));
|
|
memcpy(opret.name,name,sizeof(opret.name));
|
|
opret.version = GECKO_DEFAULTVERSION;
|
|
opret.PoSvalue = PoSvalue;
|
|
opret.nBits = nBits;
|
|
opret.p2shval = p2shval;
|
|
opret.wifval = wifval;
|
|
opret.blocktime = blocktime;
|
|
opret.port = port;
|
|
opret.timestamp = (uint32_t)time(NULL);
|
|
OS_randombytes((void *)&opret.netmagic,sizeof(opret.netmagic));
|
|
bitcoin_addr2rmd160(&opret.pubval,opret.rmd160,coinaddr);
|
|
txid = datachain_opreturn_convert(txidbytes,&txlen,msg,&opret);
|
|
if ( nBits >= GECKO_EASIESTDIFF )
|
|
threshold = bits256_from_compact(GECKO_EASIESTDIFF);
|
|
else threshold = bits256_from_compact(nBits);
|
|
for (i=0; i<100000000; i++)
|
|
{
|
|
opret.nonce = msg->H.nonce = i;
|
|
datalen = iguana_rwblockhdr(1,0,serialized,&zmsg);
|
|
hash2 = iguana_calcblockhash(symbol,btcd->chain->hashalgo,serialized,datalen);
|
|
if ( bits256_cmp(threshold,hash2) > 0 )
|
|
break;
|
|
}
|
|
//char str[65],str2[65];
|
|
//for (i=0; i<datalen; i++)
|
|
// printf("%02x",serialized[i]);
|
|
//printf(" <- msgblock datalen.%d txid.%s hash2.%s\n",datalen,bits256_str(str,txid),bits256_str(str2,hash2));
|
|
len = datachain_rwgenesis(1,serialized,&opret);
|
|
datachain_genesis_verify(&opret);
|
|
return(len);
|
|
}
|
|
|
|
void datachain_events_processKOMODO(struct supernet_info *myinfo,struct datachain_info *dPoW,struct datachain_event *event)
|
|
{
|
|
struct gecko_chain *chain; bits256 hash2,threshold; struct gecko_genesis_opreturn opret; int32_t datalen,i,j,len,txlen; char symbol[16],name[64],magicstr[16],blockstr[8192],nbitstr[16],issuer[64],hashstr[65],str2[65],argbuf[1024],chainname[GECKO_MAXNAMELEN]; cJSON *valsobj; struct iguana_msgzblock zmsg; uint8_t serialized[256],txidbytes[1024],buf[4]; struct iguana_info *virt,*btcd;
|
|
if ( (btcd= iguana_coinfind("BTCD")) != 0 && memcmp(event->opreturn,"NEW",3) == 0 )
|
|
{
|
|
//int32_t i; for (i=0; i<76; i++)
|
|
// printf("%02x",event->opreturn[i]);
|
|
//printf(" <- event\n");
|
|
if ( (len= datachain_rwgenesis(0,event->opreturn,&opret)) <= event->oplen )
|
|
{
|
|
datachain_genesis_verify(&opret);
|
|
memset(symbol,0,sizeof(symbol)), memcpy(symbol,opret.symbol,sizeof(opret.symbol));
|
|
memset(name,0,sizeof(name)), memcpy(name,opret.name,sizeof(opret.name));
|
|
hash2 = datachain_opreturn_convert(txidbytes,&txlen,(void *)&zmsg,&opret);
|
|
if ( opret.nBits >= GECKO_EASIESTDIFF )
|
|
threshold = bits256_from_compact(GECKO_EASIESTDIFF);
|
|
else threshold = bits256_from_compact(opret.nBits);
|
|
zmsg.txn_count = 1;
|
|
//n = iguana_serialize_block(virt->chain,&hash2,serialized,newblock);
|
|
datalen = iguana_rwblockhdr(1,0,serialized,&zmsg);
|
|
hash2 = iguana_calcblockhash(symbol,btcd->chain->hashalgo,serialized,datalen);
|
|
for (i=0; i<datalen; i++)
|
|
printf("%02x",serialized[i]);
|
|
printf(" <- genhdr.%d\n",datalen);
|
|
for (i=0; i<txlen; i++)
|
|
printf("%02x",txidbytes[i]);
|
|
printf(" <- genesistx\n");
|
|
//char str[65]; printf("komodo datalen.%d %s\n",datalen,bits256_str(str,hash2));
|
|
if ( bits256_cmp(threshold,hash2) > 0 )
|
|
{
|
|
bitcoin_address(issuer,60,opret.rmd160,20);
|
|
bits256_str(hashstr,hash2);
|
|
for (j=0,i=3; i>=0; i--,j++)
|
|
buf[i] = (opret.netmagic >> (j*8));
|
|
init_hexbytes_noT(magicstr,buf,4);
|
|
for (j=0,i=3; i>=0; i--,j++)
|
|
buf[i] = (opret.nBits >> (j*8));
|
|
init_hexbytes_noT(nbitstr,buf,4);
|
|
init_hexbytes_noT(blockstr,serialized,datalen);
|
|
strcat(blockstr,"01"), datalen++;
|
|
init_hexbytes_noT(&blockstr[datalen << 1],txidbytes,txlen);
|
|
sprintf(argbuf,"{\"name\":\"%s\",\"symbol\":\"%s\",\"netmagic\":\"%s\",\"port\":%u,\"blocktime\":%u,\"pubval\":\"%02x\",\"p2shval\":\"%02x\",\"wifval\":\"%02x\",\"unitval\":\"%02x\",\"genesishash\":\"%s\",\"genesis\":{\"version\":1,\"timestamp\":%u,\"nBits\":\"%s\",\"nonce\":%d,\"merkle_root\":\"%s\"},\"genesisblock\":\"%s\"}",name,symbol,magicstr,opret.port,opret.blocktime,opret.pubval,opret.p2shval,opret.wifval,(opret.nBits >> 24) & 0xff,hashstr,opret.timestamp,nbitstr,opret.nonce,bits256_str(str2,zmsg.zH.merkle_root),blockstr);
|
|
if ( (valsobj= cJSON_Parse(argbuf)) != 0 )
|
|
{
|
|
printf("datachain.NEW (%s/%s port.%u blocktime.%d) issuer.%s (%s)\n",opret.symbol,opret.name,opret.port,opret.blocktime,issuer,jprint(valsobj,0));
|
|
if ( (chain= gecko_chain(myinfo,chainname,valsobj)) != 0 && (virt= chain->info) != 0 )
|
|
printf("duplicate chain.%s rejected\n",opret.symbol);
|
|
else if ( (virt= basilisk_geckochain(myinfo,symbol,chainname,valsobj)) != 0 )
|
|
chain->info = virt;
|
|
free_json(valsobj);
|
|
}
|
|
} else printf("failed PoW test for genesis.%s\n",opret.symbol);
|
|
} else printf("opret unexpected len.%d vs %d\n",len,event->oplen);
|
|
}
|
|
}
|
|
|