miden-client-web 0.15.2

Web Client library that facilitates interaction with the Miden 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
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

use js_export_macro::js_export;
use miden_client::note::Note as NativeNote;
use miden_client::transaction::TransactionRequest as NativeTransactionRequest;
use miden_client::vm::AdviceMap as NativeAdviceMap;

use crate::models::advice_map::AdviceMap;
use crate::models::note::Note;
use crate::models::word::Word;
use crate::platform::{JsBytes, JsErr};
use crate::utils::{deserialize_from_bytes, serialize_to_bytes};

pub mod note_and_args;
pub mod note_details_and_tag;
pub mod note_id_and_args;
pub mod transaction_request_builder;

use note_details_and_tag::NoteDetailsAndTag;

/// Specifies a transaction request that can be executed by an account.
///
/// A request contains information about input notes to be consumed by the transaction (if any),
/// description of the transaction script to be executed (if any), and a set of notes expected to be
/// generated by the transaction or by consuming notes generated by the transaction.
#[derive(Clone)]
#[js_export]
pub struct TransactionRequest(NativeTransactionRequest);

#[js_export]
impl TransactionRequest {
    /// Serializes the transaction request into bytes.
    pub fn serialize(&self) -> JsBytes {
        serialize_to_bytes(&self.0)
    }

    /// Deserializes a transaction request from bytes.
    pub fn deserialize(bytes: JsBytes) -> Result<TransactionRequest, JsErr> {
        deserialize_from_bytes::<NativeTransactionRequest>(&bytes).map(TransactionRequest)
    }

    /// Returns output notes created by the sender account.
    #[js_export(js_name = "expectedOutputOwnNotes")]
    pub fn expected_output_own_notes(&self) -> Result<Vec<Note>, JsErr> {
        let native_notes: Vec<NativeNote> = self.0.expected_output_own_notes();
        let notes: Vec<Note> = native_notes.into_iter().map(Into::into).collect();
        Ok(notes)
    }

    /// Returns notes expected to be created in subsequent executions.
    #[js_export(js_name = "expectedFutureNotes")]
    pub fn expected_future_notes(&self) -> Result<Vec<NoteDetailsAndTag>, JsErr> {
        self.0
            .expected_future_notes()
            .cloned()  // This converts &(T, U) to (T, U)
            .map(|(note_details, note_tag)| {
                Ok(NoteDetailsAndTag::new(
                    note_details.into(),
                    note_tag.into()
                ))
            })
            .collect::<Result<Vec<NoteDetailsAndTag>, _>>()
    }

    /// Returns the transaction script argument if present.
    #[js_export(js_name = "scriptArg")]
    pub fn script_arg(&self) -> Option<Word> {
        self.0.script_arg().map(Word::from)
    }

    /// Returns the authentication argument if present.
    #[js_export(js_name = "authArg")]
    pub fn auth_arg(&self) -> Option<Word> {
        self.0.auth_arg().map(Word::from)
    }

    /// Returns a copy of the advice map carried by this request.
    #[js_export(js_name = "adviceMap")]
    pub fn advice_map(&self) -> AdviceMap {
        self.0.advice_map().into()
    }

    /// Returns a copy of this request with `advice_map` merged into its advice map.
    ///
    /// Entries are merged with last-write-wins semantics: a key already present in the request is
    /// overwritten by the value from `advice_map`. Use this to inject advice (e.g. a signature
    /// produced by an external signer) after the request has already been built.
    #[js_export(js_name = "extendAdviceMap")]
    pub fn extend_advice_map(&self, advice_map: &AdviceMap) -> TransactionRequest {
        let native_advice_map: NativeAdviceMap = advice_map.into();
        let mut native_request = self.0.clone();
        native_request
            .advice_map_mut()
            .extend(native_advice_map.iter().map(|(key, value)| (*key, value.clone())));
        native_request.into()
    }
}

// CONVERSIONS
// ================================================================================================

impl From<TransactionRequest> for NativeTransactionRequest {
    fn from(transaction_request: TransactionRequest) -> Self {
        transaction_request.0
    }
}

impl From<&TransactionRequest> for NativeTransactionRequest {
    fn from(transaction_request: &TransactionRequest) -> Self {
        transaction_request.0.clone()
    }
}

impl From<NativeTransactionRequest> for TransactionRequest {
    fn from(transaction_request: NativeTransactionRequest) -> Self {
        TransactionRequest(transaction_request)
    }
}

impl From<&NativeTransactionRequest> for TransactionRequest {
    fn from(transaction_request: &NativeTransactionRequest) -> Self {
        TransactionRequest(transaction_request.clone())
    }
}