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/identity_registration_funded_with_signer.rs

@@ -17,6 +17,7 @@
 
 use dashcore::hashes::Hash;
 use dpp::identity::accessors::IdentityGettersV0;
+use dpp::prelude::Identifier;
 use platform_wallet::AssetLockFunding;
 use rs_sdk_ffi::{SignerHandle, VTableSigner};
 
@@ -241,3 +242,80 @@ pub unsafe extern "C" fn platform_wallet_resume_identity_with_existing_asset_loc
     *out_identity_handle = handle;
     PlatformWalletFFIResult::ok()
 }
+
+/// Top up an EXISTING identity from an already-tracked asset lock — the
+/// inviter's "reclaim into an existing identity" path.
+///
+/// Sister to [`platform_wallet_resume_identity_with_existing_asset_lock_signer`]
+/// (which registers a NEW identity from the lock): this consumes the lock as an
+/// IdentityTopUp against `identity_id` instead. Used to reclaim an unclaimed
+/// DashPay invitation voucher — the value comes back as Platform **credits** on
+/// the inviter's own identity (the on-chain DASH is an OP_RETURN burn, so there
+/// is nothing to spend back on L1). No per-identity-key signer is needed (a
+/// top-up creates no keys); only the Core-side asset-lock signature, produced by
+/// the inviter's own resolver, which re-derives the voucher key at the invitation
+/// funding path. The `FromExistingAssetLock` resume + IS→CL fallback logic lives
+/// in `top_up_identity_with_funding`; this FFI is a thin marshaler.
+///
+/// # Safety
+/// - `out_point` must be a valid, non-null `*const OutPointFFI`; the caller
+///   retains ownership.
+/// - `identity_id` must point to 32 readable bytes.
+/// - `core_signer_handle` must be a valid, non-destroyed
+///   `*mut MnemonicResolverHandle`; the caller retains ownership.
+/// - `out_new_balance` must be a valid `*mut u64`.
+#[no_mangle]
+pub unsafe extern "C" fn platform_wallet_topup_identity_with_existing_asset_lock_signer(
+    wallet_handle: Handle,
+    out_point: *const OutPointFFI,
+    identity_id: *const [u8; 32],
+    core_signer_handle: *mut MnemonicResolverHandle,
+    out_new_balance: *mut u64,
+) -> PlatformWalletFFIResult {
+    check_ptr!(out_point);
+    check_ptr!(identity_id);
+    check_ptr!(core_signer_handle);
+    check_ptr!(out_new_balance);
+    // FFI-safe sentinel before any fallible work.
+    *out_new_balance = 0;
+
+    let out_point_ffi = *out_point;
+    let reclaim_outpoint = dashcore::OutPoint {
+        txid: dashcore::Txid::from_byte_array(out_point_ffi.txid),
+        vout: out_point_ffi.vout,
+    };
+    let identity_id = Identifier::from(*identity_id);
+
+    let core_signer_addr = core_signer_handle as usize;
+
+    let option = PLATFORM_WALLET_STORAGE.with_item(wallet_handle, |wallet| {
+        let identity_wallet = wallet.identity().clone();
+        let wallet_id = wallet.wallet_id();
+        let network = wallet.sdk().network;
+        block_on_worker(async move {
+            // SAFETY: see the fn-level safety doc — the handle is pinned alive
+            // for the duration of this FFI call.
+            let asset_lock_signer = unsafe {
+                MnemonicResolverCoreSigner::new(
+                    core_signer_addr as *mut MnemonicResolverHandle,
+                    wallet_id,
+                    network,
+                )
+            };
+            identity_wallet
+                .top_up_identity_with_funding(
+                    &identity_id,
+                    AssetLockFunding::FromExistingAssetLock {
+                        out_point: reclaim_outpoint,
+                    },
+                    &asset_lock_signer,
+                    None,
+                )
+                .await
+        })
+    });
+    let result = unwrap_option_or_return!(option);
+    let new_balance = unwrap_result_or_return!(result);
+    *out_new_balance = new_balance;
+    PlatformWalletFFIResult::ok()
+}