Cleanup and remove dead code

3 years ago · f22cbbf1e2
25 changed files with 321 additions and 321 deletions
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@ -69,7 +69,7 @@ void WaitForShutdown(boost::thread_group* threadGroup)
    // Tell the main threads to shutdown.

    if ( ASSETCHAINS_CBOPRET != 0 ) {
-        komodo_pricesinit();
+        hush_pricesinit();
 	}

    while (!fShutdown)
--- a/src/cc/CCPrices.h
+++ b/src/cc/CCPrices.h
@ -23,7 +23,7 @@
 #include "hush_defs.h"
 #include "CCinclude.h"

-int32_t komodo_priceget(int64_t *buf64,int32_t ind,int32_t height,int32_t numblocks);
+int32_t hush_priceget(int64_t *buf64,int32_t ind,int32_t height,int32_t numblocks);
 extern void GetHushEarlytxidScriptPub();
 extern CScript HUSH_EARLYTXID_SCRIPTPUB;

--- a/src/cc/CC_made_easy.md
+++ b/src/cc/CC_made_easy.md
@ -84,7 +84,7 @@ However, this is the CC contract basics chapter, so let us ignore mempool issues

 That means to just follow a known working template and only changing the things where the existing templates are not sufficient, ie. the core differentiator of your CC contract.

-In the ~/komodo/src/cc/eval.h file all the eval codes are defined, currently:
+In the hush3/src/cc/eval.h file all the eval codes are defined, currently:

 #define FOREACH_EVAL(EVAL)             \
 EVAL(EVAL_IMPORTPAYOUT, 0xe1)  \
@ -201,7 +201,7 @@ You do need to be careful not to cause a deadlock as the CC validation code is c
 Chapter 6 - faucet example
 Finally, we are ready for the first actual example of a CC contract. The faucet. This is a very simple contract and it ran into some interesting bugs in the first incarnation.

-The code in ~/komodo/src/cc/faucet.cpp is the ultimate documentation for it with all the details, so I will just address the conceptual issues here.
+The code in hush3/src/cc/faucet.cpp is the ultimate documentation for it with all the details, so I will just address the conceptual issues here.

 The idea is that people send funds to the faucet by locking it in faucet's global CC address and anybody is allowed to create a faucetget transaction that spends it.

--- a/src/cc/cclib.cpp
+++ b/src/cc/cclib.cpp
@ -47,7 +47,7 @@ std::string MYCCLIBNAME = (char *)"sudoku";
 #endif

 #ifndef BUILD_GAMESCC
-void komodo_netevent(std::vector<uint8_t> payload) {}
+void hush_netevent(std::vector<uint8_t> payload) {}
 #endif

 extern std::string MYCCLIBNAME;
--- a/src/cc/gamescc.cpp
+++ b/src/cc/gamescc.cpp
@ -479,7 +479,7 @@ int32_t games_event(uint32_t timestamp,uint256 gametxid,int32_t eventid,std::vec
    {
        GetOpReturnData(games_eventopret(timestamp,mypk,sig,payload),vopret);
        games_payloadrecv(mypk,timestamp,payload);
-        komodo_sendmessage(4,8,"events",vopret);
+        hush_sendmessage(4,8,"events",vopret);
        return(0);
    }
    fprintf(stderr,"games_eventsign error\n");
@ -539,7 +539,7 @@ UniValue games_events(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
    return(result);
 }

-void komodo_netevent(std::vector<uint8_t> message)
+void hush_netevent(std::vector<uint8_t> message)
 {
    int32_t i,retval,lag,lagerr=0; uint32_t timestamp,now; CPubKey pk; std::vector<uint8_t> sig,payload; char str[67];
    if ( games_eventdecode(timestamp,pk,sig,payload,message) == 'E' )
@ -560,7 +560,7 @@ void komodo_netevent(std::vector<uint8_t> message)
                if ( (rand() % 10) == 0 )
                {
                    //fprintf(stderr,"relay message.[%d]\n",(int32_t)message.size());
-                    komodo_sendmessage(2,2,"events",message);
+                    hush_sendmessage(2,2,"events",message);
                }
            }
        }
