feat(platform-wallet): dip-13 dashpay invitations

packages/rs-platform-wallet-ffi/src/dashpay.rs

@@ -664,6 +664,20 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider {
             .map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
     }
 
+    async fn export_invitation_private_key(
+        &self,
+        path: &key_wallet::bip32::DerivationPath,
+    ) -> Result<dashcore::secp256k1::SecretKey, platform_wallet::PlatformWalletError> {
+        let scalar = self
+            .signer
+            .export_invitation_private_key(path)
+            .map_err(|e| {
+                platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())
+            })?;
+        dashcore::secp256k1::SecretKey::from_slice(scalar.as_ref())
+            .map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
+    }
+
     async fn account_reference(
         &self,
         path: &key_wallet::bip32::DerivationPath,

packages/rs-platform-wallet-ffi/src/lib.rs

@@ -47,6 +47,7 @@ pub mod identity_top_up;
 pub mod identity_transfer;
 pub mod identity_update;
 pub mod identity_withdrawal;
+pub mod invitation;
 pub mod logging;
 pub mod managed_identity;
 pub mod manager;
@@ -115,6 +116,7 @@ pub use identity_top_up::*;
 pub use identity_transfer::*;
 pub use identity_update::*;
 pub use identity_withdrawal::*;
+pub use invitation::*;
 pub use logging::*;
 pub use managed_identity::*;
 pub use manager::*;

packages/rs-platform-wallet-ffi/src/persistence.rs

@@ -11,6 +11,7 @@ use key_wallet::account::{Account, AccountType, StandardAccountType};
 use key_wallet::bip32::DerivationPath;
 use key_wallet::bip32::ExtendedPubKey;
 use key_wallet::managed_account::address_pool::{AddressPool, AddressPoolType, PublicKeyType};
+use key_wallet::managed_account::managed_account_ref::ManagedAccountRefMut;
 use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
 use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
 use key_wallet::wallet::Wallet;
@@ -2967,7 +2968,6 @@ fn build_wallet_start_state(
     // restored wallet can hold a UTXO whose address the signer can't
     // map back to a derivation path, breaking core-to-core spends.
     {
-        use key_wallet::managed_account::managed_account_trait::ManagedAccountTrait;
         let pool_entries: &[AccountAddressPoolFFI] =
             if entry.core_address_pools.is_null() || entry.core_address_pools_count == 0 {
                 &[]
@@ -3004,48 +3004,109 @@ fn build_wallet_start_state(
                     continue;
                 }
             };
-            let funds = match account_type {
+            // Route the persisted pool back to its managed account. Wrapped in
+            // `ManagedAccountRefMut` because funds accounts and the asset-lock
+            // key-accounts are distinct types that share `ManagedAccountTrait`.
+            //
+            // The asset-lock funding accounts (registration / top-up /
+            // invitation / …) MUST be restored here: their credit outputs are
+            // OP_RETURN-payload outputs that never appear as on-chain UTXOs, so
+            // SPV can never rediscover their used indices — the persisted pool
+            // is the ONLY thing that carries the next-unused index across a
+            // restart. Dropping them (the old `_ => None`) reset the pool to
+            // index 0 every launch; for `IdentityInvitation` that reused the
+            // EXPORTED one-time voucher key across invitations (a bearer-key
+            // reuse: one leaked link could then claim every same-key invite).
+            let funds: Option<ManagedAccountRefMut> = match account_type {
                 AccountType::Standard {
                     index,
                     standard_account_type: StandardAccountType::BIP44Account,
-                } => wallet_info.accounts.standard_bip44_accounts.get_mut(&index),
+                } => wallet_info
+                    .accounts
+                    .standard_bip44_accounts
+                    .get_mut(&index)
+                    .map(ManagedAccountRefMut::Funds),
                 AccountType::Standard {
                     index,
                     standard_account_type: StandardAccountType::BIP32Account,
-                } => wallet_info.accounts.standard_bip32_accounts.get_mut(&index),
-                AccountType::CoinJoin { index } => {
-                    wallet_info.accounts.coinjoin_accounts.get_mut(&index)
-                }
+                } => wallet_info
+                    .accounts
+                    .standard_bip32_accounts
+                    .get_mut(&index)
+                    .map(ManagedAccountRefMut::Funds),
+                AccountType::CoinJoin { index } => wallet_info
+                    .accounts
+                    .coinjoin_accounts
+                    .get_mut(&index)
+                    .map(ManagedAccountRefMut::Funds),
                 AccountType::DashpayReceivingFunds {
                     index,
                     user_identity_id,
                     friend_identity_id,
-                } => wallet_info.accounts.dashpay_receival_accounts.get_mut(
-                    &key_wallet::account::account_collection::DashpayAccountKey {
-                        index,
-                        user_identity_id,
-                        friend_identity_id,
-                    },
-                ),
+                } => wallet_info
+                    .accounts
+                    .dashpay_receival_accounts
+                    .get_mut(
+                        &key_wallet::account::account_collection::DashpayAccountKey {
+                            index,
+                            user_identity_id,
+                            friend_identity_id,
+                        },
+                    )
+                    .map(ManagedAccountRefMut::Funds),
                 AccountType::DashpayExternalAccount {
                     index,
                     user_identity_id,
                     friend_identity_id,
-                } => wallet_info.accounts.dashpay_external_accounts.get_mut(
-                    &key_wallet::account::account_collection::DashpayAccountKey {
-                        index,
-                        user_identity_id,
-                        friend_identity_id,
-                    },
-                ),
+                } => wallet_info
+                    .accounts
+                    .dashpay_external_accounts
+                    .get_mut(
+                        &key_wallet::account::account_collection::DashpayAccountKey {
+                            index,
+                            user_identity_id,
+                            friend_identity_id,
+                        },
+                    )
+                    .map(ManagedAccountRefMut::Funds),
+                AccountType::IdentityRegistration => wallet_info
+                    .accounts
+                    .identity_registration
+                    .as_mut()
+                    .map(ManagedAccountRefMut::Keys),
+                AccountType::IdentityTopUp { registration_index } => wallet_info
+                    .accounts
+                    .identity_topup
+                    .get_mut(&registration_index)
+                    .map(ManagedAccountRefMut::Keys),
+                AccountType::IdentityTopUpNotBoundToIdentity => wallet_info
+                    .accounts
+                    .identity_topup_not_bound
+                    .as_mut()
+                    .map(ManagedAccountRefMut::Keys),
+                AccountType::IdentityInvitation => wallet_info
+                    .accounts
+                    .identity_invitation
+                    .as_mut()
+                    .map(ManagedAccountRefMut::Keys),
+                AccountType::AssetLockAddressTopUp => wallet_info
+                    .accounts
+                    .asset_lock_address_topup
+                    .as_mut()
+                    .map(ManagedAccountRefMut::Keys),
+                AccountType::AssetLockShieldedAddressTopUp => wallet_info
+                    .accounts
+                    .asset_lock_shielded_address_topup
+                    .as_mut()
+                    .map(ManagedAccountRefMut::Keys),
                 _ => None,
             };
