feat(ICRC-Index): add and handle ICRC-107 fee collector blocks

packages/icrc-ledger-types/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add ICRC-107 fee collector transaction type.
+
 ## 0.1.12
 
 ### Added

packages/icrc-ledger-types/src/icrc/generic_value.rs

@@ -334,6 +334,21 @@ impl From<Account> for Value {
     }
 }
 
+impl TryFrom<Value> for Principal {
+    type Error = String;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        Principal::try_from_slice(value.as_blob()?.as_slice())
+            .map_err(|err| format!("Unable to decode the principal, error {err}"))
+    }
+}
+
+impl From<Principal> for Value {
+    fn from(principal: Principal) -> Self {
+        Self::blob(principal.as_slice())
+    }
+}
+
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

packages/icrc-ledger-types/src/icrc3/transactions.rs

@@ -1,4 +1,4 @@
-use candid::{CandidType, Deserialize, Nat};
+use candid::{CandidType, Deserialize, Nat, Principal};
 use serde::Serialize;
 
 use crate::{
@@ -58,6 +58,13 @@ pub struct Approve {
     pub created_at_time: Option<u64>,
 }
 
+#[derive(CandidType, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct FeeCollector {
+    pub fee_collector: Option<Account>,
+    pub caller: Option<Principal>,
+    pub ts: Option<u64>,
+}
+
 // Representation of a Transaction which supports the Icrc1 Standard functionalities
 #[derive(CandidType, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Transaction {
@@ -66,6 +73,7 @@ pub struct Transaction {
     pub burn: Option<Burn>,
     pub transfer: Option<Transfer>,
     pub approve: Option<Approve>,
+    pub fee_collector: Option<FeeCollector>,
     pub timestamp: u64,
 }
 
@@ -78,6 +86,7 @@ impl Transaction {
             burn: Some(burn),
             transfer: None,
             approve: None,
+            fee_collector: None,
         }
     }
 
@@ -89,6 +98,7 @@ impl Transaction {
             burn: None,
             transfer: None,
             approve: None,
+            fee_collector: None,
         }
     }
 
@@ -100,6 +110,7 @@ impl Transaction {
             burn: None,
             transfer: Some(transfer),
             approve: None,
+            fee_collector: None,
         }
     }
 
@@ -111,6 +122,19 @@ impl Transaction {
             burn: None,
             transfer: None,
             approve: Some(approve),
+            fee_collector: None,
+        }
+    }
+
+    pub fn set_fee_collector(fee_collector: FeeCollector, timestamp: u64) -> Self {
+        Self {
+            kind: "107set_fee_collector".into(),
+            timestamp,
+            mint: None,
+            burn: None,
+            transfer: None,
+            approve: None,
+            fee_collector: Some(fee_collector),
         }
     }
 }

rs/ledger_suite/icrc1/BUILD.bazel

@@ -75,6 +75,7 @@ rust_test(
         "//packages/ic-ledger-hash-of:ic_ledger_hash_of",
         "//rs/ledger_suite/icrc1/tokens_u256",
         "//rs/ledger_suite/icrc1/tokens_u64",
+        "//rs/types/base_types",
     ] + DEV_DEPENDENCIES,
 )
 

rs/ledger_suite/icrc1/archive/archive.did

@@ -6,6 +6,7 @@ type Transaction = record {
   kind : text;
   mint : opt Mint;
   approve : opt Approve;
+  fee_collector : opt FeeCollector;
   timestamp : nat64;
   transfer : opt Transfer
 };
@@ -21,6 +22,12 @@ type Approve = record {
   spender : Account
 };
 
+type FeeCollector = record {
+  caller : opt principal;
+  fee_collector : opt Account;
+  ts : opt nat64
+};
+
 type Burn = record {
   from : Account;
   memo : opt vec nat8;

rs/ledger_suite/icrc1/archive/tests/tests.rs

@@ -111,6 +111,7 @@ fn test_icrc3_get_blocks() {
                 created_at_time: None,
                 memo: None,
             },
+            btype: None,
         }
     };
 
@@ -265,6 +266,7 @@ fn test_icrc3_get_blocks_number_of_blocks_limit() {
                 created_at_time: None,
                 memo: None,
             },
+            btype: None,
         }
         .encode()
     }

rs/ledger_suite/icrc1/index-ng/index-ng.did

@@ -56,10 +56,17 @@ type Transaction = record {
   kind : text;
   mint : opt Mint;
   approve : opt Approve;
+  fee_collector : opt FeeCollector;
   timestamp : nat64;
   transfer : opt Transfer
 };
 
+type FeeCollector = record {
+  caller : opt principal;
+  fee_collector : opt Account;
+  ts : opt nat64
+};
+
 type Approve = record {
   fee : opt Tokens;
   from : Account;

rs/ledger_suite/icrc1/index-ng/src/main.rs

@@ -140,6 +140,12 @@ struct State {
     /// index. Lower values will result in a more responsive UI, but higher costs due to increased
     /// cycle burn for the index, ledger and archive(s).
     retrieve_blocks_from_ledger_interval: Option<Duration>,
+
+    /// The ICRC-107 fee collector. Example values:
+    /// - `None` - legacy fee collector is used.
+    /// - `Some(None)` - 107 fee collector is enabled but fees are burned.
+    /// - `Some(Some(account1))` - 107 fee collector is enabled, `account1` collects the fees.
+    fee_collector_107: Option<Option<Account>>,
 }
 
 impl State {
@@ -161,6 +167,7 @@ impl Default for State {
             fee_collectors: Default::default(),
             last_fee: None,
             retrieve_blocks_from_ledger_interval: None,
+            fee_collector_107: None,
         }
     }
 }
