algonaut 0.8.0

A Rusty sdk for the Algorand blockchain.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use crate::{Error, algod::v2::Algod};
use algonaut_core::TransactionId;
use algonaut_model::algod::PendingTransactionResponse;
use instant::Instant;
use std::time::Duration;

/// Default timeout for [`PendingSubmission::confirm`].
const DEFAULT_CONFIRM_TIMEOUT: Duration = Duration::from_secs(60);

/// Handle returned by [`Algod::submit`], [`Algod::submit_transactions`] and
/// [`Algod::submit_raw`]. Carries the transaction id of the broadcast
/// transaction and knows how to poll algod for finality.
#[derive(Debug, Clone)]
pub struct PendingSubmission {
    algod: Algod,
    transaction_id: TransactionId,
}

impl PendingSubmission {
    pub(crate) fn new(algod: Algod, transaction_id: TransactionId) -> Self {
        Self {
            algod,
            transaction_id,
        }
    }

    /// Transaction id of the broadcast transaction.
    pub fn transaction_id(&self) -> &TransactionId {
        &self.transaction_id
    }

    /// Poll algod until the transaction is confirmed. Uses a 60s default
    /// timeout — call [`PendingSubmission::confirm_with`] to override.
    pub async fn confirm(self) -> Result<PendingTransactionResponse, Error> {
        self.confirm_with(DEFAULT_CONFIRM_TIMEOUT).await
    }

    /// Poll algod until the transaction is confirmed, returning
    /// [`Error::PendingTransactionTimeout`] if the supplied `timeout`
    /// elapses first.
    ///
    /// Between checks, waits on algod's `wait-for-block-after/{round}`
    /// long-poll rather than a fixed timer — the future stays parked
    /// until the next block lands, so the cadence is network-driven
    /// (~3–4s) instead of an arbitrary 250ms tick.
    ///
    /// If algod reports the transaction was kicked out of its pool
    /// (`pool-error` non-empty — e.g. expired, underfunded, group
    /// invalid), this returns
    /// [`Error::PendingTransactionPoolError`] immediately rather than
    /// waiting out the timeout.
    pub async fn confirm_with(
        self,
        timeout: Duration,
    ) -> Result<PendingTransactionResponse, Error> {
        let start = Instant::now();
        let mut last_round = self.algod.status().await?.last_round;
        loop {
            let pending = self.algod.pending_transaction(&self.transaction_id).await?;
            if pending.confirmed_round.is_some() {
                return Ok(pending);
            }
            if !pending.pool_error.is_empty() {
                return Err(Error::PendingTransactionPoolError {
                    reason: pending.pool_error,
                });
            }
            if start.elapsed() >= timeout {
                return Err(Error::PendingTransactionTimeout { timeout });
            }
            last_round = self.algod.status_after_block(last_round).await?.last_round;
        }
    }
}