pub trait ControlHandler: Sync {
Show 45 methods
// Required methods
fn status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<StatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn config_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ConfigResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn config_set_upstream<'life0, 'async_trait>(
&'life0 self,
params: SetUpstreamParams,
) -> Pin<Box<dyn Future<Output = Result<SetUpstreamResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn log_set_level<'life0, 'async_trait>(
&'life0 self,
params: SetLevelParams,
) -> Pin<Box<dyn Future<Output = Result<SetLevelResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn cache_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheView, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn cache_set_cap<'life0, 'async_trait>(
&'life0 self,
params: SetCapParams,
) -> Pin<Box<dyn Future<Output = Result<SetCapResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn cache_clear<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheClearResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn hosted_stores_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<HostedStoresListResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn hosted_stores_pin<'life0, 'async_trait>(
&'life0 self,
params: PinParams,
) -> Pin<Box<dyn Future<Output = Result<PinResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn hosted_stores_unpin<'life0, 'async_trait>(
&'life0 self,
params: UnpinParams,
) -> Pin<Box<dyn Future<Output = Result<UnpinResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn hosted_stores_status<'life0, 'async_trait>(
&'life0 self,
params: HostedStoreStatusParams,
) -> Pin<Box<dyn Future<Output = Result<HostedStoreStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<SyncStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn sync_trigger<'life0, 'async_trait>(
&'life0 self,
params: SyncTriggerParams,
) -> Pin<Box<dyn Future<Output = Result<SyncTriggerResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn updater_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn updater_set_channel<'life0, 'async_trait>(
&'life0 self,
params: SetChannelParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn updater_pause<'life0, 'async_trait>(
&'life0 self,
params: PauseParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn updater_resume<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn updater_check_now<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn pairing_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn pairing_approve<'life0, 'async_trait>(
&'life0 self,
params: ApproveParams,
) -> Pin<Box<dyn Future<Output = Result<PairingApproveResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn pairing_revoke<'life0, 'async_trait>(
&'life0 self,
params: RevokeParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRevokeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn peer_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn peers_connect<'life0, 'async_trait>(
&'life0 self,
params: PeersConnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersConnectResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn peers_disconnect<'life0, 'async_trait>(
&'life0 self,
params: PeersDisconnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersDisconnectResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn subscribe<'life0, 'async_trait>(
&'life0 self,
params: SubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<SubscribeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn unsubscribe<'life0, 'async_trait>(
&'life0 self,
params: UnsubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<UnsubscribeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn list_subscriptions<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ListSubscriptionsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_balance<'life0, 'async_trait>(
&'life0 self,
params: WalletBalanceParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBalanceResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_coins<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_coin_by_id<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinByIdParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinByIdResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_coin_spend<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinSpendParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinSpendResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_coins_by_parent<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsByParentParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsByParentResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_arrivals<'life0, 'async_trait>(
&'life0 self,
params: WalletArrivalsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletArrivalsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_peak<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletPeakResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn peer_counts<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<PeerCountsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletSyncStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_broadcast<'life0, 'async_trait>(
&'life0 self,
params: WalletBroadcastParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBroadcastResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_watch<'life0, 'async_trait>(
&'life0 self,
params: WalletWatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_unwatch<'life0, 'async_trait>(
&'life0 self,
params: WalletUnwatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletUnwatchResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn wallet_watched<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchedResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn profile_put_body<'life0, 'async_trait>(
&'life0 self,
params: ProfilePutBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfilePutBodyResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn profile_get_body<'life0, 'async_trait>(
&'life0 self,
params: ProfileGetBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfileGetBodyResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn pairing_request<'life0, 'async_trait>(
&'life0 self,
params: RequestParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRequestResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
fn pairing_poll<'life0, 'async_trait>(
&'life0 self,
params: PollParams,
) -> Pin<Box<dyn Future<Output = Result<PairingPollResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait;
// Provided method
fn dispatch<'life0, 'async_trait>(
&'life0 self,
request: JsonRpcRequest,
) -> Pin<Box<dyn Future<Output = JsonRpcResponse> + Send + 'async_trait>>
where Self: 'async_trait,
'life0: 'async_trait { ... }
}Expand description
The node-facing half of the contract: a running node implements this to SERVE the control
surface. Each method is typed to the catalog’s params/results; the provided
dispatch routes a raw JsonRpcRequest to the right method so a
server needs only one entry point and can never mis-route.
Open/proxied shapes (the updater beacon status, the pairing list, the peer-pool snapshot) return
Value rather than a frozen struct, matching the catalog’s ControlCall::Output for those
methods.
Required Methods§
Sourcefn status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<StatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<StatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.status
Sourcefn config_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ConfigResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn config_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ConfigResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.config.get
Sourcefn config_set_upstream<'life0, 'async_trait>(
&'life0 self,
params: SetUpstreamParams,
) -> Pin<Box<dyn Future<Output = Result<SetUpstreamResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn config_set_upstream<'life0, 'async_trait>(
&'life0 self,
params: SetUpstreamParams,
) -> Pin<Box<dyn Future<Output = Result<SetUpstreamResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.config.setUpstream
Sourcefn log_set_level<'life0, 'async_trait>(
&'life0 self,
params: SetLevelParams,
) -> Pin<Box<dyn Future<Output = Result<SetLevelResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn log_set_level<'life0, 'async_trait>(
&'life0 self,
params: SetLevelParams,
) -> Pin<Box<dyn Future<Output = Result<SetLevelResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.log.setLevel
Sourcefn cache_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheView, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn cache_get<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheView, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.cache.get
Sourcefn cache_set_cap<'life0, 'async_trait>(
&'life0 self,
params: SetCapParams,
) -> Pin<Box<dyn Future<Output = Result<SetCapResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn cache_set_cap<'life0, 'async_trait>(
&'life0 self,
params: SetCapParams,
) -> Pin<Box<dyn Future<Output = Result<SetCapResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.cache.setCap
Sourcefn cache_clear<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheClearResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn cache_clear<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<CacheClearResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.cache.clear
Sourcefn hosted_stores_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<HostedStoresListResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn hosted_stores_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<HostedStoresListResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.hostedStores.list
Sourcefn hosted_stores_pin<'life0, 'async_trait>(
&'life0 self,
params: PinParams,
) -> Pin<Box<dyn Future<Output = Result<PinResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn hosted_stores_pin<'life0, 'async_trait>(
&'life0 self,
params: PinParams,
) -> Pin<Box<dyn Future<Output = Result<PinResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.hostedStores.pin
Sourcefn hosted_stores_unpin<'life0, 'async_trait>(
&'life0 self,
params: UnpinParams,
) -> Pin<Box<dyn Future<Output = Result<UnpinResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn hosted_stores_unpin<'life0, 'async_trait>(
&'life0 self,
params: UnpinParams,
) -> Pin<Box<dyn Future<Output = Result<UnpinResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.hostedStores.unpin
Sourcefn hosted_stores_status<'life0, 'async_trait>(
&'life0 self,
params: HostedStoreStatusParams,
) -> Pin<Box<dyn Future<Output = Result<HostedStoreStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn hosted_stores_status<'life0, 'async_trait>(
&'life0 self,
params: HostedStoreStatusParams,
) -> Pin<Box<dyn Future<Output = Result<HostedStoreStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.hostedStores.status
Sourcefn sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<SyncStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<SyncStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.sync.status
Sourcefn sync_trigger<'life0, 'async_trait>(
&'life0 self,
params: SyncTriggerParams,
) -> Pin<Box<dyn Future<Output = Result<SyncTriggerResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn sync_trigger<'life0, 'async_trait>(
&'life0 self,
params: SyncTriggerParams,
) -> Pin<Box<dyn Future<Output = Result<SyncTriggerResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.sync.trigger
Sourcefn updater_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn updater_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.updater.status
Sourcefn updater_set_channel<'life0, 'async_trait>(
&'life0 self,
params: SetChannelParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn updater_set_channel<'life0, 'async_trait>(
&'life0 self,
params: SetChannelParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.updater.setChannel
Sourcefn updater_pause<'life0, 'async_trait>(
&'life0 self,
params: PauseParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn updater_pause<'life0, 'async_trait>(
&'life0 self,
params: PauseParams,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.updater.pause
Sourcefn updater_resume<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn updater_resume<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.updater.resume
Sourcefn updater_check_now<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn updater_check_now<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.updater.checkNow
Sourcefn pairing_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pairing_list<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.pairing.list
Sourcefn pairing_approve<'life0, 'async_trait>(
&'life0 self,
params: ApproveParams,
) -> Pin<Box<dyn Future<Output = Result<PairingApproveResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pairing_approve<'life0, 'async_trait>(
&'life0 self,
params: ApproveParams,
) -> Pin<Box<dyn Future<Output = Result<PairingApproveResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.pairing.approve
Sourcefn pairing_revoke<'life0, 'async_trait>(
&'life0 self,
params: RevokeParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRevokeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pairing_revoke<'life0, 'async_trait>(
&'life0 self,
params: RevokeParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRevokeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.pairing.revoke
Sourcefn peer_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn peer_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.peerStatus
Sourcefn peers_connect<'life0, 'async_trait>(
&'life0 self,
params: PeersConnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersConnectResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn peers_connect<'life0, 'async_trait>(
&'life0 self,
params: PeersConnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersConnectResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.peers.connect
Sourcefn peers_disconnect<'life0, 'async_trait>(
&'life0 self,
params: PeersDisconnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersDisconnectResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn peers_disconnect<'life0, 'async_trait>(
&'life0 self,
params: PeersDisconnectParams,
) -> Pin<Box<dyn Future<Output = Result<PeersDisconnectResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.peers.disconnect
Sourcefn subscribe<'life0, 'async_trait>(
&'life0 self,
params: SubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<SubscribeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn subscribe<'life0, 'async_trait>(
&'life0 self,
params: SubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<SubscribeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.subscribe
params.kind is OPTIONAL on the wire and absent means
SubscriptionKind::Capsule. An implementation MUST
persist untagged rows it already holds as capsules rather than discarding them: a node that
refuses to read its own pre-existing subscriptions.json starts with an empty one, and the
upgrade silently unsubscribes the user from everything.
Sourcefn unsubscribe<'life0, 'async_trait>(
&'life0 self,
params: UnsubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<UnsubscribeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn unsubscribe<'life0, 'async_trait>(
&'life0 self,
params: UnsubscribeParams,
) -> Pin<Box<dyn Future<Output = Result<UnsubscribeResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.unsubscribe
Sourcefn list_subscriptions<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ListSubscriptionsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn list_subscriptions<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<ListSubscriptionsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.listSubscriptions
Sourcefn wallet_balance<'life0, 'async_trait>(
&'life0 self,
params: WalletBalanceParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBalanceResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_balance<'life0, 'async_trait>(
&'life0 self,
params: WalletBalanceParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBalanceResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.balance (READ-only)
Sourcefn wallet_coins<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_coins<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.coins (READ-only, OPEN)
An empty coins list MUST mean “a chain was consulted and this address holds nothing”.
A read that could not consult a chain MUST return the matching catalogued error instead.
Sourcefn wallet_coin_by_id<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinByIdParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinByIdResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_coin_by_id<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinByIdParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinByIdResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.coinById (READ-only, OPEN)
Ok(coin: None) MUST mean “a chain was consulted and holds no such coin”. A read that could
not consult a chain MUST return the matching catalogued error instead — a caller that cannot
tell those apart reports a spent mint as pending forever.
The params are validated at DESERIALIZATION (lowercase 64-hex, 0x stripped), so any path
that decodes WalletCoinByIdParams refuses malformed ids as INVALID_PARAMS before this
method is called.
Sourcefn wallet_coin_spend<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinSpendParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinSpendResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_coin_spend<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinSpendParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinSpendResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.coinSpend (READ-only, OPEN)
Ok(spend: None) MUST mean “a chain was consulted and holds no spend of that coin” — the
coin is unspent, or unknown. A read that could not consult a chain MUST return the matching
catalogued error instead: a caller following a singleton forward reads “no spend” as this is
the tip and stops walking, so a failure disguised as absence produces a spend built against
a superseded singleton.
A returned spend’s puzzle_reveal MUST tree-hash to the spent coin’s own puzzle_hash, and
the implementation MUST fail closed — an error, never an unverified reveal — when it does not
or when the reveal will not parse. The reveal comes from a peer, and a peer can lie.
The params are validated at DESERIALIZATION (lowercase 64-hex, 0x stripped), so any path
that decodes WalletCoinSpendParams refuses malformed ids as INVALID_PARAMS before this
method is called.
Sourcefn wallet_coins_by_parent<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsByParentParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsByParentResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_coins_by_parent<'life0, 'async_trait>(
&'life0 self,
params: WalletCoinsByParentParams,
) -> Pin<Box<dyn Future<Output = Result<WalletCoinsByParentResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.coinsByParent (READ-only, OPEN)
Returns the parent’s DIRECT children and nothing further. An implementation MUST NOT recurse: a transitive walk over caller-supplied input is unbounded work the caller cannot bound, and a partial walk returned as a complete one is a lineage with a silent hole in it.
An empty list MUST mean “a chain was consulted and this parent created no known children”. A read that could not consult a chain MUST return the matching catalogued error instead.
The answer is ONE PAGE. An implementation MUST return at most
params.effective_limit() records, in ASCENDING coin_id order, starting strictly after
params.after_coin_id when one is given; it MUST set complete to whether the page carries
the last child; and it MUST set cursor to the last record it actually returned (None for
an empty page). It MUST NOT report complete: true on a page it truncated — a caller reads
that as the end of a lineage branch. The params are validated at DESERIALIZATION, so an
out-of-range page size is refused as INVALID_PARAMS before this method is called.
Every record MUST report asset: None: naming a coin by its parent classifies nothing, and
asserting a class this read never verified is a claim a caller would then spend against.
Sourcefn wallet_arrivals<'life0, 'async_trait>(
&'life0 self,
params: WalletArrivalsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletArrivalsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_arrivals<'life0, 'async_trait>(
&'life0 self,
params: WalletArrivalsParams,
) -> Pin<Box<dyn Future<Output = Result<WalletArrivalsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.arrivals (READ-only, TOKEN-GATED)
Gated although it is a read: the caller supplies only a cursor, so the answer names this node’s OWN watched puzzle hashes and the receive history behind them.
Every returned row MUST be a CONFIRMED arrival that the node itself judged: above its arrival baseline, not previously reported, and not the wallet’s own change. An implementation MUST NOT emit a mempool sighting here, and MUST answer an empty page rather than an error when it has no baseline — “nothing arrived” is the honest answer from a wallet that cannot yet tell history from news.
cursor MUST be the position of the last row actually returned (or the caller’s after_seq
for an empty page) and MUST NOT be latest; see
WalletArrivalsResult::latest.
Sourcefn wallet_peak<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletPeakResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_peak<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletPeakResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.peak (READ-only, OPEN)
Sourcefn peer_counts<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<PeerCountsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn peer_counts<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<PeerCountsResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.peerCounts (READ-only, OPEN)
dig_peer_count MUST be dig-node-core’s connected_peers — the same figure
control.peerStatus reports — and chia_peer_count MUST be the SAME observation
wallet_sync_status reports, served from ONE source so the two answers agree. None means
the count cannot be observed; a network that is not running is UNKNOWN, never Some(0).
Sourcefn wallet_sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletSyncStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_sync_status<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletSyncStatusResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.syncStatus (READ-only, OPEN)
WalletSyncPhase::Synced MUST require BOTH that the initial catch-up completed and that at
least one Chia peer connection is live now, which makes it strictly stronger than
WalletPeakResult::synced. peak_height MUST be the node’s OWN replica’s height or None,
never an oracle’s, and chia_peer_count counts CHIA full-node peers – never DIG peers.
Sourcefn wallet_broadcast<'life0, 'async_trait>(
&'life0 self,
params: WalletBroadcastParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBroadcastResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_broadcast<'life0, 'async_trait>(
&'life0 self,
params: WalletBroadcastParams,
) -> Pin<Box<dyn Future<Output = Result<WalletBroadcastResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.broadcast (TOKEN-GATED)
Pushes an ALREADY-SIGNED bundle: the implementation never signs, and never receives anything
it could sign with (§908). A mempool refusal is Ok with accepted: false; failing to
reach a mempool is Err.
Sourcefn wallet_watch<'life0, 'async_trait>(
&'life0 self,
params: WalletWatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_watch<'life0, 'async_trait>(
&'life0 self,
params: WalletWatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.watch (TOKEN-GATED)
Enrols PUBLIC keys for the node’s chain replica to follow. The implementation MUST derive the addresses itself, from the SAME derivation it applies to the keys already in its own custody — a second derivation is a second opinion about which addresses a key covers, and the client would read the difference as missing money.
It MUST be IDEMPOTENT: keys already enrolled are reported as added: 0 and the call
succeeds. It MUST persist the enrolment across restarts — a set that evaporates on restart
makes a node that syncs today and reports a zero balance tomorrow.
The params are validated at DESERIALIZATION (lowercase 96-hex, 0x stripped), so any path
that decodes WalletWatchParams refuses a malformed key as INVALID_PARAMS — for the WHOLE
request — before this method is called.
Sourcefn wallet_unwatch<'life0, 'async_trait>(
&'life0 self,
params: WalletUnwatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletUnwatchResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_unwatch<'life0, 'async_trait>(
&'life0 self,
params: WalletUnwatchParams,
) -> Pin<Box<dyn Future<Output = Result<WalletUnwatchResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.unwatch (TOKEN-GATED)
Deregisters keys, and the following MUST actually stop: the addresses leave the replica’s watched set, not merely the list this node reports. A registry that keeps syncing what it says it forgot is the failure this method exists to make impossible.
Deregistering a key that was never enrolled is a success reporting removed: 0.
Sourcefn wallet_watched<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchedResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn wallet_watched<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WalletWatchedResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.wallet.watched (READ-only, TOKEN-GATED)
Gated although it is a read: the caller supplies nothing, so the answer names this node’s OWN enrolled keys.
MUST return exactly the keys enrolment added, in the wire form they were accepted in, so a client can compare its own set against the node’s by value. MUST NOT include the node’s own custody keys: this method reports what was ENROLLED through it, and a caller reconciling against a superset would unwatch keys it never watched.
Sourcefn profile_put_body<'life0, 'async_trait>(
&'life0 self,
params: ProfilePutBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfilePutBodyResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn profile_put_body<'life0, 'async_trait>(
&'life0 self,
params: ProfilePutBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfilePutBodyResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.profile.putBody (TOKEN-GATED)
An implementation MUST independently resolve the profile’s root ON CHAIN, recompute the root
of the supplied body, and REFUSE the call unless the two agree and that root is confirmed.
The caller’s root is a claim to be checked — never a fact to be trusted — and dig-app gets
no exemption: it holds the key and signs the root (§908), but the bytes reach the node the
same way a peer’s bytes do, and the same check binds both. An implementation that stores
what it is handed makes this node serve arbitrary bytes under someone else’s profile id.
A body whose DECODED length exceeds MAX_BODY_BYTES (4 MiB) MUST
be refused as INVALID_PARAMS, before it is persisted: a body larger than that cannot be
served to a peer inside dig-gossip’s frame ceiling, so accepting it would store something
permanently unsyncable.
Returning Ok therefore asserts BOTH that the root was confirmed on chain and that the body
is persisted and servable. A refusal is an error, never an Ok carrying stored: false.
Sourcefn profile_get_body<'life0, 'async_trait>(
&'life0 self,
params: ProfileGetBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfileGetBodyResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn profile_get_body<'life0, 'async_trait>(
&'life0 self,
params: ProfileGetBodyParams,
) -> Pin<Box<dyn Future<Output = Result<ProfileGetBodyResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
control.profile.getBody (READ-only, TOKEN-GATED)
Ok(body_b64: None) MUST mean “this node was consulted and holds no body at that root”. A
read that FAILED MUST return a catalogued error instead — a caller that reads a failure as
absence renders an existing profile as an empty one.
The returned root MUST be the root the caller asked for; a node MUST NOT substitute a
newer body it happens to hold.
Sourcefn pairing_request<'life0, 'async_trait>(
&'life0 self,
params: RequestParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRequestResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pairing_request<'life0, 'async_trait>(
&'life0 self,
params: RequestParams,
) -> Pin<Box<dyn Future<Output = Result<PairingRequestResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
pairing.request (OPEN)
Sourcefn pairing_poll<'life0, 'async_trait>(
&'life0 self,
params: PollParams,
) -> Pin<Box<dyn Future<Output = Result<PairingPollResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pairing_poll<'life0, 'async_trait>(
&'life0 self,
params: PollParams,
) -> Pin<Box<dyn Future<Output = Result<PairingPollResult, ControlError>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
pairing.poll (OPEN)
Provided Methods§
Sourcefn dispatch<'life0, 'async_trait>(
&'life0 self,
request: JsonRpcRequest,
) -> Pin<Box<dyn Future<Output = JsonRpcResponse> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn dispatch<'life0, 'async_trait>(
&'life0 self,
request: JsonRpcRequest,
) -> Pin<Box<dyn Future<Output = JsonRpcResponse> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Route a raw JSON-RPC request to the right typed method and build the response envelope.
Deserializes the params for methods that take them, calls the handler, and serializes the
typed result. An unknown method → METHOD_NOT_FOUND; malformed params → INVALID_PARAMS.
This is the single seam a server dispatches through — the KATs exercise it end-to-end.
Dyn Compatibility§
This trait is dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".