@@ -783,8 +790,11 @@ fn append_block(block_index: BlockIndex64, block: GenericBlock) -> Result<(), Sy
             }
         });
 
+        // change the fee collector if block is a 107 block
+        process_fee_collector_block(&decoded_block);
+
         // add the block to the fee_collector if one is set
-        index_fee_collector(block_index, &decoded_block);
+        index_fee_collector(block_index);
 
         // change the balance of the involved accounts
         process_balance_changes(block_index, &decoded_block);
@@ -828,8 +838,18 @@ fn append_icrc3_blocks(new_blocks: Vec<BlockWithId>) -> Result<(), SyncError> {
     Ok(())
 }
 
-fn index_fee_collector(block_index: BlockIndex64, block: &Block<Tokens>) {
-    if let Some(fee_collector) = get_fee_collector(block_index, block) {
+fn process_fee_collector_block(block: &Block<Tokens>) {
+    if let Operation::FeeCollector {
+        fee_collector,
+        caller: _,
+    } = block.transaction.operation
+    {
+        mutate_state(|s| s.fee_collector_107 = Some(fee_collector));
+    }
+}
+
+fn index_fee_collector(block_index: BlockIndex64) {
+    if let Some(fee_collector) = get_fee_collector() {
         mutate_state(|s| {
             s.fee_collectors
                 .entry(fee_collector)
@@ -875,7 +895,7 @@ fn process_balance_changes(block_index: BlockIndex64, block: &Block<Tokens>) {
                         ))
                     });
                     mutate_state(|s| s.last_fee = Some(fee));
-                    if let Some(fee_collector) = get_fee_collector(block_index, block) {
+                    if let Some(fee_collector) = get_fee_collector() {
                         credit(block_index, fee_collector, fee);
                     }
                 }
@@ -891,7 +911,7 @@ fn process_balance_changes(block_index: BlockIndex64, block: &Block<Tokens>) {
                         ))
                     });
                     mutate_state(|s| s.last_fee = Some(fee));
-                    if let Some(fee_collector) = get_fee_collector(block_index, block) {
+                    if let Some(fee_collector) = get_fee_collector() {
                         credit(block_index, fee_collector, fee);
                     }
                 }
@@ -920,7 +940,7 @@ fn process_balance_changes(block_index: BlockIndex64, block: &Block<Tokens>) {
                     }),
                 );
                 credit(block_index, to, amount);
-                if let Some(fee_collector) = get_fee_collector(block_index, block) {
+                if let Some(fee_collector) = get_fee_collector() {
                     credit(block_index, fee_collector, fee);
                 }
             }
@@ -954,6 +974,16 @@ fn process_balance_changes(block_index: BlockIndex64, block: &Block<Tokens>) {
                 change_balance(spender, |balance| balance);
 
                 debit(block_index, from, fee);
+
+                if let Some(fee_collector_107) = get_fee_collector_107().flatten() {
+                    credit(block_index, fee_collector_107, fee);
+                }
+            }
+            Operation::FeeCollector {
+                fee_collector: _,
+                caller: _,
+            } => {
+                // Does not affect the balance
             }
         },
     );
@@ -989,19 +1019,35 @@ fn get_accounts(block: &Block<Tokens>) -> Vec<Account> {
         Operation::Mint { to, .. } => vec![to],
         Operation::Transfer { from, to, .. } => vec![from, to],
         Operation::Approve { from, .. } => vec![from],
+        Operation::FeeCollector { .. } => vec![],
     }
 }
 
-fn get_fee_collector(block_index: BlockIndex64, block: &Block<Tokens>) -> Option<Account> {
+fn get_fee_collector() -> Option<Account> {
+    get_fee_collector_107().unwrap_or_else(get_legacy_fee_collector)
+}
+
+fn get_fee_collector_107() -> Option<Option<Account>> {
+    with_state(|s| s.fee_collector_107)
+}
+
+fn get_legacy_fee_collector() -> Option<Account> {
+    let chain_length = with_blocks(|blocks| blocks.len());
+    if chain_length == 0 {
+        return None;
+    }
+    let last_block_index = chain_length - 1;
+    let block = get_decoded_block(last_block_index)
+        .expect("chain_length is positive, should have at least one block");
     if block.fee_collector.is_some() {
         block.fee_collector
     } else if let Some(fee_collector_block_index) = block.fee_collector_block_index {
         let block = get_decoded_block(fee_collector_block_index)
             .unwrap_or_else(||
-                ic_cdk::trap(format!("Block at index {block_index} has fee_collector_block_index {fee_collector_block_index} but there is no block at that index")));
+                ic_cdk::trap(format!("Block at index {last_block_index} has fee_collector_block_index {fee_collector_block_index} but there is no block at that index")));
         if block.fee_collector.is_none() {
             ic_cdk::trap(format!(
-                "Block at index {block_index} has fee_collector_block_index {fee_collector_block_index} but that block has no fee_collector set"
+                "Block at index {last_block_index} has fee_collector_block_index {fee_collector_block_index} but that block has no fee_collector set"
             ))
         } else {
             block.fee_collector