Skip to main content

ControlHandler

dig_node_control_interface::traits

Trait ControlHandler 

Source 
pub trait ControlHandler: Sync {

Show 49 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 capsule_fetch<'life0, 'async_trait>(
        &'life0 self,
        params: CapsuleFetchParams,
    ) -> Pin<Box<dyn Future<Output = Result<CapsuleFetchResult, 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 chia_peers_add<'life0, 'async_trait>(
        &'life0 self,
        params: ChiaPeersAddParams,
    ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersAddResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn chia_peers_list<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersListResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn chia_peers_remove<'life0, 'async_trait>(
        &'life0 self,
        params: ChiaPeersRemoveParams,
    ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersRemoveResult, 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§

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

fn capsule_fetch<'life0, 'async_trait>( &'life0 self, params: CapsuleFetchParams, ) -> Pin<Box<dyn Future<Output = Result<CapsuleFetchResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.capsule.fetch

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

fn chia_peers_add<'life0, 'async_trait>( &'life0 self, params: ChiaPeersAddParams, ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersAddResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.chiaPeers.add — start trusting a Chia full node the operator RUNS.

An implementation MUST write through to the ONE peer store its wallet replica reads; a second peer list is a drift bug waiting to happen.

Three obligations the shell cannot infer from the types:

  • it requires the MASTER token (ControlMethod::requires_master_token). The entry it writes carries authority that outlives the calling token, and control.pairing.revoke does not remove it;
  • params.ip is canonicalised with crate::params::canonical_peer_ip and STORED in that form, so remove and list can match what add wrote;
  • corroboration_bypassed reports the RESULTING trust state and notice carries the node’s own warning verbatim. Reporting a bypass that did not happen tells an operator they configured a node they did not.
Source

fn chia_peers_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersListResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.chiaPeers.list — the tracked Chia full-node peers, banned ones included.

Ordinary token tier: a read that confers nothing, and a paired client that cannot show the operator this list cannot show them the trust state they are subject to.

Source

fn chia_peers_remove<'life0, 'async_trait>( &'life0 self, params: ChiaPeersRemoveParams, ) -> Pin<Box<dyn Future<Output = Result<ChiaPeersRemoveResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.chiaPeers.remove — stop trusting a Chia full node.

MASTER token, like add. This is the ONLY un-trust remedy, so an implementation MUST return results::ChiaPeerRemovalOutcome::NoSuchPeer when nothing matched rather than reporting a removal it did not perform.

Source

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.

Source

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

Source

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

Source

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)

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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)

Source

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).

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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)

Source

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§

Source

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".

Implementors§