move schnorr sig verification to bitcoin lib

packages/bitcoin/Cargo.toml

@@ -6,9 +6,13 @@ edition.workspace = true
 
 [dependencies]
 bitcoin      = { workspace = true }
+digest       = { workspace = true }
+sha2         = { workspace = true }
 serde        = { workspace = true }
 schemars     = { workspace = true }
 cosmwasm-std = { workspace = true }
+k256         = { workspace = true }
+thiserror    = { workspace = true }
 
 [dev-dependencies]
 hex          = { workspace = true }

packages/bitcoin/src/error.rs

@@ -0,0 +1,9 @@
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum Error {
+    #[error("Failed to parse public key")]
+    FailedToParsePublicKey(String),
+    #[error("Invalid schnorr signature")]
+    InvalidSchnorrSignature(String),
+}

packages/bitcoin/src/lib.rs

@@ -10,9 +10,13 @@ pub use bitcoin::{
 pub use cosmwasm_std::Uint256;
 
 pub mod chain_params;
+pub mod error;
 pub mod merkle;
 pub mod op_return;
 pub mod pow;
+pub mod schnorr;
+
+pub type Result<T> = std::result::Result<T, error::Error>;
 
 #[cfg(test)]
 mod tests {

packages/btcstaking/src/identity_digest.rs → packages/bitcoin/src/schnorr.rs

@@ -4,9 +4,14 @@
 //!
 //! Adapted from `sha2` [sha256.rs](https://github.com/RustCrypto/hashes/blob/master/sha2/src/sha256.rs)
 //! and https://github.com/CosmWasm/cosmwasm/blob/main/packages/crypto/src/identity_digest.rs
+use crate::error::Error;
+use crate::Result;
 use digest::consts::U32;
 use digest::generic_array::GenericArray;
 use digest::{FixedOutput, HashMarker, Output, OutputSizeUser, Reset, Update};
+use k256::schnorr::signature::DigestVerifier;
+use k256::schnorr::Signature as SchnorrSignature;
+use k256::schnorr::VerifyingKey;
 use sha2::Digest;
 
 /// The 256-bits identity container
@@ -40,6 +45,22 @@ impl Reset for Identity256 {
     }
 }
 
-pub fn new_digest(msg_hash: [u8; 32]) -> Identity256 {
+pub fn new_digest(msg_hash: &[u8; 32]) -> Identity256 {
     Identity256::new().chain(msg_hash)
 }
+
+pub fn verify_digest(
+    pub_key: &[u8],
+    msg_hash: &[u8; 32],
+    signature: &SchnorrSignature,
+) -> Result<()> {
+    let digest = new_digest(msg_hash);
+
+    // verify the signature w.r.t. the signature, the sig hash, and the public key
+    let verifying_key = VerifyingKey::from_bytes(pub_key)
+        .map_err(|e| Error::FailedToParsePublicKey(e.to_string()))?;
+
+    verifying_key
+        .verify_digest(digest, signature)
+        .map_err(|e| Error::InvalidSchnorrSignature(e.to_string()))
+}

packages/btcstaking/Cargo.toml

@@ -5,14 +5,15 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-bitcoin       = { workspace = true }
-digest        = { workspace = true }
-rust_decimal  = { workspace = true }
-hex           = { workspace = true }
-sha2          = { workspace = true }
-k256          = { workspace = true }
-thiserror     = { workspace = true }
-eots          = { path = "../eots" }
+babylon-bitcoin = { workspace = true }
+bitcoin         = { workspace = true }
+digest          = { workspace = true }
+rust_decimal    = { workspace = true }
+hex             = { workspace = true }
+sha2            = { workspace = true }
+k256            = { workspace = true }
+thiserror       = { workspace = true }
+eots            = { path = "../eots" }
 
 [dev-dependencies]
 test-utils    = { path = "../test-utils" }

packages/btcstaking/src/error.rs

@@ -2,6 +2,8 @@ use thiserror::Error;
 
 #[derive(Error, Debug, PartialEq)]
 pub enum Error {
+    #[error("Bitcoin error: {0}")]
+    BitcoinError(#[from] babylon_bitcoin::error::Error),
     #[error("Failed to decompress bytes to a projective point")]
     DecompressPointFailed {},
     #[error("Point {0} is at infinity")]

packages/btcstaking/src/lib.rs

@@ -1,6 +1,5 @@
 mod adaptor_sig;
 pub mod error;
-mod identity_digest;
 pub mod scripts_utils;
 pub mod sig_verify;
 pub mod tx_verify;

packages/btcstaking/src/sig_verify.rs

@@ -1,7 +1,7 @@
 use crate::adaptor_sig::AdaptorSignature;
 use crate::error::Error;
-use crate::identity_digest::new_digest;
 use crate::Result;
+use babylon_bitcoin::schnorr;
 use bitcoin::hashes::Hash;
 use bitcoin::sighash::{Prevouts, SighashCache};
 use bitcoin::Transaction;
@@ -47,15 +47,8 @@ pub fn verify_transaction_sig_with_output(
 ) -> Result<()> {
     // calculate the sig hash of the tx for the given spending path
     let sighash = calc_sighash(transaction, funding_output, path_script)?;
-    let sighash_digest = new_digest(sighash);
 
-    // verify the signature w.r.t. the signature, the sig hash, and the public key
-    let verifying_key = VerifyingKey::from_bytes(&pub_key.serialize())
-        .map_err(|e| Error::FailedToParsePublicKey(e.to_string()))?;
-
-    verifying_key
-        .verify_digest(sighash_digest, signature)
-        .map_err(|e| Error::InvalidSchnorrSignature(e.to_string()))
+    schnorr::verify_digest(&pub_key.serialize(), &sighash, signature).map_err(Error::BitcoinError)
 }
 
 /// enc_verify_transaction_sig_with_output verifies the validity of a Schnorr adaptor signature for a given transaction