--- a/src/hush.h
+++ b/src/hush.h
@ -146,7 +146,7 @@ int32_t hush_parsestatefile(struct hush_state *sp,FILE *fp,char *symbol,char *de
                errs++;
            //if ( matched != 0 ) global independent states -> inside *sp
            //printf("%s.%d load[%s] ht.%d\n",SMART_CHAIN_SYMBOL,ht,symbol,kheight);
-            hush_eventadd_kmdheight(sp,symbol,ht,kheight,0);
+            hush_eventadd_hushheight(sp,symbol,ht,kheight,0);
        }
        else if ( func == 'T' )
        {
@ -157,7 +157,7 @@ int32_t hush_parsestatefile(struct hush_state *sp,FILE *fp,char *symbol,char *de
                errs++;
            //if ( matched != 0 ) global independent states -> inside *sp
            //printf("%s.%d load[%s] ht.%d t.%u\n",SMART_CHAIN_SYMBOL,ht,symbol,kheight,ktimestamp);
-            hush_eventadd_kmdheight(sp,symbol,ht,kheight,ktimestamp);
+            hush_eventadd_hushheight(sp,symbol,ht,kheight,ktimestamp);
        }
        else if ( func == 'R' )
        {
@ -285,7 +285,7 @@ int32_t hush_parsestatefiledata(struct hush_state *sp,uint8_t *filedata,long *fp
            int32_t kheight;
            if ( memread(&kheight,sizeof(kheight),filedata,&fpos,datalen) != sizeof(kheight) )
                errs++;
-             hush_eventadd_kmdheight(sp,symbol,ht,kheight,0);
+             hush_eventadd_hushheight(sp,symbol,ht,kheight,0);
        }
        else if ( func == 'T' )
        {
@ -296,7 +296,7 @@ int32_t hush_parsestatefiledata(struct hush_state *sp,uint8_t *filedata,long *fp
                errs++;
            //if ( matched != 0 ) global independent states -> inside *sp
            //printf("%s.%d load[%s] ht.%d t.%u\n",SMART_CHAIN_SYMBOL,ht,symbol,kheight,ktimestamp);
-            hush_eventadd_kmdheight(sp,symbol,ht,kheight,ktimestamp);
+            hush_eventadd_hushheight(sp,symbol,ht,kheight,ktimestamp);
        }
        else if ( func == 'R' )
        {
@ -409,7 +409,7 @@ void hush_stateupdate(int32_t height,uint8_t notarypubs[][33],uint8_t numnotarie
                if ( fwrite(&HUSHheight,1,sizeof(HUSHheight),fp) != sizeof(HUSHheight) )
                    errs++;
            }
-            hush_eventadd_kmdheight(sp,symbol,height,HUSHheight,HUSHtimestamp);
+            hush_eventadd_hushheight(sp,symbol,height,HUSHheight,HUSHtimestamp);
        } else if ( opretbuf != 0 && opretlen > 0 ) {
            uint16_t olen = opretlen;
            fputc('R',fp);
@ -711,7 +711,7 @@ int32_t hush_voutupdate(bool fJustCheck,int32_t *isratificationp,int32_t notaryi
        else if ( matched != 0 && i == 0 && j == 1 && opretlen == 149 )
        {
            if ( notaryid >= 0 && notaryid < 64 )
-                komodo_paxpricefeed(height,&scriptbuf[len],opretlen);
+                hush_paxpricefeed(height,&scriptbuf[len],opretlen);
        }
        else if ( matched != 0 )
        {
@ -792,7 +792,7 @@ int32_t hush_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
        if ( pindex->GetHeight() != hwmheight )
        {
            printf("%s hwmheight.%d vs pindex->GetHeight().%d t.%u reorg.%d\n",SMART_CHAIN_SYMBOL,hwmheight,pindex->GetHeight(),(uint32_t)pindex->nTime,hwmheight-pindex->GetHeight());
-            komodo_purge_ccdata((int32_t)pindex->GetHeight());
+            hush_purge_ccdata((int32_t)pindex->GetHeight());
            hwmheight = pindex->GetHeight();
        }
        if (!fJustCheck)
--- a/src/hush_bitcoind.h
+++ b/src/hush_bitcoind.h
@ -950,12 +950,12 @@ int32_t hush_nextheight()
    else return(hush_longestchain() + 1);
 }

-int32_t hush_isrealtime(int32_t *kmdheightp)
+int32_t hush_isrealtime(int32_t *hushheightp)
 {
    struct hush_state *sp; CBlockIndex *pindex;
    if ( (sp= hush_stateptrget((char *)"HUSH3")) != 0 )
-        *kmdheightp = sp->CURRENT_HEIGHT;
-    else *kmdheightp = 0;
+        *hushheightp = sp->CURRENT_HEIGHT;
+    else *hushheightp = 0;
    if ( (pindex= chainActive.LastTip()) != 0 && pindex->GetHeight() >= (int32_t)hush_longestchain() )
        return(1);
    else return(0);
@ -1212,7 +1212,7 @@ void hush_segids(uint8_t *hashbuf,int32_t height,int32_t n)
    }
 }

-arith_uint256 komodo_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime)
+arith_uint256 hush_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime)
 {
    arith_uint256 origtarget,easy; int32_t diff,tipdiff; int64_t mult; bool fNegative,fOverflow; CBlockIndex *tipindex;
    if ( height > 10 && (tipindex= hush_chainactive(height - 1)) != 0 ) // disable offchain diffchange
@ -1238,7 +1238,7 @@ arith_uint256 komodo_adaptivepow_target(int32_t height,arith_uint256 bnTarget,ui
    return(bnTarget);
 }

-arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc)
+arith_uint256 hush_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc)
 {
    int32_t oldflag = 0,dispflag = 0;
    CBlockIndex *pindex; arith_uint256 easydiff,bnTarget,hashval,sum,ave; bool fNegative,fOverflow; int32_t i,n,m,ht,percPoS,diff,val;
@ -1543,7 +1543,7 @@ uint64_t hush_checknotarypay(CBlock *pblock,int32_t height)
    return(0);
 }

-bool komodo_appendACscriptpub()
+bool hush_appendACscriptpub()
 {
    static bool didinit = false;
    if ( didinit ) 
@ -1638,7 +1638,7 @@ int64_t hush_checkcommission(CBlock *pblock,int32_t height)
            if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
            {
                static bool didinit = false;
-                if ( !didinit && height > HUSH_EARLYTXID_HEIGHT && HUSH_EARLYTXID != zeroid && komodo_appendACscriptpub() )
+                if ( !didinit && height > HUSH_EARLYTXID_HEIGHT && HUSH_EARLYTXID != zeroid && hush_appendACscriptpub() )
                {
                    fprintf(stderr, "appended CC_op_return to ASSETCHAINS_SCRIPTPUB.%s\n", ASSETCHAINS_SCRIPTPUB.c_str());
                    didinit = true;
--- a/src/hush_cJSON.h
+++ b/src/hush_cJSON.h
@ -36,8 +36,8 @@
 * Removal or modification of this copyright notice is prohibited.            *
 *                                                                            *
 ******************************************************************************/
-#ifndef komodo_cJSON__h
-#define komodo_cJSON__h
+#ifndef hush_cJSON__h
+#define hush_cJSON__h
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
--- a/src/hush_ccdata.h
+++ b/src/hush_ccdata.h
@ -41,7 +41,7 @@ uint256 hush_calcMoM(int32_t height,int32_t MoMdepth)
    return BuildMerkleTree(&fMutated, leaves, tree);
 }

-struct hush_ccdata_entry *komodo_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t kmdstarti,int32_t kmdendi)
+struct hush_ccdata_entry *hush_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t kmdstarti,int32_t kmdendi)
 {
    struct hush_ccdata_entry *allMoMs=0; struct hush_ccdata *ccdata,*tmpptr; int32_t i,num,max;
    bool fMutated; std::vector<uint256> tree, leaves;
@ -58,7 +58,7 @@ struct hush_ccdata_entry *komodo_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t k
            }
            allMoMs[num].MoM = ccdata->MoMdata.MoM;
            allMoMs[num].notarized_height = ccdata->MoMdata.notarized_height;
-            allMoMs[num].kmdheight = ccdata->MoMdata.height;
+            allMoMs[num].hushheight = ccdata->MoMdata.height;
            allMoMs[num].txi = ccdata->MoMdata.txi;
            strcpy(allMoMs[num].symbol,ccdata->symbol);
            num++;
@ -81,7 +81,7 @@ struct hush_ccdata_entry *komodo_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t k
    return(allMoMs);
 }

