zingolib 0.0.1

Zingo backend library.
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

//! This mod is mostly to take inputs, raw data amd convert it into lightclient actions
//! (obviously) in a test environment.

use zcash_primitives::transaction::TxId;
use zcash_protocol::{PoolType, ShieldedProtocol};

use crate::{
    lightclient::{LightClient, describe::UAReceivers, error::LightClientError},
    wallet::LightWallet,
};

/// Create a lightclient from the buffer of another
pub async fn new_client_from_save_buffer(
    template_client: &mut LightClient,
) -> Result<LightClient, LightClientError> {
    let mut wallet_bytes: Vec<u8> = vec![];
    template_client
        .wallet
        .lock()
        .await
        .write(&mut wallet_bytes, &template_client.config.chain)
        .await?;

    LightClient::create_from_wallet(
        LightWallet::read(wallet_bytes.as_slice(), template_client.config.chain)?,
        template_client.config.clone(),
        false,
    )
}
/// gets the first address that will allow a sender to send to a specific pool, as a string
/// calling \[0] on json may panic? not sure -fv
pub async fn get_base_address(client: &LightClient, pooltype: PoolType) -> String {
    match pooltype {
        PoolType::Transparent => {
            client.do_addresses(UAReceivers::All).await[0]["receivers"]["transparent"]
                .clone()
                .to_string()
        }
        PoolType::Shielded(ShieldedProtocol::Sapling) => {
            client.do_addresses(UAReceivers::All).await[0]["receivers"]["sapling"]
                .clone()
                .to_string()
        }
        PoolType::Shielded(ShieldedProtocol::Orchard) => {
            client.do_addresses(UAReceivers::All).await[0]["address"]
                .take()
                .to_string()
        }
    }
}
/// Get the total fees paid by a given client (assumes 1 capability per client).
pub async fn get_fees_paid_by_client(client: &LightClient) -> u64 {
    client.transaction_summaries().await.unwrap().paid_fees()
}
/// Helpers to provide raw_receivers to lightclients for send and shield, etc.
pub mod from_inputs {

    use nonempty::NonEmpty;
    use zcash_primitives::transaction::TxId;

    use crate::{
        lightclient::{LightClient, error::QuickSendError},
        wallet::error::ProposeSendError,
    };

    /// Panics if the address, amount or memo conversion fails.
    pub async fn quick_send(
        quick_sender: &mut crate::lightclient::LightClient,
        raw_receivers: Vec<(&str, u64, Option<&str>)>,
    ) -> Result<NonEmpty<TxId>, QuickSendError> {
        let request = transaction_request_from_send_inputs(raw_receivers)
            .expect("should be able to create a transaction request as receivers are valid.");
        quick_sender.quick_send(request).await
    }

    /// Panics if the address, amount or memo conversion fails.
    pub(crate) fn receivers_from_send_inputs(
        raw_receivers: Vec<(&str, u64, Option<&str>)>,
    ) -> crate::data::receivers::Receivers {
        raw_receivers
            .into_iter()
            .map(|(address, amount, memo)| {
                let recipient_address = crate::utils::conversion::address_from_str(address)
                    .expect("should be a valid address");
                let amount = crate::utils::conversion::zatoshis_from_u64(amount)
                    .expect("should be inside the range of valid zatoshis");
                let memo = memo.map(|memo| {
                    crate::wallet::utils::interpret_memo_string(memo.to_string())
                        .expect("should be able to interpret memo")
                });

                crate::data::receivers::Receiver::new(recipient_address, amount, memo)
            })
            .collect()
    }

    /// Creates a [`zcash_client_backend::zip321::TransactionRequest`] from rust primitives for simplified test writing.
    pub fn transaction_request_from_send_inputs(
        raw_receivers: Vec<(&str, u64, Option<&str>)>,
    ) -> Result<
        zcash_client_backend::zip321::TransactionRequest,
        zcash_client_backend::zip321::Zip321Error,
    > {
        let receivers = receivers_from_send_inputs(raw_receivers);
        crate::data::receivers::transaction_request_from_receivers(receivers)
    }

    /// Panics if the address, amount or memo conversion fails.
    pub async fn propose(
        proposer: &mut LightClient,
        raw_receivers: Vec<(&str, u64, Option<&str>)>,
    ) -> Result<crate::data::proposal::ProportionalFeeProposal, ProposeSendError> {
        let request = transaction_request_from_send_inputs(raw_receivers)
            .expect("should be able to create a transaction request as receivers are valid.");
        proposer.propose_send(request).await
    }
}

/// gets stati for a vec of txids
pub async fn lookup_statuses(
    client: &LightClient,
    txids: nonempty::NonEmpty<TxId>,
) -> nonempty::NonEmpty<Option<zingo_status::confirmation_status::ConfirmationStatus>> {
    let wallet = client.wallet.lock().await;

    txids.map(|txid| {
        wallet
            .wallet_transactions
            .get(&txid)
            .map(|transaction_record| transaction_record.status())
    })
}