diff --git a/src/init/bitcoin-node.cpp b/src/init/bitcoin-node.cpp
index 84fbb55ea822..0004367739e7 100644
--- a/src/init/bitcoin-node.cpp
+++ b/src/init/bitcoin-node.cpp
@@ -8,6 +8,7 @@
 #include <interfaces/init.h>
 #include <interfaces/ipc.h>
 #include <interfaces/node.h>
+#include <interfaces/noderpc.h>
 #include <node/context.h>
 #include <util/check.h>
 
@@ -30,6 +31,7 @@ class BitcoinNodeInit : public interfaces::Init
     std::unique_ptr<interfaces::Node> makeNode() override { return interfaces::MakeNode(m_node); }
     std::unique_ptr<interfaces::Chain> makeChain() override { return interfaces::MakeChain(m_node); }
     std::unique_ptr<interfaces::Mining> makeMining() override { return interfaces::MakeMining(m_node); }
+    std::unique_ptr<interfaces::NodeRpc> makeNodeRpc() override { return interfaces::MakeNodeRpc(m_node); }
     std::unique_ptr<interfaces::Echo> makeEcho() override { return interfaces::MakeEcho(); }
     void stop() override { makeNode()->startShutdown(); }
     interfaces::Ipc* ipc() override { return m_ipc.get(); }
diff --git a/src/interfaces/init.h b/src/interfaces/init.h
index a0e534577189..1f43b2b6b253 100644
--- a/src/interfaces/init.h
+++ b/src/interfaces/init.h
@@ -9,6 +9,7 @@
 #include <interfaces/echo.h>
 #include <interfaces/mining.h>
 #include <interfaces/node.h>
+#include <interfaces/noderpc.h>
 
 #include <memory>
 
@@ -33,6 +34,7 @@ class Init
     virtual std::unique_ptr<Node> makeNode() { return nullptr; }
     virtual std::unique_ptr<Chain> makeChain() { return nullptr; }
     virtual std::unique_ptr<Mining> makeMining() { return nullptr; }
+    virtual std::unique_ptr<NodeRpc> makeNodeRpc() { return nullptr; }
     virtual std::unique_ptr<Echo> makeEcho() { return nullptr; }
     virtual void stop() {}
     virtual Ipc* ipc() { return nullptr; }
