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.
1305 lines
58 KiB
1305 lines
58 KiB
// Copyright (c) 2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2015 The Bitcoin Core developers
|
|
// Copyright (c) 2016-2022 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 "consensus/upgrades.h"
|
|
#include "consensus/validation.h"
|
|
#include "core_io.h"
|
|
#include "init.h"
|
|
#include "deprecation.h"
|
|
#include "key_io.h"
|
|
#include "keystore.h"
|
|
#include "main.h"
|
|
#include "merkleblock.h"
|
|
#include "net.h"
|
|
#include "primitives/transaction.h"
|
|
#include "rpc/server.h"
|
|
#include "script/script.h"
|
|
#include "script/script_error.h"
|
|
#include "script/sign.h"
|
|
#include "script/standard.h"
|
|
#include "uint256.h"
|
|
#include "importcoin.h"
|
|
#ifdef ENABLE_WALLET
|
|
#include "wallet/wallet.h"
|
|
#endif
|
|
|
|
#include "hush_defs.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
|
|
#include <boost/assign/list_of.hpp>
|
|
#include <boost/thread.hpp>
|
|
|
|
#include <univalue.h>
|
|
|
|
int32_t hush_notarized_height(int32_t *prevMoMheightp,uint256 *hashp,uint256 *txidp);
|
|
|
|
using namespace std;
|
|
|
|
extern char SMART_CHAIN_SYMBOL[];
|
|
int32_t hush_dpowconfs(int32_t height,int32_t numconfs);
|
|
|
|
void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex)
|
|
{
|
|
txnouttype type;
|
|
vector<CTxDestination> addresses;
|
|
int nRequired;
|
|
|
|
out.push_back(Pair("asm", ScriptToAsmStr(scriptPubKey)));
|
|
if (fIncludeHex)
|
|
out.push_back(Pair("hex", HexStr(scriptPubKey.begin(), scriptPubKey.end())));
|
|
|
|
if (!ExtractDestinations(scriptPubKey, type, addresses, nRequired))
|
|
{
|
|
out.push_back(Pair("type", GetTxnOutputType(type)));
|
|
return;
|
|
}
|
|
|
|
out.push_back(Pair("reqSigs", nRequired));
|
|
out.push_back(Pair("type", GetTxnOutputType(type)));
|
|
|
|
UniValue a(UniValue::VARR);
|
|
for (const CTxDestination& addr : addresses) {
|
|
a.push_back(EncodeDestination(addr));
|
|
}
|
|
out.push_back(Pair("addresses", a));
|
|
}
|
|
|
|
UniValue TxShieldedSpendsToJSON(const CTransaction& tx) {
|
|
UniValue vdesc(UniValue::VARR);
|
|
for (const SpendDescription& spendDesc : tx.vShieldedSpend) {
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("cv", spendDesc.cv.GetHex()));
|
|
obj.push_back(Pair("anchor", spendDesc.anchor.GetHex()));
|
|
obj.push_back(Pair("nullifier", spendDesc.nullifier.GetHex()));
|
|
obj.push_back(Pair("rk", spendDesc.rk.GetHex()));
|
|
obj.push_back(Pair("proof", HexStr(spendDesc.zkproof.begin(), spendDesc.zkproof.end())));
|
|
obj.push_back(Pair("spendAuthSig", HexStr(spendDesc.spendAuthSig.begin(), spendDesc.spendAuthSig.end())));
|
|
vdesc.push_back(obj);
|
|
}
|
|
return vdesc;
|
|
}
|
|
|
|
UniValue TxShieldedOutputsToJSON(const CTransaction& tx) {
|
|
UniValue vdesc(UniValue::VARR);
|
|
for (const OutputDescription& outputDesc : tx.vShieldedOutput) {
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("cv", outputDesc.cv.GetHex()));
|
|
obj.push_back(Pair("cmu", outputDesc.cm.GetHex()));
|
|
obj.push_back(Pair("ephemeralKey", outputDesc.ephemeralKey.GetHex()));
|
|
obj.push_back(Pair("encCiphertext", HexStr(outputDesc.encCiphertext.begin(), outputDesc.encCiphertext.end())));
|
|
obj.push_back(Pair("outCiphertext", HexStr(outputDesc.outCiphertext.begin(), outputDesc.outCiphertext.end())));
|
|
obj.push_back(Pair("proof", HexStr(outputDesc.zkproof.begin(), outputDesc.zkproof.end())));
|
|
vdesc.push_back(obj);
|
|
}
|
|
return vdesc;
|
|
}
|
|
|
|
int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout)
|
|
{
|
|
CSpentIndexValue spentInfo; CSpentIndexKey spentKey(txid,vout);
|
|
if ( GetSpentIndex(spentKey,spentInfo) )
|
|
{
|
|
spenttxid = spentInfo.txid;
|
|
return((int32_t)spentInfo.inputIndex);
|
|
// out.push_back(Pair("spentHeight", spentInfo.blockHeight));
|
|
}
|
|
memset(&spenttxid,0,sizeof(spenttxid));
|
|
return(-1);
|
|
}
|
|
|
|
void TxToJSONExpanded(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, int nHeight = 0, int nConfirmations = 0, int nBlockTime = 0)
|
|
{
|
|
uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height;
|
|
notarized_height = hush_notarized_height(&prevMoMheight,¬arized_hash,¬arized_desttxid);
|
|
uint256 txid = tx.GetHash();
|
|
entry.push_back(Pair("txid", txid.GetHex()));
|
|
entry.push_back(Pair("overwintered", tx.fOverwintered));
|
|
entry.push_back(Pair("version", tx.nVersion));
|
|
entry.push_back(Pair("last_notarized_height", notarized_height));
|
|
if (tx.fOverwintered) {
|
|
entry.push_back(Pair("versiongroupid", HexInt(tx.nVersionGroupId)));
|
|
}
|
|
entry.push_back(Pair("locktime", (int64_t)tx.nLockTime));
|
|
if (tx.fOverwintered) {
|
|
entry.push_back(Pair("expiryheight", (int64_t)tx.nExpiryHeight));
|
|
}
|
|
UniValue vin(UniValue::VARR);
|
|
BOOST_FOREACH(const CTxIn& txin, tx.vin) {
|
|
UniValue in(UniValue::VOBJ);
|
|
if (tx.IsCoinBase())
|
|
in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
|
|
else if (tx.IsCoinImport() && txin.prevout.n==10e8) {
|
|
in.push_back(Pair("is_import", "1"));
|
|
ImportProof proof; CTransaction burnTx; std::vector<CTxOut> payouts; CTxDestination importaddress;
|
|
if (UnmarshalImportTx(tx, proof, burnTx, payouts))
|
|
{
|
|
if (burnTx.vout.size() == 0)
|
|
continue;
|
|
in.push_back(Pair("txid", burnTx.GetHash().ToString()));
|
|
in.push_back(Pair("value", ValueFromAmount(burnTx.vout.back().nValue)));
|
|
in.push_back(Pair("valueSat", burnTx.vout.back().nValue));
|
|
// extract op_return to get burn source chain.
|
|
std::vector<uint8_t> burnOpret; std::string targetSymbol; uint32_t targetCCid; uint256 payoutsHash; std::vector<uint8_t>rawproof;
|
|
if (UnmarshalBurnTx(burnTx, targetSymbol, &targetCCid, payoutsHash, rawproof))
|
|
{
|
|
if (rawproof.size() > 0)
|
|
{
|
|
std::string sourceSymbol;
|
|
E_UNMARSHAL(rawproof, ss >> sourceSymbol);
|
|
in.push_back(Pair("address", "IMP-" + sourceSymbol + "-" + burnTx.GetHash().ToString()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
in.push_back(Pair("txid", txin.prevout.hash.GetHex()));
|
|
in.push_back(Pair("vout", (int64_t)txin.prevout.n));
|
|
{
|
|
uint256 hash; CTransaction tx; CTxDestination address;
|
|
if (GetTransaction(txin.prevout.hash,tx,hash,false))
|
|
{
|
|
if (ExtractDestination(tx.vout[txin.prevout.n].scriptPubKey, address))
|
|
in.push_back(Pair("address", CBitcoinAddress(address).ToString()));
|
|
}
|
|
}
|
|
UniValue o(UniValue::VOBJ);
|
|
o.push_back(Pair("asm", ScriptToAsmStr(txin.scriptSig, true)));
|
|
o.push_back(Pair("hex", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
|
|
in.push_back(Pair("scriptSig", o));
|
|
|
|
// Add address and value info if spentindex enabled
|
|
CSpentIndexValue spentInfo;
|
|
CSpentIndexKey spentKey(txin.prevout.hash, txin.prevout.n);
|
|
if (GetSpentIndex(spentKey, spentInfo)) {
|
|
in.push_back(Pair("value", ValueFromAmount(spentInfo.satoshis)));
|
|
in.push_back(Pair("valueSat", spentInfo.satoshis));
|
|
if (spentInfo.addressType == 1) {
|
|
in.push_back(Pair("address", CBitcoinAddress(CKeyID(spentInfo.addressHash)).ToString()));
|
|
}
|
|
else if (spentInfo.addressType == 2) {
|
|
in.push_back(Pair("address", CBitcoinAddress(CScriptID(spentInfo.addressHash)).ToString()));
|
|
}
|
|
}
|
|
}
|
|
in.push_back(Pair("sequence", (int64_t)txin.nSequence));
|
|
vin.push_back(in);
|
|
}
|
|
entry.push_back(Pair("vin", vin));
|
|
BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
|
|
CBlockIndex *tipindex,*pindex = it->second;
|
|
uint64_t interest;
|
|
UniValue vout(UniValue::VARR);
|
|
for (unsigned int i = 0; i < tx.vout.size(); i++)
|
|
{
|
|
const CTxOut& txout = tx.vout[i];
|
|
UniValue out(UniValue::VOBJ);
|
|
out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
|
|
out.push_back(Pair("valueSat", txout.nValue));
|
|
out.push_back(Pair("n", (int64_t)i));
|
|
UniValue o(UniValue::VOBJ);
|
|
ScriptPubKeyToJSON(txout.scriptPubKey, o, true);
|
|
if (txout.scriptPubKey.IsOpReturn() && txout.nValue != 0)
|
|
{
|
|
std::vector<uint8_t> burnOpret; std::string targetSymbol; uint32_t targetCCid; uint256 payoutsHash; std::vector<uint8_t>rawproof;
|
|
if (UnmarshalBurnTx(tx, targetSymbol, &targetCCid, payoutsHash, rawproof))
|
|
{
|
|
out.push_back(Pair("target", "EXPORT->" + targetSymbol));
|
|
}
|
|
}
|
|
out.push_back(Pair("scriptPubKey", o));
|
|
|
|
// Add spent information if spentindex is enabled
|
|
CSpentIndexValue spentInfo;
|
|
CSpentIndexKey spentKey(txid, i);
|
|
if (GetSpentIndex(spentKey, spentInfo)) {
|
|
out.push_back(Pair("spentTxId", spentInfo.txid.GetHex()));
|
|
out.push_back(Pair("spentIndex", (int)spentInfo.inputIndex));
|
|
out.push_back(Pair("spentHeight", spentInfo.blockHeight));
|
|
}
|
|
|
|
vout.push_back(out);
|
|
}
|
|
entry.push_back(Pair("vout", vout));
|
|
|
|
if (tx.fOverwintered && tx.nVersion >= SAPLING_TX_VERSION) {
|
|
entry.push_back(Pair("valueBalance", ValueFromAmount(tx.valueBalance)));
|
|
UniValue vspenddesc = TxShieldedSpendsToJSON(tx);
|
|
entry.push_back(Pair("vShieldedSpend", vspenddesc));
|
|
UniValue voutputdesc = TxShieldedOutputsToJSON(tx);
|
|
entry.push_back(Pair("vShieldedOutput", voutputdesc));
|
|
if (!(vspenddesc.empty() && voutputdesc.empty())) {
|
|
entry.push_back(Pair("bindingSig", HexStr(tx.bindingSig.begin(), tx.bindingSig.end())));
|
|
}
|
|
}
|
|
|
|
if (!hashBlock.IsNull()) {
|
|
entry.push_back(Pair("blockhash", hashBlock.GetHex()));
|
|
|
|
if (nConfirmations > 0) {
|
|
entry.push_back(Pair("height", nHeight));
|
|
entry.push_back(Pair("confirmations", hush_dpowconfs(nHeight,nConfirmations)));
|
|
entry.push_back(Pair("rawconfirmations", nConfirmations));
|
|
entry.push_back(Pair("time", nBlockTime));
|
|
entry.push_back(Pair("blocktime", nBlockTime));
|
|
} else {
|
|
entry.push_back(Pair("height", -1));
|
|
entry.push_back(Pair("confirmations", 0));
|
|
entry.push_back(Pair("rawconfirmations", 0));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
|
|
{
|
|
entry.push_back(Pair("txid", tx.GetHash().GetHex()));
|
|
entry.push_back(Pair("overwintered", tx.fOverwintered));
|
|
entry.push_back(Pair("version", tx.nVersion));
|
|
if (tx.fOverwintered) {
|
|
entry.push_back(Pair("versiongroupid", HexInt(tx.nVersionGroupId)));
|
|
}
|
|
entry.push_back(Pair("locktime", (int64_t)tx.nLockTime));
|
|
if (tx.fOverwintered) {
|
|
entry.push_back(Pair("expiryheight", (int64_t)tx.nExpiryHeight));
|
|
}
|
|
UniValue vin(UniValue::VARR);
|
|
BOOST_FOREACH(const CTxIn& txin, tx.vin) {
|
|
UniValue in(UniValue::VOBJ);
|
|
if (tx.IsCoinBase())
|
|
in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
|
|
else {
|
|
in.push_back(Pair("txid", txin.prevout.hash.GetHex()));
|
|
in.push_back(Pair("vout", (int64_t)txin.prevout.n));
|
|
UniValue o(UniValue::VOBJ);
|
|
o.push_back(Pair("asm", ScriptToAsmStr(txin.scriptSig, true)));
|
|
o.push_back(Pair("hex", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
|
|
in.push_back(Pair("scriptSig", o));
|
|
}
|
|
in.push_back(Pair("sequence", (int64_t)txin.nSequence));
|
|
vin.push_back(in);
|
|
}
|
|
entry.push_back(Pair("vin", vin));
|
|
UniValue vout(UniValue::VARR);
|
|
BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
|
|
CBlockIndex *tipindex;//,*pindex = it->second;
|
|
uint64_t interest;
|
|
for (unsigned int i = 0; i < tx.vout.size(); i++) {
|
|
const CTxOut& txout = tx.vout[i];
|
|
UniValue out(UniValue::VOBJ);
|
|
out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
|
|
out.push_back(Pair("valueZat", txout.nValue));
|
|
out.push_back(Pair("n", (int64_t)i));
|
|
UniValue o(UniValue::VOBJ);
|
|
ScriptPubKeyToJSON(txout.scriptPubKey, o, true);
|
|
out.push_back(Pair("scriptPubKey", o));
|
|
vout.push_back(out);
|
|
}
|
|
entry.push_back(Pair("vout", vout));
|
|
|
|
if (tx.fOverwintered && tx.nVersion >= SAPLING_TX_VERSION) {
|
|
entry.push_back(Pair("valueBalance", ValueFromAmount(tx.valueBalance)));
|
|
UniValue vspenddesc = TxShieldedSpendsToJSON(tx);
|
|
entry.push_back(Pair("vShieldedSpend", vspenddesc));
|
|
UniValue voutputdesc = TxShieldedOutputsToJSON(tx);
|
|
entry.push_back(Pair("vShieldedOutput", voutputdesc));
|
|
if (!(vspenddesc.empty() && voutputdesc.empty())) {
|
|
entry.push_back(Pair("bindingSig", HexStr(tx.bindingSig.begin(), tx.bindingSig.end())));
|
|
}
|
|
}
|
|
|
|
if (!hashBlock.IsNull()) {
|
|
entry.push_back(Pair("blockhash", hashBlock.GetHex()));
|
|
BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
|
|
if (mi != mapBlockIndex.end() && (*mi).second) {
|
|
CBlockIndex* pindex = (*mi).second;
|
|
if (chainActive.Contains(pindex)) {
|
|
entry.push_back(Pair("height", pindex->GetHeight()));
|
|
entry.push_back(Pair("rawconfirmations", 1 + chainActive.Height() - pindex->GetHeight()));
|
|
entry.push_back(Pair("confirmations", hush_dpowconfs(pindex->GetHeight(),1 + chainActive.Height() - pindex->GetHeight())));
|
|
entry.push_back(Pair("time", pindex->GetBlockTime()));
|
|
entry.push_back(Pair("blocktime", pindex->GetBlockTime()));
|
|
} else {
|
|
entry.push_back(Pair("confirmations", 0));
|
|
entry.push_back(Pair("rawconfirmations", 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UniValue getrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getrawtransaction \"txid\" ( verbose )\n"
|
|
"\nNOTE: By default this function only works sometimes. This is when the tx is in the mempool\n"
|
|
"or there is an unspent output in the utxo for this transaction. To make it always work,\n"
|
|
"you need to maintain a transaction index, using the -txindex command line option.\n"
|
|
"\nReturn the raw transaction data. Also see z_viewtransaction for ztx details.\n"
|
|
"\nIf verbose=0, returns a string that is serialized, hex-encoded data for 'txid'.\n"
|
|
"If verbose is non-zero, returns an Object with information about 'txid'.\n"
|
|
|
|
"\nArguments:\n"
|
|
"1. \"txid\" (string, required) The transaction id\n"
|
|
"2. verbose (numeric, optional, default=0) If 0, return a string, other return a json object\n"
|
|
|
|
"\nResult (if verbose is not set or set to 0):\n"
|
|
"\"data\" (string) The serialized, hex-encoded data for 'txid'\n"
|
|
|
|
"\nResult (if verbose > 0):\n"
|
|
"{\n"
|
|
" \"hex\" : \"data\", (string) The serialized, hex-encoded data for 'txid'\n"
|
|
" \"size\" : n, (numeric) The length in bytes\n"
|
|
" \"txid\" : \"id\", (string) The transaction id (same as provided)\n"
|
|
" \"version\" : n, (numeric) The version\n"
|
|
" \"locktime\" : ttt, (numeric) The lock time\n"
|
|
" \"expiryheight\" : ttt, (numeric, optional) The block height after which the transaction expires\n"
|
|
" \"vin\" : [ (array of json objects)\n"
|
|
" {\n"
|
|
" \"txid\": \"id\", (string) The transaction id\n"
|
|
" \"vout\": n, (numeric) \n"
|
|
" \"scriptSig\": { (json object) The script\n"
|
|
" \"asm\": \"asm\", (string) asm\n"
|
|
" \"hex\": \"hex\" (string) hex\n"
|
|
" },\n"
|
|
" \"sequence\": n (numeric) The script sequence number\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
" \"vout\" : [ (array of json objects)\n"
|
|
" {\n"
|
|
" \"value\" : x.xxx, (numeric) The value in " + CURRENCY_UNIT + "\n"
|
|
" \"n\" : n, (numeric) index\n"
|
|
" \"scriptPubKey\" : { (json object)\n"
|
|
" \"asm\" : \"asm\", (string) the asm\n"
|
|
" \"hex\" : \"hex\", (string) the hex\n"
|
|
" \"reqSigs\" : n, (numeric) The required sigs\n"
|
|
" \"type\" : \"pubkeyhash\", (string) The type, eg 'pubkeyhash'\n"
|
|
" \"addresses\" : [ (json array of string)\n"
|
|
" \"hushaddress\" (string) Hush address\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
" }\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
" \"blockhash\" : \"hash\", (string) the block hash\n"
|
|
" \"confirmations\" : n, (numeric) The number of notarized DPoW confirmations\n"
|
|
" \"rawconfirmations\" : n, (numeric) The number of raw confirmations\n"
|
|
" \"time\" : ttt, (numeric) The transaction time in seconds since epoch (Jan 1 1970 GMT)\n"
|
|
" \"blocktime\" : ttt (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"
|
|
"}\n"
|
|
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getrawtransaction", "\"mytxid\"")
|
|
+ HelpExampleCli("getrawtransaction", "\"mytxid\" 1")
|
|
+ HelpExampleRpc("getrawtransaction", "\"mytxid\", 1")
|
|
);
|
|
|
|
|
|
uint256 hash = ParseHashV(params[0], "parameter 1");
|
|
|
|
bool fVerbose = false;
|
|
if (params.size() > 1)
|
|
fVerbose = (params[1].get_int() != 0);
|
|
|
|
CTransaction tx;
|
|
uint256 hashBlock;
|
|
int nHeight = 0;
|
|
int nConfirmations = 0;
|
|
int nBlockTime = 0;
|
|
|
|
{
|
|
LOCK(cs_main);
|
|
if (!GetTransaction(hash, tx, hashBlock, true))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");
|
|
|
|
BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
|
|
if (mi != mapBlockIndex.end() && (*mi).second) {
|
|
CBlockIndex* pindex = (*mi).second;
|
|
if (chainActive.Contains(pindex)) {
|
|
nHeight = pindex->GetHeight();
|
|
nConfirmations = 1 + chainActive.Height() - pindex->GetHeight();
|
|
nBlockTime = pindex->GetBlockTime();
|
|
} else {
|
|
nHeight = -1;
|
|
nConfirmations = 0;
|
|
nBlockTime = pindex->GetBlockTime();
|
|
}
|
|
}
|
|
}
|
|
|
|
string strHex = EncodeHexTx(tx);
|
|
|
|
if (!fVerbose)
|
|
return strHex;
|
|
|
|
UniValue result(UniValue::VOBJ);
|
|
int serializeSize = GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
|
|
|
|
result.push_back(Pair("hex", strHex));
|
|
result.push_back(Pair("size", serializeSize));
|
|
TxToJSONExpanded(tx, hashBlock, result, nHeight, nConfirmations, nBlockTime);
|
|
return result;
|
|
}
|
|
|
|
int32_t gettxout_scriptPubKey(uint8_t *scriptPubKey,int32_t maxsize,uint256 txid,int32_t n)
|
|
{
|
|
int32_t i,m; uint8_t *ptr;
|
|
LOCK(cs_main);
|
|
/*CCoins coins;
|
|
for (iter=0; iter<2; iter++)
|
|
{
|
|
if ( iter == 0 )
|
|
{
|
|
LOCK(mempool.cs);
|
|
CCoinsViewMemPool view(pcoinsTip,mempool);
|
|
if ( view.GetCoins(txid,coins) == 0 )
|
|
{
|
|
//fprintf(stderr,"cant get view\n");
|
|
continue;
|
|
}
|
|
mempool.pruneSpent(txid, coins); // TODO: this should be done by the CCoinsViewMemPool
|
|
}
|
|
else if ( pcoinsTip->GetCoins(txid,coins) == 0 )
|
|
{
|
|
//fprintf(stderr,"cant get pcoinsTip->GetCoins\n");
|
|
continue;
|
|
}
|
|
if ( n < 0 || (unsigned int)n >= coins.vout.size() || coins.vout[n].IsNull() )
|
|
{
|
|
fprintf(stderr,"iter.%d n.%d vs voutsize.%d\n",iter,n,(int32_t)coins.vout.size());
|
|
continue;
|
|
}
|
|
ptr = (uint8_t *)coins.vout[n].scriptPubKey.data();
|
|
m = coins.vout[n].scriptPubKey.size();
|
|
for (i=0; i<maxsize&&i<m; i++)
|
|
scriptPubKey[i] = ptr[i];
|
|
return(i);
|
|
}*/
|
|
CTransaction tx;
|
|
uint256 hashBlock;
|
|
if ( GetTransaction(txid,tx,hashBlock,false) == 0 )
|
|
return(-1);
|
|
else if ( n < tx.vout.size() )
|
|
{
|
|
ptr = (uint8_t *)&tx.vout[n].scriptPubKey[0];
|
|
m = tx.vout[n].scriptPubKey.size();
|
|
for (i=0; i<maxsize&&i<m; i++)
|
|
scriptPubKey[i] = ptr[i];
|
|
//fprintf(stderr,"got scriptPubKey via rawtransaction\n");
|
|
return(i);
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
UniValue gettxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || (params.size() != 1 && params.size() != 2))
|
|
throw runtime_error(
|
|
"gettxoutproof [\"txid\",...] ( blockhash )\n"
|
|
"\nReturns a hex-encoded proof that \"txid\" was included in a block.\n"
|
|
"\nNOTE: By default this function only works sometimes. This is when there is an\n"
|
|
"unspent output in the utxo for this transaction. To make it always work,\n"
|
|
"you need to maintain a transaction index, using the -txindex command line option or\n"
|
|
"specify the block in which the transaction is included in manually (by blockhash).\n"
|
|
"\nReturn the raw transaction data.\n"
|
|
"\nArguments:\n"
|
|
"1. \"txids\" (string) A json array of txids to filter\n"
|
|
" [\n"
|
|
" \"txid\" (string) A transaction hash\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
"2. \"block hash\" (string, optional) If specified, looks for txid in the block with this hash\n"
|
|
"\nResult:\n"
|
|
"\"data\" (string) A string that is a serialized, hex-encoded data for the proof.\n"
|
|
);
|
|
|
|
set<uint256> setTxids;
|
|
uint256 oneTxid;
|
|
UniValue txids = params[0].get_array();
|
|
for (size_t idx = 0; idx < txids.size(); idx++) {
|
|
const UniValue& txid = txids[idx];
|
|
if (txid.get_str().length() != 64 || !IsHex(txid.get_str()))
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid txid ")+txid.get_str());
|
|
uint256 hash(uint256S(txid.get_str()));
|
|
if (setTxids.count(hash))
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated txid: ")+txid.get_str());
|
|
setTxids.insert(hash);
|
|
oneTxid = hash;
|
|
}
|
|
|
|
LOCK(cs_main);
|
|
|
|
CBlockIndex* pblockindex = NULL;
|
|
|
|
uint256 hashBlock;
|
|
if (params.size() > 1)
|
|
{
|
|
hashBlock = uint256S(params[1].get_str());
|
|
if (!mapBlockIndex.count(hashBlock))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
|
pblockindex = mapBlockIndex[hashBlock];
|
|
} else {
|
|
CCoins coins;
|
|
if (pcoinsTip->GetCoins(oneTxid, coins) && coins.nHeight > 0 && coins.nHeight <= chainActive.Height())
|
|
pblockindex = chainActive[coins.nHeight];
|
|
}
|
|
|
|
if (pblockindex == NULL)
|
|
{
|
|
CTransaction tx;
|
|
if (!GetTransaction(oneTxid, tx, hashBlock, false) || hashBlock.IsNull())
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not yet in block");
|
|
if (!mapBlockIndex.count(hashBlock))
|
|
throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
|
|
pblockindex = mapBlockIndex[hashBlock];
|
|
}
|
|
|
|
CBlock block;
|
|
if(!ReadBlockFromDisk(block, pblockindex,1))
|
|
throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
|
|
|
|
unsigned int ntxFound = 0;
|
|
BOOST_FOREACH(const CTransaction&tx, block.vtx)
|
|
if (setTxids.count(tx.GetHash()))
|
|
ntxFound++;
|
|
if (ntxFound != setTxids.size())
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "(Not all) transactions not found in specified block");
|
|
|
|
CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
|
|
CMerkleBlock mb(block, setTxids);
|
|
ssMB << mb;
|
|
std::string strHex = HexStr(ssMB.begin(), ssMB.end());
|
|
return strHex;
|
|
}
|
|
|
|
UniValue verifytxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"verifytxoutproof \"proof\"\n"
|
|
"\nVerifies that a proof points to a transaction in a block, returning the transaction it commits to\n"
|
|
"and throwing an RPC error if the block is not in our best chain\n"
|
|
"\nArguments:\n"
|
|
"1. \"proof\" (string, required) The hex-encoded proof generated by gettxoutproof\n"
|
|
"\nResult:\n"
|
|
"[\"txid\"] (array, strings) The txid(s) which the proof commits to, or empty array if the proof is invalid\n"
|
|
);
|
|
|
|
CDataStream ssMB(ParseHexV(params[0], "proof"), SER_NETWORK, PROTOCOL_VERSION);
|
|
CMerkleBlock merkleBlock;
|
|
ssMB >> merkleBlock;
|
|
|
|
UniValue res(UniValue::VARR);
|
|
|
|
vector<uint256> vMatch;
|
|
if (merkleBlock.txn.ExtractMatches(vMatch) != merkleBlock.header.hashMerkleRoot)
|
|
return res;
|
|
|
|
LOCK(cs_main);
|
|
uint256 idx = merkleBlock.header.GetHash();
|
|
if (!mapBlockIndex.count(merkleBlock.header.GetHash()) || (mapBlockIndex.count(idx) && !chainActive.Contains(mapBlockIndex[idx])))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");
|
|
|
|
BOOST_FOREACH(const uint256& hash, vMatch)
|
|
res.push_back(hash.GetHex());
|
|
return res;
|
|
}
|
|
|
|
UniValue createrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
string examplescriptPubKey = "21021ce1eac70455c3e6c52d67c133549b8aed4a588fba594372e8048e65c4f0fcb6ac";
|
|
|
|
if (fHelp || params.size() < 2 || params.size() > 4)
|
|
throw runtime_error(
|
|
"createrawtransaction [{\"txid\":\"id\",\"vout\":n},...] {\"address\":amount,...} ( locktime ) ( expiryheight )\n"
|
|
"\nCreate a transaction spending the given inputs and creating new outputs.\n"
|
|
"Outputs can be addresses or standart scripts (in hex) or data.\n"
|
|
"Returns hex-encoded raw transaction.\n"
|
|
"Note that the transaction's inputs are not signed, and\n"
|
|
"it is not stored in the wallet or transmitted to the network.\n"
|
|
|
|
"\nArguments:\n"
|
|
"1. \"inputs\" (array, required) A json array of json objects\n"
|
|
" [\n"
|
|
" {\n"
|
|
" \"txid\":\"id\", (string, required) The transaction id\n"
|
|
" \"vout\":n, (numeric, required) The output number\n"
|
|
" \"sequence\":n (numeric, optional) The sequence number\n"
|
|
" } \n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
"2. \"outputs\" (object, required) a json object with outputs\n"
|
|
" {\n"
|
|
" \"address\": x.xxx, (numeric or string, required) The key is the HUSH address or script (in hex), the numeric value (can be string) is the " + CURRENCY_UNIT + " amount\n"
|
|
" \"data\": \"hex\" (string, optional) The key is \"data\", the value is hex encoded OP_RETURN data\n"
|
|
" ,...\n"
|
|
" }\n"
|
|
"3. locktime (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n"
|
|
"4. expiryheight (numeric, optional, default=" + strprintf("%d", DEFAULT_TX_EXPIRY_DELTA) + ") Expiry height of transaction\n"
|
|
"\nResult:\n"
|
|
"\"transaction\" (string) hex string of the transaction\n"
|
|
|
|
"\nExamples\n"
|
|
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"{\\\"address\\\":0.01}\"")
|
|
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"{\\\""+examplescriptPubKey+"\\\":0.01}\"")
|
|
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"{\\\"data\\\":\\\"00010203\\\"}\"")
|
|
+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"{\\\"address\\\":0.01}\"")
|
|
+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"{\\\""+examplescriptPubKey+"\\\":0.01}\"")
|
|
+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"{\\\"data\\\":\\\"00010203\\\"}\"")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VARR)(UniValue::VOBJ)(UniValue::VNUM)(UniValue::VNUM), true);
|
|
if (params[0].isNull() || params[1].isNull())
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, arguments 1 and 2 must be non-null");
|
|
|
|
UniValue inputs = params[0].get_array();
|
|
UniValue sendTo = params[1].get_obj();
|
|
|
|
int nextBlockHeight = chainActive.Height() + 1;
|
|
CMutableTransaction rawTx = CreateNewContextualCMutableTransaction(
|
|
Params().GetConsensus(), nextBlockHeight);
|
|
|
|
if (params.size() > 2 && !params[2].isNull()) {
|
|
int64_t nLockTime = params[2].get_int64();
|
|
if (nLockTime < 0 || nLockTime > std::numeric_limits<uint32_t>::max())
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, locktime out of range");
|
|
rawTx.nLockTime = nLockTime;
|
|
}
|
|
|
|
if (params.size() > 3 && !params[3].isNull()) {
|
|
if (NetworkUpgradeActive(nextBlockHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER)) {
|
|
int64_t nExpiryHeight = params[3].get_int64();
|
|
if (nExpiryHeight < 0 || nExpiryHeight >= TX_EXPIRY_HEIGHT_THRESHOLD) {
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, expiryheight must be nonnegative and less than %d.", TX_EXPIRY_HEIGHT_THRESHOLD));
|
|
}
|
|
rawTx.nExpiryHeight = nExpiryHeight;
|
|
} else {
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expiryheight can only be used if Overwinter is active when the transaction is mined");
|
|
}
|
|
}
|
|
|
|
for (size_t idx = 0; idx < inputs.size(); idx++) {
|
|
const UniValue& input = inputs[idx];
|
|
const UniValue& o = input.get_obj();
|
|
|
|
uint256 txid = ParseHashO(o, "txid");
|
|
|
|
const UniValue& vout_v = find_value(o, "vout");
|
|
if (!vout_v.isNum())
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
|
|
int nOutput = vout_v.get_int();
|
|
if (nOutput < 0)
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive");
|
|
|
|
uint32_t nSequence = (rawTx.nLockTime ? std::numeric_limits<uint32_t>::max() - 1 : std::numeric_limits<uint32_t>::max());
|
|
|
|
// set the sequence number if passed in the parameters object
|
|
const UniValue& sequenceObj = find_value(o, "sequence");
|
|
if (sequenceObj.isNum())
|
|
nSequence = sequenceObj.get_int();
|
|
|
|
CTxIn in(COutPoint(txid, nOutput), CScript(), nSequence);
|
|
|
|
rawTx.vin.push_back(in);
|
|
}
|
|
|
|
std::set<CTxDestination> destinations;
|
|
//std::set<std::string> destinations;
|
|
|
|
vector<string> addrList = sendTo.getKeys();
|
|
|
|
if (addrList.size() != sendTo.size()) {
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid outputs")); // for checking edge case, should never happened ...
|
|
}
|
|
|
|
//for (const std::string& name_ : addrList) {
|
|
for (size_t idx = 0; idx < sendTo.size(); idx++) {
|
|
|
|
const std::string& name_ = addrList[idx];
|
|
|
|
CScript scriptPubKey;
|
|
CTxDestination destination;
|
|
|
|
if (name_ == "data") {
|
|
std::vector<unsigned char> data = ParseHexV(sendTo[name_].getValStr(),"Data");
|
|
CTxOut out(0, CScript() << OP_RETURN << data);
|
|
rawTx.vout.push_back(out);
|
|
} else {
|
|
destination = DecodeDestination(name_);
|
|
if (IsValidDestination(destination)) {
|
|
scriptPubKey = GetScriptForDestination(destination);
|
|
} else if (IsHex(name_)) {
|
|
std::vector<unsigned char> data(ParseHex(name_));
|
|
scriptPubKey = CScript(data.begin(), data.end());
|
|
// destination is not valid, but we should convert it to valid anyway, to be able to check duplicates,
|
|
// so we need to get destination from existing scriptPubKey via ExtractDestination
|
|
if (!(ExtractDestination(scriptPubKey, destination) &&
|
|
(scriptPubKey.IsPayToPublicKeyHash() || scriptPubKey.IsPayToPublicKey() || scriptPubKey.IsPayToScriptHash())
|
|
)) {
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid script: ") + name_ + std::string(" (only P2PKH, P2PK and P2SH scripts are allowed)"));
|
|
}
|
|
}
|
|
else {
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Hush address or script: ") + name_);
|
|
}
|
|
|
|
if (!(fExperimentalMode && IS_HUSH_NOTARY)) {
|
|
// support of sending duplicates in createrawtransaction requires experimental features enabled and
|
|
// notary flag, to prevent common users to get messed up with duplicates
|
|
|
|
//if (!destinations.insert(EncodeDestination(destination)).second) {
|
|
if (!destinations.insert(destination).second) {
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated destination: ") + name_);
|
|
}
|
|
}
|
|
|
|
// CAmount nAmount = AmountFromValue(sendTo[name_]); // operator[](const std::string& key) const;
|
|
CAmount nAmount = AmountFromValue(sendTo[idx]); // operator[](size_t index) const;
|
|
|
|
CTxOut out(nAmount, scriptPubKey);
|
|
rawTx.vout.push_back(out);
|
|
}
|
|
}
|
|
|
|
return EncodeHexTx(rawTx);
|
|
}
|
|
|
|
UniValue decoderawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"decoderawtransaction \"hexstring\"\n"
|
|
"\nReturn a JSON object representing the serialized, hex-encoded transaction.\n"
|
|
|
|
"\nArguments:\n"
|
|
"1. \"hex\" (string, required) The transaction hex string\n"
|
|
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"txid\" : \"id\", (string) The transaction id\n"
|
|
" \"overwintered\" : bool (boolean) The Overwintered flag\n"
|
|
" \"version\" : n, (numeric) The version\n"
|
|
" \"versiongroupid\": \"hex\" (string, optional) The version group id (Overwintered txs)\n"
|
|
" \"locktime\" : ttt, (numeric) The lock time\n"
|
|
" \"expiryheight\" : n, (numeric, optional) Last valid block height for mining transaction (Overwintered txs)\n"
|
|
" \"vin\" : [ (array of json objects)\n"
|
|
" {\n"
|
|
" \"txid\": \"id\", (string) The transaction id\n"
|
|
" \"vout\": n, (numeric) The output number\n"
|
|
" \"scriptSig\": { (json object) The script\n"
|
|
" \"asm\": \"asm\", (string) asm\n"
|
|
" \"hex\": \"hex\" (string) hex\n"
|
|
" },\n"
|
|
" \"sequence\": n (numeric) The script sequence number\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
" \"vout\" : [ (array of json objects)\n"
|
|
" {\n"
|
|
" \"value\" : x.xxx, (numeric) The value in " + CURRENCY_UNIT + "\n"
|
|
" \"n\" : n, (numeric) index\n"
|
|
" \"scriptPubKey\" : { (json object)\n"
|
|
" \"asm\" : \"asm\", (string) the asm\n"
|
|
" \"hex\" : \"hex\", (string) the hex\n"
|
|
" \"reqSigs\" : n, (numeric) The required sigs\n"
|
|
" \"type\" : \"pubkeyhash\", (string) The type, eg 'pubkeyhash'\n"
|
|
" \"addresses\" : [ (json array of string)\n"
|
|
" \"RTZMZHDFSTFQst8XmX2dR4DaH87cEUs3gC\" (string) HUSH address\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
" }\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
"}\n"
|
|
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("decoderawtransaction", "\"hexstring\"")
|
|
+ HelpExampleRpc("decoderawtransaction", "\"hexstring\"")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR));
|
|
|
|
CTransaction tx;
|
|
|
|
if (!DecodeHexTx(tx, params[0].get_str()))
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
|
|
|
|
UniValue result(UniValue::VOBJ);
|
|
TxToJSON(tx, uint256(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
UniValue decodescript(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"decodescript \"hex\"\n"
|
|
"\nDecode a hex-encoded script.\n"
|
|
"\nArguments:\n"
|
|
"1. \"hex\" (string) the hex encoded script\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"asm\":\"asm\", (string) Script public key\n"
|
|
" \"hex\":\"hex\", (string) hex encoded public key\n"
|
|
" \"type\":\"type\", (string) The output type\n"
|
|
" \"reqSigs\": n, (numeric) The required signatures\n"
|
|
" \"addresses\": [ (json array of string)\n"
|
|
" \"address\" (string) Hush address\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
" \"p2sh\",\"address\" (string) script address\n"
|
|
"}\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("decodescript", "\"hexstring\"")
|
|
+ HelpExampleRpc("decodescript", "\"hexstring\"")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR));
|
|
|
|
UniValue r(UniValue::VOBJ);
|
|
CScript script;
|
|
if (params[0].get_str().size() > 0){
|
|
vector<unsigned char> scriptData(ParseHexV(params[0], "argument"));
|
|
script = CScript(scriptData.begin(), scriptData.end());
|
|
} else {
|
|
// Empty scripts are valid
|
|
}
|
|
ScriptPubKeyToJSON(script, r, false);
|
|
|
|
r.push_back(Pair("p2sh", EncodeDestination(CScriptID(script))));
|
|
return r;
|
|
}
|
|
|
|
/** Pushes a JSON object for script verification or signing errors to vErrorsRet. */
|
|
static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::string& strMessage)
|
|
{
|
|
UniValue entry(UniValue::VOBJ);
|
|
entry.push_back(Pair("txid", txin.prevout.hash.ToString()));
|
|
entry.push_back(Pair("vout", (uint64_t)txin.prevout.n));
|
|
entry.push_back(Pair("scriptSig", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
|
|
entry.push_back(Pair("sequence", (uint64_t)txin.nSequence));
|
|
entry.push_back(Pair("error", strMessage));
|
|
vErrorsRet.push_back(entry);
|
|
}
|
|
|
|
UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 5)
|
|
throw runtime_error(
|
|
"signrawtransaction \"hexstring\" ( [{\"txid\":\"id\",\"vout\":n,\"scriptPubKey\":\"hex\",\"redeemScript\":\"hex\"},...] [\"privatekey1\",...] sighashtype )\n"
|
|
"\nSign inputs for raw transaction (serialized, hex-encoded).\n"
|
|
"The second optional argument (may be null) is an array of previous transaction outputs that\n"
|
|
"this transaction depends on but may not yet be in the block chain.\n"
|
|
"The third optional argument (may be null) is an array of base58-encoded private\n"
|
|
"keys that, if given, will be the only keys used to sign the transaction.\n"
|
|
#ifdef ENABLE_WALLET
|
|
+ HelpRequiringPassphrase() + "\n"
|
|
#endif
|
|
|
|
"\nArguments:\n"
|
|
"1. \"hexstring\" (string, required) The transaction hex string\n"
|
|
"2. \"prevtxs\" (string, optional) An json array of previous dependent transaction outputs\n"
|
|
" [ (json array of json objects, or 'null' if none provided)\n"
|
|
" {\n"
|
|
" \"txid\":\"id\", (string, required) The transaction id\n"
|
|
" \"vout\":n, (numeric, required) The output number\n"
|
|
" \"scriptPubKey\": \"hex\", (string, required) script key\n"
|
|
" \"redeemScript\": \"hex\", (string, required for P2SH) redeem script\n"
|
|
" \"amount\": value (numeric, required) The amount spent\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
"3. \"privatekeys\" (string, optional) A json array of base58-encoded private keys for signing\n"
|
|
" [ (json array of strings, or 'null' if none provided)\n"
|
|
" \"privatekey\" (string) private key in base58-encoding\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
"4. \"sighashtype\" (string, optional, default=ALL) The signature hash type. Must be one of\n"
|
|
" \"ALL\"\n"
|
|
" \"NONE\"\n"
|
|
" \"SINGLE\"\n"
|
|
" \"ALL|ANYONECANPAY\"\n"
|
|
" \"NONE|ANYONECANPAY\"\n"
|
|
" \"SINGLE|ANYONECANPAY\"\n"
|
|
"5. \"branchid\" (string, optional) The hex representation of the consensus branch id to sign with."
|
|
" This can be used to force signing with consensus rules that are ahead of the node's current height.\n"
|
|
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"hex\" : \"value\", (string) The hex-encoded raw transaction with signature(s)\n"
|
|
" \"complete\" : true|false, (boolean) If the transaction has a complete set of signatures\n"
|
|
" \"errors\" : [ (json array of objects) Script verification errors (if there are any)\n"
|
|
" {\n"
|
|
" \"txid\" : \"hash\", (string) The hash of the referenced, previous transaction\n"
|
|
" \"vout\" : n, (numeric) The index of the output to spent and used as input\n"
|
|
" \"scriptSig\" : \"hex\", (string) The hex-encoded signature script\n"
|
|
" \"sequence\" : n, (numeric) Script sequence number\n"
|
|
" \"error\" : \"text\" (string) Verification or signing error related to the input\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
"}\n"
|
|
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("signrawtransaction", "\"myhex\"")
|
|
+ HelpExampleRpc("signrawtransaction", "\"myhex\"")
|
|
);
|
|
|
|
#ifdef ENABLE_WALLET
|
|
LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
|
|
#else
|
|
LOCK(cs_main);
|
|
#endif
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR)(UniValue::VARR)(UniValue::VARR)(UniValue::VSTR)(UniValue::VSTR), true);
|
|
|
|
vector<unsigned char> txData(ParseHexV(params[0], "argument 1"));
|
|
CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
|
|
vector<CMutableTransaction> txVariants;
|
|
while (!ssData.empty()) {
|
|
try {
|
|
CMutableTransaction tx;
|
|
ssData >> tx;
|
|
txVariants.push_back(tx);
|
|
}
|
|
catch (const std::exception&) {
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
|
|
}
|
|
}
|
|
|
|
if (txVariants.empty())
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transaction");
|
|
|
|
// mergedTx will end up with all the signatures; it
|
|
// starts as a clone of the rawtx:
|
|
CMutableTransaction mergedTx(txVariants[0]);
|
|
|
|
// Fetch previous transactions (inputs):
|
|
CCoinsView viewDummy;
|
|
CCoinsViewCache view(&viewDummy);
|
|
{
|
|
LOCK(mempool.cs);
|
|
CCoinsViewCache &viewChain = *pcoinsTip;
|
|
CCoinsViewMemPool viewMempool(&viewChain, mempool);
|
|
view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
|
|
|
|
BOOST_FOREACH(const CTxIn& txin, mergedTx.vin) {
|
|
const uint256& prevHash = txin.prevout.hash;
|
|
CCoins coins;
|
|
view.AccessCoins(prevHash); // this is certainly allowed to fail
|
|
}
|
|
|
|
view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long
|
|
}
|
|
|
|
bool fGivenKeys = false;
|
|
CBasicKeyStore tempKeystore;
|
|
if (params.size() > 2 && !params[2].isNull()) {
|
|
fGivenKeys = true;
|
|
UniValue keys = params[2].get_array();
|
|
for (size_t idx = 0; idx < keys.size(); idx++) {
|
|
UniValue k = keys[idx];
|
|
CKey key = DecodeSecret(k.get_str());
|
|
if (!key.IsValid())
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
|
|
tempKeystore.AddKey(key);
|
|
}
|
|
}
|
|
#ifdef ENABLE_WALLET
|
|
else if (pwalletMain)
|
|
EnsureWalletIsUnlocked();
|
|
#endif
|
|
|
|
// Add previous txouts given in the RPC call:
|
|
if (params.size() > 1 && !params[1].isNull()) {
|
|
UniValue prevTxs = params[1].get_array();
|
|
for (size_t idx = 0; idx < prevTxs.size(); idx++) {
|
|
const UniValue& p = prevTxs[idx];
|
|
if (!p.isObject())
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");
|
|
|
|
UniValue prevOut = p.get_obj();
|
|
|
|
RPCTypeCheckObj(prevOut, boost::assign::map_list_of("txid", UniValue::VSTR)("vout", UniValue::VNUM)("scriptPubKey", UniValue::VSTR));
|
|
|
|
uint256 txid = ParseHashO(prevOut, "txid");
|
|
|
|
int nOut = find_value(prevOut, "vout").get_int();
|
|
if (nOut < 0)
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout must be positive");
|
|
|
|
vector<unsigned char> pkData(ParseHexO(prevOut, "scriptPubKey"));
|
|
CScript scriptPubKey(pkData.begin(), pkData.end());
|
|
|
|
{
|
|
CCoinsModifier coins = view.ModifyCoins(txid);
|
|
if (coins->IsAvailable(nOut) && coins->vout[nOut].scriptPubKey != scriptPubKey) {
|
|
string err("Previous output scriptPubKey mismatch:\n");
|
|
err = err + ScriptToAsmStr(coins->vout[nOut].scriptPubKey) + "\nvs:\n"+
|
|
ScriptToAsmStr(scriptPubKey);
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
|
|
}
|
|
if ((unsigned int)nOut >= coins->vout.size())
|
|
coins->vout.resize(nOut+1);
|
|
coins->vout[nOut].scriptPubKey = scriptPubKey;
|
|
coins->vout[nOut].nValue = 0;
|
|
if (prevOut.exists("amount")) {
|
|
coins->vout[nOut].nValue = AmountFromValue(find_value(prevOut, "amount"));
|
|
}
|
|
}
|
|
|
|
// if redeemScript given and not using the local wallet (private keys
|
|
// given), add redeemScript to the tempKeystore so it can be signed:
|
|
if (fGivenKeys && scriptPubKey.IsPayToScriptHash()) {
|
|
RPCTypeCheckObj(prevOut, boost::assign::map_list_of("txid", UniValue::VSTR)("vout", UniValue::VNUM)("scriptPubKey", UniValue::VSTR)("redeemScript",UniValue::VSTR));
|
|
UniValue v = find_value(prevOut, "redeemScript");
|
|
if (!v.isNull()) {
|
|
vector<unsigned char> rsData(ParseHexV(v, "redeemScript"));
|
|
CScript redeemScript(rsData.begin(), rsData.end());
|
|
tempKeystore.AddCScript(redeemScript);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef ENABLE_WALLET
|
|
const CKeyStore& keystore = ((fGivenKeys || !pwalletMain) ? tempKeystore : *pwalletMain);
|
|
#else
|
|
const CKeyStore& keystore = tempKeystore;
|
|
#endif
|
|
|
|
int nHashType = SIGHASH_ALL;
|
|
if (params.size() > 3 && !params[3].isNull()) {
|
|
static map<string, int> mapSigHashValues =
|
|
boost::assign::map_list_of
|
|
(string("ALL"), int(SIGHASH_ALL))
|
|
(string("ALL|ANYONECANPAY"), int(SIGHASH_ALL|SIGHASH_ANYONECANPAY))
|
|
(string("NONE"), int(SIGHASH_NONE))
|
|
(string("NONE|ANYONECANPAY"), int(SIGHASH_NONE|SIGHASH_ANYONECANPAY))
|
|
(string("SINGLE"), int(SIGHASH_SINGLE))
|
|
(string("SINGLE|ANYONECANPAY"), int(SIGHASH_SINGLE|SIGHASH_ANYONECANPAY))
|
|
;
|
|
string strHashType = params[3].get_str();
|
|
if (mapSigHashValues.count(strHashType))
|
|
nHashType = mapSigHashValues[strHashType];
|
|
else
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid sighash param");
|
|
}
|
|
|
|
bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);
|
|
// Use the approximate release height if it is greater so offline nodes
|
|
// have a better estimation of the current height and will be more likely to
|
|
// determine the correct consensus branch ID. Regtest mode ignores release height.
|
|
int chainHeight = chainActive.Height() + 1;
|
|
|
|
// Grab the current consensus branch ID
|
|
auto consensusBranchId = CurrentEpochBranchId(chainHeight, Params().GetConsensus());
|
|
|
|
if (params.size() > 4 && !params[4].isNull()) {
|
|
consensusBranchId = ParseHexToUInt32(params[4].get_str());
|
|
if (!IsConsensusBranchId(consensusBranchId)) {
|
|
throw runtime_error(params[4].get_str() + " is not a valid consensus branch id");
|
|
}
|
|
}
|
|
|
|
// Script verification errors
|
|
UniValue vErrors(UniValue::VARR);
|
|
|
|
// Use CTransaction for the constant parts of the
|
|
// transaction to avoid rehashing.
|
|
CMutableTransaction mergedTxsave = mergedTx;
|
|
int32_t txpow,numiters = 0;
|
|
const CTransaction txConst(mergedTx);
|
|
if ( (txpow = ASSETCHAINS_TXPOW) != 0 )
|
|
{
|
|
if ( txConst.IsCoinBase() != 0 )
|
|
{
|
|
if ( (txpow & 2) == 0 )
|
|
txpow = 0;
|
|
}
|
|
else
|
|
{
|
|
if ( (txpow & 1) == 0 )
|
|
txpow = 0;
|
|
}
|
|
}
|
|
while ( 1 )
|
|
{
|
|
if ( txpow != 0 )
|
|
mergedTx = mergedTxsave;
|
|
// Sign what we can:
|
|
for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
|
|
CTxIn& txin = mergedTx.vin[i];
|
|
const CCoins* coins = view.AccessCoins(txin.prevout.hash);
|
|
if (coins == NULL || !coins->IsAvailable(txin.prevout.n)) {
|
|
TxInErrorToJSON(txin, vErrors, "Input not found or already spent");
|
|
continue;
|
|
}
|
|
const CScript& prevPubKey = coins->vout[txin.prevout.n].scriptPubKey;
|
|
const CAmount& amount = coins->vout[txin.prevout.n].nValue;
|
|
|
|
SignatureData sigdata;
|
|
// Only sign SIGHASH_SINGLE if there's a corresponding output:
|
|
if (!fHashSingle || (i < mergedTx.vout.size()))
|
|
ProduceSignature(MutableTransactionSignatureCreator(&keystore, &mergedTx, i, amount, nHashType), prevPubKey, sigdata, consensusBranchId);
|
|
|
|
// ... and merge in other signatures:
|
|
BOOST_FOREACH(const CMutableTransaction& txv, txVariants) {
|
|
sigdata = CombineSignatures(prevPubKey, TransactionSignatureChecker(&txConst, i, amount), sigdata, DataFromTransaction(txv, i), consensusBranchId);
|
|
}
|
|
|
|
UpdateTransaction(mergedTx, i, sigdata);
|
|
|
|
ScriptError serror = SCRIPT_ERR_OK;
|
|
if (!VerifyScript(txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, TransactionSignatureChecker(&txConst, i, amount), consensusBranchId, &serror)) {
|
|
TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
|
|
}
|
|
}
|
|
if ( txpow != 0 )
|
|
{
|
|
uint256 txid = mergedTx.GetHash();
|
|
if ( ((uint8_t *)&txid)[0] == 0 && ((uint8_t *)&txid)[31] == 0 )
|
|
break;
|
|
//fprintf(stderr,"%d: tmp txid.%s\n",numiters,txid.GetHex().c_str());
|
|
} else break;
|
|
numiters++;
|
|
}
|
|
if ( numiters > 0 )
|
|
fprintf(stderr,"ASSETCHAINS_TXPOW.%d txpow.%d numiters.%d for signature\n",ASSETCHAINS_TXPOW,txpow,numiters);
|
|
bool fComplete = vErrors.empty();
|
|
|
|
UniValue result(UniValue::VOBJ);
|
|
result.push_back(Pair("hex", EncodeHexTx(mergedTx)));
|
|
result.push_back(Pair("complete", fComplete));
|
|
if (!vErrors.empty()) {
|
|
result.push_back(Pair("errors", vErrors));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern UniValue NSPV_broadcast(char *hex);
|
|
|
|
UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"sendrawtransaction \"hexstring\" ( allowhighfees )\n"
|
|
"\nSubmits raw transaction (serialized, hex-encoded) to local node and network.\n"
|
|
"\nAlso see createrawtransaction and signrawtransaction calls.\n"
|
|
"\nArguments:\n"
|
|
"1. \"hexstring\" (string, required) The hex string of the raw transaction)\n"
|
|
"2. allowhighfees (boolean, optional, default=false) Allow high fees\n"
|
|
"\nResult:\n"
|
|
"\"hex\" (string) The transaction hash in hex\n"
|
|
"\nExamples:\n"
|
|
"\nCreate a transaction\n"
|
|
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
|
|
"Sign the transaction, and get back the hex\n"
|
|
+ HelpExampleCli("signrawtransaction", "\"myhex\"") +
|
|
"\nSend the transaction (signed hex)\n"
|
|
+ HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
|
|
"\nAs a json rpc call\n"
|
|
+ HelpExampleRpc("sendrawtransaction", "\"signedhex\"")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR)(UniValue::VBOOL));
|
|
|
|
// parse hex string from parameter
|
|
CTransaction tx;
|
|
if (!DecodeHexTx(tx, params[0].get_str()))
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
|
|
uint256 hashTx = tx.GetHash();
|
|
|
|
bool fOverrideFees = false;
|
|
if (params.size() > 1)
|
|
fOverrideFees = params[1].get_bool();
|
|
if ( HUSH_NSPV_FULLNODE )
|
|
{
|
|
CCoinsViewCache &view = *pcoinsTip;
|
|
const CCoins* existingCoins = view.AccessCoins(hashTx);
|
|
bool fHaveMempool = mempool.exists(hashTx);
|
|
bool fHaveChain = existingCoins && existingCoins->nHeight < 1000000000;
|
|
|
|
// If we are configured to send transactions via an
|
|
// external service instead of broadcasting, do that
|
|
std::string strCmd = GetArg("-txsend", "");
|
|
if (!strCmd.empty()) {
|
|
if (fHaveChain) {
|
|
throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN, "transaction already in block chain");
|
|
}
|
|
boost::replace_all(strCmd, "%s", EncodeHexTx(tx));
|
|
boost::thread t(runCommand, strCmd); // thread runs free
|
|
// Return here so we don't add to our mempool or broadcast to peers
|
|
return hashTx.GetHex();
|
|
}
|
|
if (!fHaveMempool && !fHaveChain) {
|
|
// push to local node and sync with wallets
|
|
CValidationState state;
|
|
bool fMissingInputs;
|
|
LogPrintf("%s: Submitting to mempool\n", __FUNCTION__);
|
|
if (!AcceptToMemoryPool(mempool, state, tx, false, &fMissingInputs, !fOverrideFees)) {
|
|
if (state.IsInvalid()) {
|
|
throw JSONRPCError(RPC_TRANSACTION_REJECTED, strprintf("%i: %s", state.GetRejectCode(), state.GetRejectReason()));
|
|
} else {
|
|
if (fMissingInputs) {
|
|
throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
|
|
}
|
|
throw JSONRPCError(RPC_TRANSACTION_ERROR, strprintf("Invalid state: %s", state.GetRejectReason()));
|
|
}
|
|
}
|
|
} else if (fHaveChain) {
|
|
throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN, "transaction already in block chain");
|
|
}
|
|
LogPrintf("%s: Relaying raw tx to mempool\n", __FUNCTION__);
|
|
RelayTransaction(tx);
|
|
} else {
|
|
NSPV_broadcast((char *)params[0].get_str().c_str());
|
|
}
|
|
return hashTx.GetHex();
|
|
}
|
|
|
|
static const CRPCCommand commands[] =
|
|
{ // category name actor (function) okSafeMode
|
|
// --------------------- ------------------------ ----------------------- ----------
|
|
{ "rawtransactions", "getrawtransaction", &getrawtransaction, true },
|
|
{ "rawtransactions", "createrawtransaction", &createrawtransaction, true },
|
|
{ "rawtransactions", "decoderawtransaction", &decoderawtransaction, true },
|
|
{ "rawtransactions", "decodescript", &decodescript, true },
|
|
{ "rawtransactions", "sendrawtransaction", &sendrawtransaction, false },
|
|
{ "rawtransactions", "signrawtransaction", &signrawtransaction, false }, /* uses wallet if enabled */
|
|
|
|
{ "blockchain", "gettxoutproof", &gettxoutproof, true },
|
|
{ "blockchain", "verifytxoutproof", &verifytxoutproof, true },
|
|
};
|
|
|
|
void RegisterRawTransactionRPCCommands(CRPCTable &tableRPC)
|
|
{
|
|
for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
|
|
tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
|
|
}
|
|
|