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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

use std::result;

use ex3_node_error::Error;

#[cfg(feature = "test")]
pub use tx_type_dto::*;

mod decoder;

mod tx_type_dto;

pub type Result<T> = result::Result<T, Error>;

pub struct PayloadDecoder;

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use bincode;
    use ex3_node_types::package::{EncodeTransactionPackage, TransactionPackage};
    use ex3_node_types::transaction::{Transaction, TransactionType};
    use log::*;
    use pretty_env_logger;

    use super::*;

    #[test]
    fn test_decoder() {
        pretty_env_logger::init();
        let mut type_hash_set = HashSet::new();
        let tx_packages = get_mock_tx_packages();
        for tx_package in tx_packages {
            for tx in tx_package.txs {
                let decoded_tx: Transaction = tx.into();
                debug!("r#type: {:?}", decoded_tx.r#type);
                debug!("payload_hex: {}", hex::encode(decoded_tx.payload.as_ref()));
                type_hash_set.insert(decoded_tx.r#type);
                match decoded_tx.r#type {
                    ex3_node_types::transaction::TransactionType::WalletRegister => {
                        let _ = PayloadDecoder::decode_to_wallet_identifier(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::Deposit => {
                        let _ =
                            PayloadDecoder::decode_to_deposit(decoded_tx.payload.as_ref()).unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::Withdrawal => {
                        let _ = PayloadDecoder::decode_to_withdrawal(decoded_tx.payload.as_ref())
                            .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::Transfer => {
                        let _ = PayloadDecoder::decode_to_transfer(decoded_tx.payload.as_ref())
                            .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::ResetMainSecret => {
                        let _ = PayloadDecoder::decode_to_reset_main_secret(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::CreateApiSecret => {
                        let _ = PayloadDecoder::decode_to_create_api_secret(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::DestroyApiSecret => {
                        let _ = PayloadDecoder::decode_to_destroy_api_secret(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::SubmitSpotOrder => {
                        let _ = PayloadDecoder::decode_to_submit_spot_order(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::CancelSpotOrder => {
                        let _ = PayloadDecoder::decode_to_cancel_spot_order(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::AddAmmV2Liquidity => {
                        let _ = PayloadDecoder::decode_to_add_amm_v2_liquidity(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::RemoveAmmV2Liquidity => {
                        let _ = PayloadDecoder::decode_to_remove_amm_v2_liquidity(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }

                    ex3_node_types::transaction::TransactionType::RegisterAsset => {
                        let _ =
                            PayloadDecoder::decode_to_register_asset(decoded_tx.payload.as_ref())
                                .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateGlobalWithdrawalFeeTo => {
                        let _ = PayloadDecoder::decode_to_update_global_withdrawal_fee_to(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateAssetWithdrawalFeeTo => {
                        let _ = PayloadDecoder::decode_to_update_asset_withdrawal_fee_to(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateChainConfirmationTimes => {
                        let _ = PayloadDecoder::decode_to_update_chain_confirmation_times(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::RegisterSpotMarket => {
                        let _ =
                            PayloadDecoder::decode_to_register_spot_market(decoded_tx.payload.as_ref())
                                .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateSpotMarketTradingSettings => {
                        let _ = PayloadDecoder::decode_to_update_spot_market_trading_settings(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateMarketInitialFeeTo => {
                        let _ = PayloadDecoder::decode_to_update_market_global_fee_to(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateSpotMarketFeeTo => {
                        let _ = PayloadDecoder::decode_to_update_spot_market_fee_to(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateSpotMarketInitialFee => {
                        let _ = PayloadDecoder::decode_to_update_market_global_fee(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                    ex3_node_types::transaction::TransactionType::UpdateSpotMarketFee => {
                        let _ = PayloadDecoder::decode_to_update_spot_market_fee(
                            decoded_tx.payload.as_ref(),
                        )
                        .unwrap();
                    }
                }
            }
        }

        info!("type_hash_set: {:?}", type_hash_set);
        let mut expected_set = HashSet::from_iter(TransactionType::iterator());
        expected_set.remove(&TransactionType::CreateApiSecret);
        expected_set.remove(&TransactionType::DestroyApiSecret);
        let missing_set: HashSet<TransactionType> =
            expected_set.difference(&type_hash_set).cloned().collect();
        assert!(missing_set.is_empty(), "missing_set: {:?}", missing_set);
    }

    fn get_mock_tx_packages() -> Vec<TransactionPackage> {
        let mut file = std::fs::File::open(
            "/home/newbe36524/Repos/deland/ex3-bussiness-node/src/bn_test_tx_package.dat",
        )
        .unwrap();
        let encoded_tx_packages: Vec<EncodeTransactionPackage> =
            bincode::deserialize_from(&mut file).unwrap();
        let tx_packages: Vec<TransactionPackage> = encoded_tx_packages
            .iter()
            .map(|tx| TransactionPackage::from(tx.clone()))
            .collect();

        tx_packages
    }
}