diff --git a/src/interfaces/noderpc.h b/src/interfaces/noderpc.h
new file mode 100644
index 000000000000..11579c39b4cf
--- /dev/null
+++ b/src/interfaces/noderpc.h
@@ -0,0 +1,284 @@
+// Copyright (c) 2025-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_NODERPC_H
+#define BITCOIN_INTERFACES_NODERPC_H
+
+#include <primitives/block.h>
+#include <uint256.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace node {
+struct NodeContext;
+} // namespace node
+
+namespace interfaces {
+
+struct BlockchainPruneInfo {
+    int height{0};
+    bool automatic{false};
+    uint64_t target_size{0};
+};
+
+struct BlockchainInfo {
+    std::string chain;
+    int blocks{0};
+    int headers{0};
+    std::string bestblockhash;
+    std::string bits;
+    std::string target;
+    double difficulty{0};
+    int64_t time{0};
+    int64_t mediantime{0};
+    double verificationprogress{0};
+    bool initialblockdownload{false};
+    std::string chainwork;
+    uint64_t size_on_disk{0};
+    bool pruned{false};
+    std::optional<BlockchainPruneInfo> prune;
+    std::optional<std::string> signet_challenge;
+    std::vector<std::string> warnings;
+};
+
+struct BlockHeaderInfo {
+    std::string hash;
+    int confirmations{0};
+    int height{0};
+    int version{0};
+    std::string version_hex;
+    std::string merkleroot;
+    int64_t time{0};
+    int64_t mediantime{0};
+    uint32_t nonce{0};
+    std::string bits;
+    std::string target;
+    double difficulty{0};
+    std::string chainwork;
+    int n_tx{0};
+    std::optional<std::string> previousblockhash;
+    std::optional<std::string> nextblockhash;
+};
+
+struct SmartFeeEstimate {
+    int64_t feerate{0};
+    std::vector<std::string> errors;
+    int blocks{0};
+};
+
+struct TxOutScriptPubKey {
+    std::string script_asm;
+    std::string desc;
+    std::string hex;
+    std::string type;
+    std::optional<std::string> address;
+};
+
+struct TxOutInfo {
+    std::string bestblock;
+    int confirmations{0};
+    int64_t value{0};
+    TxOutScriptPubKey script_pub_key;
+    bool coinbase{false};
+};
+
+struct TxScriptSig {
+    std::string script_asm;
+    std::string hex;
+};
+
+struct TxInput {
+    std::optional<std::string> coinbase;
+    std::optional<std::string> txid;
+    uint32_t vout{0};
+    std::optional<TxScriptSig> script_sig;
+    std::vector<std::string> txinwitness;
+    uint32_t sequence{0};
+};
+
+struct TxOutput {
+    int64_t value{0};
+    int n{0};
+    TxOutScriptPubKey script_pub_key;
+};
+
+struct TxBlockContext {
+    std::string blockhash;
+    int confirmations{0};
+    int64_t time{0};
+    int64_t blocktime{0};
+};
+
+struct TransactionDetails {
+    std::string txid;
+    std::string hash;
+    int64_t version{0};
+    int size{0};
+    int vsize{0};
+    int weight{0};
+    int64_t locktime{0};
+    std::vector<TxInput> vin;
+    std::vector<TxOutput> vout;
+    bool in_active_chain{false};
+    std::optional<TxBlockContext> block;
+};
+
+struct RawTransactionResult {
+    CTransactionRef tx;
+    std::optional<TransactionDetails> details;
+};
+
+struct TestMempoolAcceptFees {
+    int64_t base{0};
+    int64_t effective_feerate{0};
+    std::vector<std::string> effective_includes;
+};
+
+struct TestMempoolAcceptResult {
+    std::string txid;
+    std::string wtxid;
+    std::optional<std::string> package_error;
+    bool validated{false};
+    bool allowed{false};
+    std::optional<std::string> reject_reason;
+    std::optional<std::string> reject_details;
+    int64_t vsize{0};
+    std::optional<TestMempoolAcceptFees> fees;
+};
+
+struct NetworkInfoNetwork {
+    std::string name;
+    bool limited{false};
+    bool reachable{false};
+    std::string proxy;
+    bool proxy_randomize_credentials{false};
+};
+
+struct NetworkInfoLocalAddress {
+    std::string address;
+    uint16_t port{0};
+    int score{0};
+};
+
+struct NetworkInfo {
+    int version{0};
+    std::string subversion;
+    int protocolversion{0};
+    std::string localservices;
+    std::vector<std::string> localservicesnames;
+    bool localrelay{false};
+    int64_t timeoffset{0};
+    size_t connections{0};
+    size_t connections_in{0};
+    size_t connections_out{0};
+    bool networkactive{false};
+    std::vector<NetworkInfoNetwork> networks;
+    int64_t relayfee{0};
+    int64_t incrementalfee{0};
+    std::vector<NetworkInfoLocalAddress> localaddresses;
+    std::vector<std::string> warnings;
+};
+
+struct BIP9Statistics {
+    int period{0};
+    int threshold{0};
+    int elapsed{0};
+    int count{0};
+    bool possible{false};
+};
+
+struct BIP9DeploymentInfo {
+    int bit{-1};
+    int64_t start_time{0};
+    int64_t timeout{0};
+    int min_activation_height{0};
+    std::string status;
+    int since{0};
+    std::string status_next;
+    std::optional<BIP9Statistics> statistics;
+    std::string signalling;
+};
+
+struct DeploymentInfo {
+    std::string name;
+    std::string type;
+    bool active{false};
+    int height{-1};
+    std::optional<BIP9DeploymentInfo> bip9;
+};
+
+struct DeploymentsInfo {
+    std::string hash;
+    int height{-1};
+    std::vector<std::string> script_flags;
+    std::vector<DeploymentInfo> deployments;
+};
+
+class NodeRpc
+{
+public:
+    virtual ~NodeRpc() = default;
+
+    virtual BlockchainInfo getBlockchainInfo() = 0;
+
+    //! Hash of the active chain tip, hex-encoded. Mirrors getbestblockhash.
+    virtual std::string getBestBlockHash() = 0;
+
+    //! Hash of the active-chain block at the given height, hex-encoded. Throws
+    //! if the height is out of range. Mirrors getblockhash.
+    virtual std::string getBlockHash(int height) = 0;
+
+    //! Verbose header info for the given block. Throws if the block is not
+    //! found. Mirrors the verbose getblockheader.
+    virtual BlockHeaderInfo getBlockHeader(const uint256& block_hash) = 0;
+
+    //! Full block for the given hash, read from disk. Throws if the block is
+    //! not found or its data is unavailable (pruned). Mirrors getblock with
+    //! verbosity 0 (the block is serialized over the wire).
+    virtual CBlock getBlock(const uint256& block_hash) = 0;
+
+    //! Details about an unspent transaction output, or nullopt if the output is
+    //! not found (spent or never existed). When include_mempool is set, outputs
+    //! spent in the mempool are treated as unavailable. The value is in
+    //! satoshis. Mirrors gettxout.
+    virtual std::optional<TxOutInfo> getTxOut(const uint256& txid, uint32_t n, bool include_mempool) = 0;
+
+    //! Transaction for the given txid, from the mempool or a given block (no tx
+    //! index, so confirmed txs need block_hash). Throws if not found. result.tx
+    //! is the raw tx (verbosity 0); result.details is set when verbose (verbosity 1).
+    virtual RawTransactionResult getRawTransaction(const uint256& txid, bool verbose, const std::optional<uint256>& block_hash) = 0;
+
+    //! Test whether the given transactions (1..MAX_PACKAGE_COUNT, as a package
+    //! when >1) would be accepted to the mempool, without submitting them.
+    //! max_fee_rate is in sat/kvB; 0 disables the max-fee check. One result per
+    //! input tx, in order. Mirrors testmempoolaccept.
+    virtual std::vector<TestMempoolAcceptResult> testMempoolAccept(const std::vector<CTransactionRef>& txns, int64_t max_fee_rate) = 0;
+
+    //! Submit a transaction to the mempool and broadcast it (or, with
+    //! -privatebroadcast, send it only over privacy networks). max_fee_rate is
+    //! in sat/kvB (0 accepts any fee rate); max_burn_amount is in sat (outputs
+    //! provably unspendable above this are rejected). Returns the txid (hex) on
+    //! success, throws on failure. Mirrors the sendrawtransaction RPC.
+    virtual std::string sendRawTransaction(const CTransactionRef& tx, int64_t max_fee_rate, int64_t max_burn_amount) = 0;
+
+    //! Estimate the fee rate (sat/kvB) needed for confirmation within
+    //! conf_target blocks, mirroring the estimatesmartfee RPC (applies the
+    //! mempool/relay fee floor and reports the target actually used).
+    virtual SmartFeeEstimate estimateSmartFee(int conf_target, bool conservative) = 0;
+
+    virtual NetworkInfo getNetworkInfo() = 0;
+
+    virtual DeploymentsInfo getDeploymentInfo(const std::optional<uint256>& block_hash) = 0;
+};
+
+std::unique_ptr<NodeRpc> MakeNodeRpc(node::NodeContext& context);
+
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_NODERPC_H
diff --git a/src/ipc/CMakeLists.txt b/src/ipc/CMakeLists.txt
index 5378ef1924bf..970d423ba95f 100644
--- a/src/ipc/CMakeLists.txt
+++ b/src/ipc/CMakeLists.txt
@@ -14,6 +14,7 @@ target_capnp_sources(bitcoin_ipc ${CMAKE_CURRENT_SOURCE_DIR}
   capnp/echo.capnp
   capnp/init.capnp
   capnp/mining.capnp
+  capnp/noderpc.capnp
 )
 
 target_link_libraries(bitcoin_ipc
diff --git a/src/ipc/capnp/init-types.h b/src/ipc/capnp/init-types.h
index 2abd7b211e17..ab804c32d9aa 100644
--- a/src/ipc/capnp/init-types.h
+++ b/src/ipc/capnp/init-types.h
@@ -7,5 +7,6 @@
 
 #include <ipc/capnp/echo.capnp.proxy-types.h>
 #include <ipc/capnp/mining.capnp.proxy-types.h>
+#include <ipc/capnp/noderpc.capnp.proxy-types.h>
 
 #endif // BITCOIN_IPC_CAPNP_INIT_TYPES_H
diff --git a/src/ipc/capnp/init.capnp b/src/ipc/capnp/init.capnp
index 094305b44341..6e419b931e30 100644
--- a/src/ipc/capnp/init.capnp
+++ b/src/ipc/capnp/init.capnp
@@ -11,14 +11,17 @@ using Proxy = import "/mp/proxy.capnp";
 $Proxy.include("interfaces/echo.h");
 $Proxy.include("interfaces/init.h");
 $Proxy.include("interfaces/mining.h");
+$Proxy.include("interfaces/noderpc.h");
 $Proxy.includeTypes("ipc/capnp/init-types.h");
 
 using Echo = import "echo.capnp";
 using Mining = import "mining.capnp";
+using NodeRpc = import "noderpc.capnp";
 
 interface Init $Proxy.wrap("interfaces::Init") {
     construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
     makeEcho @1 (context :Proxy.Context) -> (result :Echo.Echo);
     makeMining @2 (context :Proxy.Context) -> (result :Mining.Mining);
     stop @3 (context :Proxy.Context) -> ();
+    makeNodeRpc @4 (context :Proxy.Context) -> (result :NodeRpc.NodeRpc);
 }
diff --git a/src/ipc/capnp/noderpc-types.h b/src/ipc/capnp/noderpc-types.h
new file mode 100644
index 000000000000..650bb7d41eb2
--- /dev/null
+++ b/src/ipc/capnp/noderpc-types.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2025-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_CAPNP_NODERPC_TYPES_H
+#define BITCOIN_IPC_CAPNP_NODERPC_TYPES_H
+
+#include <interfaces/noderpc.h>
+#include <ipc/capnp/common-types.h>
+
+#include <mp/proxy-types.h>
+#include <mp/type-context.h>
+#include <mp/type-decay.h>
+#include <mp/type-number.h>
+#include <mp/type-optional.h>
+#include <mp/type-string.h>
+#include <mp/type-struct.h>
+#include <mp/type-vector.h>
+
+#include <ipc/capnp/noderpc.capnp.proxy.h>
+
+#endif // BITCOIN_IPC_CAPNP_NODERPC_TYPES_H
diff --git a/src/ipc/capnp/noderpc.capnp b/src/ipc/capnp/noderpc.capnp
new file mode 100644
index 000000000000..60f9e163211d
--- /dev/null
+++ b/src/ipc/capnp/noderpc.capnp
@@ -0,0 +1,228 @@
+# Copyright (c) 2025-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+@0xb1a2c3d4e5f60718;
+
+using Cxx = import "/capnp/c++.capnp";
+$Cxx.namespace("ipc::capnp::messages");
+
+using Proxy = import "/mp/proxy.capnp";
+$Proxy.include("interfaces/noderpc.h");
+$Proxy.includeTypes("ipc/capnp/noderpc-types.h");
+
+interface NodeRpc $Proxy.wrap("interfaces::NodeRpc") {
+    destroy @0 (context :Proxy.Context) -> ();
+    getNetworkInfo @1 (context :Proxy.Context) -> (result :NetworkInfo);
+    getDeploymentInfo @2 (context :Proxy.Context, blockHash :Data) -> (result :DeploymentsInfo);
+    getBlockchainInfo @3 (context :Proxy.Context) -> (result :BlockchainInfo);
+    estimateSmartFee @4 (context :Proxy.Context, confTarget :Int32, conservative :Bool) -> (result :SmartFeeEstimate);
+    getBestBlockHash @5 (context :Proxy.Context) -> (result :Text);
+    getBlockHash @6 (context :Proxy.Context, height :Int32) -> (result :Text);
+    getBlockHeader @7 (context :Proxy.Context, blockHash :Data) -> (result :BlockHeaderInfo);
+    getBlock @8 (context :Proxy.Context, blockHash :Data) -> (result :Data);
+    getTxOut @9 (context :Proxy.Context, txid :Data, n :UInt32, includeMempool :Bool) -> (result :TxOutInfo);
+    getRawTransaction @10 (context :Proxy.Context, txid :Data, verbose :Bool, blockHash :Data) -> (result :RawTransactionResult);
+    testMempoolAccept @11 (context :Proxy.Context, txns :List(Data), maxFeeRate :Int64) -> (result :List(TestMempoolAcceptResult));
+    sendRawTransaction @12 (context :Proxy.Context, tx :Data, maxFeeRate :Int64, maxBurnAmount :Int64) -> (result :Text);
+}
+
+struct TestMempoolAcceptFees $Proxy.wrap("interfaces::TestMempoolAcceptFees") {
+    base @0 :Int64;
+    effectiveFeerate @1 :Int64 $Proxy.name("effective_feerate");
+    effectiveIncludes @2 :List(Text) $Proxy.name("effective_includes");
+}
+
+struct TestMempoolAcceptResult $Proxy.wrap("interfaces::TestMempoolAcceptResult") {
+    txid @0 :Text;
+    wtxid @1 :Text;
+    packageError @2 :Text $Proxy.name("package_error");
+    validated @3 :Bool;
+    allowed @4 :Bool;
+    rejectReason @5 :Text $Proxy.name("reject_reason");
+    rejectDetails @6 :Text $Proxy.name("reject_details");
+    vsize @7 :Int64;
+    fees @8 :TestMempoolAcceptFees;
+}
+
+struct TxScriptSig $Proxy.wrap("interfaces::TxScriptSig") {
+    scriptAsm @0 :Text $Proxy.name("script_asm");
+    hex @1 :Text;
+}
+
+struct TxInput $Proxy.wrap("interfaces::TxInput") {
+    coinbase @0 :Text;
+    txid @1 :Text;
+    vout @2 :UInt32;
+    scriptSig @3 :TxScriptSig $Proxy.name("script_sig");
+    txinwitness @4 :List(Text);
+    sequence @5 :UInt32;
+}
+
+struct TxOutput $Proxy.wrap("interfaces::TxOutput") {
+    value @0 :Int64;
+    n @1 :Int32;
+    scriptPubKey @2 :TxOutScriptPubKey $Proxy.name("script_pub_key");
+}
+
+struct TxBlockContext $Proxy.wrap("interfaces::TxBlockContext") {
+    blockhash @0 :Text;
+    confirmations @1 :Int32;
+    time @2 :Int64;
+    blocktime @3 :Int64;
+}
+
+struct TransactionDetails $Proxy.wrap("interfaces::TransactionDetails") {
+    txid @0 :Text;
+    hash @1 :Text;
+    version @2 :Int64;
+    size @3 :Int32;
+    vsize @4 :Int32;
+    weight @5 :Int32;
+    locktime @6 :Int64;
+    vin @7 :List(TxInput);
+    vout @8 :List(TxOutput);
+    inActiveChain @9 :Bool $Proxy.name("in_active_chain");
+    block @10 :TxBlockContext;
+}
+
+struct RawTransactionResult $Proxy.wrap("interfaces::RawTransactionResult") {
+    tx @0 :Data;
+    details @1 :TransactionDetails;
+}
+
+struct TxOutScriptPubKey $Proxy.wrap("interfaces::TxOutScriptPubKey") {
+    scriptAsm @0 :Text $Proxy.name("script_asm");
+    desc @1 :Text;
+    hex @2 :Text;
+    type @3 :Text;
+    address @4 :Text;
+}
+
+struct TxOutInfo $Proxy.wrap("interfaces::TxOutInfo") {
+    bestblock @0 :Text;
+    confirmations @1 :Int32;
+    value @2 :Int64;
+    scriptPubKey @3 :TxOutScriptPubKey $Proxy.name("script_pub_key");
+    coinbase @4 :Bool;
+}
+
+struct SmartFeeEstimate $Proxy.wrap("interfaces::SmartFeeEstimate") {
+    feerate @0 :Int64;
+    errors @1 :List(Text);
+    blocks @2 :Int32;
+}
+
+struct BlockHeaderInfo $Proxy.wrap("interfaces::BlockHeaderInfo") {
+    hash @0 :Text;
+    confirmations @1 :Int32;
+    height @2 :Int32;
+    version @3 :Int32;
+    versionHex @4 :Text $Proxy.name("version_hex");
+    merkleroot @5 :Text;
+    time @6 :Int64;
+    mediantime @7 :Int64;
+    nonce @8 :UInt32;
+    bits @9 :Text;
+    target @10 :Text;
+    difficulty @11 :Float64;
+    chainwork @12 :Text;
+    nTx @13 :Int32 $Proxy.name("n_tx");
+    previousblockhash @14 :Text;
+    nextblockhash @15 :Text;
+}
+
+struct BlockchainPruneInfo $Proxy.wrap("interfaces::BlockchainPruneInfo") {
+    height @0 :Int32;
+    automatic @1 :Bool;
+    targetSize @2 :UInt64 $Proxy.name("target_size");
+}
+
+struct BlockchainInfo $Proxy.wrap("interfaces::BlockchainInfo") {
+    chain @0 :Text;
+    blocks @1 :Int32;
+    headers @2 :Int32;
+    bestblockhash @3 :Text;
+    bits @4 :Text;
+    target @5 :Text;
+    difficulty @6 :Float64;
+    time @7 :Int64;
+    mediantime @8 :Int64;
+    verificationprogress @9 :Float64;
+    initialblockdownload @10 :Bool;
+    chainwork @11 :Text;
+    sizeOnDisk @12 :UInt64 $Proxy.name("size_on_disk");
+    pruned @13 :Bool;
+    prune @14 :BlockchainPruneInfo;
+    signetChallenge @15 :Text $Proxy.name("signet_challenge");
+    warnings @16 :List(Text);
+}
+
+struct NetworkInfoNetwork $Proxy.wrap("interfaces::NetworkInfoNetwork") {
+    name @0 :Text;
+    limited @1 :Bool;
+    reachable @2 :Bool;
+    proxy @3 :Text;
+    proxyRandomizeCredentials @4 :Bool $Proxy.name("proxy_randomize_credentials");
+}
+
+struct NetworkInfoLocalAddress $Proxy.wrap("interfaces::NetworkInfoLocalAddress") {
+    address @0 :Text;
+    port @1 :UInt16;
+    score @2 :Int32;
+}
+
+struct NetworkInfo $Proxy.wrap("interfaces::NetworkInfo") {
+    version @0 :Int32;
+    subversion @1 :Text;
+    protocolversion @2 :Int32;
+    localservices @3 :Text;
+    localservicesnames @4 :List(Text);
+    localrelay @5 :Bool;
+    timeoffset @6 :Int64;
+    connections @7 :UInt64;
+    connectionsIn @8 :UInt64 $Proxy.name("connections_in");
+    connectionsOut @9 :UInt64 $Proxy.name("connections_out");
+    networkactive @10 :Bool;
+    networks @11 :List(NetworkInfoNetwork);
+    relayfee @12 :Int64;
+    incrementalfee @13 :Int64;
+    localaddresses @14 :List(NetworkInfoLocalAddress);
+    warnings @15 :List(Text);
+}
+
+struct BIP9Statistics $Proxy.wrap("interfaces::BIP9Statistics") {
+    period @0 :Int32;
+    threshold @1 :Int32;
+    elapsed @2 :Int32;
+    count @3 :Int32;
+    possible @4 :Bool;
+}
+
+struct BIP9DeploymentInfo $Proxy.wrap("interfaces::BIP9DeploymentInfo") {
+    bit @0 :Int32;
+    startTime @1 :Int64 $Proxy.name("start_time");
+    timeout @2 :Int64;
+    minActivationHeight @3 :Int32 $Proxy.name("min_activation_height");
+    status @4 :Text;
+    since @5 :Int32;
+    statusNext @6 :Text $Proxy.name("status_next");
+    statistics @7 :BIP9Statistics;
+    signalling @8 :Text;
+}
+
+struct DeploymentInfo $Proxy.wrap("interfaces::DeploymentInfo") {
+    name @0 :Text;
+    type @1 :Text;
+    active @2 :Bool;
+    height @3 :Int32;
+    bip9 @4 :BIP9DeploymentInfo;
+}
+
+struct DeploymentsInfo $Proxy.wrap("interfaces::DeploymentsInfo") {
+    hash @0 :Text;
+    height @1 :Int32;
+    scriptFlags @2 :List(Text) $Proxy.name("script_flags");
+    deployments @3 :List(DeploymentInfo);
+}
+
diff --git a/src/ipc/libmultiprocess/include/mp/type-number.h b/src/ipc/libmultiprocess/include/mp/type-number.h
index 5c997f54bc8a..ddff5cdd467d 100644
--- a/src/ipc/libmultiprocess/include/mp/type-number.h
+++ b/src/ipc/libmultiprocess/include/mp/type-number.h
@@ -82,7 +82,7 @@ decltype(auto) CustomReadField(TypeList<LocalType>,
     InvokeContext& invoke_context,
     Input&& input,
     ReadDest&& read_dest,
-    typename std::enable_if<std::is_floating_point<LocalType>::value>::type* enable = 0)
+    typename std::enable_if<std::is_floating_point<LocalType>::value>::type* enable = nullptr)
 {
     auto value = input.get();
     static_assert(std::is_same<LocalType, decltype(value)>::value, "floating point type mismatch");
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 50b70fafcb0f..07ae1d8ea5ae 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -2,28 +2,38 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <arith_uint256.h>
 #include <banman.h>
 #include <block_validation.h>
 #include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <chainstate.h>
+#include <clientversion.h>
 #include <coins.h>
 #include <common/args.h>
+#include <common/messages.h>
 #include <common/settings.h>
 #include <consensus/amount.h>
+#include <consensus/consensus.h>
 #include <consensus/merkle.h>
+#include <consensus/params.h>
 #include <consensus/validation.h>
+#include <core_io.h>
+#include <crypto/hex_base.h>
+#include <deploymentinfo.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <interfaces/mining.h>
 #include <interfaces/node.h>
+#include <interfaces/noderpc.h>
 #include <interfaces/types.h>
 #include <kernel/context.h>
 #include <key.h>
 #include <logging.h>
 #include <mapport.h>
+#include <mempool_validation.h>
 #include <net.h>
 #include <net_processing.h>
 #include <net_types.h>
@@ -38,19 +48,27 @@
 #include <node/mini_miner.h>
 #include <node/mining_args.h>
 #include <node/mining_types.h>
+#include <node/protocol_version.h>
 #include <node/transaction.h>
 #include <node/types.h>
 #include <node/warnings.h>
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
+#include <policy/packages.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
+#include <pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <protocol.h>
+#include <script/interpreter.h>
+#include <script/script.h>
 #include <sync.h>
+#include <tinyformat.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <univalue.h>
+#include <util/chaintype.h>
 #include <util/check.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
@@ -58,7 +76,10 @@
 #include <util/time.h>
 #include <util/translation.h>
 #include <validationinterface.h>
+#include <versionbits.h>
 
+#include <algorithm>
+#include <array>
 #include <atomic>
 #include <condition_variable>
 #include <cstdint>
@@ -67,20 +88,44 @@
 #include <map>
 #include <memory>
 #include <optional>
+#include <span>
+#include <stdexcept>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
+using interfaces::BIP9DeploymentInfo;
+using interfaces::BIP9Statistics;
+using interfaces::BlockchainInfo;
+using interfaces::BlockchainPruneInfo;
+using interfaces::BlockHeaderInfo;
 using interfaces::BlockRef;
 using interfaces::BlockTemplate;
 using interfaces::BlockTip;
 using interfaces::Chain;
+using interfaces::DeploymentInfo;
+using interfaces::DeploymentsInfo;
 using interfaces::FoundBlock;
 using interfaces::Handler;
 using interfaces::MakeSignalHandler;
 using interfaces::Mining;
+using interfaces::NetworkInfo;
+using interfaces::NetworkInfoLocalAddress;
+using interfaces::NetworkInfoNetwork;
 using interfaces::Node;
+using interfaces::NodeRpc;
+using interfaces::RawTransactionResult;
+using interfaces::SmartFeeEstimate;
+using interfaces::TestMempoolAcceptFees;
+using interfaces::TestMempoolAcceptResult;
+using interfaces::TransactionDetails;
+using interfaces::TxBlockContext;
+using interfaces::TxInput;
+using interfaces::TxOutInfo;
+using interfaces::TxOutput;
+using interfaces::TxOutScriptPubKey;
+using interfaces::TxScriptSig;
 using node::BlockAssembler;
 using node::BlockCreateOptions;
 using node::BlockWaitOptions;
@@ -388,7 +433,9 @@ bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<Rec
     if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
     if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
     if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
-    if (block.m_locator) { *block.m_locator = GetLocator(index); }
+    if (block.m_locator) {
+        *block.m_locator = GetLocator(index);
+    }
     if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
     if (block.m_data) {
         REVERSE_LOCK(lock, cs_main);
@@ -565,9 +612,9 @@ class ChainImpl : public Chain
         return m_node.mempool->HasDescendants(txid);
     }
     bool broadcastTransaction(const CTransactionRef& tx,
-        const CAmount& max_tx_fee,
-        TxBroadcast broadcast_method,
-        std::string& err_string) override
+                              const CAmount& max_tx_fee,
+                              TxBroadcast broadcast_method,
+                              std::string& err_string) override
     {
         const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, broadcast_method, /*wait_callback=*/false);
         // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
@@ -881,7 +928,8 @@ class MinerImpl : public Mining
                                                        chainman().ActiveChainstate(),
                                                        m_node.mempool.get(),
                                                        create_options,
-                                                   }.CreateNewBlock(),
+                                                   }
+                                                       .CreateNewBlock(),
                                                    m_node);
     }
 
