Hush Full Node software. We were censored from Github, this is where all development happens now.
https://hush.is
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
11 KiB
268 lines
11 KiB
// Copyright (c) 2016-2024 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. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#include "amount.h"
|
|
#include "chain.h"
|
|
#include "chainparams.h"
|
|
#include "checkpoints.h"
|
|
#include "crosschain.h"
|
|
#include "notarizationdb.h"
|
|
#include "importcoin.h"
|
|
#include "base58.h"
|
|
#include "consensus/validation.h"
|
|
#include "cc/eval.h"
|
|
#include "cc/utils.h"
|
|
#include "cc/CCinclude.h"
|
|
#include "main.h"
|
|
#include "primitives/transaction.h"
|
|
#include "rpc/server.h"
|
|
#include "sync.h"
|
|
#include "util.h"
|
|
#include "script/script.h"
|
|
#include "script/script_error.h"
|
|
#include "script/sign.h"
|
|
#include "script/standard.h"
|
|
#include "key_io.h"
|
|
#include <stdint.h>
|
|
#include <univalue.h>
|
|
#include <regex>
|
|
|
|
using namespace std;
|
|
|
|
#define RETURN_IF_ERROR(CCerror) if ( CCerror != "" ) { ERR_RESULT(CCerror); return(result); }
|
|
#define ERR_RESULT(x) result.push_back(Pair("result", "error")) , result.push_back(Pair("error", x));
|
|
|
|
extern std::string CCerror;
|
|
extern std::string ASSETCHAINS_SELFIMPORT;
|
|
extern uint16_t ASSETCHAINS_CODAPORT, ASSETCHAINS_BEAMPORT;
|
|
int32_t ensure_CCrequirements(uint8_t evalcode);
|
|
bool EnsureWalletIsAvailable(bool avoidException);
|
|
|
|
int32_t hush_MoM(int32_t *notarized_htp,uint256 *MoMp,uint256 *hushtxidp,int32_t nHeight,uint256 *MoMoMp,int32_t *MoMoMoffsetp,int32_t *MoMoMdepthp,int32_t *hushstartip,int32_t *hushendip);
|
|
int32_t hush_MoMoMdata(char *hexstr,int32_t hexsize,struct hush_ccdataMoMoM *mdata,char *symbol,int32_t hushheight,int32_t notarized_height);
|
|
struct hush_ccdata_entry *hush_allMoMs(int32_t *nump,uint256 *MoMoMp,int32_t hushstarti,int32_t hushendi);
|
|
uint256 hush_calcMoM(int32_t height,int32_t MoMdepth);
|
|
int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
|
|
extern std::string ASSETCHAINS_SELFIMPORT;
|
|
|
|
std::string MakeCodaImportTx(uint64_t txfee, std::string receipt, std::string srcaddr, std::vector<CTxOut> vouts);
|
|
|
|
UniValue assetchainproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
uint256 hash;
|
|
|
|
// parse params and get notarization data for tx
|
|
if ( fHelp || params.size() != 1)
|
|
throw runtime_error("assetchainproof needs a txid");
|
|
|
|
hash = uint256S(params[0].get_str());
|
|
CTransaction tx;
|
|
auto proof = GetAssetchainProof(hash,tx);
|
|
auto proofData = E_MARSHAL(ss << proof);
|
|
return HexStr(proofData);
|
|
}
|
|
|
|
|
|
UniValue crosschainproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
UniValue ret(UniValue::VOBJ);
|
|
//fprintf(stderr,"crosschainproof needs to be implemented\n");
|
|
return(ret);
|
|
}
|
|
|
|
|
|
UniValue height_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
int32_t height,depth,notarized_height,MoMoMdepth,MoMoMoffset,hushstarti,hushendi; uint256 MoM,MoMoM,hushtxid; uint32_t timestamp = 0; UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR);
|
|
if ( fHelp || params.size() != 1 )
|
|
throw runtime_error("height_MoM height\n");
|
|
LOCK(cs_main);
|
|
height = atoi(params[0].get_str().c_str());
|
|
if ( height <= 0 )
|
|
{
|
|
if ( chainActive.Tip() == 0 )
|
|
{
|
|
ret.push_back(Pair("error",(char *)"no active chain yet"));
|
|
return(ret);
|
|
}
|
|
height = chainActive.Tip()->GetHeight();
|
|
}
|
|
//fprintf(stderr,"height_MoM height.%d\n",height);
|
|
depth = hush_MoM(¬arized_height,&MoM,&hushtxid,height,&MoMoM,&MoMoMoffset,&MoMoMdepth,&hushstarti,&hushendi);
|
|
ret.push_back(Pair("coin",(char *)(SMART_CHAIN_SYMBOL[0] == 0 ? "HUSH" : SMART_CHAIN_SYMBOL)));
|
|
ret.push_back(Pair("height",height));
|
|
ret.push_back(Pair("timestamp",(uint64_t)timestamp));
|
|
if ( depth > 0 )
|
|
{
|
|
ret.push_back(Pair("depth",depth));
|
|
ret.push_back(Pair("notarized_height",notarized_height));
|
|
ret.push_back(Pair("MoM",MoM.GetHex()));
|
|
ret.push_back(Pair("hushtxid",hushtxid.GetHex()));
|
|
if ( SMART_CHAIN_SYMBOL[0] != 0 )
|
|
{
|
|
ret.push_back(Pair("MoMoM",MoMoM.GetHex()));
|
|
ret.push_back(Pair("MoMoMoffset",MoMoMoffset));
|
|
ret.push_back(Pair("MoMoMdepth",MoMoMdepth));
|
|
ret.push_back(Pair("hushstarti",hushstarti));
|
|
ret.push_back(Pair("hushendi",hushendi));
|
|
}
|
|
} else ret.push_back(Pair("error",(char *)"no MoM for height"));
|
|
|
|
return ret;
|
|
}
|
|
|
|
UniValue MoMoMdata(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if ( fHelp || params.size() != 3 )
|
|
throw runtime_error("MoMoMdata symbol hushheight ccid\n");
|
|
UniValue ret(UniValue::VOBJ);
|
|
char* symbol = (char *)params[0].get_str().c_str();
|
|
int hushheight = atoi(params[1].get_str().c_str());
|
|
uint32_t ccid = atoi(params[2].get_str().c_str());
|
|
ret.push_back(Pair("coin",symbol));
|
|
ret.push_back(Pair("hushheight",hushheight-5));
|
|
ret.push_back(Pair("ccid", (int) ccid));
|
|
|
|
uint256 destNotarizationTxid;
|
|
std::vector<uint256> moms;
|
|
uint256 MoMoM = CalculateProofRoot(symbol, ccid, hushheight-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", 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)));
|
|
return ret;
|
|
}
|
|
|
|
|
|
UniValue calc_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
int32_t height,MoMdepth; uint256 MoM; UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR);
|
|
if ( fHelp || params.size() != 2 )
|
|
throw runtime_error("calc_MoM height MoMdepth\n");
|
|
LOCK(cs_main);
|
|
height = atoi(params[0].get_str().c_str());
|
|
MoMdepth = atoi(params[1].get_str().c_str());
|
|
if ( height <= 0 || MoMdepth <= 0 || MoMdepth >= height )
|
|
throw runtime_error("calc_MoM illegal height or MoMdepth\n");
|
|
//fprintf(stderr,"height_MoM height.%d\n",height);
|
|
MoM = hush_calcMoM(height,MoMdepth);
|
|
ret.push_back(Pair("coin",(char *)(SMART_CHAIN_SYMBOL[0] == 0 ? "HUSH" : SMART_CHAIN_SYMBOL)));
|
|
ret.push_back(Pair("height",height));
|
|
ret.push_back(Pair("MoMdepth",MoMdepth));
|
|
ret.push_back(Pair("MoM",MoM.GetHex()));
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
* The process to migrate funds from a chain to chain
|
|
*
|
|
* 1.Create a transaction on assetchain (deprecated):
|
|
* 1.1 generaterawtransaction
|
|
* 1.2 migrate_converttoexport
|
|
* 1.3 fundrawtransaction
|
|
* 1.4 signrawtransaction
|
|
*
|
|
* alternatively, burn (export) transaction may be created with this new rpc call:
|
|
* 1. migrate_createburntransaction
|
|
*
|
|
* next steps:
|
|
* 2. migrate_createimporttransaction
|
|
* 3. migrate_completeimporttransaction
|
|
*/
|
|
|
|
bool GetNotarizationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarizationNotaries);
|
|
|
|
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("getNotarizationsForBlock height\n\n"
|
|
"Takes a block height and returns notarization information "
|
|
"within the block");
|
|
|
|
LOCK(cs_main);
|
|
int32_t height = params[0].get_int();
|
|
if ( height < 0 || height > chainActive.Height() )
|
|
throw runtime_error("height out of range.\n");
|
|
|
|
uint256 blockHash = chainActive[height]->GetBlockHash();
|
|
|
|
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 Notarization& n, nibs)
|
|
{
|
|
UniValue item(UniValue::VOBJ); UniValue notaryarr(UniValue::VARR); std::vector<int8_t> NotarizationNotaries;
|
|
uint256 hash; CTransaction tx;
|
|
if ( myGetTransaction(n.first,tx,hash) )
|
|
{
|
|
if ( !GetNotarizationNotaries(notarypubkeys, numNN, tx.vin, NotarizationNotaries) )
|
|
continue;
|
|
}
|
|
item.push_back(make_pair("txid", n.first.GetHex()));
|
|
item.push_back(make_pair("chain", n.second.symbol));
|
|
item.push_back(make_pair("height", (int)n.second.height));
|
|
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 : NotarizationNotaries )
|
|
notaryarr.push_back(notary);
|
|
item.push_back(make_pair("notaries",notaryarr));
|
|
hush.push_back(item);
|
|
}
|
|
out.push_back(make_pair("HUSH", hush));
|
|
return out;
|
|
}
|
|
|
|
UniValue scanNotarizationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() < 2 || params.size() > 3)
|
|
throw runtime_error("scanNotarizationsDB blockHeight symbol [blocksLimit=1440]\n\n"
|
|
"Scans notarizationsdb backwards from height for a notarization"
|
|
" of given symbol");
|
|
int height = atoi(params[0].get_str().c_str());
|
|
std::string symbol = params[1].get_str().c_str();
|
|
|
|
int limit = 1440;
|
|
if (params.size() > 2) {
|
|
limit = atoi(params[2].get_str().c_str());
|
|
}
|
|
|
|
if (height == 0) {
|
|
height = chainActive.Height();
|
|
}
|
|
|
|
Notarization nota;
|
|
int matchedHeight = ScanNotarizationsDB(height, symbol, limit, nota);
|
|
if (!matchedHeight) return NullUniValue;
|
|
UniValue out(UniValue::VOBJ);
|
|
out.pushKV("height", matchedHeight);
|
|
out.pushKV("hash", nota.first.GetHex());
|
|
out.pushKV("opreturn", HexStr(E_MARSHAL(ss << nota.second)));
|
|
return out;
|
|
}
|
|
|