Struct interledger_service_util::BalanceService

pub struct BalanceService<S, O, A> { /* fields omitted */ }

Balance Service

Responsible for managing the balances of the account and the interaction with the Settlement Engine

Requires an Account and a BalanceStore

Methods

impl<S, O, A> BalanceService<S, O, A> where
    S: AddressStore + BalanceStore<Account = A> + SettlementStore<Account = A>,
    O: OutgoingService<A>,
    A: Account + SettlementAccount, 

pub fn new(store: S, next: O) -> Self

Trait Implementations

impl<S: Clone, O: Clone, A: Clone> Clone for BalanceService<S, O, A>

fn clone(&self) -> BalanceService<S, O, A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, O, A> OutgoingService<A> for BalanceService<S, O, A> where
    S: AddressStore + BalanceStore<Account = A> + SettlementStore<Account = A> + Clone + Send + Sync + 'static,
    O: OutgoingService<A> + Send + Clone + 'static,
    A: SettlementAccount + 'static, 

type Future = BoxedIlpFuture

fn send_request(
    &mut self,
    request: OutgoingRequest<A>
) -> Box<dyn Future<Item = Fulfill, Error = Reject> + Send>

On send message:

1. Calls store.update_balances_for_prepare with the prepare. If it fails, it replies with a reject
2. Tries to forward the request:
   • If it returns a fullfil, calls store.update_balances_for_fulfill and replies with the fulfill INDEPENDENTLY of if the call suceeds or fails. This makes a sendMoney call if the fulfill puts the account's balance over the settle_threshold
   • if it returns an reject calls store.update_balances_for_reject and replies with the fulfill INDEPENDENTLY of if the call suceeds or fails

fn wrap<F, R>(self, f: F) -> WrappedService<F, Self, A> where
    F: Fn(OutgoingRequest<A>, Self) -> R,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static,
    Self: Clone, 

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.