chore(ICP-Ledger): remove dfn_core from icp ledger lib (#4095)

Changes:
- Remove `DfnRuntime`, move `CdkRuntime` to `ledger_canister_core`.
- Use `CdkRuntime` in the ICP ledger.
- Use cdk `time` and `trap` in `icp/ledger/src/lib`, fix related tests -
`ic_cdk::api::time` cannot be called in tests, have to provide the time
with `add_payment_with_timestamp`.
- Import `CanisterId` from `ic_base_types` instead of `dfn_core` in
`AccountIdentifier`.

Author: maciejdfinity

Cargo.lock

@@ -21,6 +21,7 @@ rust_library(
         "//rs/types/management_canister_types",
         "//rs/utils",
         "@crate_index//:candid",
+        "@crate_index//:ic-cdk",
         "@crate_index//:serde",
     ],
 )

rs/ledger_suite/common/ledger_canister_core/BUILD.bazel

@@ -11,6 +11,7 @@ async-trait = { workspace = true }
 candid = { workspace = true }
 ic-base-types = { path = "../../../types/base_types" }
 ic-canister-log = { path = "../../../rust_canisters/canister_log" }
+ic-cdk = { workspace = true }
 ic-limits = { path = "../../../limits" }
 ic-ledger-core = { path = "../ledger_core" }
 ic-ledger-hash-of = { path = "../../../../packages/ic-ledger-hash-of" }

