diff --git a/src/cc/dapps/Makefile b/src/cc/dapps/Makefile
index 6e7874788..1fea27084 100644
--- a/src/cc/dapps/Makefile
+++ b/src/cc/dapps/Makefile
@@ -1,6 +1,10 @@
+# Copyright 2020 The Hush Developers
 # just type make to compile all dapps
 all: zmigrate oraclefeed
 
+subatomic:
+	$(CC) subatomic.c -o subatomic -lm
+
 zmigrate:
 	$(CC) zmigrate.c -o zmigrate -lm
 
@@ -9,3 +13,4 @@ oraclefeed:
 
 clean:
 	rm zmigrate oraclefeed
+
diff --git a/src/cc/dapps/dappinc.h b/src/cc/dapps/dappinc.h
new file mode 100644
index 000000000..3c71dfdec
--- /dev/null
+++ b/src/cc/dapps/dappinc.h
@@ -0,0 +1,1599 @@
+/******************************************************************************
+ * Copyright © 2014-2020 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.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <memory.h>
+#include "cJSON.c"
+
+bits256 zeroid;
+
+int32_t unstringbits(char *buf,uint64_t bits)
+{
+    int32_t i;
+    for (i=0; i<8; i++,bits>>=8)
+        if ( (buf[i]= (char)(bits & 0xff)) == 0 )
+            break;
+    buf[i] = 0;
+    return(i);
+}
+
+uint64_t stringbits(char *str)
+{
+    uint64_t bits = 0;
+    if ( str == 0 )
+        return(0);
+    int32_t i,n = (int32_t)strlen(str);
+    if ( n > 8 )
+        n = 8;
+    for (i=n-1; i>=0; i--)
+        bits = (bits << 8) | (str[i] & 0xff);
+    //printf("(%s) -> %llx %llu\n",str,(long long)bits,(long long)bits);
+    return(bits);
+}
+
+char hexbyte(int32_t c)
+{
+    c &= 0xf;
+    if ( c < 10 )
+        return('0'+c);
+    else if ( c < 16 )
+        return('a'+c-10);
+    else return(0);
+}
+
+int32_t _unhex(char c)
+{
+    if ( c >= '0' && c <= '9' )
+        return(c - '0');
+    else if ( c >= 'a' && c <= 'f' )
+        return(c - 'a' + 10);
+    else if ( c >= 'A' && c <= 'F' )
+        return(c - 'A' + 10);
+    return(-1);
+}
+
+int32_t is_hexstr(char *str,int32_t n)
+{
+    int32_t i;
+    if ( str == 0 || str[0] == 0 )
+        return(0);
+    for (i=0; str[i]!=0; i++)
+    {
+        if ( n > 0 && i >= n )
+            break;
+        if ( _unhex(str[i]) < 0 )
+            break;
+    }
+    if ( n == 0 )
+        return(i);
+    return(i == n);
+}
+
+int32_t unhex(char c)
+{
+    int32_t hex;
+    if ( (hex= _unhex(c)) < 0 )
+    {
+        //printf("unhex: illegal hexchar.(%c)\n",c);
+    }
+    return(hex);
+}
+
+unsigned char _decode_hex(char *hex) { return((unhex(hex[0])<<4) | unhex(hex[1])); }
+
+int32_t decode_hex(unsigned char *bytes,int32_t n,char *hex)
+{
+    int32_t adjust,i = 0;
+    //printf("decode.(%s)\n",hex);
+    if ( is_hexstr(hex,n) <= 0 )
+    {
+        memset(bytes,0,n);
+        return(n);
+    }
+    if ( hex[n-1] == '\n' || hex[n-1] == '\r' )
+        hex[--n] = 0;
+    if ( hex[n-1] == '\n' || hex[n-1] == '\r' )
+        hex[--n] = 0;
+    if ( n == 0 || (hex[n*2+1] == 0 && hex[n*2] != 0) )
+    {
+        if ( n > 0 )
+        {
+            bytes[0] = unhex(hex[0]);
+            printf("decode_hex n.%d hex[0] (%c) -> %d hex.(%s) [n*2+1: %d] [n*2: %d %c] len.%ld\n",n,hex[0],bytes[0],hex,hex[n*2+1],hex[n*2],hex[n*2],(long)strlen(hex));
+        }
+        bytes++;
+        hex++;
+        adjust = 1;
+    } else adjust = 0;
+    if ( n > 0 )
+    {
+        for (i=0; i<n; i++)
+            bytes[i] = _decode_hex(&hex[i*2]);
+    }
+    //bytes[i] = 0;
+    return(n + adjust);
+}
+
+int32_t init_hexbytes_noT(char *hexbytes,unsigned char *message,long len)
+{
+    int32_t i;
+    if ( len <= 0 )
+    {
+        hexbytes[0] = 0;
+        return(1);
+    }
+    for (i=0; i<len; i++)
+    {
+        hexbytes[i*2] = hexbyte((message[i]>>4) & 0xf);
+        hexbytes[i*2 + 1] = hexbyte(message[i] & 0xf);
+        //printf("i.%d (%02x) [%c%c]\n",i,message[i],hexbytes[i*2],hexbytes[i*2+1]);
+    }
+    hexbytes[len*2] = 0;
+    //printf("len.%ld\n",len*2+1);
+    return((int32_t)len*2+1);
+}
+
+long _stripwhite(char *buf,int accept)
+{
+    int32_t i,j,c;
+    if ( buf == 0 || buf[0] == 0 )
+        return(0);
+    for (i=j=0; buf[i]!=0; i++)
+    {
+        buf[j] = c = buf[i];
+        if ( c == accept || (c != ' ' && c != '\n' && c != '\r' && c != '\t' && c != '\b') )
+            j++;
+    }
+    buf[j] = 0;
+    return(j);
+}
+
+char *clonestr(char *str)
+{
+    char *clone;
+    if ( str == 0 || str[0]==0)
+    {
+        printf("warning cloning nullstr.%p\n",str);
+        //#ifdef __APPLE__
+        //        while ( 1 ) sleep(1);
+        //#endif
+        str = (char *)"<nullstr>";
+    }
+    clone = (char *)malloc(strlen(str)+16);
+    strcpy(clone,str);
+    return(clone);
+}
+
+int32_t safecopy(char *dest,char *src,long len)
+{
+    int32_t i = -1;
+    if ( src != 0 && dest != 0 && src != dest )
+    {
+        if ( dest != 0 )
+            memset(dest,0,len);
+        for (i=0; i<len&&src[i]!=0; i++)
+            dest[i] = src[i];
+        if ( i == len )
+        {
+            printf("safecopy: %s too long %ld\n",src,len);
+            //printf("divide by zero! %d\n",1/zeroval());
+#ifdef __APPLE__
+            //getchar();
+#endif
+            return(-1);
+        }
+        dest[i] = 0;
+    }
+    return(i);
+}
+
+char *bits256_str(char hexstr[65],bits256 x)
+{
+    init_hexbytes_noT(hexstr,x.bytes,sizeof(x));
+    return(hexstr);
+}
+
+int64_t conv_floatstr(char *numstr)
+{
+    double val,corr;
+    val = atof(numstr);
+    corr = (val < 0.) ? -0.50000000001 : 0.50000000001;
+    return((int64_t)(val * SATOSHIDEN + corr));
+}
+
+char *nonportable_path(char *str)
+{
+    int32_t i;
+    for (i=0; str[i]!=0; i++)
+        if ( str[i] == '/' )
+            str[i] = '\\';
+    return(str);
+}
+
+char *portable_path(char *str)
+{
+#ifdef _WIN32
+    return(nonportable_path(str));
+#else
+#ifdef __PNACL
+    /*int32_t i,n;
+     if ( str[0] == '/' )
+     return(str);
+     else
+     {
+     n = (int32_t)strlen(str);
+     for (i=n; i>0; i--)
+     str[i] = str[i-1];
+     str[0] = '/';
+     str[n+1] = 0;
+     }*/
+#endif
+    return(str);
+#endif
+}
+
+void *loadfile(char *fname,uint8_t **bufp,long *lenp,long *allocsizep)
+{
+    FILE *fp;
+    long  filesize,buflen = *allocsizep;
+    uint8_t *buf = *bufp;
+    *lenp = 0;
+    if ( (fp= fopen(portable_path(fname),"rb")) != 0 )
+    {
+        fseek(fp,0,SEEK_END);
+        filesize = ftell(fp);
+        if ( filesize == 0 )
+        {
+            fclose(fp);
+            *lenp = 0;
+            //printf("loadfile null size.(%s)\n",fname);
+            return(0);
+        }
+        if ( filesize > buflen )
+        {
+            *allocsizep = filesize;
+            *bufp = buf = (uint8_t *)realloc(buf,(long)*allocsizep+64);
+        }
+        rewind(fp);
+        if ( buf == 0 )
+            printf("Null buf ???\n");
+        else
+        {
+            if ( fread(buf,1,(long)filesize,fp) != (unsigned long)filesize )
+                printf("error reading filesize.%ld\n",(long)filesize);
+            buf[filesize] = 0;
+        }
+        fclose(fp);
+        *lenp = filesize;
+        //printf("loaded.(%s)\n",buf);
+    } //else printf("OS_loadfile couldnt load.(%s)\n",fname);
+    return(buf);
+}
+
+void *filestr(long *allocsizep,char *_fname)
+{
+    long filesize = 0; char *fname,*buf = 0; void *retptr;
+    *allocsizep = 0;
+    fname = malloc(strlen(_fname)+1);
+    strcpy(fname,_fname);
+    retptr = loadfile(fname,(uint8_t **)&buf,&filesize,allocsizep);
+    free(fname);
+    return(retptr);
+}
+
+char *send_curl(char *url,char *fname)
+{
+    long fsize; char curlstr[1024];
+    sprintf(curlstr,"curl --url \"%s\" > %s",url,fname);
+    system(curlstr);
+    return(filestr(&fsize,fname));
+}
+
+cJSON *get_urljson(char *url,char *fname)
+{
+    char *jsonstr; cJSON *json = 0;
+    if ( (jsonstr= send_curl(url,fname)) != 0 )
+    {
+        //printf("(%s) -> (%s)\n",url,jsonstr);
+        json = cJSON_Parse(jsonstr);
+        free(jsonstr);
+    }
+    return(json);
+}
+
+//////////////////////////////////////////////
+// start of dapp
+//////////////////////////////////////////////
+int md_unlink(char *file)
+{
+#ifdef _WIN32
+    _chmod(file, 0600);
+    return( _unlink(file) );
+#else
+    return(unlink(file));
+#endif
+}
+
+char *REFCOIN_CLI,DPOW_pubkeystr[67],DPOW_secpkeystr[67],DPOW_handle[67],DPOW_recvaddr[64],DPOW_recvZaddr[128];
+
+cJSON *get_komodocli(char *refcoin,char **retstrp,char *acname,char *method,char *arg0,char *arg1,char *arg2,char *arg3,char *arg4,char *arg5,char *arg6)
+{
+    long fsize; cJSON *retjson = 0; char cmdstr[32768],*jsonstr,fname[32768];
+    sprintf(fname,"/tmp/notarizer_%s_%d",method,(rand() >> 17) % 10000);
+    //if ( (acname == 0 || acname[0] == 0) && strcmp(refcoin,"KMD") != 0 )
+    //    acname = refcoin;
+    if ( acname[0] != 0 )
+    {
+        if ( refcoin[0] != 0 && strcmp(refcoin,"KMD") != 0 && strcmp(refcoin,acname) != 0 )
+            printf("unexpected: refcoin.(%s) acname.(%s)\n",refcoin,acname);
+        sprintf(cmdstr,"komodo-cli -ac_name=%s %s %s %s %s %s %s %s %s > %s\n",acname,method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
+    }
+    else if ( strcmp(refcoin,"KMD") == 0 )
+        sprintf(cmdstr,"komodo-cli %s %s %s %s %s %s %s %s > %s\n",method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
+    else if ( REFCOIN_CLI != 0 && REFCOIN_CLI[0] != 0 )
+    {
+        sprintf(cmdstr,"%s %s %s %s %s %s %s %s %s > %s\n",REFCOIN_CLI,method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
+        //printf("ref.(%s) REFCOIN_CLI (%s)\n",refcoin,cmdstr);
+    }
+//fprintf(stderr,"system(%s)\n",cmdstr);
+    system(cmdstr);
+    *retstrp = 0;
+    if ( (jsonstr= filestr(&fsize,fname)) != 0 )
+    {
+        jsonstr[strlen(jsonstr)-1]='\0';
+        //fprintf(stderr,"%s -> jsonstr.(%s)\n",cmdstr,jsonstr);
+        if ( (jsonstr[0] != '{' && jsonstr[0] != '[') || (retjson= cJSON_Parse(jsonstr)) == 0 )
+            *retstrp = jsonstr;
+        else free(jsonstr);
+        md_unlink(fname);
+    } //else fprintf(stderr,"system(%s) -> NULL\n",cmdstr);
+    return(retjson);
+}
+
+cJSON *subatomic_cli(char *clistr,char **retstrp,char *method,char *arg0,char *arg1,char *arg2,char *arg3,char *arg4,char *arg5,char *arg6)
+{
+    long fsize; cJSON *retjson = 0; char cmdstr[32768],*jsonstr,fname[32768];
+    sprintf(fname,"/tmp/subatomic_%s_%d",method,(rand() >> 17) % 10000);
+    sprintf(cmdstr,"%s %s %s %s %s %s %s %s %s > %s\n",clistr,method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
+//fprintf(stderr,"system(%s)\n",cmdstr);
+    system(cmdstr);
+    *retstrp = 0;
+    if ( (jsonstr= filestr(&fsize,fname)) != 0 )
+    {
+        jsonstr[strlen(jsonstr)-1]='\0';
+        //fprintf(stderr,"%s -> jsonstr.(%s)\n",cmdstr,jsonstr);
+        if ( (jsonstr[0] != '{' && jsonstr[0] != '[') || (retjson= cJSON_Parse(jsonstr)) == 0 )
+            *retstrp = jsonstr;
+        else free(jsonstr);
+        md_unlink(fname);
+    } //else fprintf(stderr,"system(%s) -> NULL\n",cmdstr);
+    return(retjson);
+}
+
+bits256 komodobroadcast(char *refcoin,char *acname,cJSON *hexjson)
+{
+    char *hexstr,*retstr,str[65]; cJSON *retjson; bits256 txid;
+    memset(txid.bytes,0,sizeof(txid));
+    if ( (hexstr= jstr(hexjson,"hex")) != 0 )
+    {
+        if ( (retjson= get_komodocli(refcoin,&retstr,acname,"sendrawtransaction",hexstr,"","","","","","")) != 0 )
+        {
+            //fprintf(stderr,"broadcast.(%s)\n",jprint(retjson,0));
+            free_json(retjson);
+        }
+        else if ( retstr != 0 )
+        {
+            if ( strlen(retstr) >= 64 )
+            {
+                retstr[64] = 0;
+                decode_hex(txid.bytes,32,retstr);
+            }
+            fprintf(stderr,"broadcast %s txid.(%s)\n",strlen(acname)>0?acname:refcoin,bits256_str(str,txid));
+            free(retstr);
+        }
+    }
+    return(txid);
+}
+
+bits256 sendtoaddress(char *refcoin,char *acname,char *destaddr,int64_t satoshis,char *oprethexstr)
+{
+    char numstr[32],*retstr,str[65]; cJSON *retjson; bits256 txid;
+    memset(txid.bytes,0,sizeof(txid));
+    sprintf(numstr,"%.8f",(double)satoshis/SATOSHIDEN);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"sendtoaddress",destaddr,numstr,"false","","",oprethexstr,"")) != 0 )
+    {
+        fprintf(stderr,"unexpected sendrawtransaction json.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        if ( strlen(retstr) >= 64 )
+        {
+            retstr[64] = 0;
+            decode_hex(txid.bytes,32,retstr);
+        }
+        fprintf(stderr,"sendtoaddress %s %.8f txid.(%s)\n",destaddr,(double)satoshis/SATOSHIDEN,bits256_str(str,txid));
+        free(retstr);
+    }
+    return(txid);
+}
+
+bits256 tokentransfer(char *refcoin,char *acname,char *tokenid,char *destpub,int64_t units)
+{
+    char numstr[32],*retstr,str[65]; cJSON *retjson; bits256 txid;
+    memset(txid.bytes,0,sizeof(txid));
+    sprintf(numstr,"%llu",(long long)units);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"tokentransfer",tokenid,destpub,numstr,"","","","")) != 0 )
+    {
+        txid = komodobroadcast(refcoin,acname,retjson);
+        fprintf(stderr,"tokentransfer returned (%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"tokentransfer.(%s) error.(%s)\n",acname,retstr);
+        free(retstr);
+    }
+    return(txid);
+}
+
+char *get_tokenaddress(char *refcoin,char *acname,char *tokenaddr)
+{
+    char *retstr,*str; cJSON *retjson;
+    tokenaddr[0] = 0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"tokenaddress","","","","","","","")) != 0 )
+    {
+        if ( (str= jstr(retjson,"myCCAddress(Tokens)")) != 0 )
+        {
+            strcpy(tokenaddr,str);
+            fprintf(stderr,"tokenaddress returned (%s)\n",tokenaddr);
+            free_json(retjson);
+            return(tokenaddr);
+        }
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        //fprintf(stderr,"tokentransfer.(%s) error.(%s)\n",acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+int64_t get_tokenbalance(char *refcoin,char *acname,char *tokenid)
+{
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"tokenbalance",tokenid,"","","","","","")) != 0 )
+    {
+        amount = j64bits(retjson,"balance");
+        fprintf(stderr,"tokenbalance %llu\n",(long long)amount);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
+        free(retstr);
+    }
+    return (amount);
+}
+
+cJSON *get_decodescript(char *refcoin,char *acname,char *script)
+{
+    cJSON *retjson; char *retstr;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"decodescript",script,"","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_decodescript.(%s) error.(%s)\n",acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+char *get_createmultisig2(char *refcoin,char *acname,char *msigaddr,char *redeemscript,char *pubkeyA,char *pubkeyB)
+{
+    //char para 2 '["02c3af47b51a506b08b4ededb156cb4c3f9db9e0ac7ad27b8623c08a056fdcc220", "038e61fbface549a850862f12ed99b7cbeef5c2bd2d8f1daddb34809416f0259e1"]'
+    cJSON *retjson; char *retstr,*str,params[256]; int32_t height=0;
+    msigaddr[0] = 0;
+    redeemscript[0] = 0;
+    sprintf(params,"'[\"%s\", \"%s\"]'",pubkeyA,pubkeyB);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"createmultisig","2",params,"","","","","")) != 0 )
+    {
+        if ( (str= jstr(retjson,"address")) != 0 )
+            strcpy(msigaddr,str);
+        if ( (str= jstr(retjson,"redeemScript")) != 0 )
+            strcpy(redeemscript,str);
+        free_json(retjson);
+        if ( msigaddr[0] != 0 && redeemscript[0] != 0 )
+            return(msigaddr);
+        else return(0);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"%s get_createmultisig2.(%s) error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+int32_t get_coinheight(char *refcoin,char *acname,bits256 *blockhashp)
+{
+    cJSON *retjson; char *retstr; int32_t height=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getblockchaininfo","","","","","","","")) != 0 )
+    {
+        height = jint(retjson,"blocks");
+        *blockhashp = jbits256(retjson,"bestblockhash");
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"%s get_coinheight.(%s) error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(height);
+}
+
+bits256 get_coinblockhash(char *refcoin,char *acname,int32_t height)
+{
+    cJSON *retjson; char *retstr,heightstr[32]; bits256 hash;
+    memset(hash.bytes,0,sizeof(hash));
+    sprintf(heightstr,"%d",height);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getblockhash",heightstr,"","","","","","")) != 0 )
+    {
+        fprintf(stderr,"unexpected blockhash json.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        if ( strlen(retstr) >= 64 )
+        {
+            retstr[64] = 0;
+            decode_hex(hash.bytes,32,retstr);
+        }
+        free(retstr);
+    }
+    return(hash);
+}
+
+bits256 get_coinmerkleroot(char *refcoin,char *acname,bits256 blockhash,uint32_t *blocktimep)
+{
+    cJSON *retjson; char *retstr,str[65]; bits256 merkleroot;
+    memset(merkleroot.bytes,0,sizeof(merkleroot));
+    *blocktimep = 0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getblockheader",bits256_str(str,blockhash),"","","","","","")) != 0 )
+    {
+        merkleroot = jbits256(retjson,"merkleroot");
+        *blocktimep = juint(retjson,"time");
+        //fprintf(stderr,"got merkleroot.(%s)\n",bits256_str(str,merkleroot));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"%s %s get_coinmerkleroot error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(merkleroot);
+}
+
+uint32_t get_heighttime(char *refcoin,char *acname,int32_t height)
+{
+    bits256 blockhash; uint32_t blocktime;
+    blockhash = get_coinblockhash(refcoin,acname,height);
+    get_coinmerkleroot(refcoin,acname,blockhash,&blocktime);
+    return(blocktime);
+}
+
+int32_t get_coinheader(char *refcoin,char *acname,bits256 *blockhashp,bits256 *merklerootp,int32_t prevheight)
+{
+    int32_t height = 0; char str[65]; bits256 bhash; uint32_t blocktime;
+    if ( prevheight == 0 )
+        height = get_coinheight(refcoin,acname,&bhash) - 20;
+    else height = prevheight + 1;
+    if ( height > 0 )
+    {
+        *blockhashp = get_coinblockhash(refcoin,acname,height);
+        if ( bits256_nonz(*blockhashp) != 0 )
+        {
+            *merklerootp = get_coinmerkleroot(refcoin,acname,*blockhashp,&blocktime);
+            if ( bits256_nonz(*merklerootp) != 0 )
+                return(height);
+        }
+    }
+    memset(blockhashp,0,sizeof(*blockhashp));
+    memset(merklerootp,0,sizeof(*merklerootp));
+    return(0);
+}
+
+cJSON *get_rawmempool(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getrawmempool","","","","","","","")) != 0 )
+    {
+        //printf("mempool.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_rawmempool.(%s) error.(%s)\n",acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *get_addressutxos(char *refcoin,char *acname,char *coinaddr)
+{
+    cJSON *retjson; char *retstr,jsonbuf[256];
+    if ( refcoin[0] != 0 && strcmp(refcoin,"KMD") != 0 )
+        printf("warning: assumes %s has addressindex enabled\n",refcoin);
+    sprintf(jsonbuf,"{\\\"addresses\\\":[\\\"%s\\\"]}",coinaddr);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getaddressutxos",jsonbuf,"","","","","","")) != 0 )
+    {
+        //printf("addressutxos.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_addressutxos.(%s) error.(%s)\n",acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *get_rawtransaction(char *refcoin,char *acname,bits256 txid)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getrawtransaction",bits256_str(str,txid),"1","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_rawtransaction.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *get_z_viewtransaction(char *refcoin,char *acname,bits256 txid)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_viewtransaction",bits256_str(str,txid),"","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_z_viewtransaction.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *get_listunspent(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"listunspent","","","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_listunspent.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *get_getinfo(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getinfo","","","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"get_getinfo.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *z_listunspent(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_listunspent","","","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_listunspent.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *z_listoperationids(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_listoperationids","","","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_listoperationids.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *z_getoperationstatus(char *refcoin,char *acname,char *opid)
+{
+    cJSON *retjson; char *retstr,str[65],params[512];
+    sprintf(params,"'[\"%s\"]'",opid);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_getoperationstatus",params,"","","","","","")) != 0 )
+    {
+        //printf("got status (%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_getoperationstatus.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *z_getoperationresult(char *refcoin,char *acname,char *opid)
+{
+    cJSON *retjson; char *retstr,str[65],params[512];
+    sprintf(params,"'[\"%s\"]'",opid);
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_getoperationresult",params,"","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_getoperationresult.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+int32_t validateaddress(char *refcoin,char *acname,char *depositaddr, char* compare)
+{
+    cJSON *retjson; char *retstr; int32_t res=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"validateaddress",depositaddr,"","","","","","")) != 0 )
+    {
+        if (is_cJSON_True(jobj(retjson,compare)) != 0 ) res=1;
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"validateaddress.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return (res);
+}
+
+int32_t z_validateaddress(char *refcoin,char *acname,char *depositaddr, char *compare)
+{
+    cJSON *retjson; char *retstr; int32_t res=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_validateaddress",depositaddr,"","","","","","")) != 0 )
+    {
+        if (is_cJSON_True(jobj(retjson,compare)) != 0 )
+            res=1;
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_validateaddress.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return (res);
+}
+
+int64_t get_getbalance(char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getbalance","","","","","","","")) != 0 )
+    {
+        fprintf(stderr,"get_getbalance.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        amount = atof(retstr) * SATOSHIDEN;
+        sprintf(cmpstr,"%.8f",dstr(amount));
+        if ( strcmp(retstr,cmpstr) != 0 )
+            amount++;
+        //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
+        free(retstr);
+    }
+    return (amount);
+}
+
+int64_t z_getbalance(char *refcoin,char *acname,char *coinaddr)
+{
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_getbalance",coinaddr,"","","","","","")) != 0 )
+    {
+        fprintf(stderr,"z_getbalance.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        amount = atof(retstr) * SATOSHIDEN;
+        sprintf(cmpstr,"%.8f",dstr(amount));
+        if ( strcmp(retstr,cmpstr) != 0 )
+            amount++;
+        //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
+        free(retstr);
+    }
+    return (amount);
+}
+
+int32_t z_exportkey(char *privkey,char *refcoin,char *acname,char *zaddr)
+{
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
+    privkey[0] = 0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_exportkey",zaddr,"","","","","","")) != 0 )
+    {
+        fprintf(stderr,"z_exportkey.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+        return(-1);
+    }
+    else if ( retstr != 0 )
+    {
+        //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
+        strcpy(privkey,retstr);
+        free(retstr);
+        return(0);
+    }
+    return(-1);
+}
+
+int32_t getnewaddress(char *coinaddr,char *refcoin,char *acname)
+{
+    cJSON *retjson; char *retstr; int64_t amount=0; int32_t retval = -1;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"getnewaddress","","","","","","","")) != 0 )
+    {
+        fprintf(stderr,"getnewaddress.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        strcpy(coinaddr,retstr);
+        free(retstr);
+        retval = 0;
+    }
+    return(retval);
+}
+
+int32_t z_getnewaddress(char *coinaddr,char *refcoin,char *acname,char *typestr)
+{
+    cJSON *retjson; char *retstr; int64_t amount=0; int32_t retval = -1;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_getnewaddress",typestr,"","","","","","")) != 0 )
+    {
+        fprintf(stderr,"z_getnewaddress.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        strcpy(coinaddr,retstr);
+        free(retstr);
+        retval = 0;
+    }
+    return(retval);
+}
+
+int64_t find_onetime_amount(char *coinstr,char *coinaddr)
+{
+    cJSON *array,*item; int32_t i,n; char *addr; int64_t amount = 0;
+    coinaddr[0] = 0;
+    if ( (array= get_listunspent(coinstr,"")) != 0 )
+    {
+        //printf("got listunspent.(%s)\n",jprint(array,0));
+        if ( (n= cJSON_GetArraySize(array)) > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if (is_cJSON_False(jobj(item, "spendable")) != 0)
+                {
+                    continue;
+                }
+                if ( (addr= jstr(item,"address")) != 0 )
+                {
+                    strcpy(coinaddr,addr);
+                    amount = z_getbalance(coinstr,"",coinaddr);
+                    printf("found address.(%s) with amount %.8f\n",coinaddr,dstr(amount));
+                    break;
+                }
+            }
+        }
+        free_json(array);
+    }
+    return(amount);
+}
+
+int64_t find_sprout_amount(char *coinstr,char *zcaddr)
+{
+    cJSON *array,*item; int32_t i,n; char *addr; int64_t amount = 0;
+    zcaddr[0] = 0;
+    if ( (array= z_listunspent(coinstr,"")) != 0 )
+    {
+        if ( (n= cJSON_GetArraySize(array)) > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (addr= jstr(item,"address")) != 0 && addr[0] == 'z' && addr[1] == 'c' )
+                {
+                    strcpy(zcaddr,addr);
+                    amount = z_getbalance(coinstr,"",zcaddr);
+                    printf("found address.(%s) with amount %.8f\n",zcaddr,dstr(amount));
+                    break;
+                }
+            }
+        }
+        free_json(array);
+    }
+    return(amount);
+}
+
+void importaddress(char *refcoin,char *acname,char *depositaddr)
+{
+    cJSON *retjson; char *retstr;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"importaddress",depositaddr,"","true","","","","")) != 0 )
+    {
+        printf("importaddress.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"importaddress.(%s) %s error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+}
+
+int32_t z_sendmany(char *opidstr,char *coinstr,char *acname,char *srcaddr,char *destaddr,int64_t amount,char *memostr)
+{
+    cJSON *retjson; char *retstr,params[1024],addr[128]; int32_t retval = -1;
+    sprintf(params,"'[{\"address\":\"%s\",\"amount\":%.8f,\"memo\":\"%s\"}]'",destaddr,dstr(amount),memostr);
+    sprintf(addr,"\"%s\"",srcaddr);
+    printf("z_sendmany.(%s %s) from.(%s) -> %s\n",coinstr,acname,srcaddr,params);
+    if ( (retjson= get_komodocli(coinstr,&retstr,acname,"z_sendmany",addr,params,"","","","","")) != 0 )
+    {
+        printf("unexpected json z_sendmany.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_sendmany.(%s) -> opid.(%s)\n",coinstr,retstr);
+        strcpy(opidstr,retstr);
+        free(retstr);
+        retval = 0;
+    }
+    return(retval);
+}
+
+int32_t z_mergetoaddress(char *opidstr,char *coinstr,char *acname,char *destaddr)
+{
+    cJSON *retjson; char *retstr,addr[128],*opstr; int32_t retval = -1;
+    sprintf(addr,"[\\\"ANY_SPROUT\\\"]");
+    if ( (retjson= get_komodocli(coinstr,&retstr,acname,"z_mergetoaddress",addr,destaddr,"","","","","")) != 0 )
+    {
+        if ( (opstr= jstr(retjson,"opid")) != 0 )
+            strcpy(opidstr,opstr);
+        retval = jint(retjson,"remainingNotes");
+        fprintf(stderr,"%s\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_mergetoaddress.(%s) -> opid.(%s)\n",coinstr,retstr);
+        strcpy(opidstr,retstr);
+        free(retstr);
+    }
+    return(retval);
+}
+
+int32_t empty_mempool(char *coinstr,char *acname)
+{
+    cJSON *array; int32_t n;
+    if ( (array= get_rawmempool(coinstr,acname)) != 0 )
+    {
+        if ( (n= cJSON_GetArraySize(array)) > 0 )
+            return(0);
+        free_json(array);
+        return(1);
+    }
+    return(-1);
+}
+
+cJSON *getinputarray(int64_t *totalp,cJSON *unspents,int64_t required)
+{
+    cJSON *vin,*item,*vins = cJSON_CreateArray(); int32_t i,n,v; int64_t satoshis; bits256 txid;
+    *totalp = 0;
+    if ( (n= cJSON_GetArraySize(unspents)) > 0 )
+    {
+        for (i=0; i<n; i++)
+        {
+            item = jitem(unspents,i);
+            satoshis = jdouble(item,"amount") * SATOSHIDEN;
+            txid = jbits256(item,"txid");
+            v = jint(item,"vout");
+            if ( bits256_nonz(txid) != 0 )
+            {
+                vin = cJSON_CreateObject();
+                jaddbits256(vin,"txid",txid);
+                jaddnum(vin,"vout",v);
+                jaddi(vins,vin);
+                *totalp += satoshis;
+                if ( (*totalp) >= required )
+                    break;
+            }
+        }
+    }
+    return(vins);
+}
+
+int32_t tx_has_voutaddress(char *refcoin,char *acname,bits256 txid,char *coinaddr)
+{
+    cJSON *txobj,*vouts,*vout,*vins,*vin,*sobj,*addresses; char *addr,str[65]; int32_t i,j,n,numarray,retval = 0, hasvout=0;
+    if ( (txobj= get_rawtransaction(refcoin,acname,txid)) != 0 )
+    {
+        if ( (vouts= jarray(&numarray,txobj,"vout")) != 0 )
+        {
+            for (i=0; i<numarray; i++)
+            {
+                if ((vout = jitem(vouts,i)) !=0 && (sobj= jobj(vout,"scriptPubKey")) != 0 )
+                {
+                    if ( (addresses= jarray(&n,sobj,"addresses")) != 0 )
+                    {
+                        for (j=0; j<n; j++)
+                        {
+                            addr = jstri(addresses,j);
+                            if ( strcmp(addr,coinaddr) == 0 )
+                            {
+                                //fprintf(stderr,"found %s in %s v%d\n",coinaddr,bits256_str(str,txid),i);
+                                hasvout = 1;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (hasvout==1) break;
+            }
+        }
+        // if (hasvout==1 && (vins=jarray(&numarray,txobj,"vin"))!=0)
+        // {
+        //     for (int i=0;i<numarray;i++)
+        //     {
+        //         if ((vin=jitem(vins,i))!=0 && validateaddress(refcoin,acname,jstr(vin,"address"),"ismine")!=0)
+        //         {
+        //             retval=1;
+        //             break;
+        //         }
+        //     }
+        // }
+        free_json(txobj);
+    }
+    return(hasvout);
+}
+
+int32_t have_pending_opid(char *coinstr,int32_t clearresults)
+{
+    cJSON *array,*status,*result; int32_t i,n,j,m,pending = 0; char *statusstr;
+    if ( (array= z_listoperationids(coinstr,"")) != 0 )
+    {
+        if ( (n= cJSON_GetArraySize(array)) > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                if ( (status= z_getoperationstatus(coinstr,"",jstri(array,i))) != 0 )
+                {
+                    if ( (m= cJSON_GetArraySize(status)) > 0 )
+                    {
+                        for (j=0; j<m; j++)
+                        {
+                            if ( (statusstr= jstr(jitem(status,j),"status")) != 0 )
+                            {
+                                if ( strcmp(statusstr,"executing") == 0 )
+                                {
+                                    pending++;
+                                    //printf("pending.%d\n",pending);
+                                }
+                                else if ( clearresults != 0 )
+                                {
+                                    if ( (result= z_getoperationresult(coinstr,"",jstri(array,i))) != 0 )
+                                    {
+                                        free_json(result);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    free_json(status);
+                }
+            }
+        }
+        free_json(array);
+    }
+    return(pending);
+}
+
+int64_t utxo_value(char *refcoin,char *srcaddr,bits256 txid,int32_t v)
+{
+    cJSON *txjson,*vouts,*vout,*sobj,*array; int32_t numvouts,numaddrs; int64_t val,value = 0; char *addr,str[65];
+    srcaddr[0] = 0;
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vouts= jarray(&numvouts,txjson,"vout")) != 0 && v < numvouts )
+        {
+            vout = jitem(vouts,v);
+            if ( (val= jdouble(vout,"value")*SATOSHIDEN) != 0 && (sobj= jobj(vout,"scriptPubKey")) != 0 )
+            {
+                if ( (array= jarray(&numaddrs,sobj,"addresses")) != 0 && numaddrs == 1 && (addr= jstri(array,0)) != 0 && strlen(addr) < 64 )
+                {
+                    strcpy(srcaddr,addr);
+                    value = val;
+                } else printf("couldnt get unique address for %s/%d\n",bits256_str(str,txid),v);
+            } else printf("error getting value for %s/v%d\n",bits256_str(str,txid),v);
+        }
+    }
+    return(value);
+}
+
+int32_t verify_vin(char *refcoin,bits256 txid,int32_t v,char *cmpaddr)
+{
+    cJSON *txjson,*vins,*vin; int32_t numvins; char vinaddr[64],str[65];
+    vinaddr[0] = 0;
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vins= jarray(&numvins,txjson,"vin")) != 0 && v < numvins )
+        {
+            vin = jitem(vins,v);
+            if ( utxo_value(refcoin,vinaddr,jbits256(vin,"txid"),jint(vin,"vout")) > 0 && strcmp(vinaddr,cmpaddr) == 0 )
+                return(0);
+            printf("mismatched vinaddr.(%s) vs %s\n",vinaddr,cmpaddr);
+        }
+    }
+    return(-1);
+}
+
+int32_t txid_in_vins(char *refcoin,bits256 txid,bits256 cmptxid)
+{
+    cJSON *txjson,*vins,*vin; int32_t numvins,v,vinvout; bits256 vintxid; char str[65];
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vins= jarray(&numvins,txjson,"vin")) != 0 )
+        {
+            for (v=0; v<numvins; v++)
+            {
+                vin = jitem(vins,v);
+                vintxid = jbits256(vin,"txid");
+                vinvout = jint(vin,"vout");
+                if ( memcmp(&vintxid,&cmptxid,sizeof(vintxid)) == 0 && vinvout == 0 )
+                {
+                    return(0);
+                }
+            }
+        }
+    }
+    return(-1);
+}
+
+int32_t dpow_pubkey()
+{
+    char *pstr,*retstr,*str; cJSON *retjson; int32_t retval = -1;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_stats","","","","","","","")) != 0 )
+    {
+        if ( (pstr= jstr(retjson,"publishable_pubkey")) != 0 && strlen(pstr) == 66 )
+        {
+            strcpy(DPOW_pubkeystr,pstr);
+            if ( (str= jstr(retjson,"secpkey")) != 0 )
+                strcpy(DPOW_secpkeystr,str);
+            if ( (str= jstr(retjson,"handle")) != 0 )
+                strcpy(DPOW_handle,str);
+            if ( (str= jstr(retjson,"recvaddr")) != 0 )
+                strcpy(DPOW_recvaddr,str);
+            if ( (str= jstr(retjson,"recvZaddr")) != 0 )
+                strcpy(DPOW_recvZaddr,str);
+            retval = 0;
+        }
+        if ( retval != 0 )
+            printf("DEX_stats.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    if ( DPOW_secpkeystr[0] == 0 )
+        strcpy(DPOW_secpkeystr,"02deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead");
+    return(retval);
+}
+
+cJSON *dpow_get(uint32_t shorthash)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",shorthash);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_get",numstr,"","","","","","")) != 0 )
+    {
+        //printf("DEX_get.(%s)\n",jprint(retjson,0));
+        if ( juint(retjson,"cancelled") != 0 )
+        {
+            free_json(retjson);
+            retjson = 0;
+        }
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_get.(%u) error.(%s)\n",shorthash,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_cancel(uint32_t shorthash)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",shorthash);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_cancel",numstr,"","","","","","")) != 0 )
+    {
+         //printf("DEX_cancel.(%s)\n",jprint(retjson,0));
+         return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_cancel.(%u) error.(%s)\n",shorthash,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_notarize(char *coin,int32_t height)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",height);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_notarize",coin,numstr,"","","","","")) != 0 )
+    {
+        //printf("DEX_notarize.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_notarize.(%s.%d) error.(%s)\n",coin,height,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_broadcast(int32_t priority,char *hexstr,char *tagA,char *tagB,char *pubkey,char *volA,char *volB)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",priority);
+    //fprintf(stderr,"broadcast (%s) (%s) (%s) (%s) (%s) [%s %s]\n",hexstr,numstr,tagA,tagB,pubkey,volA,volB);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_broadcast",hexstr,numstr,tagA,tagB,pubkey,volA,volB)) != 0 )
+    {
+        //fprintf(stderr,"DEX_broadcast.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_broadcast.(%s/%s) [%s %s] %s error.(%s)\n",tagA,tagB,volA,volB,hexstr,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_publish(int32_t priority,char *filename)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",priority);
+    //fprintf(stderr,"broadcast (%s) (%s) (%s) (%s) (%s) [%s %s]\n",hexstr,numstr,tagA,tagB,pubkey,volA,volB);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_publish",filename,numstr,"0","","","","")) != 0 )
+    {
+        //fprintf(stderr,"DEX_broadcast.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_publish.(%s) %d error.(%s)\n",filename,priority,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_subscribe(int32_t priority,char *filename,char *publisher)
+{
+    cJSON *retjson; char *retstr,numstr[32];
+    sprintf(numstr,"%u",priority);
+    //fprintf(stderr,"broadcast (%s) (%s) (%s) (%s) (%s) [%s %s]\n",hexstr,numstr,tagA,tagB,pubkey,volA,volB);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_subscribe",filename,numstr,"0",publisher,"","","")) != 0 )
+    {
+        //fprintf(stderr,"DEX_broadcast.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"dpow_subscribe.(%s) %d error.(%s)\n",filename,priority,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+cJSON *dpow_ntzdata(char *coin,int32_t priority,int32_t height,bits256 blockhash)
+{
+    char hexstr[256],heightstr[32];
+    bits256_str(hexstr,blockhash);
+    sprintf(heightstr,"%u",height);
+    return(dpow_broadcast(priority,hexstr,coin,heightstr,DPOW_pubkeystr,"",""));
+}
+
+bits256 dpow_ntzhash(char *coin,int32_t *prevntzheightp,uint32_t *prevntztimep)
+{
+    char *pstr,*retstr; cJSON *retjson,*array,*item; int32_t n; bits256 ntzhash; uint8_t buf[4];
+    memset(&ntzhash,0,sizeof(ntzhash));
+    *prevntzheightp = 0;
+    *prevntztimep = 0;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",coin,"notarizations",DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            item = jitem(array,0);
+            if ( (pstr= jstr(item,"decrypted")) != 0 && strlen(pstr) == 2*(32 + 2*4) )
+            {
+                decode_hex(ntzhash.bytes,32,pstr);
+                decode_hex(buf,4,pstr + 32*2);
+                *prevntzheightp = ((int32_t)buf[3] + ((int32_t)buf[2] << 8) + ((int32_t)buf[1] << 16) + ((int32_t)buf[0] << 24));
+                decode_hex(buf,4,pstr + 32*2+8);
+                *prevntztimep = ((int32_t)buf[3] + ((int32_t)buf[2] << 8) + ((int32_t)buf[1] << 16) + ((int32_t)buf[0] << 24));
+                //char str[65]; fprintf(stderr,"%s prevntz height.%d %s\n",coin,*prevntzheightp,bits256_str(str,ntzhash));
+            }
+        }
+        free_json(retjson);
+    }
+    return(ntzhash);
+}
+
+int32_t dpow_getmessage(char *payload,int32_t maxsize,char *tagA,char *tagB,char *pubkeystr)
+{
+    cJSON *retjson,*item,*array; char *retstr,*pstr; int32_t i,n,retval = 0;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",tagA,tagB,pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (pstr= jstr(item,"decrypted")) != 0 && strlen(pstr) < maxsize )
+                {
+                    retval = 1;
+                    strcpy(payload,pstr);
+                    break;
+                }
+            }
+            //fprintf(stderr,"getmessage(%s, %s, %s) -> n.%d retval.%d\n",tagA,tagB,pubkeystr,n,retval);
+        }
+        free_json(retjson);
+    }
+    return(retval);
+}
+
+int32_t dpow_hasmessage(char *payload,char *tagA,char *tagB,char *pubkeystr)
+{
+    cJSON *retjson,*item,*array; char *retstr,*pstr; int32_t i,n,retval = 0;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",tagA,tagB,pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (pstr= jstr(item,"decrypted")) != 0 && strcmp(payload,pstr) == 0 )
+                {
+                    retval = 1;
+                    //fprintf(stderr,"already have %s/%s/%s\n",tagA,tagB,pubkeystr);
+                    break;
+                }
+            }
+        }
+        free_json(retjson);
+    }
+    return(retval);
+}
+
+int32_t dpow_pubkeyregister(int32_t priority)
+{
+    cJSON *retjson,*array,*item; char *retstr,*pstr=0; int32_t i,n=0,len;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",(char *)"handles",DPOW_handle,DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            item = jitem(array,0);
+            if ( (pstr= jstr(item,"decrypted")) != 0 )
+            {
+                //fprintf(stderr,"found secpkey.(%s)\n",pstr);
+            }
+        }
+        free_json(retjson);
+    }
+    if ( pstr == 0 )
+    {
+        dpow_broadcast(priority,DPOW_secpkeystr,(char *)"handles",DPOW_handle,DPOW_pubkeystr,"","");
+        return(1);
+    }
+    return(0);
+}
+
+int32_t dpow_tokenregister(char *existing,int32_t priority,char *token_name,char *tokenid)
+{
+    cJSON *retjson,*array,*item; char *retstr,*pstr=0; int32_t i,n=0,len;
+    existing[0] = 0;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",(char *)"tokens",token_name,DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            item = jitem(array,0);
+            if ( juint(item,"cancelled") == 0 && (pstr= jstr(item,"decrypted")) != 0 )
+            {
+                strcpy(existing,pstr);
+                if ( tokenid != 0 && strcmp(pstr,tokenid) != 0 )
+                {
+                    fprintf(stderr,"found %s.tokenid (%s) != %s\n",token_name,pstr,tokenid);
+                    pstr = 0;
+                }
+            }
+        }
+        free_json(retjson);
+    }
+    if ( pstr == 0 && tokenid != 0 )
+    {
+        fprintf(stderr,"broadcast tokens %s/%s\n",token_name,tokenid);
+        dpow_broadcast(priority,tokenid,(char *)"tokens",token_name,DPOW_pubkeystr,"","");
+        return(1);
+    }
+    return(0);
+}
+
+/*bits256 komodo_DEX_filehash(FILE *fp,uint64_t offset0,uint64_t rlen,char *fname)
+{
+    bits256 filehash; uint8_t *data = (uint8_t *)calloc(1,rlen);
+    fseek(fp,offset0,SEEK_SET);
+    memset(filehash.bytes,0,sizeof(filehash));
+    if ( fread(data,1,rlen,fp) == rlen )
+        vcalc_sha256(0,filehash.bytes,data,rlen);
+    else fprintf(stderr," reading %lld bytes from %s.%llu\n",(long long)rlen,fname,(long long)offset0);
+    free(data);
+    return(filehash);
+}*/
+
+int32_t dpow_fileregister(char *existing,int32_t priority,char *fname,char *coin,int64_t price)
+{
+    FILE *fp; cJSON *retjson,*array,*item; bits256 existinghash,filehash; char tagA[16],pricestr[32],str[65],*retstr,*pstr=0; int32_t i,n=0,len;
+    existing[0] = 0;
+    sprintf(pricestr,"%.8f",dstr(price));
+    //fprintf(stderr,"filereg (%s) (%s) (%s)\n",fname,coin,pricestr);
+    memset(&filehash,0,sizeof(filehash));
+    if ( (fp= fopen(fname,"rb")) != 0 ) // better to use hash of file
+    {
+        fseek(fp,0,SEEK_END);
+        filehash.ulongs[0] = (uint64_t)ftell(fp);
+        fclose(fp);
+    } else return(-1);
+    sprintf(tagA,"'#%s'",fname);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",tagA,coin,DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            item = jitem(array,0);
+            if ( juint(item,"cancelled") == 0 && (pstr= jstr(item,"decrypted")) != 0 )
+            {
+                strcpy(existing,pstr);
+                if ( is_hexstr(existing,0) == sizeof(existinghash)*2 )
+                {
+                    decode_hex(existinghash.bytes,sizeof(existinghash),existing);
+                    if ( memcmp(&filehash,&existinghash,sizeof(filehash)) != 0 )
+                    {
+                        fprintf(stderr,"found mismatched %s vs %s: %s (%s %s)\n",existing,bits256_str(str,filehash),fname,coin,pricestr);
+                        pstr = 0;
+                    } //else fprintf(stderr,"found matching %s\n",jprint(item,0));
+                }
+            }
+        }
+        free_json(retjson);
+    }
+    if ( pstr == 0 )
+    {
+        fprintf(stderr,"broadcast %s %s (%s %s)\n",bits256_str(str,filehash),fname,coin,pricestr);
+        dpow_broadcast(priority,bits256_str(str,filehash),tagA,coin,DPOW_pubkeystr,"1",pricestr);
+        return(1);
+    }
+    return(0);
+}
+
+bits256 dpow_blockhash(char *coin,int32_t height)
+{
+    cJSON *retjson,*array,*item; char *retstr,*pstr=0,numstr[32]; int32_t i,n=0,len; bits256 hash;
+    memset(hash.bytes,0,sizeof(hash));
+    sprintf(numstr,"%d",height);
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list","0","0",coin,numstr,DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 )
+        {
+            item = jitem(array,0);
+            if ( (pstr= jstr(item,"decrypted")) != 0 )
+            {
+                //fprintf(stderr,"found blockhash.(%s)\n",pstr);
+                if ( strlen(pstr) == 64 )
+                    decode_hex(hash.bytes,sizeof(hash),pstr);
+            }
+        }
+        free_json(retjson);
+    }
+    return(hash);
+}
+
+struct inboxinfo
+{
+    uint32_t shorthash;
+    char *jsonstr,senderpub[67];
+};
+
+struct inboxinfo **dpow_inboxcheck(int32_t *nump,uint32_t *stopatp,char *tagB)
+{
+    cJSON *retjson,*array,*item; struct inboxinfo **ptrs=0; char *senderpub,*retstr,*ptr,*pstr=0,stopstr[32]; int32_t i,j,n,m=0,len;
+    sprintf(stopstr,"%u",*stopatp);
+    *nump = 0;
+    if ( (retjson= get_komodocli((char *)"",&retstr,DEXP2P_CHAIN,"DEX_list",stopstr,"0",(char *)"inbox",tagB,DPOW_pubkeystr,"","")) != 0 )
+    {
+        if ( (array= jarray(&n,retjson,"matches")) != 0 && n > 0 )
+        {
+            ptrs = calloc(n,sizeof(*ptrs));
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (senderpub= jstr(item,"senderpub")) != 0 && is_hexstr(senderpub,0) == 66 )
+                {
+                    if ( m == 0 )
+                        *stopatp = juint(item,"id");
+                    if ( (pstr= jstr(item,"decrypted")) != 0 )
+                    {
+                        ptr = clonestr(pstr);
+                        for (j=0; ptr[j]!=0; j++)
+                            if ( ptr[j] == '\'' )
+                                ptr[j] = '"';
+                        ptrs[m] = calloc(1,sizeof(struct inboxinfo));
+                        ptrs[m]->shorthash = juint(item,"id");
+                        ptrs[m]->jsonstr = ptr;
+                        strcpy(ptrs[m]->senderpub,senderpub);
+                        m++;
+                    }
+                }
+            }
+            *nump = m;
+        }
+        free_json(retjson);
+    }
+    return(ptrs);
+}
+
+
diff --git a/src/cc/dapps/subatomic.c b/src/cc/dapps/subatomic.c
new file mode 100644
index 000000000..2f6ebf824
--- /dev/null
+++ b/src/cc/dapps/subatomic.c
@@ -0,0 +1,1429 @@
+/******************************************************************************
+ * Copyright © 2014-2020 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.            *
+ *                                                                            *
+ ******************************************************************************/
+
+// build subatomic and put in path: git pull; gcc cc/dapps/subatomic.c -lm -o subatomic; cp subatomic /usr/bin
+// alice sends relcoin and gets basecoin
+
+#define DEXP2P_CHAIN ((char *)"DEX")
+#define DEXP2P_PUBKEYS ((char *)"subatomic")
+#include "dappinc.h"
+
+// for OTC mode, the following 4 functions are the only ones that should be needed to support a new "coin"
+//int64_t subatomic_getbalance(char *coin);
+//bits256 subatomic_coinpayment(int32_t OTCmode,char *coin,char *destaddr,uint64_t paytoshis,char *memostr);
+//cJSON *subatomic_txidwait(char *coin,bits256 txid,char *hexstr,int32_t numseconds);
+//int64_t subatomic_verifypayment(char *coin,cJSON *rawtx,uint64_t destsatoshis,char *destaddr);
+
+// TODO:
+// address conversion
+// new inventory types:
+//   anonsend
+
+// bob nodes:
+//   mutex for bob instances
+//   "deposits" messages and approved bobs
+//   volume caps per coin and non-notarized exposure
+
+// later:
+//   sharded storage
+
+#define SUBATOMIC_OTCDEFAULT 1
+#define SUBATOMIC_TIMEOUT 60
+#define SUBATOMIC_LOCKTIME 3600
+#define SUBATOMIC_TXFEE 10000
+
+#define SUBATOMIC_PRIORITY 5
+
+#define SUBATOMIC_OPENREQUEST 1
+#define SUBATOMIC_APPROVED 2
+#define SUBATOMIC_OPENED 3
+#define SUBATOMIC_PAYMENT 4
+#define SUBATOMIC_PAIDINFULL 5
+#define SUBATOMIC_CLOSED 6
+
+cJSON *SUBATOMIC_json;
+int32_t SUBATOMIC_retval = -1;
+
+struct abinfo
+{
+    char pubkey[67],recvaddr[64],recvZaddr[128],secp[67];
+};
+
+struct coininfo
+{
+    uint64_t satoshis,txfee,maxamount;
+    char istoken,iszaddr,isfile,isexternal,tokenid[65],coin[16],name[16],cli[256],acname[16],coinstr[16];
+};
+
+struct msginfo
+{
+    UT_hash_handle hh;
+    bits256 bobpayment,alicepayment;
+    double price;
+    uint64_t gotpayment;
+    uint32_t origid,openrequestid,approvalid,openedid,paymentids[100],paidid,closedid,locktime;
+    int32_t bobflag,status,OTCmode;
+    char payload[128],approval[128],senderpub[67],msigaddr[64],redeemscript[256];
+    struct coininfo base,rel;
+    struct abinfo alice,bob;
+} *Messages;
+
+uint64_t subatomic_txfee(char *coin)
+{
+    return(SUBATOMIC_TXFEE);
+}
+
+char *subatomic_checkname(char *tmpstr,struct msginfo *mp,int32_t baserel,char *coin)
+{
+    int32_t i,n; cJSON *external,*item; char *coinstr,*clistr; struct coininfo *ptr;
+    ptr = (baserel == 0) ? &mp->base : &mp->rel;
+    if ( coin[0] == 0 )
+        return(coin);
+    if ( (external= jarray(&n,SUBATOMIC_json,"externalcoins")) != 0 && n > 0 )
+    {
+        for (i=0; i<n; i++)
+        {
+            item = jitem(external,i);
+            if ( (clistr= jstr(item,coin)) != 0 && strlen(clistr) < sizeof(ptr->cli) )
+            {
+                ptr->isexternal = 1;
+                strcpy(ptr->cli,clistr);
+                //fprintf(stderr,"found external coin %s %s\n",coin,clistr);
+            }
+        }
+    }
+    if ( coin[0] == '#' )
+    {
+        strcpy(ptr->coinstr,coin);
+        strcpy(ptr->acname,"");
+        ptr->isfile = 1;
+        return(coin);
+    }
+    else if ( coin[0] != 'z' )
+    {
+        for (i=1; coin[i]!=0; i++)
+            if ( coin[i] == '.' )
+            {
+                dpow_tokenregister(ptr->tokenid,0,coin,0);
+                if ( ptr->tokenid[0] != 0 )
+                {
+                    strcpy(tmpstr,coin);
+                    tmpstr[i] = 0;
+                    //fprintf(stderr,"found a tokenmap %s -> %s %s\n",coin,tmpstr,ptr->tokenid);
+                    ptr->istoken = 1;
+                    strcpy(ptr->acname,coin);
+                    strcpy(ptr->coinstr,"");
+                    return(tmpstr);
+                }
+            }
+        if ( ptr->isexternal == 0 )
+        {
+            if ( strcmp(coin,"KMD") != 0 )
+            {
+                strcpy(ptr->acname,coin);
+                strcpy(ptr->coinstr,"");
+            }
+            else
+            {
+                strcpy(ptr->coinstr,coin);
+                strcpy(ptr->acname,"");
+            }
+        }
+        else
+        {
+            strcpy(ptr->coinstr,coin);
+            strcpy(ptr->acname,"");
+        }
+        return(coin);
+    }
+    else
+    {
+        for (i=1; coin[i]!=0; i++)
+            if ( isupper(coin[i]) == 0 )
+                return(coin);
+        if ( strcmp(coin+1,"KMD") != 0 )
+            ptr->iszaddr = 1;
+        return(coin+1);
+    }
+}
+
+int32_t subatomic_zonly(struct coininfo *coin)
+{
+    if ( strcmp(coin->coin,"PIRATE") == 0 )
+        return(1);
+    else return(coin->iszaddr);
+}
+
+// //////////////////////////////// the four key functions needed to support a new item for subatomics
+
+int64_t _subatomic_getbalance(struct coininfo *coin)
+{
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
+    if ( (retjson= subatomic_cli(coin->cli,&retstr,"getbalance","","","","","","","")) != 0 )
+    {
+        fprintf(stderr,"_subatomic_getbalance.(%s) %s returned json!\n",coin->coinstr,coin->cli);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        amount = atof(retstr) * SATOSHIDEN;
+        sprintf(cmpstr,"%.8f",dstr(amount));
+        if ( strcmp(retstr,cmpstr) != 0 )
+            amount++;
+        //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
+        free(retstr);
+    }
+    return (amount);
+}
+
+bits256 _subatomic_sendtoaddress(struct coininfo *coin,char *destaddr,int64_t satoshis)
+{
+    char numstr[32],*retstr,str[65]; cJSON *retjson; bits256 txid;
+    memset(txid.bytes,0,sizeof(txid));
+    sprintf(numstr,"%.8f",(double)satoshis/SATOSHIDEN);
+    if ( (retjson= subatomic_cli(coin->cli,&retstr,"sendtoaddress",destaddr,numstr,"false","","","","")) != 0 )
+    {
+        fprintf(stderr,"unexpected _subatomic_sendtoaddress json.(%s)\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        if ( strlen(retstr) >= 64 )
+        {
+            retstr[64] = 0;
+            decode_hex(txid.bytes,32,retstr);
+        }
+        fprintf(stderr,"_subatomic_sendtoaddress %s %.8f txid.(%s)\n",destaddr,(double)satoshis/SATOSHIDEN,bits256_str(str,txid));
+        free(retstr);
+    }
+    return(txid);
+}
+
+cJSON *_subatomic_rawtransaction(struct coininfo *coin,bits256 txid)
+{
+    cJSON *retjson; char *retstr,str[65];
+    if ( (retjson= subatomic_cli(coin->cli,&retstr,"getrawtransaction",bits256_str(str,txid),"1","","","","","")) != 0 )
+    {
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"_subatomic_rawtransaction.(%s) %s error.(%s)\n",coin->coin,coin->name,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
+int64_t subatomic_getbalance(struct coininfo *coin)
+{
+    char *coinstr,*acname=""; FILE *fp; int64_t retval = 0;
+    if ( strcmp(coin->coin,"KMD") != 0 )
+    {
+        acname = coin->coin;
+        coinstr = "";
+    } else coinstr = coin->coin;
+    if ( coin->isfile != 0 )
+    {
+        if ( (fp= fopen(coin->name+1,"rb")) != 0 ) // if alice, add bob pubkey to fname
+        {
+            fclose(fp);
+            retval = SATOSHIDEN;
+        }
+        return(retval);
+    }
+    else if ( subatomic_zonly(coin) != 0 )
+        return(z_getbalance(coinstr,acname,DPOW_recvZaddr));
+    else
+    {
+        if ( coin->istoken != 0 )
+        {
+            if ( get_getbalance(coinstr,acname) < SUBATOMIC_TXFEE )
+            {
+                fprintf(stderr,"not enough balance to send token\n");
+                return(0);
+            }
+            //fprintf(stderr,"token balance %s\n",coin->tokenid);
+            return(get_tokenbalance(coinstr,acname,coin->tokenid) * SATOSHIDEN);
+        }
+        else if ( coin->isexternal == 0 )
+            return(get_getbalance(coinstr,acname));
+        else return(_subatomic_getbalance(coin));
+    }
+}
+
+bits256 subatomic_coinpayment(uint32_t origid,int32_t OTCmode,struct coininfo *coin,char *destaddr,uint64_t paytoshis,char *memostr,char *destpub,char *senderpub)
+{
+    bits256 txid; char opidstr[128],opretstr[32],str[65],*status,*coinstr,*acname=""; cJSON *retjson,*retjson2,*item,*res; int32_t i,pending=0;
+    memset(&txid,0,sizeof(txid));
+    if ( OTCmode == 0 )
+    {
+        fprintf(stderr,"micropayment channels are not supported yet\n");
+        return(txid);
+    }
+    if ( coin->isfile != 0 )
+    {
+        fprintf(stderr,"start broadcast of (%s)\n",coin->coin+1);
+        if ( (retjson= dpow_publish(SUBATOMIC_PRIORITY,coin->coin+1)) != 0 ) // spawn thread
+        {
+            sprintf(opretstr,"%08x",juint(retjson,"id"));
+            sprintf(opidstr,"%u",origid);
+            if ( (retjson2= dpow_broadcast(SUBATOMIC_PRIORITY,opretstr,"inbox",opidstr,senderpub,"","")) != 0 )
+                free_json(retjson2);
+            fprintf(stderr,"broadcast file.(%s) and send id.%u to alice (%s)\n",coin->coin+1,juint(retjson,"id"),jprint(retjson,0));
+            txid = jbits256(retjson,"filehash");
+            free_json(retjson);
+        }
+        fprintf(stderr,"end broadcast of (%s) to %s\n",coin->coin+1,senderpub);
+        return(txid);
+    }
+    else if ( subatomic_zonly(coin) != 0 )
+    {
+        if ( memostr[0] == 0 )
+            memostr = "beef";
+        z_sendmany(opidstr,"",coin->coin,DPOW_recvZaddr,destaddr,paytoshis,memostr);
+        for (i=0; i<SUBATOMIC_TIMEOUT; i++)
+        {
+            if ( (retjson= z_getoperationstatus("",coin->coin,opidstr)) != 0 )
+            {
+                item = jitem(retjson,0);
+                if ( (status= jstr(item,"status")) != 0 )
+                {
+                    if ( strcmp(status,"executing") == 0 )
+                        pending++;
+                    else
+                    {
+                        res = jobj(item,"result");
+                        txid = jbits256(res,"txid");
+                        //fprintf(stderr,"got Ztx txid.%s\n",bits256_str(str,txid));
+                        free_json(retjson);
+                        break;
+                    }
+                    /*else if ( clearresults != 0 )
+                     {
+                     if ( (result= z_getoperationresult(coinstr,"",jstri(array,i))) != 0 )
+                     {
+                     free_json(result);
+                     }
+                     }*/
+                }
+                free_json(retjson);
+            }
+            sleep(1);
+        }
+        if ( i == 60 )
+            printf("%u timed out waiting for opid to finish\n",origid);
+    }
+    else
+    {
+        if ( strcmp(coin->coin,"KMD") != 0 )
+        {
+            acname = coin->coin;
+            coinstr = "";
+        } else coinstr = coin->coin;
+        if ( coin->istoken != 0 )
+            txid = tokentransfer(coinstr,acname,coin->tokenid,destpub,paytoshis/SATOSHIDEN);
+        else if ( coin->isexternal == 0 )
+        {
+            sprintf(opretstr,"%08x",origid);
+            txid = sendtoaddress(coinstr,acname,destaddr,paytoshis,opretstr);
+        } else txid = _subatomic_sendtoaddress(coin,destaddr,paytoshis);
+        printf("%u got txid.%s\n",origid,bits256_str(str,txid));
+    }
+    return(txid);
+}
+
+cJSON *subatomic_txidwait(struct coininfo *coin,bits256 txid,char *hexstr,int32_t numseconds,char *senderpub)
+{
+    int32_t i,zflag; char *coinstr,str[65],*acname=""; cJSON *rawtx; bits256 z; bits256 filehash;
+    memset(&z,0,sizeof(z));
+    if ( memcmp(&z,&txid,sizeof(txid)) == 0 )
+        return(0);
+    if ( hexstr != 0 && hexstr[0] != 0 ) // probably not worth doing and zaddr is a problem to decode
+    {
+        // compare against txid
+        // if matches, sendrawtransaction if OTC mode, decoode and return if channels mode
+    }
+    zflag = (subatomic_zonly(coin) != 0);
+    if ( strcmp(coin->coin,"KMD") != 0 )
+    {
+        acname = coin->coin;
+        coinstr = "";
+    } else coinstr = coin->coin;
+    for (i=0; i<numseconds; i++)
+    {
+        if ( coin->isfile != 0 )
+        {
+            if ( (rawtx= dpow_subscribe(SUBATOMIC_PRIORITY,coin->coin+1,senderpub)) != 0 )
+            {
+                filehash = jbits256(rawtx,"filehash");
+                if ( memcmp(&filehash,&txid,sizeof(filehash)) != 0 )
+                {
+                    fprintf(stderr,"waiting (%s) (%s)\n",coin->coin+1,jprint(rawtx,0));
+                    free_json(rawtx);
+                    rawtx = 0;
+                } else return(rawtx);
+            }
+        }
+        else if ( zflag != 0 )
+            rawtx = get_z_viewtransaction(coinstr,acname,txid);
+        else if ( coin->isexternal == 0 )
+            rawtx = get_rawtransaction(coinstr,acname,txid);
+        else rawtx = _subatomic_rawtransaction(coin,txid);
+        if ( rawtx != 0 )
+            return(rawtx);
+        sleep(1);
+    }
+    printf("%s/%s timeout waiting for %s\n",coin->name,coin->coin,bits256_str(str,txid));
+    return(0);
+}
+
+int64_t subatomic_verifypayment(struct coininfo *coin,cJSON *rawtx,uint64_t destsatoshis,char *destaddr,bits256 txid)
+{
+    int32_t i,n,m,valid=0; bits256 tokenid,filehash,checkhash; cJSON *array,*item,*sobj,*a; char *addr,*acname,*coinstr,tokenaddr[64],*hex; uint8_t hexbuf[512],pub33[33]; uint64_t netval,recvsatoshis = 0;
+    if ( coin->isfile != 0 )
+    {
+        filehash = jbits256(rawtx,"filehash");
+        checkhash = jbits256(rawtx,"checkhash");
+        if ( memcmp(&txid,&filehash,sizeof(txid)) == 0 && memcmp(&txid,&checkhash,sizeof(txid)) == 0 )
+        {
+            fprintf(stderr,"verified file is matching the filehash (%s)\n",jprint(rawtx,0));
+            return(SATOSHIDEN);
+        } else return(0);
+    }
+    else if ( subatomic_zonly(coin) != 0 )
+    {
+        if ( (array= jarray(&n,rawtx,"outputs")) != 0 && n > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (addr= jstr(item,"address")) != 0 && strcmp(addr,destaddr) == 0 )
+                    recvsatoshis += j64bits(item,"valueZat");
+            }
+        }
+    }
+    else if ( coin->istoken != 0 )
+    {
+        if ( (array= jarray(&n,rawtx,"vout")) != 0 && n > 0 )
+        {
+            item = jitem(array,0);
+            if ( (sobj= jobj(item,"scriptPubKey")) != 0 && (a= jarray(&m,sobj,"addresses")) != 0 && m == 1 )
+            {
+                if ( strcmp(coin->coin,"KMD") != 0 )
+                {
+                    acname = coin->coin;
+                    coinstr = "";
+                } else coinstr = coin->coin;
+                if ( get_tokenaddress(coinstr,acname,tokenaddr) != 0 )
+                {
+                    //fprintf(stderr,"tokenaddr.%s\n",tokenaddr);
+                    if ( (addr= jstri(a,0)) != 0 && strcmp(addr,tokenaddr) == 0 )
+                        recvsatoshis += SATOSHIDEN * (uint64_t)(jdouble(item,"value")*SATOSHIDEN + 0.000000004999);
+                    else fprintf(stderr,"miscompare (%s) vs %s\n",jprint(sobj,0),addr);
+                }
+            }
+            item = jitem(array,n-1);
+            if ( (sobj= jobj(item,"scriptPubKey")) != 0 && (hex= jstr(sobj,"hex")) != 0 && (m= is_hexstr(hex,0)) > 1 && m/2 < sizeof(hexbuf) )
+            {
+                m >>= 1;
+                decode_hex(hexbuf,m,hex);
+                decode_hex(tokenid.bytes,32,coin->tokenid);
+                decode_hex(pub33,33,DPOW_secpkeystr);
+                // opret 69len EVAL_TOKENS 't' tokenid 1 33 pub33
+                if ( hexbuf[0] == 0x6a && hexbuf[1] == 0x45 && hexbuf[2] == 0xf2 && hexbuf[3] == 't' && memcmp(&hexbuf[4],&tokenid,sizeof(tokenid)) == 0 && hexbuf[4+32] == 1 && hexbuf[4+32+1] == 33 && memcmp(&hexbuf[4+32+2],pub33,33) == 0 )
+                {
+                    valid = 1;
+                    //fprintf(stderr,"validated it is a token transfer!\n");
+                } else fprintf(stderr,"need to validate tokentransfer.(%s) %s %d\n",hex,DPOW_secpkeystr,memcmp(&hexbuf[4+32+2],pub33,33) == 0);
+                //6a 45 f2 74 2b1feef719ecb526b07416dd432bce603ac6dc8bfe794cddf105cb52f6aae3cd 01 21 02b27de3ee5335518b06f69f4fbabb029cfc737613b100996841d5532b324a5a61
+                
+            }
+            recvsatoshis *= valid;
+        }
+    }
+    else
+    {
+        if ( (array= jarray(&n,rawtx,"vout")) != 0 && n > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(array,i);
+                if ( (sobj= jobj(item,"scriptPubKey")) != 0 && (a= jarray(&m,sobj,"addresses")) != 0 && m == 1 )
+                {
+                    if ( (addr= jstri(a,0)) != 0 && strcmp(addr,destaddr) == 0 )
+                        recvsatoshis += (uint64_t)(jdouble(item,"value")*SATOSHIDEN + 0.000000004999);
+                }
+            }
+        }
+    }
+    printf("%s received %.8f vs %.8f\n",destaddr,dstr(recvsatoshis),dstr(destsatoshis));
+    return(recvsatoshis - destsatoshis);
+}
+// //////////// end
+
+struct msginfo *subatomic_find(uint32_t origid)
+{
+    struct msginfo *mp;
+    HASH_FIND(hh,Messages,&origid,sizeof(origid),mp);
+    return(mp);
+}
+
+struct msginfo *subatomic_add(uint32_t origid)
+{
+    struct msginfo *mp = calloc(1,sizeof(*mp));
+    mp->origid = origid;
+    HASH_ADD(hh,Messages,origid,sizeof(origid),mp);
+    return(mp);
+}
+
+int32_t subatomic_status(struct msginfo *mp,int32_t status)
+{
+    static FILE *fp;
+    if ( fp == 0 )
+    {
+        int32_t i,oid,s,n,num,count; struct msginfo *m; long fsize;
+        if ( (fp= fopen("SUBATOMIC.DB","rb+")) == 0 )
+        {
+            if ( (fp= fopen("SUBATOMIC.DB","wb")) == 0 )
+            {
+                fprintf(stderr,"cant create SUBATOMIC.DB\n");
+                exit(-1);
+            }
+        }
+        else
+        {
+            fseek(fp,0,SEEK_END);
+            fsize = ftell(fp);
+            if ( (fsize % (sizeof(uint32_t)*2)) != 0 )
+            {
+                fprintf(stderr,"SUBATOMIC.DB illegal filesize.%ld\n",fsize);
+                exit(-1);
+            }
+            n = (int32_t)(fsize / (sizeof(uint32_t)*2));
+            rewind(fp);
+            for (i=num=count=0; i<n; i++)
+            {
+                if ( fread(&oid,1,sizeof(oid),fp) != sizeof(oid) || fread(&s,1,sizeof(s),fp) != sizeof(s) )
+                {
+                    fprintf(stderr,"SUBATOMIC.DB corrupted at filepos.%ld\n",ftell(fp));
+                    exit(-1);
+                }
+                if ( s < 0 || s > SUBATOMIC_CLOSED )
+                {
+                    fprintf(stderr,"SUBATOMIC.DB corrupted at filepos.%ld: illegal status.%d\n",ftell(fp),s);
+                    exit(-1);
+                }
+                //fprintf(stderr,"%u <- %d\n",oid,s);
+                if ( (m= subatomic_find(oid)) == 0 )
+                {
+                    m = subatomic_add(oid);
+                    count++;
+                }
+                if ( s > m->status )
+                {
+                    m->status = s;
+                    num++;
+                }
+            }
+            fprintf(stderr,"initialized %d messages, updated %d out of total.%d\n",count,num,n);
+        }
+    }
+    if ( mp->status >= status )
+        return(-1);
+    if ( fwrite(&mp->origid,1,sizeof(mp->origid),fp) != sizeof(mp->origid) || fwrite(&status,1,sizeof(status),fp) != sizeof(status) )
+        fprintf(stderr,"error updating SUBATOMIC.DB, risk of double spends\n");
+    fflush(fp);
+    mp->status = status;
+    return(0);
+}
+
+struct msginfo *subatomic_tracker(uint32_t origid)
+{
+    struct msginfo *mp;
+    if ( (mp= subatomic_find(origid)) == 0 )
+    {
+        mp = subatomic_add(origid);
+        subatomic_status(mp,0);
+    }
+    return(mp);
+}
+
+char *subatomic_hexstr(char *jsonstr)
+{
+    char *hexstr; int32_t i,c,n = (int32_t)strlen(jsonstr);
+    hexstr = malloc(2*n + 3);
+    strcpy(hexstr,jsonstr);
+    for (i=0; i<n; i++)
+    {
+        if ( (c= jsonstr[i]) == '"' )
+            c = '\'';
+        sprintf(&hexstr[i << 1],"%02x",c);
+    }
+    sprintf(&hexstr[i << 1],"00");
+    i++;
+    hexstr[i << 1] = 0;
+    return(hexstr);
+}
+
+cJSON *subatomic_mpjson(struct msginfo *mp)
+{
+    cJSON *item;
+    item = cJSON_CreateObject();
+    jaddnum(item,"origid",mp->origid);
+    jaddnum(item,"price",mp->price);
+    jaddnum(item,"openrequest",mp->openrequestid);
+    jaddstr(item,"base",mp->base.name);
+    jaddstr(item,"basecoin",mp->base.coin);
+    jadd64bits(item,"basesatoshis",mp->base.satoshis);
+    jadd64bits(item,"basetxfee",mp->base.txfee);
+    jadd64bits(item,"maxbaseamount",mp->base.maxamount);
+    jaddstr(item,"rel",mp->rel.name);
+    jaddstr(item,"relcoin",mp->rel.coin);
+    jadd64bits(item,"relsatoshis",mp->rel.satoshis);
+    jadd64bits(item,"reltxfee",mp->rel.txfee);
+    jadd64bits(item,"maxrelamount",mp->rel.maxamount);
+    jaddstr(item,"alice",mp->alice.pubkey);
+    jaddstr(item,"alicesecp",mp->alice.secp);
+    jaddstr(item,"bob",mp->bob.pubkey);
+    jaddstr(item,"bobsecp",mp->bob.secp);
+    if ( subatomic_zonly(&mp->rel) != 0 )
+        jaddstr(item,"bobZaddr",mp->bob.recvZaddr);
+    else jaddstr(item,"bobaddr",mp->bob.recvaddr);
+    if ( mp->rel.istoken != 0 )
+        jaddstr(item,"bobtoken",mp->rel.tokenid);
+    if ( subatomic_zonly(&mp->base) != 0 )
+        jaddstr(item,"aliceZaddr",mp->alice.recvZaddr);
+    else jaddstr(item,"aliceaddr",mp->alice.recvaddr);
+    if ( mp->base.istoken != 0 )
+        jaddstr(item,"alicetoken",mp->base.tokenid);
+    return(item);
+}
+
+uint64_t subatomic_orderbook_mpset(struct msginfo *mp,char *basecheck)
+{
+    cJSON *retjson; char *tagA,*tagB,*senderpub,*str,tmpstr[32]; int32_t matches=0; double volA,volB; int64_t txfee=0;
+    strcpy(mp->base.name,basecheck);
+    strcpy(mp->base.coin,subatomic_checkname(tmpstr,mp,0,basecheck));
+    mp->rel.txfee = subatomic_txfee(mp->rel.coin);
+    if ( (retjson= dpow_get(mp->origid)) != 0 )
+    {
+        //fprintf(stderr,"dpow_get.(%s) (%s/%s)\n",jprint(retjson,0),mp->base.coin,mp->rel.coin);
+        if ( (senderpub= jstr(retjson,"senderpub")) != 0 && is_hexstr(senderpub,0) == 66 && (tagA= jstr(retjson,"tagA")) != 0 && (tagB= jstr(retjson,"tagB")) != 0 && strncmp(tagB,mp->rel.name,strlen(mp->rel.name)) == 0 && strlen(tagA) < sizeof(mp->base.name) )
+        {
+            strcpy(mp->base.name,tagA);
+            strcpy(mp->base.coin,subatomic_checkname(tmpstr,mp,0,tagA));
+            if ( basecheck[0] == 0 || strncmp(basecheck,tagA,strlen(basecheck)) == 0 )
+                matches = 1;
+            else if ( strcmp(tagA,mp->base.name) == 0 )
+                matches = 1;
+            else if ( mp->bobflag != 0 && tagA[0] == '#' && strcmp(mp->base.name,"#allfiles") == 0 )
+                matches = 1;
+            if ( matches != 0 )
+            {
+                if ( (str= jstr(retjson,"decrypted")) != 0 && strlen(str) < 128 )
+                    strcpy(mp->payload,str);
+                mp->locktime = juint(retjson,"timestamp") + SUBATOMIC_LOCKTIME;
+                mp->base.txfee = subatomic_txfee(mp->base.coin);
+                strcpy(mp->senderpub,senderpub);
+                volB = jdouble(retjson,"amountB");
+                volA = jdouble(retjson,"amountA");
+                mp->base.maxamount = volA*SATOSHIDEN + 0.0000000049999;
+                mp->rel.maxamount = volB*SATOSHIDEN + 0.0000000049999;
+                if ( 0 && mp->rel.istoken == 0 )
+                    txfee = mp->rel.txfee;
+                if ( mp->base.maxamount != 0 && mp->rel.maxamount != 0 && volA > SMALLVAL && volB > SMALLVAL && mp->rel.satoshis <= mp->rel.maxamount )
+                {
+                    mp->price = volA / volB;
+                    mp->base.satoshis = (mp->rel.satoshis - txfee) * mp->price;
+                    //fprintf(stderr,"base satoshis.%llu\n",(long long)mp->base.satoshis);
+                } else fprintf(stderr,"%u rel %llu vs (%llu %llu)\n",mp->origid,(long long)mp->rel.satoshis,(long long)mp->base.maxamount,(long long)mp->rel.maxamount);
+            } else printf("%u didnt match (%s) tagA.%s %s, tagB.%s %s %d %d\n",mp->origid,basecheck,tagA,mp->base.name,tagB,mp->rel.name,tagA[0] == '#', strcmp(mp->base.name,"#allfiles") == 0);
+        } else printf("%u didnt compare tagA.%s %s, tagB.%s %s\n",mp->origid,tagA,mp->base.name,tagB,mp->rel.name);
+        free_json(retjson);
+    }
+    return(mp->base.satoshis);
+}
+
+char *randhashstr(char *str)
+{
+    bits256 rands; int32_t i;
+    for (i=0; i<32; i++)
+        rands.bytes[i] = rand() >> 17;
+    bits256_str(str,rands);
+    return(str);
+}
+
+void subatomic_extrafields(cJSON *dest,cJSON *src)
+{
+    char *str;
+    if ( (str= jstr(src,"approval")) != 0 )
+        jaddstr(dest,"approval",str);
+    if ( (str= jstr(src,"opened")) != 0 )
+        jaddstr(dest,"opened",str);
+    if ( (str= jstr(src,"payamount")) != 0 )
+        jaddstr(dest,"payamount",str);
+    if ( (str= jstr(src,"destaddr")) != 0 )
+        jaddstr(dest,"destaddr",str);
+    if ( (str= jstr(src,"bobpayment")) != 0 )
+        jaddstr(dest,"bobpayment",str);
+    if ( (str= jstr(src,"alicepayment")) != 0 )
+        jaddstr(dest,"alicepayment",str);
+    if ( (str= jstr(src,"bobaddr")) != 0 )
+        jaddstr(dest,"bobaddr",str);
+    if ( (str= jstr(src,"bobZaddr")) != 0 )
+        jaddstr(dest,"bobZaddr",str);
+    if ( (str= jstr(src,"aliceaddr")) != 0 )
+        jaddstr(dest,"aliceaddr",str);
+    if ( (str= jstr(src,"aliceZaddr")) != 0 )
+        jaddstr(dest,"aliceZaddr",str);
+    if ( (str= jstr(src,"alicetoken")) != 0 )
+        jaddstr(dest,"alicetoken",str);
+    if ( (str= jstr(src,"bobtoken")) != 0 )
+        jaddstr(dest,"bobtoken",str);
+}
+
+char *subatomic_submit(cJSON *argjson,int32_t tobob)
+{
+    char *jsonstr,*hexstr;
+    jaddnum(argjson,"tobob",tobob != 0);
+    jsonstr = jprint(argjson,1);
+    hexstr = subatomic_hexstr(jsonstr);
+    free(jsonstr);
+    return(hexstr);
+}
+
+#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_DROP 0x75
+#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
+#define SCRIPT_OP_CHECKLOCKTIMEVERIFY 0xb1
+
+int32_t subatomic_redeemscript(char *redeemscript,uint32_t locktime,char *pubkeyA,char *pubkeyB) // not needed
+{
+    // if ( refund ) OP_HASH160 <2of2 multisig hash> OP_EQUAL   // standard multisig
+    // else <locktime> CLTV OP_DROP <pubkeyA> OP_CHECKSIG // standard spend
+    uint8_t pubkeyAbytes[33],pubkeyBbytes[33],hex[4096]; int32_t i,n = 0;
+    decode_hex(pubkeyAbytes,33,pubkeyA);
+    decode_hex(pubkeyBbytes,33,pubkeyB);
+    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++] = 4;
+    hex[n++] = locktime & 0xff, locktime >>= 8;
+    hex[n++] = locktime & 0xff, locktime >>= 8;
+    hex[n++] = locktime & 0xff, locktime >>= 8;
+    hex[n++] = locktime & 0xff;
+    hex[n++] = SCRIPT_OP_CHECKLOCKTIMEVERIFY;
+    hex[n++] = SCRIPT_OP_DROP;
+    hex[n++] = 33; memcpy(&hex[n],pubkeyAbytes,33); n += 33;
+    hex[n++] = SCRIPT_OP_CHECKSIG;
+    hex[n++] = SCRIPT_OP_ENDIF;
+    for (i=0; i<n; i++)
+    {
+        redeemscript[i*2] = hexbyte((hex[i]>>4) & 0xf);
+        redeemscript[i*2 + 1] = hexbyte(hex[i] & 0xf);
+    }
+    redeemscript[n*2] = 0;
+    /*tmpbuf[0] = SCRIPT_OP_HASH160;
+     tmpbuf[1] = 20;
+     calc_OP_HASH160(scriptPubKey,tmpbuf+2,redeemscript);
+     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(n);
+}
+
+int32_t subatomic_approved(struct msginfo *mp,cJSON *approval,cJSON *msgjson,char *senderpub)
+{
+    char *hexstr,numstr[32],redeemscript[1024],*coin,*acname=""; cJSON *retjson,*decodejson; int32_t i,retval = 0;
+    subatomic_extrafields(approval,msgjson);
+    if ( mp->OTCmode == 0 )
+    {
+        coin = (mp->bobflag != 0) ? mp->base.coin : mp->rel.coin; // the other side gets this coin
+        if ( strcmp(coin,"KMD") != 0 )
+        {
+            acname = coin;
+            coin = "";
+        }
+        if ( get_createmultisig2(coin,acname,mp->msigaddr,mp->redeemscript,mp->alice.secp,mp->bob.secp) != 0 )
+        {
+            subatomic_redeemscript(redeemscript,mp->locktime,mp->alice.secp,mp->bob.secp);
+            if ( (decodejson= get_decodescript(coin,acname,redeemscript)) != 0 )
+            {
+                fprintf(stderr,"%s %s msigaddr.%s %s -> %s %s\n",mp->bobflag!=0?"bob":"alice",(mp->bobflag != 0) ? mp->base.coin : mp->rel.coin,mp->msigaddr,mp->redeemscript,redeemscript,jprint(decodejson,0));
+                free(decodejson);
+            }
+        }
+    }
+    sprintf(numstr,"%u",mp->origid);
+    for (i=0; numstr[i]!=0; i++)
+        sprintf(&mp->approval[i<<1],"%02x",numstr[i]);
+    sprintf(&mp->approval[i<<1],"%02x",' ');
+    i++;
+    mp->approval[i<<1] = 0;
+    jaddstr(approval,"approval",mp->approval);
+    hexstr = subatomic_submit(approval,!mp->bobflag);
+    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"approved",senderpub,"","")) != 0 )
+    {
+        if ( (mp->approvalid= juint(retjson,"id")) != 0 )
+            retval = 1;
+        printf("%u approvalid.%u (%s)\n",mp->origid,mp->approvalid,senderpub);
+        subatomic_status(mp,SUBATOMIC_APPROVED);
+        free_json(retjson);
+    }
+    free(hexstr);
+    return(retval);
+}
+
+int32_t subatomic_opened(struct msginfo *mp,cJSON *opened,cJSON *msgjson,char *senderpub)
+{
+    char *hexstr,channelstr[65]; cJSON *retjson; int32_t retval = 0;
+    subatomic_extrafields(opened,msgjson);
+    jaddstr(opened,"opened",randhashstr(channelstr));
+    hexstr = subatomic_submit(opened,!mp->bobflag);
+    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"opened",senderpub,"","")) != 0 )
+    {
+        if ( (mp->openedid= juint(retjson,"id")) != 0 )
+            retval = 1;
+        printf("%u openedid.%u\n",mp->origid,mp->openedid);
+        subatomic_status(mp,SUBATOMIC_OPENED);
+        free_json(retjson);
+    }
+    free(hexstr);
+    return(retval);
+}
+
+int32_t subatomic_payment(struct msginfo *mp,cJSON *payment,cJSON *msgjson,char *senderpub)
+{
+    bits256 txid; uint64_t paytoshis; cJSON *retjson; char numstr[32],*coin,*dest,*hexstr; int32_t retval = 0;
+    if ( mp->bobflag == 0 )
+    {
+        coin = mp->rel.name;
+        paytoshis = mp->rel.satoshis;
+        if ( subatomic_zonly(&mp->rel) != 0 )
+            dest = mp->bob.recvZaddr;
+        else dest = mp->bob.recvaddr;
+        sprintf(numstr,"%llu",(long long)paytoshis);
+        jaddstr(payment,"alicepays",numstr);
+        jaddstr(payment,"bobdestaddr",dest);
+        txid = subatomic_coinpayment(mp->origid,mp->OTCmode,&mp->rel,dest,paytoshis,mp->approval,mp->bob.secp,senderpub);
+        jaddbits256(payment,"alicepayment",txid);
+        mp->alicepayment = txid;
+        hexstr = 0; // get it from rawtransaction of txid
+        jaddstr(payment,"alicetx",hexstr);
+    }
+    else
+    {
+        coin = mp->base.name;
+        paytoshis = mp->base.satoshis;
+        if ( subatomic_zonly(&mp->base) != 0 )
+            dest = mp->alice.recvZaddr;
+        else dest = mp->alice.recvaddr;
+        sprintf(numstr,"%llu",(long long)paytoshis);
+        jaddstr(payment,"bobpays",numstr);
+        jaddstr(payment,"alicedestaddr",dest);
+        txid = subatomic_coinpayment(mp->origid,mp->OTCmode,&mp->base,dest,paytoshis,mp->approval,mp->alice.secp,senderpub);
+        jaddbits256(payment,"bobpayment",txid);
+        mp->bobpayment = txid;
+        hexstr = 0; // get it from rawtransaction of txid
+        jaddstr(payment,"bobtx",hexstr);
+    }
+    hexstr = subatomic_submit(payment,!mp->bobflag);
+    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"payment",senderpub,"","")) != 0 )
+    {
+        if ( (mp->paymentids[0]= juint(retjson,"id")) != 0 )
+            retval = 1;
+        printf("%u: %.8f %s -> %s, paymentid[0] %u\n",mp->origid,dstr(paytoshis),coin,dest,mp->paymentids[0]);
+        subatomic_status(mp,SUBATOMIC_PAYMENT);
+        free_json(retjson);
+    }
+    free(hexstr);
+    return(retval);
+}
+
+int32_t subatomic_paidinfull(struct msginfo *mp,cJSON *paid,cJSON *msgjson,char *senderpub)
+{
+    char *hexstr; cJSON *retjson; int32_t retval = 0;
+    jaddstr(paid,"paid","in full");
+    subatomic_extrafields(paid,msgjson);
+    hexstr = subatomic_submit(paid,!mp->bobflag);
+    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"paid",senderpub,"","")) != 0 )
+    {
+        if ( (mp->paidid= juint(retjson,"id")) != 0 )
+            retval = 1;
+        printf("%u paidid.%u\n",mp->origid,mp->paidid);
+        subatomic_status(mp,SUBATOMIC_PAIDINFULL);
+        free_json(retjson);
+    }
+    free(hexstr);
+    return(retval);
+}
+
+int32_t subatomic_closed(struct msginfo *mp,cJSON *closed,cJSON *msgjson,char *senderpub)
+{
+    char *hexstr; cJSON *retjson; int32_t retval = 0;
+    jaddnum(closed,"closed",mp->origid);
+    subatomic_extrafields(closed,msgjson);
+    hexstr = subatomic_submit(closed,!mp->bobflag);
+    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"closed",senderpub,"","")) != 0 )
+    {
+        if ( (mp->closedid= juint(retjson,"id")) != 0 )
+            retval = 1;
+        subatomic_status(mp,SUBATOMIC_CLOSED);
+        printf("%u closedid.%u\n",mp->origid,mp->closedid);
+        free_json(retjson);
+    }
+    free(hexstr);
+    return(retval);
+}
+
+uint32_t subatomic_alice_openrequest(struct msginfo *origmp)
+{
+    struct msginfo *mp; cJSON *retjson,*openrequest; char *hexstr,*str,tmpstr[32];
+    mp = subatomic_tracker(origmp->origid);
+    mp->origid = origmp->origid;
+    mp->rel.satoshis = origmp->rel.satoshis;
+    mp->rel.istoken = origmp->rel.istoken;
+    strcpy(mp->rel.tokenid,origmp->rel.tokenid);
+    strcpy(mp->rel.name,origmp->rel.name);
+    strcpy(mp->rel.coin,subatomic_checkname(tmpstr,mp,1,origmp->rel.name));
+    strcpy(mp->alice.pubkey,DPOW_pubkeystr);
+    strcpy(mp->alice.secp,DPOW_secpkeystr);
+    strcpy(mp->alice.recvZaddr,DPOW_recvZaddr);
+    strcpy(mp->alice.recvaddr,DPOW_recvaddr);
+    printf("rel.%s/%s %s openrequest %u status.%d (%s/%s)\n",mp->rel.name,mp->rel.coin,mp->rel.tokenid,mp->origid,mp->status,mp->alice.recvaddr,mp->alice.recvZaddr);
+    if ( mp->status == 0 && subatomic_orderbook_mpset(mp,"") != 0 )
+    {
+        strcpy(mp->bob.pubkey,mp->senderpub);
+        if ( subatomic_zonly(&mp->base) != 0 || subatomic_zonly(&mp->rel) != 0 )
+            mp->OTCmode = 1;
+        else mp->OTCmode = SUBATOMIC_OTCDEFAULT;
+        strcpy(origmp->base.name,mp->base.name);
+        strcpy(origmp->base.coin,mp->base.coin);
+        origmp->base.istoken = mp->base.istoken;
+        strcpy(origmp->base.tokenid,mp->base.tokenid);
+        origmp->OTCmode = mp->OTCmode;
+        if ( mp->rel.istoken != 0 && ((mp->rel.satoshis % SATOSHIDEN) != 0 || mp->rel.iszaddr != 0) )
+        {
+            printf("%u cant do zaddr or fractional rel %s.%s tokens %.8f\n",mp->origid,mp->rel.coin,mp->rel.tokenid,dstr(mp->rel.satoshis));
+            return(0);
+        }
+        else if ( mp->base.istoken != 0 && ((mp->base.satoshis % SATOSHIDEN) != 0 || mp->base.iszaddr != 0 ) )
+        {
+            printf("%u cant do zaddr or fractional base %s.%s tokens %.8f\n",mp->origid,mp->base.coin,mp->base.tokenid,dstr(mp->base.satoshis));
+            return(0);
+        }
+        else if ( (openrequest= subatomic_mpjson(mp)) != 0 )
+        {
+            hexstr = subatomic_submit(openrequest,!mp->bobflag);
+            if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,(char *)"inbox",(char *)"openrequest",mp->bob.pubkey,"","")) != 0 )
+            {
+                mp->openrequestid = juint(retjson,"id");
+                printf("%u openrequest.%u -> (%s)\n",mp->origid,mp->openrequestid,mp->bob.pubkey);
+                subatomic_status(mp,SUBATOMIC_OPENREQUEST);
+                free_json(retjson);
+            }
+            free(hexstr);
+        }
+    }
+    return(mp->openrequestid);
+}
+
+void subatomic_bob_gotopenrequest(uint32_t inboxid,char *senderpub,cJSON *msgjson,char *basename,char *relname)
+{
+    struct msginfo *mp; cJSON *approval; int32_t origid; char *addr,tmpstr[32],*coin,*acname="";
+    origid = juint(msgjson,"origid");
+    mp = subatomic_tracker(origid);
+    strcpy(mp->base.name,basename);
+    strcpy(mp->base.coin,subatomic_checkname(tmpstr,mp,0,basename));
+    strcpy(mp->rel.name,relname);
+    strcpy(mp->rel.coin,subatomic_checkname(tmpstr,mp,1,relname));
+    mp->origid = origid;
+    mp->rel.satoshis = j64bits(msgjson,"relsatoshis");
+    mp->bobflag = 1;
+    strcpy(mp->bob.pubkey,DPOW_pubkeystr);
+    strcpy(mp->bob.secp,DPOW_secpkeystr);
+    strcpy(mp->bob.recvZaddr,DPOW_recvZaddr);
+    strcpy(mp->bob.recvaddr,DPOW_recvaddr);
+    if ( (addr= jstr(msgjson,"aliceaddr")) != 0 )
+        strcpy(mp->alice.recvaddr,addr);
+    if ( (addr= jstr(msgjson,"aliceZaddr")) != 0 )
+        strcpy(mp->alice.recvZaddr,addr);
+    if ( (addr= jstr(msgjson,"alicesecp")) != 0 )
+        strcpy(mp->alice.secp,addr);
+    if ( subatomic_zonly(&mp->base) != 0 || subatomic_zonly(&mp->rel) != 0 )
+        mp->OTCmode = 1;
+    else mp->OTCmode = SUBATOMIC_OTCDEFAULT;
+    printf("%u got open request\n",mp->origid);
+    if ( mp->status == 0 && subatomic_orderbook_mpset(mp,basename) != 0 && (approval= subatomic_mpjson(mp)) != 0 )
+    {
+        if ( mp->rel.istoken != 0 && ((mp->rel.satoshis % SATOSHIDEN) != 0 || mp->rel.iszaddr != 0) )
+        {
+            printf("%u cant do zaddr or fractional rel %s.%s tokens %.8f\n",mp->origid,mp->rel.coin,mp->rel.tokenid,dstr(mp->rel.satoshis));
+            subatomic_closed(mp,approval,msgjson,senderpub);
+            return;
+        }
+        else if ( mp->base.istoken != 0 && ((mp->base.satoshis % SATOSHIDEN) != 0 || mp->base.iszaddr != 0 ) )
+        {
+            printf("%u cant do zaddr or fractional base %s.%s tokens %.8f\n",mp->origid,mp->base.coin,mp->base.tokenid,dstr(mp->base.satoshis));
+            subatomic_closed(mp,approval,msgjson,senderpub);
+            return;
+        }
+        else if ( subatomic_getbalance(&mp->base) < mp->base.satoshis )
+        {
+            printf("%u bob node low on %s funds! %.8f not enough for %.8f\n",mp->origid,mp->base.coin,dstr(subatomic_getbalance(&mp->base)),dstr(mp->base.satoshis));
+            subatomic_closed(mp,approval,msgjson,senderpub);
+        }
+        else
+        {
+            printf("%u bob (%s/%s) gotopenrequest origid.%u status.%d (%s/%s) SENDERPUB.(%s)\n",mp->origid,mp->base.name,mp->rel.name,mp->origid,mp->status,mp->bob.recvaddr,mp->bob.recvZaddr,senderpub);
+            subatomic_approved(mp,approval,msgjson,senderpub);
+        }
+    }
+}
+
+int32_t subatomic_channelapproved(uint32_t inboxid,char *senderpub,cJSON *msgjson,struct msginfo *origmp)
+{
+    struct msginfo *mp; cJSON *approval; char *addr,*coin,*acname; int32_t retval = 0;
+    mp = subatomic_tracker(juint(msgjson,"origid"));
+    if ( subatomic_orderbook_mpset(mp,mp->base.name) != 0 && (approval= subatomic_mpjson(mp)) != 0 )
+    {
+        printf("%u iambob.%d (%s/%s) channelapproved origid.%u status.%d\n",mp->origid,mp->bobflag,mp->base.name,mp->rel.name,mp->origid,mp->status);
+        if ( mp->bobflag == 0 && mp->status == SUBATOMIC_OPENREQUEST )
+        {
+            if ( (addr= jstr(msgjson,"bobaddr")) != 0 )
+                strcpy(mp->bob.recvaddr,addr);
+            if ( (addr= jstr(msgjson,"bobZaddr")) != 0 )
+                strcpy(mp->bob.recvZaddr,addr);
+            if ( (addr= jstr(msgjson,"bobsecp")) != 0 )
+                strcpy(mp->bob.secp,addr);
+            retval = subatomic_approved(mp,approval,msgjson,senderpub);
+        }
+        else if ( mp->bobflag != 0 && mp->status == SUBATOMIC_APPROVED )
+            retval = subatomic_opened(mp,approval,msgjson,senderpub);
+    }
+    return(retval);
+}
+
+int32_t subatomic_incomingopened(uint32_t inboxid,char *senderpub,cJSON *msgjson,struct msginfo *origmp)
+{
+    struct msginfo *mp; cJSON *payment; int32_t retval = 0;
+    mp = subatomic_tracker(juint(msgjson,"origid"));
+    if ( subatomic_orderbook_mpset(mp,mp->base.name) != 0 && (payment= subatomic_mpjson(mp)) != 0 )
+    {
+        printf("%u iambob.%d (%s/%s) incomingchannel status.%d\n",mp->origid,mp->bobflag,mp->base.name,mp->rel.name,mp->status);
+        if ( mp->bobflag == 0 && mp->status == SUBATOMIC_APPROVED )
+            retval = subatomic_payment(mp,payment,msgjson,senderpub);
+        else if ( mp->bobflag != 0 && mp->status == SUBATOMIC_OPENED )
+            retval = 1; // nothing to do
+    }
+    return(retval);
+}
+
+int32_t subatomic_incomingpayment(uint32_t inboxid,char *senderpub,cJSON *msgjson,struct msginfo *origmp)
+{
+    static FILE *fp;
+    struct msginfo *mp; cJSON *pay,*rawtx,*retjson; bits256 txid; char str[65],*hexstr; int32_t retval = 0;
+    mp = subatomic_tracker(juint(msgjson,"origid"));
+    if ( subatomic_orderbook_mpset(mp,mp->base.name) != 0 && (pay= subatomic_mpjson(mp)) != 0 )
+    {
+        printf("%u iambob.%d (%s/%s) incomingpayment status.%d\n",mp->origid,mp->bobflag,mp->base.name,mp->rel.name,mp->status);
+        if ( mp->bobflag == 0 )
+        {
+            txid = jbits256(msgjson,"bobpayment");
+            jaddbits256(msgjson,"alicepayment",mp->alicepayment);
+            printf("%u alice waits for %s.%s to be in mempool (%.8f -> %s)\n",mp->origid,mp->base.name,bits256_str(str,txid),dstr(mp->base.satoshis),subatomic_zonly(&mp->base) == 0 ? mp->alice.recvaddr : mp->alice.recvZaddr);
+            hexstr = jstr(msgjson,"bobtx");
+            if ( (rawtx= subatomic_txidwait(&mp->base,txid,hexstr,SUBATOMIC_TIMEOUT,senderpub)) != 0 )
+            {
+                if ( subatomic_verifypayment(&mp->base,rawtx,mp->base.satoshis,subatomic_zonly(&mp->base) == 0 ? mp->alice.recvaddr : mp->alice.recvZaddr,txid) >= 0 )
+                    mp->gotpayment = 1;
+                free_json(rawtx);
+            }
+            if ( mp->gotpayment != 0 )
+            {
+                printf("%u SWAP COMPLETE <<<<<<<<<<<<<<<<\n",mp->origid);
+                SUBATOMIC_retval = 0;
+                if ( mp->base.iszaddr == 0 )
+                {
+                    sprintf(str,"%u",mp->origid);
+                    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,bits256_str(str,mp->alicepayment),(char *)"completed",str,DPOW_pubkeystr,"","")) != 0 )
+                        free_json(retjson);
+                }
+            }
+            else
+            {
+                printf("%u SWAP INCOMPLETE, waiting on %s.%s\n",mp->origid,mp->base.name,bits256_str(str,txid));
+                if ( (fp= fopen("SUBATOMIC.incomplete","a+")) != 0 )
+                {
+                    char *jsonstr = jprint(msgjson,0);
+                    fwrite(jsonstr,1,strlen(jsonstr),fp);
+                    fputc('\n',fp);
+                    fclose(fp);
+                    free(jsonstr);
+                }
+                if ( mp->base.iszaddr == 0 )
+                {
+                    sprintf(str,"%u",mp->origid);
+                    if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,bits256_str(str,mp->alicepayment),(char *)"incomplete",str,DPOW_pubkeystr,"","")) != 0 )
+                        free_json(retjson);
+                }
+                subatomic_closed(mp,pay,msgjson,senderpub);
+                exit(-1);
+            }
+        }
+        if ( mp->gotpayment != 0 )
+            retval = subatomic_paidinfull(mp,pay,msgjson,senderpub);
+        else
+        {
+            if ( mp->bobflag != 0 && mp->status == SUBATOMIC_OPENED )
+            {
+                txid = jbits256(msgjson,"alicepayment");
+                printf("%u bob waits for %s.%s to be in mempool (%.8f -> %s)\n",mp->origid,mp->rel.name,bits256_str(str,txid),dstr(mp->rel.satoshis),subatomic_zonly(&mp->rel) == 0 ? mp->bob.recvaddr : mp->bob.recvZaddr);
+                hexstr = jstr(msgjson,"alicetx");
+                if ( (rawtx= subatomic_txidwait(&mp->rel,txid,hexstr,SUBATOMIC_TIMEOUT,senderpub)) != 0 )
+                {
+                    if ( subatomic_verifypayment(&mp->rel,rawtx,mp->rel.satoshis,subatomic_zonly(&mp->rel) == 0 ? mp->bob.recvaddr : mp->bob.recvZaddr,txid) >= 0 )
+                        mp->gotpayment = 1;
+                    free_json(rawtx);
+                }
+                if ( mp->gotpayment != 0 )
+                {
+                    retval = subatomic_payment(mp,pay,msgjson,senderpub);
+                    jaddbits256(msgjson,"bobpayment",mp->bobpayment);
+                    if ( mp->rel.iszaddr == 0 )
+                    {
+                        sprintf(str,"%u",mp->origid);
+                        if ( (retjson= dpow_broadcast(SUBATOMIC_PRIORITY,bits256_str(str,mp->bobpayment),(char *)"completed",str,DPOW_pubkeystr,"","")) != 0 )
+                            free_json(retjson);
+                    }
+                    printf("%u SWAP COMPLETE <<<<<<<<<<<<<<<<\n",mp->origid);
+                    if ( (fp= fopen("SUBATOMIC.proof","rb+")) == 0 )
+                        fp = fopen("SUBATOMIC.proof","wb");
+                    if ( fp != 0 )
+                    {
+                        char *jsonstr = jprint(msgjson,0);
+                        fseek(fp,0,SEEK_END);
+                        fwrite(jsonstr,1,strlen(jsonstr),fp);
+                        fputc('\n',fp);
+                        fflush(fp);
+                        free(jsonstr);
+                    }
+                } else printf("%u SWAP INCOMPLETE: %s\n",mp->origid,jprint(msgjson,0));
+            }
+        }
+    }
+    return(retval);
+}
+
+int32_t subatomic_incomingfullypaid(uint32_t inboxid,char *senderpub,cJSON *msgjson,struct msginfo *origmp)
+{
+    struct msginfo *mp; cJSON *closed; int32_t retval = 0;
+    mp = subatomic_tracker(juint(msgjson,"origid"));
+    if ( subatomic_orderbook_mpset(mp,mp->base.name) != 0 && (closed= subatomic_mpjson(mp)) != 0 )
+    {
+        printf("%u iambob.%d (%s/%s) incomingfullypaid status.%d\n",mp->origid,mp->bobflag,mp->base.name,mp->rel.name,mp->status);
+        // error check msgjson vs M
+        if ( mp->bobflag == 0 && mp->status == SUBATOMIC_PAIDINFULL )
+            retval = subatomic_closed(mp,closed,msgjson,senderpub);
+        else if ( mp->bobflag != 0 && mp->status == SUBATOMIC_PAYMENT )
+            retval = subatomic_paidinfull(mp,closed,msgjson,senderpub);
+    }
+    return(retval);
+}
+
+int32_t subatomic_incomingclosed(uint32_t inboxid,char *senderpub,cJSON *msgjson,struct msginfo *origmp)
+{
+    struct msginfo *mp; cJSON *closed; int32_t retval = 0;
+    mp = subatomic_tracker(juint(msgjson,"origid"));
+    if ( subatomic_orderbook_mpset(mp,mp->base.name) != 0 && (closed= subatomic_mpjson(mp)) != 0 )
+    {
+        printf("%u iambob.%d (%s/%s) incomingclose status.%d\n",mp->origid,mp->bobflag,mp->base.name,mp->rel.name,mp->status);
+        if ( mp->bobflag != 0 )
+            dpow_cancel(mp->origid);
+        if ( mp->status < SUBATOMIC_CLOSED )
+        {
+            retval = subatomic_closed(mp,closed,msgjson,senderpub);
+            subatomic_status(mp,SUBATOMIC_CLOSED);
+        }
+        retval = 1;
+    }
+    return(retval);
+}
+
+int32_t subatomic_ismine(int32_t bobflag,cJSON *json,char *basename,char *relname)
+{
+    char *base,*rel;
+    if ( (base= jstr(json,"base")) != 0 && (rel= jstr(json,"rel")) != 0 )
+    {
+        if ( strcmp(base,basename) == 0 && strcmp(rel,relname) == 0 )
+            return(1);
+        if ( bobflag != 0 )
+        {
+            if ( strcmp(basename,"#allfiles") == 0 && base[0] == '#' )
+                return(1);
+            fprintf(stderr,"skip ismine (%s/%s) vs (%s/%s)\n",basename,relname,base,rel);
+        }
+    }
+    return(0);
+}
+
+void subatomic_tokensregister(int32_t priority)
+{
+    char *token_name,*tokenid,existing[65]; cJSON *tokens,*token; int32_t i,numtokens;
+    if ( SUBATOMIC_json != 0 && (tokens= jarray(&numtokens,SUBATOMIC_json,"tokens")) != 0 )
+    {
+        for (i=0; i<numtokens; i++)
+        {
+            token = jitem(tokens,i);
+            if ( token != 0 )
+            {
+                token_name = jfieldname(token);
+                tokenid = jstr(token,token_name);
+                //fprintf(stderr,"TOKEN (%s %s)\n",token_name,tokenid);
+                if ( token_name != 0 && tokenid != 0 )
+                    dpow_tokenregister(existing,priority,token_name,tokenid);
+            }
+        }
+    }
+}
+
+void subatomic_filesregister(int32_t priority)
+{
+    char *fname,*tokenid,*coin,existing[512]; int64_t price; cJSON *files,*file,*prices; int32_t i,j,m,numfiles;
+    if ( SUBATOMIC_json != 0 && (files= jarray(&numfiles,SUBATOMIC_json,"files")) != 0 )
+    {
+        for (i=0; i<numfiles; i++)
+        {
+            file = jitem(files,i);
+            if ( file != 0 )
+            {
+                // {"filename":"komodod",prices:[{"KMD":0.1}, {"PIRATE:1"}]}
+                fname = jstr(file,"filename");
+                if ( (prices= jarray(&m,file,"prices")) != 0 && m > 0 )
+                {
+                    for (j=0; j<m; j++)
+                    {
+                        coin = jfieldname(jitem(prices,j));
+                        price = (jdouble(jitem(prices,j),coin)*SATOSHIDEN + 0.00000000499999);
+                        //pricestr = jstr(jitem(prices,j),coin);
+                        //fprintf(stderr,"%s %.8f, ",coin,dstr(price));
+                        dpow_fileregister(existing,priority,fname,coin,price);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void subatomic_loop(struct msginfo *mp)
+{
+    static char *tagBs[] = { "openrequest", "approved", "opened", "payment", "paid", "closed" };
+    static uint32_t stopats[sizeof(tagBs)/sizeof(*tagBs)];
+    struct inboxinfo **ptrs,*ptr; char *tagB; int32_t i,iter,n,msgs=0,mask=0; cJSON *inboxjson;
+    fprintf(stderr,"start subatomic_loop iambob.%d %s -> %s, %u %llu %u\n",mp->bobflag,mp->base.name,mp->rel.name,mp->origid,(long long)mp->rel.satoshis,mp->openrequestid);
+    while ( 1 )
+    {
+        if ( msgs == 0 )
+        {
+            sleep(1);
+            fflush(stdout);
+            if ( mp->bobflag != 0 )
+            {
+                dpow_pubkeyregister(SUBATOMIC_PRIORITY);
+                subatomic_tokensregister(SUBATOMIC_PRIORITY);
+                subatomic_filesregister(SUBATOMIC_PRIORITY);
+            }
+        }
+        msgs = 0;
+        for (iter=0; iter<(int32_t)(sizeof(tagBs)/sizeof(*tagBs)); iter++)
+        {
+            tagB = tagBs[iter];
+            if ( (ptrs= dpow_inboxcheck(&n,&stopats[iter],tagB)) != 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    msgs++;
+                    if ( (ptr= ptrs[i]) != 0 )
+                    {
+                        if ( (inboxjson= cJSON_Parse(ptr->jsonstr)) != 0 )
+                        {
+                            if ( jint(inboxjson,"tobob") != mp->bobflag )
+                                continue;
+                            if ( subatomic_ismine(mp->bobflag,inboxjson,mp->base.name,mp->rel.name) != 0 )
+                            {
+                                if ( strcmp(tagB,"openrequest") == 0 && mp->bobflag != 0 )
+                                    subatomic_bob_gotopenrequest(ptr->shorthash,ptr->senderpub,inboxjson,mp->base.name,mp->rel.name);
+                                else if ( strcmp(tagB,"approved") == 0 )
+                                    mask |= subatomic_channelapproved(ptr->shorthash,ptr->senderpub,inboxjson,mp) << 0;
+                                else if ( strcmp(tagB,"opened") == 0 )
+                                    mask |= subatomic_incomingopened(ptr->shorthash,ptr->senderpub,inboxjson,mp) << 1;
+                                else if ( strcmp(tagB,"payment") == 0 )
+                                    mask |= subatomic_incomingpayment(ptr->shorthash,ptr->senderpub,inboxjson,mp) << 2;
+                                else if ( strcmp(tagB,"paid") == 0 )
+                                    mask |= subatomic_incomingfullypaid(ptr->shorthash,ptr->senderpub,inboxjson,mp) << 3;
+                                else if ( strcmp(tagB,"closed") == 0 )
+                                    mask |= subatomic_incomingclosed(ptr->shorthash,ptr->senderpub,inboxjson,mp) * 0x1f;
+                                else fprintf(stderr,"iambob.%d unknown unexpected tagB.(%s)\n",mp->bobflag,tagB);
+                            }
+                            free_json(inboxjson);
+                        } else fprintf(stderr,"subatomic iambob.%d loop got unparseable(%s)\n",mp->bobflag,ptr->jsonstr);
+                        free(ptr);
+                        ptrs[i] = 0;
+                    }
+                }
+                free(ptrs);
+            }
+        }
+        if ( mp->bobflag == 0 && (mask & 0x1f) == 0x1f )
+        {
+            printf("alice %u %llu %u finished\n",mp->origid,(long long)mp->rel.satoshis,mp->openrequestid);
+            break;
+        }
+    }
+}
+
+int32_t main(int32_t argc,char **argv)
+{
+    char *fname = "subatomic.json";
+    int32_t i,height; char *coin,*kcli,*subatomic,*hashstr,*acname=(char *)""; cJSON *retjson; bits256 blockhash; char checkstr[65],str[65],str2[65],tmpstr[32]; long fsize; struct msginfo M;
+    memset(&M,0,sizeof(M));
+    srand((int32_t)time(NULL));
+    if ( (subatomic= filestr(&fsize,fname)) == 0 )
+    {
+        fprintf(stderr,"cant load %s file\n",fname);
+        exit(-1);
+    }
+    if ( (SUBATOMIC_json= cJSON_Parse(subatomic)) == 0 )
+    {
+        fprintf(stderr,"cant parse subatomic.json file (%s)\n",subatomic);
+        exit(-1);
+    }
+    free(subatomic);
+    if ( argc >= 4 )
+    {
+        if ( dpow_pubkey() < 0 )
+        {
+            fprintf(stderr,"couldnt set pubkey for DEX\n");
+            return(-1);
+        }
+        coin = (char *)argv[1];
+        if ( argv[2][0] != 0 )
+            REFCOIN_CLI = (char *)argv[2];
+        else
+        {
+            if ( strcmp(coin,"KMD") != 0 )
+            {
+                acname = coin;
+            }
+        }
+        hashstr = (char *)argv[3];
+        strcpy(M.rel.coin,subatomic_checkname(tmpstr,&M,1,coin));
+        strcpy(M.rel.name,coin);
+        if ( argc == 4 && strlen(hashstr) == 64 ) // for blocknotify usage, seems not needed
+        {
+            height = get_coinheight(coin,acname,&blockhash);
+            bits256_str(checkstr,blockhash);
+            if ( strcmp(checkstr,hashstr) == 0 )
+            {
+                fprintf(stderr,"%s: (%s) %s height.%d\n",coin,REFCOIN_CLI!=0?REFCOIN_CLI:"",checkstr,height);
+                if ( (retjson= dpow_ntzdata(coin,SUBATOMIC_PRIORITY,height,blockhash)) != 0 )
+                    free_json(retjson);
+            } else fprintf(stderr,"coin.%s (%s) %s vs %s, height.%d\n",coin,REFCOIN_CLI!=0?REFCOIN_CLI:"",checkstr,hashstr,height);
+            if ( strcmp("BTC",coin) != 0 )
+            {
+                bits256 prevntzhash,ntzhash; int32_t prevntzheight,ntzheight; uint32_t ntztime,prevntztime; char hexstr[81]; cJSON *retjson2;
+                prevntzhash = dpow_ntzhash(coin,&prevntzheight,&prevntztime);
+                if ( (retjson= get_getinfo(coin,acname)) != 0 )
+                {
+                    ntzheight = juint(retjson,"notarized");
+                    ntzhash = jbits256(retjson,"notarizedhash");
+                    if ( ntzheight > prevntzheight )
+                    {
+                        get_coinmerkleroot(coin,acname,ntzhash,&ntztime);
+                        fprintf(stderr,"NOTARIZATION %s.%d %s t.%u\n",coin,ntzheight,bits256_str(str,ntzhash),ntztime);
+                        bits256_str(hexstr,ntzhash);
+                        sprintf(&hexstr[64],"%08x",ntzheight);
+                        sprintf(&hexstr[72],"%08x",ntztime);
+                        hexstr[80] = 0;
+                        if ( (retjson2= dpow_broadcast(SUBATOMIC_PRIORITY,hexstr,coin,"notarizations",DPOW_pubkeystr,"","")) != 0 )
+                            free_json(retjson2);
+                    }
+                    else if ( ntzheight == prevntzheight && memcmp(&prevntzhash,&ntzhash,32) != 0 )
+                        fprintf(stderr,"NTZ ERROR %s.%d %s != %s\n",coin,ntzheight,bits256_str(str,ntzhash),bits256_str(str2,prevntzhash));
+                    free_json(retjson);
+                }
+            }
+        }
+        else if ( argc == 5 && atol(hashstr) > 10000 )
+        {
+            char checkstr[32]; uint64_t mult = 1;
+            M.origid = (uint32_t)atol(hashstr);
+            sprintf(checkstr,"%u",M.origid);
+            if ( strcmp(checkstr,hashstr) == 0 ) // alice
+            {
+                M.rel.satoshis = (uint64_t)(atof(argv[4])*SATOSHIDEN+0.0000000049999);
+                for (i=0; M.rel.name[i]!=0; i++)
+                    if ( M.rel.name[i] == '.' )
+                    {
+                        mult = SATOSHIDEN;
+                        break;
+                    }
+                if ( subatomic_getbalance(&M.rel) < M.rel.satoshis/mult )
+                {
+                    fprintf(stderr,"not enough balance %s %.8f for %.8f\n",M.rel.coin,dstr(subatomic_getbalance(&M.rel)),dstr(M.rel.satoshis/mult));
+                    return(-1);
+                }
+                fprintf(stderr,"subatomic_channel_alice (%s/%s) %s %u with %.8f %llu\n",M.rel.name,M.rel.coin,hashstr,M.origid,atof(argv[4]),(long long)M.rel.satoshis);
+                dpow_pubkeyregister(SUBATOMIC_PRIORITY);
+                M.openrequestid = subatomic_alice_openrequest(&M);
+                if ( M.openrequestid != 0 )
+                    subatomic_loop(&M);
+            } else fprintf(stderr,"checkstr mismatch %s %s != %s\n",coin,hashstr,checkstr);
+        }
+        else
+        {
+            M.bobflag = 1;
+            strcpy(M.base.name,hashstr);
+            strcpy(M.base.coin,subatomic_checkname(tmpstr,&M,0,hashstr));
+            subatomic_loop(&M); // while ( 1 ) loop for each relcoin -> basecoin
+        }
+    }
+    return(SUBATOMIC_retval);
+}
+
diff --git a/src/cc/dapps/subatomic.json b/src/cc/dapps/subatomic.json
new file mode 100644
index 000000000..7832fdb9e
--- /dev/null
+++ b/src/cc/dapps/subatomic.json
@@ -0,0 +1,27 @@
+{
+"authorized": [
+    {"chmex":"030754bffcf6dfcb34a20c486ff5a5be5546b9cc16fba9692165272b3f8e98c4af" },
+    {"SHossain":"03c8657bd57b6ceb14514a10e99fe8a0cec5a9bc24592df7f66f050e670e4f6bac" },
+    {"satinder":"03732f8ef851ff234c74d0df575c2c5b159e2bab3faca4ec52b3f217d5cda5361d" },
+    {"ml777":"02453d028c74cb9551e1aaf35113383b6ecbd9f06ff23a4ab1a953429b9763e345" },
+    {"tonylhub":"0218e0f435d4544404c25a7759b7f7174d821215085ef936218c5569d975af468b" },
+    {"gthub":"036c7de9a5090fbad78b9eea41549ccacc07bd0e9e7f8d290c88f470f3569e1a35" },
+    {"zkTrader":"026c6b0b35ec0adc2f8a5c648da1fce634f798c69d5e9fe518400447e88398b830" },
+    {"nutellalicka":"03aee08860e0340f0f490a3ef3718d6676882f2d63d4f536dfebb1d348b82c79ee" },
+    {"gcharang":"02d3431950c2f0f9654217b6ce3d44468d3a9ca7255741767fdeee7c5ec6b47567" },
+    {"jl777":"02b27de3ee5335518b06f69f4fbabb029cfc737613b100996841d5532b324a5a61" }
+],
+"tokens":[
+    {"RICK.demo":"2b1feef719ecb526b07416dd432bce603ac6dc8bfe794cddf105cb52f6aae3cd"}
+],
+"files":[
+    {"filename":"hushd","prices":[{"HUSH":0.1}, {"PIRATE":1}]}
+],
+"externalcoins":[
+    { "BTC":"bitcoin-cli" },
+    { "KMD":"komodod-cli" },
+    { "CHIPS":"chips-cli" },
+    { "PIRATE":"pirate-cli" }
+]
+}
+