-int32_t komodo_addpair(struct hush_ccdataMoMoM *mdata,int32_t notarized_height,int32_t offset,int32_t maxpairs)
+int32_t hush_addpair(struct hush_ccdataMoMoM *mdata,int32_t notarized_height,int32_t offset,int32_t maxpairs)
 {
    if ( maxpairs >= 0) {
        if ( mdata->numpairs >= maxpairs )
@ -91,7 +91,7 @@ int32_t komodo_addpair(struct hush_ccdataMoMoM *mdata,int32_t notarized_height,i
            //fprintf(stderr,"pairs reallocated to %p num.%d\n",mdata->pairs,mdata->numpairs);
        }
    } else {
-        fprintf(stderr,"komodo_addpair.maxpairs %d must be >= 0\n",(int32_t)maxpairs);
+        fprintf(stderr,"hush_addpair.maxpairs %d must be >= 0\n",(int32_t)maxpairs);
        return(-1);
    }
    mdata->pairs[mdata->numpairs].notarized_height = notarized_height;
@ -100,7 +100,7 @@ int32_t komodo_addpair(struct hush_ccdataMoMoM *mdata,int32_t notarized_height,i
    return(maxpairs);
 }

-int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mdata,char *symbol,int32_t kmdheight,int32_t notarized_height)
+int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mdata,char *symbol,int32_t hushheight,int32_t notarized_height)
 {
    uint8_t hexdata[8192]; struct hush_ccdata *ccdata,*tmpptr; int32_t len,maxpairs,i,retval=-1,depth,starti,endi,CCid=0; struct hush_ccdata_entry *allMoMs;
    starti = endi = depth = len = maxpairs = 0;
@ -114,7 +114,7 @@ int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mda
    portable_mutex_lock(&HUSH_CC_mutex);
    DL_FOREACH_SAFE(CC_data,ccdata,tmpptr)
    {
-        if ( ccdata->MoMdata.height < kmdheight )
+        if ( ccdata->MoMdata.height < hushheight )
        {
            //fprintf(stderr,"%s notarized.%d kmd.%d\n",ccdata->symbol,ccdata->MoMdata.notarized_height,ccdata->MoMdata.height);
            if ( strcmp(ccdata->symbol,symbol) == 0 )
@ -140,13 +140,13 @@ int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mda
    mdata->kmdendi = endi;
    if ( starti != 0 && endi != 0 && endi >= starti )
    {
-        if ( (allMoMs= komodo_allMoMs(&depth,&mdata->MoMoM,starti,endi)) != 0 )
+        if ( (allMoMs= hush_allMoMs(&depth,&mdata->MoMoM,starti,endi)) != 0 )
        {
            mdata->MoMoMdepth = depth;
            for (i=0; i<depth; i++)
            {
                if ( strcmp(symbol,allMoMs[i].symbol) == 0 )
-                    maxpairs = komodo_addpair(mdata,allMoMs[i].notarized_height,i,maxpairs);
+                    maxpairs = hush_addpair(mdata,allMoMs[i].notarized_height,i,maxpairs);
            }
            if ( mdata->numpairs > 0 )
            {
@ -160,7 +160,7 @@ int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mda
                {
                    if ( len + sizeof(uint32_t)*2 > sizeof(hexdata) )
                    {
-                        fprintf(stderr,"%s %d %d i.%d of %d exceeds hexdata.%d\n",symbol,kmdheight,notarized_height,i,mdata->numpairs,(int32_t)sizeof(hexdata));
+                        fprintf(stderr,"%s %d %d i.%d of %d exceeds hexdata.%d\n",symbol,hushheight,notarized_height,i,mdata->numpairs,(int32_t)sizeof(hexdata));
                        break;
                    }
                    len += dragon_rwnum(1,&hexdata[len],sizeof(uint32_t),(uint8_t *)&mdata->pairs[i].notarized_height);
@ -171,7 +171,7 @@ int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mda
                    init_hexbytes_noT(hexstr,hexdata,len);
                    //fprintf(stderr,"hexstr.(%s)\n",hexstr);
                    retval = 0;
-                } else fprintf(stderr,"%s %d %d too much hexdata[%d] for hexstr[%d]\n",symbol,kmdheight,notarized_height,len,hexsize);
+                } else fprintf(stderr,"%s %d %d too much hexdata[%d] for hexstr[%d]\n",symbol,hushheight,notarized_height,len,hexsize);
            }
            free(allMoMs);
        }
@ -179,7 +179,7 @@ int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mda
    return(retval);
 }

-void komodo_purge_ccdata(int32_t height)
+void hush_purge_ccdata(int32_t height)
 {
    struct hush_ccdata *ccdata,*tmpptr;
    if ( SMART_CHAIN_SYMBOL[0] == 0 )
@ -247,7 +247,7 @@ int32_t hush_rwccdata(char *thischain,int32_t rwflag,struct hush_ccdata *ccdata,
        {
            for (i=0; i<MoMoMdata->numpairs; i++)
            {
-                if ( (np= komodo_npptr(MoMoMdata->pairs[i].notarized_height)) != 0 )
+                if ( (np= hush_npptr(MoMoMdata->pairs[i].notarized_height)) != 0 )
                {
                    memset(&zero,0,sizeof(zero));
                    if ( memcmp(&np->MoMoM,&zero,sizeof(np->MoMoM)) == 0 )
--- a/src/hush_defs.h
+++ b/src/hush_defs.h
@ -594,7 +594,7 @@ extern int32_t ASSETCHAINS_EARLYTXIDCONTRACT;
 int tx_height( const uint256 &hash );
 extern std::vector<std::string> vAllowListAddress;
 extern std::map <std::int8_t, int32_t> mapHeightEvalActivate;
-void komodo_netevent(std::vector<uint8_t> payload);
+void hush_netevent(std::vector<uint8_t> payload);
 int32_t getacseason(uint32_t timestamp);
 int32_t gethushseason(int32_t height);

@ -603,8 +603,8 @@ int32_t gethushseason(int32_t height);
 #define HUSH_KVBINARY 2
 #define PRICES_SMOOTHWIDTH 1
 #define PRICES_MAXDATAPOINTS 8
-uint64_t komodo_paxprice(uint64_t *seedp,int32_t height,char *base,char *rel,uint64_t basevolume);
-int32_t komodo_paxprices(int32_t *heights,uint64_t *prices,int32_t max,char *base,char *rel);
+uint64_t hush_paxprice(uint64_t *seedp,int32_t height,char *base,char *rel,uint64_t basevolume);
+int32_t hush_paxprices(int32_t *heights,uint64_t *prices,int32_t max,char *base,char *rel);
 int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
 char *bitcoin_address(char *coinaddr,uint8_t addrtype,uint8_t *pubkey_or_rmd160,int32_t len);
 int32_t hush_minerids(uint8_t *minerids,int32_t height,int32_t width);
@ -615,22 +615,22 @@ int32_t hush_longestchain();
 int32_t hush_dpowconfs(int32_t height,int32_t numconfs);
 int8_t hush_segid(int32_t nocache,int32_t height);
 int32_t hush_heightpricebits(uint64_t *seedp,uint32_t *heightbits,int32_t nHeight);
-char *komodo_pricename(char *name,int32_t ind);
-int32_t komodo_priceind(const char *symbol);
-int32_t komodo_pricesinit();
-int64_t komodo_priceave(int64_t *tmpbuf,int64_t *correlated,int32_t cskip);
-int64_t komodo_pricecorrelated(uint64_t seed,int32_t ind,uint32_t *rawprices,int32_t rawskip,uint32_t *nonzprices,int32_t smoothwidth);
+char *hush_pricename(char *name,int32_t ind);
+int32_t hush_priceind(const char *symbol);
+int32_t hush_pricesinit();
+int64_t hush_priceave(int64_t *tmpbuf,int64_t *correlated,int32_t cskip);
+int64_t hush_pricecorrelated(uint64_t seed,int32_t ind,uint32_t *rawprices,int32_t rawskip,uint32_t *nonzprices,int32_t smoothwidth);
 int32_t hush_nextheight();
 uint32_t hush_heightstamp(int32_t height);
-int64_t komodo_pricemult(int32_t ind);
-int32_t komodo_priceget(int64_t *buf64,int32_t ind,int32_t height,int32_t numblocks);
+int64_t hush_pricemult(int32_t ind);
+int32_t hush_priceget(int64_t *buf64,int32_t ind,int32_t height,int32_t numblocks);
 int32_t hush_currentheight();
 int32_t hush_notarized_bracket(struct notarized_checkpoint *nps[2],int32_t height);
-arith_uint256 komodo_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime);
+arith_uint256 hush_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime);
 bool hush_hardfork_active(uint32_t time);

 uint256 Parseuint256(const char *hexstr);
-void komodo_sendmessage(int32_t minpeers, int32_t maxpeers, const char *message, std::vector<uint8_t> payload);
+void hush_sendmessage(int32_t minpeers, int32_t maxpeers, const char *message, std::vector<uint8_t> payload);
 CBlockIndex *hush_getblockindex(uint256 hash);
 int32_t hush_nextheight();
 CBlockIndex *hush_blockindex(uint256 hash);
--- a/src/hush_events.h
+++ b/src/hush_events.h
@ -88,7 +88,7 @@ void hush_eventadd_pricefeed(struct hush_state *sp,char *symbol,int32_t height,u
        memcpy(F.prices,prices,sizeof(*F.prices) * num);
        hush_eventadd(sp,height,symbol,HUSH_EVENT_PRICEFEED,(uint8_t *)&F,(int32_t)(sizeof(F.num) + sizeof(*F.prices) * num));
        if ( sp != 0 )
-            komodo_pvals(height,prices,num);
+            hush_pvals(height,prices,num);
    } //else fprintf(stderr,"skip pricefeed[%d]\n",num);
 }

@ -107,7 +107,7 @@ void hush_eventadd_opreturn(struct hush_state *sp,char *symbol,int32_t height,ui
        hush_eventadd(sp,height,symbol,HUSH_EVENT_OPRETURN,opret,O.oplen);
        free(opret);
        if ( sp != 0 )
-            komodo_opreturn(height,value,buf,opretlen,txid,vout,symbol);
+            hush_opreturn(height,value,buf,opretlen,txid,vout,symbol);
    }
 }

@ -155,32 +155,32 @@ void hush_event_rewind(struct hush_state *sp,char *symbol,int32_t height)
    }
 }

-void komodo_setkmdheight(struct hush_state *sp,int32_t kmdheight,uint32_t timestamp)
+void hush_sethushheight(struct hush_state *sp,int32_t hushheight,uint32_t timestamp)
 {
    if ( sp != 0 )
    {
-        if ( kmdheight > sp->SAVEDHEIGHT )
+        if ( hushheight > sp->SAVEDHEIGHT )
        {
-            sp->SAVEDHEIGHT = kmdheight;
+            sp->SAVEDHEIGHT = hushheight;
            sp->SAVEDTIMESTAMP = timestamp;
        }
-        if ( kmdheight > sp->CURRENT_HEIGHT )
-            sp->CURRENT_HEIGHT = kmdheight;
+        if ( hushheight > sp->CURRENT_HEIGHT )
+            sp->CURRENT_HEIGHT = hushheight;
    }
 }

-void hush_eventadd_kmdheight(struct hush_state *sp,char *symbol,int32_t height,int32_t kmdheight,uint32_t timestamp)
+void hush_eventadd_hushheight(struct hush_state *sp,char *symbol,int32_t height,int32_t hushheight,uint32_t timestamp)
 {
    uint32_t buf[2];
-    if ( kmdheight > 0 ) {
-        buf[0] = (uint32_t)kmdheight;
+    if ( hushheight > 0 ) {
+        buf[0] = (uint32_t)hushheight;
        buf[1] = timestamp;
        hush_eventadd(sp,height,symbol,HUSH_EVENT_HUSHHEIGHT,(uint8_t *)buf,sizeof(buf));
        if ( sp != 0 )
-            komodo_setkmdheight(sp,kmdheight,timestamp);
+            hush_sethushheight(sp,hushheight,timestamp);
    } else {
-        //fprintf(stderr,"REWIND kmdheight.%d\n",kmdheight);
-        kmdheight = -kmdheight;
+        //fprintf(stderr,"REWIND hushheight.%d\n",hushheight);
+        hushheight = -hushheight;
        hush_eventadd(sp,height,symbol,HUSH_EVENT_REWIND,(uint8_t *)&height,sizeof(height));
        if ( sp != 0 )
            hush_event_rewind(sp,symbol,height);
--- a/src/hush_gateway.h
+++ b/src/hush_gateway.h
--- a/src/hush_globals.h
+++ b/src/hush_globals.h
@ -26,11 +26,11 @@ int32_t hush_notarizeddata(int32_t nHeight,uint256 *notarized_hashp,uint256 *not
 char *hush_issuemethod(char *userpass,char *method,char *params,uint16_t port);
 void hush_init(int32_t height);
 int32_t hush_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,uint32_t timestamp);
-int32_t hush_isrealtime(int32_t *kmdheightp);
-uint64_t komodo_paxtotal();
+int32_t hush_isrealtime(int32_t *hushheightp);
+uint64_t hush_paxtotal();
 int32_t hush_longestchain();
-uint64_t komodo_maxallowed(int32_t baseid);
-int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
+uint64_t hush_maxallowed(int32_t baseid);
+int32_t hush_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
 int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts);
 pthread_mutex_t hush_mutex;

--- a/src/hush_nSPV_fullnode.h
+++ b/src/hush_nSPV_fullnode.h
@ -863,7 +863,7 @@ int32_t NSPV_getspentinfo(struct NSPV_spentinfo *ptr,uint256 txid,int32_t vout)
    return(len);
 }

-void komodo_nSPVreq(CNode *pfrom,std::vector<uint8_t> request) // received a request
+void hush_nSPVreq(CNode *pfrom,std::vector<uint8_t> request) // received a request
 {
    int32_t len,slen,ind,reqheight,n; std::vector<uint8_t> response; uint32_t timestamp = (uint32_t)time(NULL);
    if ( (len= request.size()) > 0 )
--- a/src/hush_nSPV_superlite.h
+++ b/src/hush_nSPV_superlite.h
@ -128,9 +128,9 @@ struct NSPV_ntzsproofresp *NSPV_ntzsproof_add(struct NSPV_ntzsproofresp *ptr)
    return(&NSPV_ntzsproofresp_cache[i]);
 }

-// komodo_nSPVresp is called from async message processing
+// hush_nSPVresp is called from async message processing

-void komodo_nSPVresp(CNode *pfrom,std::vector<uint8_t> response) // received a response
+void hush_nSPVresp(CNode *pfrom,std::vector<uint8_t> response) // received a response
 {
    struct NSPV_inforesp I; int32_t len; uint32_t timestamp = (uint32_t)time(NULL);
    strncpy(NSPV_lastpeer,pfrom->addr.ToString().c_str(),sizeof(NSPV_lastpeer)-1);
@ -274,9 +274,9 @@ UniValue NSPV_logout()
    return(result);
 }

-// komodo_nSPV from main polling loop (really this belongs in its own file, but it is so small, it ended up here)
+// hush_nSPV from main polling loop (really this belongs in its own file, but it is so small, it ended up here)

-void komodo_nSPV(CNode *pto) // polling loop from SendMessages
+void hush_nSPV(CNode *pto) // polling loop from SendMessages
 {
    uint8_t msg[256]; int32_t i,len=0; uint32_t timestamp = (uint32_t)time(NULL);
    if ( NSPV_logintime != 0 && timestamp > NSPV_logintime+NSPV_AUTOLOGOUT )
--- a/src/hush_notary.h
+++ b/src/hush_notary.h
@ -246,7 +246,7 @@ int32_t hush_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,ui

 //struct hush_state *hush_stateptr(char *symbol,char *dest);

-struct notarized_checkpoint *komodo_npptr_for_height(int32_t height, int *idx)
+struct notarized_checkpoint *hush_npptr_for_height(int32_t height, int *idx)
 {
    char symbol[HUSH_SMART_CHAIN_MAXLEN],dest[HUSH_SMART_CHAIN_MAXLEN]; int32_t i; struct hush_state *sp; struct notarized_checkpoint *np = 0;
    if ( (sp= hush_stateptr(symbol,dest)) != 0 )
@ -263,13 +263,13 @@ struct notarized_checkpoint *komodo_npptr_for_height(int32_t height, int *idx)
    return(0);
 }

-struct notarized_checkpoint *komodo_npptr(int32_t height)
+struct notarized_checkpoint *hush_npptr(int32_t height)
 {
    int idx;
-    return komodo_npptr_for_height(height, &idx);
+    return hush_npptr_for_height(height, &idx);
 }

-struct notarized_checkpoint *komodo_npptr_at(int idx)
+struct notarized_checkpoint *hush_npptr_at(int idx)
 {
    char symbol[HUSH_SMART_CHAIN_MAXLEN],dest[HUSH_SMART_CHAIN_MAXLEN]; struct hush_state *sp;
    if ( (sp= hush_stateptr(symbol,dest)) != 0 )
@ -278,7 +278,7 @@ struct notarized_checkpoint *komodo_npptr_at(int idx)
    return(0);
 }

-int32_t komodo_prevMoMheight()
+int32_t hush_prevMoMheight()
 {
    static uint256 zero;
    char symbol[HUSH_SMART_CHAIN_MAXLEN],dest[HUSH_SMART_CHAIN_MAXLEN]; int32_t i; struct hush_state *sp; struct notarized_checkpoint *np = 0;
@ -314,7 +314,7 @@ int32_t hush_notarized_height(int32_t *prevMoMheightp,uint256 *hashp,uint256 *tx
        {
            *hashp = sp->NOTARIZED_HASH;
            *txidp = sp->NOTARIZED_DESTTXID;
-            *prevMoMheightp = komodo_prevMoMheight();
+            *prevMoMheightp = hush_prevMoMheight();
        }
        return(sp->NOTARIZED_HEIGHT);
    } else return(0);
@ -342,7 +342,7 @@ int32_t hush_dpowconfs(int32_t txheight,int32_t numconfs)
 int32_t hush_MoMdata(int32_t *notarized_htp,uint256 *MoMp,uint256 *hushtxidp,int32_t height,uint256 *MoMoMp,int32_t *MoMoMoffsetp,int32_t *MoMoMdepthp,int32_t *kmdstartip,int32_t *kmdendip)
 {
    struct notarized_checkpoint *np = 0;
-    if ( (np= komodo_npptr(height)) != 0 )
+    if ( (np= hush_npptr(height)) != 0 )
    {
        *notarized_htp = np->notarized_height;
        *MoMp = np->MoM;
--- a/src/hush_pax.h
+++ b/src/hush_pax.h
@ -133,7 +133,7 @@ uint64_t peggy_smooth_coeffs[sizeof(Peggy_inds)/sizeof(*Peggy_inds)] =	// numpri
    1, 1, 1, 1, 1, 1, 0, 0, // isum 100000000000
 };

-uint64_t komodo_maxallowed(int32_t baseid)
+uint64_t hush_maxallowed(int32_t baseid)
 {
    uint64_t mult,val = COIN * (uint64_t)10000;
    if ( baseid < 0 || baseid >= 32 )
@ -144,7 +144,7 @@ uint64_t komodo_maxallowed(int32_t baseid)
    return(mult * val);
 }

-uint64_t komodo_paxvol(uint64_t volume,uint64_t price)
+uint64_t hush_paxvol(uint64_t volume,uint64_t price)
 {
    if ( volume < 10000000000 )
        return((volume * price) / 1000000000);
@ -170,7 +170,7 @@ void pax_rank(uint64_t *ranked,uint32_t *pvals)
    int32_t i; uint64_t vals[32],sum = 0;
    for (i=0; i<32; i++)
    {
-        vals[i] = komodo_paxvol(M1SUPPLY[i] / MINDENOMS[i],pvals[i]);
+        vals[i] = hush_paxvol(M1SUPPLY[i] / MINDENOMS[i],pvals[i]);
        sum += vals[i];
    }
    for (i=0; i<32; i++)
@ -228,11 +228,11 @@ double PAX_val(uint32_t pval,int32_t baseid)
    return(0.);
 }

-void komodo_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals)
+void hush_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals)
 {
 }

-uint64_t komodo_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed)
+uint64_t hush_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed)
 {
    int32_t i,j,k,ind,zeroes,wt,nonz; int64_t delta; uint64_t lastprice,tolerance,den,densum,sum=0;
    for (sum=i=zeroes=nonz=0; i<numvotes; i++)
@ -294,22 +294,22 @@ uint64_t komodo_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed)
    return(sum);
 }

