bitcoin · ryanofsky · Jul 26, 2024 · Dec 5, 2017 · Dec 5, 2017 · Dec 5, 2017
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
@@ -359,7 +359,7 @@ class Chain
     //! support for writing null values to settings.json.
     //! Depending on the action returned by the update function, this will either
     //! update the setting in memory or write the updated settings to disk.
-    virtual bool updateRwSetting(const std::string& name, const SettingsUpdate& update_function) = 0;
+    virtual bool updateRwSetting(const std::string& name, SettingsUpdate update_function) = 0;
 //! Update a setting in <datadir>/settings.json. 
 virtual void updateRwSetting(const std::string& name, const common::SettingsValue& value) = 0; 
 //! Force a setting value to be applied, overriding any other configuration 
 //! source, but not being persisted. 
 virtual void forceSetting(const std::string& name, const common::SettingsValue& value) = 0; 
 //! Update a setting in <datadir>/settings.json. 
 virtual void updateRwSetting(const std::string& name, const common::SettingsValue& value) = 0; 
  
 //! Force a setting value to be applied, overriding any other configuration 
 //! source, but not being persisted. 
 virtual void forceSetting(const std::string& name, const common::SettingsValue& value) = 0; 
 
     //! Replace a setting in <datadir>/settings.json with a new value.
     //! Null can be passed to erase the setting.
@@ -408,7 +408,8 @@ class ChainClient
     //! Load saved state.
     virtual bool load() = 0;
 
-    //! Start client execution and provide a scheduler.
+    //! Start client execution and provide a scheduler. (Scheduler is
+    //! ignored if client is out-of-process).
     virtual void start(CScheduler& scheduler) = 0;
 
     //! Shut down client.

