From ebdbca6b21569a58bf55955a754d3ea755d71d73 Mon Sep 17 00:00:00 2001 From: thephez Date: Tue, 4 Nov 2025 15:43:52 -0500 Subject: [PATCH 01/15] feat: add script to store dash-cli help output for parsing --- scripts/dash-dump-cli-help.sh | 232 ++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 scripts/dash-dump-cli-help.sh diff --git a/scripts/dash-dump-cli-help.sh b/scripts/dash-dump-cli-help.sh new file mode 100644 index 000000000..49dbd1529 --- /dev/null +++ b/scripts/dash-dump-cli-help.sh @@ -0,0 +1,232 @@ +#!/usr/bin/env bash +# +# dump-dash-cli-help.sh +# +# Iterate over all dash-cli RPC commands (including subcommands where applicable) +# and dump their help text into: +# - A single readable text file (OUT) +# - Optionally, a newline-delimited JSON file (OUT_JSONL) for machine parsing +# +# Usage: +# chmod +x dump-dash-cli-help.sh +# ./dump-dash-cli-help.sh +# +# Overrides: +# CLI=/path/to/dash-cli NET_ARGS="-testnet" OUT="help.txt" ./dump-dash-cli-help.sh +# +# Dependencies: +# Needs a running Dash node with RPC access (same as using dash-cli manually). +# +set -euo pipefail + +# ---- Config (override via env vars when running) ----------------------------- +CLI="${CLI:-$HOME/code/dash/src/dash-cli}" # Path to dash-cli executable +NET_ARGS="${NET_ARGS:--testnet}" # e.g. "", "-testnet", "-regtest" +OUT="${OUT:-dash-cli-help-$(date -u +%Y%m%dT%H%M%SZ).txt}" # Text output file +OUT_JSONL="${OUT_JSONL:-dash-cli-help-$(date -u +%Y%m%dT%H%M%SZ).jsonl}" # JSONL output +FORMAT_JSONL="${FORMAT_JSONL:-1}" # set to 0 to disable JSONL output +# ------------------------------------------------------------------------------ + +# Sanity check on the CLI binary +if [[ ! -x "$CLI" ]]; then + echo "error: CLI not found or not executable at: $CLI" >&2 + exit 1 +fi + +# Capture version text (non-fatal if it fails) +# Extract schema like "v23.0.0-rc.3" from dash-cli -version +full_version="$("$CLI" $NET_ARGS -version 2>/dev/null || true)" +VERSION="$(sed -n 's/.*v\([0-9][^ ]*\).*/\1/p' <<< "$full_version")" + +# Grab the full top-level help (one call, reused) +TOP_HELP="$("$CLI" $NET_ARGS help 2>/dev/null | sed 's/\r$//')" + +# Build list of top-level commands and their "signature tail" +declare -A CMD_TAIL=() +mapfile -t CMDS < <( + awk ' + /^[a-z][a-z0-9_-]*/ { + cmd=$1 + if (!seen[cmd]++) print cmd + } + ' <<<"$TOP_HELP" | sort -u +) + +# Fill the tail map: command -> "arguments signature" +while IFS=$'\t' read -r cmd tail; do + [[ -n "${cmd:-}" ]] || continue + CMD_TAIL["$cmd"]="$tail" +done < <( + awk ' + /^[a-z][a-z0-9_-]*/ { + cmd=$1 + sub($1"[ \t]*","") + print cmd "\t" $0 + } + ' <<<"$TOP_HELP" +) + +if ((${#CMDS[@]} == 0)); then + echo "error: could not parse any commands from top-level help" >&2 + exit 1 +fi + +# Detect "family" RPCs by the single argument named "command" +is_family() { + local tail="${1:-}" + # Exactly one arg named "command" + [[ "$tail" =~ ^\"command\"([[:space:]]*)$ ]] +} + +# Append a help block to the OUTPUT +append_help () { + local title="$1"; shift + { + echo + echo "================================================================================" + echo "## $title" + echo "--------------------------------------------------------------------------------" + "$CLI" $NET_ARGS help "$@" 2>&1 || echo "(error retrieving help for: $*)" + } >> "$OUT" +} + +# Capture help output as a string (without writing to file yet) +capture_help () { + "$CLI" $NET_ARGS help "$@" 2>&1 | sed 's/\r$//' +} + +# Parse "Available commands:" section from `help ` +discover_subcommands () { + local cmd="$1" + local txt + txt="$("$CLI" $NET_ARGS help "$cmd" 2>/dev/null | sed 's/\r$//')" || return 0 + + awk ' + BEGIN { insec=0 } + /^Available commands:/ { insec=1; next } + /^Arguments:/ { insec=0 } + insec==1 { + # Stop if a blank line separates sections in some versions + if ($0 ~ /^[[:space:]]*$/) next + # Lines look like: + # register - Create and send ProTx to network + # update_service_evo - Create ... + # (sometimes with extra spaces or tabs) + if ($0 ~ /^[[:space:]]*[A-Za-z0-9_-]+/) { + line=$0 + sub(/^[[:space:]]*/, "", line) + # Split on " - " (dash with spaces) first; fallback to first field + n = split(line, parts, /[[:space:]]+-[[:space:]]+/) + if (n >= 1) { + subcmd = parts[1] + } else { + # fallback: first whitespace-delimited token + split(line, parts2, /[[:space:]]+/) + subcmd = parts2[1] + } + # trim any trailing colon just in case + sub(/:$/, "", subcmd) + if (subcmd != "") print subcmd + } + } + ' <<<"$txt" | sort -u +} + +# -------------------- Write Header ----------------------- +{ + echo "# dash-cli help dump" + echo + echo "CLI: $CLI" + echo "Network args: $NET_ARGS" + [[ -n "$VERSION" ]] && echo "Version: $VERSION" + echo "Generated: $(date -u '+%Y-%m-%d %H:%M:%SZ')" + echo + echo "## Top-level command list (${#CMDS[@]})" + for c in "${CMDS[@]}"; do + echo "$c ${CMD_TAIL[$c]}" + done + echo +} > "$OUT" + +# -------------------- Main loop -------------------------- +for cmd in "${CMDS[@]}"; do + help_raw="$(capture_help "$cmd")" + append_help "$cmd" "$cmd" + echo "wrote help for $cmd" >&2 + + # JSONL output (root command) + if [[ "$FORMAT_JSONL" -eq 1 ]]; then + jq -cn \ + --arg cmd "$cmd" \ + --arg version "$VERSION" \ + --arg net "$NET_ARGS" \ + --arg help "$help_raw" \ + --arg qual "$cmd" \ + --arg tail "${CMD_TAIL[$cmd]}" \ + --argjson isfam "$([[ $(is_family "${CMD_TAIL[$cmd]}") ]] && echo true || echo false)" \ + '{ + command: $cmd, + subcommand: null, + qualified: $qual, + signature_tail: $tail, + is_family: $isfam, + help_raw: $help, + version: $version, + network_args: $net, + generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") + }' >> "$OUT_JSONL" + fi + + # Check if this is a family RPC + if is_family "${CMD_TAIL[$cmd]}"; then + mapfile -t SUBS < <(discover_subcommands "$cmd" || true) + if ((${#SUBS[@]} > 0)); then + { + echo + echo "### Subcommands for '$cmd' (${#SUBS[@]}):" + printf '%s\n' "${SUBS[@]}" + echo + } >> "$OUT" + + for sub in "${SUBS[@]}"; do + help_sub="$(capture_help "$cmd" "$sub")" + append_help "$cmd $sub" "$cmd" "$sub" + echo " wrote help for $cmd $sub" >&2 + + # JSONL output (subcommand) + if [[ "$FORMAT_JSONL" -eq 1 ]]; then + jq -cn \ + --arg cmd "$cmd" \ + --arg sub "$sub" \ + --arg version "$VERSION" \ + --arg net "$NET_ARGS" \ + --arg help "$help_sub" \ + --arg qual "$cmd $sub" \ + --arg tail "${CMD_TAIL[$cmd]}" \ + '{ + command: $cmd, + subcommand: $sub, + qualified: $qual, + signature_tail: $tail, + is_family: true, + help_raw: $help, + version: $version, + network_args: $net, + generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") + }' >> "$OUT_JSONL" + fi + done + else + { + echo + echo "### Subcommands for '$cmd': none discovered" + echo + } >> "$OUT" + fi + fi +done + +echo "Done. Wrote $(wc -l < "$OUT") lines to $OUT" >&2 +if [[ "$FORMAT_JSONL" -eq 1 ]]; then + echo "Also wrote JSONL to $OUT_JSONL" >&2 +fi From dae47426694e0f2aa846cb8c539ba161a9264eb0 Mon Sep 17 00:00:00 2001 From: thephez Date: Tue, 4 Nov 2025 15:54:08 -0500 Subject: [PATCH 02/15] feat: include hash of help for quick reference --- scripts/dash-dump-cli-help.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/scripts/dash-dump-cli-help.sh b/scripts/dash-dump-cli-help.sh index 49dbd1529..98aaeaa03 100644 --- a/scripts/dash-dump-cli-help.sh +++ b/scripts/dash-dump-cli-help.sh @@ -156,6 +156,7 @@ for cmd in "${CMDS[@]}"; do # JSONL output (root command) if [[ "$FORMAT_JSONL" -eq 1 ]]; then + help_sha256=$(printf '%s' "$help_raw" | sha256sum | awk '{print $1}') jq -cn \ --arg cmd "$cmd" \ --arg version "$VERSION" \ @@ -163,6 +164,7 @@ for cmd in "${CMDS[@]}"; do --arg help "$help_raw" \ --arg qual "$cmd" \ --arg tail "${CMD_TAIL[$cmd]}" \ + --arg hash "$help_sha256" \ --argjson isfam "$([[ $(is_family "${CMD_TAIL[$cmd]}") ]] && echo true || echo false)" \ '{ command: $cmd, @@ -171,6 +173,7 @@ for cmd in "${CMDS[@]}"; do signature_tail: $tail, is_family: $isfam, help_raw: $help, + help_sha256: $hash, version: $version, network_args: $net, generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") @@ -195,6 +198,7 @@ for cmd in "${CMDS[@]}"; do # JSONL output (subcommand) if [[ "$FORMAT_JSONL" -eq 1 ]]; then + help_sha256_sub=$(printf '%s' "$help_sub" | sha256sum | awk '{print $1}') jq -cn \ --arg cmd "$cmd" \ --arg sub "$sub" \ @@ -203,6 +207,7 @@ for cmd in "${CMDS[@]}"; do --arg help "$help_sub" \ --arg qual "$cmd $sub" \ --arg tail "${CMD_TAIL[$cmd]}" \ + --arg hash "$help_sha256_sub" \ '{ command: $cmd, subcommand: $sub, @@ -210,6 +215,7 @@ for cmd in "${CMDS[@]}"; do signature_tail: $tail, is_family: true, help_raw: $help, + help_sha256: $hash, version: $version, network_args: $net, generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") From 6cbad3f6251a6aebd256d39db26cf84c0b14bf0e Mon Sep 17 00:00:00 2001 From: thephez Date: Tue, 4 Nov 2025 15:54:19 -0500 Subject: [PATCH 03/15] feat: include version in filename --- scripts/dash-dump-cli-help.sh | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/scripts/dash-dump-cli-help.sh b/scripts/dash-dump-cli-help.sh index 98aaeaa03..7098bc445 100644 --- a/scripts/dash-dump-cli-help.sh +++ b/scripts/dash-dump-cli-help.sh @@ -38,6 +38,13 @@ fi full_version="$("$CLI" $NET_ARGS -version 2>/dev/null || true)" VERSION="$(sed -n 's/.*v\([0-9][^ ]*\).*/\1/p' <<< "$full_version")" +# Update output filenames to include version (if available) +if [[ -n "$VERSION" ]]; then + OUT="dash-cli-help-${VERSION}-$(date -u +%Y%m%dT%H%M%SZ).txt" + OUT_JSONL="dash-cli-help-${VERSION}-$(date -u +%Y%m%dT%H%M%SZ).jsonl" +fi + + # Grab the full top-level help (one call, reused) TOP_HELP="$("$CLI" $NET_ARGS help 2>/dev/null | sed 's/\r$//')" From 477f939a35c8699d1ed1faa7deb333ab4f2cc684 Mon Sep 17 00:00:00 2001 From: thephez Date: Tue, 4 Nov 2025 16:53:40 -0500 Subject: [PATCH 04/15] feat: move repeated fields to metadata object and allow cli errors to bubble up --- scripts/dash-dump-cli-help.sh | 54 +++++++++++++++++++++++------------ 1 file changed, 36 insertions(+), 18 deletions(-) mode change 100644 => 100755 scripts/dash-dump-cli-help.sh diff --git a/scripts/dash-dump-cli-help.sh b/scripts/dash-dump-cli-help.sh old mode 100644 new mode 100755 index 7098bc445..b2a79d98f --- a/scripts/dash-dump-cli-help.sh +++ b/scripts/dash-dump-cli-help.sh @@ -21,11 +21,27 @@ set -euo pipefail # ---- Config (override via env vars when running) ----------------------------- CLI="${CLI:-$HOME/code/dash/src/dash-cli}" # Path to dash-cli executable -NET_ARGS="${NET_ARGS:--testnet}" # e.g. "", "-testnet", "-regtest" +NET_ARGS="${NET_ARGS-"-testnet"}" # e.g. "", "-testnet", "-regtest" OUT="${OUT:-dash-cli-help-$(date -u +%Y%m%dT%H%M%SZ).txt}" # Text output file OUT_JSONL="${OUT_JSONL:-dash-cli-help-$(date -u +%Y%m%dT%H%M%SZ).jsonl}" # JSONL output FORMAT_JSONL="${FORMAT_JSONL:-1}" # set to 0 to disable JSONL output # ------------------------------------------------------------------------------ +echo $CLI +echo $NET_ARGS + +# Split NET_ARGS into an array so empty/multiple flags work reliably +read -r -a NET_ARR <<< "${NET_ARGS}" + +# Helper that runs dash-cli with NET_ARR and surfaces errors +run_cli() { + local out + if ! out="$("$CLI" "${NET_ARR[@]}" "$@" 2>&1)"; then + echo "dash-cli failed for: $CLI ${NET_ARR[*]} $*" >&2 + echo "$out" >&2 + exit 1 + fi + printf '%s' "$out" +} # Sanity check on the CLI binary if [[ ! -x "$CLI" ]]; then @@ -35,7 +51,7 @@ fi # Capture version text (non-fatal if it fails) # Extract schema like "v23.0.0-rc.3" from dash-cli -version -full_version="$("$CLI" $NET_ARGS -version 2>/dev/null || true)" +full_version="$( "$CLI" "${NET_ARR[@]}" -version 2>/dev/null || true )" VERSION="$(sed -n 's/.*v\([0-9][^ ]*\).*/\1/p' <<< "$full_version")" # Update output filenames to include version (if available) @@ -46,7 +62,7 @@ fi # Grab the full top-level help (one call, reused) -TOP_HELP="$("$CLI" $NET_ARGS help 2>/dev/null | sed 's/\r$//')" +TOP_HELP="$( run_cli help | sed 's/\r$//' )" # Build list of top-level commands and their "signature tail" declare -A CMD_TAIL=() @@ -93,20 +109,20 @@ append_help () { echo "================================================================================" echo "## $title" echo "--------------------------------------------------------------------------------" - "$CLI" $NET_ARGS help "$@" 2>&1 || echo "(error retrieving help for: $*)" + run_cli help "$@" 2>&1 || echo "(error retrieving help for: $*)" } >> "$OUT" } # Capture help output as a string (without writing to file yet) capture_help () { - "$CLI" $NET_ARGS help "$@" 2>&1 | sed 's/\r$//' + run_cli help "$@" 2>&1 | sed 's/\r$//' } # Parse "Available commands:" section from `help ` discover_subcommands () { local cmd="$1" local txt - txt="$("$CLI" $NET_ARGS help "$cmd" 2>/dev/null | sed 's/\r$//')" || return 0 + txt="$( run_cli help "$cmd" 2>/dev/null | sed 's/\r$//')" || return 0 awk ' BEGIN { insec=0 } @@ -155,6 +171,18 @@ discover_subcommands () { echo } > "$OUT" +# Write JSONL metadata header (single line) before per-command records +if [[ "$FORMAT_JSONL" -eq 1 ]]; then + jq -cn \ + --arg version "$VERSION" \ + --arg net "$NET_ARGS" \ + --arg cli "$CLI" \ + --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \ + --argjson count "${#CMDS[@]}" \ + '{metadata:{version:$version, network_args:$net, cli_path:$cli, generated_utc:$ts, command_count:$count, format:"dash-cli-help-dump-v1"}}' \ + > "$OUT_JSONL" +fi + # -------------------- Main loop -------------------------- for cmd in "${CMDS[@]}"; do help_raw="$(capture_help "$cmd")" @@ -166,8 +194,6 @@ for cmd in "${CMDS[@]}"; do help_sha256=$(printf '%s' "$help_raw" | sha256sum | awk '{print $1}') jq -cn \ --arg cmd "$cmd" \ - --arg version "$VERSION" \ - --arg net "$NET_ARGS" \ --arg help "$help_raw" \ --arg qual "$cmd" \ --arg tail "${CMD_TAIL[$cmd]}" \ @@ -180,10 +206,7 @@ for cmd in "${CMDS[@]}"; do signature_tail: $tail, is_family: $isfam, help_raw: $help, - help_sha256: $hash, - version: $version, - network_args: $net, - generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") + help_sha256: $hash }' >> "$OUT_JSONL" fi @@ -209,8 +232,6 @@ for cmd in "${CMDS[@]}"; do jq -cn \ --arg cmd "$cmd" \ --arg sub "$sub" \ - --arg version "$VERSION" \ - --arg net "$NET_ARGS" \ --arg help "$help_sub" \ --arg qual "$cmd $sub" \ --arg tail "${CMD_TAIL[$cmd]}" \ @@ -222,10 +243,7 @@ for cmd in "${CMDS[@]}"; do signature_tail: $tail, is_family: true, help_raw: $help, - help_sha256: $hash, - version: $version, - network_args: $net, - generated_utc: now|strftime("%Y-%m-%dT%H:%M:%SZ") + help_sha256: $hash }' >> "$OUT_JSONL" fi done From 974d12daa1d361afc1341557ecfc9da42d8f31dd Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 09:54:48 -0500 Subject: [PATCH 05/15] feat: add rpc change summary script --- rpc_changes_summary.py | 222 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 222 insertions(+) create mode 100644 rpc_changes_summary.py diff --git a/rpc_changes_summary.py b/rpc_changes_summary.py new file mode 100644 index 000000000..97ae61589 --- /dev/null +++ b/rpc_changes_summary.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +""" +Generate executive summary of RPC changes between versions. +""" + +import json +import re + +def parse_jsonl(filepath): + """Parse JSONL file and return dict of command -> data""" + commands = {} + with open(filepath, 'r') as f: + for line in f: + if line.strip(): + data = json.loads(line) + if 'metadata' in data: + continue + commands[data['command']] = data + return commands + +def find_deprecated_items(help_text): + """Find all deprecated items in help text""" + deprecated = [] + lines = help_text.split('\n') + for line in lines: + if '(DEPRECATED' in line.upper(): + # Extract the field name or description + deprecated.append(line.strip()) + return deprecated + +def extract_signature(help_text): + """Extract the command signature from help text""" + lines = help_text.split('\n') + if lines: + return lines[0].strip() + return "" + +def categorize_changes(old_commands, new_commands): + """Categorize all changes between versions""" + old_cmds = set(old_commands.keys()) + new_cmds = set(new_commands.keys()) + + changes = { + 'added': sorted(new_cmds - old_cmds), + 'removed': sorted(old_cmds - new_cmds), + 'modified': {}, + 'newly_deprecated': {}, + 'signature_changed': [], + } + + # Analyze common commands + common = sorted(old_cmds & new_cmds) + for cmd in common: + old_help = old_commands[cmd].get('help_raw', '') + new_help = new_commands[cmd].get('help_raw', '') + + # Check if modified + if old_commands[cmd].get('help_sha256') != new_commands[cmd].get('help_sha256'): + old_sig = extract_signature(old_help) + new_sig = extract_signature(new_help) + + # Check for deprecations + old_dep = set(find_deprecated_items(old_help)) + new_dep = set(find_deprecated_items(new_help)) + newly_dep = new_dep - old_dep + + if newly_dep: + changes['newly_deprecated'][cmd] = list(newly_dep) + + # Check for signature changes + if old_sig != new_sig: + changes['signature_changed'].append({ + 'command': cmd, + 'old': old_sig, + 'new': new_sig + }) + + # Store all modifications + changes['modified'][cmd] = { + 'old_sig': old_sig, + 'new_sig': new_sig, + 'sig_changed': old_sig != new_sig, + 'has_deprecations': len(newly_dep) > 0 + } + + return changes + +def generate_summary(old_file, new_file, old_version, new_version): + """Generate executive summary""" + print(f"Parsing {old_file}...") + old_commands = parse_jsonl(old_file) + print(f"Found {len(old_commands)} commands in {old_version}") + + print(f"\nParsing {new_file}...") + new_commands = parse_jsonl(new_file) + print(f"Found {len(new_commands)} commands in {new_version}") + + changes = categorize_changes(old_commands, new_commands) + + # Generate summary report + report = [] + report.append(f"# Dash Core RPC Changes: {old_version} → {new_version}") + report.append(f"\n**Executive Summary**\n") + + # Key Statistics + report.append("## Key Statistics\n") + report.append(f"- **Total RPCs in {old_version}:** {len(old_commands)}") + report.append(f"- **Total RPCs in {new_version}:** {len(new_commands)}") + report.append(f"- **Added RPCs:** {len(changes['added'])}") + report.append(f"- **Removed RPCs:** {len(changes['removed'])}") + report.append(f"- **Modified RPCs:** {len(changes['modified'])}") + report.append(f"- **RPCs with signature changes:** {len(changes['signature_changed'])}") + report.append(f"- **RPCs with new deprecations:** {len(changes['newly_deprecated'])}") + report.append("") + + # Major Changes Section + report.append("## Major Changes\n") + + # Added RPCs + if changes['added']: + report.append(f"### Added RPCs ({len(changes['added'])})\n") + for cmd in changes['added']: + desc = new_commands[cmd].get('help_raw', '').split('\n') + sig = desc[0] if desc else cmd + report.append(f"- **`{cmd}`**") + if len(desc) > 1: + report.append(f" - {desc[1].strip()}") + report.append("") + + # Removed RPCs + if changes['removed']: + report.append(f"### Removed RPCs ({len(changes['removed'])})\n") + for cmd in changes['removed']: + desc = old_commands[cmd].get('help_raw', '').split('\n') + report.append(f"- **`{cmd}`**") + if len(desc) > 1: + report.append(f" - {desc[1].strip()}") + report.append("") + + # Signature Changes (Most Important) + if changes['signature_changed']: + report.append(f"### RPCs with Signature Changes ({len(changes['signature_changed'])})\n") + report.append("*These commands have changes to their parameters or calling format*\n") + for change in changes['signature_changed']: + report.append(f"#### `{change['command']}`\n") + report.append("**Old signature:**") + report.append(f"```") + report.append(change['old']) + report.append(f"```\n") + report.append("**New signature:**") + report.append(f"```") + report.append(change['new']) + report.append(f"```\n") + + # New Deprecations + if changes['newly_deprecated']: + report.append(f"### New Deprecation Notices ({len(changes['newly_deprecated'])})\n") + report.append("*These commands or fields are newly marked as deprecated*\n") + for cmd, deps in sorted(changes['newly_deprecated'].items()): + report.append(f"#### `{cmd}`\n") + for dep in deps: + # Clean up the deprecation notice + dep_clean = dep.strip() + report.append(f"- {dep_clean}") + report.append("") + + # Modified RPCs without signature changes + modified_no_sig = {k: v for k, v in changes['modified'].items() + if not v['sig_changed'] and not v['has_deprecations']} + if modified_no_sig: + report.append(f"### Other Modified RPCs ({len(modified_no_sig)})\n") + report.append("*These commands have changes to documentation, result format, or minor details*\n") + for cmd in sorted(modified_no_sig.keys()): + report.append(f"- `{cmd}`") + report.append("") + + # Key Observations + report.append("## Key Observations\n") + + # Platform/EvoNode changes + platform_related = [cmd for cmd in changes['signature_changed'] + if 'platform' in cmd['new'].lower() or 'evo' in cmd['new'].lower()] + if platform_related: + report.append(f"### Platform/EvoNode Changes ({len(platform_related)})") + report.append("Several commands related to Platform and EvoNodes have been updated:") + for change in platform_related: + report.append(f"- `{change['command']}`") + report.append("") + + # Deprecated service field + service_deprecated = [cmd for cmd, deps in changes['newly_deprecated'].items() + if any('service' in dep.lower() for dep in deps)] + if service_deprecated: + report.append("### Deprecated 'service' Field") + report.append("The following commands now deprecate the 'service' field (IP:PORT format),") + report.append("moving to a new 'addresses' structure:") + for cmd in service_deprecated: + report.append(f"- `{cmd}`") + report.append("") + + # BLS legacy deprecation + if 'bls' in changes['newly_deprecated']: + report.append("### BLS Legacy Scheme Deprecated") + report.append("The legacy BLS scheme is now deprecated in the `bls` command.") + report.append("This requires the `-deprecatedrpc=legacy_mn` flag to use.") + report.append("") + + return '\n'.join(report) + +if __name__ == '__main__': + old_file = '/home/phez/code/dashpay-docs/dash-cli-help-22.1.3-20251104T214929Z.jsonl' + new_file = '/home/phez/code/dashpay-docs/dash-cli-help-23.0.0-rc.3-20251104T213450Z.jsonl' + + summary = generate_summary(old_file, new_file, '22.1.3', '23.0.0-rc.3') + + output_file = '/home/phez/code/dashpay-docs/rpc-changes-summary-22.1.3-to-23.0.0-rc.3.md' + with open(output_file, 'w') as f: + f.write(summary) + + print(f"\n\nSummary generated: {output_file}") + print("\n" + "="*80) + print(summary) From c2700e168355251cacfd13a435969b96a381c20d Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 10:34:26 -0500 Subject: [PATCH 06/15] script: update to capture all subcommands also, output summary table --- rpc_changes_summary.py | 532 +++++++++++++++++++++++++++++------------ 1 file changed, 376 insertions(+), 156 deletions(-) diff --git a/rpc_changes_summary.py b/rpc_changes_summary.py index 97ae61589..1d3be98e3 100644 --- a/rpc_changes_summary.py +++ b/rpc_changes_summary.py @@ -1,92 +1,281 @@ #!/usr/bin/env python3 """ Generate executive summary of RPC changes between versions. + +Improvements vs. previous version: +- Index JSONL by `qualified` (command OR "command subcommand") to avoid overwriting subcommands. +- Categorize changes more granularly: signature, arguments, result fields, and deprecations. +- Robust deprecation finder and "replaced with" detector. +- Distinguish docs-only changes from structural changes. """ import json import re +from collections import defaultdict + +# ---------- JSONL parsing ---------- def parse_jsonl(filepath): - """Parse JSONL file and return dict of command -> data""" - commands = {} + """ + Parse JSONL file and return dict: qualified -> record + Skips metadata lines. + """ + cmds = {} with open(filepath, 'r') as f: for line in f: - if line.strip(): - data = json.loads(line) - if 'metadata' in data: - continue - commands[data['command']] = data - return commands - -def find_deprecated_items(help_text): - """Find all deprecated items in help text""" - deprecated = [] - lines = help_text.split('\n') - for line in lines: - if '(DEPRECATED' in line.upper(): - # Extract the field name or description - deprecated.append(line.strip()) - return deprecated - -def extract_signature(help_text): - """Extract the command signature from help text""" - lines = help_text.split('\n') - if lines: - return lines[0].strip() + if not line.strip(): + continue + data = json.loads(line) + if 'metadata' in data: + continue + # Use 'qualified' so subcommands aren't overwritten + key = data.get('qualified') or data.get('command') + if not key: + continue + cmds[key] = data + return cmds + +# ---------- Text helpers ---------- + +_DEPRECATION_RE = re.compile(r'\( *DEPRECATED\b[^)]*\)', re.IGNORECASE) +_REPLACED_WITH_RE = re.compile(r'\b(replaced\s+with)\b[: ]+(?P.+)$', re.IGNORECASE) +_ARGUMENTS_HDR_RE = re.compile(r'^\s*Arguments:\s*$', re.IGNORECASE) +_RESULT_HDR_RE = re.compile(r'^\s*Result\b', re.IGNORECASE) + +# Lines like: "field" : type, (qualifiers) description +_RESULT_FIELD_RE = re.compile(r'^\s*"(?P[^"]+)"\s*:\s*') + +# Try to extract a concise "signature" = first non-empty line +def extract_signature(help_text: str) -> str: + for line in help_text.splitlines(): + s = line.strip() + if s: + return s return "" +def find_deprecated_items(help_text: str): + """Return list of lines that contain '(DEPRECATED...)', case-insensitive.""" + hits = [] + for line in help_text.splitlines(): + if _DEPRECATION_RE.search(line): + hits.append(line.strip()) + return hits + +def find_replacements(help_text: str): + """ + Find "replaced with X" hints, returned as list of (line, replacement) tuples. + Useful for mapping old->new field names. + """ + items = [] + for line in help_text.splitlines(): + m = _REPLACED_WITH_RE.search(line) + if m: + items.append((line.strip(), m.group('replacement').strip())) + return items + +def parse_arguments_section(help_text: str): + """ + Parse 'Arguments:' block into a set of argument keys and a dict for detail. + Heuristics: lines in the arguments block often start with '1. name (...)' or quoted names. + We’ll extract names conservatively. + """ + lines = help_text.splitlines() + in_args = False + args = [] + for i, line in enumerate(lines): + if _ARGUMENTS_HDR_RE.match(line): + in_args = True + continue + if in_args: + # Stop if we hit an empty line or another header-like thing + if not line.strip(): + break + if _RESULT_HDR_RE.match(line): + break + # Try patterns: + # 1. number-dot form: 1. argname (type, optional, ...) + m = re.match(r'^\s*\d+\.\s*([A-Za-z0-9_\[\]".-]+)', line) + if m: + name = m.group(1).strip() + # strip surrounding quotes if present + name = name.strip('"') + args.append(name) + continue + # 2. quoted field as an argument name + m2 = re.match(r'^\s*"([^"]+)"\s*[:)]', line) + if m2: + args.append(m2.group(1).strip()) + continue + # 3. bare token at start (fallback) + m3 = re.match(r'^\s*([A-Za-z0-9_".-]+)\s', line) + if m3 and not line.strip().startswith('{'): + token = m3.group(1).strip('"') + args.append(token) + # Normalize + dedup + return list(dict.fromkeys(args)) + +def parse_result_fields(help_text: str): + """ + Parse 'Result' block for JSON-style field names. + Collect quoted keys at start-of-line with colon. + """ + lines = help_text.splitlines() + in_result = False + fields = [] + for line in lines: + if _RESULT_HDR_RE.match(line): + in_result = True + continue + if in_result: + # Heuristic stop: out of structured result section if code fence or blank block end + if line.strip().startswith('Examples:'): + break + m = _RESULT_FIELD_RE.match(line) + if m: + fields.append(m.group('name').strip()) + return list(dict.fromkeys(fields)) + +def extract_signature_args(signature: str): + """ + Heuristic arg name extraction from the signature line. + We capture tokens inside quotes, like "label", "address", or ["address",...] + """ + quoted = re.findall(r'"([^"]+)"', signature) + # Also catch bracketed array arg names like ["address",...] + bracket_names = re.findall(r'\[\s*"([^"]+)"', signature) + tokens = quoted + bracket_names + # Dedup preserving order + return list(dict.fromkeys(tokens)) + +# ---------- Change categorization ---------- + +def compare_structures(old_help: str, new_help: str): + """Return a dict with structured diffs between two help texts.""" + old_sig = extract_signature(old_help) + new_sig = extract_signature(new_help) + + old_sig_args = set(extract_signature_args(old_sig)) + new_sig_args = set(extract_signature_args(new_sig)) + + old_args = set(parse_arguments_section(old_help)) + new_args = set(parse_arguments_section(new_help)) + + old_fields = set(parse_result_fields(old_help)) + new_fields = set(parse_result_fields(new_help)) + + old_dep = set(find_deprecated_items(old_help)) + new_dep = set(find_deprecated_items(new_help)) + newly_dep = sorted(new_dep - old_dep) + + repl = find_replacements(new_help) + + return { + "old_sig": old_sig, + "new_sig": new_sig, + "signature_changed": (old_sig != new_sig), + "sig_args_added": sorted(new_sig_args - old_sig_args), + "sig_args_removed": sorted(old_sig_args - new_sig_args), + + "args_added": sorted(new_args - old_args), + "args_removed": sorted(old_args - new_args), + + "result_fields_added": sorted(new_fields - old_fields), + "result_fields_removed": sorted(old_fields - new_fields), + + "newly_deprecated": newly_dep, + "replacements": repl, + } + def categorize_changes(old_commands, new_commands): - """Categorize all changes between versions""" - old_cmds = set(old_commands.keys()) - new_cmds = set(new_commands.keys()) + """Compute added/removed/modified and categorize modified details.""" + old_keys = set(old_commands.keys()) + new_keys = set(new_commands.keys()) changes = { - 'added': sorted(new_cmds - old_cmds), - 'removed': sorted(old_cmds - new_cmds), - 'modified': {}, - 'newly_deprecated': {}, - 'signature_changed': [], + "added": sorted(new_keys - old_keys), + "removed": sorted(old_keys - new_keys), + "modified": {}, # key -> detail dict } - # Analyze common commands - common = sorted(old_cmds & new_cmds) - for cmd in common: - old_help = old_commands[cmd].get('help_raw', '') - new_help = new_commands[cmd].get('help_raw', '') - - # Check if modified - if old_commands[cmd].get('help_sha256') != new_commands[cmd].get('help_sha256'): - old_sig = extract_signature(old_help) - new_sig = extract_signature(new_help) - - # Check for deprecations - old_dep = set(find_deprecated_items(old_help)) - new_dep = set(find_deprecated_items(new_help)) - newly_dep = new_dep - old_dep - - if newly_dep: - changes['newly_deprecated'][cmd] = list(newly_dep) - - # Check for signature changes - if old_sig != new_sig: - changes['signature_changed'].append({ - 'command': cmd, - 'old': old_sig, - 'new': new_sig - }) - - # Store all modifications - changes['modified'][cmd] = { - 'old_sig': old_sig, - 'new_sig': new_sig, - 'sig_changed': old_sig != new_sig, - 'has_deprecations': len(newly_dep) > 0 - } + common = sorted(old_keys & new_keys) + for key in common: + old = old_commands[key] + new = new_commands[key] + if old.get('help_sha256') == new.get('help_sha256'): + continue # unchanged + + detail = compare_structures(old.get('help_raw', ''), new.get('help_raw', '')) + + # classify reason (multiple may apply; keep a compact list) + reasons = [] + if detail["signature_changed"] or detail["sig_args_added"] or detail["sig_args_removed"]: + reasons.append("signature") + if detail["args_added"] or detail["args_removed"]: + reasons.append("arguments") + if detail["result_fields_added"] or detail["result_fields_removed"]: + reasons.append("result") + if detail["newly_deprecated"]: + reasons.append("deprecation") + if not reasons: + reasons.append("docs-only") + + detail["reasons"] = reasons + changes["modified"][key] = detail return changes +# ---------- Reporting helpers ---------- + +def render_change_details(key, d, report): + """Append all detected details for an RPC to the report (under one heading).""" + report.append(f"#### `{key}`") + + # Signature delta + if d["old_sig"] or d["new_sig"]: + if d["old_sig"] != d["new_sig"]: + report.append("**Old signature:**") + report.append("```") + report.append(d["old_sig"]) + report.append("```\n") + report.append("**New signature:**") + report.append("```") + report.append(d["new_sig"]) + report.append("```\n") + + # Arg deltas (signature & Arguments:) + bullets = [] + if d["sig_args_added"]: + bullets.append(f"sig added: {', '.join(d['sig_args_added'])}") + if d["sig_args_removed"]: + bullets.append(f"sig removed: {', '.join(d['sig_args_removed'])}") + if d["args_added"]: + bullets.append(f"args added: {', '.join(d['args_added'])}") + if d["args_removed"]: + bullets.append(f"args removed: {', '.join(d['args_removed'])}") + if bullets: + report.append("- " + "; ".join(bullets)) + + # Result field deltas + bullets = [] + if d["result_fields_added"]: + bullets.append(f"result added: {', '.join(d['result_fields_added'])}") + if d["result_fields_removed"]: + bullets.append(f"result removed: {', '.join(d['result_fields_removed'])}") + if bullets: + report.append("- " + "; ".join(bullets)) + + # Deprecations + replacements + if d["newly_deprecated"]: + for dep in d["newly_deprecated"]: + report.append(f"- deprecation: {dep}") + for line, repl in d.get("replacements", []): + report.append(f"- replacement hint: {line}") + + report.append("") # spacing + +# ---------- Reporting ---------- + def generate_summary(old_file, new_file, old_version, new_version): - """Generate executive summary""" print(f"Parsing {old_file}...") old_commands = parse_jsonl(old_file) print(f"Found {len(old_commands)} commands in {old_version}") @@ -97,117 +286,148 @@ def generate_summary(old_file, new_file, old_version, new_version): changes = categorize_changes(old_commands, new_commands) - # Generate summary report report = [] - report.append(f"# Dash Core RPC Changes: {old_version} → {new_version}") - report.append(f"\n**Executive Summary**\n") + report.append(f"# Dash Core RPC Changes: {old_version} → {new_version}\n") + report.append("**Executive Summary**\n") - # Key Statistics + # Key Stats report.append("## Key Statistics\n") - report.append(f"- **Total RPCs in {old_version}:** {len(old_commands)}") - report.append(f"- **Total RPCs in {new_version}:** {len(new_commands)}") - report.append(f"- **Added RPCs:** {len(changes['added'])}") - report.append(f"- **Removed RPCs:** {len(changes['removed'])}") - report.append(f"- **Modified RPCs:** {len(changes['modified'])}") - report.append(f"- **RPCs with signature changes:** {len(changes['signature_changed'])}") - report.append(f"- **RPCs with new deprecations:** {len(changes['newly_deprecated'])}") + report.append(f"- **Total RPC entries in {old_version}:** {len(old_commands)}") + report.append(f"- **Total RPC entries in {new_version}:** {len(new_commands)}") + report.append(f"- **Added RPC entries:** {len(changes['added'])}") + report.append(f"- **Removed RPC entries:** {len(changes['removed'])}") + report.append(f"- **Modified RPC entries:** {len(changes['modified'])}") + + # Reason counts + reason_counts = defaultdict(int) + for d in changes["modified"].values(): + for r in d["reasons"]: + reason_counts[r] += 1 + if reason_counts: + report.append("- **By reason:** " + ", ".join(f"{k}: {v}" for k, v in sorted(reason_counts.items()))) report.append("") - # Major Changes Section + # Major changes report.append("## Major Changes\n") - # Added RPCs + # Added if changes['added']: report.append(f"### Added RPCs ({len(changes['added'])})\n") - for cmd in changes['added']: - desc = new_commands[cmd].get('help_raw', '').split('\n') - sig = desc[0] if desc else cmd - report.append(f"- **`{cmd}`**") - if len(desc) > 1: - report.append(f" - {desc[1].strip()}") - report.append("") - - # Removed RPCs - if changes['removed']: - report.append(f"### Removed RPCs ({len(changes['removed'])})\n") - for cmd in changes['removed']: - desc = old_commands[cmd].get('help_raw', '').split('\n') - report.append(f"- **`{cmd}`**") - if len(desc) > 1: - report.append(f" - {desc[1].strip()}") + for key in changes['added']: + desc_lines = new_commands[key].get('help_raw', '').splitlines() + sig = desc_lines[0].strip() if desc_lines else key + report.append(f"- **`{key}`**") + if len(desc_lines) > 1 and desc_lines[1].strip(): + report.append(f" - {desc_lines[1].strip()}") report.append("") - # Signature Changes (Most Important) - if changes['signature_changed']: - report.append(f"### RPCs with Signature Changes ({len(changes['signature_changed'])})\n") - report.append("*These commands have changes to their parameters or calling format*\n") - for change in changes['signature_changed']: - report.append(f"#### `{change['command']}`\n") - report.append("**Old signature:**") - report.append(f"```") - report.append(change['old']) - report.append(f"```\n") - report.append("**New signature:**") - report.append(f"```") - report.append(change['new']) - report.append(f"```\n") - - # New Deprecations - if changes['newly_deprecated']: - report.append(f"### New Deprecation Notices ({len(changes['newly_deprecated'])})\n") - report.append("*These commands or fields are newly marked as deprecated*\n") - for cmd, deps in sorted(changes['newly_deprecated'].items()): - report.append(f"#### `{cmd}`\n") - for dep in deps: - # Clean up the deprecation notice - dep_clean = dep.strip() - report.append(f"- {dep_clean}") - report.append("") - - # Modified RPCs without signature changes - modified_no_sig = {k: v for k, v in changes['modified'].items() - if not v['sig_changed'] and not v['has_deprecations']} - if modified_no_sig: - report.append(f"### Other Modified RPCs ({len(modified_no_sig)})\n") - report.append("*These commands have changes to documentation, result format, or minor details*\n") - for cmd in sorted(modified_no_sig.keys()): - report.append(f"- `{cmd}`") + # Removed + if changes['removed']: + report.append(f"### Removed RPCs ({len(changes['removed'])})\n") + for key in changes['removed']: + desc_lines = old_commands[key].get('help_raw', '').splitlines() + report.append(f"- **`{key}`**") + if len(desc_lines) > 1 and desc_lines[1].strip(): + report.append(f" - {desc_lines[1].strip()}") report.append("") - # Key Observations + # ----- One appearance per RPC via priority bucketing ----- + priority = ["signature", "deprecation", "arguments", "result", "docs-only"] + bucket = {k: [] for k in priority} + for key, d in changes["modified"].items(): + for r in priority: + if r in d["reasons"]: + bucket[r].append((key, d)) + break + + # Signature + if bucket["signature"]: + report.append(f"### RPCs with Signature Changes ({len(bucket['signature'])})\n") + report.append("*These commands changed their top-line call format*\n") + for key, d in bucket["signature"]: + render_change_details(key, d, report) + + # Deprecations + if bucket["deprecation"]: + report.append(f"### New Deprecation Notices ({len(bucket['deprecation'])})\n") + for key, d in bucket["deprecation"]: + render_change_details(key, d, report) + + # Arguments + if bucket["arguments"]: + report.append(f"### Argument Changes ({len(bucket['arguments'])})\n") + for key, d in bucket["arguments"]: + render_change_details(key, d, report) + + # Result fields + if bucket["result"]: + report.append(f"### Result Field Changes ({len(bucket['result'])})\n") + for key, d in bucket["result"]: + render_change_details(key, d, report) + + # Docs-only + if bucket["docs-only"]: + report.append(f"### Other Modified RPCs (Docs-only, {len(bucket['docs-only'])})\n") + report.append("*Changed descriptions/examples without structural differences*\n") + for key, d in bucket["docs-only"]: + render_change_details(key, d, report) + + # Consolidated table for all modified RPCs + if changes['modified']: + report.append("## Modified RPCs (Consolidated)\n") + report.append("| RPC | Sig | Args | Result | Deprecation | Notes |") + report.append("|-----|:---:|:----:|:------:|:-----------:|-------|") + + for key, data in sorted(changes['modified'].items()): + sig = "✔" if data["signature_changed"] or data["sig_args_added"] or data["sig_args_removed"] else "" + args = "✔" if data["args_added"] or data["args_removed"] or data["sig_args_added"] or data["sig_args_removed"] else "" + res = "✔" if data["result_fields_added"] or data["result_fields_removed"] else "" + dep = "✔" if data["newly_deprecated"] else "" + + notes = "; ".join(filter(None, [ + (data["sig_args_added"] and f"sig added: {', '.join(data['sig_args_added'])}") or "", + (data["sig_args_removed"] and f"sig removed: {', '.join(data['sig_args_removed'])}") or "", + (data["args_added"] and f"args added: {', '.join(data['args_added'])}") or "", + (data["args_removed"] and f"args removed: {', '.join(data['args_removed'])}") or "", + (data["result_fields_added"] and f"result added: {', '.join(data['result_fields_added'])}") or "", + (data["result_fields_removed"] and f"result removed: {', '.join(data['result_fields_removed'])}") or "", + ])) + + report.append(f"| `{key}` | {sig} | {args} | {res} | {dep} | {notes} |") + + report.append("") # table spacing + + # Key observations (example heuristics; adapt to your needs) report.append("## Key Observations\n") - # Platform/EvoNode changes - platform_related = [cmd for cmd in changes['signature_changed'] - if 'platform' in cmd['new'].lower() or 'evo' in cmd['new'].lower()] - if platform_related: - report.append(f"### Platform/EvoNode Changes ({len(platform_related)})") - report.append("Several commands related to Platform and EvoNodes have been updated:") - for change in platform_related: - report.append(f"- `{change['command']}`") - report.append("") + # Rebuild sig_changes & newly_depr context from buckets for observations + sig_changes = bucket["signature"] + newly_depr = dict(bucket["deprecation"]) - # Deprecated service field - service_deprecated = [cmd for cmd, deps in changes['newly_deprecated'].items() - if any('service' in dep.lower() for dep in deps)] - if service_deprecated: - report.append("### Deprecated 'service' Field") - report.append("The following commands now deprecate the 'service' field (IP:PORT format),") - report.append("moving to a new 'addresses' structure:") - for cmd in service_deprecated: - report.append(f"- `{cmd}`") + evo_related = [ k for k, v in sig_changes if "evo" in v["new_sig"].lower() or "platform" in v["new_sig"].lower() ] + if evo_related: + report.append(f"### Platform/EvoNode Signatures ({len(evo_related)})") + for key in evo_related: + report.append(f"- `{key}`") report.append("") - # BLS legacy deprecation - if 'bls' in changes['newly_deprecated']: - report.append("### BLS Legacy Scheme Deprecated") - report.append("The legacy BLS scheme is now deprecated in the `bls` command.") - report.append("This requires the `-deprecatedrpc=legacy_mn` flag to use.") + service_depr = [ + k for k, v in newly_depr.items() + if any("service" in s.lower() for s in v["newly_deprecated"]) + ] + if service_depr: + report.append("### Deprecated 'service' Field\n") + report.append("These commands now deprecate the `service` field in favor of structured `addresses`:\n") + for k in service_depr: + report.append(f"- `{k}`") report.append("") - return '\n'.join(report) + return "\n".join(report) + +# ---------- CLI ---------- if __name__ == '__main__': + # Sample usage — update paths/versions as needed old_file = '/home/phez/code/dashpay-docs/dash-cli-help-22.1.3-20251104T214929Z.jsonl' new_file = '/home/phez/code/dashpay-docs/dash-cli-help-23.0.0-rc.3-20251104T213450Z.jsonl' From 348934c8340fad4a3d86035db6586ead008cbe5a Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 10:44:14 -0500 Subject: [PATCH 07/15] refactor: improve RPC changes report formatting and organization MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Reorganize report to show consolidated table before detailed sections - Enhance change detail rendering with grouped, nested bullet points - Add emoji indicators for change types (➕ added, ➖ removed, ⚠️ deprecated, 🔁 replacement) - Replace verbose "Notes" column with concise "Change Types" in table - Add anchor links from table to detailed sections for navigation - Filter out docs-only changes from consolidated table - Improve spacing and markdown code block formatting --- rpc_changes_summary.py | 117 +++++++++++++++++++++++++---------------- 1 file changed, 71 insertions(+), 46 deletions(-) diff --git a/rpc_changes_summary.py b/rpc_changes_summary.py index 1d3be98e3..156e3d337 100644 --- a/rpc_changes_summary.py +++ b/rpc_changes_summary.py @@ -228,50 +228,72 @@ def categorize_changes(old_commands, new_commands): def render_change_details(key, d, report): """Append all detected details for an RPC to the report (under one heading).""" - report.append(f"#### `{key}`") + report.append(f"#### `{key}`\n") - # Signature delta + # Signature delta (show blocks only if signature string changed) if d["old_sig"] or d["new_sig"]: if d["old_sig"] != d["new_sig"]: report.append("**Old signature:**") - report.append("```") + report.append("\n```text") report.append(d["old_sig"]) report.append("```\n") report.append("**New signature:**") - report.append("```") + report.append("\n```text") report.append(d["new_sig"]) report.append("```\n") - # Arg deltas (signature & Arguments:) - bullets = [] + # Build grouped changes with nested bullets + groups = [] + + # Signature-arg tokens (from the signature line) + sig_parts = [] if d["sig_args_added"]: - bullets.append(f"sig added: {', '.join(d['sig_args_added'])}") + sig_parts.append(f"➕ {', '.join(d['sig_args_added'])}") if d["sig_args_removed"]: - bullets.append(f"sig removed: {', '.join(d['sig_args_removed'])}") + sig_parts.append(f"➖ {', '.join(d['sig_args_removed'])}") + if sig_parts: + groups.append(("signature", sig_parts)) + + # Arguments section deltas (from Arguments: block) + arg_parts = [] if d["args_added"]: - bullets.append(f"args added: {', '.join(d['args_added'])}") + arg_parts.append(f"➕ {', '.join(d['args_added'])}") if d["args_removed"]: - bullets.append(f"args removed: {', '.join(d['args_removed'])}") - if bullets: - report.append("- " + "; ".join(bullets)) + arg_parts.append(f"➖ {', '.join(d['args_removed'])}") + if arg_parts: + groups.append(("args", arg_parts)) # Result field deltas - bullets = [] + res_parts = [] if d["result_fields_added"]: - bullets.append(f"result added: {', '.join(d['result_fields_added'])}") + res_parts.append(f"➕ {', '.join(d['result_fields_added'])}") if d["result_fields_removed"]: - bullets.append(f"result removed: {', '.join(d['result_fields_removed'])}") - if bullets: - report.append("- " + "; ".join(bullets)) + res_parts.append(f"➖ {', '.join(d['result_fields_removed'])}") + if res_parts: + groups.append(("result", res_parts)) - # Deprecations + replacements + # Deprecations + dep_parts = [] if d["newly_deprecated"]: for dep in d["newly_deprecated"]: - report.append(f"- deprecation: {dep}") + dep_parts.append(f"⚠️ deprecated: {dep}") + groups.append(("deprecation", dep_parts)) + + # Replacements (informational) + repl_parts = [] for line, repl in d.get("replacements", []): - report.append(f"- replacement hint: {line}") + repl_parts.append(f"🔁 replacement hint: {line}") + if repl_parts: + groups.append(("notes", repl_parts)) + + # Render groups + for label, parts in groups: + report.append(f"- {label}:") + for part in parts: + report.append(f" - {part}") + report.append("") # spacing after each group - report.append("") # spacing + report.append("") # final spacing # ---------- Reporting ---------- @@ -331,6 +353,34 @@ def generate_summary(old_file, new_file, old_version, new_version): report.append(f" - {desc_lines[1].strip()}") report.append("") + # Consolidated table for all modified RPCs (excluding docs-only changes) + if changes['modified']: + report.append("## Modified RPCs (Consolidated)\n") + report.append("| RPC | Sig | Args | Result | Deprecation | Change Types |") + report.append("|-----|:---:|:----:|:------:|:-----------:|--------------|") + + for key, data in sorted(changes['modified'].items()): + # Skip docs-only changes + if data["reasons"] == ["docs-only"]: + continue + + # Columns: checkmarks based on detected changes + sig = "✔" if data["signature_changed"] or data["sig_args_added"] or data["sig_args_removed"] else "" + args = "✔" if data["args_added"] or data["args_removed"] or data["sig_args_added"] or data["sig_args_removed"] else "" + res = "✔" if data["result_fields_added"] or data["result_fields_removed"] else "" + dep = "✔" if data["newly_deprecated"] else "" + + # High-level types of changes (for Notes column) + change_types = ", ".join(data["reasons"]) # e.g. "signature, arguments" + + # Anchor link to detailed section (GitHub-style heading id) + link = f"[`{key}`](#{key.replace(' ', '-').lower()})" + + report.append(f"| {link} | {sig} | {args} | {res} | {dep} | {change_types} |") + + report.append("") # table spacing + + # ----- One appearance per RPC via priority bucketing ----- priority = ["signature", "deprecation", "arguments", "result", "docs-only"] bucket = {k: [] for k in priority} @@ -372,31 +422,6 @@ def generate_summary(old_file, new_file, old_version, new_version): for key, d in bucket["docs-only"]: render_change_details(key, d, report) - # Consolidated table for all modified RPCs - if changes['modified']: - report.append("## Modified RPCs (Consolidated)\n") - report.append("| RPC | Sig | Args | Result | Deprecation | Notes |") - report.append("|-----|:---:|:----:|:------:|:-----------:|-------|") - - for key, data in sorted(changes['modified'].items()): - sig = "✔" if data["signature_changed"] or data["sig_args_added"] or data["sig_args_removed"] else "" - args = "✔" if data["args_added"] or data["args_removed"] or data["sig_args_added"] or data["sig_args_removed"] else "" - res = "✔" if data["result_fields_added"] or data["result_fields_removed"] else "" - dep = "✔" if data["newly_deprecated"] else "" - - notes = "; ".join(filter(None, [ - (data["sig_args_added"] and f"sig added: {', '.join(data['sig_args_added'])}") or "", - (data["sig_args_removed"] and f"sig removed: {', '.join(data['sig_args_removed'])}") or "", - (data["args_added"] and f"args added: {', '.join(data['args_added'])}") or "", - (data["args_removed"] and f"args removed: {', '.join(data['args_removed'])}") or "", - (data["result_fields_added"] and f"result added: {', '.join(data['result_fields_added'])}") or "", - (data["result_fields_removed"] and f"result removed: {', '.join(data['result_fields_removed'])}") or "", - ])) - - report.append(f"| `{key}` | {sig} | {args} | {res} | {dep} | {notes} |") - - report.append("") # table spacing - # Key observations (example heuristics; adapt to your needs) report.append("## Key Observations\n") From bb87f99ffef6b557c65e61c62c64341fd6a0517c Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 10:52:18 -0500 Subject: [PATCH 08/15] refactor: move and rename script --- .../generate-core-rpc-change-summary.py | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) rename rpc_changes_summary.py => scripts/generate-core-rpc-change-summary.py (96%) mode change 100644 => 100755 diff --git a/rpc_changes_summary.py b/scripts/generate-core-rpc-change-summary.py old mode 100644 new mode 100755 similarity index 96% rename from rpc_changes_summary.py rename to scripts/generate-core-rpc-change-summary.py index 156e3d337..0d5145c4f --- a/rpc_changes_summary.py +++ b/scripts/generate-core-rpc-change-summary.py @@ -1,12 +1,6 @@ #!/usr/bin/env python3 """ Generate executive summary of RPC changes between versions. - -Improvements vs. previous version: -- Index JSONL by `qualified` (command OR "command subcommand") to avoid overwriting subcommands. -- Categorize changes more granularly: signature, arguments, result fields, and deprecations. -- Robust deprecation finder and "replaced with" detector. -- Distinguish docs-only changes from structural changes. """ import json @@ -453,12 +447,12 @@ def generate_summary(old_file, new_file, old_version, new_version): if __name__ == '__main__': # Sample usage — update paths/versions as needed - old_file = '/home/phez/code/dashpay-docs/dash-cli-help-22.1.3-20251104T214929Z.jsonl' - new_file = '/home/phez/code/dashpay-docs/dash-cli-help-23.0.0-rc.3-20251104T213450Z.jsonl' + old_file = 'dash-cli-help-22.1.3-20251104T214929Z.jsonl' + new_file = 'dash-cli-help-23.0.0-rc.3-20251104T213450Z.jsonl' summary = generate_summary(old_file, new_file, '22.1.3', '23.0.0-rc.3') - output_file = '/home/phez/code/dashpay-docs/rpc-changes-summary-22.1.3-to-23.0.0-rc.3.md' + output_file = 'rpc-changes-summary-22.1.3-to-23.0.0-rc.3.md' with open(output_file, 'w') as f: f.write(summary) From 9bd17821ab0820bffc36ba3706964e5fe1e820d1 Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 10:59:38 -0500 Subject: [PATCH 09/15] feat: use core version from jsonl --- scripts/generate-core-rpc-change-summary.py | 60 +++++++++++++++------ 1 file changed, 45 insertions(+), 15 deletions(-) diff --git a/scripts/generate-core-rpc-change-summary.py b/scripts/generate-core-rpc-change-summary.py index 0d5145c4f..0256c9674 100755 --- a/scripts/generate-core-rpc-change-summary.py +++ b/scripts/generate-core-rpc-change-summary.py @@ -5,9 +5,29 @@ import json import re +import os from collections import defaultdict -# ---------- JSONL parsing ---------- +# ---------- JSONL parsing & metadata ---------- + +def read_metadata(filepath): + """ + Read first JSONL line that contains {"metadata": {...}} and return that dict. + Returns {} if not found. + """ + with open(filepath, 'r') as f: + for line in f: + line = line.strip() + if not line: + continue + try: + data = json.loads(line) + except json.JSONDecodeError: + continue + meta = data.get("metadata") + if isinstance(meta, dict): + return meta + return {} def parse_jsonl(filepath): """ @@ -90,9 +110,7 @@ def parse_arguments_section(help_text: str): # 1. number-dot form: 1. argname (type, optional, ...) m = re.match(r'^\s*\d+\.\s*([A-Za-z0-9_\[\]".-]+)', line) if m: - name = m.group(1).strip() - # strip surrounding quotes if present - name = name.strip('"') + name = m.group(1).strip().strip('"') args.append(name) continue # 2. quoted field as an argument name @@ -291,12 +309,22 @@ def render_change_details(key, d, report): # ---------- Reporting ---------- -def generate_summary(old_file, new_file, old_version, new_version): - print(f"Parsing {old_file}...") +def generate_summary(old_file, new_file, old_version=None, new_version=None): + # Pull metadata versions if present + old_meta = read_metadata(old_file) + new_meta = read_metadata(new_file) + meta_old_ver = (old_meta.get("version") or "").strip() + meta_new_ver = (new_meta.get("version") or "").strip() + + # Resolve final versions to use for headings/filenames + old_version = old_version or meta_old_ver or "old" + new_version = new_version or meta_new_ver or "new" + + print(f"Parsing {old_file} (version: {meta_old_ver or 'n/a'})...") old_commands = parse_jsonl(old_file) print(f"Found {len(old_commands)} commands in {old_version}") - print(f"\nParsing {new_file}...") + print(f"\nParsing {new_file} (version: {meta_new_ver or 'n/a'})...") new_commands = parse_jsonl(new_file) print(f"Found {len(new_commands)} commands in {new_version}") @@ -369,12 +397,10 @@ def generate_summary(old_file, new_file, old_version, new_version): # Anchor link to detailed section (GitHub-style heading id) link = f"[`{key}`](#{key.replace(' ', '-').lower()})" - report.append(f"| {link} | {sig} | {args} | {res} | {dep} | {change_types} |") report.append("") # table spacing - # ----- One appearance per RPC via priority bucketing ----- priority = ["signature", "deprecation", "arguments", "result", "docs-only"] bucket = {k: [] for k in priority} @@ -441,21 +467,25 @@ def generate_summary(old_file, new_file, old_version, new_version): report.append(f"- `{k}`") report.append("") - return "\n".join(report) + return "\n".join(report), old_version, new_version # ---------- CLI ---------- if __name__ == '__main__': - # Sample usage — update paths/versions as needed + # Sample usage — update paths as needed old_file = 'dash-cli-help-22.1.3-20251104T214929Z.jsonl' new_file = 'dash-cli-help-23.0.0-rc.3-20251104T213450Z.jsonl' - summary = generate_summary(old_file, new_file, '22.1.3', '23.0.0-rc.3') + report, old_ver, new_ver = generate_summary(old_file, new_file) + + # Build output filename from metadata versions if available + safe_old = re.sub(r'[^A-Za-z0-9._-]+', '_', old_ver) + safe_new = re.sub(r'[^A-Za-z0-9._-]+', '_', new_ver) + output_file = f'rpc-changes-summary-{safe_old}-to-{safe_new}.md' - output_file = 'rpc-changes-summary-22.1.3-to-23.0.0-rc.3.md' with open(output_file, 'w') as f: - f.write(summary) + f.write(report) print(f"\n\nSummary generated: {output_file}") print("\n" + "="*80) - print(summary) + print(report) From e4a89d6a7fd90437bc326dee361c87f971d03726 Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 10:59:59 -0500 Subject: [PATCH 10/15] refactor: move core rpc scripts --- scripts/{ => core-rpc-tools}/dash-dump-cli-help.sh | 0 scripts/{ => core-rpc-tools}/generate-core-rpc-change-summary.py | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename scripts/{ => core-rpc-tools}/dash-dump-cli-help.sh (100%) rename scripts/{ => core-rpc-tools}/generate-core-rpc-change-summary.py (100%) diff --git a/scripts/dash-dump-cli-help.sh b/scripts/core-rpc-tools/dash-dump-cli-help.sh similarity index 100% rename from scripts/dash-dump-cli-help.sh rename to scripts/core-rpc-tools/dash-dump-cli-help.sh diff --git a/scripts/generate-core-rpc-change-summary.py b/scripts/core-rpc-tools/generate-core-rpc-change-summary.py similarity index 100% rename from scripts/generate-core-rpc-change-summary.py rename to scripts/core-rpc-tools/generate-core-rpc-change-summary.py From 53ad2e031e5b5d1ec3ad65526bc846331173f733 Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 11:50:05 -0500 Subject: [PATCH 11/15] refactor: rename files --- .../core-rpc-tools/{dash-dump-cli-help.sh => dump-cli-help.sh} | 0 ...-core-rpc-change-summary.py => generate-rpc-change-summary.py} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename scripts/core-rpc-tools/{dash-dump-cli-help.sh => dump-cli-help.sh} (100%) rename scripts/core-rpc-tools/{generate-core-rpc-change-summary.py => generate-rpc-change-summary.py} (100%) diff --git a/scripts/core-rpc-tools/dash-dump-cli-help.sh b/scripts/core-rpc-tools/dump-cli-help.sh similarity index 100% rename from scripts/core-rpc-tools/dash-dump-cli-help.sh rename to scripts/core-rpc-tools/dump-cli-help.sh diff --git a/scripts/core-rpc-tools/generate-core-rpc-change-summary.py b/scripts/core-rpc-tools/generate-rpc-change-summary.py similarity index 100% rename from scripts/core-rpc-tools/generate-core-rpc-change-summary.py rename to scripts/core-rpc-tools/generate-rpc-change-summary.py From b2dc6f836b1830216274b8359a5826af86fd241b Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 11:50:27 -0500 Subject: [PATCH 12/15] docs: add readme --- scripts/core-rpc-tools/README.md | 177 +++++++++++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 scripts/core-rpc-tools/README.md diff --git a/scripts/core-rpc-tools/README.md b/scripts/core-rpc-tools/README.md new file mode 100644 index 000000000..93366a673 --- /dev/null +++ b/scripts/core-rpc-tools/README.md @@ -0,0 +1,177 @@ +# Dash Core RPC Documentation Tools + +This directory contains tools to assist with updating Dash Core RPC documentation when new versions are released. + +## Overview + +These scripts automate the process of: + +1. Extracting all RPC command help text from Dash Core +2. Comparing RPC definitions between versions +3. Generating human-readable change summaries + +This workflow helps documentation maintainers quickly identify what changed between Dash Core versions and update the RPC reference docs accordingly. + +## Prerequisites + +### Required Software + +* **dash-cli**: The Dash Core command-line interface (from your local Dash Core build or installation) +* **Running Dash node**: A Dash node with RPC access (testnet, mainnet, or regtest) +* **Python 3**: For running the comparison script +* **jq**: For JSON processing (used by dump-cli-help.sh) +* **Bash**: For running the shell script + +### Setup + +1. Ensure your Dash node is running and synced +2. Verify dash-cli can connect to your node: + + ```bash + dash-cli -testnet getblockchaininfo + ``` + +3. Install jq if not already installed: + + ```bash + # Ubuntu/Debian + sudo apt-get install jq + + # macOS + brew install jq + ``` + +## Complete Workflow + +### Step 1: Dump RPC Help for the Old Version + +First, dump all RPC help text from the version you're upgrading FROM: + +```bash +cd scripts/core-rpc-tools + +# Set path to your dash-cli for version 22.1.3 (example) +CLI="$HOME/dashcore-22.1.3/bin/dash-cli" NET_ARGS="-testnet" ./dump-cli-help.sh +``` + +This generates two files: + +* `dash-cli-help-22.1.3-.txt` - Human-readable text file +* `dash-cli-help-22.1.3-.jsonl` - Machine-readable JSONL file + +### Step 2: Dump RPC Help for the New Version + +Switch to the new Dash Core version and dump its help: + +```bash +# Restart your node with the new version +# Then dump help again +cd ~/code/dashpay-docs/scripts/core-rpc-tools +CLI="$HOME/dashcore-23.0.0/bin/dash-cli" NET_ARGS="-testnet" ./dump-cli-help.sh +``` + +This generates: + +* `dash-cli-help-23.0.0-.txt` +* `dash-cli-help-23.0.0-.jsonl` + +### Step 3: Generate Change Summary + +Compare the two versions and generate a detailed change report: + +```bash +# Edit generate-rpc-change-summary.py to set your file paths + +python3 generate-rpc-change-summary.py +``` + +This generates: + +* `rpc-changes-summary-22.1.3-to-23.0.0.md` - Comprehensive change summary + +## Script Details + +### dump-cli-help.sh + +**Purpose**: Extracts help text for all RPC commands and subcommands from dash-cli. + +**Usage**: + +```bash +./dump-cli-help.sh +``` + +**Configuration via Environment Variables**: + +```bash +# Custom dash-cli path +CLI="/path/to/dash-cli" ./dump-cli-help.sh + +# Different network +NET_ARGS="" ./dump-cli-help.sh # mainnet +``` + +**How It Works**: + +1. Runs `dash-cli help` to get the full command list +2. Iterates through each command and captures `dash-cli help ` +3. Detects "family" RPCs (commands with subcommands like `protx`, `bls`, `coinjoin`) +4. For family RPCs, discovers and captures help for each subcommand +5. Outputs both human-readable text and structured JSONL format +6. Automatically extracts version from `dash-cli -version` and includes it in filenames + +**Output Files**: + +* **Text file** (`.txt`): Formatted for human reading, with headers and separators +* **JSONL file** (`.jsonl`): One JSON object per line, structured for machine parsing + * Metadata header with version, network, timestamp + * One record per command/subcommand with: + * `command`: Top-level command name + * `subcommand`: Subcommand name (null for root commands) + * `qualified`: Full command string (e.g., "protx register") + * `signature_tail`: Argument signature from help list + * `is_family`: Whether this is a family RPC with subcommands + * `help_raw`: Complete help text + * `help_sha256`: Hash for detecting changes + +### generate-rpc-change-summary.py + +**Purpose**: Compares two JSONL help dumps and generates a detailed change summary. + +**Usage**: + +```bash +# Edit the script to set your input files +nano generate-rpc-change-summary.py + +# Then run +python3 generate-rpc-change-summary.py +``` + +**Configuration** (edit the `__main__` block at the bottom): + +```python +if __name__ == '__main__': + old_file = 'dash-cli-help--.jsonl' + new_file = 'dash-cli-help--.jsonl' + + # ... rest of script +``` + +## Output Files Reference + +After running the complete workflow, you'll have these files: + +| File | Purpose | Format | +|------|---------|--------| +| `dash-cli-help-{version}-{timestamp}.txt` | Human-readable help dump | Plain text with headers | +| `dash-cli-help-{version}-{timestamp}.jsonl` | Machine-readable help dump | JSONL (one JSON per line) | +| `rpc-changes-summary-{oldver}-to-{newver}.md` | Change summary report | Markdown | + +**Recommended versioning**: Keep all JSONL files in version control to track historical changes: + +```bash +git add dash-cli-help-*.jsonl +git add rpc-changes-summary-*.md +git commit -m "feat: add RPC change analysis for " +``` From 0edcf3f9655a5e637459576294234aca2a8c4d7f Mon Sep 17 00:00:00 2001 From: thephez Date: Wed, 5 Nov 2025 11:52:40 -0500 Subject: [PATCH 13/15] docs: add core 22.1.3 rpc help output --- .../core-rpc-tools/dash-cli-help-22.1.3.jsonl | 243 ++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 scripts/core-rpc-tools/dash-cli-help-22.1.3.jsonl diff --git a/scripts/core-rpc-tools/dash-cli-help-22.1.3.jsonl b/scripts/core-rpc-tools/dash-cli-help-22.1.3.jsonl new file mode 100644 index 000000000..e0af52f78 --- /dev/null +++ b/scripts/core-rpc-tools/dash-cli-help-22.1.3.jsonl @@ -0,0 +1,243 @@ +{"metadata":{"version":"22.1.3","network_args":"","cli_path":"/home/phez/Downloads/dashcore-22.1.3/bin/dash-cli","generated_utc":"2025-11-04T21:49:29Z","command_count":180,"format":"dash-cli-help-dump-v1"}} +{"command":"abandontransaction","subcommand":null,"qualified":"abandontransaction","signature_tail":"\"txid\"","is_family":false,"help_raw":"abandontransaction \"txid\"\n\nMark in-wallet transaction as abandoned\nThis will mark this transaction and all its in-wallet descendants as abandoned which will allow\nfor their inputs to be respent. It can be used to replace \"stuck\" or evicted transactions.\nIt only works on transactions which are not included in a block and are not currently in the mempool.\nIt has no effect on transactions which are already abandoned.\n\nArguments:\n1. txid (string, required) The transaction id\n\nResult:\nnull (json null)\n\nExamples:\n> dash-cli abandontransaction \"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"abandontransaction\", \"params\": [\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"53d30b53e1c2e7cbc094c484656c0c977ecc64175c718a13f0a941e955afdf1e"} +{"command":"abortrescan","subcommand":null,"qualified":"abortrescan","signature_tail":"","is_family":false,"help_raw":"abortrescan\n\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\n\nResult:\ntrue|false (boolean) Whether the abort was successful\n\nExamples:\n\nImport a private key\n> dash-cli importprivkey \"mykey\"\n\nAbort the running wallet rescan\n> dash-cli abortrescan \n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"abortrescan\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"fb7510162398538589ada914ef54e7b8bbf3d28c10361bec58553bfb6a5e8a2f"} +{"command":"addmultisigaddress","subcommand":null,"qualified":"addmultisigaddress","signature_tail":"nrequired [\"key\",...] ( \"label\" )","is_family":false,"help_raw":"addmultisigaddress nrequired [\"key\",...] ( \"label\" )\n\nAdd an nrequired-to-sign multisignature address to the wallet. Requires a new wallet backup.\nEach key is a Dash address or hex-encoded public key.\nThis functionality is only intended for use with non-watchonly addresses.\nSee `importaddress` for watchonly p2sh address support.\nIf 'label' is specified, assign address to that label.\n\nArguments:\n1. nrequired (numeric, required) The number of required signatures out of the n keys or addresses.\n2. keys (json array, required) The Dash addresses or hex-encoded public keys\n [\n \"key\", (string) Dash address or hex-encoded public key\n ...\n ]\n3. label (string, optional) A label to assign the addresses to.\n\nResult:\n{ (json object)\n \"address\" : \"str\", (string) The value of the new multisig address\n \"redeemScript\" : \"hex\", (string) The string value of the hex-encoded redemption script\n \"descriptor\" : \"str\" (string) The descriptor for this multisig.\n}\n\nExamples:\n\nAdd a multisig address from 2 addresses\n> dash-cli addmultisigaddress 2 \"[\\\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\\\",\\\"XwQQkwA4FYkq2XERzMY2CiAZhJTEDAbtc0\\\"]\"\n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"addmultisigaddress\", \"params\": [2, \"[\\\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\\\",\\\"XwQQkwA4FYkq2XERzMY2CiAZhJTEDAbtc0\\\"]\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"7aa8eac0228c4dac37930241cbaf8c6a95642a8f0b087911fdb0551e5392ef07"} +{"command":"addnode","subcommand":null,"qualified":"addnode","signature_tail":"\"node\" \"command\" ( v2transport )","is_family":false,"help_raw":"addnode \"node\" \"command\" ( v2transport )\n\nAttempts to add or remove a node from the addnode list.\nOr try a connection to a node once.\nNodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be\nfull nodes as other outbound peers are (though such peers will not be synced from).\nAddnode connections are limited to 8 at a time and are counted separately from the -maxconnections limit.\n\nArguments:\n1. node (string, required) The node (see getpeerinfo for nodes)\n2. command (string, required) 'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once\n3. v2transport (boolean, optional, default=set by -v2transport) Attempt to connect using BIP324 v2 transport protocol (ignored for 'remove' command)\n\nResult:\nnull (json null)\n\nExamples:\n> dash-cli addnode \"192.168.0.6:9999\" \"onetry\" true\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"addnode\", \"params\": [\"192.168.0.6:9999\", \"onetry\" true]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"db2e3375d4db4eb99535c1f5905366b784ea518d0b4cb82d33030ab52c25841b"} +{"command":"analyzepsbt","subcommand":null,"qualified":"analyzepsbt","signature_tail":"\"psbt\"","is_family":false,"help_raw":"analyzepsbt \"psbt\"\n\nAnalyzes and provides information about the current status of a PSBT and its inputs\n\nArguments:\n1. psbt (string, required) A base64 string of a PSBT\n\nResult:\n{ (json object)\n \"inputs\" : [ (json array)\n { (json object)\n \"has_utxo\" : true|false, (boolean) Whether a UTXO is provided\n \"is_final\" : true|false, (boolean) Whether the input is finalized\n \"missing\" : { (json object, optional) Things that are missing that are required to complete this input\n \"pubkeys\" : [ (json array, optional)\n \"hex\", (string) Public key ID, hash160 of the public key, of a public key whose BIP 32 derivation path is missing\n ...\n ],\n \"signatures\" : [ (json array, optional)\n \"hex\", (string) Public key ID, hash160 of the public key, of a public key whose signature is missing\n ...\n ],\n \"redeemscript\" : \"hex\" (string, optional) Hash160 of the redeemScript that is missing\n },\n \"next\" : \"str\" (string, optional) Role of the next person that this input needs to go to\n },\n ...\n ],\n \"estimated_vsize\" : n, (numeric, optional) Estimated vsize of the final signed transaction\n \"estimated_feerate\" : n, (numeric, optional) Estimated feerate of the final signed transaction in DASH/kB. Shown only if all UTXO slots in the PSBT have been filled\n \"fee\" : n, (numeric, optional) The transaction fee paid. Shown only if all UTXO slots in the PSBT have been filled\n \"next\" : \"str\", (string) Role of the next person that this psbt needs to go to\n \"error\" : \"str\" (string, optional) Error message if there is one\n}\n\nExamples:\n> dash-cli analyzepsbt \"psbt\"","help_sha256":"ee8c591d40ad36d9988efb1cb180fe57f025c03bbcc23b3597f26680b1763a88"} +{"command":"backupwallet","subcommand":null,"qualified":"backupwallet","signature_tail":"\"destination\"","is_family":false,"help_raw":"backupwallet \"destination\"\n\nSafely copies current wallet file to destination, which can be a directory or a path with filename.\n\nArguments:\n1. destination (string, required) The destination directory or file\n\nResult:\nnull (json null)\n\nExamples:\n> dash-cli backupwallet \"backup.dat\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"backupwallet\", \"params\": [\"backup.dat\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"2d2b8952142144a72be34de58813314e9b4b619be7a8f26394b13aa3b3fb422b"} +{"command":"bls","subcommand":null,"qualified":"bls","signature_tail":"\"command\"","is_family":false,"help_raw":"bls \"command\"\nSet of commands to execute BLS related actions.\nTo get help on individual commands, use \"help bls command\".\n\nAvailable commands:\n generate - Create a BLS secret/public key pair\n fromsecret - Parse a BLS secret key and return the secret/public key pair\n\nArguments:\n1. command (string, required) The command to execute","help_sha256":"c7fd9566834a6d258c19a32f7ae4a26eb77d98b176c2c3ac3f29401bf77c6103"} +{"command":"bls","subcommand":"fromsecret","qualified":"bls fromsecret","signature_tail":"\"command\"","is_family":true,"help_raw":"bls fromsecret \"secret\" ( legacy )\n\nParses a BLS secret key and returns the secret/public key pair.\n\nArguments:\n1. secret (string, required) The BLS secret key\n2. legacy (boolean, optional, default=false) Pass true if you need in legacy scheme\n\nResult:\n{ (json object)\n \"secret\" : \"hex\", (string) BLS secret key\n \"public\" : \"hex\", (string) BLS public key\n \"scheme\" : \"hex\" (string) BLS scheme (valid schemes: legacy, basic)\n}\n\nExamples:\n> dash-cli bls fromsecret 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f","help_sha256":"c3f5e65cc75858743a374e5e668b1216cced8fb589da7476333fdaed2578f9fa"} +{"command":"bls","subcommand":"generate","qualified":"bls generate","signature_tail":"\"command\"","is_family":true,"help_raw":"bls generate ( legacy )\n\nReturns a BLS secret/public key pair.\n\nArguments:\n1. legacy (boolean, optional, default=false) Set it true if need in legacy BLS scheme\n\nResult:\n{ (json object)\n \"secret\" : \"hex\", (string) BLS secret key\n \"public\" : \"hex\", (string) BLS public key\n \"scheme\" : \"hex\" (string) BLS scheme (valid schemes: legacy, basic)\n}\n\nExamples:\n> dash-cli bls generate ","help_sha256":"663f62202aee1540523347aaa0a624407317d6fe7ed19f53bccc7fe45ff9ab2f"} +{"command":"clearbanned","subcommand":null,"qualified":"clearbanned","signature_tail":"","is_family":false,"help_raw":"clearbanned\n\nClear all banned IPs.\n\nResult:\nnull (json null)\n\nExamples:\n> dash-cli clearbanned \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"clearbanned\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"29986265f75a9d04178641f78458898a05dda9031f73c8ba9578e8e9cc1374b0"} +{"command":"coinjoin","subcommand":null,"qualified":"coinjoin","signature_tail":"\"command\"","is_family":false,"help_raw":"coinjoin \"command\"\n\nAvailable commands:\n start - Start mixing\n stop - Stop mixing\n reset - Reset mixing\nArguments:\n1. command (string, required) The command to execute","help_sha256":"160f33818cbc6fc9542843ceb217404a20b47c3616eb1f62a64445ba3ba80ca3"} +{"command":"coinjoin","subcommand":"reset","qualified":"coinjoin reset","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoin reset\n\nReset CoinJoin mixing\n\nResult:\n\"str\" (string) Status of request\n\nExamples:\n> dash-cli coinjoin reset \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoin reset\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"d3df617bd4be53c893f67e9be46e9632315c21f68ba6ebad259653726a5e210d"} +{"command":"coinjoin","subcommand":"start","qualified":"coinjoin start","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoin start\n\nStart CoinJoin mixing\nWallet must be unlocked for mixing\n\nResult:\n\"str\" (string) Status of request\n\nExamples:\n> dash-cli coinjoin start \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoin start\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"71111243036bb9c3e108a4cbec0e18e7475429f88c682a869b39bd6158659bab"} +{"command":"coinjoin","subcommand":"stop","qualified":"coinjoin stop","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoin stop\n\nStop CoinJoin mixing\n\nResult:\n\"str\" (string) Status of request\n\nExamples:\n> dash-cli coinjoin stop \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoin stop\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"1e92aed4ba7e9f8d814460a58b9be7d223841e532927f8eee3f43ad3765c1793"} +{"command":"coinjoinsalt","subcommand":null,"qualified":"coinjoinsalt","signature_tail":"\"command\"","is_family":false,"help_raw":"coinjoinsalt \"command\"\n\nAvailable commands:\n generate - Generate new CoinJoin salt\n get - Fetch existing CoinJoin salt\n set - Set new CoinJoin salt\n\nArguments:\n1. command (string, required) The command to execute","help_sha256":"cf554b7ce8bbfd0a3787fa1d6cb512982efe51937b7e5744ef507924dc4e52e3"} +{"command":"coinjoinsalt","subcommand":"generate","qualified":"coinjoinsalt generate","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoinsalt generate ( overwrite )\n\nGenerate new CoinJoin salt and store it in the wallet database\nCannot generate new salt if CoinJoin mixing is in process or wallet has private keys disabled.\n\nArguments:\n1. overwrite (boolean, optional, default=false) Generate new salt even if there is an existing salt and/or there is CoinJoin balance\n\nResult:\ntrue|false (boolean) Status of CoinJoin salt generation and commitment\n\nExamples:\n> dash-cli coinjoinsalt generate \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoinsalt generate\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"462b4a90983e917bd5f8a8285083b1d5285141ac86ac91ad4357707974d28680"} +{"command":"coinjoinsalt","subcommand":"get","qualified":"coinjoinsalt get","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoinsalt get\n\nFetch existing CoinJoin salt\nCannot fetch salt if wallet has private keys disabled.\n\nResult:\n\"hex\" (string) CoinJoin salt\n\nExamples:\n> dash-cli coinjoinsalt get \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoinsalt get\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"aba473af85b79573865da9bf98bcb4aba9513e02d6a3af28131e0f4c00889687"} +{"command":"coinjoinsalt","subcommand":"set","qualified":"coinjoinsalt set","signature_tail":"\"command\"","is_family":true,"help_raw":"coinjoinsalt set \"salt\" ( overwrite )\n\nSet new CoinJoin salt\nCannot set salt if CoinJoin mixing is in process or wallet has private keys disabled.\nWill overwrite existing salt. The presence of a CoinJoin balance will cause the wallet to rescan.\n\nArguments:\n1. salt (string, required) Desired CoinJoin salt value for the wallet\n2. overwrite (boolean, optional, default=false) Overwrite salt even if CoinJoin balance present\n\nResult:\ntrue|false (boolean) Status of CoinJoin salt change request\n\nExamples:\n> dash-cli coinjoinsalt set f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"coinjoinsalt set\", \"params\": [f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"e7bf3606bfaa8203a8aa6c9ab899608b80cff37e7567737632c2b1db242b8a04"} +{"command":"combinepsbt","subcommand":null,"qualified":"combinepsbt","signature_tail":"[\"psbt\",...]","is_family":false,"help_raw":"combinepsbt [\"psbt\",...]\n\nCombine multiple partially signed blockchain transactions into one transaction.\nImplements the Combiner role.\n\nArguments:\n1. txs (json array, required) The base64 strings of partially signed transactions\n [\n \"psbt\", (string) A base64 string of a PSBT\n ...\n ]\n\nResult:\n\"str\" (string) The base64-encoded partially signed transaction\n\nExamples:\n> dash-cli combinepsbt '[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]'","help_sha256":"34be5e755733b5238a8d859baf28d23abc5424fbf4f6d4b050885ea7c0db7c6f"} +{"command":"combinerawtransaction","subcommand":null,"qualified":"combinerawtransaction","signature_tail":"[\"hexstring\",...]","is_family":false,"help_raw":"combinerawtransaction [\"hexstring\",...]\n\nCombine multiple partially signed transactions into one transaction.\nThe combined transaction may be another partially signed transaction or a \nfully signed transaction.\nArguments:\n1. txs (json array, required) The of hex strings of partially signed transactions\n [\n \"hexstring\", (string) A hex-encoded raw transaction\n ...\n ]\n\nResult:\n\"str\" (string) The hex-encoded raw transaction with signature(s)\n\nExamples:\n> dash-cli combinerawtransaction '[\"myhex1\", \"myhex2\", \"myhex3\"]'","help_sha256":"38428ac2aaf2379b4e738f1f6eabf9139023fe67e96e3e56e50aa6af3e48984a"} +{"command":"converttopsbt","subcommand":null,"qualified":"converttopsbt","signature_tail":"\"hexstring\" ( permitsigdata )","is_family":false,"help_raw":"converttopsbt \"hexstring\" ( permitsigdata )\n\nConverts a network serialized transaction to a PSBT. This should be used only with createrawtransaction and fundrawtransaction\ncreatepsbt and walletcreatefundedpsbt should be used for new applications.\n\nArguments:\n1. hexstring (string, required) The hex string of a raw transaction\n2. permitsigdata (boolean, optional, default=false) If true, any signatures in the input will be discarded and conversion\n will continue. If false, RPC will fail if any signatures are present.\n\nResult:\n\"str\" (string) The resulting raw transaction (base64-encoded string)\n\nExamples:\n\nCreate a transaction\n> dash-cli createrawtransaction \"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"\n\nConvert the transaction to a PSBT\n> dash-cli converttopsbt \"rawtransaction\"","help_sha256":"8503644a5353ce0e1a83c109e266f42671bf8d5ac689f38c195903f6ed977889"} +{"command":"createmultisig","subcommand":null,"qualified":"createmultisig","signature_tail":"nrequired [\"key\",...]","is_family":false,"help_raw":"createmultisig nrequired [\"key\",...]\n\nCreates a multi-signature address with n signature of m keys required.\nIt returns a json object with the address and redeemScript.\n\nArguments:\n1. nrequired (numeric, required) The number of required signatures out of the n keys.\n2. keys (json array, required) The hex-encoded public keys.\n [\n \"key\", (string) The hex-encoded public key\n ...\n ]\n\nResult:\n{ (json object)\n \"address\" : \"str\", (string) The value of the new multisig address.\n \"redeemScript\" : \"hex\", (string) The string value of the hex-encoded redemption script.\n \"descriptor\" : \"str\" (string) The descriptor for this multisig.\n}\n\nExamples:\n\nCreate a multisig address from 2 public keys\n> dash-cli createmultisig 2 \"[\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\\\",\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\\\"]\"\n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"createmultisig\", \"params\": [2, [\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\",\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\"]]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"0f9d3eb297ca438edc563e2169679d75e79ff2c8b44ad246c23b575b2966d7a8"} +{"command":"createpsbt","subcommand":null,"qualified":"createpsbt","signature_tail":"[{\"txid\":\"hex\",\"vout\":n,\"sequence\":n},...] [{\"address\":amount,...},{\"data\":\"hex\"},...] ( locktime )","is_family":false,"help_raw":"createpsbt [{\"txid\":\"hex\",\"vout\":n,\"sequence\":n},...] [{\"address\":amount,...},{\"data\":\"hex\"},...] ( locktime )\n\nCreates a transaction in the Partially Signed Transaction format.\nImplements the Creator role.\n\nArguments:\n1. inputs (json array, required) The json objects\n [\n { (json object)\n \"txid\": \"hex\", (string, required) The transaction id\n \"vout\": n, (numeric, required) The output number\n \"sequence\": n, (numeric, optional, default=depends on the value of the 'locktime' argument) The sequence number\n },\n ...\n ]\n2. outputs (json array, required) The with outputs (key-value pairs), where none of the keys are duplicated.\n That is, each address can only appear once and there can only be one 'data' object.\n For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n accepted as second parameter.\n [\n { (json object)\n \"address\": amount, (numeric or string, required) A key-value pair. The key (string) is the Dash address, the value (float or string) is the amount in DASH\n ...\n },\n { (json object)\n \"data\": \"hex\", (string, required) A key-value pair. The key must be \"data\", the value is hex-encoded data\n },\n ...\n ]\n3. locktime (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n\nResult:\n\"str\" (string) The resulting raw transaction (base64-encoded string)\n\nExamples:\n> dash-cli createpsbt \"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"","help_sha256":"f8c5c3293ec4c6b0de6f3e986db653753b95ee098a321c2c1ca9d81c7936de53"} +{"command":"createrawtransaction","subcommand":null,"qualified":"createrawtransaction","signature_tail":"[{\"txid\":\"hex\",\"vout\":n,\"sequence\":n},...] [{\"address\":amount,...},{\"data\":\"hex\"},...] ( locktime )","is_family":false,"help_raw":"createrawtransaction [{\"txid\":\"hex\",\"vout\":n,\"sequence\":n},...] [{\"address\":amount,...},{\"data\":\"hex\"},...] ( locktime )\n\nCreate a transaction spending the given inputs and creating new outputs.\nOutputs can be addresses or data.\nReturns hex-encoded raw transaction.\nNote that the transaction's inputs are not signed, and\nit is not stored in the wallet or transmitted to the network.\n\nArguments:\n1. inputs (json array, required) The inputs\n [\n { (json object)\n \"txid\": \"hex\", (string, required) The transaction id\n \"vout\": n, (numeric, required) The output number\n \"sequence\": n, (numeric, optional, default=depends on the value of the 'locktime' argument) The sequence number\n },\n ...\n ]\n2. outputs (json array, required) The outputs (key-value pairs), where none of the keys are duplicated.\n That is, each address can only appear once and there can only be one 'data' object.\n For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n accepted as second parameter.\n [\n { (json object)\n \"address\": amount, (numeric or string, required) A key-value pair. The key (string) is the Dash address, the value (float or string) is the amount in DASH\n ...\n },\n { (json object)\n \"data\": \"hex\", (string, required) A key-value pair. The key must be \"data\", the value is hex-encoded data\n },\n ...\n ]\n3. locktime (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n\nResult:\n\"hex\" (string) hex string of the transaction\n\nExamples:\n> dash-cli createrawtransaction \"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"\n> dash-cli createrawtransaction \"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"createrawtransaction\", \"params\": [\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"address\\\":0.01}]\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"createrawtransaction\", \"params\": [\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"5774d8b78f1ffc81f5e4422a08c14b8f4cc28a46f37a8f24db99a5d1a47632aa"} +{"command":"createwallet","subcommand":null,"qualified":"createwallet","signature_tail":"\"wallet_name\" ( disable_private_keys blank \"passphrase\" avoid_reuse descriptors load_on_startup )","is_family":false,"help_raw":"createwallet \"wallet_name\" ( disable_private_keys blank \"passphrase\" avoid_reuse descriptors load_on_startup )\n\nCreates and loads a new wallet.\n\nArguments:\n1. wallet_name (string, required) The name for the new wallet. If this is a path, the wallet will be created at the path location.\n2. disable_private_keys (boolean, optional, default=false) Disable the possibility of private keys (only watchonlys are possible in this mode).\n3. blank (boolean, optional, default=false) Create a blank wallet. A blank wallet has no keys or HD seed. One can be set using upgradetohd (by mnemonic) or sethdseed (WIF private key).\n4. passphrase (string, optional) Encrypt the wallet with this passphrase.\n5. avoid_reuse (boolean, optional, default=false) Keep track of coin reuse, and treat dirty and clean coins differently with privacy considerations in mind.\n6. descriptors (boolean, optional, default=false) Create a native descriptor wallet. The wallet will use descriptors internally to handle address creation. This feature is well-tested but still considered experimental.\n7. load_on_startup (boolean, optional) Save wallet name to persistent settings and load on startup. True to add wallet to startup list, false to remove, null to leave unchanged.\n\nResult:\n{ (json object)\n \"name\" : \"str\", (string) The wallet name if created successfully. If the wallet was created using a full path, the wallet_name will be the full path.\n \"warning\" : \"str\" (string) Warning message if wallet was not loaded cleanly.\n}\n\nExamples:\n> dash-cli createwallet \"testwallet\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"createwallet\", \"params\": [\"testwallet\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> dash-cli -named createwallet wallet_name=descriptors avoid_reuse=true descriptors=true load_on_startup=true\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"createwallet\", \"params\": {\"wallet_name\":\"descriptors\",\"avoid_reuse\":true,\"descriptors\":true,\"load_on_startup\":true}}' -H 'content-type: text/plain;' http://127.0.0.1:8332/","help_sha256":"4b812f7b5707e2985ea9b96dfabc35ffcc85f3941bb29ac5b5e4519100c375de"} +{"command":"debug","subcommand":null,"qualified":"debug","signature_tail":"\"category\"","is_family":false,"help_raw":"debug \"category\"\nChange debug category on the fly. Specify single category or use '+' to specify many.\nThe valid logging categories are: addrman, bench, blockstorage, chainlocks, cmpctblock, coindb, coinjoin, creditpool, ehf, estimatefee, gobject, http, i2p, instantsend, ipc, leveldb, libevent, llmq, llmq-dkg, llmq-sigs, mempool, mempoolrej, mnpayments, mnsync, net, netconn, proxy, prune, qt, rand, reindex, rpc, selectcoins, spork, tor, txreconciliation, validation, walletdb, zmq.\nlibevent logging is configured on startup and cannot be modified by this RPC during runtime.\nThere are also a few meta-categories:\n - \"all\", \"1\" and \"\" activate all categories at once;\n - \"dash\" activates all Dash-specific categories at once;\n - \"none\" (or \"0\") deactivates all categories at once.\nNote: If specified category doesn't match any of the above, no error is thrown.\n\nArguments:\n1. category (string, required) The name of the debug category to turn on.\n\nResult:\n\"str\" (string) \"Debug mode: \" followed by the specified category\n\nExamples:\n> dash-cli debug dash\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"debug\", \"params\": [dash+net]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"80ea800dd82c2afaf94380f2e908706de39aa563bb7b083e18640c70569c8d00"} +{"command":"decodepsbt","subcommand":null,"qualified":"decodepsbt","signature_tail":"\"psbt\"","is_family":false,"help_raw":"decodepsbt \"psbt\"\n\nReturn a JSON object representing the serialized, base64-encoded partially signed blockchain transaction.\n\nArguments:\n1. psbt (string, required) The PSBT base64 string\n\nResult:\n{ (json object)\n \"tx\" : { (json object) The decoded network-serialized unsigned transaction.\n ... The layout is the same as the output of decoderawtransaction.\n },\n \"global_xpubs\" : [ (json array)\n { (json object)\n \"xpub\" : \"str\", (string) The extended public key this path corresponds to\n \"master_fingerprint\" : \"hex\", (string) The fingerprint of the master key\n \"path\" : \"str\" (string) The path\n },\n ...\n ],\n \"psbt_version\" : n, (numeric) The PSBT version number. Not to be confused with the unsigned transaction version\n \"proprietary\" : [ (json array) The global proprietary map\n { (json object)\n \"identifier\" : \"hex\", (string) The hex string for the proprietary identifier\n \"subtype\" : n, (numeric) The number for the subtype\n \"key\" : \"hex\", (string) The hex for the key\n \"value\" : \"hex\" (string) The hex for the value\n },\n ...\n ],\n \"unknown\" : { (json object) The unknown global fields\n \"key\" : \"hex\", (string) (key-value pair) An unknown key-value pair\n ...\n },\n \"inputs\" : [ (json array)\n { (json object)\n \"non_witness_utxo\" : { (json object, optional) Decoded network transaction for non-witness UTXOs\n ...\n },\n \"partial_signatures\" : { (json object, optional)\n \"pubkey\" : \"str\", (string) The public key and signature that corresponds to it.\n ...\n },\n \"sighash\" : \"str\", (string, optional) The sighash type to be used\n \"redeem_script\" : { (json object, optional)\n \"asm\" : \"str\", (string) The asm\n \"hex\" : \"hex\", (string) The hex\n \"type\" : \"str\" (string) The type, eg 'pubkeyhash'\n },\n \"bip32_derivs\" : [ (json array, optional)\n { (json object, optional) The public key with the derivation path as the value.\n \"master_fingerprint\" : \"str\", (string) The fingerprint of the master key\n \"path\" : \"str\" (string) The path\n },\n ...\n ],\n \"final_scriptsig\" : { (json object, optional)\n \"asm\" : \"str\", (string) The asm\n \"hex\" : \"str\" (string) The hex\n },\n \"ripemd160_preimages\" : { (json object, optional)\n \"hash\" : \"str\", (string) The hash and preimage that corresponds to it.\n ...\n },\n \"sha256_preimages\" : { (json object, optional)\n \"hash\" : \"str\", (string) The hash and preimage that corresponds to it.\n ...\n },\n \"hash160_preimages\" : { (json object, optional)\n \"hash\" : \"str\", (string) The hash and preimage that corresponds to it.\n ...\n },\n \"hash256_preimages\" : { (json object, optional)\n \"hash\" : \"str\", (string) The hash and preimage that corresponds to it.\n ...\n },\n \"unknown\" : { (json object, optional) The unknown input fields\n \"key\" : \"hex\", (string) (key-value pair) An unknown key-value pair\n ...\n },\n \"proprietary\" : [ (json array) The input proprietary map\n { (json object)\n \"identifier\" : \"hex\", (string) The hex string for the proprietary identifier\n \"subtype\" : n, (numeric) The number for the subtype\n \"key\" : \"hex\", (string) The hex for the key\n \"value\" : \"hex\" (string) The hex for the value\n },\n ...\n ]\n },\n ...\n ],\n \"outputs\" : [ (json array)\n { (json object)\n \"redeem_script\" : { (json object, optional)\n \"asm\" : \"str\", (string) The asm\n \"hex\" : \"hex\", (string) The hex\n \"type\" : \"str\" (string) The type, eg 'pubkeyhash'\n },\n \"bip32_derivs\" : [ (json array, optional)\n { (json object)\n \"pubkey\" : \"str\", (string) The public key this path corresponds to\n \"master_fingerprint\" : \"str\", (string) The fingerprint of the master key\n \"path\" : \"str\" (string) The path\n },\n ...\n ],\n \"unknown\" : { (json object) The unknown global fields\n \"key\" : \"hex\", (string) (key-value pair) An unknown key-value pair\n ...\n },\n \"proprietary\" : [ (json array) The output proprietary map\n { (json object)\n \"identifier\" : \"hex\", (string) The hex string for the proprietary identifier\n \"subtype\" : n, (numeric) The number for the subtype\n \"key\" : \"hex\", (string) The hex for the key\n \"value\" : \"hex\" (string) The hex for the value\n },\n ...\n ]\n },\n ...\n ],\n \"fee\" : n (numeric, optional) The transaction fee paid if all UTXOs slots in the PSBT have been filled.\n}\n\nExamples:\n> dash-cli decodepsbt \"psbt\"","help_sha256":"570346737ae5414f79cea2a5b974bf092cf969b1950c82127fb3e67f0bfe9b1d"} +{"command":"decoderawtransaction","subcommand":null,"qualified":"decoderawtransaction","signature_tail":"\"hexstring\"","is_family":false,"help_raw":"decoderawtransaction \"hexstring\"\n\nReturn a JSON object representing the serialized, hex-encoded transaction.\n\nArguments:\n1. hexstring (string, required) The transaction hex string\n\nResult:\n{ (json object)\n \"txid\" : \"hex\", (string) The transaction id\n \"size\" : n, (numeric) The transaction size\n \"version\" : n, (numeric) The version\n \"type\" : n, (numeric) The type\n \"locktime\" : xxx, (numeric) The lock time\n \"vin\" : [ (json array)\n { (json object)\n \"txid\" : \"hex\", (string) The transaction id\n \"vout\" : n, (numeric) The output number\n \"scriptSig\" : { (json object) The script\n \"asm\" : \"str\", (string) asm\n \"hex\" : \"hex\" (string) hex\n },\n \"sequence\" : n (numeric) The script sequence number\n },\n ...\n ],\n \"vout\" : [ (json array)\n { (json object)\n \"value\" : n, (numeric) The value in DASH\n \"n\" : n, (numeric) index\n \"scriptPubKey\" : { (json object)\n \"asm\" : \"str\", (string) the asm\n \"hex\" : \"hex\", (string) the hex\n \"reqSigs\" : n, (numeric, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Number of required signatures\n \"type\" : \"str\", (string) The type, eg 'pubkeyhash'\n \"address\" : \"str\", (string, optional) Dash address (only if a well-defined address exists)\n \"addresses\" : [ (json array, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Array of Dash addresses\n \"str\", (string) Dash address\n ...\n ]\n }\n },\n ...\n ],\n \"extraPayloadSize\" : n, (numeric, optional) Size of DIP2 extra payload. Only present if it's a special TX\n \"extraPayload\" : \"hex\" (string, optional) Hex-encoded DIP2 extra payload data. Only present if it's a special TX\n}\n\nExamples:\n> dash-cli decoderawtransaction \"hexstring\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"decoderawtransaction\", \"params\": [\"hexstring\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"0ca16427eb96a4dd0b6f40668144266bf78e539d358e436d03620603b6be09f9"} +{"command":"decodescript","subcommand":null,"qualified":"decodescript","signature_tail":"\"hexstring\"","is_family":false,"help_raw":"decodescript \"hexstring\"\n\nDecode a hex-encoded script.\n\nArguments:\n1. hexstring (string, required) the hex-encoded script\n\nResult:\n{ (json object)\n \"asm\" : \"str\", (string) Script public key\n \"type\" : \"str\", (string) The output type (e.g. nonstandard, pubkey, pubkeyhash, scripthash, multisig, nulldata)\n \"address\" : \"str\", (string, optional) Dash address (only if a well-defined address exists)\n \"reqSigs\" : n, (numeric, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Number of required signatures\n \"addresses\" : [ (json array, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Array of Dash addresses\n \"str\", (string) Dash address\n ...\n ],\n \"p2sh\" : \"str\" (string) address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH)\n}\n\nExamples:\n> dash-cli decodescript \"hexstring\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"decodescript\", \"params\": [\"hexstring\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"f7ffddde8fdf821140c7cb0d215200ea4496efb067620fa86dc52f39e311b945"} +{"command":"deriveaddresses","subcommand":null,"qualified":"deriveaddresses","signature_tail":"\"descriptor\" ( range )","is_family":false,"help_raw":"deriveaddresses \"descriptor\" ( range )\n\nDerives one or more addresses corresponding to an output descriptor.\nExamples of output descriptors are:\n pkh() P2PKH outputs for the given pubkey\n sh(multi(,,,...)) P2SH-multisig outputs for the given threshold and pubkeys\n raw() Outputs whose scriptPubKey equals the specified hex scripts\n\nIn the above, either refers to a fixed public key in hexadecimal notation, or to an xpub/xprv optionally followed by one\nor more path elements separated by \"/\", where \"h\" represents a hardened child key.\nFor more information on output descriptors, see the documentation in the doc/descriptors.md file.\n\nArguments:\n1. descriptor (string, required) The descriptor\n2. range (numeric or array, optional) If a ranged descriptor is used, this specifies the end or the range (in [begin,end] notation) to derive.\n\nResult:\n[ (json array)\n \"str\", (string) the derived addresses\n ...\n]\n\nExamples:\n\nFirst three receive addresses\n> dash-cli deriveaddresses \"wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu\" \"[0,2]\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"deriveaddresses\", \"params\": [\"wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu\", \"[0,2]\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"6774614eeab8369c477902d86f8468447e76ade17aaf97734dff4e21561611db"} +{"command":"disconnectnode","subcommand":null,"qualified":"disconnectnode","signature_tail":"( \"address\" nodeid )","is_family":false,"help_raw":"disconnectnode ( \"address\" nodeid )\n\nImmediately disconnects from the specified peer node.\n\nStrictly one out of 'address' and 'nodeid' can be provided to identify the node.\n\nTo disconnect by nodeid, either set 'address' to the empty string, or call using the named 'nodeid' argument only.\n\nArguments:\n1. address (string, optional, default=fallback to nodeid) The IP address/port of the node\n2. nodeid (numeric, optional, default=fallback to address) The node ID (see getpeerinfo for node IDs)\n\nResult:\nnull (json null)\n\nExamples:\n> dash-cli disconnectnode \"192.168.0.6:9999\"\n> dash-cli disconnectnode \"\" 1\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"disconnectnode\", \"params\": [\"192.168.0.6:9999\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"disconnectnode\", \"params\": [\"\", 1]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"88c027459677697b0e475e5993e8fe34cd28a18f2345f4476fb5430021962ddf"} +{"command":"dumphdinfo","subcommand":null,"qualified":"dumphdinfo","signature_tail":"","is_family":false,"help_raw":"dumphdinfo\nReturns an object containing sensitive private info about this HD wallet.\n\nResult:\n{ (json object)\n \"hdseed\" : \"hex\", (string) The HD seed (bip32, in hex)\n \"mnemonic\" : \"str\", (string) The mnemonic for this HD wallet (bip39, english words)\n \"mnemonicpassphrase\" : \"str\" (string) The mnemonic passphrase for this HD wallet (bip39)\n}\n\nExamples:\n> dash-cli dumphdinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"dumphdinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"d885b50633d7668cfed75026dfc33cc6f4f5baa1261eb8d736d95ff2f814c0c4"} +{"command":"dumpprivkey","subcommand":null,"qualified":"dumpprivkey","signature_tail":"\"address\"","is_family":false,"help_raw":"dumpprivkey \"address\"\n\nReveals the private key corresponding to 'address'.\nThen the importprivkey can be used with this output\n\nArguments:\n1. address (string, required) The Dash address for the private key\n\nResult:\n\"str\" (string) The private key\n\nExamples:\n> dash-cli dumpprivkey \"myaddress\"\n> dash-cli importprivkey \"mykey\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"dumpprivkey\", \"params\": [\"myaddress\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"287e3a0a549060d74ac8aec5c1ae2dddc0f235e69364946b7d01f496bd26b3ab"} +{"command":"dumpwallet","subcommand":null,"qualified":"dumpwallet","signature_tail":"\"filename\"","is_family":false,"help_raw":"dumpwallet \"filename\"\n\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\nImported scripts are included in the dumpfile too, their corresponding addresses will be added automatically by importwallet.\nNote that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\nonly backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\n\nArguments:\n1. filename (string, required) The filename with path (absolute path recommended)\n\nResult:\n{ (json object)\n \"keys\" : n, (numeric) The number of keys contained in the wallet dump\n \"filename\" : \"str\", (string) The filename with full absolute path\n \"warning\" : \"str\" (string) A warning about not sharing the wallet dump with anyone\n}\n\nExamples:\n> dash-cli dumpwallet \"test\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"dumpwallet\", \"params\": [\"test\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"10a06e8f05329b58df7ec47e23aa6d735c374c9a818e08c749854e4bc726a7a5"} +{"command":"encryptwallet","subcommand":null,"qualified":"encryptwallet","signature_tail":"\"passphrase\"","is_family":false,"help_raw":"encryptwallet \"passphrase\"\n\nEncrypts the wallet with 'passphrase'. This is for first time encryption.\nAfter this, any calls that interact with private keys such as sending or signing \nwill require the passphrase to be set prior the making these calls.\nUse the walletpassphrase call for this, and then walletlock call.\nIf the wallet is already encrypted, use the walletpassphrasechange call.\n\nArguments:\n1. passphrase (string, required) The pass phrase to encrypt the wallet with. It must be at least 1 character, but should be long.\n\nResult:\n\"str\" (string) A string with further instructions\n\nExamples:\n\nEncrypt your wallet\n> dash-cli encryptwallet \"my pass phrase\"\n\nNow set the passphrase to use the wallet, such as for signing or sending Dash\n> dash-cli walletpassphrase \"my pass phrase\"\n\nNow we can do something like sign\n> dash-cli signmessage \"address\" \"test message\"\n\nNow lock the wallet again by removing the passphrase\n> dash-cli walletlock \n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"encryptwallet\", \"params\": [\"my pass phrase\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"1e516a43b0cd4a298fdfdc6df5aa61652205f1ea38defc03e832a512f6489799"} +{"command":"estimatesmartfee","subcommand":null,"qualified":"estimatesmartfee","signature_tail":"conf_target ( \"estimate_mode\" )","is_family":false,"help_raw":"estimatesmartfee conf_target ( \"estimate_mode\" )\n\nEstimates the approximate fee per kilobyte needed for a transaction to begin\nconfirmation within conf_target blocks if possible and return the number of blocks\nfor which the estimate is valid.\n\nArguments:\n1. conf_target (numeric, required) Confirmation target in blocks (1 - 1008)\n2. estimate_mode (string, optional, default=\"conservative\") The fee estimate mode.\n Whether to return a more conservative estimate which also satisfies\n a longer history. A conservative estimate potentially returns a\n higher feerate and is more likely to be sufficient for the desired\n target, but is not as responsive to short term drops in the\n prevailing fee market. Must be one of (case insensitive):\n \"unset\"\n \"economical\"\n \"conservative\"\n\nResult:\n{ (json object)\n \"feerate\" : n, (numeric, optional) estimate fee rate in DASH/kB (only present if no errors were encountered)\n \"errors\" : [ (json array, optional) Errors encountered during processing (if there are any)\n \"str\", (string) error\n ...\n ],\n \"blocks\" : n (numeric) block number where estimate was found\n The request target will be clamped between 2 and the highest target\n fee estimation is able to return based on how long it has been running.\n An error is returned if not enough transactions and blocks\n have been observed to make an estimate for any number of blocks.\n}\n\nExamples:\n> dash-cli estimatesmartfee 6\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"estimatesmartfee\", \"params\": [6]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"dcbaa18438f37a59ab79ae170dee3c41ebe01a2fc47983c9c0210d67b8e7cb60"} +{"command":"finalizepsbt","subcommand":null,"qualified":"finalizepsbt","signature_tail":"\"psbt\" ( extract )","is_family":false,"help_raw":"finalizepsbt \"psbt\" ( extract )\nFinalize the inputs of a PSBT. If the transaction is fully signed, it will produce a\nnetwork serialized transaction which can be broadcast with sendrawtransaction. Otherwise a PSBT will be\ncreated which has the final_scriptSig field filled for inputs that are complete.\nImplements the Finalizer and Extractor roles.\n\nArguments:\n1. psbt (string, required) A base64 string of a PSBT\n2. extract (boolean, optional, default=true) If true and the transaction is complete,\n extract and return the complete transaction in normal network serialization instead of the PSBT.\n\nResult:\n{ (json object)\n \"psbt\" : \"str\", (string) The base64-encoded partially signed transaction if not extracted\n \"hex\" : \"hex\", (string) The hex-encoded network transaction if extracted\n \"complete\" : true|false (boolean) If the transaction has a complete set of signatures\n}\n\nExamples:\n> dash-cli finalizepsbt \"psbt\"","help_sha256":"d0785493f82774c074a09d5c94e8c705e6de61b4d5176da44507eebb425f1319"} +{"command":"fundrawtransaction","subcommand":null,"qualified":"fundrawtransaction","signature_tail":"\"hexstring\" ( options )","is_family":false,"help_raw":"fundrawtransaction \"hexstring\" ( options )\n\nIf the transaction has no inputs, they will be automatically selected to meet its out value.\nIt will add at most one change output to the outputs.\nNo existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\nNote that inputs which were signed may need to be resigned after completion since in/outputs have been added.\nThe inputs added will not be signed, use signrawtransactionwithkey\n or signrawtransactionwithwallet for that.\nNote that all existing inputs must have their previous output transaction be in the wallet.\nNote that all inputs selected must be of standard form and P2SH scripts must be\nin the wallet using importaddress or addmultisigaddress (to calculate fees).\nYou can see whether this is the case by checking the \"solvable\" field in the listunspent output.\nOnly pay-to-pubkey, multisig, and P2SH versions thereof are currently supported for watch-only\n\nArguments:\n1. hexstring (string, required) The hex string of the raw transaction\n2. options (json object, optional) for backward compatibility: passing in a true instead of an object will result in {\"includeWatching\":true}\n {\n \"add_inputs\": bool, (boolean, optional, default=true) For a transaction with existing inputs, automatically include more if they are not enough.\n \"include_unsafe\": bool, (boolean, optional, default=false) Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n If that happens, you will need to fund the transaction with different inputs and republish it.\n \"changeAddress\": \"str\", (string, optional, default=pool address) The Dash address to receive the change\n \"changePosition\": n, (numeric, optional, default=random) The index of the change output\n \"includeWatching\": bool, (boolean, optional, default=true for watch-only wallets, otherwise false) Also select inputs which are watch only.\n Only solvable inputs can be used. Watch-only destinations are solvable if the public key and/or output script was imported,\n e.g. with 'importpubkey' or 'importmulti' with the 'pubkeys' or 'desc' field.\n \"lockUnspents\": bool, (boolean, optional, default=false) Lock selected unspent outputs\n \"fee_rate\": amount, (numeric or string, optional, default=not set, fall back to wallet fee estimation) Specify a fee rate in duff/B.\n \"feeRate\": amount, (numeric or string, optional, default=not set, fall back to wallet fee estimation) Specify a fee rate in DASH/kB.\n \"subtractFeeFromOutputs\": [ (json array, optional, default=[]) The integers.\n The fee will be equally deducted from the amount of each specified output.\n Those recipients will receive less Dash than you enter in their corresponding amount field.\n If no outputs are specified here, the sender pays the fee.\n vout_index, (numeric) The zero-based output index, before a change output is added.\n ...\n ],\n \"conf_target\": n, (numeric, optional, default=wallet -txconfirmtarget) Confirmation target in blocks\n \"estimate_mode\": \"str\", (string, optional, default=\"unset\") The fee estimate mode, must be one of (case insensitive):\n \"unset\"\n \"economical\"\n \"conservative\"\n }\n\nResult:\n{ (json object)\n \"hex\" : \"hex\", (string) The resulting raw transaction (hex-encoded string)\n \"fee\" : n, (numeric) Fee in DASH the resulting transaction pays\n \"changepos\" : n (numeric) The position of the added change output, or -1\n}\n\nExamples:\n\nCreate a transaction with no inputs\n> dash-cli createrawtransaction \"[]\" \"{\\\"myaddress\\\":0.01}\"\n\nAdd sufficient unsigned inputs to meet the output value\n> dash-cli fundrawtransaction \"rawtransactionhex\"\n\nSign the transaction\n> dash-cli signrawtransaction \"fundedtransactionhex\"\n\nSend the transaction\n> dash-cli sendrawtransaction \"signedtransactionhex\"","help_sha256":"bcb7cf2e203ff67bc07305c0dc647b5ff176e4bf3829c533ce8715eb22cd8901"} +{"command":"generateblock","subcommand":null,"qualified":"generateblock","signature_tail":"\"output\" [\"rawtx/txid\",...]","is_family":false,"help_raw":"generateblock \"output\" [\"rawtx/txid\",...]\n\nMine a block with a set of ordered transactions immediately to a specified address or descriptor (before the RPC call returns)\n\nArguments:\n1. output (string, required) The address or descriptor to send the newly generated coins to.\n2. transactions (json array, required) An array of hex strings which are either txids or raw transactions.\n Txids must reference transactions currently in the mempool.\n All transactions must be valid and in valid order, otherwise the block will be rejected.\n [\n \"rawtx/txid\", (string)\n ...\n ]\n\nResult:\n{ (json object)\n \"hash\" : \"hex\" (string) hash of generated block\n}\n\nExamples:\n\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n> dash-cli generateblock \"myaddress\" '[\"rawtx\", \"mempool_txid\"]'","help_sha256":"82fb933e318a33bfec7281bb8f17dc3e5e277ce7cf4115d38f91950d0f2e3fd2"} +{"command":"generatetoaddress","subcommand":null,"qualified":"generatetoaddress","signature_tail":"nblocks \"address\" ( maxtries )","is_family":false,"help_raw":"generatetoaddress nblocks \"address\" ( maxtries )\n\nMine blocks immediately to a specified address (before the RPC call returns)\n\nArguments:\n1. nblocks (numeric, required) How many blocks are generated immediately.\n2. address (string, required) The address to send the newly generated coins to.\n3. maxtries (numeric, optional, default=1000000) How many iterations to try.\n\nResult:\n[ (json array) hashes of blocks generated\n \"hex\", (string) blockhash\n ...\n]\n\nExamples:\n\nGenerate 11 blocks to myaddress\n> dash-cli generatetoaddress 11 \"myaddress\"\nIf you are using the Dash Core wallet, you can get a new address to send the newly generated coins to with:\n> dash-cli getnewaddress ","help_sha256":"a7916a917fa39338fe071a92736ffa8f47bf8b3e89c8485012b22d87ecd10fc0"} +{"command":"generatetodescriptor","subcommand":null,"qualified":"generatetodescriptor","signature_tail":"num_blocks \"descriptor\" ( maxtries )","is_family":false,"help_raw":"generatetodescriptor num_blocks \"descriptor\" ( maxtries )\n\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n\nArguments:\n1. num_blocks (numeric, required) How many blocks are generated immediately.\n2. descriptor (string, required) The descriptor to send the newly generated coins to.\n3. maxtries (numeric, optional, default=1000000) How many iterations to try.\n\nResult:\n[ (json array)\n \"hex\", (string) hashes of blocks generated\n ...\n]\n\nExamples:\n\nGenerate 11 blocks to mydesc\n> dash-cli generatetodescriptor 11 \"mydesc\"","help_sha256":"5f094ae73ecc67bb061e12d3f99198ae5c175aef4019506bd719c81914463e81"} +{"command":"getaddednodeinfo","subcommand":null,"qualified":"getaddednodeinfo","signature_tail":"( \"node\" )","is_family":false,"help_raw":"getaddednodeinfo ( \"node\" )\n\nReturns information about the given added node, or all added nodes\n(note that onetry addnodes are not listed here)\n\nArguments:\n1. node (string, optional, default=all nodes) If provided, return information about this specific node, otherwise all nodes are returned.\n\nResult:\n[ (json array)\n { (json object)\n \"addednode\" : \"str\", (string) The node IP address or name (as provided to addnode)\n \"connected\" : true|false, (boolean) If connected\n \"addresses\" : [ (json array) Only when connected = true\n { (json object)\n \"address\" : \"str\", (string) The Dash server IP and port we're connected to\n \"connected\" : \"str\" (string) connection, inbound or outbound\n },\n ...\n ]\n },\n ...\n]\n\nExamples:\n> dash-cli getaddednodeinfo \"192.168.0.201\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddednodeinfo\", \"params\": [\"192.168.0.201\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"f7ae41ea4b8e16ca01a32190d4b826e9f26389242abe4d2c85021ef256f69db3"} +{"command":"getaddressbalance","subcommand":null,"qualified":"getaddressbalance","signature_tail":"( [\"address\",...] )","is_family":false,"help_raw":"getaddressbalance ( [\"address\",...] )\n\nReturns the balance for an address(es) (requires addressindex to be enabled).\n\nArguments:\n1. addresses (json array, optional, default=[])\n [\n \"address\", (string, optional, default=\"\") The base58check encoded address\n ...\n ]\n\nResult:\n{ (json object)\n \"balance\" : n, (numeric) The current total balance in duffs\n \"balance_immature\" : n, (numeric) The current immature balance in duffs\n \"balance_spendable\" : n, (numeric) The current spendable balance in duffs\n \"received\" : n (numeric) The total number of duffs received (including change)\n}\n\nExamples:\n> dash-cli getaddressbalance '{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressbalance\", \"params\": [{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"30d1678757d2c06c01c2f89ca766d1fce066b65cdfc0740311e90256a66b5dae"} +{"command":"getaddressdeltas","subcommand":null,"qualified":"getaddressdeltas","signature_tail":"( [\"address\",...] )","is_family":false,"help_raw":"getaddressdeltas ( [\"address\",...] )\n\nReturns all changes for an address (requires addressindex to be enabled).\n\nArguments:\n1. addresses (json array, optional, default=[])\n [\n \"address\", (string, optional, default=\"\") The base58check encoded address\n ...\n ]\n\nResult:\n[ (json array)\n { (json object)\n \"satoshis\" : n, (numeric) The difference of duffs\n \"txid\" : \"hex\", (string) The related txid\n \"index\" : n, (numeric) The related input or output index\n \"blockindex\" : n, (numeric) The related block index\n \"height\" : n, (numeric) The block height\n \"address\" : \"str\" (string) The base58check encoded address\n },\n ...\n]\n\nExamples:\n> dash-cli getaddressdeltas '{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressdeltas\", \"params\": [{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"06321324be5c6dada24e800e5a69e7496e48173b0f6d89816623a9e94feb5e2a"} +{"command":"getaddressesbylabel","subcommand":null,"qualified":"getaddressesbylabel","signature_tail":"\"label\"","is_family":false,"help_raw":"getaddressesbylabel \"label\"\n\nReturns the list of addresses assigned the specified label.\n\nArguments:\n1. label (string, required) The label.\n\nResult:\n{ (json object) json object with addresses as keys\n \"address\" : { (json object) json object with information about address\n \"purpose\" : \"str\" (string) Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n },\n ...\n}\n\nExamples:\n> dash-cli getaddressesbylabel \"tabby\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressesbylabel\", \"params\": [\"tabby\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"2c6bf3140e3b1b5ca3e4f21677603e85ee4e48848ad91c1c16b1f99ba8934034"} +{"command":"getaddressinfo","subcommand":null,"qualified":"getaddressinfo","signature_tail":"\"address\"","is_family":false,"help_raw":"getaddressinfo \"address\"\n\nReturn information about the given Dash address.\nSome of the information will only be present if the address is in the active wallet.\n\nArguments:\n1. address (string, required) The Dash address for which to get information.\n\nResult:\n{ (json object)\n \"address\" : \"str\", (string) The Dash address validated.\n \"scriptPubKey\" : \"hex\", (string) The hex-encoded scriptPubKey generated by the address.\n \"ismine\" : true|false, (boolean) If the address is yours.\n \"iswatchonly\" : true|false, (boolean) If the address is watchonly.\n \"solvable\" : true|false, (boolean) If we know how to spend coins sent to this address, ignoring the possible lack of private keys.\n \"desc\" : \"str\", (string, optional) A descriptor for spending coins sent to this address (only when solvable).\n \"parent_desc\" : \"str\", (string, optional) The descriptor used to derive this address if this is a descriptor wallet\n \"isscript\" : true|false, (boolean) If the key is a script.\n \"ischange\" : true|false, (boolean) If the address was used for change output.\n \"script\" : \"str\", (string, optional) The output script type. Only if isscript is true and the redeemscript is known. Possible types: nonstandard, pubkey, pubkeyhash, scripthash, multisig, nulldata\n \"hex\" : \"hex\", (string, optional) The redeemscript for the p2sh address.\n \"pubkeys\" : [ (json array, optional) Array of pubkeys associated with the known redeemscript (only if script is multisig).\n \"str\", (string)\n ...\n ],\n \"addresses\" : [ (json array, optional) Array of addresses associated with the known redeemscript (only if script is multisig).\n \"str\", (string)\n ...\n ],\n \"sigsrequired\" : n, (numeric, optional) The number of signatures required to spend multisig output (only if script is multisig).\n \"pubkey\" : \"hex\", (string, optional) The hex value of the raw public key, for single-key addresses.\n \"iscompressed\" : true|false, (boolean, optional) If the pubkey is compressed.\n \"timestamp\" : xxx, (numeric, optional) The creation time of the key, if available, expressed in UNIX epoch time.\n \"hdchainid\" : \"hex\", (string, optional) The ID of the HD chain.\n \"hdkeypath\" : \"str\", (string, optional) The HD keypath, if the key is HD and available.\n \"hdseedid\" : \"hex\", (string, optional) The Hash160 of the HD seed.\n \"hdmasterfingerprint\" : \"hex\", (string, optional) The fingerprint of the master key.\n \"labels\" : [ (json array) An array of labels associated with the address. Currently limited to one label but returned as an array to keep the API stable if multiple labels are enabled in the future.\n \"str\", (string) Label name (defaults to \"\").\n ...\n ]\n}\n\nExamples:\n> dash-cli getaddressinfo XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressinfo\", \"params\": [XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"6a5c91a557f3ae1477ac281fb4b90150504600917be461cd25f6eabe76403af7"} +{"command":"getaddressmempool","subcommand":null,"qualified":"getaddressmempool","signature_tail":"( [\"address\",...] )","is_family":false,"help_raw":"getaddressmempool ( [\"address\",...] )\n\nReturns all mempool deltas for an address (requires addressindex to be enabled).\n\nArguments:\n1. addresses (json array, optional, default=[])\n [\n \"address\", (string, optional, default=\"\") The base58check encoded address\n ...\n ]\n\nResult:\n[ (json array)\n { (json object)\n \"address\" : \"str\", (string) The base58check encoded address\n \"txid\" : \"hex\", (string) The related txid\n \"index\" : n, (numeric) The related input or output index\n \"satoshis\" : n, (numeric) The difference of duffs\n \"timestamp\" : xxx, (numeric) The time the transaction entered the mempool (seconds)\n \"prevtxid\" : \"hex\", (string) The previous txid (if spending)\n \"prevout\" : n (numeric) The previous transaction output index (if spending)\n },\n ...\n]\n\nExamples:\n> dash-cli getaddressmempool '{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressmempool\", \"params\": [{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"8d6862d5c35ba326d99ec703513aa21fc1f8c7b5e33edc2f8bb3e6fb319d17a3"} +{"command":"getaddresstxids","subcommand":null,"qualified":"getaddresstxids","signature_tail":"( [\"address\",...] )","is_family":false,"help_raw":"getaddresstxids ( [\"address\",...] )\n\nReturns the txids for an address(es) (requires addressindex to be enabled).\n\nArguments:\n1. addresses (json array, optional, default=[])\n [\n \"address\", (string, optional, default=\"\") The base58check encoded address\n ...\n ]\n\nResult:\n[ (json array)\n \"hex\", (string) The transaction id\n ...\n]\n\nExamples:\n> dash-cli getaddresstxids '{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddresstxids\", \"params\": [{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"5eb2ca386617ab8e3b4f683a1c24030e31594833d1a1cb180b4d15ff6352e58b"} +{"command":"getaddressutxos","subcommand":null,"qualified":"getaddressutxos","signature_tail":"( [\"address\",...] )","is_family":false,"help_raw":"getaddressutxos ( [\"address\",...] )\n\nReturns all unspent outputs for an address (requires addressindex to be enabled).\n\nArguments:\n1. addresses (json array, optional, default=[])\n [\n \"address\", (string, optional, default=\"\") The base58check encoded address\n ...\n ]\n\nResult:\n[ (json array)\n { (json object)\n \"address\" : \"str\", (string) The address base58check encoded\n \"txid\" : \"hex\", (string) The output txid\n \"index\" : n, (numeric) The output index\n \"script\" : \"hex\", (string) The script hex-encoded\n \"satoshis\" : n, (numeric) The number of duffs of the output\n \"height\" : n (numeric) The block height\n },\n ...\n]\n\nExamples:\n> dash-cli getaddressutxos '{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getaddressutxos\", \"params\": [{\"addresses\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"c77e1adb8269a4b7ba5f532e5884246472aa9e879fd1c976f3c88e1edcb44f71"} +{"command":"getassetunlockstatuses","subcommand":null,"qualified":"getassetunlockstatuses","signature_tail":"[index,...] ( height )","is_family":false,"help_raw":"getassetunlockstatuses [index,...] ( height )\n\nReturns the status of given Asset Unlock indexes at the tip of the chain or at a specific block height if specified.\n\nArguments:\n1. indexes (json array, required) The Asset Unlock indexes (no more than 100)\n [\n index, (numeric) An Asset Unlock index\n ...\n ]\n2. height (numeric) The maximum block height to check\n\nResult:\n[ (json array) Response is an array with the same size as the input txids\n { (json object)\n \"index\" : n, (numeric) The Asset Unlock index\n \"status\" : \"str\" (string) Status of the Asset Unlock index: {chainlocked|mined|mempooled|unknown}\n },\n ...\n]\n\nExamples:\n> dash-cli getassetunlockstatuses '[\"myindex\",...]'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getassetunlockstatuses\", \"params\": [[\"myindex\",...]]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"c05485e2cc9d395eb5f9acf736194b3ffc6626d84fa5895f9df07673f00daf76"} +{"command":"getbalance","subcommand":null,"qualified":"getbalance","signature_tail":"( \"dummy\" minconf addlocked include_watchonly avoid_reuse )","is_family":false,"help_raw":"getbalance ( \"dummy\" minconf addlocked include_watchonly avoid_reuse )\n\nReturns the total available balance.\nThe available balance is what the wallet considers currently spendable, and is\nthus affected by options which limit spendability such as -spendzeroconfchange.\n\nArguments:\n1. dummy (string, optional) Remains for backward compatibility. Must be excluded or set to \"*\".\n2. minconf (numeric, optional, default=0) Only include transactions confirmed at least this many times.\n3. addlocked (boolean, optional, default=false) Whether to include transactions locked via InstantSend in the wallet's balance.\n4. include_watchonly (boolean, optional, default=true for watch-only wallets, otherwise false) Also include balance in watch-only addresses (see 'importaddress')\n5. avoid_reuse (boolean, optional, default=true) (only available if avoid_reuse wallet flag is set) Do not include balance in dirty outputs; addresses are considered dirty if they have previously been used in a transaction. If true, this also activates avoidpartialspends, grouping outputs by their addresses.\n\nResult:\nn (numeric) The total amount in DASH received for this wallet.\n\nExamples:\n\nThe total amount in the wallet with 0 or more confirmations\n> dash-cli getbalance \n\nThe total amount in the wallet with at least 6 confirmations\n> dash-cli getbalance \"*\" 6\n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getbalance\", \"params\": [\"*\", 6]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"1b93e917b47f1dc2e969b8b7f9957b668f16ff530bd281026bd5668c0268f053"} +{"command":"getbalances","subcommand":null,"qualified":"getbalances","signature_tail":"","is_family":false,"help_raw":"getbalances\nReturns an object with all balances in DASH.\n\nResult:\n{ (json object)\n \"mine\" : { (json object) balances from outputs that the wallet can sign\n \"trusted\" : n, (numeric) trusted balance (outputs created by the wallet or confirmed outputs)\n \"untrusted_pending\" : n, (numeric) untrusted pending balance (outputs created by others that are in the mempool)\n \"immature\" : n, (numeric) balance from immature coinbase outputs\n \"used\" : n, (numeric) (only present if avoid_reuse is set) balance from coins sent to addresses that were previously spent from (potentially privacy violating)\n \"coinjoin\" : n (numeric) CoinJoin balance (outputs with enough rounds created by the wallet via mixing)\n },\n \"watchonly\" : { (json object) watchonly balances (not present if wallet does not watch anything)\n \"trusted\" : n, (numeric) trusted balance (outputs created by the wallet or confirmed outputs)\n \"untrusted_pending\" : n, (numeric) untrusted pending balance (outputs created by others that are in the mempool)\n \"immature\" : n (numeric) balance from immature coinbase outputs\n }\n}\n\nExamples:\n> dash-cli getbalances \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getbalances\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"b0667f4705299c1e6992a453ff05d8fc831a166f59be7ea4afd23cb078a3fe34"} +{"command":"getbestblockhash","subcommand":null,"qualified":"getbestblockhash","signature_tail":"","is_family":false,"help_raw":"getbestblockhash\n\nReturns the hash of the best (tip) block in the most-work fully-validated chain.\n\nResult:\n\"hex\" (string) the block hash, hex-encoded\n\nExamples:\n> dash-cli getbestblockhash \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getbestblockhash\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"bc62f632e01bb238abda0b40662ad16e5d9934e1ccb2209fc0ad980a3a030570"} +{"command":"getbestchainlock","subcommand":null,"qualified":"getbestchainlock","signature_tail":"","is_family":false,"help_raw":"getbestchainlock\n\nReturns information about the best ChainLock. Throws an error if there is no known ChainLock yet.\nResult:\n{ (json object)\n \"hash\" : \"hex\", (string) The block hash hex-encoded\n \"height\" : n, (numeric) The block height or index\n \"signature\" : \"hex\", (string) The ChainLock's BLS signature\n \"known_block\" : true|false, (boolean) True if the block is known by our node\n \"hex\" : \"hex\" (string) The serialized, hex-encoded data for best ChainLock\n}\n\nExamples:\n> dash-cli getbestchainlock \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getbestchainlock\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"794274267cd9a6991cc3c2c77838a4d48804d52b8f4f6690e8c0acabdffa54c4"} +{"command":"getblock","subcommand":null,"qualified":"getblock","signature_tail":"\"blockhash\" ( verbosity )","is_family":false,"help_raw":"getblock \"blockhash\" ( verbosity )\n\nIf verbosity is 0, returns a string that is serialized, hex-encoded data for block 'hash'.\nIf verbosity is 1, returns an Object with information about block .\nIf verbosity is 2, returns an Object with information about block and information about each transaction. \n\nArguments:\n1. blockhash (string, required) The block hash\n2. verbosity (numeric, optional, default=1) 0 for hex-encoded data, 1 for a json object, and 2 for json object with transaction data\n\nResult (for verbosity = 0):\n\"hex\" (string) A string that is serialized, hex-encoded data for block 'hash'\n\nResult (for verbosity = 1):\n{ (json object)\n \"hash\" : \"hex\", (string) the block hash (same as provided)\n \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n \"height\" : n, (numeric) The block height or index\n \"version\" : n, (numeric) The block version\n \"versionHex\" : \"hex\", (string) The block version formatted in hexadecimal\n \"merkleroot\" : \"hex\", (string) The merkle root\n \"time\" : xxx, (numeric) The block time expressed in UNIX epoch time\n \"mediantime\" : xxx, (numeric) The median block time expressed in UNIX epoch time\n \"nonce\" : n, (numeric) The nonce\n \"bits\" : \"hex\", (string) The bits\n \"difficulty\" : n, (numeric) The difficulty\n \"chainwork\" : \"hex\", (string) Expected number of hashes required to produce the current chain\n \"nTx\" : n, (numeric) The number of transactions in the block\n \"previousblockhash\" : \"hex\", (string, optional) The hash of the previous block (if available)\n \"nextblockhash\" : \"hex\", (string, optional) The hash of the next block (if available)\n \"chainlock\" : true|false, (boolean) The state of the block ChainLock\n \"size\" : n, (numeric) The block size\n \"tx\" : [ (json array) The transaction ids\n \"hex\", (string) The transaction id\n ...\n ],\n \"cbTx\" : { (json object) The coinbase special transaction\n \"version\" : n, (numeric) The coinbase special transaction version\n \"height\" : n, (numeric) The block height\n \"merkleRootMNList\" : \"hex\", (string) The merkle root of the masternode list\n \"merkleRootQuorums\" : \"hex\" (string) The merkle root of the quorum list\n }\n}\n\nResult (for verbosity = 2):\n{ (json object)\n ..., Same output as verbosity = 1\n \"tx\" : [ (json array)\n { (json object)\n ..., The transactions in the format of the getrawtransaction RPC. Different from verbosity = 1 \"tx\" result\n \"fee\" : n (numeric) The transaction fee in DASH, omitted if block undo data is not available\n },\n ...\n ]\n}\n\nExamples:\n> dash-cli getblock \"00000000000fd08c2fb661d2fcb0d49abb3a91e5f27082ce64feed3b4dede2e2\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblock\", \"params\": [\"00000000000fd08c2fb661d2fcb0d49abb3a91e5f27082ce64feed3b4dede2e2\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"3f03a9a0d2a1cacf2b812c9044f58cc70558a2f04e86d948d6209cba90b2748b"} +{"command":"getblockchaininfo","subcommand":null,"qualified":"getblockchaininfo","signature_tail":"","is_family":false,"help_raw":"getblockchaininfo\nReturns an object containing various state info regarding blockchain processing.\n\nResult:\n{ (json object)\n \"chain\" : \"str\", (string) current network name (main, test, regtest) and devnet or devnet- for \"-devnet\" and \"-devnet=\" respectively\n \n \"blocks\" : n, (numeric) the height of the most-work fully-validated chain. The genesis block has height 0\n \"headers\" : n, (numeric) the current number of headers we have validated\n \"bestblockhash\" : \"str\", (string) the hash of the currently best block\n \"difficulty\" : n, (numeric) the current difficulty\n \"time\" : xxx, (numeric) The block time expressed in UNIX epoch time\n \"mediantime\" : xxx, (numeric) The median block time expressed in UNIX epoch time\n \"verificationprogress\" : n, (numeric) estimate of verification progress [0..1]\n \"initialblockdownload\" : true|false, (boolean) (debug information) estimate of whether this node is in Initial Block Download mode\n \"chainwork\" : \"hex\", (string) total amount of work in active chain, in hexadecimal\n \"size_on_disk\" : n, (numeric) the estimated size of the block and undo files on disk\n \"pruned\" : true|false, (boolean) if the blocks are subject to pruning\n \"pruneheight\" : n, (numeric) lowest-height complete block stored (only present if pruning is enabled)\n \"automatic_pruning\" : true|false, (boolean) whether automatic pruning is enabled (only present if pruning is enabled)\n \"prune_target_size\" : n, (numeric) the target size used by pruning (only present if automatic pruning is enabled)\n \"softforks\" : { (json object) status of softforks in progress\n \"type\" : \"str\", (string) one of \"buried\", \"bip9\"\n \"bip9\" : { (json object) status of bip9 softforks (only for \"bip9\" type)\n \"status\" : \"str\", (string) one of \"defined\", \"started\", \"locked_in\", \"active\", \"failed\"\n \"bit\" : n, (numeric) the bit (0-28) in the block version field used to signal this softfork (only for \"started\" and \"locked_in\" status)\n \"start_time\" : xxx, (numeric) the minimum median time past of a block at which the bit gains its meaning\n \"timeout\" : xxx, (numeric) the median time past of a block at which the deployment is considered failed if not yet locked in\n \"ehf\" : true|false, (boolean) returns true for EHF activated forks\n \"ehf_height\" : n, (numeric, optional) the minimum height when miner's signals for the deployment matter. Below this height miner signaling cannot trigger hard fork lock-in. Not specified for non-EHF forks\n \"since\" : n, (numeric) height of the first block to which the status applies\n \"activation_height\" : n, (numeric) expected activation height for this softfork (only for \"locked_in\" status)\n \"min_activation_height\" : n, (numeric) minimum height of blocks for which the rules may be enforced\n \"statistics\" : { (json object) numeric statistics about signalling for a softfork (only for \"started\" and \"locked_in\" status)\n \"period\" : n, (numeric) the length in blocks of the signalling period\n \"threshold\" : n, (numeric) the number of blocks with the version bit set required to activate the feature (only for \"started\" status)\n \"elapsed\" : n, (numeric) the number of blocks elapsed since the beginning of the current period\n \"count\" : n, (numeric) the number of blocks with the version bit set in the current period\n \"possible\" : true|false (boolean) returns false if there are not enough blocks left in this period to pass activation threshold (only for \"started\" status)\n }\n },\n \"height\" : n, (numeric) height of the first block which the rules are or will be enforced (only for \"buried\" type, or \"bip9\" type with \"active\" status)\n \"active\" : true|false (boolean) true if the rules are enforced for the mempool and the next block\n },\n \"warnings\" : \"str\" (string) any network and blockchain warnings\n}\n\nExamples:\n> dash-cli getblockchaininfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockchaininfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"5bd7202ff4f42c638a3064df0bcc2c96a4adefbd24d0314d05b702e4c59d2606"} +{"command":"getblockcount","subcommand":null,"qualified":"getblockcount","signature_tail":"","is_family":false,"help_raw":"getblockcount\n\nReturns the height of the most-work fully-validated chain.\nThe genesis block has height 0.\n\nResult:\nn (numeric) The current block count\n\nExamples:\n> dash-cli getblockcount \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockcount\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"b7a69f6b4d3a64f04fd1e36f000adaf868e9d24ef7223a18977910d2fa0be9ef"} +{"command":"getblockfilter","subcommand":null,"qualified":"getblockfilter","signature_tail":"\"blockhash\" ( \"filtertype\" )","is_family":false,"help_raw":"getblockfilter \"blockhash\" ( \"filtertype\" )\n\nRetrieve a BIP 157 content filter for a particular block.\n\nArguments:\n1. blockhash (string, required) The hash of the block\n2. filtertype (string, optional, default=\"basic\") The type name of the filter\n\nResult:\n{ (json object)\n \"filter\" : \"hex\", (string) the hex-encoded filter data\n \"header\" : \"hex\" (string) the hex-encoded filter header\n}\n\nExamples:\n> dash-cli getblockfilter \"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" \"basic\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockfilter\", \"params\": [\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\", \"basic\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"73d3294bfd94996281d3953081a055c34d04ffbd84458976fef760792ae6437c"} +{"command":"getblockfrompeer","subcommand":null,"qualified":"getblockfrompeer","signature_tail":"\"blockhash\" peer_id","is_family":false,"help_raw":"getblockfrompeer \"blockhash\" peer_id\n\nAttempt to fetch block from a given peer.\n\nWe must have the header for this block, e.g. using submitheader.\n\nReturns {} if a block-request was successfully scheduled\n\nArguments:\n1. blockhash (string, required) The block hash to try to fetch\n2. peer_id (numeric, required) The peer to fetch it from (see getpeerinfo for peer IDs)\n\nResult:\n{ (json object)\n \"warnings\" : \"str\" (string, optional) any warnings\n}\n\nExamples:\n> dash-cli getblockfrompeer \"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockfrompeer\", \"params\": [\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"d018cb65d7250318ffbc28ecc09bfcc84ace62d936d8b16cd564779a0cdbfe18"} +{"command":"getblockhash","subcommand":null,"qualified":"getblockhash","signature_tail":"height","is_family":false,"help_raw":"getblockhash height\n\nReturns hash of block in best-block-chain at height provided.\n\nArguments:\n1. height (numeric, required) The height index\n\nResult:\n\"hex\" (string) The block hash\n\nExamples:\n> dash-cli getblockhash 1000\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockhash\", \"params\": [1000]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"585dc2341498d67e7cdf6198f3b1c4d050e8ecd58d5df21a5165c1e1296f390e"} +{"command":"getblockhashes","subcommand":null,"qualified":"getblockhashes","signature_tail":"high low","is_family":false,"help_raw":"getblockhashes high low\n\nReturns array of hashes of blocks within the timestamp range provided.\n\nArguments:\n1. high (numeric, required) The newer block timestamp\n2. low (numeric, required) The older block timestamp\n\nResult:\n[ (json array)\n \"hex\", (string) The block hash\n ...\n]\n\nExamples:\n> dash-cli getblockhashes 1231614698 1231024505\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockhashes\", \"params\": [1231614698, 1231024505]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"84d1d9c7d61df2ec6404b15a1d8d702ae2e2928585b94ea791f40dace2af966e"} +{"command":"getblockheader","subcommand":null,"qualified":"getblockheader","signature_tail":"\"blockhash\" ( verbose )","is_family":false,"help_raw":"getblockheader \"blockhash\" ( verbose )\n\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\nIf verbose is true, returns an Object with information about blockheader .\n\nArguments:\n1. blockhash (string, required) The block hash\n2. verbose (boolean, optional, default=true) true for a json object, false for the hex-encoded data\n\nResult (for verbose = true):\n{ (json object)\n \"hash\" : \"hex\", (string) the block hash (same as provided)\n \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n \"height\" : n, (numeric) The block height or index\n \"version\" : n, (numeric) The block version\n \"versionHex\" : \"hex\", (string) The block version formatted in hexadecimal\n \"merkleroot\" : \"hex\", (string) The merkle root\n \"time\" : xxx, (numeric) The block time expressed in UNIX epoch time\n \"mediantime\" : xxx, (numeric) The median block time expressed in UNIX epoch time\n \"nonce\" : n, (numeric) The nonce\n \"bits\" : \"hex\", (string) The bits\n \"difficulty\" : n, (numeric) The difficulty\n \"chainwork\" : \"hex\", (string) Expected number of hashes required to produce the current chain\n \"nTx\" : n, (numeric) The number of transactions in the block\n \"previousblockhash\" : \"hex\", (string, optional) The hash of the previous block (if available)\n \"nextblockhash\" : \"hex\", (string, optional) The hash of the next block (if available)\n \"chainlock\" : true|false (boolean) The state of the block ChainLock\n}\n\nResult (for verbose=false):\n\"hex\" (string) A string that is serialized, hex-encoded data for block 'hash'\n\nExamples:\n> dash-cli getblockheader \"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockheader\", \"params\": [\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"2b175359d3d6f5037e78dc8641d370af74ed9499ee70993c54e96c31b851d30d"} +{"command":"getblockheaders","subcommand":null,"qualified":"getblockheaders","signature_tail":"\"blockhash\" ( count verbose )","is_family":false,"help_raw":"getblockheaders \"blockhash\" ( count verbose )\n\nReturns an array of items with information about blockheaders starting from .\n\nIf verbose is false, each item is a string that is serialized, hex-encoded data for a single blockheader.\nIf verbose is true, each item is an Object with information about a single blockheader.\n\nArguments:\n1. blockhash (string, required) The block hash\n2. count (numeric, optional, default=2000)\n3. verbose (boolean, optional, default=true) true for a json object, false for the hex-encoded data\n\nResult (for verbose = true):\n[ (json array)\n { (json object)\n \"hash\" : \"hex\", (string) The block hash (same as provided)\n \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n \"height\" : n, (numeric) The block height or index\n \"version\" : n, (numeric) The block version\n \"versionHex\" : \"hex\", (string) The block version formatted in hexadecimal\n \"merkleroot\" : \"hex\", (string) The merkle root\n \"time\" : xxx, (numeric) The block time expressed in UNIX epoch time\n \"mediantime\" : xxx, (numeric) The median block time expressed in UNIX epoch time\n \"nonce\" : n, (numeric) The nonce\n \"bits\" : \"hex\", (string) The bits\n \"difficulty\" : n, (numeric) The difficulty\n \"chainwork\" : \"hex\", (string) Expected number of hashes required to produce the current chain\n \"nTx\" : n, (numeric) The number of transactions in the block\n \"previousblockhash\" : \"hex\", (string, optional) The hash of the previous block (if available)\n \"nextblockhash\" : \"hex\", (string, optional) The hash of the next block (if available)\n \"chainlock\" : true|false (boolean) The state of the block ChainLock\n },\n ...\n]\n\nResult (for verbose=false):\n[ (json array)\n \"hex\", (string) A string that is serialized, hex-encoded data for block 'hash'\n ...\n]\n\nExamples:\n> dash-cli getblockheaders \"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 2000\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockheaders\", \"params\": [\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 2000]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"f13b1e48a4e0b7ddc94b01e2ec8452db93880b2f13676abe1ebd957a6fb0d9d7"} +{"command":"getblockstats","subcommand":null,"qualified":"getblockstats","signature_tail":"hash_or_height ( stats )","is_family":false,"help_raw":"getblockstats hash_or_height ( stats )\n\nCompute per block statistics for a given window. All amounts are in duffs.\nIt won't work for some heights with pruning.\n\nArguments:\n1. hash_or_height (string or numeric, required) The block hash or height of the target block\n2. stats (json array, optional, default=all values) Values to plot (see result below)\n [\n \"height\", (string) Selected statistic\n \"time\", (string) Selected statistic\n ...\n ]\n\nResult:\n{ (json object)\n \"avgfee\" : n, (numeric) Average fee in the block\n \"avgfeerate\" : n, (numeric) Average feerate (in duffs per virtual byte)\n \"avgtxsize\" : n, (numeric) Average transaction size\n \"blockhash\" : \"hex\", (string) The block hash (to check for potential reorgs)\n \"feerate_percentiles\" : [ (json array) Feerates at the 10th, 25th, 50th, 75th, and 90th percentile weight unit (in duffs per byte)\n n, (numeric) The 10th percentile feerate\n n, (numeric) The 25th percentile feerate\n n, (numeric) The 50th percentile feerate\n n, (numeric) The 75th percentile feerate\n n (numeric) The 90th percentile feerate\n ],\n \"height\" : n, (numeric) The height of the block\n \"ins\" : n, (numeric) The number of inputs (excluding coinbase)\n \"maxfee\" : n, (numeric) Maximum fee in the block\n \"maxfeerate\" : n, (numeric) Maximum feerate (in duffs per virtual byte)\n \"maxtxsize\" : n, (numeric) Maximum transaction size\n \"medianfee\" : n, (numeric) Truncated median fee in the block\n \"mediantime\" : n, (numeric) The block median time past\n \"mediantxsize\" : n, (numeric) Truncated median transaction size\n \"minfee\" : n, (numeric) Minimum fee in the block\n \"minfeerate\" : n, (numeric) Minimum feerate (in duffs per virtual byte)\n \"mintxsize\" : n, (numeric) Minimum transaction size\n \"outs\" : n, (numeric) The number of outputs\n \"subsidy\" : n, (numeric) The block subsidy\n \"time\" : n, (numeric) The block time\n \"total_out\" : n, (numeric) Total amount in all outputs (excluding coinbase and thus reward [ie subsidy + totalfee])\n \"total_size\" : n, (numeric) Total size of all non-coinbase transactions\n \"totalfee\" : n, (numeric) The fee total\n \"txs\" : n, (numeric) The number of transactions (including coinbase)\n \"utxo_increase\" : n, (numeric) The increase/decrease in the number of unspent outputs\n \"utxo_size_inc\" : n (numeric) The increase/decrease in size for the utxo index (not discounting op_return and similar)\n}\n\nExamples:\n> dash-cli getblockstats '\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"' '[\"minfeerate\",\"avgfeerate\"]'\n> dash-cli getblockstats 1000 '[\"minfeerate\",\"avgfeerate\"]'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockstats\", \"params\": [\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\", [\"minfeerate\",\"avgfeerate\"]]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblockstats\", \"params\": [1000, [\"minfeerate\",\"avgfeerate\"]]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"d8637a577caf258e01a287df6632180c610033f988905c3e05067b71ea4a58b8"} +{"command":"getblocktemplate","subcommand":null,"qualified":"getblocktemplate","signature_tail":"( \"template_request\" )","is_family":false,"help_raw":"getblocktemplate ( \"template_request\" )\n\nIf the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\nIt returns data needed to construct a block to work on.\nFor full specification, see BIPs 22, 23, and 9:\n https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n\nArguments:\n1. template_request (json object, optional, default={}) Format of the template\n {\n \"mode\": \"str\", (string, optional) This must be set to \"template\", \"proposal\" (see BIP 23), or omitted\n \"capabilities\": [ (json array, optional) A list of strings\n \"str\", (string) client side supported feature, 'longpoll', 'coinbasevalue', 'proposal', 'serverlist', 'workid'\n ...\n ],\n \"rules\": [ (json array, required) A list of strings\n \"str\", (string) client side supported softfork deployment\n ...\n ],\n }\n\nResult (If the proposal was accepted with mode=='proposal'):\nnull (json null)\n\nResult (If the proposal was not accepted with mode=='proposal'):\n\"str\" (string) According to BIP22\n\nResult (Otherwise):\n{ (json object)\n \"capabilities\" : [ (json array) specific client side supported features\n \"str\", (string) capability\n ...\n ],\n \"version\" : n, (numeric) The preferred block version\n \"rules\" : [ (json array) specific block rules that are to be enforced\n \"str\", (string) name of a rule the client must understand to some extent; see BIP 9 for format\n ...\n ],\n \"vbavailable\" : { (json object) set of pending, supported versionbit (BIP 9) softfork deployments\n \"rulename\" : n, (numeric) identifies the bit number as indicating acceptance and readiness for the named softfork rule\n ...\n },\n \"vbrequired\" : n, (numeric) bit mask of versionbits the server requires set in submissions\n \"previousblockhash\" : \"str\", (string) The hash of current highest block\n \"transactions\" : [ (json array) contents of non-coinbase transactions that should be included in the next block\n { (json object)\n \"data\" : \"hex\", (string) transaction data encoded in hexadecimal (byte-for-byte)\n \"txid\" : \"hex\", (string) transaction id encoded in little-endian hexadecimal\n \"hash\" : \"hex\", (string) hash encoded in little-endian hexadecimal\n \"depends\" : [ (json array) array of numbers\n n, (numeric) transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is\n ...\n ],\n \"fee\" : n, (numeric) difference in value between transaction inputs and outputs (in duffs); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one\n \"sigops\" : n (numeric) total number of SigOps, as counted for purposes of block limits; if key is not present, sigop count is unknown and clients MUST NOT assume there aren't any\n },\n ...\n ],\n \"coinbaseaux\" : { (json object) data that should be included in the coinbase's scriptSig content\n \"key\" : \"hex\", (string) values must be in the coinbase (keys may be ignored)\n ...\n },\n \"coinbasevalue\" : n, (numeric) maximum allowable input to coinbase transaction, including the generation award and transaction fees (in duffs)\n \"longpollid\" : \"str\", (string) an id to include with a request to longpoll on an update to this template\n \"target\" : \"str\", (string) The hash target\n \"mintime\" : xxx, (numeric) The minimum timestamp appropriate for the next block time, expressed in UNIX epoch time\n \"mutable\" : [ (json array) list of ways the block template may be changed\n \"str\", (string) A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'\n ...\n ],\n \"noncerange\" : \"hex\", (string) A range of valid nonces\n \"sigoplimit\" : n, (numeric) limit of sigops in blocks\n \"sizelimit\" : n, (numeric) limit of block size\n \"curtime\" : xxx, (numeric) current timestamp in UNIX epoch time\n \"bits\" : \"str\", (string) compressed target of next block\n \"previousbits\" : \"str\", (string) compressed target of current highest block\n \"height\" : n, (numeric) The height of the next block\n \"masternode\" : [ (json array) required masternode payments that must be included in the next block\n { (json object)\n \"payee\" : \"hex\", (string) payee address\n \"script\" : \"hex\", (string) payee scriptPubKey\n \"amount\" : n (numeric) required amount to pay\n },\n ...\n ],\n \"masternode_payments_started\" : true|false, (boolean) true, if masternode payments started\n \"masternode_payments_enforced\" : true|false, (boolean) true, if masternode payments are enforced\n \"superblock\" : [ (json array) required superblock payees that must be included in the next block\n { (json object)\n \"payee\" : \"hex\", (string) payee address\n \"script\" : \"hex\", (string) payee scriptPubKey\n \"amount\" : n (numeric) required amount to pay\n },\n ...\n ],\n \"superblocks_started\" : true|false, (boolean) true, if superblock payments started\n \"superblocks_enabled\" : true|false, (boolean) true, if superblock payments are enabled\n \"coinbase_payload\" : \"hex\" (string) coinbase transaction payload data encoded in hexadecimal\n}\n\nExamples:\n> dash-cli getblocktemplate \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getblocktemplate\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"a1b68d54527ef4e2aafa0befd675f95c15107e5a01157a744cf6089b55938448"} +{"command":"getchaintips","subcommand":null,"qualified":"getchaintips","signature_tail":"( count branchlen )","is_family":false,"help_raw":"getchaintips ( count branchlen )\nReturn information about all known tips in the block tree, including the main chain as well as orphaned branches.\n\nArguments:\n1. count (numeric, optional, default=2147483647) only show this much of latest tips\n2. branchlen (numeric, optional, default=-1) only show tips that have equal or greater length of branch\n\nResult:\n[ (json array)\n { (json object)\n \"height\" : n, (numeric) height of the chain tip\n \"hash\" : \"hex\", (string) block hash of the tip\n \"difficulty\" : n, (numeric) The difficulty\n \"chainwork\" : \"hex\", (string) Expected number of hashes required to produce the current chain (in hex)\n \"branchlen\" : n, (numeric) zero for main chain, otherwise length of branch connecting the tip to the main chain\n \"forkpoint\" : \"hex\", (string) same as \"hash\" for the main chain\n \"status\" : \"str\" (string) status of the chain, \"active\" for the main chain\n Possible values for status:\n 1. \"invalid\" This branch contains at least one invalid block\n 2. \"headers-only\" Not all blocks for this branch are available, but the headers are valid\n 3. \"valid-headers\" All blocks are available for this branch, but they were never fully validated\n 4. \"valid-fork\" This branch is not part of the active chain, but is fully validated\n 5. \"active\" This is the tip of the active main chain, which is certainly valid\n 6. \"conflicting\" This block or one of its ancestors is conflicting with ChainLocks.\n },\n ...\n]\n\nExamples:\n> dash-cli getchaintips \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getchaintips\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"e5e43c89649541687a6cfc676634957027380c7a37833c0677fdca1cb379b7e8"} +{"command":"getchaintxstats","subcommand":null,"qualified":"getchaintxstats","signature_tail":"( nblocks \"blockhash\" )","is_family":false,"help_raw":"getchaintxstats ( nblocks \"blockhash\" )\n\nCompute statistics about the total number and rate of transactions in the chain.\n\nArguments:\n1. nblocks (numeric, optional, default=one month) Size of the window in number of blocks\n2. blockhash (string, optional, default=chain tip) The hash of the block that ends the window.\n\nResult:\n{ (json object)\n \"time\" : xxx, (numeric) The timestamp for the final block in the window, expressed in UNIX epoch time\n \"txcount\" : n, (numeric) The total number of transactions in the chain up to that point\n \"window_final_block_hash\" : \"hex\", (string) The hash of the final block in the window\n \"window_final_block_height\" : n, (numeric) The height of the final block in the window.\n \"window_block_count\" : n, (numeric) Size of the window in number of blocks\n \"window_tx_count\" : n, (numeric, optional) The number of transactions in the window. Only returned if \"window_block_count\" is > 0\n \"window_interval\" : n, (numeric, optional) The elapsed time in the window in seconds. Only returned if \"window_block_count\" is > 0\n \"txrate\" : n (numeric, optional) The average rate of transactions per second in the window. Only returned if \"window_interval\" is > 0\n}\n\nExamples:\n> dash-cli getchaintxstats \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getchaintxstats\", \"params\": [2016]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"a1d1b3779975de6321e5f30a1c76a3bea2ce6861ce4f4bd353ab16ad0a8bc486"} +{"command":"getcoinjoininfo","subcommand":null,"qualified":"getcoinjoininfo","signature_tail":"","is_family":false,"help_raw":"getcoinjoininfo\nReturns an object containing an information about CoinJoin settings and state.\n\nResult (for regular nodes):\n{ (json object)\n \"enabled\" : true|false, (boolean) Whether mixing functionality is enabled\n \"multisession\" : true|false, (boolean) Whether CoinJoin Multisession option is enabled\n \"max_sessions\" : n, (numeric) How many parallel mixing sessions can there be at once\n \"max_rounds\" : n, (numeric) How many rounds to mix\n \"max_amount\" : n, (numeric) Target CoinJoin balance in DASH\n \"denoms_goal\" : n, (numeric) How many inputs of each denominated amount to target\n \"denoms_hardcap\" : n, (numeric) Maximum limit of how many inputs of each denominated amount to create\n \"queue_size\" : n, (numeric) How many queues there are currently on the network\n \"running\" : true|false, (boolean) Whether mixing is currently running\n \"sessions\" : [ (json array)\n { (json object)\n \"protxhash\" : \"hex\", (string) The ProTxHash of the masternode\n \"outpoint\" : \"hex\", (string) The outpoint of the masternode\n \"service\" : \"str\", (string) The IP address and port of the masternode\n \"denomination\" : n, (numeric) The denomination of the mixing session in DASH\n \"state\" : \"hex\", (string) Current state of the mixing session\n \"entries_count\" : n (numeric) The number of entries in the mixing session\n },\n ...\n ],\n \"keys_left\" : n, (numeric, optional) How many new keys are left since last automatic backup (if applicable)\n \"warnings\" : \"str\" (string) Warnings if any\n}\n\nResult (for masternodes):\n{ (json object)\n \"queue_size\" : n, (numeric) How many queues there are currently on the network\n \"denomination\" : n, (numeric) The denomination of the mixing session in DASH\n \"state\" : \"hex\", (string) Current state of the mixing session\n \"entries_count\" : n (numeric) The number of entries in the mixing session\n}\n\nExamples:\n> dash-cli getcoinjoininfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getcoinjoininfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"e6d273ab1f7dc2383fccc8c67cceb5bd360935a1d9c9de2432d304cf48103890"} +{"command":"getconnectioncount","subcommand":null,"qualified":"getconnectioncount","signature_tail":"","is_family":false,"help_raw":"getconnectioncount\n\nReturns the number of connections to other nodes.\n\nResult:\nn (numeric) The connection count\n\nExamples:\n> dash-cli getconnectioncount \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getconnectioncount\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"f2862f791fbe1b0d58fd2be0bd42c775c6acec6aa3d67cab26e86da87e322f94"} +{"command":"getdescriptorinfo","subcommand":null,"qualified":"getdescriptorinfo","signature_tail":"\"descriptor\"","is_family":false,"help_raw":"getdescriptorinfo \"descriptor\"\n\nAnalyses a descriptor.\n\nArguments:\n1. descriptor (string, required) The descriptor\n\nResult:\n{ (json object)\n \"descriptor\" : \"str\", (string) The descriptor in canonical form, without private keys\n \"checksum\" : \"str\", (string) The checksum for the input descriptor\n \"isrange\" : true|false, (boolean) Whether the descriptor is ranged\n \"issolvable\" : true|false, (boolean) Whether the descriptor is solvable\n \"hasprivatekeys\" : true|false (boolean) Whether the input descriptor contained at least one private key\n}\n\nExamples:\n\nAnalyse a descriptor\n> dash-cli getdescriptorinfo \"wpkh([d34db33f/84h/0h/0h]0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2dce28d959f2815b16f81798)\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getdescriptorinfo\", \"params\": [\"wpkh([d34db33f/84h/0h/0h]0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2dce28d959f2815b16f81798)\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"4ea252cc0415d23f3d73fa7528eef581f4d3efa857e3d3b08acf2d9505c6f5b2"} +{"command":"getdifficulty","subcommand":null,"qualified":"getdifficulty","signature_tail":"","is_family":false,"help_raw":"getdifficulty\n\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n\nResult:\nn (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\n\nExamples:\n> dash-cli getdifficulty \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getdifficulty\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"eee3845c2e56c6b7500cea092dd89cf90b6161d1f207bf970f4357eefae9dd05"} +{"command":"getgovernanceinfo","subcommand":null,"qualified":"getgovernanceinfo","signature_tail":"","is_family":false,"help_raw":"getgovernanceinfo\nReturns an object containing governance parameters.\n\nResult:\n{ (json object)\n \"governanceminquorum\" : n, (numeric) the absolute minimum number of votes needed to trigger a governance action\n \"proposalfee\" : n, (numeric) the collateral transaction fee which must be paid to create a proposal in DASH\n \"superblockcycle\" : n, (numeric) the number of blocks between superblocks\n \"superblockmaturitywindow\" : n, (numeric) the superblock trigger creation window\n \"lastsuperblock\" : n, (numeric) the block number of the last superblock\n \"nextsuperblock\" : n, (numeric) the block number of the next superblock\n \"fundingthreshold\" : n, (numeric) the number of absolute yes votes required for a proposal to be passing\n \"governancebudget\" : n (numeric) the governance budget for the next superblock in DASH\n}\n\nExamples:\n> dash-cli getgovernanceinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getgovernanceinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"8ef1e4cc58f70b96320a95643addf30ca18ccdeb06c019ef654f449015c89a7d"} +{"command":"getindexinfo","subcommand":null,"qualified":"getindexinfo","signature_tail":"( \"index_name\" )","is_family":false,"help_raw":"getindexinfo ( \"index_name\" )\n\nReturns the status of one or all available indices currently running in the node.\n\nArguments:\n1. index_name (string, optional) Filter results for an index with a specific name.\n\nResult:\n{ (json object)\n \"name\" : { (json object) The name of the index\n \"synced\" : true|false, (boolean) Whether the index is synced or not\n \"best_block_height\" : n (numeric) The block height to which the index is synced\n }\n}\n\nExamples:\n> dash-cli getindexinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getindexinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> dash-cli getindexinfo txindex\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getindexinfo\", \"params\": [txindex]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"e18b1b2e51f97145b41062ee9d74ff873aaaea48912c0e05f224760b085bc621"} +{"command":"getislocks","subcommand":null,"qualified":"getislocks","signature_tail":"[\"txid\",...]","is_family":false,"help_raw":"getislocks [\"txid\",...]\n\nReturns the raw InstantSend lock data for each txids. Returns Null if there is no known IS yet.\nArguments:\n1. txids (json array, required) The transaction ids (no more than 100)\n [\n \"txid\", (string) A transaction hash\n ...\n ]\n\nResult:\n[ (json array) Response is an array with the same size as the input txids\n { (json object)\n \"txid\" : \"hex\", (string) The transaction id\n \"inputs\" : [ (json array) The inputs\n { (json object)\n \"txid\" : \"hex\", (string) The transaction id\n \"vout\" : n (numeric) The output number\n },\n ...\n ],\n \"cycleHash\" : \"hex\", (string) The Cycle Hash\n \"signature\" : \"hex\", (string) The InstantSend's BLS signature\n \"hex\" : \"hex\" (string) The serialized, hex-encoded data for 'txid'\n },\n \"str\", (string) Just 'None' string\n ...\n]\n\nExamples:\n> dash-cli getislocks '[\"txid\",...]'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getislocks\", \"params\": ['[\"txid\",...]']}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"df1a412684e60a4049f3d8f954591183a4b2be9a8d2314fcf0ea286d81f7cc03"} +{"command":"getmemoryinfo","subcommand":null,"qualified":"getmemoryinfo","signature_tail":"( \"mode\" )","is_family":false,"help_raw":"getmemoryinfo ( \"mode\" )\nReturns an object containing information about memory usage.\n\nArguments:\n1. mode (string, optional, default=\"stats\") determines what kind of information is returned.\n - \"stats\" returns general statistics about memory usage in the daemon.\n - \"mallocinfo\" returns an XML string describing low-level heap state (only available if compiled with glibc 2.10+).\n\nResult (mode \"stats\"):\n{ (json object)\n \"locked\" : { (json object) Information about locked memory manager\n \"used\" : n, (numeric) Number of bytes used\n \"free\" : n, (numeric) Number of bytes available in current arenas\n \"total\" : n, (numeric) Total number of bytes managed\n \"locked\" : n, (numeric) Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk.\n \"chunks_used\" : n, (numeric) Number allocated chunks\n \"chunks_free\" : n (numeric) Number unused chunks\n }\n}\n\nResult (mode \"mallocinfo\"):\n\"str\" (string) \"...\"\n\nExamples:\n> dash-cli getmemoryinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmemoryinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"e1c459fb3e359a38575a919b8d1d64a7d932a4b615197f9bf7195c979a036718"} +{"command":"getmempoolancestors","subcommand":null,"qualified":"getmempoolancestors","signature_tail":"\"txid\" ( verbose )","is_family":false,"help_raw":"getmempoolancestors \"txid\" ( verbose )\n\nIf txid is in the mempool, returns all in-mempool ancestors.\n\nArguments:\n1. txid (string, required) The transaction id (must be in mempool)\n2. verbose (boolean, optional, default=false) True for a json object, false for array of transaction ids\n\nResult (for verbose = false):\n[ (json array)\n \"hex\", (string) The transaction id of an in-mempool ancestor transaction\n ...\n]\n\nResult (for verbose = true):\n{ (json object)\n \"transactionid\" : { (json object)\n \"vsize\" : n, (numeric) virtual transaction size. This can be different from actual serialized size for high-sigop transactions.\n \"fee\" : n, (numeric, optional) transaction fee, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"modifiedfee\" : n, (numeric, optional) transaction fee with fee deltas used for mining priority, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"time\" : xxx, (numeric) local time transaction entered pool in UNIX epoch time\n \"height\" : n, (numeric) block height when transaction entered pool\n \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n \"descendantsize\" : n, (numeric) size of in-mempool descendants (including this one)\n \"descendantfees\" : n, (numeric, optional) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n \"ancestorsize\" : n, (numeric) size of in-mempool ancestors (including this one)\n \"ancestorfees\" : n, (numeric, optional) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"fees\" : { (json object)\n \"base\" : n, (numeric) transaction fee, denominated in DASH\n \"modified\" : n, (numeric) transaction fee with fee deltas used for mining priority, denominated in DASH\n \"ancestor\" : n, (numeric) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in DASH\n \"descendant\" : n (numeric) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in DASH\n },\n \"depends\" : [ (json array) unconfirmed transactions used as inputs for this transaction\n \"hex\", (string) parent transaction id\n ...\n ],\n \"spentby\" : [ (json array) unconfirmed transactions spending outputs from this transaction\n \"hex\", (string) child transaction id\n ...\n ],\n \"instantsend\" : true|false, (boolean) True if this transaction was locked via InstantSend\n \"unbroadcast\" : true|false (boolean) Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)\n },\n ...\n}\n\nExamples:\n> dash-cli getmempoolancestors \"mytxid\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmempoolancestors\", \"params\": [\"mytxid\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"66fcc2218c61fd175d07c686d812acc67aed92c9f8d97eefe7e27ce455a30b3e"} +{"command":"getmempooldescendants","subcommand":null,"qualified":"getmempooldescendants","signature_tail":"\"txid\" ( verbose )","is_family":false,"help_raw":"getmempooldescendants \"txid\" ( verbose )\n\nIf txid is in the mempool, returns all in-mempool descendants.\n\nArguments:\n1. txid (string, required) The transaction id (must be in mempool)\n2. verbose (boolean, optional, default=false) True for a json object, false for array of transaction ids\n\nResult (for verbose = false):\n[ (json array)\n \"hex\", (string) The transaction id of an in-mempool descendant transaction\n ...\n]\n\nResult (for verbose = true):\n{ (json object)\n \"transactionid\" : { (json object)\n \"vsize\" : n, (numeric) virtual transaction size. This can be different from actual serialized size for high-sigop transactions.\n \"fee\" : n, (numeric, optional) transaction fee, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"modifiedfee\" : n, (numeric, optional) transaction fee with fee deltas used for mining priority, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"time\" : xxx, (numeric) local time transaction entered pool in UNIX epoch time\n \"height\" : n, (numeric) block height when transaction entered pool\n \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n \"descendantsize\" : n, (numeric) size of in-mempool descendants (including this one)\n \"descendantfees\" : n, (numeric, optional) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n \"ancestorsize\" : n, (numeric) size of in-mempool ancestors (including this one)\n \"ancestorfees\" : n, (numeric, optional) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"fees\" : { (json object)\n \"base\" : n, (numeric) transaction fee, denominated in DASH\n \"modified\" : n, (numeric) transaction fee with fee deltas used for mining priority, denominated in DASH\n \"ancestor\" : n, (numeric) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in DASH\n \"descendant\" : n (numeric) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in DASH\n },\n \"depends\" : [ (json array) unconfirmed transactions used as inputs for this transaction\n \"hex\", (string) parent transaction id\n ...\n ],\n \"spentby\" : [ (json array) unconfirmed transactions spending outputs from this transaction\n \"hex\", (string) child transaction id\n ...\n ],\n \"instantsend\" : true|false, (boolean) True if this transaction was locked via InstantSend\n \"unbroadcast\" : true|false (boolean) Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)\n },\n ...\n}\n\nExamples:\n> dash-cli getmempooldescendants \"mytxid\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmempooldescendants\", \"params\": [\"mytxid\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"bff3996a63cd8ac31e1f50e55779488b467f6bdaedaf7395a77dc1c6aea2c46a"} +{"command":"getmempoolentry","subcommand":null,"qualified":"getmempoolentry","signature_tail":"\"txid\"","is_family":false,"help_raw":"getmempoolentry \"txid\"\n\nReturns mempool data for given transaction\n\nArguments:\n1. txid (string, required) The transaction id (must be in mempool)\n\nResult:\n{ (json object)\n \"vsize\" : n, (numeric) virtual transaction size. This can be different from actual serialized size for high-sigop transactions.\n \"fee\" : n, (numeric, optional) transaction fee, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"modifiedfee\" : n, (numeric, optional) transaction fee with fee deltas used for mining priority, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"time\" : xxx, (numeric) local time transaction entered pool in UNIX epoch time\n \"height\" : n, (numeric) block height when transaction entered pool\n \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n \"descendantsize\" : n, (numeric) size of in-mempool descendants (including this one)\n \"descendantfees\" : n, (numeric, optional) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n \"ancestorsize\" : n, (numeric) size of in-mempool ancestors (including this one)\n \"ancestorfees\" : n, (numeric, optional) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"fees\" : { (json object)\n \"base\" : n, (numeric) transaction fee, denominated in DASH\n \"modified\" : n, (numeric) transaction fee with fee deltas used for mining priority, denominated in DASH\n \"ancestor\" : n, (numeric) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in DASH\n \"descendant\" : n (numeric) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in DASH\n },\n \"depends\" : [ (json array) unconfirmed transactions used as inputs for this transaction\n \"hex\", (string) parent transaction id\n ...\n ],\n \"spentby\" : [ (json array) unconfirmed transactions spending outputs from this transaction\n \"hex\", (string) child transaction id\n ...\n ],\n \"instantsend\" : true|false, (boolean) True if this transaction was locked via InstantSend\n \"unbroadcast\" : true|false (boolean) Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)\n}\n\nExamples:\n> dash-cli getmempoolentry \"mytxid\"\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmempoolentry\", \"params\": [\"mytxid\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"1d59e9e8a3f62853f9793755b3815298ddd47be93519ccf92d3b34e1bf6be519"} +{"command":"getmempoolinfo","subcommand":null,"qualified":"getmempoolinfo","signature_tail":"","is_family":false,"help_raw":"getmempoolinfo\n\nReturns details on the active state of the TX memory pool.\n\nResult:\n{ (json object)\n \"loaded\" : true|false, (boolean) True if the mempool is fully loaded\n \"size\" : n, (numeric) Current tx count\n \"bytes\" : n, (numeric) Sum of all transaction sizes\n \"usage\" : n, (numeric) Total memory usage for the mempool\n \"total_fee\" : n, (numeric) Total fees for the mempool in DASH, ignoring modified fees through prioritisetransaction\n \"maxmempool\" : n, (numeric) Maximum memory usage for the mempool\n \"mempoolminfee\" : n, (numeric) Minimum fee rate in DASH/kB for tx to be accepted. Is the maximum of minrelaytxfee and minimum mempool fee\n \"minrelaytxfee\" : n, (numeric) Current minimum relay fee for transactions\n \"instantsendlocks\" : n, (numeric) Number of unconfirmed InstantSend locks\n \"unbroadcastcount\" : n (numeric) Current number of transactions that haven't passed initial broadcast yet\n}\n\nExamples:\n> dash-cli getmempoolinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmempoolinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"501d6e5cfb9579c9e27e464849a076af6e14f327a82e1c3b007baad8bb92e639"} +{"command":"getmerkleblocks","subcommand":null,"qualified":"getmerkleblocks","signature_tail":"\"filter\" \"blockhash\" ( count )","is_family":false,"help_raw":"getmerkleblocks \"filter\" \"blockhash\" ( count )\n\nReturns an array of hex-encoded merkleblocks for blocks starting from which match .\n\nArguments:\n1. filter (string, required) The hex-encoded bloom filter\n2. blockhash (string, required) The block hash\n3. count (numeric, optional, default=2000)\n\nResult:\n[ (json array)\n \"hex\", (string) A string that is serialized, hex-encoded data for a merkleblock\n ...\n]\n\nExamples:\n> dash-cli getmerkleblocks \"2303028005802040100040000008008400048141010000f8400420800080025004000004130000000000000001\" \"00000000007e1432d2af52e8463278bf556b55cf5049262f25634557e2e91202\" 2000\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmerkleblocks\", \"params\": [\"2303028005802040100040000008008400048141010000f8400420800080025004000004130000000000000001\" \"00000000007e1432d2af52e8463278bf556b55cf5049262f25634557e2e91202\" 2000]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"fc62f27104b6118b2f050f9c4e9ed9667f3b91fcc4157177be358fe55cbc2a78"} +{"command":"getmininginfo","subcommand":null,"qualified":"getmininginfo","signature_tail":"","is_family":false,"help_raw":"getmininginfo\n\nReturns a json object containing mining-related information.\nResult:\n{ (json object)\n \"blocks\" : n, (numeric) The current block\n \"currentblocksize\" : n, (numeric, optional) The block size of the last assembled block (only present if a block was ever assembled)\n \"currentblocktx\" : n, (numeric, optional) The number of block transactions of the last assembled block (only present if a block was ever assembled)\n \"difficulty\" : n, (numeric) The current difficulty\n \"networkhashps\" : n, (numeric) The network hashes per second\n \"pooledtx\" : n, (numeric) The size of the mempool\n \"chain\" : \"str\", (string) current network name (main, test, regtest)\n \"warnings\" : \"str\" (string) any network and blockchain warnings\n}\n\nExamples:\n> dash-cli getmininginfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getmininginfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"31351ace967ec0786586318f0af9a5a0c14fa67084f5f16b1bde3c065b8dc0a5"} +{"command":"getnettotals","subcommand":null,"qualified":"getnettotals","signature_tail":"","is_family":false,"help_raw":"getnettotals\n\nReturns information about network traffic, including bytes in, bytes out,\nand current time.\n\nResult:\n{ (json object)\n \"totalbytesrecv\" : n, (numeric) Total bytes received\n \"totalbytessent\" : n, (numeric) Total bytes sent\n \"timemillis\" : xxx, (numeric) Current UNIX epoch time in milliseconds\n \"uploadtarget\" : { (json object)\n \"timeframe\" : n, (numeric) Length of the measuring timeframe in seconds\n \"target\" : n, (numeric) Target in bytes\n \"target_reached\" : true|false, (boolean) True if target is reached\n \"serve_historical_blocks\" : true|false, (boolean) True if serving historical blocks\n \"bytes_left_in_cycle\" : n, (numeric) Bytes left in current time cycle\n \"time_left_in_cycle\" : n (numeric) Seconds left in current time cycle\n }\n}\n\nExamples:\n> dash-cli getnettotals \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnettotals\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"6e09a9e208d5979d0279e8f1660e14141919af84fc9baee580b6ffd7db77a83e"} +{"command":"getnetworkhashps","subcommand":null,"qualified":"getnetworkhashps","signature_tail":"( nblocks height )","is_family":false,"help_raw":"getnetworkhashps ( nblocks height )\n\nReturns the estimated network hashes per second based on the last n blocks.\nPass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\nPass in [height] to estimate the network speed at the time when a certain block was found.\n\nArguments:\n1. nblocks (numeric, optional, default=120) The number of blocks, or -1 for blocks since last difficulty change.\n2. height (numeric, optional, default=-1) To estimate at the time of the given height.\n\nResult:\nn (numeric) Hashes per second estimated\n\nExamples:\n> dash-cli getnetworkhashps \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnetworkhashps\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"a295a8f4d7f1fe71c7199d79c3fc1b0ba6dcc83176f0c3f62f23286f61398d00"} +{"command":"getnetworkinfo","subcommand":null,"qualified":"getnetworkinfo","signature_tail":"","is_family":false,"help_raw":"getnetworkinfo\nReturns an object containing various state info regarding P2P networking.\n\nResult:\n{ (json object)\n \"version\" : n, (numeric) the server version\n \"buildversion\" : \"str\", (string) the server build version including RC info or commit as relevant\n \"subversion\" : \"str\", (string) the server subversion string\n \"protocolversion\" : n, (numeric) the protocol version\n \"localservices\" : \"hex\", (string) the services we offer to the network\n \"localservicesnames\" : [ (json array) the services we offer to the network, in human-readable form\n \"str\", (string) the service name\n ...\n ],\n \"localrelay\" : true|false, (boolean) true if transaction relay is requested from peers\n \"timeoffset\" : n, (numeric) the time offset\n \"connections\" : n, (numeric) the total number of connections\n \"connections_in\" : n, (numeric) the number of inbound connections\n \"connections_out\" : n, (numeric) the number of outbound connections\n \"connections_mn\" : n, (numeric) the number of verified mn connections\n \"connections_mn_in\" : n, (numeric) the number of inbound verified mn connections\n \"connections_mn_out\" : n, (numeric) the number of outbound verified mn connections\n \"networkactive\" : true|false, (boolean) whether p2p networking is enabled\n \"socketevents\" : \"str\", (string) the socket events mode, either kqueue, epoll, poll or select\n \"networks\" : [ (json array) information per network\n { (json object)\n \"name\" : \"str\", (string) network (ipv4, ipv6, onion, i2p, cjdns)\n \"limited\" : true|false, (boolean) is the network limited using -onlynet?\n \"reachable\" : true|false, (boolean) is the network reachable?\n \"proxy\" : \"str\", (string) (\"host:port\") the proxy that is used for this network, or empty if none\n \"proxy_randomize_credentials\" : true|false (boolean) Whether randomized credentials are used\n },\n ...\n ],\n \"relayfee\" : n, (numeric) minimum relay fee for transactions in DASH/kB\n \"incrementalfee\" : n, (numeric) minimum fee increment for mempool limiting in DASH/kB\n \"localaddresses\" : [ (json array) list of local addresses\n { (json object)\n \"address\" : \"str\", (string) network address\n \"port\" : n, (numeric) network port\n \"score\" : n (numeric) relative score\n },\n ...\n ],\n \"warnings\" : \"str\" (string) any network and blockchain warnings\n}\n\nExamples:\n> dash-cli getnetworkinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnetworkinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"10744942a4bbc3128daeb7ea8aade1eca0603d3f70f870ff8d07b1075a426727"} +{"command":"getnewaddress","subcommand":null,"qualified":"getnewaddress","signature_tail":"( \"label\" )","is_family":false,"help_raw":"getnewaddress ( \"label\" )\n\nReturns a new Dash address for receiving payments.\nIf 'label' is specified, it is added to the address book \nso payments received with the address will be associated with 'label'.\n\nArguments:\n1. label (string, optional, default=\"\") The label name for the address to be linked to. It can also be set to the empty string \"\" to represent the default label. The label does not need to exist, it will be created if there is no label by the given name.\n\nResult:\n\"str\" (string) The new Dash address\n\nExamples:\n> dash-cli getnewaddress \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnewaddress\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"15e93e7c43d10966e3f2f632f2ca8c48c0ffda00a87ab50dc9817e5cdab54630"} +{"command":"getnodeaddresses","subcommand":null,"qualified":"getnodeaddresses","signature_tail":"( count \"network\" )","is_family":false,"help_raw":"getnodeaddresses ( count \"network\" )\nReturn known addresses, after filtering for quality and recency.\nThese can potentially be used to find new peers in the network.\nThe total number of addresses known to the node may be higher.\nArguments:\n1. count (numeric, optional, default=1) The maximum number of addresses to return. Specify 0 to return all known addresses.\n2. network (string, optional, default=all networks) Return only addresses of the specified network. Can be one of: ipv4, ipv6, onion, i2p, cjdns.\n\nResult:\n[ (json array)\n { (json object)\n \"time\" : xxx, (numeric) The UNIX epoch time when the node was last seen\n \"services\" : n, (numeric) The services offered by the node\n \"address\" : \"str\", (string) The address of the node\n \"port\" : n, (numeric) The port number of the node\n \"network\" : \"str\" (string) The network (ipv4, ipv6, onion, i2p, cjdns) the node connected through\n },\n ...\n]\n\nExamples:\n> dash-cli getnodeaddresses 8\n> dash-cli getnodeaddresses 4 \"i2p\"\n> dash-cli -named getnodeaddresses network=onion count=12\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnodeaddresses\", \"params\": [8]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getnodeaddresses\", \"params\": [4, \"i2p\"]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"90472d1a2bb4db169743974db82a25f6bb65e908cff4acb530decc42a01e0f04"} +{"command":"getpeerinfo","subcommand":null,"qualified":"getpeerinfo","signature_tail":"","is_family":false,"help_raw":"getpeerinfo\n\nReturns data about each connected network node as a json array of objects.\n\nResult:\n[ (json array)\n { (json object)\n \"id\" : n, (numeric) Peer index\n \"addr\" : \"str\", (string) (host:port) The IP address and port of the peer\n \"addrbind\" : \"str\", (string) (ip:port) Bind address of the connection to the peer\n \"addrlocal\" : \"str\", (string) (ip:port) Local address as reported by the peer\n \"network\" : \"str\", (string) Network (ipv4, ipv6, onion, i2p, cjdns, not_publicly_routable)\n \"mapped_as\" : \"str\", (string) The AS in the BGP route to the peer used for diversifying peer selection\n \"services\" : \"hex\", (string) The services offered\n \"servicesnames\" : [ (json array) the services offered, in human-readable form\n \"str\", (string) the service name if it is recognised\n ...\n ],\n \"verified_proregtx_hash\" : \"hex\", (string, optional) Only present when the peer is a masternode and successfully authenticated via MNAUTH. In this case, this field contains the protx hash of the masternode\n \"verified_pubkey_hash\" : \"hex\", (string, optional) Only present when the peer is a masternode and successfully authenticated via MNAUTH. In this case, this field contains the hash of the masternode's operator public key\n \"relaytxes\" : true|false, (boolean) Whether peer has asked us to relay transactions to it\n \"lastsend\" : xxx, (numeric) The UNIX epoch time of the last send\n \"lastrecv\" : xxx, (numeric) The UNIX epoch time of the last receive\n \"last_transaction\" : xxx, (numeric) The UNIX epoch time of the last valid transaction received from this peer\n \"last_block\" : xxx, (numeric) The UNIX epoch time of the last block received from this peer\n \"bytessent\" : n, (numeric) The total bytes sent\n \"bytesrecv\" : n, (numeric) The total bytes received\n \"conntime\" : xxx, (numeric) The UNIX epoch time of the connection\n \"timeoffset\" : n, (numeric) The time offset in seconds\n \"pingtime\" : n, (numeric) ping time (if available)\n \"minping\" : n, (numeric) minimum observed ping time (if any at all)\n \"pingwait\" : n, (numeric) ping wait (if non-zero)\n \"version\" : n, (numeric) The peer version, such as 70001\n \"subver\" : \"str\", (string) The string version\n \"inbound\" : true|false, (boolean) Inbound (true) or Outbound (false)\n \"bip152_hb_to\" : true|false, (boolean) Whether we selected peer as (compact blocks) high-bandwidth peer\n \"bip152_hb_from\" : true|false, (boolean) Whether peer selected us as (compact blocks) high-bandwidth peer\n \"masternode\" : true|false, (boolean) Whether connection was due to masternode connection attempt\n \"banscore\" : n, (numeric) The ban score (DEPRECATED, returned only if config option -deprecatedrpc=banscore is passed)\n \"startingheight\" : n, (numeric) The starting height (block) of the peer\n \"synced_headers\" : n, (numeric) The last header we have in common with this peer\n \"synced_blocks\" : n, (numeric) The last block we have in common with this peer\n \"inflight\" : [ (json array)\n n, (numeric) The heights of blocks we're currently asking from this peer\n ...\n ],\n \"addr_relay_enabled\" : true|false, (boolean) Whether we participate in address relay with this peer\n \"addr_processed\" : n, (numeric) The total number of addresses processed, excluding those dropped due to rate limiting\n \"addr_rate_limited\" : n, (numeric) The total number of addresses dropped due to rate limiting\n \"permissions\" : [ (json array) Any special permissions that have been granted to this peer\n \"str\", (string) bloomfilter (allow requesting BIP37 filtered blocks and transactions),\n noban (do not ban for misbehavior; implies download),\n forcerelay (relay transactions that are already in the mempool; implies relay),\n relay (relay even in -blocksonly mode),\n mempool (allow requesting BIP35 mempool contents),\n download (allow getheaders during IBD, no disconnect after maxuploadtarget limit),\n addr (responses to GETADDR avoid hitting the cache and contain random records with the most up-to-date info).\n \n ...\n ],\n \"bytessent_per_msg\" : { (json object)\n \"msg\" : n, (numeric) The total bytes sent aggregated by message type\n When a message type is not listed in this json object, the bytes sent are 0.\n Only known message types can appear as keys in the object.\n ...\n },\n \"bytesrecv_per_msg\" : { (json object)\n \"msg\" : n, (numeric) The total bytes received aggregated by message type\n When a message type is not listed in this json object, the bytes received are 0.\n Only known message types can appear as keys in the object and all bytes received of unknown message types are listed under '*other*'.\n ...\n },\n \"connection_type\" : \"str\", (string) Type of connection: \n outbound-full-relay (default automatic connections),\n block-relay-only (does not relay transactions or addresses),\n inbound (initiated by the peer),\n manual (added via addnode RPC or -addnode/-connect configuration options),\n addr-fetch (short-lived automatic connection for soliciting addresses),\n feeler (short-lived automatic connection for testing addresses).\n Please note this output is unlikely to be stable in upcoming releases as we iterate to\n best capture connection behaviors.\n \"transport_protocol_type\" : \"str\", (string) Type of transport protocol: \n detecting (peer could be v1 or v2),\n v1 (plaintext transport protocol),\n v2 (BIP324 encrypted transport protocol).\n \n \"session_id\" : \"str\" (string) The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n \n },\n ...\n]\n\nExamples:\n> dash-cli getpeerinfo \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getpeerinfo\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"cefcb77410655e742063050aff62efce95580711cea28dbec6e1188d0342ba77"} +{"command":"getrawchangeaddress","subcommand":null,"qualified":"getrawchangeaddress","signature_tail":"","is_family":false,"help_raw":"getrawchangeaddress\n\nReturns a new Dash address, for receiving change.\nThis is for use with raw transactions, NOT normal use.\n\nResult:\n\"str\" (string) The address\n\nExamples:\n> dash-cli getrawchangeaddress \n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getrawchangeaddress\", \"params\": []}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"5a3c57159ab3627ced62bd0eca24425e8f1c810c6cedd102ba9c930865454376"} +{"command":"getrawmempool","subcommand":null,"qualified":"getrawmempool","signature_tail":"( verbose mempool_sequence )","is_family":false,"help_raw":"getrawmempool ( verbose mempool_sequence )\n\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n\nArguments:\n1. verbose (boolean, optional, default=false) True for a json object, false for array of transaction ids\n2. mempool_sequence (boolean, optional, default=false) If verbose=false, returns a json object with transaction list and mempool sequence number attached.\n\nResult (for verbose = false):\n[ (json array)\n \"hex\", (string) The transaction id\n ...\n]\n\nResult (for verbose = true):\n{ (json object)\n \"transactionid\" : { (json object)\n \"vsize\" : n, (numeric) virtual transaction size. This can be different from actual serialized size for high-sigop transactions.\n \"fee\" : n, (numeric, optional) transaction fee, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"modifiedfee\" : n, (numeric, optional) transaction fee with fee deltas used for mining priority, denominated in DASH (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"time\" : xxx, (numeric) local time transaction entered pool in UNIX epoch time\n \"height\" : n, (numeric) block height when transaction entered pool\n \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n \"descendantsize\" : n, (numeric) size of in-mempool descendants (including this one)\n \"descendantfees\" : n, (numeric, optional) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n \"ancestorsize\" : n, (numeric) size of in-mempool ancestors (including this one)\n \"ancestorfees\" : n, (numeric, optional) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in duffs (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)\n \"fees\" : { (json object)\n \"base\" : n, (numeric) transaction fee, denominated in DASH\n \"modified\" : n, (numeric) transaction fee with fee deltas used for mining priority, denominated in DASH\n \"ancestor\" : n, (numeric) transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in DASH\n \"descendant\" : n (numeric) transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in DASH\n },\n \"depends\" : [ (json array) unconfirmed transactions used as inputs for this transaction\n \"hex\", (string) parent transaction id\n ...\n ],\n \"spentby\" : [ (json array) unconfirmed transactions spending outputs from this transaction\n \"hex\", (string) child transaction id\n ...\n ],\n \"instantsend\" : true|false, (boolean) True if this transaction was locked via InstantSend\n \"unbroadcast\" : true|false (boolean) Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)\n },\n ...\n}\n\nResult (for verbose = false and mempool_sequence = true):\n{ (json object)\n \"txids\" : [ (json array)\n \"hex\", (string) The transaction id\n ...\n ],\n \"mempool_sequence\" : n (numeric) The mempool sequence value.\n}\n\nExamples:\n> dash-cli getrawmempool true\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getrawmempool\", \"params\": [true]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"cbe99ab3e1314e704ae8ad95d34f62df9d0f02f042a87b03d63f45f1bc16f07f"} +{"command":"getrawtransaction","subcommand":null,"qualified":"getrawtransaction","signature_tail":"\"txid\" ( verbose \"blockhash\" )","is_family":false,"help_raw":"getrawtransaction \"txid\" ( verbose \"blockhash\" )\n\nReturn the raw transaction data.\n\nBy default, this call only returns a transaction if it is in the mempool. If -txindex is enabled\nand no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.\nIf a blockhash argument is passed, it will return the transaction if\nthe specified block is available and the transaction is in that block.\n\nHint: Use gettransaction for wallet transactions.\n\nIf verbose is 'true', returns an Object with information about 'txid'.\nIf verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.\n\nArguments:\n1. txid (string, required) The transaction id\n2. verbose (boolean, optional, default=false) If false, return a string, otherwise return a json object\n3. blockhash (string, optional) The block in which to look for the transaction\n\nResult (if verbose is not set or set to false):\n\"str\" (string) The serialized, hex-encoded data for 'txid'\n\nResult (if verbose is set to true):\n{ (json object)\n \"in_active_chain\" : true|false, (boolean) Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)\n \"txid\" : \"hex\", (string) The transaction id (same as provided)\n \"size\" : n, (numeric) The serialized transaction size\n \"version\" : n, (numeric) The version\n \"type\" : n, (numeric) The type\n \"locktime\" : xxx, (numeric) The lock time\n \"vin\" : [ (json array)\n { (json object)\n \"txid\" : \"hex\", (string) The transaction id\n \"vout\" : n, (numeric) The output number\n \"scriptSig\" : { (json object) The script\n \"asm\" : \"str\", (string) asm\n \"hex\" : \"hex\" (string) hex\n },\n \"sequence\" : n (numeric) The script sequence number\n },\n ...\n ],\n \"vout\" : [ (json array)\n { (json object)\n \"value\" : n, (numeric) The value in DASH\n \"n\" : n, (numeric) index\n \"scriptPubKey\" : { (json object)\n \"asm\" : \"str\", (string) the asm\n \"hex\" : \"str\", (string) the hex\n \"reqSigs\" : n, (numeric, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Number of required signatures\n \"type\" : \"str\", (string) The type, eg 'pubkeyhash'\n \"address\" : \"str\", (string, optional) Dash address (only if a well-defined address exists)\n \"addresses\" : [ (json array, optional) (DEPRECATED, returned only if config option -deprecatedrpc=addresses is passed) Array of Dash addresses\n \"str\", (string) Dash address\n ...\n ]\n }\n },\n ...\n ],\n \"extraPayloadSize\" : n, (numeric, optional) Size of DIP2 extra payload. Only present if it's a special TX\n \"extraPayload\" : \"hex\", (string, optional) Hex-encoded DIP2 extra payload data. Only present if it's a special TX\n \"hex\" : \"hex\", (string) The serialized, hex-encoded data for 'txid'\n \"blockhash\" : \"hex\", (string) the block hash\n \"height\" : n, (numeric) The block height\n \"confirmations\" : n, (numeric) The confirmations\n \"blocktime\" : xxx, (numeric) The block time expressed in UNIX epoch time\n \"time\" : n, (numeric) Same as \"blocktime\"\n \"instantlock\" : true|false, (boolean) Current transaction lock state\n \"instantlock_internal\" : true|false, (boolean) Current internal transaction lock state\n \"chainlock\" : true|false (boolean) The state of the corresponding block ChainLock\n}\n\nExamples:\n> dash-cli getrawtransaction \"mytxid\"\n> dash-cli getrawtransaction \"mytxid\" true\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getrawtransaction\", \"params\": [\"mytxid\", true]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/\n> dash-cli getrawtransaction \"mytxid\" false \"myblockhash\"\n> dash-cli getrawtransaction \"mytxid\" true \"myblockhash\"","help_sha256":"a4c1e55b98b56ab356b4003827ef2d159a3051dbe82904aca4e30d41fc1f49b5"} +{"command":"getrawtransactionmulti","subcommand":null,"qualified":"getrawtransactionmulti","signature_tail":"{\"blockhash\":[\"txid\",...]} ( verbose )","is_family":false,"help_raw":"getrawtransactionmulti {\"blockhash\":[\"txid\",...]} ( verbose )\n\nReturns the raw transaction data for multiple transactions.\n\nThis call is an extension of getrawtransaction that supports multiple transactions.\nIt accepts a map of block hashes to a list of transaction hashes.\nA block hash of 0 indicates transactions not yet mined or in the mempool.\n\nArguments:\n1. transactions (json object, required) A JSON object with block hashes as keys and lists of transaction hashes as values (no more than 100 in total)\n {\n \"blockhash\": [ (json array) The block hash and the list of transaction ids to fetch\n \"txid\", (string) The transaction id\n ...\n ],\n }\n2. verbose (boolean, optional, default=false) If false, return a string, otherwise return a json object\n\nExamples:\n> dash-cli getrawtransactionmulti '{\"blockhash1\":[\"txid1\",\"txid2\"], \"0\":[\"txid3\"]}'\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getrawtransactionmulti\", \"params\": ['{\"blockhash1\":[\"txid1\",\"txid2\"], \"0\":[\"txid3\"]}]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"dc2324e9ff5591a48d05e2704b304adbc0fd6a51e596764c9203a2b0d74b97ac"} +{"command":"getreceivedbyaddress","subcommand":null,"qualified":"getreceivedbyaddress","signature_tail":"\"address\" ( minconf addlocked )","is_family":false,"help_raw":"getreceivedbyaddress \"address\" ( minconf addlocked )\n\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n\nArguments:\n1. address (string, required) The Dash address for transactions.\n2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n3. addlocked (boolean, optional, default=false) Whether to include transactions locked via InstantSend.\n\nResult:\nn (numeric) The total amount in DASH received at this address.\n\nExamples:\n\nThe amount from transactions with at least 1 confirmation\n> dash-cli getreceivedbyaddress \"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\"\n\nThe amount including unconfirmed transactions, zero confirmations\n> dash-cli getreceivedbyaddress \"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\" 0\n\nThe amount with at least 6 confirmations\n> dash-cli getreceivedbyaddress \"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\" 6\n\nAs a JSON-RPC call\n> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", \"method\": \"getreceivedbyaddress\", \"params\": [\"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0\", 6]}' -H 'content-type: text/plain;' http://127.0.0.1:9998/","help_sha256":"6da81a889a2a9851b5290050378be579f827d6719a557e0c1884644fec40c896"} +{"command":"getreceivedbylabel","subcommand":null,"qualified":"getreceivedbylabel","signature_tail":"\"label\" ( minconf addlocked )","is_family":false,"help_raw":"getreceivedbylabel \"label\" ( minconf addlocked )\n\nReturns the total amount received by addresses with