-uint64_t komodo_paxpriceB(uint64_t seed,int32_t height,char *base,char *rel,uint64_t basevolume)
+uint64_t hush_paxpriceB(uint64_t seed,int32_t height,char *base,char *rel,uint64_t basevolume)
 {
    return 0;
 }

-uint64_t komodo_paxprice(uint64_t *seedp,int32_t height,char *base,char *rel,uint64_t basevolume)
+uint64_t hush_paxprice(uint64_t *seedp,int32_t height,char *base,char *rel,uint64_t basevolume)
 {
    return 0;
 }

-int32_t komodo_paxprices(int32_t *heights,uint64_t *prices,int32_t max,char *base,char *rel)
+int32_t hush_paxprices(int32_t *heights,uint64_t *prices,int32_t max,char *base,char *rel)
 {
    return 0;
 }

-void komodo_paxpricefeed(int32_t height,uint8_t *pricefeed,int32_t opretlen)
+void hush_paxpricefeed(int32_t height,uint8_t *pricefeed,int32_t opretlen)
 {
 }

--- a/src/hush_structs.h
+++ b/src/hush_structs.h
@ -77,7 +77,7 @@ struct pax_transaction
 {
    UT_hash_handle hh;
    uint256 txid;
-    uint64_t komodoshis,fiatoshis,validated;
+    uint64_t puposhis,fiatoshis,validated;
    int32_t marked,height,otherheight,approved,didstats,ready;
    uint16_t vout;
    char symbol[HUSH_SMART_CHAIN_MAXLEN],source[HUSH_SMART_CHAIN_MAXLEN],coinaddr[64]; uint8_t rmd160[20],type,buf[35];
@ -97,7 +97,7 @@ struct hush_ccdataMoM
    int32_t MoMdepth,notarized_height,height,txi;
 };

