hush
/
hush3
9
0
Fork 11
Code Issues 143 Pull Requests 2 Projects Releases 16 Wiki Activity
Browse Source

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
pull/5/head
Duke Leto 4 years ago
parent
710559576c
commit
6a30b40415
30 changed files with 346 additions and 458 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 24
      src/cc/CCutils.cpp
  2. 4
      src/cc/betprotocol.cpp
  3. 25
      src/cc/cclib.cpp
  4. 8
      src/cc/eval.cpp
  5. 20
      src/cc/eval.h
  6. 4
      src/cc/importpayout.cpp
  7. 78
      src/crosschain.cpp
  8. 4
      src/crosschain.h
  9. 16
      src/hush.h
  10. 2
      src/hush_defs.h
  11. 18
      src/hush_globals.h
  12. 2
      src/hush_notary.h
  13. 12
      src/hush_utils.h
  14. 16
      src/init.cpp
  15. 44
      src/komodo_bitcoind.h
  16. 41
      src/komodo_events.h
  17. 4
      src/komodo_nSPV_fullnode.h
  18. 195
      src/main.cpp
  19. 40
      src/miner.cpp
  20. 92
      src/notarizationdb.cpp
  21. 17
      src/notarizationdb.h
  22. 6
      src/pow.cpp
  23. 2
      src/rpc/client.cpp
  24. 42
      src/rpc/crosschain.cpp
  25. 4
      src/rpc/server.cpp
  26. 4
      src/rpc/server.h
  27. 10
      src/test-hush/test_eval_bet.cpp
  28. 46
      src/test-hush/test_eval_notarization.cpp
  29. 20
      src/test-hush/test_parse_notarization.cpp
  30. 4
      src/wallet/wallet.cpp

24
src/cc/CCutils.cpp
View File

@ -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);

4
src/cc/betprotocol.cpp
View File

@ -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()))

25
src/cc/cclib.cpp
View File

@ -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 )
{

8
src/cc/eval.cpp
View File

@ -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;

20
src/cc/eval.h
View File

@ -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);
/*

4
src/cc/importpayout.cpp
View File

@ -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()))

78
src/crosschain.cpp
View File

@ -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

4
src/crosschain.h
View File

@ -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 */

16
src/hush.h
View File

@ -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 )
{

2
src/hush_defs.h
View File

@ -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];

18
src/hush_globals.h
View File

@ -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);

2
src/hush_notary.h
View File

@ -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 )
{

12
src/hush_utils.h
View File

@ -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)

16
src/init.cpp
View File

@ -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"))

44
src/komodo_bitcoind.h
View File

@ -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);

41
src/komodo_events.h
View File

@ -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

4
src/komodo_nSPV_fullnode.h
View File

@ -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 )

195
src/main.cpp
View File

@ -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));
}
}
}

40
src/miner.cpp
View File

@ -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");

92
src/notarizationdb.cpp
View File

@ -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;
}

17
src/notarizationdb.h
View File

@ -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 */

6
src/pow.cpp
View File

@ -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 )

2
src/rpc/client.cpp
View File

@ -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},

42
src/rpc/crosschain.cpp
View File

@ -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);

4
src/rpc/server.cpp
View File

@ -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 },

4
src/rpc/server.h
View File

@ -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);

10
src/test-hush/test_eval_bet.cpp
View File

@ -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);

46
src/test-hush/test_eval_notarisation.cpp → src/test-hush/test_eval_notarization.cpp
View File

@ -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 */

20
src/test-hush/test_parse_notarisation.cpp → src/test-hush/test_parse_notarization.cpp
View File

@ -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);
}

4
src/wallet/wallet.cpp
View File

@ -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>

Write Preview
Loading…
Cancel
Save