From 3d0a7c378a9fa1c3dbad9a346119c4bb1cc28372 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:14:06 +0000
Subject: [PATCH 01/21] chore: pin rust-dashcore for crypto API migration
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Prepare the dependency graph; consumer adaptations and validation follow before publication.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
Cargo.lock | 125 +++++++++++++++++++++++--------------
Cargo.toml | 17 ++---
packages/rs-dpp/Cargo.toml | 2 +-
packages/rs-dpp/src/lib.rs | 2 +
4 files changed, 91 insertions(+), 55 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 1a5f036177b..00ebaadcf9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1367,7 +1367,7 @@ version = "3.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -1825,7 +1825,7 @@ dependencies = [
[[package]]
name = "dash-network"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"cbindgen 0.29.4",
"grovedb-bincode",
@@ -1836,7 +1836,7 @@ dependencies = [
[[package]]
name = "dash-network-seeds"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"dash-network",
]
@@ -1847,9 +1847,20 @@ version = "0.1.0-beta"
source = "git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7#33fcc59e1868c803f9608e0e78ee8bddf3abcee7"
dependencies = [
"ambassador",
- "bitcoin-consensus-encoding 1.3.0",
"bitcoin-internals 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "dash-types",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7)",
+ "delegate",
+ "hex-conservative 1.3.0",
+]
+
+[[package]]
+name = "dash-num"
+version = "0.1.0-beta"
+source = "git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5#d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5"
+dependencies = [
+ "ambassador",
+ "bitcoin-internals 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
"delegate",
"hex-conservative 1.3.0",
"serde",
@@ -1859,22 +1870,44 @@ dependencies = [
name = "dash-pkc"
version = "0.1.0-beta"
source = "git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7#33fcc59e1868c803f9608e0e78ee8bddf3abcee7"
+dependencies = [
+ "aes 0.9.3",
+ "bitcoin_hashes 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "blst",
+ "cfg-if",
+ "dash-num 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7)",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7)",
+ "ff 0.14.0",
+ "group 0.14.0",
+ "hex-conservative 1.3.0",
+ "rand_core 0.10.1",
+ "sha2 0.11.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "dash-pkc"
+version = "0.1.0-beta"
+source = "git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5#d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5"
dependencies = [
"aes 0.9.3",
"base58ck 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bitcoin_hashes 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"blst",
"cfg-if",
- "dash-num",
- "dash-types",
+ "dash-num 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
"ed25519-dalek 3.0.0",
"ff 0.14.0",
"group 0.14.0",
"hex-conservative 1.3.0",
"rand_core 0.10.1",
+ "secp256k1",
"serde",
"sha2 0.11.0",
"subtle",
+ "thiserror 2.0.18",
"zeroize",
]
@@ -1970,7 +2003,7 @@ dependencies = [
[[package]]
name = "dash-spv"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"async-trait",
"chrono",
@@ -2003,30 +2036,31 @@ name = "dash-types"
version = "0.1.0-beta"
source = "git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7#33fcc59e1868c803f9608e0e78ee8bddf3abcee7"
dependencies = [
- "bitcoin-consensus-encoding 1.3.0",
- "bitcoin-primitives 0.103.0",
"cfg-if",
- "dash-types-marker",
"hex-conservative 1.3.0",
- "serde",
"subtle",
"zeroize",
]
[[package]]
-name = "dash-types-marker"
+name = "dash-types"
version = "0.1.0-beta"
-source = "git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7#33fcc59e1868c803f9608e0e78ee8bddf3abcee7"
+source = "git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5#d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5"
dependencies = [
- "quote",
- "syn 2.0.117",
- "xxhash-rust",
+ "bitcoin-consensus-encoding 1.3.0",
+ "bitcoin-primitives 0.103.0",
+ "cfg-if",
+ "hex-conservative 1.3.0",
+ "serde",
+ "subtle",
+ "thiserror 2.0.18",
+ "zeroize",
]
[[package]]
name = "dashcore"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"anyhow",
"base64 0.22.1",
@@ -2034,15 +2068,14 @@ dependencies = [
"bitvec",
"blake3",
"dash-network",
- "dash-num",
- "dash-types",
+ "dash-num 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
"dashcore-crypto",
"dashcore-private",
"dashcore_hashes",
"grovedb-bincode",
"grovedb-bincode-derive",
"hex-conservative 1.3.0",
- "secp256k1",
"serde",
"thiserror 2.0.18",
"tracing",
@@ -2051,33 +2084,34 @@ dependencies = [
[[package]]
name = "dashcore-crypto"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"base58ck 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bitcoin-crypto",
"dash-network",
- "dash-pkc",
- "dash-types",
+ "dash-pkc 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
+ "dash-types 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=d9e0d241e2e06edff455f88c9cb3b9ce0d8a8ac5)",
"dashcore-private",
"dashcore_hashes",
+ "delegate",
"grovedb-bincode",
"grovedb-bincode-derive",
"hex-conservative 1.3.0",
- "secp256k1",
"serde",
"thiserror 2.0.18",
"tracing",
+ "zeroize",
]
[[package]]
name = "dashcore-private"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
[[package]]
name = "dashcore-rpc"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"dashcore-rpc-json",
"hex-conservative 1.3.0",
@@ -2090,7 +2124,7 @@ dependencies = [
[[package]]
name = "dashcore-rpc-json"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"dashcore",
"grovedb-bincode",
@@ -2105,7 +2139,7 @@ dependencies = [
[[package]]
name = "dashcore_hashes"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"bitcoin_hashes 0.14.101",
"grovedb-bincode",
@@ -2386,7 +2420,7 @@ dependencies = [
"chrono",
"chrono-tz",
"ciborium",
- "dash-pkc",
+ "dash-pkc 0.1.0-beta (git+https://github.com/dashpay/base-sdk?rev=33fcc59e1868c803f9608e0e78ee8bddf3abcee7)",
"dash-spv",
"dashcore",
"dashcore-rpc",
@@ -2425,6 +2459,7 @@ dependencies = [
"regex",
"rust_decimal",
"rust_decimal_macros",
+ "secp256k1",
"serde",
"serde_json",
"serde_repr",
@@ -2760,7 +2795,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -2821,7 +2856,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
dependencies = [
"cfg-if",
"rustix 1.1.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -3196,7 +3231,7 @@ dependencies = [
[[package]]
name = "git-state"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
[[package]]
name = "glob"
@@ -4189,7 +4224,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
dependencies = [
"hermit-abi",
"libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -4436,7 +4471,7 @@ dependencies = [
[[package]]
name = "key-wallet"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"async-trait",
"bip39",
@@ -4448,7 +4483,6 @@ dependencies = [
"grovedb-bincode",
"grovedb-bincode-derive",
"hex-conservative 1.3.0",
- "secp256k1",
"serde",
"serde_json",
"tracing",
@@ -4459,7 +4493,7 @@ dependencies = [
[[package]]
name = "key-wallet-ffi"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"cbindgen 0.29.4",
"dash-network",
@@ -4468,14 +4502,13 @@ dependencies = [
"key-wallet",
"key-wallet-manager",
"libc",
- "secp256k1",
"tokio",
]
[[package]]
name = "key-wallet-manager"
version = "0.45.0"
-source = "git+https://github.com/dashpay/rust-dashcore?rev=280b3f2ccbd737ae52d14f925625286964610e30#280b3f2ccbd737ae52d14f925625286964610e30"
+source = "git+https://github.com/dashpay/rust-dashcore?rev=ecc567ed3e59577b692808a89e98dea1074dad09#ecc567ed3e59577b692808a89e98dea1074dad09"
dependencies = [
"async-trait",
"dashcore",
@@ -4985,7 +5018,7 @@ version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -6078,7 +6111,7 @@ dependencies = [
"once_cell",
"socket2 0.5.10",
"tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -6898,7 +6931,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -6911,7 +6944,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -6970,7 +7003,7 @@ dependencies = [
"security-framework",
"security-framework-sys",
"webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -7782,7 +7815,7 @@ dependencies = [
"getrandom 0.4.2",
"once_cell",
"rustix 1.1.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -9219,7 +9252,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
diff --git a/Cargo.toml b/Cargo.toml
index c5de8df04ee..d693d89acb0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,6 +55,7 @@ members = [
]
[workspace.dependencies]
+secp256k1 = { version = "=0.33.1", features = ["rand", "serde", "recovery"] }
bincode = { package = "grovedb-bincode", version = "=2.1.0" }
grovedb = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83114d86f88222e7ff09fc47ae75360f0", default-features = false }
grovedb-costs = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83114d86f88222e7ff09fc47ae75360f0" }
@@ -65,14 +66,14 @@ grovedb-storage = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83
grovedb-version = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83114d86f88222e7ff09fc47ae75360f0" }
grovedb-epoch-based-storage-flags = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83114d86f88222e7ff09fc47ae75360f0" }
grovedb-commitment-tree = { git = "https://github.com/dashpay/grovedb", rev = "fc7028d83114d86f88222e7ff09fc47ae75360f0" }
-dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-dash-network-seeds = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-key-wallet-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-dash-network = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
-dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "280b3f2ccbd737ae52d14f925625286964610e30" }
+dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+dash-network-seeds = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+key-wallet-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+dash-network = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
+dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "ecc567ed3e59577b692808a89e98dea1074dad09" }
tokio-metrics = "0.5"
# Size-tuned profile for the iOS `rs-unified-sdk-ffi` staticlib, which
diff --git a/packages/rs-dpp/Cargo.toml b/packages/rs-dpp/Cargo.toml
index d9d074919af..a7e1e10b675 100644
--- a/packages/rs-dpp/Cargo.toml
+++ b/packages/rs-dpp/Cargo.toml
@@ -12,6 +12,7 @@ authors = [
]
[dependencies]
+secp256k1 = { workspace = true }
dash-pkc = { git = "https://github.com/dashpay/base-sdk", rev = "33fcc59e1868c803f9608e0e78ee8bddf3abcee7", default-features = false, features = ["bls"], optional = true }
# Keep downstream lockfiles from retaining blst versions without WASM aggregate verification.
# TODO: Remove this constraint once the pinned rust-dashcore dependency graph enforces a compatible blst minimum.
@@ -31,7 +32,6 @@ chrono = { version = "0.4.35", default-features = false, features = [
chrono-tz = { version = "0.8", optional = true }
ciborium = { version = "0.2.2", optional = true }
dashcore = { workspace = true, features = [
- "secp-recovery",
"rand",
"signer",
"serde",
diff --git a/packages/rs-dpp/src/lib.rs b/packages/rs-dpp/src/lib.rs
index 2a7ab144989..f893f1423ff 100644
--- a/packages/rs-dpp/src/lib.rs
+++ b/packages/rs-dpp/src/lib.rs
@@ -14,6 +14,8 @@
extern crate core;
pub use dashcore;
+/// Low-level ECDSA primitives used by Platform signature validation.
+pub use secp256k1;
#[cfg(feature = "core_key_wallet")]
pub use key_wallet;
From 34d93ec26403365ccd500dc0f3712dfe678378f5 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:19:07 +0000
Subject: [PATCH 02/21] refactor(wallet): adapt native crypto keys and preserve
signature bytes
Co-Authored-By: Claude GPT-6
---
.../examples/dpns_marketplace_testnet.rs | 6 +-
.../rs-platform-wallet/src/manager/startup.rs | 16 +---
.../src/masternode/locator.rs | 4 +-
.../rs-platform-wallet/src/test_support.rs | 15 ++--
.../src/wallet/asset_lock/build.rs | 6 +-
.../src/wallet/core/sign_message.rs | 52 ++++++-------
.../src/wallet/core/transaction.rs | 4 +-
.../src/wallet/core_address_key.rs | 8 +-
.../src/wallet/identity/crypto/auto_accept.rs | 14 ++--
.../wallet/identity/crypto/contact_info.rs | 2 +-
.../src/wallet/identity/crypto/dip14.rs | 6 +-
.../src/wallet/identity/crypto/validation.rs | 2 +-
.../wallet/identity/network/contact_info.rs | 2 +-
.../identity/network/contact_requests.rs | 47 +++++++-----
.../src/wallet/identity/network/discovery.rs | 5 +-
.../identity/network/identity_handle.rs | 27 +++----
.../src/wallet/identity/network/invitation.rs | 4 +-
.../src/wallet/identity/network/payments.rs | 46 ++++++------
.../src/wallet/identity/network/sdk_writer.rs | 6 +-
.../wallet/identity/network/seed_binding.rs | 8 +-
.../src/wallet/masternode_withdrawal.rs | 74 ++++++++-----------
.../fund_from_asset_lock.rs | 6 +-
.../src/wallet/provider_ecdsa_key_tests.rs | 2 +-
.../src/wallet/provider_key_at_index.rs | 41 +++++-----
.../src/wallet/shielded/wallet_drain_tests.rs | 4 +-
25 files changed, 187 insertions(+), 220 deletions(-)
diff --git a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
index 535e6453980..440e00a5d65 100644
--- a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
+++ b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
@@ -115,10 +115,10 @@ fn dapi_addresses() -> AddressList {
/// Whether `sk_bytes` is the private key for `key` (33-byte pubkey for
/// ECDSA_SECP256K1, hash160 for ECDSA_HASH160).
fn private_key_matches(key: &dpp::identity::IdentityPublicKey, sk_bytes: &[u8; 32]) -> bool {
- let Ok(sk) = dashcore::secp256k1::SecretKey::from_secret_bytes(*sk_bytes) else {
+ let Ok(sk) = dpp::secp256k1::SecretKey::from_secret_bytes(*sk_bytes) else {
return false;
};
- let pubkey = dashcore::secp256k1::PublicKey::from_secret_key(&sk).serialize();
+ let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&sk).serialize();
match key.key_type() {
KeyType::ECDSA_SECP256K1 => key.data().as_slice() == pubkey.as_slice(),
KeyType::ECDSA_HASH160 => {
@@ -173,7 +173,7 @@ fn parse_private_key(raw: &str) -> Option<[u8; 32]> {
}
dashcore::PrivateKey::from_wif(trimmed)
.ok()
- .map(|pk| pk.inner.to_secret_bytes())
+ .map(|pk| *pk.inner.to_bytes())
}
async fn discover(
diff --git a/packages/rs-platform-wallet/src/manager/startup.rs b/packages/rs-platform-wallet/src/manager/startup.rs
index 36f4721bb3a..846f48015f0 100644
--- a/packages/rs-platform-wallet/src/manager/startup.rs
+++ b/packages/rs-platform-wallet/src/manager/startup.rs
@@ -131,23 +131,9 @@ impl std::fmt::Display for ScanKeyError {
}
}
-/// Owns a resolved master xpriv and erases it when it drops.
-///
-/// `ExtendedPrivKey` has no erasing `Drop`, so an explicit
-/// `non_secure_erase` at the end of the scan only covers the paths that reach
-/// it. A caller that drops the whole `start_wallet_subsystems` future while
-/// discovery is awaiting Platform reaches none of them, and the scalar stays
-/// in the freed future. Tying the erase to the value's lifetime instead of to
-/// a code path makes cancellation — which this call now invites, since it is
-/// budget-bounded and abandonable by design — a non-event.
+/// Owns a resolved master xpriv whose secret key zeroizes on drop.
struct ScanKeyGuard(ExtendedPrivKey);
-impl Drop for ScanKeyGuard {
- fn drop(&mut self) {
- self.0.private_key.non_secure_erase();
- }
-}
-
impl std::ops::Deref for ScanKeyGuard {
type Target = ExtendedPrivKey;
diff --git a/packages/rs-platform-wallet/src/masternode/locator.rs b/packages/rs-platform-wallet/src/masternode/locator.rs
index 2790c2414dc..380664cf904 100644
--- a/packages/rs-platform-wallet/src/masternode/locator.rs
+++ b/packages/rs-platform-wallet/src/masternode/locator.rs
@@ -36,7 +36,6 @@ use std::sync::Arc;
use dash_sdk::platform::types::identity::NonUniquePublicKeyHashQuery;
use dash_sdk::platform::Fetch;
use dashcore::hashes::{hash160, Hash};
-use dashcore::secp256k1::{PublicKey as SecpPublicKey, SecretKey as SecpSecretKey};
use dashcore::{Network, PrivateKey};
use dpp::bls::{PublicKey as BlsPublicKey, SecretKey as BlsSecretKey};
use dpp::ed25519_dalek::SigningKey;
@@ -45,6 +44,7 @@ use dpp::identity::accessors::IdentityGettersV0;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::{Identity, Purpose};
use dpp::prelude::Identifier;
+use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey as SecpSecretKey};
use zeroize::Zeroizing;
use super::list::{find_in_summaries, MasternodeListQuery, MasternodeListSummary};
@@ -315,7 +315,7 @@ pub fn parse_locator_input(
}
return Ok(ParsedLocatorInput {
candidates: vec![MasternodeLocatorInput::Secret(LocatorSecret::Ecdsa {
- secret: Zeroizing::new(key.inner.to_secret_bytes()),
+ secret: key.inner.to_bytes(),
compressed: key.compressed,
})],
});
diff --git a/packages/rs-platform-wallet/src/test_support.rs b/packages/rs-platform-wallet/src/test_support.rs
index 9879ceb1041..0dbca35e9b1 100644
--- a/packages/rs-platform-wallet/src/test_support.rs
+++ b/packages/rs-platform-wallet/src/test_support.rs
@@ -10,8 +10,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use async_trait::async_trait;
+use dashcore::crypto::ecdsa::{EcdsaPublicKey as PublicKey, EcdsaSignature};
use dashcore::hashes::Hash;
-use dashcore::secp256k1::{ecdsa, Message, PublicKey};
use dashcore::BlockHash;
#[cfg(test)]
use dashcore::Txid;
@@ -134,13 +134,18 @@ impl Signer for WalletSigner {
&self,
path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
let key = self
.wallet
.derive_private_key(path)
.map_err(|e| e.to_string())?;
- let message = Message::from_digest(sighash);
- Ok((key.sign_ecdsa(message), PublicKey::from_secret_key(&key)))
+ // Match message-signing vectors without low-R nonce grinding.
+ Ok((
+ key.sign_recoverable(&sighash)
+ .signature()
+ .map_err(|e| e.to_string())?,
+ key.public_key(),
+ ))
}
async fn public_key(&self, path: &DerivationPath) -> Result {
@@ -148,7 +153,7 @@ impl Signer for WalletSigner {
.wallet
.derive_private_key(path)
.map_err(|e| e.to_string())?;
- Ok(PublicKey::from_secret_key(&key))
+ Ok(key.public_key())
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/asset_lock/build.rs b/packages/rs-platform-wallet/src/wallet/asset_lock/build.rs
index 3b5ca3f6d90..8feba80262c 100644
--- a/packages/rs-platform-wallet/src/wallet/asset_lock/build.rs
+++ b/packages/rs-platform-wallet/src/wallet/asset_lock/build.rs
@@ -4294,8 +4294,8 @@ mod tests {
sighash: [u8; 32],
) -> Result<
(
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
+ dashcore::crypto::ecdsa::EcdsaSignature,
+ dashcore::crypto::ecdsa::EcdsaPublicKey,
),
String,
> {
@@ -4307,7 +4307,7 @@ mod tests {
async fn public_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
self.inner.public_key(path).await
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/core/sign_message.rs b/packages/rs-platform-wallet/src/wallet/core/sign_message.rs
index 9316053883b..4c428156b2c 100644
--- a/packages/rs-platform-wallet/src/wallet/core/sign_message.rs
+++ b/packages/rs-platform-wallet/src/wallet/core/sign_message.rs
@@ -25,7 +25,7 @@
//! ## Why the recovery id is found by trial
//!
//! [`Signer`] is a *plain*-ECDSA interface: `sign_ecdsa` hands back a
-//! non-recoverable [`ecdsa::Signature`] plus the compressed public key, which is
+//! non-recoverable [`EcdsaSignature`] plus the compressed public key, which is
//! all a P2PKH `scriptSig` needs. The recovery id is not recoverable from that
//! pair analytically, so it is found by trying all four candidates and keeping
//! the one that recovers the signer's own public key — exactly what dashj's
@@ -44,10 +44,9 @@
use std::str::FromStr;
use dashcore::address::Payload;
+use dashcore::crypto::ecdsa::{EcdsaPublicKey, EcdsaRecSignature};
use dashcore::hashes::Hash;
-use dashcore::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
-use dashcore::secp256k1::Message;
-use dashcore::sign_message::{signed_msg_hash, MessageSignature};
+use dashcore::sign_message::{self, signed_msg_hash};
use dashcore::{Address as DashAddress, AddressType, PublicKey as DashPublicKey};
use key_wallet::managed_account::managed_account_trait::ManagedAccountTrait;
use key_wallet::signer::{Signer, SignerMethod};
@@ -274,16 +273,11 @@ impl CoreWallet {
});
}
- let digest = Message::from_digest(hash.to_byte_array());
- let compact = signature.serialize_compact();
-
let recoverable = RECOVERY_IDS
.into_iter()
- .filter_map(|id| RecoveryId::try_from(id).ok())
- .filter_map(|recid| RecoverableSignature::from_compact(&compact, recid).ok())
+ .filter_map(|id| EcdsaRecSignature::from_parts(signature, id as u8, true).ok())
.find(|candidate| {
- candidate
- .recover_ecdsa(digest)
+ EcdsaPublicKey::recover(hash.as_byte_array(), candidate)
.is_ok_and(|recovered| recovered == public_key)
})
.ok_or_else(|| PlatformWalletError::MessageSigningFailed {
@@ -291,7 +285,7 @@ impl CoreWallet {
reason: "no recovery id in 0..=3 recovers the signing public key".to_string(),
})?;
- Ok(MessageSignature::new(recoverable, true).to_base64())
+ Ok(sign_message::to_base64(recoverable))
}
}
@@ -300,8 +294,8 @@ mod tests {
use std::str::FromStr;
use std::sync::Arc;
- use dashcore::secp256k1::{ecdsa, PublicKey};
- use dashcore::sign_message::{signed_msg_hash, MessageSignature};
+ use dashcore::crypto::ecdsa::{EcdsaPublicKey as PublicKey, EcdsaSignature};
+ use dashcore::sign_message::{self, signed_msg_hash};
use dashcore::{Address as DashAddress, Network};
use key_wallet::signer::{Signer, SignerMethod, TransactionCategory};
use key_wallet::DerivationPath;
@@ -344,15 +338,18 @@ mod tests {
/// Verify `signature_base64` against `address` the way an external verifier
/// would: decode, re-derive the digest from the message alone, recover.
fn verifies_for(signature_base64: &str, address: &DashAddress) -> bool {
- MessageSignature::from_base64(signature_base64)
- .expect("signature is valid base64 of a 65-byte recoverable signature")
- .is_signed_by_address(address, signed_msg_hash(MESSAGE))
- .expect("P2PKH address is a supported verification target")
+ sign_message::is_signed_by_address(
+ &sign_message::from_base64(signature_base64)
+ .expect("signature is valid base64 of a 65-byte recoverable signature"),
+ address,
+ signed_msg_hash(MESSAGE),
+ )
+ .expect("P2PKH address is a supported verification target")
}
/// **Cross-implementation parity.** A signature produced by dashj
/// (`ECKeyTest.verifyMessage`) must verify under this crate's
- /// `signed_msg_hash` + `MessageSignature`, proving the two agree on the
+ /// `signed_msg_hash` + `sign_message`, proving the two agree on the
/// `"\x19DarkCoin Signed Message:\n"` prefix, the varint length prefix, the
/// double-SHA256, the 65-byte header encoding, and the compressed-key flag.
///
@@ -398,10 +395,13 @@ mod tests {
.expect("the empty message is signable");
assert!(
- MessageSignature::from_base64(&signature)
- .expect("valid base64 of a 65-byte recoverable signature")
- .is_signed_by_address(&address, signed_msg_hash(""))
- .expect("P2PKH address is a supported verification target"),
+ sign_message::is_signed_by_address(
+ &sign_message::from_base64(&signature)
+ .expect("valid base64 of a 65-byte recoverable signature"),
+ &address,
+ signed_msg_hash("")
+ )
+ .expect("P2PKH address is a supported verification target"),
"a signature over the empty message must verify against signed_msg_hash(\"\")"
);
}
@@ -538,7 +538,7 @@ mod tests {
&self,
_path: &DerivationPath,
_sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
panic!(
"sign_ecdsa must never be reached on a signer that does not advertise \
SignerMethod::Digest — sign_message is required to refuse first"
@@ -568,7 +568,7 @@ mod tests {
&self,
_path: &DerivationPath,
_sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
Err(format!(
"{}no private key stored for this derivation path",
crate::error::SIGNER_KEY_UNAVAILABLE_PREFIX
@@ -624,7 +624,7 @@ mod tests {
&self,
_path: &DerivationPath,
_sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
Err(format!(
"remote signer reported: {}oops",
crate::error::SIGNER_KEY_UNAVAILABLE_PREFIX
diff --git a/packages/rs-platform-wallet/src/wallet/core/transaction.rs b/packages/rs-platform-wallet/src/wallet/core/transaction.rs
index de4bdb692c0..92924440e97 100644
--- a/packages/rs-platform-wallet/src/wallet/core/transaction.rs
+++ b/packages/rs-platform-wallet/src/wallet/core/transaction.rs
@@ -1006,7 +1006,7 @@ mod tests {
use std::sync::Arc;
use async_trait::async_trait;
- use dashcore::secp256k1::{ecdsa, PublicKey};
+ use dashcore::crypto::ecdsa::{EcdsaPublicKey as PublicKey, EcdsaSignature};
use dashcore::{Address as DashAddress, Network};
use key_wallet::account::account_type::StandardAccountType;
use key_wallet::signer::{Signer, SignerMethod};
@@ -1906,7 +1906,7 @@ mod tests {
&self,
_path: &DerivationPath,
_sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
Err("intentional signer failure")
}
diff --git a/packages/rs-platform-wallet/src/wallet/core_address_key.rs b/packages/rs-platform-wallet/src/wallet/core_address_key.rs
index 7adb517e769..37ec9990e41 100644
--- a/packages/rs-platform-wallet/src/wallet/core_address_key.rs
+++ b/packages/rs-platform-wallet/src/wallet/core_address_key.rs
@@ -119,7 +119,7 @@ impl PlatformWallet {
"failed to derive private key at {path}: {e}"
))
})?;
- Zeroizing::new(derived.private_key.to_secret_bytes())
+ derived.private_key.to_bytes()
}
None => {
// Resident key-bearing wallet — derive from its own root.
@@ -131,15 +131,15 @@ impl PlatformWallet {
"failed to derive private key at {path} from resident wallet: {e}"
))
})?;
- Zeroizing::new(secret_key.to_secret_bytes())
+ secret_key.to_bytes()
}
};
// Build the network-aware compressed WIF. `SecretKey::from_secret_bytes`
// over the just-derived bytes is infallible, but map its error
// rather than unwrap to keep the boundary panic-free.
- let secret_key =
- dashcore::secp256k1::SecretKey::from_secret_bytes(*secret_bytes).map_err(|e| {
+ let secret_key = dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&secret_bytes)
+ .map_err(|e| {
PlatformWalletError::KeyDerivation(format!(
"derived private key bytes were not a valid secp256k1 scalar: {e}"
))
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
index b7f142ff1a0..959afd6ab7e 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
@@ -25,8 +25,8 @@
//! `m/9'/coin'/16'/timestamp'` (all segments hardened)
use dashcore::hashes::{sha256, Hash, HashEngine};
-use dashcore::secp256k1::{ecdsa::Signature, Message, SecretKey};
use dpp::prelude::Identifier;
+use dpp::secp256k1::{ecdsa::Signature, Message, SecretKey};
use key_wallet::bip32::{ChildNumber, DerivationPath};
use key_wallet::dip9::{
DASH_COIN_TYPE, DASH_TESTNET_COIN_TYPE, FEATURE_PURPOSE, FEATURE_PURPOSE_DASHPAY_AUTO_ACCEPT,
@@ -115,7 +115,7 @@ pub fn derive_auto_accept_private_key(
PlatformWalletError::InvalidIdentityData(format!("Failed to derive auto-accept key: {}", e))
})?;
- let secret_bytes = zeroize::Zeroizing::new(ext_priv.private_key.to_secret_bytes());
+ let secret_bytes = ext_priv.private_key.to_bytes();
SecretKey::from_secret_bytes(*secret_bytes).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
@@ -219,7 +219,7 @@ pub fn auto_accept_proof_expiry(proof_bytes: &[u8]) -> Option {
/// check clock-free makes it deterministically testable; the acceptance path
/// pairs the two.)
pub fn verify_auto_accept_proof_with_pubkey(
- pubkey: &dashcore::secp256k1::PublicKey,
+ pubkey: &dpp::secp256k1::PublicKey,
proof_bytes: &[u8],
sender_id: &Identifier,
recipient_id: &Identifier,
@@ -265,7 +265,7 @@ pub fn verify_auto_accept_proof(
return Ok(false);
};
let secret_key = derive_auto_accept_private_key(wallet, network, timestamp)?;
- let pubkey = dashcore::secp256k1::PublicKey::from_secret_key(&secret_key);
+ let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&secret_key);
Ok(verify_auto_accept_proof_with_pubkey(
&pubkey,
proof_bytes,
@@ -318,7 +318,7 @@ pub fn decode_auto_accept_key_blob(blob: &[u8]) -> Result<(SecretKey, u32), Plat
return Err(invalid("auto-accept key size must be 32"));
}
let secret_key = <[u8; 32]>::try_from(&blob[6..KEY_BLOB_LEN])
- .map_err(|_| dashcore::secp256k1::Error::InvalidSecretKey)
+ .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey)
.and_then(SecretKey::from_secret_bytes)
.map_err(|e| invalid(format!("invalid auto-accept private key: {e}")))?;
Ok((secret_key, expiry))
@@ -573,7 +573,7 @@ mod tests {
assert_eq!(proof.len(), 70);
assert_eq!(auto_accept_proof_expiry(&proof), Some(expiry));
- let pubkey = dashcore::secp256k1::PublicKey::from_secret_key(&owner_key);
+ let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&owner_key);
assert!(
verify_auto_accept_proof_with_pubkey(&pubkey, &proof, &scanner, &owner, account_ref),
"owner verifies the scanner's proof against its own re-derived pubkey"
@@ -676,7 +676,7 @@ mod tests {
#[test]
fn verify_with_pubkey_rejects_truncated_and_no_expiry() {
let key = SecretKey::from_secret_bytes([0x05u8; 32]).unwrap();
- let pubkey = dashcore::secp256k1::PublicKey::from_secret_key(&key);
+ let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&key);
let (s, r) = test_ids();
assert!(!verify_auto_accept_proof_with_pubkey(
&pubkey, &[0u8; 3], &s, &r, 0
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/contact_info.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/contact_info.rs
index 4c5a02a20c6..52f84f16a4f 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/contact_info.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/contact_info.rs
@@ -121,7 +121,7 @@ pub fn derive_contact_info_keys(
"Failed to derive contactInfo key: {e}"
))
})?;
- Ok(Zeroizing::new(ext.private_key.to_secret_bytes()))
+ Ok(ext.private_key.to_bytes())
};
Ok(ContactInfoKeys {
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/dip14.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/dip14.rs
index b6772f0bf92..5e1cb9acf01 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/dip14.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/dip14.rs
@@ -125,7 +125,7 @@ pub fn derive_contact_xpub(
let compact = platform_encryption::CompactXpub {
parent_fingerprint: xpub.parent_fingerprint.to_bytes(),
chain_code: xpub.chain_code.to_bytes(),
- public_key: xpub.public_key.serialize(),
+ public_key: xpub.public_key.to_compressed(),
};
Ok(ContactXpubData { xpub, compact })
@@ -159,8 +159,8 @@ pub fn reconstruct_contact_xpub(
compact: platform_encryption::CompactXpub,
network: Network,
) -> Result {
- let public_key =
- dashcore::secp256k1::PublicKey::from_slice(&compact.public_key).map_err(|e| {
+ let public_key = dashcore::crypto::ecdsa::EcdsaPublicKey::from_bytes(&compact.public_key)
+ .map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Compact contact xpub has an invalid compressed public key: {e}"
))
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
index c14757f7d56..8b46ce08955 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
@@ -851,7 +851,7 @@ mod tests {
/// Derive the compressed secp256k1 pubkey (`[u8; 33]`) for a fixed
/// in-range scalar — the shape a breadcrumb re-derivation produces.
fn fixed_scalar_and_compressed_pubkey() -> ([u8; 32], [u8; 33]) {
- use dashcore::secp256k1::{PublicKey, SecretKey};
+ use dpp::secp256k1::{PublicKey, SecretKey};
let mut scalar = [0u8; 32];
scalar[31] = 7;
let sk = SecretKey::from_secret_bytes(scalar).expect("in-range scalar");
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
index 690875080a3..1920acb8d68 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
@@ -515,8 +515,8 @@ impl DashPayView<'_, B> {
S: Signer + Send + Sync,
C: super::ContactCryptoProvider + Sync,
{
- use dashcore::secp256k1::rand::{rng, RngCore};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
+ use dpp::secp256k1::rand::{rng, RngCore};
// Build the decrypted-payload struct once: it is both the local
// metadata applied to the contact AND (on publish) the plaintext the
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
index 8d8753248a4..c860355489a 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
@@ -50,7 +50,7 @@ pub trait ContactCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dashcore::secp256k1::PublicKey,
+ peer: &dpp::secp256k1::PublicKey,
) -> Result, PlatformWalletError>;
/// Export the raw **auto-accept private key** at `path` (DIP-15 QR
@@ -64,7 +64,7 @@ pub trait ContactCryptoProvider {
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result;
+ ) -> Result;
/// Export the raw **invitation-funding private key** at `path` (DIP-13
/// sub-feature `3'`) — the second deliberate raw-key export (alongside
@@ -85,7 +85,7 @@ pub trait ContactCryptoProvider {
async fn export_invitation_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
Err(PlatformWalletError::InvalidIdentityData(
"invitation private-key export is not supported by this crypto provider".to_string(),
))
@@ -201,34 +201,40 @@ impl ContactCryptoProvider for SeedCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dashcore::secp256k1::PublicKey,
+ peer: &dpp::secp256k1::PublicKey,
) -> Result, PlatformWalletError> {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test ecdh derive: {e}"))
})?;
Ok(zeroize::Zeroizing::new(
- platform_encryption::derive_shared_key_ecdh(&xprv.private_key, peer),
+ platform_encryption::derive_shared_key_ecdh(
+ &dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))?,
+ peer,
+ ),
))
}
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test export auto-accept: {e}"))
})?;
- Ok(xprv.private_key)
+ dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))
}
async fn export_invitation_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test export invitation: {e}"))
})?;
- Ok(xprv.private_key)
+ dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))
}
async fn account_reference(
@@ -242,7 +248,7 @@ impl ContactCryptoProvider for SeedCryptoProvider {
PlatformWalletError::InvalidIdentityData(format!("test accountRef derive: {e}"))
})?;
Ok(platform_encryption::calculate_account_reference(
- &xprv.private_key.to_secret_bytes(),
+ &*xprv.private_key.to_bytes(),
compact_xpub,
account_index,
version,
@@ -260,7 +266,7 @@ impl ContactCryptoProvider for SeedCryptoProvider {
})?;
Ok(platform_encryption::unmask_account_reference(
account_reference,
- &xprv.private_key.to_secret_bytes(),
+ &*xprv.private_key.to_bytes(),
compact_xpub,
))
}
@@ -341,7 +347,7 @@ impl SeedCryptoProvider {
.map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test contactInfo derive: {e}"))
})?;
- Ok(xprv.private_key.to_secret_bytes())
+ Ok(*xprv.private_key.to_bytes())
}
}
@@ -363,7 +369,7 @@ pub enum AutoAcceptProofSource {
/// QR (`dapk`), binding it to the accountReference this send computes.
SignWithKey {
/// The auto-accept private key handed out in the QR.
- secret_key: dashcore::secp256k1::SecretKey,
+ secret_key: dpp::secp256k1::SecretKey,
/// The proof's expiry (the key blob's timestamp / derivation index).
expiry: u32,
},
@@ -523,7 +529,7 @@ impl DashPayView<'_, B> {
let xpub_bytes = platform_encryption::CompactXpub {
parent_fingerprint: contact_xpub_ext.parent_fingerprint.to_bytes(),
chain_code: contact_xpub_ext.chain_code.to_bytes(),
- public_key: contact_xpub_ext.public_key.serialize(),
+ public_key: contact_xpub_ext.public_key.to_compressed(),
}
.to_bytes()
.to_vec();
@@ -644,7 +650,7 @@ impl DashPayView<'_, B> {
"Recipient identity has no key at index {recipient_key_index}"
))
})?;
- dashcore::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
+ dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Recipient encryption public key is invalid: {e}"
))
@@ -2460,7 +2466,7 @@ impl DashPayView<'_, B> {
.get(contact_encryption_key_index)
{
Some(k) => {
- match dashcore::secp256k1::PublicKey::from_slice(k.data().as_slice()) {
+ match dpp::secp256k1::PublicKey::from_slice(k.data().as_slice()) {
Ok(pk) => pk,
Err(e) => {
tracing::warn!(
@@ -3674,7 +3680,7 @@ impl DashPayView<'_, B> {
"Contact identity has no key at index {contact_encryption_key_index}"
))
})?;
- dashcore::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
+ dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Contact encryption public key is invalid: {e}"
))
@@ -5598,7 +5604,7 @@ mod contact_info_provider_tests {
/// the resident `derive_shared_key_ecdh` at the same path.
#[tokio::test]
async fn ecdh_shared_secret_returns_zeroizing_matching_resident_derivation() {
- use dashcore::secp256k1::{PublicKey, SecretKey};
+ use dpp::secp256k1::{PublicKey, SecretKey};
let seed = Mnemonic::from_phrase(PHRASE)
.expect("valid mnemonic")
@@ -5628,7 +5634,10 @@ mod contact_info_provider_tests {
let xprv = wallet
.derive_extended_private_key(&path)
.expect("resident xprv");
- let expected = platform_encryption::derive_shared_key_ecdh(&xprv.private_key, &peer);
+ let expected = platform_encryption::derive_shared_key_ecdh(
+ &SecretKey::from_secret_bytes(*xprv.private_key.to_bytes()).expect("valid scalar"),
+ &peer,
+ );
assert_eq!(
*shared, expected,
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/discovery.rs b/packages/rs-platform-wallet/src/wallet/identity/network/discovery.rs
index 11011b4b884..6407953c2a6 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/discovery.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/discovery.rs
@@ -302,10 +302,7 @@ impl IdentityWallet {
if let Ok((_, xpriv, _)) =
derive_identity_auth_keypair(wallet, network, identity_index, *key_id)
{
- candidate_scalars.insert(
- *key_id,
- zeroize::Zeroizing::new(xpriv.private_key.to_secret_bytes()),
- );
+ candidate_scalars.insert(*key_id, xpriv.private_key.to_bytes());
}
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
index 6b4e18892ad..ff30931ed2c 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
@@ -23,7 +23,7 @@
use std::collections::BTreeMap;
use std::sync::{Arc, Mutex as StdMutex};
-use dashcore::secp256k1::PublicKey;
+use dashcore::crypto::ecdsa::EcdsaPublicKey as PublicKey;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::{IdentityPublicKey, KeyType};
use dpp::prelude::Identifier;
@@ -183,8 +183,8 @@ pub fn derive_connect_keypair_from_master(
Ok(DerivedIdentityAuthKey {
derivation_path: path,
- private_key: Zeroizing::new(derived.private_key.to_secret_bytes()),
- public_key: extended_pub.public_key.serialize(),
+ private_key: derived.private_key.to_bytes(),
+ public_key: extended_pub.public_key.to_compressed(),
})
}
@@ -229,16 +229,7 @@ pub fn derive_ecdsa_identity_auth_keypair_from_master(
identity_index,
key_index,
)?;
- // `ExtendedPrivKey` doesn't implement `Zeroize`, so we can't
- // wrap it in `Zeroizing` directly — but its inner
- // `secp256k1::SecretKey` does implement `Drop` with a memzero,
- // so the secret scalar is scrubbed when `derived` falls out of
- // scope. The surrounding `chain_code` / `depth` /
- // `parent_fingerprint` / `child_number` are non-secret BIP-32
- // metadata; leaking them on the stack is a non-event. The
- // returned `private_key` is wrapped in `Zeroizing` below so
- // the 32-byte scalar copy crossing the function boundary is
- // also scrubbed on the caller's drop.
+ // The derived scalar and its exported byte copy zeroize on drop.
let derived = master.derive_priv(&path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Failed to derive private key at (identity={identity_index}, key={key_index}): {e}"
@@ -248,8 +239,8 @@ pub fn derive_ecdsa_identity_auth_keypair_from_master(
Ok(DerivedIdentityAuthKey {
derivation_path: path,
- private_key: Zeroizing::new(derived.private_key.to_secret_bytes()),
- public_key: extended_pub.public_key.serialize(),
+ private_key: derived.private_key.to_bytes(),
+ public_key: extended_pub.public_key.to_compressed(),
})
}
@@ -310,7 +301,7 @@ pub(crate) fn derive_identity_auth_key_hash(
let (_path, _priv, public_key) =
derive_identity_auth_keypair(wallet, network, identity_index, key_index)?;
- let public_key_bytes = public_key.serialize();
+ let public_key_bytes = public_key.to_compressed();
let key_hash = ripemd160_sha256(&public_key_bytes);
let mut key_hash_array = [0u8; 20];
@@ -519,7 +510,7 @@ impl IdentityWallet {
))
})?;
- Ok(Zeroizing::new(secret_key.to_secret_bytes()))
+ Ok(secret_key.to_bytes())
}
/// Get a read-lock handle to the shared [`WalletManager`].
@@ -753,7 +744,7 @@ mod tests {
/// the returned scalar.
#[test]
fn connect_keypairs_match_the_pinned_vectors() {
- use dashcore::secp256k1::{PublicKey as SecpPublicKey, SecretKey};
+ use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey};
for (network, key, expected) in [
(
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
index b275fe19471..0ef5b91c25f 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
@@ -480,8 +480,8 @@ mod tests {
_sighash: [u8; 32],
) -> Result<
(
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
+ dashcore::crypto::ecdsa::EcdsaSignature,
+ dashcore::crypto::ecdsa::EcdsaPublicKey,
),
Self::Error,
> {
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
index 3d9d09ff81d..e8bfa8ec253 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
@@ -2324,8 +2324,8 @@ mod tests {
sighash: [u8; 32],
) -> Result<
(
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
+ dashcore::crypto::ecdsa::EcdsaSignature,
+ dashcore::crypto::ecdsa::EcdsaPublicKey,
),
String,
> {
@@ -2333,23 +2333,24 @@ mod tests {
.wallet
.derive_extended_private_key(path)
.map_err(|e| e.to_string())?;
- let msg = dashcore::secp256k1::Message::from_digest(sighash);
- let sig = xprv.private_key.sign_ecdsa(msg);
- let pk = dashcore::secp256k1::PublicKey::from_secret_key(&xprv.private_key);
+ let sig = xprv
+ .private_key
+ .sign_recoverable(&sighash)
+ .signature()
+ .map_err(|e| e.to_string())?;
+ let pk = xprv.private_key.public_key();
Ok((sig, pk))
}
async fn public_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let xprv = self
.wallet
.derive_extended_private_key(path)
.map_err(|e| e.to_string())?;
- Ok(dashcore::secp256k1::PublicKey::from_secret_key(
- &xprv.private_key,
- ))
+ Ok(xprv.private_key.public_key())
}
}
@@ -2501,8 +2502,8 @@ mod tests {
) -> Identity {
use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::{IdentityPublicKey, SecurityLevel};
- let data = dashcore::secp256k1::PublicKey::from_secret_key(
- &dashcore::secp256k1::SecretKey::from_secret_bytes([0x37u8; 32]).expect("secret"),
+ let data = dpp::secp256k1::PublicKey::from_secret_key(
+ &dpp::secp256k1::SecretKey::from_secret_bytes([0x37u8; 32]).expect("secret"),
)
.serialize()
.to_vec();
@@ -10127,8 +10128,8 @@ mod tests {
contract_bounds: None,
key_type: KeyType::ECDSA_SECP256K1,
read_only: false,
- data: dashcore::secp256k1::PublicKey::from_secret_key(
- &dashcore::secp256k1::SecretKey::from_secret_bytes([0x24u8; 32]).expect("secret"),
+ data: dpp::secp256k1::PublicKey::from_secret_key(
+ &dpp::secp256k1::SecretKey::from_secret_bytes([0x24u8; 32]).expect("secret"),
)
.serialize()
.to_vec()
@@ -10396,9 +10397,9 @@ mod tests {
let provider = SeedCryptoProvider::from_seed(seed, Network::Testnet);
// The contact's encryption keypair (the "sender" of the request).
- let contact_secret = dashcore::secp256k1::SecretKey::from_secret_bytes([0x42u8; 32])
+ let contact_secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x42u8; 32])
.expect("valid contact secret");
- let contact_public = dashcore::secp256k1::PublicKey::from_secret_key(&contact_secret);
+ let contact_public = dpp::secp256k1::PublicKey::from_secret_key(&contact_secret);
// Our side, through the production provider.
let ours = provider
@@ -10413,7 +10414,8 @@ mod tests {
.await
.expect("our xpub at the legacy key id")
.public_key;
- let theirs = platform_encryption::derive_shared_key_ecdh(&contact_secret, &our_public);
+ let theirs =
+ platform_encryption::derive_shared_key_ecdh(&contact_secret, &our_public.into());
assert_eq!(
ours.as_slice(),
theirs.as_slice(),
@@ -10490,8 +10492,8 @@ mod tests {
contract_bounds: None,
key_type: KeyType::ECDSA_SECP256K1,
read_only: false,
- data: dashcore::secp256k1::PublicKey::from_secret_key(
- &dashcore::secp256k1::SecretKey::from_secret_bytes([byte; 32]).expect("secret"),
+ data: dpp::secp256k1::PublicKey::from_secret_key(
+ &dpp::secp256k1::SecretKey::from_secret_bytes([byte; 32]).expect("secret"),
)
.serialize()
.to_vec()
@@ -10667,7 +10669,7 @@ mod tests {
async fn ecdh_shared_secret(
&self,
_path: &key_wallet::bip32::DerivationPath,
- _peer: &dashcore::secp256k1::PublicKey,
+ _peer: &dpp::secp256k1::PublicKey,
) -> Result, crate::error::PlatformWalletError>
{
Ok(zeroize::Zeroizing::new([0u8; 32]))
@@ -10675,15 +10677,13 @@ mod tests {
async fn export_auto_accept_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result
- {
+ ) -> Result {
unimplemented!("auto-accept QR is a send-path method, not exercised by the drain")
}
async fn export_invitation_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result
- {
+ ) -> Result {
unimplemented!(
"invitation create is a send-path method, not exercised by the drain"
)
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
index 5012ea38ff2..4d9afca936d 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
@@ -115,7 +115,7 @@ pub(crate) struct SendContactRequestParams<'a> {
/// secret — the client-side equivalent of the old SdkSide key-id
/// guard, so a recipient-key mismatch fails loudly instead of
/// silently encrypting with the wrong secret.
- pub expected_recipient_pubkey: dashcore::secp256k1::PublicKey,
+ pub expected_recipient_pubkey: dpp::secp256k1::PublicKey,
/// DashPay receiving-account xpub to share with the recipient, in the
/// **69-byte DIP-15 compact form** (`parentFingerprint ‖ chainCode ‖
/// pubKey`) — NOT `ExtendedPubKey::encode()`. The SDK validates len == 69
@@ -223,10 +223,10 @@ impl SdkWriter {
&IdentityPublicKey,
u32,
) -> std::future::Ready<
- Result,
+ Result,
>;
let ecdh_provider: EcdhProvider = EcdhProvider::ClientSide {
- get_shared_secret: move |peer: &dashcore::secp256k1::PublicKey| {
+ get_shared_secret: move |peer: &dpp::secp256k1::PublicKey| {
let peer_matches = *peer == expected_recipient_pubkey;
async move {
if !peer_matches {
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
index 30cbc92a253..b7eb81cf316 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
@@ -1245,8 +1245,8 @@ mod tests {
_sighash: [u8; 32],
) -> Result<
(
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
+ dashcore::crypto::ecdsa::EcdsaSignature,
+ dashcore::crypto::ecdsa::EcdsaPublicKey,
),
Self::Error,
> {
@@ -1753,7 +1753,7 @@ mod tests {
async fn ecdh_shared_secret(
&self,
_path: &key_wallet::bip32::DerivationPath,
- _peer: &dashcore::secp256k1::PublicKey,
+ _peer: &dpp::secp256k1::PublicKey,
) -> Result, PlatformWalletError> {
unreachable!("the gate refuses, so no queue entry is ever derived")
}
@@ -1761,7 +1761,7 @@ mod tests {
async fn export_auto_accept_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
unreachable!("the gate refuses, so no queue entry is ever derived")
}
diff --git a/packages/rs-platform-wallet/src/wallet/masternode_withdrawal.rs b/packages/rs-platform-wallet/src/wallet/masternode_withdrawal.rs
index 94f16c80ffa..e90851b9fb5 100644
--- a/packages/rs-platform-wallet/src/wallet/masternode_withdrawal.rs
+++ b/packages/rs-platform-wallet/src/wallet/masternode_withdrawal.rs
@@ -28,10 +28,8 @@
use std::fmt;
use async_trait::async_trait;
+use dashcore::crypto::ecdsa::{EcdsaPublicKey, EcdsaRecSignature, EcdsaSecretKey, EcdsaSignature};
use dashcore::hashes::{hash160, sha256d, Hash};
-use dashcore::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
-use dashcore::secp256k1::Message;
-use dashcore::sign_message::MessageSignature;
use dashcore::{Address as DashAddress, AddressType, Network, ScriptBuf};
use dpp::address_funds::AddressWitness;
use dpp::identity::accessors::IdentityGettersV0;
@@ -527,13 +525,13 @@ pub(crate) async fn execute_masternode_withdrawal
/// key against the masternode identity key's hash160, so a wrong key still
/// cannot produce a broadcastable signature.
pub struct RawSecretCoreSigner {
- secret: dashcore::secp256k1::SecretKey,
+ secret: EcdsaSecretKey,
}
impl RawSecretCoreSigner {
/// `secret` must be a valid secp256k1 scalar (32 bytes).
pub fn from_bytes(secret: &[u8; 32]) -> Result {
- let secret = dashcore::secp256k1::SecretKey::from_secret_bytes(*secret).map_err(|_| {
+ let secret = EcdsaSecretKey::from_bytes(secret).map_err(|_| {
PlatformWalletError::InvalidParameter("not a valid secp256k1 private key".to_string())
})?;
Ok(Self { secret })
@@ -541,8 +539,8 @@ impl RawSecretCoreSigner {
/// hash160 of this key's compressed public key.
pub fn public_key_hash160(&self) -> [u8; 20] {
- let public = dashcore::secp256k1::PublicKey::from_secret_key(&self.secret);
- hash160::Hash::hash(&public.serialize()).to_byte_array()
+ let public = self.secret.public_key();
+ hash160::Hash::hash(&public.to_compressed()).to_byte_array()
}
}
@@ -565,27 +563,19 @@ impl CoreSigner for RawSecretCoreSigner {
&self,
_path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<
- (
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
- ),
- Self::Error,
- > {
- let msg = Message::from_digest(sighash);
+ ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> {
+ // Recoverable signing preserves RFC6979 bytes without low-R grinding.
Ok((
- self.secret.sign_ecdsa(msg),
- dashcore::secp256k1::PublicKey::from_secret_key(&self.secret),
+ self.secret
+ .sign_recoverable(&sighash)
+ .signature()
+ .map_err(|e| e.to_string())?,
+ self.secret.public_key(),
))
}
- async fn public_key(
- &self,
- _path: &DerivationPath,
- ) -> Result {
- Ok(dashcore::secp256k1::PublicKey::from_secret_key(
- &self.secret,
- ))
+ async fn public_key(&self, _path: &DerivationPath) -> Result {
+ Ok(self.secret.public_key())
}
}
@@ -689,7 +679,8 @@ where
// Bind the derived key to the identity key BEFORE emitting anything:
// a wrong index / wrong seed yields a different pubkey.
- let derived_hash: [u8; 20] = hash160::Hash::hash(&public_key.serialize()).to_byte_array();
+ let derived_hash: [u8; 20] =
+ hash160::Hash::hash(&public_key.to_compressed()).to_byte_array();
if derived_hash != self.expected_key_hash160 {
return Err(ProtocolError::Generic(format!(
"the key derived at {} does not match the masternode identity key (hash160 {} \
@@ -700,14 +691,10 @@ where
)));
}
- let msg = Message::from_digest(digest);
- let compact = signature.serialize_compact();
let recoverable = (0..4i32)
- .filter_map(|id| RecoveryId::try_from(id).ok())
- .filter_map(|recid| RecoverableSignature::from_compact(&compact, recid).ok())
+ .filter_map(|id| EcdsaRecSignature::from_parts(signature, id as u8, true).ok())
.find(|candidate| {
- candidate
- .recover_ecdsa(msg)
+ EcdsaPublicKey::recover(&digest, candidate)
.is_ok_and(|recovered| recovered == public_key)
})
.ok_or_else(|| {
@@ -716,10 +703,7 @@ where
)
})?;
- Ok(MessageSignature::new(recoverable, true)
- .serialize()
- .to_vec()
- .into())
+ Ok(recoverable.as_bytes().to_vec().into())
}
async fn sign_create_witness(
@@ -740,7 +724,7 @@ where
#[cfg(test)]
mod tests {
use super::*;
- use dashcore::secp256k1::{PublicKey, SecretKey};
+ use dashcore::crypto::ecdsa::{EcdsaPublicKey as PublicKey, EcdsaSecretKey as SecretKey};
use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::{Purpose, SecurityLevel};
use std::str::FromStr;
@@ -762,23 +746,25 @@ mod tests {
&self,
_path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(dashcore::secp256k1::ecdsa::Signature, PublicKey), Self::Error> {
- let msg = Message::from_digest(sighash);
+ ) -> Result<(EcdsaSignature, PublicKey), Self::Error> {
Ok((
- self.secret.sign_ecdsa(msg),
- PublicKey::from_secret_key(&self.secret),
+ self.secret
+ .sign_recoverable(&sighash)
+ .signature()
+ .map_err(|e| e.to_string())?,
+ self.secret.public_key(),
))
}
async fn public_key(&self, _path: &DerivationPath) -> Result {
- Ok(PublicKey::from_secret_key(&self.secret))
+ Ok(self.secret.public_key())
}
}
fn fixture() -> (FixedKeySigner, [u8; 20], IdentityPublicKey) {
- let secret = SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid scalar");
- let pubkey = PublicKey::from_secret_key(&secret);
- let hash: [u8; 20] = hash160::Hash::hash(&pubkey.serialize()).to_byte_array();
+ let secret = SecretKey::from_bytes(&[0x42u8; 32]).expect("valid scalar");
+ let pubkey = secret.public_key();
+ let hash: [u8; 20] = hash160::Hash::hash(&pubkey.to_compressed()).to_byte_array();
let key = IdentityPublicKey::V0(IdentityPublicKeyV0 {
id: 0,
purpose: Purpose::OWNER,
diff --git a/packages/rs-platform-wallet/src/wallet/platform_addresses/fund_from_asset_lock.rs b/packages/rs-platform-wallet/src/wallet/platform_addresses/fund_from_asset_lock.rs
index 63cd36a4a65..bf10c6ef736 100644
--- a/packages/rs-platform-wallet/src/wallet/platform_addresses/fund_from_asset_lock.rs
+++ b/packages/rs-platform-wallet/src/wallet/platform_addresses/fund_from_asset_lock.rs
@@ -921,8 +921,8 @@ mod tests {
_sighash: [u8; 32],
) -> Result<
(
- dashcore::secp256k1::ecdsa::Signature,
- dashcore::secp256k1::PublicKey,
+ dashcore::crypto::ecdsa::EcdsaSignature,
+ dashcore::crypto::ecdsa::EcdsaPublicKey,
),
Self::Error,
> {
@@ -932,7 +932,7 @@ mod tests {
async fn public_key(
&self,
_path: &key_wallet::DerivationPath,
- ) -> Result {
+ ) -> Result {
unreachable!("underfunded fresh asset lock must fail before asset-lock signing")
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/provider_ecdsa_key_tests.rs b/packages/rs-platform-wallet/src/wallet/provider_ecdsa_key_tests.rs
index da78ae53ba3..8a71d843a8d 100644
--- a/packages/rs-platform-wallet/src/wallet/provider_ecdsa_key_tests.rs
+++ b/packages/rs-platform-wallet/src/wallet/provider_ecdsa_key_tests.rs
@@ -116,7 +116,7 @@ async fn private_reveal_is_internally_consistent() {
// WIF and raw scalar must be the same key.
let from_wif = PrivateKey::from_wif(wif).expect("valid WIF");
assert_eq!(
- from_wif.inner.to_secret_bytes().to_vec(),
+ from_wif.inner.to_bytes().to_vec(),
**scalar,
"{kind:?}#{index}: WIF and raw scalar disagree"
);
diff --git a/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs b/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
index 47c3ad04b51..284d8c694ad 100644
--- a/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
+++ b/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
@@ -74,7 +74,7 @@
//! are scrubbed when dropped.
use dashcore::bls_sig_utils::BlsScheme;
-use dashcore::eddsa::{EddsaPkBytes, EddsaPkHash, EddsaSecretKey};
+use dashcore::eddsa::{EddsaPkBytes, EddsaPkHash};
use key_wallet::account::derivation::AccountDerivation;
use key_wallet::account::{AccountType, BLSAccount, EdDSAAccount};
use key_wallet::bip32::{ChildNumber, ExtendedPrivKey};
@@ -156,7 +156,7 @@ pub fn derive_platform_node_public_keys(
"failed to derive Ed25519 platform-node key at index {index}: {e}"
))
})?;
- let public_key: [u8; 32] = EddsaSecretKey::from(&signing_key).public_key().to_bytes();
+ let public_key: [u8; 32] = signing_key.public_key().to_bytes();
// The 20-byte platform node id = SHA256(ed25519 pubkey)[..20] — the
// Tenderdash/CometBFT convention (rust-dashcore #884) that a ProRegTx
// `platform_node_id` field carries, NOT a hash160.
@@ -567,8 +567,7 @@ impl PlatformWallet {
"failed to derive Ed25519 platform-node key at index {index}: {e}"
))
})?;
- let verifying_bytes: [u8; 32] =
- EddsaSecretKey::from(&signing_key).public_key().to_bytes();
+ let verifying_bytes: [u8; 32] = signing_key.public_key().to_bytes();
let public_key_bytes = verifying_bytes.to_vec();
// The 20-byte platform node id = SHA256(ed25519 pubkey)[..20]
@@ -665,7 +664,7 @@ impl PlatformWallet {
"invalid provider key index {index}: {e}"
))
})?;
- let mut child_xpriv = master
+ let child_xpriv = master
.derive_priv(&account_path)
.and_then(|acct| {
let child_path: key_wallet::bip32::DerivationPath =
@@ -677,26 +676,20 @@ impl PlatformWallet {
"failed to derive provider private key at index {index}: {e}"
))
})?;
- let mut private = child_xpriv.to_priv();
+ let private = child_xpriv.to_priv();
let derived_public = private.public_key();
- // Produce every output while the scalar is still live,
- // then erase it. `dashcore::PrivateKey` is `Copy` and
- // has no `Drop`, so unlike the `Zeroizing` outputs below
- // nothing scrubs it on the way out — the raw scalar
- // would otherwise be left behind in this frame. Both
- // copies are erased: the extended key it came from, and
- // the `PrivateKey` itself.
+ // Secret-key owners and exported scalar copies zeroize on drop.
let outputs = if derived_public == public_key {
Some((
- Zeroizing::new(private.inner.to_secret_bytes().to_vec()),
+ Zeroizing::new(private.inner.to_bytes().to_vec()),
Zeroizing::new(private.to_wif()),
))
} else {
None
};
- private.inner.non_secure_erase();
- child_xpriv.private_key.non_secure_erase();
+ drop(private);
+ drop(child_xpriv);
let Some((scalar, wif)) = outputs else {
return Err(PlatformWalletError::KeyDerivation(format!(
@@ -788,7 +781,7 @@ mod tests {
.expect("platform_node_key_at");
assert_eq!(
k.public_key,
- EddsaSecretKey::from(&via_api).public_key().to_bytes(),
+ via_api.public_key().to_bytes(),
"snapshot pubkey must equal platform_node_key_at at {i}"
);
}
@@ -813,7 +806,7 @@ mod tests {
// The snapshot's index-0 public key corresponds to that golden secret.
assert_eq!(
keys[0].public_key,
- EddsaSecretKey::from(&sk0).public_key().to_bytes(),
+ sk0.public_key().to_bytes(),
"snapshot index-0 pubkey must match the golden secret's public key"
);
// Golden pubkey + Tenderdash node-id (SHA256[..20]) for mainnet
@@ -1136,8 +1129,8 @@ mod tests {
let expected = master.derive_priv(&path).expect("path derivation");
assert_eq!(
- derived.inner.to_secret_bytes(),
- expected.private_key.to_secret_bytes(),
+ derived.inner.to_bytes(),
+ expected.private_key.to_bytes(),
"{kind:?} key at index {index} on {network:?} must come from \
m/9'/{coin}/3'/{family}/{index}"
);
@@ -1173,8 +1166,8 @@ mod tests {
.expect("doubled derivation");
assert_ne!(
- derived.inner.to_secret_bytes(),
- doubled.private_key.to_secret_bytes(),
+ derived.inner.to_bytes(),
+ doubled.private_key.to_bytes(),
"the account derivation path is being applied twice again"
);
}
@@ -1245,8 +1238,8 @@ mod tests {
.expect("path derivation");
assert_eq!(
- derived.inner.to_secret_bytes(),
- expected.private_key.to_secret_bytes(),
+ derived.inner.to_bytes(),
+ expected.private_key.to_bytes(),
"{kind:?} watch-only derivation must match m/9'/5'/3'/{family}/19"
);
}
diff --git a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
index a24133f5e28..26d64b47140 100644
--- a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
+++ b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
@@ -44,8 +44,8 @@ fn drain_lock_fixture() -> (TrackedAssetLock, BTreeMap)
let keys = OrchardKeySet::from_seed(&[0x42; 32], Network::Testnet, 0)
.unwrap()
.viewing_keys();
- let secret = dashcore::secp256k1::SecretKey::from_secret_bytes([0x11; 32]).unwrap();
- let public = dashcore::PublicKey::new(dashcore::secp256k1::PublicKey::from_secret_key(&secret));
+ let secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x11; 32]).unwrap();
+ let public = dashcore::PublicKey::new(dpp::secp256k1::PublicKey::from_secret_key(&secret));
let transaction = Transaction {
version: 3,
lock_time: 0,
From cccf3cc48d59a19679bd5d78ed8bd89b0097045f Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:19:04 +0000
Subject: [PATCH 03/21] refactor(ffi): adapt native bindings to typed Core
cryptography
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Preserve compact signing and compressed public-key encodings at the FFI boundary.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
.../src/address_private_key.rs | 2 +-
.../rs-platform-wallet-ffi/src/dashpay.rs | 10 +-
.../rs-platform-wallet-ffi/src/derivation.rs | 4 +-
.../src/derive_connect_key.rs | 3 +-
.../src/derive_identity_key_at_slot.rs | 2 +-
.../src/identity_derive_and_persist.rs | 4 +-
.../src/identity_discovery.rs | 11 +-
.../src/identity_key_preview.rs | 30 +++--
.../src/identity_keys_from_mnemonic.rs | 6 +-
.../src/identity_loading.rs | 11 +-
.../src/identity_registration_with_signer.rs | 4 +-
.../rs-platform-wallet-ffi/src/invitation.rs | 10 +-
.../rs-platform-wallet-ffi/src/persistence.rs | 2 +-
.../src/secp256k1_primitives.rs | 4 +-
.../src/sign_with_mnemonic_resolver.rs | 12 +-
packages/rs-platform-wallet-ffi/src/utils.rs | 8 +-
.../src/address/transitions/transfer.rs | 13 +--
.../src/address/transitions/withdraw.rs | 9 +-
.../transitions/cast_vote.rs | 2 +-
.../src/identity/create_from_addresses.rs | 9 +-
packages/rs-sdk-ffi/src/identity/helpers.rs | 7 +-
.../src/identity/top_up_from_addresses.rs | 10 +-
.../src/mnemonic_resolver_core_signer.rs | 103 +++++++++---------
packages/rs-sdk-ffi/src/signer_simple.rs | 3 +-
packages/rs-unified-sdk-jni/src/tx_decode.rs | 4 +-
25 files changed, 129 insertions(+), 154 deletions(-)
diff --git a/packages/rs-platform-wallet-ffi/src/address_private_key.rs b/packages/rs-platform-wallet-ffi/src/address_private_key.rs
index 31b801db797..aab2c538925 100644
--- a/packages/rs-platform-wallet-ffi/src/address_private_key.rs
+++ b/packages/rs-platform-wallet-ffi/src/address_private_key.rs
@@ -158,7 +158,7 @@ pub unsafe extern "C" fn platform_wallet_address_private_key(
// Wipe the resolved master's inner scalar — `ExtendedPrivKey`
// has no `Drop` / `Zeroize`. No-op on the resident path.
if let Some(mut master) = master_opt {
- master.private_key.non_secure_erase();
+ master.private_key.zeroize();
}
result.map_err(PlatformWalletFFIResult::from)
diff --git a/packages/rs-platform-wallet-ffi/src/dashpay.rs b/packages/rs-platform-wallet-ffi/src/dashpay.rs
index c731c6091ec..94960f1378f 100644
--- a/packages/rs-platform-wallet-ffi/src/dashpay.rs
+++ b/packages/rs-platform-wallet-ffi/src/dashpay.rs
@@ -821,7 +821,7 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dashcore::secp256k1::PublicKey,
+ peer: &dpp::secp256k1::PublicKey,
) -> Result, platform_wallet::PlatformWalletError> {
self.signer
.ecdh_shared_secret(path, peer)
@@ -831,28 +831,28 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider {
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let scalar = self
.signer
.export_auto_accept_private_key(path)
.map_err(|e| {
platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())
})?;
- dashcore::secp256k1::SecretKey::from_secret_bytes(*scalar)
+ dpp::secp256k1::SecretKey::from_secret_bytes(*scalar)
.map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
}
async fn export_invitation_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let scalar = self
.signer
.export_invitation_private_key(path)
.map_err(|e| {
platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())
})?;
- dashcore::secp256k1::SecretKey::from_secret_bytes(*scalar)
+ dpp::secp256k1::SecretKey::from_secret_bytes(*scalar)
.map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
}
diff --git a/packages/rs-platform-wallet-ffi/src/derivation.rs b/packages/rs-platform-wallet-ffi/src/derivation.rs
index 5d30ac8ef6a..b04d8aa426c 100644
--- a/packages/rs-platform-wallet-ffi/src/derivation.rs
+++ b/packages/rs-platform-wallet-ffi/src/derivation.rs
@@ -91,13 +91,13 @@ pub unsafe extern "C" fn platform_wallet_derive_ext_priv_key_from_mnemonic(
let derived = unwrap_result_or_return!(master.derive_priv(&path));
- let secret = Zeroizing::new(derived.private_key.to_secret_bytes());
+ let secret = derived.private_key.to_bytes();
std::ptr::copy_nonoverlapping(secret.as_ptr(), out_secret_key, 32);
std::ptr::copy_nonoverlapping(derived.chain_code.as_ref().as_ptr(), out_chain_code, 32);
if !out_public_key.is_null() {
- let pubkey_bytes = derived.private_key.public_key().serialize();
+ let pubkey_bytes = derived.private_key.public_key().to_compressed();
std::ptr::copy_nonoverlapping(pubkey_bytes.as_ptr(), out_public_key, 33);
}
diff --git a/packages/rs-platform-wallet-ffi/src/derive_connect_key.rs b/packages/rs-platform-wallet-ffi/src/derive_connect_key.rs
index 0e726223610..bc56406d908 100644
--- a/packages/rs-platform-wallet-ffi/src/derive_connect_key.rs
+++ b/packages/rs-platform-wallet-ffi/src/derive_connect_key.rs
@@ -30,6 +30,7 @@ use crate::identity_keys_from_mnemonic::resolve_master_from_resolver;
use crate::types::{read_identifier, FFINetwork, Network};
use crate::{check_ptr, unwrap_result_or_return};
use rs_sdk_ffi::MnemonicResolverHandle;
+use zeroize::Zeroize;
/// `sub_feature` for the DashPay Connect session authentication key. The
/// leaf is the connect request id (`hash256` of the app's ephemeral public
@@ -175,7 +176,7 @@ pub unsafe extern "C" fn dash_sdk_derive_connect_key_with_resolver(
let derived = derive_connect_keypair_from_master(&master, kw_network, key);
// Dropping `master` zeroizes it too; erase now so the scalar does not
// outlive the derive.
- master.private_key.non_secure_erase();
+ master.private_key.zeroize();
let derived = unwrap_result_or_return!(derived);
(*out_key).private_key_bytes = *derived.private_key;
diff --git a/packages/rs-platform-wallet-ffi/src/derive_identity_key_at_slot.rs b/packages/rs-platform-wallet-ffi/src/derive_identity_key_at_slot.rs
index d2d9f0da1ec..b9d5276ccdf 100644
--- a/packages/rs-platform-wallet-ffi/src/derive_identity_key_at_slot.rs
+++ b/packages/rs-platform-wallet-ffi/src/derive_identity_key_at_slot.rs
@@ -81,7 +81,7 @@ unsafe fn derive_at_slot_inner(
let pub_len = pub_box.len();
std::mem::forget(pub_box);
- let secret_key = match dashcore::secp256k1::SecretKey::from_secret_bytes(*derived.private_key) {
+ let secret_key = match dashcore::ecdsa::EcdsaSecretKey::from_bytes(&derived.private_key) {
Ok(k) => k,
Err(e) => {
drop(Box::from_raw(std::ptr::slice_from_raw_parts_mut(
diff --git a/packages/rs-platform-wallet-ffi/src/identity_derive_and_persist.rs b/packages/rs-platform-wallet-ffi/src/identity_derive_and_persist.rs
index 7beb37acde8..e395ca03219 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_derive_and_persist.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_derive_and_persist.rs
@@ -312,12 +312,12 @@ pub unsafe extern "C" fn dash_sdk_derive_and_persist_identity_keys(
// Materialize pubkey + hash160 once.
let extended_pub = ExtendedPubKey::from_priv(&derived);
- let pub_bytes: [u8; 33] = extended_pub.public_key.serialize();
+ let pub_bytes: [u8; 33] = extended_pub.public_key.to_compressed();
let pub_hash: [u8; 20] = dashcore::hashes::hash160::Hash::hash(&pub_bytes).to_byte_array();
// Hold the secret scalar in a buffer that drops with
// `zeroize::Zeroize::zeroize` at scope end.
- let mut priv_scalar: [u8; 32] = derived.private_key.to_secret_bytes();
+ let mut priv_scalar: [u8; 32] = *derived.private_key.to_bytes();
let path_cstring = match CString::new(path.to_string()) {
Ok(s) => s,
diff --git a/packages/rs-platform-wallet-ffi/src/identity_discovery.rs b/packages/rs-platform-wallet-ffi/src/identity_discovery.rs
index d9a34e94794..351c928ebfb 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_discovery.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_discovery.rs
@@ -40,7 +40,7 @@
//! `wallet_id`), build the master `ExtendedPrivKey`, and drive
//! `discover_from_master`. The mnemonic / seed / master scalar all
//! live in `Zeroizing` buffers (the master's `private_key` is
-//! explicitly `non_secure_erase`d — `ExtendedPrivKey` has no `Drop`)
+//! explicitly `zeroize`d — `ExtendedPrivKey` also wipes on `Drop`)
//! and are scrubbed before this function returns. This is the path
//! the iOS app takes. If the resolver is null for such a wallet, the
//! call returns an error hinting that a mnemonic resolver handle is
@@ -63,6 +63,7 @@ use crate::runtime::block_on_worker;
use crate::types::Network;
use crate::{unwrap_option_or_return, unwrap_result_or_return};
use rs_sdk_ffi::MnemonicResolverHandle;
+use zeroize::Zeroize;
/// Heap-allocated array of 32-byte identity ids returned by
/// [`platform_wallet_discover_identities`]. Release by handing the
@@ -219,7 +220,7 @@ pub unsafe extern "C" fn platform_wallet_discover_identities(
// so the discovery and preview paths can't drift; the helper
// holds the mnemonic / seed in `Zeroizing` buffers and scrubs
// them before returning. The master's inner scalar is wiped by
- // us below (`ExtendedPrivKey` has no `Drop`).
+ // us below (`ExtendedPrivKey` also wipes on `Drop`).
let master = match unsafe {
resolve_master_from_resolver(mnemonic_resolver_handle, &wallet_id, network)
} {
@@ -233,9 +234,9 @@ pub unsafe extern "C" fn platform_wallet_discover_identities(
// `master`), so we hand ownership in and wipe it INSIDE the
// future once `discover_from_master` is done deriving.
//
- // `ExtendedPrivKey` has no `Drop` / `Zeroize`, so the inner
+ // `ExtendedPrivKey` also wipes on `Drop` / `Zeroize`, so the inner
// secp256k1 scalar is scrubbed explicitly with
- // `non_secure_erase` — same hygiene as
+ // `zeroize` — same hygiene as
// `dash_sdk_sign_with_mnemonic_resolver_and_path` and
// `mnemonic_resolver_core_signer`. (`seed` / `mnemonic_buf` are
// `Zeroizing` and already scrubbed inside
@@ -243,7 +244,7 @@ pub unsafe extern "C" fn platform_wallet_discover_identities(
block_on_worker(async move {
let mut master = master;
let scan_result = identity.discover_from_master(opts, &master).await;
- master.private_key.non_secure_erase();
+ master.private_key.zeroize();
scan_result
})
.map_err(PlatformWalletFFIResult::from)
diff --git a/packages/rs-platform-wallet-ffi/src/identity_key_preview.rs b/packages/rs-platform-wallet-ffi/src/identity_key_preview.rs
index 837722a5dbd..a1f81582de3 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_key_preview.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_key_preview.rs
@@ -52,7 +52,7 @@
//! [`derive_ecdsa_identity_auth_keypair_from_master`] — the same
//! derive the rescan-via-resolver and the registration paths use.
//! The mnemonic / seed / master scalar live in `Zeroizing` buffers
-//! (the master's `private_key` is explicitly `non_secure_erase`d as
+//! (the master's `private_key` is explicitly `zeroize`d as
//! belt-and-braces — the pinned key-wallet rev zeroizes
//! `ExtendedPrivKey` on `Drop`) and are scrubbed before this
//! function returns. This is the path the iOS app takes. If the
@@ -69,7 +69,7 @@ use key_wallet::bip32::ExtendedPrivKey;
use key_wallet::Wallet;
use platform_wallet::wallet::identity::network::derive_ecdsa_identity_auth_keypair_from_master;
use platform_wallet::{derive_identity_auth_keypair, IDENTITY_GAP_LIMIT, MASTER_KEY_INDEX};
-use zeroize::Zeroizing;
+use zeroize::{Zeroize, Zeroizing};
use crate::error::*;
use crate::handle::*;
@@ -366,15 +366,13 @@ unsafe fn preview_identity_registration_keys_inner(
// WIF: network-aware (mainnet → 0xCC, testnet/devnet/
// regtest → 0xEF) and compressed. Same construction
// `key_wallet::derive_private_key_as_wif` performs.
- let secret_key = dashcore::secp256k1::SecretKey::from_secret_bytes(
- *material.private_key,
- )
- .map_err(|e| {
- PlatformWalletFFIResult::err(
- PlatformWalletFFIResultCode::ErrorWalletOperation,
- format!("SecretKey::from_slice failed: {e}"),
- )
- })?;
+ let secret_key = dashcore::ecdsa::EcdsaSecretKey::from_bytes(&material.private_key)
+ .map_err(|e| {
+ PlatformWalletFFIResult::err(
+ PlatformWalletFFIResultCode::ErrorWalletOperation,
+ format!("SecretKey::from_slice failed: {e}"),
+ )
+ })?;
let dash_private = DashPrivateKey {
compressed: true,
network,
@@ -455,14 +453,14 @@ unsafe fn preview_identity_registration_keys_inner(
identity_index,
key_index,
)?;
- let private_key = Zeroizing::new(ext_priv.private_key.to_secret_bytes());
+ let private_key = ext_priv.private_key.to_bytes();
// Belt-and-braces: the pinned key-wallet rev zeroizes
// `ExtendedPrivKey` on Drop; erase explicitly anyway
// (cheap, and robust to an upstream Drop regression).
- ext_priv.private_key.non_secure_erase();
+ ext_priv.private_key.zeroize();
Ok(RowMaterial {
path: path.to_string(),
- public_key: public_key.serialize(),
+ public_key: public_key.to_compressed(),
private_key,
})
}
@@ -517,7 +515,7 @@ unsafe fn preview_identity_registration_keys_inner(
//
// `master_opt` outlives `source` below (which borrows it),
// and its inner scalar is wiped just before this closure
- // returns — see the `non_secure_erase` at the bottom.
+ // returns — see the `zeroize` at the bottom.
let mut master_opt: Option = None;
if !wallet_has_resident_keys {
if mnemonic_resolver_handle.is_null() {
@@ -616,7 +614,7 @@ unsafe fn preview_identity_registration_keys_inner(
// explicitly. Same hygiene as the discovery resolver path.
// No-op on the resident path (no master was resolved).
if let Some(mut master) = master_opt {
- master.private_key.non_secure_erase();
+ master.private_key.zeroize();
}
loop_result
})();
diff --git a/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs b/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
index fd4c6948d79..748e7aeb30f 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
@@ -77,7 +77,7 @@ pub(crate) fn parse_mnemonic_any_language(phrase: &str) -> Result = pub_bytes.to_vec().into_boxed_slice();
let pub_ptr = pub_box.as_mut_ptr();
let pub_len = pub_box.len();
@@ -402,7 +402,7 @@ pub unsafe extern "C" fn dash_sdk_derive_identity_keys_from_mnemonic(
public_key: pub_ptr,
public_key_len: pub_len,
private_key_wif: wif_cstring.into_raw(),
- private_key_bytes: derived.private_key.to_secret_bytes(),
+ private_key_bytes: *derived.private_key.to_bytes(),
});
}
diff --git a/packages/rs-platform-wallet-ffi/src/identity_loading.rs b/packages/rs-platform-wallet-ffi/src/identity_loading.rs
index bf704dd9e53..1657b5f2865 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_loading.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_loading.rs
@@ -42,7 +42,7 @@
//! `wallet_id`), build the master `ExtendedPrivKey`, and drive
//! `load_identity_by_index_from_master`. The mnemonic / seed / master
//! scalar all live in `Zeroizing` buffers (the master's `private_key`
-//! is explicitly `non_secure_erase`d — `ExtendedPrivKey` has no
+//! is explicitly `zeroize`d — `ExtendedPrivKey` also wipes on
//! `Drop`) and are scrubbed before this function returns. This is the
//! path the iOS app takes. If the resolver is null for such a wallet,
//! the call returns an error hinting that a mnemonic resolver handle
@@ -64,6 +64,7 @@ use crate::runtime::block_on_worker;
use crate::types::Network;
use crate::{unwrap_option_or_return, unwrap_result_or_return};
use rs_sdk_ffi::MnemonicResolverHandle;
+use zeroize::Zeroize;
/// Load the identity registered for this wallet at a single BIP-9 HD
/// identity index by deriving the DIP-9 MASTER authentication key at
@@ -187,7 +188,7 @@ pub unsafe extern "C" fn platform_wallet_load_identity_at_index(
// helper the discovery and preview paths use so they can't drift;
// the helper holds the mnemonic / seed in `Zeroizing` buffers and
// scrubs them before returning. The master's inner scalar is
- // wiped by us below (`ExtendedPrivKey` has no `Drop`).
+ // wiped by us below (`ExtendedPrivKey` also wipes on `Drop`).
let master = match unsafe {
resolve_master_from_resolver(mnemonic_resolver_handle, &wallet_id, network)
} {
@@ -202,9 +203,9 @@ pub unsafe extern "C" fn platform_wallet_load_identity_at_index(
// future once `load_identity_by_index_from_master` is done
// deriving.
//
- // `ExtendedPrivKey` has no `Drop` / `Zeroize`, so the inner
+ // `ExtendedPrivKey` also wipes on `Drop` / `Zeroize`, so the inner
// secp256k1 scalar is scrubbed explicitly with
- // `non_secure_erase` — same hygiene as
+ // `zeroize` — same hygiene as
// `platform_wallet_discover_identities`. (`seed` / `mnemonic_buf`
// are `Zeroizing` and already scrubbed inside
// `resolve_master_from_resolver`.)
@@ -213,7 +214,7 @@ pub unsafe extern "C" fn platform_wallet_load_identity_at_index(
let load_result = identity
.load_identity_by_index_from_master(identity_index, &master)
.await;
- master.private_key.non_secure_erase();
+ master.private_key.zeroize();
load_result
})
.map_err(PlatformWalletFFIResult::from)
diff --git a/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs b/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
index 1840c3be90c..b09ac132013 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
@@ -687,7 +687,7 @@ pub unsafe extern "C" fn platform_wallet_derive_identity_keys_for_index(
}
};
- let pub_bytes: [u8; 33] = public_key.serialize();
+ let pub_bytes: [u8; 33] = public_key.to_compressed();
let mut pub_box: Box<[u8]> = pub_bytes.to_vec().into_boxed_slice();
let pub_ptr = pub_box.as_mut_ptr();
let pub_len = pub_box.len();
@@ -719,7 +719,7 @@ pub unsafe extern "C" fn platform_wallet_derive_identity_keys_for_index(
public_key: pub_ptr,
public_key_len: pub_len,
private_key_wif: wif_cstring.into_raw(),
- private_key_bytes: ext_priv.private_key.to_secret_bytes(),
+ private_key_bytes: *ext_priv.private_key.to_bytes(),
});
}
Ok(rows)
diff --git a/packages/rs-platform-wallet-ffi/src/invitation.rs b/packages/rs-platform-wallet-ffi/src/invitation.rs
index 9c766dfcb68..03d3a1eed18 100644
--- a/packages/rs-platform-wallet-ffi/src/invitation.rs
+++ b/packages/rs-platform-wallet-ffi/src/invitation.rs
@@ -682,8 +682,8 @@ pub unsafe extern "C" fn platform_wallet_parse_invitation(
#[cfg(test)]
mod tests {
use super::*;
- use dashcore::secp256k1::SecretKey;
use dashcore::{Network, PrivateKey};
+ use dpp::secp256k1::SecretKey;
// Marshalling-boundary coverage. The invitation codec and claim semantics
// are pinned library-side in `dash_sdk::platform::dashpay`'s invitation
@@ -854,7 +854,9 @@ mod tests {
#[test]
fn claim_invitation_rejects_duplicate_key_ids_before_wallet_lookup() {
let voucher = SecretKey::from_secret_bytes([0x11u8; 32]).expect("valid scalar");
- let wif = PrivateKey::new(voucher, Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher.to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri =
std::ffi::CString::new(format!("dashpay://invite?assetlocktx=aa&pk={wif}")).unwrap();
@@ -929,7 +931,9 @@ mod tests {
#[test]
fn should_surface_inviter_display_name_and_avatar_in_the_preview() {
let key = SecretKey::from_secret_bytes([0x11u8; 32]).unwrap();
- let wif = PrivateKey::new(key, Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&key.to_secret_bytes(), Network::Testnet)
+ .expect("valid key")
+ .to_wif();
let txid = "ab".repeat(32);
let take = |ptr: *mut c_char| -> Option {
if ptr.is_null() {
diff --git a/packages/rs-platform-wallet-ffi/src/persistence.rs b/packages/rs-platform-wallet-ffi/src/persistence.rs
index 69ef9433a5b..09e06b1fe14 100644
--- a/packages/rs-platform-wallet-ffi/src/persistence.rs
+++ b/packages/rs-platform-wallet-ffi/src/persistence.rs
@@ -5275,7 +5275,7 @@ fn build_address_pools_from_derived(
// `dashcore::PublicKey`; its compressed serialization is the
// 33-byte ECDSA form, left-aligned in the 48-byte slot.
let mut public_key = [0u8; 48];
- public_key[..33].copy_from_slice(&d.public_key.inner.serialize());
+ public_key[..33].copy_from_slice(&d.public_key.inner.to_compressed());
pool_entries.push(CoreAddressEntryFFI {
public_key,
public_key_len: 33,
diff --git a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
index 5615d7b2259..3d65d672fc0 100644
--- a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
+++ b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
@@ -2,8 +2,8 @@
use std::slice;
-use dashcore::secp256k1::ecdh::shared_secret_point;
-use dashcore::secp256k1::{PublicKey, SecretKey};
+use dpp::secp256k1::ecdh::shared_secret_point;
+use dpp::secp256k1::{PublicKey, SecretKey};
use zeroize::Zeroizing;
use crate::error::*;
diff --git a/packages/rs-platform-wallet-ffi/src/sign_with_mnemonic_resolver.rs b/packages/rs-platform-wallet-ffi/src/sign_with_mnemonic_resolver.rs
index c2ea005a996..d0c5e4d42ec 100644
--- a/packages/rs-platform-wallet-ffi/src/sign_with_mnemonic_resolver.rs
+++ b/packages/rs-platform-wallet-ffi/src/sign_with_mnemonic_resolver.rs
@@ -277,7 +277,7 @@ pub unsafe extern "C" fn dash_sdk_sign_with_mnemonic_resolver_and_path(
Ok(d) => d,
Err(_) => return fail(SIGN_WITH_RESOLVER_ERR_DERIVATION),
};
- let secret_bytes: Zeroizing<[u8; 32]> = Zeroizing::new(derived.private_key.to_secret_bytes());
+ let secret_bytes: Zeroizing<[u8; 32]> = derived.private_key.to_bytes();
// ---- Bind the derived key to the expected on-chain key -------------------
// Reject before signing if the key derived here doesn't reproduce the
@@ -290,7 +290,7 @@ pub unsafe extern "C" fn dash_sdk_sign_with_mnemonic_resolver_and_path(
if !expected_key_data.is_null() && expected_key_data_len > 0 {
let derived_pubkey = key_wallet::bip32::ExtendedPubKey::from_priv(&derived)
.public_key
- .serialize();
+ .to_compressed();
// Build the expected slice only for the two lengths the binding
// policy accepts (33 or 20), never from the caller-supplied
// `expected_key_data_len` directly: a malformed huge length must not
@@ -496,7 +496,9 @@ mod tests {
let derived = master
.derive_priv(&DerivationPath::from_str(path_str).unwrap())
.expect("derive");
- let expected_pubkey = ExtendedPubKey::from_priv(&derived).public_key.serialize();
+ let expected_pubkey = ExtendedPubKey::from_priv(&derived)
+ .public_key
+ .to_compressed();
let mut sig_buf = [0u8; 128];
let mut sig_len: usize = 0;
@@ -589,7 +591,9 @@ mod tests {
let derived = master
.derive_priv(&DerivationPath::from_str(path_str).unwrap())
.expect("derive");
- let pubkey = ExtendedPubKey::from_priv(&derived).public_key.serialize();
+ let pubkey = ExtendedPubKey::from_priv(&derived)
+ .public_key
+ .to_compressed();
let expected_hash = dash_sdk::dpp::util::hash::ripemd160_sha256(&pubkey);
let mut sig_buf = [0u8; 128];
diff --git a/packages/rs-platform-wallet-ffi/src/utils.rs b/packages/rs-platform-wallet-ffi/src/utils.rs
index 770ae09777c..b844a07f3e5 100644
--- a/packages/rs-platform-wallet-ffi/src/utils.rs
+++ b/packages/rs-platform-wallet-ffi/src/utils.rs
@@ -7,7 +7,7 @@ use std::os::raw::{c_char, c_uchar};
/// has no `Drop` wipe of its own — so without this the copy would survive on the
/// stack after the call returns. Mirrors `WipingSecretKey` in
/// `rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs`.
-struct WipingSecretKey(dashcore::secp256k1::SecretKey);
+struct WipingSecretKey(dpp::secp256k1::SecretKey);
impl Drop for WipingSecretKey {
fn drop(&mut self) {
@@ -202,7 +202,7 @@ pub unsafe extern "C" fn platform_wallet_pubkey_hash_from_private_key(
return -1;
}
use dashcore::hashes::Hash;
- use dashcore::secp256k1::{PublicKey, SecretKey};
+ use dpp::secp256k1::{PublicKey, SecretKey};
let sk_bytes = std::slice::from_raw_parts(private_key, 32);
// `WipingSecretKey` scrubs the `from_secret_bytes`-allocated scalar copy on every
@@ -210,7 +210,7 @@ pub unsafe extern "C" fn platform_wallet_pubkey_hash_from_private_key(
// panic) — the caller's `private_key` bytes are theirs to manage, but this
// copy must not linger.
let secret_key = match <[u8; 32]>::try_from(sk_bytes)
- .map_err(|_| dashcore::secp256k1::Error::InvalidSecretKey)
+ .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey)
.and_then(SecretKey::from_secret_bytes)
{
Ok(sk) => WipingSecretKey(sk),
@@ -265,7 +265,7 @@ mod tests {
#[test]
fn test_pubkey_hash_from_private_key_matches_canonical_derivation() {
use dashcore::hashes::Hash;
- use dashcore::secp256k1::{PublicKey, SecretKey};
+ use dpp::secp256k1::{PublicKey, SecretKey};
// A fixed, in-range scalar.
let mut scalar = [0u8; 32];
diff --git a/packages/rs-sdk-ffi/src/address/transitions/transfer.rs b/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
index a3ef56455f6..304285a93d8 100644
--- a/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
+++ b/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
@@ -5,7 +5,6 @@
use dash_sdk::dpp::address_funds::{
AddressFundsFeeStrategy, AddressFundsFeeStrategyStep, AddressWitness, PlatformAddress,
};
-use dash_sdk::dpp::dashcore::secp256k1::SecretKey;
use dash_sdk::dpp::dashcore::{Network, PrivateKey};
use dash_sdk::dpp::fee::Credits;
use dash_sdk::dpp::identity::signer::Signer;
@@ -60,7 +59,7 @@ impl Signer for AddressSigner {
// Sign the data using dashcore signer
let signature =
- dash_sdk::dpp::dashcore::signer::sign(data, private_key.inner.as_secret_bytes())
+ dash_sdk::dpp::dashcore::signer::sign(data, private_key.inner.to_bytes().as_ref())
.map_err(|e| ProtocolError::Generic(format!("Signing failed: {}", e)))?;
Ok(BinaryData::new(signature.to_vec()))
@@ -85,7 +84,7 @@ impl Signer for AddressSigner {
// Sign the data
let signature =
- dash_sdk::dpp::dashcore::signer::sign(data, private_key.inner.as_secret_bytes())
+ dash_sdk::dpp::dashcore::signer::sign(data, private_key.inner.to_bytes().as_ref())
.map_err(|e| ProtocolError::Generic(format!("Signing failed: {}", e)))?;
// Create P2PKH witness (most common for single key)
@@ -238,10 +237,7 @@ unsafe fn dash_sdk_address_transfer_funds_inner(
// Parse private key (32 bytes)
let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let secret_key = match <[u8; 32]>::try_from(pk_bytes)
- .map_err(|_| dash_sdk::dpp::dashcore::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
+ let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
@@ -251,9 +247,6 @@ unsafe fn dash_sdk_address_transfer_funds_inner(
}
};
- // Create PrivateKey (network doesn't matter for signing)
- let private_key = PrivateKey::new(secret_key, Network::Testnet);
-
signer.add_key(&address, private_key);
input_map.insert(address, input.amount);
}
diff --git a/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs b/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
index db685b4bf0b..d451b8553bf 100644
--- a/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
+++ b/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
@@ -6,7 +6,6 @@ use dash_sdk::dpp::address_funds::{
AddressFundsFeeStrategy, AddressFundsFeeStrategyStep, PlatformAddress,
};
use dash_sdk::dpp::dashcore::address::NetworkUnchecked;
-use dash_sdk::dpp::dashcore::secp256k1::SecretKey;
use dash_sdk::dpp::dashcore::PrivateKey;
use dash_sdk::dpp::dashcore::{Address, Network};
use dash_sdk::dpp::fee::Credits;
@@ -210,10 +209,7 @@ unsafe fn dash_sdk_address_withdraw_funds_inner(
// Parse private key (32 bytes)
let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let secret_key = match <[u8; 32]>::try_from(pk_bytes)
- .map_err(|_| dash_sdk::dpp::dashcore::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
+ let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
@@ -223,9 +219,6 @@ unsafe fn dash_sdk_address_withdraw_funds_inner(
}
};
- // Create PrivateKey (network doesn't matter for signing)
- let private_key = PrivateKey::new(secret_key, Network::Testnet);
-
signer.add_key(&address, private_key);
input_map.insert(address, input.amount);
}
diff --git a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
index 2451b3ce171..6d969b6a2fc 100644
--- a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
+++ b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
@@ -61,9 +61,9 @@ use crate::sdk::SDKWrapper;
use crate::types::{FFINetwork, Network, SDKHandle};
use crate::{DashSDKResult, FFIError};
use dash_sdk::dpp::dashcore::hashes::{hash160, Hash};
-use dash_sdk::dpp::dashcore::secp256k1::{PublicKey, SecretKey};
use dash_sdk::dpp::dashcore::ProTxHash;
use dash_sdk::dpp::platform_value::{Identifier, Value};
+use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice;
use dash_sdk::dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll;
use dash_sdk::dpp::voting::vote_polls::VotePoll;
diff --git a/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs b/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
index cc32e028811..65c118c5ecc 100644
--- a/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
+++ b/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
@@ -1,7 +1,6 @@
//! Identity creation from addresses operations
use dash_sdk::dpp::address_funds::PlatformAddress;
-use dash_sdk::dpp::dashcore::secp256k1::SecretKey;
use dash_sdk::dpp::dashcore::{Network, PrivateKey};
use dash_sdk::dpp::fee::Credits;
use dash_sdk::dpp::identity::Identity;
@@ -170,10 +169,7 @@ unsafe fn dash_sdk_identity_create_from_addresses_inner(
// Parse private key (32 bytes)
let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let secret_key = match <[u8; 32]>::try_from(pk_bytes)
- .map_err(|_| dash_sdk::dpp::dashcore::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
+ let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
@@ -183,9 +179,6 @@ unsafe fn dash_sdk_identity_create_from_addresses_inner(
}
};
- // Create PrivateKey (network doesn't matter for signing)
- let private_key = PrivateKey::new(secret_key, Network::Testnet);
-
address_signer.add_key(&address, private_key);
// Use nonce from input, or fetch if 0
let nonce = if input.nonce == 0 {
diff --git a/packages/rs-sdk-ffi/src/identity/helpers.rs b/packages/rs-sdk-ffi/src/identity/helpers.rs
index bb10745d4d0..de1442a4bd3 100644
--- a/packages/rs-sdk-ffi/src/identity/helpers.rs
+++ b/packages/rs-sdk-ffi/src/identity/helpers.rs
@@ -1,6 +1,6 @@
//! Helper functions for identity operations
-use dash_sdk::dpp::dashcore::{self, Network, PrivateKey};
+use dash_sdk::dpp::dashcore::{Network, PrivateKey};
use dash_sdk::dpp::prelude::{AssetLockProof, UserFeeIncrease};
use dash_sdk::dpp::state_transition::batch_transition::methods::StateTransitionCreationOptions;
use dash_sdk::dpp::state_transition::StateTransitionSigningOptions;
@@ -89,9 +89,8 @@ pub unsafe fn parse_private_key(
private_key_bytes: *const [u8; 32],
) -> Result {
let key_bytes = *private_key_bytes;
- let secret_key = dashcore::secp256k1::SecretKey::from_secret_bytes(key_bytes)
- .map_err(|e| FFIError::InternalError(format!("Invalid private key: {}", e)))?;
- Ok(PrivateKey::new(secret_key, Network::Mainnet))
+ PrivateKey::from_byte_array(&key_bytes, Network::Mainnet)
+ .map_err(|e| FFIError::InternalError(format!("Invalid private key: {}", e)))
}
/// Helper function to create instant asset lock proof from components
diff --git a/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs b/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
index 9cc74ccd280..2922a5635be 100644
--- a/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
+++ b/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
@@ -1,7 +1,6 @@
//! Identity top-up from addresses operations
use dash_sdk::dpp::address_funds::PlatformAddress;
-use dash_sdk::dpp::dashcore::secp256k1::SecretKey;
use dash_sdk::dpp::dashcore::PrivateKey;
use dash_sdk::dpp::fee::Credits;
use dash_sdk::dpp::prelude::Identity;
@@ -151,10 +150,7 @@ unsafe fn dash_sdk_identity_top_up_from_addresses_inner(
// Parse private key (32 bytes)
let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let secret_key = match <[u8; 32]>::try_from(pk_bytes)
- .map_err(|_| dash_sdk::dpp::dashcore::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
+ let private_key = match PrivateKey::from_slice(pk_bytes, wrapper.sdk.network) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
@@ -164,10 +160,6 @@ unsafe fn dash_sdk_identity_top_up_from_addresses_inner(
}
};
- // Create PrivateKey (network doesn't matter for signing — `PrivateKey`
- // only carries it through to WIF encoding, which we never invoke here).
- let private_key = PrivateKey::new(secret_key, wrapper.sdk.network);
-
signer.add_key(&address, private_key);
input_map.insert(address, input.amount);
}
diff --git a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
index c4be3c24dc6..17f895bee1f 100644
--- a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
+++ b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
@@ -50,14 +50,8 @@
//! - **`Zeroizing` wrappers** scrub the plain byte buffers that carry
//! no `Drop` of their own: the resolver mnemonic buffer, the BIP-39
//! seed, and the final derived 32-byte scalar.
-//! - **The `WipingSecretKey` RAII guard** scrubs the raw
-//! [`secp256k1::SecretKey`] copies at the two sign sites, where the
-//! scalar comes back out of `SecretKey::from_secret_bytes`. `SecretKey` is an
-//! upstream secp256k1 type with no `Zeroize` impl (only
-//! `non_secure_erase()`), so it can't ride a `Zeroizing` wrapper; the
-//! guard wipes it on every exit path — normal return, `?`-early-return,
-//! and panic-unwind — closing the one leak window a bare inline erase
-//! would leave open between construction and the scrub.
+//! - **Typed ECDSA secret keys** scrub signing copies on drop. The
+//! `WipingSecretKey` guard scrubs the raw secp256k1 copy used for ECDH.
//!
//! Combined, no private key bytes survive past the trait-method
//! boundary.
@@ -66,8 +60,9 @@ use std::ffi::c_void;
use std::os::raw::c_char;
use async_trait::async_trait;
+use dash_sdk::dpp::secp256k1;
use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
-use key_wallet::dashcore::secp256k1;
+use key_wallet::dashcore::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaSecretKey, EcdsaSignature};
use key_wallet::dip9::{
DASHPAY_CONTACT_INFO_ENC_TO_USER_ID_CHILD, DASHPAY_CONTACT_INFO_PRIVATE_DATA_CHILD,
FEATURE_PURPOSE, FEATURE_PURPOSE_DASHPAY_AUTO_ACCEPT, FEATURE_PURPOSE_IDENTITIES,
@@ -167,6 +162,10 @@ pub enum MnemonicResolverSignerError {
/// error.
#[error("invalid private key scalar: {0}")]
InvalidScalar(String),
+
+ /// Decoding the generated recoverable signature failed.
+ #[error("ECDSA signature conversion failed: {0}")]
+ SignatureConversion(#[source] EcdsaError),
}
/// `key_wallet::signer::Signer` implementation that derives ECDSA
@@ -349,11 +348,9 @@ impl MnemonicResolverCoreSigner {
&self,
path: &DerivationPath,
) -> Result, MnemonicResolverSignerError> {
- // `to_secret_bytes()` copies the scalar out of the borrowed key; the
+ // `to_bytes()` copies the scalar out of the borrowed key; the
// `ExtendedPrivKey` itself never leaves `resolve_and_derive`.
- self.resolve_and_derive(path, |derived| {
- Zeroizing::new(derived.private_key.to_secret_bytes())
- })
+ self.resolve_and_derive(path, |derived| derived.private_key.to_bytes())
}
/// Export the raw auto-accept private scalar at `path` (DIP-15 QR
@@ -453,9 +450,11 @@ impl MnemonicResolverCoreSigner {
// Read the scalar by reference inside the closure; the borrowed
// `ExtendedPrivKey` self-wipes on `Drop` when `resolve_and_derive`
// returns. Only the ECDH product crosses the boundary.
- let shared = self.resolve_and_derive(path, |derived| {
- platform_encryption::derive_shared_key_ecdh(&derived.private_key, peer_pubkey)
- })?;
+ let secret = WipingSecretKey(
+ secp256k1::SecretKey::from_secret_bytes(*self.derive_priv(path)?)
+ .map_err(|e| MnemonicResolverSignerError::InvalidScalar(e.to_string()))?,
+ );
+ let shared = platform_encryption::derive_shared_key_ecdh(&secret.0, peer_pubkey);
Ok(Zeroizing::new(shared))
}
@@ -602,15 +601,7 @@ pub struct ContactInfoOpened {
pub private_data: Vec,
}
-/// RAII guard that wipes a [`secp256k1::SecretKey`]'s scalar on `Drop`.
-///
-/// `SecretKey` is an upstream secp256k1 type with no `Zeroize` impl (only
-/// `non_secure_erase()`), so it can't ride a `Zeroizing` wrapper. Wrapping the
-/// `SecretKey::from_secret_bytes` copy here wipes it on every exit path — normal
-/// return, `?`-early-return, and panic-unwind — closing the leak window a bare
-/// inline `non_secure_erase()` would leave open between construction and the
-/// manual scrub. This is the one key intermediate that upstream key-wallet's
-/// `Zeroize`/`Drop` on `ExtendedPrivKey` cannot cover.
+/// Scrubs the raw secp256k1 scalar copy used by ECDH on every exit path.
struct WipingSecretKey(secp256k1::SecretKey);
impl Drop for WipingSecretKey {
@@ -634,32 +625,23 @@ impl Signer for MnemonicResolverCoreSigner {
&self,
path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(secp256k1::ecdsa::Signature, secp256k1::PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> {
let secret_bytes = self.derive_priv(path)?;
- // `SecretKey::from_secret_bytes` validates the 32-byte scalar is a
- // legitimate field element. The `WipingSecretKey` guard scrubs this
- // separate copy on every exit path, including a panic between here and
- // the return — `Zeroizing<[u8;32]>` already covers `secret_bytes`.
- let secret = WipingSecretKey(
- secp256k1::SecretKey::from_secret_bytes(*secret_bytes)
- .map_err(|e| MnemonicResolverSignerError::InvalidScalar(e.to_string()))?,
- );
- let msg = secp256k1::Message::from_digest(sighash);
- let signature = secret.0.sign_ecdsa(msg);
- let pubkey = secp256k1::PublicKey::from_secret_key(&secret.0);
- Ok((signature, pubkey))
+ let secret = EcdsaSecretKey::from_bytes(&secret_bytes)
+ .map_err(|e| MnemonicResolverSignerError::InvalidScalar(e.to_string()))?;
+ // Recoverable signing preserves the non-grinding deterministic signature.
+ let signature = secret
+ .sign_recoverable(&sighash)
+ .signature()
+ .map_err(MnemonicResolverSignerError::SignatureConversion)?;
+ Ok((signature, secret.public_key()))
}
- async fn public_key(&self, path: &DerivationPath) -> Result {
+ async fn public_key(&self, path: &DerivationPath) -> Result {
let secret_bytes = self.derive_priv(path)?;
- // `WipingSecretKey` scrubs this `from_secret_bytes` copy on every exit path,
- // including panic-unwind — `Zeroizing<[u8;32]>` covers `secret_bytes`.
- let secret = WipingSecretKey(
- secp256k1::SecretKey::from_secret_bytes(*secret_bytes)
- .map_err(|e| MnemonicResolverSignerError::InvalidScalar(e.to_string()))?,
- );
- let pubkey = secp256k1::PublicKey::from_secret_key(&secret.0);
- Ok(pubkey)
+ let secret = EcdsaSecretKey::from_bytes(&secret_bytes)
+ .map_err(|e| MnemonicResolverSignerError::InvalidScalar(e.to_string()))?;
+ Ok(secret.public_key())
}
}
@@ -746,10 +728,21 @@ mod tests {
.await
.expect("signing succeeds");
- let msg = secp256k1::Message::from_digest(sighash);
- sig.verify(msg, &pk)
+ pk.verify(&sighash, sig)
.expect("signature must verify against returned pubkey");
+ let secret = WipingSecretKey(
+ secp256k1::SecretKey::from_secret_bytes(
+ *signer.derive_priv(&test_path()).expect("derived scalar"),
+ )
+ .expect("valid scalar"),
+ );
+ let expected = secret
+ .0
+ .sign_ecdsa(secp256k1::Message::from_digest(sighash));
+ assert_eq!(sig.to_bytes(), expected.serialize_compact());
+ assert_eq!(pk.to_compressed(), secret.0.public_key().serialize());
+
unsafe { dash_sdk_mnemonic_resolver_destroy(resolver) };
}
@@ -1013,7 +1006,11 @@ mod tests {
let xprv = wallet
.derive_extended_private_key(&path)
.expect("wallet derives the private key at path");
- let expected = platform_encryption::derive_shared_key_ecdh(&xprv.private_key, &peer_pk);
+ let expected = platform_encryption::derive_shared_key_ecdh(
+ &secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ .expect("derived scalar"),
+ &peer_pk,
+ );
// New route: resolver-backed signer fed the same mnemonic.
let resolver = make_resolver(english_resolve);
@@ -1066,7 +1063,7 @@ mod tests {
.derive_extended_private_key(&path)
.expect("wallet derives the private key at path")
.private_key
- .to_secret_bytes();
+ .to_bytes();
let expected = platform_encryption::calculate_account_reference(
&secret,
&compact_xpub,
@@ -1149,7 +1146,7 @@ mod tests {
let wallet =
Wallet::from_seed_bytes(seed, Network::Testnet, WalletAccountCreationOptions::None)
.expect("seeded wallet");
- let enc_key: [u8; 32] = {
+ let enc_key: Zeroizing<[u8; 32]> = {
let path = root_path.clone().extend([
ChildNumber::from_hardened_idx(65536).unwrap(),
ChildNumber::from_hardened_idx(derivation_index).unwrap(),
@@ -1158,7 +1155,7 @@ mod tests {
.derive_extended_private_key(&path)
.expect("derive encToUserId key")
.private_key
- .to_secret_bytes()
+ .to_bytes()
};
let expected_enc = platform_encryption::encrypt_enc_to_user_id(&enc_key, &contact_id);
assert_eq!(
diff --git a/packages/rs-sdk-ffi/src/signer_simple.rs b/packages/rs-sdk-ffi/src/signer_simple.rs
index 3ad020582d8..69538a103fb 100644
--- a/packages/rs-sdk-ffi/src/signer_simple.rs
+++ b/packages/rs-sdk-ffi/src/signer_simple.rs
@@ -403,8 +403,7 @@ pub unsafe extern "C" fn dash_sdk_sign_with_mnemonic_and_path(
// which has no `Drop` of its own — is scrubbed when the function
// returns. `derived` self-wipes separately: `ExtendedPrivKey`
// zeroizes on `Drop`.
- let secret_bytes: zeroize::Zeroizing<[u8; 32]> =
- zeroize::Zeroizing::new(derived.private_key.to_secret_bytes());
+ let secret_bytes: zeroize::Zeroizing<[u8; 32]> = derived.private_key.to_bytes();
// ---- Sign ---------------------------------------------------------------
// `dashcore::signer::sign` returns a 65-byte compact recoverable
diff --git a/packages/rs-unified-sdk-jni/src/tx_decode.rs b/packages/rs-unified-sdk-jni/src/tx_decode.rs
index f5b5772e440..c69382e7619 100644
--- a/packages/rs-unified-sdk-jni/src/tx_decode.rs
+++ b/packages/rs-unified-sdk-jni/src/tx_decode.rs
@@ -209,8 +209,8 @@ mod tests {
use super::*;
use dashcore::consensus::serialize;
+ use dashcore::ecdsa::EcdsaSecretKey;
use dashcore::hashes::Hash;
- use dashcore::secp256k1::SecretKey;
use dashcore::{
Address, Network, OutPoint, PublicKey, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness,
};
@@ -247,7 +247,7 @@ mod tests {
}
fn test_pubkey() -> PublicKey {
- let sk = SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid secret key");
+ let sk = EcdsaSecretKey::from_bytes(&[0x42u8; 32]).expect("valid secret key");
PublicKey::new(sk.public_key())
}
From 069207d4348203c9b79d2a2a060fa0f8184c82c1 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:21:23 +0000
Subject: [PATCH 04/21] test(ffi): pin signer bytes across deterministic
digests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Exercise multiple digests to detect accidental low-R signature grinding.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
.../src/mnemonic_resolver_core_signer.rs | 28 +++++++++----------
1 file changed, 14 insertions(+), 14 deletions(-)
diff --git a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
index 17f895bee1f..038a089f814 100644
--- a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
+++ b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
@@ -722,26 +722,26 @@ mod tests {
let signer =
unsafe { MnemonicResolverCoreSigner::new(resolver, [0u8; 32], Network::Testnet) };
- let sighash = [0x42u8; 32];
- let (sig, pk) = signer
- .sign_ecdsa(&test_path(), sighash)
- .await
- .expect("signing succeeds");
-
- pk.verify(&sighash, sig)
- .expect("signature must verify against returned pubkey");
-
let secret = WipingSecretKey(
secp256k1::SecretKey::from_secret_bytes(
*signer.derive_priv(&test_path()).expect("derived scalar"),
)
.expect("valid scalar"),
);
- let expected = secret
- .0
- .sign_ecdsa(secp256k1::Message::from_digest(sighash));
- assert_eq!(sig.to_bytes(), expected.serialize_compact());
- assert_eq!(pk.to_compressed(), secret.0.public_key().serialize());
+ for byte in 0..32 {
+ let sighash = [byte; 32];
+ let (sig, pk) = signer
+ .sign_ecdsa(&test_path(), sighash)
+ .await
+ .expect("signing succeeds");
+ pk.verify(&sighash, sig)
+ .expect("signature must verify against returned pubkey");
+ let expected = secret
+ .0
+ .sign_ecdsa(secp256k1::Message::from_digest(sighash));
+ assert_eq!(sig.to_bytes(), expected.serialize_compact());
+ assert_eq!(pk.to_compressed(), secret.0.public_key().serialize());
+ }
unsafe { dash_sdk_mnemonic_resolver_destroy(resolver) };
}
From f17cfde7c50e3f4db58147b4ce978e3e378e0dea Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:24:19 +0000
Subject: [PATCH 05/21] refactor!: migrate Platform consumers to typed Core
cryptography
Preserve consensus ECDSA parsing, verification and error strings through DPP-owned validation using the unchanged secp256k1 backend. Adapt SDK and binding key ownership and add historical signature and malformed-input regressions.
Co-Authored-By: Claudius the Magnificent
---
.../src/address_funds/platform_address.rs | 37 ++-
.../identity/identity_public_key/key_type.rs | 58 +++--
.../identity_public_key/v0/methods/mod.rs | 15 +-
.../v0/mod.rs | 14 +-
packages/rs-dpp/src/signing.rs | 2 +-
packages/rs-dpp/src/state_transition/mod.rs | 39 +--
.../signing_tests.rs | 13 +-
.../signing_tests.rs | 2 +-
.../signing_tests.rs | 11 +-
.../state_transition_identity_signed.rs | 12 +-
.../instant_asset_lock_proof_fixture.rs | 12 +-
packages/rs-dpp/src/util/ecdsa.rs | 88 +++++++
packages/rs-dpp/src/util/mod.rs | 1 +
packages/rs-dpp/tests/ecdsa_compatibility.rs | 232 ++++++++++++++++++
.../generate_wasm_contract_cache_vectors.rs | 3 +-
...rate_wasm_state_transition_wait_vectors.rs | 3 +-
.../src/execution/check_tx/v0/mod.rs | 4 +-
.../transform_into_action/v0/mod.rs | 3 +-
.../identity_create/state/v0/mod.rs | 3 +-
.../identity_create_from_addresses/tests.rs | 20 +-
.../transform_into_action/v0/mod.rs | 3 +-
.../state_transitions/identity_update/mod.rs | 4 +-
.../shield_from_asset_lock/tests.rs | 2 +-
.../transform_into_action/v0/mod.rs | 3 +-
.../transform_into_action/v1/mod.rs | 3 +-
.../state_transitions/test_helpers.rs | 2 +-
.../tests/strategy_tests/strategy.rs | 12 +-
.../rs-scripts/src/bin/register_identity.rs | 8 +-
.../src/platform/dashpay/contact_request.rs | 10 +-
.../rs-sdk/src/platform/dashpay/invitation.rs | 101 ++++----
.../rs-sdk/src/platform/dashpay/profile.rs | 4 +-
.../rs-sdk/src/platform/dpns_usernames/mod.rs | 4 +-
packages/rs-sdk/src/platform/encrypted_for.rs | 6 +-
.../platform/moderation_charters/requests.rs | 8 +-
.../platform/transition/broadcast_identity.rs | 2 +-
.../src/platform/transition/put_document.rs | 4 +-
.../src/platform/transition/top_up_address.rs | 2 +-
.../platform/transition/top_up_identity.rs | 2 +-
packages/simple-signer/src/signer.rs | 8 +-
.../simple-signer/src/single_key_signer.rs | 37 +--
packages/strategy-tests/src/lib.rs | 4 +-
packages/strategy-tests/src/transitions.rs | 5 +-
.../generate_temporary_ecdsa_private_key.rs | 9 +-
packages/wasm-dpp2/src/public_key.rs | 18 +-
packages/wasm-sdk/src/encrypted_for.rs | 2 +-
.../state_transitions/contract/cache_tests.rs | 3 +-
packages/wasm-sdk/src/wallet/dip14.rs | 25 +-
.../src/wallet/extended_derivation.rs | 4 +-
.../wasm-sdk/src/wallet/key_derivation.rs | 6 +-
.../wasm-sdk/src/wallet/key_generation.rs | 11 +-
50 files changed, 611 insertions(+), 273 deletions(-)
create mode 100644 packages/rs-dpp/src/util/ecdsa.rs
create mode 100644 packages/rs-dpp/tests/ecdsa_compatibility.rs
diff --git a/packages/rs-dpp/src/address_funds/platform_address.rs b/packages/rs-dpp/src/address_funds/platform_address.rs
index 3b98a513002..715bce40668 100644
--- a/packages/rs-dpp/src/address_funds/platform_address.rs
+++ b/packages/rs-dpp/src/address_funds/platform_address.rs
@@ -5,18 +5,18 @@ use crate::prelude::AddressNonce;
use crate::serialization::JsonConvertible;
#[cfg(all(feature = "value-conversion", feature = "serde-conversion"))]
use crate::serialization::ValueConvertible;
+use crate::util::ecdsa;
use crate::ProtocolError;
use bech32::{Bech32m, Hrp};
use bincode::{Decode, DecodeUntrusted, Encode};
use dashcore::address::Payload;
use dashcore::blockdata::script::ScriptBuf;
use dashcore::hashes::{sha256d, Hash};
-use dashcore::secp256k1::Message;
-use dashcore::sign_message::MessageSignature;
-use dashcore::{Address, Network, PrivateKey, PubkeyHash, PublicKey, ScriptHash};
+use dashcore::{Address, Network, PrivateKey, PubkeyHash, ScriptHash};
use platform_serialization_derive::{
PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize,
};
+use secp256k1::Message;
#[cfg(feature = "serde-conversion")]
use serde::{Deserialize, Serialize};
use std::convert::TryFrom;
@@ -491,17 +491,13 @@ impl PlatformAddress {
// This saves 33 bytes per witness (no need to include pubkey)
// at a ~4% CPU cost increase (recovery vs verify).
let data_hash = dashcore::signer::double_sha(signable_bytes);
- dashcore::signer::verify_hash_signature(
- &data_hash,
- signature.as_slice(),
- pubkey_hash,
- )
- .map_err(|e| {
- ProtocolError::AddressWitnessError(format!(
- "P2PKH signature verification failed: {}",
- e
- ))
- })?;
+ ecdsa::verify_hash_signature(&data_hash, signature.as_slice(), pubkey_hash)
+ .map_err(|e| {
+ ProtocolError::AddressWitnessError(format!(
+ "P2PKH signature verification failed: {}",
+ e
+ ))
+ })?;
Ok(AddressWitnessVerificationOperations::for_p2pkh(
signable_bytes.len(),
@@ -556,8 +552,7 @@ impl PlatformAddress {
while sig_idx < valid_signatures.len() && pubkey_idx < pubkeys.len() {
signature_verifications += 1;
- let sig = MessageSignature::from_slice(valid_signatures[sig_idx].as_slice())
- .map(|message_signature| message_signature.signature)
+ let sig = ecdsa::parse_compact_signature(valid_signatures[sig_idx].as_slice())
.map_err(|e| {
ProtocolError::AddressWitnessError(format!(
"Invalid signature format: {}",
@@ -565,11 +560,11 @@ impl PlatformAddress {
))
})?;
- let pub_key = PublicKey::from_slice(&pubkeys[pubkey_idx]).map_err(|e| {
+ let pub_key = ecdsa::parse_public_key(&pubkeys[pubkey_idx]).map_err(|e| {
ProtocolError::AddressWitnessError(format!("Invalid public key: {}", e))
})?;
- if sig.to_standard().verify(msg, &pub_key.inner).is_ok() {
+ if sig.to_standard().verify(msg, &pub_key).is_ok() {
matched += 1;
sig_idx += 1;
}
@@ -790,9 +785,9 @@ mod tests {
use super::*;
use dashcore::blockdata::opcodes::all::*;
use dashcore::hashes::Hash;
- use dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dashcore::PublicKey;
use platform_value::BinaryData;
+ use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
/// All non-mainnet networks share the `tdash` HRP (DIP-0018), so an address parsed from a
/// bech32m string can only ever report Mainnet or Testnet — never Devnet/Regtest. Network
@@ -857,7 +852,9 @@ mod tests {
let (secret_key, public_key) = create_keypair(seed);
// Create PrivateKey from the secret key
- let private_key = PrivateKey::new(secret_key, Network::Testnet);
+ let private_key =
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Testnet)
+ .expect("valid test secret key");
// Derive address using From<&PrivateKey>
let address_from_private = PlatformAddress::from(&private_key);
diff --git a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
index 260fc6b3a9d..02df74d6347 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
@@ -3,13 +3,13 @@ use anyhow::bail;
use bincode::{Decode, DecodeUntrusted, Encode};
#[cfg(feature = "cbor")]
use ciborium::value::Value as CborValue;
-#[cfg(feature = "random-public-keys")]
-use dashcore::secp256k1::rand::rngs::StdRng as EcdsaRng;
-#[cfg(feature = "random-public-keys")]
-use dashcore::secp256k1::rand::SeedableRng;
use dashcore::Network;
use itertools::Itertools;
use lazy_static::lazy_static;
+#[cfg(feature = "random-public-keys")]
+use secp256k1::rand::rngs::StdRng as EcdsaRng;
+#[cfg(feature = "random-public-keys")]
+use secp256k1::rand::SeedableRng;
#[cfg(feature = "bls-signatures")]
use crate::bls::{self, BlsError};
@@ -163,9 +163,9 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
- private_key.public_key().to_bytes()
+ let secret_key = secp256k1::SecretKey::new(&mut rng);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ public_key.serialize().to_vec()
}
KeyType::BLS12_381 => {
let private_key = bls::SecretKey::random(rng);
@@ -203,16 +203,15 @@ impl KeyType {
pub fn public_key_data_from_private_key_data(
&self,
private_key_bytes: &[u8; 32],
- network: Network,
+ _network: Network,
) -> Result, ProtocolError> {
match self {
KeyType::ECDSA_SECP256K1 => {
- let secret_key =
- dashcore::secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
- .map_err(|e| ProtocolError::Generic(e.to_string()))?;
- let private_key = dashcore::PrivateKey::new(secret_key, network);
+ let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
+ .map_err(|e| ProtocolError::Generic(e.to_string()))?;
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- Ok(private_key.public_key().to_bytes())
+ Ok(public_key.serialize().to_vec())
}
KeyType::BLS12_381 => {
#[cfg(feature = "bls-signatures")]
@@ -234,12 +233,11 @@ impl KeyType {
));
}
KeyType::ECDSA_HASH160 => {
- let secret_key =
- dashcore::secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
- .map_err(|e| ProtocolError::Generic(e.to_string()))?;
- let private_key = dashcore::PrivateKey::new(secret_key, network);
+ let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
+ .map_err(|e| ProtocolError::Generic(e.to_string()))?;
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- Ok(ripemd160_sha256(private_key.public_key().to_bytes().as_slice()).to_vec())
+ Ok(ripemd160_sha256(public_key.serialize().as_slice()).to_vec())
}
KeyType::EDDSA_25519_HASH160 => {
#[cfg(feature = "ed25519-dalek")]
@@ -266,11 +264,11 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
+ let secret_key = secp256k1::SecretKey::new(&mut rng);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
(
- private_key.public_key().to_bytes(),
- private_key.inner.to_secret_bytes(),
+ public_key.serialize().to_vec(),
+ secret_key.to_secret_bytes(),
)
}
KeyType::BLS12_381 => {
@@ -282,11 +280,11 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
+ let secret_key = secp256k1::SecretKey::new(&mut rng);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
(
- ripemd160_sha256(private_key.public_key().to_bytes().as_slice()).to_vec(),
- private_key.inner.to_secret_bytes(),
+ ripemd160_sha256(public_key.serialize().as_slice()).to_vec(),
+ secret_key.to_secret_bytes(),
)
}
KeyType::EDDSA_25519_HASH160 => {
@@ -301,11 +299,11 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
+ let secret_key = secp256k1::SecretKey::new(&mut rng);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
(
- ripemd160_sha256(private_key.public_key().to_bytes().as_slice()).to_vec(),
- private_key.inner.to_secret_bytes(),
+ ripemd160_sha256(public_key.serialize().as_slice()).to_vec(),
+ secret_key.to_secret_bytes(),
)
}
}
diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
index 2f7034433b9..9f30211a538 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
@@ -9,9 +9,9 @@ use crate::util::hash::ripemd160_sha256;
use crate::ProtocolError;
use anyhow::anyhow;
use dashcore::hashes::Hash;
-use dashcore::secp256k1::SecretKey;
use dashcore::{Network, PublicKey as ECDSAPublicKey};
use platform_value::{BinaryData, Bytes20};
+use secp256k1::SecretKey;
impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
/// Get the original public key hash
fn public_key_hash(&self) -> Result<[u8; 20], ProtocolError> {
@@ -78,7 +78,7 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k
key_type: KeyType,
data: &BinaryData,
private_key_bytes: &[u8; 32],
- network: Network,
+ _network: Network,
) -> Result {
match key_type {
KeyType::ECDSA_SECP256K1 => {
@@ -86,9 +86,9 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k
Ok(secret_key) => secret_key,
Err(_) => return Ok(false),
};
- let private_key = dashcore::PrivateKey::new(secret_key, network);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- Ok(private_key.public_key().to_bytes() == data.as_slice())
+ Ok(public_key.serialize().as_slice() == data.as_slice())
}
KeyType::BLS12_381 => {
#[cfg(feature = "bls-signatures")]
@@ -112,12 +112,9 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k
Ok(secret_key) => secret_key,
Err(_) => return Ok(false),
};
- let private_key = dashcore::PrivateKey::new(secret_key, network);
+ let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- Ok(
- ripemd160_sha256(private_key.public_key().to_bytes().as_slice()).as_slice()
- == data.as_slice(),
- )
+ Ok(ripemd160_sha256(public_key.serialize().as_slice()).as_slice() == data.as_slice())
}
KeyType::EDDSA_25519_HASH160 => {
#[cfg(feature = "ed25519-dalek")]
diff --git a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/validate_asset_lock_transaction_structure/v0/mod.rs b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/validate_asset_lock_transaction_structure/v0/mod.rs
index 8b2c1560226..9a766840675 100644
--- a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/validate_asset_lock_transaction_structure/v0/mod.rs
+++ b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/validate_asset_lock_transaction_structure/v0/mod.rs
@@ -58,21 +58,25 @@ pub(super) fn validate_asset_lock_transaction_structure_v0(
#[cfg(test)]
mod tests {
use super::*;
- use dashcore::secp256k1::rand::rng;
use dashcore::transaction::special_transaction::asset_lock::AssetLockPayload;
use dashcore::{Network, OutPoint, PrivateKey, ScriptBuf, TxIn, Txid};
+ use secp256k1::rand::rng;
use std::str::FromStr;
fn make_asset_lock_transaction(num_inputs: usize) -> Transaction {
let mut rng = rng();
- let input_secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let private_key = PrivateKey::new(input_secret_key, Network::Testnet);
+ let input_secret_key = secp256k1::SecretKey::new(&mut rng);
+ let private_key =
+ PrivateKey::from_byte_array(input_secret_key.as_secret_bytes(), Network::Testnet)
+ .expect("valid test secret key");
let public_key = private_key.public_key();
let public_key_hash = public_key.pubkey_hash();
- let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
- let one_time_private_key = PrivateKey::new(secret_key, Network::Testnet);
+ let secret_key = secp256k1::SecretKey::new(&mut rng);
+ let one_time_private_key =
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Testnet)
+ .expect("valid test secret key");
let one_time_public_key = one_time_private_key.public_key();
let one_time_key_hash = one_time_public_key.pubkey_hash();
diff --git a/packages/rs-dpp/src/signing.rs b/packages/rs-dpp/src/signing.rs
index ba2256dd17b..621809cd121 100644
--- a/packages/rs-dpp/src/signing.rs
+++ b/packages/rs-dpp/src/signing.rs
@@ -2,6 +2,7 @@
use crate::bls::{self, Signature};
use crate::identity::KeyType;
use crate::serialization::PlatformMessageSignable;
+use crate::util::ecdsa as signer;
#[cfg(feature = "message-signature-verification")]
use crate::{
consensus::signature::{
@@ -11,7 +12,6 @@ use crate::{
};
#[cfg(feature = "message-signing")]
use crate::{BlsModule, ProtocolError};
-use dashcore::signer;
impl PlatformMessageSignable for &[u8] {
#[cfg(feature = "message-signature-verification")]
diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs
index fcdef43b5ef..058de23dca3 100644
--- a/packages/rs-dpp/src/state_transition/mod.rs
+++ b/packages/rs-dpp/src/state_transition/mod.rs
@@ -8,12 +8,12 @@ use std::ops::RangeInclusive;
use platform_value::{BinaryData, Identifier};
pub use state_transition_types::*;
-use bincode::{Decode, DecodeUntrusted, Encode};
#[cfg(any(
feature = "state-transition-signing",
feature = "state-transition-validation"
))]
-use dashcore::signer;
+use crate::util::ecdsa as signer;
+use bincode::{Decode, DecodeUntrusted, Encode};
#[cfg(feature = "state-transition-validation")]
use dashcore::signer::double_sha;
use platform_serialization_derive::{
@@ -2190,7 +2190,7 @@ impl StateTransition {
/// returned public key (libsecp256k1 normalises both signing paths to
/// low-s form so the 64-byte `r||s` payload is bit-identical).
/// 4. Serialise as a 65-byte compact recoverable signature with the
- /// `compressed` prefix convention used by `MessageSignature` — i.e.
+ /// `compressed` prefix convention used by Core signatures — i.e.
/// `[recovery_id + 27 + 4, r (32) || s (32)]`.
///
/// # Errors
@@ -2211,10 +2211,10 @@ impl StateTransition {
path: &::key_wallet::bip32::DerivationPath,
signer: &S,
) -> Result<(), ProtocolError> {
- use dashcore::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
- use dashcore::secp256k1::Message;
- use dashcore::sign_message::MessageSignature;
+ use dashcore::crypto::ecdsa::EcdsaRecSignature;
use dashcore::signer::double_sha;
+ use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
+ use secp256k1::Message;
let data = self.signable_bytes()?;
// Pre-image transform matches `dashcore::signer::sign`: double-SHA256
@@ -2237,7 +2237,7 @@ impl StateTransition {
// `sign_ecdsa_recoverable` outputs to low-s form, so the 64-byte
// `r||s` payload is bit-identical to what `dashcore::signer::sign`
// produces.
- let compact_64 = signature.serialize_compact();
+ let compact_64 = signature.to_bytes();
let msg = Message::from_digest(digest);
let mut found: Option = None;
@@ -2251,7 +2251,7 @@ impl StateTransition {
Err(_) => continue,
};
if let Ok(recovered) = candidate.recover_ecdsa(msg) {
- if recovered == public_key {
+ if recovered == public_key.into() {
found = Some(candidate);
break;
}
@@ -2272,7 +2272,14 @@ impl StateTransition {
// always passes `true` regardless of the underlying key encoding. The
// signer's `sign_ecdsa` returns the compressed `secp256k1::PublicKey`,
// so this is consistent.
- let compact_65 = MessageSignature::new(recoverable, true).serialize();
+ let (recovery_id, _) = recoverable.serialize_compact();
+ let compact_65 = EcdsaRecSignature::from_parts(
+ recoverable.to_standard().into(),
+ recovery_id.to_u8(),
+ true,
+ )
+ .map_err(|e| ProtocolError::ExternalSignerError(e.to_string()))?
+ .to_bytes();
if !self.set_signature(compact_65.to_vec().into()) {
return Err(ProtocolError::InvalidVerificationWrongNumberOfElements {
@@ -4655,9 +4662,10 @@ mod tests {
#[tokio::test]
async fn sign_with_core_signer_matches_sign_by_private_key_byte_for_byte() {
use async_trait::async_trait;
- use dashcore::secp256k1::{self, ecdsa, rand, Message, PublicKey, SecretKey};
+ use dashcore::crypto::ecdsa::{EcdsaPublicKey, EcdsaSignature};
use key_wallet::bip32::{DerivationPath, ExtendedPubKey};
use key_wallet::signer::{ExtendedPubKeySigner, Signer as KwSigner, SignerMethod};
+ use secp256k1::{self, rand, Message, PublicKey, SecretKey};
/// Fixed-key in-memory signer used only by this test. Mirrors how a
/// real KeychainSigner would behave: derive once, sign atomically,
@@ -4681,14 +4689,17 @@ mod tests {
&self,
_path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> {
let msg = Message::from_digest(sighash);
let sig = self.secret.sign_ecdsa(msg);
- Ok((sig, self.public))
+ Ok((sig.into(), self.public.into()))
}
- async fn public_key(&self, _path: &DerivationPath) -> Result {
- Ok(self.public)
+ async fn public_key(
+ &self,
+ _path: &DerivationPath,
+ ) -> Result {
+ Ok(self.public.into())
}
}
diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/signing_tests.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/signing_tests.rs
index fa7c6f13398..79f46a87c03 100644
--- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/signing_tests.rs
+++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/signing_tests.rs
@@ -14,10 +14,10 @@
use std::collections::{BTreeMap, HashMap};
use dashcore::hashes::Hash;
-use dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dashcore::{OutPoint, PublicKey};
use platform_value::BinaryData;
use platform_version::version::PlatformVersion;
+use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use crate::address_funds::{AddressFundsFeeStrategyStep, AddressWitness, PlatformAddress};
use crate::identity::signer::Signer;
@@ -202,9 +202,10 @@ async fn try_from_asset_lock_with_signer_and_private_key_signs_multiple_inputs()
#[tokio::test]
async fn try_from_asset_lock_with_signers_produces_matching_signature() {
use async_trait::async_trait;
- use dashcore::secp256k1::{ecdsa, Message};
+ use dashcore::ecdsa::{EcdsaPublicKey, EcdsaSignature};
use key_wallet::bip32::{DerivationPath, ExtendedPubKey};
use key_wallet::signer::{ExtendedPubKeySigner, Signer as KwSigner, SignerMethod};
+ use secp256k1::Message;
/// Fixed-key in-memory `key_wallet::signer::Signer`. Mirrors how the
/// Swift KeychainSigner behaves: derive once, sign atomically. Path
@@ -227,13 +228,13 @@ async fn try_from_asset_lock_with_signers_produces_matching_signature() {
&self,
_path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, RawPublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> {
let msg = Message::from_digest(sighash);
- Ok((self.secret.sign_ecdsa(msg), self.public))
+ Ok((self.secret.sign_ecdsa(msg).into(), self.public.into()))
}
- async fn public_key(&self, _path: &DerivationPath) -> Result {
- Ok(self.public)
+ async fn public_key(&self, _path: &DerivationPath) -> Result {
+ Ok(self.public.into())
}
}
diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs
index 6ac8d35825d..1a53894720f 100644
--- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs
+++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs
@@ -13,9 +13,9 @@ use std::collections::{BTreeMap, HashMap};
use dashcore::blockdata::opcodes::all::*;
use dashcore::blockdata::script::ScriptBuf;
use dashcore::hashes::Hash;
-use dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dashcore::PublicKey;
use platform_value::BinaryData;
+use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use crate::address_funds::{AddressWitness, PlatformAddress};
use crate::identity::signer::Signer;
diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/signing_tests.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/signing_tests.rs
index 542dd3fb724..9ba80c940a9 100644
--- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/signing_tests.rs
+++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/signing_tests.rs
@@ -33,9 +33,10 @@ use dashcore::OutPoint;
use platform_version::version::PlatformVersion;
use async_trait::async_trait;
-use dashcore::secp256k1::{ecdsa, Message, PublicKey, SecretKey};
+use dashcore::ecdsa::{EcdsaPublicKey, EcdsaSignature};
use key_wallet::bip32::{DerivationPath, ExtendedPubKey};
use key_wallet::signer::{ExtendedPubKeySigner, Signer as KwSigner, SignerMethod};
+use secp256k1::{Message, PublicKey, SecretKey};
/// Fixed-key in-memory `key_wallet::signer::Signer`. Mirrors how a
/// Swift KeychainSigner behaves: derive once, sign atomically. Path
@@ -68,13 +69,13 @@ impl KwSigner for FixedKeySigner {
&self,
_path: &DerivationPath,
sighash: [u8; 32],
- ) -> Result<(ecdsa::Signature, PublicKey), Self::Error> {
+ ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> {
let msg = Message::from_digest(sighash);
- Ok((self.secret.sign_ecdsa(msg), self.public))
+ Ok((self.secret.sign_ecdsa(msg).into(), self.public.into()))
}
- async fn public_key(&self, _path: &DerivationPath) -> Result {
- Ok(self.public)
+ async fn public_key(&self, _path: &DerivationPath) -> Result {
+ Ok(self.public.into())
}
}
diff --git a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
index ff38671e537..3bc6085669f 100644
--- a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
+++ b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
@@ -6,7 +6,7 @@ use crate::consensus::signature::{
InvalidSignaturePublicKeySecurityLevelError, PublicKeyIsDisabledError,
};
use anyhow::anyhow;
-use dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
+use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
#[cfg(feature = "state-transition-validation")]
use crate::state_transition::errors::WrongPublicKeyPurposeError;
@@ -107,7 +107,7 @@ pub trait StateTransitionIdentitySigned: StateTransitionLike {
pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], ProtocolError> {
let sk = <[u8; 32]>::try_from(private_key)
- .map_err(|_| dashcore::secp256k1::Error::InvalidSecretKey)
+ .map_err(|_| secp256k1::Error::InvalidSecretKey)
.and_then(RawSecretKey::from_secret_bytes)
.map_err(|e| anyhow!("Invalid ECDSA private key: {}", e))?;
@@ -260,8 +260,8 @@ pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], Prot
// }
//
// fn get_test_keys() -> Keys {
-// let secp = dashcore::secp256k1::Secp256k1::new();
-// let mut rng = dashcore::secp256k1::rand::thread_rng();
+// let secp = secp256k1::Secp256k1::new();
+// let mut rng = secp256k1::rand::thread_rng();
// let mut std_rng = StdRng::seed_from_u64(99999);
// let (private_key, public_key) = secp.generate_keypair(&mut rng);
//
@@ -410,8 +410,8 @@ pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], Prot
// let mut st = get_mock_state_transition();
// let mut keys = get_test_keys();
//
-// let secp = dashcore::secp256k1::Secp256k1::new();
-// let mut rng = dashcore::secp256k1::rand::thread_rng();
+// let secp = secp256k1::Secp256k1::new();
+// let mut rng = secp256k1::rand::thread_rng();
// let (_, public_key) = secp.generate_keypair(&mut rng);
//
// keys.identity_public_key.data = BinaryData::new(public_key.serialize().to_vec());
diff --git a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
index 23e620c6f81..07308342871 100644
--- a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
+++ b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
@@ -1,16 +1,16 @@
+use secp256k1::SecretKey;
use std::str::FromStr;
use dashcore::bls_sig_utils::BLSSignature;
use dashcore::hash_types::CycleHash;
use crate::balances::credits::Duffs;
-use dashcore::secp256k1::rand::rng;
use dashcore::transaction::special_transaction::asset_lock::AssetLockPayload;
use dashcore::transaction::special_transaction::TransactionPayload;
use dashcore::{
- secp256k1::SecretKey, InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxIn,
- TxOut, Txid,
+ InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxIn, TxOut, Txid,
};
+use secp256k1::rand::rng;
use crate::identity::state_transition::asset_lock_proof::{AssetLockProof, InstantAssetLockProof};
@@ -53,8 +53,10 @@ pub fn instant_asset_lock_proof_transaction_fixture(
let public_key_hash = public_key.pubkey_hash();
//let from_address = Address::p2pkh(&public_key, Network::Testnet);
let secret_key = SecretKey::new(&mut rng);
- let one_time_private_key =
- one_time_private_key.unwrap_or_else(|| PrivateKey::new(secret_key, Network::Testnet));
+ let one_time_private_key = one_time_private_key.unwrap_or_else(|| {
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Testnet)
+ .expect("valid test secret key")
+ });
let one_time_public_key = one_time_private_key.public_key();
// We are going to fund 1 Dash and
diff --git a/packages/rs-dpp/src/util/ecdsa.rs b/packages/rs-dpp/src/util/ecdsa.rs
new file mode 100644
index 00000000000..40f9bfa4874
--- /dev/null
+++ b/packages/rs-dpp/src/util/ecdsa.rs
@@ -0,0 +1,88 @@
+//! Platform ECDSA verification, including consensus-stable parsing and errors.
+
+use dashcore::hashes::{hash160, sha256d, Hash};
+use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
+use secp256k1::{Message, PublicKey};
+use thiserror::Error;
+
+pub use dashcore::signer::{double_sha, sign, sign_hash};
+
+/// Errors whose display text is included in Platform consensus errors.
+#[derive(Debug, Error)]
+pub enum EcdsaVerificationError {
+ #[error("length not 65 bytes")]
+ SignatureLength,
+ #[error("invalid encoding")]
+ SignatureEncoding(#[source] secp256k1::Error),
+ #[error("key secp256k1 error")]
+ PublicKeyEncoding(#[source] secp256k1::Error),
+ #[error("length {0} invalid for this base58 type")]
+ PublicKeyLength(usize),
+ #[error("key prefix invalid: {0}")]
+ PublicKeyPrefix(u8),
+ #[error(transparent)]
+ Crypto(#[from] secp256k1::Error),
+ #[error("Invalid hash length")]
+ HashLength,
+ #[error("the signature isn't valid")]
+ WrongKeyHash,
+}
+
+/// Decode a compact signature using the historical Platform acceptance rules.
+pub fn parse_compact_signature(
+ bytes: &[u8],
+) -> Result {
+ if bytes.len() != 65 {
+ return Err(EcdsaVerificationError::SignatureLength);
+ }
+ if !(27..=34).contains(&bytes[0]) {
+ return Err(EcdsaVerificationError::SignatureEncoding(
+ secp256k1::Error::InvalidRecoveryId,
+ ));
+ }
+ let id = RecoveryId::try_from(i32::from((bytes[0] - 27) & 3))
+ .map_err(EcdsaVerificationError::SignatureEncoding)?;
+ RecoverableSignature::from_compact(&bytes[1..], id)
+ .map_err(EcdsaVerificationError::SignatureEncoding)
+}
+
+/// Decode a SEC1 key, rejecting hybrid keys and preserving consensus error text.
+pub fn parse_public_key(bytes: &[u8]) -> Result {
+ match bytes.len() {
+ 33 => (),
+ 65 if bytes[0] == 4 => (),
+ 65 => return Err(EcdsaVerificationError::PublicKeyPrefix(bytes[0])),
+ len => return Err(EcdsaVerificationError::PublicKeyLength(len)),
+ }
+ PublicKey::from_slice(bytes).map_err(EcdsaVerificationError::PublicKeyEncoding)
+}
+
+/// Verify a double-SHA256 message signature without changing historical errors.
+pub fn verify_data_signature(
+ data: &[u8],
+ signature: &[u8],
+ public_key: &[u8],
+) -> Result<(), EcdsaVerificationError> {
+ let message = Message::from_digest(sha256d::Hash::hash(data).to_byte_array());
+ let signature = parse_compact_signature(signature)?;
+ let public_key = parse_public_key(public_key)?;
+ signature.to_standard().verify(message, &public_key)?;
+ Ok(())
+}
+
+/// Recover and compare the compressed key hash, irrespective of the header's compression bit.
+pub fn verify_hash_signature(
+ hash: &[u8],
+ signature: &[u8],
+ public_key_hash: &[u8],
+) -> Result<(), EcdsaVerificationError> {
+ let signature = parse_compact_signature(signature)?;
+ let digest = hash
+ .try_into()
+ .map_err(|_| EcdsaVerificationError::HashLength)?;
+ let public_key = signature.recover_ecdsa(Message::from_digest(digest))?;
+ if hash160::Hash::hash(&public_key.serialize()).as_byte_array() != public_key_hash {
+ return Err(EcdsaVerificationError::WrongKeyHash);
+ }
+ Ok(())
+}
diff --git a/packages/rs-dpp/src/util/mod.rs b/packages/rs-dpp/src/util/mod.rs
index a95aa51923f..5a051123b08 100644
--- a/packages/rs-dpp/src/util/mod.rs
+++ b/packages/rs-dpp/src/util/mod.rs
@@ -4,6 +4,7 @@ pub mod cbor_serializer;
pub mod cbor_value;
pub mod deserializer;
+pub mod ecdsa;
pub mod entropy_generator;
pub mod hash;
pub mod is_non_zero_fibonacci_number;
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
new file mode 100644
index 00000000000..cb188b4761f
--- /dev/null
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -0,0 +1,232 @@
+#[path = "fixtures/historical_hashes/vectors.rs"]
+#[expect(
+ dead_code,
+ reason = "shared historical fixtures include other algorithms"
+)]
+mod vectors;
+
+use dpp::address_funds::{AddressWitness, PlatformAddress};
+use dpp::dashcore::hashes::{hash160, Hash};
+use dpp::identity::KeyType;
+use dpp::serialization::PlatformMessageSignable;
+use dpp::util::ecdsa::{
+ parse_compact_signature, parse_public_key, sign, verify_data_signature, verify_hash_signature,
+};
+use dpp::ProtocolError;
+use vectors::{ECDSA_PUBLIC_KEY, TRANSFER_ECDSA_SIGNATURE, TRANSFER_HASH, TRANSFER_SIGNABLE};
+
+fn fixture() -> (Vec, Vec, Vec) {
+ (
+ hex::decode(TRANSFER_SIGNABLE).unwrap(),
+ hex::decode(TRANSFER_ECDSA_SIGNATURE).unwrap(),
+ hex::decode(ECDSA_PUBLIC_KEY).unwrap(),
+ )
+}
+
+#[test]
+fn should_preserve_historical_signature_bytes_and_verification() {
+ let (data, signature, public_key) = fixture();
+ assert_eq!(sign(&data, &[1; 32]).unwrap().as_slice(), signature);
+ verify_data_signature(&data, &signature, &public_key).unwrap();
+ assert!(data
+ .as_slice()
+ .verify_signature(KeyType::ECDSA_SECP256K1, &public_key, &signature)
+ .is_valid());
+}
+
+#[test]
+fn should_preserve_all_compact_header_acceptance_rules() {
+ let (_, mut signature, _) = fixture();
+ for header in 0..=u8::MAX {
+ signature[0] = header;
+ let result = parse_compact_signature(&signature);
+ if (27..=34).contains(&header) {
+ let (id, compact) = result.unwrap().serialize_compact();
+ assert_eq!(id.to_u8(), (header - 27) & 3);
+ assert_eq!(compact.as_slice(), &signature[1..]);
+ } else {
+ assert_eq!(
+ result.unwrap_err().to_string(),
+ "invalid encoding",
+ "header {header}"
+ );
+ }
+ }
+}
+
+#[test]
+fn should_preserve_compact_length_and_scalar_errors() {
+ for len in [0, 1, 64, 66] {
+ assert_eq!(
+ parse_compact_signature(&vec![0; len])
+ .unwrap_err()
+ .to_string(),
+ "length not 65 bytes"
+ );
+ }
+ let order =
+ hex::decode("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap();
+ for start in [1, 33] {
+ for scalar in [order.as_slice(), &[0xff; 32]] {
+ let (_, mut signature, _) = fixture();
+ signature[start..start + 32].copy_from_slice(scalar);
+ assert_eq!(
+ parse_compact_signature(&signature).unwrap_err().to_string(),
+ "invalid encoding"
+ );
+ }
+ }
+ // libsecp parses zero scalars, but neither verification nor recovery succeeds.
+ let mut zero = [0; 65];
+ zero[0] = 31;
+ parse_compact_signature(&zero).unwrap();
+ let (data, _, public_key) = fixture();
+ assert_eq!(
+ verify_data_signature(&data, &zero, &public_key)
+ .unwrap_err()
+ .to_string(),
+ "signature failed verification"
+ );
+ assert_eq!(
+ verify_hash_signature(&[0; 32], &zero, &[0; 20])
+ .unwrap_err()
+ .to_string(),
+ "malformed signature"
+ );
+}
+
+#[test]
+fn should_preserve_public_key_encodings_and_error_text() {
+ let (_, _, public_key) = fixture();
+ let parsed = parse_public_key(&public_key).unwrap();
+ let mut uncompressed = parsed.serialize_uncompressed();
+ assert_eq!(parse_public_key(&uncompressed).unwrap(), parsed);
+ for prefix in [0, 2, 3, 6, 7] {
+ uncompressed[0] = prefix;
+ assert_eq!(
+ parse_public_key(&uncompressed).unwrap_err().to_string(),
+ format!("key prefix invalid: {prefix}")
+ );
+ }
+ for len in [0, 32, 34, 64, 66] {
+ assert_eq!(
+ parse_public_key(&vec![0; len]).unwrap_err().to_string(),
+ format!("length {len} invalid for this base58 type")
+ );
+ }
+ let mut invalid = [0xff; 33];
+ invalid[0] = 2;
+ assert_eq!(
+ parse_public_key(&invalid).unwrap_err().to_string(),
+ "key secp256k1 error"
+ );
+}
+
+#[test]
+fn should_report_invalid_signature_before_invalid_key_or_hash() {
+ let (data, mut signature, _) = fixture();
+ signature[1..33].fill(0xff);
+ assert_eq!(
+ verify_data_signature(&data, &signature, &[])
+ .unwrap_err()
+ .to_string(),
+ "invalid encoding"
+ );
+ assert_eq!(
+ verify_hash_signature(&[], &signature, &[])
+ .unwrap_err()
+ .to_string(),
+ "invalid encoding"
+ );
+ let (_, valid_signature, _) = fixture();
+ assert_eq!(
+ verify_hash_signature(&[], &valid_signature, &[])
+ .unwrap_err()
+ .to_string(),
+ "Invalid hash length"
+ );
+}
+
+#[test]
+fn should_recover_compressed_key_hash_for_both_header_compression_flags() {
+ let (_, mut signature, public_key) = fixture();
+ let hash = hex::decode(TRANSFER_HASH).unwrap();
+ let key_hash = hash160::Hash::hash(&public_key).to_byte_array();
+ for header in [27, 31] {
+ signature[0] = header;
+ verify_hash_signature(&hash, &signature, &key_hash).unwrap();
+ assert_eq!(
+ verify_hash_signature(&hash, &signature, &[0; 20])
+ .unwrap_err()
+ .to_string(),
+ "the signature isn't valid"
+ );
+ }
+}
+
+#[test]
+fn should_reject_high_s_verification_but_accept_high_s_recovery() {
+ let (data, mut signature, public_key) = fixture();
+ // n minus the historical signature's S, with the recovery parity flipped.
+ signature[33..].copy_from_slice(
+ &hex::decode("e952933fd7484a943559327bf88e9c0261fda84544e0b2f4736f786a1ad2c20b").unwrap(),
+ );
+ signature[0] = 32;
+ assert_eq!(
+ verify_data_signature(&data, &signature, &public_key)
+ .unwrap_err()
+ .to_string(),
+ "signature failed verification"
+ );
+ verify_hash_signature(
+ &hex::decode(TRANSFER_HASH).unwrap(),
+ &signature,
+ hash160::Hash::hash(&public_key).as_byte_array(),
+ )
+ .unwrap();
+}
+
+#[test]
+fn should_preserve_multisig_malformed_signature_error() {
+ let (data, mut signature, public_key) = fixture();
+ let mut script = vec![0x51, 33];
+ script.extend_from_slice(&public_key);
+ script.extend_from_slice(&[0x51, 0xae]);
+ let address = PlatformAddress::P2sh(hash160::Hash::hash(&script).to_byte_array());
+ signature[0] = 35;
+ let witness = AddressWitness::P2sh {
+ signatures: vec![signature.into()],
+ redeem_script: script.into(),
+ };
+ let error = address
+ .verify_bytes_against_witness(&witness, &data)
+ .unwrap_err();
+ match error {
+ ProtocolError::AddressWitnessError(message) => {
+ assert_eq!(message, "Invalid signature format: invalid encoding")
+ }
+ error => panic!("unexpected error: {error}"),
+ }
+}
+
+#[test]
+fn should_preserve_multisig_malformed_public_key_error() {
+ let (data, signature, _) = fixture();
+ let mut script = vec![0x51, 33, 2];
+ script.extend_from_slice(&[0xff; 32]);
+ script.extend_from_slice(&[0x51, 0xae]);
+ let address = PlatformAddress::P2sh(hash160::Hash::hash(&script).to_byte_array());
+ let witness = AddressWitness::P2sh {
+ signatures: vec![signature.into()],
+ redeem_script: script.into(),
+ };
+ let error = address
+ .verify_bytes_against_witness(&witness, &data)
+ .unwrap_err();
+ match error {
+ ProtocolError::AddressWitnessError(message) => {
+ assert_eq!(message, "Invalid public key: key secp256k1 error")
+ }
+ error => panic!("unexpected error: {error}"),
+ }
+}
diff --git a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
index c0dae098abf..32a039a8d70 100644
--- a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
+++ b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
@@ -9,7 +9,7 @@ use dapi_grpc::platform::v0::{
use dpp::address_funds::AddressWitness;
use dpp::block::block_info::BlockInfo;
use dpp::bls::SecretKey;
-use dpp::dashcore::{secp256k1, signer};
+use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
use dpp::data_contract::DataContract;
@@ -21,6 +21,7 @@ use dpp::identity::{
Identity, IdentityPublicKey, IdentityV0, KeyType, PartialIdentity, Purpose, SecurityLevel,
};
use dpp::platform_value::{platform_value, BinaryData, Value};
+use dpp::secp256k1;
use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition;
use dpp::state_transition::batch_transition::batched_transition::BatchedTransitionRef;
diff --git a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
index e34aee790ac..23f0fbfdd63 100644
--- a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
+++ b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
@@ -9,7 +9,7 @@ use dapi_grpc::Message;
use dpp::address_funds::AddressWitness;
use dpp::block::block_info::BlockInfo;
use dpp::bls::SecretKey;
-use dpp::dashcore::{secp256k1, signer};
+use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::config::moderation::{ContractModerationConfig, ContractModerators};
use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
@@ -19,6 +19,7 @@ use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey, IdentityV0, KeyType, Purpose, SecurityLevel};
use dpp::platform_value::{platform_value, BinaryData, Value};
+use dpp::secp256k1;
use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition;
diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
index f3c805ec01a..dc3d9ff14e8 100644
--- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
@@ -338,8 +338,6 @@ mod tests {
use assert_matches::assert_matches;
use dpp::consensus::state::state_error::StateError;
use dpp::dash_to_credits;
- use dpp::dashcore::secp256k1::rand::rngs::StdRng as SecpStdRng;
- use dpp::dashcore::secp256k1::rand::SeedableRng as _;
use dpp::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Setters;
use dpp::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
use dpp::data_contract::change_control_rules::v0::ChangeControlRulesV0;
@@ -357,6 +355,8 @@ mod tests {
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::signer::Signer;
use dpp::platform_value::Bytes32;
+ use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng;
+ use dpp::secp256k1::rand::SeedableRng as _;
use dpp::state_transition::batch_transition::methods::v1::DocumentsBatchTransitionMethodsV1;
use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
index a30b4a8004e..d12a0dc0345 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
@@ -7,9 +7,10 @@ use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointNotEnou
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::dashcore::hashes::Hash;
-use dpp::dashcore::{signer, ScriptBuf, Txid};
+use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::state_transition::AssetLockProved;
use dpp::identity::KeyType;
+use dpp::util::ecdsa as signer;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
index debb977bd89..1138360893d 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
@@ -8,8 +8,9 @@ use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::identity::IdentityAlreadyExistsError;
use dpp::dashcore::hashes::Hash;
-use dpp::dashcore::{signer, ScriptBuf, Txid};
+use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::KeyType;
+use dpp::util::ecdsa as signer;
use dpp::identity::state_transition::AssetLockProved;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
index 98f16f265f4..9596a86d6b5 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
@@ -9376,13 +9376,13 @@ mod tests {
mod actual_signature_verification {
use super::*;
use dpp::dashcore::hashes::Hash;
- use dpp::dashcore::secp256k1::PublicKey as RawSecp256k1PublicKey;
+ use dpp::secp256k1::PublicKey as RawSecp256k1PublicKey;
use dpp::serialization::Signable;
/// Helper to create a properly signed P2PKH witness
/// Note: Creates a recoverable signature for P2PKH (65 bytes)
fn create_real_p2pkh_witness(
- secret_key: &dpp::dashcore::secp256k1::SecretKey,
+ secret_key: &dpp::secp256k1::SecretKey,
signable_bytes: &[u8],
) -> (PlatformAddress, AddressWitness) {
let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret_key);
@@ -9410,7 +9410,7 @@ mod tests {
let public_keys = create_default_public_keys(&mut rng, platform_version);
// Create a real secret key
- let secret_key = dpp::dashcore::secp256k1::SecretKey::from_secret_bytes([
+ let secret_key = dpp::secp256k1::SecretKey::from_secret_bytes([
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
0x1d, 0x1e, 0x1f, 0x20,
@@ -9486,8 +9486,8 @@ mod tests {
let public_keys = create_default_public_keys(&mut rng, platform_version);
// Create address from one key
- let correct_secret = dpp::dashcore::secp256k1::SecretKey::from_secret_bytes([1u8; 32])
- .expect("valid secret key");
+ let correct_secret =
+ dpp::secp256k1::SecretKey::from_secret_bytes([1u8; 32]).expect("valid secret key");
let raw_correct_pubkey = RawSecp256k1PublicKey::from_secret_key(&correct_secret);
let correct_pubkey = PublicKey::new(raw_correct_pubkey);
let pubkey_hash =
@@ -9495,8 +9495,8 @@ mod tests {
let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array());
// But sign with different key
- let wrong_secret = dpp::dashcore::secp256k1::SecretKey::from_secret_bytes([2u8; 32])
- .expect("valid secret key");
+ let wrong_secret =
+ dpp::secp256k1::SecretKey::from_secret_bytes([2u8; 32]).expect("valid secret key");
let mut inputs = BTreeMap::new();
inputs.insert(address.clone(), (1 as AddressNonce, dash_to_credits!(1.0)));
@@ -9557,8 +9557,7 @@ mod tests {
.map(|i| {
let mut key_bytes = [0u8; 32];
key_bytes[0] = i;
- dpp::dashcore::secp256k1::SecretKey::from_secret_bytes(key_bytes)
- .expect("valid")
+ dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid")
})
.collect();
@@ -9646,8 +9645,7 @@ mod tests {
.map(|i| {
let mut key_bytes = [0u8; 32];
key_bytes[0] = i + 10;
- dpp::dashcore::secp256k1::SecretKey::from_secret_bytes(key_bytes)
- .expect("valid")
+ dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid")
})
.collect();
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
index 4592192f754..e981aea78f1 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
@@ -7,9 +7,10 @@ use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointNotEnou
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::dashcore::hashes::Hash;
-use dpp::dashcore::{signer, ScriptBuf, Txid};
+use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::state_transition::AssetLockProved;
use dpp::identity::KeyType;
+use dpp::util::ecdsa as signer;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
index 9f935dbed81..7581eedd6db 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
@@ -141,8 +141,6 @@ mod tests {
use dpp::consensus::ConsensusError;
use dpp::dash_to_credits;
use dpp::dashcore::key::Keypair;
- use dpp::dashcore::secp256k1::rand::rngs::StdRng as SecpStdRng;
- use dpp::dashcore::secp256k1::rand::SeedableRng as _;
use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::identifier::Identifier;
@@ -152,6 +150,8 @@ mod tests {
use dpp::identity::signer::Signer;
use dpp::identity::KeyType::ECDSA_SECP256K1;
use dpp::identity::{KeyType, Purpose, SecurityLevel};
+ use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng;
+ use dpp::secp256k1::rand::SeedableRng as _;
use dpp::serialization::{PlatformSerializable, Signable};
use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0;
use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
index 998e9851790..bf4f963a990 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
@@ -625,7 +625,7 @@ mod tests {
let transition = create_signed_shield_from_asset_lock_transition(
asset_lock_proof,
- &wrong_private_key.inner.to_secret_bytes(), // Wrong key
+ &wrong_private_key.inner.to_bytes(), // Wrong key
vec![create_dummy_serialized_action()],
5000,
[42u8; 32],
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
index 5caff640825..ce660e30a37 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
@@ -22,7 +22,8 @@ use dpp::consensus::basic::state_transition::ShieldedImplicitFeeCapExceededError
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::state_error::StateError;
use dpp::dashcore::hashes::Hash;
-use dpp::dashcore::{signer, ScriptBuf, Txid};
+use dpp::util::ecdsa as signer;
+use dpp::dashcore::{ ScriptBuf, Txid};
use dpp::fee::Credits;
use dpp::shielded::compute_minimum_shielded_fee;
use dpp::identity::state_transition::AssetLockProved;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
index 23ad804a857..7922cbde3de 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
@@ -23,7 +23,8 @@ use dpp::consensus::basic::state_transition::ShieldedImplicitFeeCapExceededError
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::state_error::StateError;
use dpp::dashcore::hashes::Hash;
-use dpp::dashcore::{signer, ScriptBuf, Txid};
+use dpp::util::ecdsa as signer;
+use dpp::dashcore::{ ScriptBuf, Txid};
use dpp::fee::Credits;
use dpp::shielded::{compute_minimum_shielded_fee, shield_from_asset_lock_extra_sighash_data};
use dpp::identity::state_transition::AssetLockProved;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
index 830f8e55124..feec8ab2f6e 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
@@ -17,11 +17,11 @@ use dpp::block::block_info::BlockInfo;
use dpp::consensus::ConsensusError;
use dpp::dashcore::blockdata::script::ScriptBuf;
use dpp::dashcore::hashes::{sha256, Hash};
-use dpp::dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dpp::dashcore::PublicKey;
use dpp::identity::signer::Signer;
use dpp::platform_value::BinaryData;
use dpp::prelude::AddressNonce;
+use dpp::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dpp::serialization::PlatformSerializable;
use dpp::shielded::builder::OrchardProver;
use dpp::shielded::SerializedAction;
diff --git a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
index 16dba17f478..80bb161de21 100644
--- a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
+++ b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
@@ -27,9 +27,9 @@ use dpp::ProtocolError;
// Scope, SpendAuthorizingKey, SpendingKey,
// };
-use dpp::dashcore::secp256k1::SecretKey;
use dpp::data_contract::document_type::random_document::CreateRandomDocument;
use dpp::data_contract::{DataContract, DataContractFactory};
+use dpp::secp256k1::SecretKey;
use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
use strategy_tests::frequency::Frequency;
use strategy_tests::operations::FinalizeBlockOperation::IdentityAddKeys;
@@ -2204,7 +2204,8 @@ impl NetworkStrategy {
let sk: [u8; 32] = pk.try_into().unwrap();
let secret_key = SecretKey::from_str(hex::encode(sk).as_str()).unwrap();
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::new(secret_key, Network::Mainnet),
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ .expect("valid test secret key"),
amount_range,
rng,
);
@@ -2268,7 +2269,8 @@ impl NetworkStrategy {
let sk_bytes: [u8; 32] = pk.try_into().unwrap();
let secret_key = SecretKey::from_str(hex::encode(sk_bytes).as_str()).unwrap();
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::new(secret_key, Network::Mainnet),
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ .expect("valid test secret key"),
amount_range,
rng,
);
@@ -3175,7 +3177,9 @@ fn create_signed_instant_asset_lock_proofs_for_identities(
let pk_fixed: [u8; 32] = pk.try_into().unwrap();
let secret_key = SecretKey::from_str(hex::encode(pk_fixed).as_str()).unwrap();
- let private_key = PrivateKey::new(secret_key, Network::Mainnet);
+ let private_key =
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ .expect("valid test secret key");
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
private_key,
diff --git a/packages/rs-scripts/src/bin/register_identity.rs b/packages/rs-scripts/src/bin/register_identity.rs
index 5caa3060869..7c852c28155 100644
--- a/packages/rs-scripts/src/bin/register_identity.rs
+++ b/packages/rs-scripts/src/bin/register_identity.rs
@@ -514,9 +514,11 @@ async fn run() -> Result<(), String> {
} else {
// FRESH: generate a one-time key, build + Core-sign + broadcast the
// asset lock, capturing all recovery credentials BEFORE broadcast.
- let mut secp_rng = dpp::dashcore::secp256k1::rand::rng();
- let one_time_secret = dpp::dashcore::secp256k1::SecretKey::new(&mut secp_rng);
- let one_time_private_key = PrivateKey::new(one_time_secret, network);
+ let mut secp_rng = dpp::secp256k1::rand::rng();
+ let one_time_secret = dpp::secp256k1::SecretKey::new(&mut secp_rng);
+ let one_time_private_key =
+ PrivateKey::from_byte_array(one_time_secret.as_secret_bytes(), network)
+ .map_err(|e| format!("failed to construct asset-lock private key: {e}"))?;
let one_time_public_key = one_time_private_key.public_key();
let one_time_key_hash = one_time_public_key.pubkey_hash();
let one_time_address = Address::p2pkh(&one_time_public_key, network);
diff --git a/packages/rs-sdk/src/platform/dashpay/contact_request.rs b/packages/rs-sdk/src/platform/dashpay/contact_request.rs
index a59a5c6a0ac..3f528a4bba6 100644
--- a/packages/rs-sdk/src/platform/dashpay/contact_request.rs
+++ b/packages/rs-sdk/src/platform/dashpay/contact_request.rs
@@ -5,9 +5,6 @@
use crate::platform::transition::put_document::PutDocument;
use crate::platform::Document;
use crate::{Error, Sdk};
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{Rng, RngCore, SeedableRng};
-use dpp::dashcore::secp256k1::{PublicKey, SecretKey};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
use dpp::document::DocumentV0;
@@ -18,6 +15,9 @@ use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey};
use dpp::platform_value::{Bytes32, Value};
use dpp::prelude::Identifier;
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{Rng, RngCore, SeedableRng};
+use dpp::secp256k1::{PublicKey, SecretKey};
use platform_encryption::{
derive_shared_key_ecdh, encrypt_account_label, encrypt_extended_public_key, COMPACT_XPUB_LEN,
};
@@ -575,8 +575,8 @@ impl Sdk {
#[cfg(test)]
mod tests {
use super::*;
- use dpp::dashcore::secp256k1;
- use dpp::dashcore::secp256k1::rand::{self, RngCore};
+ use dpp::secp256k1;
+ use dpp::secp256k1::rand::{self, RngCore};
#[test]
fn test_ecdh_encryption_produces_correct_size() {
diff --git a/packages/rs-sdk/src/platform/dashpay/invitation.rs b/packages/rs-sdk/src/platform/dashpay/invitation.rs
index b84c1e4b58f..ca0953712df 100644
--- a/packages/rs-sdk/src/platform/dashpay/invitation.rs
+++ b/packages/rs-sdk/src/platform/dashpay/invitation.rs
@@ -69,7 +69,6 @@
use std::collections::BTreeMap;
use dpp::dashcore::consensus::Decodable;
-use dpp::dashcore::secp256k1::{PublicKey, SecretKey};
use dpp::dashcore::transaction::special_transaction::TransactionPayload;
use dpp::dashcore::{InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxOut};
use dpp::identity::accessors::IdentityGettersV0;
@@ -82,6 +81,7 @@ use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
use dpp::identity::v0::IdentityV0;
use dpp::identity::{Identity, IdentityPublicKey, KeyID, Purpose, SecurityLevel};
use dpp::prelude::{AssetLockProof, Identifier};
+use dpp::secp256k1::{PublicKey, SecretKey};
use crate::core::FetchedCoreTransaction;
use crate::platform::transition::asset_lock_submission::{
@@ -423,11 +423,11 @@ pub fn encode_invitation_uri(
};
// WIF, compressed (the default for `PrivateKey::new`), network-correct.
- // `PrivateKey` is `Copy` and not zeroized on drop, so wipe this copy.
- let mut private_key = PrivateKey::new(*voucher_key, network);
+ let private_key = PrivateKey::from_byte_array(&voucher_key.to_secret_bytes(), network)
+ .map_err(|e| invalid(format!("invalid invitation voucher key: {e}")))?;
let mut wif = String::with_capacity(52);
let wif_result = private_key.fmt_wif(&mut wif);
- private_key.inner.non_secure_erase();
+ drop(private_key);
wif_result.map_err(|_| invalid("failed to encode invitation voucher key"))?;
let mut query = String::new();
@@ -555,19 +555,16 @@ pub fn parse_invitation_uri(uri: &str) -> Result Result {
Ok(hex::encode(bytes))
}
-/// RAII scrub for the voucher `PrivateKey` copy used on the claim path.
-/// `dashcore::PrivateKey` wraps a `secp256k1::SecretKey` that has no
-/// Drop-zeroize, so the imported bearer scalar would otherwise linger in memory
-/// after `claim_invitation` returns on every exit path (success or error).
-struct WipingPrivateKey(PrivateKey);
-
-impl Drop for WipingPrivateKey {
- fn drop(&mut self) {
- self.0.inner.non_secure_erase();
- }
-}
-
impl Sdk {
/// The identity id this invitation WOULD create, without claiming it.
///
@@ -892,8 +877,10 @@ impl Sdk {
// The voucher key signs the asset lock's outer ST signature (ECDSA over
// the credit-output pubkey hash), scrubbed on every exit path by the
- // `WipingPrivateKey` guard.
- let voucher_priv = WipingPrivateKey(PrivateKey::new(invitation.voucher_key, self.network));
+ // native secret-key owner.
+ let voucher_priv =
+ PrivateKey::from_byte_array(&invitation.voucher_key.to_secret_bytes(), self.network)
+ .map_err(|e| invalid(format!("invalid invitation voucher scalar: {e}")))?;
// Build the placeholder identity ONCE so both the primary attempt and the
// IS→CL fallback submit the same key set without a `keys_map` clone.
@@ -917,7 +904,7 @@ impl Sdk {
placeholder.put_to_platform_and_wait_for_response_with_private_key(
self,
proof.clone(),
- &voucher_priv.0,
+ &voucher_priv,
identity_signer,
s,
)
@@ -1377,11 +1364,13 @@ mod tests {
#[test]
fn should_round_trip_a_wif_keeping_compression_and_network() {
for (network, first_byte) in [(Network::Mainnet, 204u8), (Network::Testnet, 239u8)] {
- let wif = PrivateKey::new(voucher(), network).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), network)
+ .expect("valid voucher")
+ .to_wif();
let decoded = PrivateKey::from_wif(&wif).expect("wif decodes");
assert!(decoded.compressed, "voucher WIF must be compressed");
assert_eq!(decoded.network, network, "network preserved");
- assert_eq!(decoded.inner.to_secret_bytes(), voucher().to_secret_bytes());
+ assert_eq!(*decoded.inner.to_bytes(), voucher().to_secret_bytes());
// Network byte matches bitcoinj/legacy (0xCC mainnet, 0xEF testnet).
let raw = dpp::dashcore::base58::decode(&wif).unwrap();
assert_eq!(raw[0], first_byte);
@@ -1425,7 +1414,9 @@ mod tests {
/// byte-level, interop — the two legacy wallets differ in order).
#[test]
fn should_parse_a_link_regardless_of_field_order() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri = format!("dashpay://invite?islock=deadbeef&pk={wif}&du=bob&assetlocktx=aabbcc");
let parsed = parse_invitation_uri(&uri).expect("parse");
assert_eq!(parsed.funding_txid, "aabbcc");
@@ -1440,7 +1431,9 @@ mod tests {
/// first-class alternative to the custom scheme (iOS emits it).
#[test]
fn should_parse_a_link_on_the_applink_host() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri = format!(
"https://invitations.dashpay.io/applink?du=carol&assetlocktx=aabb&pk={wif}&islock=cc"
);
@@ -1456,7 +1449,9 @@ mod tests {
/// accepted over cleartext `http`. Neither mobile wallet emits an `http` link.
#[test]
fn should_reject_an_applink_over_plain_http() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri =
format!("http://invitations.dashpay.io/applink?du=carol&assetlocktx=aabb&pk={wif}");
assert!(matches!(
@@ -1470,7 +1465,9 @@ mod tests {
/// (a ChainLock-confirmed invite Android's own validator accepts).
#[test]
fn should_parse_an_islock_that_is_present_absent_or_null() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let present = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=00aa11");
assert_eq!(
parse_invitation_uri(&present)
@@ -1493,7 +1490,9 @@ mod tests {
/// A `du`-less link still parses (iOS accepts du-less links).
#[test]
fn should_parse_a_link_without_a_du_field() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=bb");
let parsed = parse_invitation_uri(&uri).expect("parse");
assert!(parsed.inviter.is_none());
@@ -1501,7 +1500,9 @@ mod tests {
#[test]
fn should_reject_a_link_missing_pk_or_assetlocktx() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
// No pk.
assert!(parse_invitation_uri("dashpay://invite?assetlocktx=aa").is_err());
// No assetlocktx.
@@ -1518,7 +1519,11 @@ mod tests {
#[test]
fn should_reject_an_uncompressed_wif() {
- let uncompressed = PrivateKey::new_uncompressed(voucher(), Network::Testnet).to_wif();
+ let mut private_key =
+ PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher");
+ private_key.compressed = false;
+ let uncompressed = private_key.to_wif();
let uri = format!("dashpay://invite?assetlocktx=aa&pk={uncompressed}");
let err = parse_invitation_uri(&uri).unwrap_err();
assert!(err.to_string().contains("compressed"));
@@ -1541,7 +1546,9 @@ mod tests {
/// display-name + avatar-url) parses to the right fields.
#[test]
fn should_parse_an_android_style_link() {
- let wif = PrivateKey::new(voucher(), Network::Mainnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Mainnet)
+ .expect("valid voucher")
+ .to_wif();
// Android order: du, assetlocktx, pk, islock, display-name, avatar-url.
let uri = format!(
"dashpay://invite?du=satoshi&assetlocktx={txid}&pk={wif}&islock={islock}&display-name=Sat%20Oshi&avatar-url=https%3A%2F%2Fimg.example%2Fa.png",
@@ -1610,7 +1617,9 @@ mod tests {
/// surface them (the reference wallets emit those independently of `du`).
#[test]
fn should_keep_inviter_metadata_when_the_du_field_is_missing() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
let uri = format!(
"dashpay://invite?assetlocktx=aa&pk={wif}&display-name=No%20User&avatar-url=https%3A%2F%2Fimg%2Fx.png"
);
@@ -1625,12 +1634,12 @@ mod tests {
/// first) — reject rather than claim a wallet-dependent key.
#[test]
fn should_reject_a_link_with_duplicate_required_keys() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
- let other = PrivateKey::new(
- SecretKey::from_secret_bytes([0x44u8; 32]).unwrap(),
- Network::Testnet,
- )
- .to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
+ let other = PrivateKey::from_byte_array(&[0x44u8; 32], Network::Testnet)
+ .expect("valid scalar")
+ .to_wif();
let dup_pk = format!("dashpay://invite?assetlocktx=aa&pk={wif}&pk={other}");
assert!(parse_invitation_uri(&dup_pk)
.unwrap_err()
@@ -1650,7 +1659,9 @@ mod tests {
/// (with a `pk`/`assetlocktx`) would be parsed.
#[test]
fn should_reject_a_link_with_a_decoy_scheme_or_host() {
- let wif = PrivateKey::new(voucher(), Network::Testnet).to_wif();
+ let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ .expect("valid voucher")
+ .to_wif();
// Suffixed authority — not exactly `invite`.
let suffixed = format!("dashpay://inviteXYZ?assetlocktx=aa&pk={wif}");
assert!(parse_invitation_uri(&suffixed).is_err());
diff --git a/packages/rs-sdk/src/platform/dashpay/profile.rs b/packages/rs-sdk/src/platform/dashpay/profile.rs
index fce6d5ae2fa..8417dce46c4 100644
--- a/packages/rs-sdk/src/platform/dashpay/profile.rs
+++ b/packages/rs-sdk/src/platform/dashpay/profile.rs
@@ -11,8 +11,6 @@ use crate::platform::documents::transitions::{
};
use crate::platform::FetchMany;
use crate::{Error, Sdk};
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{Rng, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dpp::data_contract::DataContract;
@@ -21,6 +19,8 @@ use dpp::identity::signer::Signer;
use dpp::identity::IdentityPublicKey;
use dpp::platform_value::{platform_value, Value};
use dpp::prelude::Identifier;
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{Rng, SeedableRng};
use drive::query::{OrderClause, WhereClause, WhereOperator};
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
diff --git a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
index dc8dbab06da..fd79e49c7c2 100644
--- a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
+++ b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
@@ -11,8 +11,6 @@ use crate::platform::transition::put_document::PutDocument;
use crate::platform::transition::put_settings::PutSettings;
use crate::platform::{Document, FetchMany};
use crate::{Error, Sdk};
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{Rng, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::document::{DocumentV0, DocumentV0Getters};
use dpp::fee::Credits;
@@ -21,6 +19,8 @@ use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey};
use dpp::platform_value::Value;
use dpp::prelude::Identifier;
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{Rng, SeedableRng};
use dpp::state_transition::batch_transition::methods::StateTransitionCreationOptions;
use std::collections::BTreeMap;
use std::sync::Arc;
diff --git a/packages/rs-sdk/src/platform/encrypted_for.rs b/packages/rs-sdk/src/platform/encrypted_for.rs
index 2d8af5f5e93..c7c37818512 100644
--- a/packages/rs-sdk/src/platform/encrypted_for.rs
+++ b/packages/rs-sdk/src/platform/encrypted_for.rs
@@ -26,9 +26,6 @@
//! which a wrong key passes about once in 256 attempts and then returns garbage; a caller that
//! must tell the two apart has to recognise its plaintext.
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{RngCore, SeedableRng};
-use dpp::dashcore::secp256k1::{PublicKey, SecretKey};
use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
use dpp::data_contract::document_type::{
DocumentPropertyReferenceTarget, DocumentPropertyType, DocumentTypeRef, EncryptedFor,
@@ -43,6 +40,9 @@ use dpp::platform_value::btreemap_extensions::{
BTreeValueMapInsertionPathHelper, BTreeValueMapPathHelper,
};
use dpp::platform_value::{Identifier, Value};
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{RngCore, SeedableRng};
+use dpp::secp256k1::{PublicKey, SecretKey};
use platform_encryption::{decrypt_aes_256_cbc, derive_shared_key_ecdh, encrypt_aes_256_cbc};
use std::collections::BTreeMap;
use std::fmt;
diff --git a/packages/rs-sdk/src/platform/moderation_charters/requests.rs b/packages/rs-sdk/src/platform/moderation_charters/requests.rs
index 9af9df68a99..bdb5087de94 100644
--- a/packages/rs-sdk/src/platform/moderation_charters/requests.rs
+++ b/packages/rs-sdk/src/platform/moderation_charters/requests.rs
@@ -3,9 +3,6 @@
use crate::platform::encrypted_for::encrypt_property_for;
use crate::platform::{DataContract, Document, Fetch, Identity};
use crate::{Error, Sdk};
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{Rng, SeedableRng};
-use dpp::dashcore::secp256k1::SecretKey;
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::methods::DocumentTypeBasicMethods;
use dpp::document::{DocumentV0, DocumentV0Getters, INITIAL_REVISION};
@@ -15,6 +12,9 @@ use dpp::moderation_charter::{
RESIGNATION_REQUEST_DOCUMENT_TYPE_NAME, SUBMITTED_CHARTER_DOCUMENT_TYPE_NAME,
};
use dpp::platform_value::{Bytes32, Identifier, Value};
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{Rng, SeedableRng};
+use dpp::secp256k1::SecretKey;
use std::collections::BTreeMap;
/// The property of both request types that carries the message, declared `encryptedFor` the
@@ -247,7 +247,6 @@ fn fresh_entropy() -> Bytes32 {
mod tests {
use super::*;
use crate::platform::encrypted_for::{decrypt_property, EncryptedPropertyEnvelope};
- use dpp::dashcore::secp256k1::PublicKey;
use dpp::data_contract::document_type::property_constraints::DocumentSystemValues;
use dpp::data_contract::validate_document::DataContractDocumentValidationMethodsV0;
use dpp::identity::contract_bounds::ContractBounds;
@@ -256,6 +255,7 @@ mod tests {
use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
use dpp::moderation_charter::MODERATION_CHARTERS_CONTRACT_ID;
use dpp::platform_value::BinaryData;
+ use dpp::secp256k1::PublicKey;
use dpp::system_data_contracts::{load_system_data_contract, SystemDataContract};
use dpp::version::PlatformVersion;
diff --git a/packages/rs-sdk/src/platform/transition/broadcast_identity.rs b/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
index 319fa8d5269..beffdd8c964 100644
--- a/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
+++ b/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
@@ -154,7 +154,7 @@ impl>
IdentityCreateTransition::try_from_identity_with_signer_and_private_key(
self,
asset_lock_proof,
- asset_lock_proof_private_key.inner.as_secret_bytes(),
+ &asset_lock_proof_private_key.inner.to_bytes(),
signer,
&NativeBlsModule,
user_fee_increase,
diff --git a/packages/rs-sdk/src/platform/transition/put_document.rs b/packages/rs-sdk/src/platform/transition/put_document.rs
index 171ae87faa9..bc9319bc357 100644
--- a/packages/rs-sdk/src/platform/transition/put_document.rs
+++ b/packages/rs-sdk/src/platform/transition/put_document.rs
@@ -4,8 +4,6 @@ use super::waitable::{wait_for_document_and_owner_balance, Waitable};
use crate::platform::documents::contest_fund::with_contest_fund_to_join;
use crate::platform::transition::put_settings::PutSettings;
use crate::{Error, Sdk};
-use dpp::dashcore::secp256k1::rand::rngs::StdRng;
-use dpp::dashcore::secp256k1::rand::{Rng, SeedableRng};
use dpp::data_contract::document_type::accessors::{DocumentTypeV0Getters, DocumentTypeV2Getters};
use dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dpp::data_contract::document_type::DocumentType;
@@ -14,6 +12,8 @@ use dpp::fee::Credits;
use dpp::identity::signer::Signer;
use dpp::identity::IdentityPublicKey;
use dpp::prelude::Identifier;
+use dpp::secp256k1::rand::rngs::StdRng;
+use dpp::secp256k1::rand::{Rng, SeedableRng};
use dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
use dpp::state_transition::batch_transition::BatchTransition;
use dpp::state_transition::StateTransition;
diff --git a/packages/rs-sdk/src/platform/transition/top_up_address.rs b/packages/rs-sdk/src/platform/transition/top_up_address.rs
index 88cdf2003dc..50c58f752e5 100644
--- a/packages/rs-sdk/src/platform/transition/top_up_address.rs
+++ b/packages/rs-sdk/src/platform/transition/top_up_address.rs
@@ -159,7 +159,7 @@ impl> TopUpAddress for AddressesWithBalances {
let state_transition = create_address_funding_from_asset_lock_transition(
asset_lock_proof,
- asset_lock_private_key.inner.as_secret_bytes(),
+ &asset_lock_private_key.inner.to_bytes(),
BTreeMap::new(),
self.clone(),
fee_strategy,
diff --git a/packages/rs-sdk/src/platform/transition/top_up_identity.rs b/packages/rs-sdk/src/platform/transition/top_up_identity.rs
index 3962ff00fcf..4ef41120ac7 100644
--- a/packages/rs-sdk/src/platform/transition/top_up_identity.rs
+++ b/packages/rs-sdk/src/platform/transition/top_up_identity.rs
@@ -81,7 +81,7 @@ impl TopUpIdentity for Identity {
let state_transition = IdentityTopUpTransition::try_from_identity_with_private_key(
self,
asset_lock_proof,
- asset_lock_proof_private_key.inner.as_secret_bytes(),
+ &asset_lock_proof_private_key.inner.to_bytes(),
user_fee_increase,
sdk.version(),
None,
diff --git a/packages/simple-signer/src/signer.rs b/packages/simple-signer/src/signer.rs
index 9a760c0db5e..3a10d345941 100644
--- a/packages/simple-signer/src/signer.rs
+++ b/packages/simple-signer/src/signer.rs
@@ -5,17 +5,17 @@ use dpp::address_funds::{AddressWitness, PlatformAddress};
use dpp::bincode::{Decode, Encode};
use dpp::bls;
-use dpp::dashcore::secp256k1::rand::SeedableRng;
-use dpp::dashcore::secp256k1::{PublicKey, SecretKey};
use dpp::dashcore::signer;
use dpp::ed25519_dalek::Signer as BlsSigner;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::signer::Signer;
use dpp::identity::{IdentityPublicKey, KeyType};
use dpp::platform_value::BinaryData;
+use dpp::secp256k1::rand::SeedableRng;
+use dpp::secp256k1::{PublicKey, SecretKey};
use dpp::state_transition::errors::InvalidIdentityPublicKeyTypeError;
use dpp::util::hash::ripemd160_sha256;
-use dpp::{dashcore, ed25519_dalek, ProtocolError};
+use dpp::{ed25519_dalek, ProtocolError};
use rand::RngCore;
use std::collections::BTreeMap;
use std::fmt::{Debug, Formatter};
@@ -100,7 +100,7 @@ impl SimpleSigner {
// Generate a valid secp256k1 secret key from random bytes
let mut seed = [0u8; 32];
rng.fill_bytes(&mut seed);
- let mut ecdsa_rng = dashcore::secp256k1::rand::rngs::StdRng::from_seed(seed);
+ let mut ecdsa_rng = dpp::secp256k1::rand::rngs::StdRng::from_seed(seed);
let secret_key = SecretKey::new(&mut ecdsa_rng);
// Derive compressed public key
diff --git a/packages/simple-signer/src/single_key_signer.rs b/packages/simple-signer/src/single_key_signer.rs
index 30cd749ed28..2b5d039387f 100644
--- a/packages/simple-signer/src/single_key_signer.rs
+++ b/packages/simple-signer/src/single_key_signer.rs
@@ -84,24 +84,6 @@ impl SingleKeySigner {
}
}
-impl Drop for SingleKeySigner {
- /// `secp256k1::SecretKey` is `Copy` and does not erase itself, and this
- /// signer is built per FFI call for keys that are deliberately never
- /// persisted, so the scalar is cleared when the handle is destroyed.
- ///
- /// This covers the copies this type owns. It does not reach the one the
- /// pinned `dashcore` makes internally: `signer::sign` parses its own
- /// `SecretKey` from the bytes handed to it and does not erase it before
- /// returning. Closing that gap needs erasing storage inside
- /// `rust-dashcore` itself.
- ///
- /// TODO(dashconnect-key-hygiene): upstream zeroizing parse/sign storage to
- /// `rust-dashcore`, then bump the pinned revision here.
- fn drop(&mut self) {
- self.private_key.inner.non_secure_erase();
- }
-}
-
#[async_trait]
impl Signer for SingleKeySigner {
async fn sign(
@@ -114,7 +96,7 @@ impl Signer for SingleKeySigner {
KeyType::ECDSA_SECP256K1 | KeyType::ECDSA_HASH160 => {
// Do not log private key material. Log data fingerprint only.
debug!(data_hex = %hex::encode(data), "SingleKeySigner: signing data");
- let secret_bytes = Zeroizing::new(self.private_key.inner.to_secret_bytes());
+ let secret_bytes = self.private_key.inner.to_bytes();
let signature = signer::sign(data, &secret_bytes[..])?;
Ok(signature.to_vec().into())
}
@@ -156,9 +138,8 @@ impl Signer for SingleKeySigner {
match identity_public_key.key_type() {
KeyType::ECDSA_SECP256K1 => {
// Compare full public key
- let public_key =
- dashcore::secp256k1::PublicKey::from_secret_key(&self.private_key.inner);
- let public_key_bytes = public_key.serialize();
+ let public_key = self.private_key.inner.public_key();
+ let public_key_bytes = public_key.to_compressed();
identity_public_key.data().as_slice() == public_key_bytes
}
@@ -166,9 +147,8 @@ impl Signer for SingleKeySigner {
// Compare hash160 of public key
use dpp::dashcore::hashes::{hash160, Hash};
- let public_key =
- dashcore::secp256k1::PublicKey::from_secret_key(&self.private_key.inner);
- let public_key_bytes = public_key.serialize();
+ let public_key = self.private_key.inner.public_key();
+ let public_key_bytes = public_key.to_compressed();
let public_key_hash160 = hash160::Hash::hash(&public_key_bytes)
.to_byte_array()
.to_vec();
@@ -220,7 +200,7 @@ mod tests {
let hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
let signer = SingleKeySigner::from_hex(hex, Network::Testnet)
.map_err(|e| format!("signer init failed: {}", e))?;
- assert_eq!(signer.private_key().inner.to_secret_bytes().len(), 32);
+ assert_eq!(signer.private_key().inner.to_bytes().len(), 32);
Ok(())
}
@@ -248,8 +228,7 @@ mod tests {
use dpp::dashcore::hashes::{hash160, Hash};
let signer = SingleKeySigner::new_from_slice(&[0x03; 32], Network::Testnet)?;
- let public_key =
- dashcore::secp256k1::PublicKey::from_secret_key(&signer.private_key.inner).serialize();
+ let public_key = signer.private_key.inner.public_key().to_compressed();
let full_key = identity_key(KeyType::ECDSA_SECP256K1, public_key.to_vec());
assert!(signer.can_sign_with(&full_key));
@@ -271,7 +250,7 @@ mod tests {
let hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
let signer = SingleKeySigner::from_string(hex, Network::Testnet)
.map_err(|e| format!("signer init failed: {}", e))?;
- assert_eq!(signer.private_key().inner.to_secret_bytes().len(), 32);
+ assert_eq!(signer.private_key().inner.to_bytes().len(), 32);
// Test WIF detection
let private_key = PrivateKey::from_byte_array(&[0x02; 32], Network::Testnet)
diff --git a/packages/strategy-tests/src/lib.rs b/packages/strategy-tests/src/lib.rs
index 9a8ad37941f..8ea99c421d9 100644
--- a/packages/strategy-tests/src/lib.rs
+++ b/packages/strategy-tests/src/lib.rs
@@ -761,7 +761,7 @@ impl Strategy {
let funding_transition =
AddressFundingFromAssetLockTransitionV0::try_from_asset_lock_with_signer_and_private_key(
asset_lock_proof,
- private_key.inner.to_secret_bytes().as_slice(),
+ private_key.inner.to_bytes().as_slice(),
BTreeMap::new(), // no additional inputs
outputs,
vec![AddressFundsFeeStrategyStep::ReduceOutput(0)],
@@ -2206,7 +2206,7 @@ impl Strategy {
let funding_transition =
AddressFundingFromAssetLockTransitionV0::try_from_asset_lock_with_signer_and_private_key(
asset_lock_proof,
- private_key.inner.to_secret_bytes().as_slice(),
+ private_key.inner.to_bytes().as_slice(),
BTreeMap::new(), // no additional inputs
outputs,
vec![AddressFundsFeeStrategyStep::ReduceOutput(0)],
diff --git a/packages/strategy-tests/src/transitions.rs b/packages/strategy-tests/src/transitions.rs
index bf678e6b412..751b4f28b89 100644
--- a/packages/strategy-tests/src/transitions.rs
+++ b/packages/strategy-tests/src/transitions.rs
@@ -32,7 +32,6 @@
//! each action.
use dpp::address_funds::PlatformAddress;
-use dpp::dashcore::secp256k1::SecretKey;
use dpp::dashcore::{
bls_sig_utils::BLSSignature, hash_types::CycleHash, InstantLock, OutPoint, ScriptBuf,
Transaction, TxIn, TxOut, Txid,
@@ -50,6 +49,7 @@ use dpp::identity::Purpose::{AUTHENTICATION, TRANSFER};
use dpp::identity::SecurityLevel::{CRITICAL, MASTER};
use dpp::identity::{Identity, IdentityPublicKey, KeyID, KeyType, Purpose, SecurityLevel};
use dpp::prelude::AssetLockProof;
+use dpp::secp256k1::SecretKey;
use dpp::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0;
use dpp::state_transition::identity_create_transition::IdentityCreateTransition;
use dpp::state_transition::identity_credit_transfer_transition::v0::IdentityCreditTransferTransitionV0;
@@ -1214,7 +1214,8 @@ where
.unwrap();
let secret_key = SecretKey::from_str(hex::encode(pk).as_str()).unwrap();
let asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::new(secret_key, Network::Mainnet),
+ PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ .expect("valid test secret key"),
amount_range,
rng,
);
diff --git a/packages/wasm-dpp/src/generate_temporary_ecdsa_private_key.rs b/packages/wasm-dpp/src/generate_temporary_ecdsa_private_key.rs
index 38854a3f64b..d3b5077c8d8 100644
--- a/packages/wasm-dpp/src/generate_temporary_ecdsa_private_key.rs
+++ b/packages/wasm-dpp/src/generate_temporary_ecdsa_private_key.rs
@@ -1,14 +1,11 @@
-use dpp::dashcore::secp256k1::rand::thread_rng;
-
-use dpp::dashcore::{secp256k1::SecretKey, Network, PrivateKey};
+use dpp::dashcore::ecdsa::EcdsaSecretKey;
+use dpp::dashcore::{Network, PrivateKey};
use wasm_bindgen::prelude::wasm_bindgen;
use wasm_bindgen::JsValue;
#[wasm_bindgen(js_name = generateTemporaryEcdsaPrivateKey)]
pub fn generate_temporary_ecdsa_private_key() -> JsValue {
- let mut rng = thread_rng();
-
- let secret_key = SecretKey::new(&mut rng);
+ let secret_key = EcdsaSecretKey::generate();
let one_time_private_key = PrivateKey::new(secret_key, Network::Testnet).to_string();
JsValue::from_str(&one_time_private_key)
diff --git a/packages/wasm-dpp2/src/public_key.rs b/packages/wasm-dpp2/src/public_key.rs
index 49faa6feef7..62e154466de 100644
--- a/packages/wasm-dpp2/src/public_key.rs
+++ b/packages/wasm-dpp2/src/public_key.rs
@@ -1,7 +1,8 @@
use crate::error::{WasmDppError, WasmDppResult};
use crate::impl_wasm_type_info;
use dpp::dashcore::key::constants;
-use dpp::dashcore::{PublicKey, secp256k1};
+use dpp::dashcore::PublicKey;
+use dpp::secp256k1;
use std::convert::TryInto;
use wasm_bindgen::prelude::wasm_bindgen;
@@ -57,7 +58,10 @@ impl PublicKeyWasm {
}
.map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
- Ok(PublicKeyWasm(PublicKey { compressed, inner }))
+ Ok(PublicKeyWasm(PublicKey {
+ compressed,
+ inner: inner.into(),
+ }))
}
#[wasm_bindgen(getter = "compressed")]
@@ -68,9 +72,9 @@ impl PublicKeyWasm {
#[wasm_bindgen(getter = "inner")]
pub fn inner(&self) -> Vec {
if self.0.compressed {
- self.0.inner.serialize().into()
+ self.0.inner.to_compressed().into()
} else {
- self.0.inner.serialize_uncompressed().into()
+ self.0.inner.to_uncompressed().into()
}
}
@@ -88,7 +92,8 @@ impl PublicKeyWasm {
self.0.compressed = true;
self.0.inner = secp256k1::PublicKey::from_byte_array_compressed(bytes)
- .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
+ .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?
+ .into();
} else {
if inner.len() != constants::UNCOMPRESSED_PUBLIC_KEY_SIZE {
return Err(WasmDppError::invalid_argument(format!(
@@ -104,7 +109,8 @@ impl PublicKeyWasm {
self.0.compressed = false;
self.0.inner = secp256k1::PublicKey::from_byte_array_uncompressed(bytes)
- .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
+ .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?
+ .into();
}
Ok(())
diff --git a/packages/wasm-sdk/src/encrypted_for.rs b/packages/wasm-sdk/src/encrypted_for.rs
index 5e86489b3c7..22ec507c310 100644
--- a/packages/wasm-sdk/src/encrypted_for.rs
+++ b/packages/wasm-sdk/src/encrypted_for.rs
@@ -5,7 +5,7 @@
use crate::error::WasmSdkError;
use crate::sdk::WasmSdk;
-use dash_sdk::dpp::dashcore::secp256k1::{PublicKey, SecretKey};
+use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Getters;
use dash_sdk::dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dash_sdk::dpp::data_contract::document_type::DocumentTypeRef;
diff --git a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
index e010c93be6d..7fc146e8d00 100644
--- a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
+++ b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
@@ -9,7 +9,7 @@ use dapi_grpc::platform::v0::{
WaitForStateTransitionResultResponse,
};
use dash_sdk::dpp::address_funds::AddressWitness;
-use dash_sdk::dpp::dashcore::{secp256k1, signer, Network};
+use dash_sdk::dpp::dashcore::{signer, Network};
use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Setters;
use dash_sdk::dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
use dash_sdk::dpp::data_contract::TokenConfiguration;
@@ -17,6 +17,7 @@ use dash_sdk::dpp::document::{DocumentV0, DocumentV0Setters};
use dash_sdk::dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dash_sdk::dpp::identity::{KeyType, PartialIdentity, Purpose, SecurityLevel};
use dash_sdk::dpp::platform_value::{platform_value, BinaryData, Value};
+use dash_sdk::dpp::secp256k1;
use dash_sdk::dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
use dash_sdk::dpp::state_transition::batch_transition::BatchTransition;
use dash_sdk::dpp::state_transition::StateTransition;
diff --git a/packages/wasm-sdk/src/wallet/dip14.rs b/packages/wasm-sdk/src/wallet/dip14.rs
index 1deb3fb80e1..d898e7c2acb 100644
--- a/packages/wasm-sdk/src/wallet/dip14.rs
+++ b/packages/wasm-sdk/src/wallet/dip14.rs
@@ -3,11 +3,12 @@
//! This module implements DIP14, which extends BIP32 to support 256-bit derivation indices
//! instead of the standard 31-bit limitation.
+use dash_sdk::dpp::dashcore::ecdsa::{EcdsaPublicKey, EcdsaSecretKey};
use dash_sdk::dpp::dashcore::hashes::{sha256, Hash};
-use dash_sdk::dpp::dashcore::secp256k1::{self, PublicKey, Scalar, SecretKey};
use dash_sdk::dpp::dashcore::Network;
use dash_sdk::dpp::key_wallet;
use dash_sdk::dpp::key_wallet::bip32::{ExtendedPrivKey, ExtendedPubKey};
+use dash_sdk::dpp::secp256k1::{self, Scalar, SecretKey};
use hmac::{Hmac, Mac};
use sha2::Sha512;
use std::convert::TryInto;
@@ -46,7 +47,7 @@ pub struct Dip14ExtendedPrivKey {
pub parent_fingerprint: [u8; 4],
pub child_number: [u8; 32], // 256-bit child number
pub chain_code: [u8; 32],
- pub private_key: SecretKey,
+ pub private_key: EcdsaSecretKey,
}
// DIP14 Version bytes
@@ -69,7 +70,7 @@ impl Dip14ExtendedPrivKey {
parent_fingerprint: key.parent_fingerprint.as_ref().try_into().unwrap(),
child_number,
chain_code: key.chain_code.as_ref().try_into().unwrap(),
- private_key: key.private_key,
+ private_key: key.private_key.clone(),
}
}
@@ -91,7 +92,7 @@ impl Dip14ExtendedPrivKey {
parent_fingerprint: key_wallet::bip32::Fingerprint::from_bytes(self.parent_fingerprint),
child_number,
chain_code: key_wallet::bip32::ChainCode::from_bytes(self.chain_code),
- private_key: self.private_key,
+ private_key: self.private_key.clone(),
})
}
@@ -104,12 +105,12 @@ impl Dip14ExtendedPrivKey {
if hardened {
// Hardened: 0x00 || ser256(k_parent) || ser256(i)
hmac.update(&[0x00]);
- hmac.update(&self.private_key.to_secret_bytes());
+ hmac.update(self.private_key.to_bytes().as_ref());
hmac.update(&ser256(index));
} else {
// Non-hardened: ser_P(point(k_parent)) || ser256(i)
- let public_key = PublicKey::from_secret_key(&self.private_key);
- hmac.update(&public_key.serialize());
+ let public_key = self.private_key.public_key();
+ hmac.update(&public_key.to_compressed());
hmac.update(&ser256(index));
}
@@ -143,13 +144,13 @@ impl Dip14ExtendedPrivKey {
// Perform scalar addition: child_key = parent_key + IL (mod n)
let child_key = self
.private_key
- .add_tweak(&tweak)
+ .add_tweak(&tweak.to_be_bytes())
.map_err(|e| Dip14Error::DerivationFailed(format!("Failed to add tweak: {}", e)))?;
// Calculate parent fingerprint (first 4 bytes of parent pubkey hash160)
- let parent_pubkey = PublicKey::from_secret_key(&self.private_key);
+ let parent_pubkey = self.private_key.public_key();
// Use sha256 then ripemd160 to create hash160
- let sha256_hash = sha256::Hash::hash(&parent_pubkey.serialize());
+ let sha256_hash = sha256::Hash::hash(&parent_pubkey.to_compressed());
let parent_pubkey_hash =
dash_sdk::dpp::dashcore::hashes::ripemd160::Hash::hash(&sha256_hash[..]);
let mut parent_fingerprint = [0u8; 4];
@@ -169,7 +170,7 @@ impl Dip14ExtendedPrivKey {
/// Get the extended public key
pub fn to_extended_pub_key(&self) -> Dip14ExtendedPubKey {
- let public_key = PublicKey::from_secret_key(&self.private_key);
+ let public_key = self.private_key.public_key();
Dip14ExtendedPubKey {
network: self.network,
@@ -189,7 +190,7 @@ pub struct Dip14ExtendedPubKey {
pub parent_fingerprint: [u8; 4],
pub child_number: [u8; 32], // 256-bit child number
pub chain_code: [u8; 32],
- pub public_key: PublicKey,
+ pub public_key: EcdsaPublicKey,
}
impl Dip14ExtendedPubKey {
diff --git a/packages/wasm-sdk/src/wallet/extended_derivation.rs b/packages/wasm-sdk/src/wallet/extended_derivation.rs
index 8a1de840261..049d044d437 100644
--- a/packages/wasm-sdk/src/wallet/extended_derivation.rs
+++ b/packages/wasm-sdk/src/wallet/extended_derivation.rs
@@ -113,14 +113,14 @@ fn derive_common_from_mnemonic(
.map_err(|e| WasmSdkError::generic(format!("Failed to derive key: {}", e)))?;
let xpub = bip32::ExtendedPubKey::from_priv(&derived_key);
- let private_key = dashcore::PrivateKey::new(derived_key.private_key, net);
+ let private_key = dashcore::PrivateKey::new(derived_key.private_key.clone(), net);
let public_key = private_key.public_key();
let address = dashcore::Address::p2pkh(&public_key, net);
Ok(CommonDerivation {
path: path.to_string(),
private_key_wif: private_key.to_wif(),
- private_key_hex: hex::encode(private_key.inner.to_secret_bytes()),
+ private_key_hex: hex::encode(private_key.inner.to_bytes().as_slice()),
public_key_hex: hex::encode(public_key.to_bytes()),
address: address.to_string(),
network: network.to_string(),
diff --git a/packages/wasm-sdk/src/wallet/key_derivation.rs b/packages/wasm-sdk/src/wallet/key_derivation.rs
index 9423e329d74..d9f67a68a4a 100644
--- a/packages/wasm-sdk/src/wallet/key_derivation.rs
+++ b/packages/wasm-sdk/src/wallet/key_derivation.rs
@@ -430,7 +430,7 @@ impl WasmSdk {
// Get public key
let public_key = private_key.public_key();
- let public_key_bytes = public_key.inner.serialize();
+ let public_key_bytes = public_key.inner.to_compressed();
// Get address
let address = dashcore::Address::p2pkh(&public_key, net);
@@ -484,7 +484,7 @@ impl WasmSdk {
// In v0.40-dev, ExtendedPrivKey might have a different structure
// Create a PrivateKey from the derived key
- let private_key = dashcore::PrivateKey::new(derived_key.private_key, net);
+ let private_key = dashcore::PrivateKey::new(derived_key.private_key.clone(), net);
// Get public key
let public_key = private_key.public_key();
@@ -495,7 +495,7 @@ impl WasmSdk {
Ok(PathDerivedKeyInfoWasm {
path,
private_key_wif: private_key.to_wif(),
- private_key_hex: hex::encode(private_key.inner.to_secret_bytes()),
+ private_key_hex: hex::encode(private_key.inner.to_bytes().as_slice()),
public_key: hex::encode(public_key.to_bytes()),
address: address.to_string(),
network,
diff --git a/packages/wasm-sdk/src/wallet/key_generation.rs b/packages/wasm-sdk/src/wallet/key_generation.rs
index 8830b5b13e3..82a366c81ca 100644
--- a/packages/wasm-sdk/src/wallet/key_generation.rs
+++ b/packages/wasm-sdk/src/wallet/key_generation.rs
@@ -6,8 +6,8 @@ use crate::error::WasmSdkError;
use crate::impl_wasm_serde_conversions;
use crate::sdk::WasmSdk;
use dash_sdk::dpp::dashcore::hashes::{sha256, Hash};
-use dash_sdk::dpp::dashcore::secp256k1::SecretKey;
use dash_sdk::dpp::dashcore::{Address, Network, PrivateKey, PublicKey};
+use dash_sdk::dpp::secp256k1::SecretKey;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
use wasm_bindgen::prelude::*;
@@ -68,12 +68,12 @@ impl WasmSdk {
network_label: &str,
) -> Result {
let public_key = private_key.public_key();
- let public_key_bytes = public_key.inner.serialize();
+ let public_key_bytes = public_key.inner.to_compressed();
let address = Address::p2pkh(&public_key, network);
Ok(KeyPair {
private_key_wif: private_key.to_wif(),
- private_key_hex: hex::encode(private_key.inner.to_secret_bytes()),
+ private_key_hex: hex::encode(private_key.inner.to_bytes().as_slice()),
public_key: hex::encode(public_key_bytes),
address: address.to_string(),
network: network_label.to_string(),
@@ -220,11 +220,10 @@ impl WasmSdk {
let hash = sha256::Hash::hash(message_bytes);
// Sign the hash
- let secret_key = SecretKey::from_secret_bytes(private_key.inner.to_secret_bytes())
+ let secret_key = SecretKey::from_secret_bytes(*private_key.inner.to_bytes())
.map_err(|e| WasmSdkError::invalid_argument(format!("Invalid secret key: {}", e)))?;
- let message_hash =
- dash_sdk::dpp::dashcore::secp256k1::Message::from_digest(hash.to_byte_array());
+ let message_hash = dash_sdk::dpp::secp256k1::Message::from_digest(hash.to_byte_array());
let signature = secret_key.sign_ecdsa(message_hash);
Ok(hex::encode(signature.serialize_compact()))
From 43795f5250e520d28ab3e756dc6a3f23f10cdbbb Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:26:26 +0000
Subject: [PATCH 06/21] fix: adapt zeroizing key exports to signing slices
---
packages/rs-dpp/src/state_transition/mod.rs | 6 +++---
packages/rs-platform-wallet/Cargo.toml | 9 +--------
.../rs-sdk/src/platform/transition/broadcast_identity.rs | 2 +-
.../rs-sdk/src/platform/transition/top_up_address.rs | 2 +-
.../rs-sdk/src/platform/transition/top_up_identity.rs | 2 +-
5 files changed, 7 insertions(+), 14 deletions(-)
diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs
index 058de23dca3..616a18ae75d 100644
--- a/packages/rs-dpp/src/state_transition/mod.rs
+++ b/packages/rs-dpp/src/state_transition/mod.rs
@@ -2185,10 +2185,10 @@ impl StateTransition {
///
/// 1. `digest = double_sha256(self.signable_bytes()?)`
/// 2. `signer.sign_ecdsa(path, digest).await` → non-recoverable
- /// `(secp256k1::ecdsa::Signature, secp256k1::PublicKey)`.
+ /// `(EcdsaSignature, EcdsaPublicKey)`.
/// 3. Recover the recovery id by trying all four candidates against the
- /// returned public key (libsecp256k1 normalises both signing paths to
- /// low-s form so the 64-byte `r||s` payload is bit-identical).
+ /// returned public key. Byte parity requires a signer that uses the
+ /// same deterministic nonce without low-R grinding.
/// 4. Serialise as a 65-byte compact recoverable signature with the
/// `compressed` prefix convention used by Core signatures — i.e.
/// `[recovery_id + 27 + 4, r (32) || s (32)]`.
diff --git a/packages/rs-platform-wallet/Cargo.toml b/packages/rs-platform-wallet/Cargo.toml
index bb5e83480f3..7da2bb5ce6c 100644
--- a/packages/rs-platform-wallet/Cargo.toml
+++ b/packages/rs-platform-wallet/Cargo.toml
@@ -17,14 +17,7 @@ key-wallet = { workspace = true }
key-wallet-manager = { workspace = true, features = [] }
dash-spv = { workspace = true }
-# Core dependencies.
-#
-# `base64` is NOT among dashcore's default features (those are `secp-recovery`
-# and `bincode`), but `MessageSignature::to_base64` / `from_base64` are gated on
-# it — and base64 is the only wire form a classic Dash signed message has, the
-# one CrowdNode and Dash Core's `verifymessage` RPC accept. `secp-recovery`
-# arrives by default and carries `secp256k1/recovery`, which
-# `RecoverableSignature` / `recover_ecdsa` need. See `wallet::core::sign_message`.
+# Core dependencies. Classic Dash signed messages use the optional base64 encoding.
dashcore = { workspace = true, features = ["base64"] }
# Standard dependencies
diff --git a/packages/rs-sdk/src/platform/transition/broadcast_identity.rs b/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
index beffdd8c964..1c3feb25dfb 100644
--- a/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
+++ b/packages/rs-sdk/src/platform/transition/broadcast_identity.rs
@@ -154,7 +154,7 @@ impl>
IdentityCreateTransition::try_from_identity_with_signer_and_private_key(
self,
asset_lock_proof,
- &asset_lock_proof_private_key.inner.to_bytes(),
+ &asset_lock_proof_private_key.inner.to_bytes()[..],
signer,
&NativeBlsModule,
user_fee_increase,
diff --git a/packages/rs-sdk/src/platform/transition/top_up_address.rs b/packages/rs-sdk/src/platform/transition/top_up_address.rs
index 50c58f752e5..da018b38c67 100644
--- a/packages/rs-sdk/src/platform/transition/top_up_address.rs
+++ b/packages/rs-sdk/src/platform/transition/top_up_address.rs
@@ -159,7 +159,7 @@ impl> TopUpAddress for AddressesWithBalances {
let state_transition = create_address_funding_from_asset_lock_transition(
asset_lock_proof,
- &asset_lock_private_key.inner.to_bytes(),
+ &asset_lock_private_key.inner.to_bytes()[..],
BTreeMap::new(),
self.clone(),
fee_strategy,
diff --git a/packages/rs-sdk/src/platform/transition/top_up_identity.rs b/packages/rs-sdk/src/platform/transition/top_up_identity.rs
index 4ef41120ac7..1c627c77a29 100644
--- a/packages/rs-sdk/src/platform/transition/top_up_identity.rs
+++ b/packages/rs-sdk/src/platform/transition/top_up_identity.rs
@@ -81,7 +81,7 @@ impl TopUpIdentity for Identity {
let state_transition = IdentityTopUpTransition::try_from_identity_with_private_key(
self,
asset_lock_proof,
- &asset_lock_proof_private_key.inner.to_bytes(),
+ &asset_lock_proof_private_key.inner.to_bytes()[..],
user_fee_increase,
sdk.version(),
None,
From 1e8767074d39b3af7cd894417e48d91b3d4697fe Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:27:07 +0000
Subject: [PATCH 07/21] fix(dpp): preserve identity public key parse errors
---
.../identity_public_key/v0/methods/mod.rs | 12 ++++-
packages/rs-dpp/tests/ecdsa_compatibility.rs | 46 ++++++++++++++++++-
2 files changed, 55 insertions(+), 3 deletions(-)
diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
index 9f30211a538..b296df0d815 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
@@ -5,6 +5,7 @@ use crate::ed25519_dalek;
use crate::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
use crate::identity::KeyType;
+use crate::util::ecdsa::parse_public_key;
use crate::util::hash::ripemd160_sha256;
use crate::ProtocolError;
use anyhow::anyhow;
@@ -45,8 +46,15 @@ pub(in crate::identity::identity_public_key) fn public_key_hash_for_key_data(
KeyType::ECDSA_SECP256K1 => {
let key = match data.len() {
// TODO: We need to update schema and tests for 65 len keys
- 65 | 33 => ECDSAPublicKey::from_slice(data.as_slice())
- .map_err(|e| anyhow!("unable to create pub key - {}", e))?,
+ 65 | 33 => {
+ // Preserve historical SEC1 validation errors and hash the supplied encoding.
+ let inner = parse_public_key(data.as_slice())
+ .map_err(|e| anyhow!("unable to create pub key - {}", e))?;
+ ECDSAPublicKey {
+ compressed: data.len() == 33,
+ inner: inner.into(),
+ }
+ }
_ => {
return Err(ProtocolError::ParsingError(format!(
"the key length is invalid: {} Allowed sizes: 33 or 65 bytes for ecdsa key",
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
index cb188b4761f..df3e23525bb 100644
--- a/packages/rs-dpp/tests/ecdsa_compatibility.rs
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -7,7 +7,9 @@ mod vectors;
use dpp::address_funds::{AddressWitness, PlatformAddress};
use dpp::dashcore::hashes::{hash160, Hash};
-use dpp::identity::KeyType;
+use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
+use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
+use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
use dpp::serialization::PlatformMessageSignable;
use dpp::util::ecdsa::{
parse_compact_signature, parse_public_key, sign, verify_data_signature, verify_hash_signature,
@@ -230,3 +232,45 @@ fn should_preserve_multisig_malformed_public_key_error() {
error => panic!("unexpected error: {error}"),
}
}
+
+#[test]
+fn should_preserve_identity_public_key_hash_errors_and_encoding() {
+ let (_, _, public_key) = fixture();
+ let parsed = parse_public_key(&public_key).unwrap();
+ let identity_key = |bytes: Vec| {
+ IdentityPublicKey::V0(IdentityPublicKeyV0 {
+ id: 0,
+ purpose: Purpose::AUTHENTICATION,
+ security_level: SecurityLevel::HIGH,
+ contract_bounds: None,
+ key_type: KeyType::ECDSA_SECP256K1,
+ data: bytes.into(),
+ read_only: false,
+ disabled_at: None,
+ })
+ };
+ for bytes in [public_key, parsed.serialize_uncompressed().to_vec()] {
+ assert_eq!(
+ identity_key(bytes.clone()).public_key_hash().unwrap(),
+ hash160::Hash::hash(&bytes).to_byte_array()
+ );
+ }
+ let mut malformed = vec![0xff; 33];
+ malformed[0] = 2;
+ assert_eq!(
+ identity_key(malformed)
+ .public_key_hash()
+ .unwrap_err()
+ .to_string(),
+ "Generic Error: unable to create pub key - key secp256k1 error"
+ );
+ let mut hybrid = parsed.serialize_uncompressed().to_vec();
+ hybrid[0] = 6;
+ assert_eq!(
+ identity_key(hybrid)
+ .public_key_hash()
+ .unwrap_err()
+ .to_string(),
+ "Generic Error: unable to create pub key - key prefix invalid: 6"
+ );
+}
From 4625a620efdaf99646933dfc5987ed6eb59fb12a Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:27:34 +0000
Subject: [PATCH 08/21] fix(sdk): remove redundant voucher key reference
---
packages/rs-sdk/src/platform/dashpay/invitation.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/packages/rs-sdk/src/platform/dashpay/invitation.rs b/packages/rs-sdk/src/platform/dashpay/invitation.rs
index ca0953712df..23f29a33744 100644
--- a/packages/rs-sdk/src/platform/dashpay/invitation.rs
+++ b/packages/rs-sdk/src/platform/dashpay/invitation.rs
@@ -904,7 +904,7 @@ impl Sdk {
placeholder.put_to_platform_and_wait_for_response_with_private_key(
self,
proof.clone(),
- &voucher_priv,
+ voucher_priv,
identity_signer,
s,
)
From 374d0c6e0a8a33a89740a9670284ac9c286a3c56 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:27:54 +0000
Subject: [PATCH 09/21] fix(wallet): convert provider keys at crypto API
boundaries
Co-Authored-By: Claude GPT-6
---
.../src/wallet/identity/network/contact_requests.rs | 2 +-
.../src/wallet/identity/network/invitation.rs | 2 +-
.../src/wallet/identity/network/seed_binding.rs | 2 +-
.../src/wallet/provider_key_at_index.rs | 11 ++++++-----
4 files changed, 9 insertions(+), 8 deletions(-)
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
index c860355489a..e6e64e3542c 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
@@ -3011,7 +3011,7 @@ impl DashPayView<'_, B> {
}
};
let valid = verify_auto_accept_proof_with_pubkey(
- &pubkey,
+ &pubkey.into(),
proof,
&request.sender_id,
&owner,
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
index 0ef5b91c25f..2e475a55f86 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
@@ -491,7 +491,7 @@ mod tests {
async fn public_key(
&self,
_path: &key_wallet::DerivationPath,
- ) -> Result {
+ ) -> Result {
unreachable!("the durability gate must fire before any key derivation")
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
index b7eb81cf316..212b901a022 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
@@ -1256,7 +1256,7 @@ mod tests {
async fn public_key(
&self,
_path: &key_wallet::DerivationPath,
- ) -> Result {
+ ) -> Result {
unreachable!("the seed-binding gate must fire before any key derivation")
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs b/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
index 284d8c694ad..644e8ddb6e7 100644
--- a/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
+++ b/packages/rs-platform-wallet/src/wallet/provider_key_at_index.rs
@@ -74,7 +74,7 @@
//! are scrubbed when dropped.
use dashcore::bls_sig_utils::BlsScheme;
-use dashcore::eddsa::{EddsaPkBytes, EddsaPkHash};
+use dashcore::eddsa::{EddsaPkBytes, EddsaPkHash, EddsaSecretKey};
use key_wallet::account::derivation::AccountDerivation;
use key_wallet::account::{AccountType, BLSAccount, EdDSAAccount};
use key_wallet::bip32::{ChildNumber, ExtendedPrivKey};
@@ -156,7 +156,7 @@ pub fn derive_platform_node_public_keys(
"failed to derive Ed25519 platform-node key at index {index}: {e}"
))
})?;
- let public_key: [u8; 32] = signing_key.public_key().to_bytes();
+ let public_key: [u8; 32] = EddsaSecretKey::from(&signing_key).public_key().to_bytes();
// The 20-byte platform node id = SHA256(ed25519 pubkey)[..20] — the
// Tenderdash/CometBFT convention (rust-dashcore #884) that a ProRegTx
// `platform_node_id` field carries, NOT a hash160.
@@ -567,7 +567,8 @@ impl PlatformWallet {
"failed to derive Ed25519 platform-node key at index {index}: {e}"
))
})?;
- let verifying_bytes: [u8; 32] = signing_key.public_key().to_bytes();
+ let verifying_bytes: [u8; 32] =
+ EddsaSecretKey::from(&signing_key).public_key().to_bytes();
let public_key_bytes = verifying_bytes.to_vec();
// The 20-byte platform node id = SHA256(ed25519 pubkey)[..20]
@@ -781,7 +782,7 @@ mod tests {
.expect("platform_node_key_at");
assert_eq!(
k.public_key,
- via_api.public_key().to_bytes(),
+ EddsaSecretKey::from(&via_api).public_key().to_bytes(),
"snapshot pubkey must equal platform_node_key_at at {i}"
);
}
@@ -806,7 +807,7 @@ mod tests {
// The snapshot's index-0 public key corresponds to that golden secret.
assert_eq!(
keys[0].public_key,
- sk0.public_key().to_bytes(),
+ EddsaSecretKey::from(&sk0).public_key().to_bytes(),
"snapshot index-0 pubkey must match the golden secret's public key"
);
// Golden pubkey + Tenderdash node-id (SHA256[..20]) for mainnet
From dde93e9a67f30d5945936c27fc61a5588470c671 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:29:05 +0000
Subject: [PATCH 10/21] fix(wallet): use native secret export autoderef
Co-Authored-By: Claude GPT-6
---
.../src/wallet/identity/network/contact_requests.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
index e6e64e3542c..aaff5afd70d 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
@@ -248,7 +248,7 @@ impl ContactCryptoProvider for SeedCryptoProvider {
PlatformWalletError::InvalidIdentityData(format!("test accountRef derive: {e}"))
})?;
Ok(platform_encryption::calculate_account_reference(
- &*xprv.private_key.to_bytes(),
+ &xprv.private_key.to_bytes(),
compact_xpub,
account_index,
version,
@@ -266,7 +266,7 @@ impl ContactCryptoProvider for SeedCryptoProvider {
})?;
Ok(platform_encryption::unmask_account_reference(
account_reference,
- &*xprv.private_key.to_bytes(),
+ &xprv.private_key.to_bytes(),
compact_xpub,
))
}
From 6aee11e7223e5e2282b4a2ed61d15b4fcd7e053b Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:29:50 +0000
Subject: [PATCH 11/21] fix: adapt WASM encryption keys and seeded node test
keys
---
.../rs-drive-abci/src/execution/check_tx/v0/mod.rs | 3 ++-
.../state_transitions/identity_update/mod.rs | 2 +-
.../shield_from_asset_lock/tests.rs | 2 +-
packages/wasm-sdk/src/encrypted_for.rs | 13 ++++++++-----
packages/wasm-sdk/src/moderation_charters.rs | 13 +++----------
5 files changed, 15 insertions(+), 18 deletions(-)
diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
index dc3d9ff14e8..88540c43801 100644
--- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
@@ -296,7 +296,8 @@ mod tests {
use simple_signer::signer::SimpleSigner;
use dpp::consensus::ConsensusError;
- use dpp::dashcore::{key::Keypair, signer, Network, PrivateKey};
+ use dpp::dashcore::{signer, Network, PrivateKey};
+ use dpp::secp256k1::Keypair;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::document_type::random_document::{
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
index 7581eedd6db..cdf34a96a22 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
@@ -140,7 +140,6 @@ mod tests {
use dpp::consensus::codes::ErrorWithCode;
use dpp::consensus::ConsensusError;
use dpp::dash_to_credits;
- use dpp::dashcore::key::Keypair;
use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::identifier::Identifier;
@@ -152,6 +151,7 @@ mod tests {
use dpp::identity::{KeyType, Purpose, SecurityLevel};
use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng;
use dpp::secp256k1::rand::SeedableRng as _;
+ use dpp::secp256k1::Keypair;
use dpp::serialization::{PlatformSerializable, Signable};
use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0;
use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
index bf4f963a990..2b23e2db76f 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/tests.rs
@@ -625,7 +625,7 @@ mod tests {
let transition = create_signed_shield_from_asset_lock_transition(
asset_lock_proof,
- &wrong_private_key.inner.to_bytes(), // Wrong key
+ wrong_private_key.inner.to_bytes().as_slice(), // Wrong key
vec![create_dummy_serialized_action()],
5000,
[42u8; 32],
diff --git a/packages/wasm-sdk/src/encrypted_for.rs b/packages/wasm-sdk/src/encrypted_for.rs
index 22ec507c310..d9dcdb6e4e4 100644
--- a/packages/wasm-sdk/src/encrypted_for.rs
+++ b/packages/wasm-sdk/src/encrypted_for.rs
@@ -5,7 +5,6 @@
use crate::error::WasmSdkError;
use crate::sdk::WasmSdk;
-use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Getters;
use dash_sdk::dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dash_sdk::dpp::data_contract::document_type::DocumentTypeRef;
@@ -14,6 +13,7 @@ use dash_sdk::dpp::document::DocumentV0Getters;
use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dash_sdk::dpp::identity::{IdentityPublicKey, KeyType};
use dash_sdk::dpp::platform_value::Value;
+use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::platform::encrypted_for::{
decrypt_property, encrypt_property, EncryptedPropertyEnvelope, EncryptionKeys,
};
@@ -154,10 +154,13 @@ fn secp256k1_public_key(key: &IdentityPublicKey, field: &str) -> Result Result {
- Ok(PrivateKeyWasm::try_from_options(options, field)?
- .inner()
- .inner)
+pub(crate) fn secret_key_from_options(
+ options: &JsValue,
+ field: &str,
+) -> Result {
+ let key = PrivateKeyWasm::try_from_options(options, field)?.inner();
+ SecretKey::from_secret_bytes(*key.inner.to_bytes())
+ .map_err(|e| WasmSdkError::invalid_argument(format!("{field}: {e}")))
}
/// `document` with its properties coerced to the types its document type declares: a document
diff --git a/packages/wasm-sdk/src/moderation_charters.rs b/packages/wasm-sdk/src/moderation_charters.rs
index 07104258fe2..2036a99373a 100644
--- a/packages/wasm-sdk/src/moderation_charters.rs
+++ b/packages/wasm-sdk/src/moderation_charters.rs
@@ -3,7 +3,7 @@
//! leader. Thin bindings over `dash_sdk::platform::moderation_charters`, where every read is a
//! proved document query on the system contract.
-use crate::encrypted_for::message_from_options;
+use crate::encrypted_for::{message_from_options, secret_key_from_options};
use crate::error::WasmSdkError;
use crate::sdk::WasmSdk;
use dash_sdk::dpp::moderation_charter::{
@@ -24,7 +24,6 @@ use wasm_dpp2::data_contract::document::DocumentWasm;
use wasm_dpp2::identifier::{IdentifierLikeJs, IdentifierWasm};
use wasm_dpp2::identity::IdentityWasm;
use wasm_dpp2::utils::{try_from_options_optional_with, try_to_u32};
-use wasm_dpp2::PrivateKeyWasm;
#[wasm_bindgen(typescript_custom_section)]
const MODERATION_CHARTERS_TS: &'static str = r#"
@@ -403,10 +402,7 @@ impl WasmSdk {
let submitted_charter_id: Identifier =
IdentifierWasm::try_from_options(&options, "submittedCharterId")?.into();
let message = message_from_options(&options, "message")?;
- let writer_encryption_key =
- PrivateKeyWasm::try_from_options(&options, "writerEncryptionKey")?
- .inner()
- .inner;
+ let writer_encryption_key = secret_key_from_options(&options, "writerEncryptionKey")?;
let writer = self.writer_from_options(&options).await?;
let request = self
.as_ref()
@@ -433,10 +429,7 @@ impl WasmSdk {
let elected_charter_id: Identifier =
IdentifierWasm::try_from_options(&options, "electedCharterId")?.into();
let message = message_from_options(&options, "message")?;
- let writer_encryption_key =
- PrivateKeyWasm::try_from_options(&options, "writerEncryptionKey")?
- .inner()
- .inner;
+ let writer_encryption_key = secret_key_from_options(&options, "writerEncryptionKey")?;
let writer = self.writer_from_options(&options).await?;
let request = self
.as_ref()
From 4ad35d0b4810019993e7b5d4b04017da46d06984 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:31:08 +0000
Subject: [PATCH 12/21] fix(wasm): retain private key owner during scalar
conversion
---
packages/wasm-sdk/src/encrypted_for.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/packages/wasm-sdk/src/encrypted_for.rs b/packages/wasm-sdk/src/encrypted_for.rs
index d9dcdb6e4e4..b4a8f5330a2 100644
--- a/packages/wasm-sdk/src/encrypted_for.rs
+++ b/packages/wasm-sdk/src/encrypted_for.rs
@@ -158,8 +158,8 @@ pub(crate) fn secret_key_from_options(
options: &JsValue,
field: &str,
) -> Result {
- let key = PrivateKeyWasm::try_from_options(options, field)?.inner();
- SecretKey::from_secret_bytes(*key.inner.to_bytes())
+ let key = PrivateKeyWasm::try_from_options(options, field)?;
+ SecretKey::from_secret_bytes(*key.inner().inner.to_bytes())
.map_err(|e| WasmSdkError::invalid_argument(format!("{field}: {e}")))
}
From a9018cdfc8b0fa0d0350180cc2b83c7ea6fbd2bf Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:31:05 +0000
Subject: [PATCH 13/21] fix(ffi): preserve key ownership and use typed scalar
parsers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
.../rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs | 2 +-
.../src/identity_registration_with_signer.rs | 2 +-
packages/rs-sdk-ffi/src/address/transitions/transfer.rs | 4 ++--
packages/rs-sdk-ffi/src/address/transitions/withdraw.rs | 4 ++--
packages/rs-sdk-ffi/src/identity/create_from_addresses.rs | 4 ++--
packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs | 4 ++--
6 files changed, 10 insertions(+), 10 deletions(-)
diff --git a/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs b/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
index 748e7aeb30f..f82146dcfd9 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs
@@ -381,7 +381,7 @@ pub unsafe extern "C" fn dash_sdk_derive_identity_keys_from_mnemonic(
let dash_private = DashPrivateKey {
compressed: true,
network: kw_network,
- inner: derived.private_key,
+ inner: derived.private_key.clone(),
};
let wif_cstring = match CString::new(dash_private.to_wif()) {
Ok(s) => s,
diff --git a/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs b/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
index b09ac132013..687d2955307 100644
--- a/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
+++ b/packages/rs-platform-wallet-ffi/src/identity_registration_with_signer.rs
@@ -696,7 +696,7 @@ pub unsafe extern "C" fn platform_wallet_derive_identity_keys_for_index(
let dash_private = DashPrivateKey {
compressed: true,
network,
- inner: ext_priv.private_key,
+ inner: ext_priv.private_key.clone(),
};
let wif_cstring = match CString::new(dash_private.to_wif()) {
Ok(s) => s,
diff --git a/packages/rs-sdk-ffi/src/address/transitions/transfer.rs b/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
index 304285a93d8..8319a5984a8 100644
--- a/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
+++ b/packages/rs-sdk-ffi/src/address/transitions/transfer.rs
@@ -236,8 +236,8 @@ unsafe fn dash_sdk_address_transfer_funds_inner(
};
// Parse private key (32 bytes)
- let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
+ let pk_bytes = &*input.private_key.cast::<[u8; 32]>();
+ let private_key = match PrivateKey::from_byte_array(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
diff --git a/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs b/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
index d451b8553bf..903aa14a650 100644
--- a/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
+++ b/packages/rs-sdk-ffi/src/address/transitions/withdraw.rs
@@ -208,8 +208,8 @@ unsafe fn dash_sdk_address_withdraw_funds_inner(
};
// Parse private key (32 bytes)
- let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
+ let pk_bytes = &*input.private_key.cast::<[u8; 32]>();
+ let private_key = match PrivateKey::from_byte_array(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
diff --git a/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs b/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
index 65c118c5ecc..ec27b06292e 100644
--- a/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
+++ b/packages/rs-sdk-ffi/src/identity/create_from_addresses.rs
@@ -168,8 +168,8 @@ unsafe fn dash_sdk_identity_create_from_addresses_inner(
};
// Parse private key (32 bytes)
- let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let private_key = match PrivateKey::from_slice(pk_bytes, Network::Testnet) {
+ let pk_bytes = &*input.private_key.cast::<[u8; 32]>();
+ let private_key = match PrivateKey::from_byte_array(pk_bytes, Network::Testnet) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
diff --git a/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs b/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
index 2922a5635be..b1e87470b37 100644
--- a/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
+++ b/packages/rs-sdk-ffi/src/identity/top_up_from_addresses.rs
@@ -149,8 +149,8 @@ unsafe fn dash_sdk_identity_top_up_from_addresses_inner(
};
// Parse private key (32 bytes)
- let pk_bytes = std::slice::from_raw_parts(input.private_key, 32);
- let private_key = match PrivateKey::from_slice(pk_bytes, wrapper.sdk.network) {
+ let pk_bytes = &*input.private_key.cast::<[u8; 32]>();
+ let private_key = match PrivateKey::from_byte_array(pk_bytes, wrapper.sdk.network) {
Ok(sk) => sk,
Err(e) => {
return DashSDKResult::error(DashSDKError::new(
From 5c5dfa02d0658fe2b087cf7e71b18d798eff57b5 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:32:36 +0000
Subject: [PATCH 14/21] style(wasm): apply crate edition import ordering
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
packages/wasm-dpp2/src/public_key.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/packages/wasm-dpp2/src/public_key.rs b/packages/wasm-dpp2/src/public_key.rs
index 62e154466de..52a1a421cc6 100644
--- a/packages/wasm-dpp2/src/public_key.rs
+++ b/packages/wasm-dpp2/src/public_key.rs
@@ -1,7 +1,7 @@
use crate::error::{WasmDppError, WasmDppResult};
use crate::impl_wasm_type_info;
-use dpp::dashcore::key::constants;
use dpp::dashcore::PublicKey;
+use dpp::dashcore::key::constants;
use dpp::secp256k1;
use std::convert::TryInto;
use wasm_bindgen::prelude::wasm_bindgen;
From 549d013a75886a995bdc392f3aeab123c4cd02dd Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 12:34:36 +0000
Subject: [PATCH 15/21] test(dpp): assert transparent legacy key parsing errors
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
packages/rs-dpp/tests/ecdsa_compatibility.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
index df3e23525bb..4628dbf9dbe 100644
--- a/packages/rs-dpp/tests/ecdsa_compatibility.rs
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -262,7 +262,7 @@ fn should_preserve_identity_public_key_hash_errors_and_encoding() {
.public_key_hash()
.unwrap_err()
.to_string(),
- "Generic Error: unable to create pub key - key secp256k1 error"
+ "unable to create pub key - key secp256k1 error"
);
let mut hybrid = parsed.serialize_uncompressed().to_vec();
hybrid[0] = 6;
@@ -271,6 +271,6 @@ fn should_preserve_identity_public_key_hash_errors_and_encoding() {
.public_key_hash()
.unwrap_err()
.to_string(),
- "Generic Error: unable to create pub key - key prefix invalid: 6"
+ "unable to create pub key - key prefix invalid: 6"
);
}
From 675a7ea9486fc46fb9b81e954dc9238a4e864bb0 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 13:33:54 +0000
Subject: [PATCH 16/21] refactor(dpp): use Core ECDSA verification directly
Remove the local compatibility adapter while preserving signature acceptance, key encodings and fee operations. Adopt upstream diagnostic text and error precedence; these descriptions are carried in ABCI info, outside the Tenderdash results hash.
Co-Authored-By: OpenAI Codex
---
.../src/address_funds/platform_address.rs | 16 +-
.../identity_public_key/v0/methods/mod.rs | 12 +-
packages/rs-dpp/src/signing.rs | 2 +-
packages/rs-dpp/src/state_transition/mod.rs | 4 +-
packages/rs-dpp/src/util/ecdsa.rs | 88 ---------
packages/rs-dpp/src/util/mod.rs | 1 -
packages/rs-dpp/tests/ecdsa_compatibility.rs | 180 +++++++++++++-----
.../transform_into_action/v0/mod.rs | 2 +-
.../identity_create/state/v0/mod.rs | 2 +-
.../transform_into_action/v0/mod.rs | 2 +-
.../transform_into_action/v0/mod.rs | 2 +-
.../transform_into_action/v1/mod.rs | 2 +-
12 files changed, 147 insertions(+), 166 deletions(-)
delete mode 100644 packages/rs-dpp/src/util/ecdsa.rs
diff --git a/packages/rs-dpp/src/address_funds/platform_address.rs b/packages/rs-dpp/src/address_funds/platform_address.rs
index 715bce40668..efa7ee96109 100644
--- a/packages/rs-dpp/src/address_funds/platform_address.rs
+++ b/packages/rs-dpp/src/address_funds/platform_address.rs
@@ -5,18 +5,18 @@ use crate::prelude::AddressNonce;
use crate::serialization::JsonConvertible;
#[cfg(all(feature = "value-conversion", feature = "serde-conversion"))]
use crate::serialization::ValueConvertible;
-use crate::util::ecdsa;
use crate::ProtocolError;
use bech32::{Bech32m, Hrp};
use bincode::{Decode, DecodeUntrusted, Encode};
use dashcore::address::Payload;
use dashcore::blockdata::script::ScriptBuf;
use dashcore::hashes::{sha256d, Hash};
-use dashcore::{Address, Network, PrivateKey, PubkeyHash, ScriptHash};
+use dashcore::{
+ sign_message, signer, Address, Network, PrivateKey, PubkeyHash, PublicKey, ScriptHash,
+};
use platform_serialization_derive::{
PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize,
};
-use secp256k1::Message;
#[cfg(feature = "serde-conversion")]
use serde::{Deserialize, Serialize};
use std::convert::TryFrom;
@@ -491,7 +491,7 @@ impl PlatformAddress {
// This saves 33 bytes per witness (no need to include pubkey)
// at a ~4% CPU cost increase (recovery vs verify).
let data_hash = dashcore::signer::double_sha(signable_bytes);
- ecdsa::verify_hash_signature(&data_hash, signature.as_slice(), pubkey_hash)
+ signer::verify_hash_signature(&data_hash, signature.as_slice(), pubkey_hash)
.map_err(|e| {
ProtocolError::AddressWitnessError(format!(
"P2PKH signature verification failed: {}",
@@ -547,12 +547,12 @@ impl PlatformAddress {
let mut signature_verifications: u16 = 0;
let signable_bytes_hash = sha256d::Hash::hash(signable_bytes).to_byte_array();
- let msg = Message::from_digest(signable_bytes_hash);
while sig_idx < valid_signatures.len() && pubkey_idx < pubkeys.len() {
signature_verifications += 1;
- let sig = ecdsa::parse_compact_signature(valid_signatures[sig_idx].as_slice())
+ let sig = sign_message::from_slice(valid_signatures[sig_idx].as_slice())
+ .and_then(|signature| signature.signature().map_err(Into::into))
.map_err(|e| {
ProtocolError::AddressWitnessError(format!(
"Invalid signature format: {}",
@@ -560,11 +560,11 @@ impl PlatformAddress {
))
})?;
- let pub_key = ecdsa::parse_public_key(&pubkeys[pubkey_idx]).map_err(|e| {
+ let pub_key = PublicKey::from_slice(&pubkeys[pubkey_idx]).map_err(|e| {
ProtocolError::AddressWitnessError(format!("Invalid public key: {}", e))
})?;
- if sig.to_standard().verify(msg, &pub_key).is_ok() {
+ if pub_key.inner.verify(&signable_bytes_hash, sig).is_ok() {
matched += 1;
sig_idx += 1;
}
diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
index b296df0d815..9f30211a538 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
@@ -5,7 +5,6 @@ use crate::ed25519_dalek;
use crate::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
use crate::identity::KeyType;
-use crate::util::ecdsa::parse_public_key;
use crate::util::hash::ripemd160_sha256;
use crate::ProtocolError;
use anyhow::anyhow;
@@ -46,15 +45,8 @@ pub(in crate::identity::identity_public_key) fn public_key_hash_for_key_data(
KeyType::ECDSA_SECP256K1 => {
let key = match data.len() {
// TODO: We need to update schema and tests for 65 len keys
- 65 | 33 => {
- // Preserve historical SEC1 validation errors and hash the supplied encoding.
- let inner = parse_public_key(data.as_slice())
- .map_err(|e| anyhow!("unable to create pub key - {}", e))?;
- ECDSAPublicKey {
- compressed: data.len() == 33,
- inner: inner.into(),
- }
- }
+ 65 | 33 => ECDSAPublicKey::from_slice(data.as_slice())
+ .map_err(|e| anyhow!("unable to create pub key - {}", e))?,
_ => {
return Err(ProtocolError::ParsingError(format!(
"the key length is invalid: {} Allowed sizes: 33 or 65 bytes for ecdsa key",
diff --git a/packages/rs-dpp/src/signing.rs b/packages/rs-dpp/src/signing.rs
index 621809cd121..ba2256dd17b 100644
--- a/packages/rs-dpp/src/signing.rs
+++ b/packages/rs-dpp/src/signing.rs
@@ -2,7 +2,6 @@
use crate::bls::{self, Signature};
use crate::identity::KeyType;
use crate::serialization::PlatformMessageSignable;
-use crate::util::ecdsa as signer;
#[cfg(feature = "message-signature-verification")]
use crate::{
consensus::signature::{
@@ -12,6 +11,7 @@ use crate::{
};
#[cfg(feature = "message-signing")]
use crate::{BlsModule, ProtocolError};
+use dashcore::signer;
impl PlatformMessageSignable for &[u8] {
#[cfg(feature = "message-signature-verification")]
diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs
index 616a18ae75d..1c4ecc83b6b 100644
--- a/packages/rs-dpp/src/state_transition/mod.rs
+++ b/packages/rs-dpp/src/state_transition/mod.rs
@@ -8,12 +8,12 @@ use std::ops::RangeInclusive;
use platform_value::{BinaryData, Identifier};
pub use state_transition_types::*;
+use bincode::{Decode, DecodeUntrusted, Encode};
#[cfg(any(
feature = "state-transition-signing",
feature = "state-transition-validation"
))]
-use crate::util::ecdsa as signer;
-use bincode::{Decode, DecodeUntrusted, Encode};
+use dashcore::signer;
#[cfg(feature = "state-transition-validation")]
use dashcore::signer::double_sha;
use platform_serialization_derive::{
diff --git a/packages/rs-dpp/src/util/ecdsa.rs b/packages/rs-dpp/src/util/ecdsa.rs
deleted file mode 100644
index 40f9bfa4874..00000000000
--- a/packages/rs-dpp/src/util/ecdsa.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-//! Platform ECDSA verification, including consensus-stable parsing and errors.
-
-use dashcore::hashes::{hash160, sha256d, Hash};
-use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
-use secp256k1::{Message, PublicKey};
-use thiserror::Error;
-
-pub use dashcore::signer::{double_sha, sign, sign_hash};
-
-/// Errors whose display text is included in Platform consensus errors.
-#[derive(Debug, Error)]
-pub enum EcdsaVerificationError {
- #[error("length not 65 bytes")]
- SignatureLength,
- #[error("invalid encoding")]
- SignatureEncoding(#[source] secp256k1::Error),
- #[error("key secp256k1 error")]
- PublicKeyEncoding(#[source] secp256k1::Error),
- #[error("length {0} invalid for this base58 type")]
- PublicKeyLength(usize),
- #[error("key prefix invalid: {0}")]
- PublicKeyPrefix(u8),
- #[error(transparent)]
- Crypto(#[from] secp256k1::Error),
- #[error("Invalid hash length")]
- HashLength,
- #[error("the signature isn't valid")]
- WrongKeyHash,
-}
-
-/// Decode a compact signature using the historical Platform acceptance rules.
-pub fn parse_compact_signature(
- bytes: &[u8],
-) -> Result {
- if bytes.len() != 65 {
- return Err(EcdsaVerificationError::SignatureLength);
- }
- if !(27..=34).contains(&bytes[0]) {
- return Err(EcdsaVerificationError::SignatureEncoding(
- secp256k1::Error::InvalidRecoveryId,
- ));
- }
- let id = RecoveryId::try_from(i32::from((bytes[0] - 27) & 3))
- .map_err(EcdsaVerificationError::SignatureEncoding)?;
- RecoverableSignature::from_compact(&bytes[1..], id)
- .map_err(EcdsaVerificationError::SignatureEncoding)
-}
-
-/// Decode a SEC1 key, rejecting hybrid keys and preserving consensus error text.
-pub fn parse_public_key(bytes: &[u8]) -> Result {
- match bytes.len() {
- 33 => (),
- 65 if bytes[0] == 4 => (),
- 65 => return Err(EcdsaVerificationError::PublicKeyPrefix(bytes[0])),
- len => return Err(EcdsaVerificationError::PublicKeyLength(len)),
- }
- PublicKey::from_slice(bytes).map_err(EcdsaVerificationError::PublicKeyEncoding)
-}
-
-/// Verify a double-SHA256 message signature without changing historical errors.
-pub fn verify_data_signature(
- data: &[u8],
- signature: &[u8],
- public_key: &[u8],
-) -> Result<(), EcdsaVerificationError> {
- let message = Message::from_digest(sha256d::Hash::hash(data).to_byte_array());
- let signature = parse_compact_signature(signature)?;
- let public_key = parse_public_key(public_key)?;
- signature.to_standard().verify(message, &public_key)?;
- Ok(())
-}
-
-/// Recover and compare the compressed key hash, irrespective of the header's compression bit.
-pub fn verify_hash_signature(
- hash: &[u8],
- signature: &[u8],
- public_key_hash: &[u8],
-) -> Result<(), EcdsaVerificationError> {
- let signature = parse_compact_signature(signature)?;
- let digest = hash
- .try_into()
- .map_err(|_| EcdsaVerificationError::HashLength)?;
- let public_key = signature.recover_ecdsa(Message::from_digest(digest))?;
- if hash160::Hash::hash(&public_key.serialize()).as_byte_array() != public_key_hash {
- return Err(EcdsaVerificationError::WrongKeyHash);
- }
- Ok(())
-}
diff --git a/packages/rs-dpp/src/util/mod.rs b/packages/rs-dpp/src/util/mod.rs
index 5a051123b08..a95aa51923f 100644
--- a/packages/rs-dpp/src/util/mod.rs
+++ b/packages/rs-dpp/src/util/mod.rs
@@ -4,7 +4,6 @@ pub mod cbor_serializer;
pub mod cbor_value;
pub mod deserializer;
-pub mod ecdsa;
pub mod entropy_generator;
pub mod hash;
pub mod is_non_zero_fibonacci_number;
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
index 4628dbf9dbe..f73658df3af 100644
--- a/packages/rs-dpp/tests/ecdsa_compatibility.rs
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -5,15 +5,16 @@
)]
mod vectors;
-use dpp::address_funds::{AddressWitness, PlatformAddress};
+use dpp::address_funds::{AddressWitness, AddressWitnessVerificationOperations, PlatformAddress};
+use dpp::consensus::codes::ErrorWithCode;
use dpp::dashcore::hashes::{hash160, Hash};
+use dpp::dashcore::signer::{sign, verify_data_signature, verify_hash_signature};
+use dpp::dashcore::{sign_message, PublicKey};
use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
+use dpp::secp256k1::{ecdsa::RecoverableSignature, ecdsa::RecoveryId, Message};
use dpp::serialization::PlatformMessageSignable;
-use dpp::util::ecdsa::{
- parse_compact_signature, parse_public_key, sign, verify_data_signature, verify_hash_signature,
-};
use dpp::ProtocolError;
use vectors::{ECDSA_PUBLIC_KEY, TRANSFER_ECDSA_SIGNATURE, TRANSFER_HASH, TRANSFER_SIGNABLE};
@@ -25,6 +26,80 @@ fn fixture() -> (Vec, Vec, Vec) {
)
}
+#[test]
+fn should_match_historical_verification_for_all_headers_and_scalar_boundaries() {
+ let (data, signature, public_key) = fixture();
+ let message =
+ Message::from_digest(dpp::dashcore::hashes::sha256d::Hash::hash(&data).to_byte_array());
+ let raw_key = dpp::secp256k1::PublicKey::from_slice(&public_key).unwrap();
+ let order =
+ hex::decode("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap();
+ let mut signatures = vec![signature.clone()];
+ for start in [1, 33] {
+ for scalar in [&[0; 32][..], order.as_slice(), &[0xff; 32][..]] {
+ let mut candidate = signature.clone();
+ candidate[start..start + 32].copy_from_slice(scalar);
+ signatures.push(candidate);
+ }
+ }
+ for mut candidate in signatures {
+ for header in 0..=u8::MAX {
+ candidate[0] = header;
+ // Baseline Core parsed recovery metadata before verifying with libsecp256k1.
+ let historical_valid = (27..=34).contains(&header) && {
+ let id = RecoveryId::try_from(i32::from((header - 27) & 3)).unwrap();
+ RecoverableSignature::from_compact(&candidate[1..], id)
+ .and_then(|sig| sig.to_standard().verify(message, &raw_key))
+ .is_ok()
+ };
+ let result =
+ data.as_slice()
+ .verify_signature(KeyType::ECDSA_SECP256K1, &public_key, &candidate);
+ assert_eq!(result.is_valid(), historical_valid, "header {header}");
+ if !historical_valid {
+ assert_eq!(result.errors[0].code(), 20009);
+ }
+ }
+ }
+}
+
+#[test]
+fn should_preserve_witness_fee_operations_for_recovery_and_multisig_search() {
+ let (data, signature, public_key) = fixture();
+ let address = PlatformAddress::P2pkh(hash160::Hash::hash(&public_key).to_byte_array());
+ let witness = AddressWitness::P2pkh {
+ signature: signature.clone().into(),
+ };
+ assert_eq!(
+ address
+ .verify_bytes_against_witness(&witness, &data)
+ .unwrap(),
+ AddressWitnessVerificationOperations::for_p2pkh(data.len())
+ );
+
+ let other = dpp::secp256k1::SecretKey::from_secret_bytes([2; 32]).unwrap();
+ let other_key = dpp::secp256k1::PublicKey::from_secret_key(&other).serialize();
+ let mut script = vec![0x51, 33];
+ script.extend_from_slice(&other_key);
+ script.push(33);
+ script.extend_from_slice(&public_key);
+ script.extend_from_slice(&[0x52, 0xae]);
+ let address = PlatformAddress::P2sh(hash160::Hash::hash(&script).to_byte_array());
+ let witness = AddressWitness::P2sh {
+ signatures: vec![signature.into()],
+ redeem_script: script.into(),
+ };
+ assert_eq!(
+ address
+ .verify_bytes_against_witness(&witness, &data)
+ .unwrap(),
+ AddressWitnessVerificationOperations::for_p2sh_multisig(2, data.len())
+ );
+ assert!(address
+ .verify_bytes_against_witness(&witness, b"different message")
+ .is_err());
+}
+
#[test]
fn should_preserve_historical_signature_bytes_and_verification() {
let (data, signature, public_key) = fixture();
@@ -41,15 +116,15 @@ fn should_preserve_all_compact_header_acceptance_rules() {
let (_, mut signature, _) = fixture();
for header in 0..=u8::MAX {
signature[0] = header;
- let result = parse_compact_signature(&signature);
+ let result = sign_message::from_slice(&signature).unwrap().signature();
if (27..=34).contains(&header) {
- let (id, compact) = result.unwrap().serialize_compact();
- assert_eq!(id.to_u8(), (header - 27) & 3);
- assert_eq!(compact.as_slice(), &signature[1..]);
+ let parsed = sign_message::from_slice(&signature).unwrap();
+ assert_eq!(parsed.recovery_id().unwrap(), (header - 27) & 3);
+ assert_eq!(result.unwrap().to_bytes().as_slice(), &signature[1..]);
} else {
assert_eq!(
result.unwrap_err().to_string(),
- "invalid encoding",
+ "recovery id out of range (must be 0..4)",
"header {header}"
);
}
@@ -60,7 +135,7 @@ fn should_preserve_all_compact_header_acceptance_rules() {
fn should_preserve_compact_length_and_scalar_errors() {
for len in [0, 1, 64, 66] {
assert_eq!(
- parse_compact_signature(&vec![0; len])
+ sign_message::from_slice(&vec![0; len])
.unwrap_err()
.to_string(),
"length not 65 bytes"
@@ -73,80 +148,83 @@ fn should_preserve_compact_length_and_scalar_errors() {
let (_, mut signature, _) = fixture();
signature[start..start + 32].copy_from_slice(scalar);
assert_eq!(
- parse_compact_signature(&signature).unwrap_err().to_string(),
- "invalid encoding"
+ sign_message::from_slice(&signature)
+ .unwrap()
+ .signature()
+ .unwrap_err()
+ .to_string(),
+ "signature bytes are malformed"
);
}
}
// libsecp parses zero scalars, but neither verification nor recovery succeeds.
let mut zero = [0; 65];
zero[0] = 31;
- parse_compact_signature(&zero).unwrap();
+ sign_message::from_slice(&zero)
+ .unwrap()
+ .signature()
+ .unwrap();
let (data, _, public_key) = fixture();
assert_eq!(
verify_data_signature(&data, &zero, &public_key)
.unwrap_err()
.to_string(),
- "signature failed verification"
+ "signature verification failed"
);
assert_eq!(
verify_hash_signature(&[0; 32], &zero, &[0; 20])
.unwrap_err()
.to_string(),
- "malformed signature"
+ "recovery failed; no valid public key"
);
}
#[test]
-fn should_preserve_public_key_encodings_and_error_text() {
+fn should_preserve_public_key_encodings() {
let (_, _, public_key) = fixture();
- let parsed = parse_public_key(&public_key).unwrap();
- let mut uncompressed = parsed.serialize_uncompressed();
- assert_eq!(parse_public_key(&uncompressed).unwrap(), parsed);
+ let parsed = PublicKey::from_slice(&public_key).unwrap();
+ let mut uncompressed = parsed.inner.to_uncompressed();
+ assert_eq!(
+ PublicKey::from_slice(&uncompressed).unwrap().inner,
+ parsed.inner
+ );
for prefix in [0, 2, 3, 6, 7] {
uncompressed[0] = prefix;
assert_eq!(
- parse_public_key(&uncompressed).unwrap_err().to_string(),
+ PublicKey::from_slice(&uncompressed)
+ .unwrap_err()
+ .to_string(),
format!("key prefix invalid: {prefix}")
);
}
for len in [0, 32, 34, 64, 66] {
assert_eq!(
- parse_public_key(&vec![0; len]).unwrap_err().to_string(),
+ PublicKey::from_slice(&vec![0; len])
+ .unwrap_err()
+ .to_string(),
format!("length {len} invalid for this base58 type")
);
}
let mut invalid = [0xff; 33];
invalid[0] = 2;
assert_eq!(
- parse_public_key(&invalid).unwrap_err().to_string(),
- "key secp256k1 error"
+ PublicKey::from_slice(&invalid).unwrap_err().to_string(),
+ "key ECDSA error"
);
}
#[test]
-fn should_report_invalid_signature_before_invalid_key_or_hash() {
- let (data, mut signature, _) = fixture();
+fn should_reject_malformed_inputs_with_stable_consensus_codes() {
+ let (data, mut signature, public_key) = fixture();
signature[1..33].fill(0xff);
- assert_eq!(
- verify_data_signature(&data, &signature, &[])
- .unwrap_err()
- .to_string(),
- "invalid encoding"
- );
- assert_eq!(
- verify_hash_signature(&[], &signature, &[])
- .unwrap_err()
- .to_string(),
- "invalid encoding"
- );
- let (_, valid_signature, _) = fixture();
- assert_eq!(
- verify_hash_signature(&[], &valid_signature, &[])
- .unwrap_err()
- .to_string(),
- "Invalid hash length"
- );
+ for key in [public_key.as_slice(), &[]] {
+ let result = data
+ .as_slice()
+ .verify_signature(KeyType::ECDSA_SECP256K1, key, &signature);
+ assert!(!result.is_valid());
+ assert_eq!(result.errors[0].code(), 20009);
+ }
+ assert!(verify_hash_signature(&[], &signature, &[]).is_err());
}
#[test]
@@ -178,7 +256,7 @@ fn should_reject_high_s_verification_but_accept_high_s_recovery() {
verify_data_signature(&data, &signature, &public_key)
.unwrap_err()
.to_string(),
- "signature failed verification"
+ "signature verification failed"
);
verify_hash_signature(
&hex::decode(TRANSFER_HASH).unwrap(),
@@ -227,16 +305,16 @@ fn should_preserve_multisig_malformed_public_key_error() {
.unwrap_err();
match error {
ProtocolError::AddressWitnessError(message) => {
- assert_eq!(message, "Invalid public key: key secp256k1 error")
+ assert_eq!(message, "Invalid public key: key ECDSA error")
}
error => panic!("unexpected error: {error}"),
}
}
#[test]
-fn should_preserve_identity_public_key_hash_errors_and_encoding() {
+fn should_use_core_identity_public_key_errors_and_preserve_encoding() {
let (_, _, public_key) = fixture();
- let parsed = parse_public_key(&public_key).unwrap();
+ let parsed = PublicKey::from_slice(&public_key).unwrap();
let identity_key = |bytes: Vec| {
IdentityPublicKey::V0(IdentityPublicKeyV0 {
id: 0,
@@ -249,7 +327,7 @@ fn should_preserve_identity_public_key_hash_errors_and_encoding() {
disabled_at: None,
})
};
- for bytes in [public_key, parsed.serialize_uncompressed().to_vec()] {
+ for bytes in [public_key, parsed.inner.to_uncompressed().to_vec()] {
assert_eq!(
identity_key(bytes.clone()).public_key_hash().unwrap(),
hash160::Hash::hash(&bytes).to_byte_array()
@@ -262,9 +340,9 @@ fn should_preserve_identity_public_key_hash_errors_and_encoding() {
.public_key_hash()
.unwrap_err()
.to_string(),
- "unable to create pub key - key secp256k1 error"
+ "unable to create pub key - key ECDSA error"
);
- let mut hybrid = parsed.serialize_uncompressed().to_vec();
+ let mut hybrid = parsed.inner.to_uncompressed().to_vec();
hybrid[0] = 6;
assert_eq!(
identity_key(hybrid)
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
index d12a0dc0345..6d580bbeb76 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funding_from_asset_lock/transform_into_action/v0/mod.rs
@@ -7,10 +7,10 @@ use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointNotEnou
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::dashcore::hashes::Hash;
+use dpp::dashcore::signer;
use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::state_transition::AssetLockProved;
use dpp::identity::KeyType;
-use dpp::util::ecdsa as signer;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
index 1138360893d..b6292f538cb 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs
@@ -8,9 +8,9 @@ use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::identity::IdentityAlreadyExistsError;
use dpp::dashcore::hashes::Hash;
+use dpp::dashcore::signer;
use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::KeyType;
-use dpp::util::ecdsa as signer;
use dpp::identity::state_transition::AssetLockProved;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
index e981aea78f1..95f9ed1ecc7 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/transform_into_action/v0/mod.rs
@@ -7,10 +7,10 @@ use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointNotEnou
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::dashcore::hashes::Hash;
+use dpp::dashcore::signer;
use dpp::dashcore::{ScriptBuf, Txid};
use dpp::identity::state_transition::AssetLockProved;
use dpp::identity::KeyType;
-use dpp::util::ecdsa as signer;
use dpp::prelude::ConsensusValidationResult;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
index ce660e30a37..ee5e5b80f18 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v0/mod.rs
@@ -22,7 +22,7 @@ use dpp::consensus::basic::state_transition::ShieldedImplicitFeeCapExceededError
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::state_error::StateError;
use dpp::dashcore::hashes::Hash;
-use dpp::util::ecdsa as signer;
+use dpp::dashcore::signer;
use dpp::dashcore::{ ScriptBuf, Txid};
use dpp::fee::Credits;
use dpp::shielded::compute_minimum_shielded_fee;
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
index 7922cbde3de..2cb0a3d15ba 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/shield_from_asset_lock/transform_into_action/v1/mod.rs
@@ -23,7 +23,7 @@ use dpp::consensus::basic::state_transition::ShieldedImplicitFeeCapExceededError
use dpp::consensus::signature::{BasicECDSAError, SignatureError};
use dpp::consensus::state::state_error::StateError;
use dpp::dashcore::hashes::Hash;
-use dpp::util::ecdsa as signer;
+use dpp::dashcore::signer;
use dpp::dashcore::{ ScriptBuf, Txid};
use dpp::fee::Credits;
use dpp::shielded::{compute_minimum_shielded_fee, shield_from_asset_lock_extra_sighash_data};
From 2cd9d2fd7f43659dad2ab372444c2dcedb132d4f Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:12:30 +0000
Subject: [PATCH 17/21] refactor(bindings): use Core typed crypto outside ECDH
boundaries
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Preserve non-grinding signatures, SEC1 parser acceptance and compressed encodings.
Keep direct secp256k1 dependencies only for ECDH primitives and compatibility tests.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
packages/rs-platform-wallet-ffi/Cargo.toml | 2 +
.../rs-platform-wallet-ffi/src/dashpay.rs | 11 ++--
.../rs-platform-wallet-ffi/src/invitation.rs | 10 ++--
.../src/secp256k1_primitives.rs | 27 +++++-----
packages/rs-platform-wallet-ffi/src/utils.rs | 40 +++-----------
packages/rs-sdk-ffi/Cargo.toml | 2 +
.../transitions/cast_vote.rs | 8 +--
.../src/mnemonic_resolver_core_signer.rs | 1 -
packages/wasm-dpp2/src/public_key.rs | 52 ++++++++++++++-----
packages/wasm-sdk/Cargo.toml | 2 +
packages/wasm-sdk/src/encrypted_for.rs | 2 +-
.../state_transitions/contract/cache_tests.rs | 14 ++---
packages/wasm-sdk/src/wallet/dip14.rs | 27 ++--------
.../wasm-sdk/src/wallet/key_generation.rs | 19 +++----
14 files changed, 101 insertions(+), 116 deletions(-)
diff --git a/packages/rs-platform-wallet-ffi/Cargo.toml b/packages/rs-platform-wallet-ffi/Cargo.toml
index fd8a735f80a..62ead3c9b7a 100644
--- a/packages/rs-platform-wallet-ffi/Cargo.toml
+++ b/packages/rs-platform-wallet-ffi/Cargo.toml
@@ -10,6 +10,8 @@ description = "C FFI bindings for platform-wallet"
crate-type = ["staticlib", "cdylib", "rlib"]
[dependencies]
+# Core does not expose the ECDH primitives used at this binding boundary.
+secp256k1 = { workspace = true }
# `bls`/`eddsa` are required explicitly, not just inherited from
# `platform-wallet`'s default features: `persistence.rs` calls
# `rebuild_provider_key_account` and matches on `ProviderKeyExtendedPubKey`,
diff --git a/packages/rs-platform-wallet-ffi/src/dashpay.rs b/packages/rs-platform-wallet-ffi/src/dashpay.rs
index 94960f1378f..bb61b971620 100644
--- a/packages/rs-platform-wallet-ffi/src/dashpay.rs
+++ b/packages/rs-platform-wallet-ffi/src/dashpay.rs
@@ -32,6 +32,7 @@
//! established contact via their `DashpayExternalAccount`. Runs
//! the Core transaction path internally.
+use dashcore::ecdsa::EcdsaSecretKey;
use std::ffi::CStr;
use std::os::raw::c_char;
@@ -821,7 +822,7 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dpp::secp256k1::PublicKey,
+ peer: &secp256k1::PublicKey,
) -> Result, platform_wallet::PlatformWalletError> {
self.signer
.ecdh_shared_secret(path, peer)
@@ -831,28 +832,28 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider {
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let scalar = self
.signer
.export_auto_accept_private_key(path)
.map_err(|e| {
platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())
})?;
- dpp::secp256k1::SecretKey::from_secret_bytes(*scalar)
+ EcdsaSecretKey::from_bytes(&scalar)
.map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
}
async fn export_invitation_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let scalar = self
.signer
.export_invitation_private_key(path)
.map_err(|e| {
platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())
})?;
- dpp::secp256k1::SecretKey::from_secret_bytes(*scalar)
+ EcdsaSecretKey::from_bytes(&scalar)
.map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()))
}
diff --git a/packages/rs-platform-wallet-ffi/src/invitation.rs b/packages/rs-platform-wallet-ffi/src/invitation.rs
index 03d3a1eed18..f7e17540430 100644
--- a/packages/rs-platform-wallet-ffi/src/invitation.rs
+++ b/packages/rs-platform-wallet-ffi/src/invitation.rs
@@ -682,8 +682,8 @@ pub unsafe extern "C" fn platform_wallet_parse_invitation(
#[cfg(test)]
mod tests {
use super::*;
+ use dashcore::ecdsa::EcdsaSecretKey;
use dashcore::{Network, PrivateKey};
- use dpp::secp256k1::SecretKey;
// Marshalling-boundary coverage. The invitation codec and claim semantics
// are pinned library-side in `dash_sdk::platform::dashpay`'s invitation
@@ -853,8 +853,8 @@ mod tests {
/// unknown wallet is looked up, and no signer/network work is attempted.
#[test]
fn claim_invitation_rejects_duplicate_key_ids_before_wallet_lookup() {
- let voucher = SecretKey::from_secret_bytes([0x11u8; 32]).expect("valid scalar");
- let wif = PrivateKey::from_byte_array(&voucher.to_secret_bytes(), Network::Testnet)
+ let voucher = EcdsaSecretKey::from_bytes(&[0x11u8; 32]).expect("valid scalar");
+ let wif = PrivateKey::from_byte_array(&voucher.to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri =
@@ -930,8 +930,8 @@ mod tests {
/// (percent-decoded), and both are null for a link that carries neither.
#[test]
fn should_surface_inviter_display_name_and_avatar_in_the_preview() {
- let key = SecretKey::from_secret_bytes([0x11u8; 32]).unwrap();
- let wif = PrivateKey::from_byte_array(&key.to_secret_bytes(), Network::Testnet)
+ let key = EcdsaSecretKey::from_bytes(&[0x11u8; 32]).unwrap();
+ let wif = PrivateKey::from_byte_array(&key.to_bytes(), Network::Testnet)
.expect("valid key")
.to_wif();
let txid = "ab".repeat(32);
diff --git a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
index 3d65d672fc0..8ba7b0d17cc 100644
--- a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
+++ b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs
@@ -2,8 +2,9 @@
use std::slice;
-use dpp::secp256k1::ecdh::shared_secret_point;
-use dpp::secp256k1::{PublicKey, SecretKey};
+use dashcore::ecdsa::{EcdsaPublicKey, EcdsaSecretKey};
+use secp256k1::ecdh::shared_secret_point;
+use secp256k1::SecretKey;
use zeroize::Zeroizing;
use crate::error::*;
@@ -27,29 +28,25 @@ fn invalid_parameter(message: impl Into) -> PlatformWalletFFIResult {
fn parse_secret_key(
private_key: *const u8,
private_key_len: usize,
-) -> Result {
+) -> Result {
if private_key_len != 32 {
return Err(invalid_parameter(format!(
"secp256k1 private keys must be exactly 32 bytes, got {private_key_len}"
)));
}
- // Converting the caller's slice straight into the `[u8; 32]`
- // `SecretKey::from_secret_bytes` takes would leave an unguarded copy of
- // the scalar on the stack. Staging it here keeps every copy this side
- // owns wiped.
+ // Keep the borrowed input's temporary scalar copy zeroized.
let mut staged = Zeroizing::new([0u8; 32]);
staged.copy_from_slice(unsafe { slice::from_raw_parts(private_key, private_key_len) });
- SecretKey::from_secret_bytes(*staged)
- .map(WipingSecretKey)
+ EcdsaSecretKey::from_bytes(&staged)
.map_err(|error| invalid_parameter(format!("Invalid secp256k1 private key: {error}")))
}
fn parse_compressed_public_key(
public_key: *const u8,
public_key_len: usize,
-) -> Result {
+) -> Result {
if public_key_len != 33 {
return Err(invalid_parameter(format!(
"Compressed secp256k1 public keys must be exactly 33 bytes, got {public_key_len}"
@@ -63,7 +60,7 @@ fn parse_compressed_public_key(
));
}
- PublicKey::from_slice(bytes)
+ EcdsaPublicKey::from_bytes(bytes)
.map_err(|error| invalid_parameter(format!("Invalid compressed secp256k1 point: {error}")))
}
@@ -94,7 +91,7 @@ pub unsafe extern "C" fn platform_wallet_secp256k1_compressed_public_key(
check_ptr!(out_pubkey);
let secret_key = unwrap_result_or_return!(parse_secret_key(seckey, seckey_len));
- let compressed = PublicKey::from_secret_key(&secret_key.0).serialize();
+ let compressed = secret_key.public_key().to_compressed();
std::ptr::copy_nonoverlapping(compressed.as_ptr(), out_pubkey, compressed.len());
PlatformWalletFFIResult::ok()
}
@@ -119,7 +116,11 @@ pub unsafe extern "C" fn platform_wallet_secp256k1_ecdh_shared_x(
// the scalar here is the wallet's private ephemeral key and the point
// comes from the peer, so the multiplication must not branch on the
// secret. Returns `x || y`; DashConnect wants the raw, unhashed X.
- let shared_point = Zeroizing::new(shared_secret_point(&public_key, &secret_key.0));
+ let raw_secret = WipingSecretKey(unwrap_result_or_return!(SecretKey::from_secret_bytes(
+ *secret_key.to_bytes()
+ )
+ .map_err(|error| invalid_parameter(format!("Invalid secp256k1 private key: {error}")))));
+ let shared_point = Zeroizing::new(shared_secret_point(&public_key.into(), &raw_secret.0));
std::ptr::copy_nonoverlapping(shared_point.as_ptr(), out_shared_x, 32);
PlatformWalletFFIResult::ok()
}
diff --git a/packages/rs-platform-wallet-ffi/src/utils.rs b/packages/rs-platform-wallet-ffi/src/utils.rs
index b844a07f3e5..a7448ce5e1f 100644
--- a/packages/rs-platform-wallet-ffi/src/utils.rs
+++ b/packages/rs-platform-wallet-ffi/src/utils.rs
@@ -1,20 +1,8 @@
use crate::error::*;
use crate::{check_ptr, unwrap_result_or_return};
+use dashcore::ecdsa::EcdsaSecretKey;
use std::os::raw::{c_char, c_uchar};
-/// RAII guard that scrubs a `secp256k1::SecretKey`'s scalar on drop. `from_secret_bytes`
-/// allocates a 32-byte scalar copy of the caller's private key, and `SecretKey`
-/// has no `Drop` wipe of its own — so without this the copy would survive on the
-/// stack after the call returns. Mirrors `WipingSecretKey` in
-/// `rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs`.
-struct WipingSecretKey(dpp::secp256k1::SecretKey);
-
-impl Drop for WipingSecretKey {
- fn drop(&mut self) {
- self.0.non_secure_erase();
- }
-}
-
/// Serialize any object to JSON bytes
#[no_mangle]
pub unsafe extern "C" fn platform_wallet_serialize_to_json_bytes(
@@ -202,21 +190,13 @@ pub unsafe extern "C" fn platform_wallet_pubkey_hash_from_private_key(
return -1;
}
use dashcore::hashes::Hash;
- use dpp::secp256k1::{PublicKey, SecretKey};
-
- let sk_bytes = std::slice::from_raw_parts(private_key, 32);
- // `WipingSecretKey` scrubs the `from_secret_bytes`-allocated scalar copy on every
- // exit path (the success return below, the `Err` early return, and any
- // panic) — the caller's `private_key` bytes are theirs to manage, but this
- // copy must not linger.
- let secret_key = match <[u8; 32]>::try_from(sk_bytes)
- .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
- Ok(sk) => WipingSecretKey(sk),
+
+ let sk_bytes = &*private_key.cast::<[u8; 32]>();
+ let secret_key = match EcdsaSecretKey::from_bytes(sk_bytes) {
+ Ok(sk) => sk,
Err(_) => return -1,
};
- let pubkey = PublicKey::from_secret_key(&secret_key.0).serialize();
+ let pubkey = secret_key.public_key().to_compressed();
let hash = dashcore::hashes::hash160::Hash::hash(&pubkey);
let h: [u8; 20] = hash.to_byte_array();
std::ptr::copy_nonoverlapping(h.as_ptr(), out_hash, 20);
@@ -264,9 +244,6 @@ mod tests {
#[test]
fn test_pubkey_hash_from_private_key_matches_canonical_derivation() {
- use dashcore::hashes::Hash;
- use dpp::secp256k1::{PublicKey, SecretKey};
-
// A fixed, in-range scalar.
let mut scalar = [0u8; 32];
scalar[31] = 1;
@@ -277,10 +254,7 @@ mod tests {
};
assert_eq!(rc, 0);
- let sk = SecretKey::from_secret_bytes(scalar).expect("in-range scalar");
- let pubkey = PublicKey::from_secret_key(&sk).serialize();
- let expected: [u8; 20] = dashcore::hashes::hash160::Hash::hash(&pubkey).to_byte_array();
- assert_eq!(out, expected);
+ assert_eq!(hex::encode(out), "751e76e8199196d454941c45d1b3a323f1433bd6");
}
#[test]
diff --git a/packages/rs-sdk-ffi/Cargo.toml b/packages/rs-sdk-ffi/Cargo.toml
index 33f50995ad7..3dc09beade4 100644
--- a/packages/rs-sdk-ffi/Cargo.toml
+++ b/packages/rs-sdk-ffi/Cargo.toml
@@ -11,6 +11,8 @@ crate-type = ["staticlib", "cdylib", "rlib"]
[dependencies]
+# Core does not expose the ECDH primitives used at this binding boundary.
+secp256k1 = { workspace = true }
dash-sdk = { path = "../rs-sdk", features = [
"dpns-contract",
"dashpay-contract",
diff --git a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
index 6d969b6a2fc..28bfac3bf29 100644
--- a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
+++ b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs
@@ -60,10 +60,10 @@
use crate::sdk::SDKWrapper;
use crate::types::{FFINetwork, Network, SDKHandle};
use crate::{DashSDKResult, FFIError};
+use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey;
use dash_sdk::dpp::dashcore::hashes::{hash160, Hash};
use dash_sdk::dpp::dashcore::ProTxHash;
use dash_sdk::dpp::platform_value::{Identifier, Value};
-use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice;
use dash_sdk::dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll;
use dash_sdk::dpp::voting::vote_polls::VotePoll;
@@ -341,10 +341,10 @@ unsafe fn cast_vote_inner(
// `masternode_voting_key.public_key_hash()` to derive the voter
// identifier, and `SingleKeySigner::can_sign_with` recomputes the same
// hash160 from the private key, so the two agree by construction.
- let secret_key = SecretKey::from_secret_bytes(*key_array)
+ let secret_key = EcdsaSecretKey::from_bytes(&key_array)
.map_err(|e| invalid(&format!("Invalid voting private key: {}", e)))?;
- let public_key = PublicKey::from_secret_key(&secret_key);
- let voting_address = hash160::Hash::hash(&public_key.serialize()).to_byte_array();
+ let public_key = secret_key.public_key();
+ let voting_address = hash160::Hash::hash(&public_key.to_compressed()).to_byte_array();
// ---- Broadcast, then diagnose only on failure ---------------------------
let wrapper = &*(sdk_handle as *const SDKWrapper);
diff --git a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
index 038a089f814..7cf839d71e6 100644
--- a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
+++ b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs
@@ -60,7 +60,6 @@ use std::ffi::c_void;
use std::os::raw::c_char;
use async_trait::async_trait;
-use dash_sdk::dpp::secp256k1;
use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
use key_wallet::dashcore::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaSecretKey, EcdsaSignature};
use key_wallet::dip9::{
diff --git a/packages/wasm-dpp2/src/public_key.rs b/packages/wasm-dpp2/src/public_key.rs
index 52a1a421cc6..fcc8135b337 100644
--- a/packages/wasm-dpp2/src/public_key.rs
+++ b/packages/wasm-dpp2/src/public_key.rs
@@ -1,8 +1,8 @@
use crate::error::{WasmDppError, WasmDppResult};
use crate::impl_wasm_type_info;
use dpp::dashcore::PublicKey;
+use dpp::dashcore::ecdsa::EcdsaPublicKey;
use dpp::dashcore::key::constants;
-use dpp::secp256k1;
use std::convert::TryInto;
use wasm_bindgen::prelude::wasm_bindgen;
@@ -40,7 +40,7 @@ impl PublicKeyWasm {
public_key_bytes.try_into().map_err(|_| {
WasmDppError::invalid_argument("compressed public key must contain 33 bytes")
})?;
- secp256k1::PublicKey::from_byte_array_compressed(bytes)
+ EcdsaPublicKey::from_bytes(&bytes)
} else {
if public_key_bytes.len() != constants::UNCOMPRESSED_PUBLIC_KEY_SIZE {
return Err(WasmDppError::invalid_argument(format!(
@@ -54,14 +54,11 @@ impl PublicKeyWasm {
WasmDppError::invalid_argument("uncompressed public key must contain 65 bytes")
})?;
- secp256k1::PublicKey::from_byte_array_uncompressed(bytes)
+ EcdsaPublicKey::from_bytes(&bytes)
}
.map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
- Ok(PublicKeyWasm(PublicKey {
- compressed,
- inner: inner.into(),
- }))
+ Ok(PublicKeyWasm(PublicKey { compressed, inner }))
}
#[wasm_bindgen(getter = "compressed")]
@@ -91,9 +88,8 @@ impl PublicKeyWasm {
})?;
self.0.compressed = true;
- self.0.inner = secp256k1::PublicKey::from_byte_array_compressed(bytes)
- .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?
- .into();
+ self.0.inner = EcdsaPublicKey::from_bytes(&bytes)
+ .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
} else {
if inner.len() != constants::UNCOMPRESSED_PUBLIC_KEY_SIZE {
return Err(WasmDppError::invalid_argument(format!(
@@ -108,9 +104,8 @@ impl PublicKeyWasm {
})?;
self.0.compressed = false;
- self.0.inner = secp256k1::PublicKey::from_byte_array_uncompressed(bytes)
- .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?
- .into();
+ self.0.inner = EcdsaPublicKey::from_bytes(&bytes)
+ .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
}
Ok(())
@@ -136,3 +131,34 @@ impl PublicKeyWasm {
}
impl_wasm_type_info!(PublicKeyWasm, PublicKey);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use dpp::dashcore::ecdsa::EcdsaSecretKey;
+
+ #[test]
+ fn should_preserve_public_key_parser_encoding_contracts() {
+ let key = EcdsaSecretKey::from_bytes(&[1; 32])
+ .expect("valid scalar")
+ .public_key();
+ let compressed = key.to_compressed();
+ let uncompressed = key.to_uncompressed();
+ let mut hybrid = uncompressed;
+ hybrid[0] = 6 | (hybrid[64] & 1);
+
+ let parsed = PublicKeyWasm::constructor(true, compressed.to_vec()).expect("compressed key");
+ assert_eq!(parsed.inner(), compressed);
+ assert!(PublicKeyWasm::constructor(true, uncompressed.to_vec()).is_err());
+ for bytes in [uncompressed, hybrid] {
+ let mut parsed = PublicKeyWasm::constructor(false, bytes.to_vec()).expect("SEC1 key");
+ assert_eq!(parsed.inner(), uncompressed);
+ parsed.set_inner(bytes.to_vec()).expect("SEC1 setter");
+ assert_eq!(parsed.inner(), uncompressed);
+ }
+ // The Core wire parser is stricter than the raw SEC1 constructor/setter.
+ assert!(PublicKeyWasm::from_bytes(hybrid.to_vec()).is_err());
+ hybrid[0] ^= 1;
+ assert!(PublicKeyWasm::constructor(false, hybrid.to_vec()).is_err());
+ }
+}
diff --git a/packages/wasm-sdk/Cargo.toml b/packages/wasm-sdk/Cargo.toml
index 153fe020896..9d0e65a5aa7 100644
--- a/packages/wasm-sdk/Cargo.toml
+++ b/packages/wasm-sdk/Cargo.toml
@@ -60,6 +60,8 @@ moderation-charters-contract = [
token_reward_explanations = ["dash-sdk/token_reward_explanations"]
[dependencies]
+# Core does not expose the ECDH primitives used at this binding boundary.
+secp256k1 = { workspace = true }
dash-sdk = { path = "../rs-sdk", features = [
"serde",
"core_key_wallet",
diff --git a/packages/wasm-sdk/src/encrypted_for.rs b/packages/wasm-sdk/src/encrypted_for.rs
index b4a8f5330a2..fe93e626d26 100644
--- a/packages/wasm-sdk/src/encrypted_for.rs
+++ b/packages/wasm-sdk/src/encrypted_for.rs
@@ -13,11 +13,11 @@ use dash_sdk::dpp::document::DocumentV0Getters;
use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dash_sdk::dpp::identity::{IdentityPublicKey, KeyType};
use dash_sdk::dpp::platform_value::Value;
-use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey};
use dash_sdk::platform::encrypted_for::{
decrypt_property, encrypt_property, EncryptedPropertyEnvelope, EncryptionKeys,
};
use dash_sdk::platform::{Document, Identifier};
+use secp256k1::{PublicKey, SecretKey};
use std::collections::BTreeMap;
use wasm_bindgen::prelude::wasm_bindgen;
use wasm_bindgen::JsValue;
diff --git a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
index 7fc146e8d00..333b3cf91da 100644
--- a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
+++ b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs
@@ -9,6 +9,7 @@ use dapi_grpc::platform::v0::{
WaitForStateTransitionResultResponse,
};
use dash_sdk::dpp::address_funds::AddressWitness;
+use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey;
use dash_sdk::dpp::dashcore::{signer, Network};
use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Setters;
use dash_sdk::dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
@@ -17,7 +18,6 @@ use dash_sdk::dpp::document::{DocumentV0, DocumentV0Setters};
use dash_sdk::dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dash_sdk::dpp::identity::{KeyType, PartialIdentity, Purpose, SecurityLevel};
use dash_sdk::dpp::platform_value::{platform_value, BinaryData, Value};
-use dash_sdk::dpp::secp256k1;
use dash_sdk::dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
use dash_sdk::dpp::state_transition::batch_transition::BatchTransition;
use dash_sdk::dpp::state_transition::StateTransition;
@@ -147,12 +147,12 @@ fn identity_key_with_seed(seed: u8) -> IdentityPublicKey {
purpose: Purpose::AUTHENTICATION,
security_level: SecurityLevel::CRITICAL,
key_type: KeyType::ECDSA_SECP256K1,
- data: secp256k1::PublicKey::from_secret_key(
- &secp256k1::SecretKey::from_secret_bytes([seed; 32]).expect("identity secret"),
- )
- .serialize()
- .to_vec()
- .into(),
+ data: EcdsaSecretKey::from_bytes(&[seed; 32])
+ .expect("identity secret")
+ .public_key()
+ .to_compressed()
+ .to_vec()
+ .into(),
..Default::default()
})
}
diff --git a/packages/wasm-sdk/src/wallet/dip14.rs b/packages/wasm-sdk/src/wallet/dip14.rs
index d898e7c2acb..db0b250ba24 100644
--- a/packages/wasm-sdk/src/wallet/dip14.rs
+++ b/packages/wasm-sdk/src/wallet/dip14.rs
@@ -8,7 +8,6 @@ use dash_sdk::dpp::dashcore::hashes::{sha256, Hash};
use dash_sdk::dpp::dashcore::Network;
use dash_sdk::dpp::key_wallet;
use dash_sdk::dpp::key_wallet::bip32::{ExtendedPrivKey, ExtendedPubKey};
-use dash_sdk::dpp::secp256k1::{self, Scalar, SecretKey};
use hmac::{Hmac, Mac};
use sha2::Sha512;
use std::convert::TryInto;
@@ -120,31 +119,15 @@ impl Dip14ExtendedPrivKey {
// Perform scalar addition: child_key = IL + parent_key (mod n)
// This is the core of BIP32/DIP14 child key derivation
- // First, try to create a secret key from IL
- let il_scalar = match <[u8; 32]>::try_from(il_bytes)
- .map_err(|_| secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
- {
- Ok(key) => key,
- Err(_) => {
- return Err(Dip14Error::DerivationFailed(
- "Invalid IL bytes (IL >= n)".to_string(),
- ))
- }
- };
-
- // Add parent key to IL
- // In secp256k1, we perform scalar addition: child_key = parent_key + IL (mod n)
- // Convert IL to a Scalar for the tweak operation
- let il_scalar_bytes = il_scalar.to_secret_bytes();
- let tweak = Scalar::from_be_bytes(il_scalar_bytes).map_err(|_| {
- Dip14Error::DerivationFailed("Failed to convert IL to scalar".to_string())
- })?;
+ let il_bytes: &[u8; 32] = il_bytes.try_into().map_err(|_| Dip14Error::InvalidKey)?;
+ // Retain rejection of a zero IL as well as out-of-range scalars.
+ let il_scalar = EcdsaSecretKey::from_bytes(il_bytes)
+ .map_err(|_| Dip14Error::DerivationFailed("Invalid IL bytes (IL >= n)".to_string()))?;
// Perform scalar addition: child_key = parent_key + IL (mod n)
let child_key = self
.private_key
- .add_tweak(&tweak.to_be_bytes())
+ .add_tweak(&il_scalar.to_bytes())
.map_err(|e| Dip14Error::DerivationFailed(format!("Failed to add tweak: {}", e)))?;
// Calculate parent fingerprint (first 4 bytes of parent pubkey hash160)
diff --git a/packages/wasm-sdk/src/wallet/key_generation.rs b/packages/wasm-sdk/src/wallet/key_generation.rs
index 82a366c81ca..3e833a72bc9 100644
--- a/packages/wasm-sdk/src/wallet/key_generation.rs
+++ b/packages/wasm-sdk/src/wallet/key_generation.rs
@@ -7,7 +7,6 @@ use crate::impl_wasm_serde_conversions;
use crate::sdk::WasmSdk;
use dash_sdk::dpp::dashcore::hashes::{sha256, Hash};
use dash_sdk::dpp::dashcore::{Address, Network, PrivateKey, PublicKey};
-use dash_sdk::dpp::secp256k1::SecretKey;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
use wasm_bindgen::prelude::*;
@@ -94,10 +93,6 @@ impl WasmSdk {
let private_key = PrivateKey::from_byte_array(&key_bytes, net)
.map_err(|e| WasmSdkError::generic(format!("Failed to create private key: {}", e)))?;
- // Ensure secret key is valid before building info
- SecretKey::from_secret_bytes(key_bytes)
- .map_err(|e| WasmSdkError::invalid_argument(format!("Invalid secret key: {}", e)))?;
-
let key_pair = Self::build_key_pair(&private_key, net, network_wasm.as_str())?;
Ok(KeyPairWasm::from(key_pair))
}
@@ -219,14 +214,14 @@ impl WasmSdk {
let message_bytes = message.as_bytes();
let hash = sha256::Hash::hash(message_bytes);
- // Sign the hash
- let secret_key = SecretKey::from_secret_bytes(*private_key.inner.to_bytes())
- .map_err(|e| WasmSdkError::invalid_argument(format!("Invalid secret key: {}", e)))?;
-
- let message_hash = dash_sdk::dpp::secp256k1::Message::from_digest(hash.to_byte_array());
- let signature = secret_key.sign_ecdsa(message_hash);
+ // Preserve deterministic, non-grinding compact signature bytes.
+ let signature = private_key
+ .inner
+ .sign_recoverable(&hash.to_byte_array())
+ .signature()
+ .map_err(|e| WasmSdkError::generic(format!("Failed to encode signature: {}", e)))?;
- Ok(hex::encode(signature.serialize_compact()))
+ Ok(hex::encode(signature.to_bytes()))
}
/// Generate deterministic test identity keys for SDK functional tests.
From 0ae0e930078a5dd9cc92c35341d6ebe1b5b157ff Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:13:09 +0000
Subject: [PATCH 18/21] test(wasm-sdk): preserve deterministic message
signature encoding
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
.../wasm-sdk/src/wallet/key_generation.rs | 28 +++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/packages/wasm-sdk/src/wallet/key_generation.rs b/packages/wasm-sdk/src/wallet/key_generation.rs
index 3e833a72bc9..fc275d6fb00 100644
--- a/packages/wasm-sdk/src/wallet/key_generation.rs
+++ b/packages/wasm-sdk/src/wallet/key_generation.rs
@@ -289,3 +289,31 @@ impl WasmSdk {
Ok(to_object(&result)?)
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use secp256k1::{Message, SecretKey};
+
+ #[test]
+ fn should_preserve_message_signature_bytes_for_both_wif_encodings() {
+ let scalar = [1; 32];
+ let raw = SecretKey::from_secret_bytes(scalar).expect("valid scalar");
+ let mut private_key =
+ PrivateKey::from_byte_array(&scalar, Network::Testnet).expect("valid scalar");
+ for compressed in [true, false] {
+ private_key.compressed = compressed;
+ for i in 0..32 {
+ let message = format!("message {i}");
+ let digest = sha256::Hash::hash(message.as_bytes()).to_byte_array();
+ let expected = raw
+ .sign_ecdsa(Message::from_digest(digest))
+ .serialize_compact();
+ assert_eq!(
+ WasmSdk::sign_message(&message, &private_key.to_wif()).expect("signature"),
+ hex::encode(expected)
+ );
+ }
+ }
+ }
+}
From 4fb5d0036b8e926a5ba86f47081d15372b8a43b4 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:25:41 +0000
Subject: [PATCH 19/21] refactor: remove production DPP raw secp256k1
dependency
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Use Core typed keys and signatures throughout non-ECDH consumers, retaining
raw primitives only at the encryption boundary and in compatibility tests.
Preserve seeded key generation, compact signature bytes, and validation
outcomes with differential and historical-vector coverage.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
Co-Authored-By: Codex GPT-6
---
Cargo.lock | 6 +
packages/rs-dpp/Cargo.toml | 2 +-
.../identity/identity_public_key/key_type.rs | 63 ++++----
.../identity_public_key/v0/methods/mod.rs | 17 ++-
packages/rs-dpp/src/lib.rs | 2 -
packages/rs-dpp/src/state_transition/mod.rs | 54 ++-----
.../state_transition_identity_signed.rs | 8 +-
.../instant_asset_lock_proof_fixture.rs | 9 +-
packages/rs-dpp/tests/ecdsa_compatibility.rs | 40 ++++-
.../generate_wasm_contract_cache_vectors.rs | 14 +-
...rate_wasm_state_transition_wait_vectors.rs | 14 +-
.../src/execution/check_tx/v0/mod.rs | 22 +--
.../identity_create_from_addresses/tests.rs | 52 ++++---
.../state_transitions/identity_update/mod.rs | 139 +++++++++---------
.../state_transitions/test_helpers.rs | 34 +++--
.../tests/strategy_tests/strategy.rs | 21 ++-
packages/rs-platform-wallet/Cargo.toml | 2 +
.../examples/dpns_marketplace_testnet.rs | 4 +-
.../src/masternode/locator.rs | 12 +-
.../src/wallet/identity/crypto/auto_accept.rs | 71 ++++++---
.../src/wallet/identity/crypto/validation.rs | 8 +-
.../wallet/identity/network/contact_info.rs | 2 +-
.../identity/network/contact_requests.rs | 63 ++++----
.../identity/network/identity_handle.rs | 9 +-
.../src/wallet/identity/network/invitation.rs | 5 +-
.../src/wallet/identity/network/payments.rs | 47 +++---
.../src/wallet/identity/network/sdk_writer.rs | 15 +-
.../wallet/identity/network/seed_binding.rs | 5 +-
.../src/wallet/shielded/wallet_drain_tests.rs | 4 +-
.../rs-scripts/src/bin/register_identity.rs | 5 +-
packages/rs-sdk/Cargo.toml | 2 +
.../src/platform/dashpay/contact_request.rs | 9 +-
.../rs-sdk/src/platform/dashpay/invitation.rs | 55 ++++---
.../rs-sdk/src/platform/dashpay/profile.rs | 4 +-
.../rs-sdk/src/platform/dpns_usernames/mod.rs | 4 +-
packages/rs-sdk/src/platform/encrypted_for.rs | 6 +-
.../platform/moderation_charters/requests.rs | 8 +-
.../src/platform/transition/put_document.rs | 4 +-
packages/simple-signer/Cargo.toml | 6 +-
packages/simple-signer/src/signer.rs | 50 ++++++-
packages/strategy-tests/src/transitions.rs | 6 +-
41 files changed, 496 insertions(+), 407 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 00ebaadcf9f..e7b9e2bf9ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1987,6 +1987,7 @@ dependencies = [
"rs-dapi-client",
"rs-sdk-trusted-context-provider",
"sanitize-filename",
+ "secp256k1",
"serde",
"serde_json",
"tempfile",
@@ -5568,6 +5569,7 @@ dependencies = [
"rayon",
"rs-sdk-trusted-context-provider",
"rusqlite",
+ "secp256k1",
"serde",
"serde_json",
"sha2 0.10.9",
@@ -5603,6 +5605,7 @@ dependencies = [
"parking_lot",
"platform-wallet",
"rs-sdk-ffi",
+ "secp256k1",
"serde_json",
"tokio",
"tokio-metrics",
@@ -6760,6 +6763,7 @@ dependencies = [
"once_cell",
"platform-encryption",
"rs-sdk-trusted-context-provider",
+ "secp256k1",
"serde",
"serde_json",
"simple-signer",
@@ -7523,6 +7527,7 @@ dependencies = [
"grovedb-bincode",
"hex",
"rand 0.8.6",
+ "secp256k1",
"tracing",
"zeroize",
]
@@ -9131,6 +9136,7 @@ dependencies = [
"rand 0.8.6",
"rs-dapi-client",
"rs-sdk-trusted-context-provider",
+ "secp256k1",
"serde",
"serde-wasm-bindgen 0.5.0",
"serde_json",
diff --git a/packages/rs-dpp/Cargo.toml b/packages/rs-dpp/Cargo.toml
index a7e1e10b675..c561826f240 100644
--- a/packages/rs-dpp/Cargo.toml
+++ b/packages/rs-dpp/Cargo.toml
@@ -12,7 +12,6 @@ authors = [
]
[dependencies]
-secp256k1 = { workspace = true }
dash-pkc = { git = "https://github.com/dashpay/base-sdk", rev = "33fcc59e1868c803f9608e0e78ee8bddf3abcee7", default-features = false, features = ["bls"], optional = true }
# Keep downstream lockfiles from retaining blst versions without WASM aggregate verification.
# TODO: Remove this constraint once the pinned rust-dashcore dependency graph enforces a compatible blst minimum.
@@ -85,6 +84,7 @@ tracing = { version = "0.1.41" }
grovedb-commitment-tree = { workspace = true, optional = true }
[dev-dependencies]
+secp256k1 = { workspace = true }
tokio = { version = "1.40", features = ["full"] }
pretty_assertions = { version = "1.4.1" }
dpp = { path = ".", default-features = false, features = [
diff --git a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
index 02df74d6347..115348572c4 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
@@ -3,13 +3,14 @@ use anyhow::bail;
use bincode::{Decode, DecodeUntrusted, Encode};
#[cfg(feature = "cbor")]
use ciborium::value::Value as CborValue;
+use dashcore::crypto::ecdsa::EcdsaSecretKey;
+#[cfg(feature = "random-public-keys")]
+use dashcore::key::rand::rngs::StdRng as EcdsaRng;
+#[cfg(feature = "random-public-keys")]
+use dashcore::key::rand::{RngCore, SeedableRng};
use dashcore::Network;
use itertools::Itertools;
use lazy_static::lazy_static;
-#[cfg(feature = "random-public-keys")]
-use secp256k1::rand::rngs::StdRng as EcdsaRng;
-#[cfg(feature = "random-public-keys")]
-use secp256k1::rand::SeedableRng;
#[cfg(feature = "bls-signatures")]
use crate::bls::{self, BlsError};
@@ -71,6 +72,17 @@ lazy_static! {
.unwrap();
}
+#[cfg(feature = "random-public-keys")]
+fn random_ecdsa_secret_key(rng: &mut EcdsaRng) -> EcdsaSecretKey {
+ loop {
+ let mut bytes = [0; 32];
+ rng.fill_bytes(&mut bytes);
+ if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) {
+ return key;
+ }
+ }
+}
+
impl KeyType {
/// Gets the default size of the public key
pub fn default_size(&self) -> usize {
@@ -163,9 +175,9 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = secp256k1::SecretKey::new(&mut rng);
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- public_key.serialize().to_vec()
+ let secret_key = random_ecdsa_secret_key(&mut rng);
+ let public_key = secret_key.public_key();
+ public_key.to_compressed().to_vec()
}
KeyType::BLS12_381 => {
let private_key = bls::SecretKey::random(rng);
@@ -207,11 +219,11 @@ impl KeyType {
) -> Result, ProtocolError> {
match self {
KeyType::ECDSA_SECP256K1 => {
- let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
+ let secret_key = EcdsaSecretKey::from_bytes(private_key_bytes)
.map_err(|e| ProtocolError::Generic(e.to_string()))?;
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let public_key = secret_key.public_key();
- Ok(public_key.serialize().to_vec())
+ Ok(public_key.to_compressed().to_vec())
}
KeyType::BLS12_381 => {
#[cfg(feature = "bls-signatures")]
@@ -233,11 +245,11 @@ impl KeyType {
));
}
KeyType::ECDSA_HASH160 => {
- let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes)
+ let secret_key = EcdsaSecretKey::from_bytes(private_key_bytes)
.map_err(|e| ProtocolError::Generic(e.to_string()))?;
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let public_key = secret_key.public_key();
- Ok(ripemd160_sha256(public_key.serialize().as_slice()).to_vec())
+ Ok(ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec())
}
KeyType::EDDSA_25519_HASH160 => {
#[cfg(feature = "ed25519-dalek")]
@@ -264,12 +276,9 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = secp256k1::SecretKey::new(&mut rng);
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
- (
- public_key.serialize().to_vec(),
- secret_key.to_secret_bytes(),
- )
+ let secret_key = random_ecdsa_secret_key(&mut rng);
+ let public_key = secret_key.public_key();
+ (public_key.to_compressed().to_vec(), *secret_key.to_bytes())
}
KeyType::BLS12_381 => {
let private_key = crate::bls::SecretKey::random(rng);
@@ -280,11 +289,11 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = secp256k1::SecretKey::new(&mut rng);
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let secret_key = random_ecdsa_secret_key(&mut rng);
+ let public_key = secret_key.public_key();
(
- ripemd160_sha256(public_key.serialize().as_slice()).to_vec(),
- secret_key.to_secret_bytes(),
+ ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec(),
+ *secret_key.to_bytes(),
)
}
KeyType::EDDSA_25519_HASH160 => {
@@ -299,11 +308,11 @@ impl KeyType {
let mut seed = [0u8; 32];
rng.fill(&mut seed);
let mut rng = EcdsaRng::from_seed(seed);
- let secret_key = secp256k1::SecretKey::new(&mut rng);
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let secret_key = random_ecdsa_secret_key(&mut rng);
+ let public_key = secret_key.public_key();
(
- ripemd160_sha256(public_key.serialize().as_slice()).to_vec(),
- secret_key.to_secret_bytes(),
+ ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec(),
+ *secret_key.to_bytes(),
)
}
}
diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
index 9f30211a538..4f986140e00 100644
--- a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
+++ b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
@@ -8,10 +8,10 @@ use crate::identity::KeyType;
use crate::util::hash::ripemd160_sha256;
use crate::ProtocolError;
use anyhow::anyhow;
+use dashcore::crypto::ecdsa::EcdsaSecretKey;
use dashcore::hashes::Hash;
use dashcore::{Network, PublicKey as ECDSAPublicKey};
use platform_value::{BinaryData, Bytes20};
-use secp256k1::SecretKey;
impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
/// Get the original public key hash
fn public_key_hash(&self) -> Result<[u8; 20], ProtocolError> {
@@ -82,13 +82,13 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k
) -> Result {
match key_type {
KeyType::ECDSA_SECP256K1 => {
- let secret_key = match SecretKey::from_secret_bytes(*private_key_bytes) {
+ let secret_key = match EcdsaSecretKey::from_bytes(private_key_bytes) {
Ok(secret_key) => secret_key,
Err(_) => return Ok(false),
};
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let public_key = secret_key.public_key();
- Ok(public_key.serialize().as_slice() == data.as_slice())
+ Ok(public_key.to_compressed().as_slice() == data.as_slice())
}
KeyType::BLS12_381 => {
#[cfg(feature = "bls-signatures")]
@@ -108,13 +108,16 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k
));
}
KeyType::ECDSA_HASH160 => {
- let secret_key = match SecretKey::from_secret_bytes(*private_key_bytes) {
+ let secret_key = match EcdsaSecretKey::from_bytes(private_key_bytes) {
Ok(secret_key) => secret_key,
Err(_) => return Ok(false),
};
- let public_key = secp256k1::PublicKey::from_secret_key(&secret_key);
+ let public_key = secret_key.public_key();
- Ok(ripemd160_sha256(public_key.serialize().as_slice()).as_slice() == data.as_slice())
+ Ok(
+ ripemd160_sha256(public_key.to_compressed().as_slice()).as_slice()
+ == data.as_slice(),
+ )
}
KeyType::EDDSA_25519_HASH160 => {
#[cfg(feature = "ed25519-dalek")]
diff --git a/packages/rs-dpp/src/lib.rs b/packages/rs-dpp/src/lib.rs
index f893f1423ff..2a7ab144989 100644
--- a/packages/rs-dpp/src/lib.rs
+++ b/packages/rs-dpp/src/lib.rs
@@ -14,8 +14,6 @@
extern crate core;
pub use dashcore;
-/// Low-level ECDSA primitives used by Platform signature validation.
-pub use secp256k1;
#[cfg(feature = "core_key_wallet")]
pub use key_wallet;
diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs
index 1c4ecc83b6b..c8befa9d8a6 100644
--- a/packages/rs-dpp/src/state_transition/mod.rs
+++ b/packages/rs-dpp/src/state_transition/mod.rs
@@ -9,6 +9,8 @@ use platform_value::{BinaryData, Identifier};
pub use state_transition_types::*;
use bincode::{Decode, DecodeUntrusted, Encode};
+#[cfg(all(feature = "state-transition-signing", feature = "core_key_wallet"))]
+use dashcore::crypto::ecdsa::{EcdsaPublicKey, EcdsaRecSignature};
#[cfg(any(
feature = "state-transition-signing",
feature = "state-transition-validation"
@@ -2211,15 +2213,10 @@ impl StateTransition {
path: &::key_wallet::bip32::DerivationPath,
signer: &S,
) -> Result<(), ProtocolError> {
- use dashcore::crypto::ecdsa::EcdsaRecSignature;
- use dashcore::signer::double_sha;
- use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
- use secp256k1::Message;
-
let data = self.signable_bytes()?;
// Pre-image transform matches `dashcore::signer::sign`: double-SHA256
// of the signable bytes is the actual ECDSA message digest.
- let data_hash = double_sha(&data);
+ let data_hash = signer::double_sha(&data);
let digest: [u8; 32] = data_hash.as_slice().try_into().map_err(|_| {
ProtocolError::Generic("double_sha did not return 32 bytes".to_string())
})?;
@@ -2229,32 +2226,16 @@ impl StateTransition {
.await
.map_err(|e| ProtocolError::ExternalSignerError(format!("signer failed: {}", e)))?;
- // The signer returns a non-recoverable signature. The legacy path
- // stores a 65-byte recoverable compact signature, so we brute-force
- // the recovery id (0..3) by reconstructing a `RecoverableSignature`
- // and comparing the recovered public key with the one the signer
- // returned. secp256k1 normalises both `sign_ecdsa` and
- // `sign_ecdsa_recoverable` outputs to low-s form, so the 64-byte
- // `r||s` payload is bit-identical to what `dashcore::signer::sign`
- // produces.
- let compact_64 = signature.to_bytes();
- let msg = Message::from_digest(digest);
-
- let mut found: Option = None;
- for id in 0..4i32 {
- let recid = match RecoveryId::try_from(id) {
- Ok(r) => r,
- Err(_) => continue,
- };
- let candidate = match RecoverableSignature::from_compact(&compact_64, recid) {
- Ok(s) => s,
+ // Recover the metadata without changing the signer's compact signature bytes.
+ let mut found = None;
+ for id in 0..4 {
+ let candidate = match EcdsaRecSignature::from_parts(signature, id, true) {
+ Ok(candidate) => candidate,
Err(_) => continue,
};
- if let Ok(recovered) = candidate.recover_ecdsa(msg) {
- if recovered == public_key.into() {
- found = Some(candidate);
- break;
- }
+ if EcdsaPublicKey::recover(&digest, &candidate).is_ok_and(|key| key == public_key) {
+ found = Some(candidate);
+ break;
}
}
let recoverable = found.ok_or_else(|| {
@@ -2268,18 +2249,7 @@ impl StateTransition {
)
})?;
- // Compressed-pubkey convention matches `dashcore::signer::sign`, which
- // always passes `true` regardless of the underlying key encoding. The
- // signer's `sign_ecdsa` returns the compressed `secp256k1::PublicKey`,
- // so this is consistent.
- let (recovery_id, _) = recoverable.serialize_compact();
- let compact_65 = EcdsaRecSignature::from_parts(
- recoverable.to_standard().into(),
- recovery_id.to_u8(),
- true,
- )
- .map_err(|e| ProtocolError::ExternalSignerError(e.to_string()))?
- .to_bytes();
+ let compact_65 = recoverable.to_bytes();
if !self.set_signature(compact_65.to_vec().into()) {
return Err(ProtocolError::InvalidVerificationWrongNumberOfElements {
diff --git a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
index 3bc6085669f..b66172bf9e0 100644
--- a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
+++ b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs
@@ -6,7 +6,7 @@ use crate::consensus::signature::{
InvalidSignaturePublicKeySecurityLevelError, PublicKeyIsDisabledError,
};
use anyhow::anyhow;
-use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
+use dashcore::crypto::ecdsa::{EcdsaError, EcdsaSecretKey};
#[cfg(feature = "state-transition-validation")]
use crate::state_transition::errors::WrongPublicKeyPurposeError;
@@ -107,11 +107,11 @@ pub trait StateTransitionIdentitySigned: StateTransitionLike {
pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], ProtocolError> {
let sk = <[u8; 32]>::try_from(private_key)
- .map_err(|_| secp256k1::Error::InvalidSecretKey)
- .and_then(RawSecretKey::from_secret_bytes)
+ .map_err(|_| EcdsaError::InvalidSecretKey)
+ .and_then(|bytes| EcdsaSecretKey::from_bytes(&bytes))
.map_err(|e| anyhow!("Invalid ECDSA private key: {}", e))?;
- let public_key_compressed = RawPublicKey::from_secret_key(&sk).serialize();
+ let public_key_compressed = sk.public_key().to_compressed();
Ok(public_key_compressed)
}
diff --git a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
index 07308342871..99c7679efe7 100644
--- a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
+++ b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs
@@ -1,4 +1,4 @@
-use secp256k1::SecretKey;
+use dashcore::crypto::ecdsa::EcdsaSecretKey;
use std::str::FromStr;
use dashcore::bls_sig_utils::BLSSignature;
@@ -10,7 +10,6 @@ use dashcore::transaction::special_transaction::TransactionPayload;
use dashcore::{
InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxIn, TxOut, Txid,
};
-use secp256k1::rand::rng;
use crate::identity::state_transition::asset_lock_proof::{AssetLockProof, InstantAssetLockProof};
@@ -45,16 +44,14 @@ pub fn instant_asset_lock_proof_transaction_fixture(
one_time_private_key: Option,
amount: Option,
) -> Transaction {
- let mut rng = rng();
-
let private_key_hex = "cSBnVM4xvxarwGQuAfQFwqDg9k5tErHUHzgWsEfD4zdwUasvqRVY";
let private_key = PrivateKey::from_str(private_key_hex).unwrap();
let public_key = private_key.public_key();
let public_key_hash = public_key.pubkey_hash();
//let from_address = Address::p2pkh(&public_key, Network::Testnet);
- let secret_key = SecretKey::new(&mut rng);
+ let secret_key = EcdsaSecretKey::generate();
let one_time_private_key = one_time_private_key.unwrap_or_else(|| {
- PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Testnet)
+ PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Testnet)
.expect("valid test secret key")
});
let one_time_public_key = one_time_private_key.public_key();
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
index f73658df3af..3481f05c794 100644
--- a/packages/rs-dpp/tests/ecdsa_compatibility.rs
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -13,9 +13,9 @@ use dpp::dashcore::{sign_message, PublicKey};
use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
-use dpp::secp256k1::{ecdsa::RecoverableSignature, ecdsa::RecoveryId, Message};
use dpp::serialization::PlatformMessageSignable;
use dpp::ProtocolError;
+use secp256k1::{ecdsa::RecoverableSignature, ecdsa::RecoveryId, Message};
use vectors::{ECDSA_PUBLIC_KEY, TRANSFER_ECDSA_SIGNATURE, TRANSFER_HASH, TRANSFER_SIGNABLE};
fn fixture() -> (Vec, Vec, Vec) {
@@ -31,7 +31,7 @@ fn should_match_historical_verification_for_all_headers_and_scalar_boundaries()
let (data, signature, public_key) = fixture();
let message =
Message::from_digest(dpp::dashcore::hashes::sha256d::Hash::hash(&data).to_byte_array());
- let raw_key = dpp::secp256k1::PublicKey::from_slice(&public_key).unwrap();
+ let raw_key = secp256k1::PublicKey::from_slice(&public_key).unwrap();
let order =
hex::decode("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap();
let mut signatures = vec![signature.clone()];
@@ -77,8 +77,8 @@ fn should_preserve_witness_fee_operations_for_recovery_and_multisig_search() {
AddressWitnessVerificationOperations::for_p2pkh(data.len())
);
- let other = dpp::secp256k1::SecretKey::from_secret_bytes([2; 32]).unwrap();
- let other_key = dpp::secp256k1::PublicKey::from_secret_key(&other).serialize();
+ let other = secp256k1::SecretKey::from_secret_bytes([2; 32]).unwrap();
+ let other_key = secp256k1::PublicKey::from_secret_key(&other).serialize();
let mut script = vec![0x51, 33];
script.extend_from_slice(&other_key);
script.push(33);
@@ -352,3 +352,35 @@ fn should_use_core_identity_public_key_errors_and_preserve_encoding() {
"unable to create pub key - key prefix invalid: 6"
);
}
+
+#[test]
+fn should_preserve_seeded_key_generation_and_rng_consumption() {
+ use rand::{rngs::StdRng, Rng, SeedableRng};
+ use secp256k1::rand::{rngs::StdRng as LegacyRng, SeedableRng as _};
+ let version = dpp::version::PlatformVersion::latest();
+ for seed in 0..64 {
+ for key_type in [
+ KeyType::ECDSA_SECP256K1,
+ KeyType::ECDSA_HASH160,
+ KeyType::BIP13_SCRIPT_HASH,
+ ] {
+ let mut actual_rng = StdRng::seed_from_u64(seed);
+ let mut expected_rng = actual_rng.clone();
+ let mut seed = [0u8; 32];
+ expected_rng.fill(&mut seed);
+ let secret = secp256k1::SecretKey::new(&mut LegacyRng::from_seed(seed));
+ let public = secp256k1::PublicKey::from_secret_key(&secret).serialize();
+ let expected_public = if key_type == KeyType::ECDSA_SECP256K1 {
+ public.to_vec()
+ } else {
+ hash160::Hash::hash(&public).to_byte_array().to_vec()
+ };
+ let (actual_public, actual_secret) = key_type
+ .random_public_and_private_key_data(&mut actual_rng, version)
+ .unwrap();
+ assert_eq!(actual_secret, secret.to_secret_bytes());
+ assert_eq!(actual_public, expected_public);
+ assert_eq!(actual_rng.gen::<[u8; 32]>(), expected_rng.gen::<[u8; 32]>());
+ }
+ }
+}
diff --git a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
index 32a039a8d70..5d11e11e539 100644
--- a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
+++ b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs
@@ -9,6 +9,7 @@ use dapi_grpc::platform::v0::{
use dpp::address_funds::AddressWitness;
use dpp::block::block_info::BlockInfo;
use dpp::bls::SecretKey;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
@@ -21,7 +22,6 @@ use dpp::identity::{
Identity, IdentityPublicKey, IdentityV0, KeyType, PartialIdentity, Purpose, SecurityLevel,
};
use dpp::platform_value::{platform_value, BinaryData, Value};
-use dpp::secp256k1;
use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition;
use dpp::state_transition::batch_transition::batched_transition::BatchedTransitionRef;
@@ -128,12 +128,12 @@ fn identity_key_with_seed(seed: u8) -> IdentityPublicKey {
purpose: Purpose::AUTHENTICATION,
security_level: SecurityLevel::CRITICAL,
key_type: KeyType::ECDSA_SECP256K1,
- data: secp256k1::PublicKey::from_secret_key(
- &secp256k1::SecretKey::from_secret_bytes([seed; 32]).expect("identity secret"),
- )
- .serialize()
- .to_vec()
- .into(),
+ data: EcdsaSecretKey::from_bytes(&[seed; 32])
+ .expect("identity secret")
+ .public_key()
+ .to_compressed()
+ .to_vec()
+ .into(),
..Default::default()
})
}
diff --git a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
index 23f0fbfdd63..71bf691cf3f 100644
--- a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
+++ b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs
@@ -9,6 +9,7 @@ use dapi_grpc::Message;
use dpp::address_funds::AddressWitness;
use dpp::block::block_info::BlockInfo;
use dpp::bls::SecretKey;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::config::moderation::{ContractModerationConfig, ContractModerators};
@@ -19,7 +20,6 @@ use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey, IdentityV0, KeyType, Purpose, SecurityLevel};
use dpp::platform_value::{platform_value, BinaryData, Value};
-use dpp::secp256k1;
use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition;
@@ -116,12 +116,12 @@ fn identity_key() -> IdentityPublicKey {
purpose: Purpose::AUTHENTICATION,
security_level: SecurityLevel::CRITICAL,
key_type: KeyType::ECDSA_SECP256K1,
- data: secp256k1::PublicKey::from_secret_key(
- &secp256k1::SecretKey::from_secret_bytes([1; 32]).expect("identity secret"),
- )
- .serialize()
- .to_vec()
- .into(),
+ data: EcdsaSecretKey::from_bytes(&[1; 32])
+ .expect("identity secret")
+ .public_key()
+ .to_compressed()
+ .to_vec()
+ .into(),
..Default::default()
})
}
diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
index 88540c43801..3ed67a7f47a 100644
--- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
+++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs
@@ -295,9 +295,9 @@ mod tests {
use dpp::validation::ValidationResult;
use simple_signer::signer::SimpleSigner;
+ use crate::execution::validation::state_transition::test_helpers::random_ecdsa_secret_key;
use dpp::consensus::ConsensusError;
use dpp::dashcore::{signer, Network, PrivateKey};
- use dpp::secp256k1::Keypair;
use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
use dpp::data_contract::document_type::random_document::{
@@ -339,6 +339,8 @@ mod tests {
use assert_matches::assert_matches;
use dpp::consensus::state::state_error::StateError;
use dpp::dash_to_credits;
+ use dpp::dashcore::key::rand::rngs::StdRng as SecpStdRng;
+ use dpp::dashcore::key::rand::SeedableRng as _;
use dpp::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Setters;
use dpp::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
use dpp::data_contract::change_control_rules::v0::ChangeControlRulesV0;
@@ -356,8 +358,6 @@ mod tests {
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::signer::Signer;
use dpp::platform_value::Bytes32;
- use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng;
- use dpp::secp256k1::rand::SeedableRng as _;
use dpp::state_transition::batch_transition::methods::v1::DocumentsBatchTransitionMethodsV1;
use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
@@ -3910,7 +3910,7 @@ mod tests {
let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1));
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -3918,7 +3918,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
};
@@ -3926,9 +3926,9 @@ mod tests {
let signable_bytes = new_key
.signable_bytes()
.expect("expected to get signable bytes");
- let secret = new_key_pair.secret_key();
+ let secret = &new_key_pair;
let signature =
- signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign");
+ signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign");
new_key.signature = signature.to_vec().into();
@@ -4010,7 +4010,7 @@ mod tests {
let platform_state = platform.state.load();
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -4018,7 +4018,7 @@ mod tests {
security_level: SecurityLevel::MEDIUM,
key_type: ECDSA_SECP256K1,
read_only: true,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(SingleContractDocumentType {
id: Dashpay.id(),
@@ -4045,8 +4045,8 @@ mod tests {
let data = update_transition
.signable_bytes()
.expect("expected signable bytes");
- let secret = new_key_pair.secret_key();
- new_key.signature = signer::sign(&data, &secret.to_secret_bytes())
+ let secret = &new_key_pair;
+ new_key.signature = signer::sign(&data, secret.to_bytes().as_ref())
.expect("expected to sign")
.to_vec()
.into();
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
index 9596a86d6b5..aabbd2be487 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs
@@ -9376,23 +9376,23 @@ mod tests {
mod actual_signature_verification {
use super::*;
use dpp::dashcore::hashes::Hash;
- use dpp::secp256k1::PublicKey as RawSecp256k1PublicKey;
use dpp::serialization::Signable;
/// Helper to create a properly signed P2PKH witness
/// Note: Creates a recoverable signature for P2PKH (65 bytes)
fn create_real_p2pkh_witness(
- secret_key: &dpp::secp256k1::SecretKey,
+ secret_key: &dpp::dashcore::crypto::ecdsa::EcdsaSecretKey,
signable_bytes: &[u8],
) -> (PlatformAddress, AddressWitness) {
- let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret_key);
+ let raw_pubkey = secret_key.public_key();
let pubkey = PublicKey::new(raw_pubkey);
- let pubkey_hash = dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes());
+ let pubkey_hash =
+ dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref());
let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array());
// Sign using dashcore::signer which creates a recoverable signature
let signature =
- dpp::dashcore::signer::sign(signable_bytes, secret_key.as_secret_bytes())
+ dpp::dashcore::signer::sign(signable_bytes, secret_key.to_bytes().as_ref())
.expect("signing should succeed");
let witness = AddressWitness::P2pkh {
@@ -9410,16 +9410,17 @@ mod tests {
let public_keys = create_default_public_keys(&mut rng, platform_version);
// Create a real secret key
- let secret_key = dpp::secp256k1::SecretKey::from_secret_bytes([
+ let secret_key = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
0x1d, 0x1e, 0x1f, 0x20,
])
.expect("valid secret key");
- let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(&secret_key);
+ let raw_pubkey = secret_key.public_key();
let pubkey = PublicKey::new(raw_pubkey);
- let pubkey_hash = dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes());
+ let pubkey_hash =
+ dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref());
let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array());
let mut inputs = BTreeMap::new();
@@ -9446,7 +9447,7 @@ mod tests {
// Now create the signature using recoverable signing
let signature =
- dpp::dashcore::signer::sign(&signable_bytes, secret_key.as_secret_bytes())
+ dpp::dashcore::signer::sign(&signable_bytes, secret_key.to_bytes().as_ref())
.expect("signing should succeed");
// Create the signed transition
@@ -9487,16 +9488,17 @@ mod tests {
// Create address from one key
let correct_secret =
- dpp::secp256k1::SecretKey::from_secret_bytes([1u8; 32]).expect("valid secret key");
- let raw_correct_pubkey = RawSecp256k1PublicKey::from_secret_key(&correct_secret);
+ dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[1u8; 32])
+ .expect("valid secret key");
+ let raw_correct_pubkey = correct_secret.public_key();
let correct_pubkey = PublicKey::new(raw_correct_pubkey);
let pubkey_hash =
- dpp::dashcore::hashes::hash160::Hash::hash(&correct_pubkey.to_bytes());
+ dpp::dashcore::hashes::hash160::Hash::hash(correct_pubkey.to_bytes().as_ref());
let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array());
// But sign with different key
- let wrong_secret =
- dpp::secp256k1::SecretKey::from_secret_bytes([2u8; 32]).expect("valid secret key");
+ let wrong_secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[2u8; 32])
+ .expect("valid secret key");
let mut inputs = BTreeMap::new();
inputs.insert(address.clone(), (1 as AddressNonce, dash_to_credits!(1.0)));
@@ -9523,7 +9525,7 @@ mod tests {
// Sign with WRONG key - this will produce a signature that when recovered
// will give a different public key than expected
let wrong_signature =
- dpp::dashcore::signer::sign(&signable_bytes, wrong_secret.as_secret_bytes())
+ dpp::dashcore::signer::sign(&signable_bytes, wrong_secret.to_bytes().as_ref())
.expect("signing should succeed");
// Create transition with mismatched signature (signed by wrong key)
@@ -9557,17 +9559,18 @@ mod tests {
.map(|i| {
let mut key_bytes = [0u8; 32];
key_bytes[0] = i;
- dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid")
+ dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&key_bytes)
+ .expect("valid")
})
.collect();
let addresses: Vec<_> = secrets
.iter()
.map(|secret| {
- let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret);
+ let raw_pubkey = secret.public_key();
let pubkey = PublicKey::new(raw_pubkey);
let pubkey_hash =
- dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes());
+ dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref());
PlatformAddress::P2pkh(pubkey_hash.to_byte_array())
})
.collect();
@@ -9609,7 +9612,7 @@ mod tests {
.expect("should find");
let secret = &secrets[idx];
let signature =
- dpp::dashcore::signer::sign(&signable_bytes, secret.as_secret_bytes())
+ dpp::dashcore::signer::sign(&signable_bytes, secret.to_bytes().as_ref())
.expect("signing should succeed");
witnesses.push(AddressWitness::P2pkh {
@@ -9645,15 +9648,16 @@ mod tests {
.map(|i| {
let mut key_bytes = [0u8; 32];
key_bytes[0] = i + 10;
- dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid")
+ dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&key_bytes)
+ .expect("valid")
})
.collect();
let pubkeys: Vec<[u8; 33]> = secrets
.iter()
.map(|secret| {
- let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret);
- raw_pubkey.serialize()
+ let raw_pubkey = secret.public_key();
+ raw_pubkey.to_compressed()
})
.collect();
@@ -9697,9 +9701,9 @@ mod tests {
.expect("should get signable bytes");
// Sign with first 2 keys (2-of-3) using DER signatures for P2SH
- let sig1 = dpp::dashcore::signer::sign(&signable_bytes, secrets[0].as_secret_bytes())
+ let sig1 = dpp::dashcore::signer::sign(&signable_bytes, secrets[0].to_bytes().as_ref())
.expect("signing should succeed");
- let sig2 = dpp::dashcore::signer::sign(&signable_bytes, secrets[1].as_secret_bytes())
+ let sig2 = dpp::dashcore::signer::sign(&signable_bytes, secrets[1].to_bytes().as_ref())
.expect("signing should succeed");
let _signed_transition = IdentityCreateFromAddressesTransition::V0(
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
index cdf34a96a22..b8f12557530 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs
@@ -129,6 +129,7 @@ impl StateTransitionStateValidation for IdentityUpdateTransition {
#[cfg(test)]
mod tests {
use crate::config::{PlatformConfig, PlatformTestConfig};
+ use crate::execution::validation::state_transition::test_helpers::random_ecdsa_secret_key;
use crate::execution::validation::state_transition::tests::{
setup_add_key_to_identity, setup_identity_return_master_key,
};
@@ -140,6 +141,9 @@ mod tests {
use dpp::consensus::codes::ErrorWithCode;
use dpp::consensus::ConsensusError;
use dpp::dash_to_credits;
+ use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
+ use dpp::dashcore::key::rand::rngs::StdRng as SecpStdRng;
+ use dpp::dashcore::key::rand::SeedableRng as _;
use dpp::dashcore::signer;
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::identifier::Identifier;
@@ -149,9 +153,6 @@ mod tests {
use dpp::identity::signer::Signer;
use dpp::identity::KeyType::ECDSA_SECP256K1;
use dpp::identity::{KeyType, Purpose, SecurityLevel};
- use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng;
- use dpp::secp256k1::rand::SeedableRng as _;
- use dpp::secp256k1::Keypair;
use dpp::serialization::{PlatformSerializable, Signable};
use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0;
use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
@@ -262,7 +263,7 @@ mod tests {
let mut rng = SecpStdRng::seed_from_u64(292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -270,7 +271,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
};
@@ -293,9 +294,9 @@ mod tests {
.signable_bytes()
.expect("expected signable bytes");
- let secret = new_key_pair.secret_key();
+ let secret = &new_key_pair;
let signature =
- signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign");
+ signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign");
new_key.signature = signature.to_vec().into();
@@ -542,14 +543,14 @@ mod tests {
};
let platform_state = platform.state.load();
let mut rng = SecpStdRng::seed_from_u64(292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
purpose: Purpose::AUTHENTICATION,
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(bounds.clone()),
};
@@ -567,13 +568,10 @@ mod tests {
.into()
};
let signable_bytes = build(new_key.clone()).signable_bytes().unwrap();
- new_key.signature = signer::sign(
- &signable_bytes,
- &new_key_pair.secret_key().to_secret_bytes(),
- )
- .unwrap()
- .to_vec()
- .into();
+ new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref())
+ .unwrap()
+ .to_vec()
+ .into();
let mut update_transition = build(new_key);
update_transition
.set_signature(signer.sign(&key, signable_bytes.as_slice()).await.unwrap());
@@ -752,7 +750,7 @@ mod tests {
};
let platform_state = platform.state.load();
let mut rng = SecpStdRng::seed_from_u64(293);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let build =
|revision: u64, nonce: u64, add: Vec, disable| {
StateTransition::from(IdentityUpdateTransition::from(IdentityUpdateTransitionV0 {
@@ -777,20 +775,17 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(bounds.clone()),
};
let signable_bytes = build(revision, nonce, vec![new_key.clone()], vec![])
.signable_bytes()
.unwrap();
- new_key.signature = signer::sign(
- &signable_bytes,
- &new_key_pair.secret_key().to_secret_bytes(),
- )
- .unwrap()
- .to_vec()
- .into();
+ new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref())
+ .unwrap()
+ .to_vec()
+ .into();
let mut update = build(revision, nonce, vec![new_key], vec![]);
update.set_signature(signer.sign(&key, signable_bytes.as_slice()).await.unwrap());
signed_updates.push(update);
@@ -1111,9 +1106,9 @@ mod tests {
.unwrap();
let bounds = ContractBounds::SingleContract { id: dashpay.id() };
let mut rng = SecpStdRng::seed_from_u64(292);
- let pairs: BTreeMap = [2u32, 3, 4]
+ let pairs: BTreeMap = [2u32, 3, 4]
.into_iter()
- .map(|id| (id, Keypair::new(&mut rng)))
+ .map(|id| (id, random_ecdsa_secret_key(&mut rng)))
.collect();
let bound_key = |id: u32| IdentityPublicKeyInCreationV0 {
id,
@@ -1121,7 +1116,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: pairs[&id].public_key().serialize().to_vec().into(),
+ data: pairs[&id].public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(bounds.clone()),
};
@@ -1228,7 +1223,7 @@ mod tests {
let mut adds = vec![bound_key(3), bound_key(2)];
let signable = unsigned(1, adds.clone(), vec![]).signable_bytes().unwrap();
for key in &mut adds {
- key.signature = signer::sign(&signable, &pairs[&key.id].secret_key().to_secret_bytes())
+ key.signature = signer::sign(&signable, pairs[&key.id].to_bytes().as_ref())
.unwrap()
.to_vec()
.into();
@@ -1243,7 +1238,7 @@ mod tests {
let mut adds = vec![bound_key(4)];
let signable = unsigned(2, adds.clone(), vec![3]).signable_bytes().unwrap();
for key in &mut adds {
- key.signature = signer::sign(&signable, &pairs[&key.id].secret_key().to_secret_bytes())
+ key.signature = signer::sign(&signable, pairs[&key.id].to_bytes().as_ref())
.unwrap()
.to_vec()
.into();
@@ -1677,7 +1672,7 @@ mod tests {
let mut rng = SecpStdRng::seed_from_u64(1292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -1685,7 +1680,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: KeyType::ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
};
@@ -1864,7 +1859,7 @@ mod tests {
let mut rng = SecpStdRng::seed_from_u64(1292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -1872,7 +1867,7 @@ mod tests {
security_level: SecurityLevel::MEDIUM,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(ContractBounds::SingleContract {
id: data_contract.id(),
@@ -1898,9 +1893,9 @@ mod tests {
.expect("expected signable bytes");
// Sign the new key with its own private key
- let secret = new_key_pair.secret_key();
+ let secret = &new_key_pair;
let signature =
- signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign");
+ signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign");
new_key.signature = signature.to_vec().into();
@@ -2148,10 +2143,10 @@ mod tests {
let mut rng = SecpStdRng::seed_from_u64(1292);
// Two encryption keys, the newer one listed first: both write the encryption
// current-key alias, and the one naming the highest key id must win.
- let pairs: Vec<(u32, Purpose, Keypair)> = vec![
- (4, Purpose::ENCRYPTION, Keypair::new(&mut rng)),
- (2, Purpose::ENCRYPTION, Keypair::new(&mut rng)),
- (3, Purpose::DECRYPTION, Keypair::new(&mut rng)),
+ let pairs: Vec<(u32, Purpose, EcdsaSecretKey)> = vec![
+ (4, Purpose::ENCRYPTION, random_ecdsa_secret_key(&mut rng)),
+ (2, Purpose::ENCRYPTION, random_ecdsa_secret_key(&mut rng)),
+ (3, Purpose::DECRYPTION, random_ecdsa_secret_key(&mut rng)),
];
let mut adds: Vec = pairs
.iter()
@@ -2161,7 +2156,7 @@ mod tests {
security_level: SecurityLevel::MEDIUM,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: pair.public_key().serialize().to_vec().into(),
+ data: pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(bounds.clone()),
})
@@ -2267,7 +2262,7 @@ mod tests {
.signable_bytes()
.expect("expected signable bytes");
for (key, (_, _, pair)) in adds.iter_mut().zip(&pairs) {
- key.signature = signer::sign(&signable, &pair.secret_key().to_secret_bytes())
+ key.signature = signer::sign(&signable, pair.to_bytes().as_ref())
.expect("expected to sign")
.to_vec()
.into();
@@ -2636,7 +2631,7 @@ mod tests {
let mut rng = SecpStdRng::seed_from_u64(1292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 2,
@@ -2644,7 +2639,7 @@ mod tests {
security_level: SecurityLevel::MEDIUM,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: Some(ContractBounds::SingleContractDocumentType {
id: data_contract.id(),
@@ -2671,9 +2666,9 @@ mod tests {
.expect("expected signable bytes");
// Sign the new key with its own private key
- let secret = new_key_pair.secret_key();
+ let secret = &new_key_pair;
let signature =
- signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign");
+ signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign");
new_key.signature = signature.to_vec().into();
@@ -3007,7 +3002,7 @@ mod tests {
let platform_state = platform.state.load();
let mut rng = SecpStdRng::seed_from_u64(292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
// Add a key with id 2 and also disable key id 2 in the same transition
let new_key = IdentityPublicKeyInCreationV0 {
@@ -3016,7 +3011,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
};
@@ -3236,7 +3231,7 @@ mod tests {
let platform_state = platform.state.load();
let mut rng = SecpStdRng::seed_from_u64(292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let signable_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 {
identity_id: identity.id(),
@@ -3249,7 +3244,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
},
@@ -3267,9 +3262,9 @@ mod tests {
.expect("expected signable bytes");
// Sign the new key
- let secret = new_key_pair.secret_key();
+ let secret = &new_key_pair;
let key_sig =
- signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign");
+ signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign");
let mut new_key = IdentityPublicKeyInCreationV0 {
id: 1, // existing key ID
@@ -3277,7 +3272,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
};
@@ -3371,14 +3366,14 @@ mod tests {
let platform_state = platform.state.load();
let mut rng = SecpStdRng::seed_from_u64(292);
- let new_key_pair = Keypair::new(&mut rng);
+ let new_key_pair = random_ecdsa_secret_key(&mut rng);
let mut new_key = IdentityPublicKeyInCreationV1 {
id: NEW_KEY_ID,
purpose: added_key.purpose,
security_level: added_key.security_level,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: new_key_pair.public_key().serialize().to_vec().into(),
+ data: new_key_pair.public_key().to_compressed().to_vec().into(),
contract_bounds: None,
total_budget: added_key.total_budget,
expires_at: added_key.expires_at,
@@ -3405,13 +3400,10 @@ mod tests {
let signable_bytes = transition_adding(new_key.clone())
.signable_bytes()
.expect("expected signable bytes");
- new_key.signature = signer::sign(
- &signable_bytes,
- &new_key_pair.secret_key().to_secret_bytes(),
- )
- .expect("expected to sign")
- .to_vec()
- .into();
+ new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref())
+ .expect("expected to sign")
+ .to_vec()
+ .into();
let mut update_transition = transition_adding(new_key);
update_transition.set_signature(
@@ -3920,12 +3912,15 @@ mod tests {
nonce: IdentityNonce,
) -> StateTransition {
let mut rng = SecpStdRng::seed_from_u64(292);
- let authentication_key_pair = Keypair::new(&mut rng);
+ let authentication_key_pair = random_ecdsa_secret_key(&mut rng);
let (authentication_key_type, authentication_key_data) = match fault {
Some(Fault::UndecodableBlsKeyData) => (KeyType::BLS12_381, vec![0xff; 48]),
_ => (
ECDSA_SECP256K1,
- authentication_key_pair.public_key().serialize().to_vec(),
+ authentication_key_pair
+ .public_key()
+ .to_compressed()
+ .to_vec(),
),
};
let update_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 {
@@ -3972,11 +3967,9 @@ mod tests {
else {
panic!("expected an identity update v0 transition");
};
- let proof_of_possession = signer::sign(
- &signable_bytes,
- &authentication_key_pair.secret_key().to_secret_bytes(),
- )
- .expect("expected to sign");
+ let proof_of_possession =
+ signer::sign(&signable_bytes, authentication_key_pair.to_bytes().as_ref())
+ .expect("expected to sign");
update_v0.add_public_keys[0].set_signature(proof_of_possession.to_vec().into());
match fault {
None => {}
@@ -4075,7 +4068,9 @@ mod tests {
/// keys, each with its proof of possession, signed by the owner's master key.
async fn update_adding_ecdsa_keys(owner: &Owner, key_count: usize) -> StateTransition {
let mut rng = SecpStdRng::seed_from_u64(517);
- let key_pairs: Vec = (0..key_count).map(|_| Keypair::new(&mut rng)).collect();
+ let key_pairs: Vec = (0..key_count)
+ .map(|_| random_ecdsa_secret_key(&mut rng))
+ .collect();
let update_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 {
identity_id: owner.identity.id(),
revision: 1,
@@ -4090,7 +4085,7 @@ mod tests {
security_level: SecurityLevel::HIGH,
key_type: ECDSA_SECP256K1,
read_only: false,
- data: key_pair.public_key().serialize().to_vec().into(),
+ data: key_pair.public_key().to_compressed().to_vec().into(),
signature: Default::default(),
contract_bounds: None,
}
@@ -4115,7 +4110,7 @@ mod tests {
};
for (key, key_pair) in update_v0.add_public_keys.iter_mut().zip(&key_pairs) {
let proof_of_possession =
- signer::sign(&signable_bytes, &key_pair.secret_key().to_secret_bytes())
+ signer::sign(&signable_bytes, key_pair.to_bytes().as_ref())
.expect("expected to sign");
key.set_signature(proof_of_possession.to_vec().into());
}
diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
index feec8ab2f6e..ac41847e2c2 100644
--- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
+++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs
@@ -16,12 +16,13 @@ use dpp::address_funds::{AddressWitness, OrchardAddress, PlatformAddress};
use dpp::block::block_info::BlockInfo;
use dpp::consensus::ConsensusError;
use dpp::dashcore::blockdata::script::ScriptBuf;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use dpp::dashcore::hashes::{sha256, Hash};
+use dpp::dashcore::key::rand::RngCore as EcdsaRngCore;
use dpp::dashcore::PublicKey;
use dpp::identity::signer::Signer;
use dpp::platform_value::BinaryData;
use dpp::prelude::AddressNonce;
-use dpp::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey};
use dpp::serialization::PlatformSerializable;
use dpp::shielded::builder::OrchardProver;
use dpp::shielded::SerializedAction;
@@ -61,14 +62,14 @@ pub use dpp::ProtocolError as TestProtocolError;
/// A P2PKH key entry containing the secret key only
#[derive(Debug, Clone)]
pub struct P2pkhKeyEntry {
- pub secret_key: RawSecretKey,
+ pub secret_key: EcdsaSecretKey,
}
/// A P2SH multisig entry containing multiple secret keys and the redeem script
#[derive(Debug, Clone)]
pub struct P2shMultisigEntry {
pub threshold: u8,
- pub secret_keys: Vec,
+ pub secret_keys: Vec,
pub redeem_script: Vec,
}
@@ -84,19 +85,19 @@ impl TestAddressSigner {
Self::default()
}
- pub fn create_keypair(seed: [u8; 32]) -> (RawSecretKey, PublicKey) {
+ pub fn create_keypair(seed: [u8; 32]) -> (EcdsaSecretKey, PublicKey) {
// Hash the seed to ensure it's always a valid secret key
// (non-zero, less than curve order). Raw seeds like [0u8; 32] are invalid.
let hashed_seed = sha256::Hash::hash(&seed);
- let secret_key = RawSecretKey::from_secret_bytes(*hashed_seed.as_byte_array())
- .expect("valid secret key");
- let raw_public_key = RawPublicKey::from_secret_key(&secret_key);
+ let secret_key =
+ EcdsaSecretKey::from_bytes(hashed_seed.as_byte_array()).expect("valid secret key");
+ let raw_public_key = secret_key.public_key();
let public_key = PublicKey::new(raw_public_key);
(secret_key, public_key)
}
- pub fn sign_data(data: &[u8], secret_key: &RawSecretKey) -> Vec {
- dpp::dashcore::signer::sign(data, secret_key.as_secret_bytes())
+ pub fn sign_data(data: &[u8], secret_key: &EcdsaSecretKey) -> Vec {
+ dpp::dashcore::signer::sign(data, secret_key.to_bytes().as_ref())
.expect("signing should succeed")
.to_vec()
}
@@ -124,7 +125,7 @@ impl TestAddressSigner {
pub fn add_p2sh_multisig(&mut self, threshold: u8, seeds: &[[u8; 32]]) -> PlatformAddress {
let keypairs: Vec<_> = seeds.iter().map(|s| Self::create_keypair(*s)).collect();
- let secret_keys: Vec<_> = keypairs.iter().map(|(sk, _)| *sk).collect();
+ let secret_keys: Vec<_> = keypairs.iter().map(|(sk, _)| sk.clone()).collect();
let public_keys: Vec<_> = keypairs.iter().map(|(_, pk)| *pk).collect();
let redeem_script = Self::create_multisig_script(threshold, &public_keys);
@@ -150,7 +151,7 @@ impl TestAddressSigner {
PlatformAddress::P2pkh(hash) => self
.p2pkh_keys
.get(hash)
- .map(|entry| entry.secret_key.to_secret_bytes()),
+ .map(|entry| *entry.secret_key.to_bytes()),
_ => None,
}
}
@@ -954,3 +955,14 @@ fn serialize_bundle_actions(
})
.collect()
}
+
+/// Draws the same seeded scalar as the historical secp256k1 keypair constructor.
+pub fn random_ecdsa_secret_key(rng: &mut impl EcdsaRngCore) -> EcdsaSecretKey {
+ loop {
+ let mut bytes = [0; 32];
+ rng.fill_bytes(&mut bytes);
+ if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) {
+ return key;
+ }
+ }
+}
diff --git a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
index 80bb161de21..93182900ae4 100644
--- a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
+++ b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs
@@ -27,9 +27,9 @@ use dpp::ProtocolError;
// Scope, SpendAuthorizingKey, SpendingKey,
// };
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey;
use dpp::data_contract::document_type::random_document::CreateRandomDocument;
use dpp::data_contract::{DataContract, DataContractFactory};
-use dpp::secp256k1::SecretKey;
use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
use strategy_tests::frequency::Frequency;
use strategy_tests::operations::FinalizeBlockOperation::IdentityAddKeys;
@@ -2202,9 +2202,9 @@ impl NetworkStrategy {
.random_public_and_private_key_data(rng, platform_version)
.unwrap();
let sk: [u8; 32] = pk.try_into().unwrap();
- let secret_key = SecretKey::from_str(hex::encode(sk).as_str()).unwrap();
+ let secret_key = SecretKey::from_bytes(&sk).unwrap();
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet)
.expect("valid test secret key"),
amount_range,
rng,
@@ -2247,7 +2247,7 @@ impl NetworkStrategy {
IdentityTopUpTransition::try_from_identity_with_private_key(
identity,
asset_lock_proof,
- secret_key.as_secret_bytes(),
+ secret_key.to_bytes().as_ref(),
0,
platform_version,
None,
@@ -2267,9 +2267,9 @@ impl NetworkStrategy {
.random_public_and_private_key_data(rng, platform_version)
.unwrap();
let sk_bytes: [u8; 32] = pk.try_into().unwrap();
- let secret_key = SecretKey::from_str(hex::encode(sk_bytes).as_str()).unwrap();
+ let secret_key = SecretKey::from_bytes(&sk_bytes).unwrap();
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet)
.expect("valid test secret key"),
amount_range,
rng,
@@ -2322,7 +2322,7 @@ impl NetworkStrategy {
(
asset_lock_proof,
- secret_key.to_secret_bytes().to_vec(),
+ secret_key.to_bytes().to_vec(),
funded_amount,
)
}
@@ -3176,10 +3176,9 @@ fn create_signed_instant_asset_lock_proofs_for_identities(
.unwrap();
let pk_fixed: [u8; 32] = pk.try_into().unwrap();
- let secret_key = SecretKey::from_str(hex::encode(pk_fixed).as_str()).unwrap();
- let private_key =
- PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
- .expect("valid test secret key");
+ let secret_key = SecretKey::from_bytes(&pk_fixed).unwrap();
+ let private_key = PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet)
+ .expect("valid test secret key");
let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
private_key,
diff --git a/packages/rs-platform-wallet/Cargo.toml b/packages/rs-platform-wallet/Cargo.toml
index 7da2bb5ce6c..8a7ee0b16a5 100644
--- a/packages/rs-platform-wallet/Cargo.toml
+++ b/packages/rs-platform-wallet/Cargo.toml
@@ -7,6 +7,8 @@ license = "MIT"
description = "Platform wallet with identity management support"
[dependencies]
+# platform-encryption exposes raw ECDH keys; Core has no typed ECDH API yet.
+secp256k1 = { workspace = true }
# Dash Platform packages
dpp = { path = "../rs-dpp" }
dash-sdk = { path = "../rs-sdk", default-features = false, features = ["dashpay-contract", "dpns-contract", "wallet"] }
diff --git a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
index 440e00a5d65..53bd2060982 100644
--- a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
+++ b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs
@@ -115,10 +115,10 @@ fn dapi_addresses() -> AddressList {
/// Whether `sk_bytes` is the private key for `key` (33-byte pubkey for
/// ECDSA_SECP256K1, hash160 for ECDSA_HASH160).
fn private_key_matches(key: &dpp::identity::IdentityPublicKey, sk_bytes: &[u8; 32]) -> bool {
- let Ok(sk) = dpp::secp256k1::SecretKey::from_secret_bytes(*sk_bytes) else {
+ let Ok(sk) = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(sk_bytes) else {
return false;
};
- let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&sk).serialize();
+ let pubkey = sk.public_key().to_compressed();
match key.key_type() {
KeyType::ECDSA_SECP256K1 => key.data().as_slice() == pubkey.as_slice(),
KeyType::ECDSA_HASH160 => {
diff --git a/packages/rs-platform-wallet/src/masternode/locator.rs b/packages/rs-platform-wallet/src/masternode/locator.rs
index 380664cf904..f18a6629ce7 100644
--- a/packages/rs-platform-wallet/src/masternode/locator.rs
+++ b/packages/rs-platform-wallet/src/masternode/locator.rs
@@ -38,13 +38,13 @@ use dash_sdk::platform::Fetch;
use dashcore::hashes::{hash160, Hash};
use dashcore::{Network, PrivateKey};
use dpp::bls::{PublicKey as BlsPublicKey, SecretKey as BlsSecretKey};
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecpSecretKey;
use dpp::ed25519_dalek::SigningKey;
use dpp::identifier::MasternodeIdentifiers;
use dpp::identity::accessors::IdentityGettersV0;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::{Identity, Purpose};
use dpp::prelude::Identifier;
-use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey as SecpSecretKey};
use zeroize::Zeroizing;
use super::list::{find_in_summaries, MasternodeListQuery, MasternodeListSummary};
@@ -224,7 +224,7 @@ fn is_mainnet(network: Network) -> bool {
/// only when below the group order; ed25519 accepts any 32 bytes as a seed.
fn secret_candidates(bytes: &[u8; 32]) -> Vec {
let mut out = Vec::with_capacity(3);
- if SecpSecretKey::from_secret_bytes(*bytes).is_ok() {
+ if SecpSecretKey::from_bytes(bytes).is_ok() {
out.push(MasternodeLocatorInput::Secret(LocatorSecret::Ecdsa {
secret: Zeroizing::new(*bytes),
compressed: true,
@@ -358,12 +358,12 @@ pub fn parse_locator_input(
/// hash160 of the secp256k1 public key for `secret`, or `None` when the
/// scalar is out of range.
pub fn ecdsa_key_id(secret: &[u8; 32], compressed: bool) -> Option<[u8; 20]> {
- let sk = SecpSecretKey::from_secret_bytes(*secret).ok()?;
- let pk = SecpPublicKey::from_secret_key(&sk);
+ let sk = SecpSecretKey::from_bytes(secret).ok()?;
+ let pk = sk.public_key();
let bytes: Vec = if compressed {
- pk.serialize().to_vec()
+ pk.to_compressed().to_vec()
} else {
- pk.serialize_uncompressed().to_vec()
+ pk.to_uncompressed().to_vec()
};
Some(hash160::Hash::hash(&bytes).to_byte_array())
}
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
index 959afd6ab7e..5232b4d8339 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs
@@ -24,9 +24,11 @@
//!
//! `m/9'/coin'/16'/timestamp'` (all segments hardened)
+use dashcore::crypto::ecdsa::{
+ EcdsaError, EcdsaPublicKey, EcdsaSecretKey as SecretKey, EcdsaSignature,
+};
use dashcore::hashes::{sha256, Hash, HashEngine};
use dpp::prelude::Identifier;
-use dpp::secp256k1::{ecdsa::Signature, Message, SecretKey};
use key_wallet::bip32::{ChildNumber, DerivationPath};
use key_wallet::dip9::{
DASH_COIN_TYPE, DASH_TESTNET_COIN_TYPE, FEATURE_PURPOSE, FEATURE_PURPOSE_DASHPAY_AUTO_ACCEPT,
@@ -117,7 +119,7 @@ pub fn derive_auto_accept_private_key(
let secret_bytes = ext_priv.private_key.to_bytes();
- SecretKey::from_secret_bytes(*secret_bytes).map_err(|e| {
+ SecretKey::from_bytes(&secret_bytes).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Invalid derived auto-accept private key: {}",
e
@@ -148,16 +150,17 @@ pub fn sign_auto_accept_proof(
timestamp: u32,
) -> Vec {
let msg_hash = build_message_hash(sender_id, recipient_id, account_reference);
- let message = Message::from_digest(msg_hash);
- let signature = secret_key.sign_ecdsa(message);
- let sig_bytes = signature.serialize_compact();
+ // Recoverable signing preserves RFC 6979 bytes without low-R grinding.
+ let signature = secret_key.sign_recoverable(&msg_hash);
+ let compact = signature.to_bytes();
+ let sig_bytes = &compact[1..];
let mut proof = Vec::with_capacity(1 + 4 + 1 + 64);
proof.push(KEY_TYPE_ECDSA);
proof.extend_from_slice(×tamp.to_be_bytes()); // 4 bytes BE
proof.push(ECDSA_SIG_SIZE);
- proof.extend_from_slice(&sig_bytes); // 64 bytes compact ECDSA
+ proof.extend_from_slice(sig_bytes); // 64 bytes compact ECDSA
proof
}
@@ -219,7 +222,7 @@ pub fn auto_accept_proof_expiry(proof_bytes: &[u8]) -> Option {
/// check clock-free makes it deterministically testable; the acceptance path
/// pairs the two.)
pub fn verify_auto_accept_proof_with_pubkey(
- pubkey: &dpp::secp256k1::PublicKey,
+ pubkey: &EcdsaPublicKey,
proof_bytes: &[u8],
sender_id: &Identifier,
recipient_id: &Identifier,
@@ -232,17 +235,18 @@ pub fn verify_auto_accept_proof_with_pubkey(
if sig_len != 64 || proof_bytes.len() < 6 + sig_len {
return false;
}
- let signature_bytes = &proof_bytes[6..6 + sig_len];
+ let Ok(signature_bytes) = <&[u8; 64]>::try_from(&proof_bytes[6..6 + sig_len]) else {
+ return false;
+ };
let msg_hash = build_message_hash(sender_id, recipient_id, account_reference);
- let message = Message::from_digest(msg_hash);
- let signature = match Signature::from_compact(signature_bytes) {
+ let signature = match EcdsaSignature::from_bytes(signature_bytes) {
Ok(s) => s,
Err(_) => return false,
};
- signature.verify(message, pubkey).is_ok()
+ pubkey.verify(&msg_hash, signature).is_ok()
}
/// Verify an auto-accept proof by re-deriving the expected key from `wallet`.
@@ -265,7 +269,7 @@ pub fn verify_auto_accept_proof(
return Ok(false);
};
let secret_key = derive_auto_accept_private_key(wallet, network, timestamp)?;
- let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&secret_key);
+ let pubkey = secret_key.public_key();
Ok(verify_auto_accept_proof_with_pubkey(
&pubkey,
proof_bytes,
@@ -294,7 +298,7 @@ pub fn encode_auto_accept_key_blob(secret_key: &SecretKey, expiry: u32) -> Vec Result<(SecretKey, u32), Plat
return Err(invalid("auto-accept key size must be 32"));
}
let secret_key = <[u8; 32]>::try_from(&blob[6..KEY_BLOB_LEN])
- .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey)
- .and_then(SecretKey::from_secret_bytes)
+ .map_err(|_| EcdsaError::InvalidSecretKey)
+ .and_then(|bytes| SecretKey::from_bytes(&bytes))
.map_err(|e| invalid(format!("invalid auto-accept private key: {e}")))?;
Ok((secret_key, expiry))
}
@@ -404,6 +408,29 @@ mod tests {
)
}
+ #[test]
+ fn should_preserve_historical_auto_accept_signature_bytes() {
+ let (sender, recipient) = test_ids();
+ for scalar in 1..=64u8 {
+ let bytes = [scalar; 32];
+ let key = SecretKey::from_bytes(&bytes).unwrap();
+ let legacy = secp256k1::SecretKey::from_secret_bytes(bytes).unwrap();
+ let hash = build_message_hash(&sender, &recipient, 42);
+ let expected = legacy
+ .sign_ecdsa(secp256k1::Message::from_digest(hash))
+ .serialize_compact();
+ let proof = sign_auto_accept_proof(&key, &sender, &recipient, 42, 100);
+ assert_eq!(&proof[6..], &expected);
+ assert!(verify_auto_accept_proof_with_pubkey(
+ &key.public_key(),
+ &proof,
+ &sender,
+ &recipient,
+ 42
+ ));
+ }
+ }
+
#[test]
fn test_generate_proof_format() {
let wallet = test_wallet();
@@ -573,7 +600,7 @@ mod tests {
assert_eq!(proof.len(), 70);
assert_eq!(auto_accept_proof_expiry(&proof), Some(expiry));
- let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&owner_key);
+ let pubkey = owner_key.public_key();
assert!(
verify_auto_accept_proof_with_pubkey(&pubkey, &proof, &scanner, &owner, account_ref),
"owner verifies the scanner's proof against its own re-derived pubkey"
@@ -595,14 +622,14 @@ mod tests {
#[test]
fn key_blob_round_trip_and_rejects_malformed() {
- let key = SecretKey::from_secret_bytes([0x07u8; 32]).unwrap();
+ let key = SecretKey::from_bytes(&[0x07u8; 32]).unwrap();
let blob = encode_auto_accept_key_blob(&key, 12345);
assert_eq!(blob.len(), 38);
assert_eq!(blob[0], 0x00); // key type
assert_eq!(blob[5], 0x20); // key size
let (k2, e2) = decode_auto_accept_key_blob(&blob).expect("decode");
- assert_eq!(k2.to_secret_bytes(), key.to_secret_bytes());
+ assert_eq!(k2.to_bytes(), key.to_bytes());
assert_eq!(e2, 12345);
assert!(decode_auto_accept_key_blob(&blob[..37]).is_err(), "short");
@@ -616,7 +643,7 @@ mod tests {
#[test]
fn uri_round_trip_and_rejects_malformed() {
- let key = SecretKey::from_secret_bytes([0x09u8; 32]).unwrap();
+ let key = SecretKey::from_bytes(&[0x09u8; 32]).unwrap();
let blob = encode_auto_accept_key_blob(&key, 999);
let uri = encode_dashpay_contact_uri("bobspizza", &blob);
assert!(uri.starts_with("dash:?du=bobspizza&dapk="));
@@ -664,7 +691,7 @@ mod tests {
);
// The cap must not reject a normal-length (valid) dapk.
- let key = SecretKey::from_secret_bytes([0x09u8; 32]).unwrap();
+ let key = SecretKey::from_bytes(&[0x09u8; 32]).unwrap();
let blob = encode_auto_accept_key_blob(&key, 1);
let uri = encode_dashpay_contact_uri("alice", &blob);
assert!(
@@ -675,8 +702,8 @@ mod tests {
#[test]
fn verify_with_pubkey_rejects_truncated_and_no_expiry() {
- let key = SecretKey::from_secret_bytes([0x05u8; 32]).unwrap();
- let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&key);
+ let key = SecretKey::from_bytes(&[0x05u8; 32]).unwrap();
+ let pubkey = key.public_key();
let (s, r) = test_ids();
assert!(!verify_auto_accept_proof_with_pubkey(
&pubkey, &[0u8; 3], &s, &r, 0
diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
index 8b46ce08955..820cec79a72 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs
@@ -364,7 +364,7 @@ pub(crate) fn validate_recipient_key(
/// drift from the discovery-time ownership decision.
///
/// `derived_pubkey` is the 33-byte compressed pubkey re-derived at a
-/// breadcrumb path (`ExtendedPubKey::from_priv(..).public_key.serialize()`).
+/// breadcrumb path (`ExtendedPubKey::from_priv(..).public_key.to_compressed()`).
/// `expected_key_data` is the on-chain key's `data`, discriminated by length:
///
/// - **33 bytes** → the on-chain key is an `ECDSA_SECP256K1` key whose `data`
@@ -851,11 +851,11 @@ mod tests {
/// Derive the compressed secp256k1 pubkey (`[u8; 33]`) for a fixed
/// in-range scalar — the shape a breadcrumb re-derivation produces.
fn fixed_scalar_and_compressed_pubkey() -> ([u8; 32], [u8; 33]) {
- use dpp::secp256k1::{PublicKey, SecretKey};
+ use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey;
let mut scalar = [0u8; 32];
scalar[31] = 7;
- let sk = SecretKey::from_secret_bytes(scalar).expect("in-range scalar");
- let pubkey = PublicKey::from_secret_key(&sk).serialize();
+ let sk = SecretKey::from_bytes(&scalar).expect("in-range scalar");
+ let pubkey = sk.public_key().to_compressed();
(scalar, pubkey)
}
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
index 1920acb8d68..011053dd660 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs
@@ -515,8 +515,8 @@ impl DashPayView<'_, B> {
S: Signer + Send + Sync,
C: super::ContactCryptoProvider + Sync,
{
+ use dpp::dashcore::key::rand::{rng, RngCore};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
- use dpp::secp256k1::rand::{rng, RngCore};
// Build the decrypted-payload struct once: it is both the local
// metadata applied to the contact AND (on publish) the plaintext the
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
index aaff5afd70d..c85d8cce931 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs
@@ -1,6 +1,7 @@
//! DashPay contact request lifecycle: send, sync, accept, reject.
use super::signing_key::AvailableSigningKey;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use dpp::document::DocumentV0Getters;
use dpp::identity::accessors::IdentityGettersV0;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
@@ -50,7 +51,7 @@ pub trait ContactCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dpp::secp256k1::PublicKey,
+ peer: &secp256k1::PublicKey,
) -> Result, PlatformWalletError>;
/// Export the raw **auto-accept private key** at `path` (DIP-15 QR
@@ -64,7 +65,7 @@ pub trait ContactCryptoProvider {
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result;
+ ) -> Result;
/// Export the raw **invitation-funding private key** at `path` (DIP-13
/// sub-feature `3'`) — the second deliberate raw-key export (alongside
@@ -85,7 +86,7 @@ pub trait ContactCryptoProvider {
async fn export_invitation_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
Err(PlatformWalletError::InvalidIdentityData(
"invitation private-key export is not supported by this crypto provider".to_string(),
))
@@ -201,14 +202,14 @@ impl ContactCryptoProvider for SeedCryptoProvider {
async fn ecdh_shared_secret(
&self,
path: &key_wallet::bip32::DerivationPath,
- peer: &dpp::secp256k1::PublicKey,
+ peer: &secp256k1::PublicKey,
) -> Result, PlatformWalletError> {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test ecdh derive: {e}"))
})?;
Ok(zeroize::Zeroizing::new(
platform_encryption::derive_shared_key_ecdh(
- &dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ &secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
.map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))?,
peer,
),
@@ -218,22 +219,22 @@ impl ContactCryptoProvider for SeedCryptoProvider {
async fn export_auto_accept_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test export auto-accept: {e}"))
})?;
- dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ EcdsaSecretKey::from_bytes(&xprv.private_key.to_bytes())
.map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))
}
async fn export_invitation_private_key(
&self,
path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!("test export invitation: {e}"))
})?;
- dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes())
+ EcdsaSecretKey::from_bytes(&xprv.private_key.to_bytes())
.map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))
}
@@ -369,7 +370,7 @@ pub enum AutoAcceptProofSource {
/// QR (`dapk`), binding it to the accountReference this send computes.
SignWithKey {
/// The auto-accept private key handed out in the QR.
- secret_key: dpp::secp256k1::SecretKey,
+ secret_key: EcdsaSecretKey,
/// The proof's expiry (the key blob's timestamp / derivation index).
expiry: u32,
},
@@ -650,7 +651,7 @@ impl DashPayView<'_, B> {
"Recipient identity has no key at index {recipient_key_index}"
))
})?;
- dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
+ secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Recipient encryption public key is invalid: {e}"
))
@@ -2465,25 +2466,23 @@ impl DashPayView<'_, B> {
.public_keys()
.get(contact_encryption_key_index)
{
- Some(k) => {
- match dpp::secp256k1::PublicKey::from_slice(k.data().as_slice()) {
- Ok(pk) => pk,
- Err(e) => {
- tracing::warn!(
- owner = %entry.owner_identity_id, contact = %entry.contact_id,
- error = %e,
- "drain: contact encryption key invalid; marking channel broken"
- );
- self.mark_contact_channel_broken(
- &entry.owner_identity_id,
- &entry.contact_id,
- )
- .await;
- cleared.push(entry.key());
- continue;
- }
+ Some(k) => match secp256k1::PublicKey::from_slice(k.data().as_slice()) {
+ Ok(pk) => pk,
+ Err(e) => {
+ tracing::warn!(
+ owner = %entry.owner_identity_id, contact = %entry.contact_id,
+ error = %e,
+ "drain: contact encryption key invalid; marking channel broken"
+ );
+ self.mark_contact_channel_broken(
+ &entry.owner_identity_id,
+ &entry.contact_id,
+ )
+ .await;
+ cleared.push(entry.key());
+ continue;
}
- }
+ },
None => {
// Left queued, not broken: the contact's identity
// can gain this key later, exactly as ours can, and
@@ -3011,7 +3010,7 @@ impl DashPayView<'_, B> {
}
};
let valid = verify_auto_accept_proof_with_pubkey(
- &pubkey.into(),
+ &pubkey,
proof,
&request.sender_id,
&owner,
@@ -3680,7 +3679,7 @@ impl DashPayView<'_, B> {
"Contact identity has no key at index {contact_encryption_key_index}"
))
})?;
- dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
+ secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| {
PlatformWalletError::InvalidIdentityData(format!(
"Contact encryption public key is invalid: {e}"
))
@@ -5604,7 +5603,7 @@ mod contact_info_provider_tests {
/// the resident `derive_shared_key_ecdh` at the same path.
#[tokio::test]
async fn ecdh_shared_secret_returns_zeroizing_matching_resident_derivation() {
- use dpp::secp256k1::{PublicKey, SecretKey};
+ use secp256k1::{PublicKey, SecretKey};
let seed = Mnemonic::from_phrase(PHRASE)
.expect("valid mnemonic")
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
index ff30931ed2c..fd5d367f61b 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs
@@ -744,7 +744,7 @@ mod tests {
/// the returned scalar.
#[test]
fn connect_keypairs_match_the_pinned_vectors() {
- use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey};
+ use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey;
for (network, key, expected) in [
(
@@ -764,11 +764,8 @@ mod tests {
assert_eq!(derived.derivation_path, key.derivation_path(network));
let secret: [u8; 32] = *derived.private_key;
- let sk = SecretKey::from_secret_bytes(secret).expect("valid scalar");
- assert_eq!(
- SecpPublicKey::from_secret_key(&sk).serialize(),
- derived.public_key
- );
+ let sk = SecretKey::from_bytes(&secret).expect("valid scalar");
+ assert_eq!(sk.public_key().to_compressed(), derived.public_key);
}
}
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
index 2e475a55f86..b00db6a513a 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs
@@ -14,6 +14,7 @@
//! ([`send_contact_request_with_external_signer`](IdentityWallet::send_contact_request_with_external_signer)).
use std::collections::BTreeMap;
+use zeroize::Zeroize;
use dpp::identity::accessors::IdentityGettersV0;
use dpp::identity::signer::Signer;
@@ -259,7 +260,7 @@ impl IdentityWallet {
let mut voucher_key = crypto_provider.export_invitation_private_key(&path).await?;
// Build the (secret) URI, then scrub the exported scalar on BOTH the
- // success and the encode-error path. `secp256k1::SecretKey` has no
+ // success and the encode-error path. `EcdsaSecretKey` has no
// Drop-zeroize, so wipe it explicitly; scrubbing before propagating an
// encode failure matters most there — on that path the key never
// legitimately left the device, so a lingering copy is the worst kind.
@@ -267,7 +268,7 @@ impl IdentityWallet {
// the embedded proof; the invitee refetches the tx at claim.
let network = self.sdk.network;
let uri_result = encode_invitation_uri(&voucher_key, network, &proof, inviter.as_ref());
- voucher_key.non_secure_erase();
+ voucher_key.zeroize();
let uri = uri_result?;
Ok(Invitation {
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
index e8bfa8ec253..77d2ca9d216 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs
@@ -2005,6 +2005,7 @@ mod tests {
//! 3. Reconcile must be idempotent and never clobber an existing
//! entry for the same txid.
+ use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
use std::collections::BTreeMap;
use std::sync::{Arc, Mutex};
@@ -2502,11 +2503,11 @@ mod tests {
) -> Identity {
use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
use dpp::identity::{IdentityPublicKey, SecurityLevel};
- let data = dpp::secp256k1::PublicKey::from_secret_key(
- &dpp::secp256k1::SecretKey::from_secret_bytes([0x37u8; 32]).expect("secret"),
- )
- .serialize()
- .to_vec();
+ let data = EcdsaSecretKey::from_bytes(&[0x37u8; 32])
+ .expect("secret")
+ .public_key()
+ .to_compressed()
+ .to_vec();
Identity::V0(IdentityV0 {
id: Identifier::from(id_bytes),
public_keys: [(
@@ -10128,12 +10129,12 @@ mod tests {
contract_bounds: None,
key_type: KeyType::ECDSA_SECP256K1,
read_only: false,
- data: dpp::secp256k1::PublicKey::from_secret_key(
- &dpp::secp256k1::SecretKey::from_secret_bytes([0x24u8; 32]).expect("secret"),
- )
- .serialize()
- .to_vec()
- .into(),
+ data: EcdsaSecretKey::from_bytes(&[0x24u8; 32])
+ .expect("secret")
+ .public_key()
+ .to_compressed()
+ .to_vec()
+ .into(),
disabled_at: None,
});
let our_identity = Identity::V0(IdentityV0 {
@@ -10397,9 +10398,9 @@ mod tests {
let provider = SeedCryptoProvider::from_seed(seed, Network::Testnet);
// The contact's encryption keypair (the "sender" of the request).
- let contact_secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x42u8; 32])
- .expect("valid contact secret");
- let contact_public = dpp::secp256k1::PublicKey::from_secret_key(&contact_secret);
+ let contact_secret =
+ secp256k1::SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid contact secret");
+ let contact_public = secp256k1::PublicKey::from_secret_key(&contact_secret);
// Our side, through the production provider.
let ours = provider
@@ -10492,12 +10493,12 @@ mod tests {
contract_bounds: None,
key_type: KeyType::ECDSA_SECP256K1,
read_only: false,
- data: dpp::secp256k1::PublicKey::from_secret_key(
- &dpp::secp256k1::SecretKey::from_secret_bytes([byte; 32]).expect("secret"),
- )
- .serialize()
- .to_vec()
- .into(),
+ data: EcdsaSecretKey::from_bytes(&[byte; 32])
+ .expect("secret")
+ .public_key()
+ .to_compressed()
+ .to_vec()
+ .into(),
disabled_at: None,
})
};
@@ -10669,7 +10670,7 @@ mod tests {
async fn ecdh_shared_secret(
&self,
_path: &key_wallet::bip32::DerivationPath,
- _peer: &dpp::secp256k1::PublicKey,
+ _peer: &secp256k1::PublicKey,
) -> Result, crate::error::PlatformWalletError>
{
Ok(zeroize::Zeroizing::new([0u8; 32]))
@@ -10677,13 +10678,13 @@ mod tests {
async fn export_auto_accept_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
unimplemented!("auto-accept QR is a send-path method, not exercised by the drain")
}
async fn export_invitation_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
unimplemented!(
"invitation create is a send-path method, not exercised by the drain"
)
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
index 4d9afca936d..2999d05fdde 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs
@@ -115,7 +115,7 @@ pub(crate) struct SendContactRequestParams<'a> {
/// secret — the client-side equivalent of the old SdkSide key-id
/// guard, so a recipient-key mismatch fails loudly instead of
/// silently encrypting with the wrong secret.
- pub expected_recipient_pubkey: dpp::secp256k1::PublicKey,
+ pub expected_recipient_pubkey: secp256k1::PublicKey,
/// DashPay receiving-account xpub to share with the recipient, in the
/// **69-byte DIP-15 compact form** (`parentFingerprint ‖ chainCode ‖
/// pubKey`) — NOT `ExtendedPubKey::encode()`. The SDK validates len == 69
@@ -219,14 +219,13 @@ impl SdkWriter {
// `F`/`Fut` (SdkSide) type params are unused here, so a never-called
// `fn` placeholder satisfies their bounds.
// Aliased so the annotation stays under the type-complexity lint.
- type UnusedSdkSideEcdh = fn(
- &IdentityPublicKey,
- u32,
- ) -> std::future::Ready<
- Result,
- >;
+ type UnusedSdkSideEcdh =
+ fn(
+ &IdentityPublicKey,
+ u32,
+ ) -> std::future::Ready>;
let ecdh_provider: EcdhProvider = EcdhProvider::ClientSide {
- get_shared_secret: move |peer: &dpp::secp256k1::PublicKey| {
+ get_shared_secret: move |peer: &secp256k1::PublicKey| {
let peer_matches = *peer == expected_recipient_pubkey;
async move {
if !peer_matches {
diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
index 212b901a022..4d77159bca0 100644
--- a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
+++ b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs
@@ -609,6 +609,7 @@ impl PlatformWallet {
#[cfg(test)]
mod tests {
use super::SeedBindingVerification;
+ use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
@@ -1753,7 +1754,7 @@ mod tests {
async fn ecdh_shared_secret(
&self,
_path: &key_wallet::bip32::DerivationPath,
- _peer: &dpp::secp256k1::PublicKey,
+ _peer: &secp256k1::PublicKey,
) -> Result, PlatformWalletError> {
unreachable!("the gate refuses, so no queue entry is ever derived")
}
@@ -1761,7 +1762,7 @@ mod tests {
async fn export_auto_accept_private_key(
&self,
_path: &key_wallet::bip32::DerivationPath,
- ) -> Result {
+ ) -> Result {
unreachable!("the gate refuses, so no queue entry is ever derived")
}
diff --git a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
index 26d64b47140..9ccd84eb50f 100644
--- a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
+++ b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs
@@ -44,8 +44,8 @@ fn drain_lock_fixture() -> (TrackedAssetLock, BTreeMap)
let keys = OrchardKeySet::from_seed(&[0x42; 32], Network::Testnet, 0)
.unwrap()
.viewing_keys();
- let secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x11; 32]).unwrap();
- let public = dashcore::PublicKey::new(dpp::secp256k1::PublicKey::from_secret_key(&secret));
+ let secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[0x11; 32]).unwrap();
+ let public = dashcore::PublicKey::new(secret.public_key());
let transaction = Transaction {
version: 3,
lock_time: 0,
diff --git a/packages/rs-scripts/src/bin/register_identity.rs b/packages/rs-scripts/src/bin/register_identity.rs
index 7c852c28155..9c67a3a6e73 100644
--- a/packages/rs-scripts/src/bin/register_identity.rs
+++ b/packages/rs-scripts/src/bin/register_identity.rs
@@ -514,10 +514,9 @@ async fn run() -> Result<(), String> {
} else {
// FRESH: generate a one-time key, build + Core-sign + broadcast the
// asset lock, capturing all recovery credentials BEFORE broadcast.
- let mut secp_rng = dpp::secp256k1::rand::rng();
- let one_time_secret = dpp::secp256k1::SecretKey::new(&mut secp_rng);
+ let one_time_secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::generate();
let one_time_private_key =
- PrivateKey::from_byte_array(one_time_secret.as_secret_bytes(), network)
+ PrivateKey::from_byte_array(&one_time_secret.to_bytes(), network)
.map_err(|e| format!("failed to construct asset-lock private key: {e}"))?;
let one_time_public_key = one_time_private_key.public_key();
let one_time_key_hash = one_time_public_key.pubkey_hash();
diff --git a/packages/rs-sdk/Cargo.toml b/packages/rs-sdk/Cargo.toml
index 8ed5f0992dd..39e8764c84c 100644
--- a/packages/rs-sdk/Cargo.toml
+++ b/packages/rs-sdk/Cargo.toml
@@ -4,6 +4,8 @@ version.workspace = true
edition = "2021"
[dependencies]
+# platform-encryption exposes raw ECDH keys; Core has no typed ECDH API yet.
+secp256k1 = { workspace = true }
arc-swap = { version = "1.7.1" }
chrono = { version = "0.4.38" }
diff --git a/packages/rs-sdk/src/platform/dashpay/contact_request.rs b/packages/rs-sdk/src/platform/dashpay/contact_request.rs
index 3f528a4bba6..ab7f340b5fe 100644
--- a/packages/rs-sdk/src/platform/dashpay/contact_request.rs
+++ b/packages/rs-sdk/src/platform/dashpay/contact_request.rs
@@ -5,6 +5,8 @@
use crate::platform::transition::put_document::PutDocument;
use crate::platform::Document;
use crate::{Error, Sdk};
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{Rng, RngCore, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
use dpp::document::DocumentV0;
@@ -15,12 +17,10 @@ use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey};
use dpp::platform_value::{Bytes32, Value};
use dpp::prelude::Identifier;
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{Rng, RngCore, SeedableRng};
-use dpp::secp256k1::{PublicKey, SecretKey};
use platform_encryption::{
derive_shared_key_ecdh, encrypt_account_label, encrypt_extended_public_key, COMPACT_XPUB_LEN,
};
+use secp256k1::{PublicKey, SecretKey};
use std::collections::BTreeMap;
/// ECDH provider for contact request encryption
@@ -575,8 +575,7 @@ impl Sdk {
#[cfg(test)]
mod tests {
use super::*;
- use dpp::secp256k1;
- use dpp::secp256k1::rand::{self, RngCore};
+ use dpp::dashcore::key::rand::{self, RngCore};
#[test]
fn test_ecdh_encryption_produces_correct_size() {
diff --git a/packages/rs-sdk/src/platform/dashpay/invitation.rs b/packages/rs-sdk/src/platform/dashpay/invitation.rs
index 23f29a33744..1ac9bc91769 100644
--- a/packages/rs-sdk/src/platform/dashpay/invitation.rs
+++ b/packages/rs-sdk/src/platform/dashpay/invitation.rs
@@ -67,8 +67,10 @@
//! emit it.
use std::collections::BTreeMap;
+use zeroize::Zeroize;
use dpp::dashcore::consensus::Decodable;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey;
use dpp::dashcore::transaction::special_transaction::TransactionPayload;
use dpp::dashcore::{InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxOut};
use dpp::identity::accessors::IdentityGettersV0;
@@ -81,7 +83,6 @@ use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
use dpp::identity::v0::IdentityV0;
use dpp::identity::{Identity, IdentityPublicKey, KeyID, Purpose, SecurityLevel};
use dpp::prelude::{AssetLockProof, Identifier};
-use dpp::secp256k1::{PublicKey, SecretKey};
use crate::core::FetchedCoreTransaction;
use crate::platform::transition::asset_lock_submission::{
@@ -252,7 +253,7 @@ impl Drop for ParsedInvitation {
/// Scrub the voucher scalar on drop — it is literal bearer money. Mirrors
/// the resolver signer's key hygiene (`WipingSecretKey`).
fn drop(&mut self) {
- self.voucher_key.non_secure_erase();
+ self.voucher_key.zeroize();
}
}
@@ -276,7 +277,7 @@ fn invalid(msg: impl Into) -> InvitationError {
/// The P2PKH script the voucher key controls (compressed-pubkey hash160). This
/// is the selector that binds the voucher key to its funded credit output.
fn voucher_credit_script(voucher_key: &SecretKey) -> ScriptBuf {
- let pubkey = PublicKey::from_secret_key(voucher_key);
+ let pubkey = voucher_key.public_key();
let hash = dpp::dashcore::PublicKey::new(pubkey).pubkey_hash();
ScriptBuf::new_p2pkh(&hash)
}
@@ -423,7 +424,7 @@ pub fn encode_invitation_uri(
};
// WIF, compressed (the default for `PrivateKey::new`), network-correct.
- let private_key = PrivateKey::from_byte_array(&voucher_key.to_secret_bytes(), network)
+ let private_key = PrivateKey::from_byte_array(&voucher_key.to_bytes(), network)
.map_err(|e| invalid(format!("invalid invitation voucher key: {e}")))?;
let mut wif = String::with_capacity(52);
let wif_result = private_key.fmt_wif(&mut wif);
@@ -561,7 +562,7 @@ pub fn parse_invitation_uri(uri: &str) -> Result SecretKey {
- SecretKey::from_secret_bytes([0x11u8; 32]).expect("valid scalar")
+ SecretKey::from_bytes(&[0x11u8; 32]).expect("valid scalar")
}
fn inviter_info() -> InviterInfo {
@@ -1330,7 +1331,7 @@ mod tests {
/// Build an asset-lock tx whose credit output at `index` pays the voucher
/// key (and `index` decoy outputs before it that do not).
fn asset_lock_tx_paying_voucher_at(key: &SecretKey, index: usize) -> Transaction {
- let decoy = SecretKey::from_secret_bytes([0x22u8; 32]).unwrap();
+ let decoy = SecretKey::from_bytes(&[0x22u8; 32]).unwrap();
let mut credit_outputs = Vec::new();
for _ in 0..index {
credit_outputs.push(TxOut {
@@ -1364,13 +1365,13 @@ mod tests {
#[test]
fn should_round_trip_a_wif_keeping_compression_and_network() {
for (network, first_byte) in [(Network::Mainnet, 204u8), (Network::Testnet, 239u8)] {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), network)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), network)
.expect("valid voucher")
.to_wif();
let decoded = PrivateKey::from_wif(&wif).expect("wif decodes");
assert!(decoded.compressed, "voucher WIF must be compressed");
assert_eq!(decoded.network, network, "network preserved");
- assert_eq!(*decoded.inner.to_bytes(), voucher().to_secret_bytes());
+ assert_eq!(decoded.inner.to_bytes(), voucher().to_bytes());
// Network byte matches bitcoinj/legacy (0xCC mainnet, 0xEF testnet).
let raw = dpp::dashcore::base58::decode(&wif).unwrap();
assert_eq!(raw[0], first_byte);
@@ -1386,10 +1387,7 @@ mod tests {
assert!(uri.starts_with("dashpay://invite?"));
let parsed = parse_invitation_uri(&uri).expect("parse");
- assert_eq!(
- parsed.voucher_key.to_secret_bytes(),
- voucher().to_secret_bytes()
- );
+ assert_eq!(parsed.voucher_key.to_bytes(), voucher().to_bytes());
assert_eq!(parsed.inviter, Some(info));
assert!(parsed.islock_hex.is_some());
// The parsed txid matches the proof's transaction id (big-endian).
@@ -1414,7 +1412,7 @@ mod tests {
/// byte-level, interop — the two legacy wallets differ in order).
#[test]
fn should_parse_a_link_regardless_of_field_order() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri = format!("dashpay://invite?islock=deadbeef&pk={wif}&du=bob&assetlocktx=aabbcc");
@@ -1431,7 +1429,7 @@ mod tests {
/// first-class alternative to the custom scheme (iOS emits it).
#[test]
fn should_parse_a_link_on_the_applink_host() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri = format!(
@@ -1449,7 +1447,7 @@ mod tests {
/// accepted over cleartext `http`. Neither mobile wallet emits an `http` link.
#[test]
fn should_reject_an_applink_over_plain_http() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri =
@@ -1465,7 +1463,7 @@ mod tests {
/// (a ChainLock-confirmed invite Android's own validator accepts).
#[test]
fn should_parse_an_islock_that_is_present_absent_or_null() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let present = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=00aa11");
@@ -1490,7 +1488,7 @@ mod tests {
/// A `du`-less link still parses (iOS accepts du-less links).
#[test]
fn should_parse_a_link_without_a_du_field() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=bb");
@@ -1500,7 +1498,7 @@ mod tests {
#[test]
fn should_reject_a_link_missing_pk_or_assetlocktx() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
// No pk.
@@ -1519,9 +1517,8 @@ mod tests {
#[test]
fn should_reject_an_uncompressed_wif() {
- let mut private_key =
- PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
- .expect("valid voucher");
+ let mut private_key = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
+ .expect("valid voucher");
private_key.compressed = false;
let uncompressed = private_key.to_wif();
let uri = format!("dashpay://invite?assetlocktx=aa&pk={uncompressed}");
@@ -1546,7 +1543,7 @@ mod tests {
/// display-name + avatar-url) parses to the right fields.
#[test]
fn should_parse_an_android_style_link() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Mainnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Mainnet)
.expect("valid voucher")
.to_wif();
// Android order: du, assetlocktx, pk, islock, display-name, avatar-url.
@@ -1594,7 +1591,7 @@ mod tests {
#[test]
fn should_reject_a_funding_tx_with_no_output_paying_the_voucher() {
let key = voucher();
- let other = SecretKey::from_secret_bytes([0x33u8; 32]).unwrap();
+ let other = SecretKey::from_bytes(&[0x33u8; 32]).unwrap();
let tx = asset_lock_tx_paying_voucher_at(&other, 0);
let err = voucher_output_index(&tx, &key).unwrap_err();
assert!(err.to_string().contains("does not control"));
@@ -1617,7 +1614,7 @@ mod tests {
/// surface them (the reference wallets emit those independently of `du`).
#[test]
fn should_keep_inviter_metadata_when_the_du_field_is_missing() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let uri = format!(
@@ -1634,7 +1631,7 @@ mod tests {
/// first) — reject rather than claim a wallet-dependent key.
#[test]
fn should_reject_a_link_with_duplicate_required_keys() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
let other = PrivateKey::from_byte_array(&[0x44u8; 32], Network::Testnet)
@@ -1659,7 +1656,7 @@ mod tests {
/// (with a `pk`/`assetlocktx`) would be parsed.
#[test]
fn should_reject_a_link_with_a_decoy_scheme_or_host() {
- let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet)
+ let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet)
.expect("valid voucher")
.to_wif();
// Suffixed authority — not exactly `invite`.
@@ -1810,7 +1807,7 @@ mod tests {
#[test]
fn should_derive_the_prospective_id_from_the_selected_credit_output() {
let key = voucher();
- let decoy = SecretKey::from_secret_bytes([0x22u8; 32]).unwrap();
+ let decoy = SecretKey::from_bytes(&[0x22u8; 32]).unwrap();
let payload = AssetLockPayload {
version: 1,
credit_outputs: vec![
diff --git a/packages/rs-sdk/src/platform/dashpay/profile.rs b/packages/rs-sdk/src/platform/dashpay/profile.rs
index 8417dce46c4..3585ac4fff4 100644
--- a/packages/rs-sdk/src/platform/dashpay/profile.rs
+++ b/packages/rs-sdk/src/platform/dashpay/profile.rs
@@ -11,6 +11,8 @@ use crate::platform::documents::transitions::{
};
use crate::platform::FetchMany;
use crate::{Error, Sdk};
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{Rng, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dpp::data_contract::DataContract;
@@ -19,8 +21,6 @@ use dpp::identity::signer::Signer;
use dpp::identity::IdentityPublicKey;
use dpp::platform_value::{platform_value, Value};
use dpp::prelude::Identifier;
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{Rng, SeedableRng};
use drive::query::{OrderClause, WhereClause, WhereOperator};
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
diff --git a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
index fd79e49c7c2..8181ae8b05b 100644
--- a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
+++ b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs
@@ -11,6 +11,8 @@ use crate::platform::transition::put_document::PutDocument;
use crate::platform::transition::put_settings::PutSettings;
use crate::platform::{Document, FetchMany};
use crate::{Error, Sdk};
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{Rng, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::document::{DocumentV0, DocumentV0Getters};
use dpp::fee::Credits;
@@ -19,8 +21,6 @@ use dpp::identity::signer::Signer;
use dpp::identity::{Identity, IdentityPublicKey};
use dpp::platform_value::Value;
use dpp::prelude::Identifier;
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{Rng, SeedableRng};
use dpp::state_transition::batch_transition::methods::StateTransitionCreationOptions;
use std::collections::BTreeMap;
use std::sync::Arc;
diff --git a/packages/rs-sdk/src/platform/encrypted_for.rs b/packages/rs-sdk/src/platform/encrypted_for.rs
index c7c37818512..74118019e3b 100644
--- a/packages/rs-sdk/src/platform/encrypted_for.rs
+++ b/packages/rs-sdk/src/platform/encrypted_for.rs
@@ -26,6 +26,8 @@
//! which a wrong key passes about once in 256 attempts and then returns garbage; a caller that
//! must tell the two apart has to recognise its plaintext.
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{RngCore, SeedableRng};
use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
use dpp::data_contract::document_type::{
DocumentPropertyReferenceTarget, DocumentPropertyType, DocumentTypeRef, EncryptedFor,
@@ -40,10 +42,8 @@ use dpp::platform_value::btreemap_extensions::{
BTreeValueMapInsertionPathHelper, BTreeValueMapPathHelper,
};
use dpp::platform_value::{Identifier, Value};
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{RngCore, SeedableRng};
-use dpp::secp256k1::{PublicKey, SecretKey};
use platform_encryption::{decrypt_aes_256_cbc, derive_shared_key_ecdh, encrypt_aes_256_cbc};
+use secp256k1::{PublicKey, SecretKey};
use std::collections::BTreeMap;
use std::fmt;
diff --git a/packages/rs-sdk/src/platform/moderation_charters/requests.rs b/packages/rs-sdk/src/platform/moderation_charters/requests.rs
index bdb5087de94..a7196c7d90a 100644
--- a/packages/rs-sdk/src/platform/moderation_charters/requests.rs
+++ b/packages/rs-sdk/src/platform/moderation_charters/requests.rs
@@ -3,6 +3,8 @@
use crate::platform::encrypted_for::encrypt_property_for;
use crate::platform::{DataContract, Document, Fetch, Identity};
use crate::{Error, Sdk};
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{Rng, SeedableRng};
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::data_contract::document_type::methods::DocumentTypeBasicMethods;
use dpp::document::{DocumentV0, DocumentV0Getters, INITIAL_REVISION};
@@ -12,9 +14,7 @@ use dpp::moderation_charter::{
RESIGNATION_REQUEST_DOCUMENT_TYPE_NAME, SUBMITTED_CHARTER_DOCUMENT_TYPE_NAME,
};
use dpp::platform_value::{Bytes32, Identifier, Value};
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{Rng, SeedableRng};
-use dpp::secp256k1::SecretKey;
+use secp256k1::SecretKey;
use std::collections::BTreeMap;
/// The property of both request types that carries the message, declared `encryptedFor` the
@@ -255,9 +255,9 @@ mod tests {
use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
use dpp::moderation_charter::MODERATION_CHARTERS_CONTRACT_ID;
use dpp::platform_value::BinaryData;
- use dpp::secp256k1::PublicKey;
use dpp::system_data_contracts::{load_system_data_contract, SystemDataContract};
use dpp::version::PlatformVersion;
+ use secp256k1::PublicKey;
fn key_pair(scalar: u8) -> (SecretKey, PublicKey) {
let secret_key = SecretKey::from_secret_bytes([scalar; 32]).expect("a valid scalar");
diff --git a/packages/rs-sdk/src/platform/transition/put_document.rs b/packages/rs-sdk/src/platform/transition/put_document.rs
index bc9319bc357..06cd8622274 100644
--- a/packages/rs-sdk/src/platform/transition/put_document.rs
+++ b/packages/rs-sdk/src/platform/transition/put_document.rs
@@ -4,6 +4,8 @@ use super::waitable::{wait_for_document_and_owner_balance, Waitable};
use crate::platform::documents::contest_fund::with_contest_fund_to_join;
use crate::platform::transition::put_settings::PutSettings;
use crate::{Error, Sdk};
+use dpp::dashcore::key::rand::rngs::StdRng;
+use dpp::dashcore::key::rand::{Rng, SeedableRng};
use dpp::data_contract::document_type::accessors::{DocumentTypeV0Getters, DocumentTypeV2Getters};
use dpp::data_contract::document_type::methods::DocumentTypeV0Methods;
use dpp::data_contract::document_type::DocumentType;
@@ -12,8 +14,6 @@ use dpp::fee::Credits;
use dpp::identity::signer::Signer;
use dpp::identity::IdentityPublicKey;
use dpp::prelude::Identifier;
-use dpp::secp256k1::rand::rngs::StdRng;
-use dpp::secp256k1::rand::{Rng, SeedableRng};
use dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
use dpp::state_transition::batch_transition::BatchTransition;
use dpp::state_transition::StateTransition;
diff --git a/packages/simple-signer/Cargo.toml b/packages/simple-signer/Cargo.toml
index d09a1910d2a..0eeebca6cfe 100644
--- a/packages/simple-signer/Cargo.toml
+++ b/packages/simple-signer/Cargo.toml
@@ -24,10 +24,14 @@ bincode = { workspace = true, features = ["serde"] }
base64 = { version = "0.22.1" }
hex = { version = "0.4.3" }
# rand 0.8 `RngCore`, the RNG type strategy-tests/drive-abci pass in; the
-# secp256k1 re-export is rand 0.9.
+# Core key RNG re-export is rand 0.9.
rand = { version = "0.8", default-features = false }
tracing = "0.1.41"
zeroize = "1"
[package.metadata.cargo-machete]
ignored = ["bincode"]
+
+[dev-dependencies]
+secp256k1 = { workspace = true }
+rand = { version = "0.8", features = ["std_rng"] }
diff --git a/packages/simple-signer/src/signer.rs b/packages/simple-signer/src/signer.rs
index 3a10d345941..f25f0a46d46 100644
--- a/packages/simple-signer/src/signer.rs
+++ b/packages/simple-signer/src/signer.rs
@@ -5,14 +5,14 @@ use dpp::address_funds::{AddressWitness, PlatformAddress};
use dpp::bincode::{Decode, Encode};
use dpp::bls;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey;
+use dpp::dashcore::key::rand::{RngCore as EcdsaRngCore, SeedableRng};
use dpp::dashcore::signer;
use dpp::ed25519_dalek::Signer as BlsSigner;
use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
use dpp::identity::signer::Signer;
use dpp::identity::{IdentityPublicKey, KeyType};
use dpp::platform_value::BinaryData;
-use dpp::secp256k1::rand::SeedableRng;
-use dpp::secp256k1::{PublicKey, SecretKey};
use dpp::state_transition::errors::InvalidIdentityPublicKeyTypeError;
use dpp::util::hash::ripemd160_sha256;
use dpp::{ed25519_dalek, ProtocolError};
@@ -100,19 +100,25 @@ impl SimpleSigner {
// Generate a valid secp256k1 secret key from random bytes
let mut seed = [0u8; 32];
rng.fill_bytes(&mut seed);
- let mut ecdsa_rng = dpp::secp256k1::rand::rngs::StdRng::from_seed(seed);
- let secret_key = SecretKey::new(&mut ecdsa_rng);
+ let mut ecdsa_rng = dpp::dashcore::key::rand::rngs::StdRng::from_seed(seed);
+ let secret_key = loop {
+ let mut bytes = [0; 32];
+ EcdsaRngCore::fill_bytes(&mut ecdsa_rng, &mut bytes);
+ if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) {
+ break key;
+ }
+ };
// Derive compressed public key
- let public_key = PublicKey::from_secret_key(&secret_key);
- let pubkey_ser = public_key.serialize(); // 33-byte compressed
+ let public_key = secret_key.public_key();
+ let pubkey_ser = public_key.to_compressed(); // 33-byte compressed
let address_hash = ripemd160_sha256(&pubkey_ser);
// Store private key so this signer can later sign for this address
// (use *_in_creation to mirror your identity key behavior)
self.address_private_keys_in_creation
- .insert(address_hash, secret_key.to_secret_bytes());
+ .insert(address_hash, *secret_key.to_bytes());
PlatformAddress::P2pkh(address_hash)
}
@@ -260,3 +266,33 @@ impl Signer for SimpleSigner {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use rand::{rngs::StdRng, SeedableRng};
+ use secp256k1::rand::{rngs::StdRng as LegacyRng, SeedableRng as _};
+
+ #[test]
+ fn should_preserve_seeded_address_key_generation() {
+ for seed in 0..64 {
+ let mut rng = StdRng::seed_from_u64(seed);
+ let mut expected_rng = rng.clone();
+ let mut seed = [0; 32];
+ expected_rng.fill_bytes(&mut seed);
+ let expected_key = secp256k1::SecretKey::new(&mut LegacyRng::from_seed(seed));
+ let expected_public = secp256k1::PublicKey::from_secret_key(&expected_key).serialize();
+ let expected_hash = ripemd160_sha256(&expected_public);
+ let mut signer = SimpleSigner::default();
+ assert_eq!(
+ signer.add_random_address_key(&mut rng),
+ PlatformAddress::P2pkh(expected_hash)
+ );
+ assert_eq!(
+ signer.address_private_keys_in_creation[&expected_hash],
+ expected_key.to_secret_bytes()
+ );
+ assert_eq!(rng.next_u64(), expected_rng.next_u64());
+ }
+ }
+}
diff --git a/packages/strategy-tests/src/transitions.rs b/packages/strategy-tests/src/transitions.rs
index 751b4f28b89..f16c2af2a83 100644
--- a/packages/strategy-tests/src/transitions.rs
+++ b/packages/strategy-tests/src/transitions.rs
@@ -32,6 +32,7 @@
//! each action.
use dpp::address_funds::PlatformAddress;
+use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey;
use dpp::dashcore::{
bls_sig_utils::BLSSignature, hash_types::CycleHash, InstantLock, OutPoint, ScriptBuf,
Transaction, TxIn, TxOut, Txid,
@@ -49,7 +50,6 @@ use dpp::identity::Purpose::{AUTHENTICATION, TRANSFER};
use dpp::identity::SecurityLevel::{CRITICAL, MASTER};
use dpp::identity::{Identity, IdentityPublicKey, KeyID, KeyType, Purpose, SecurityLevel};
use dpp::prelude::AssetLockProof;
-use dpp::secp256k1::SecretKey;
use dpp::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0;
use dpp::state_transition::identity_create_transition::IdentityCreateTransition;
use dpp::state_transition::identity_credit_transfer_transition::v0::IdentityCreditTransferTransitionV0;
@@ -1212,9 +1212,9 @@ where
let (_, pk) = ECDSA_SECP256K1
.random_public_and_private_key_data(rng, platform_version)
.unwrap();
- let secret_key = SecretKey::from_str(hex::encode(pk).as_str()).unwrap();
+ let secret_key = SecretKey::from_bytes(&pk).unwrap();
let asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range(
- PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet)
+ PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet)
.expect("valid test secret key"),
amount_range,
rng,
From 9f281314589d34d644db17c4158978a836daeb98 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:36:00 +0000
Subject: [PATCH 20/21] test(dpp): assert typed crypto errors and clarify nonce
parity
---
packages/rs-dpp/src/state_transition/mod.rs | 8 ++--
packages/rs-dpp/tests/ecdsa_compatibility.rs | 46 +++++++++-----------
2 files changed, 25 insertions(+), 29 deletions(-)
diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs
index 1c4ecc83b6b..c33411e89c9 100644
--- a/packages/rs-dpp/src/state_transition/mod.rs
+++ b/packages/rs-dpp/src/state_transition/mod.rs
@@ -2233,10 +2233,10 @@ impl StateTransition {
// stores a 65-byte recoverable compact signature, so we brute-force
// the recovery id (0..3) by reconstructing a `RecoverableSignature`
// and comparing the recovered public key with the one the signer
- // returned. secp256k1 normalises both `sign_ecdsa` and
- // `sign_ecdsa_recoverable` outputs to low-s form, so the 64-byte
- // `r||s` payload is bit-identical to what `dashcore::signer::sign`
- // produces.
+ // returned. Byte parity with `dashcore::signer::sign` requires the
+ // same deterministic nonce without low-R grinding, as well as low-S
+ // normalization. Core `sign_recoverable` meets that contract; `sign`
+ // performs low-R grinding and may produce different bytes.
let compact_64 = signature.to_bytes();
let msg = Message::from_digest(digest);
diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs
index f73658df3af..4a5fb76af00 100644
--- a/packages/rs-dpp/tests/ecdsa_compatibility.rs
+++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs
@@ -7,7 +7,10 @@ mod vectors;
use dpp::address_funds::{AddressWitness, AddressWitnessVerificationOperations, PlatformAddress};
use dpp::consensus::codes::ErrorWithCode;
+use dpp::dashcore::crypto::ecdsa::EcdsaError;
use dpp::dashcore::hashes::{hash160, Hash};
+use dpp::dashcore::key::Error as KeyError;
+use dpp::dashcore::sign_message::MessageSignatureError;
use dpp::dashcore::signer::{sign, verify_data_signature, verify_hash_signature};
use dpp::dashcore::{sign_message, PublicKey};
use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
@@ -123,8 +126,8 @@ fn should_preserve_all_compact_header_acceptance_rules() {
assert_eq!(result.unwrap().to_bytes().as_slice(), &signature[1..]);
} else {
assert_eq!(
- result.unwrap_err().to_string(),
- "recovery id out of range (must be 0..4)",
+ result.unwrap_err(),
+ EcdsaError::InvalidRecoveryId,
"header {header}"
);
}
@@ -135,10 +138,8 @@ fn should_preserve_all_compact_header_acceptance_rules() {
fn should_preserve_compact_length_and_scalar_errors() {
for len in [0, 1, 64, 66] {
assert_eq!(
- sign_message::from_slice(&vec![0; len])
- .unwrap_err()
- .to_string(),
- "length not 65 bytes"
+ sign_message::from_slice(&vec![0; len]).unwrap_err(),
+ MessageSignatureError::InvalidLength
);
}
let order =
@@ -151,9 +152,8 @@ fn should_preserve_compact_length_and_scalar_errors() {
sign_message::from_slice(&signature)
.unwrap()
.signature()
- .unwrap_err()
- .to_string(),
- "signature bytes are malformed"
+ .unwrap_err(),
+ EcdsaError::InvalidSignature
);
}
}
@@ -168,14 +168,14 @@ fn should_preserve_compact_length_and_scalar_errors() {
assert_eq!(
verify_data_signature(&data, &zero, &public_key)
.unwrap_err()
- .to_string(),
- "signature verification failed"
+ .downcast_ref::(),
+ Some(&EcdsaError::VerifyFailed)
);
assert_eq!(
verify_hash_signature(&[0; 32], &zero, &[0; 20])
.unwrap_err()
- .to_string(),
- "recovery failed; no valid public key"
+ .downcast_ref::(),
+ Some(&EcdsaError::RecoveryFailed)
);
}
@@ -191,25 +191,21 @@ fn should_preserve_public_key_encodings() {
for prefix in [0, 2, 3, 6, 7] {
uncompressed[0] = prefix;
assert_eq!(
- PublicKey::from_slice(&uncompressed)
- .unwrap_err()
- .to_string(),
- format!("key prefix invalid: {prefix}")
+ PublicKey::from_slice(&uncompressed).unwrap_err(),
+ KeyError::InvalidKeyPrefix(prefix)
);
}
for len in [0, 32, 34, 64, 66] {
assert_eq!(
- PublicKey::from_slice(&vec![0; len])
- .unwrap_err()
- .to_string(),
- format!("length {len} invalid for this base58 type")
+ PublicKey::from_slice(&vec![0; len]).unwrap_err(),
+ KeyError::InvalidBase58PayloadLength(len)
);
}
let mut invalid = [0xff; 33];
invalid[0] = 2;
assert_eq!(
- PublicKey::from_slice(&invalid).unwrap_err().to_string(),
- "key ECDSA error"
+ PublicKey::from_slice(&invalid).unwrap_err(),
+ KeyError::Ecdsa(EcdsaError::InvalidPublicKey)
);
}
@@ -255,8 +251,8 @@ fn should_reject_high_s_verification_but_accept_high_s_recovery() {
assert_eq!(
verify_data_signature(&data, &signature, &public_key)
.unwrap_err()
- .to_string(),
- "signature verification failed"
+ .downcast_ref::(),
+ Some(&EcdsaError::VerifyFailed)
);
verify_hash_signature(
&hex::decode(TRANSFER_HASH).unwrap(),
From d14aa581fcd9ca6941f5fa8746aa39378ef69322 Mon Sep 17 00:00:00 2001
From: Lukasz Klimek <842586+lklimek@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:36:53 +0000
Subject: [PATCH 21/21] test(swift-sdk): retain fixture writer while taking
migration snapshot
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Take the committed preservation snapshot before releasing the SwiftData
container and context so their teardown cannot race the source read lock.
Keep the migration and all thirteen field-preservation assertions unchanged.
🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent
---
.../SwiftDashSDKTests/DashModelMigrationTests.swift | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift
index ca12a56c435..e2ea9489f0a 100644
--- a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift
+++ b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift
@@ -722,6 +722,7 @@ final class DashModelMigrationTests: XCTestCase {
func testAcceptedV1PreservesAllThirteenFieldsMissingFromHistoricalV2() throws {
let (directory, url) = try copyFixture(Self.fixtures[0])
defer { try? FileManager.default.removeItem(at: directory) }
+ let before = directory.appendingPathComponent("before.store")
try autoreleasepool {
let schema = Schema(versionedSchema: DashSchemaV1.self)
let container = try ModelContainer(for: schema, configurations: [
@@ -749,9 +750,12 @@ final class DashModelMigrationTests: XCTestCase {
context.insert(type)
context.insert(index)
try context.save()
+ // Snapshot committed rows before releasing the writer: its teardown
+ // can checkpoint the WAL and contend with the backup's source read lock.
+ try withExtendedLifetime((container, context)) {
+ try DashLegacyStoreSQLite.copy(from: url, to: before)
+ }
}
- let before = directory.appendingPathComponent("before.store")
- try DashLegacyStoreSQLite.copy(from: url, to: before)
try autoreleasepool {
let container = try DashModelContainer.create(url: url)
let context = container.mainContext