nado-sdk 0.3.4

Official Rust SDK for the Nado Protocol API
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

use std::time::Duration;

use ethers::abi::AbiEncode;
use ethers::types::Bytes;
use ethers::types::TransactionReceipt;
use eyre::Result;

use crate::bindings::endpoint::endpoint;
use crate::math::to_i128_x18;
use crate::math::ONE_X6;
use crate::tx::TxType;

use crate::builders::execute::slow_mode::SubmitSlowModeTxParams;
use crate::core::execute::NadoExecute;
use crate::utils::client_error::none_error;
use crate::{build_and_call, fields_to_vars, nado_builder};

nado_builder!(
    DepositInsuranceBuilder,
    NadoExecute,
    amount: u128,
    mints_tokens: bool,
    approves_allowance: bool,
    erc20_sleep_secs: u64,
    gas_price: u128;

    pub async fn deposit_and_await_balance(&self) -> Result<Option<TransactionReceipt>> {
        let expected_balance = self.calculate_expected_balance().await?;
        if self.nado.is_rest_client() {
            self.handle_erc20().await?;
        }
        let tx_hash = self.execute().await?;
        self.await_expected_balance(expected_balance).await?;
        Ok(tx_hash)
    }

    async fn handle_erc20(&self) -> Result<()> {
        fields_to_vars!(self, amount);
        let sleep = self.erc20_sleep_secs.unwrap_or_default();
        if self.mints_tokens.unwrap_or(false) {
            self.nado.mint_mock_erc20(0, amount).await?;
            tokio::time::sleep(Duration::from_secs(sleep)).await;
        }
        if self.approves_allowance.unwrap_or(false) {
            self.nado.approve_endpoint_allowance(0, amount).await?;
            tokio::time::sleep(Duration::from_secs(sleep)).await;
        }
        Ok(())
    }

    async fn calculate_expected_balance(&self) -> Result<i128> {
        fields_to_vars!(self, amount);
        let mut amount = amount as i128 / ONE_X6;
        amount = to_i128_x18(amount);
        let pre_balance = self.nado.get_insurance().await?.insurance;

        Ok(pre_balance + amount)
    }

    async fn await_expected_balance(&self, expected_balance: i128) -> Result<()> {
        loop {
            println!("waiting for deposit...");
            let insurance = self.nado.get_insurance().await?.insurance;
            if insurance >= expected_balance {
                return Ok(());
            }
            tokio::time::sleep(Duration::from_millis(500)).await;
        }
    }

    build_and_call!(self, execute, submit_slow_mode_tx => Option<TransactionReceipt>);

    pub fn build(&self) -> Result<SubmitSlowModeTxParams> {
        fields_to_vars!(self, amount);

        let tx = deposit_insurance_bytes(amount);

        Ok(SubmitSlowModeTxParams {
            tx,
            mints_fee: false,
            approves_fee: false,
            erc20_sleep_secs: self.erc20_sleep_secs,
            gas_price: self.gas_price
        })
    }

);

// TODO: this only deposits into cross group
pub fn deposit_insurance_bytes(amount: u128) -> Bytes {
    let tx_bytes = AbiEncode::encode(endpoint::UnsignedDepositInsuranceReturn(
        endpoint::DepositInsurance { amount },
    ));
    Bytes::from([vec![TxType::DepositInsurance as u8], tx_bytes].concat())
}