diff --git a/src/ipc/CMakeLists.txt b/src/ipc/CMakeLists.txt
@@ -3,15 +3,18 @@
 # file COPYING or https://opensource.org/license/mit/.
 
 add_library(bitcoin_ipc STATIC EXCLUDE_FROM_ALL
+  capnp/chain.cpp
   capnp/mining.cpp
   capnp/protocol.cpp
   interfaces.cpp
   process.cpp
 )
 
 target_capnp_sources(bitcoin_ipc ${CMAKE_CURRENT_SOURCE_DIR}
+  capnp/chain.capnp
   capnp/common.capnp
   capnp/echo.capnp
+  capnp/handler.capnp
   capnp/init.capnp
   capnp/mining.capnp
   capnp/rpc.capnp
@@ -22,6 +25,8 @@ target_link_libraries(bitcoin_ipc
     core_interface
     univalue
     Boost::headers
+  PUBLIC
+    bitcoin_common
 )
 
 if(BUILD_TESTS)

diff --git a/src/ipc/capnp/chain-types.h b/src/ipc/capnp/chain-types.h
@@ -0,0 +1,107 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://opensource.org/license/mit.
+
+#ifndef BITCOIN_IPC_CAPNP_CHAIN_TYPES_H
+#define BITCOIN_IPC_CAPNP_CHAIN_TYPES_H
+
+#include <coins.h>
+#include <ipc/capnp/chain.capnp.proxy.h>
+#include <ipc/capnp/common.capnp.proxy-types.h>
+#include <ipc/capnp/handler.capnp.proxy-types.h>
+#include <interfaces/chain.h>
+#include <kernel/types.h>
+#include <policy/fees/block_policy_estimator.h>
+#include <primitives/block.h>
+#include <rpc/server.h>
+
+//! Specialization of handleRpc needed because it takes a CRPCCommand& reference
+//! argument, so a manual cleanup callback is needed to free the passed
+//! CRPCCommand struct and proxy ActorCallback object.
+template <>
+struct mp::ProxyServerMethodTraits<ipc::capnp::messages::Chain::HandleRpcParams>
+{
+    using Context = ServerContext<ipc::capnp::messages::Chain,
+                                  ipc::capnp::messages::Chain::HandleRpcParams,
+                                  ipc::capnp::messages::Chain::HandleRpcResults>;
+    static ::capnp::Void invoke(Context& context);
+};
+
+//! Specialization of start method needed to provide CScheduler& reference
+//! argument.
+template <>
+struct mp::ProxyServerMethodTraits<ipc::capnp::messages::ChainClient::StartParams>
+{
+    using ChainContext = ServerContext<ipc::capnp::messages::ChainClient,
+                                       ipc::capnp::messages::ChainClient::StartParams,
+                                       ipc::capnp::messages::ChainClient::StartResults>;
+    static void invoke(ChainContext& context);
+};
+
+namespace mp {
+//! Overload CustomBuildMessage, CustomPassMessage, and CustomReadMessage to
+//! serialize interfaces::FoundBlock parameters. Custom conversion functions are
+//! needed because there is not a 1:1 correspondence between members of the C++
+//! FoundBlock class and the Cap'n Proto FoundBlockParam and FoundBlockResult
+//! structs. Separate param and result structs are needed because Cap'n Proto
+//! only has input and output parameters, not in/out parameters like C++.
+void CustomBuildMessage(InvokeContext& invoke_context,
+                        const interfaces::FoundBlock& dest,
+                        ipc::capnp::messages::FoundBlockParam::Builder&& builder);
+void CustomPassMessage(InvokeContext& invoke_context,
+                       const ipc::capnp::messages::FoundBlockParam::Reader& reader,
+                       ipc::capnp::messages::FoundBlockResult::Builder&& builder,
+                       std::function<void(const interfaces::FoundBlock&)>&& fn);
+void CustomReadMessage(InvokeContext& invoke_context,
+                       const ipc::capnp::messages::FoundBlockResult::Reader& reader,
+                       const interfaces::FoundBlock& dest);
+
+//! Overload CustomBuildMessage and CustomPassMessage to serialize
+//! interfaces::BlockInfo parameters. Custom conversion functions are needed
+//! because BlockInfo structs contain pointer and reference members, and custom
+//! code is needed to deal with their lifetimes. Specifics are described in the
+//! implementation of these functions.
+void CustomBuildMessage(InvokeContext& invoke_context,
+                        const interfaces::BlockInfo& block,
+                        ipc::capnp::messages::BlockInfo::Builder&& builder);
+void CustomPassMessage(InvokeContext& invoke_context,
+                       const ipc::capnp::messages::BlockInfo::Reader& reader,
+                       ::capnp::Void builder,
+                       std::function<void(const interfaces::BlockInfo&)>&& fn);
+
+//! CScheduler& server-side argument handling. Skips argument so it can
+//! be handled by ProxyServerMethodTraits ChainClient::Start code.
+template <typename Accessor, typename ServerContext, typename Fn, typename... Args>
+void CustomPassField(TypeList<CScheduler&>, ServerContext& server_context, const Fn& fn, Args&&... args)
+{
+    fn.invoke(server_context, std::forward<Args>(args)...);
+}
+
+//! CRPCCommand& server-side argument handling. Skips argument so it can
+//! be handled by ProxyServerMethodTraits Chain::HandleRpc code.
+template <typename Accessor, typename ServerContext, typename Fn, typename... Args>
+void CustomPassField(TypeList<const CRPCCommand&>, ServerContext& server_context, const Fn& fn, Args&&... args)
+{
+    fn.invoke(server_context, std::forward<Args>(args)...);
+}
+
+//! Override to avoid assert failures that would happen trying to serialize
+//! spent coins. Probably it would be best for Coin serialization code not
+//! to assert, but avoiding serialization in this case is harmless.
+bool CustomHasValue(InvokeContext& invoke_context, const Coin& coin);
+
+//! Overload CustomBuildMessage and CustomReadMessage to serialize HelpResult.
+inline void CustomBuildMessage(InvokeContext& invoke_context, const HelpResult& dest, ipc::capnp::messages::HelpResult::Builder&& builder)
+{
+    builder.setMessage(dest.what());
+}
+
+template <typename Input>
+void ThrowField(TypeList<HelpResult>, InvokeContext& invoke_context, Input&& input)
+{
+    auto data = input.get().getMessage();
+    throw HelpResult(std::string(CharCast(data.begin()), data.size()));
+}
+} // namespace mp
+
+#endif // BITCOIN_IPC_CAPNP_CHAIN_TYPES_H
diff --git a/src/ipc/capnp/chain.capnp b/src/ipc/capnp/chain.capnp
@@ -0,0 +1,173 @@
+# Copyright (c) The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or https://opensource.org/license/mit.
+
+@0x94f21a4864bd2c65;
+
+using Cxx = import "/capnp/c++.capnp";
+$Cxx.namespace("ipc::capnp::messages");
+
+using Proxy = import "/mp/proxy.capnp";
+$Proxy.include("interfaces/chain.h");
+$Proxy.include("rpc/server.h");
+$Proxy.includeTypes("ipc/capnp/chain-types.h");
+
+using Common = import "common.capnp";
+using Handler = import "handler.capnp";
+
+interface Chain $Proxy.wrap("interfaces::Chain") {
+    destroy @0 (context :Proxy.Context) -> ();
+    getHeight @1 (context :Proxy.Context) -> (result :Int32, hasResult :Bool);
+    getBlockHash @2 (context :Proxy.Context, height :Int32) -> (result :Data);
+    haveBlockOnDisk @3 (context :Proxy.Context, height :Int32) -> (result :Bool);
+    findLocatorFork @4 (context :Proxy.Context, locator :Data) -> (result :Int32, hasResult :Bool);
+    hasBlockFilterIndex @5 (context :Proxy.Context, filterType :UInt8) -> (result :Bool);
+    blockFilterMatchesAny @6 (context :Proxy.Context, filterType :UInt8, blockHash :Data, filterSet :List(Data)) -> (result :Bool, hasResult :Bool);
+    findBlock @7 (context :Proxy.Context, hash :Data, block :FoundBlockParam) -> (block :FoundBlockResult, result :Bool);
+    findFirstBlockWithTimeAndHeight @8 (context :Proxy.Context, minTime :Int64, minHeight :Int32, block :FoundBlockParam) -> (block :FoundBlockResult, result :Bool);
+    findAncestorByHeight @9 (context :Proxy.Context, blockHash :Data, ancestorHeight :Int32, ancestor :FoundBlockParam) -> (ancestor :FoundBlockResult, result :Bool);
+    findAncestorByHash @10 (context :Proxy.Context, blockHash :Data, ancestorHash :Data, ancestor :FoundBlockParam) -> (ancestor :FoundBlockResult, result :Bool);
+    findCommonAncestor @11 (context :Proxy.Context, blockHash1 :Data, blockHash2 :Data, ancestor :FoundBlockParam, block1 :FoundBlockParam, block2 :FoundBlockParam) -> (ancestor :FoundBlockResult, block1 :FoundBlockResult, block2 :FoundBlockResult, result :Bool);
+    findCoins @12 (context :Proxy.Context, coins :List(Common.Pair(Data, Data))) -> (coins :List(Common.Pair(Data, Data)));
+    guessVerificationProgress @13 (context :Proxy.Context, blockHash :Data) -> (result :Float64);
+    hasBlocks @14 (context :Proxy.Context, blockHash :Data, minHeight :Int32, maxHeight: Int32, hasMaxHeight :Bool) -> (result :Bool);
+    isRBFOptIn @15 (context :Proxy.Context, tx :Data) -> (result :Int32);
+    isInMempool @16 (context :Proxy.Context, txid :Data) -> (result :Bool);
+    hasDescendantsInMempool @17 (context :Proxy.Context, txid :Data) -> (result :Bool);
+    broadcastTransaction @18 (context :Proxy.Context, tx: Data, maxTxFee :Int64, broadcastMethod :Int32) -> (error: Text, result :Bool);
+    getTransactionAncestry @19 (context :Proxy.Context, txid :Data) -> (ancestors :UInt64, descendants :UInt64, ancestorsize :UInt64, ancestorfees :Int64);
+    calculateIndividualBumpFees @20 (context :Proxy.Context, outpoints :List(Data), targetFeerate :Data) -> (result: List(Common.PairInt64(Data)));
+    calculateCombinedBumpFee @21 (context :Proxy.Context, outpoints :List(Data), targetFeerate :Data) -> (result :Int64, hasResult :Bool);
+    getPackageLimits @22 (context :Proxy.Context) -> (ancestors :UInt32, descendants :UInt32);
+    checkChainLimits @23 (context :Proxy.Context, tx :Data) -> (result :Common.ResultVoid);
+    estimateSmartFee @24 (context :Proxy.Context, numBlocks :Int32, conservative :Bool, wantCalc :Bool) -> (calc :Common.FeeCalculation, result :Data);
+    estimateMaxBlocks @25 (context :Proxy.Context) -> (result :UInt32);
+    mempoolMinFee @26 (context :Proxy.Context) -> (result :Data);
+    relayMinFee @27 (context :Proxy.Context) -> (result :Data);
+    relayIncrementalFee @28 (context :Proxy.Context) -> (result :Data);
+    relayDustFee @29 (context :Proxy.Context) -> (result :Data);
+    havePruned @30 (context :Proxy.Context) -> (result :Bool);
+    getPruneHeight @31 (context :Proxy.Context) -> (result: Int32, hasResult: Bool);
+    isReadyToBroadcast @32 (context :Proxy.Context) -> (result :Bool);
+    isInitialBlockDownload @33 (context :Proxy.Context) -> (result :Bool);
+    shutdownRequested @34 (context :Proxy.Context) -> (result :Bool);
+    initMessage @35 (context :Proxy.Context, message :Text) -> ();
+    initWarning @36 (context :Proxy.Context, message :Common.BilingualStr) -> ();
+    initError @37 (context :Proxy.Context, message :Common.BilingualStr) -> ();
+    showProgress @38 (context :Proxy.Context, title :Text, progress :Int32, resumePossible :Bool) -> ();
+    handleNotifications @39 (context :Proxy.Context, notifications :ChainNotifications) -> (result :Handler.Handler);
+    waitForNotificationsIfTipChanged @40 (context :Proxy.Context, oldTip :Data) -> ();
+    waitForNotifications @41 (context :Proxy.Context) -> ();
+    handleRpc @42 (context :Proxy.Context, command :RPCCommand) -> (result :Handler.Handler);
+    rpcEnableDeprecated @43 (context :Proxy.Context, method :Text) -> (result :Bool);
+    getSetting @44 (context :Proxy.Context, name :Text) -> (result :Text);
+    getSettingsList @45 (context :Proxy.Context, name :Text) -> (result :List(Text));
+    getRwSetting @46 (context :Proxy.Context, name :Text) -> (result :Text);
+    updateRwSetting @47 (context :Proxy.Context, name :Text, update: SettingsUpdateCallback) -> (result :Bool);
+    overwriteRwSetting @48 (context :Proxy.Context, name :Text, value :Text, action :Int32) -> (result :Bool);
+    deleteRwSettings @49 (context :Proxy.Context, name :Text, action: Int32) -> (result :Bool);
+    requestMempoolTransactions @50 (context :Proxy.Context, notifications :ChainNotifications) -> ();
+    hasAssumedValidChain @51 (context :Proxy.Context) -> (result :Bool);
+}
+
+interface ChainNotifications $Proxy.wrap("interfaces::Chain::Notifications") {
+    destroy @0 (context :Proxy.Context) -> ();
+    transactionAddedToMempool @1 (context :Proxy.Context, tx :Data) -> ();
+    transactionRemovedFromMempool @2 (context :Proxy.Context, tx :Data, reason :Int32) -> ();
 virtual void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {} 
-    transactionRemovedFromMempool @2 (context :Proxy.Context, tx :Data, reason :Int32) -> ();
+    transactionRemovedFromMempool @2 (context :Proxy.Context, tx :Data, reason :UInt32) -> ();
 virtual void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {} 
-    transactionRemovedFromMempool @2 (context :Proxy.Context, tx :Data, reason :Int32) -> ();
+    transactionRemovedFromMempool @2 (context :Proxy.Context, tx :Data, reason :UInt32) -> ();
+    blockConnected @3 (context :Proxy.Context, role: ChainstateRole, block :BlockInfo) -> ();
+    blockDisconnected @4 (context :Proxy.Context, block :BlockInfo) -> ();
+    updatedBlockTip @5 (context :Proxy.Context) -> ();
+    chainStateFlushed @6 (context :Proxy.Context, role: ChainstateRole, locator :Data) -> ();
+}
+
+interface ChainClient $Proxy.wrap("interfaces::ChainClient") {
+    destroy @0 (context :Proxy.Context) -> ();
+    registerRpcs @1 (context :Proxy.Context) -> ();
+    verify @2 (context :Proxy.Context) -> (result :Bool);
+    load @3 (context :Proxy.Context) -> (result :Bool);
+    start @4 (context :Proxy.Context, scheduler :Void) -> ();
+    stop @5 (context :Proxy.Context) -> ();
+    setMockTime @6 (context :Proxy.Context, time :Int64) -> ();
+    schedulerMockForward @7 (context :Proxy.Context, deltaSeconds :Int64) -> ();
+}
+
+struct RPCCommand $Proxy.wrap("CRPCCommand") {
+   category @0 :Text;
+   name @1 :Text;
+   actor @2 :ActorCallback;
+   argNames @3 :List(RPCArg);
+   uniqueId @4 :Int64 $Proxy.name("unique_id");
+}
+
+# Representation of std::pair<std::string, bool> in CRPCCommand
+struct RPCArg {
 CRPCCommand(std::string category, std::string name, Actor actor, std::vector<std::pair<std::string, bool>> args, intptr_t unique_id) 
-struct RPCArg {
+# transport-only struct corresponding to `std::pair<std::string, bool>` in `CRPCCommand` constructor
+struct RPCArg {
 CRPCCommand(std::string category, std::string name, Actor actor, std::vector<std::pair<std::string, bool>> args, intptr_t unique_id) 
-struct RPCArg {
+# transport-only struct corresponding to `std::pair<std::string, bool>` in `CRPCCommand` constructor
+struct RPCArg {
+   name @0 :Text;
+   namedOnly @1: Bool;
+}
+
+interface ActorCallback $Proxy.wrap("ProxyCallback<CRPCCommand::Actor>") {
+    call @0 (context :Proxy.Context, request :JSONRPCRequest, response :Text, lastCallback :Bool) -> (error :Text $Proxy.exception("std::exception"), rpcError :Text $Proxy.exception("UniValue"), typeError :Text $Proxy.exception("UniValue::type_error"), helpResult :HelpResult $Proxy.exception("HelpResult"), response :Text, result: Bool);
+}
+
+struct HelpResult {
+    message @0 :Text;
+}
+
+struct JSONRPCRequest $Proxy.wrap("JSONRPCRequest") {
+    id @0 :Text;
 std::optional<UniValue> id = UniValue::VNULL; 
 std::optional<UniValue> id = UniValue::VNULL; 
+    method @1 :Text $Proxy.name("strMethod");
+    params @2 :Text;
+    mode @3 :Int32;
+    uri @4 :Text $Proxy.name("URI");
+    authUser @5 :Text;
+    peerAddr @6 :Text;
+    version @7: Int32 $Proxy.name("m_json_version");
+}
+
+struct FoundBlockParam {
+    wantHash @0 :Bool;
+    wantHeight @1 :Bool;
+    wantTime @2 :Bool;
+    wantMaxTime @3 :Bool;
+    wantMtpTime @4 :Bool;
+    wantInActiveChain @5 :Bool;
+    wantLocator @6 :Bool;
+    nextBlock @7: FoundBlockParam;
+    wantData @8 :Bool;
+}
+
+struct FoundBlockResult {
+    hash @0 :Data;
+    height @1 :Int32;
+    time @2 :Int64;
+    maxTime @3 :Int64;
+    mtpTime @4 :Int64;
+    inActiveChain @5 :Bool;
+    locator @6 :Data;
+    nextBlock @7: FoundBlockResult;
+    data @8 :Data;
+    found @9 :Bool;
+}
+
+struct BlockInfo $Proxy.wrap("interfaces::BlockInfo") {
+    # Fields skipped below with Proxy.skip are pointer fields manually handled
+    # by CustomBuildMessage / CustomPassMessage overloads.
+    hash @0 :Data $Proxy.skip;
+    prevHash @1 :Data $Proxy.skip;
+    height @2 :Int32 = -1;
+    fileNumber @3 :Int32 = -1 $Proxy.name("file_number");
+    dataPos @4 :UInt32 = 0 $Proxy.name("data_pos");
+    data @5 :Data $Proxy.skip;
+    undoData @6 :Data $Proxy.skip;
+    chainTimeMax @7 :UInt32 = 0 $Proxy.name("chain_time_max");
+}
+
+struct ChainstateRole $Proxy.wrap("kernel::ChainstateRole") {
+    validated @0 :Bool;
+    historical @1 :Bool;
+}
+
+interface SettingsUpdateCallback $Proxy.wrap("ProxyCallback<interfaces::SettingsUpdate>") {
+    destroy @0 (context :Proxy.Context) -> ();
+    call @1 (context :Proxy.Context, value :Text) -> (value :Text, result: Int32, hasResult: Bool);
+}