diff --git a/Cargo.lock b/Cargo.lock index e157f74987dd..b2be5df5bbba 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10569,7 +10569,6 @@ dependencies = [ name = "ic-ledger-suite-orchestrator-test-utils" version = "0.9.0" dependencies = [ - "assert_matches", "candid", "ic-base-types", "ic-cdk 0.19.0", @@ -10577,11 +10576,8 @@ dependencies = [ "ic-icrc1-ledger", "ic-ledger-suite-orchestrator", "ic-management-canister-types 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", - "ic-management-canister-types-private", "ic-metrics-assert", - "ic-state-machine-tests", "ic-test-utilities-load-wasm", - "ic-types", "ic-types-cycles", "ic-universal-canister", "icrc-ledger-types", diff --git a/rs/ethereum/ledger-suite-orchestrator/test_utils/BUILD.bazel b/rs/ethereum/ledger-suite-orchestrator/test_utils/BUILD.bazel index 314e6cb73fc9..6c7e5caf1f00 100644 --- a/rs/ethereum/ledger-suite-orchestrator/test_utils/BUILD.bazel +++ b/rs/ethereum/ledger-suite-orchestrator/test_utils/BUILD.bazel @@ -22,13 +22,9 @@ rust_library( "//packages/pocket-ic", "//rs/ethereum/ledger-suite-orchestrator:ledger_suite_orchestrator", "//rs/ledger_suite/icrc1/ledger", - "//rs/state_machine_tests", "//rs/types/base_types", "//rs/types/cycles", - "//rs/types/management_canister_types", - "//rs/types/types", "//rs/universal_canister/lib", - "@crate_index//:assert_matches", "@crate_index//:candid", "@crate_index//:ic-cdk", "@crate_index//:ic-management-canister-types", diff --git a/rs/ethereum/ledger-suite-orchestrator/test_utils/Cargo.toml b/rs/ethereum/ledger-suite-orchestrator/test_utils/Cargo.toml index 5280672a5d4b..12113c4aa972 100644 --- a/rs/ethereum/ledger-suite-orchestrator/test_utils/Cargo.toml +++ b/rs/ethereum/ledger-suite-orchestrator/test_utils/Cargo.toml @@ -7,7 +7,6 @@ edition.workspace = true documentation.workspace = true [dependencies] -assert_matches = { workspace = true } candid = { workspace = true } ic-base-types = { path = "../../../types/base_types" } ic-cdk = { workspace = true } @@ -15,12 +14,9 @@ ic-http-types = { path = "../../../../packages/ic-http-types" } ic-icrc1-ledger = { path = "../../../ledger_suite/icrc1/ledger" } ic-ledger-suite-orchestrator = { path = "../../ledger-suite-orchestrator" } ic-management-canister-types = { workspace = true } -ic-management-canister-types-private = { path = "../../../types/management_canister_types" } ic-metrics-assert = { path = "../../../../packages/ic-metrics-assert", features = ["pocket_ic"] } -ic-state-machine-tests = { path = "../../../state_machine_tests" } ic-test-utilities-load-wasm = { path = "../../../test_utilities/load_wasm" } ic-types-cycles = { path = "../../../types/cycles" } -ic-types = { path = "../../../types/types" } ic-universal-canister = { path = "../../../universal_canister/lib" } icrc-ledger-types = { path = "../../../../packages/icrc-ledger-types" } paste = { workspace = true } diff --git a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/flow.rs b/rs/ethereum/ledger-suite-orchestrator/test_utils/src/flow.rs deleted file mode 100644 index 3bc0e064cbdf..000000000000 --- a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/flow.rs +++ /dev/null @@ -1,459 +0,0 @@ -use crate::universal_canister::UniversalCanister; -use crate::{ - LedgerAccount, LedgerMetadataKey, LedgerMetadataValue, LedgerSuiteOrchestrator, - MINTER_PRINCIPAL, assert_reply, ledger_wasm, out_of_band_upgrade, stop_canister, -}; -use candid::{Decode, Encode, Nat, Principal}; -use ic_base_types::{CanisterId, PrincipalId}; -use ic_icrc1_ledger::ChangeArchiveOptions; -use ic_ledger_suite_orchestrator::candid::{AddErc20Arg, ManagedCanisterIds}; -use ic_ledger_suite_orchestrator::state::{IndexWasm, LedgerWasm}; -use ic_management_canister_types::{CanisterInfoResult, CanisterInstallMode, InstallCodeArgs}; -use ic_management_canister_types_private::CanisterStatusResultV2; -use ic_metrics_assert::{CanisterHttpQuery, MetricsAssert}; -use ic_state_machine_tests::{StateMachine, UserError}; -use icrc_ledger_types::icrc1::transfer::{TransferArg, TransferError}; -use icrc_ledger_types::icrc3::archive::ArchiveInfo; -use icrc_ledger_types::icrc3::blocks::{GetBlocksRequest, GetBlocksResult}; -use std::collections::BTreeSet; - -pub struct AddErc20TokenFlow { - pub setup: LedgerSuiteOrchestrator, - pub params: AddErc20Arg, -} - -impl AddErc20TokenFlow { - pub fn expect_new_ledger_and_index_canisters(self) -> ManagedCanistersAssert { - let contract = self.params.contract; - let canister_ids = self.setup.wait_for(|| { - match self.setup.call_orchestrator_canister_ids(&contract) { - Some(ids) if ids.ledger.is_some() && ids.index.is_some() => Ok(ids), - incomplete_ids => Err(format!( - "Not all canister IDs are available for ERC-20 {contract:?}: {incomplete_ids:?}" - )), - } - }); - assert_ne!( - canister_ids.ledger, canister_ids.index, - "BUG: ledger and index canister IDs MUST be different" - ); - - self.setup - .wait_for_canister_to_be_installed_and_running(canister_ids.ledger.unwrap()); - self.setup - .wait_for_canister_to_be_installed_and_running(canister_ids.index.unwrap()); - - ManagedCanistersAssert { - setup: self.setup, - canister_ids, - } - } -} - -pub struct ManagedCanistersAssert { - pub setup: LedgerSuiteOrchestrator, - pub canister_ids: ManagedCanisterIds, -} - -impl AsRef for ManagedCanistersAssert { - fn as_ref(&self) -> &StateMachine { - self.setup.env.as_ref() - } -} - -impl ManagedCanistersAssert { - pub fn assert_all_controlled_by(self, expected_controllers: &[Principal]) -> Self { - for canister_id in self.all_canister_ids() { - assert_eq!( - self.setup - .canister_status_of(canister_id) - .settings() - .controllers() - .into_iter() - .map(|p| p.0) - .collect::>(), - expected_controllers - .iter() - .copied() - .collect::>(), // convert to set to ignore order - "BUG: unexpected controller for canister {} in managed canisters {}", - canister_id, - self.canister_ids - ); - } - self - } - - pub fn check_metrics(self) -> MetricsAssert { - MetricsAssert::from_http_query(self) - } - - pub fn trigger_creation_of_archive(self) -> Self { - const ARCHIVE_TRIGGER_THRESHOLD: usize = 10; - - // The productive value for `trigger_threshold` is `2_000`, - // which would require `2_000` transfers to trigger the creation of an archive, - // which would take in the order of 20s (order of magnitude is 10ms per transfer with state machine tests). - // We set this value to an artificially low number to speed up the test. - self.upgrade_ledger_to_change_archive_options(ChangeArchiveOptions { - trigger_threshold: Some(ARCHIVE_TRIGGER_THRESHOLD), - ..Default::default() - }); - let archive_ids_before: BTreeSet<_> = self - .call_ledger_archives() - .into_iter() - .map(|info| info.canister_id) - .collect(); - - for _i in 0..ARCHIVE_TRIGGER_THRESHOLD { - let from = MINTER_PRINCIPAL; - let to = Principal::management_canister(); - self.call_ledger_icrc1_transfer( - from, - &TransferArg { - from_subaccount: None, - to: to.into(), - fee: None, - created_at_time: None, - memo: None, - amount: Nat::from(1_u8), - }, - ) - .expect("BUG: fail to make a transfer to trigger archive creation"); - } - - let archive_ids_after: BTreeSet<_> = self - .call_ledger_archives() - .into_iter() - .map(|info| info.canister_id) - .collect(); - assert_eq!( - archive_ids_after.len(), - archive_ids_before.len() + 1, - "BUG: expected one more archive canister" - ); - assert!(archive_ids_before.is_subset(&archive_ids_after)); - - Self { - setup: self.setup, - canister_ids: ManagedCanisterIds { - ledger: self.canister_ids.ledger, - index: self.canister_ids.index, - archives: Vec::from_iter(archive_ids_after), - }, - } - } - - pub fn assert_ledger_canister_info_satisfy bool>( - self, - caller: &UniversalCanister, - predicate: P, - ) -> Self { - let canister_info = caller.canister_info(self.ledger_canister_id()); - assert!( - predicate(&canister_info), - "BUG: ledger canister info does not satisfy predicate. Canister info: {canister_info:?}" - ); - self - } - - pub fn assert_index_canister_info_satisfy bool>( - self, - caller: &UniversalCanister, - predicate: P, - ) -> Self { - let canister_info = caller.canister_info(self.index_canister_id()); - assert!( - predicate(&canister_info), - "BUG: index canister info does not satisfy predicate. Canister info: {canister_info:?}" - ); - self - } - - pub fn assert_all_archive_canister_info_satisfy bool>( - self, - caller: &UniversalCanister, - predicate: P, - ) -> Self { - assert!( - !self.canister_ids.archives.is_empty(), - "BUG: no archive canisters" - ); - for archive in self.archive_canister_ids() { - let canister_info = caller.canister_info(archive); - assert!( - predicate(&canister_info), - "BUG: archive canister info does not satisfy predicate. Canister info: {canister_info:?}" - ); - } - self - } - - pub fn stop_ledger(self) -> Self { - stop_canister( - &self, - self.setup.ledger_suite_orchestrator_id, - self.ledger_canister_id(), - ); - self - } - - pub fn stop_index(self) -> Self { - stop_canister( - &self, - self.setup.ledger_suite_orchestrator_id, - self.index_canister_id(), - ); - self - } - - pub fn ledger_out_of_band_upgrade>( - self, - controller: T, - wasm: LedgerWasm, - ) -> Self { - out_of_band_upgrade( - &self, - controller.into(), - self.ledger_canister_id(), - wasm.to_bytes(), - ) - .expect("failed to upgrade ledger canister"); - self - } - - pub fn index_out_of_band_upgrade>( - self, - controller: T, - wasm: IndexWasm, - ) -> Self { - out_of_band_upgrade( - &self, - controller.into(), - self.index_canister_id(), - wasm.to_bytes(), - ) - .expect("failed to upgrade index canister"); - self - } - - pub fn call_ledger_icrc1_transfer( - &self, - from: Principal, - arg: &TransferArg, - ) -> Result { - Decode!( - &self.setup.env.execute_ingress_as( - PrincipalId(from), - self.ledger_canister_id(), - "icrc1_transfer", - Encode!(arg) - .unwrap() - ) - .expect("failed to transfer funds") - .bytes(), - Result - ) - .expect("failed to decode transfer response") - } - - pub fn upgrade_ledger_to_change_archive_options(&self, archive_options: ChangeArchiveOptions) { - use ic_icrc1_ledger::{LedgerArgument, UpgradeArgs as LedgerUpgradeArgs}; - - let module_hash_before = self - .ledger_canister_status() - .module_hash() - .expect("BUG: ledger is not installed"); - - let upgrade_args = Some(LedgerArgument::Upgrade(Some(LedgerUpgradeArgs { - change_archive_options: Some(archive_options), - ..Default::default() - }))); - let res = self.setup.env.execute_ingress_as( - self.setup.ledger_suite_orchestrator_id.into(), - CanisterId::ic_00(), - "install_code", - Encode!(&InstallCodeArgs { - mode: CanisterInstallMode::Upgrade(None), - canister_id: self.ledger_canister_id().into(), - wasm_module: ledger_wasm().to_bytes(), - arg: Encode!(&upgrade_args).unwrap(), - sender_canister_version: None, - }) - .unwrap(), - ); - assert_reply(res.unwrap()); - let module_hash_after = self - .ledger_canister_status() - .module_hash() - .expect("BUG: ledger is not installed"); - assert_eq!( - module_hash_before, module_hash_after, - "BUG: ledger wasm hash changed when changing archive options" - ); - } - - pub fn call_ledger_icrc3_get_blocks(&self, request: &Vec) -> GetBlocksResult { - Decode!( - &self - .setup - .env - .execute_ingress( - self.ledger_canister_id(), - "icrc3_get_blocks", - Encode!(request).unwrap() - ) - .expect("failed to call icrc3_get_blocks") - .bytes(), - GetBlocksResult - ) - .expect("failed to decode icrc3_get_blocks response") - } - - fn call_ledger_archives(&self) -> Vec { - Decode!( - &self - .setup - .env - .query(self.ledger_canister_id(), "archives", Encode!().unwrap()) - .expect("failed to query archives") - .bytes(), - Vec - ) - .expect("failed to decode archives response") - } - - pub fn assert_index_has_correct_ledger_id(self) -> Self { - assert_eq!( - self.call_index_ledger_id(), - self.canister_ids.ledger.unwrap() - ); - self - } - - pub fn ledger_canister_status(&self) -> CanisterStatusResultV2 { - self.setup.canister_status_of(self.ledger_canister_id()) - } - - pub fn assert_ledger_has_cycles(self, expected: u128) -> Self { - assert_eq!(self.ledger_canister_status().cycles(), expected); - self - } - - pub fn assert_index_has_cycles(self, expected: u128) -> Self { - assert_eq!( - self.setup - .canister_status_of(self.index_canister_id()) - .cycles(), - expected - ); - self - } - - pub fn assert_all_archives_have_cycles(self, expected: u128) -> Self { - assert!( - !self.archive_canister_ids().is_empty(), - "BUG: no archive canisters" - ); - for archive in self.archive_canister_ids() { - assert_eq!(self.setup.canister_status_of(archive).cycles(), expected); - } - self - } - - pub fn assert_ledger_has_wasm_hash>(self, expected: T) -> Self { - assert_eq!( - self.ledger_canister_status().module_hash(), - Some(expected.as_ref().to_vec()), - "BUG: unexpected wasm hash for ledger canister" - ); - self - } - - pub fn assert_index_has_wasm_hash>(self, expected: T) -> Self { - assert_eq!( - self.setup - .canister_status_of(self.index_canister_id()) - .module_hash(), - Some(expected.as_ref().to_vec()), - "BUG: unexpected wasm hash for index canister" - ); - self - } - - fn call_index_ledger_id(&self) -> Principal { - Decode!( - &assert_reply( - self.setup - .env - .query(self.index_canister_id(), "ledger_id", Encode!().unwrap()) - .expect("failed to query get_transactions on the ledger") - ), - Principal - ) - .unwrap() - } - pub fn ledger_canister_id(&self) -> CanisterId { - CanisterId::unchecked_from_principal(PrincipalId::from(self.canister_ids.ledger.unwrap())) - } - - pub fn index_canister_id(&self) -> CanisterId { - CanisterId::unchecked_from_principal(PrincipalId::from(self.canister_ids.index.unwrap())) - } - - pub fn archive_canister_ids(&self) -> Vec { - self.canister_ids - .archives - .iter() - .map(|p| CanisterId::unchecked_from_principal(PrincipalId::from(*p))) - .collect() - } - - fn all_canister_ids(&self) -> Vec { - vec![self.ledger_canister_id(), self.index_canister_id()] - .into_iter() - .chain(self.archive_canister_ids()) - .collect() - } -} - -impl CanisterHttpQuery for ManagedCanistersAssert { - fn http_query(&self, request: Vec) -> Result, UserError> { - self.setup.http_query(request) - } -} - -macro_rules! assert_ledger { - ($name:expr_2021, $ty:ty) => { - paste::paste! { - pub fn [](env: &ic_state_machine_tests::StateMachine, ledger_canister_id: ic_base_types::CanisterId) -> $ty { - candid::Decode!( - &assert_reply( - env - .query(ledger_canister_id, $name, candid::Encode!().unwrap()) - .expect("failed to query on the ledger") - ), - $ty - ) - .unwrap() - } - impl ManagedCanistersAssert { - pub fn []>(self, expected: T) -> Self { - assert_eq!([](&self.setup.env, self.ledger_canister_id()), expected.into(), "BUG: unexpected value for ledger {}", stringify!($name)); - self - } - } - } - }; -} - -assert_ledger!("icrc1_name", String); -assert_ledger!("icrc1_symbol", String); -assert_ledger!("icrc1_decimals", u8); -assert_ledger!("icrc1_total_supply", Nat); -assert_ledger!("icrc1_fee", Nat); -assert_ledger!("icrc1_minting_account", Option); -assert_ledger!( - "icrc1_metadata", - Vec<(LedgerMetadataKey, LedgerMetadataValue)> -); diff --git a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/lib.rs b/rs/ethereum/ledger-suite-orchestrator/test_utils/src/lib.rs index cbaecc4aa206..d6758dc9f54e 100644 --- a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/lib.rs +++ b/rs/ethereum/ledger-suite-orchestrator/test_utils/src/lib.rs @@ -1,28 +1,13 @@ -use crate::flow::{AddErc20TokenFlow, ManagedCanistersAssert}; -use assert_matches::assert_matches; -use candid::{Decode, Encode, Nat, Principal}; -use ic_base_types::{CanisterId, PrincipalId}; -use ic_cdk::management_canister::CanisterStatusResult; +use candid::{Nat, Principal}; use ic_ledger_suite_orchestrator::candid::{ - AddErc20Arg, CyclesManagement, Erc20Contract, InitArg, InstalledCanister, InstalledLedgerSuite, - LedgerInitArg, ManagedCanisterIds, OrchestratorArg, OrchestratorInfo, UpgradeArg, + AddErc20Arg, Erc20Contract, InitArg, InstalledCanister, InstalledLedgerSuite, LedgerInitArg, }; -use ic_ledger_suite_orchestrator::state::{ - ArchiveWasm, IndexWasm, LedgerSuiteVersion, LedgerWasm, Wasm, WasmHash, -}; -use ic_management_canister_types::{CanisterInstallMode, InstallCodeArgs}; -use ic_management_canister_types_private::{CanisterStatusResultV2, CanisterStatusType}; -use ic_metrics_assert::{CanisterHttpQuery, MetricsAssert}; -use ic_state_machine_tests::{StateMachine, StateMachineBuilder, UserError, WasmResult}; -use ic_types_cycles::Cycles; +use ic_ledger_suite_orchestrator::state::{ArchiveWasm, IndexWasm, LedgerWasm, Wasm}; pub use icrc_ledger_types::icrc::generic_metadata_value::MetadataValue as LedgerMetadataValue; pub use icrc_ledger_types::icrc::metadata_key::MetadataKey as LedgerMetadataKey; pub use icrc_ledger_types::icrc1::account::Account as LedgerAccount; -use std::sync::Arc; -pub mod flow; pub mod pocket_ic; -pub mod universal_canister; const MAX_TICKS: usize = 10; const GIT_COMMIT_HASH: &str = "6a8e5fca2c6b4e12966638c444e994e204b42989"; @@ -34,322 +19,6 @@ pub const NNS_ROOT_PRINCIPAL: Principal = Principal::from_slice(&[0_u8]); pub const MINTER_PRINCIPAL: Principal = Principal::from_slice(&[0_u8, 0, 0, 0, 2, 48, 0, 156, 1, 1]); -pub struct LedgerSuiteOrchestrator { - pub env: Arc, - pub ledger_suite_orchestrator_id: CanisterId, - pub ledger_suite_orchestrator_wasm: Vec, - pub embedded_ledger_wasm_hash: WasmHash, - pub embedded_index_wasm_hash: WasmHash, - pub embedded_archive_wasm_hash: WasmHash, -} - -impl Default for LedgerSuiteOrchestrator { - fn default() -> Self { - Self::new(Arc::new(new_state_machine()), default_init_arg()).register_embedded_wasms() - } -} - -impl AsRef for LedgerSuiteOrchestrator { - fn as_ref(&self) -> &StateMachine { - &self.env - } -} - -impl LedgerSuiteOrchestrator { - pub fn with_cycles_management(cycles_management: CyclesManagement) -> Self { - let init_arg = InitArg { - cycles_management: Some(cycles_management), - ..default_init_arg() - }; - Self::new(Arc::new(new_state_machine()), init_arg) - } - - pub fn new(env: Arc, init_arg: InitArg) -> Self { - let ledger_suite_orchestrator_id = - env.create_canister_with_cycles(None, Cycles::new(u128::MAX), None); - Self { - env, - ledger_suite_orchestrator_id, - ledger_suite_orchestrator_wasm: ledger_suite_orchestrator_wasm(), - embedded_ledger_wasm_hash: ledger_wasm().hash().clone(), - embedded_index_wasm_hash: index_wasm().hash().clone(), - embedded_archive_wasm_hash: archive_wasm().hash().clone(), - } - .install_ledger_suite_orchestrator(init_arg) - } - - pub fn new_with_ledger_get_blocks_disabled(env: Arc, init_arg: InitArg) -> Self { - let ledger_suite_orchestrator_id = - env.create_canister_with_cycles(None, Cycles::new(u128::MAX), None); - Self { - env, - ledger_suite_orchestrator_id, - ledger_suite_orchestrator_wasm: ledger_suite_orchestrator_get_blocks_disabled_wasm(), - embedded_ledger_wasm_hash: ledger_get_blocks_disabled_wasm().hash().clone(), - embedded_index_wasm_hash: index_wasm().hash().clone(), - embedded_archive_wasm_hash: archive_wasm().hash().clone(), - } - .install_ledger_suite_orchestrator(init_arg) - } - - fn install_ledger_suite_orchestrator(self, init_arg: InitArg) -> Self { - self.env - .install_existing_canister( - self.ledger_suite_orchestrator_id, - self.ledger_suite_orchestrator_wasm.clone(), - Encode!(&OrchestratorArg::InitArg(init_arg)).unwrap(), - ) - .unwrap(); - self - } - - pub fn upgrade_ledger_suite_orchestrator_expecting_ok( - self, - upgrade_arg: &OrchestratorArg, - ) -> Self { - self.upgrade_ledger_suite_orchestrator_with_same_wasm(upgrade_arg) - .expect("Failed to upgrade ledger suite orchestrator"); - self - } - - pub fn register_embedded_wasms(self) -> Self { - self.upgrade_ledger_suite_orchestrator_expecting_ok(&OrchestratorArg::UpgradeArg( - UpgradeArg { - git_commit_hash: Some(GIT_COMMIT_HASH.to_string()), - ledger_compressed_wasm_hash: None, - index_compressed_wasm_hash: None, - archive_compressed_wasm_hash: None, - cycles_management: None, - manage_ledger_suites: None, - }, - )) - } - - pub fn embedded_ledger_suite_version(&self) -> LedgerSuiteVersion { - LedgerSuiteVersion { - ledger_compressed_wasm_hash: self.embedded_ledger_wasm_hash.clone(), - index_compressed_wasm_hash: self.embedded_index_wasm_hash.clone(), - archive_compressed_wasm_hash: self.embedded_archive_wasm_hash.clone(), - } - } - - pub fn upgrade_ledger_suite_orchestrator_with_same_wasm( - &self, - upgrade_arg: &OrchestratorArg, - ) -> Result<(), UserError> { - self.env.tick(); //tick before upgrade to finish current timers which are reset afterwards - self.env.upgrade_canister( - self.ledger_suite_orchestrator_id, - self.ledger_suite_orchestrator_wasm.clone(), - Encode!(upgrade_arg).unwrap(), - ) - } - - pub fn get_canister_status(&self) -> CanisterStatusResult { - Decode!( - &assert_reply( - self.env - .execute_ingress( - self.ledger_suite_orchestrator_id, - "get_canister_status", - Encode!().unwrap() - ) - .expect("failed to call get_canister_status") - ), - CanisterStatusResult - ) - .unwrap() - } - - pub fn assert_managed_canisters(self, contract: &Erc20Contract) -> ManagedCanistersAssert { - let canister_ids = self - .call_orchestrator_canister_ids(contract) - .unwrap_or_else(|| panic!("No managed canister IDs found for contract {contract:?}")); - - assert_ne!( - canister_ids.ledger, canister_ids.index, - "BUG: ledger and index canister IDs MUST be different" - ); - - ManagedCanistersAssert { - setup: self, - canister_ids, - } - } - - pub fn add_erc20_token(self, params: AddErc20Arg) -> AddErc20TokenFlow { - let setup = self.upgrade_ledger_suite_orchestrator_expecting_ok( - &OrchestratorArg::AddErc20Arg(params.clone()), - ); - AddErc20TokenFlow { setup, params } - } - - pub fn manage_installed_canisters( - self, - manage_installed_canister: Vec, - ) -> Self { - self.upgrade_ledger_suite_orchestrator_expecting_ok(&OrchestratorArg::UpgradeArg( - UpgradeArg { - git_commit_hash: None, - ledger_compressed_wasm_hash: None, - index_compressed_wasm_hash: None, - archive_compressed_wasm_hash: None, - cycles_management: None, - manage_ledger_suites: Some(manage_installed_canister), - }, - )) - } - - pub fn upgrade_ledger_suite_orchestrator( - self, - new_ledger_suite_orchestrator_wasm: Vec, - upgrade_arg: UpgradeArg, - ) -> Self { - self.env.tick(); //tick before upgrade to finish current timers which are reset afterwards - let new_embedded_ledger_wasm_hash = upgrade_arg - .ledger_compressed_wasm_hash - .clone() - .map(|s| s.parse().unwrap()) - .unwrap_or(self.embedded_ledger_wasm_hash); - let new_embedded_index_wasm_hash = upgrade_arg - .index_compressed_wasm_hash - .clone() - .map(|s| s.parse().unwrap()) - .unwrap_or(self.embedded_index_wasm_hash); - let new_embedded_archive_wasm_hash = upgrade_arg - .archive_compressed_wasm_hash - .clone() - .map(|s| s.parse().unwrap()) - .unwrap_or(self.embedded_archive_wasm_hash); - self.env - .upgrade_canister( - self.ledger_suite_orchestrator_id, - new_ledger_suite_orchestrator_wasm.clone(), - Encode!(&OrchestratorArg::UpgradeArg(upgrade_arg)).unwrap(), - ) - .expect("Failed to upgrade ERC20"); - Self { - env: self.env, - ledger_suite_orchestrator_id: self.ledger_suite_orchestrator_id, - ledger_suite_orchestrator_wasm: new_ledger_suite_orchestrator_wasm, - embedded_ledger_wasm_hash: new_embedded_ledger_wasm_hash, - embedded_index_wasm_hash: new_embedded_index_wasm_hash, - embedded_archive_wasm_hash: new_embedded_archive_wasm_hash, - } - } - - pub fn call_orchestrator_canister_ids( - &self, - contract: &Erc20Contract, - ) -> Option { - Decode!( - &assert_reply( - self.env - .execute_ingress( - self.ledger_suite_orchestrator_id, - "canister_ids", - Encode!(contract).unwrap() - ) - .expect("failed to execute token transfer") - ), - Option - ) - .unwrap() - } - - pub fn advance_time_for_periodic_tasks(&self) { - self.env - .advance_time(std::time::Duration::from_secs(60 * 60 + 1)); - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - } - - pub fn advance_time_for_upgrade(&self) { - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - self.env.tick(); - } - - pub fn canister_status_of(&self, controlled_canister_id: CanisterId) -> CanisterStatusResultV2 { - self.env - .canister_status_as( - self.ledger_suite_orchestrator_id.into(), - controlled_canister_id, - ) - .unwrap() - .unwrap() - } - - pub fn get_orchestrator_info(&self) -> OrchestratorInfo { - Decode!( - &assert_reply( - self.env - .query( - self.ledger_suite_orchestrator_id, - "get_orchestrator_info", - Encode!().unwrap() - ) - .unwrap() - ), - OrchestratorInfo - ) - .unwrap() - } - - pub fn check_metrics(self) -> MetricsAssert { - MetricsAssert::from_http_query(self) - } - - pub fn wait_for(&self, f: F) -> T - where - F: Fn() -> Result, - E: std::fmt::Debug, - { - let mut last_error = None; - for _ in 0..MAX_TICKS { - self.env.tick(); - match f() { - Ok(t) => return t, - Err(e) => { - last_error = Some(e); - } - } - } - panic!("Failed to get result after {MAX_TICKS} ticks: {last_error:?}"); - } - - pub fn wait_for_canister_to_be_installed_and_running(&self, canister_id: Principal) { - let canister_id = PrincipalId(canister_id).try_into().unwrap(); - self.wait_for(|| { - let ledger_status = self.canister_status_of(canister_id); - if ledger_status.status() == CanisterStatusType::Running - && ledger_status.module_hash().is_some() - { - Ok(()) - } else { - Err(format!( - "Canister {canister_id} is not ready {ledger_status:?}" - )) - } - }); - } -} - -impl CanisterHttpQuery for LedgerSuiteOrchestrator { - fn http_query(&self, request: Vec) -> Result, UserError> { - self.as_ref() - .query(self.ledger_suite_orchestrator_id, "http_request", request) - .map(assert_reply) - } -} - pub fn default_init_arg() -> InitArg { InitArg { more_controller_ids: vec![NNS_ROOT_PRINCIPAL], @@ -358,13 +27,6 @@ pub fn default_init_arg() -> InitArg { } } -pub fn new_state_machine() -> StateMachine { - StateMachineBuilder::new() - .with_master_ecdsa_public_key() - .with_default_canister_range() - .build() -} - pub fn ledger_suite_orchestrator_wasm() -> Vec { let wasm_path = std::env::var("LEDGER_SUITE_ORCHESTRATOR_WASM_PATH").unwrap(); std::fs::read(wasm_path).unwrap() @@ -487,51 +149,3 @@ fn ledger_init_arg, V: Into>( token_logo: "".to_string(), } } - -pub fn assert_reply(result: WasmResult) -> Vec { - match result { - WasmResult::Reply(bytes) => bytes, - WasmResult::Reject(reject) => { - panic!("Expected a successful reply, got a reject: {reject}") - } - } -} - -pub fn out_of_band_upgrade>( - env: T, - controller: PrincipalId, - target: CanisterId, - wasm: Vec, -) -> Result<(), UserError> { - env.as_ref() - .execute_ingress_as( - controller, - CanisterId::ic_00(), - "install_code", - Encode!(&InstallCodeArgs { - mode: CanisterInstallMode::Upgrade(None), - canister_id: target.into(), - wasm_module: wasm, - arg: Encode!(&()).unwrap(), - sender_canister_version: None, - }) - .unwrap(), - ) - .map(|_| ()) -} - -pub fn stop_canister, P: Into>( - env: T, - controller: P, - target: CanisterId, -) { - let controller = controller.into(); - let stop_res = env.as_ref().stop_canister_as(controller, target); - assert_matches!(stop_res, Ok(WasmResult::Reply(_))); - let status = env - .as_ref() - .canister_status_as(controller, target) - .unwrap() - .unwrap(); - assert_eq!(status.status(), CanisterStatusType::Stopped); -} diff --git a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/universal_canister.rs b/rs/ethereum/ledger-suite-orchestrator/test_utils/src/universal_canister.rs deleted file mode 100644 index ff20a7547332..000000000000 --- a/rs/ethereum/ledger-suite-orchestrator/test_utils/src/universal_canister.rs +++ /dev/null @@ -1,67 +0,0 @@ -use crate::assert_reply; -use candid::{Decode, Encode}; -use ic_base_types::{CanisterId, PrincipalId}; -use ic_management_canister_types::CanisterInfoArgs; -pub use ic_management_canister_types::{ - CanisterInfoResult, CanisterStatusType, ChangeDetails, CodeDeploymentMode, CodeDeploymentRecord, -}; -use ic_state_machine_tests::StateMachine; -use ic_types_cycles::Cycles; -use ic_universal_canister::{UNIVERSAL_CANISTER_WASM, call_args, wasm}; -use std::sync::Arc; - -pub struct UniversalCanister { - pub env: Arc, - pub canister_id: CanisterId, -} - -impl UniversalCanister { - pub fn new(env: Arc) -> Self { - let canister_id = env.create_canister_with_cycles(None, Cycles::new(u128::MAX), None); - Self { env, canister_id }.install_wasm() - } - - fn install_wasm(self) -> Self { - self.env - .install_existing_canister(self.canister_id, UNIVERSAL_CANISTER_WASM.to_vec(), vec![]) - .unwrap(); - self - } - - pub fn canister_info(&self, target: CanisterId) -> CanisterInfoResult { - let info_request_payload = universal_canister_payload( - &PrincipalId::default(), - "canister_info", - Encode!(&CanisterInfoArgs { - canister_id: target.into(), - num_requested_changes: Some(u64::MAX), - }) - .unwrap(), - Cycles::new(0), - ); - let bytes = assert_reply( - self.env - .execute_ingress(self.canister_id, "update", info_request_payload) - .unwrap(), - ); - Decode!(&bytes[..], CanisterInfoResult).expect("failed to decode canister_info response") - } -} - -fn universal_canister_payload( - receiver: &PrincipalId, - method: &str, - payload: Vec, - cycles: Cycles, -) -> Vec { - wasm() - .call_with_cycles( - receiver, - method, - call_args() - .other_side(payload) - .on_reject(wasm().reject_message().reject()), - cycles, - ) - .build() -}