-struct hush_ccdata_entry { uint256 MoM; int32_t notarized_height,kmdheight,txi; char symbol[65]; };
+struct hush_ccdata_entry { uint256 MoM; int32_t notarized_height,hushheight,txi; char symbol[65]; };
 struct hush_ccdatapair { int32_t notarized_height,MoMoMoffset; };

 struct hush_ccdataMoMoM
--- a/src/hush_utils.h
+++ b/src/hush_utils.h
@ -980,7 +980,7 @@ int32_t dragon_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *
    return(len);
 }

-int32_t komodo_scriptitemlen(int32_t *opretlenp,uint8_t *script)
+int32_t hush_scriptitemlen(int32_t *opretlenp,uint8_t *script)
 {
    int32_t opretlen,len = 0;
    if ( (opretlen= script[len++]) >= 0x4c )
@ -2292,7 +2292,7 @@ void hush_args(char *argv0)
                        extralen += symbol.size();
                    }
                }
-                //komodo_pricesinit();
+                //hush_pricesinit();
                hush_cbopretupdate(1); // will set Mineropret
                fprintf(stderr,"This blockchain uses data produced from CoinDesk Bitcoin Price Index\n");
            }
@ -2325,7 +2325,7 @@ void hush_args(char *argv0)

        if ( (baseid = hush_baseid(SMART_CHAIN_SYMBOL)) >= 0 && baseid < 32 )
        {
-            //komodo_maxallowed(baseid);
+            //hush_maxallowed(baseid);
            if(fDebug) 
                printf("baseid.%d MAX_MONEY.%s %.8f\n",baseid,SMART_CHAIN_SYMBOL,(double)MAX_MONEY/SATOSHIDEN);
        }
