update icrc3

Author: Gwojda

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bity-ic-icrc3"
-version = "0.4.9"
+version = "0.5.0"
 edition = "2021"
 license = "MIT"
 description = "bity icrc3 library"

src/icrc3/Cargo.toml

@@ -293,11 +293,14 @@ impl Blockchain {
             return None;
         }
 
-        if block_id > self.chain_length() {
+        if block_id >= self.chain_length() {
+            // This is a non-archived block stored locally
+            let local_index = block_id - self.chain_length();
             self.local_transactions
-                .get(block_id as usize - self.chain_length() as usize - 1)
+                .get(local_index as usize)
                 .map(|(_, block)| block.clone())
         } else {
+            // This is an archived block, we don't have it locally
             None
         }
     }

src/icrc3/src/blockchain/blockchain.rs

@@ -30,14 +30,14 @@ pub const PERMITTED_DRIFT: Duration = Duration::from_millis(100);
 /// * `blockchain` - The blockchain implementation
 /// * `ledger` - A queue of recent transactions
 /// * `prepared_transactions` - A FIFO queue of prepared transaction hashes
-/// * `last_index` - The index of the last transaction
+/// * `next_index` - The index of the next transaction
 /// * `icrc3_config` - Configuration parameters
 #[derive(Serialize, Deserialize)]
 pub struct ICRC3 {
     pub blockchain: Blockchain,
     pub ledger: VecDeque<ICRC3Value>,
     pub prepared_transactions: VecDeque<(String, TimestampNanos)>,
-    pub last_index: u64,
+    pub next_index: u64,
     pub last_phash: Option<ByteBuf>,
     pub icrc3_config: ICRC3Config,
 }
@@ -102,7 +102,7 @@ impl ICRC3 {
 
             ledger: VecDeque::new(),
             prepared_transactions: VecDeque::new(),
-            last_index: 0,
+            next_index: 0,
             last_phash: None,
             icrc3_config,
         }
