Struct interledger_service_util::MaxPacketAmountService

pub struct MaxPacketAmountService<I, S> { /* fields omitted */ }

MaxPacketAmount Service

This service is used by nodes to limit the maximum value of each packet they are willing to forward. Nodes may limit the packet amount for a variety of reasons:

• Liquidity: a node operator may not way to allow a single high-value packet to tie up a large portion of its liquidity at once (especially because they do not know whether the packet will be fulfilled or rejected)
• Security: each packet carries some risk, due to the possibility that a node's failure to pass back the fulfillment within the available time window would cause that node to lose money. Keeping the value of each individual packet low may help reduce the impact of such a failure Signaling: nodes SHOULD set the maximum packet amount lower than the maximum amount in flight (also known as the payment or money bandwidth). T04: Insufficient Liquidity errors do not communicate to the sender how much they can send, largely because the "available liquidity" may be time based or based on the rate of other payments going through and thus difficult to communicate effectively. In contrast, the F08: Amount Too Large error conveys the maximum back to the sender, because this limit is assumed to be a static value, and alllows sender-side software like STREAM implementations to respond accordingly. Therefore, setting the maximum packet amount lower than the total money bandwidth allows client implementations to quickly adjust their packet amounts to appropriate levels. Requires a MaxPacketAmountAccount and no store.

Methods

impl<I, S> MaxPacketAmountService<I, S>

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

Trait Implementations

impl<I: Clone, S: Clone> Clone for MaxPacketAmountService<I, S>

fn clone(&self) -> MaxPacketAmountService<I, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, S, A> IncomingService<A> for MaxPacketAmountService<I, S> where
    I: IncomingService<A>,
    S: AddressStore,
    A: MaxPacketAmountAccount, 

type Future = BoxedIlpFuture

fn handle_request(&mut self, request: IncomingRequest<A>) -> Self::Future

On receive request:

1. if request.prepare.amount <= request.from.max_packet_amount forward the request, else error

fn wrap<F, R>(self, f: F) -> WrappedService<F, Self, A> where
    F: Fn(IncomingRequest<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.