Struct PathFind 

pub struct PathFind<'a> {
    pub common_fields: CommonFields<'a>,
    pub destination_account: Cow<'a, str>,
    pub destination_amount: Currency<'a>,
    pub source_account: Cow<'a, str>,
    pub subcommand: PathFindSubcommand,
    pub paths: Option<Vec<Path<'a>>>,
    pub send_max: Option<Currency<'a>>,
}

WebSocket API only! The path_find method searches for a path along which a transaction can possibly be made, and periodically sends updates when the path changes over time. For a simpl<’a>er version that is supported by JSON-RPC, see the ripple_path_find method. For payments occurring strictly in XRP, it is not necessary to find a path, because XRP can be sent directly to any account.

Although the rippled server tries to find the cheapest path or combination of paths for making a payment, it is not guaranteed that the paths returned by this method are, in fact, the best paths. Due to server load, pathfinding may not find the best results. Additionally, you should be careful with the pathfinding results from untrusted servers. A server could be modified to return less-than-optimal paths to earn money for its operators. If you do not have your own server that you can trust with pathfinding, you should compare the results of pathfinding from multiple servers run by different parties, to minimize the risk of a single server returning poor results. (Note: A server returning less-than-optimal results is not necessarily proof of malicious behavior; it could also be a symptom of heavy server load.)

See Path Find: <https://xrpl.org/path_find.html>

Fields

common_fields: CommonFields<'a>

The common fields shared by all requests.

destination_account: Cow<'a, str>

Unique address of the account to find a path to. (In other words, the account that would receive a payment.)

destination_amount: Currency<'a>

Currency Amount that the destination account would receive in a transaction. Special case: New in: rippled 0.30.0 You can specify “-1” (for XRP) or provide -1 as the contents of the value field (for non-XRP currencies). This requests a path to deliver as much as possible, while spending no more than the amount specified in send_max (if provided).

source_account: Cow<'a, str>

Unique address of the account to find a path from. (In other words, the account that would be sending a payment.)

subcommand: PathFindSubcommand

Use “create” to send the create sub-command.

paths: Option<Vec<Path<'a>>>

Array of arrays of objects, representing payment paths to check. You can use this to keep updated on changes to particular paths you already know about, or to check the overall cost to make a payment along a certain path.

send_max: Option<Currency<'a>>

Currency Amount that would be spent in the transaction. Not compatible with source_currencies.

Implementations

impl<'a> PathFind<'a>

pub fn new( id: Option<Cow<'a, str>>, destination_account: Cow<'a, str>, destination_amount: Currency<'a>, source_account: Cow<'a, str>, subcommand: PathFindSubcommand, paths: Option<Vec<Vec<PathStep<'a>>>>, send_max: Option<Currency<'a>>, ) -> Self

Trait Implementations

impl<'a> Clone for PathFind<'a>

fn clone(&self) -> PathFind<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PathFind<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for PathFind<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Eq for PathFind<'a>

impl<'a> From<PathFind<'a>> for XRPLRequest<'a>

fn from(request: PathFind<'a>) -> Self

Converts to this type from the input type.

impl<'a> Model for PathFind<'a>

fn get_errors(&self) -> XRPLModelResult<()>

Collects a models errors and returns the first error that occurs.

fn validate(&self) -> XRPLModelResult<()>

Simply forwards the error from get_errors if there was one.

fn is_valid(&self) -> bool

Checks if the model is valid.

impl<'a> PartialEq for PathFind<'a>

fn eq(&self, other: &PathFind<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> Request<'a> for PathFind<'a>

fn get_common_fields(&self) -> &CommonFields<'a>

fn get_common_fields_mut(&mut self) -> &mut CommonFields<'a>

impl<'a> Serialize for PathFind<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for PathFind<'a>