feat: DEFI-2671: schedule task for processing withdrawals

integration_tests/tests/tests.rs

@@ -16,7 +16,9 @@ use cksol_types::{
     UpdateBalanceArgs, UpdateBalanceError, WithdrawSolArgs, WithdrawSolError, WithdrawSolStatus,
 };
 use cksol_types_internal::{UpgradeArgs, event::EventType, log::Priority};
-use ic_pocket_canister_runtime::{JsonRpcResponse, MockHttpOutcalls, MockHttpOutcallsBuilder};
+use ic_pocket_canister_runtime::{
+    JsonRpcRequestMatcher, JsonRpcResponse, MockHttpOutcalls, MockHttpOutcallsBuilder,
+};
 use icrc_ledger_types::icrc1::account::Subaccount;
 use serde_json::json;
 use sol_rpc_types::{CommitmentLevel, ConsensusStrategy, GetTransactionEncoding, RpcConfig};
@@ -209,6 +211,8 @@ mod withdraw_sol_tests {
 
     use super::*;
 
+    const WITHDRAWAL_PROCESSING_DELAY: Duration = Duration::from_mins(1);
+
     #[tokio::test]
     async fn should_validate_solana_address() {
         let setup = SetupBuilder::new().build().await;
@@ -556,6 +560,76 @@ mod withdraw_sol_tests {
 
         setup.drop().await;
     }
+
+    #[tokio::test]
+    async fn should_process_pending_withdrawals() {
+        const WITHDRAWAL_AMOUNT: u64 = 100_000_000;
+        const WITHDRAWAL_ADDRESS: &str = "E4MpwNnMWs2XtW5gVrxZvyS7fMq31QD5HvbxmwP45Tz3";
+
+        let setup = SetupBuilder::new()
+            .with_initial_ledger_balances(vec![(
+                DEFAULT_CALLER_ACCOUNT,
+                Nat::from(10 * WITHDRAWAL_AMOUNT),
+            )])
+            .build()
+            .await;
+
+        setup
+            .ledger()
+            .approve(
+                None,
+                WITHDRAWAL_AMOUNT,
+                Account {
+                    owner: setup.minter_canister_id(),
+                    subaccount: None,
+                },
+            )
+            .await;
+
+        let WithdrawSolOk { block_index } = setup
+            .minter()
+            .withdraw_sol(WithdrawSolArgs {
+                from_subaccount: None,
+                amount: WITHDRAWAL_AMOUNT,
+                address: WITHDRAWAL_ADDRESS.to_string(),
+            })
+            .await
+            .expect("withdraw_sol should succeed");
+
+        setup.advance_time(WITHDRAWAL_PROCESSING_DELAY).await;
+        setup
+            .execute_http_mocks(estimate_blockhash_http_mocks())
+            .await;
+
+        setup.minter().assert_that_events().await.satisfy(|events| {
+            check!(events.iter().any(|e| matches!(
+                e,
+                EventType::SentWithdrawalTransaction {
+                    transactions,
+                    ..
+                } if transactions.iter().any(|(idx, _)| *idx == block_index)
+            )));
+        });
+
+        setup.drop().await;
+    }
+
+    fn estimate_blockhash_http_mocks() -> MockHttpOutcalls {
+        let mut builder = MockHttpOutcallsBuilder::new();
+        for id in 0..4u64 {
+            builder = builder
+                .given(JsonRpcRequestMatcher::with_method("getSlot").with_id(id))
+                .respond_with(get_slot_response(1).with_id(id))
+        }
+        for id in 4..8u64 {
+            builder = builder
+                .given(JsonRpcRequestMatcher::with_method("getBlock").with_id(id))
+                .respond_with(
+                    get_block_response("4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZAMdL4VZHirAn").with_id(id),
+                )
+        }
+        builder.build()
+    }
 }
 
 mod update_balance_tests {

libs/types-internal/src/event.rs

@@ -91,6 +91,11 @@ pub enum EventType {
         /// and the amount consolidated from each account.
         deposits: Vec<(Account, Lamport)>,
     },
+    /// A withdrawal transaction was signed and is ready to be sent to the network.
+    SentWithdrawalTransaction {
+        /// The burn block indices and corresponding transaction signatures.
+        transactions: Vec<(u64, Signature)>,
+    },
     /// A previously submitted transaction was resubmitted with a new signature.
     ResubmittedTransaction {
         /// The signature of the old transaction being replaced.

libs/types-internal/src/log.rs

@@ -7,6 +7,9 @@ use std::{fmt, fmt::Formatter, str::FromStr};
 /// The priority level of a log entry.
 #[derive(LogPriorityLevels, Serialize, Deserialize, PartialEq, Debug, Copy, Clone)]
 pub enum Priority {
+    /// Error log entries.
+    #[log_level(capacity = 1000, name = "ERROR")]
+    Error,
     /// Informational log entries.
     #[log_level(capacity = 1000, name = "INFO")]
     Info,
@@ -26,6 +29,7 @@ impl FromStr for Priority {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_lowercase().as_str() {
+            "error" => Ok(Priority::Error),
             "info" => Ok(Priority::Info),
             "debug" => Ok(Priority::Debug),
             _ => Err("could not recognize priority".to_string()),
@@ -36,6 +40,7 @@ impl FromStr for Priority {
 impl fmt::Display for Priority {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
+            Priority::Error => write!(f, "ERROR"),
             Priority::Info => write!(f, "INFO"),
             Priority::Debug => write!(f, "DEBUG"),
         }

libs/types/src/lib.rs

@@ -207,10 +207,6 @@ pub enum WithdrawSolStatus {
     /// Withdrawal request is waiting to be processed.
     Pending,
 
-    /// Transaction fees were estimated and a Solana transaction was created.
-    /// Transaction is not signed yet.
-    TxCreated,
-
     /// Solana transaction was signed and is sent to the network.
     TxSent(SolTransaction),
 

minter/cksol-minter.did

@@ -208,10 +208,6 @@ type WithdrawSolStatus = variant {
     // Withdrawal request is waiting to be processed.
     Pending;
 
-    // Transaction fees were estimated and a Solana transaction was created.
-    // Transaction is not signed yet.
-    TxCreated;
-
     // Solana transaction was signed and is sent to the network.
     TxSent : SolTransaction;
 
@@ -299,6 +295,11 @@ type EventType = variant {
         // and the amount consolidated from each account.
         deposits: vec record { Account; Lamport };
     };
+    // A withdrawal transaction was signed and is ready to be sent to the network.
+    SentWithdrawalTransaction : record {
+        // The burn block indices and corresponding transaction signatures.
+        transactions: vec record { nat64; Signature };
+    };
     // A previously submitted transaction was resubmitted with a new signature.
     ResubmittedTransaction : record {
         // The signature of the old transaction being replaced.

minter/src/consolidate/mod.rs

@@ -1,4 +1,5 @@
 use crate::{
+    address::{derivation_path, derive_public_key, lazy_get_schnorr_master_key},
     guard::TimerGuard,
     runtime::CanisterRuntime,
     sol_transfer::{CreateTransferError, MAX_SIGNATURES, create_signed_transfer_transaction},
@@ -9,6 +10,7 @@ use canlog::log;
 use cksol_types_internal::log::Priority;
 use icrc_ledger_types::icrc1::account::Account;
 use sol_rpc_types::{Lamport, Slot};
+use solana_address::Address;
 use solana_hash::Hash;
 use solana_signature::Signature;
 use std::time::Duration;
@@ -101,10 +103,15 @@ async fn submit_consolidation_transaction<R: CanisterRuntime>(
         owner: runtime.canister_self(),
         subaccount: None,
     };
+    let master_key = lazy_get_schnorr_master_key().await;
+    let minter_address = Address::from(
+        derive_public_key(&master_key, derivation_path(&minter_account)).serialize_raw(),
+    );
+
     let (transaction, signers) = create_signed_transfer_transaction(
         minter_account,
         &funds_to_consolidate,
-        minter_account,
+        minter_address,
         recent_blockhash,
         &runtime.signer(),
     )

minter/src/main.rs

@@ -2,6 +2,7 @@ use candid::Principal;
 use canlog::{Log, Sort};
 use cksol_minter::consolidate::{DEPOSIT_CONSOLIDATION_DELAY, consolidate_deposits};
 use cksol_minter::monitor::{MONITOR_SUBMITTED_TRANSACTIONS_DELAY, monitor_submitted_transactions};
+use cksol_minter::withdraw_sol::{WITHDRAWAL_PROCESSING_DELAY, process_pending_withdrawals};
 use cksol_minter::{
     address::lazy_get_schnorr_master_key, runtime::IcCanisterRuntime, state::read_state,
 };
@@ -72,7 +73,7 @@ async fn withdraw_sol(args: WithdrawSolArgs) -> Result<WithdrawSolOk, WithdrawSo
     let minter_account: Account = ic_cdk::api::canister_self().into();
 
     cksol_minter::withdraw_sol::withdraw_sol(
-        IcCanisterRuntime::new(),
+        &IcCanisterRuntime::new(),
         minter_account,
         ic_cdk::api::msg_caller(),
         args.from_subaccount,
@@ -83,8 +84,8 @@ async fn withdraw_sol(args: WithdrawSolArgs) -> Result<WithdrawSolOk, WithdrawSo
 }
 
 #[ic_cdk::update]
-async fn withdraw_sol_status(block_index: u64) -> WithdrawSolStatus {
-    read_state(|s| s.withdrawal_status(block_index))
+fn withdraw_sol_status(block_index: u64) -> WithdrawSolStatus {
+    cksol_minter::withdraw_sol::withdraw_sol_status(block_index)
 }
 
 #[ic_cdk::query]
@@ -153,6 +154,14 @@ fn get_events(
             EventType::ConsolidatedDeposits { deposits } => {
                 event::EventType::ConsolidatedDeposits { deposits }
             }
+            EventType::SentWithdrawalTransaction { transactions } => {
+                event::EventType::SentWithdrawalTransaction {
+                    transactions: transactions
+                        .iter()
+                        .map(|(idx, sig)| (*idx.get(), sig.into()))
+                        .collect(),
+                }
+            }
             EventType::ResubmittedTransaction {
                 old_signature,
                 new_signature,
@@ -216,10 +225,12 @@ fn http_request(request: HttpRequest) -> HttpResponse {
 
             match request.raw_query_param("priority").map(Priority::from_str) {
                 Some(Ok(priority)) => match priority {
+                    Priority::Error => log.push_logs(Priority::Error),
                     Priority::Info => log.push_logs(Priority::Info),
                     Priority::Debug => log.push_logs(Priority::Debug),
                 },
                 Some(Err(_)) | None => {
+                    log.push_logs(Priority::Error);
                     log.push_logs(Priority::Info);
                     log.push_logs(Priority::Debug);
                 }
@@ -277,6 +288,9 @@ fn setup_timers() {
     ic_cdk_timers::set_timer_interval(DEPOSIT_CONSOLIDATION_DELAY, async || {
         consolidate_deposits(IcCanisterRuntime::new()).await;
     });
+    ic_cdk_timers::set_timer_interval(WITHDRAWAL_PROCESSING_DELAY, async || {
+        process_pending_withdrawals(&IcCanisterRuntime::new()).await;
+    });
     ic_cdk_timers::set_timer_interval(MONITOR_SUBMITTED_TRANSACTIONS_DELAY, async || {
         monitor_submitted_transactions(IcCanisterRuntime::new()).await;
     });

minter/src/sol_transfer/mod.rs

@@ -29,8 +29,8 @@ pub enum CreateTransferError {
 }
 
 /// Creates a signed Solana transaction that transfers lamports from
-/// each minter-controlled address (identified by its account) to the
-/// destination account's derived address.
+/// each minter-controlled address (identified by its account)
+/// to `target_address` Solana address.
 ///
 /// Returns the signed transaction and the list of signer accounts
 /// (in signature order: fee payer first, then sources).
@@ -41,7 +41,7 @@ pub enum CreateTransferError {
 pub async fn create_signed_transfer_transaction(
     fee_payer_account: Account,
     sources: &[(Account, Lamport)],
-    destination_account: Account,
+    target_address: Address,
     recent_blockhash: Hash,
     signer: &impl SchnorrSigner,
 ) -> Result<(Transaction, Vec<Account>), CreateTransferError> {
@@ -52,7 +52,6 @@ pub async fn create_signed_transfer_transaction(
         (derivation_path, public_key.serialize_raw().into())
     };
 
-    let (_, target_address) = derive_address(&destination_account);
     let (fee_payer_derivation_path, fee_payer_address) = derive_address(&fee_payer_account);
 
     let (source_derivation_paths, source_addresses): (Vec<_>, Vec<_>) = sources

minter/src/sol_transfer/tests.rs

@@ -41,7 +41,7 @@ async fn should_create_signed_transaction_with_single_source() {
     let (tx, signers) = create_signed_transfer_transaction(
         source_account,
         &[(source_account, amount)],
-        target_account,
+        target_address,
         blockhash,
         &signer,
     )
@@ -100,7 +100,7 @@ async fn should_create_signed_transaction_with_multiple_sources() {
     let (tx, signers) = create_signed_transfer_transaction(
         account_1,
         &[(account_1, amount), (account_2, amount)],
-        target_account,
+        derive_address(&target_account),
         blockhash,
         &signer,
     )
@@ -155,7 +155,7 @@ async fn should_fail_when_signing_is_rejected() {
     let result = create_signed_transfer_transaction(
         source_account,
         &[(source_account, 500_000_000)],
-        target_account,
+        derive_address(&target_account),
         blockhash,
         &signer,
     )
@@ -191,7 +191,7 @@ async fn should_fail_when_second_signing_fails() {
     let result = create_signed_transfer_transaction(
         account_1,
         &[(account_1, 100_000_000), (account_2, 100_000_000)],
-        target_account,
+        derive_address(&target_account),
         blockhash,
         &signer,
     )
@@ -230,9 +230,14 @@ async fn should_fail_when_too_many_signatures() {
         subaccount: None,
     };
 
-    let result =
-        create_signed_transfer_transaction(fee_payer, &sources, target_account, blockhash, &signer)
-            .await;
+    let result = create_signed_transfer_transaction(
+        fee_payer,
+        &sources,
+        derive_address(&target_account),
+        blockhash,
+        &signer,
+    )
+    .await;
 
     assert!(
         matches!(result, Err(CreateTransferError::TooManySignatures { max: MAX_SIGNATURES, got }) if got == MAX_SIGNATURES + 1)
@@ -270,9 +275,14 @@ async fn should_not_fail_for_max_signatures() {
 
     let signer = MockSchnorrSigner::with_signatures(vec![[0x11u8; 64]; MAX_SIGNATURES as usize]);
 
-    let result =
-        create_signed_transfer_transaction(fee_payer, &sources, target_account, blockhash, &signer)
-            .await;
+    let result = create_signed_transfer_transaction(
+        fee_payer,
+        &sources,
+        derive_address(&target_account),
+        blockhash,
+        &signer,
+    )
+    .await;
 
     assert!(result.is_ok());
 }
@@ -309,7 +319,7 @@ async fn should_create_signed_transaction_with_fee_payer() {
         let (tx, signers) = create_signed_transfer_transaction(
             fee_payer_account,
             &sources,
-            target_account,
+            derive_address(&target_account),
             blockhash,
             &signer,
         )

minter/src/state/audit.rs

@@ -52,6 +52,11 @@ fn apply_state_transition(state: &mut State, payload: &EventType) {
         EventType::ConsolidatedDeposits { deposits } => {
             state.process_consolidated_deposits(deposits);
         }
+        EventType::SentWithdrawalTransaction { transactions } => {
+            for (burn_block_index, signature) in transactions {
+                state.process_sent_withdrawal_transaction(burn_block_index, signature);
+            }
+        }
         EventType::ResubmittedTransaction {
             old_signature,
             new_signature,