Enum CurrencyAmount 

pub enum CurrencyAmount {
    XRP(BigInt),
    IssuedCurrency(IssuedCurrencyAmount),
}

Variants

XRP(BigInt)

IssuedCurrency(IssuedCurrencyAmount)

Implementations

impl CurrencyAmount

pub fn xrp(drops: u64) -> Self

Examples found in repository

examples/account_submit_payment.rs (line 35)

async fn main() {
    // Generate testnet credentials.
    let creds_one = testnet::get_testnet_credentials()
        .await
        .expect("error generating testnet credentials");
    println!("Created account: {:?}", creds_one);

    // Create a new XRPL client with the HTTP transport pointed at ripple testnet.
    let xrpl = XRPL::new(
        HTTP::builder()
            .with_endpoint("https://s.altnet.rippletest.net:51234/")
            .unwrap()
            .build()
            .unwrap(),
    );

    // Create wallet from secret
    let mut wallet =
        Wallet::from_secret(&creds_one.account.secret).unwrap();

    // Create a payment transaction.
    let mut payment = Payment::default();
    payment.amount = CurrencyAmount::xrp(100000000);
    payment.destination = "rp7pmm4rzTGmtZDuvrG1z9Xrm3KwHRipDw".to_owned(); // Set the destination to the second account.

    // Convert the payment into a transaction.
    let mut tx = payment.into_transaction();

    let tx_blob = wallet.fill_and_sign(&mut tx, &xrpl).await.unwrap();

    println!("Transaction: {:?}", tx);

    // Create a sign_and_submit request.
    let mut submit_req = SubmitRequest::default();
    submit_req.tx_blob = tx_blob;

    // Submit the transaction to the ledger.
    let submit_res = xrpl
        .submit(submit_req)
        .await
        .expect("failed to make submit request");
    println!("Got response to submit request: {:?}", submit_res);

    // Create an account info request to see the balance of account two.
    let mut req = AccountInfoRequest::default();
    // Set the account to the second set of testnet credentials.
    req.account = "rp7pmm4rzTGmtZDuvrG1z9Xrm3KwHRipDw".to_owned();
    // Fetch the account info for an address.
    let account_info = xrpl
        .account_info(req)
        .await
        .expect("failed to make account_info request");
    // Print the account and balance
    println!(
        "Address {} has balance of {:?}",
        account_info.account_data.account, account_info.account_data.balance
    );
}

pub fn issued_currency(value: Decimal, currency: &str, issuer: &Address) -> Self

Trait Implementations

impl Clone for CurrencyAmount

fn clone(&self) -> CurrencyAmount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CurrencyAmount

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

Formats the value using the given formatter.

impl Default for CurrencyAmount

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CurrencyAmount

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CurrencyAmount

fn eq(&self, other: &CurrencyAmount) -> 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 Serialize for CurrencyAmount

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CurrencyAmount

impl StructuralPartialEq for CurrencyAmount