@ -2381,7 +2381,7 @@ void hush_args(char *argv0)
        if ( ASSETCHAINS_RPCPORT == 0 )
            ASSETCHAINS_RPCPORT = ASSETCHAINS_P2PPORT + 1;
        //ASSETCHAINS_NOTARIES = GetArg("-ac_notaries","");
-        //komodo_assetchain_pubkeys((char *)ASSETCHAINS_NOTARIES.c_str());
+        //hush_assetchain_pubkeys((char *)ASSETCHAINS_NOTARIES.c_str());
        dragon_rwnum(1,magic,sizeof(ASSETCHAINS_MAGIC),(void *)&ASSETCHAINS_MAGIC);
        for (i=0; i<4; i++)
            sprintf(&magicstr[i<<1],"%02x",magic[i]);
--- a/src/main.cpp
+++ b/src/main.cpp
@ -82,7 +82,7 @@ int32_t hush_block2pubkey33(uint8_t *pubkey33,CBlock *block);
 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
 void hush_setactivation(int32_t height);
 void hush_changeblocktime();
-void komodo_pricesupdate(int32_t height,CBlock *pblock);
+void hush_pricesupdate(int32_t height,CBlock *pblock);
 BlockMap mapBlockIndex;
 CChain chainActive;
 CBlockIndex *pindexBestHeader = NULL;
@ -1423,7 +1423,7 @@ bool CheckTransaction(uint32_t tiptime,const CTransaction& tx, CValidationState
 {
    static uint256 array[64]; static int32_t numbanned,indallvouts; int32_t j,k,n;
    if ( *(int32_t *)&array[0] == 0 )
-        numbanned = komodo_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
+        numbanned = hush_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
    n = tx.vin.size();
    if ( SMART_CHAIN_SYMBOL[0] == 0 )
    {
@ -4041,7 +4041,7 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
    {
 		//fprintf(stderr,"%s: HUSH_NSPV_FULLNODE\n", __FUNCTION__);
        if ( ASSETCHAINS_CBOPRET != 0 )
-            komodo_pricesupdate(pindexNew->GetHeight(),pblock);
+            hush_pricesupdate(pindexNew->GetHeight(),pblock);
        if ( ASSETCHAINS_SAPLING <= 0 && pindexNew->nTime > HUSH_SAPING_ACTIVATION - 24*3600 )
            hush_activate_sapling(pindexNew);
        if ( ASSETCHAINS_CC != 0 && HUSH_SNAPSHOT_INTERVAL != 0 && (pindexNew->GetHeight() % HUSH_SNAPSHOT_INTERVAL) == 0 && pindexNew->GetHeight() >= HUSH_SNAPSHOT_INTERVAL )
@ -4472,7 +4472,7 @@ CBlockIndex* AddToBlockIndex(const CBlockHeader& block)

    if (it != mapBlockIndex.end())
    {
-        if ( it->second != 0 ) // vNodes.size() >= HUSH_LIMITED_NETWORKSIZE, change behavior to allow komodo_ensure to work
+        if ( it->second != 0 ) // vNodes.size() >= HUSH_LIMITED_NETWORKSIZE
        {
            // this is the strange case where somehow the hash is in the mapBlockIndex via as yet undetermined process, but the pindex for the hash is not there. Theoretically it is due to processing the block headers, but I have seen it get this case without having received it from the block headers or anywhere else... jl777
            //fprintf(stderr,"addtoblockindex already there %p\n",it->second);
@ -4480,7 +4480,7 @@ CBlockIndex* AddToBlockIndex(const CBlockHeader& block)
        }
        if ( miPrev != mapBlockIndex.end() && (*miPrev).second == 0 )
        {
-            //fprintf(stderr,"edge case of both block and prevblock in the strange state\n");
+            fprintf(stderr,"%s: edge case of both block and prevblock in the strange state\n", __func__);
            return(0); // return here to avoid the state of pindex->GetHeight() not set and pprev NULL
        }
    }
@ -7075,7 +7075,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
        }
        std::vector<uint8_t> payload;
        vRecv >> payload;
-        komodo_netevent(payload);
+        hush_netevent(payload);
        return(true);
    } else if (strCommand == "verack") {
        pfrom->SetRecvVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
@ -7275,7 +7275,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
        {
            std::vector<uint8_t> payload;
            vRecv >> payload;
-            komodo_nSPVreq(pfrom,payload);
+            hush_nSPVreq(pfrom,payload);
        }
        return(true);
    } else if (strCommand == "nSPV") {
@ -7283,7 +7283,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
        {
            std::vector<uint8_t> payload;
            vRecv >> payload;
-            komodo_nSPVresp(pfrom,payload);
+            hush_nSPVresp(pfrom,payload);
        }
        return(true);
    }
@ -8010,7 +8010,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
        }
        if ( HUSH_NSPV_SUPERLITE )
        {
-            komodo_nSPV(pto);
+            hush_nSPV(pto);
            return(true);
        }
        BOOST_FOREACH(const CBlockReject& reject, state.rejects)
--- a/src/miner.cpp
+++ b/src/miner.cpp
@ -147,8 +147,8 @@ int32_t hush_is_notarytx(const CTransaction& tx);
 uint64_t hush_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &NotarizationNotaries, uint32_t timestamp, int32_t height, uint8_t *script, int32_t len);
 int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
 int32_t hush_getnotarizedheight(uint32_t timestamp,int32_t height, uint8_t *script, int32_t len);
