Struct BandwidthController 

pub struct BandwidthController<St> { /* private fields */ }

Owns all ecash credential state and is the single writer to the credential Storage.

It serves ticket spending, credential acquisition, and global signing-data retrieval while keeping storage consistent by being the only component that writes to it. The acquisition and retrieval work is delegated to two pluggable, storage-free fetchers: they only do the network/cryptographic work and hand the results back for the controller to persist.

• CredentialPublicDataFetcher (public_data_fetcher): lazily retrieves the global ecash signing materials - master verification key, coin-index and expiration-date signatures - when they’re missing locally.
• CredentialFetcher (credential_fetcher): provisions usable ticketbooks (making deposits and aggregating wallet signatures). It is a superset of the public-data fetcher, so installing one via Self::with_credential_fetcher also registers it as the public-data fetcher.

It can be driven two ways:

• Self::run — the event loop: handles requests from BandwidthControllerRequestSender and, on native targets, proactively restocks low ticket types in the background, keeps the global data topped up, and resolves wait_for_ticketbooks readiness waiters as fetches complete.
• directly on a non-running instance — e.g. Self::fetch_ticketbook or Self::prepare_ecash_ticket — for one-shot use without spawning the loop.

Implementations

impl<St: Storage> BandwidthController<St>

pub fn new(storage: St) -> Self

pub fn with_config(self, config: BandwidthControllerConfig) -> Self

pub fn with_credential_fetcher( self, fetcher: impl CredentialFetcher + 'static, ) -> Self

pub fn with_credential_public_data_fetcher( self, fetcher: impl CredentialPublicDataFetcher + 'static, ) -> Self

pub fn get_request_sender(&self) -> BandwidthControllerRequestSender

Get the request channel used to send request to the controller. Request are handled only if the BandwidthController is running using run

pub async fn run(self, shutdown_token: ShutdownToken)

Runs the controller event loop, handling incoming requests until the request channel is closed or cancellation is requested. Additionally drives the proactive restock timer and drains completed background fetches.

pub async fn prepare_ecash_ticket( &self, ticketbook_type: TicketType, provider_pk: [u8; 32], tickets_to_spend: u32, spend_time: OffsetDateTime, ) -> Result<Option<PreparedCredential>, BandwidthControllerError>

pub async fn get_next_usable_ticketbook( &self, ticketbook_type: TicketType, tickets: u32, ) -> Result<Option<RetrievedTicketbook>, BandwidthControllerError>

Tries to retrieve one of the stored, unused credentials for the given type that hasn’t yet expired.

pub async fn fetch_ticketbook( &self, ticketbook_type: TicketType, ) -> Result<(), BandwidthControllerError>

Fetches a ticketbook of ticketbook_type via the configured credential fetcher and persists it (together with the global signing materials it needs). The fetch runs inline, so this works on a controller that isn’t running its event loop - suitable for one-shot issuance.

Trait Implementations

impl<St: Storage> BandwidthTicketProvider for BandwidthController<St>

fn get_ecash_ticket<'life0, 'async_trait>( &'life0 self, ticket_type: TicketType, gateway_id: PublicKey, tickets_to_spend: u32, spend_time: OffsetDateTime, ) -> Pin<Box<dyn Future<Output = Result<Option<PreparedCredential>, BandwidthControllerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_upgrade_mode_token<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, BandwidthControllerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn attempt_revert_spending<'life0, 'async_trait>( &'life0 self, metadata: PreparedCredentialMetadata, ) -> Pin<Box<dyn Future<Output = Result<bool, BandwidthControllerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,