@@ -265,7 +265,7 @@ impl ICRC3 {
     /// A vector containing the root hash of the certification tree
     pub fn get_hash_tree(&self) -> Vec<u8> {
         let hash_tree_root = last_block_hash_tree(
-            self.last_index,
+            self.next_index,
             self.blockchain
                 .last_hash
                 .unwrap_or(HashOf::new([0; 32]))
@@ -327,7 +327,7 @@ impl From<ICRC3> for Certificate {
     ///
     /// The certificate is then set as the certified data for the canister.
     fn from(val: ICRC3) -> Self {
-        let last_block_index = val.last_index;
+        let last_block_index = val.next_index - 1;
         let last_block_hash = val.blockchain.last_hash.unwrap_or(HashOf::new([0; 32]));
 
         let leaf1 = leaf(last_block_index.to_string());

src/icrc3/src/icrc3.rs

@@ -239,15 +239,15 @@ impl ICRC3Interface for ICRC3 {
                 if let Some(ICRC3Value::Blob(existing_thash)) = existing_map.get("thash") {
                     if existing_thash.as_slice() == transaction_hash {
                         return Err(Icrc3Error::DuplicateTransaction {
-                            duplicate_of: self.last_index - i as u64,
+                            duplicate_of: self.next_index - i as u64 - 1,
                         });
                     }
                 }
             }
         }
 
         self.ledger.push_back(checked_transaction.clone());
-        self.last_index += 1;
+        self.next_index += 1;
         self.last_phash = Some(ByteBuf::from(transaction_hash));
 
         let block = DefaultBlock::from_transaction(
@@ -263,7 +263,7 @@ impl ICRC3Interface for ICRC3 {
             }
         }
 
-        Ok(self.last_index)
+        Ok(self.next_index)
     }
 
     fn prepare_transaction<T: TransactionType>(
@@ -338,7 +338,7 @@ impl ICRC3Interface for ICRC3 {
                 if let Some(ICRC3Value::Blob(existing_thash)) = existing_map.get("thash") {
                     if existing_thash.as_slice() == transaction_hash {
                         return Err(Icrc3Error::DuplicateTransaction {
-                            duplicate_of: self.last_index - i as u64,
+                            duplicate_of: self.next_index - i as u64 - 1,
                         });
                     }
                 }
@@ -407,21 +407,19 @@ impl ICRC3Interface for ICRC3 {
             }
         });
 
-        self.last_index += 1;
         self.last_phash = Some(ByteBuf::from(icrc3_transaction.clone().hash().to_vec()));
 
         // Add block to blockchain
         let block =
             DefaultBlock::from_transaction(self.blockchain.last_hash, icrc3_transaction, timestamp);
 
-        match self.blockchain.add_block(block) {
-            Ok(_) => (),
-            Err(e) => {
-                return Err(Icrc3Error::Icrc3Error(e));
+        return match self.blockchain.add_block(block) {
+            Ok(index) => {
+                self.next_index = index + 1;
+                Ok(index)
             }
-        }
-
-        Ok(self.last_index)
+            Err(e) => Err(Icrc3Error::Icrc3Error(e)),
+        };
     }
 
     fn icrc3_get_archives(&self) -> Vec<ICRC3ArchiveInfo> {
@@ -443,7 +441,7 @@ impl ICRC3Interface for ICRC3 {
         args: Vec<GetBlocksRequest>,
     ) -> crate::types::icrc3_get_blocks::Response {
         let mut response = GetBlocksResult {
-            log_length: Nat::from(self.last_index),
+            log_length: Nat::from(self.next_index),
             blocks: vec![],
             archived_blocks: vec![],
         };
@@ -457,7 +455,7 @@ impl ICRC3Interface for ICRC3 {
             let mut current_canister = None;
 
             for i in start..start + length {
-                if i > self.blockchain.chain_length() {
+                if i >= self.blockchain.chain_length() {
                     let block = self.blockchain.get_block(i);
 
                     if let Some(block) = block {
@@ -469,6 +467,7 @@ impl ICRC3Interface for ICRC3 {
                         continue;
                     }
                 }
+
                 let block_canister_id = self.blockchain.get_block_canister_id(i);
 
                 trace(format!("block_canister_id: {:?}", block_canister_id));

src/icrc3/src/interface.rs

@@ -27,7 +27,7 @@ fn add_same_transactions(_: RandomTransactionArgs) -> RandomTransactionResponse
         }
         Err(e) => match e {
             bity_ic_icrc3::types::Icrc3Error::DuplicateTransaction { duplicate_of } => {
-                if duplicate_of == 1 {
+                if duplicate_of == 0 {
                     trace(format!("transaction already added: {}", duplicate_of));
                 } else {
                     ic_cdk::trap(format!(

src/icrc3/wasm/icrc3_archive_canister.wasm.gz

@@ -2,6 +2,7 @@ use crate::client::icrc3::*;
 use crate::icrc3_suite::setup::default_test_setup;
 use crate::utils::tick_n_blocks;
 
+use bity_ic_canister_time::DAY_IN_MS;
 use candid::Nat;
 use icrc_ledger_types::icrc3::blocks::GetBlocksRequest;
 use std::time::Duration;
@@ -76,54 +77,111 @@ fn test_multiple_transactions() {
     );
 
     assert_eq!(get_blocks_result.blocks.len(), 10);
-}
 
-#[test]
-fn test_throttling() {
-    let mut test_env = default_test_setup();
+    for (i, block) in get_blocks_result.blocks.iter().enumerate() {
+        println!("Block {}: {:?}", i, block);
+        assert_eq!(block.id, Nat::from(i as u64));
+    }
 
-    for _ in 0..15 {
+    test_env
+        .pic
+        .advance_time(Duration::from_millis(DAY_IN_MS * 2));
+    tick_n_blocks(&mut test_env.pic, 50);
+
+    let get_blocks_result = icrc3_get_blocks(
+        &mut test_env.pic,
+        test_env.controller,
+        test_env.icrc3_id,
+        &get_blocks_args,
+    );
+
+    println!("get_blocks_result: {:?}", get_blocks_result);
+    assert_eq!(get_blocks_result.blocks.len(), 0);
+    assert_eq!(get_blocks_result.archived_blocks.len(), 1);
+
+    let archived_block = get_blocks_result.archived_blocks[0].clone();
+
+    let get_blocks_result_2 = icrc3_get_blocks(
+        &mut test_env.pic,
+        test_env.controller,
+        archived_block.callback.canister_id,
+        &archived_block.args,
+    );
+
+    assert_eq!(get_blocks_result_2.blocks.len(), 10);
+    assert_eq!(get_blocks_result_2.archived_blocks.len(), 0);
+
+    for (i, block) in get_blocks_result_2.blocks.iter().enumerate() {
+        println!("Block {}: {:?}", i, block);
+        assert_eq!(block.id, Nat::from(i as u64));
+    }
+
+    for _ in 0..10 {
         add_random_transaction(
             &mut test_env.pic,
             test_env.controller,
             test_env.icrc3_id,
             &(),
         );
 
-        test_env.pic.advance_time(Duration::from_millis(100));
+        test_env.pic.advance_time(Duration::from_secs(2));
         tick_n_blocks(&mut test_env.pic, 50);
     }
 
-    let get_blocks_args = vec![GetBlocksRequest {
-        start: Nat::from(0u64),
-        length: Nat::from(100u64),
-    }];
-
     let get_blocks_result = icrc3_get_blocks(
         &mut test_env.pic,
         test_env.controller,
         test_env.icrc3_id,
         &get_blocks_args,
     );
 
-    assert_eq!(get_blocks_result.blocks.len(), 13);
-    assert_eq!(get_blocks_result.archived_blocks.len(), 0);
-}
+    println!("get_blocks_result: {:?}", get_blocks_result);
+    assert_eq!(get_blocks_result.blocks.len(), 10);
+    assert_eq!(get_blocks_result.archived_blocks.len(), 1);
 
-#[test]
-fn test_concurrent_transactions() {
-    let mut test_env = default_test_setup();
+    let archived_block = get_blocks_result.archived_blocks[0].clone();
 
-    add_same_transactions(
+    let get_blocks_result_2 = icrc3_get_blocks(
         &mut test_env.pic,
         test_env.controller,
-        test_env.icrc3_id,
-        &(),
+        archived_block.callback.canister_id,
+        &archived_block.args,
     );
 
+    println!("get_blocks_result_2: {:?}", get_blocks_result_2);
+    assert_eq!(get_blocks_result_2.blocks.len(), 10);
+    assert_eq!(get_blocks_result_2.archived_blocks.len(), 0);
+
+    for (i, block) in get_blocks_result.blocks.iter().enumerate() {
+        println!("Block {}: {:?}", i, block);
+        assert_eq!(block.id, Nat::from(i as u64 + 10));
+    }
+
+    for (i, block) in get_blocks_result_2.blocks.iter().enumerate() {
+        println!("Block {}: {:?}", i, block);
+        assert_eq!(block.id, Nat::from(i as u64));
+    }
+}
+
+#[test]
+fn test_throttling() {
+    let mut test_env = default_test_setup();
+
+    for _ in 0..15 {
+        add_random_transaction(
+            &mut test_env.pic,
+            test_env.controller,
+            test_env.icrc3_id,
+            &(),
+        );
+
+        test_env.pic.advance_time(Duration::from_millis(100));
+        tick_n_blocks(&mut test_env.pic, 50);
+    }
+
     let get_blocks_args = vec![GetBlocksRequest {
         start: Nat::from(0u64),
-        length: Nat::from(10u64),
+        length: Nat::from(100u64),
     }];
 
     let get_blocks_result = icrc3_get_blocks(
@@ -133,9 +191,7 @@ fn test_concurrent_transactions() {
         &get_blocks_args,
     );
 
-    println!("get_blocks_result: {:?}", get_blocks_result);
-
-    assert_eq!(get_blocks_result.blocks.len(), 1);
+    assert_eq!(get_blocks_result.blocks.len(), 13);
     assert_eq!(get_blocks_result.archived_blocks.len(), 0);
 }