Struct ChiaLightClient 

pub struct ChiaLightClient { /* private fields */ }

A subscribing Chia wallet-protocol light client over a shared PeerBackend.

Implementations

impl ChiaLightClient

pub async fn new(backend: Arc<PeerBackend>, request_timeout: Duration) -> Self

Builds a light client over backend’s pool and starts the drive-loop that keeps its subscription cache current.

No connection is made here: the pool is already holding sessions, and this client pins one of them the first time it subscribes.

pub async fn subscribe_coins( &self, coin_ids: Vec<Bytes32>, ) -> Result<(), LightClientError>

Subscribes to coin_ids on the anchor session and seeds the cache with their current state.

Wraps request_coin_state(subscribe = true); future changes stream back via the drive-loop.

pub async fn subscribe_puzzle_hashes( &self, puzzle_hashes: Vec<Bytes32>, filters: CoinStateFilters, ) -> Result<(), LightClientError>

Subscribes to every coin paying to puzzle_hashes under filters, seeding the cache.

Wraps request_puzzle_state(subscribe = true) (paging until finished).

pub async fn submit_spend( &self, bundle: SpendBundle, ) -> Result<SubmitOutcome, LightClientError>

Submits bundle to the network, mapping the node’s ack to a typed SubmitOutcome.

This is a WRITE path and is deliberately NOT part of the reads-only ChainSource surface.

pub async fn peak(&self) -> Option<(u32, Bytes32)>

The current peak (height, header_hash) as observed on the followed session, if known.

Deliberately the FOLLOWED peer’s peak and not PeerPool::peak_height, which is the highest any held peer has claimed. The cache’s coin states come from one session, and the no-coin-above-the-peak invariant that keeps a confirmation count from underflowing is only meaningful if the peak came from the same session as the coins.

pub async fn unsubscribe_coins( &self, coin_ids: Vec<Bytes32>, ) -> Result<(), LightClientError>

Removes the subscription to coin_ids and stops tracking them locally.

pub fn needs_rearm(&self) -> bool

Whether the followed session has ENDED, so the subscription set is no longer armed anywhere.

A consumer polling this can tell a chain with nothing to say from a stream that stopped talking — the distinction a silent light client otherwise hides.

pub async fn reconnect(&self) -> Result<(), LightClientError>

Re-anchors on a live pooled session and re-arms the existing subscription set, so a dropped connection recovers without the caller re-subscribing.

Cheaper than its chia-peer ancestor by exactly one dial: the pool is already holding replacement sessions, so this re-issues subscriptions rather than reconnecting.

pub async fn as_chain_source_provider( &self, handle: Handle, ) -> LightClientProvider

Exposes the read side as a LightClientProvider for registration in a chain-source registry.

handle MUST belong to a multi-thread tokio runtime (the sync facade blocks on it).

Call this AFTER subscribing. The descriptor’s ProviderKind is read from the session this client is actually anchored to, and before the first subscription there is none — so an early call reports the conservative Custom rather than guessing.

pub async fn provider_info(&self) -> ProviderInfo

The provider descriptor this client registers with.

LocalNode when the answering session was reached from a configured or co-resident address, Custom when it came from a DNS introducer. This is what the pool OBSERVED, not what an operator declared — chia-peer derived the same field from a config flag, so a discovered peer answering a config.endpoint client was reported as the operator’s own node.

trustless is always false: a light-client answer is one peer’s word. The registry’s custody view is operator-assigned and fails closed, and this flag is advisory there — it never grants trust, which is why reporting the origin honestly matters more than the priority does.

Trait Implementations

impl Drop for ChiaLightClient

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.