Struct Submit

pub struct Submit<'a> {
    pub common_fields: CommonFields<'a>,
    pub tx_blob: Cow<'a, str>,
    pub fail_hard: Option<bool>,
}

The submit method applies a transaction and sends it to the network to be confirmed and included in future ledgers.

This command has two modes:

• Submit-only mode takes a signed, serialized transaction as a binary blob, and submits it to the network as-is. Since signed transaction objects are immutable, no part of the transaction can be modified or automatically filled in after submission.
• Sign-and-submit mode takes a JSON-formatted Transaction object, completes and signs the transaction in the same manner as the sign method, and then submits the signed transaction. We recommend only using this mode for testing and development.

To send a transaction as robustly as possible, you should construct and sign it in advance, persist it somewhere that you can access even after a power outage, then submit it as a tx_blob. After submission, monitor the network with the tx method command to see if the transaction was successfully applied; if a restart or other problem occurs, you can safely re-submit the tx_blob transaction: it won’t be applied twice since it has the same sequence number as the old transaction.

See Submit: <https://xrpl.org/submit.html>

Fields

common_fields: CommonFields<'a>

The common fields shared by all requests.

tx_blob: Cow<'a, str>

Hex representation of the signed transaction to submit. This can also be a multi-signed transaction.

fail_hard: Option<bool>

If true, and the transaction fails locally, do not retry or relay the transaction to other servers

Implementations

impl<'a> Submit<'a>

pub fn new( id: Option<Cow<'a, str>>, tx_blob: Cow<'a, str>, fail_hard: Option<bool>, ) -> Self

Trait Implementations

impl<'a> Clone for Submit<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Submit<'a>

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

Converts to this type from the input type.

impl<'a> Model for Submit<'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 Submit<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Request<'a> for Submit<'a>

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

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

impl<'a> Serialize for Submit<'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> Eq for Submit<'a>

impl<'a> StructuralPartialEq for Submit<'a>