ootle-rs 0.4.1

A Rust library for interacting with the Tari Ootle network.
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

//   Copyright 2026 The Tari Project
//   SPDX-License-Identifier: BSD-3-Clause

use tari_ootle_transaction::{Transaction, UnsealedTransaction, UnsignedTransaction};

use crate::{
    transaction::TransactionSealSigner,
    wallet::{TransactionAuthorization, WalletResult},
};

#[derive(Clone, Debug, Default)]
pub struct Initial;
pub struct WithTx(UnsignedTransaction);

#[derive(Clone, Debug, Default)]
pub struct TransactionRequest<State = Initial> {
    state: State,
    authorizations: Vec<TransactionAuthorization>,
}

impl TransactionRequest<Initial> {
    pub fn new() -> Self {
        Self {
            state: Initial,
            authorizations: Vec::new(),
        }
    }

    pub fn with_transaction(self, builder: UnsignedTransaction) -> TransactionRequest<WithTx> {
        TransactionRequest {
            state: WithTx(builder),
            authorizations: self.authorizations,
        }
    }
}

impl<State> TransactionRequest<State> {
    pub fn add_authorization(mut self, auth: TransactionAuthorization) -> Self {
        self.authorizations.push(auth);
        self
    }

    pub fn with_authorizations<I>(mut self, auths: I) -> Self
    where I: IntoIterator<Item = TransactionAuthorization> {
        self.authorizations.extend(auths);
        self
    }
}

impl TransactionRequest<WithTx> {
    pub fn build_unsealed(self) -> UnsealedTransaction {
        self.state.0.finish()
    }

    pub async fn build(self, seal_signer: &dyn TransactionSealSigner) -> WalletResult<Transaction> {
        let builder = self.state.0;
        let unsealed = builder.with_signatures(self.authorizations.into_iter().map(|a| a.into_signature()).collect());
        let final_tx = seal_signer.seal_transaction(unsealed).await?;
        Ok(final_tx)
    }
}