-            let Some(funds_account) = funds else {
+            let Some(mut funds_account) = funds else {
                 pools_dropped += 1;
                 tracing::warn!(
                     wallet_id = %hex::encode(entry.wallet_id),
                     ?account_type,
-                    "load: skipping persisted address pool with no matching funds account"
+                    "load: skipping persisted address pool with no matching managed account"
                 );
                 continue;
             };

packages/rs-platform-wallet-storage/migrations/V003__invitations.rs

@@ -0,0 +1,25 @@
+//! Add the `invitations` table (DIP-13 DashPay invitations).
+//!
+//! Inviter-side records of created invitations, powering the "Sent invitations"
+//! status list and (future) reclaim of an unclaimed voucher. **No key material
+//! is stored** — the one-time voucher key is HD-derived and re-derivable from
+//! `funding_index` on demand.
+//!
+//! All fields map to explicit columns (the entry is all-primitive), so no
+//! opaque lifecycle blob is needed — the row reconstructs directly.
+
+pub fn migration() -> String {
+    "CREATE TABLE invitations (
+        wallet_id BLOB NOT NULL,
+        outpoint BLOB NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('created', 'claimed', 'reclaimed')),
+        funding_index INTEGER NOT NULL,
+        amount_duffs INTEGER NOT NULL,
+        expiry_unix INTEGER NOT NULL,
+        created_at_secs INTEGER NOT NULL,
+        has_inviter INTEGER NOT NULL,
+        PRIMARY KEY (wallet_id, outpoint),
+        FOREIGN KEY (wallet_id) REFERENCES wallet_metadata(wallet_id) ON DELETE CASCADE
+    );"
+    .to_string()
+}

packages/rs-platform-wallet-storage/src/sqlite/persister.rs

@@ -1087,6 +1087,9 @@ fn apply_changeset_to_tx(
     if let Some(locks) = cs.asset_locks.as_ref() {
         schema::asset_locks::apply(tx, wallet_id, locks)?;
     }
+    if let Some(invitations) = cs.invitations.as_ref() {
+        schema::invitations::apply(tx, wallet_id, invitations)?;
+    }
     if let Some(balances) = cs.token_balances.as_ref() {
         schema::token_balances::apply(tx, wallet_id, balances)?;
     }