ex3-block-builder 0.15.29

EX3 block report data structure.
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
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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

use crate::{BlockBuilder, SnapshotVaultIndex};
use ex3_blockchain_public_types::{ActivatedSecretVault, SnapshotCursor};
use ex3_canister_types::range::ReportRange;
use ex3_crypto::sha256;
use ex3_node_types::number::Ex3Uint;
use ex3_node_types::range::CandidRange;
use ex3_node_types::transaction::EncodedTransaction;
use ex3_node_types::{BlockHeight, SecretVaultSeqId, WalletRegistrySeqId};
use ex3_node_types::{MerkleNode, WalletRegisterId};
use ex3_secret_vault_public_types::SecretUpdateTxShardingSubReport;
use ex3_serde::bincode::serialize;
use num_traits::{CheckedSub, One, ToPrimitive, Zero};
use rs_merkle::algorithms::Sha256;
use rs_merkle::MerkleTree;
use std::cmp::max;
use std::collections::{BTreeMap, VecDeque};

impl BlockBuilder {
    /// Generate secret update tx sharding sub reports
    pub(crate) fn generate_secret_update_tx_sharding_sub_reports(
        &self,
        tx_map: BTreeMap<SecretVaultSeqId, Vec<(EncodedTransaction, usize)>>,
        txs_merkle_tree: &MerkleTree<Sha256>,
        snapshot_vault_cursor_of_pre_height: &SnapshotCursor,
    ) -> BTreeMap<WalletRegistrySeqId, Vec<SecretUpdateTxShardingSubReport>> {
        let mut secret_update_tx_sharding_sub_reports = BTreeMap::new();
        // secret vault seq id start from 0
        // every secret vault has [MAX_SECRET_PER_VAULT_CANISTER] secrets

        let max_secret_vault_seq_id = max(
            snapshot_vault_cursor_of_pre_height.max_activated_secret_vault_seq_id,
            tx_map.keys().max().unwrap_or(&0).clone(),
        );

        let mut next_secret_vault_seq_id: SecretVaultSeqId = 0;
        let mut tx_map_mut = tx_map;

        while next_secret_vault_seq_id <= max_secret_vault_seq_id {
            let mut secret_update_txs_sub_reports = vec![];

            // If no txs in this secret vault, generate a empty
            // SecretUpdateTxShardingSubReport for it
            if !tx_map_mut.contains_key(&next_secret_vault_seq_id) {
                next_secret_vault_seq_id += 1;
                continue;
            }

            let mut secret_update_txs = tx_map_mut
                .remove(&next_secret_vault_seq_id)
                .unwrap()
                .into_iter()
                .collect::<VecDeque<_>>();

            let total_tx_count_in_sharding = secret_update_txs.len();

            loop {
                let mut txs = vec![];
                for _ in 0..self.max_secret_update_txs_per_sharding_sub_report {
                    if let Some(tx) = secret_update_txs.pop_front() {
                        txs.push(tx);
                    } else {
                        break;
                    }
                }

                if txs.len() == 0 {
                    break;
                }
                let (txs, indexes) =
                    txs.into_iter()
                        .map(|(tx, index)| (tx, index.clone()))
                        .unzip::<EncodedTransaction, usize, Vec<EncodedTransaction>, Vec<usize>>();

                let merkle_proof = txs_merkle_tree.proof(&indexes);

                let report_start = secret_update_txs_sub_reports.len()
                    * self.max_secret_update_txs_per_sharding_sub_report.clone();
                let report_end = report_start + indexes.len();

                let range = ReportRange {
                    total_count: txs_merkle_tree.leaves_len().try_into().unwrap(),
                    sharding_range: CandidRange {
                        start: 0u32,
                        end: total_tx_count_in_sharding.try_into().unwrap(),
                    },
                    report_range: CandidRange {
                        start: report_start.try_into().unwrap(),
                        end: report_end.try_into().unwrap(),
                    },
                };

                let report = SecretUpdateTxShardingSubReport {
                    merkle_proof: merkle_proof.to_bytes(),
                    range,
                    txs,
                    secret_tx_indexes: indexes.into_iter().map(|i| i.try_into().unwrap()).collect(),
                };

                secret_update_txs_sub_reports.push(report);
            }

            secret_update_tx_sharding_sub_reports
                .insert(next_secret_vault_seq_id, secret_update_txs_sub_reports);

            next_secret_vault_seq_id += 1;
        }
        secret_update_tx_sharding_sub_reports
    }

