test(ic-icrc-rosetta): add ICRC-122 system test for authorized mint/burn

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bogwar

rs/rosetta-api/icrc1/tests/system_tests.rs

@@ -2272,3 +2272,279 @@ fn test_query_blocks_range() {
         )
         .unwrap()
 }
+
+async fn get_block_operations(
+    rosetta_client: &RosettaClient,
+    network_identifier: NetworkIdentifier,
+    block_index: u64,
+) -> Vec<rosetta_core::objects::Operation> {
+    let response = rosetta_client
+        .block(
+            network_identifier,
+            PartialBlockIdentifier {
+                index: Some(block_index),
+                hash: None,
+            },
+        )
+        .await
+        .expect("Failed to fetch block");
+    response
+        .block
+        .expect("Block response missing block")
+        .transactions
+        .first()
+        .expect("Block has no transactions")
+        .operations
+        .clone()
+}
+
+#[test]
+fn test_authorized_mint_and_burn_122() {
+    let rt = Runtime::new().unwrap();
+    let setup = Setup::builder()
+        .with_custom_ledger_wasm(icrc3_test_ledger())
+        .build();
+
+    rt.block_on(async {
+        let env = RosettaTestingEnvironmentBuilder::new(&setup).build().await;
+
+        let agent = get_custom_agent(Arc::new(test_identity()), setup.port).await;
+
+        let account_1 = Account {
+            owner: PrincipalId::new_user_test_id(1).into(),
+            subaccount: None,
+        };
+        let account_2 = Account {
+            owner: PrincipalId::new_user_test_id(2).into(),
+            subaccount: None,
+        };
+        let caller = PrincipalId::new_user_test_id(42);
+
+        // Block 0: regular mint to account_1 (10M)
+        let block0 = BlockBuilder::new(0, 0)
+            .mint(account_1, Tokens::from(10_000_000_u64))
+            .build();
+        let idx = add_block(&agent, &env.icrc1_ledger_id, &block0)
+            .await
+            .expect("failed to add block 0");
+        assert_eq!(idx, Nat::from(0_u64));
+
+        // Block 1: minimal authorized mint to account_2 (5M) — no caller/mthd/reason
+        let block1 = BlockBuilder::new(1, 1)
+            .with_parent_hash(block0.hash().to_vec())
+            .authorized_mint(account_2, Tokens::from(5_000_000_u64))
+            .build();
+        let idx = add_block(&agent, &env.icrc1_ledger_id, &block1)
+            .await
+            .expect("failed to add block 1");
+        assert_eq!(idx, Nat::from(1_u64));
+
+        // Block 2: full authorized mint to account_1 (2M) — with caller, mthd, reason, created_at_time
+        let block2 = BlockBuilder::new(2, 2)
+            .with_parent_hash(block1.hash().to_vec())
+            .authorized_mint(account_1, Tokens::from(2_000_000_u64))
+            .with_caller(caller.into())
+            .with_mthd("152mint".to_string())
+            .with_reason("funding".to_string())
+            .with_created_at_time(1_700_000_000_000_000_000)
+            .build();
+        let idx = add_block(&agent, &env.icrc1_ledger_id, &block2)
+            .await
+            .expect("failed to add block 2");
+        assert_eq!(idx, Nat::from(2_u64));
+
+        // Block 3: minimal authorized burn from account_1 (1M)
+        let block3 = BlockBuilder::new(3, 3)
+            .with_parent_hash(block2.hash().to_vec())
+            .authorized_burn(account_1, Tokens::from(1_000_000_u64))
+            .build();
+        let idx = add_block(&agent, &env.icrc1_ledger_id, &block3)
+            .await
+            .expect("failed to add block 3");
+        assert_eq!(idx, Nat::from(3_u64));
+
+        // Block 4: full authorized burn from account_1 (3M) — with caller, mthd, reason, created_at_time
+        let block4 = BlockBuilder::new(4, 4)
+            .with_parent_hash(block3.hash().to_vec())
+            .authorized_burn(account_1, Tokens::from(3_000_000_u64))
+            .with_caller(caller.into())
+            .with_mthd("152burn".to_string())
+            .with_reason("compliance".to_string())
+            .with_created_at_time(1_700_000_001_000_000_000)
+            .build();
+        let idx = add_block(&agent, &env.icrc1_ledger_id, &block4)
+            .await
+            .expect("failed to add block 4");
+        assert_eq!(idx, Nat::from(4_u64));
+
+        // Wait for Rosetta to sync all blocks
+        let synced = wait_for_rosetta_block(&env.rosetta_client, env.network_identifier.clone(), 4)
+            .await
+            .expect("Failed to sync Rosetta to block 4");
+        assert_eq!(synced, 4);
+
+        // Verify balances: account_1 = 10M + 2M - 1M - 3M = 8M, account_2 = 5M
+        assert_rosetta_balance(
+            account_1,
+            4,
+            8_000_000,
+            &env.rosetta_client,
+            env.network_identifier.clone(),
+        )
+        .await;
+        assert_rosetta_balance(
+            account_2,
+            4,
+            5_000_000,
+            &env.rosetta_client,
+            env.network_identifier.clone(),
+        )
+        .await;
+
+        // Verify block 1 operations (minimal authorized mint)
+        let ops1 =
+            get_block_operations(&env.rosetta_client, env.network_identifier.clone(), 1).await;
+        assert_eq!(ops1.len(), 1);
+        assert_eq!(ops1[0].type_, OperationType::AuthorizedMint.to_string());
+        assert_eq!(
+            ops1[0].account.as_ref().unwrap(),
+            &AccountIdentifier::from(account_2)
+        );
+        assert_eq!(ops1[0].amount.as_ref().unwrap().value, "5000000");
+        // Minimal block: metadata should have no caller/mthd/reason
+        if let Some(ref meta1) = ops1[0].metadata {
+            assert!(meta1.get("caller").is_none() || meta1.get("caller").unwrap().is_null());
+            assert!(meta1.get("mthd").is_none() || meta1.get("mthd").unwrap().is_null());
+            assert!(meta1.get("reason").is_none() || meta1.get("reason").unwrap().is_null());
+        }
+
+        // Verify block 2 operations (full authorized mint with metadata)
+        let ops2 =
+            get_block_operations(&env.rosetta_client, env.network_identifier.clone(), 2).await;
+        assert_eq!(ops2.len(), 1);
+        assert_eq!(ops2[0].type_, OperationType::AuthorizedMint.to_string());
+        assert_eq!(
+            ops2[0].account.as_ref().unwrap(),
+            &AccountIdentifier::from(account_1)
+        );
+        assert_eq!(ops2[0].amount.as_ref().unwrap().value, "2000000");
+        let meta2 = ops2[0]
+            .metadata
+            .as_ref()
+            .expect("Expected metadata on full authorized mint");
+        assert_eq!(
+            meta2.get("caller").and_then(|v| v.as_str()),
+            Some(hex::encode(caller.as_slice()).as_str())
+        );
+        assert_eq!(meta2.get("mthd").and_then(|v| v.as_str()), Some("152mint"));
+        assert_eq!(
+            meta2.get("reason").and_then(|v| v.as_str()),
+            Some("funding")
+        );
+
+        // Verify block 3 operations (minimal authorized burn)
+        let ops3 =
+            get_block_operations(&env.rosetta_client, env.network_identifier.clone(), 3).await;
+        assert_eq!(ops3.len(), 1);
+        assert_eq!(ops3[0].type_, OperationType::AuthorizedBurn.to_string());
+        assert_eq!(
+            ops3[0].account.as_ref().unwrap(),
+            &AccountIdentifier::from(account_1)
+        );
+        assert_eq!(ops3[0].amount.as_ref().unwrap().value, "-1000000");
+        // Minimal block: metadata should have no caller/mthd/reason
+        if let Some(ref meta3) = ops3[0].metadata {
+            assert!(meta3.get("caller").is_none() || meta3.get("caller").unwrap().is_null());
+            assert!(meta3.get("mthd").is_none() || meta3.get("mthd").unwrap().is_null());
+            assert!(meta3.get("reason").is_none() || meta3.get("reason").unwrap().is_null());
+        }
+
+        // Verify block 4 operations (full authorized burn with metadata)
+        let ops4 =
+            get_block_operations(&env.rosetta_client, env.network_identifier.clone(), 4).await;
+        assert_eq!(ops4.len(), 1);
+        assert_eq!(ops4[0].type_, OperationType::AuthorizedBurn.to_string());
+        assert_eq!(
+            ops4[0].account.as_ref().unwrap(),
+            &AccountIdentifier::from(account_1)
+        );
+        assert_eq!(ops4[0].amount.as_ref().unwrap().value, "-3000000");
+        let meta4 = ops4[0]
+            .metadata
+            .as_ref()
+            .expect("Expected metadata on full authorized burn");
+        assert_eq!(
+            meta4.get("caller").and_then(|v| v.as_str()),
+            Some(hex::encode(caller.as_slice()).as_str())
+        );
+        assert_eq!(meta4.get("mthd").and_then(|v| v.as_str()), Some("152burn"));
+        assert_eq!(
+            meta4.get("reason").and_then(|v| v.as_str()),
+            Some("compliance")
+        );
+
+        // Verify search_transactions by account_1 (blocks 0, 2, 3, 4)
+        let search_req_1 = SearchTransactionsRequest {
+            network_identifier: env.network_identifier.clone(),
+            account_identifier: Some(account_1.into()),
+            ..Default::default()
+        };
+        let search_resp_1 = env
+            .rosetta_client
+            .search_transactions(&search_req_1)
+            .await
+            .expect("Failed to search transactions for account_1");
+        let block_indices_1: HashSet<u64> = search_resp_1
+            .transactions
+            .iter()
+            .map(|t| t.block_identifier.index)
+            .collect();
+        assert!(
+            block_indices_1.contains(&0),
+            "account_1 should appear in block 0"
+        );
+        assert!(
+            block_indices_1.contains(&2),
+            "account_1 should appear in block 2"
+        );
+        assert!(
+            block_indices_1.contains(&3),
+            "account_1 should appear in block 3"
+        );
+        assert!(
+            block_indices_1.contains(&4),
+            "account_1 should appear in block 4"
+        );
+        assert_eq!(
+            block_indices_1.len(),
+            4,
+            "account_1 should appear in exactly 4 blocks"
+        );
+
+        // Verify search_transactions by account_2 (block 1)
+        let search_req_2 = SearchTransactionsRequest {
+            network_identifier: env.network_identifier.clone(),
+            account_identifier: Some(account_2.into()),
+            ..Default::default()
+        };
+        let search_resp_2 = env
+            .rosetta_client
+            .search_transactions(&search_req_2)
+            .await
+            .expect("Failed to search transactions for account_2");
+        let block_indices_2: HashSet<u64> = search_resp_2
+            .transactions
+            .iter()
+            .map(|t| t.block_identifier.index)
+            .collect();
+        assert!(
+            block_indices_2.contains(&1),
+            "account_2 should appear in block 1"
+        );
+        assert_eq!(
+            block_indices_2.len(),
+            1,
+            "account_2 should appear in exactly 1 block"
+        );
+    });
+}