Struct interledger_service_util::ExchangeRateService

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

Exchange Rates Service

Responsible for getting the exchange rates for the two assets in the outgoing request (request.from.asset_code, request.to.asset_code). Requires a ExchangeRateStore

Methods

impl<S, O, A> ExchangeRateService<S, O, A> where
    S: AddressStore + ExchangeRateStore,
    O: OutgoingService<A>,
    A: Account, 

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

Trait Implementations

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

fn clone(&self) -> ExchangeRateService<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 ExchangeRateService<S, O, A> where
    S: AddressStore + ExchangeRateStore + Clone + Send + Sync + 'static,
    O: OutgoingService<A> + Send + Clone + 'static,
    A: Account + Sync + 'static, 

type Future = BoxedIlpFuture

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

On send request:

1. If the prepare packet's amount is 0, it just forwards
2. Retrieves the exchange rate from the store (the store independently is responsible for polling the rates)
   • return reject if the call to the store fails
3. Calculates the exchange rate AND scales it up/down depending on how many decimals each asset requires
4. Updates the amount in the prepare packet and forwards it

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.