test(ICRC_Index): DEFI-2527: index-ng u256 token testing (#7788)

Not all `index-ng` tests were also being run with `u256` tokens - in
particular, the integration tests under `tests/`, with the bazel target
`name = "index_ng_test" + conf["test_suffix"],`, were only using the
`u256` feature for one config, and not e.g., for the
`"get_blocks_disabled"` and `"icrc3_disabled"` features. This PR
proposes to add the `u256-tokens` feature flag where it was missing, and
also proposes to add a test that explicitly verifies that `Tokens::MAX`
returns the expected value, and verifies that the ledger and index
handle large transfer and approve amounts correctly.

Author: mbjorkqvist

rs/ledger_suite/icrc1/index-ng/BUILD.bazel

@@ -123,6 +123,7 @@ rust_test(
             "//rs/ledger_suite/icrc1/ledger",
             "//rs/ledger_suite/icrc1/test_utils",
             "//rs/ledger_suite/icrc1/test_utils/icrc3_test_ledger",
+            "//rs/ledger_suite/icrc1/tokens_u256",
             "//rs/ledger_suite/icrc1/tokens_u64",
             "//rs/ledger_suite/test_utils/state_machine_helpers:ic-ledger-suite-state-machine-helpers",
             "//rs/ledger_suite/tests/sm-tests:ic-ledger-suite-state-machine-tests",
@@ -153,7 +154,7 @@ rust_test(
             "test_suffix": "",
         },
         {
-            "crate_features": [],
+            "crate_features": ["u256-tokens"],
             "index_wasm": ":index_ng_canister_u256.wasm.gz",
             "ledger_wasm": "//rs/ledger_suite/icrc1/ledger:ledger_canister_u256.wasm.gz",
             "test_suffix": "_u256",
@@ -166,7 +167,10 @@ rust_test(
             "test_suffix": "_wo_getblocks",
         },
         {
-            "crate_features": ["get_blocks_disabled"],
+            "crate_features": [
+                "get_blocks_disabled",
+                "u256-tokens",
+            ],
             "index_wasm": ":index_ng_canister_u256.wasm.gz",
             "ledger_wasm": "//rs/ledger_suite/icrc1/ledger:ledger_canister_u256_getblocksdisabled.wasm.gz",
             "test_suffix": "_u256_wo_getblocks",
@@ -179,7 +183,10 @@ rust_test(
             "test_suffix": "_wo_icrc3",
         },
         {
-            "crate_features": ["icrc3_disabled"],
+            "crate_features": [
+                "icrc3_disabled",
+                "u256-tokens",
+            ],
             "index_wasm": ":index_ng_canister_u256.wasm.gz",
             "ledger_wasm": "@ic-icrc1-ledger-wo-icrc-3-u256.wasm.gz//file",
             "test_suffix": "_wo_icrc3_u256",

rs/ledger_suite/icrc1/index-ng/tests/common/mod.rs

@@ -59,11 +59,15 @@ pub fn default_archive_options() -> ArchiveOptions {
 
 #[allow(dead_code)]
 pub fn index_ng_wasm() -> Vec<u8> {
-    ic_test_utilities_load_wasm::load_wasm(
-        std::env::var("CARGO_MANIFEST_DIR").unwrap(),
-        "ic-icrc1-index-ng",
-        &[],
-    )
+    let index_ng_wasm_path = std::env::var("IC_ICRC1_INDEX_NG_WASM_PATH").expect(
+        "The Index-ng wasm path must be set using the env variable IC_ICRC1_INDEX_NG_WASM_PATH",
+    );
+    std::fs::read(&index_ng_wasm_path).unwrap_or_else(|e| {
+        panic!(
+            "failed to load Wasm file from path {} (env var IC_ICRC1_INDEX_NG_WASM_PATH): {}",
+            index_ng_wasm_path, e
+        )
+    })
 }
 
 pub fn install_ledger(

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

@@ -6,18 +6,19 @@ use crate::common::{
 use candid::{Decode, Encode, Nat, Principal};
 use ic_agent::identity::Identity;
 use ic_base_types::{CanisterId, PrincipalId};
+use ic_icrc1::blocks::generic_block_to_encoded_block;
+use ic_icrc1::{Block, Operation};
 use ic_icrc1_index_ng::{
     DEFAULT_MAX_BLOCKS_PER_RESPONSE, FeeCollectorRanges, GetAccountTransactionsArgs,
     GetAccountTransactionsResponse, GetAccountTransactionsResult, GetBlocksResponse, IndexArg,
     InitArg as IndexInitArg, ListSubaccountsArgs, TransactionWithId,
 };
-use ic_icrc1_ledger::{
-    ChangeFeeCollector, LedgerArgument, Tokens, UpgradeArgs as LedgerUpgradeArgs,
-};
+use ic_icrc1_ledger::{ChangeFeeCollector, LedgerArgument, UpgradeArgs as LedgerUpgradeArgs};
 use ic_icrc1_test_utils::{
     ArgWithCaller, LedgerEndpointArg, icrc3::BlockBuilder, minter_identity,
     valid_transactions_strategy,
 };
+use ic_ledger_core::block::BlockType;
 use ic_ledger_suite_state_machine_helpers::{
     add_block, archive_blocks, get_logs, set_icrc3_enabled,
 };
@@ -26,6 +27,7 @@ use ic_state_machine_tests::StateMachine;
 use icrc_ledger_types::icrc::generic_value::ICRC3Value;
 use icrc_ledger_types::icrc1::account::{Account, Subaccount};
 use icrc_ledger_types::icrc1::transfer::{BlockIndex, TransferArg, TransferError};
+use icrc_ledger_types::icrc2::allowance::{Allowance, AllowanceArgs};
 use icrc_ledger_types::icrc2::approve::{ApproveArgs, ApproveError};
 use icrc_ledger_types::icrc2::transfer_from::{TransferFromArgs, TransferFromError};
 use icrc_ledger_types::icrc3::blocks::GetBlocksRequest;
@@ -40,6 +42,12 @@ use std::time::{Duration, SystemTime};
 
 mod common;
 
+#[cfg(not(feature = "u256-tokens"))]
+type Tokens = ic_icrc1_tokens_u64::U64;
+
+#[cfg(feature = "u256-tokens")]
+type Tokens = ic_icrc1_tokens_u256::U256;
+
 fn index_wasm() -> Vec<u8> {
     ic_test_utilities_load_wasm::load_wasm(
         std::env::var("CARGO_MANIFEST_DIR").unwrap(),
@@ -1536,6 +1544,92 @@ fn test_principal_subaccounts() {
     assert!(subaccounts.contains(&account(2, 1).subaccount.unwrap()));
 }
 
+#[test]
+fn test_large_transfers_and_approvals() {
+    let env = &StateMachine::new();
+    let minter = minter_identity().sender().unwrap();
+    let ledger_id = install_ledger(env, vec![], default_archive_options(), None, minter);
+    let index_id = install_index_ng(env, index_init_arg_without_interval(ledger_id));
+    let account1 = account(1, 0);
+    let account2 = account(2, 0);
+    let max_amount = Nat::from(Tokens::MAX);
+
+    // Make sure we are using the correct token type.
+    #[cfg(not(feature = "u256-tokens"))]
+    assert_eq!(max_amount, Nat::from(u64::MAX));
+    #[cfg(feature = "u256-tokens")]
+    assert_ne!(max_amount, Nat::from(u64::MAX));
+
+    // Mint a huge amount
+    let req = TransferArg {
+        from_subaccount: None,
+        to: account1,
+        amount: max_amount.clone(),
+        created_at_time: None,
+        fee: None,
+        memo: None,
+    };
+    let mint_index = icrc1_transfer(env, ledger_id, minter.into(), req);
+    assert_eq!(mint_index, Nat::from(0u64));
+
+    // Test initial mint block.
+    wait_until_sync_is_completed(env, index_id, ledger_id);
+    assert_ledger_index_parity(env, ledger_id, index_id);
+    let balance = Decode!(
+        &env.execute_ingress(index_id, "icrc1_balance_of", Encode!(&account1).unwrap())
+            .expect("Failed to send icrc1_balance_of")
+            .bytes(),
+        Nat
+    )
+    .expect("Failed to decode icrc1_balance_of response");
+    assert_eq!(balance, max_amount);
+
+    // Approve a huge amount
+    let req = ApproveArgs {
+        from_subaccount: None,
+        spender: account2,
+        amount: max_amount.clone(),
+        expected_allowance: None,
+        expires_at: None,
+        fee: None,
+        memo: None,
+        created_at_time: None,
+    };
+    let approve_index = icrc2_approve(env, ledger_id, PrincipalId(account1.owner), req);
+    assert_eq!(approve_index, Nat::from(1u64));
+
+    wait_until_sync_is_completed(env, index_id, ledger_id);
+    assert_ledger_index_parity(env, ledger_id, index_id);
+
+    let arg = AllowanceArgs {
+        account: account1,
+        spender: account2,
+    };
+    let allowance = Decode!(
+        &env.query(ledger_id, "icrc2_allowance", Encode!(&arg).unwrap())
+            .expect("failed to guery the allowance")
+            .bytes(),
+        Allowance
+    )
+    .expect("failed to decode allowance response");
+    assert_eq!(allowance.allowance, max_amount);
+
+    let res = index_get_blocks(env, index_id, 1, 1);
+    let index_approval_block = res.blocks.first().expect("expected at least one block");
+    let encoded_block = generic_block_to_encoded_block(index_approval_block.clone())
+        .expect("should convert generic block to encoded block");
+    let block: Block<Tokens> = Block::decode(encoded_block).expect("should decode encoded block");
+    match block.transaction.operation {
+        Operation::Approve { amount, .. } => {
+            assert_eq!(
+                amount,
+                Tokens::try_from(max_amount).expect("should convert max amount to Tokens")
+            );
+        }
+        _ => panic!("expected Approve operation"),
+    }
+}
+
 #[test]
 fn test_index_http_request_decoding_quota() {
     let env = &StateMachine::new();