dig_node_control_interface/
traits.rs

1//! The two contract traits: the client-facing call builder/parser and the node-facing handler.
2//!
3//! * [`ControlCall`] binds a typed params struct to its [`ControlMethod`] and its typed result — so
4//!   a caller writes `client.request(&SetCapParams { cap_bytes })` and gets back a `SetCapResult`,
5//!   never a stringly-typed `Value`.
6//! * [`ControlClient`] is what a CLIENT depends on: build a JSON-RPC request from a typed call, and
7//!   parse a response back into the typed result (or a [`ControlError`]). Pure — no transport; the
8//!   consumer carries the bytes over dig-ipc / loopback-mTLS itself.
9//! * [`ControlHandler`] is what a NODE implements to SERVE the surface: one typed method per control
10//!   method, plus a provided [`dispatch`](ControlHandler::dispatch) that routes a raw request to the
11//!   right method — the single anti-drift seam the conformance KATs exercise.
12
13use async_trait::async_trait;
14use serde::de::DeserializeOwned;
15use serde::Serialize;
16use serde_json::Value;
17
18use crate::envelope::{JsonRpcRequest, JsonRpcResponse, RequestId};
19use crate::error::{ControlError, ControlErrorCode};
20use crate::method::ControlMethod;
21use crate::params;
22use crate::results;
23
24/// A typed control call: a params struct that knows its [`ControlMethod`] and its result type.
25///
26/// Implemented by every struct in [`crate::params`]; this is what makes
27/// [`ControlClient::parse_response`] return the right typed result for each method at compile time.
28pub trait ControlCall: Serialize {
29    /// The wire method this call invokes.
30    const METHOD: ControlMethod;
31    /// The typed result this call returns on success.
32    type Output: DeserializeOwned;
33}
34
35/// Serialize a typed call's params into a JSON object (`{}` for a no-param call, never `null`).
36fn params_value<C: ControlCall>(call: &C) -> Value {
37    match serde_json::to_value(call) {
38        Ok(Value::Null) => Value::Object(Default::default()),
39        Ok(v) => v,
40        Err(_) => Value::Object(Default::default()),
41    }
42}
43
44/// Build the JSON-RPC request envelope for a typed control call. Pure.
45pub fn build_request<C: ControlCall>(id: RequestId, call: &C) -> JsonRpcRequest {
46    JsonRpcRequest::new(id, C::METHOD.name(), params_value(call))
47}
48
49/// Parse a JSON-RPC response into a typed result, or the [`ControlError`] it carried. Pure.
50pub fn parse_response<C: ControlCall>(
51    response: JsonRpcResponse,
52) -> Result<C::Output, ControlError> {
53    let value = response.into_result()?;
54    serde_json::from_value(value).map_err(|e| {
55        ControlError::of(
56            ControlErrorCode::ControlError,
57            format!("failed to parse {} result: {e}", C::METHOD.name()),
58        )
59    })
60}
61
62/// The client-facing half of the contract: turn typed calls into requests and responses back into
63/// typed results.
64///
65/// The default implementations cover every client; a consumer implements this trait only to
66/// customise request construction (e.g. attaching the control token in a bespoke way). The blanket
67/// [`DefaultControlClient`] gives callers the standard behaviour for free.
68pub trait ControlClient {
69    /// Build the request envelope for a typed call with the given request `id`.
70    fn build_request<C: ControlCall>(&self, id: RequestId, call: &C) -> JsonRpcRequest {
71        build_request(id, call)
72    }
73
74    /// Parse a response envelope into the typed result for call type `C`.
75    fn parse_response<C: ControlCall>(
76        &self,
77        response: JsonRpcResponse,
78    ) -> Result<C::Output, ControlError> {
79        parse_response::<C>(response)
80    }
81}
82
83/// The standard, zero-configuration [`ControlClient`] using the default request/response behaviour.
84#[derive(Debug, Clone, Copy, Default)]
85pub struct DefaultControlClient;
86
87impl ControlClient for DefaultControlClient {}
88
89/// The node-facing half of the contract: a running node implements this to SERVE the control
90/// surface. Each method is typed to the catalog's params/results; the provided
91/// [`dispatch`](ControlHandler::dispatch) routes a raw [`JsonRpcRequest`] to the right method so a
92/// server needs only one entry point and can never mis-route.
93///
94/// Open/proxied shapes (the updater beacon status, the pairing list, the peer-pool snapshot) return
95/// [`Value`] rather than a frozen struct, matching the catalog's [`ControlCall::Output`] for those
96/// methods.
97#[async_trait]
98pub trait ControlHandler: Sync {
99    /// `control.status`
100    async fn status(&self) -> Result<results::StatusResult, ControlError>;
101    /// `control.config.get`
102    async fn config_get(&self) -> Result<results::ConfigResult, ControlError>;
103    /// `control.config.setUpstream`
104    async fn config_set_upstream(
105        &self,
106        params: params::SetUpstreamParams,
107    ) -> Result<results::SetUpstreamResult, ControlError>;
108    /// `control.log.setLevel`
109    async fn log_set_level(
110        &self,
111        params: params::SetLevelParams,
112    ) -> Result<results::SetLevelResult, ControlError>;
113    /// `control.cache.get`
114    async fn cache_get(&self) -> Result<results::CacheView, ControlError>;
115    /// `control.cache.setCap`
116    async fn cache_set_cap(
117        &self,
118        params: params::SetCapParams,
119    ) -> Result<results::SetCapResult, ControlError>;
120    /// `control.cache.clear`
121    async fn cache_clear(&self) -> Result<results::CacheClearResult, ControlError>;
122    /// `control.hostedStores.list`
123    async fn hosted_stores_list(&self) -> Result<results::HostedStoresListResult, ControlError>;
124    /// `control.hostedStores.pin`
125    async fn hosted_stores_pin(
126        &self,
127        params: params::PinParams,
128    ) -> Result<results::PinResult, ControlError>;
129    /// `control.hostedStores.unpin`
130    async fn hosted_stores_unpin(
131        &self,
132        params: params::UnpinParams,
133    ) -> Result<results::UnpinResult, ControlError>;
134    /// `control.hostedStores.status`
135    async fn hosted_stores_status(
136        &self,
137        params: params::HostedStoreStatusParams,
138    ) -> Result<results::HostedStoreStatusResult, ControlError>;
139    /// `control.sync.status`
140    async fn sync_status(&self) -> Result<results::SyncStatusResult, ControlError>;
141    /// `control.sync.trigger`
142    async fn sync_trigger(
143        &self,
144        params: params::SyncTriggerParams,
145    ) -> Result<results::SyncTriggerResult, ControlError>;
146    /// `control.updater.status`
147    async fn updater_status(&self) -> Result<Value, ControlError>;
148    /// `control.updater.setChannel`
149    async fn updater_set_channel(
150        &self,
151        params: params::SetChannelParams,
152    ) -> Result<Value, ControlError>;
153    /// `control.updater.pause`
154    async fn updater_pause(&self, params: params::PauseParams) -> Result<Value, ControlError>;
155    /// `control.updater.resume`
156    async fn updater_resume(&self) -> Result<Value, ControlError>;
157    /// `control.updater.checkNow`
158    async fn updater_check_now(&self) -> Result<Value, ControlError>;
159    /// `control.pairing.list`
160    async fn pairing_list(&self) -> Result<Value, ControlError>;
161    /// `control.pairing.approve`
162    async fn pairing_approve(
163        &self,
164        params: params::ApproveParams,
165    ) -> Result<results::PairingApproveResult, ControlError>;
166    /// `control.pairing.revoke`
167    async fn pairing_revoke(
168        &self,
169        params: params::RevokeParams,
170    ) -> Result<results::PairingRevokeResult, ControlError>;
171    /// `control.peerStatus`
172    async fn peer_status(&self) -> Result<Value, ControlError>;
173    /// `control.peers.connect`
174    async fn peers_connect(
175        &self,
176        params: params::PeersConnectParams,
177    ) -> Result<results::PeersConnectResult, ControlError>;
178    /// `control.peers.disconnect`
179    async fn peers_disconnect(
180        &self,
181        params: params::PeersDisconnectParams,
182    ) -> Result<results::PeersDisconnectResult, ControlError>;
183    /// `control.subscribe`
184    async fn subscribe(
185        &self,
186        params: params::SubscribeParams,
187    ) -> Result<results::SubscribeResult, ControlError>;
188    /// `control.unsubscribe`
189    async fn unsubscribe(
190        &self,
191        params: params::UnsubscribeParams,
192    ) -> Result<results::UnsubscribeResult, ControlError>;
193    /// `control.listSubscriptions`
194    async fn list_subscriptions(&self) -> Result<results::ListSubscriptionsResult, ControlError>;
195    /// `control.wallet.balance` (READ-only)
196    async fn wallet_balance(
197        &self,
198        params: params::WalletBalanceParams,
199    ) -> Result<results::WalletBalanceResult, ControlError>;
200    /// `control.wallet.coins` (READ-only, OPEN)
201    ///
202    /// An empty `coins` list MUST mean "a chain was consulted and this address holds nothing".
203    /// A read that could not consult a chain MUST return the matching catalogued error instead.
204    async fn wallet_coins(
205        &self,
206        params: params::WalletCoinsParams,
207    ) -> Result<results::WalletCoinsResult, ControlError>;
208    /// `control.wallet.coinById` (READ-only, OPEN)
209    ///
210    /// `Ok(coin: None)` MUST mean "a chain was consulted and holds no such coin". A read that could
211    /// not consult a chain MUST return the matching catalogued error instead — a caller that cannot
212    /// tell those apart reports a spent mint as pending forever.
213    ///
214    /// The params are validated at DESERIALIZATION (lowercase 64-hex, `0x` stripped), so any path
215    /// that decodes `WalletCoinByIdParams` refuses malformed ids as `INVALID_PARAMS` before this
216    /// method is called.
217    async fn wallet_coin_by_id(
218        &self,
219        params: params::WalletCoinByIdParams,
220    ) -> Result<results::WalletCoinByIdResult, ControlError>;
221    /// `control.wallet.peak` (READ-only, OPEN)
222    async fn wallet_peak(&self) -> Result<results::WalletPeakResult, ControlError>;
223    /// `control.peerCounts` (READ-only, OPEN)
224    ///
225    /// `dig_peer_count` MUST be dig-node-core's `connected_peers` — the same figure
226    /// `control.peerStatus` reports — and `chia_peer_count` MUST be the SAME observation
227    /// `wallet_sync_status` reports, served from ONE source so the two answers agree. `None` means
228    /// the count cannot be observed; a network that is not running is UNKNOWN, never `Some(0)`.
229    async fn peer_counts(&self) -> Result<results::PeerCountsResult, ControlError>;
230    /// `control.wallet.syncStatus` (READ-only, OPEN)
231    ///
232    /// `WalletSyncPhase::Synced` MUST require BOTH that the initial catch-up completed and that at
233    /// least one Chia peer connection is live now, which makes it strictly stronger than
234    /// `WalletPeakResult::synced`. `peak_height` MUST be the node's OWN replica's height or `None`,
235    /// never an oracle's, and `chia_peer_count` counts CHIA full-node peers -- never DIG peers.
236    async fn wallet_sync_status(&self) -> Result<results::WalletSyncStatusResult, ControlError>;
237    /// `control.wallet.broadcast` (TOKEN-GATED)
238    ///
239    /// Pushes an ALREADY-SIGNED bundle: the implementation never signs, and never receives anything
240    /// it could sign with (§908). A mempool refusal is `Ok` with `accepted: false`; failing to
241    /// reach a mempool is `Err`.
242    async fn wallet_broadcast(
243        &self,
244        params: params::WalletBroadcastParams,
245    ) -> Result<results::WalletBroadcastResult, ControlError>;
246    /// `pairing.request` (OPEN)
247    async fn pairing_request(
248        &self,
249        params: params::RequestParams,
250    ) -> Result<results::PairingRequestResult, ControlError>;
251    /// `pairing.poll` (OPEN)
252    async fn pairing_poll(
253        &self,
254        params: params::PollParams,
255    ) -> Result<results::PairingPollResult, ControlError>;
256
257    /// Route a raw JSON-RPC request to the right typed method and build the response envelope.
258    ///
259    /// Deserializes the params for methods that take them, calls the handler, and serializes the
260    /// typed result. An unknown method → `METHOD_NOT_FOUND`; malformed params → `INVALID_PARAMS`.
261    /// This is the single seam a server dispatches through — the KATs exercise it end-to-end.
262    async fn dispatch(&self, request: JsonRpcRequest) -> JsonRpcResponse {
263        let id = request.id.clone();
264        let Some(method) = ControlMethod::from_name(&request.method) else {
265            return JsonRpcResponse::error(
266                id,
267                ControlError::of(
268                    ControlErrorCode::MethodNotFound,
269                    format!("unknown control method: {}", request.method),
270                ),
271            );
272        };
273        match self.dispatch_method(method, request.params).await {
274            Ok(result) => JsonRpcResponse::success(id, result),
275            Err(err) => JsonRpcResponse::error(id, err),
276        }
277    }
278
279    /// Route to the typed method by [`ControlMethod`], returning the result as a [`Value`]. Split
280    /// from [`dispatch`](ControlHandler::dispatch) so the envelope wrapping stays in one place.
281    #[doc(hidden)]
282    async fn dispatch_method(
283        &self,
284        method: ControlMethod,
285        params: Value,
286    ) -> Result<Value, ControlError> {
287        /// Deserialize a method's params, mapping a shape error to `INVALID_PARAMS`.
288        fn decode<T: DeserializeOwned>(params: Value) -> Result<T, ControlError> {
289            serde_json::from_value(params)
290                .map_err(|e| ControlError::of(ControlErrorCode::InvalidParams, e.to_string()))
291        }
292        /// Serialize a typed result to a `Value` (infallible for our derive-Serialize results).
293        fn encode<T: Serialize>(value: T) -> Result<Value, ControlError> {
294            serde_json::to_value(value)
295                .map_err(|e| ControlError::of(ControlErrorCode::ControlError, e.to_string()))
296        }
297        match method {
298            ControlMethod::Status => encode(self.status().await?),
299            ControlMethod::ConfigGet => encode(self.config_get().await?),
300            ControlMethod::ConfigSetUpstream => {
301                encode(self.config_set_upstream(decode(params)?).await?)
302            }
303            ControlMethod::LogSetLevel => encode(self.log_set_level(decode(params)?).await?),
304            ControlMethod::CacheGet => encode(self.cache_get().await?),
305            ControlMethod::CacheSetCap => encode(self.cache_set_cap(decode(params)?).await?),
306            ControlMethod::CacheClear => encode(self.cache_clear().await?),
307            ControlMethod::HostedStoresList => encode(self.hosted_stores_list().await?),
308            ControlMethod::HostedStoresPin => {
309                encode(self.hosted_stores_pin(decode(params)?).await?)
310            }
311            ControlMethod::HostedStoresUnpin => {
312                encode(self.hosted_stores_unpin(decode(params)?).await?)
313            }
314            ControlMethod::HostedStoresStatus => {
315                encode(self.hosted_stores_status(decode(params)?).await?)
316            }
317            ControlMethod::SyncStatus => encode(self.sync_status().await?),
318            ControlMethod::SyncTrigger => encode(self.sync_trigger(decode(params)?).await?),
319            ControlMethod::UpdaterStatus => self.updater_status().await,
320            ControlMethod::UpdaterSetChannel => self.updater_set_channel(decode(params)?).await,
321            ControlMethod::UpdaterPause => self.updater_pause(decode(params)?).await,
322            ControlMethod::UpdaterResume => self.updater_resume().await,
323            ControlMethod::UpdaterCheckNow => self.updater_check_now().await,
324            ControlMethod::PairingList => self.pairing_list().await,
325            ControlMethod::PairingApprove => encode(self.pairing_approve(decode(params)?).await?),
326            ControlMethod::PairingRevoke => encode(self.pairing_revoke(decode(params)?).await?),
327            ControlMethod::PeerStatus => self.peer_status().await,
328            ControlMethod::PeerCounts => encode(self.peer_counts().await?),
329            ControlMethod::PeersConnect => encode(self.peers_connect(decode(params)?).await?),
330            ControlMethod::PeersDisconnect => encode(self.peers_disconnect(decode(params)?).await?),
331            ControlMethod::Subscribe => encode(self.subscribe(decode(params)?).await?),
332            ControlMethod::Unsubscribe => encode(self.unsubscribe(decode(params)?).await?),
333            ControlMethod::ListSubscriptions => encode(self.list_subscriptions().await?),
334            ControlMethod::WalletBalance => encode(self.wallet_balance(decode(params)?).await?),
335            ControlMethod::WalletCoins => encode(self.wallet_coins(decode(params)?).await?),
336            // Re-validated here idempotently; deserialization already enforced the same rule.
337            ControlMethod::WalletCoinById => {
338                let params: params::WalletCoinByIdParams = decode(params)?;
339                encode(self.wallet_coin_by_id(params.validated()?).await?)
340            }
341            ControlMethod::WalletPeak => encode(self.wallet_peak().await?),
342            ControlMethod::WalletSyncStatus => encode(self.wallet_sync_status().await?),
343            ControlMethod::WalletBroadcast => encode(self.wallet_broadcast(decode(params)?).await?),
344            ControlMethod::PairingRequest => encode(self.pairing_request(decode(params)?).await?),
345            ControlMethod::PairingPoll => encode(self.pairing_poll(decode(params)?).await?),
346        }
347    }
348}
dig_node_control_interface/traits.rs

dig_node_control_interface/
traits.rs
