add custom dummy getdefault

Author: Jiloc

stacks-common/Cargo.toml

@@ -46,6 +46,7 @@ slog-term = "2.6.0"
 
 # Optional dependencies
 slog-json = { version = "2.3.0", optional = true }
+getrandom = { version = "0.2", default-features = false, optional = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = {version = "0.23", optional = true}
@@ -63,8 +64,7 @@ secp256k1 = { version = "0.24.3", features = ["serde", "recovery"] }
 rusqlite = { workspace = true, optional = true }
 
 [target.'cfg(target_family = "wasm")'.dependencies]
-libsecp256k1 = { version = "0.7.0", default-features = false, features = ["hmac", "static-context"] }
-getrandom = { version = "0.2.12", features = ["js"], optional = true }
+libsecp256k1 = { version = "0.7.0", default-features = false, features = ["hmac"] }
 
 [target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(any(target_os="windows"))))'.dependencies]
 sha2 = { version = "0.10", features = ["asm"] }
@@ -93,8 +93,12 @@ slog_json = ["slog-json"]
 rusqlite = ["dep:rusqlite", "rand"]
 # Enables the rand module. This flag must be off on deterministic
 # platforms such as CosmWasm
-rand = ["dep:rand", "dep:getrandom"]
+rand = ["dep:rand"]
 serde = []
 testing = ["rand"]
 bech32_std = []
 bech32_strict = []
+
+# Wasm-specific features for easier configuration
+wasm-web = ["rand", "getrandom/js", "libsecp256k1/static-context"]
+wasm-deterministic = ["getrandom/custom"]

stacks-common/src/libcommon.rs

@@ -110,6 +110,23 @@ pub mod versions {
     include!(concat!(env!("OUT_DIR"), "/versions.rs"));
 }
 
+#[cfg(all(feature = "wasm-deterministic", target_family = "wasm"))]
+mod getrandom {
+    use core::num::NonZeroU32;
+
+    use getrandom::Error;
+
+    pub const NO_RANDOMNESS_ERROR_CODE: u32 = Error::CUSTOM_START;
+    pub fn always_fail(_buf: &mut [u8]) -> Result<(), Error> {
+        let code = NonZeroU32::new(NO_RANDOMNESS_ERROR_CODE).unwrap();
+        Err(Error::from(code))
+    }
+    pub use getrandom::register_custom_getrandom;
+}
+
+#[cfg(all(feature = "wasm-deterministic", target_family = "wasm"))]
+getrandom::register_custom_getrandom!(getrandom::always_fail);
+
 /// This test asserts that the constant above doesn't change.
 /// This exists because the constant above is used by Epoch 2.5 instantiation code.
 ///

stacks-common/src/util/secp256k1/wasm.rs

@@ -16,10 +16,11 @@
 
 use ::libsecp256k1;
 pub use ::libsecp256k1::Error;
+#[cfg(not(feature = "wasm-deterministic"))]
+use ::libsecp256k1::{Error as LibSecp256k1Error, Message as LibSecp256k1Message};
 use ::libsecp256k1::{
-    Error as LibSecp256k1Error, Message as LibSecp256k1Message, PublicKey as LibSecp256k1PublicKey,
-    RecoveryId as LibSecp256k1RecoveryId, SecretKey as LibSecp256k1PrivateKey,
-    Signature as LibSecp256k1Signature,
+    PublicKey as LibSecp256k1PublicKey, RecoveryId as LibSecp256k1RecoveryId,
+    SecretKey as LibSecp256k1PrivateKey, Signature as LibSecp256k1Signature,
 };
 use serde::de::{Deserialize, Error as de_Error};
 use serde::Serialize;
@@ -101,6 +102,7 @@ impl Secp256k1PublicKey {
         Secp256k1PublicKey::from_slice(&data[..]).map_err(|_e| "Invalid public key hex string")
     }
 
+    #[cfg(not(feature = "wasm-deterministic"))]
     pub fn from_private(privk: &Secp256k1PrivateKey) -> Secp256k1PublicKey {
         let key = LibSecp256k1PublicKey::from_secret_key(&privk.key);
         Secp256k1PublicKey {
@@ -109,6 +111,7 @@ impl Secp256k1PublicKey {
         }
     }
 
+    #[cfg(not(feature = "wasm-deterministic"))]
     /// recover message and signature to public key (will be compressed)
     pub fn recover_to_pubkey(
         msg: &[u8],
@@ -186,6 +189,7 @@ impl Secp256k1PrivateKey {
     }
 }
 
+#[cfg(not(feature = "wasm-deterministic"))]
 pub fn secp256k1_recover(
     message_arr: &[u8],
     serialized_signature: &[u8],
@@ -197,6 +201,7 @@ pub fn secp256k1_recover(
     Ok(recovered_pub_key.serialize_compressed())
 }
 
+#[cfg(not(feature = "wasm-deterministic"))]
 pub fn secp256k1_verify(
     message_arr: &[u8],
     serialized_signature: &[u8],
@@ -300,6 +305,12 @@ impl PublicKey for Secp256k1PublicKey {
         self.to_bytes()
     }
 
+    #[cfg(feature = "wasm-deterministic")]
+    fn verify(&self, _data_hash: &[u8], _sig: &MessageSignature) -> Result<bool, &'static str> {
+        Err("Not implemented for wasm-deterministic")
+    }
+
+    #[cfg(not(feature = "wasm-deterministic"))]
     fn verify(&self, data_hash: &[u8], sig: &MessageSignature) -> Result<bool, &'static str> {
         let pub_key = Secp256k1PublicKey::recover_to_pubkey(data_hash, sig)?;
         Ok(self.eq(&pub_key))
@@ -315,6 +326,12 @@ impl PrivateKey for Secp256k1PrivateKey {
         bits
     }
 
+    #[cfg(feature = "wasm-deterministic")]
+    fn sign(&self, _data_hash: &[u8]) -> Result<MessageSignature, &'static str> {
+        Err("Not implemented for wasm-deterministic")
+    }
+
+    #[cfg(not(feature = "wasm-deterministic"))]
     fn sign(&self, data_hash: &[u8]) -> Result<MessageSignature, &'static str> {
         let message = LibSecp256k1Message::parse_slice(data_hash)
             .map_err(|_e| "Invalid message: failed to decode data hash: must be a 32-byte hash")?;