    /// Generate secret vault data integrity
    pub(crate) fn generate_secret_vault_data_integrity(
        &self,
        current_block_height: &BlockHeight,
        secret_update_tx_sharding_sub_reports: &BTreeMap<
            WalletRegistrySeqId,
            Vec<SecretUpdateTxShardingSubReport>,
        >,
        snapshot_vault_cursor: &SnapshotCursor,
        snapshot_vault_index: &SnapshotVaultIndex,
    ) -> (
        BTreeMap<WalletRegistrySeqId, MerkleNode>,
        Vec<ActivatedSecretVault>,
    ) {
        let mut secret_vault_data_integrity = BTreeMap::new();
        let mut new_activated_secret_vaults = vec![];
        secret_update_tx_sharding_sub_reports
            .iter()
            .for_each(|(secret_vault_seq_id, reports)| {
                // pre block height process in this secret vault
                let mut pre_block_height_processed: Option<BlockHeight> = None;

                if secret_vault_seq_id <= &snapshot_vault_cursor.max_activated_secret_vault_seq_id
                    && *current_block_height > BlockHeight::zero()
                {
                    pre_block_height_processed = Some(
                        current_block_height
                            .checked_sub(&BlockHeight::one())
                            .unwrap(),
                    );
                }

                let total_vaults_count = snapshot_vault_index.get_total_vaults_count();
                let total_merkle_node_count = snapshot_vault_index.get_total_merkle_node_count();
                let secret_vault_index =
                    snapshot_vault_index.get_secret_vault_index(secret_vault_seq_id);

                let mut data_buffer = vec![];

                // 2.1. pre_block_height_bytes: the block height of the last processed block
                data_buffer.extend(
                    serialize(&pre_block_height_processed).expect("serialize should not fail"),
                );

                // 2.2. current_block_height_bytes: the block height of the current processed block
                data_buffer.extend(current_block_height.0.to_bytes_le());

                // 2.3. canister_id_bytes: current secret vault sequence id
                data_buffer.extend(secret_vault_seq_id.to_le_bytes());

                // 2.4. secret_update_tx_count_bytes: the count of secret update txs in current sharding report
                let secret_update_tx_count: u32 = reports
                    .iter()
                    .fold(0, |acc, report| acc + report.txs.len())
                    .try_into()
                    .unwrap();
                data_buffer.extend(secret_update_tx_count.to_le_bytes());

                // 2.5. total_merkle_node_count_bytes
                data_buffer.extend(total_merkle_node_count.to_le_bytes());

                // 2.6. canister_index_bytes: the index of the current secret vault canister
                //   in the data integrity merkle tree
                data_buffer.extend(secret_vault_index.to_le_bytes());

                // 2.7. data_bytes: the bytes of current sharding report txs
                reports.iter().for_each(|report| {
                    data_buffer.extend(&report.merkle_proof);
                });

                let data_integrity: MerkleNode = sha256(data_buffer);
                secret_vault_data_integrity.insert(secret_vault_seq_id.clone(), data_integrity);

                if pre_block_height_processed.is_none() {
                    new_activated_secret_vaults.push(ActivatedSecretVault {
                        canister_seq_id: secret_vault_seq_id.clone(),
                        canister_total_count: total_vaults_count,
                        canister_index: secret_vault_index,
                        hash_of_sharding: data_integrity,
                    });
                }
            });

        (secret_vault_data_integrity, new_activated_secret_vaults)
    }

    /// Get secret vault seq id by wallet id
    pub fn get_secret_vault_seq_id_by_wallet_id(
        &self,
        wallet_id: &WalletRegisterId,
    ) -> SecretVaultSeqId {
        // secret vault seq id is start from 0
        // every secret vault has [MAX_WALLETS_PER_SECRET_VAULT_CANISTER] wallets
        // so we can get secret vault seq id by wallet id
        let wallet_id = wallet_id
            .checked_sub(&Ex3Uint::from(self.start_wallet_id.clone()))
            .unwrap();
        (wallet_id.0 / self.max_wallets_per_secret_vault_canister.clone())
            .to_u64()
            .unwrap()
    }
}