ootle-rs 0.5.0

A Rust library for interacting with the Tari Ootle network.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

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

use std::collections::HashSet;

use tari_ootle_common_types::{
    SubstateRequirement,
    engine_types::{limits, published_template::TemplateBlob},
};
use tari_ootle_template_metadata::MetadataHash;
use tari_ootle_transaction::{TransactionBuilder, UnsignedTransaction, args};
use tari_template_lib_types::{Amount, ResourceAddress, constants::TARI_TOKEN};

use crate::{
    Address,
    ToAccountAddress,
    builtin_templates::traits::UnsignedTransactionBuilder,
    provider::{Provider, ProviderError, WantInput},
};

pub type IAccount<'a, P> = AccountInvokeBuilder<'a, P>;

pub struct AccountInvokeBuilder<'a, P> {
    builder: TransactionBuilder,
    provider: &'a P,
    want_list: HashSet<WantInput>,
}

impl<'a, P: Provider> UnsignedTransactionBuilder for AccountInvokeBuilder<'a, P> {
    fn default_signer_address(&self) -> &Address {
        self.provider.default_signer_address()
    }

    fn add_input<S: Into<SubstateRequirement>>(mut self, substate_id: S) -> Self {
        self.builder = self.builder.add_input(substate_id);
        self
    }

    async fn prepare(self) -> Result<UnsignedTransaction, ProviderError> {
        let Self {
            builder,
            provider,
            want_list,
            ..
        } = self;
        let unsigned_tx = builder.build_unsigned();
        let unsigned_tx = provider.resolve_input_want_list(unsigned_tx, &want_list).await?;
        Ok(unsigned_tx)
    }
}

impl<'a, P: Provider> AccountInvokeBuilder<'a, P> {
    pub fn new(provider: &'a P) -> Self {
        let network = provider.network();
        Self {
            builder: TransactionBuilder::new(network).with_auto_fill_inputs(),
            provider,
            want_list: HashSet::new(),
        }
    }

    pub fn pay_fee<A: Into<Amount>>(mut self, amount: A) -> Self {
        let component_addr = self.default_signer_address().to_account_address();
        self.want_list.insert(WantInput::VaultForResource {
            component_address: component_addr,
            resource_address: TARI_TOKEN,
            required: true,
        });
        self.builder = self.builder.pay_fee_from_component(component_addr, amount);
        self
    }

    fn next_bucket_name(&mut self) -> String {
        format!("__AccountInvokeBuilder_{}", self.builder.next_workspace_id())
    }

    pub fn public_transfer<A: Into<Amount>>(
        mut self,
        to: &Address,
        resource_address: ResourceAddress,
        amount: A,
    ) -> Self {
        let amount: Amount = amount.into();
        if !amount.is_positive() {
            panic!("Transfer amount must be positive");
        }
        let from_component_addr = self.default_signer_address().to_account_address();
        let to_component_addr = to.to_account_address();
        let bucket_name = self.next_bucket_name();
        // We need the vault to pay from
        self.want_list.insert(WantInput::VaultForResource {
            component_address: from_component_addr,
            resource_address,
            required: true,
        });
        // We need the substate of the recipient account to deposit into, if it exists
        self.want_list.insert(WantInput::SpecificSubstate {
            substate_id: to_component_addr.into(),
            required: false,
        });
        // We need the vault to deposit into, if it exists
        self.want_list.insert(WantInput::VaultForResource {
            component_address: to_component_addr,
            resource_address,
            // If it doesn't exist, the  CreateAccount instruction will create it
            required: false,
        });

        self.builder = self
            .builder
            .call_method(from_component_addr, "withdraw", args![resource_address, amount])
            .put_last_instruction_output_on_workspace(&bucket_name)
            .create_account_with_bucket(*to.account_public_key(), bucket_name);
        self
    }

    // TODO: move common builder code into a builder trait
    pub fn publish_template<T: TryInto<TemplateBlob>>(mut self, template: T) -> Self {
        let Ok(template) = template.try_into() else {
            panic!(
                "Template blob exceeds maximum size of {} bytes",
                limits::ENGINE_LIMITS.max_template_binary_size_bytes
            );
        };
        self.builder = self.builder.publish_template(template);
        self
    }

    pub fn publish_template_with_metadata<T: TryInto<TemplateBlob>>(
        mut self,
        template: T,
        metadata_hash: MetadataHash,
    ) -> Self {
        let Ok(template) = template.try_into() else {
            panic!(
                "Template blob exceeds maximum size of {} bytes",
                limits::ENGINE_LIMITS.max_template_binary_size_bytes
            );
        };
        self.builder = self.builder.publish_template_with_metadata(template, metadata_hash);
        self
    }
}