-CScript komodo_mineropret(int32_t nHeight);
-bool komodo_appendACscriptpub();
+CScript hush_mineropret(int32_t nHeight);
+bool hush_appendACscriptpub();

 CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32_t gpucount, bool isStake)
 {
@ -167,7 +167,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
        }
    } else pk = _pk;

-    uint64_t deposits,voutsum=0; int32_t isrealtime,kmdheight; uint32_t blocktime; const CChainParams& chainparams = Params();
+    uint64_t deposits,voutsum=0; int32_t isrealtime,hushheight; uint32_t blocktime; const CChainParams& chainparams = Params();
    bool fNotarizationBlock = false; std::vector<int8_t> NotarizationNotaries;
    
    //fprintf(stderr,"create new block\n");
@ -612,7 +612,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
            if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
            {
                static bool didinit = false;
-                if ( !didinit && nHeight > HUSH_EARLYTXID_HEIGHT && HUSH_EARLYTXID != zeroid && komodo_appendACscriptpub() )
+                if ( !didinit && nHeight > HUSH_EARLYTXID_HEIGHT && HUSH_EARLYTXID != zeroid && hush_appendACscriptpub() )
                {
                    fprintf(stderr, "appended ccopreturn to ASSETCHAINS_SCRIPTPUB.%s\n", ASSETCHAINS_SCRIPTPUB.c_str());
                    didinit = true;
@ -667,7 +667,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
            int32_t numv = (int32_t)txNew.vout.size();
            txNew.vout.resize(numv+1);
            txNew.vout[numv].nValue = 0;
-            txNew.vout[numv].scriptPubKey = komodo_mineropret(nHeight);
+            txNew.vout[numv].scriptPubKey = hush_mineropret(nHeight);
            //printf("autocreate commision/cbopret.%lld vout[%d]\n",(long long)ASSETCHAINS_CBOPRET,(int32_t)txNew.vout.size());
        }
        pblock->vtx[0] = txNew;
@ -879,7 +879,7 @@ CBlockTemplate* CreateNewBlockWithKey(CReserveKey& reservekey, int32_t nHeight,
    return CreateNewBlock(pubkey, scriptPubKey, gpucount, isStake);
 }

-void komodo_sendmessage(int32_t minpeers,int32_t maxpeers,const char *message,std::vector<uint8_t> payload)
+void hush_sendmessage(int32_t minpeers,int32_t maxpeers,const char *message,std::vector<uint8_t> payload)
 {
    int32_t numsent = 0;
    LOCK(cs_vNodes);
@ -956,7 +956,7 @@ static bool ProcessBlockFound(CBlock* pblock)

 int32_t hush_baseid(char *origbase);
 int32_t hush_eligiblenotary(uint8_t pubkeys[66][33],int32_t *mids,uint32_t *blocktimes,int32_t *nonzpkeysp,int32_t height);
-arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc);
+arith_uint256 hush_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc);
 int32_t FOUND_BLOCK,HUSH_MAYBEMINED;
 extern int32_t HUSH_LASTMINED,HUSH_INSYNC;
 int32_t roundrobin_delay;
@ -1237,7 +1237,7 @@ void static BitcoinMiner()
            } else Mining_start = 0;

            //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
-            //    HASHTarget_POW = komodo_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
+            //    HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
            gotinvalid = 0;
            while (true)
            {
@ -1462,7 +1462,7 @@ void static BitcoinMiner()
                        HASHTarget.SetCompact(pblock->nBits);
                        hashTarget = HASHTarget;
                        savebits = pblock->nBits;
-                        //hashTarget = HASHTarget_POW = komodo_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
+                        //hashTarget = HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
                    }
                    /*if ( NOTARY_PUBKEY33[0] == 0 )
                    {
@ -1472,7 +1472,7 @@ void static BitcoinMiner()
                        {
                            // Changing pblock->nTime can change work required on testnet:
                            HASHTarget.SetCompact(pblock->nBits);
-                            HASHTarget_POW = komodo_PoWtarget(&percPoS,HASHTarget,Mining_height,ASSETCHAINS_STAKED);
+                            HASHTarget_POW = hush_PoWtarget(&percPoS,HASHTarget,Mining_height,ASSETCHAINS_STAKED);
                        }
                    }*/
                }
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@ -1027,7 +1027,7 @@ UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk)
    return ret;
 }

-int32_t komodo_pending_withdraws(char *opretstr);
+int32_t hush_pending_withdraws(char *opretstr);
 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 extern char CURRENCIES[][8];

@ -1037,7 +1037,7 @@ UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk)
    if ( fHelp || params.size() != 0 )
        throw runtime_error("paxpending needs no args\n");
    LOCK(cs_main);
-    if ( (opretlen= komodo_pending_withdraws(opretbuf)) > 0 )
+    if ( (opretlen= hush_pending_withdraws(opretbuf)) > 0 )
        ret.push_back(Pair("withdraws", opretbuf));
    else ret.push_back(Pair("withdraws", (char *)""));
    for (baseid=0; baseid<32; baseid++)
