|
|
|
@ -3840,475 +3840,6 @@ UniValue fundrawtransaction(const UniValue& params, bool fHelp, const CPubKey& m |
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (fHelp) { |
|
|
|
throw runtime_error( |
|
|
|
"zcsamplejoinsplit\n" |
|
|
|
"\n" |
|
|
|
"Perform a joinsplit and return the JSDescription.\n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
LOCK(cs_main); |
|
|
|
|
|
|
|
uint256 joinSplitPubKey; |
|
|
|
uint256 anchor = SproutMerkleTree().root(); |
|
|
|
JSDescription samplejoinsplit(*pzcashParams, |
|
|
|
joinSplitPubKey, |
|
|
|
anchor, |
|
|
|
{JSInput(), JSInput()}, |
|
|
|
{JSOutput(), JSOutput()}, |
|
|
|
0, |
|
|
|
0); |
|
|
|
|
|
|
|
CDataStream ss(SER_NETWORK, SAPLING_TX_VERSION | (1 << 31)); |
|
|
|
ss << samplejoinsplit; |
|
|
|
|
|
|
|
return HexStr(ss.begin(), ss.end()); |
|
|
|
} |
|
|
|
|
|
|
|
UniValue zc_benchmark(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (!EnsureWalletIsAvailable(fHelp)) { |
|
|
|
return NullUniValue; |
|
|
|
} |
|
|
|
|
|
|
|
if (fHelp || params.size() < 2) { |
|
|
|
throw runtime_error( |
|
|
|
"zcbenchmark benchmarktype samplecount\n" |
|
|
|
"\n" |
|
|
|
"Runs a benchmark of the selected type samplecount times,\n" |
|
|
|
"returning the running times of each sample.\n" |
|
|
|
"\n" |
|
|
|
"Output: [\n" |
|
|
|
" {\n" |
|
|
|
" \"runningtime\": runningtime\n" |
|
|
|
" },\n" |
|
|
|
" {\n" |
|
|
|
" \"runningtime\": runningtime\n" |
|
|
|
" }\n" |
|
|
|
" ...\n" |
|
|
|
"]\n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
LOCK(cs_main); |
|
|
|
|
|
|
|
std::string benchmarktype = params[0].get_str(); |
|
|
|
int samplecount = params[1].get_int(); |
|
|
|
|
|
|
|
if (samplecount <= 0) { |
|
|
|
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid samplecount"); |
|
|
|
} |
|
|
|
|
|
|
|
std::vector<double> sample_times; |
|
|
|
|
|
|
|
JSDescription samplejoinsplit; |
|
|
|
|
|
|
|
if (benchmarktype == "verifyjoinsplit") { |
|
|
|
CDataStream ss(ParseHexV(params[2].get_str(), "js"), SER_NETWORK, SAPLING_TX_VERSION | (1 << 31)); |
|
|
|
ss >> samplejoinsplit; |
|
|
|
} |
|
|
|
|
|
|
|
for (int i = 0; i < samplecount; i++) { |
|
|
|
if (benchmarktype == "sleep") { |
|
|
|
sample_times.push_back(benchmark_sleep()); |
|
|
|
} else if (benchmarktype == "createjoinsplit") { |
|
|
|
if (params.size() < 3) { |
|
|
|
sample_times.push_back(benchmark_create_joinsplit()); |
|
|
|
} else { |
|
|
|
int nThreads = params[2].get_int(); |
|
|
|
std::vector<double> vals = benchmark_create_joinsplit_threaded(nThreads); |
|
|
|
// Divide by nThreads^2 to get average seconds per JoinSplit because
|
|
|
|
// we are running one JoinSplit per thread.
|
|
|
|
sample_times.push_back(std::accumulate(vals.begin(), vals.end(), 0.0) / (nThreads*nThreads)); |
|
|
|
} |
|
|
|
} else if (benchmarktype == "verifyjoinsplit") { |
|
|
|
sample_times.push_back(benchmark_verify_joinsplit(samplejoinsplit)); |
|
|
|
#ifdef ENABLE_MINING |
|
|
|
} else if (benchmarktype == "solveequihash") { |
|
|
|
if (params.size() < 3) { |
|
|
|
sample_times.push_back(benchmark_solve_equihash()); |
|
|
|
} else { |
|
|
|
int nThreads = params[2].get_int(); |
|
|
|
std::vector<double> vals = benchmark_solve_equihash_threaded(nThreads); |
|
|
|
sample_times.insert(sample_times.end(), vals.begin(), vals.end()); |
|
|
|
} |
|
|
|
#endif |
|
|
|
} else if (benchmarktype == "verifyequihash") { |
|
|
|
sample_times.push_back(benchmark_verify_equihash()); |
|
|
|
} else if (benchmarktype == "validatelargetx") { |
|
|
|
// Number of inputs in the spending transaction that we will simulate
|
|
|
|
int nInputs = 11130; |
|
|
|
if (params.size() >= 3) { |
|
|
|
nInputs = params[2].get_int(); |
|
|
|
} |
|
|
|
sample_times.push_back(benchmark_large_tx(nInputs)); |
|
|
|
} else if (benchmarktype == "trydecryptnotes") { |
|
|
|
int nAddrs = params[2].get_int(); |
|
|
|
sample_times.push_back(benchmark_try_decrypt_notes(nAddrs)); |
|
|
|
} else if (benchmarktype == "incnotewitnesses") { |
|
|
|
int nTxs = params[2].get_int(); |
|
|
|
sample_times.push_back(benchmark_increment_note_witnesses(nTxs)); |
|
|
|
} else if (benchmarktype == "connectblockslow") { |
|
|
|
if (Params().NetworkIDString() != "regtest") { |
|
|
|
throw JSONRPCError(RPC_TYPE_ERROR, "Benchmark must be run in regtest mode"); |
|
|
|
} |
|
|
|
sample_times.push_back(benchmark_connectblock_slow()); |
|
|
|
} else if (benchmarktype == "sendtoaddress") { |
|
|
|
if (Params().NetworkIDString() != "regtest") { |
|
|
|
throw JSONRPCError(RPC_TYPE_ERROR, "Benchmark must be run in regtest mode"); |
|
|
|
} |
|
|
|
auto amount = AmountFromValue(params[2]); |
|
|
|
sample_times.push_back(benchmark_sendtoaddress(amount)); |
|
|
|
} else if (benchmarktype == "loadwallet") { |
|
|
|
if (Params().NetworkIDString() != "regtest") { |
|
|
|
throw JSONRPCError(RPC_TYPE_ERROR, "Benchmark must be run in regtest mode"); |
|
|
|
} |
|
|
|
sample_times.push_back(benchmark_loadwallet()); |
|
|
|
} else if (benchmarktype == "listunspent") { |
|
|
|
sample_times.push_back(benchmark_listunspent()); |
|
|
|
} else if (benchmarktype == "createsaplingspend") { |
|
|
|
sample_times.push_back(benchmark_create_sapling_spend()); |
|
|
|
} else if (benchmarktype == "createsaplingoutput") { |
|
|
|
sample_times.push_back(benchmark_create_sapling_output()); |
|
|
|
} else if (benchmarktype == "verifysaplingspend") { |
|
|
|
sample_times.push_back(benchmark_verify_sapling_spend()); |
|
|
|
} else if (benchmarktype == "verifysaplingoutput") { |
|
|
|
sample_times.push_back(benchmark_verify_sapling_output()); |
|
|
|
} else { |
|
|
|
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid benchmarktype"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
UniValue results(UniValue::VARR); |
|
|
|
for (auto time : sample_times) { |
|
|
|
UniValue result(UniValue::VOBJ); |
|
|
|
result.push_back(Pair("runningtime", time)); |
|
|
|
results.push_back(result); |
|
|
|
} |
|
|
|
|
|
|
|
return results; |
|
|
|
} |
|
|
|
|
|
|
|
UniValue zc_raw_receive(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (!EnsureWalletIsAvailable(fHelp)) { |
|
|
|
return NullUniValue; |
|
|
|
} |
|
|
|
|
|
|
|
if (fHelp || params.size() != 2) { |
|
|
|
throw runtime_error( |
|
|
|
"zcrawreceive zcsecretkey encryptednote\n" |
|
|
|
"\n" |
|
|
|
"DEPRECATED. Decrypts encryptednote and checks if the coin commitments\n" |
|
|
|
"are in the blockchain as indicated by the \"exists\" result.\n" |
|
|
|
"\n" |
|
|
|
"Output: {\n" |
|
|
|
" \"amount\": value,\n" |
|
|
|
" \"note\": noteplaintext,\n" |
|
|
|
" \"exists\": exists\n" |
|
|
|
"}\n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR)(UniValue::VSTR)); |
|
|
|
|
|
|
|
LOCK(cs_main); |
|
|
|
|
|
|
|
auto spendingkey = DecodeSpendingKey(params[0].get_str()); |
|
|
|
if (!IsValidSpendingKey(spendingkey)) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid spending key"); |
|
|
|
} |
|
|
|
if (boost::get<libzcash::SproutSpendingKey>(&spendingkey) == nullptr) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Only works with Sprout spending keys"); |
|
|
|
} |
|
|
|
SproutSpendingKey k = boost::get<libzcash::SproutSpendingKey>(spendingkey); |
|
|
|
|
|
|
|
uint256 epk; |
|
|
|
unsigned char nonce; |
|
|
|
ZCNoteEncryption::Ciphertext ct; |
|
|
|
uint256 h_sig; |
|
|
|
|
|
|
|
{ |
|
|
|
CDataStream ssData(ParseHexV(params[1], "encrypted_note"), SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
try { |
|
|
|
ssData >> nonce; |
|
|
|
ssData >> epk; |
|
|
|
ssData >> ct; |
|
|
|
ssData >> h_sig; |
|
|
|
} catch(const std::exception &) { |
|
|
|
throw runtime_error( |
|
|
|
"encrypted_note could not be decoded" |
|
|
|
); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
ZCNoteDecryption decryptor(k.receiving_key()); |
|
|
|
|
|
|
|
SproutNotePlaintext npt = SproutNotePlaintext::decrypt( |
|
|
|
decryptor, |
|
|
|
ct, |
|
|
|
epk, |
|
|
|
h_sig, |
|
|
|
nonce |
|
|
|
); |
|
|
|
SproutPaymentAddress payment_addr = k.address(); |
|
|
|
SproutNote decrypted_note = npt.note(payment_addr); |
|
|
|
|
|
|
|
assert(pwalletMain != NULL); |
|
|
|
std::vector<boost::optional<SproutWitness>> witnesses; |
|
|
|
uint256 anchor; |
|
|
|
uint256 commitment = decrypted_note.cm(); |
|
|
|
pwalletMain->WitnessNoteCommitment( |
|
|
|
{commitment}, |
|
|
|
witnesses, |
|
|
|
anchor |
|
|
|
); |
|
|
|
|
|
|
|
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
ss << npt; |
|
|
|
|
|
|
|
UniValue result(UniValue::VOBJ); |
|
|
|
result.push_back(Pair("amount", ValueFromAmount(decrypted_note.value()))); |
|
|
|
result.push_back(Pair("note", HexStr(ss.begin(), ss.end()))); |
|
|
|
result.push_back(Pair("exists", (bool) witnesses[0])); |
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (!EnsureWalletIsAvailable(fHelp)) { |
|
|
|
return NullUniValue; |
|
|
|
} |
|
|
|
|
|
|
|
if (fHelp || params.size() != 5) { |
|
|
|
throw runtime_error( |
|
|
|
"zcrawjoinsplit rawtx inputs outputs vpub_old vpub_new\n" |
|
|
|
" inputs: a JSON object mapping {note: zcsecretkey, ...}\n" |
|
|
|
" outputs: a JSON object mapping {zcaddr: value, ...}\n" |
|
|
|
"\n" |
|
|
|
"DEPRECATED. Splices a joinsplit into rawtx. Inputs are unilaterally confidential.\n" |
|
|
|
"Outputs are confidential between sender/receiver. The vpub_old and\n" |
|
|
|
"vpub_new values are globally public and move transparent value into\n" |
|
|
|
"or out of the confidential value store, respectively.\n" |
|
|
|
"\n" |
|
|
|
"Note: The caller is responsible for delivering the output enc1 and\n" |
|
|
|
"enc2 to the appropriate recipients, as well as signing rawtxout and\n" |
|
|
|
"ensuring it is mined. (A future RPC call will deliver the confidential\n" |
|
|
|
"payments in-band on the blockchain.)\n" |
|
|
|
"\n" |
|
|
|
"Output: {\n" |
|
|
|
" \"encryptednote1\": enc1,\n" |
|
|
|
" \"encryptednote2\": enc2,\n" |
|
|
|
" \"rawtxn\": rawtxout\n" |
|
|
|
"}\n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
LOCK(cs_main); |
|
|
|
|
|
|
|
CTransaction tx; |
|
|
|
if (!DecodeHexTx(tx, params[0].get_str())) |
|
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed"); |
|
|
|
|
|
|
|
UniValue inputs = params[1].get_obj(); |
|
|
|
UniValue outputs = params[2].get_obj(); |
|
|
|
|
|
|
|
CAmount vpub_old(0); |
|
|
|
CAmount vpub_new(0); |
|
|
|
|
|
|
|
if (params[3].get_real() != 0.0) |
|
|
|
vpub_old = AmountFromValue(params[3]); |
|
|
|
|
|
|
|
if (params[4].get_real() != 0.0) |
|
|
|
vpub_new = AmountFromValue(params[4]); |
|
|
|
|
|
|
|
std::vector<JSInput> vjsin; |
|
|
|
std::vector<JSOutput> vjsout; |
|
|
|
std::vector<SproutNote> notes; |
|
|
|
std::vector<SproutSpendingKey> keys; |
|
|
|
std::vector<uint256> commitments; |
|
|
|
|
|
|
|
for (const string& name_ : inputs.getKeys()) { |
|
|
|
auto spendingkey = DecodeSpendingKey(inputs[name_].get_str()); |
|
|
|
if (!IsValidSpendingKey(spendingkey)) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid spending key"); |
|
|
|
} |
|
|
|
if (boost::get<libzcash::SproutSpendingKey>(&spendingkey) == nullptr) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Only works with Sprout spending keys"); |
|
|
|
} |
|
|
|
SproutSpendingKey k = boost::get<libzcash::SproutSpendingKey>(spendingkey); |
|
|
|
|
|
|
|
keys.push_back(k); |
|
|
|
|
|
|
|
SproutNotePlaintext npt; |
|
|
|
|
|
|
|
{ |
|
|
|
CDataStream ssData(ParseHexV(name_, "note"), SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
ssData >> npt; |
|
|
|
} |
|
|
|
|
|
|
|
SproutPaymentAddress addr = k.address(); |
|
|
|
SproutNote note = npt.note(addr); |
|
|
|
notes.push_back(note); |
|
|
|
commitments.push_back(note.cm()); |
|
|
|
} |
|
|
|
|
|
|
|
uint256 anchor; |
|
|
|
std::vector<boost::optional<SproutWitness>> witnesses; |
|
|
|
pwalletMain->WitnessNoteCommitment(commitments, witnesses, anchor); |
|
|
|
|
|
|
|
assert(witnesses.size() == notes.size()); |
|
|
|
assert(notes.size() == keys.size()); |
|
|
|
|
|
|
|
{ |
|
|
|
for (size_t i = 0; i < witnesses.size(); i++) { |
|
|
|
if (!witnesses[i]) { |
|
|
|
throw runtime_error( |
|
|
|
"joinsplit input could not be found in tree" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
vjsin.push_back(JSInput(*witnesses[i], notes[i], keys[i])); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
while (vjsin.size() < ZC_NUM_JS_INPUTS) { |
|
|
|
vjsin.push_back(JSInput()); |
|
|
|
} |
|
|
|
|
|
|
|
for (const string& name_ : outputs.getKeys()) { |
|
|
|
auto addrTo = DecodePaymentAddress(name_); |
|
|
|
if (!IsValidPaymentAddress(addrTo)) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid recipient address."); |
|
|
|
} |
|
|
|
if (boost::get<libzcash::SproutPaymentAddress>(&addrTo) == nullptr) { |
|
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Only works with Sprout payment addresses"); |
|
|
|
} |
|
|
|
CAmount nAmount = AmountFromValue(outputs[name_]); |
|
|
|
|
|
|
|
vjsout.push_back(JSOutput(boost::get<libzcash::SproutPaymentAddress>(addrTo), nAmount)); |
|
|
|
} |
|
|
|
|
|
|
|
while (vjsout.size() < ZC_NUM_JS_OUTPUTS) { |
|
|
|
vjsout.push_back(JSOutput()); |
|
|
|
} |
|
|
|
|
|
|
|
// TODO
|
|
|
|
if (vjsout.size() != ZC_NUM_JS_INPUTS || vjsin.size() != ZC_NUM_JS_OUTPUTS) { |
|
|
|
throw runtime_error("unsupported joinsplit input/output counts"); |
|
|
|
} |
|
|
|
|
|
|
|
uint256 joinSplitPubKey; |
|
|
|
unsigned char joinSplitPrivKey[crypto_sign_SECRETKEYBYTES]; |
|
|
|
crypto_sign_keypair(joinSplitPubKey.begin(), joinSplitPrivKey); |
|
|
|
|
|
|
|
CMutableTransaction mtx(tx); |
|
|
|
mtx.nVersion = 2; |
|
|
|
mtx.joinSplitPubKey = joinSplitPubKey; |
|
|
|
|
|
|
|
JSDescription jsdesc(*pzcashParams, |
|
|
|
joinSplitPubKey, |
|
|
|
anchor, |
|
|
|
{vjsin[0], vjsin[1]}, |
|
|
|
{vjsout[0], vjsout[1]}, |
|
|
|
vpub_old, |
|
|
|
vpub_new); |
|
|
|
|
|
|
|
{ |
|
|
|
auto verifier = libzcash::ProofVerifier::Strict(); |
|
|
|
assert(jsdesc.Verify(*pzcashParams, verifier, joinSplitPubKey)); |
|
|
|
} |
|
|
|
|
|
|
|
mtx.vjoinsplit.push_back(jsdesc); |
|
|
|
|
|
|
|
// Empty output script.
|
|
|
|
CScript scriptCode; |
|
|
|
CTransaction signTx(mtx); |
|
|
|
auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus()); |
|
|
|
uint256 dataToBeSigned = SignatureHash(scriptCode, signTx, NOT_AN_INPUT, SIGHASH_ALL, 0, consensusBranchId); |
|
|
|
|
|
|
|
// Add the signature
|
|
|
|
assert(crypto_sign_detached(&mtx.joinSplitSig[0], NULL, |
|
|
|
dataToBeSigned.begin(), 32, |
|
|
|
joinSplitPrivKey |
|
|
|
) == 0); |
|
|
|
|
|
|
|
// Sanity check
|
|
|
|
assert(crypto_sign_verify_detached(&mtx.joinSplitSig[0], |
|
|
|
dataToBeSigned.begin(), 32, |
|
|
|
mtx.joinSplitPubKey.begin() |
|
|
|
) == 0); |
|
|
|
|
|
|
|
CTransaction rawTx(mtx); |
|
|
|
|
|
|
|
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
ss << rawTx; |
|
|
|
|
|
|
|
std::string encryptedNote1; |
|
|
|
std::string encryptedNote2; |
|
|
|
{ |
|
|
|
CDataStream ss2(SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
ss2 << ((unsigned char) 0x00); |
|
|
|
ss2 << jsdesc.ephemeralKey; |
|
|
|
ss2 << jsdesc.ciphertexts[0]; |
|
|
|
ss2 << jsdesc.h_sig(*pzcashParams, joinSplitPubKey); |
|
|
|
|
|
|
|
encryptedNote1 = HexStr(ss2.begin(), ss2.end()); |
|
|
|
} |
|
|
|
{ |
|
|
|
CDataStream ss2(SER_NETWORK, PROTOCOL_VERSION); |
|
|
|
ss2 << ((unsigned char) 0x01); |
|
|
|
ss2 << jsdesc.ephemeralKey; |
|
|
|
ss2 << jsdesc.ciphertexts[1]; |
|
|
|
ss2 << jsdesc.h_sig(*pzcashParams, joinSplitPubKey); |
|
|
|
|
|
|
|
encryptedNote2 = HexStr(ss2.begin(), ss2.end()); |
|
|
|
} |
|
|
|
|
|
|
|
UniValue result(UniValue::VOBJ); |
|
|
|
result.push_back(Pair("encryptednote1", encryptedNote1)); |
|
|
|
result.push_back(Pair("encryptednote2", encryptedNote2)); |
|
|
|
result.push_back(Pair("rawtxn", HexStr(ss.begin(), ss.end()))); |
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
UniValue zc_raw_keygen(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (!EnsureWalletIsAvailable(fHelp)) { |
|
|
|
return NullUniValue; |
|
|
|
} |
|
|
|
|
|
|
|
if (fHelp || params.size() != 0) { |
|
|
|
throw runtime_error( |
|
|
|
"zcrawkeygen\n" |
|
|
|
"\n" |
|
|
|
"DEPRECATED. Generate a zcaddr which can send and receive confidential values.\n" |
|
|
|
"\n" |
|
|
|
"Output: {\n" |
|
|
|
" \"zcaddress\": zcaddr,\n" |
|
|
|
" \"zcsecretkey\": zcsecretkey,\n" |
|
|
|
" \"zcviewingkey\": zcviewingkey,\n" |
|
|
|
"}\n" |
|
|
|
); |
|
|
|
} |
|
|
|
|
|
|
|
auto k = SproutSpendingKey::random(); |
|
|
|
auto addr = k.address(); |
|
|
|
auto viewing_key = k.viewing_key(); |
|
|
|
|
|
|
|
UniValue result(UniValue::VOBJ); |
|
|
|
result.push_back(Pair("zcaddress", EncodePaymentAddress(addr))); |
|
|
|
result.push_back(Pair("zcsecretkey", EncodeSpendingKey(k))); |
|
|
|
result.push_back(Pair("zcviewingkey", EncodeViewingKey(viewing_key))); |
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
UniValue z_getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk) |
|
|
|
{ |
|
|
|
if (!EnsureWalletIsAvailable(fHelp)) |
|
|
|
@ -8776,11 +8307,6 @@ static const CRPCCommand commands[] = |
|
|
|
{ "wallet", "walletlock", &walletlock, true }, |
|
|
|
{ "wallet", "walletpassphrasechange", &walletpassphrasechange, true }, |
|
|
|
{ "wallet", "walletpassphrase", &walletpassphrase, true }, |
|
|
|
{ "wallet", "zcbenchmark", &zc_benchmark, true }, |
|
|
|
{ "wallet", "zcrawkeygen", &zc_raw_keygen, true }, |
|
|
|
{ "wallet", "zcrawjoinsplit", &zc_raw_joinsplit, true }, |
|
|
|
{ "wallet", "zcrawreceive", &zc_raw_receive, true }, |
|
|
|
{ "wallet", "zcsamplejoinsplit", &zc_sample_joinsplit, true }, |
|
|
|
{ "wallet", "z_listreceivedbyaddress", &z_listreceivedbyaddress, false }, |
|
|
|
{ "wallet", "z_listunspent", &z_listunspent, false }, |
|
|
|
{ "wallet", "z_getbalance", &z_getbalance, false }, |
|
|
|
|
