lukechilds
/
SuperNET
mirror of https://github.com/lukechilds/SuperNET.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
4262 Commits
31 Branches
0 Tags
196 MiB
Tree: 59fb44ab07
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '59fb44ab07'
${ noResults }
SuperNET/InstantDEX/subatomic.h

1497 lines
62 KiB
Raw Normal View History

initial commit
9 years ago
/******************************************************************************
* Copyright © 2014-2015 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. *
* *
******************************************************************************/
#ifndef xcode_subatomic_h
#define xcode_subatomic_h
//https://bitcointalk.org/index.php?topic=1172153.0
#include <stdbool.h>
struct bp_key { void *k; };
typedef struct cstring {
char *str; // string data, incl. NUL
size_t len; // length of string, not including NUL
size_t alloc; // total allocated buffer length
} cstring;
extern bool bp_key_init(struct bp_key *key);
extern void bp_key_free(struct bp_key *key);
extern bool bp_key_generate(struct bp_key *key);
extern bool bp_privkey_set(struct bp_key *key, const void *privkey, size_t pk_len);
extern bool bp_pubkey_set(struct bp_key *key, const void *pubkey, size_t pk_len);
extern bool bp_key_secret_set(struct bp_key *key, const void *privkey_, size_t pk_len);
extern bool bp_privkey_get(const struct bp_key *key, void **privkey, size_t *pk_len);
extern bool bp_pubkey_get(const struct bp_key *key, void **pubkey, size_t *pk_len);
extern bool bp_key_secret_get(void *p, size_t len, const struct bp_key *key);
extern bool bp_sign(const struct bp_key *key, const void *data, size_t data_len,void **sig_, size_t *sig_len_);
extern bool bp_verify(const struct bp_key *key, const void *data, size_t data_len,const void *sig, size_t sig_len);
void cstr_free(cstring *s, bool free_buf);
cstring *base58_encode_check(unsigned char addrtype,bool have_addrtype,const void *data,size_t data_len);
cstring *base58_decode_check(unsigned char *addrtype, const char *s_in);
int32_t btc_setprivkey(struct bp_key *key,char *privkeystr);
int32_t btc_getpubkey(char pubkeystr[67],uint8_t pubkeybuf[33],struct bp_key *key);
void btc_freekey(void *key);
struct btcaddr
{
struct bp_key key;
uint8_t *pubkey; uint16_t p2sh;
char addr[36],coin[8];
uint8_t privkey[280];
};
#define SCRIPT_OP_IF 0x63
#define SCRIPT_OP_ELSE 0x67
#define SCRIPT_OP_DUP 0x76
#define SCRIPT_OP_ENDIF 0x68
#define SCRIPT_OP_TRUE 0x51
#define SCRIPT_OP_2 0x52
#define SCRIPT_OP_3 0x53
#define SCRIPT_OP_EQUALVERIFY 0x88
#define SCRIPT_OP_HASH160 0xa9
#define SCRIPT_OP_EQUAL 0x87
#define SCRIPT_OP_CHECKSIG 0xac
#define SCRIPT_OP_CHECKMULTISIG 0xae
#define SCRIPT_OP_CHECKMULTISIGVERIFY 0xaf
char *create_atomictx_scripts(uint8_t addrtype,char *scriptPubKey,char *p2shaddr,char *pubkeyA,char *pubkeyB,char *hash160str)
{
// if ( refund ) OP_HASH160 <2of2 multisig hash> OP_EQUAL // standard multisig
// else OP_DUP OP_HASH160 <hash160> OP_EQUALVERIFY OP_CHECKSIG // standard spend
cstring *btc_addr; char *retstr; uint8_t pubkeyAbytes[33],pubkeyBbytes[33],hash160[20],tmpbuf[24],hex[4096]; int32_t i,n = 0;
decode_hex(pubkeyAbytes,33,pubkeyA);
decode_hex(pubkeyBbytes,33,pubkeyB);
decode_hex(hash160,20,hash160str);
hex[n++] = SCRIPT_OP_IF;
hex[n++] = SCRIPT_OP_2;
hex[n++] = 33, memcpy(&hex[n],pubkeyAbytes,33), n += 33;
hex[n++] = 33, memcpy(&hex[n],pubkeyBbytes,33), n += 33;
hex[n++] = SCRIPT_OP_2;
hex[n++] = SCRIPT_OP_CHECKMULTISIG;
hex[n++] = SCRIPT_OP_ELSE;
hex[n++] = SCRIPT_OP_DUP;
hex[n++] = SCRIPT_OP_HASH160;
hex[n++] = 20; memcpy(&hex[n],hash160,20); n += 20;
hex[n++] = SCRIPT_OP_EQUALVERIFY;
hex[n++] = SCRIPT_OP_CHECKSIG;
hex[n++] = SCRIPT_OP_ENDIF;
if ( (retstr= calloc(1,n*2+16)) == 0 )
return(0);
//printf("pubkeyA.(%s) pubkeyB.(%s) hash160.(%s) ->\n",pubkeyA,pubkeyB,hash160str);
//strcpy(retstr,"01");
//sprintf(retstr+2,"%02x",n);
for (i=0; i<n; i++)
{
retstr[i*2] = hexbyte((hex[i]>>4) & 0xf);
retstr[i*2 + 1] = hexbyte(hex[i] & 0xf);
//printf("%02x",hex[i]);
}
retstr[n*2] = 0;
calc_OP_HASH160(scriptPubKey,tmpbuf+2,retstr);
tmpbuf[0] = SCRIPT_OP_HASH160;
tmpbuf[1] = 20;
tmpbuf[22] = SCRIPT_OP_EQUAL;
init_hexbytes_noT(scriptPubKey,tmpbuf,23);
if ( p2shaddr != 0 )
{
p2shaddr[0] = 0;
if ( (btc_addr= base58_encode_check(addrtype,true,tmpbuf+2,20)) != 0 )
{
if ( strlen(btc_addr->str) < 36 )
strcpy(p2shaddr,btc_addr->str);
cstr_free(btc_addr,true);
}
}
return(retstr);
}
#ifdef noiguana
int32_t create_MofN(uint8_t addrtype,char *redeemScript,char *scriptPubKey,char *p2shaddr,char *pubkeys[],int32_t M,int32_t N)
{
cstring *btc_addr; uint8_t pubkey[33],tmpbuf[24],hex[4096]; int32_t i,n = 0;
hex[n++] = 0x50 + M;
for (i=0; i<N; i++)
{
decode_hex(pubkey,33,pubkeys[i]);
hex[n++] = 33;
memcpy(&hex[n],pubkey,33);
n += 33;
}
hex[n++] = 0x50 + N;
hex[n++] = SCRIPT_OP_CHECKMULTISIG;
for (i=0; i<n; i++)
{
redeemScript[i*2] = hexbyte((hex[i]>>4) & 0xf);
redeemScript[i*2 + 1] = hexbyte(hex[i] & 0xf);
//fprintf(stderr,"%02x",hex[i]);
}
//fprintf(stderr," n.%d\n",n);
redeemScript[n*2] = 0;
calc_OP_HASH160(0,tmpbuf+2,redeemScript);
//printf("op160.(%s)\n",redeemScript);
tmpbuf[0] = SCRIPT_OP_HASH160;
tmpbuf[1] = 20;
tmpbuf[22] = SCRIPT_OP_EQUAL;
init_hexbytes_noT(scriptPubKey,tmpbuf,23);
p2shaddr[0] = 0;
if ( (btc_addr= base58_encode_check(addrtype,true,tmpbuf+2,20)) != 0 )
{
if ( strlen(btc_addr->str) < 36 )
strcpy(p2shaddr,btc_addr->str);
cstr_free(btc_addr,true);
}
return(n);
}
struct btcaddr *btcaddr_new(char *coinstr,char *p2sh_script)
{
uint8_t script[8192],md160[20]; char pubkeystr[512],privkeystr[512],hashstr[41]; struct coin777 *coin;
void *privkey=0,*pubkey=0; int32_t n; size_t len,slen; cstring *btc_addr; struct btcaddr *btc;
if ( (btc= calloc(1,sizeof(*btc))) == 0 || (coin = coin777_find(coinstr,1)) == 0 )
{
if ( btc != 0 )
free(btc);
return(0);
}
strncpy(btc->coin,coin->name,sizeof(btc->coin)-1);
if ( p2sh_script != 0 )
{
calc_OP_HASH160(0,md160,p2sh_script);
btc->p2sh = n = (int32_t)strlen(p2sh_script) >> 1;
decode_hex(script,n,p2sh_script);
if ( (btc_addr= base58_encode_check(coin->p2shtype,true,md160,sizeof(md160))) != 0 )
{
if ( n > sizeof(btc->privkey)-23 )
{
printf("script.(%s) len.%d is too big\n",p2sh_script,n);
free(btc);
return(0);
}
strcpy(btc->addr,btc_addr->str);
memcpy(btc->privkey,script,n);
btc->pubkey = &btc->privkey[sizeof(btc->privkey) - 23];
btc->pubkey[0] = SCRIPT_OP_HASH160;
btc->pubkey[2] = 20;
memcpy(&btc->pubkey[2],md160,20);
btc->pubkey[22] = SCRIPT_OP_EQUAL;
init_hexbytes_noT(privkeystr,script,n);
printf("type.%u btcaddr.%ld addr.(%s) %ld p2sh.(%s) %d\n",coin->p2shtype,(long)sizeof(struct btcaddr),btc->addr,(long)strlen(btc->addr),privkeystr,n);
cstr_free(btc_addr,true);
} else free(btc), btc = 0;
return(btc);
}
else if ( bp_key_init(&btc->key) != 0 && bp_key_generate(&btc->key) != 0 && bp_pubkey_get(&btc->key,&pubkey,&len) != 0 && bp_privkey_get(&btc->key,&privkey,&slen) != 0 )
{
if ( len == 33 && slen == 214 && memcmp((void *)((long)privkey + slen - 33),pubkey,33) == 0 )
{
init_hexbytes_noT(pubkeystr,pubkey,len);
init_hexbytes_noT(privkeystr,privkey,slen);
calc_OP_HASH160(hashstr,md160,pubkeystr);
if ( (btc_addr= base58_encode_check(coin->addrtype,true,md160,sizeof(md160))) != 0 )
{
strcpy(btc->addr,btc_addr->str);
memcpy(btc->privkey,privkey,slen);
btc->pubkey = &btc->privkey[slen - len];
printf("type.%u btcaddr.%ld rmd160.(%s) addr.(%s) %ld pubkey.(%s) %d privkey.(%s) %d\n",coin->addrtype,(long)sizeof(struct btcaddr),hashstr,btc->addr,(long)strlen(btc->addr),pubkeystr,(int32_t)len,privkeystr,(int32_t)slen);
cstr_free(btc_addr,true);
}
else free(btc), btc = 0;
} else free(btc), btc = 0;
}
return(btc);
}
int32_t btc_getpubkey(char pubkeystr[67],uint8_t pubkeybuf[33],struct bp_key *key)
{
void *pubkey = 0; size_t len = 0;
bp_pubkey_get(key,&pubkey,&len);
if ( pubkey != 0 )
{
if ( pubkeystr != 0 )
{
if ( len < 34 )
{
init_hexbytes_noT(pubkeystr,pubkey,(int32_t)len);
memcpy(pubkeybuf,pubkey,len);
}
else printf("btc_getpubkey error len.%d\n",(int32_t)len), len = -1;
}
//printf("btc_getpubkey len.%ld (%s).%p\n",len,pubkeystr,pubkeystr);
} else len = -1;
return((int32_t)len);
}
int32_t btc_convrmd160(char *coinaddr,uint8_t addrtype,uint8_t md160[20])
{
cstring *btc_addr;
if ( (btc_addr= base58_encode_check(addrtype,true,md160,20)) != 0 )
{
strcpy(coinaddr,btc_addr->str);
cstr_free(btc_addr,true);
return(0);
}
return(-1);
}
int32_t btc_coinaddr(char *coinaddr,uint8_t addrtype,char *pubkeystr)
{
uint8_t rmd160[20]; char hashstr[41];
calc_OP_HASH160(hashstr,rmd160,pubkeystr);
return(btc_convrmd160(coinaddr,addrtype,rmd160));
}
int32_t btc_convaddr(char *hexaddr,char *addr58)
{
uint8_t addrtype; cstring *cstr;
if ( (cstr= base58_decode_check(&addrtype,(const char *)addr58)) != 0 )
{
sprintf(hexaddr,"%02x",addrtype);
init_hexbytes_noT(hexaddr+2,(void *)cstr->str,cstr->len);
cstr_free(cstr,true);
return(0);
}
return(-1);
}
int32_t btc_priv2wip(char *wipstr,uint8_t privkey[32],uint8_t addrtype)
{
uint8_t tmp[128]; char hexstr[67]; cstring *btc_addr;
memcpy(tmp,privkey,32);
tmp[32] = 1;
init_hexbytes_noT(hexstr,tmp,32);
if ( (btc_addr= base58_encode_check(addrtype,true,tmp,33)) != 0 )
{
strcpy(wipstr,btc_addr->str);
cstr_free(btc_addr,true);
}
printf("-> (%s) -> wip.(%s) addrtype.%02x\n",hexstr,wipstr,addrtype);
return(0);
}
int32_t btc_wip2priv(uint8_t privkey[32],char *wipstr)
{
uint8_t addrtype; cstring *cstr; int32_t len = -1;
if ( (cstr= base58_decode_check(&addrtype,(const char *)wipstr)) != 0 )
{
init_hexbytes_noT((void *)privkey,(void *)cstr->str,cstr->len);
if ( cstr->str[cstr->len-1] == 0x01 )
cstr->len--;
memcpy(privkey,cstr->str,cstr->len);
len = (int32_t)cstr->len;
char tmp[138];
btc_priv2wip(tmp,privkey,addrtype);
printf("addrtype.%02x wipstr.(%llx) len.%d\n",addrtype,*(long long *)privkey,len);
cstr_free(cstr,true);
}
return(len);
}
int32_t btc_setprivkey(struct bp_key *key,char *privkeystr)
{
uint8_t privkey[512]; int32_t len = btc_wip2priv(privkey,privkeystr);
if ( len < 0 || bp_key_init(key) == 0 || bp_key_secret_set(key,privkey,len) == 0 )
{
printf("error setting privkey\n");
return(-1);
}
return(0);
}
void jumblr_freekey(void *key)
{
bp_key_free(key);
free(key);
}
int32_t btc_priv2pub(uint8_t pubkey[33],uint8_t privkey[32])
{
size_t len; void *pub = 0; int32_t retval = -1;
struct bp_key *key = calloc(1,sizeof(*key));
if ( key != 0 && bp_key_init(key) != 0 && bp_key_secret_set(key,privkey,32) != 0 )
{
bp_pubkey_get(key,&pub,&len);
bp_key_free(key);
if ( len == 33 )
memcpy(pubkey,pub,33);
if ( pub != 0 )
free(pub);
return(retval);
}
if ( key != 0 )
bp_key_free(key);
return(retval);
}
int32_t btc_pub2rmd(uint8_t rmd160[20],uint8_t pubkey[33])
{
char pubkeystr[67],hashstr[41];
init_hexbytes_noT(pubkeystr,pubkey,33);
calc_OP_HASH160(hashstr,rmd160,pubkeystr);
return(0);
}
void *jumblr_bpkey(char *pubP,struct coin777 *coin,char *coinaddr)
{
uint8_t buf[2048]; char *privkey; struct bp_key *key = 0;
//printf("coin.%s (%s)\n",coin->name,coinaddr);
if ( (privkey = dumpprivkey(coin->name,coin->serverport,coin->userpass,coinaddr)) != 0 )
{
//printf("privkey.(%s)\n",privkey);
key = calloc(1,sizeof(*key));
if ( key != 0 && btc_setprivkey(key,privkey) == 0 && btc_getpubkey(pubP,buf,key) > 0 )
return(key);
btc_freekey(key);
}
return(0);
}
void set_spendscript(char *spendscript,char *coinaddr)
{
char hexaddr[128];
btc_convaddr(hexaddr,coinaddr);
sprintf(spendscript,"76a914%s88ac",hexaddr+2);
}
int32_t script_coinaddr(char *coinaddr,cJSON *scriptobj)
{
struct destbuf buf; cJSON *addresses;
coinaddr[0] = 0;
if ( scriptobj == 0 )
return(-1);
if ( (addresses= cJSON_GetObjectItem(scriptobj,"addresses")) != 0 )
{
copy_cJSON(&buf,jitem(addresses,0));
strcpy(coinaddr,buf.buf);
return(0);
}
return(-1);
}
char *pangea_signp2sh(int32_t oldtx_format,struct cointx_info *refT,int32_t redeemi,char *redeemscript,char sigs[][256],int32_t n,uint8_t privkey[32],int32_t privkeyind)
{
char hexstr[16384]; bits256 hash2; uint8_t data[4096],sigbuf[512]; struct bp_key key;
struct cointx_info *T; int32_t i,len; void *sig = NULL; size_t siglen = 0; struct cointx_input *vin;
if ( bp_key_init(&key) != 0 && bp_key_secret_set(&key,privkey,32) != 0 )
{
if ( (T= calloc(1,sizeof(*T))) == 0 )
return(0);
*T = *refT; vin = &T->inputs[redeemi];
for (i=0; i<T->numinputs; i++)
strcpy(T->inputs[i].sigs,"00");
strcpy(vin->sigs,redeemscript);
vin->sequence = (uint32_t)-1;
T->nlocktime = 0;
//disp_cointx(&T);
emit_cointx(&hash2,data,sizeof(data),T,oldtx_format,SIGHASH_ALL);
//printf("HASH2.(%llx)\n",(long long)hash2.txid);
if ( bp_sign(&key,hash2.bytes,sizeof(hash2),&sig,&siglen) != 0 )
{
memcpy(sigbuf,sig,siglen);
sigbuf[siglen++] = SIGHASH_ALL;
init_hexbytes_noT(sigs[privkeyind],sigbuf,(int32_t)siglen);
strcpy(vin->sigs,"00");
for (i=0; i<n; i++)
{
if ( sigs[i][0] != 0 )
{
sprintf(vin->sigs + strlen(vin->sigs),"%02x%s",(int32_t)strlen(sigs[i])>>1,sigs[i]);
//printf("(%s).%ld ",sigs[i],strlen(sigs[i]));
}
}
len = (int32_t)(strlen(redeemscript)/2);
if ( len >= 0xfd )
sprintf(&vin->sigs[strlen(vin->sigs)],"4d%02x%02x",len & 0xff,(len >> 8) & 0xff);
else sprintf(&vin->sigs[strlen(vin->sigs)],"4c%02x",len);
sprintf(&vin->sigs[strlen(vin->sigs)],"%s",redeemscript);
//printf("after A.(%s) othersig.(%s) siglen.%02lx -> (%s)\n",hexstr,othersig != 0 ? othersig : "",siglen,vin->sigs);
//printf("vinsigs.(%s) %ld\n",vin->sigs,strlen(vin->sigs));
_emit_cointx(hexstr,sizeof(hexstr),T,oldtx_format);
//disp_cointx(&T);
free(T);
return(clonestr(hexstr));
}
else printf("error signing\n");
free(T);
}
return(0);
}
uint64_t jumblr_getcoinaddr(char *coinaddr,struct destbuf *scriptPubKey,struct coin777 *coin,char *txid,int32_t vout)
{
char *rawtransaction,*txidstr,*asmstr; uint64_t value = 0; int32_t n,m,len,reqSigs; cJSON *json,*scriptobj,*array,*item,*hexobj;
scriptPubKey->buf[0] = 0;
if ( (rawtransaction= _get_transaction(coin->name,coin->serverport,coin->userpass,txid)) == 0 )
{
printf("jumblr_getprivkey: error getting (%s)\n",txid);
return(0);
}
if ( (json= cJSON_Parse(rawtransaction)) != 0 )
{
if ( (txidstr= jstr(json,"txid")) == 0 || strcmp(txidstr,txid) != 0 )
{
printf("jumblr_getcoinaddr no txid or mismatch\n");
free_json(json);
free(rawtransaction);
return(0);
}
if ( (array= jarray(&n,json,"vout")) != 0 && vout < n && (item= jitem(array,vout)) != 0 )
{
reqSigs = (int32_t)get_cJSON_int(item,"reqSigs");
value = conv_cJSON_float(item,"value");
scriptobj = cJSON_GetObjectItem(item,"scriptPubKey");
printf("ITEM.(%s)\n",jprint(item,0));
if ( scriptobj != 0 )
{
printf("script.(%s)\n",jprint(scriptobj,0));
script_coinaddr(coinaddr,scriptobj);
hexobj = cJSON_GetObjectItem(scriptobj,"hex");
if ( scriptPubKey != 0 && hexobj != 0 )
copy_cJSON(scriptPubKey,hexobj);
else
{
// OP_DUP OP_HASH160 f563e867027dedd109c9bb5f3354c3cc41dc7c7f OP_EQUALVERIFY OP_CHECKSIG
// 0318d4f6cdcbe6c822b979fc318dbe4ad58287223c8fb57b7bec0c88cd58a4b16a OP_CHECKSIG
if ( (asmstr= jstr(scriptobj,"asm")) != 0 )
{
len = (int32_t)strlen(asmstr);
m = (int32_t)strlen(" OP_EQUALVERIFY OP_CHECKSIG");
if ( strncmp(asmstr,"OP_DUP OP_HASH160 ",strlen("OP_DUP OP_HASH160 ")) == 0 && strcmp(&asmstr[len - m]," OP_EQUALVERIFY OP_CHECKSIG") == 0 )
set_spendscript(scriptPubKey->buf,coinaddr);
else
{
printf("nonstandard.(%s)\n",&asmstr[len - m]);
m = (int32_t)strlen(" OP_CHECKSIG");
if ( strcmp(&asmstr[len - m]," OP_CHECKSIG") == 0 )
{
printf("key sig (%s)\n",asmstr);
sprintf(scriptPubKey->buf,"%02x",(len-m)/2);
memcpy(&scriptPubKey->buf[2],asmstr,(len - m));
scriptPubKey->buf[2 + (len - m)] = 0;
strcat(scriptPubKey->buf,"ac");
}
}
}
}
} else printf("null scriptobj.%p (%s)\n",scriptobj,coinaddr);
}
free_json(json);
}
free(rawtransaction);
return(value);
}
char *jumblr_getprivkey(uint64_t *valuep,struct destbuf *scriptPubKey,uint32_t *locktimep,struct coin777 *coin,char *txid,int32_t vout)
{
char *rawtransaction,*txidstr,*privkey=0,coinaddr[64]; uint64_t value = 0; int32_t n,reqSigs; cJSON *json,*scriptobj,*array,*item,*hexobj;
*locktimep = -1;
scriptPubKey->buf[0] = 0;
if ( (rawtransaction= _get_transaction(coin->name,coin->serverport,coin->userpass,txid)) == 0 )
{
printf("jumblr_getprivkey: error getting (%s)\n",txid);
return(0);
}
if ( (json= cJSON_Parse(rawtransaction)) != 0 )//get_decoderaw_json(coin,rawtransaction)) != 0 )
{
*locktimep = (int32_t)get_cJSON_int(json,"locktime");
if ( (txidstr= jstr(json,"txid")) == 0 || strcmp(txidstr,txid) != 0 )
{
printf("jumblr_getprivkey no txid or mismatch\n");
free_json(json);
free(rawtransaction);
return(0);
}
//printf("txidstr.(%s) vout.%d\n",txidstr,vout);
if ( (array= jarray(&n,json,"vout")) != 0 && (item= jitem(array,vout)) != 0 )
{
scriptobj = cJSON_GetObjectItem(item,"scriptPubKey");
if ( scriptobj != 0 && script_coinaddr(coinaddr,scriptobj) == 0 )
{
reqSigs = (int32_t)get_cJSON_int(item,"reqSigs");
value = conv_cJSON_float(item,"value");
hexobj = cJSON_GetObjectItem(scriptobj,"hex");
if ( scriptPubKey != 0 && hexobj != 0 )
copy_cJSON(scriptPubKey,hexobj);
privkey = dumpprivkey(coin->name,coin->serverport,coin->userpass,coinaddr);
} else printf("null scriptobj.%p (%s)\n",scriptobj,coinaddr);
}
free_json(json);
}
free(rawtransaction);
if ( valuep != 0 )
*valuep = value;
return(privkey);
}
cJSON *cointx_vins_json_params(struct coin777 *coin,char *rawbytes)
{
int32_t i; cJSON *json,*array; char coinaddr[128]; struct destbuf scriptPubKey; struct cointx_info *cointx;
array = cJSON_CreateArray();
printf("convert.(%s)\n",rawbytes);
if ( (cointx= _decode_rawtransaction(rawbytes,coin->mgw.oldtx_format)) != 0 )
{
disp_cointx(cointx);
for (i=0; i<cointx->numinputs; i++)
{
json = cJSON_CreateObject();
jaddstr(json,"txid",cointx->inputs[i].tx.txidstr);
jaddnum(json,"vout",cointx->inputs[i].tx.vout);
if ( cointx->inputs[i].sigs[0] != 0 )
jaddstr(json,"scriptPubKey",cointx->inputs[i].sigs);
else
{
jumblr_getcoinaddr(coinaddr,&scriptPubKey,coin,cointx->inputs[i].tx.txidstr,cointx->inputs[i].tx.vout);
jaddstr(json,"scriptPubKey",scriptPubKey.buf);
}
cJSON_AddItemToArray(array,json);
}
free(cointx);
}
return(array);
}
char *jumblr_signraw_json_params(struct coin777 *coin,char *rawbytes)
{
char *paramstr = 0; cJSON *array,*rawobj,*vinsobj;//,*keysobj;char *coinaddrs[MAX_SUBATOMIC_INPUTS+1],
if ( (rawobj= cJSON_CreateString(rawbytes)) != 0 )
{
if ( (vinsobj= cointx_vins_json_params(coin,rawbytes)) != 0 )
{
array = cJSON_CreateArray();
jaddi(array,rawobj);
jaddi(array,vinsobj);
//cJSON_AddItemToArray(array,keysobj);
paramstr = jprint(array,1);
}
else free_json(rawobj);
}
return(paramstr);
}
int32_t jumblr_signtx(char *signedtx,unsigned long destsize,struct coin777 *coin,char *signparams)
{
cJSON *json,*compobj; char *retstr,*deststr; uint32_t completed = 0;
signedtx[0] = 0;
//printf("cp.%d vs %d: subatomic_signtx rawbytes.(%s)\n",cp->coinid,coinid,rawbytes);
if ( coin != 0 && signparams != 0 )
{
_stripwhite(signparams,' ');
printf("got signparams.(%s)\n",signparams);
if ( (retstr= bitcoind_RPC(0,coin->name,coin->serverport,coin->userpass,"signrawtransaction",signparams)) != 0 )
{
//printf("got retstr.(%s)\n",retstr);
if ( (json= cJSON_Parse(retstr)) != 0 )
{
if ( (deststr= jstr(json,"hex")) != 0 )
{
compobj = cJSON_GetObjectItem(json,"complete");
if ( compobj != 0 )
completed = ((compobj->type&0xff) == cJSON_True);
if ( strlen(deststr) > destsize )
printf("sign_rawtransaction: strlen(deststr) %ld > %ld destize\n",(long)strlen(deststr),destsize);
else strcpy(signedtx,deststr);
} else printf("cant get hex from.(%s)\n",retstr);
free_json(json);
} else printf("json parse error.(%s)\n",retstr);
free(retstr);
} else printf("error signing rawtx\n");
} else printf("error generating signparams\n");
return(completed);
}
char *jumblr_signvin(char *sigstr,struct coin777 *coin,char *signedtx,int32_t bufsize,void *bpkey,char *pubP,struct cointx_info *refT,int32_t redeemi,char *rawtx)
{
// signrawtransaction <hex string> [{"txid":txid,"vout":n,"scriptPubKey":hex},...] [<privatekey1>,...]
char hexstr[4096],redeem[2048]; bits256 hash2; uint8_t *data,sigbuf[1024];
struct cointx_info *T; int32_t i; void *sig = NULL; size_t siglen = 0; struct cointx_input *vin;
sigstr[0] = 0;
if ( 1 )
{
char *paramstr; cJSON *vinarray,*item,*array = cJSON_CreateArray();
vinarray = cJSON_CreateArray();
jaddistr(array,rawtx);
for (i=0; i<refT->numinputs; i++)
{
vin = &refT->inputs[i];
item = cJSON_CreateObject();
jaddstr(item,"txid",vin->tx.txidstr);
jaddnum(item,"vout",vin->tx.vout);
jaddstr(item,"scriptPubKey",vin->sigs);
jaddi(vinarray,item);
}
jaddi(array,vinarray);
paramstr = jprint(array,1);
if ( jumblr_signtx(signedtx,bufsize,coin,paramstr) > 0 )
printf("SIGS completed\n");
if ( signedtx[0] != 0 )
{
if ( (T= _decode_rawtransaction(signedtx,coin->mgw.oldtx_format)) != 0 )
{
strcpy(sigstr,T->inputs[redeemi].sigs);
free(T);
return(sigstr);
}
}
return(0);
}
if ( (T = calloc(1,sizeof(*T))) == 0 )
{
printf("unexpected out of mem in jumblr_signvin\n");
return(0);
}
*T = *refT;
vin = &T->inputs[redeemi];
safecopy(redeem,vin->sigs,sizeof(redeem));
fprintf(stderr,"redeemi.%d numinputs.%d\n",redeemi,T->numinputs);
for (i=0; i<T->numinputs; i++)
if ( i != redeemi )
strcpy(T->inputs[i].sigs,"00");
vin->sequence = (uint32_t)-1;
T->nlocktime = 0;
data = malloc(65536);
disp_cointx(T);
emit_cointx(&hash2,data,sizeof(data),T,coin->mgw.oldtx_format,SIGHASH_ALL);
free(data);
if ( bp_sign(bpkey,hash2.bytes,sizeof(hash2),&sig,&siglen) != 0 && sig != 0 )
{
memcpy(sigbuf,sig,siglen);
free(sig);
sigbuf[siglen++] = SIGHASH_ALL;
init_hexbytes_noT(hexstr,sigbuf,(int32_t)siglen);
sprintf(vin->sigs,"%02x%s%02x%s",(uint32_t)siglen,hexstr,(uint32_t)strlen(pubP)/2,pubP);
strcpy(sigstr,vin->sigs);
printf("after P.(%s) siglen.%02x -> %s pubP.(%s)\n",sigstr,(uint32_t)siglen,vin->sigs,pubP);
}
free(T);
if ( sigstr[0] != 0 )
return(sigstr);
else return(0);
}
int32_t script_has_coinaddr(cJSON *scriptobj,char *coinaddr)
{
int32_t i,n; struct destbuf buf; cJSON *addresses,*addrobj;
if ( scriptobj == 0 )
return(0);
addresses = cJSON_GetObjectItem(scriptobj,"addresses");
if ( addresses != 0 )
{
n = cJSON_GetArraySize(addresses);
for (i=0; i<n; i++)
{
addrobj = cJSON_GetArrayItem(addresses,i);
copy_cJSON(&buf,addrobj);
if ( strcmp(buf.buf,coinaddr) == 0 )
return(1);
}
}
return(0);
}
cJSON *get_decoderaw_json(struct coin777 *coin,char *rawtransaction)
{
char *str,*retstr; cJSON *json = 0;
str = malloc(strlen(rawtransaction)+4);
//printf("got rawtransaction.(%s)\n",rawtransaction);
sprintf(str,"\"%s\"",rawtransaction);
if ( (retstr= bitcoind_passthru(coin->name,coin->serverport,coin->userpass,"decoderawtransaction",str)) != 0 && retstr[0] != 0 )
{
//printf("got decodetransaction.(%s)\n",retstr);
json = cJSON_Parse(retstr);
} else printf("error decoding.(%s)\n",str);
if ( retstr != 0 )
free(retstr);
free(str);
return(json);
}
char *subatomic_decodetxid(int64_t *valuep,struct destbuf *scriptPubKey,uint32_t *locktimep,struct coin777 *coin,char *rawtransaction,char *mycoinaddr)
{
char *txidstr,checkasmstr[1024],*asmstr,*txid = 0; uint64_t value = 0; int32_t i,n,nval,reqSigs; cJSON *json,*scriptobj,*array,*item,*hexobj;
*locktimep = -1;
if ( (json= get_decoderaw_json(coin,rawtransaction)) != 0 )
{
*locktimep = (int32_t)get_cJSON_int(json,"locktime");
if ( (txidstr= jstr(json,"txid")) == 0 )
{
printf("subatomic_decodetxid no txid\n");
return(0);
}
txid = clonestr(txidstr);
array = cJSON_GetObjectItem(json,"vout");
if ( mycoinaddr != 0 && is_cJSON_Array(array) != 0 )
{
n = cJSON_GetArraySize(array);
for (i=0; i<n; i++)
{
item = cJSON_GetArrayItem(array,i);
hexobj = 0;
scriptobj = cJSON_GetObjectItem(item,"scriptPubKey");
if ( mycoinaddr != 0 && scriptobj != 0 && script_has_coinaddr(scriptobj,mycoinaddr) != 0 )
{
nval = (int32_t)get_cJSON_int(item,"n");
if ( nval == i )
{
reqSigs = (int32_t)get_cJSON_int(item,"reqSigs");
value = conv_cJSON_float(item,"value");
hexobj = cJSON_GetObjectItem(scriptobj,"hex");
if ( scriptPubKey != 0 && hexobj != 0 )
copy_cJSON(scriptPubKey,hexobj);
if ( reqSigs == 1 && hexobj != 0 )
{
sprintf(checkasmstr,"OP_DUP OP_HASH160 %s OP_EQUALVERIFY OP_CHECKSIG","need to figure out how ot gen magic number");
if ( (asmstr= jstr(scriptobj,"asm")) != 0 && strcmp(asmstr,checkasmstr) != 0 )
printf("warning: (%s) != check.(%s)\n",asmstr,checkasmstr);
}
}
}
}
}
}
if ( valuep != 0 )
*valuep = value;
return(txid);
}
cJSON *subatomic_vins_json_params(struct coin777 *coin,struct subatomic_rawtransaction *rp)
{
int32_t i; cJSON *json,*array; struct subatomic_unspent_tx *up;
array = cJSON_CreateArray();
for (i=0; i<rp->numinputs; i++)
{
up = &rp->inputs[i];
json = cJSON_CreateObject();
jaddstr(json,"txid",up->txid.buf);
jaddnum(json,"vout",up->vout);
if ( up->scriptPubKey.buf[0] != 0 )
jaddstr(json,"scriptPubKey",up->scriptPubKey.buf);
if ( up->redeemScript.buf[0] != 0 )
jaddstr(json,"redeemScript",up->redeemScript.buf);
cJSON_AddItemToArray(array,json);
}
return(array);
}
cJSON *subatomic_privkeys_json_params(struct coin777 *coin,char **coinaddrs,int32_t n)
{
int32_t i; char *privkey; cJSON *array = cJSON_CreateArray();
//sprintf(walletkey,"[\"%s\",%d]",Global_subatomic->NXTADDR,BITCOIN_WALLET_UNLOCKSECONDS);
// locking first avoids error, hacky but no time for wallet fiddling now
//bitcoind_RPC(0,coin->name,coin->serverport,coin->userpass,"walletlock",0);
//bitcoind_RPC(0,coin->name,coin->serverport,coin->userpass,"walletpassphrase",walletkey);
for (i=0; i<n; i++)
{
if ( coinaddrs[i][0] != 0 )
{
printf("privkeys.(%s)\n",coinaddrs[i]);
if ( (privkey= dumpprivkey(coin->name,coin->serverport,coin->userpass,coinaddrs[i])) != 0 )
{
jaddistr(array,privkey);
free(privkey);
}
}
}
return(array);
}
char *subatomic_signraw_json_params(char *skipaddr,char *coinaddr,struct coin777 *coin,struct subatomic_rawtransaction *rp,char *rawbytes)
{
int32_t i,j,flag; char *coinaddrs[MAX_SUBATOMIC_INPUTS+1],*paramstr = 0; cJSON *array,*rawobj,*vinsobj,*keysobj;
if ( (rawobj= cJSON_CreateString(rawbytes)) != 0 )
{
if ( (vinsobj= subatomic_vins_json_params(coin,rp)) != 0 )
{
// printf("add %d inputs skipaddr.%s coinaddr.%s\n",rp->numinputs,skipaddr,coinaddr);
for (i=flag=j=0; i<rp->numinputs; i++)
{
if ( skipaddr == 0 || strcmp(rp->inputs[i].address.buf,skipaddr) != 0 )
{
printf("i.%d j.%d flag.%d %s\n",i,j,flag,rp->inputs[i].address.buf);
coinaddrs[j] = rp->inputs[i].address.buf;
if ( coinaddr != 0 && strcmp(coinaddrs[j],coinaddr) == 0 )
flag++;
j++;
}
}
//printf("i.%d j.%d flag.%d\n",i,j,flag);
//if ( coinaddr != 0 && flag == 0 )
//coinaddrs[j++] = coinaddr;
coinaddrs[j] = 0;
keysobj = subatomic_privkeys_json_params(coin,coinaddrs,j);
if ( keysobj != 0 )
{
array = cJSON_CreateArray();
cJSON_AddItemToArray(array,rawobj);
cJSON_AddItemToArray(array,vinsobj);
cJSON_AddItemToArray(array,keysobj);
paramstr = cJSON_Print(array);
free_json(array);
}
else free_json(vinsobj);
}
else free_json(rawobj);
}
return(paramstr);
}
char *subatomic_signtx(char *skipaddr,uint32_t *lockedblockp,int64_t *valuep,char *coinaddr,char *signedtx,unsigned long destsize,struct coin777 *coin,struct subatomic_rawtransaction *rp,char *rawbytes)
{
cJSON *json,*compobj; char *retstr,*deststr,*signparams,*txid = 0; uint32_t locktime = 0;
rp->txid[0] = signedtx[0] = 0;
rp->completed = -1;
//printf("cp.%d vs %d: subatomic_signtx rawbytes.(%s)\n",cp->coinid,coinid,rawbytes);
if ( coin != 0 && (signparams= subatomic_signraw_json_params(skipaddr,coinaddr,coin,rp,rawbytes)) != 0 )
{
_stripwhite(signparams,' ');
//printf("got signparams.(%s)\n",signparams);
if ( (retstr= bitcoind_RPC(0,coin->name,coin->serverport,coin->userpass,"signrawtransaction",signparams)) != 0 )
{
//printf("got retstr.(%s)\n",retstr);
if ( (json= cJSON_Parse(retstr)) != 0 )
{
if ( (deststr= jstr(json,"hex")) != 0 )
{
compobj = cJSON_GetObjectItem(json,"complete");
if ( compobj != 0 )
rp->completed = ((compobj->type&0xff) == cJSON_True);
if ( strlen(deststr) > destsize )
printf("sign_rawtransaction: strlen(deststr) %ld > %ld destize\n",(long)strlen(deststr),destsize);
else
{
strcpy(signedtx,deststr);
txid = subatomic_decodetxid(valuep,0,&locktime,coin,deststr,coinaddr);
if ( txid != 0 )
{
safecopy(rp->txid,txid,sizeof(rp->txid));
free(txid);
txid = rp->txid;
}
// printf("got signedtransaction -> txid.(%s) %.8f\n",rp->txid,dstr(valuep!=0?*valuep:0));
}
} else printf("cant get hex from.(%s)\n",retstr);
free_json(json);
} else printf("json parse error.(%s)\n",retstr);
free(retstr);
} else printf("error signing rawtx\n");
free(signparams);
} else printf("error generating signparams\n");
if ( lockedblockp != 0 )
*lockedblockp = locktime;
return(txid);
}
cJSON *subatomic_vouts_json_params(struct subatomic_rawtransaction *rp)
{
int32_t i; cJSON *json,*obj;
json = cJSON_CreateObject();
for (i=0; i<rp->numoutputs; i++)
{
obj = cJSON_CreateNumber((double)rp->destamounts[i]/SATOSHIDEN);
cJSON_AddItemToObject(json,rp->destaddrs[i],obj);
}
// printf("numdests.%d (%s)\n",rp->numoutputs,cJSON_Print(json));
return(json);
}
char *subatomic_rawtxid_json(struct coin777 *coin,struct subatomic_rawtransaction *rp)
{
char *paramstr = 0; cJSON *array,*vinsobj,*voutsobj;
if ( (vinsobj= subatomic_vins_json_params(coin,rp)) != 0 )
{
if ( (voutsobj= subatomic_vouts_json_params(rp)) != 0 )
{
array = cJSON_CreateArray();
cJSON_AddItemToArray(array,vinsobj);
cJSON_AddItemToArray(array,voutsobj);
paramstr = cJSON_Print(array);
free_json(array); // this frees both vinsobj and voutsobj
}
else free_json(vinsobj);
}
// printf("subatomic_rawtxid_json.%s\n",paramstr);
return(paramstr);
}
uint64_t subatomic_donation(struct coin777 *coin,uint64_t amount)
{
uint64_t donation = 0;
if ( coin->donationaddress[0] != 0 )
{
donation = amount >> 11;
if ( donation < coin->mgw.txfee )
donation = coin->mgw.txfee;
}
return(donation);
}
char *gather_account_addresses(struct coin777 *coin,char *account)
{
cJSON *array,*retarray,*subarray,*item; int32_t i,j,m,n; char *acct;
//printf("call listaddressgroupings\n");
if ( (array= _get_localaddresses(coin->name,coin->serverport,coin->userpass)) != 0 )
{
retarray = cJSON_CreateArray();
n = cJSON_GetArraySize(array);
for (i=0; i<n; i++)
{
if ( (subarray= jitem(array,i)) != 0 )
{
//printf("%d of %d: %s\n",i,n,jprint(subarray,0));
if ( is_cJSON_Array(subarray) != 0 && (m= cJSON_GetArraySize(subarray)) > 0 )
{
for (j=0; j<m; j++)
{
if ( (item= jitem(subarray,j)) != 0 && is_cJSON_Array(item) != 0 && cJSON_GetArraySize(item) > 2 )
{
if ( (acct= jstr(jitem(item,2),0)) != 0 && strcmp(acct,account) == 0 )
{
//printf("gather.(%s) %s\n",jstr(jitem(item,0),0),account);
jaddistr(retarray,jstr(jitem(item,0),0));
}
} //else printf("skip item.%p, %d %d\n",item,is_cJSON_Array(item),cJSON_GetArraySize(item));
}
}
}
}
free_json(array);
if ( cJSON_GetArraySize(retarray) == 0 )
{
free_json(retarray);
return(0);
}
else return(jprint(retarray,1));
}
else return(0);
}
struct subatomic_unspent_tx *gather_unspents(uint64_t *totalp,int32_t *nump,struct coin777 *coin,char *account)
{
int32_t i,j,num; struct subatomic_unspent_tx *ups = 0; char *params,*addrs,*retstr; cJSON *json,*item;
/*{
"txid" : "1ccd2a9d0f8d690ed13b6768fc6c041972362f5531922b6b152ed2c98d3fe113",
"vout" : 1,
"address" : "DK3nxu6GshBcQNDMqc66ARcwqDZ1B5TJe5",
"scriptPubKey" : "76a9149891029995222077889b36c77e2b85690878df9088ac",
"amount" : 2.00000000,
"confirmations" : 72505
},*/
*totalp = *nump = 0;
if ( account != 0 && account[0] != 0 )
{
if ( (addrs= gather_account_addresses(coin,account)) != 0 )
{
if ( (params = calloc(1,strlen(addrs) + 128)) == 0 )
{
free(addrs);
return(0);
}
addrs[strlen(addrs)-1] = 0;
sprintf(params,"[%d, 99999999, [%s]]",coin->minconfirms,addrs+1);
free(addrs);
} else return(0);
}
else
{
if ( (params = calloc(1,128)) == 0 )
return(0);
sprintf(params,"%d, 99999999",coin->minconfirms);
}
//printf("issue listunspent.(%s)\n",params);
if ( (retstr= bitcoind_passthru(coin->name,coin->serverport,coin->userpass,"listunspent",params)) != 0 )
{
//printf("unspents (%s)\n",retstr);
if ( (json= cJSON_Parse(retstr)) != 0 )
{
if ( is_cJSON_Array(json) != 0 && (num= cJSON_GetArraySize(json)) > 0 )
{
ups = calloc(num,sizeof(struct subatomic_unspent_tx));
for (i=j=0; i<num; i++)
{
item = cJSON_GetArrayItem(json,i);
copy_cJSON(&ups[j].address,cJSON_GetObjectItem(item,"address"));
//if ( skipcoinaddr == 0 || strcmp(skipcoinaddr,ups[j].address.buf) != 0 )
{
copy_cJSON(&ups[j].txid,cJSON_GetObjectItem(item,"txid"));
copy_cJSON(&ups[j].scriptPubKey,cJSON_GetObjectItem(item,"scriptPubKey"));
ups[j].vout = (int32_t)get_cJSON_int(item,"vout");
ups[j].amount = conv_cJSON_float(item,"amount");
ups[j].confirmations = (int32_t)get_cJSON_int(item,"confirmations");
*totalp += ups[j].amount;
j++;
}
}
*nump = j;
if ( j > 0 )
{
int _decreasing_signedint64(const void *a,const void *b);
if ( j > 1 )
qsort(ups,j,sizeof(*ups),_decreasing_signedint64);
if ( coin->changeaddr[0] == 0 )
strcpy(coin->changeaddr,ups[0].address.buf);
//for (i=0; i<j; i++)
//printf("%s/v%-3d %13.6f %s confs.%-6d | total %.6f\n",ups[i].txid.buf,ups[i].vout,dstr(ups[i].amount),ups[i].address.buf,ups[i].confirmations,dstr(*totalp));
}
}
free_json(json);
}
free(retstr);
}
free(params);
if ( *nump == 0 )
printf("no (%s) unspents for (%s)\n",coin->name,account != 0 ? account : "");
return(ups);
}
struct subatomic_unspent_tx *subatomic_bestfit(struct coin777 *coin,struct subatomic_unspent_tx *unspents,int32_t numunspents,uint64_t value,int32_t mode)
{
int32_t i; uint64_t above,below,gap,atx_value; struct subatomic_unspent_tx *vin,*abovevin,*belowvin;
abovevin = belowvin = 0;
for (above=below=i=0; i<numunspents; i++)
{
vin = &unspents[i];
atx_value = vin->amount;
//printf("(%.8f vs %.8f)\n",dstr(atx_value),dstr(value));
if ( atx_value == value )
return(vin);
else if ( atx_value > value )
{
gap = (atx_value - value);
if ( above == 0 || gap < above )
{
above = gap;
abovevin = vin;
}
}
else if ( mode == 0 )
{
gap = (value - atx_value);
if ( below == 0 || gap < below )
{
below = gap;
belowvin = vin;
}
}
}
if ( (vin= (abovevin != 0) ? abovevin : belowvin) == 0 && mode == 1 )
vin = unspents;
return(vin);
}
int64_t subatomic_calc_rawinputs(struct coin777 *coin,struct subatomic_rawtransaction *rp,uint64_t amount,struct subatomic_unspent_tx *ups,int32_t num,uint64_t donation)
{
uint64_t sum = 0; struct subatomic_unspent_tx *up; int32_t i;
rp->inputsum = rp->numinputs = 0;
printf("unspent num %d, amount %.8f vs donation %.8f txfee %.8f\n",num,dstr(amount),dstr(donation),dstr(coin->mgw.txfee));
if ( coin == 0 || num == 0 ) // (donation + coin->mgw.txfee) > amount ||
return(0);
amount += coin->mgw.txfee + donation;
for (i=0; i<num&&i<((int32_t)(sizeof(rp->inputs)/sizeof(*rp->inputs))); i++)
{
if ( (up= subatomic_bestfit(coin,ups,num,amount,0)) != 0 )
{
sum += up->amount;
rp->inputs[rp->numinputs++] = *up;
if ( sum >= amount )
{
rp->amount = (amount - coin->mgw.txfee - donation);
rp->change = (sum - amount);
rp->inputsum = sum;
printf("numinputs %d sum %.8f vs amount %.8f change %.8f -> txfee %.8f\n",rp->numinputs,dstr(rp->inputsum),dstr(amount),dstr(rp->change),dstr(sum - rp->change - rp->amount));
return(rp->inputsum);
}
}
printf("error getting bestfit unspent\n");
break;
}
printf("i.%d error numinputs %d sum %.8f\n",i,rp->numinputs,dstr(rp->inputsum));
return(0);
}
char *subatomic_gen_rawtransaction(char *skipaddr,struct coin777 *coin,struct subatomic_rawtransaction *rp,char *signcoinaddr,uint32_t locktime,uint32_t vin0sequenceid,char *redeem0script)
{
char *rawparams,*retstr,*txid=0; int64_t value; long len; struct cointx_info *cointx;
if ( (rawparams= subatomic_rawtxid_json(coin,rp)) != 0 )
{
_stripwhite(rawparams,' ');
//printf("create.(%s)\n",rawparams);
if ( (retstr= bitcoind_RPC(0,coin->name,coin->serverport,coin->userpass,"createrawtransaction",rawparams)) != 0 )
{
if ( retstr[0] != 0 )
{
// printf("calc_rawtransaction retstr.(%s)\n",retstr);
safecopy(rp->rawtransaction,retstr,sizeof(rp->rawtransaction));
len = strlen(rp->rawtransaction);
if ( len < 8 )
{
printf("funny rawtransactionlen %ld??\n",len);
free(rawparams);
return(0);
}
if ( locktime != 0 || redeem0script != 0 )
{
if ( (cointx= _decode_rawtransaction(rp->rawtransaction,coin->mgw.oldtx_format)) != 0 )
{
//printf("%s\n->\n",rp->rawtransaction);
cointx->nlocktime = locktime;
cointx->inputs[0].sequence = vin0sequenceid;
if ( redeem0script != 0 )
safecopy(cointx->outputs[0].script,redeem0script,sizeof(cointx->outputs[0].script));
_emit_cointx(rp->rawtransaction,sizeof(rp->rawtransaction),cointx,coin->mgw.oldtx_format);
_validate_decoderawtransaction(rp->rawtransaction,cointx,coin->mgw.oldtx_format);
//printf("spliced tx.(%s)\n",rp->rawtransaction);
free(cointx);
}
printf("locktime.%d sequenceid.%d signcoinaddr.(%s)\n",locktime,vin0sequenceid,signcoinaddr!=0?signcoinaddr:"");
}
if ( signcoinaddr != 0 )
{
txid = subatomic_signtx(skipaddr,0,&value,signcoinaddr,rp->signedtransaction,sizeof(rp->signedtransaction),coin,rp,rp->rawtransaction);
printf("signedtxid.%s\n",txid);
}
}
free(retstr);
} else printf("error creating rawtransaction from.(%s)\n",rawparams);
free(rawparams);
} else printf("error creating rawparams\n");
return(txid);
}
char *subatomic_signp2sh(char *sigstr,struct coin777 *coin,struct cointx_info *refT,int32_t msigflag,int32_t lockblocks,int32_t redeemi,char *redeemscript,int32_t p2shflag,char *privkeystr,int32_t privkeyind,char *othersig,char *otherpubkey,char *checkprivkey)
{
char hexstr[1024],pubP[128],*sig0,*sig1; bits256 hash2; uint8_t data[4096],sigbuf[512]; struct bp_key key,keyV;
struct cointx_info *T; int32_t i,n; void *sig = NULL; size_t siglen = 0; struct cointx_input *vin;
if ( (T= calloc(1,sizeof(*T))) == 0 )
return(0);
if ( privkeystr != 0 )
btc_setprivkey(&key,privkeystr);
*T = *refT; vin = &T->inputs[redeemi];
for (i=0; i<T->numinputs; i++)
strcpy(T->inputs[i].sigs,"00");
strcpy(vin->sigs,redeemscript);
if ( msigflag == 0 )
{
vin->sequence = (uint32_t)-1;
T->nlocktime = 0;
}
else
{
if ( vin->sequence == 0 )
vin->sequence = (uint32_t)time(NULL);
if ( T->nlocktime == 0 && lockblocks != 0 )
{
if ( lockblocks != 0 )
{
coin->ramchain.RTblocknum = _get_RTheight(&coin->ramchain.lastgetinfo,coin->name,coin->serverport,coin->userpass,coin->ramchain.RTblocknum);
if ( coin->ramchain.RTblocknum == 0 )
{
printf("cant get RTblocknum for %s\n",coin->name);
free(T);
return(0);
}
lockblocks += coin->ramchain.RTblocknum;
}
T->nlocktime = lockblocks;
}
}
//disp_cointx(&T);
emit_cointx(&hash2,data,sizeof(data),T,coin->mgw.oldtx_format,SIGHASH_ALL);
//printf("HASH2.(%llx)\n",(long long)hash2.txid);
if ( msigflag != 0 )
{
if ( othersig != 0 )
{
n = (int32_t)strlen(otherpubkey) >> 1;
decode_hex(data,n,otherpubkey);
if ( bp_key_init(&keyV) == 0 || bp_pubkey_set(&keyV,data,n) == 0 )
{
printf("cant set pubkey\n");
free(T);
return(0);
}
n = (int32_t)strlen(othersig) >> 1;
decode_hex(data,n,othersig);
if ( data[n-1] != SIGHASH_ALL )
{
printf("othersig.(%s) hash type mismatch %d != %d\n",othersig,data[n-1],SIGHASH_ALL);
free(T);
return(0);
}
if ( bp_verify(&keyV,hash2.bytes,sizeof(hash2),data,n-1) == 0 )
{
hexstr[0] = 0;
if ( checkprivkey != 0 )
{
//printf("checkprivkey.(%s)\n",checkprivkey);
btc_setprivkey(&keyV,checkprivkey);
void *dispkey; size_t slen;
bp_privkey_get(&keyV,&dispkey,&slen);
//for (i=0; i<slen; i++)
// printf("%02x",((uint8_t *)dispkey)[i]);
//printf(" checkkey\n");
if ( bp_sign(&keyV,hash2.bytes,sizeof(hash2),&sig,&siglen) != 0 )
init_hexbytes_noT(hexstr,sigbuf,(int32_t)siglen);
}
printf("othersig.(%s) doesnt verify vs (%s)\n",othersig,hexstr);
//return(0);
} else printf("SIG.%d VERIFIED\n",privkeyind ^ 1);
}
if ( privkeystr != 0 )
{
void *dispkey; size_t slen;
bp_privkey_get(&key,&dispkey,&slen);
//for (i=0; i<slen; i++)
// printf("%02x",((uint8_t *)dispkey)[i]);
//printf(" dispkey.(%s)\n",privkeystr);
if ( bp_sign(&key,hash2.bytes,sizeof(hash2),&sig,&siglen) != 0 )
{
memcpy(sigbuf,sig,siglen);
sigbuf[siglen++] = SIGHASH_ALL;
init_hexbytes_noT(hexstr,sigbuf,(int32_t)siglen);
if ( sigstr != 0 )
strcpy(sigstr,hexstr);
if ( privkeyind == 0 )
sig0 = hexstr, sig1 = othersig != 0 ? othersig : "";
else sig1 = hexstr, sig0 = othersig != 0 ? othersig : "";
sprintf(vin->sigs,"00%02x%s%02x%s51",(int32_t)strlen(sig0)>>1,sig0,(int32_t)strlen(sig1)>>1,sig1);
//printf("after A.(%s) othersig.(%s) siglen.%02lx -> (%s)\n",hexstr,othersig != 0 ? othersig : "",siglen,vin->sigs);
}
else
{
printf("error signing\n");
free(T);
return(0);
}
}
else vin->sigs[0] = 0;
}
else
{
if ( bp_sign(&key,hash2.bytes,sizeof(hash2),&sig,&siglen) != 0 && btc_getpubkey(pubP,data,&key) > 0 )
{
memcpy(sigbuf,sig,siglen);
sigbuf[siglen++] = SIGHASH_ALL;
init_hexbytes_noT(hexstr,sigbuf,(int32_t)siglen);
sprintf(vin->sigs,"%02x%s%02x%s00",(int32_t)siglen,hexstr,(int32_t)strlen(pubP)/2,pubP);
//printf("after P.(%s) siglen.%02lx\n",vin->sigs,siglen);
}
}
if ( vin->sigs[0] != 0 )
{
if ( p2shflag != 0 )
sprintf(&vin->sigs[strlen(vin->sigs)],"4c%02x",(int32_t)strlen(redeemscript)/2);
sprintf(&vin->sigs[strlen(vin->sigs)],"%s",redeemscript);
}
//printf("scriptSig.(%s)\n",vin->sigs);
_emit_cointx(hexstr,sizeof(hexstr),T,coin->mgw.oldtx_format);
//disp_cointx(&T);
free(T);
return(clonestr(hexstr));
//printf("T.msigredeem %d -> (%s)\n",msigflag,hexstr);
}
char *subatomic_fundingtx(char *refredeemscript,struct subatomic_rawtransaction *funding,struct coin777 *coin,char *mypubkey,char *otherpubkey,char *pkhash,uint64_t amount,int32_t lockblocks)
{
char scriptPubKey[128],mycoinaddr[64],p2shaddr[64],sigstr[512],*refundtx=0,*redeemscript,*txid=0; struct subatomic_unspent_tx *utx;
uint64_t total,donation; int32_t num,n=0,lockblock = 0; struct cointx_info *refT; uint8_t rmd160[20];
memset(funding,0,sizeof(*funding));
refredeemscript[0] = 0;
if ( (redeemscript= create_atomictx_scripts(coin->p2shtype,scriptPubKey,p2shaddr,mypubkey,otherpubkey,pkhash)) != 0 )
{
strcpy(refredeemscript,redeemscript);
if ( btc_coinaddr(mycoinaddr,coin->addrtype,mypubkey) != 0 && (utx= gather_unspents(&total,&num,coin,0)) != 0 )
{
donation = subatomic_donation(coin,amount);
//printf("CREATE FUNDING TX.(%s) [%s %s %s] for %.8f -> %s locktime.%u donation %.8f\n",coin->name,mypubkey,otherpubkey,pkhash,dstr(amount),p2shaddr,lockblock,dstr(donation));
if ( subatomic_calc_rawinputs(coin,funding,amount,utx,num,donation) >= amount )
{
if ( funding->amount == amount && funding->change == (funding->inputsum - amount - coin->mgw.txfee - donation) )
{
safecopy(funding->destaddrs[n],p2shaddr,sizeof(funding->destaddrs[n]));
funding->destamounts[n] = amount;
n++;
}
if ( donation != 0 )
{
if ( coin->donationaddress[0] != 0 )
{
safecopy(funding->destaddrs[n],coin->donationaddress,sizeof(funding->destaddrs[n]));
funding->destamounts[n] = donation;
n++;
} else funding->change += donation;
}
if ( funding->change != 0 )
{
if ( coin->changeaddr[0] == 0 )
{
printf("no changeaddress for (%s)\n",coin->name);
return(0);
}
safecopy(funding->destaddrs[n],coin->changeaddr,sizeof(funding->destaddrs[n]));
funding->destamounts[n] = funding->change;
n++;
}
funding->numoutputs = n;
if ( (txid= subatomic_gen_rawtransaction(0,coin,funding,p2shaddr,lockblock,lockblock==0?0xffffffff:(uint32_t)time(NULL),coin->usep2sh!=0?0:redeemscript)) == 0 )
printf("error creating tx\n");
else
{
if ( (refT= calloc(1,sizeof(*refT))) == 0 )
return(0);
refT->version = 1;
refT->timestamp = (uint32_t)time(NULL);
strcpy(refT->inputs[0].tx.txidstr,txid);
refT->inputs[0].tx.vout = 0;
refT->numinputs = 1;
strcpy(scriptPubKey,"76a914");
calc_OP_HASH160(scriptPubKey+6,rmd160,mypubkey);
strcat(scriptPubKey,"88ac");
if ( mycoinaddr[0] != 0 )
{
strcpy(refT->outputs[0].coinaddr,mycoinaddr);
strcpy(refT->outputs[0].script,scriptPubKey);
refT->outputs[0].value = funding->destamounts[0] - coin->mgw.txfee;
refT->numoutputs = 1;
if ( lockblocks == 0 )
lockblocks = 10;
refundtx = subatomic_signp2sh(sigstr,coin,refT,1,lockblocks,0,redeemscript,coin->usep2sh,0,0,0,0,0);
free(refT);
} else printf("cant get %s addr from (%s)\n",coin->name,mypubkey);
}
} else printf("error: probably not enough funds\n");
} else printf("error: btc_coinaddr.(%s)\n",mycoinaddr);
free(redeemscript);
} else printf("subatomic_fundingtx: cant create redeemscript\n");
return(refundtx);
}
char *subatomic_spendtx(struct destbuf *spendtxid,char *vintxid,char *refundsig,struct coin777 *coin,char *otherpubkey,char *mypubkey,char *onetimepubkey,uint64_t amount,char *refundtx,char *refredeemscript)
{
char scriptPubKey[128],p2shaddr[64],rmdstr[41],onetimecoinaddr[64],msigcoinaddr[64],sigstr[512]; cJSON *json;
char *redeemscript,*signedtx,*spendtx=0,*mprivkey,*oprivkey; uint8_t rmd160[20]; long diff=0; struct cointx_info *refundT=0;
refundsig[0] = onetimecoinaddr[0] = msigcoinaddr[0] = spendtxid->buf[0] = vintxid[0] = 0;
if ( btc_coinaddr(onetimecoinaddr,coin->addrtype,onetimepubkey) != 0 && btc_coinaddr(msigcoinaddr,coin->addrtype,mypubkey) != 0 )
{
//printf("mypubkey.(%s) -> (%s)\n",mypubkey,msigcoinaddr);
calc_OP_HASH160(rmdstr,rmd160,onetimepubkey);
amount -= coin->mgw.txfee;
coin->ramchain.RTblocknum = _get_RTheight(&coin->ramchain.lastgetinfo,coin->name,coin->serverport,coin->userpass,coin->ramchain.RTblocknum);
if ( (refundT= _decode_rawtransaction(refundtx,coin->mgw.oldtx_format)) != 0 && refundT->inputs[0].sequence != 0xffffffff && refundT->nlocktime != 0 && (diff= ((long)refundT->nlocktime - coin->ramchain.RTblocknum)) > 1 && diff < 1000 )
{
strcpy(vintxid,refundT->inputs[0].tx.txidstr);
if ( (redeemscript= create_atomictx_scripts(coin->p2shtype,scriptPubKey,p2shaddr,otherpubkey,mypubkey,rmdstr)) != 0 )
{
if ( refundT->outputs[0].value == amount && strcmp(refredeemscript,redeemscript) == 0 && refundT->numinputs == 1 && refundT->numoutputs == 1 )
{
if ( (mprivkey= dumpprivkey(coin->name,coin->serverport,coin->userpass,msigcoinaddr)) != 0 && (oprivkey= dumpprivkey(coin->name,coin->serverport,coin->userpass,onetimecoinaddr)) != 0 )
{
//printf("mprivkey.(%s)\n",mprivkey);
if ( (signedtx= subatomic_signp2sh(refundsig,coin,refundT,1,0,0,redeemscript,coin->usep2sh,mprivkey,1,0,0,0)) != 0 )
{
//printf("one sig.(%s)\n",signedtx);
free(signedtx);
strcpy(refundT->outputs[0].coinaddr,onetimecoinaddr);
sprintf(scriptPubKey,"76a914%s88ac",rmdstr);
strcpy(refundT->outputs[0].script,scriptPubKey);
spendtx = subatomic_signp2sh(sigstr,coin,refundT,0,0,0,redeemscript,coin->usep2sh,oprivkey,0,0,0,0);
if ( (json= get_decoderaw_json(coin,spendtx)) != 0 )
{
copy_cJSON(spendtxid,jobj(json,"txid"));
free_json(json);
}
} else printf("Error signing\n");
free(mprivkey);
free(oprivkey);
}
else
{
if ( mprivkey != 0 )
free(mprivkey);
printf("error getting privkeys M.(%s) onetime.(%s)\n",msigcoinaddr,onetimecoinaddr);
}
} else printf("error (%.8f vs %.8f) comparing redeemscript.(%s) vs (%s) io.(%d %d)\n",dstr(refundT->outputs[0].value),dstr(amount),refredeemscript,redeemscript,refundT->numinputs,refundT->numoutputs);
free(redeemscript);
} else printf("error creating redeemscript\n");
free(refundT);
} else printf("error decoding refundT.%p or diff %ld too big (%u %u)\n",refundT,diff,refundT->nlocktime,coin->ramchain.RTblocknum);
} else printf("error getting addresses (%s) (%s)\n",msigcoinaddr,onetimecoinaddr);
return(spendtx);
}
char *subatomic_validate(struct coin777 *coin,char *pubA,char *pubB,char *pkhash,char *refundtx,char *refundsig)
{
char scriptPubKey[512],mycoinaddr[64],p2shaddr[128],mysig[512],*redeemscript,*privkeystr,*signedrefund=0;
struct cointx_info *refundT;
if ( (refundT= _decode_rawtransaction(refundtx,coin->mgw.oldtx_format)) != 0 && btc_coinaddr(mycoinaddr,coin->addrtype,pubA) != 0 )
{
if ( (privkeystr= dumpprivkey(coin->name,coin->serverport,coin->userpass,mycoinaddr)) != 0 )
{
if ( (redeemscript= create_atomictx_scripts(coin->p2shtype,scriptPubKey,p2shaddr,pubA,pubB,pkhash)) != 0 )
{
if ( (signedrefund= subatomic_signp2sh(mysig,coin,refundT,1,0,0,redeemscript,1,privkeystr,0,refundsig,pubB,0)) != 0 )
{
//printf("SIGNEDREFUND.(%s)\n",signedrefund);
}
free(redeemscript);
}
free(privkeystr);
}
free(refundT);
}
return(signedrefund);
}
void test_subatomic()
{
char pkhash[8192],pubA[67],pubB[67],pubP[67]; uint8_t tmpbuf[512]; struct coin777 *coin;
struct subatomic_rawtransaction funding; char refredeemscript[4096],vintxid[128],swapacct[64],othercoinaddr[64],mycoinaddr[64],onetimeaddr[64],refundsig[512],*signedrefund,*refundtx=0,*spendtx=0;
uint64_t amount; struct destbuf pubkey; struct destbuf spendtxid;
coin = coin777_find("BTCD",1);
if ( strcmp(coin->name,"BTC") == 0 )
coin->mgw.oldtx_format = 1;
//coin->usep2sh = 0;
strcpy(mycoinaddr,coin->atomicsend),get_pubkey(&pubkey,coin->name,coin->serverport,coin->userpass,mycoinaddr), strcpy(pubA,pubkey.buf);
strcpy(othercoinaddr,coin->atomicrecv),get_pubkey(&pubkey,coin->name,coin->serverport,coin->userpass,othercoinaddr), strcpy(pubB,pubkey.buf);
sprintf(swapacct,"%u",777);
if ( get_acct_coinaddr(onetimeaddr,coin->name,coin->serverport,coin->userpass,swapacct) != 0 )
{
get_pubkey(&pubkey,coin->name,coin->serverport,coin->userpass,onetimeaddr);
strcpy(pubP,pubkey.buf);
printf("onetimeadddr.(%s) pubkey.(%s)\n",onetimeaddr,pubP);
}
calc_OP_HASH160(pkhash,tmpbuf,pubP);
amount = 20000;
printf("pkhash.(%s)\n",pkhash);
if ( (refundtx= subatomic_fundingtx(refredeemscript,&funding,coin,pubA,pubB,pkhash,20000,10)) != 0 )
{
printf("FUNDING.(%s) unsignedrefund.(%s)\n",funding.signedtransaction,refundtx);
if ( (spendtx= subatomic_spendtx(&spendtxid,vintxid,refundsig,coin,pubA,pubB,pubP,amount,refundtx,refredeemscript)) != 0 )
{
printf("vin.%s SPENDTX.(%s) %s refundsig.(%s)\n",vintxid,spendtx,spendtxid.buf,refundsig);
if ( (signedrefund= subatomic_validate(coin,pubA,pubB,pkhash,refundtx,refundsig)) != 0 )
{
printf("SIGNEDREFUND.(%s)\n",signedrefund);
free(signedrefund);
} else printf("null signedrefund\n");
} else printf("null spendtx\n");
free(refundtx);
}
getchar();
}
#endif
#endif