@ -1076,7 +1076,7 @@ UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk)
    else height = atoi(params[2].get_str().c_str());
    //if ( params.size() == 3 || (basevolume= COIN * atof(params[3].get_str().c_str())) == 0 )
        basevolume = 100000;
-    relvolume = komodo_paxprice(&seed,height,(char *)base.c_str(),(char *)rel.c_str(),basevolume);
+    relvolume = hush_paxprice(&seed,height,(char *)base.c_str(),(char *)rel.c_str(),basevolume);
    ret.push_back(Pair("base", base));
    ret.push_back(Pair("rel", rel));
    ret.push_back(Pair("height", height));
--- a/src/rpc/crosschain.cpp
+++ b/src/rpc/crosschain.cpp
@ -57,8 +57,8 @@ bool EnsureWalletIsAvailable(bool avoidException);


 int32_t hush_MoM(int32_t *notarized_htp,uint256 *MoMp,uint256 *hushtxidp,int32_t nHeight,uint256 *MoMoMp,int32_t *MoMoMoffsetp,int32_t *MoMoMdepthp,int32_t *kmdstartip,int32_t *kmdendip);
-int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mdata,char *symbol,int32_t kmdheight,int32_t notarized_height);
-struct hush_ccdata_entry *komodo_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t kmdstarti,int32_t kmdendi);
+int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mdata,char *symbol,int32_t hushheight,int32_t notarized_height);
+struct hush_ccdata_entry *hush_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t kmdstarti,int32_t kmdendi);
 uint256 hush_calcMoM(int32_t height,int32_t MoMdepth);
 int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
 extern std::string ASSETCHAINS_SELFIMPORT;
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@ -52,7 +52,7 @@ using namespace std;
 extern int32_t ASSETCHAINS_FOUNDERS;
 uint64_t the_commission(const CBlock *pblock,int32_t height);
 int32_t hush_blockload(CBlock& block,CBlockIndex *pindex);
-arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc);
+arith_uint256 hush_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc);

 /**
 * Return average network hashes per second based on the last 'lookup' blocks,
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@ -614,7 +614,7 @@ int32_t hush_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t
 extern int32_t HUSH_PAX;
 int32_t hush_is_issuer();
 int32_t dragon_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
-int32_t hush_isrealtime(int32_t *kmdheightp);
+int32_t hush_isrealtime(int32_t *hushheightp);
 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 int32_t hush_kvsearch(uint256 *refpubkeyp,int32_t current_height,uint32_t *flagsp,int32_t *heightp,uint8_t value[DRAGON_MAXSCRIPTSIZE],uint8_t *key,int32_t keylen);
 int32_t hush_kvcmp(uint8_t *refvalue,uint16_t refvaluesize,uint8_t *value,uint16_t valuesize);
@ -768,7 +768,7 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)

 UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,komodoshis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
+    uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,puposhis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
    bool fSubtractFeeFromAmount = false;
    if ( HUSH_PAX == 0 )
    {
@ -793,28 +793,28 @@ UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
        fprintf(stderr,"available %llu vs fiatoshis %llu\n",(long long)available,(long long)fiatoshis);
        throw runtime_error("paxdeposit not enough available inventory");
    }
-    komodoshis = PAX_fiatdest(&seed,0,destaddr,pubkey37,(char *)params[0].get_str().c_str(),height,(char *)base.c_str(),fiatoshis);
+    puposhis = PAX_fiatdest(&seed,0,destaddr,pubkey37,(char *)params[0].get_str().c_str(),height,(char *)base.c_str(),fiatoshis);
    dest.append(destaddr);
    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
    if (!destaddress.IsValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
    for (i=0; i<33; i++)
        fprintf(stderr,"%02x",pubkey37[i]);
-    fprintf(stderr," ht.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) komodoshis.%llu seed.%llx\n",height,(char *)params[0].get_str().c_str(),(char *)base.c_str(),(long long)fiatoshis,destaddr,(long long)komodoshis,(long long)seed);
+    fprintf(stderr," ht.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",height,(char *)params[0].get_str().c_str(),(char *)base.c_str(),(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
    EnsureWalletIsUnlocked();
    CWalletTx wtx;
-    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = komodoshis / 1000;
+    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = puposhis / 1000;
    if ( fee < 10000 )
        fee = 10000;
    dragon_rwnum(1,&pubkey37[33],sizeof(height),&height);
    opretlen = hush_opreturnscript(opretbuf,'D',pubkey37,37);
-    SendMoney(address.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,komodoshis);
+    SendMoney(address.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,puposhis);
    return wtx.GetHash().GetHex();
 }

 UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    CWalletTx wtx; std::string dest; int32_t kmdheight; uint64_t seed,komodoshis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false;
+    CWalletTx wtx; std::string dest; int32_t hushheight; uint64_t seed,puposhis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false;
    if ( SMART_CHAIN_SYMBOL[0] == 0 )
        return(0);
    if (!EnsureWalletIsAvailable(fHelp))
@ -822,26 +822,26 @@ UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
    throw runtime_error("paxwithdraw deprecated");
    if (fHelp || params.size() != 2)
        throw runtime_error("paxwithdraw address fiatamount");
-    if ( hush_isrealtime(&kmdheight) == 0 )
+    if ( hush_isrealtime(&hushheight) == 0 )
        return(0);
    LOCK2(cs_main, pwalletMain->cs_wallet);
    CBitcoinAddress address(params[0].get_str());
    if (!address.IsValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
    int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN;
-    komodoshis = PAX_fiatdest(&seed,1,destaddr,pubkey37,(char *)params[0].get_str().c_str(),kmdheight,SMART_CHAIN_SYMBOL,fiatoshis);
+    puposhis = PAX_fiatdest(&seed,1,destaddr,pubkey37,(char *)params[0].get_str().c_str(),hushheight,SMART_CHAIN_SYMBOL,fiatoshis);
    dest.append(destaddr);
    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
    if (!destaddress.IsValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
    for (i=0; i<33; i++)
        printf("%02x",pubkey37[i]);
-    printf(" kmdheight.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) komodoshis.%llu seed.%llx\n",kmdheight,(char *)params[0].get_str().c_str(),SMART_CHAIN_SYMBOL,(long long)fiatoshis,destaddr,(long long)komodoshis,(long long)seed);
+    printf(" hushheight.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",hushheight,(char *)params[0].get_str().c_str(),SMART_CHAIN_SYMBOL,(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
    EnsureWalletIsUnlocked();
    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = fiatoshis / 1000;
    if ( fee < 10000 )
        fee = 10000;
-    dragon_rwnum(1,&pubkey37[33],sizeof(kmdheight),&kmdheight);
+    dragon_rwnum(1,&pubkey37[33],sizeof(hushheight),&hushheight);
    opretlen = hush_opreturnscript(opretbuf,'W',pubkey37,37);
    SendMoney(destaddress.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,fiatoshis);
    return wtx.GetHash().GetHex();