Use bitcoin_hashes for Sha256

Cargo.lock

@@ -72,6 +72,15 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
 
+[[package]]
+name = "bitcoin_hashes"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "006cc91e1a1d99819bc5b8214be3555c1f0611b169f527a1fdc54ed1f2b745b0"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -117,6 +126,7 @@ name = "cln-grpc"
 version = "0.0.1"
 dependencies = [
  "anyhow",
+ "bitcoin_hashes",
  "cln-rpc",
  "hex",
  "log",
@@ -164,6 +174,7 @@ name = "cln-rpc"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "bitcoin_hashes",
  "bytes",
  "env_logger",
  "futures-util",

cln-grpc/Cargo.toml

@@ -10,6 +10,7 @@ cln-rpc = { path="../cln-rpc" }
 tonic = { version = "^0.5", features = ["tls", "transport"] }
 prost = "0.8"
 hex = "0.4.3"
+bitcoin_hashes = { version = "0.10.0", features = [ "serde" ] }
 
 [dev-dependencies]
 serde_json = "1.0.72"

cln-grpc/src/convert.rs

@@ -8,6 +8,8 @@ use std::convert::From;
 use cln_rpc::model::{responses,requests};
 use crate::pb;
 use std::str::FromStr;
+use bitcoin_hashes::sha256::Hash as Sha256;
+use bitcoin_hashes::Hash;
 
 #[allow(unused_variables)]
 impl From<responses::GetinfoAddress> for pb::GetinfoAddress {
@@ -1020,7 +1022,7 @@ impl From<pb::SendpayRequest> for requests::SendpayRequest {
     fn from(c: pb::SendpayRequest) -> Self {
         Self {
             route: c.route.into_iter().map(|s| s.into()).collect(), // Rule #4
-            payment_hash: c.payment_hash.try_into().unwrap(), // Rule #1 for type hash
+            payment_hash: Sha256::from_slice(&c.payment_hash).unwrap(), // Rule #1 for type hash
             label: c.label, // Rule #1 for type string?
             amount_msat: c.amount_msat.map(|a| a.into()), // Rule #1 for type msat?
             bolt11: c.bolt11, // Rule #1 for type string?
@@ -1218,14 +1220,14 @@ impl From<pb::SendonionRequest> for requests::SendonionRequest {
     fn from(c: pb::SendonionRequest) -> Self {
         Self {
             onion: hex::encode(&c.onion), // Rule #1 for type hex
-            payment_hash: c.payment_hash.try_into().unwrap(), // Rule #1 for type hash
+            payment_hash: Sha256::from_slice(&c.payment_hash).unwrap(), // Rule #1 for type hash
             label: c.label, // Rule #1 for type string?
             shared_secrets: Some(c.shared_secrets.into_iter().map(|s| s.try_into().unwrap()).collect()), // Rule #4
             partid: c.partid.map(|v| v as u16), // Rule #1 for type u16?
             bolt11: c.bolt11, // Rule #1 for type string?
             amount_msat: c.amount_msat.map(|a| a.into()), // Rule #1 for type msat?
             destination: c.destination.map(|v| cln_rpc::primitives::Pubkey::from_slice(&v[..]).unwrap()), // Rule #1 for type pubkey?
-            localofferid: c.localofferid.map(|v| v.try_into().unwrap()), // Rule #1 for type hash?
+            localofferid: c.localofferid.map(|v| Sha256::from_slice(&v).unwrap()), // Rule #1 for type hash?
             groupid: c.groupid, // Rule #1 for type u64?
         }
     }
@@ -1236,7 +1238,7 @@ impl From<pb::ListsendpaysRequest> for requests::ListsendpaysRequest {
     fn from(c: pb::ListsendpaysRequest) -> Self {
         Self {
             bolt11: c.bolt11, // Rule #1 for type string?
-            payment_hash: c.payment_hash.map(|v| v.try_into().unwrap()), // Rule #1 for type hash?
+            payment_hash: c.payment_hash.map(|v| Sha256::from_slice(&v).unwrap()), // Rule #1 for type hash?
             status: c.status.map(|v| v.try_into().unwrap()),
         }
     }
@@ -1302,7 +1304,7 @@ impl From<pb::WaitinvoiceRequest> for requests::WaitinvoiceRequest {
 impl From<pb::WaitsendpayRequest> for requests::WaitsendpayRequest {
     fn from(c: pb::WaitsendpayRequest) -> Self {
         Self {
-            payment_hash: c.payment_hash.try_into().unwrap(), // Rule #1 for type hash
+            payment_hash: Sha256::from_slice(&c.payment_hash).unwrap(), // Rule #1 for type hash
             timeout: c.timeout, // Rule #1 for type u32?
             partid: c.partid, // Rule #1 for type u64?
             groupid: c.groupid, // Rule #1 for type u64?
@@ -1502,7 +1504,7 @@ impl From<pb::ListpaysRequest> for requests::ListpaysRequest {
     fn from(c: pb::ListpaysRequest) -> Self {
         Self {
             bolt11: c.bolt11, // Rule #1 for type string?
-            payment_hash: c.payment_hash.map(|v| v.try_into().unwrap()), // Rule #1 for type hash?
+            payment_hash: c.payment_hash.map(|v| Sha256::from_slice(&v).unwrap()), // Rule #1 for type hash?
             status: c.status.map(|v| v.try_into().unwrap()),
         }
     }

cln-grpc/src/pb.rs

@@ -1,5 +1,6 @@
 tonic::include_proto!("cln");
 use std::str::FromStr;
+use bitcoin_hashes::Hash;
 
 use cln_rpc::primitives::{
     Amount as JAmount, AmountOrAll as JAmountOrAll, AmountOrAny as JAmountOrAny,
@@ -21,7 +22,7 @@ impl From<Amount> for JAmount {
 impl From<JOutpoint> for Outpoint {
     fn from(a: JOutpoint) -> Self {
         Outpoint {
-            txid: a.txid,
+            txid: a.txid.to_vec(),
             outnum: a.outnum,
         }
     }
@@ -30,7 +31,7 @@ impl From<JOutpoint> for Outpoint {
 impl From<Outpoint> for JOutpoint {
     fn from(a: Outpoint) -> Self {
         JOutpoint {
-            txid: a.txid,
+            txid: bitcoin_hashes::sha256::Hash::from_slice(&a.txid).unwrap(),
             outnum: a.outnum,
         }
     }

cln-rpc/Cargo.toml

@@ -9,6 +9,7 @@ path = "examples/getinfo.rs"
 
 [dependencies]
 anyhow = "1.0.51"
+bitcoin_hashes = { version = "0.10.0", features = [ "serde" ] }
 bytes = "1.1.0"
 log = "0.4.14"
 serde = { version = "1.0.131", features = ["derive"] }

cln-rpc/src/primitives.rs

@@ -5,6 +5,9 @@ use serde::{Deserialize, Serialize};
 use serde::{Deserializer, Serializer};
 use std::str::FromStr;
 use std::string::ToString;
+use bitcoin_hashes::Hash as BitcoinHash;
+
+pub use bitcoin_hashes::sha256::Hash as Sha256;
 
 #[derive(Copy, Clone, Serialize, Deserialize, Debug)]
 #[allow(non_camel_case_types)]
@@ -224,51 +227,9 @@ impl Secret {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct Sha256([u8; 32]);
-impl Sha256 {
-    pub fn to_vec(self) -> Vec<u8> {
-        self.0.to_vec()
-    }
-}
-
-impl TryFrom<Vec<u8>> for Sha256 {
-    type Error = crate::Error;
-    fn try_from(v: Vec<u8>) -> Result<Self, crate::Error> {
-        if v.len() != 32 {
-            Err(anyhow!("Unexpected hash length: {}", hex::encode(v)))
-        } else {
-            Ok(Sha256(v.try_into().unwrap()))
-        }
-    }
-}
-
-impl Serialize for Sha256 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&hex::encode(&self.0))
-    }
-}
-
-impl<'de> Deserialize<'de> for Sha256 {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        use serde::de::Error;
-        let s: String = Deserialize::deserialize(deserializer)?;
-        let h = hex::decode(s).map_err(|_| Error::custom("not a valid hex string"))?;
-        Ok(Sha256(h.try_into().map_err(|_| {
-            Error::custom("not a valid hex-encoded hash")
-        })?))
-    }
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub struct Outpoint {
-    pub txid: Vec<u8>,
+    pub txid: Sha256,
     pub outnum: u32,
 }
 
@@ -294,8 +255,11 @@ impl<'de> Deserialize<'de> for Outpoint {
             return Err(Error::custom("not a valid txid:output tuple"));
         }
 
-        let txid =
+        let txid_bytes =
             hex::decode(splits[0]).map_err(|_| Error::custom("not a valid hex encoded txid"))?;
+
+        let txid= Sha256::from_slice(&txid_bytes).map_err(|e| Error::custom(format!("Invalid TxId: {}", e)))?;
+
         let outnum: u32 = splits[1]
             .parse()
             .map_err(|e| Error::custom(format!("{} is not a valid number: {}", s, e)))?;

contrib/msggen/msggen/gen/grpc.py

@@ -349,6 +349,8 @@ class GrpcConverterGenerator(IGenerator):
         use cln_rpc::model::{responses,requests};
         use crate::pb;
         use std::str::FromStr;
+        use bitcoin_hashes::sha256::Hash as Sha256;
+        use bitcoin_hashes::Hash;
 
         """)
 
@@ -434,8 +436,8 @@ class GrpcUnconverterGenerator(GrpcConverterGenerator):
                     'short_channel_id?': f'c.{name}.map(|v| cln_rpc::primitives::ShortChannelId::from_str(&v).unwrap())',
                     'secret': f'c.{name}.try_into().unwrap()',
                     'secret?': f'c.{name}.map(|v| v.try_into().unwrap())',
-                    'hash': f'c.{name}.try_into().unwrap()',
+                    'hash': f'Sha256::from_slice(&c.{name}).unwrap()',
-                    'hash?': f'c.{name}.map(|v| v.try_into().unwrap())',
+                    'hash?': f'c.{name}.map(|v| Sha256::from_slice(&v).unwrap())',
                     'txid': f'hex::encode(&c.{name})',
                 }.get(
                     typ,