fix(platform-wallet): support HASH160 DashPay contact signing keys

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/ffi/SignerNative.kt

@@ -49,6 +49,14 @@ internal object SignerNative {
      */
     external fun signWithPrivateKey(privateKey: ByteArray, network: Int, data: ByteArray): ByteArray?
 
+    /**
+     * Whether Rust signs an identity key of DPP `KeyType` discriminant
+     * [keyType] (`dash_sdk_resolver_supports_key_type`, the predicate
+     * `KeychainSigner.swift` asks). Pure; a value outside `0..=255` is
+     * `false`.
+     */
+    external fun resolverSupportsKeyType(keyType: Int): Boolean
+
     /**
      * One-shot derive-then-sign for platform-address keys (the
      * `keyType == 0xFF` branch). Derives an ECDSA secp256k1 key from

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/security/KeystoreSigner.kt

@@ -58,6 +58,12 @@ class KeystoreSigner(
      * Room rows and re-seed `pendingIdentityKeys`.
      */
     private val onSigningKeyInvalidated: (suspend (pubkeyHex: String) -> Unit)? = null,
+    /**
+     * Whether Rust signs an identity key of a DPP `KeyType` discriminant.
+     * Rust owns that set; the parameter exists so a JVM unit test can stub
+     * it without the native library.
+     */
+    private val supportsIdentityKeyType: (Int) -> Boolean = SignerNative::resolverSupportsKeyType,
 ) : NativeSignerBridge(), AutoCloseable {
 
     private val handleRef =
@@ -303,21 +309,23 @@ class KeystoreSigner(
     }
 
     override fun canSignWith(pubkeyBytes: ByteArray, keyType: Int): Boolean = try {
-        if (keyType == PLATFORM_ADDRESS_HASH_KEY_TYPE) {
-            // Prerequisites for the derive-and-sign path: a row with a
-            // non-empty derivation path plus a stored wallet mnemonic.
-            // Existence-only — hasMnemonic never decrypts, so no plaintext
-            // is materialized for a mere capability check.
-            runBlocking {
-                platformAddressDao.getAllByAddressHash(pubkeyBytes).any { row ->
-                    row.derivationPath.isNotEmpty() && storage.hasMnemonic(row.walletId)
+        when {
+            keyType == PLATFORM_ADDRESS_HASH_KEY_TYPE ->
+                // Prerequisites for the derive-and-sign path: a row with a
+                // non-empty derivation path plus a stored wallet mnemonic.
+                // Existence-only — hasMnemonic never decrypts, so no plaintext
+                // is materialized for a mere capability check.
+                runBlocking {
+                    platformAddressDao.getAllByAddressHash(pubkeyBytes).any { row ->
+                        row.derivationPath.isNotEmpty() && storage.hasMnemonic(row.walletId)
+                    }
                 }
+            else -> identityKeySignable(keyType, supportsIdentityKeyType) {
+                // Ciphertext presence is not signing capability after Android
+                // replaces KEYS_ALIAS: the stale blob remains in DataStore but
+                // can never be decrypted by the replacement private key.
+                runBlocking { storage.isPrivateKeyDecryptable(storageKeyFor(pubkeyBytes)) }
             }
-        } else {
-            // Ciphertext presence is not signing capability after Android
-            // replaces KEYS_ALIAS: the stale blob remains in DataStore but
-            // can never be decrypted by the replacement private key.
-            runBlocking { storage.isPrivateKeyDecryptable(storageKeyFor(pubkeyBytes)) }
         }
     } catch (_: Exception) {
         false
@@ -372,6 +380,21 @@ class KeystoreSigner(
          */
         private const val PLATFORM_ADDRESS_HASH_KEY_TYPE: Int = 0xFF
 
+        /**
+         * Whether [canSignWith] reports an identity key of DPP `KeyType`
+         * discriminant [keyType] signable. Rust picks signing keys by this
+         * answer: claiming a key the secp256k1 sign path cannot sign (BLS,
+         * EdDSA) would get it chosen and then signed with the wrong
+         * algorithm, so [supportsKeyType] (Rust's predicate) is asked first
+         * and [privateKeyDecryptable] only for a type it accepts. Factored
+         * pure so it is unit-testable without the native signer handle.
+         */
+        internal fun identityKeySignable(
+            keyType: Int,
+            supportsKeyType: (Int) -> Boolean,
+            privateKeyDecryptable: () -> Boolean,
+        ): Boolean = supportsKeyType(keyType) && privateKeyDecryptable()
+
         /**
          * Structured completion code for a sign-path failure [t]:
          * [KeyPermanentlyInvalidatedException] is a "key unavailable until

packages/kotlin-sdk/sdk/src/test/kotlin/org/dashfoundation/dashsdk/security/KeystoreSignerKeyTypeTest.kt

@@ -0,0 +1,50 @@
+package org.dashfoundation.dashsdk.security
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Pins how [KeystoreSigner.canSignWith] answers for an identity key. Rust
+ * chooses the signing key by that answer, so a key type Rust's predicate
+ * refuses (BLS, EdDSA) must not be reported signable even with a stored
+ * private key. Which types Rust signs is pinned by the Rust tests of
+ * `dash_sdk_resolver_supports_key_type`; this JVM test cannot load the
+ * native library, so it stubs the predicate.
+ */
+class KeystoreSignerKeyTypeTest {
+
+    @Test
+    fun refusesAKeyTypeRustDoesNotSignWithoutConsultingStorage() {
+        var storageConsulted = false
+        val signable = KeystoreSigner.identityKeySignable(
+            keyType = 1,
+            supportsKeyType = { false },
+        ) {
+            storageConsulted = true
+            true
+        }
+        assertFalse(signable)
+        assertFalse(storageConsulted)
+    }
+
+    @Test
+    fun asksRustAboutTheKeyTypeItWasGiven() {
+        var askedFor: Int? = null
+        KeystoreSigner.identityKeySignable(
+            keyType = 2,
+            supportsKeyType = {
+                askedFor = it
+                true
+            },
+        ) { true }
+        assertEquals(2, askedFor)
+    }
+
+    @Test
+    fun reportsAKeyTypeRustSignsSignableOnlyWhenItsKeyDecrypts() {
+        assertTrue(KeystoreSigner.identityKeySignable(0, { true }) { true })
+        assertFalse(KeystoreSigner.identityKeySignable(0, { true }) { false })
+    }
+}

packages/rs-dpp/src/identity/identity_public_key/key_type.rs

@@ -110,6 +110,22 @@ impl KeyType {
         }
     }
 
+    /// Can a key of this type sign an identity-signed state transition?
+    ///
+    /// This is the set Drive's identity-signed validation verifies a signature by; a key of
+    /// any other type is refused there with `InvalidIdentityPublicKeyTypeError`. Clients use
+    /// it to choose or check a signing key before building a transition. A Drive test pins the
+    /// two to agree for every key type.
+    pub fn can_sign_identity_signed_transition(&self) -> bool {
+        match self {
+            KeyType::ECDSA_SECP256K1 => true,
+            KeyType::BLS12_381 => true,
+            KeyType::ECDSA_HASH160 => true,
+            KeyType::BIP13_SCRIPT_HASH => false,
+            KeyType::EDDSA_25519_HASH160 => false,
+        }
+    }
+
     pub fn signature_verify_cost(
         &self,
         platform_version: &PlatformVersion,
@@ -413,6 +429,24 @@ mod tests {
         );
     }
 
+    // -- can_sign_identity_signed_transition() --
+
+    #[test]
+    fn should_sign_identity_signed_transitions_only_with_ecdsa_bls_and_hash160_keys() {
+        let signing: Vec<KeyType> = KeyType::all_key_types()
+            .into_iter()
+            .filter(KeyType::can_sign_identity_signed_transition)
+            .collect();
+        assert_eq!(
+            signing,
+            [
+                KeyType::ECDSA_SECP256K1,
+                KeyType::BLS12_381,
+                KeyType::ECDSA_HASH160
+            ]
+        );
+    }
+
     // -- is_unique_key_type() --
 
     #[test]

packages/rs-drive-abci/src/execution/validation/state_transition/common/validate_state_transition_identity_signed/v0/mod.rs

@@ -269,6 +269,19 @@ mod tests {
     use dpp::state_transition::errors::PublicKeySecurityLevelNotMetError;
     use dpp::state_transition::errors::WrongPublicKeyPurposeError;
 
+    /// Clients choose and check signing keys by the dpp predicate; it must name exactly the key
+    /// types this validation verifies a signature by.
+    #[test]
+    fn should_agree_with_the_dpp_identity_signing_key_type_predicate_for_every_key_type() {
+        for key_type in KeyType::all_key_types() {
+            assert_eq!(
+                key_type.can_sign_identity_signed_transition(),
+                SUPPORTED_KEY_TYPES.contains(&key_type),
+                "{key_type:?}"
+            );
+        }
+    }
+
     mod convert_to_consensus_signature_error_tests {
         use super::*;
 

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

@@ -1380,7 +1380,6 @@ mod tests {
             identity_id,
             purpose: dpp::identity::Purpose::AUTHENTICATION,
             security_levels: vec![dpp::identity::SecurityLevel::CRITICAL],
-            key_types: vec![dpp::identity::KeyType::ECDSA_SECP256K1],
             transition: "an identity update".to_string(),
         });
         assert_eq!(result.code, PlatformWalletFFIResultCode::ErrorUnknown);
@@ -1393,7 +1392,6 @@ mod tests {
             identity.as_str(),
             "AUTHENTICATION",
             "CRITICAL",
-            "ECDSA_SECP256K1",
             "an identity update",
         ] {
             assert!(message.contains(part), "{message}");

packages/rs-platform-wallet/src/error.rs

@@ -6,7 +6,7 @@ use dpp::consensus::state::address_funds::AddressInvalidNonceError;
 use dpp::consensus::ConsensusError;
 use dpp::fee::Credits;
 use dpp::identifier::Identifier;
-use dpp::identity::{KeyType, Purpose, SecurityLevel};
+use dpp::identity::{Purpose, SecurityLevel};
 use dpp::prelude::{AddressNonce, CoreBlockHeight};
 use key_wallet::account::StandardAccountType;
 use key_wallet::wallet::managed_wallet_info::asset_lock_builder::AssetLockFundingType;
@@ -87,19 +87,18 @@ pub enum PlatformWalletError {
     InvalidIdentityData(String),
 
     /// No key of the identity can sign `transition`: none has `purpose`, one of
-    /// `security_levels` and one of `key_types` while also being enabled, unexpired and inside
-    /// its contract bounds.
+    /// `security_levels` and a type Platform verifies an identity signature by while also being
+    /// enabled, unexpired and inside its contract bounds.
     /// It stays so until an identity update adds such a key. A key that qualifies but that the
     /// signer cannot use is the signer-unavailable error instead.
     #[error(
-        "identity {identity_id} has no usable {purpose} key of type {key_types:?} at security \
-         level {security_levels:?} to sign {transition}"
+        "identity {identity_id} has no usable {purpose} key at security level \
+         {security_levels:?} to sign {transition}"
     )]
     NoUsableSigningKey {
         identity_id: Identifier,
         purpose: Purpose,
         security_levels: Vec<SecurityLevel>,
-        key_types: Vec<KeyType>,
         transition: String,
     },
 

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

@@ -77,7 +77,6 @@ pub use wallet::identity::network::{
     check_signing_key, derive_identity_auth_keypair, usable_signing_key, AutoAcceptProofSource,
     ContactCryptoProvider, ContactInfoOpened, ContactInfoPublishOutcome, ContactInfoSealed,
     SeedBindingVerification, SigningScope, IDENTITY_GAP_LIMIT, MASTER_KEY_INDEX,
-    PLATFORM_SIGNING_KEY_TYPES, WALLET_SIGNING_KEY_TYPES,
 };
 pub use wallet::identity::{
     calculate_account_reference, derive_auto_accept_private_key, derive_contact_payment_address,