diff --git a/qa/rpc-tests/shieldcoinbase_donation.py b/qa/rpc-tests/shieldcoinbase_donation.py new file mode 100755 index 000000000..cce21d85b --- /dev/null +++ b/qa/rpc-tests/shieldcoinbase_donation.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +# Copyright (c) 2016-2025 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 + +from test_framework.test_framework import BitcoinTestFramework +from test_framework.authproxy import JSONRPCException +from test_framework.util import assert_equal, assert_greater_than, assert_greater_than_or_equal, \ + initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ + stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises, assert_true, \ + wait_and_assert_operationid_status + +import time +from decimal import Decimal + +def assert_success(result): + assert_equal(result['result'], 'success') + +def assert_error(result): + assert_equal(result['result'], 'error') + +class ShieldCoinbaseDonationTest (BitcoinTestFramework): + def setup_chain(self): + print("Initializing test directory "+self.options.tmpdir) + self.num_nodes = 1 + self.options.nocleanup = 1 # do not delete datadir after test run + #self.options.nocleanup = 0 + initialize_chain_clean(self.options.tmpdir, self.num_nodes) + + def setup_network(self, split = False): + print("Setting up network...") + self.supply = 555 + self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, + extra_args=[[ + # always give -ac_name as first extra_arg and port as third + '-ac_name=ZZZ', + #'-ac_algo=randomx', + #'-testnode=1', # why does this make the test node hang before run_test() ? + '-conf='+self.options.tmpdir+'/node0/regtest/ZZZ.conf', + '-port=63367', + '-rpcport=63368', + '-ac_supply=' + str(self.supply), + '-ac_reward=300000000', + '-ac_private=1', + '-allowlist=127.0.0.1', + '-regtest', + '--daemon', + #'-debug', + '-zrpc', + '-zdebug', + '-zrpcunsafe' + ]] + ) + self.is_network_split = False + self.rpc = self.nodes[0] + self.sync_all() + print("Done setting up network") + + def run_test (self): + # NOTE: order of these tests is important + self.run_test_default() + self.run_test_custom() + self.run_test_custom_nondefault_fee() + + def run_test_default(self): + rpc = self.nodes[0] + + # mine initial ac_supply + rpc.generate(1) + self.sync_all() + + zaddr1 = rpc.z_getnewaddress() + #rpc.z_exportkey(zaddr1) + + # first we test the default situation where no donation is given and + # it defaults to 0 + response = rpc.z_shieldcoinbase('*', zaddr1, 0, 1) + opid = response['opid'] + shieldingValue = response['shieldingValue'] + + assert_true( shieldingValue >= self.supply ) + + print("opid=" + opid) + + time.sleep(2) # give some time for the ztx to complete + + # 555 supply plus magic utxo = 555.05537304 + # NOTE: if any consensus params for this testcoin are changed above, + # the magic utxo will change and this value will need to be updated + totalSupply = 55505537304 # in puposhis + expectedAmount = totalSupply + + json = rpc.z_getoperationstatus() + txid = json[0]['result']['txid'] + + wait_and_assert_operationid_status(rpc, opid) + + rawtx0 = rpc.z_viewtransaction(txid) + assert_equal( rawtx0['outputs'][0]['valueZat'] , expectedAmount, '5% donation sends correct sendAmount') + + def run_test_custom_nondefault_fee(self): + rpc = self.nodes[0] + zaddr1 = rpc.z_getnewaddress() + + donation = 5 + + # donation zaddr is already imported from previous test + # NOTE: goal here is to test a situation where + # sendAmount/donationAmount arithmetic leads to a situation where the + # exact amount in satoshis must deal with truncation/rounding + + # shield funds to a new zaddr in this wallet with non-default fee + fee = 0.00000001 # 1 puposhi fee will lead to some kind of rounding/truncation arithmetic + response = rpc.z_shieldcoinbase('*', zaddr1, fee, 1, donation) + opid = response['opid'] + print("opid=" + opid) + + shieldingValue = response['shieldingValue'] + # sanity check. None of the expected values below will be correct if + # this is different + assert_equal( str(shieldingValue) , "3.00010000" ) + + # TODO: this might not be enough time for slow machines, better + # solution would be to wait until the opid finishes + time.sleep(2) # give some time for the ztx to complete + + # confirm tx from above + rpc.generate(1) + self.sync_all() + + # get the txid + json = rpc.z_getoperationstatus() + # NOTE: this is index 1 because this test runs after the above test + # It would be better to specifically find the data for our opid + txid = json[1]['result']['txid'] + print("txid=" + txid) + + rpc.z_listunspent() + + # (300010000 - 1)*.05 + # 15000499.95 + # (300010000 - 1) - 15000499 + # 285009500 + # The above value will be truncated (not rounded) by casting from + # double to CAmount/int64_t which means the donation will be 15000499 + # and the sendAmount will be 300010000 - 1 (the fee) - 15000499 = 285009500 + + + # these values assume that 3.0001 was shielded + expectedSendAmount = 285009500 + expectedDonationAmount = 15000499 + + # lookup txid + rawtx1 = rpc.z_viewtransaction(txid) + + # TODO: set this up once for all tests since they all use the same zaddr + donation_zaddr = "zregtestsapling1y30nwg0clsu6gcyrnvht8hdyfk3vwtszlh6kc4z5hv9hmpxzg2g0nx7c60xeecggm9x9gma96t4" + + # there should be two outputs to different addresses, order is nondeterministic + if rawtx1['outputs'][0]['address'] == donation_zaddr: + donation_zout = 0 + other_zout = 1 + else: + donation_zout = 1 + other_zout = 0 + + assert_equal( rawtx1['outputs'][donation_zout]['address'] , donation_zaddr, 'correct zaddr gets donation') + assert_equal( rawtx1['outputs'][donation_zout]['valueZat'] , expectedDonationAmount, '5% donation sends correct donationAmount') + + assert_equal( rawtx1['outputs'][other_zout]['address'] , zaddr1, 'correct zaddr gets main amount') + assert_equal( rawtx1['outputs'][other_zout]['valueZat'] , expectedSendAmount, '5% donation sends correct sendAmount') + + #TODO: assert sum = 3 + + def run_test_custom(self): + rpc = self.nodes[0] + zaddr1 = rpc.z_getnewaddress() + + # generate some new coinbase funds + rpc.generate(1) + self.sync_all() + + testing_zaddr = "zregtestsapling1y30nwg0clsu6gcyrnvht8hdyfk3vwtszlh6kc4z5hv9hmpxzg2g0nx7c60xeecggm9x9gma96t4" + testing_privkey = "secret-extended-key-regtest1q0hgrms7qqqqpqrsz6myrtnh3ccp8uzp0kgxj6029wr6vq5hqvyccdlz7a745pgm5eeaamxqp9rxll2xctfrlw2l8xhxsc7zsut2tyz0374rrlk8srjswx7rhm6hcf2d7fuwajazvjesafduzxyka4w02tqjxdehzvghyrsd2zll90k3g2ckdvc5kqd6r7r7nglrtj0ej5a40d6lh8zxrvdlxrpuc59y5m8n9tekdxh4wpqn3smv5nxu4vvu58f8dgwn92qfqrvxqlscchtyh" + + # import zaddr that receives donation , no rescan + rpc.z_importkey(testing_privkey, "no") + + rpc.z_listaddresses() + + # now we test giving a donation parameter + donation = 5 + + # shield funds to a new zaddr in this wallet with default fee + fee = 0.0001 + response = rpc.z_shieldcoinbase('*', zaddr1, fee, 1, donation) + opid = response['opid'] + print("opid=" + opid) + #wait_and_assert_operationid_status(rpc, opid) + shieldingValue = response['shieldingValue'] + + assert_greater_than_or_equal( shieldingValue , 3.0 ) + + time.sleep(2) # give some time for the ztx to complete + + rpc.getinfo() + + rpc.generate(1) + self.sync_all() + + # get the txid + json = rpc.z_getoperationstatus() + txid = json[0]['result']['txid'] + print("txid=" + txid) + + rpc.z_listunspent() + + # (3 - fee)*0.05 + expectedAmount1 = 14999500 + + # lookup txid + rawtx1 = rpc.z_viewtransaction(txid) + # there should be two outputs to different addresses, order is nondeterministic + if rawtx1['outputs'][0]['address'] == testing_zaddr: + donation_zout = 0 + other_zout = 1 + else: + donation_zout = 1 + other_zout = 0 + + # print("donation_zout=%d other_zout=%d" % (donation_zout,other_zout) ) + + assert_equal( rawtx1['outputs'][donation_zout]['address'] , testing_zaddr, 'correct zaddr gets donation') + assert_equal( rawtx1['outputs'][donation_zout]['valueZat'] , expectedAmount1, '5% donation sends correct donationAmount') + + # (3 - fee)*0.95 + expectedAmount2 = 284990500 + assert_equal( rawtx1['outputs'][other_zout]['address'] , zaddr1, 'correct zaddr gets main amount') + assert_equal( rawtx1['outputs'][other_zout]['valueZat'] , expectedAmount2, '5% donation sends correct sendAmount') + + + assert_equal( expectedAmount1 + expectedAmount2, 299990000, 'sendAmount+donationAmount = targetAmount - fee' ) + + +if __name__ == '__main__': + ShieldCoinbaseDonationTest().main() + diff --git a/src/transaction_builder.cpp b/src/transaction_builder.cpp index f942296a8..10f2383e5 100644 --- a/src/transaction_builder.cpp +++ b/src/transaction_builder.cpp @@ -54,6 +54,9 @@ void TransactionBuilder::AddSaplingOutput( CAmount value, std::array memo) { + if(fZdebug) { + LogPrintf("%s: adding output with value=%ld\n", __func__, value); + } auto note = libzcash::SaplingNote(to, value); outputs.emplace_back(ovk, note, memo); mtx.valueBalance -= value; diff --git a/src/wallet/asyncrpcoperation_shieldcoinbase.cpp b/src/wallet/asyncrpcoperation_shieldcoinbase.cpp index 57113f930..34d87b58f 100644 --- a/src/wallet/asyncrpcoperation_shieldcoinbase.cpp +++ b/src/wallet/asyncrpcoperation_shieldcoinbase.cpp @@ -54,8 +54,9 @@ AsyncRPCOperation_shieldcoinbase::AsyncRPCOperation_shieldcoinbase( std::vector inputs, std::string toAddress, CAmount fee, + uint8_t donation, UniValue contextInfo) : - builder_(builder), tx_(contextualTx), inputs_(inputs), fee_(fee), contextinfo_(contextInfo) + builder_(builder), tx_(contextualTx), inputs_(inputs), fee_(fee), donation_(donation), contextinfo_(contextInfo) { assert(contextualTx.nVersion >= 2); // transaction format version must support vjoinsplit @@ -67,6 +68,10 @@ AsyncRPCOperation_shieldcoinbase::AsyncRPCOperation_shieldcoinbase( throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Empty inputs"); } + if (donation < 0 || donation > 10 ) { + throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid donation percentage, must be an integer between 0 and 10"); + } + // Check the destination address is valid for this network i.e. not testnet being used on mainnet auto address = DecodePaymentAddress(toAddress); if (IsValidPaymentAddress(address)) { @@ -161,24 +166,7 @@ void AsyncRPCOperation_shieldcoinbase::main() { bool AsyncRPCOperation_shieldcoinbase::main_impl() { CAmount minersFee = fee_; - - size_t numInputs = inputs_.size(); - - /* - // Check mempooltxinputlimit to avoid creating a transaction which the local mempool rejects - size_t limit = (size_t)GetArg("-mempooltxinputlimit", 0); - { - LOCK(cs_main); - if (NetworkUpgradeActive(chainActive.Height() + 1, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER)) { - limit = 0; - } - } - if (limit>0 && numInputs > limit) { - throw JSONRPCError(RPC_WALLET_ERROR, - strprintf("Number of inputs %d is greater than mempooltxinputlimit of %d", - numInputs, limit)); - } - */ + size_t numInputs = inputs_.size(); CAmount targetAmount = 0; for (ShieldCoinbaseUTXO & utxo : inputs_) { @@ -192,10 +180,10 @@ bool AsyncRPCOperation_shieldcoinbase::main_impl() { } CAmount sendAmount = targetAmount - minersFee; - LogPrint("zrpc", "%s: spending %s to shield %s with fee %s\n", - getId(), FormatMoney(targetAmount), FormatMoney(sendAmount), FormatMoney(minersFee)); + LogPrint("zrpc", "%s: spending %s to shield %s with fee %s, donation=%d\n", + getId(), FormatMoney(targetAmount), FormatMoney(sendAmount), FormatMoney(minersFee), donation_); - return boost::apply_visitor(ShieldToAddress(this, sendAmount), tozaddr_); + return boost::apply_visitor(ShieldToAddress(this, sendAmount, donation_), tozaddr_); } extern UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk); @@ -228,20 +216,55 @@ bool ShieldToAddress::operator()(const libzcash::SaplingPaymentAddress &zaddr) c m_op->builder_.AddTransparentInput(COutPoint(t.txid, t.vout), t.scriptPubKey, t.amount); } } + //TODO: TESTING zaddr only, only use on regtest + //TODO: randomly select from a set + auto dzaddr = "zregtestsapling1y30nwg0clsu6gcyrnvht8hdyfk3vwtszlh6kc4z5hv9hmpxzg2g0nx7c60xeecggm9x9gma96t4"; + auto donationZaddr = DecodePaymentAddress(dzaddr); + if (!IsValidPaymentAddress(donationZaddr)) { + throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid donation zaddr, Unknown address format: ") + dzaddr); + } - // Send all value to the target z-addr - m_op->builder_.SendChangeTo(zaddr, ovk); + if(donation) { + //if donation>0, send X% of value to zaddr and Y% of of value to donatezaddr where X+Y=100% + + // calculate donation as a double then convert to CAmount + double amount = (static_cast(donation)/100)*static_cast(sendAmount); + CAmount donationAmount = static_cast(amount); + + // add original recipient as first output, with sendAmount less the donation + CAmount newAmount = sendAmount - donationAmount; + m_op->builder_.AddSaplingOutput(ovk, zaddr, newAmount); + + auto donationZout = boost::get(donationZaddr); + m_op->builder_.AddSaplingOutput(ovk, donationZout, donationAmount); + + if(fZdebug) { + LogPrintf("%s: donation=%ld, sendAmount=%ld, newAmount=%ld, donationAmount=%ld, newAmount+donationAmount=%ld fee=%ld\n", __func__, + donation, sendAmount, newAmount, donationAmount, newAmount+donationAmount, m_op->fee_); + } + + // zdust as third output, so donation txs are indistinguishable from + // non-donation z_shieldcoinbase txs + auto zdust1 = DecodePaymentAddress(randomSietchZaddr()); + auto sietchZout1 = boost::get(zdust1); + m_op->builder_.AddSaplingOutput(ovk, sietchZout1, 0); + + } else { + // Send all value to the target z-addr + m_op->builder_.SendChangeTo(zaddr, ovk); + + // Sietchified Shielding of Coinbase Funds + // Add Sietch zouts so it's unclear which zout contains value :) + // This reduces metadata leakage of coinbase t=>z tx's + CAmount amount = 0; + auto zdust1 = DecodePaymentAddress(randomSietchZaddr()); + auto zdust2 = DecodePaymentAddress(randomSietchZaddr()); + auto sietchZout1 = boost::get(zdust1); + auto sietchZout2 = boost::get(zdust2); + m_op->builder_.AddSaplingOutput(ovk, sietchZout1, amount); + m_op->builder_.AddSaplingOutput(ovk, sietchZout2, amount); + } - // Sietchified Shielding of Coinbase Funds - // Add Sietch zouts so it's unclear which zout contains value :) - // This reduces metadata leakage of coinbase t=>z tx's - CAmount amount = 0; - auto zdust1 = DecodePaymentAddress(randomSietchZaddr()); - auto zdust2 = DecodePaymentAddress(randomSietchZaddr()); - auto sietchZout1 = boost::get(zdust1); - auto sietchZout2 = boost::get(zdust2); - m_op->builder_.AddSaplingOutput(ovk, sietchZout1, amount); - m_op->builder_.AddSaplingOutput(ovk, sietchZout2, amount); // Build the transaction auto maybe_tx = m_op->builder_.Build(); diff --git a/src/wallet/asyncrpcoperation_shieldcoinbase.h b/src/wallet/asyncrpcoperation_shieldcoinbase.h index b9a49611d..121d214b9 100644 --- a/src/wallet/asyncrpcoperation_shieldcoinbase.h +++ b/src/wallet/asyncrpcoperation_shieldcoinbase.h @@ -49,6 +49,7 @@ public: std::vector inputs, std::string toAddress, CAmount fee = SHIELD_COINBASE_DEFAULT_MINERS_FEE, + uint8_t donation = 0, UniValue contextInfo = NullUniValue); virtual ~AsyncRPCOperation_shieldcoinbase(); @@ -63,7 +64,6 @@ public: virtual UniValue getStatus() const; bool testmode = false; // Set to true to disable sending txs and generating proofs - bool cheatSpend = false; // set when this is shielding a cheating coinbase private: friend class ShieldToAddress; @@ -76,6 +76,9 @@ private: std::vector inputs_; + // this is a donation % between 0 and 10, not a CAmount + uint8_t donation_; + TransactionBuilder builder_; CTransaction tx_; @@ -92,15 +95,15 @@ class ShieldToAddress : public boost::static_visitor private: AsyncRPCOperation_shieldcoinbase *m_op; CAmount sendAmount; + uint8_t donation = 0; public: - ShieldToAddress(AsyncRPCOperation_shieldcoinbase *op, CAmount sendAmount) : - m_op(op), sendAmount(sendAmount) {} + ShieldToAddress(AsyncRPCOperation_shieldcoinbase *op, CAmount sendAmount, uint8_t donation) : + m_op(op), sendAmount(sendAmount), donation(donation) {} bool operator()(const libzcash::SaplingPaymentAddress &zaddr) const; bool operator()(const libzcash::InvalidEncoding& no) const; }; - // To test private methods, a friend class can act as a proxy class TEST_FRIEND_AsyncRPCOperation_shieldcoinbase { public: @@ -131,6 +134,4 @@ public: } }; - #endif /* ASYNCRPCOPERATION_SHIELDCOINBASE_H */ - diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp index e53fbec1e..da348b76f 100644 --- a/src/wallet/rpcwallet.cpp +++ b/src/wallet/rpcwallet.cpp @@ -1341,19 +1341,19 @@ UniValue sendfrom(const UniValue& params, bool fHelp, const CPubKey& mypk) "\nSend 0.01 " + strprintf("%s",hush_chainname()) + " from the default account to the address, must have at least 1 confirmation\n" + HelpExampleCli("sendfrom", "\"\" \"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\" 0.01") + "\nSend 0.01 from the tabby account to the given address, funds must have at least 6 confirmations\n" - + HelpExampleCli("sendfrom", "\"tabby\" \"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\" 0.01 6 \"donation\" \"seans outpost\"") + + + HelpExampleCli("sendfrom", "\"tabby\" \"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\" 0.01 6 \"donation\" \"Hush Puppy Freedom Fund\"") + "\nAs a json rpc call\n" - + HelpExampleRpc("sendfrom", "\"tabby\", \"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", 0.01, 6, \"donation\", \"seans outpost\"") + + HelpExampleRpc("sendfrom", "\"tabby\", \"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", 0.01, 6, \"donation\", \"Hush Puppy Freedom Fund\"") ); if ( ASSETCHAINS_PRIVATE != 0 ) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "cant use transparent addresses in private chain"); + throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot use transparent addresses in private chain"); LOCK2(cs_main, pwalletMain->cs_wallet); std::string strAccount = AccountFromValue(params[0]); CTxDestination dest = DecodeDestination(params[1].get_str()); if (!IsValidDestination(dest)) { - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Hush address!"); + throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address!"); } CAmount nAmount = AmountFromValue(params[2]); if (nAmount <= 0) @@ -4828,7 +4828,7 @@ UniValue z_viewtransaction(const UniValue& params, bool fHelp, const CPubKey& my UniValue entry(UniValue::VOBJ); if (!pwalletMain->mapWallet.count(hash)) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet Hush transaction id!"); + throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id!"); const CWalletTx& wtx = pwalletMain->mapWallet[hash]; entry.push_back(Pair("txid", hash.GetHex())); @@ -5487,9 +5487,9 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp if (!EnsureWalletIsAvailable(fHelp)) return NullUniValue; - if (fHelp || params.size() < 2 || params.size() > 4) + if (fHelp || params.size() < 2 || params.size() > 5) throw runtime_error( - "z_shieldcoinbase \"fromaddress\" \"tozaddress\" ( fee ) ( limit )\n" + "z_shieldcoinbase \"fromaddress\" \"tozaddress\" ( fee ) ( limit ) ( donation )\n" "\nShield transparent coinbase funds by sending to a shielded zaddr. This is an asynchronous operation and utxos" "\nselected for shielding will be locked. If there is an error, they are unlocked. The RPC call `listlockunspent`" "\ncan be used to return a list of locked utxos. The number of coinbase utxos selected for shielding can be limited" @@ -5502,15 +5502,16 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp "2. \"toaddress\" (string, required) The address is a zaddr.\n" "3. fee (numeric, optional, default=" + strprintf("%s", FormatMoney(SHIELD_COINBASE_DEFAULT_MINERS_FEE)) + ") The fee amount to attach to this transaction.\n" - "4. limit (numeric, optional, default=" + "4. limit (integer, optional, default=" + strprintf("%d", SHIELD_COINBASE_DEFAULT_LIMIT) + ") Limit on the maximum number of utxos to shield. Set to 0 to use as many as will fit in the transaction.\n" + "5. donation (integer, optional, default=0) Percentage of coinbase funds to donate. Must be between 0 and 10 inclusive.\n" "\nResult:\n" "{\n" - " \"remainingUTXOs\": xxx (numeric) Number of coinbase utxos still available for shielding.\n" + " \"remainingUTXOs\": xxx (integer) Number of coinbase utxos still available for shielding.\n" " \"remainingValue\": xxx (numeric) Value of coinbase utxos still available for shielding.\n" - " \"shieldingUTXOs\": xxx (numeric) Number of coinbase utxos being shielded.\n" - " \"shieldingValue\": xxx (numeric) Value of coinbase utxos being shielded.\n" - " \"opid\": xxx (string) An operationid to pass to z_getoperationstatus to get the result of the operation.\n" + " \"shieldingUTXOs\": xxx (integer) Number of coinbase utxos being shielded.\n" + " \"shieldingValue\": xxx (numeric) Value of coinbase utxos being shielded.\n" + " \"opid\": xxx (string) An operationid to pass to z_getoperationstatus to get the result of the operation.\n" "}\n" "\nExamples:\n" + HelpExampleCli("z_shieldcoinbase", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\" \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"") @@ -5559,6 +5560,16 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp } } + uint8_t donation = 0; + if (params.size() > 4) { + donation = params[4].get_int(); + if (donation < 0 || donation > 10 ) { + throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid donation percentage, must be an integer between 0 and 10"); + } + } + + LogPrintf("%s: donation=%d\n", __func__, donation); + int nextBlockHeight = chainActive.Height() + 1; bool overwinterActive = nextBlockHeight>=1 ? true : false; // NetworkUpgradeActive(nextBlockHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER); unsigned int max_tx_size = MAX_TX_SIZE_AFTER_SAPLING; @@ -5659,15 +5670,13 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp contextInfo.push_back(Pair("fromaddress", params[0])); contextInfo.push_back(Pair("toaddress", params[1])); contextInfo.push_back(Pair("fee", ValueFromAmount(nFee))); + contextInfo.push_back(Pair("donation", donation)); - // Builder (used if Sapling addresses are involved) - TransactionBuilder builder = TransactionBuilder( - Params().GetConsensus(), nextBlockHeight, pwalletMain); + TransactionBuilder builder = TransactionBuilder( Params().GetConsensus(), nextBlockHeight, pwalletMain); // Contextual transaction we will build on int blockHeight = chainActive.LastTip()->GetHeight(); nextBlockHeight = blockHeight + 1; - // (used if no Sapling addresses are involved) CMutableTransaction contextualTx = CreateNewContextualCMutableTransaction( Params().GetConsensus(), nextBlockHeight); contextualTx.nLockTime = chainActive.LastTip()->GetHeight(); @@ -5678,7 +5687,7 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp // Create operation and add to global queue std::shared_ptr q = getAsyncRPCQueue(); - std::shared_ptr operation( new AsyncRPCOperation_shieldcoinbase(builder, contextualTx, inputs, destaddress, nFee, contextInfo) ); + std::shared_ptr operation( new AsyncRPCOperation_shieldcoinbase(builder, contextualTx, inputs, destaddress, nFee, donation, contextInfo) ); q->addOperation(operation); AsyncRPCOperationId operationId = operation->getId(); @@ -5688,6 +5697,7 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp o.push_back(Pair("remainingValue", ValueFromAmount(remainingValue))); o.push_back(Pair("shieldingUTXOs", static_cast(numUtxos))); o.push_back(Pair("shieldingValue", ValueFromAmount(shieldedValue))); + o.push_back(Pair("donation", donation)); o.push_back(Pair("opid", operationId)); return o; } diff --git a/test.sh b/test.sh index a48d5f3f8..dba7a8c15 100755 --- a/test.sh +++ b/test.sh @@ -7,4 +7,5 @@ export PYTHONPATH=./qa/rpc-tests/test_framework/ #./qa/rpc-tests/ac_private.py -./qa/rpc-tests/lockzins.py --tracerpc +# ./qa/rpc-tests/lockzins.py --tracerpc + ./qa/rpc-tests/shieldcoinbase_donation.py --tracerpc