dhatu 0.2.2

dhatu core libraries
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
144
145
146
147

use subxt::ext::sp_core::sr25519::Pair;

use crate::{
    registrar::{key_manager::prelude::PublicAddress, signer::TxBuilder},
    tx::extrinsics::{
        prelude::{
            extrinsics, reserve::FundsReserve, transfer_nft_contract::constructor::TransferNFT,
            ExtrinsicSubmitter,
        },
        transaction_constructor::calldata::Selector,
    },
    types::{NodeClient, Unit},
};

use super::{
    traits::{MigrationTransaction as Transaction, MigrationTransactionAttributes},
    types::{
        MigrationTransaction as SubmittableTransaction, MigrationTransactionPayload,
        MigrationTransactionResultNotifier,
    },
};

/// default fees for migration transaction
const STATIC_NFT_TRANSFER_FEE: &str = "0.009"; // 9  mili units (9mU)

/// migration transaction. wrap aroung raw substrate extrinsics.
/// providing method to ensure enough gas, sign and submit the transaction.
pub(crate) struct MigrationTransaction {
    signer: Pair,
    notifier: MigrationTransactionResultNotifier,
    reserve: FundsReserve,
    client: NodeClient,
    payload: Option<MigrationTransactionPayload>,
    inner_tx: Option<SubmittableTransaction>,
}

impl MigrationTransaction {
    pub fn new(
        signer: Pair,
        notifier: MigrationTransactionResultNotifier,
        reserve: FundsReserve,
        client: NodeClient,
        payload: Option<MigrationTransactionPayload>,
        inner_tx: Option<SubmittableTransaction>,
    ) -> Self {
        Self {
            signer,
            notifier,
            reserve,
            client,
            payload,
            inner_tx,
        }
    }

    /// construct migration transaction payload,
    /// usuallly called first.
    pub fn construct_payload(
        mut self,
        address: PublicAddress,
        to: PublicAddress,
        token_id: u32,
        function_selector: Selector,
    ) -> Self {
        let tx = TransferNFT::construct(address, to, token_id, function_selector).unwrap();

        self.payload = Some(tx);

        self
    }

    /// sign the constructed migration transaction payload
    pub async fn sign(mut self) -> Self {
        let client = self.client.clone();
        let acc = self.signer.clone();
        let payload = self
            .payload
            .take()
            .expect("migration payload not constructed");

        let tx = TxBuilder::signed(&client.into(), acc.into(), payload)
            .await
            .expect("should sign transaction");

        self.inner_tx = Some(tx.0);

        self
    }

    /// ensure enough gas for the transaction.
    /// currently this automatically transfer funds regardless of quota threshold.
    ///
    /// will send [9mu](STATIC_NFT_TRANSFER_FEE) to the signer.
    pub async fn ensure_enough_gas(self) -> Self {
        let account = self.signer.clone().into();

        // future implementation will dynamically check the threshold and then transfer.
        // currently this automatically transfer funds regardless of quota threshold
        let value =
            Unit::new(STATIC_NFT_TRANSFER_FEE, None).expect("static conversion should not fail");

        self.reserve.transfer_funds(account, value).await.unwrap();

        self
    }

    /// submit the transaction to the connected rpc node.
    pub async fn submit(mut self) -> crate::tx::extrinsics::prelude::extrinsics::Transaction {
        let tx = self
            .inner_tx
            .take()
            .expect("inner transaction should have been built");

        let progress = ExtrinsicSubmitter::submit(tx.into()).await.unwrap();
        let notifier_channel = self.notifier.clone();

        extrinsics::Transaction::new(progress, Some(notifier_channel), None)
    }
}

impl MigrationTransactionAttributes for MigrationTransaction {
    fn signer(&self) -> &Pair {
        &self.signer
    }

    fn notifier(&self) -> &MigrationTransactionResultNotifier {
        &self.notifier
    }

    fn reserve(&self) -> &FundsReserve {
        &self.reserve
    }

    fn client(&self) -> &NodeClient {
        &self.client
    }

    fn payload(&self) -> Option<&MigrationTransactionPayload> {
        self.payload.as_ref()
    }

    fn inner_tx(&self) -> Option<&SubmittableTransaction> {
        self.inner_tx.as_ref()
    }
}

impl Transaction for MigrationTransaction {}