@@ -907,12 +955,622 @@ class MinerImpl : public Mining
     const NodeContext& m_node;
 };
 
+// Difficulty as a multiple of the minimum difficulty, mirroring the old
+// rpc/blockchain.cpp helper.
+double GetDifficulty(const CBlockIndex& blockindex)
+{
+    int nShift = (blockindex.nBits >> 24) & 0xff;
+    double dDiff = (double)0x0000ffff / (double)(blockindex.nBits & 0x00ffffff);
+    while (nShift < 29) {
+        dDiff *= 256.0;
+        nShift++;
+    }
+    while (nShift > 29) {
+        dDiff /= 256.0;
+        nShift--;
+    }
+    return dDiff;
+}
+
+// Number of confirmations for a block (and its successor on the active chain),
+// mirroring the old rpc/blockchain.cpp helper.
+int ComputeNextBlockAndDepth(const CBlockIndex& tip, const CBlockIndex& blockindex, const CBlockIndex*& next)
+{
+    next = tip.GetAncestor(blockindex.nHeight + 1);
+    if (next && next->pprev == &blockindex) {
+        return tip.nHeight - blockindex.nHeight + 1;
+    }
+    next = nullptr;
+    return &blockindex == &tip ? 1 : -1;
+}
+
+// Difficulty target for a block, mirroring the old rpc/util.cpp GetTarget.
+uint256 GetTarget(const CBlockIndex& blockindex, const uint256 pow_limit)
+{
+    arith_uint256 target{*CHECK_NONFATAL(DeriveTarget(blockindex.nBits, pow_limit))};
+    return ArithToUint256(target);
+}
+
+// Height of the last pruned block, mirroring the old rpc/blockchain.cpp helper.
+std::optional<int> GetPruneHeight(const BlockManager& blockman, const CChain& chain) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+{
+    AssertLockHeld(::cs_main);
+
+    // Search for the last block missing block data or undo data. Don't let the
+    // search consider the genesis block, because the genesis block does not
+    // have undo data, but should not be considered pruned.
+    const CBlockIndex* first_block{chain[1]};
+    const CBlockIndex* chain_tip{chain.Tip()};
+
+    // If there are no blocks after the genesis block, or no blocks at all, nothing is pruned.
+    if (!first_block || !chain_tip) return std::nullopt;
+
+    // If the chain tip is pruned, everything is pruned.
+    if ((chain_tip->nStatus & BLOCK_HAVE_MASK) != BLOCK_HAVE_MASK) return chain_tip->nHeight;
+
+    const auto& first_unpruned{blockman.GetFirstBlock(*chain_tip, /*status_mask=*/BLOCK_HAVE_MASK, first_block)};
+    if (&first_unpruned == first_block) {
+        // All blocks between first_block and chain_tip have data, so nothing is pruned.
+        return std::nullopt;
+    }
+
+    // Block before the first unpruned block is the last pruned block.
+    return CHECK_NONFATAL(first_unpruned.pprev)->nHeight;
+}
+
+TxOutScriptPubKey BuildScriptPubKey(const CScript& script)
+{
+    TxOutScriptPubKey spk;
+    UniValue o(UniValue::VOBJ);
+    ScriptToUniv(script, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
+    spk.script_asm = o["asm"].get_str();
+    spk.desc = o["desc"].get_str();
+    spk.hex = o["hex"].get_str();
+    spk.type = o["type"].get_str();
+    if (o.exists("address")) spk.address = o["address"].get_str();
+    return spk;
+}
+
+// Mirrors getrawtransaction verbosity 1 (TxToUniv at SHOW_DETAILS, no undo data,
+// plus the block context from TxToJSON). in_active_chain is meaningful only when
+// the caller supplied a block hash.
+TransactionDetails BuildTransactionDetails(const CTransaction& tx, const uint256& hash_block, bool in_active_chain, ChainstateManager& chainman) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+{
+    TransactionDetails d;
+    d.txid = tx.GetHash().GetHex();
+    d.hash = tx.GetWitnessHash().GetHex();
+    d.version = tx.version;
+    d.size = static_cast<int>(tx.ComputeTotalSize());
+    const int32_t weight = GetTransactionWeight(tx);
+    d.weight = weight;
+    d.vsize = (weight + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
+    d.locktime = tx.nLockTime;
+
+    for (const auto& txin : tx.vin) {
+        TxInput in;
+        if (tx.IsCoinBase()) {
+            in.coinbase = HexStr(txin.scriptSig);
+        } else {
+            in.txid = txin.prevout.hash.GetHex();
+            in.vout = txin.prevout.n;
+            TxScriptSig ss;
+            ss.script_asm = ScriptToAsmStr(txin.scriptSig, /*fAttemptSighashDecode=*/true);
+            ss.hex = HexStr(txin.scriptSig);
+            in.script_sig = std::move(ss);
+        }
+        if (!txin.scriptWitness.IsNull()) {
+            for (const auto& item : txin.scriptWitness.stack) {
+                in.txinwitness.push_back(HexStr(item));
+            }
+        }
+        in.sequence = txin.nSequence;
+        d.vin.push_back(std::move(in));
+    }
+
+    for (unsigned int i = 0; i < tx.vout.size(); ++i) {
+        const CTxOut& txout = tx.vout[i];
+        TxOutput out;
+        out.value = txout.nValue;
+        out.n = static_cast<int>(i);
+        out.script_pub_key = BuildScriptPubKey(txout.scriptPubKey);
+        d.vout.push_back(std::move(out));
+    }
+
+    d.in_active_chain = in_active_chain;
+
+    if (!hash_block.IsNull()) {
+        TxBlockContext ctx;
+        ctx.blockhash = hash_block.GetHex();
+        const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash_block);
+        if (pindex && chainman.ActiveChain().Contains(*pindex)) {
+            ctx.confirmations = 1 + chainman.ActiveChain().Height() - pindex->nHeight;
+            ctx.time = pindex->GetBlockTime();
+            ctx.blocktime = pindex->GetBlockTime();
+        }
+        d.block = std::move(ctx);
+    }
+
+    return d;
+}
+
+class NodeRpcImpl : public NodeRpc
+{
+public:
+    explicit NodeRpcImpl(NodeContext& node) : m_node(node) {}
+    BlockchainInfo getBlockchainInfo() override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        LOCK(::cs_main);
+        Chainstate& active_chainstate = chainman.ActiveChainstate();
+        const CBlockIndex& tip{*CHECK_NONFATAL(active_chainstate.m_chain.Tip())};
+
+        BlockchainInfo info;
+        info.chain = chainman.GetParams().GetChainTypeString();
+        info.blocks = tip.nHeight;
+        info.headers = chainman.m_best_header ? chainman.m_best_header->nHeight : -1;
+        info.bestblockhash = tip.GetBlockHash().GetHex();
+        info.bits = strprintf("%08x", tip.nBits);
+        info.target = GetTarget(tip, chainman.GetConsensus().powLimit).GetHex();
+        info.difficulty = GetDifficulty(tip);
+        info.time = tip.GetBlockTime();
+        info.mediantime = tip.GetMedianTimePast();
+        info.verificationprogress = chainman.GuessVerificationProgress(&tip);
+        info.initialblockdownload = chainman.IsInitialBlockDownload();
+        info.chainwork = tip.nChainWork.GetHex();
+        info.size_on_disk = chainman.m_blockman.CalculateCurrentUsage();
+        info.pruned = chainman.m_blockman.IsPruneMode();
+        if (info.pruned) {
+            BlockchainPruneInfo& prune = info.prune.emplace();
+            const auto prune_height{GetPruneHeight(chainman.m_blockman, active_chainstate.m_chain)};
+            prune.height = prune_height ? prune_height.value() + 1 : 0;
+            prune.automatic = chainman.m_blockman.GetPruneTarget() != BlockManager::PRUNE_TARGET_MANUAL;
+            if (prune.automatic) {
+                prune.target_size = chainman.m_blockman.GetPruneTarget();
+            }
+        }
+        if (chainman.GetParams().GetChainType() == ChainType::SIGNET) {
+            info.signet_challenge = HexStr(chainman.GetParams().GetConsensus().signet_challenge);
+        }
+        if (m_node.warnings) {
+            for (const auto& warning : m_node.warnings->GetMessages()) {
+                info.warnings.push_back(warning.original);
+            }
+        }
+        return info;
+    }
+    std::string getBestBlockHash() override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        LOCK(::cs_main);
+        return chainman.ActiveChain().Tip()->GetBlockHash().GetHex();
+    }
+    std::string getBlockHash(int height) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        LOCK(::cs_main);
+        const CChain& active_chain = chainman.ActiveChain();
+        if (height < 0 || height > active_chain.Height()) {
+            throw std::runtime_error("Block height out of range");
+        }
+        return active_chain[height]->GetBlockHash().GetHex();
+    }
+    BlockHeaderInfo getBlockHeader(const uint256& block_hash) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        const CBlockIndex* pblockindex;
+        const CBlockIndex* tip;
+        {
+            LOCK(::cs_main);
+            pblockindex = chainman.m_blockman.LookupBlockIndex(block_hash);
+            tip = chainman.ActiveChain().Tip();
+        }
+        if (!pblockindex) {
+            throw std::runtime_error("Block not found");
+        }
+
+        BlockHeaderInfo info;
+        info.hash = pblockindex->GetBlockHash().GetHex();
+        const CBlockIndex* pnext;
+        info.confirmations = ComputeNextBlockAndDepth(*Assert(tip), *pblockindex, pnext);
+        info.height = pblockindex->nHeight;
+        info.version = pblockindex->nVersion;
+        info.version_hex = strprintf("%08x", pblockindex->nVersion);
+        info.merkleroot = pblockindex->hashMerkleRoot.GetHex();
+        info.time = pblockindex->nTime;
+        info.mediantime = pblockindex->GetMedianTimePast();
+        info.nonce = pblockindex->nNonce;
+        info.bits = strprintf("%08x", pblockindex->nBits);
+        info.target = GetTarget(*pblockindex, chainman.GetConsensus().powLimit).GetHex();
+        info.difficulty = GetDifficulty(*pblockindex);
+        info.chainwork = pblockindex->nChainWork.GetHex();
+        info.n_tx = pblockindex->nTx;
+        if (pblockindex->pprev) info.previousblockhash = pblockindex->pprev->GetBlockHash().GetHex();
+        if (pnext) info.nextblockhash = pnext->GetBlockHash().GetHex();
+        return info;
+    }
+    CBlock getBlock(const uint256& block_hash) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        const CBlockIndex* pblockindex;
+        {
+            LOCK(::cs_main);
+            pblockindex = chainman.m_blockman.LookupBlockIndex(block_hash);
+        }
+        if (!pblockindex) {
+            throw std::runtime_error("Block not found");
+        }
+
+        CBlock block;
+        if (!chainman.m_blockman.ReadBlock(block, *pblockindex)) {
+            // Block data may be unavailable if the block was pruned.
+            throw std::runtime_error("Block not available (pruned data?)");
+        }
+        return block;
+    }
+    std::optional<TxOutInfo> getTxOut(const uint256& txid, uint32_t n, bool include_mempool) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        LOCK(::cs_main);
+
+        const COutPoint out{Txid::FromUint256(txid), n};
+        Chainstate& active_chainstate = chainman.ActiveChainstate();
+        CCoinsViewCache* coins_view = &active_chainstate.CoinsTip();
+
+        std::optional<Coin> coin;
+        if (include_mempool) {
+            CTxMemPool& mempool = *Assert(m_node.mempool);
+            LOCK(mempool.cs);
+            CCoinsViewMemPool view(coins_view, mempool);
+            if (!mempool.isSpent(out)) coin = view.GetCoin(out);
+        } else {
+            coin = coins_view->GetCoin(out);
+        }
+        if (!coin) return std::nullopt;
+
+        TxOutInfo info;
+        const CBlockIndex* pindex = active_chainstate.m_blockman.LookupBlockIndex(coins_view->GetBestBlock());
+        info.bestblock = pindex->GetBlockHash().GetHex();
+        if (coin->nHeight == MEMPOOL_HEIGHT) {
+            info.confirmations = 0;
+        } else {
+            info.confirmations = pindex->nHeight - coin->nHeight + 1;
+        }
+        info.value = coin->out.nValue;
+        info.script_pub_key = BuildScriptPubKey(coin->out.scriptPubKey);
+        info.coinbase = coin->IsCoinBase();
+        return info;
+    }
+    RawTransactionResult getRawTransaction(const uint256& txid, bool verbose, const std::optional<uint256>& block_hash) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+
+        if (txid == chainman.GetParams().GenesisBlock().hashMerkleRoot) {
+            // Special exception for the genesis block coinbase transaction.
+            throw std::runtime_error("The genesis block coinbase is not considered an ordinary transaction and cannot be retrieved");
+        }
+
+        const CBlockIndex* blockindex = nullptr;
+        if (block_hash) {
+            LOCK(::cs_main);
+            blockindex = chainman.m_blockman.LookupBlockIndex(*block_hash);
+            if (!blockindex) {
+                throw std::runtime_error("Block hash not found");
+            }
+        }
+
+        uint256 hash_block;
+        const CTransactionRef tx = GetTransaction(blockindex, m_node.mempool.get(), Txid::FromUint256(txid), chainman.m_blockman, hash_block);
+        if (!tx) {
+            if (blockindex) {
+                const bool block_has_data = WITH_LOCK(::cs_main, return blockindex->nStatus & BLOCK_HAVE_DATA);
+                if (!block_has_data) {
+                    throw std::runtime_error("Block not available");
+                }
+                throw std::runtime_error("No such transaction found in the provided block");
+            }
+            // No tx index: a confirmed tx can only be found via its block hash.
+            throw std::runtime_error("No such mempool transaction. Provide a block hash to look it up in a specific block");
+        }
+
+        RawTransactionResult result;
+        result.tx = tx;
+        if (verbose) {
+            LOCK(::cs_main);
+            const bool in_active_chain = blockindex && chainman.ActiveChain().Contains(*blockindex);
+            result.details = BuildTransactionDetails(*tx, hash_block, in_active_chain, chainman);
+        }
+        return result;
+    }
+    std::vector<TestMempoolAcceptResult> testMempoolAccept(const std::vector<CTransactionRef>& txns, int64_t max_fee_rate) override
+    {
+        if (txns.size() < 1 || txns.size() > MAX_PACKAGE_COUNT) {
+            throw std::runtime_error(strprintf("Array must contain between 1 and %u transactions.", MAX_PACKAGE_COUNT));
+        }
+
+        CTxMemPool& mempool = *Assert(m_node.mempool);
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        Chainstate& chainstate = chainman.ActiveChainstate();
+
+        // Matches ParseFeeRate in the RPC: reject fee rates >= 1 BTC/kvB. 0 means "any".
+        if (max_fee_rate >= COIN) {
+            throw std::runtime_error("Fee rates larger than or equal to 1BTC/kvB are not accepted");
+        }
+        const CFeeRate max_raw_tx_fee_rate{max_fee_rate};
+
+        const PackageMempoolAcceptResult package_result = [&] {
+            LOCK(::cs_main);
+            if (txns.size() > 1) return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/true, /*client_maxfeerate=*/{});
+            return PackageMempoolAcceptResult(txns[0]->GetWitnessHash(), ProcessTransaction(chainman, txns[0], /*test_accept=*/true));
+        }();
+
+        std::vector<TestMempoolAcceptResult> results;
+        results.reserve(txns.size());
+
+        // We will check transaction fees while we iterate through txns in order. If any transaction fee
+        // exceeds maxfeerate, we will leave the rest of the validation results blank, because it
+        // doesn't make sense to return a validation result for a transaction if its ancestor(s) would
+        // not be submitted.
+        bool exit_early{false};
+        for (const auto& tx : txns) {
+            TestMempoolAcceptResult r;
+            r.txid = tx->GetHash().GetHex();
+            r.wtxid = tx->GetWitnessHash().GetHex();
+            if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY) {
+                r.package_error = package_result.m_state.ToString();
+            }
+            auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
+            if (exit_early || it == package_result.m_tx_results.end()) {
+                // Validation unfinished. Just return the txid and wtxid.
+                results.push_back(std::move(r));
+                continue;
+            }
+            const auto& tx_result = it->second;
+            // Package testmempoolaccept doesn't allow transactions to already be in the mempool.
+            CHECK_NONFATAL(tx_result.m_result_type != MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
+            r.validated = true;
+            if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
+                const CAmount fee = tx_result.m_base_fees.value();
+                const int64_t virtual_size = tx_result.m_vsize.value();
+                const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
+                if (max_raw_tx_fee && fee > max_raw_tx_fee) {
+                    r.allowed = false;
+                    r.reject_reason = "max-fee-exceeded";
+                    exit_early = true;
+                } else {
+                    // Only return the fee and vsize if the tx would pass ATMP.
+                    r.allowed = true;
+                    r.vsize = virtual_size;
+                    TestMempoolAcceptFees fees;
+                    fees.base = fee;
+                    fees.effective_feerate = tx_result.m_effective_feerate.value().GetFeePerK();
+                    for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
+                        fees.effective_includes.push_back(wtxid.ToString());
+                    }
+                    r.fees = std::move(fees);
+                }
+            } else {
+                r.allowed = false;
+                const TxValidationState& state = tx_result.m_state;
+                if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
+                    r.reject_reason = "missing-inputs";
+                } else {
+                    r.reject_reason = state.GetRejectReason();
+                    r.reject_details = state.ToString();
+                }
+            }
+            results.push_back(std::move(r));
+        }
+        return results;
+    }
+    std::string sendRawTransaction(const CTransactionRef& tx, int64_t max_fee_rate, int64_t max_burn_amount) override
+    {
+        for (const auto& out : tx->vout) {
+            if ((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
+                throw std::runtime_error(common::TransactionErrorString(TransactionError::MAX_BURN_EXCEEDED).original);
+            }
+        }
+
+        // Matches ParseFeeRate in the RPC: reject fee rates >= 1 BTC/kvB. 0 means "any".
+        if (max_fee_rate >= COIN) {
+            throw std::runtime_error("Fee rates larger than or equal to 1BTC/kvB are not accepted");
+        }
+        const CFeeRate max_raw_tx_fee_rate{max_fee_rate};
+        const int64_t virtual_size = GetVirtualTransactionSize(*tx);
+        const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
+
+        const bool private_broadcast_enabled{m_node.args && m_node.args->GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)};
+        if (private_broadcast_enabled &&
+            !g_reachable_nets.Contains(NET_ONION) &&
+            !g_reachable_nets.Contains(NET_I2P)) {
+            throw std::runtime_error(
+                "-privatebroadcast is enabled, but none of the Tor or I2P networks is "
+                "reachable. Maybe the location of the Tor proxy couldn't be retrieved "
+                "from the Tor daemon at startup. Check whether the Tor daemon is running "
+                "and that -torcontrol, -torpassword and -i2psam are configured properly.");
+        }
+        const auto method = private_broadcast_enabled ? TxBroadcast::NO_MEMPOOL_PRIVATE_BROADCAST : TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL;
+
+        std::string err_string;
+        const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_raw_tx_fee, method, /*wait_callback=*/true);
+        if (TransactionError::OK != err) {
+            throw std::runtime_error(err_string.empty() ? common::TransactionErrorString(err).original : err_string);
+        }
+        return tx->GetHash().GetHex();
+    }
+    SmartFeeEstimate estimateSmartFee(int conf_target, bool conservative) override
+    {
+        SmartFeeEstimate result;
+        if (!m_node.fee_estimator || !m_node.mempool) {
+            result.errors.emplace_back("Fee estimation disabled");
+            return result;
+        }
+        CBlockPolicyEstimator& fee_estimator = *m_node.fee_estimator;
+        CTxMemPool& mempool = *m_node.mempool;
+
+        // Ensure the estimator has seen all recently connected blocks.
+        CHECK_NONFATAL(mempool.m_opts.signals)->SyncWithValidationInterfaceQueue();
+
+        const unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
+        if (conf_target < 1 || static_cast<unsigned int>(conf_target) > max_target) {
+            throw std::runtime_error(strprintf("Invalid conf_target, must be between %u and %u", 1, max_target));
+        }
+
+        FeeCalculation fee_calc;
+        CFeeRate fee_rate{fee_estimator.estimateSmartFee(conf_target, &fee_calc, conservative)};
+        if (fee_rate != CFeeRate(0)) {
+            // Floor the estimate at the mempool min fee and the relay fee, like the RPC.
+            const CFeeRate min_mempool_feerate{mempool.GetMinFee()};
+            const CFeeRate min_relay_feerate{mempool.m_opts.min_relay_feerate};
+            fee_rate = std::max({fee_rate, min_mempool_feerate, min_relay_feerate});
+            result.feerate = fee_rate.GetFeePerK();
+        } else {
+            result.errors.emplace_back("Insufficient data or no feerate found");
+        }
+        result.blocks = fee_calc.returnedTarget;
+        return result;
+    }
+    NetworkInfo getNetworkInfo() override
+    {
+        NetworkInfo info;
+        info.version = CLIENT_VERSION;
+        info.subversion = strSubVersion;
+        info.protocolversion = PROTOCOL_VERSION;
+        if (m_node.connman) {
+            const ServiceFlags services = m_node.connman->GetLocalServices();
+            info.localservices = strprintf("%016x", static_cast<uint64_t>(services));
+            info.localservicesnames = serviceFlagsToStr(services);
+        }
+        if (m_node.peerman) {
+            const auto peerman_info{m_node.peerman->GetInfo()};
+            info.localrelay = !peerman_info.ignores_incoming_txs;
+            info.timeoffset = Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset);
+        }
+        if (m_node.connman) {
+            info.networkactive = m_node.connman->GetNetworkActive();
+            info.connections = m_node.connman->GetNodeCount(ConnectionDirection::Both);
+            info.connections_in = m_node.connman->GetNodeCount(ConnectionDirection::In);
+            info.connections_out = m_node.connman->GetNodeCount(ConnectionDirection::Out);
+        }
+        for (int n = 0; n < NET_MAX; ++n) {
+            const enum Network network = static_cast<enum Network>(n);
+            if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
+            NetworkInfoNetwork& net = info.networks.emplace_back();
+            net.name = GetNetworkName(network);
+            net.limited = !g_reachable_nets.Contains(network);
+            net.reachable = g_reachable_nets.Contains(network);
+            if (const auto proxy = GetProxy(network)) {
+                net.proxy = proxy->ToString();
+                net.proxy_randomize_credentials = proxy->m_tor_stream_isolation;
+            }
+        }
+        if (m_node.mempool) {
+            info.relayfee = m_node.mempool->m_opts.min_relay_feerate.GetFeePerK();
+            info.incrementalfee = m_node.mempool->m_opts.incremental_relay_feerate.GetFeePerK();
+        }
+        {
+            LOCK(g_maplocalhost_mutex);
+            for (const auto& [addr, service] : mapLocalHost) {
+                NetworkInfoLocalAddress& local = info.localaddresses.emplace_back();
+                local.address = addr.ToStringAddr();
+                local.port = service.nPort;
+                local.score = service.nScore;
+            }
+        }
+        if (m_node.warnings) {
+            for (const auto& warning : m_node.warnings->GetMessages()) {
+                info.warnings.push_back(warning.original);
+            }
+        }
+        return info;
+    }
+    DeploymentsInfo getDeploymentInfo(const std::optional<uint256>& block_hash) override
+    {
+        ChainstateManager& chainman = *Assert(m_node.chainman);
+        LOCK(::cs_main);
+
+        const CBlockIndex* blockindex;
+        if (!block_hash) {
+            blockindex = Assert(chainman.ActiveChain().Tip());
+        } else {
+            blockindex = chainman.m_blockman.LookupBlockIndex(*block_hash);
+            if (!blockindex) {
+                throw std::runtime_error("Block not found");
+            }
+        }
+
+        DeploymentsInfo info;
+        info.hash = blockindex->GetBlockHash().ToString();
+        info.height = blockindex->nHeight;
+        for (const auto& flag : GetScriptFlagNames(GetBlockScriptFlags(*blockindex, chainman))) {
+            info.script_flags.push_back(flag);
+        }
+
+        // Buried deployments (BIP 90): active from a hardcoded height.
+        const auto add_buried = [&](Consensus::BuriedDeployment dep) {
+            if (!DeploymentEnabled(chainman, dep)) return;
+            DeploymentInfo& d = info.deployments.emplace_back();
+            d.name = DeploymentName(dep);
+            d.type = "buried";
+            d.active = DeploymentActiveAfter(blockindex, chainman, dep);
+            d.height = chainman.GetConsensus().DeploymentHeight(dep);
+        };
+        add_buried(Consensus::DEPLOYMENT_HEIGHTINCB);
+        add_buried(Consensus::DEPLOYMENT_DERSIG);
+        add_buried(Consensus::DEPLOYMENT_CLTV);
+        add_buried(Consensus::DEPLOYMENT_CSV);
+        add_buried(Consensus::DEPLOYMENT_SEGWIT);
+
+        // BIP 9 versionbits deployments.
+        const auto add_bip9 = [&](Consensus::DeploymentPos pos) {
+            if (!DeploymentEnabled(chainman, pos)) return;
+            DeploymentInfo& d = info.deployments.emplace_back();
+            d.name = DeploymentName(pos);
+            d.type = "bip9";
+
+            const BIP9Info bip9_info{chainman.m_versionbitscache.Info(*blockindex, chainman.GetConsensus(), pos)};
+            const Consensus::BIP9Deployment& depparams{chainman.GetConsensus().vDeployments[pos]};
+            BIP9DeploymentInfo& bip9 = d.bip9.emplace();
+            if (bip9_info.stats.has_value()) {
+                bip9.bit = depparams.bit;
+            }
+            bip9.start_time = depparams.nStartTime;
+            bip9.timeout = depparams.nTimeout;
+            bip9.min_activation_height = depparams.min_activation_height;
+            bip9.status = bip9_info.current_state;
+            bip9.since = bip9_info.since;
+            bip9.status_next = bip9_info.next_state;
+            if (bip9_info.stats.has_value()) {
+                BIP9Statistics& stats = bip9.statistics.emplace();
+                stats.period = bip9_info.stats->period;
+                stats.elapsed = bip9_info.stats->elapsed;
+                stats.count = bip9_info.stats->count;
+                stats.threshold = bip9_info.stats->threshold;
+                stats.possible = bip9_info.stats->possible;
+
+                bip9.signalling.reserve(bip9_info.signalling_blocks.size());
+                for (const bool s : bip9_info.signalling_blocks) {
+                    bip9.signalling.push_back(s ? '#' : '-');
+                }
+            }
+            if (bip9_info.active_since.has_value()) {
+                d.height = *bip9_info.active_since;
+                d.active = (*bip9_info.active_since <= blockindex->nHeight + 1);
+            }
+        };
+        add_bip9(Consensus::DEPLOYMENT_TESTDUMMY);
+
+        return info;
+    }
+    NodeContext& m_node;
+};
+
 } // namespace
 } // namespace node
 
 namespace interfaces {
 std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
 std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
+std::unique_ptr<NodeRpc> MakeNodeRpc(node::NodeContext& context) { return std::make_unique<node::NodeRpcImpl>(context); }
 std::unique_ptr<Mining> MakeMining(const node::NodeContext& context, bool wait_loaded)
 {
     if (wait_loaded) {