Once men turned their thinking over to machines in the hope that this would set them free.

But that only permitted other men with machines to enslave them. -- Reverend Mother Gaius Helen Mohiam
2020-12-09 07:23:08 -05:00
parent 710559576c
commit 6a30b40415
30 changed files with 346 additions and 458 deletions
--- a/src/cc/CCutils.cpp
+++ b/src/cc/CCutils.cpp
@@ -1,3 +1,6 @@
+// Copyright (c) 2016-2020 The Hush developers
+// Distributed under the GPLv3 software license, see the accompanying
+// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
 /******************************************************************************
 * Copyright © 2014-2019 The SuperNET Developers.                             *
 *                                                                            *
@@ -13,10 +16,7 @@
 *                                                                            *
 ******************************************************************************/

-/*
- CCutils has low level functions that are universally useful for all contracts.
- */
-
+// CCutils has low level functions that are universally useful for all contracts.
 #include "CCinclude.h"
 #include "hush_structs.h"
 #include "key_io.h"
@@ -28,7 +28,7 @@
 #endif // TESTMODE
 int32_t hush_dpowconfs(int32_t height,int32_t numconfs);
 struct hush_state *hush_stateptr(char *symbol,char *dest);
-extern uint32_t KOMODO_DPOWCONFS;
+extern uint32_t HUSH_DPOWCONFS;

 void endiancpy(uint8_t *dest,uint8_t *src,int32_t len)
 {
@@ -823,12 +823,12 @@ int64_t TotalPubkeyCCInputs(const CTransaction &tx, const CPubKey &pubkey)
 bool ProcessCC(struct CCcontract_info *cp,Eval* eval, std::vector<uint8_t> paramsNull,const CTransaction &ctx, unsigned int nIn)
 {
    CTransaction createTx; uint256 assetid,assetid2,hashBlock; uint8_t funcid; int32_t height,i,n,from_mempool = 0; int64_t amount; std::vector<uint8_t> origpubkey;
-    height = KOMODO_CONNECTING;
-    if ( KOMODO_CONNECTING < 0 ) // always comes back with > 0 for final confirmation
+    height = HUSH_CONNECTING;
+    if ( HUSH_CONNECTING < 0 ) // always comes back with > 0 for final confirmation
        return(true);
    if ( ASSETCHAINS_CC == 0 || (height & ~(1<<30)) < KOMODO_CCACTIVATE )
        return eval->Invalid("CC are disabled or not active yet");
-    if ( (KOMODO_CONNECTING & (1<<30)) != 0 )
+    if ( (HUSH_CONNECTING & (1<<30)) != 0 )
    {
        from_mempool = 1;
        height &= ((1<<30) - 1);
@@ -836,7 +836,7 @@ bool ProcessCC(struct CCcontract_info *cp,Eval* eval, std::vector<uint8_t> param
    if (cp->validate == NULL)
        return eval->Invalid("validation not supported for eval code");

-    //fprintf(stderr,"KOMODO_CONNECTING.%d mempool.%d vs CCactive.%d\n",height,from_mempool,KOMODO_CCACTIVATE);
+    //fprintf(stderr,"HUSH_CONNECTING.%d mempool.%d vs CCactive.%d\n",height,from_mempool,KOMODO_CCACTIVATE);
    // there is a chance CC tx is valid in mempool, but invalid when in block, so we cant filter duplicate requests. if any of the vins are spent, for example
    //txid = ctx.GetHash();
    //if ( txid == cp->prevtxid )
@@ -869,12 +869,12 @@ bool CClib_Dispatch(const CC *cond,Eval *eval,std::vector<uint8_t> paramsNull,co
        fprintf(stderr,"-ac_cclib=%s vs myname %s\n",ASSETCHAINS_CCLIB.c_str(),MYCCLIBNAME.c_str());
        return eval->Invalid("-ac_cclib name mismatches myname");
    }
-    height = KOMODO_CONNECTING;
-    if ( KOMODO_CONNECTING < 0 ) // always comes back with > 0 for final confirmation
+    height = HUSH_CONNECTING;
+    if ( HUSH_CONNECTING < 0 ) // always comes back with > 0 for final confirmation
        return(true);
    if ( ASSETCHAINS_CC == 0 || (height & ~(1<<30)) < KOMODO_CCACTIVATE )
        return eval->Invalid("CC are disabled or not active yet");
-    if ( (KOMODO_CONNECTING & (1<<30)) != 0 )
+    if ( (HUSH_CONNECTING & (1<<30)) != 0 )
    {
        from_mempool = 1;
        height &= ((1<<30) - 1);
--- a/src/cc/betprotocol.cpp
+++ b/src/cc/betprotocol.cpp
@@ -215,8 +215,8 @@ bool Eval::ImportPayout(const std::vector<uint8_t> params, const CTransaction &i

    // Check disputeTx solves momproof from vout[0]
    {
-        NotarisationData data(0);
-        if (!GetNotarisationData(proof.notarisationHash, data))
+        NotarizationData data(0);
+        if (!GetNotarizationData(proof.notarisationHash, data))
            return Invalid("coudnt-load-mom");

        if (data.MoM != proof.branch.Exec(disputeTx.GetHash()))
--- a/src/cc/cclib.cpp
+++ b/src/cc/cclib.cpp
@@ -1,4 +1,6 @@
-// Copyright © 2019-2020 The Hush Developers
+// Copyright (c) 2016-2020 The Hush developers
+// Distributed under the GPLv3 software license, see the accompanying
+// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
 /******************************************************************************
 * Copyright © 2014-2019 The SuperNET Developers.                             *
 *                                                                            *
@@ -13,10 +15,8 @@
 * Removal or modification of this copyright notice is prohibited.            *
 *                                                                            *
 ******************************************************************************/
-
 #include <assert.h>
 #include <cryptoconditions.h>
-
 #include "primitives/block.h"
 #include "primitives/transaction.h"
 #include "script/cc.h"
@@ -27,15 +27,12 @@
 #include "chain.h"
 #include "core_io.h"
 #include "crosschain.h"
-
 #define FAUCET2SIZE COIN
 #define EVAL_FAUCET2 EVAL_FIRSTUSER
-
 #ifdef BUILD_ROGUE
 #define EVAL_ROGUE 17
 std::string MYCCLIBNAME = (char *)"rogue";

-
 #elif BUILD_CUSTOMCC
 #include "customcc.h"

@@ -446,13 +443,12 @@ bool CClib_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const C
        else return eval->Invalid("invalid evalcode");
 #endif
    }
-    numvins = tx.vin.size();
-    numvouts = tx.vout.size();
+    numvins       = tx.vin.size();
+    numvouts      = tx.vout.size();
    preventCCvins = preventCCvouts = -1;
-    if ( numvouts < 1 )
+    if ( numvouts < 1 ) {
        return eval->Invalid("no vouts");
-    else
-    {
+    } else {
        for (i=0; i<numvins; i++)
        {
            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
@@ -462,13 +458,10 @@ bool CClib_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const C
            }
        }
        //fprintf(stderr,"check amounts\n");
-        if ( CClibExactAmounts(cp,eval,tx,1,10000) == false )
-        {
+        if ( CClibExactAmounts(cp,eval,tx,1,10000) == false ) {
            fprintf(stderr,"faucetget invalid amount\n");
            return false;
-        }
-        else
-        {
+        } else {
            preventCCvouts = 1;
            if ( IsCClibvout(cp,tx,0,cp->unspendableCCaddr) != 0 )
            {
--- a/src/cc/eval.cpp
+++ b/src/cc/eval.cpp
@@ -181,13 +181,13 @@ bool Eval::CheckNotaryInputs(const CTransaction &tx, uint32_t height, uint32_t t
 }

 // Get MoM from a notarisation tx hash (on HUSH)
-bool Eval::GetNotarisationData(const uint256 notaryHash, NotarisationData &data) const
+bool Eval::GetNotarizationData(const uint256 notaryHash, NotarizationData &data) const
 {
    CTransaction notarisationTx;
    CBlockIndex block;
    if (!GetTxConfirmed(notaryHash, notarisationTx, block)) return false;
    if (!CheckNotaryInputs(notarisationTx, block.GetHeight(), block.nTime)) return false;
-    if (!ParseNotarisationOpReturn(notarisationTx, data)) return false;
+    if (!ParseNotarizationOpReturn(notarisationTx, data)) return false;
    return true;
 }

@@ -205,9 +205,9 @@ std::string Eval::GetAssetchainsSymbol() const


 /*
- * Notarisation data, ie, OP_RETURN payload in notarisation transactions
+ * Notarization data, ie, OP_RETURN payload in notarisation transactions
 */
-bool ParseNotarisationOpReturn(const CTransaction &tx, NotarisationData &data)
+bool ParseNotarizationOpReturn(const CTransaction &tx, NotarizationData &data)
 {
    if (tx.vout.size() < 2) return false;
    std::vector<unsigned char> vdata;
--- a/src/cc/eval.h
+++ b/src/cc/eval.h
@@ -69,7 +69,7 @@ typedef uint8_t EvalCode;


 class AppVM;
-class NotarisationData;
+class NotarizationData;


 class Eval
@@ -110,7 +110,7 @@ public:
    virtual bool GetSpendsConfirmed(uint256 hash, std::vector<CTransaction> &spends) const;
    virtual bool GetBlock(uint256 hash, CBlockIndex& blockIdx) const;
    virtual int32_t GetNotaries(uint8_t pubkeys[64][33], int32_t height, uint32_t timestamp) const;
-    virtual bool GetNotarisationData(uint256 notarisationHash, NotarisationData &data) const;
+    virtual bool GetNotarizationData(uint256 notarisationHash, NotarizationData &data) const;
    virtual bool CheckNotaryInputs(const CTransaction &tx, uint32_t height, uint32_t timestamp) const;
    virtual uint32_t GetAssetchainsCC() const;
    virtual std::string GetAssetchainsSymbol() const;
@@ -160,10 +160,10 @@ extern char SMART_CHAIN_SYMBOL[65];
 /*
 * Data from notarisation OP_RETURN from chain being notarised
 */
-class NotarisationData
+class NotarizationData
 {
 public:
-    int IsBackNotarisation = 0;
+    int IsBackNotarization = 0;
    uint256 blockHash      = uint256();
    uint32_t height        = 0;
    uint256 txHash         = uint256();
@@ -174,7 +174,7 @@ public:
    uint256 MoMoM          = uint256();
    uint32_t MoMoMDepth    = 0;

-    NotarisationData(int IsBack=2) : IsBackNotarisation(IsBack) {
+    NotarizationData(int IsBack=2) : IsBackNotarization(IsBack) {
        symbol[0] = '\0';
    }

@@ -183,8 +183,8 @@ public:
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action) {

-        bool IsBack = IsBackNotarisation;
-        if (2 == IsBackNotarisation) IsBack = DetectBackNotarisation(s, ser_action);
+        bool IsBack = IsBackNotarization;
+        if (2 == IsBackNotarization) IsBack = DetectBackNotarization(s, ser_action);

        READWRITE(blockHash);
        READWRITE(height);
@@ -219,7 +219,7 @@ public:
    }

    template <typename Stream>
-    bool DetectBackNotarisation(Stream& s, CSerActionUnserialize act)
+    bool DetectBackNotarization(Stream& s, CSerActionUnserialize act)
    {
        if (SMART_CHAIN_SYMBOL[0]) return 1;
        if (s.size() >= 72) {
@@ -230,14 +230,14 @@ public:
    }
    
    template <typename Stream>
-    bool DetectBackNotarisation(Stream& s, CSerActionSerialize act)
+    bool DetectBackNotarization(Stream& s, CSerActionSerialize act)
    {
        return !txHash.IsNull();
    }
 };


-bool ParseNotarisationOpReturn(const CTransaction &tx, NotarisationData &data);
+bool ParseNotarizationOpReturn(const CTransaction &tx, NotarizationData &data);


 /*
--- a/src/cc/importpayout.cpp
+++ b/src/cc/importpayout.cpp
@@ -79,8 +79,8 @@ bool Eval::ImportPayout(const std::vector<uint8_t> params, const CTransaction &i

    // Check disputeTx solves momproof from vout[0]
    {
-        NotarisationData data;
-        if (!GetNotarisationData(proof.notarisationHash, data))
+        NotarizationData data;
+        if (!GetNotarizationData(proof.notarisationHash, data))
            return Invalid("coudnt-load-mom");

        if (data.MoM != proof.Exec(disputeTx.GetHash()))
--- a/src/crosschain.cpp
+++ b/src/crosschain.cpp
@@ -48,7 +48,7 @@ CBlockIndex *komodo_getblockindex(uint256 hash);

 /* On KMD */
 uint256 CalculateProofRoot(const char* symbol, uint32_t targetCCid, int kmdHeight,
-        std::vector<uint256> &moms, uint256 &destNotarisationTxid)
+        std::vector<uint256> &moms, uint256 &destNotarizationTxid)
 {
    /*
     * Notaries don't wait for confirmation on KMD before performing a backnotarisation,
@@ -67,33 +67,33 @@ uint256 CalculateProofRoot(const char* symbol, uint32_t targetCCid, int kmdHeigh
    if (kmdHeight < 0 || kmdHeight > chainActive.Height())
        return uint256();

-    int seenOwnNotarisations = 0, i = 0;
+    int seenOwnNotarizations = 0, i = 0;

    int authority = GetSymbolAuthority(symbol);
    std::set<uint256> tmp_moms;

    for (i=0; i<NOTARISATION_SCAN_LIMIT_BLOCKS; i++) {
        if (i > kmdHeight) break;
-        NotarisationsInBlock notarisations;
+        NotarizationsInBlock notarisations;
        uint256 blockHash = *chainActive[kmdHeight-i]->phashBlock;
-        if (!GetBlockNotarisations(blockHash, notarisations))
+        if (!GetBlockNotarizations(blockHash, notarisations))
            continue;

        // See if we have an own notarisation in this block
-        BOOST_FOREACH(Notarisation& nota, notarisations) {
+        BOOST_FOREACH(Notarization& nota, notarisations) {
            if (strcmp(nota.second.symbol, symbol) == 0)
            {
-                seenOwnNotarisations++;
-                if (seenOwnNotarisations == 1)
-                    destNotarisationTxid = nota.first;
-                else if (seenOwnNotarisations == 7)
+                seenOwnNotarizations++;
+                if (seenOwnNotarizations == 1)
+                    destNotarizationTxid = nota.first;
+                else if (seenOwnNotarizations == 7)
                    goto end;
                //break;
            }
        }

-        if (seenOwnNotarisations >= 1) {
-            BOOST_FOREACH(Notarisation& nota, notarisations) {
+        if (seenOwnNotarizations >= 1) {
+            BOOST_FOREACH(Notarization& nota, notarisations) {
                if (GetSymbolAuthority(nota.second.symbol) == authority)
                    if (nota.second.ccId == targetCCid) {
                      tmp_moms.insert(nota.second.MoM);
@@ -104,7 +104,7 @@ uint256 CalculateProofRoot(const char* symbol, uint32_t targetCCid, int kmdHeigh
    }

    // Not enough own notarisations found to return determinate MoMoM
-    destNotarisationTxid = uint256();
+    destNotarizationTxid = uint256();
    moms.clear();
    return uint256();

@@ -112,7 +112,7 @@ end:
    // add set to vector. Set makes sure there are no dupes included. 
    moms.clear();
    std::copy(tmp_moms.begin(), tmp_moms.end(), std::back_inserter(moms));
-    //fprintf(stderr, "SeenOwnNotarisations.%i moms.size.%li blocks scanned.%i\n",seenOwnNotarisations, moms.size(), i);
+    //fprintf(stderr, "SeenOwnNotarizations.%i moms.size.%li blocks scanned.%i\n",seenOwnNotarizations, moms.size(), i);
    return GetMerkleRoot(moms);
 }

@@ -123,15 +123,15 @@ end:
 * Will scan notarisations leveldb up to a limit
 */
 template <typename IsTarget>
-int ScanNotarisationsFromHeight(int nHeight, const IsTarget f, Notarisation &found)
+int ScanNotarizationsFromHeight(int nHeight, const IsTarget f, Notarization &found)
 {
    int limit = std::min(nHeight + NOTARISATION_SCAN_LIMIT_BLOCKS, chainActive.Height());
    int start = std::max(nHeight, 1);

    for (int h=start; h<limit; h++) {
-        NotarisationsInBlock notarisations;
+        NotarizationsInBlock notarisations;

-        if (!GetBlockNotarisations(*chainActive[h]->phashBlock, notarisations))
+        if (!GetBlockNotarizations(*chainActive[h]->phashBlock, notarisations))
            continue;

        BOOST_FOREACH(found, notarisations) {
@@ -160,11 +160,11 @@ TxProof GetCrossChainProof(const uint256 txid, const char* targetSymbol, uint32_
    // Get a kmd height for given notarisation Txid
    int kmdHeight;
    {
-        CTransaction sourceNotarisation;
+        CTransaction sourceNotarization;
        uint256 hashBlock;
        CBlockIndex blockIdx;
-        if (!eval->GetTxConfirmed(assetChainProof.first, sourceNotarisation, blockIdx))
-            throw std::runtime_error("Notarisation not found");
+        if (!eval->GetTxConfirmed(assetChainProof.first, sourceNotarization, blockIdx))
+            throw std::runtime_error("Notarization not found");
        kmdHeight = blockIdx.GetHeight();
    }

@@ -174,11 +174,11 @@ TxProof GetCrossChainProof(const uint256 txid, const char* targetSymbol, uint32_
    // a notarisation from B, and it might not include our notarisation from A
    // at all. So, the thing we need to do is scan forwards to find the notarisation for B,
    // that is inclusive of A.
-    Notarisation nota;
-    auto isTarget = [&](Notarisation &nota) {
+    Notarization nota;
+    auto isTarget = [&](Notarization &nota) {
        return strcmp(nota.second.symbol, targetSymbol) == 0;
    };
-    kmdHeight = ScanNotarisationsFromHeight(kmdHeight, isTarget, nota);
+    kmdHeight = ScanNotarizationsFromHeight(kmdHeight, isTarget, nota);
    if (!kmdHeight)
        throw std::runtime_error("Cannot find notarisation for target inclusive of source");
        
@@ -187,8 +187,8 @@ TxProof GetCrossChainProof(const uint256 txid, const char* targetSymbol, uint32_

    // Get MoMs for kmd height and symbol
    std::vector<uint256> moms;
-    uint256 targetChainNotarisationTxid;
-    uint256 MoMoM = CalculateProofRoot(targetSymbol, targetCCid, kmdHeight, moms, targetChainNotarisationTxid);
+    uint256 targetChainNotarizationTxid;
+    uint256 MoMoM = CalculateProofRoot(targetSymbol, targetCCid, kmdHeight, moms, targetChainNotarizationTxid);
    if (MoMoM.IsNull())
        throw std::runtime_error("No MoMs found");

@@ -222,7 +222,7 @@ cont:
    if (newBranch.Exec(txid) != MoMoM)
        throw std::runtime_error("Proof check failed");

-    return std::make_pair(targetChainNotarisationTxid,newBranch);
+    return std::make_pair(targetChainNotarizationTxid,newBranch);
 }


@@ -251,21 +251,21 @@ void CompleteImportTransaction(CTransaction &importTx, int32_t offset)
    importTx = MakeImportCoinTransaction(newProof, burnTx, payouts);
 }

-bool IsSameAssetChain(const Notarisation &nota) {
+bool IsSameAssetChain(const Notarization &nota) {
    return strcmp(nota.second.symbol, SMART_CHAIN_SYMBOL) == 0;
 };


 /* On assetchain */
-bool GetNextBacknotarisation(uint256 kmdNotarisationTxid, Notarisation &out)
+bool GetNextBacknotarisation(uint256 kmdNotarizationTxid, Notarization &out)
 {
    /*
     * Here we are given a txid, and a proof.
     * We go from the KMD notarisation txid to the backnotarisation,
     * then jump to the next backnotarisation, which contains the corresponding MoMoM.
     */
-    Notarisation bn;
-    if (!GetBackNotarisation(kmdNotarisationTxid, bn))
+    Notarization bn;
+    if (!GetBackNotarization(kmdNotarizationTxid, bn))
        return false;

    // Need to get block height of that backnotarisation
@@ -277,11 +277,11 @@ bool GetNextBacknotarisation(uint256 kmdNotarisationTxid, Notarisation &out)
        return false;
    }

-    return (bool) ScanNotarisationsFromHeight(block.GetHeight()+1, &IsSameAssetChain, out);
+    return (bool) ScanNotarizationsFromHeight(block.GetHeight()+1, &IsSameAssetChain, out);
 }


-bool CheckMoMoM(uint256 kmdNotarisationHash, uint256 momom)
+bool CheckMoMoM(uint256 kmdNotarizationHash, uint256 momom)
 {
    /*
     * Given a notarisation hash and an MoMoM. Backnotarisations may arrive out of order
@@ -290,8 +290,8 @@ bool CheckMoMoM(uint256 kmdNotarisationHash, uint256 momom)
     * This is a sledgehammer approach...
     */

-    Notarisation bn;
-    if (!GetBackNotarisation(kmdNotarisationHash, bn))
+    Notarization bn;
+    if (!GetBackNotarization(kmdNotarizationHash, bn))
        return false;

    // Need to get block height of that backnotarisation
@@ -303,12 +303,12 @@ bool CheckMoMoM(uint256 kmdNotarisationHash, uint256 momom)
        return false;
    }

-    Notarisation nota;
-    auto checkMoMoM = [&](Notarisation &nota) {
+    Notarization nota;
+    auto checkMoMoM = [&](Notarization &nota) {
        return nota.second.MoMoM == momom;
    };

-    return (bool) ScanNotarisationsFromHeight(block.GetHeight()-100, checkMoMoM, nota);
+    return (bool) ScanNotarizationsFromHeight(block.GetHeight()-100, checkMoMoM, nota);

 }

@@ -428,7 +428,7 @@ TxProof GetAssetchainProof(uint256 hash,CTransaction burnTx)
 {
    int nIndex;
    CBlockIndex* blockIndex;
-    Notarisation nota;
+    Notarization nota;
    std::vector<uint256> branch;
    {
        uint256 blockHash;
@@ -444,11 +444,11 @@ TxProof GetAssetchainProof(uint256 hash,CTransaction burnTx)
        // The assumption here is that the first notarisation for a height GTE than
        // the transaction block height will contain the corresponding MoM. If there
        // are sequence issues with the notarisations this may fail.
-        auto isTarget = [&](Notarisation &nota) {
+        auto isTarget = [&](Notarization &nota) {
            if (!IsSameAssetChain(nota)) return false;
            return nota.second.height >= blockIndex->GetHeight();
        };
-        if (!ScanNotarisationsFromHeight(blockIndex->GetHeight(), isTarget, nota))
+        if (!ScanNotarizationsFromHeight(blockIndex->GetHeight(), isTarget, nota))
            throw std::runtime_error("backnotarisation not yet confirmed");

        // index of block in MoM leaves
--- a/src/crosschain.h
+++ b/src/crosschain.h
@@ -36,13 +36,13 @@ TxProof GetAssetchainProof(uint256 hash,CTransaction burnTx);

 /* On HUSH */
 uint256 CalculateProofRoot(const char* symbol, uint32_t targetCCid, int kmdHeight,
-        std::vector<uint256> &moms, uint256 &destNotarisationTxid);
+        std::vector<uint256> &moms, uint256 &destNotarizationTxid);
 TxProof GetCrossChainProof(const uint256 txid, const char* targetSymbol, uint32_t targetCCid,
        const TxProof assetChainProof,int32_t offset);
 void CompleteImportTransaction(CTransaction &importTx,int32_t offset);

 /* On assetchain */
-bool CheckMoMoM(uint256 kmdNotarisationHash, uint256 momom);
+bool CheckMoMoM(uint256 kmdNotarizationHash, uint256 momom);
 bool CheckNotariesApproval(uint256 burntxid, const std::vector<uint256> & notaryTxids);

 #endif /* CROSSCHAIN_H */
--- a/src/hush.h
+++ b/src/hush.h
@@ -15,17 +15,15 @@
 * Removal or modification of this copyright notice is prohibited.            *
 *                                                                            *
 ******************************************************************************/
-
-#ifndef H_KOMODO_H
-#define H_KOMODO_H
+#ifndef H_HUSH_H
+#define H_HUSH_H
 #include "hush_defs.h"

 #ifdef _WIN32
 #define printf(...)
 #endif

-// Todo: verify: reorgs
-
+// Todo: verify: reorgs, lollerskates
 #define HUSH_SMART_CHAINS_WAITNOTARIZE
 #define KOMODO_PAXMAX (10000 * COIN)
 extern int32_t NOTARIZED_HEIGHT;
@@ -59,7 +57,7 @@ int32_t komodo_parsestatefile(struct hush_state *sp,FILE *fp,char *symbol,char *
 #include "komodo_events.h"
 #include "komodo_ccdata.h"

-void komodo_currentheight_set(int32_t height)
+void hush_currentheight_set(int32_t height)
 {
    char symbol[HUSH_SMART_CHAIN_MAXLEN],dest[HUSH_SMART_CHAIN_MAXLEN]; struct hush_state *sp;
    if ( (sp= hush_stateptr(symbol,dest)) != 0 )
@@ -525,11 +523,11 @@ int32_t komodo_validate_chain(uint256 srchash,int32_t notarized_height)
        else if ( notarized_height > 101 )
            rewindtarget = notarized_height - 101;
        else rewindtarget = 0;
-        if ( rewindtarget != 0 && rewindtarget > KOMODO_REWIND && rewindtarget > last_rewind )
+        if ( rewindtarget != 0 && rewindtarget > HUSH_REWIND && rewindtarget > last_rewind )
        {
            if ( last_rewind != 0 )
            {
-                //KOMODO_REWIND = rewindtarget;
+                //HUSH_REWIND = rewindtarget;
                fprintf(stderr,"%s FORK detected. notarized.%d %s not in this chain! last notarization %d -> rewindtarget.%d\n",SMART_CHAIN_SYMBOL,notarized_height,srchash.ToString().c_str(),sp->NOTARIZED_HEIGHT,rewindtarget);
            }
            last_rewind = rewindtarget;
@@ -848,7 +846,7 @@ int32_t hush_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
            hush_stateupdate(pindex->GetHeight(),0,0,0,zero,0,0,0,0,-pindex->GetHeight(),pindex->nTime,0,0,0,0,zero,0);
        }
    }
-    komodo_currentheight_set(chainActive.LastTip()->GetHeight());
+    hush_currentheight_set(chainActive.LastTip()->GetHeight());
    int transaction = 0;
    if ( pindex != 0 )
    {
--- a/src/hush_defs.h
+++ b/src/hush_defs.h
@@ -513,7 +513,7 @@ extern std::vector<std::string> ASSETCHAINS_PRICES,ASSETCHAINS_STOCKS;

 extern uint256 KOMODO_EARLYTXID;

-extern int32_t KOMODO_CONNECTING,KOMODO_CCACTIVATE,KOMODO_DEALERNODE;
+extern int32_t HUSH_CONNECTING,KOMODO_CCACTIVATE,KOMODO_DEALERNODE;
 extern uint32_t ASSETCHAINS_CC;
 extern std::string CCerror,ASSETCHAINS_CCLIB;
 extern uint8_t ASSETCHAINS_CCDISABLES[256];
--- a/src/hush_globals.h
+++ b/src/hush_globals.h
@@ -17,7 +17,6 @@
 ******************************************************************************/

 #include "hush_defs.h"
-
 void komodo_prefetch(FILE *fp);
 uint32_t komodo_heightstamp(int32_t height);
 void hush_stateupdate(int32_t height,uint8_t notarypubs[][33],uint8_t numnotaries,uint8_t notaryid,uint256 txhash,uint64_t voutmask,uint8_t numvouts,uint32_t *pvals,uint8_t numpvals,int32_t kheight,uint32_t ktime,uint64_t opretvalue,uint8_t *opretbuf,uint16_t opretlen,uint16_t vout,uint256 MoM,int32_t MoMdepth);
@@ -33,7 +32,6 @@ int32_t hush_longestchain();
 uint64_t komodo_maxallowed(int32_t baseid);
 int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
 int32_t komodo_checkvout(int32_t vout,int32_t k,int32_t indallvouts);
-
 pthread_mutex_t komodo_mutex,staked_mutex;

 #define KOMODO_ELECTION_GAP 2000    //((SMART_CHAIN_SYMBOL[0] == 0) ? 2000 : 100)
@@ -42,7 +40,6 @@ pthread_mutex_t komodo_mutex,staked_mutex;
 struct pax_transaction *PAX;
 int32_t NUM_PRICES; uint32_t *PVALS;
 struct knotaries_entry *Pubkeys;
-
 struct hush_state KOMODO_STATES[34];

 #define _COINBASE_MATURITY 100
@@ -50,7 +47,7 @@ int COINBASE_MATURITY = _COINBASE_MATURITY;//100;
 unsigned int WITNESS_CACHE_SIZE = _COINBASE_MATURITY+10;
 uint256 KOMODO_EARLYTXID;

-int32_t HUSH_MININGTHREADS = -1,IS_HUSH_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,HUSH_PASSPORT_INITDONE,KOMODO_PAX,HUSH_EXCHANGEWALLET,KOMODO_REWIND,STAKED_ERA,KOMODO_CONNECTING = -1,KOMODO_DEALERNODE,KOMODO_EXTRASATOSHI,ASSETCHAINS_FOUNDERS,ASSETCHAINS_CBMATURITY,KOMODO_NSPV;
+int32_t HUSH_MININGTHREADS = -1,IS_HUSH_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,HUSH_PASSPORT_INITDONE,KOMODO_PAX,HUSH_EXCHANGEWALLET,HUSH_REWIND,HUSH_CONNECTING = -1,KOMODO_DEALERNODE,HUSH_EXTRASATOSHI,ASSETCHAINS_FOUNDERS,ASSETCHAINS_CBMATURITY,KOMODO_NSPV;
 int32_t HUSH_INSYNC,KOMODO_LASTMINED,prevKOMODO_LASTMINED,KOMODO_CCACTIVATE,JUMBLR_PAUSE = 1;
 std::string NOTARY_PUBKEY,ASSETCHAINS_NOTARIES,ASSETCHAINS_OVERRIDE_PUBKEY,DONATION_PUBKEY,ASSETCHAINS_SCRIPTPUB,NOTARY_ADDRESS,ASSETCHAINS_SELFIMPORT,ASSETCHAINS_CCLIB;
 uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEYHASH[20],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE,ASSETCHAINS_TXPOW,ASSETCHAINS_MARMARA;
@@ -62,7 +59,7 @@ char NOTARY_ADDRESSES[NUM_HUSH_SEASONS][64][64];

 char SMART_CHAIN_SYMBOL[HUSH_SMART_CHAIN_MAXLEN],ASSETCHAINS_USERPASS[4096];
 uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_BEAMPORT,ASSETCHAINS_CODAPORT;
-uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC,KOMODO_STOPAT,KOMODO_DPOWCONFS = 1,STAKING_MIN_DIFF;
+uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC,KOMODO_STOPAT,HUSH_DPOWCONFS = 1,STAKING_MIN_DIFF;
 uint32_t ASSETCHAINS_MAGIC = 2387029918;
 int64_t ASSETCHAINS_GENESISTXVAL = 5000000000;

@@ -101,7 +98,7 @@ uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY = 10,ASSETCHAINS_FOUNDERS_REW
 uint32_t HUSH_INITDONE;
 char KMDUSERPASS[8192+512+1],BTCUSERPASS[8192]; uint16_t KMD_PORT = 7771,BITCOIND_RPCPORT = 7771;
 uint64_t PENDING_KOMODO_TX;
-extern int32_t KOMODO_LOADINGBLOCKS;
+extern int32_t HUSH_LOADINGBLOCKS;
 unsigned int MAX_BLOCK_SIGOPS = 20000;
 int32_t HUSH_TESTNODE, KOMODO_SNAPSHOT_INTERVAL;
 CScript KOMODO_EARLYTXID_SCRIPTPUB;
@@ -131,7 +128,7 @@ int32_t komodo_baseid(char *origbase)
 #ifndef SATOSHIDEN
 #define SATOSHIDEN ((uint64_t)100000000L)
 #endif
-uint64_t komodo_current_supply(uint32_t nHeight)
+uint64_t hush_current_supply(uint32_t nHeight)
 {
    uint64_t cur_money;
    int32_t baseid;
@@ -255,9 +252,7 @@ uint64_t komodo_current_supply(uint32_t nHeight)

                        // add more for the base rectangle if lowest subsidy is not 0
                        cur_money += lowestSubsidy * (curEnd - lastEnd);
-                    }
-                    else
-                    {
+                    } else {
                        for ( int k = lastEnd; k < curEnd; k += period )
                        {
                            cur_money += period * reward;
@@ -272,8 +267,7 @@ uint64_t komodo_current_supply(uint32_t nHeight)
    }    
    if ( KOMODO_BIT63SET(cur_money) != 0 )
        return(KOMODO_MAXNVALUE);
-    if ( ASSETCHAINS_COMMISSION != 0 )
-    {
+    if ( ASSETCHAINS_COMMISSION != 0 ) {
        uint64_t newval = (cur_money + (cur_money/COIN * ASSETCHAINS_COMMISSION));
        if ( KOMODO_BIT63SET(newval) != 0 )
            return(KOMODO_MAXNVALUE);
--- a/src/hush_notary.h
+++ b/src/hush_notary.h
@@ -317,7 +317,7 @@ int32_t hush_dpowconfs(int32_t txheight,int32_t numconfs)
 {
    static int32_t hadnotarization;
    char symbol[HUSH_SMART_CHAIN_MAXLEN],dest[HUSH_SMART_CHAIN_MAXLEN]; struct hush_state *sp;
-    if ( KOMODO_DPOWCONFS != 0 && txheight > 0 && numconfs > 0 && (sp= hush_stateptr(symbol,dest)) != 0 )
+    if ( HUSH_DPOWCONFS != 0 && txheight > 0 && numconfs > 0 && (sp= hush_stateptr(symbol,dest)) != 0 )
    {
        if ( sp->NOTARIZED_HEIGHT > 0 )
        {
--- a/src/hush_utils.h
+++ b/src/hush_utils.h
@@ -1541,7 +1541,7 @@ char *argv0names[] = {
 // Large total supplies lead to numerical errors, beware!
 uint64_t hush_max_money()
 {
-    return komodo_current_supply(10000000);
+    return hush_current_supply(10000000);
 }


@@ -1859,9 +1859,9 @@ void hush_args(char *argv0)
        i++;
    }
    
-    if ( (KOMODO_REWIND= GetArg("-rewind",0)) != 0 )
+    if ( (HUSH_REWIND= GetArg("-rewind",0)) != 0 )
    {
-        printf("KOMODO_REWIND %d\n",KOMODO_REWIND);
+        printf("HUSH_REWIND %d\n",HUSH_REWIND);
    }
    KOMODO_EARLYTXID = Parseuint256(GetArg("-earlytxid","0").c_str());    
    ASSETCHAINS_EARLYTXIDCONTRACT = GetArg("-ac_earlytxidcontract",0);
@@ -2433,7 +2433,7 @@ fprintf(stderr,"extralen.%d before disable bits\n",extralen);
                break;
        }
    }
-    int32_t dpowconfs = KOMODO_DPOWCONFS;
+    int32_t dpowconfs = HUSH_DPOWCONFS;
    if ( SMART_CHAIN_SYMBOL[0] != 0 )
    {
        BITCOIND_RPCPORT = GetArg("-rpcport", ASSETCHAINS_RPCPORT);
@@ -2502,9 +2502,9 @@ fprintf(stderr,"extralen.%d before disable bits\n",extralen);
            CCENABLE(EVAL_ORACLES);
        }
    } else BITCOIND_RPCPORT = GetArg("-rpcport", BaseParams().RPCPort());
-    KOMODO_DPOWCONFS = GetArg("-dpowconfs",dpowconfs);
+    HUSH_DPOWCONFS = GetArg("-dpowconfs",dpowconfs);
    if ( SMART_CHAIN_SYMBOL[0] == 0 || strcmp(SMART_CHAIN_SYMBOL,"SUPERNET") == 0 || strcmp(SMART_CHAIN_SYMBOL,"DEX") == 0 || strcmp(SMART_CHAIN_SYMBOL,"COQUI") == 0 || strcmp(SMART_CHAIN_SYMBOL,"PIRATE") == 0 || strcmp(SMART_CHAIN_SYMBOL,"KMDICE") == 0 )
-        KOMODO_EXTRASATOSHI = 1;
+        HUSH_EXTRASATOSHI = 1;
 }

 void komodo_nameset(char *symbol,char *dest,char *source)
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -90,7 +90,7 @@ using namespace std;
 #include "hush_defs.h"
 extern void ThreadSendAlert();
 extern bool komodo_dailysnapshot(int32_t height);
-extern int32_t KOMODO_LOADINGBLOCKS;
+extern int32_t HUSH_LOADINGBLOCKS;
 extern char SMART_CHAIN_SYMBOL[];
 extern int32_t KOMODO_SNAPSHOT_INTERVAL;
 extern void komodo_init(int32_t height);
@@ -693,7 +693,7 @@ void ThreadImport(std::vector<boost::filesystem::path> vImportFiles)
        LogPrintf("Reindexing finished\n");
        // To avoid ending up in a situation without genesis block, re-try initializing (no-op if reindexing worked):
        InitBlockIndex();
-        KOMODO_LOADINGBLOCKS = 0;
+        HUSH_LOADINGBLOCKS = 0;
    }

    // hardcoded $DATADIR/bootstrap.dat
@@ -943,7 +943,7 @@ bool AppInitServers(boost::thread_group& threadGroup)
 /** Initialize Hush.
 *  @pre Parameters should be parsed and config file should be read.
 */
-extern int32_t KOMODO_REWIND;
+extern int32_t HUSH_REWIND;

 bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
 {
@@ -1792,7 +1792,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
                    strLoadError = _("Error initializing block database");
                    break;
                }
-                KOMODO_LOADINGBLOCKS = 0;
+                HUSH_LOADINGBLOCKS = 0;
                // Check for changed -txindex state
                if (fTxIndex != GetBoolArg("-txindex", true)) {
                    strLoadError = _("You need to rebuild the database using -reindex to change -txindex");
@@ -1834,7 +1834,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
                    LogPrintf("Prune: pruned datadir may not have more than %d blocks; -checkblocks=%d may fail\n",
                        MIN_BLOCKS_TO_KEEP, GetArg("-checkblocks", 288));
                }
-                if ( KOMODO_REWIND == 0 )
+                if ( HUSH_REWIND == 0 )
                {
                    LogPrintf("Verifying block DB...");
                    if (!CVerifyDB().VerifyDB(pcoinsdbview, GetArg("-checklevel", 3), GetArg("-checkblocks", 288))) {
@@ -1870,7 +1870,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
            }
        }
    }
-    KOMODO_LOADINGBLOCKS = 0;
+    HUSH_LOADINGBLOCKS = 0;

    // As LoadBlockIndex can take several minutes, it's possible the user
    // requested to kill the GUI during the last operation. If so, exit.
@@ -2145,7 +2145,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
        uiInterface.NotifyBlockTip.connect(BlockNotifyCallback);
     if (mapArgs.count("-txexpirynotify"))
        uiInterface.NotifyTxExpiration.connect(TxExpiryNotifyCallback);
-    if ( KOMODO_REWIND >= 0 )
+    if ( HUSH_REWIND >= 0 )
    {
        uiInterface.InitMessage(_("Activating best chain..."));
        // scan for better chains in the block chain database, that are not yet connected in the active best chain
@@ -2153,7 +2153,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
        if ( !ActivateBestChain(true,state))
            strErrors << "Failed to connect best block";
    } else {
-        fprintf(stderr,"KOMODO_REWIND < 0\n");
+        fprintf(stderr,"HUSH_REWIND < 0\n");
    }
    std::vector<boost::filesystem::path> vImportFiles;
    if (mapArgs.count("-loadblock"))
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -754,7 +754,7 @@ int32_t komodo_is_notarytx(const CTransaction& tx)
    return(0);
 }

-int32_t komodo_block2height(CBlock *block)
+int32_t hush_block2height(CBlock *block)
 {
    static uint32_t match,mismatch;
    int32_t i,n,height2=-1,height = 0; uint8_t *ptr; CBlockIndex *pindex = NULL;
@@ -796,7 +796,7 @@ int32_t komodo_block2height(CBlock *block)
 int32_t komodo_block2pubkey33(uint8_t *pubkey33,CBlock *block)
 {
    int32_t n;
-    if ( KOMODO_LOADINGBLOCKS == 0 )
+    if ( HUSH_LOADINGBLOCKS == 0 )
        memset(pubkey33,0xff,33);
    else memset(pubkey33,0,33);
    if ( block->vtx[0].vout.size() > 0 )
@@ -872,7 +872,7 @@ uint32_t komodo_heightstamp(int32_t height)
    if ( pindex->didinit == 0 )
    {
        pindex->notaryid = -1;
-        if ( KOMODO_LOADINGBLOCKS == 0 )
+        if ( HUSH_LOADINGBLOCKS == 0 )
            memset(pindex->pubkey33,0xff,33);
        else memset(pindex->pubkey33,0,33);
        if ( komodo_blockload(block,pindex) == 0 )
@@ -882,7 +882,7 @@ uint32_t komodo_heightstamp(int32_t height)
            //    fprintf(stderr,"%02x",pindex->pubkey33[i]);
            //fprintf(stderr," set pubkey at height %d/%d\n",pindex->GetHeight(),height);
            //if ( pindex->pubkey33[0] == 2 || pindex->pubkey33[0] == 3 )
-            //    pindex->didinit = (KOMODO_LOADINGBLOCKS == 0);
+            //    pindex->didinit = (HUSH_LOADINGBLOCKS == 0);
        } // else fprintf(stderr,"error loading block at %d/%d",pindex->GetHeight(),height);
    }
    if ( pindex->didinit != 0 && pindex->GetHeight() >= 0 && (num= hush_notaries(pubkeys,(int32_t)pindex->GetHeight(),(uint32_t)pindex->nTime)) > 0 )
@@ -1203,7 +1203,7 @@ int32_t komodo_isrealtime(int32_t *kmdheightp)
 int32_t komodo_validate_interest(const CTransaction &tx,int32_t txheight,uint32_t cmptime,int32_t dispflag)
 {
    dispflag = 1;
-    if ( KOMODO_REWIND == 0 && SMART_CHAIN_SYMBOL[0] == 0 && (int64_t)tx.nLockTime >= LOCKTIME_THRESHOLD ) //1473793441 )
+    if ( HUSH_REWIND == 0 && SMART_CHAIN_SYMBOL[0] == 0 && (int64_t)tx.nLockTime >= LOCKTIME_THRESHOLD ) //1473793441 )
    {
        if ( txheight > 246748 )
        {
@@ -1838,7 +1838,7 @@ int32_t komodo_getnotarizedheight(uint32_t timestamp,int32_t height, uint8_t *sc
    return(notarizedheight);
 }

-uint64_t komodo_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &NotarisationNotaries, uint32_t timestamp, int32_t height, uint8_t *script, int32_t len)
+uint64_t komodo_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &NotarizationNotaries, uint32_t timestamp, int32_t height, uint8_t *script, int32_t len)
 {
    // fetch notary pubkey array.
    uint64_t total = 0, AmountToPay = 0;
@@ -1855,16 +1855,16 @@ uint64_t komodo_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &Notar
        return(0);

    // resize coinbase vouts to number of notary nodes +1 for coinbase itself.
-    txNew.vout.resize(NotarisationNotaries.size()+1);
+    txNew.vout.resize(NotarizationNotaries.size()+1);
    
    // Calcualte the amount to pay according to the current era.
-    AmountToPay = komodo_notarypayamount(height,NotarisationNotaries.size());
+    AmountToPay = komodo_notarypayamount(height,NotarizationNotaries.size());
    if ( AmountToPay == 0 )
        return(0);
    
    // loop over notarisation vins and add transaction to coinbase.
    // Commented prints here can be used to verify manually the pubkeys match.
-    for (int8_t n = 0; n < NotarisationNotaries.size(); n++) 
+    for (int8_t n = 0; n < NotarizationNotaries.size(); n++) 
    {
        uint8_t *ptr;
        txNew.vout[n+1].scriptPubKey.resize(35);
@@ -1872,18 +1872,18 @@ uint64_t komodo_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &Notar
        ptr[0] = 33;
        for (int8_t i=0; i<33; i++)
        {
-            ptr[i+1] = notarypubkeys[NotarisationNotaries[n]][i];
+            ptr[i+1] = notarypubkeys[NotarizationNotaries[n]][i];
            //fprintf(stderr,"%02x",ptr[i+1]);
        }
        ptr[34] = OP_CHECKSIG;
-        //fprintf(stderr," set notary %i PUBKEY33 into vout[%i] amount.%lu\n",NotarisationNotaries[n],n+1,AmountToPay);
+        //fprintf(stderr," set notary %i PUBKEY33 into vout[%i] amount.%lu\n",NotarizationNotaries[n],n+1,AmountToPay);
        txNew.vout[n+1].nValue = AmountToPay;
        total += txNew.vout[n+1].nValue;
    }
    return(total);
 }

-bool GetNotarisationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarisationNotaries)
+bool GetNotarizationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarizationNotaries)
 {
    uint8_t *script; int32_t scriptlen;
    if ( notarypubkeys[0][0] == 0 )
@@ -1898,7 +1898,7 @@ bool GetNotarisationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const
                script = (uint8_t *)&tx1.vout[txin.prevout.n].scriptPubKey[0];
                scriptlen = (int32_t)tx1.vout[txin.prevout.n].scriptPubKey.size();
                if ( scriptlen == 35 && script[0] == 33 && script[34] == OP_CHECKSIG && memcmp(script+1,notarypubkeys[i],33) == 0 )
-                    NotarisationNotaries.push_back(i);
+                    NotarizationNotaries.push_back(i);
            }
        } else return false;
    }
@@ -1907,16 +1907,16 @@ bool GetNotarisationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const

 uint64_t komodo_checknotarypay(CBlock *pblock,int32_t height)
 {
-    std::vector<int8_t> NotarisationNotaries; uint8_t *script; int32_t scriptlen;
+    std::vector<int8_t> NotarizationNotaries; uint8_t *script; int32_t scriptlen;
    uint64_t timestamp = pblock->nTime;
    int8_t numSN = 0; uint8_t notarypubkeys[64][33] = {0};
    numSN = hush_notaries(notarypubkeys, height, timestamp);
-    if ( !GetNotarisationNotaries(notarypubkeys, numSN, pblock->vtx[1].vin, NotarisationNotaries) )
+    if ( !GetNotarizationNotaries(notarypubkeys, numSN, pblock->vtx[1].vin, NotarizationNotaries) )
        return(0);
    
    // check a notary didnt sign twice (this would be an invalid notarisation later on and cause problems)
-    std::set<int> checkdupes( NotarisationNotaries.begin(), NotarisationNotaries.end() );
-    if ( checkdupes.size() != NotarisationNotaries.size() ) {
+    std::set<int> checkdupes( NotarizationNotaries.begin(), NotarizationNotaries.end() );
+    if ( checkdupes.size() != NotarizationNotaries.size() ) {
        fprintf(stderr, "Possible notarisation is signed multiple times by same notary. It is invalid.\n");
        return(0);
    }
@@ -1933,7 +1933,7 @@ uint64_t komodo_checknotarypay(CBlock *pblock,int32_t height)
        {
            // Create the coinbase tx again, using the extracted data, this is the same function the miner uses, with the same data. 
            // This allows us to know exactly that the coinbase is correct.
-            totalsats = komodo_notarypay(txNew, NotarisationNotaries, pblock->nTime, height, script, scriptlen);
+            totalsats = komodo_notarypay(txNew, NotarizationNotaries, pblock->nTime, height, script, scriptlen);
        } 
        else 
        {
@@ -1968,20 +1968,20 @@ uint64_t komodo_checknotarypay(CBlock *pblock,int32_t height)
        // Check the pubkeys match the pubkeys in the notarisation.
        script = (uint8_t *)&txout.scriptPubKey[0];
        scriptlen = (int32_t)txout.scriptPubKey.size();
-        if ( scriptlen == 35 && script[0] == 33 && script[34] == OP_CHECKSIG && memcmp(script+1,notarypubkeys[NotarisationNotaries[n-1]],33) == 0 )
+        if ( scriptlen == 35 && script[0] == 33 && script[34] == OP_CHECKSIG && memcmp(script+1,notarypubkeys[NotarizationNotaries[n-1]],33) == 0 )
        {
            // check the value is correct
            if ( pblock->vtx[0].vout[n].nValue == AmountToPay )
            {
                matches++;
                total += txout.nValue;
-                //fprintf(stderr, "MATCHED AmountPaid.%lu notaryid.%i\n",AmountToPay,NotarisationNotaries[n-1]);
+                //fprintf(stderr, "MATCHED AmountPaid.%lu notaryid.%i\n",AmountToPay,NotarizationNotaries[n-1]);
            }
-            else fprintf(stderr, "NOT MATCHED AmountPaid.%llu AmountToPay.%llu notaryid.%i\n", (long long)pblock->vtx[0].vout[n].nValue, (long long)AmountToPay, NotarisationNotaries[n-1]);
+            else fprintf(stderr, "NOT MATCHED AmountPaid.%llu AmountToPay.%llu notaryid.%i\n", (long long)pblock->vtx[0].vout[n].nValue, (long long)AmountToPay, NotarizationNotaries[n-1]);
        }
        n++;
    }
-    if ( matches != 0 && matches == NotarisationNotaries.size() && totalsats == total )
+    if ( matches != 0 && matches == NotarizationNotaries.size() && totalsats == total )
    {
        //fprintf(stderr, "Validated coinbase matches notarisation in tx position 1.\n" );
        return(totalsats);
--- a/src/komodo_events.h
+++ b/src/komodo_events.h
@@ -1,3 +1,6 @@
+// Copyright (c) 2019-2020 The Hush developers
+// Distributed under the GPLv3 software license, see the accompanying
+// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
 /******************************************************************************
 * Copyright © 2014-2019 The SuperNET Developers.                             *
 *                                                                            *
@@ -13,8 +16,8 @@
 *                                                                            *
 ******************************************************************************/

-#ifndef H_KOMODOEVENTS_H
-#define H_KOMODOEVENTS_H
+#ifndef H_HUSHEVENTS_H
+#define H_HUSHEVENTS_H
 #include "hush_defs.h"

 struct komodo_event *komodo_eventadd(struct hush_state *sp,int32_t height,char *symbol,uint8_t type,uint8_t *data,uint16_t datalen)
@@ -169,16 +172,13 @@ void komodo_setkmdheight(struct hush_state *sp,int32_t kmdheight,uint32_t timest
 void komodo_eventadd_kmdheight(struct hush_state *sp,char *symbol,int32_t height,int32_t kmdheight,uint32_t timestamp)
 {
    uint32_t buf[2];
-    if ( kmdheight > 0 )
-    {
+    if ( kmdheight > 0 ) {
        buf[0] = (uint32_t)kmdheight;
        buf[1] = timestamp;
        komodo_eventadd(sp,height,symbol,KOMODO_EVENT_KMDHEIGHT,(uint8_t *)buf,sizeof(buf));
        if ( sp != 0 )
            komodo_setkmdheight(sp,kmdheight,timestamp);
-    }
-    else
-    {
+    } else {
        //fprintf(stderr,"REWIND kmdheight.%d\n",kmdheight);
        kmdheight = -kmdheight;
        komodo_eventadd(sp,height,symbol,KOMODO_EVENT_REWIND,(uint8_t *)&height,sizeof(height));
@@ -188,31 +188,4 @@ void komodo_eventadd_kmdheight(struct hush_state *sp,char *symbol,int32_t height
 }


-/*void komodo_eventadd_deposit(int32_t actionflag,char *symbol,int32_t height,uint64_t komodoshis,char *fiat,uint64_t fiatoshis,uint8_t rmd160[20],bits256 kmdtxid,uint16_t kmdvout,uint64_t price)
- {
- uint8_t opret[512]; uint16_t opretlen;
- komodo_eventadd_opreturn(symbol,height,KOMODO_OPRETURN_DEPOSIT,kmdtxid,komodoshis,kmdvout,opret,opretlen);
- }
- 
- void komodo_eventadd_issued(int32_t actionflag,char *symbol,int32_t height,int32_t fiatheight,bits256 fiattxid,uint16_t fiatvout,bits256 kmdtxid,uint16_t kmdvout,uint64_t fiatoshis)
- {
- uint8_t opret[512]; uint16_t opretlen;
- komodo_eventadd_opreturn(symbol,height,KOMODO_OPRETURN_ISSUED,fiattxid,fiatoshis,fiatvout,opret,opretlen);
- }
- 
- void komodo_eventadd_withdraw(int32_t actionflag,char *symbol,int32_t height,uint64_t komodoshis,char *fiat,uint64_t fiatoshis,uint8_t rmd160[20],bits256 fiattxid,int32_t fiatvout,uint64_t price)
- {
- uint8_t opret[512]; uint16_t opretlen;
- komodo_eventadd_opreturn(symbol,height,KOMODO_OPRETURN_WITHDRAW,fiattxid,fiatoshis,fiatvout,opret,opretlen);
- }
- 
- void komodo_eventadd_redeemed(int32_t actionflag,char *symbol,int32_t height,bits256 kmdtxid,uint16_t kmdvout,int32_t fiatheight,bits256 fiattxid,uint16_t fiatvout,uint64_t komodoshis)
- {
- uint8_t opret[512]; uint16_t opretlen;
- komodo_eventadd_opreturn(symbol,height,KOMODO_OPRETURN_REDEEMED,kmdtxid,komodoshis,kmdvout,opret,opretlen);
- }*/
-
-// process events
-//
-
 #endif
--- a/src/komodo_nSPV_fullnode.h
+++ b/src/komodo_nSPV_fullnode.h
@@ -36,12 +36,12 @@ struct NSPV_ntzargs

 int32_t NSPV_notarization_find(struct NSPV_ntzargs *args,int32_t height,int32_t dir)
 {
-    int32_t ntzheight = 0; uint256 hashBlock; CTransaction tx; Notarisation nota; char *symbol; std::vector<uint8_t> opret;
+    int32_t ntzheight = 0; uint256 hashBlock; CTransaction tx; Notarization nota; char *symbol; std::vector<uint8_t> opret;
    symbol = (SMART_CHAIN_SYMBOL[0] == 0) ? (char *)"KMD" : SMART_CHAIN_SYMBOL;
    memset(args,0,sizeof(*args));
    if ( dir > 0 )
        height += 10;
-    if ( (args->txidht= ScanNotarisationsDB(height,symbol,1440,nota)) == 0 )
+    if ( (args->txidht= ScanNotarizationsDB(height,symbol,1440,nota)) == 0 )
        return(-1);
    args->txid = nota.first;
    if ( !GetTransaction(args->txid,tx,hashBlock,false) || tx.vout.size() < 2 )
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -65,24 +65,22 @@ using namespace std;
 # error "Hush cannot be compiled without assertions, lulz"
 #endif

+// which fork? lulzzzzzzz
 #include "librustzcash.h"

-/**
- * Global state
- */
+// Global state

 #define TMPFILE_START 100000000
 CCriticalSection cs_main;
 extern uint8_t NOTARY_PUBKEY33[33];
-extern int32_t KOMODO_LOADINGBLOCKS,HUSH_LONGESTCHAIN,HUSH_INSYNC,KOMODO_CONNECTING,KOMODO_EXTRASATOSHI;
-int32_t KOMODO_NEWBLOCKS;
+extern int32_t HUSH_LOADINGBLOCKS,HUSH_LONGESTCHAIN,HUSH_INSYNC,HUSH_CONNECTING,HUSH_EXTRASATOSHI;
+int32_t HUSH_NEWBLOCKS;
 int32_t komodo_block2pubkey33(uint8_t *pubkey33,CBlock *block);
 //void komodo_broadcast(CBlock *pblock,int32_t limit);
 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
 void hush_setactivation(int32_t height);
 void hush_changeblocktime();
 void komodo_pricesupdate(int32_t height,CBlock *pblock);
-
 BlockMap mapBlockIndex;
 CChain chainActive;
 CBlockIndex *pindexBestHeader = NULL;
@@ -679,9 +677,9 @@ bool komodo_dailysnapshot(int32_t height)
    {
        // we are on chain init, and need to scan all the way back to the correct height, other wise our node will have a diffrent snapshot to online nodes.
        // use the notarizationsDB to scan back from the consesnus height to get the offset we need.
-        std::string symbol; Notarisation nota;
+        std::string symbol; Notarization nota;
        symbol.assign(SMART_CHAIN_SYMBOL);
-        if ( ScanNotarisationsDB(height-extraoffset, symbol, 100, nota) == 0 )
+        if ( ScanNotarizationsDB(height-extraoffset, symbol, 100, nota) == 0 )
            undo_height = height-extraoffset-reorglimit; 
        else undo_height = nota.second.height;
        //fprintf(stderr, "height.%i-extraoffset.%i = startscanfrom.%i to get undo_height.%i\n", height, extraoffset, height-extraoffset, undo_height);
@@ -2009,20 +2007,20 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
        // invalid blocks, however allowing such transactions into the mempool
        // can be exploited as a DoS attack.
        // XXX: is this neccesary for CryptoConditions?
-        if ( KOMODO_CONNECTING <= 0 && chainActive.LastTip() != 0 )
+        if ( HUSH_CONNECTING <= 0 && chainActive.LastTip() != 0 )
        {
            flag = 1;
-            KOMODO_CONNECTING = (1<<30) + (int32_t)chainActive.LastTip()->GetHeight() + 1;
+            HUSH_CONNECTING = (1<<30) + (int32_t)chainActive.LastTip()->GetHeight() + 1;
        }

        if (!ContextualCheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, txdata, Params().GetConsensus(), consensusBranchId))
        {
            if ( flag != 0 )
-                KOMODO_CONNECTING = -1;
+                HUSH_CONNECTING = -1;
            return error("AcceptToMemoryPool: BUG! PLEASE REPORT THIS! ConnectInputs failed against MANDATORY but not STANDARD flags %s", hash.ToString());
        }
        if ( flag != 0 )
-            KOMODO_CONNECTING = -1;
+            HUSH_CONNECTING = -1;

        {
            LOCK(pool.cs);
@@ -2908,11 +2906,11 @@ static bool ApplyTxInUndo(const CTxInUndo& undo, CCoinsViewCache& view, const CO

 void ConnectNotarizations(const CBlock &block, int height)
 {
-    NotarisationsInBlock notarisations = ScanBlockNotarizations(block, height);
+    NotarizationsInBlock notarisations = ScanBlockNotarizations(block, height);
    if (notarisations.size() > 0) {
        CDBBatch batch = CDBBatch(*pnotarizations);
        batch.Write(block.GetHash(), notarisations);
-        WriteBackNotarisations(notarisations, batch);
+        WriteBackNotarizations(notarisations, batch);
        pnotarizations->WriteBatch(batch, true);
        LogPrintf("ConnectBlock: wrote %i block notarizations in block: %s\n",
                notarisations.size(), block.GetHash().GetHex().data());
@@ -2921,11 +2919,11 @@ void ConnectNotarizations(const CBlock &block, int height)

 void DisconnectNotarizations(const CBlock &block)
 {
-    NotarisationsInBlock nibs;
-    if (GetBlockNotarisations(block.GetHash(), nibs)) {
+    NotarizationsInBlock nibs;
+    if (GetBlockNotarizations(block.GetHash(), nibs)) {
        CDBBatch batch = CDBBatch(*pnotarizations);
        batch.Erase(block.GetHash());
-        EraseBackNotarisations(nibs, batch);
+        EraseBackNotarizations(nibs, batch);
        pnotarizations->WriteBatch(batch, true);
        LogPrintf("DisconnectTip: deleted %i block notarizations in block: %s\n",
            nibs.size(), block.GetHash().GetHex().data());
@@ -3594,7 +3592,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
        return state.DoS(100, error("ConnectBlock(): coinbase for block 1 pays wrong amount (actual=%d vs correct=%d)", block.vtx[0].GetValueOut(), blockReward),
                            REJECT_INVALID, "bad-cb-amount");
    }
-    if ( block.vtx[0].GetValueOut() > blockReward+KOMODO_EXTRASATOSHI )
+    if ( block.vtx[0].GetValueOut() > blockReward+HUSH_EXTRASATOSHI )
    {
        if ( SMART_CHAIN_SYMBOL[0] != 0 || pindex->GetHeight() >= KOMODO_NOTARIES_HEIGHT1 || block.vtx[0].vout[0].nValue > blockReward )
        {
@@ -3844,7 +3842,7 @@ void static UpdateTip(CBlockIndex *pindexNew) {
    // New best block
    nTimeBestReceived = GetTime();
    mempool.AddTransactionsUpdated(1);
-    KOMODO_NEWBLOCKS++;
+    HUSH_NEWBLOCKS++;
    double progress;
    if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
        progress = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), chainActive.LastTip());
@@ -4044,7 +4042,7 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
            return AbortNode(state, "Failed to read block");
        pblock = &block;
    }
-    KOMODO_CONNECTING = (int32_t)pindexNew->GetHeight();
+    HUSH_CONNECTING = (int32_t)pindexNew->GetHeight();
    //fprintf(stderr,"%s connecting ht.%d maxsize.%d vs %d\n",SMART_CHAIN_SYMBOL,(int32_t)pindexNew->GetHeight(),MAX_BLOCK_SIZE(pindexNew->GetHeight()),(int32_t)::GetSerializeSize(*pblock, SER_NETWORK, PROTOCOL_VERSION));
 
    // Apply the block atomically to the chain state.
@@ -4054,7 +4052,7 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
    {
        CCoinsViewCache view(pcoinsTip);
        bool rv = ConnectBlock(*pblock, state, pindexNew, view, false, true);
-        KOMODO_CONNECTING = -1;
+        HUSH_CONNECTING = -1;
        GetMainSignals().BlockChecked(*pblock, state);
        if (!rv) {
            if (state.IsInvalid())
@@ -4322,11 +4320,11 @@ static bool ActivateBestChainStep(bool fSkipdpow, CValidationState &state, CBloc
            return false;
        fBlocksDisconnected = true;
    }
-    if ( KOMODO_REWIND != 0 )
+    if ( HUSH_REWIND != 0 )
    {
        CBlockIndex *tipindex;
-        fprintf(stderr,">>>>>>>>>>> rewind start ht.%d -> KOMODO_REWIND.%d\n",chainActive.LastTip()->GetHeight(),KOMODO_REWIND);
-        while ( KOMODO_REWIND > 0 && (tipindex= chainActive.LastTip()) != 0 && tipindex->GetHeight() > KOMODO_REWIND )
+        fprintf(stderr,">>>>>>>>>>> rewind start ht.%d -> HUSH_REWIND.%d\n",chainActive.LastTip()->GetHeight(),HUSH_REWIND);
+        while ( HUSH_REWIND > 0 && (tipindex= chainActive.LastTip()) != 0 && tipindex->GetHeight() > HUSH_REWIND )
        {
            fBlocksDisconnected = true;
            fprintf(stderr,"%d ",(int32_t)tipindex->GetHeight());
@@ -4334,10 +4332,10 @@ static bool ActivateBestChainStep(bool fSkipdpow, CValidationState &state, CBloc
            if ( !DisconnectTip(state) )
                break;
        }
-        fprintf(stderr,"reached rewind.%d, best to do: ./komodo-cli -ac_name=%s stop\n",KOMODO_REWIND,SMART_CHAIN_SYMBOL);
+        fprintf(stderr,"reached rewind.%d, best to do: ./komodo-cli -ac_name=%s stop\n",HUSH_REWIND,SMART_CHAIN_SYMBOL);
        sleep(20);
        fprintf(stderr,"resuming normal operations\n");
-        KOMODO_REWIND = 0;
+        HUSH_REWIND = 0;
        //return(true);
    }
    // Build list of new blocks to connect.
@@ -5185,7 +5183,7 @@ bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const C
    for (uint32_t i = 0; i < block.vtx.size(); i++)
    {
        const CTransaction& tx = block.vtx[i];
-        if ( komodo_validate_interest(tx,height == 0 ? komodo_block2height((CBlock *)&block) : height,block.nTime,0) < 0 )
+        if ( komodo_validate_interest(tx,height == 0 ? hush_block2height((CBlock *)&block) : height,block.nTime,0) < 0 )
        {
            fprintf(stderr, "validate intrest failed for txnum.%i tx.%s\n", i, tx.ToString().c_str());
            return error("CheckBlock: komodo_validate_interest failed");
@@ -5241,9 +5239,14 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
    int nHeight = pindexPrev->GetHeight()+1;

    // Check Proof-of-Work
-    if ( (SMART_CHAIN_SYMBOL[0] != 0 || nHeight < 235300 || nHeight > 236000) && block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
-    {
-        cout "Incorrect Proof-of-Work! " << block.nBits << " block.nBits vs. calc " << GetNextWorkRequired(pindexPrev, &block, consensusParams) << " for height " << nHeight << " " << block.GetHash().ToString() << " with time " << block.GetBlockTime() <<  endl;
+    if ( (SMART_CHAIN_SYMBOL[0] != 0 || nHeight < 235300 || nHeight > 236000) && block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams)) {
+        cout << "Incorrect Proof-of-Work! " << 
+            block.nBits << " block.nBits vs. calc " <<
+            GetNextWorkRequired(pindexPrev, &block, consensusParams) <<
+            " for height " << nHeight << " " << 
+            block.GetHash().ToString() << " with time " <<
+            block.GetBlockTime() <<  endl;
+
        return state.DoS(100, error("%s: Incorrect Proof-of-Work at height %d", __func__, nHeight), REJECT_INVALID, "bad-diffbits");
    }

@@ -5361,9 +5364,8 @@ bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidat
            miSelf->second = pindex = AddToBlockIndex(block);
        if (ppindex)
            *ppindex = pindex;
-        if ( pindex != 0 && (pindex->nStatus & BLOCK_FAILED_MASK) != 0 )
-        {
-            if ( ASSETCHAINS_CC == 0 )//&& (ASSETCHAINS_PRIVATE == 0 || HUSH_INSYNC >= Params().GetConsensus().vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight) )
+        if ( pindex != 0 && (pindex->nStatus & BLOCK_FAILED_MASK) != 0 ) {
+            if ( ASSETCHAINS_CC == 0 ) {
                return state.Invalid(error("%s: block is marked invalid", __func__), 0, "duplicate");
            } else {
                fprintf(stderr,"reconsider block %s\n",hash.GetHex().c_str());
@@ -5372,11 +5374,9 @@ bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidat
        }
        return true;
    }
-    if (!CheckBlockHeader(futureblockp,*ppindex!=0?(*ppindex)->GetHeight():0,*ppindex, block, state,0))
-    {
-        if ( *futureblockp == 0 )
-        {
-            LogPrintf("AcceptBlockHeader CheckBlockHeader error\n");
+    if (!CheckBlockHeader(futureblockp,*ppindex!=0?(*ppindex)->GetHeight():0,*ppindex, block, state,0)) {
+        if ( *futureblockp == 0 ) {
+            LogPrintf("%s: CheckBlockHeader futureblock=0\n", __func__);
            return false;
        }
    }
@@ -5387,7 +5387,7 @@ bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidat
        BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
        if (mi == mapBlockIndex.end())
        {
-            LogPrintf("AcceptBlockHeader hashPrevBlock %s not found\n",block.hashPrevBlock.ToString().c_str());
+            LogPrintf("%s: hashPrevBlock %s not found\n",__func__, block.hashPrevBlock.ToString().c_str());
            //*futureblockp = 1;
            return(false);
            //return state.DoS(10, error("%s: prev block not found", __func__), 0, "bad-prevblk");
@@ -5395,7 +5395,7 @@ bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidat
        pindexPrev = (*mi).second;
        if (pindexPrev == 0 )
        {
-            LogPrintf("AcceptBlockHeader hashPrevBlock %s no pindexPrev\n",block.hashPrevBlock.ToString().c_str());
+            LogPrintf("%s: hashPrevBlock %s no pindexPrev\n",__func__,block.hashPrevBlock.ToString().c_str());
            return(false);
        }
        if ( (pindexPrev->nStatus & BLOCK_FAILED_MASK) )
@@ -5404,7 +5404,7 @@ bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidat
    if (!ContextualCheckBlockHeader(block, state, pindexPrev))
    {
        //fprintf(stderr,"AcceptBlockHeader ContextualCheckBlockHeader failed\n");
-        LogPrintf("AcceptBlockHeader ContextualCheckBlockHeader failed\n");
+        LogPrintf("%s: ContextualCheckBlockHeader failed\n",__func__);
        return false;
    }
    if (pindex == NULL)
@@ -5434,13 +5434,13 @@ bool AcceptBlock(int32_t *futureblockp,CBlock& block, CValidationState& state, C
    {
        if ( *futureblockp == 0 )
        {
-            LogPrintf("AcceptBlock AcceptBlockHeader error\n");
+            LogPrintf("%s: AcceptBlockHeader error\n",__func__);
            return false;
        }
    }
    if ( pindex == 0 )
    {
-        LogPrintf("AcceptBlock null pindex\n");
+        LogPrintf("%s: null pindex\n", __func__);
        *futureblockp = true;
        return false;
    }
@@ -5556,7 +5556,7 @@ static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned
    return (nFound >= nRequired);
 }

-void komodo_currentheight_set(int32_t height);
+void hush_currentheight_set(int32_t height);

 CBlockIndex *komodo_ensure(CBlock *pblock, uint256 hash)
 {
@@ -5595,26 +5595,23 @@ bool ProcessNewBlock(bool from_miner,int32_t height,CValidationState &state, CNo
    {
        LOCK(cs_main);
        if ( chainActive.LastTip() != 0 )
-            komodo_currentheight_set(chainActive.LastTip()->GetHeight());
-        checked = CheckBlock(&futureblock,height!=0?height:komodo_block2height(pblock),0,*pblock, state, verifier,0);
+            hush_currentheight_set(chainActive.LastTip()->GetHeight());
+        checked = CheckBlock(&futureblock,height!=0?height:hush_block2height(pblock),0,*pblock, state, verifier,0);
        bool fRequested = MarkBlockAsReceived(hash);
-        // Test thing on LABS to test viability of rejecting a node pushing a chain.
-        // Supposed to stop malicious forks being pushed. Untested. Disabled incase of problems it may cause.
-        if ( 0 && pfrom && !fRequested && vNodes.size() > 1 )
-        {
+        // Reject nodes which push malicious chainforks.
+        // Originally researched and written by blackjok3r, core dev of KMD+LABS
+        // Optimized by Hush developers ;)
+        if ( GetArg("-debugchainforks",false) && (pfrom && !fRequested && vNodes.size() > 1) ) {
            pfrom->nBlocksinARow += 1;
            if ( pfrom->nBlocksinARow >= 10 )
            {
                pfrom->nBlocksinARow2 += 1;
-                if ( pfrom->nBlocksinARow2 > 5 )
-                {
-                    pfrom->nBlocksinARow = 0;
+                if ( pfrom->nBlocksinARow2 > 5 ) {
+                    pfrom->nBlocksinARow  = 0;
                    pfrom->nBlocksinARow2 = 0;
-                    fprintf(stderr, "reset node.%i\n",(int32_t)pfrom->GetId());
-                }
-                else 
-                {
-                    fprintf(stderr, "Requesting new peer node.%i blocksinrow.%i blocsinrow2.%i\n",(int32_t)pfrom->GetId(),pfrom->nBlocksinARow,pfrom->nBlocksinARow2);
+                    fprintf(stderr, "%s: reset node.%i\n",__func__, (int32_t)pfrom->GetId());
+                } else {
+                    fprintf(stderr, "%s: Requesting new peer node.%i blocksinrow.%i blocsinrow2.%i\n",__func__, (int32_t)pfrom->GetId(),pfrom->nBlocksinARow,pfrom->nBlocksinARow2);
                    return(false);
                }
            }
@@ -5661,7 +5658,7 @@ bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex
    CBlockIndex indexDummy(block);
    indexDummy.pprev = pindexPrev;
    indexDummy.SetHeight(pindexPrev->GetHeight() + 1);
-    // JoinSplit proofs are verified in ConnectBlock
+    // zk proofs are verified in ConnectBlock
    auto verifier = libzcash::ProofVerifier::Disabled();
    // NOTE: CheckBlockHeader is called by CheckBlock
    if (!ContextualCheckBlockHeader(block, state, pindexPrev))
@@ -5691,10 +5688,7 @@ bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex
    return true;
 }

-/**
- * BLOCK PRUNING CODE
- */
-
+// BLOCK PRUNING CODE
 /* Calculate the amount of disk space the block & undo files currently use */
 uint64_t CalculateCurrentUsage()
 {
@@ -5899,12 +5893,10 @@ CBlockIndex * InsertBlockIndex(uint256 hash)
    return pindexNew;
 }

-//void komodo_pindex_init(CBlockIndex *pindex,int32_t height);
-
 bool static LoadBlockIndexDB()
 {
    const CChainParams& chainparams = Params();
-    LogPrintf("%s: start loading guts\n", __func__);
+    //LogPrintf("%s: start loading guts\n", __func__);
    if (!pblocktree->LoadBlockIndexGuts())
        return false;
    LogPrintf("%s: loaded guts\n", __func__);
@@ -5917,11 +5909,13 @@ bool static LoadBlockIndexDB()
    {
        CBlockIndex* pindex = item.second;
        vSortedByHeight.push_back(make_pair(pindex->GetHeight(), pindex));
-        //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
    }
-    //fprintf(stderr,"load blockindexDB paired %u\n",(uint32_t)time(NULL));
+    if(fDebug)
+        fprintf(stderr,"load blockindexDB paired %u\n",(uint32_t)time(NULL));
    sort(vSortedByHeight.begin(), vSortedByHeight.end());
-    //fprintf(stderr,"load blockindexDB sorted %u\n",(uint32_t)time(NULL));
+    if(fDebug)
+        fprintf(stderr,"load blockindexDB sorted %u\n",(uint32_t)time(NULL));
+
    BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*)& item, vSortedByHeight)
    {
        CBlockIndex* pindex = item.second;
@@ -6015,7 +6009,6 @@ bool static LoadBlockIndexDB()
            pindex->BuildSkip();
        if (pindex->IsValid(BLOCK_VALID_TREE) && (pindexBestHeader == NULL || CBlockIndexWorkComparator()(pindexBestHeader, pindex)))
            pindexBestHeader = pindex;
-        //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
    }
    fprintf(stderr,"load blockindexDB chained %u\n",(uint32_t)time(NULL));

@@ -6098,7 +6091,6 @@ bool static LoadBlockIndexDB()
        if (pindex->pprev) {
            pindex->pprev->hashFinalSproutRoot = pindex->hashSproutAnchor;
        }
-        //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
    }

    // Load pointer to end of best chain
@@ -6422,10 +6414,10 @@ void UnloadBlockIndex()
 bool LoadBlockIndex()
 {
    // Load block index from databases
-    KOMODO_LOADINGBLOCKS = 1;
+    HUSH_LOADINGBLOCKS = 1;
    if (!fReindex && !LoadBlockIndexDB())
    {
-        KOMODO_LOADINGBLOCKS = 0;
+        HUSH_LOADINGBLOCKS = 0;
        return false;
    }
    fprintf(stderr,"finished loading blocks %s\n",SMART_CHAIN_SYMBOL);
@@ -6951,7 +6943,7 @@ void static ProcessGetData(CNode* pfrom)
                            //hash = block.GetHash();
                            //for (z=31; z>=0; z--)
                            //    fprintf(stderr,"%02x",((uint8_t *)&hash)[z]);
-                            //fprintf(stderr," send block %d\n",komodo_block2height(&block));
+                            //fprintf(stderr," send block %d\n",hush_block2height(&block));
                            pfrom->PushMessage("block", block);
                        }
                        else // MSG_FILTERED_BLOCK)
@@ -8136,9 +8128,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
        if (pto->nVersion == 0)
            return true;

-        //
        // Message: ping
-        //
        bool pingSend = false;
        if (pto->fPingQueued) {
            // RPC ping request by user
@@ -8187,9 +8177,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
                nLastRebroadcast = GetTime();
        }

-        //
        // Message: addr
-        //
        if (fSendTrickle)
        {
            vector<CAddress> vAddr;
@@ -8215,9 +8203,9 @@ bool SendMessages(CNode* pto, bool fSendTrickle)

        CNodeState &state = *State(pto->GetId());
        if (state.fShouldBan) {
-            if (pto->fWhitelisted)
+            if (pto->fWhitelisted) {
                LogPrintf("Warning: not punishing whitelisted peer %s!\n", pto->addr.ToString());
-            else {
+            } else {
                pto->fDisconnect = true;
                if (pto->addr.IsLocal())
                    LogPrintf("Warning: not banning local peer %s!\n", pto->addr.ToString());
@@ -8260,9 +8248,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
            GetMainSignals().Broadcast(nTimeBestReceived);
        }

-        //
        // Message: inventory
-        //
        vector<CInv> vInv;
        vector<CInv> vInvWait;
        {
@@ -8340,9 +8326,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
            }
        }

-        //
        // Message: getdata (blocks)
-        //
        static uint256 zero;
        vector<CInv> vGetData;
        if (!pto->fDisconnect && !pto->fClient && (fFetch || !IsInitialBlockDownload()) && state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
@@ -8352,8 +8336,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
            BOOST_FOREACH(CBlockIndex *pindex, vToDownload) {
                vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
                MarkBlockAsInFlight(pto->GetId(), pindex->GetBlockHash(), consensusParams, pindex);
-                LogPrint("net", "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),
-                         pindex->GetHeight(), pto->id);
+                LogPrint("net", "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(), pindex->GetHeight(), pto->id);
            }
            if (state.nBlocksInFlight == 0 && staller != -1) {
                if (State(staller)->nStallingSince == 0) {
@@ -8362,24 +8345,8 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
                }
            }
        }
-        /*CBlockIndex *pindex;
-        if ( komodo_requestedhash != zero && komodo_requestedcount < 16 && (pindex= komodo_getblockindex(komodo_requestedhash)) != 0 )
-        {
-            LogPrint("net","komodo_requestedhash.%d request %s to nodeid.%d\n",komodo_requestedcount,komodo_requestedhash.ToString().c_str(),pto->GetId());
-            fprintf(stderr,"komodo_requestedhash.%d request %s to nodeid.%d\n",komodo_requestedcount,komodo_requestedhash.ToString().c_str(),pto->GetId());
-            vGetData.push_back(CInv(MSG_BLOCK, komodo_requestedhash));
-            MarkBlockAsInFlight(pto->GetId(), komodo_requestedhash, consensusParams, pindex);
-            komodo_requestedcount++;
-            if ( komodo_requestedcount > 16 )
-            {
-                memset(&komodo_requestedhash,0,sizeof(komodo_requestedhash));
-                komodo_requestedcount = 0;
-            }
-        }*/

-        //
        // Message: getdata (non-blocks)
-        //
        while (!pto->fDisconnect && !pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
        {
            const CInv& inv = (*pto->mapAskFor.begin()).second;
@@ -8441,28 +8408,24 @@ CMutableTransaction CreateNewContextualCMutableTransaction(const Consensus::Para
    CMutableTransaction mtx;
    if ( KOMODO_NSPV_SUPERLITE )
    {
-        mtx.fOverwintered = true;
-        mtx.nExpiryHeight = 0;
+        mtx.fOverwintered   = true;
+        mtx.nExpiryHeight   = 0;
        mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
-        mtx.nVersion = SAPLING_TX_VERSION;
-    }
-    else
-    {
+        mtx.nVersion        = SAPLING_TX_VERSION;
+    } else {
        bool isOverwintered = NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_OVERWINTER);
        if (isOverwintered)
        {
-            mtx.fOverwintered = true;
-            mtx.nExpiryHeight = nHeight + expiryDelta;
+            mtx.fOverwintered       = true;
+            mtx.nExpiryHeight       = nHeight + expiryDelta;
            if (NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_SAPLING))
            {
                mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
-                mtx.nVersion = SAPLING_TX_VERSION;
-            }
-            else
-            {
+                mtx.nVersion        = SAPLING_TX_VERSION;
+            } else {
                mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
-                mtx.nVersion = OVERWINTER_TX_VERSION;
-                mtx.nExpiryHeight = std::min(mtx.nExpiryHeight,static_cast<uint32_t>(consensusParams.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight - 1));
+                mtx.nVersion        = OVERWINTER_TX_VERSION;
+                mtx.nExpiryHeight   = std::min(mtx.nExpiryHeight,static_cast<uint32_t>(consensusParams.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight - 1));
            }
        }
    }
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -151,7 +151,7 @@ uint64_t the_commission(const CBlock *block,int32_t height);
 int32_t komodo_notaryvin(CMutableTransaction &txNew,uint8_t *notarypub33, void *ptr);
 int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex);
 int32_t komodo_is_notarytx(const CTransaction& tx);
-uint64_t komodo_notarypay(CMutableTransaction &txNew, std::vector<int8_t> &NotarisationNotaries, uint32_t timestamp, int32_t height, uint8_t *script, int32_t len);
+uint64_t komodo_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 komodo_getnotarizedheight(uint32_t timestamp,int32_t height, uint8_t *script, int32_t len);
 CScript komodo_mineropret(int32_t nHeight);
@@ -175,7 +175,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();
-    bool fNotarisationBlock = false; std::vector<int8_t> NotarisationNotaries;
+    bool fNotarizationBlock = false; std::vector<int8_t> NotarizationNotaries;
    
    //fprintf(stderr,"create new block\n");
    // Create new block
@@ -276,7 +276,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
        vecPriority.reserve(mempool.mapTx.size() + 1);

        // now add transactions from the mem pool
-        int32_t Notarisations = 0; uint64_t txvalue;
+        int32_t Notarizations = 0; uint64_t txvalue;
        for (CTxMemPool::indexed_transaction_set::iterator mi = mempool.mapTx.begin();
             mi != mempool.mapTx.end(); ++mi)
        {
@@ -307,15 +307,15 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
            double dPriority = 0;
            CAmount nTotalIn = 0;
            bool fMissingInputs = false;
-            bool fNotarisation = false;
-            std::vector<int8_t> TMP_NotarisationNotaries;
+            bool fNotarization = false;
+            std::vector<int8_t> TMP_NotarizationNotaries;
            if (tx.IsCoinImport())
            {
                CAmount nValueIn = GetCoinImportValue(tx); // burn amount
                nTotalIn += nValueIn;
                dPriority += (double)nValueIn * 1000;  // flat multiplier... max = 1e16.
            } else {
-                TMP_NotarisationNotaries.clear();
+                TMP_NotarizationNotaries.clear();
                bool fToCryptoAddress = false;
                if ( numSN != 0 && notarypubkeys[0][0] != 0 && komodo_is_notarytx(tx) == 1 )
                    fToCryptoAddress = true;
@@ -376,20 +376,20 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                            if ( scriptlen == 35 && script[0] == 33 && script[34] == OP_CHECKSIG && memcmp(script+1,notarypubkeys[i],33) == 0 )
                            {
                                // We can add the index of each notary to vector, and clear it if this notarisation is not valid later on.
-                                TMP_NotarisationNotaries.push_back(i);                          
+                                TMP_NotarizationNotaries.push_back(i);                          
                            }
                        }
                    }
                    dPriority += (double)nValueIn * nConf;
                }
-                if ( numSN != 0 && notarypubkeys[0][0] != 0 && TMP_NotarisationNotaries.size() >= numSN / 5 )
+                if ( numSN != 0 && notarypubkeys[0][0] != 0 && TMP_NotarizationNotaries.size() >= numSN / 5 )
                {
                    // check a notary didnt sign twice (this would be an invalid notarisation later on and cause problems)
-                    std::set<int> checkdupes( TMP_NotarisationNotaries.begin(), TMP_NotarisationNotaries.end() );
-                    if ( checkdupes.size() != TMP_NotarisationNotaries.size() ) 
+                    std::set<int> checkdupes( TMP_NotarizationNotaries.begin(), TMP_NotarizationNotaries.end() );
+                    if ( checkdupes.size() != TMP_NotarizationNotaries.size() ) 
                    {
                        fprintf(stderr, "possible notarisation is signed multiple times by same notary, passed as normal transaction.\n");
-                    } else fNotarisation = true;
+                    } else fNotarization = true;
                }
                nTotalIn += tx.GetShieldedValueIn();
            }
@@ -405,7 +405,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32

            CFeeRate feeRate(nTotalIn-tx.GetValueOut(), nTxSize);

-            if ( fNotarisation ) 
+            if ( fNotarization ) 
            {
                // Special miner for notary pay chains. Can only enter this if numSN/notarypubkeys is set higher up.
                if ( tx.vout.size() == 2 && tx.vout[1].nValue == 0 )
@@ -415,10 +415,10 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                    int32_t scriptlen = (int32_t)tx.vout[1].scriptPubKey.size();
                    if ( script[0] == OP_RETURN )
                    {
-                        Notarisations++;
-                        if ( Notarisations > 1 ) 
+                        Notarizations++;
+                        if ( Notarizations > 1 ) 
                        {
-                            fprintf(stderr, "skipping notarization.%d\n",Notarisations);
+                            fprintf(stderr, "skipping notarization.%d\n",Notarizations);
                            // Any attempted notarization needs to be in its own block!
                            continue;
                        }
@@ -426,10 +426,10 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                        if ( notarizedheight != 0 )
                        {
                            // this is the first one we see, add it to the block as TX1 
-                            NotarisationNotaries = TMP_NotarisationNotaries;
+                            NotarizationNotaries = TMP_NotarizationNotaries;
                            dPriority = 1e16;
-                            fNotarisationBlock = true;
-                            //fprintf(stderr, "Notarisation %s set to maximum priority\n",hash.ToString().c_str());
+                            fNotarizationBlock = true;
+                            //fprintf(stderr, "Notarization %s set to maximum priority\n",hash.ToString().c_str());
                        }
                    }
                }
@@ -673,14 +673,14 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
 			LEAVE_CRITICAL_SECTION(mempool.cs);
 			return(0);
        } 
-        else if ( fNotarisationBlock && ASSETCHAINS_NOTARY_PAY[0] != 0 && pblock->vtx[1].vout.size() == 2 && pblock->vtx[1].vout[1].nValue == 0 )
+        else if ( fNotarizationBlock && ASSETCHAINS_NOTARY_PAY[0] != 0 && pblock->vtx[1].vout.size() == 2 && pblock->vtx[1].vout[1].nValue == 0 )
        {
            // Get the OP_RETURN for the notarisation
            uint8_t *script = (uint8_t *)&pblock->vtx[1].vout[1].scriptPubKey[0];
            int32_t scriptlen = (int32_t)pblock->vtx[1].vout[1].scriptPubKey.size();
            if ( script[0] == OP_RETURN )
            {
-                uint64_t totalsats = komodo_notarypay(txNew, NotarisationNotaries, pblock->nTime, nHeight, script, scriptlen);
+                uint64_t totalsats = komodo_notarypay(txNew, NotarizationNotaries, pblock->nTime, nHeight, script, scriptlen);
                if ( totalsats == 0 )
                {
                    fprintf(stderr, "Could not create notary payment, trying again.\n");
--- a/src/notarizationdb.cpp
+++ b/src/notarizationdb.cpp
@@ -12,66 +12,64 @@
 NotarizationDB *pnotarizations;
 NotarizationDB::NotarizationDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "notarizations", nCacheSize, fMemory, fWipe, false, 64) { }

-NotarisationsInBlock ScanBlockNotarizations(const CBlock &block, int nHeight)
+NotarizationsInBlock ScanBlockNotarizations(const CBlock &block, int nHeight)
 {
    EvalRef eval;
-    NotarisationsInBlock vNotarisations;
+    NotarizationsInBlock vNotarizations;
    int timestamp = block.nTime;
    bool ishush3  = strncmp(SMART_CHAIN_SYMBOL, "HUSH3",5) == 0 ? true : false;

-    // No valid ntz's before this height on HUSH3
-    if(ishush3 && (nHeight <= 360000)) {
-        return vNotarisations;
+    // No valid ntz's before this height
+    int minheight = ishush3 ? 360000 : 1;
+    if(ishush3 && (nHeight <= GetArg("-dpow_height",minheight))) {
+        return vNotarizations;
    }

    for (unsigned int i = 0; i < block.vtx.size(); i++) {
        CTransaction tx = block.vtx[i];

-        NotarisationData data;
-        bool parsed = ParseNotarisationOpReturn(tx, data);
-        if (!parsed) data = NotarisationData();
+        NotarizationData data;
+        bool parsed = ParseNotarizationOpReturn(tx, data);
+        if (!parsed) data = NotarizationData();
        if (strlen(data.symbol) == 0)
          continue;

-        //printf("Checked notarisation data for %s \n",data.symbol);
+        //printf("Checked notarization data for %s \n",data.symbol);
        int authority = GetSymbolAuthority(data.symbol);

        if (authority == CROSSCHAIN_HUSH) {
            if (!eval->CheckNotaryInputs(tx, nHeight, block.nTime))
                continue;
-            //printf("Authorised notarisation data for %s \n",data.symbol);
        }

        if (parsed) {
-            vNotarisations.push_back(std::make_pair(tx.GetHash(), data));
-            //printf("Parsed a notarisation for: %s, txid:%s, ccid:%i, momdepth:%i\n",
-            //      data.symbol, tx.GetHash().GetHex().data(), data.ccId, data.MoMDepth);
-            //if (!data.MoMoM.IsNull()) printf("MoMoM:%s\n", data.MoMoM.GetHex().data());
+            vNotarizations.push_back(std::make_pair(tx.GetHash(), data));
+            if(fDebug) {
+                printf("Parsed a notarization for: %s, txid:%s, ccid:%i, momdepth:%i\n", data.symbol, tx.GetHash().GetHex().data(), data.ccId, data.MoMDepth);
+                if (!data.MoMoM.IsNull()) printf("MoMoM:%s\n", data.MoMoM.GetHex().data());
+            }
        } else
-            LogPrintf("WARNING: Couldn't parse notarisation for tx: %s at height %i\n", tx.GetHash().GetHex().data(), nHeight);
+            LogPrintf("WARNING: Couldn't parse notarization for tx: %s at height %i\n", tx.GetHash().GetHex().data(), nHeight);
    }
-    return vNotarisations;
+    return vNotarizations;
 }

-bool GetBlockNotarisations(uint256 blockHash, NotarisationsInBlock &nibs)
+bool GetBlockNotarizations(uint256 blockHash, NotarizationsInBlock &nibs)
 {
    return pnotarizations->Read(blockHash, nibs);
 }


-bool GetBackNotarisation(uint256 notarisationHash, Notarisation &n)
+bool GetBackNotarization(uint256 notarisationHash, Notarization &n)
 {
    return pnotarizations->Read(notarisationHash, n);
 }

-
-/*
- * Write an index of HUSH notarisation id -> backnotarisation
- */
-void WriteBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch)
+// Write an index of HUSH notarisation id -> backnotarisation
+void WriteBackNotarizations(const NotarizationsInBlock notarisations, CDBBatch &batch)
 {
    int wrote = 0;
-    BOOST_FOREACH(const Notarisation &n, notarisations)
+    BOOST_FOREACH(const Notarization &n, notarisations)
    {
        if (!n.second.txHash.IsNull()) {
            batch.Write(n.second.txHash, n);
@@ -80,33 +78,30 @@ void WriteBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &
    }
 }

-
-void EraseBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch)
+void EraseBackNotarizations(const NotarizationsInBlock notarisations, CDBBatch &batch)
 {
-    BOOST_FOREACH(const Notarisation &n, notarisations)
+    BOOST_FOREACH(const Notarization &n, notarisations)
    {
        if (!n.second.txHash.IsNull())
            batch.Erase(n.second.txHash);
    }
 }

-/*
- * Scan notarisationsdb backwards for blocks containing a notarisation
- * for given symbol. Return height of matched notarisation or 0.
- */
-int ScanNotarisationsDB(int height, std::string symbol, int scanLimitBlocks, Notarisation& out)
+// Scan notarisationsdb backwards for blocks containing a notarisation
+// for given symbol. Return height of matched notarisation or 0.
+int ScanNotarizationsDB(int height, std::string symbol, int scanLimitBlocks, Notarization& out)
 {
    if (height < 0 || height > chainActive.Height())
        return false;

    for (int i=0; i<scanLimitBlocks; i++) {
        if (i > height) break;
-        NotarisationsInBlock notarisations;
+        NotarizationsInBlock notarisations;
        uint256 blockHash = *chainActive[height-i]->phashBlock;
-        if (!GetBlockNotarisations(blockHash, notarisations))
+        if (!GetBlockNotarizations(blockHash, notarisations))
            continue;

-        BOOST_FOREACH(Notarisation& nota, notarisations) {
+        BOOST_FOREACH(Notarization& nota, notarisations) {
            if (strcmp(nota.second.symbol, symbol.data()) == 0) {
                out = nota;
                return height-i;
@@ -115,30 +110,3 @@ int ScanNotarisationsDB(int height, std::string symbol, int scanLimitBlocks, Not
    }
    return 0;
 }
-
-int ScanNotarisationsDB2(int height, std::string symbol, int scanLimitBlocks, Notarisation& out)
-{
-    int32_t i,maxheight,ht;
-    maxheight = chainActive.Height();
-    if ( height < 0 || height > maxheight )
-        return false;
-    for (i=0; i<scanLimitBlocks; i++)
-    {
-        ht = height+i;
-        if ( ht > maxheight )
-            break;
-        NotarisationsInBlock notarisations;
-        uint256 blockHash = *chainActive[ht]->phashBlock;
-        if ( !GetBlockNotarisations(blockHash,notarisations) )
-            continue;
-        BOOST_FOREACH(Notarisation& nota,notarisations)
-        {
-            if ( strcmp(nota.second.symbol,symbol.data()) == 0 )
-            {
-                out = nota;
-                return(ht);
-            }
-        }
-    }
-    return 0;
-}
--- a/src/notarizationdb.h
+++ b/src/notarizationdb.h
@@ -15,15 +15,14 @@ public:
 };

 extern NotarizationDB *pnotarizations;
-typedef std::pair<uint256,NotarisationData> Notarisation;
-typedef std::vector<Notarisation> NotarisationsInBlock;
+typedef std::pair<uint256,NotarizationData> Notarization;
+typedef std::vector<Notarization> NotarizationsInBlock;

-NotarisationsInBlock ScanBlockNotarizations(const CBlock &block, int nHeight);
-bool GetBlockNotarisations(uint256 blockHash, NotarisationsInBlock &nibs);
-bool GetBackNotarisation(uint256 notarisationHash, Notarisation &n);
-void WriteBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch);
-void EraseBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch);
-int ScanNotarisationsDB(int height, std::string symbol, int scanLimitBlocks, Notarisation& out);
-int ScanNotarisationsDB2(int height, std::string symbol, int scanLimitBlocks, Notarisation& out);
+NotarizationsInBlock ScanBlockNotarizations(const CBlock &block, int nHeight);
+bool GetBlockNotarizations(uint256 blockHash, NotarizationsInBlock &nibs);
+bool GetBackNotarization(uint256 notarisationHash, Notarization &n);
+void WriteBackNotarizations(const NotarizationsInBlock notarisations, CDBBatch &batch);
+void EraseBackNotarizations(const NotarizationsInBlock notarisations, CDBBatch &batch);
+int ScanNotarizationsDB(int height, std::string symbol, int scanLimitBlocks, Notarization& out);

 #endif  /* HUSH_NOTARISATIONDB_H */
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -661,13 +661,13 @@ extern char SMART_CHAIN_SYMBOL[HUSH_SMART_CHAIN_MAXLEN];
 #define KOMODO_ELECTION_GAP 2000

 int32_t komodo_eligiblenotary(uint8_t pubkeys[66][33],int32_t *mids,uint32_t blocktimes[66],int32_t *nonzpkeysp,int32_t height);
-int32_t KOMODO_LOADINGBLOCKS = 1;
+int32_t HUSH_LOADINGBLOCKS = 1;

 extern std::string NOTARY_PUBKEY;

 bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t height, const Consensus::Params& params)
 {
-    extern int32_t KOMODO_REWIND;
+    extern int32_t HUSH_REWIND;
    uint256 hash;
    bool fNegative,fOverflow; uint8_t origpubkey33[33]; int32_t i,nonzpkeys=0,nonz=0,special=0,special2=0,notaryid=-1,flag = 0, mids[66]; uint32_t tiptime,blocktimes[66];
    arith_uint256 bnTarget; uint8_t pubkeys[66][33];
@@ -733,7 +733,7 @@ bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t
    // Check proof of work matches claimed amount
    if ( UintToArith256(hash = blkHeader.GetHash()) > bnTarget )
    {
-        if ( KOMODO_LOADINGBLOCKS != 0 )
+        if ( HUSH_LOADINGBLOCKS != 0 )
            return true;

        if ( SMART_CHAIN_SYMBOL[0] != 0 || height > 792000 )
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -179,7 +179,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
    { "assetchainproof", 1},
    { "crosschainproof", 1},
    { "getproofroot", 2},
-    { "getNotarisationsForBlock", 0},
+    { "getNotarizationsForBlock", 0},
    { "height_MoM", 1},
    { "calc_MoM", 2},
    { "migrate_completeimporttransaction", 1},
--- a/src/rpc/crosschain.cpp
+++ b/src/rpc/crosschain.cpp
@@ -143,14 +143,14 @@ UniValue MoMoMdata(const UniValue& params, bool fHelp, const CPubKey& mypk)
    ret.push_back(Pair("kmdheight",kmdheight-5));
    ret.push_back(Pair("ccid", (int) ccid));

-    uint256 destNotarisationTxid;
+    uint256 destNotarizationTxid;
    std::vector<uint256> moms;
-    uint256 MoMoM = CalculateProofRoot(symbol, ccid, kmdheight-5, moms, destNotarisationTxid);
+    uint256 MoMoM = CalculateProofRoot(symbol, ccid, kmdheight-5, moms, destNotarizationTxid);

    UniValue valMoms(UniValue::VARR);
    for (int i=0; i<moms.size(); i++) valMoms.push_back(moms[i].GetHex());
    ret.push_back(Pair("MoMs", valMoms));
-    ret.push_back(Pair("notarization_hash", destNotarisationTxid.GetHex()));
+    ret.push_back(Pair("notarization_hash", destNotarizationTxid.GetHex()));
    ret.push_back(Pair("MoMoM", MoMoM.GetHex()));
    auto vmomomdata = E_MARSHAL(ss << MoMoM; ss << ((uint32_t)0));
    ret.push_back(Pair("data", HexStr(vmomomdata)));
@@ -789,7 +789,7 @@ UniValue selfimport(const UniValue& params, bool fHelp, const CPubKey& mypk)
    return result;
 }

-bool GetNotarisationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarisationNotaries);
+bool GetNotarizationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarizationNotaries);


 UniValue importdual(const UniValue& params, bool fHelp, const CPubKey& mypk)
@@ -1121,11 +1121,11 @@ UniValue importgatewaydumpprivkey(const UniValue& params, bool fHelp, const CPub
    return(ImportGatewayDumpPrivKey(bindtxid,vchSecret));
 }

-UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
+UniValue getNotarizationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
    // TODO take timestamp as param, and loop blockindex to get starting/finish height.
    if (fHelp || params.size() != 1)
-        throw runtime_error("getNotarisationsForBlock height\n\n"
+        throw runtime_error("getNotarizationsForBlock height\n\n"
                "Takes a block height and returns notarisation information "
                "within the block");

@@ -1136,21 +1136,21 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPub
    
    uint256 blockHash = chainActive[height]->GetBlockHash(); 
    
-    NotarisationsInBlock nibs;
-    GetBlockNotarisations(blockHash, nibs);
+    NotarizationsInBlock nibs;
+    GetBlockNotarizations(blockHash, nibs);
    UniValue out(UniValue::VOBJ);
    //out.push_back(make_pair("blocktime",(int)));
    UniValue hush(UniValue::VARR);
    int8_t numNN = 0; uint8_t notarypubkeys[64][33] = {0};
    numNN = hush_notaries(notarypubkeys, height, chainActive[height]->nTime);

-    BOOST_FOREACH(const Notarisation& n, nibs)
+    BOOST_FOREACH(const Notarization& n, nibs)
    {
-        UniValue item(UniValue::VOBJ); UniValue notaryarr(UniValue::VARR); std::vector<int8_t> NotarisationNotaries;
+        UniValue item(UniValue::VOBJ); UniValue notaryarr(UniValue::VARR); std::vector<int8_t> NotarizationNotaries;
        uint256 hash; CTransaction tx;
        if ( myGetTransaction(n.first,tx,hash) )
        {
-            if ( !GetNotarisationNotaries(notarypubkeys, numNN, tx.vin, NotarisationNotaries) )
+            if ( !GetNotarizationNotaries(notarypubkeys, numNN, tx.vin, NotarizationNotaries) )
                continue;
        }
        item.push_back(make_pair("txid", n.first.GetHex()));
@@ -1159,7 +1159,7 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPub
        item.push_back(make_pair("blockhash", n.second.blockHash.GetHex()));
        //item.push_back(make_pair("HUSH_height", height)); // for when timstamp input is used.
        
-        for ( auto notary : NotarisationNotaries )
+        for ( auto notary : NotarizationNotaries )
            notaryarr.push_back(notary);
        item.push_back(make_pair("notaries",notaryarr));
        hush.push_back(item);
@@ -1168,19 +1168,19 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPub
    return out;
 }

-/*UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
+/*UniValue getNotarizationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
    if (fHelp || params.size() != 1)
-        throw runtime_error("getNotarisationsForBlock blockHash\n\n"
+        throw runtime_error("getNotarizationsForBlock blockHash\n\n"
                "Takes a block hash and returns notarisation transactions "
                "within the block");

    uint256 blockHash = uint256S(params[0].get_str());

-    NotarisationsInBlock nibs;
-    GetBlockNotarisations(blockHash, nibs);
+    NotarizationsInBlock nibs;
+    GetBlockNotarizations(blockHash, nibs);
    UniValue out(UniValue::VARR);
-    BOOST_FOREACH(const Notarisation& n, nibs)
+    BOOST_FOREACH(const Notarization& n, nibs)
    {
        UniValue item(UniValue::VARR);
        item.push_back(n.first.GetHex());
@@ -1191,10 +1191,10 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPub
 }*/


-UniValue scanNotarisationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk)
+UniValue scanNotarizationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
    if (fHelp || params.size() < 2 || params.size() > 3)
-        throw runtime_error("scanNotarisationsDB blockHeight symbol [blocksLimit=1440]\n\n"
+        throw runtime_error("scanNotarizationsDB blockHeight symbol [blocksLimit=1440]\n\n"
                "Scans notarisationsdb backwards from height for a notarisation"
                " of given symbol");
    int height = atoi(params[0].get_str().c_str());
@@ -1209,8 +1209,8 @@ UniValue scanNotarisationsDB(const UniValue& params, bool fHelp, const CPubKey&
        height = chainActive.Height();
    }

-    Notarisation nota;
-    int matchedHeight = ScanNotarisationsDB(height, symbol, limit, nota);
+    Notarization nota;
+    int matchedHeight = ScanNotarizationsDB(height, symbol, limit, nota);
    if (!matchedHeight) return NullUniValue;
    UniValue out(UniValue::VOBJ);
    out.pushKV("height", matchedHeight);
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -354,8 +354,8 @@ static const CRPCCommand vRPCCommands[] =
    { "crosschain",         "height_MoM",             &height_MoM,             true  },
    { "crosschain",         "assetchainproof",        &assetchainproof,        true  },
    { "crosschain",         "crosschainproof",        &crosschainproof,        true  },
-    { "crosschain",         "getNotarisationsForBlock", &getNotarisationsForBlock, true },
-    { "crosschain",         "scanNotarisationsDB",    &scanNotarisationsDB,    true },
+    { "crosschain",         "getNotarizationsForBlock", &getNotarizationsForBlock, true },
+    { "crosschain",         "scanNotarizationsDB",    &scanNotarizationsDB,    true },
    { "crosschain",         "getimports",             &getimports,             true },
    { "crosschain",         "getwalletburntransactions",  &getwalletburntransactions,             true },
    { "crosschain",         "migrate_converttoexport", &migrate_converttoexport, true  },
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -495,8 +495,8 @@ extern UniValue calc_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk
 extern UniValue height_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue assetchainproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue crosschainproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue scanNotarisationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getNotarizationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue scanNotarizationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue getimports(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue getwalletburntransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue migrate_converttoexport(const UniValue& params, bool fHelp, const CPubKey& mypk);
--- a/src/test-hush/test_eval_bet.cpp
+++ b/src/test-hush/test_eval_bet.cpp
@@ -123,16 +123,16 @@ public:
        return true;
    }

-    bool GetNotarisationData(uint256 notarisationHash, NotarisationData &data) const
+    bool GetNotarizationData(uint256 notarisationHash, NotarizationData &data) const
    {
-        if (notarisationHash == NotarisationHash()) {
+        if (notarisationHash == NotarizationHash()) {
            data.MoM = MoM;
            return true;
        }
        return false;
    }

-    static uint256 NotarisationHash()
+    static uint256 NotarizationHash()
    {
        uint256 h;
        h.begin()[0] = 123;
@@ -206,7 +206,7 @@ public:
        int nIndex = 5;
        std::vector<uint256> vBranch;
        vBranch.resize(3);
-        return {MerkleBranch(nIndex, vBranch), EvalMock::NotarisationHash()};
+        return {MerkleBranch(nIndex, vBranch), EvalMock::NotarizationHash()};
    }

    CMutableTransaction ImportPayoutTx()
@@ -562,7 +562,7 @@ TEST_F(TestBet, testImportPayoutMangleSessionId)
 }


-TEST_F(TestBet, testImportPayoutInvalidNotarisationHash)
+TEST_F(TestBet, testImportPayoutInvalidNotarizationHash)
 {
    EvalMock eval = ebet.SetEvalMock(12);

--- a/src/test-hush/test_eval_notarization.cpp
+++ b/src/test-hush/test_eval_notarization.cpp
@@ -21,7 +21,7 @@
 extern int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);


-namespace TestEvalNotarisation {
+namespace TestEvalNotarization {


    class EvalMock : public Eval
@@ -96,14 +96,14 @@ namespace TestEvalNotarisation {
    static auto vMomProof = ParseHex("0303faecbdd4b3da128c2cd2701bb143820a967069375b2ec5b612f39bbfe78a8611978871c193457ab1e21b9520f4139f113b8d75892eb93ee247c18bccfd067efed7eacbfcdc8946cf22de45ad536ec0719034fb9bc825048fe6ab61fee5bd6e9aae0bb279738d46673c53d68eb2a72da6dbff215ee41a4d405a74ff7cd355805b");  // $ fiat/bots txMoMproof $proofTxHash

    /*
-       TEST(TestEvalNotarisation, testGetNotarisation)
+       TEST(TestEvalNotarization, testGetNotarization)
       {
       EvalMock eval;
       CMutableTransaction notary(notaryTx);
       SetupEval(eval, notary, noop);

-       NotarisationData data;
-    ASSERT_TRUE(eval.GetNotarisationData(notary.GetHash(), data));
+       NotarizationData data;
+    ASSERT_TRUE(eval.GetNotarizationData(notary.GetHash(), data));
    EXPECT_EQ(data.height, 77455);
    EXPECT_EQ(data.blockHash.GetHex(), "000030ef29d072f417cec86ad5a5ab4f8c413c7f96f572a098e45d6e3e0f8eae");
    EXPECT_STREQ(data.symbol, "BOTS");
@@ -116,7 +116,7 @@ namespace TestEvalNotarisation {
 }


-TEST(TestEvalNotarisation, testInvalidNotaryPubkey)
+TEST(TestEvalNotarization, testInvalidNotaryPubkey)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);
@@ -124,13 +124,13 @@ TEST(TestEvalNotarisation, testInvalidNotaryPubkey)

    memset(eval.notaries[10], 0, 33);

-    NotarisationData data;
-    ASSERT_FALSE(eval.GetNotarisationData(notary.GetHash(), data));
+    NotarizationData data;
+    ASSERT_FALSE(eval.GetNotarizationData(notary.GetHash(), data));
 }
 */


-TEST(TestEvalNotarisation, testInvalidNotarisationBadOpReturn)
+TEST(TestEvalNotarization, testInvalidNotarizationBadOpReturn)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);
@@ -138,12 +138,12 @@ TEST(TestEvalNotarisation, testInvalidNotarisationBadOpReturn)
    notary.vout[1].scriptPubKey = CScript() << OP_RETURN << 0;
    SetupEval(eval, notary, noop);

-    NotarisationData data(0);
-    ASSERT_FALSE(eval.GetNotarisationData(notary.GetHash(), data));
+    NotarizationData data(0);
+    ASSERT_FALSE(eval.GetNotarizationData(notary.GetHash(), data));
 }


-TEST(TestEvalNotarisation, testInvalidNotarisationTxNotEnoughSigs)
+TEST(TestEvalNotarization, testInvalidNotarizationTxNotEnoughSigs)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);
@@ -152,24 +152,24 @@ TEST(TestEvalNotarisation, testInvalidNotarisationTxNotEnoughSigs)
        tx.vin.resize(10);
    });

-    NotarisationData data(0);
-    ASSERT_FALSE(eval.GetNotarisationData(notary.GetHash(), data));
+    NotarizationData data(0);
+    ASSERT_FALSE(eval.GetNotarizationData(notary.GetHash(), data));
 }


-TEST(TestEvalNotarisation, testInvalidNotarisationTxDoesntExist)
+TEST(TestEvalNotarization, testInvalidNotarizationTxDoesntExist)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);

    SetupEval(eval, notary, noop);

-    NotarisationData data(0);
-    ASSERT_FALSE(eval.GetNotarisationData(uint256(), data));
+    NotarizationData data(0);
+    ASSERT_FALSE(eval.GetNotarizationData(uint256(), data));
 }


-TEST(TestEvalNotarisation, testInvalidNotarisationDupeNotary)
+TEST(TestEvalNotarization, testInvalidNotarizationDupeNotary)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);
@@ -178,12 +178,12 @@ TEST(TestEvalNotarisation, testInvalidNotarisationDupeNotary)
        tx.vin[1] = tx.vin[3];
    });

-    NotarisationData data(0);
-    ASSERT_FALSE(eval.GetNotarisationData(notary.GetHash(), data));
+    NotarizationData data(0);
+    ASSERT_FALSE(eval.GetNotarizationData(notary.GetHash(), data));
 }


-TEST(TestEvalNotarisation, testInvalidNotarisationInputNotCheckSig)
+TEST(TestEvalNotarization, testInvalidNotarizationInputNotCheckSig)
 {
    EvalMock eval;
    CMutableTransaction notary(notaryTx);
@@ -197,10 +197,10 @@ TEST(TestEvalNotarisation, testInvalidNotarisationInputNotCheckSig)
        eval.txs[txIn.GetHash()] = CTransaction(txIn);
    });

-    NotarisationData data(0);
-    ASSERT_FALSE(eval.GetNotarisationData(notary.GetHash(), data));
+    NotarizationData data(0);
+    ASSERT_FALSE(eval.GetNotarizationData(notary.GetHash(), data));
 }



-} /* namespace TestEvalNotarisation */
+} /* namespace TestEvalNotarization */
--- a/src/test-hush/test_parse_notarization.cpp
+++ b/src/test-hush/test_parse_notarization.cpp
@@ -10,42 +10,42 @@
 #include "testutils.h"


-namespace TestParseNotarisation {
+namespace TestParseNotarization {

-class TestParseNotarisation : public ::testing::Test, public Eval {};
+class TestParseNotarization : public ::testing::Test, public Eval {};


-TEST(TestParseNotarisation, test_ee2fa)
+TEST(TestParseNotarization, test_ee2fa)
 {
    // ee2fa47820a31a979f9f21cb3fedbc484bf9a8957cb6c9acd0af28ced29bdfe1
    std::vector<uint8_t> opret = ParseHex("c349ff90f3bce62c1b7b49d1da0423b1a3d9b733130cce825b95b9e047c729066e020d00743a06fdb95ad5775d032b30bbb3680dac2091a0f800cf54c79fd3461ce9b31d4b4d4400");
-    NotarisationData nd;
+    NotarizationData nd;
    ASSERT_TRUE(E_UNMARSHAL(opret, ss >> nd));
 }

-TEST(TestParseNotarisation, test__)
+TEST(TestParseNotarization, test__)
 {
    // 576e910a1f704207bcbcf724124ff9adc5237f45cb6919589cd0aa152caec424
    std::vector<uint8_t> opret = ParseHex("b3ed7fbbfbc027caeeeec81e65489ec5d9cd47cda675a5cbb75b4a845e67cf0ef6330300b5a6bd8385feb833f3be961c9d8a46fcecd36dcdfa42ad81a20a892433722f0b4b4d44004125a06024eae24c11f36ea110acd707b041d5355b6e1b42de5e2614357999c6aa02000d26ad0300000000404b4c000000000005130300500d000061f22ba7d19fe29ac3baebd839af8b7127d1f90755534400");
-    NotarisationData nd;
+    NotarizationData nd;
    // We can't parse this one
    ASSERT_FALSE(E_UNMARSHAL(opret, ss >> nd));
 }

-TEST(TestParseNotarisation, test__a)
+TEST(TestParseNotarization, test__a)
 {
    // be55101e6c5a93fb3611a44bd66217ad8714d204275ea4e691cfff9d65dff85c TXSCL
    std::vector<uint8_t> opret = ParseHex("fb9ea2818eec8b07f8811bab49d64379db074db478997f8114666f239bd79803cc460000d0fac4e715b7e2b917a5d79f85ece0c423d27bd3648fd39ac1dc7db8e1bd4b16545853434c00a69eab9f23d7fb63c4624973e7a9079d6ada2f327040936356d7af5e849f6d670a0003001caf7b7b9e1c9bc59d0c7a619c9683ab1dd0794b6f3ea184a19f8fda031150e700000000");
-    NotarisationData nd(1);
+    NotarizationData nd(1);
    bool res = E_UNMARSHAL(opret, ss >> nd);
    ASSERT_TRUE(res);
 }

-TEST(TestParseNotarisation, test__b)
+TEST(TestParseNotarization, test__b)
 {
    // 03085dafed656aaebfda25bf43ffe9d1fb72565bb1fc8b2a12a631659f28f877 TXSCL
    std::vector<uint8_t> opret = ParseHex("48c71a10aa060eab1a43f52acefac3b81fb2a2ce310186b06141884c0501d403c246000052e6d49afd82d9ab3d97c996dd9b6a78a554ffa1625e8dadf0494bd1f8442e3e545853434c007cc5c07e3b67520fd14e23cd5b49f2aa022f411500fd3326ff91e6dc0544a1c90c0003008b69117bb1376ac8df960f785d8c208c599d3a36248c98728256bb6d4737e59600000000");
-    NotarisationData nd(1);
+    NotarizationData nd(1);
    bool res = E_UNMARSHAL(opret, ss >> nd);
    ASSERT_TRUE(res);
 }
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -918,7 +918,7 @@ void CWallet::DecrementNoteWitnesses(const CBlockIndex* pindex)
 {
    LOCK(cs_wallet);

-    extern int32_t KOMODO_REWIND;
+    extern int32_t HUSH_REWIND;

    for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
        //Sapling
@@ -937,7 +937,7 @@ void CWallet::DecrementNoteWitnesses(const CBlockIndex* pindex)
            }
        }
    }
-    assert(KOMODO_REWIND != 0 || WITNESS_CACHE_SIZE != _COINBASE_MATURITY+10);
+    assert(HUSH_REWIND != 0 || WITNESS_CACHE_SIZE != _COINBASE_MATURITY+10);
 }

 template<typename NoteData>