feat(key-wallet): add platform accounts and core tx split

Author: PastaPastaPasta

key-wallet-manager/src/wallet_manager/mod.rs

@@ -22,7 +22,7 @@ use key_wallet::wallet::managed_wallet_info::{ManagedWalletInfo, TransactionReco
 use key_wallet::wallet::WalletType;
 use key_wallet::Utxo;
 use key_wallet::{Account, AccountType, Address, ExtendedPrivKey, Mnemonic, Network, Wallet};
-use key_wallet::{ExtendedPubKey, WalletBalance};
+use key_wallet::{ExtendedPubKey, WalletCoreBalance};
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use zeroize::Zeroize;
@@ -483,8 +483,9 @@ impl<T: WalletInfoInterface> WalletManager<T> {
             let wallet_info_opt = self.wallet_infos.get_mut(&wallet_id);
 
             if let (Some(wallet), Some(wallet_info)) = (wallet_opt, wallet_info_opt) {
-                let check_result =
-                    wallet_info.check_transaction(tx, context, wallet, update_state_if_found).await;
+                let check_result = wallet_info
+                    .check_core_transaction(tx, context, wallet, update_state_if_found)
+                    .await;
 
                 // If the transaction is relevant
                 if check_result.is_relevant {
@@ -904,7 +905,10 @@ impl<T: WalletInfoInterface> WalletManager<T> {
     }
 
     /// Get balance for a specific wallet
-    pub fn get_wallet_balance(&self, wallet_id: &WalletId) -> Result<WalletBalance, WalletError> {
+    pub fn get_wallet_balance(
+        &self,
+        wallet_id: &WalletId,
+    ) -> Result<WalletCoreBalance, WalletError> {
         // Get the wallet info
         let wallet_info =
             self.wallet_infos.get(wallet_id).ok_or(WalletError::WalletNotFound(*wallet_id))?;

key-wallet/src/account/account_type.rs

@@ -4,7 +4,9 @@
 
 use crate::bip32::{ChildNumber, DerivationPath};
 use crate::dip9::DerivationPathReference;
-use crate::transaction_checking::transaction_router::AccountTypeToCheck;
+use crate::transaction_checking::transaction_router::{
+    AccountTypeToCheck, PlatformAccountConversionError,
+};
 use crate::Network;
 #[cfg(feature = "bincode")]
 use bincode_derive::{Decode, Encode};
@@ -94,40 +96,45 @@ pub enum AccountType {
     },
 }
 
-impl From<AccountType> for AccountTypeToCheck {
-    fn from(value: AccountType) -> Self {
+impl TryFrom<AccountType> for AccountTypeToCheck {
+    type Error = PlatformAccountConversionError;
+
+    fn try_from(value: AccountType) -> Result<Self, Self::Error> {
         match value {
             AccountType::Standard {
                 standard_account_type,
                 ..
             } => match standard_account_type {
-                StandardAccountType::BIP44Account => AccountTypeToCheck::StandardBIP44,
-                StandardAccountType::BIP32Account => AccountTypeToCheck::StandardBIP32,
+                StandardAccountType::BIP44Account => Ok(AccountTypeToCheck::StandardBIP44),
+                StandardAccountType::BIP32Account => Ok(AccountTypeToCheck::StandardBIP32),
             },
             AccountType::CoinJoin {
                 ..
-            } => AccountTypeToCheck::CoinJoin,
-            AccountType::IdentityRegistration => AccountTypeToCheck::IdentityRegistration,
+            } => Ok(AccountTypeToCheck::CoinJoin),
+            AccountType::IdentityRegistration => Ok(AccountTypeToCheck::IdentityRegistration),
             AccountType::IdentityTopUp {
                 ..
-            } => AccountTypeToCheck::IdentityTopUp,
+            } => Ok(AccountTypeToCheck::IdentityTopUp),
             AccountType::IdentityTopUpNotBoundToIdentity => {
-                AccountTypeToCheck::IdentityTopUpNotBound
+                Ok(AccountTypeToCheck::IdentityTopUpNotBound)
             }
-            AccountType::IdentityInvitation => AccountTypeToCheck::IdentityInvitation,
-            AccountType::ProviderVotingKeys => AccountTypeToCheck::ProviderVotingKeys,
-            AccountType::ProviderOwnerKeys => AccountTypeToCheck::ProviderOwnerKeys,
-            AccountType::ProviderOperatorKeys => AccountTypeToCheck::ProviderOperatorKeys,
-            AccountType::ProviderPlatformKeys => AccountTypeToCheck::ProviderPlatformKeys,
+            AccountType::IdentityInvitation => Ok(AccountTypeToCheck::IdentityInvitation),
+            AccountType::ProviderVotingKeys => Ok(AccountTypeToCheck::ProviderVotingKeys),
+            AccountType::ProviderOwnerKeys => Ok(AccountTypeToCheck::ProviderOwnerKeys),
+            AccountType::ProviderOperatorKeys => Ok(AccountTypeToCheck::ProviderOperatorKeys),
+            AccountType::ProviderPlatformKeys => Ok(AccountTypeToCheck::ProviderPlatformKeys),
             AccountType::DashpayReceivingFunds {
                 ..
-            } => AccountTypeToCheck::DashpayReceivingFunds,
+            } => Ok(AccountTypeToCheck::DashpayReceivingFunds),
             AccountType::DashpayExternalAccount {
                 ..
-            } => AccountTypeToCheck::DashpayExternalAccount,
+            } => Ok(AccountTypeToCheck::DashpayExternalAccount),
             AccountType::PlatformPayment {
                 ..
-            } => AccountTypeToCheck::PlatformPayment,
+            } => {
+                // Platform Payment accounts (DIP-17) operate on Dash Platform, not Core chain.
+                Err(PlatformAccountConversionError)
+            }
         }
     }
 }

key-wallet/src/lib.rs

@@ -65,10 +65,12 @@ pub use error::{Error, Result};
 pub use gap_limit::{GapLimit, GapLimitManager, GapLimitStage};
 pub use managed_account::address_pool::{AddressInfo, AddressPool, KeySource, PoolStats};
 pub use managed_account::managed_account_type::ManagedAccountType;
+pub use managed_account::managed_platform_account::ManagedPlatformAccount;
+pub use managed_account::platform_address::PlatformP2PKHAddress;
 pub use mnemonic::Mnemonic;
 pub use seed::Seed;
 pub use utxo::{Utxo, UtxoSet};
-pub use wallet::{balance::WalletBalance, Wallet};
+pub use wallet::{balance::WalletCoreBalance, Wallet};
 
 /// Re-export commonly used types
 pub mod prelude {