rs/ledger_suite/common/ledger_canister_core/Cargo.toml

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use candid::utils::{ArgumentDecoder, ArgumentEncoder};
-use ic_base_types::CanisterId;
+use ic_base_types::{CanisterId, PrincipalId};
 
 #[async_trait]
 pub trait Runtime {
@@ -33,3 +33,33 @@ pub fn heap_memory_size_bytes() -> usize {
 pub fn heap_memory_size_bytes() -> usize {
     0
 }
+
+#[derive(Debug)]
+pub struct CdkRuntime;
+
+#[async_trait]
+impl Runtime for CdkRuntime {
+    fn id() -> CanisterId {
+        CanisterId::try_from(PrincipalId::from(ic_cdk::api::id())).unwrap()
+    }
+
+    fn print(msg: impl AsRef<str>) {
+        ic_cdk::api::print(msg)
+    }
+
+    async fn call<In, Out>(
+        id: CanisterId,
+        method: &str,
+        cycles: u64,
+        args: In,
+    ) -> Result<Out, (i32, String)>
+    where
+        In: ArgumentEncoder + Send,
+        Out: for<'a> ArgumentDecoder<'a>,
+    {
+        let principal_id = PrincipalId::from(id);
+        ic_cdk::api::call::call_with_payment(principal_id.into(), method, args, cycles)
+            .await
+            .map_err(|(code, msg)| (code as i32, msg))
+    }
+}

rs/ledger_suite/common/ledger_canister_core/src/runtime.rs

@@ -8,7 +8,6 @@ package(default_visibility = ["//visibility:public"])
     rust_library(
         name = "ledger" + name_suffix,
         srcs = [
-            "src/dfn_runtime.rs",
             "src/lib.rs",
             "src/tests.rs",
         ],
@@ -35,8 +34,6 @@ package(default_visibility = ["//visibility:public"])
             "//rs/ledger_suite/icp:icp_ledger",
             "//rs/ledger_suite/icrc1",
             "//rs/limits",
-            "//rs/rust_canisters/dfn_candid",
-            "//rs/rust_canisters/dfn_core",
             "//rs/types/base_types",
             "@crate_index//:candid",
             "@crate_index//:hex",

rs/ledger_suite/icp/ledger/BUILD.bazel

@@ -1,10 +1,11 @@
-use dfn_core::api::{now, trap_with};
 use ic_base_types::{CanisterId, PrincipalId};
+use ic_cdk::{api::time, trap};
 use ic_ledger_canister_core::archive::ArchiveCanisterWasm;
 use ic_ledger_canister_core::blockchain::Blockchain;
 use ic_ledger_canister_core::ledger::{
     self as core_ledger, LedgerContext, LedgerData, TransactionInfo,
 };
+use ic_ledger_canister_core::runtime::CdkRuntime;
 use ic_ledger_core::balances::BalancesStore;
 use ic_ledger_core::{
     approvals::{Allowance, AllowanceTable, AllowancesData},
@@ -32,8 +33,6 @@ use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::sync::RwLock;
 use std::time::Duration;
 
-mod dfn_runtime;
-
 #[cfg(test)]
 mod tests;
 
@@ -193,7 +192,7 @@ pub struct Ledger {
     approvals: LedgerAllowances,
     #[serde(default)]
     stable_approvals: AllowanceTable<StableAllowancesData>,
-    pub blockchain: Blockchain<dfn_runtime::DfnRuntime, IcpLedgerArchiveWasm>,
+    pub blockchain: Blockchain<CdkRuntime, IcpLedgerArchiveWasm>,
     // DEPRECATED
     pub maximum_number_of_accounts: usize,
     // DEPRECATED
@@ -269,7 +268,7 @@ impl LedgerContext for Ledger {
 }
 
 impl LedgerData for Ledger {
-    type Runtime = dfn_runtime::DfnRuntime;
+    type Runtime = CdkRuntime;
     type ArchiveWasm = IcpLedgerArchiveWasm;
     type Transaction = Transaction;
     type Block = Block;
@@ -373,7 +372,7 @@ impl Ledger {
         operation: Operation,
         created_at_time: Option<TimeStamp>,
     ) -> Result<(BlockIndex, HashOf<EncodedBlock>), PaymentError> {
-        let now = TimeStamp::from(dfn_core::api::now());
+        let now = TimeStamp::from_nanos_since_unix_epoch(time());
         self.add_payment_with_timestamp(memo, operation, created_at_time, now)
     }
 
@@ -554,7 +553,7 @@ impl Ledger {
     pub fn upgrade(&mut self, args: UpgradeArgs) {
         if let Some(icrc1_minting_account) = args.icrc1_minting_account {
             if Some(AccountIdentifier::from(icrc1_minting_account)) != self.minting_account_id {
-                trap_with(
+                trap(
                     "The icrc1 minting account is not the same as the minting account set during initialization",
                 );
             }
@@ -629,7 +628,7 @@ pub fn change_notification_state(
         height,
         block_timestamp,
         new_state,
-        TimeStamp::from(now()),
+        TimeStamp::from_nanos_since_unix_epoch(time()),
     )
 }
 

rs/ledger_suite/icp/ledger/src/dfn_runtime.rs

@@ -278,41 +278,46 @@ fn bad_created_at_time() {
         amount: Tokens::from_e8s(1000),
     };
 
-    let now = dfn_core::api::now().into();
+    let now = SystemTime::now().into();
 
     assert_eq!(
         PaymentError::TransferError(TransferError::TxTooOld {
             allowed_window_nanos: Duration::from_secs(24 * 60 * 60).as_nanos() as u64,
         }),
         state
-            .add_payment(
+            .add_payment_with_timestamp(
                 Memo(1),
                 transfer.clone(),
-                Some(now - state.transaction_window - Duration::from_secs(1))
+                Some(now - state.transaction_window - Duration::from_secs(1)),
+                now
             )
             .unwrap_err()
     );
 
     state
-        .add_payment(
+        .add_payment_with_timestamp(
             Memo(2),
             transfer.clone(),
             Some(now - Duration::from_secs(1)),
+            now,
         )
         .unwrap();
 
     assert_eq!(
         PaymentError::TransferError(TransferError::TxCreatedInFuture),
         state
-            .add_payment(
+            .add_payment_with_timestamp(
                 Memo(3),
                 transfer.clone(),
-                Some(now + Duration::from_secs(120))
+                Some(now + Duration::from_secs(120)),
+                now
             )
             .unwrap_err()
     );
 
-    state.add_payment(Memo(4), transfer, Some(now)).unwrap();
+    state
+        .add_payment_with_timestamp(Memo(4), transfer, Some(now), now)
+        .unwrap();
 }
 
 /// Check that block timestamps don't go backwards.
@@ -328,9 +333,15 @@ fn monotonic_timestamps() {
         amount: Tokens::from_e8s(1000),
     };
 
-    state.add_payment(Memo(1), transfer.clone(), None).unwrap();
+    let now = TimeStamp::from_nanos_since_unix_epoch(1_000_000_000);
 
-    state.add_payment(Memo(2), transfer.clone(), None).unwrap();
+    state
+        .add_payment_with_timestamp(Memo(1), transfer.clone(), None, now)
+        .unwrap();
+
+    state
+        .add_payment_with_timestamp(Memo(2), transfer.clone(), None, now)
+        .unwrap();
 
     state
         .add_payment_with_timestamp(
@@ -366,30 +377,31 @@ fn duplicate_txns() {
         amount: Tokens::from_e8s(1000),
     };
 
-    let now = dfn_core::api::now().into();
+    let now = SystemTime::now().into();
 
     assert_eq!(
         state
-            .add_payment(Memo::default(), transfer.clone(), Some(now))
+            .add_payment_with_timestamp(Memo::default(), transfer.clone(), Some(now), now)
             .unwrap()
             .0,
         0
     );
 
     assert_eq!(
         state
-            .add_payment(Memo(123), transfer.clone(), Some(now))
+            .add_payment_with_timestamp(Memo(123), transfer.clone(), Some(now), now)
             .unwrap()
             .0,
         1
     );
 
     assert_eq!(
         state
-            .add_payment(
+            .add_payment_with_timestamp(
                 Memo::default(),
                 transfer.clone(),
-                Some(now - Duration::from_secs(1))
+                Some(now - Duration::from_secs(1)),
+                now
             )
             .unwrap()
             .0,
@@ -412,7 +424,7 @@ fn duplicate_txns() {
     assert_eq!(
         PaymentError::TransferError(TransferError::TxDuplicate { duplicate_of: 0 }),
         state
-            .add_payment(Memo::default(), transfer.clone(), Some(now))
+            .add_payment_with_timestamp(Memo::default(), transfer.clone(), Some(now), now)
             .unwrap_err()
     );
 
@@ -670,7 +682,7 @@ fn test_throttle_tx_per_second_nok() {
         amount: Tokens::from_e8s(1000),
     };
 
-    let now: TimeStamp = dfn_core::api::now().into();
+    let now = TimeStamp::from_nanos_since_unix_epoch(1000000);
 
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1)), 0);
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1002)), 1);
@@ -693,7 +705,7 @@ fn test_throttle_tx_per_second_ok() {
         to: PrincipalId::new_user_test_id(1).into(),
         amount: Tokens::from_e8s(1000),
     };
-    let now: TimeStamp = dfn_core::api::now().into();
+    let now = TimeStamp::from_nanos_since_unix_epoch(1000000);
 
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1)), 0);
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1002)), 1);
@@ -714,7 +726,7 @@ fn test_throttle_two_tx_per_second_after_soft_limit_ok() {
         to: PrincipalId::new_user_test_id(1).into(),
         amount: Tokens::from_e8s(1000),
     };
-    let now: TimeStamp = dfn_core::api::now().into();
+    let now = TimeStamp::from_nanos_since_unix_epoch(1000000);
 
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1)), 0);
     assert_eq!(apply_at(&mut ledger, &op, now + millis(2)), 1);
@@ -741,7 +753,7 @@ fn test_throttle_two_tx_per_second_after_soft_limit_nok() {
         to: PrincipalId::new_user_test_id(1).into(),
         amount: Tokens::from_e8s(1000),
     };
-    let now: TimeStamp = dfn_core::api::now().into();
+    let now = TimeStamp::from_nanos_since_unix_epoch(1000000);
 
     assert_eq!(apply_at(&mut ledger, &op, now + millis(1)), 0);
     assert_eq!(apply_at(&mut ledger, &op, now + millis(2)), 1);

rs/ledger_suite/icp/ledger/src/lib.rs

@@ -1,6 +1,5 @@
 use candid::{CandidType, Principal};
-use dfn_core::CanisterId;
-use ic_base_types::{CanisterIdError, PrincipalId, PrincipalIdError};
+use ic_base_types::{CanisterId, CanisterIdError, PrincipalId, PrincipalIdError};
 use ic_crypto_sha2::Sha224;
 use ic_stable_structures::{storable::Bound, Storable};
 use icrc_ledger_types::icrc1::account::Account;