From 8165ec828932aa468624fa66b1188a1cbbea327f Mon Sep 17 00:00:00 2001 From: Ruslan Kasheparov Date: Tue, 30 Jun 2026 12:37:36 +0200 Subject: [PATCH] rpc: fix fields type in man --- src/rpc/blockchain.cpp | 8 +- src/rpc/node.cpp | 19 +-- src/rpc/rawtransaction.cpp | 207 ++++++++++++++++++-------------- src/wallet/rpc/backup.cpp | 8 +- src/wallet/rpc/elements.cpp | 36 +++--- src/wallet/rpc/spend.cpp | 17 ++- src/wallet/rpc/transactions.cpp | 17 ++- 7 files changed, 172 insertions(+), 140 deletions(-) diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp index 84ceaafa29..2eebb8c1c7 100644 --- a/src/rpc/blockchain.cpp +++ b/src/rpc/blockchain.cpp @@ -1454,14 +1454,14 @@ RPCHelpMan getblockchaininfo() {RPCResult::Type::NUM, "blocks", "the height of the most-work fully-validated chain. The genesis block has height 0"}, {RPCResult::Type::NUM, "headers", "the current number of headers we have validated"}, {RPCResult::Type::STR, "bestblockhash", "the hash of the currently best block"}, - /* ELEMENTS: not present {RPCResult::Type::NUM, "difficulty", "the current difficulty"}, */ - {RPCResult::Type::STR_HEX, "bits", "nBits: compact representation of the block difficulty target"}, - {RPCResult::Type::STR_HEX, "target", "The difficulty target"}, + {RPCResult::Type::STR_HEX, "bits", /*optional=*/true, "nBits: compact representation of the block difficulty target"}, + {RPCResult::Type::STR_HEX, "target", /*optional=*/true, "The difficulty target"}, + {RPCResult::Type::NUM, "difficulty", /*optional=*/true, "the current difficulty"}, {RPCResult::Type::NUM_TIME, "time", "The block time expressed in " + UNIX_EPOCH_TIME}, {RPCResult::Type::NUM_TIME, "mediantime", "The median block time expressed in " + UNIX_EPOCH_TIME}, {RPCResult::Type::NUM, "verificationprogress", "estimate of verification progress [0..1]"}, {RPCResult::Type::BOOL, "initialblockdownload", "(debug information) estimate of whether this node is in Initial Block Download mode"}, - /* ELEMENTS: not present {RPCResult::Type::STR_HEX, "chainwork", "total amount of work in active chain, in hexadecimal"}, */ + {RPCResult::Type::STR_HEX, "chainwork", /*optional=*/true, "total amount of work in active chain, in hexadecimal"}, {RPCResult::Type::NUM, "size_on_disk", "the estimated size of the block and undo files on disk"}, {RPCResult::Type::BOOL, "pruned", "if the blocks are subject to pruning"}, {RPCResult::Type::BOOL, "trim_headers", "whether header trimming is enabled (-trim-headers)"}, diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp index 2dccb4827a..5e8b77b856 100644 --- a/src/rpc/node.cpp +++ b/src/rpc/node.cpp @@ -422,7 +422,8 @@ static RPCHelpMan tweakfedpegscript() RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR_HEX, "script", "The fedpegscript tweaked with claim_script"}, - {RPCResult::Type::STR, "address", "The address corresponding to the tweaked fedpegscript"}, + {RPCResult::Type::STR, "p2wsh", "The native segwit address for the tweaked fedpegscript"}, + {RPCResult::Type::STR, "p2shwsh", "The P2SH-wrapped segwit address for the tweaked fedpegscript"}, } }, RPCExamples{""}, @@ -492,7 +493,11 @@ static RPCHelpMan getpakinfo() { {RPCResult::Type::OBJ, "block_paklist", "The PAK list loaded from latest epoch", { - {RPCResult::Type::ELISION, "", ""} + {RPCResult::Type::ARR, "online", "Online PAK pubkeys in hex", + {{RPCResult::Type::STR_HEX, "", "online pubkey"}}}, + {RPCResult::Type::ARR, "offline", "Offline PAK pubkeys in hex", + {{RPCResult::Type::STR_HEX, "", "offline pubkey"}}}, + {RPCResult::Type::BOOL, "reject", "Whether peg-outs are rejected (no offline keys)"}, }}, } }, @@ -516,9 +521,9 @@ static RPCHelpMan calcfastmerkleroot() return RPCHelpMan{"calcfastmerkleroot", "\nhidden utility RPC for computing sha2 midstates\n", { - {"leaves", RPCArg::Type::ARR, RPCArg::Optional::NO, "array of data to compute the fast merkle root of.", + {"leaves", RPCArg::Type::ARR, RPCArg::Optional::NO, "Array of 32-byte hashes to compute the fast merkle root of.", { - {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "hex-encoded data"}, + {"hash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "32-byte hex-encoded hash"}, }}, }, RPCResult{ @@ -548,12 +553,12 @@ static RPCHelpMan calcfastmerkleroot() static RPCHelpMan dumpassetlabels() { return RPCHelpMan{"dumpassetlabels", - "\nLists all known asset id/label pairs in this wallet. This list can be modified with `-assetdir` configuration argument.\n", + "\nLists all known asset label/id pairs known to this node. This list can be modified with the `-assetdir` configuration argument.\n", {}, RPCResult{ RPCResult::Type::OBJ, "labels", "", { - {RPCResult::Type::ELISION, "", "the label for each asset id"}, + {RPCResult::Type::ELISION, "", "the asset id (hex) for each label"}, }, }, RPCExamples{ @@ -623,7 +628,7 @@ static RPCHelpMan createblindedaddress() {"blinding_key", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The blinding public key. This can be obtained for a given address using `getaddressinfo` (`confidential_key` field)."}, }, RPCResult{ - RPCResult::Type::STR, "blinded_address", "The blinded address" + RPCResult::Type::STR, "", "The blinded address" }, RPCExamples{ "\nCreate a blinded address\n" diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp index 2ea9c3e21c..abf7cd1866 100644 --- a/src/rpc/rawtransaction.cpp +++ b/src/rpc/rawtransaction.cpp @@ -98,17 +98,16 @@ static std::vector DecodeTxDoc(const std::string& txid_field_doc) { return { // When updating this documentation, update `getrawtransaction` in the same way. - {RPCResult::Type::STR_HEX, "txid", "The transaction id"}, + {RPCResult::Type::STR_HEX, "txid", txid_field_doc}, {RPCResult::Type::STR_HEX, "hash", "The transaction hash (differs from txid for witness transactions)"}, - {RPCResult::Type::OBJ, "fee", "The fee specified in the transaction", {}, /*skip_type_check=*/true}, // Elements: this is an object + {RPCResult::Type::STR_HEX, "wtxid", /*optional=*/true, "The witness transaction id"}, + {RPCResult::Type::STR_HEX, "withash", /*optional=*/true, "Hash of witness serialization only"}, + {RPCResult::Type::NUM, "version", "The version"}, {RPCResult::Type::NUM, "size", "The serialized transaction size"}, {RPCResult::Type::NUM, "vsize", "The virtual transaction size (differs from size for witness transactions)"}, {RPCResult::Type::NUM, "weight", "The transaction's weight (between vsize*4-3 and vsize*4)"}, {RPCResult::Type::NUM, "discountvsize", /*optional=*/true, "The discounted virtual transaction size, only differs from vsize for Confidential Transactions"}, {RPCResult::Type::NUM, "discountweight", /*optional=*/true, "The discounted transaction weight, only differs from weight for Confidential Transactions"}, - {RPCResult::Type::STR_HEX, "withash", /*optional=*/true, "The hash of the witness"}, - {RPCResult::Type::STR_HEX, "wtxid", /*optional=*/true, "Hash of the serialized transaction, including witness data"}, - {RPCResult::Type::NUM, "version", "The version"}, {RPCResult::Type::NUM_TIME, "locktime", "The lock time"}, {RPCResult::Type::ARR, "vin", "", { @@ -122,27 +121,27 @@ static std::vector DecodeTxDoc(const std::string& txid_field_doc) {RPCResult::Type::STR, "asm", "Disassembly of the signature script"}, {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"}, }}, + {RPCResult::Type::BOOL, "is_pegin", /*optional=*/true, "Whether this input is a peg-in (if not coinbase transaction)"}, + {RPCResult::Type::NUM, "sequence", "The script sequence number"}, {RPCResult::Type::ARR, "txinwitness", /*optional=*/true, "", { - {RPCResult::Type::STR_HEX, "hex", "hex-encoded witness data (if any)"}, + {RPCResult::Type::STR_HEX, "", "hex-encoded witness stack item (if any)"}, }}, - {RPCResult::Type::NUM, "sequence", "The script sequence number"}, - {RPCResult::Type::BOOL, "is_pegin", /*optional=*/true, "Is this input a pegin"}, {RPCResult::Type::ARR, "pegin_witness", /*optional=*/true, "", { - {RPCResult::Type::STR_HEX, "", "hex-encoded witness data (if any)"}, + {RPCResult::Type::STR_HEX, "", "hex-encoded peg-in witness stack item (if any)"}, }}, - {RPCResult::Type::OBJ, "issuance", /*optional=*/true, "", + {RPCResult::Type::OBJ, "issuance", /*optional=*/true, "Asset issuance data (if present on input)", { - {RPCResult::Type::STR_HEX, "assetBlindingNonce", /*optional=*/true, ""}, - {RPCResult::Type::STR_HEX, "assetEntropy", /*optional=*/true, ""}, - {RPCResult::Type::BOOL, "isreissuance", /*optional=*/true, ""}, - {RPCResult::Type::STR_HEX, "token", /*optional=*/true, ""}, - {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, ""}, - {RPCResult::Type::STR_AMOUNT, "assetamount", /*optional=*/true, ""}, - {RPCResult::Type::STR_HEX, "assetamountcommitment", /*optional=*/true, ""}, - {RPCResult::Type::STR_AMOUNT, "tokenamount", /*optional=*/true, ""}, - {RPCResult::Type::STR_HEX, "tokenamountcommitment", /*optional=*/true, ""}, + {RPCResult::Type::STR_HEX, "assetBlindingNonce", "The asset blinding nonce"}, + {RPCResult::Type::STR_HEX, "assetEntropy", "The asset entropy"}, + {RPCResult::Type::BOOL, "isreissuance", "Whether this is a reissuance"}, + {RPCResult::Type::STR_HEX, "token", /*optional=*/true, "The reissuance token id (omitted for reissuances)"}, + {RPCResult::Type::STR_HEX, "asset", "The asset id"}, + {RPCResult::Type::STR_AMOUNT, "assetamount", /*optional=*/true, "The explicit issued asset amount"}, + {RPCResult::Type::STR_HEX, "assetamountcommitment", /*optional=*/true, "The blinded issued asset amount commitment"}, + {RPCResult::Type::STR_AMOUNT, "tokenamount", /*optional=*/true, "The explicit reissuance token amount"}, + {RPCResult::Type::STR_HEX, "tokenamountcommitment", /*optional=*/true, "The blinded reissuance token amount commitment"}, }}, }}, }}, @@ -150,22 +149,33 @@ static std::vector DecodeTxDoc(const std::string& txid_field_doc) { {RPCResult::Type::OBJ, "", "", { - {RPCResult::Type::NUM, "value", "The value in " + CURRENCY_UNIT}, - {RPCResult::Type::STR_AMOUNT, "value", /*optional=*/true, "The value in " + CURRENCY_UNIT}, + {RPCResult::Type::STR_AMOUNT, "value", /*optional=*/true, "The value in " + CURRENCY_UNIT + " (explicit outputs, or decoded confidential value)"}, {RPCResult::Type::STR_AMOUNT, "value-minimum", /*optional=*/true, "Minimum decoded value for confidential outputs"}, {RPCResult::Type::STR_AMOUNT, "value-maximum", /*optional=*/true, "Maximum decoded value for confidential outputs"}, - {RPCResult::Type::NUM, "ct-exponent", /*optional=*/true, "Confidential transaction exponent"}, - {RPCResult::Type::NUM, "ct-bits", /*optional=*/true, "Confidential transaction mantissa bits"}, - {RPCResult::Type::STR_HEX, "valuecommitment", /*optional=*/true, "Hex value commitment for confidential outputs"}, - {RPCResult::Type::STR_HEX, "surjectionproof", /*optional=*/true, "Asset surjection proof"}, + {RPCResult::Type::NUM, "ct-exponent", /*optional=*/true, "Confidential transaction value exponent"}, + {RPCResult::Type::NUM, "ct-bits", /*optional=*/true, "Confidential transaction value mantissa bits"}, + {RPCResult::Type::STR_HEX, "valuecommitment", /*optional=*/true, "Hex-encoded value commitment for confidential outputs"}, + {RPCResult::Type::STR_HEX, "surjectionproof", /*optional=*/true, "Hex-encoded asset surjection proof"}, {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, "Explicit asset id"}, - {RPCResult::Type::STR_HEX, "assetcommitment", /*optional=*/true, "Asset commitment"}, - {RPCResult::Type::STR_HEX, "commitmentnonce", /*optional=*/true, "Nonce commitment for confidential outputs"}, + {RPCResult::Type::STR_HEX, "assetcommitment", /*optional=*/true, "Hex-encoded asset commitment"}, + {RPCResult::Type::STR_HEX, "commitmentnonce", /*optional=*/true, "Hex-encoded output blinding pubkey or nonce commitment"}, {RPCResult::Type::BOOL, "commitmentnonce_fully_valid", /*optional=*/true, "Whether the nonce commitment parses as a valid pubkey"}, - {RPCResult::Type::NUM, "n", "index"}, - {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()}, + {RPCResult::Type::NUM, "n", "The output index"}, + {RPCResult::Type::OBJ, "scriptPubKey", "", Cat>(ScriptPubKeyDoc(), { + {RPCResult::Type::STR_HEX, "pegout_chain", /*optional=*/true, "Parent chain genesis block hash (peg-out outputs only)"}, + {RPCResult::Type::STR, "pegout_asm", /*optional=*/true, "Disassembly of the peg-out output script"}, + {RPCResult::Type::STR, "pegout_desc", /*optional=*/true, "Inferred descriptor for the peg-out output script"}, + {RPCResult::Type::STR_HEX, "pegout_hex", /*optional=*/true, "The peg-out output script bytes, hex-encoded"}, + {RPCResult::Type::STR, "pegout_address", /*optional=*/true, "The peg-out address on the parent chain"}, + {RPCResult::Type::STR, "pegout_type", /*optional=*/true, "The peg-out output script type"}, + })}, }}, }}, + {RPCResult::Type::OBJ, "fee", /*optional=*/true, "Fee output totals mapped by asset id", { + {RPCResult::Type::ELISION, "", "fee amount for each asset"}, + }, /*skip_type_check=*/true}, + {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "The block hash"}, + {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The serialized, hex-encoded transaction"}, }; } @@ -340,12 +350,9 @@ static RPCHelpMan getrawtransaction() Cat>( { {RPCResult::Type::BOOL, "in_active_chain", /*optional=*/true, "Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"}, - {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the block hash"}, {RPCResult::Type::NUM, "confirmations", /*optional=*/true, "The confirmations"}, {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME}, {RPCResult::Type::NUM, "time", /*optional=*/true, "Same as \"blocktime\""}, - {RPCResult::Type::OBJ, "fee", "The fee supplied for the transaction.", {}, /*skip_type_check=*/true}, // ELEMENTS: this is an object (assetId and value), but in bitcoin this is a STR_AMOUNT - {RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded data for 'txid'"}, }, DecodeTxDoc(/*txid_field_doc=*/"The transaction id (same as provided)")), }, @@ -353,7 +360,6 @@ static RPCHelpMan getrawtransaction() RPCResult::Type::OBJ, "", "", { {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"}, - {RPCResult::Type::NUM, "fee", /*optional=*/true, "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"}, {RPCResult::Type::ARR, "vin", "", { {RPCResult::Type::OBJ, "", "utxo being spent", @@ -951,6 +957,35 @@ const RPCResult decodepsbt_inputs{ { {RPCResult::Type::STR_HEX, "", "hex-encoded witness data (if any)"}, }}, + {RPCResult::Type::STR_HEX, "previous_txid", /*optional=*/ true, "The TXID of the prevout"}, + {RPCResult::Type::NUM, "previous_vout", /*optional=*/ true, "The output index of the prevout"}, + {RPCResult::Type::NUM, "sequence", /*optional=*/ true, "The sequence number"}, + {RPCResult::Type::NUM, "time_locktime", /*optional=*/ true, "The required time-based locktime for this input"}, + {RPCResult::Type::NUM, "height_locktime", /*optional=*/ true, "The required height-based locktime for this input"}, + {RPCResult::Type::STR_AMOUNT, "issuance_value", /*optional=*/ true, "The explicit issuance value"}, + {RPCResult::Type::STR_HEX, "issuance_value_commitment", /*optional=*/ true, "The issuance value commitment"}, + {RPCResult::Type::STR_HEX, "issuance_value_rangeproof", /*optional=*/ true, "The issuance value rangeproof"}, + {RPCResult::Type::STR_HEX, "blind_issuance_value_proof", /*optional=*/ true, "The blind issuance value proof"}, + {RPCResult::Type::STR_AMOUNT, "issuance_reissuance_amount", /*optional=*/ true, "The explicit reissuance token amount"}, + {RPCResult::Type::STR_HEX, "issuance_reissuance_amount_commitment", /*optional=*/ true, "The reissuance token amount commitment"}, + {RPCResult::Type::STR_HEX, "issuance_reissuance_amount_rangeproof", /*optional=*/ true, "The reissuance token amount rangeproof"}, + {RPCResult::Type::STR_HEX, "blind_reissuance_amount_proof", /*optional=*/ true, "The blind reissuance token amount proof"}, + {RPCResult::Type::STR_HEX, "issuance_blinding_nonce", /*optional=*/ true, "The issuance blinding nonce"}, + {RPCResult::Type::STR_HEX, "issuance_asset_entropy", /*optional=*/ true, "The issuance asset entropy"}, + {RPCResult::Type::STR_HEX, "pegin_bitcoin_tx", /*optional=*/ true, "The hex-encoded Bitcoin transaction"}, + {RPCResult::Type::STR_HEX, "pegin_txout_proof", /*optional=*/ true, "The hex-encoded raw txout proof"}, + {RPCResult::Type::STR_HEX, "pegin_claim_script", /*optional=*/ true, "The peg-in claim script"}, + {RPCResult::Type::STR_HEX, "pegin_genesis_hash", /*optional=*/ true, "The hex-encoded genesis block hash of the parent chain"}, + {RPCResult::Type::STR_AMOUNT, "pegin_value", /*optional=*/ true, "The peg-in value"}, + {RPCResult::Type::ARR, "pegin_witness", /*optional=*/ true, "The peg-in witness stack", + {{RPCResult::Type::STR_HEX, "", "hex-encoded witness item"}}}, + {RPCResult::Type::STR_HEX, "utxo_rangeproof", /*optional=*/ true, "The UTXO range proof"}, + {RPCResult::Type::STR_HEX, "asset_proof", /*optional=*/ true, "The asset proof"}, + {RPCResult::Type::STR_HEX, "explicit_asset", /*optional=*/ true, "The explicit asset type"}, + {RPCResult::Type::STR_AMOUNT, "explicit_value", /*optional=*/ true, "The explicit value"}, + {RPCResult::Type::STR_HEX, "value_proof", /*optional=*/ true, "The value proof"}, + {RPCResult::Type::BOOL, "blinded_issuance", /*optional=*/ true, "Whether the issuance is blinded"}, + {RPCResult::Type::STR, "status", /*optional=*/true, "Status"}, {RPCResult::Type::OBJ_DYN, "ripemd160_preimages", /*optional=*/ true, "", { {RPCResult::Type::STR, "hash", "The hash and preimage that corresponds to it."}, @@ -1004,35 +1039,21 @@ const RPCResult decodepsbt_inputs{ }}, {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"}, {RPCResult::Type::STR_HEX, "taproot_merkle_root", /*optional=*/ true, "The hex-encoded Taproot merkle root"}, - {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/ true, "The unknown input fields", - { - {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, - }}, {RPCResult::Type::ARR, "proprietary", /*optional=*/true, "The input proprietary map", - { - {RPCResult::Type::OBJ, "", "", { - {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"}, - {RPCResult::Type::NUM, "subtype", "The number for the subtype"}, - {RPCResult::Type::STR_HEX, "key", "The hex for the key"}, - {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, + {RPCResult::Type::OBJ, "", "", + { + {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"}, + {RPCResult::Type::NUM, "subtype", "The number for the subtype"}, + {RPCResult::Type::STR_HEX, "key", "The hex for the key"}, + {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, + }}, + }}, + }}, + {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/ true, "The unknown input fields", + { + {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, }}, - }}, - {RPCResult::Type::STR_HEX, "previous_txid", /*optional=*/ true, "The TXID of the prevout"}, - {RPCResult::Type::NUM, "previous_vout", /*optional=*/ true, "The output index of the prevout"}, - {RPCResult::Type::NUM, "sequence", /*optional=*/ true, "The sequence number"}, - {RPCResult::Type::STR_HEX, "pegin_bitcoin_tx", /*optional=*/ true, "The hex-encoded Bitcoin transaction"}, - {RPCResult::Type::STR_HEX, "pegin_claim_script", /*optional=*/ true, "The peg-in claim script"}, - {RPCResult::Type::STR_HEX, "pegin_genesis_hash", /*optional=*/ true, "The hex-encoded genesis block hash of the parent chain"}, - {RPCResult::Type::STR_HEX, "pegin_txout_proof", /*optional=*/ true, "The hex-encoded raw txout proof"}, - {RPCResult::Type::STR_AMOUNT, "pegin_value", /*optional=*/ true, "The peg-in value"}, - {RPCResult::Type::STR_HEX, "utxo_rangeproof", /*optional=*/ true, "The UTXO range proof"}, - {RPCResult::Type::STR_HEX, "asset_proof", /*optional=*/ true, "The asset proof"}, - {RPCResult::Type::STR_HEX, "explicit_asset", /*optional=*/ true, "The explicit asset type"}, - {RPCResult::Type::STR_AMOUNT, "explicit_value", /*optional=*/ true, "The explicit value"}, - {RPCResult::Type::STR_HEX, "value_proof", /*optional=*/ true, "The value proof"}, - {RPCResult::Type::STR, "status", /*optional=*/true, "Status"}, - }}, } }; @@ -1062,6 +1083,26 @@ const RPCResult decodepsbt_outputs{ {RPCResult::Type::STR, "path", "The path"}, }}, }}, + {RPCResult::Type::STR_AMOUNT, "amount", /*optional=*/true, "The value in " + CURRENCY_UNIT}, + {RPCResult::Type::OBJ, "script", /*optional=*/true, "The output script (scriptPubKey) for this output", + { + {RPCResult::Type::STR, "asm", "Disassembly of the public key script"}, + {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"}, + {RPCResult::Type::STR_HEX, "hex", "The raw public key script bytes, hex-encoded"}, + {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, + {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, + }}, + {RPCResult::Type::STR_HEX, "value_commitment", /*optional=*/true, "The value commitment"}, + {RPCResult::Type::STR_HEX, "asset_commitment", /*optional=*/true, "The asset commitment"}, + {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, "The asset type"}, + {RPCResult::Type::STR_HEX, "rangeproof", /*optional=*/true, "The rangeproof"}, + {RPCResult::Type::STR_HEX, "surjection_proof", /*optional=*/true, "The surjection proof"}, + {RPCResult::Type::STR_HEX, "ecdh_pubkey", /*optional=*/true, "The ECDH pubkey"}, + {RPCResult::Type::STR_HEX, "blinding_pubkey", /*optional=*/true, "The blinding pubkey"}, + {RPCResult::Type::NUM, "blinder_index", /*optional=*/true, "Output index of the blinder for this output"}, + {RPCResult::Type::STR_HEX, "blind_value_proof", /*optional=*/true, "The blind value proof"}, + {RPCResult::Type::STR_HEX, "blind_asset_proof", /*optional=*/true, "The blind asset proof"}, + {RPCResult::Type::STR, "status", /*optional=*/true, "Status"}, {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"}, {RPCResult::Type::ARR, "taproot_tree", /*optional=*/ true, "The tuples that make up the Taproot tree, in depth first search order", { @@ -1085,10 +1126,6 @@ const RPCResult decodepsbt_outputs{ }}, }}, }}, - {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/true, "The unknown output fields", - { - {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, - }}, {RPCResult::Type::ARR, "proprietary", /*optional=*/true, "The output proprietary map", { {RPCResult::Type::OBJ, "", "", @@ -1099,26 +1136,10 @@ const RPCResult decodepsbt_outputs{ {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, }}, }}, - {RPCResult::Type::NUM, "amount", /*optional=*/true, "The value in " + CURRENCY_UNIT}, - {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, "The asset type"}, - {RPCResult::Type::OBJ, "script", "", + {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/true, "The unknown output fields", { - {RPCResult::Type::STR, "asm", "Disassembly of the public key script"}, - {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"}, - {RPCResult::Type::STR_HEX, "hex", "The raw public key script bytes, hex-encoded"}, - {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, - {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, + {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, }}, - {RPCResult::Type::NUM, "blinder_index", /*optional=*/true, "Output index of the blinder for this output"}, - {RPCResult::Type::STR_HEX, "blinding_pubkey", /*optional=*/true, "The blinding pubkey"}, - {RPCResult::Type::STR, "status", /*optional=*/true, "Status"}, - {RPCResult::Type::STR, "asset_commitment", /*optional=*/true, "The asset commitment"}, - {RPCResult::Type::STR, "blind_asset_proof", /*optional=*/true, "The blind asset proof"}, - {RPCResult::Type::STR, "blind_value_proof", /*optional=*/true, "The blind value proof"}, - {RPCResult::Type::STR, "ecdh_pubkey", /*optional=*/true, "The ECDH pubkey"}, - {RPCResult::Type::STR, "rangeproof", /*optional=*/true, "The rangeproof"}, - {RPCResult::Type::STR, "surjection_proof", /*optional=*/true, "The surjection proof"}, - {RPCResult::Type::STR, "value_commitment", /*optional=*/true, "The value commitment"}, }}, } }; @@ -1148,20 +1169,17 @@ static RPCHelpMan decodepsbt() {RPCResult::Type::STR, "path", "The path"}, }}, }}, - {RPCResult::Type::NUM, "tx_version", "The version number of the unsigned transaction. Not to be confused with PSBT version"}, + {RPCResult::Type::NUM, "tx_version", /*optional=*/true, "The version number of the unsigned transaction. Not to be confused with PSBT version"}, {RPCResult::Type::NUM, "fallback_locktime", /*optional=*/true, "The locktime to fallback to if no inputs specify a required locktime."}, - {RPCResult::Type::NUM, "fees", "The fees specified in this psbt.", {}, /*skip_type_check=*/true}, // ELEMENTS has an explicit fee output, bitcoin does not (they are implicit) - {RPCResult::Type::NUM, "input_count", "The number of inputs in this psbt"}, - {RPCResult::Type::NUM, "output_count", "The number of outputs in this psbt."}, - {RPCResult::Type::NUM, "inputs_modifiable", /*optional=*/true, "Whether inputs can be modified"}, - {RPCResult::Type::NUM, "outputs_modifiable", /*optional=*/true, "Whether outputs can be modified"}, - {RPCResult::Type::ARR, "sighash_single_indexes", /*optional=*/true, "The indexes which have SIGHASH_SINGLE signatures", - {{RPCResult::Type::NUM, "", "Index of an input with a SIGHASH_SINGLE signature"}}, - }, + {RPCResult::Type::NUM, "input_count", /*optional=*/true, "The number of inputs in this psbt"}, + {RPCResult::Type::NUM, "output_count", /*optional=*/true, "The number of outputs in this psbt."}, + {RPCResult::Type::BOOL, "inputs_modifiable", /*optional=*/true, "Whether inputs can be modified"}, + {RPCResult::Type::BOOL, "outputs_modifiable", /*optional=*/true, "Whether outputs can be modified"}, + {RPCResult::Type::BOOL, "has_sighash_single", /*optional=*/true, "Whether any input uses SIGHASH_SINGLE"}, {RPCResult::Type::NUM, "psbt_version", "The PSBT version number. Not to be confused with the unsigned transaction version"}, {RPCResult::Type::ARR, "scalar_offsets", /*optional=*/true, "The PSET scalar elements", { - {RPCResult::Type::STR_HEX, "scalar", "A scalar offset stored in the PSET"}, + {RPCResult::Type::STR_HEX, "", "A scalar offset stored in the PSET"}, }}, {RPCResult::Type::ARR, "proprietary", "The global proprietary map", { @@ -1173,13 +1191,16 @@ static RPCHelpMan decodepsbt() {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, }}, }}, - {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/true, "The unknown global fields", + {RPCResult::Type::OBJ, "fees", "The fees specified in this psbt, mapped by asset label or id", + { + {RPCResult::Type::ELISION, "", "fee amount for each asset"}, + }}, + {RPCResult::Type::OBJ_DYN, "unknown", "The unknown global fields", { {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, }}, decodepsbt_inputs, decodepsbt_outputs, - {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The transaction fee paid if all UTXOs slots in the PSBT have been filled."}, } }, RPCExamples{ diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp index cd2930390c..ee08f72357 100644 --- a/src/wallet/rpc/backup.cpp +++ b/src/wallet/rpc/backup.cpp @@ -2037,7 +2037,7 @@ RPCHelpMan restorewallet() RPCHelpMan getwalletpakinfo() { return RPCHelpMan{"getwalletpakinfo", - "\nReturns relevant pegout authorization key (PAK) information about this wallet. Throws an error if initpegoutwallet` has not been invoked on this wallet.\n", + "\nReturns relevant pegout authorization key (PAK) information about this wallet. Throws an error if `initpegoutwallet` has not been invoked on this wallet.\n", {}, RPCResult{ RPCResult::Type::OBJ, "", "", @@ -2132,7 +2132,7 @@ RPCHelpMan importblindingkey() "\nImports a private blinding key in hex for a CT address.", { {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The CT address"}, - {"hexkey", RPCArg::Type::STR, RPCArg::Optional::NO, "The blinding key in hex"}, + {"hexkey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The 32-byte blinding key in hex"}, }, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{ @@ -2225,7 +2225,7 @@ RPCHelpMan importmasterblindingkey() RPCHelpMan importissuanceblindingkey() { return RPCHelpMan{"importissuanceblindingkey", - "\nImports a private blinding key in hex for an asset issuance.", + "\nImports a private blinding key in hex for an asset issuance. Unlike `importblindingkey`, the key is stored without verifying it matches the issuance blinding pubkey.\n", { {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id of the issuance"}, {"vin", RPCArg::Type::NUM, RPCArg::Optional::NO, "The input number of the issuance in the transaction."}, @@ -2233,7 +2233,7 @@ RPCHelpMan importissuanceblindingkey() }, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{ - HelpExampleCli("importblindingkey", "\"my blinded CT address\" ") + HelpExampleCli("importissuanceblindingkey", " 0 ") }, [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue { diff --git a/src/wallet/rpc/elements.cpp b/src/wallet/rpc/elements.cpp index b455c33459..e814544932 100644 --- a/src/wallet/rpc/elements.cpp +++ b/src/wallet/rpc/elements.cpp @@ -156,7 +156,7 @@ RPCHelpMan getpeginaddress() RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "mainchain_address", "mainchain deposit address to send bitcoin to"}, - {RPCResult::Type::STR_HEX, "claim_script", "claim script committed to by the mainchain address. This may be required in `claimpegin` to retrieve pegged-in funds\n"}, + {RPCResult::Type::STR_HEX, "claim_script", "Full script hex committed to by the mainchain address. This may be required in `claimpegin` to retrieve pegged-in funds\n"}, {RPCResult::Type::STR_AMOUNT, "pegin_min_amount", /*optional=*/true, "Minimum peg-in amount in " + CURRENCY_UNIT}, {RPCResult::Type::NUM, "pegin_min_height", /*optional=*/true, "Minimum block height for peg-in amount rule"}, {RPCResult::Type::BOOL, "pegin_min_active", /*optional=*/true, "Whether the peg-in minimum height rule is active at the current tip"}, @@ -281,7 +281,7 @@ bool DerivePubTweak(const std::vector& vPath, const CPubKey& keyMaster RPCHelpMan initpegoutwallet() { return RPCHelpMan{"initpegoutwallet", - "\nThis call is for Liquid network initialization on the Liquid wallet. The wallet generates a new Liquid pegout authorization key (PAK) and stores it in the Liquid wallet. It then combines this with the `bitcoin_descriptor` to finally create a PAK entry for the network. This allows the user to send Liquid coins directly to a secure offline Bitcoin wallet at the derived path from the bitcoin_descriptor using the `sendtomainchain` command. Losing the Liquid PAK or offline Bitcoin root key will result in the inability to pegout funds, so immediate backup upon initialization is required.\n" + + "\nThis call is for Liquid network initialization on the Liquid wallet. The wallet generates a new Liquid pegout authorization key (PAK) unless `liquid_pak` is provided, and stores it in the Liquid wallet. It then combines this with the `bitcoin_descriptor` to finally create a PAK entry for the network. This allows the user to send Liquid coins directly to a secure offline Bitcoin wallet at the derived path from the bitcoin_descriptor using the `sendtomainchain` command. Losing the Liquid PAK or offline Bitcoin root key will result in the inability to pegout funds, so immediate backup upon initialization is required. Requires a legacy wallet.\n" + wallet::HELP_REQUIRING_PASSPHRASE, { {"bitcoin_descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The Bitcoin descriptor that includes a single extended pubkey. Must be one of the following: pkh(), sh(wpkh()), or wpkh(). This is used as the destination chain for the Bitcoin destination wallet. The derivation path from the xpub is given by the descriptor, typically `0/k`, reflecting the external chain of the wallet. DEPRECATED: If a plain xpub is given, pkh() is assumed, with the `0/k` derivation from that xpub. See link for more details on script descriptors: https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md"}, @@ -456,7 +456,7 @@ RPCHelpMan initpegoutwallet() RPCHelpMan sendtomainchain_base() { return RPCHelpMan{"sendtomainchain", - "\nSends sidechain funds to the given mainchain address, through the federated peg-in mechanism\n" + "\nSends sidechain funds to the given mainchain address, through the federated peg-out (withdraw) mechanism\n" + wallet::HELP_REQUIRING_PASSPHRASE, { {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The destination address on Bitcoin mainchain"}, @@ -472,7 +472,7 @@ RPCHelpMan sendtomainchain_base() RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR_HEX, "txid", "The transaction id."}, - {RPCResult::Type::STR, "fee reason", /*optional=*/true, "The transaction fee reason."} + {RPCResult::Type::STR, "fee_reason", /*optional=*/true, "The transaction fee reason."} }, }, }, @@ -571,11 +571,11 @@ bool ParseKeyPath(const std::vector>& split, KeyPath& out) RPCHelpMan sendtomainchain_pak() { return RPCHelpMan{"sendtomainchain", - "\nSends Liquid funds to the Bitcoin mainchain, through the federated withdraw mechanism. The wallet internally generates the returned `bitcoin_address` via `bitcoin_descriptor` and `bip32_counter` previously set in `initpegoutwallet`. The counter will be incremented upon successful send, avoiding address re-use.\n" + "\nSends Liquid funds to the Bitcoin mainchain, through the federated withdraw mechanism. The wallet internally generates the returned `bitcoin_address` via `bitcoin_descriptor` and `bip32_counter` previously set in `initpegoutwallet`. The counter will be incremented upon successful send, avoiding address re-use. Requires a legacy wallet. Minimum peg-out amount is 0.00100000 BTC.\n" + wallet::HELP_REQUIRING_PASSPHRASE, { {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Must be \"\". Only for non-PAK `sendtomainchain` compatibility."}, - {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount being sent to `bitcoin_address`."}, + {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount being sent to `bitcoin_address` (minimum 0.00100000 BTC)."}, {"subtractfeefromamount", RPCArg::Type::BOOL, RPCArg::Default{false}, "The fee will be deducted from the amount being pegged-out."}, {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, return extra information about the transaction."}, }, @@ -584,8 +584,8 @@ RPCHelpMan sendtomainchain_pak() { {RPCResult::Type::STR, "bitcoin_address", "destination address on Bitcoin mainchain"}, {RPCResult::Type::STR_HEX, "txid", "transaction ID of the resulting Liquid transaction"}, - {RPCResult::Type::STR, "fee reason", /*optional=*/true, "If verbose is set to true, the Liquid transaction fee reason"}, - {RPCResult::Type::STR, "bitcoin_descriptor", "xpubkey of the child destination address"}, + {RPCResult::Type::STR, "fee_reason", /*optional=*/true, "If verbose is set to true, the Liquid transaction fee reason"}, + {RPCResult::Type::STR, "bitcoin_descriptor", "Bitcoin descriptor string used for peg-out destination derivation"}, {RPCResult::Type::STR, "bip32_counter", "derivation counter for the `bitcoin_descriptor`"}, }, }, @@ -994,8 +994,8 @@ RPCHelpMan createrawpegin() { {"bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"}, {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"}, - {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The witness program generated by getpeginaddress. Only needed if not in wallet."}, - {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "The fee rate of the Bitcoin transaction in sats/vb, only necessary when validatepegin=0."}, + {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The full script hex from getpeginaddress. If omitted, every script in the wallet address book is tried as a candidate claim script."}, + {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "The fee rate of the Bitcoin transaction in sats/vb. Required when validatepegin=0, including when a peg-in subsidy requires it."}, }, RPCResult{ RPCResult::Type::OBJ, "", "", @@ -1039,13 +1039,13 @@ RPCHelpMan claimpegin() { return RPCHelpMan{"claimpegin", "\nClaim coins from the main chain by creating a peg-in transaction with the necessary metadata after the corresponding Bitcoin transaction.\n" - "Note that the transaction will not be relayed unless it is buried at least 102 blocks deep.\n" + "Note that the transaction will not be relayed until it is buried at least `pegin_min_depth + 2` blocks deep (chain-dependent).\n" "If a transaction is not relayed it may require manual addition to a functionary mempool in order for it to be mined.\n", { {"bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"}, {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"}, - {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The witness program generated by getpeginaddress. Only needed if not in wallet."}, - {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "The fee rate of the Bitcoin transaction in sats/vb, only necessary when validatepegin=0."}, + {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The full script hex from getpeginaddress. If omitted, every script in the wallet address book is tried as a candidate claim script."}, + {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "The fee rate of the Bitcoin transaction in sats/vb. Required when validatepegin=0, including when a peg-in subsidy requires it."}, }, RPCResult{ RPCResult::Type::STR_HEX, "txid", "txid of the resulting sidechain transaction", @@ -1503,7 +1503,7 @@ static CTransactionRef SendGenerationTransaction(const CScript& asset_script, co RPCHelpMan issueasset() { return RPCHelpMan{"issueasset", - "\nCreate an asset. Must have funds in wallet to do so. Returns asset hex id.\n" + "\nCreate an asset. Must have funds in wallet to do so. Returns issuance details including txid, vin, entropy, asset, and token.\n" "For more fine-grained control such as multiple issuances, see `rawissueasset` RPC call.\n", { {"assetamount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "Amount of asset to generate. Note that the amount is BTC-like, with 8 decimal places."}, @@ -1715,7 +1715,7 @@ RPCHelpMan listissuances() {RPCResult::Type::STR_HEX, "entropy", "Entropy of the asset type"}, {RPCResult::Type::STR_HEX, "asset", "Asset type for issuance if known"}, {RPCResult::Type::STR, "assetlabel", /*optional=*/true, "Asset label for issuance if set"}, - {RPCResult::Type::STR_HEX, "token", /*optional=*/true, "Token type for issuancen"}, + {RPCResult::Type::STR_HEX, "token", /*optional=*/true, "Token type for issuance"}, {RPCResult::Type::NUM, "vin", "The input position of the issuance in the transaction"}, {RPCResult::Type::STR_AMOUNT, "assetamount", "The amount of asset issued. Is -1 if blinded and unknown to wallet"}, {RPCResult::Type::STR_AMOUNT, "tokenamount", /*optional=*/true, "The reissuance token amount issued. Is -1 if blinded and unknown to wallet"}, @@ -1806,13 +1806,13 @@ RPCHelpMan destroyamount() }, { RPCResult{"if verbose is not set or set to false", - RPCResult::Type::STR_HEX, "transactionid", "the transaction id", + RPCResult::Type::STR_HEX, "txid", "the transaction id", }, RPCResult{"if verbose is set to true", RPCResult::Type::OBJ, "", "", { - {RPCResult::Type::STR_HEX, "transactionid", "the transaction id"}, - {RPCResult::Type::STR, "fee reason", "The transaction fee reason."}, + {RPCResult::Type::STR_HEX, "txid", "the transaction id"}, + {RPCResult::Type::STR, "fee_reason", "The transaction fee reason."}, }, }, }, diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp index edfbc4338b..b044140abb 100644 --- a/src/wallet/rpc/spend.cpp +++ b/src/wallet/rpc/spend.cpp @@ -268,7 +268,7 @@ RPCHelpMan sendtoaddress() {"avoid_reuse", RPCArg::Type::BOOL, RPCArg::Default{true}, "(only available if avoid_reuse wallet flag is set) Avoid spending from dirty addresses; addresses are considered\n" "dirty if they have previously been used in a transaction. If true, this also activates avoidpartialspends, grouping outputs by their addresses."}, {"assetlabel", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Hex asset id or asset label for balance."}, - {"ignoreblindfail", RPCArg::Type::BOOL, RPCArg::Default{true}, "Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs."}, + {"ignoreblindfail", RPCArg::Type::BOOL, RPCArg::Default{true}, "If true, continue when output blinding fails (e.g. due to too many blinded inputs/outputs) instead of failing the RPC."}, {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."}, {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, return extra information about the transaction."}, }, @@ -396,7 +396,7 @@ RPCHelpMan sendmany() {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "A key-value pair where the key is the address used and the value is an asset label or hex asset ID."}, }, }, - {"ignoreblindfail", RPCArg::Type::BOOL, RPCArg::Default{true}, "Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs."}, + {"ignoreblindfail", RPCArg::Type::BOOL, RPCArg::Default{true}, "If true, continue when output blinding fails (e.g. due to too many blinded inputs/outputs) instead of failing the RPC."}, {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."}, {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, return extra information about the transaction."}, }, @@ -1028,7 +1028,7 @@ RPCHelpMan signrawtransactionwithwallet() {RPCResult::Type::NUM, "vout", "The index of the output to spent and used as input"}, {RPCResult::Type::ARR, "witness", "", { - {RPCResult::Type::STR_HEX, "witness", ""}, + {RPCResult::Type::STR_HEX, "", "hex-encoded witness stack item"}, }}, {RPCResult::Type::STR_HEX, "scriptSig", "The hex-encoded signature script"}, {RPCResult::Type::NUM, "sequence", "Script sequence number"}, @@ -1348,6 +1348,14 @@ RPCHelpMan send() {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"}, {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"}, {"sequence", RPCArg::Type::NUM, RPCArg::DefaultHint{"depends on the value of the 'replaceable' and 'locktime' arguments"}, "The sequence number"}, + {"pegin_bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(only for pegin inputs) The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"}, + {"pegin_txout_proof", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(only for pegin inputs) A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"}, + {"pegin_claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(only for pegin inputs) The claim script generated by getpeginaddress."}, + {"issuance_amount", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The amount to be issued on this input"}, + {"issuance_tokens", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The number of reissuance tokens to generate on this input"}, + {"asset_entropy", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "Additional entropy for new issuance, or original asset entropy for reissuance"}, + {"asset_blinding_nonce", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "For reissuance only, the blinding nonce of the reissuance token being spent"}, + {"blind_reissuance", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether reissuance tokens should be blinded"}, {"weight", RPCArg::Type::NUM, RPCArg::DefaultHint{"Calculated from wallet and solving data"}, "The maximum weight for this input, " "including the weight of the outpoint and sequence number. " "Note that signature sizes are not guaranteed to be consistent, " @@ -1445,6 +1453,7 @@ RPCHelpMan sendall() {"", RPCArg::Type::OBJ_USER_KEYS, RPCArg::Optional::OMITTED, "", { {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""}, + {"asset", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The asset label or hex id for this output if it is not the main chain asset"}, }, }, }, @@ -1702,7 +1711,7 @@ RPCHelpMan walletprocesspsbt() HELP_REQUIRING_PASSPHRASE, { {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"}, - {"sign", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also sign the transaction when updating (requires wallet to be unlocked)"}, + {"sign", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also sign the transaction when updating (requires wallet to be unlocked). Signing is only performed once the PSBT is fully blinded."}, {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type to sign with if not specified by the PSBT. Must be one of\n" " \"DEFAULT\"\n" " \"ALL\"\n" diff --git a/src/wallet/rpc/transactions.cpp b/src/wallet/rpc/transactions.cpp index 16d9be9e22..e460052b44 100644 --- a/src/wallet/rpc/transactions.cpp +++ b/src/wallet/rpc/transactions.cpp @@ -509,7 +509,7 @@ RPCHelpMan listtransactions() {RPCResult::Type::STR_HEX, "assetblinder", /*optional=*/true, "The asset blinder"}, {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"}, {RPCResult::Type::NUM, "vout", "the vout value"}, - {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n" + {RPCResult::Type::STR_AMOUNT, "fee", "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n" "'send' category of transactions."}, }, TransactionDescriptionString()), @@ -621,20 +621,17 @@ RPCHelpMan listsinceblock() "\"orphan\" Orphaned coinbase transactions received."}, {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and is positive\n" "for all other categories"}, - {RPCResult::Type::STR_HEX, "amountblinder", "The amount blinding factor in hex"}, - {RPCResult::Type::STR_HEX, "asset", "The asset id in hex"}, - {RPCResult::Type::STR_HEX, "assetblinder", "The asset blinding factor in hex"}, + {RPCResult::Type::STR_HEX, "amountblinder", /*optional=*/true, "The amount blinding factor in hex"}, + {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, "The asset id in hex"}, + {RPCResult::Type::STR_HEX, "assetblinder", /*optional=*/true, "The asset blinding factor in hex"}, + {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"}, {RPCResult::Type::NUM, "vout", "the vout value"}, - {RPCResult::Type::STR_HEX, "amountblinder", /*optional=*/true, "The amount blinder"}, - {RPCResult::Type::STR_HEX, "asset", /*optional=*/true, "The asset type"}, - {RPCResult::Type::STR_HEX, "assetblinder", /*optional=*/true, "The asset blinder"}, - {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n" - "'send' category of transactions."}, + {RPCResult::Type::STR_AMOUNT, "fee", "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n" + "'send' category of transactions."}, }, TransactionDescriptionString()), { {RPCResult::Type::BOOL, "abandoned", "'true' if the transaction has been abandoned (inputs are respendable)."}, - {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"}, })}, }}, {RPCResult::Type::ARR, "removed", /*optional=*/true, "\n"