Merge pull request #9 from Rigidity/data-stores

Data stores

Author: Rigidity

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chia-wallet-sdk"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 license = "Apache-2.0"
 description = "An unofficial SDK for building Chia wallets."

src/address.rs

@@ -1,18 +1,84 @@
-/// Parses an address into a puzzle hash.
-pub fn parse_address(address: &str) -> [u8; 32] {
-    if let Ok(puzzle_hash) = hex::decode(strip_prefix(address)) {
-        puzzle_hash.try_into().expect("invalid puzzle hash")
+use bech32::{u5, Variant};
+use hex::FromHexError;
+use thiserror::Error;
+
+/// Errors you can get while trying to decode an address.
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
+pub enum AddressError {
+    /// The wrong HRP prefix was used.
+    #[error("invalid prefix `{0}`")]
+    InvalidPrefix(String),
+
+    /// The address was encoded as bech32, rather than bech32m.
+    #[error("encoding is not bech32m")]
+    InvalidFormat,
+
+    /// The data was not 32 bytes in length.
+    #[error("wrong length, expected 32 bytes but found {0}")]
+    WrongLength(usize),
+
+    /// An error occured while trying to decode the address.
+    #[error("error when decoding address: {0}")]
+    Decode(#[from] bech32::Error),
+}
+
+/// Errors you can get while trying to decode a puzzle hash.
+#[derive(Error, Debug, Clone, PartialEq)]
+pub enum PuzzleHashError {
+    /// The buffer was not 32 bytes in length.
+    #[error("wrong length, expected 32 bytes but found {0}")]
+    WrongLength(usize),
+
+    /// An error occured while trying to decode the puzzle hash.
+    #[error("error when decoding puzzle hash: {0}")]
+    Decode(#[from] FromHexError),
+}
+
+/// Decodes a puzzle hash from hex, with or without a prefix.
+pub fn decode_puzzle_hash(puzzle_hash: &str) -> Result<[u8; 32], PuzzleHashError> {
+    let data = hex::decode(strip_prefix(puzzle_hash))?;
+    let length = data.len();
+    data.try_into()
+        .map_err(|_| PuzzleHashError::WrongLength(length))
+}
+
+/// Encodes a puzzle hash into hex, with or without a prefix.
+pub fn encode_puzzle_hash(puzzle_hash: [u8; 32], include_0x: bool) -> String {
+    if include_0x {
+        format!("0x{}", hex::encode(puzzle_hash))
     } else {
-        let (_hrp, data, _variant) = bech32::decode(address).expect("invalid address");
-        let puzzle_hash = bech32::convert_bits(&data, 5, 8, false).expect("invalid address data");
-        puzzle_hash
-            .try_into()
-            .expect("invalid address puzzle hash encoding")
+        hex::encode(puzzle_hash)
     }
 }
 
+/// Decodes an address into a puzzle hash and HRP prefix.
+pub fn decode_address(address: &str) -> Result<([u8; 32], String), AddressError> {
+    let (hrp, data, variant) = bech32::decode(address)?;
+    if variant != Variant::Bech32m {
+        return Err(AddressError::InvalidFormat);
+    }
+
+    let data = bech32::convert_bits(&data, 5, 8, false)?;
+    let length = data.len();
+    let puzzle_hash = data
+        .try_into()
+        .map_err(|_| AddressError::WrongLength(length))?;
+
+    Ok((puzzle_hash, hrp))
+}
+
+/// Encodes an address with a given HRP prefix.
+pub fn encode_address(puzzle_hash: [u8; 32], prefix: &str) -> Result<String, bech32::Error> {
+    let data = bech32::convert_bits(&puzzle_hash, 8, 5, true)
+        .unwrap()
+        .into_iter()
+        .map(u5::try_from_u8)
+        .collect::<Result<Vec<_>, bech32::Error>>()?;
+    bech32::encode(prefix, data, Variant::Bech32m)
+}
+
 /// Removes the `0x` prefix from a puzzle hash in hex format.
-fn strip_prefix(puzzle_hash: &str) -> &str {
+pub fn strip_prefix(puzzle_hash: &str) -> &str {
     if let Some(puzzle_hash) = puzzle_hash.strip_prefix("0x") {
         puzzle_hash
     } else if let Some(puzzle_hash) = puzzle_hash.strip_prefix("0X") {
@@ -21,3 +87,87 @@ fn strip_prefix(puzzle_hash: &str) -> &str {
         puzzle_hash
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use hex_literal::hex;
+
+    use super::*;
+
+    fn check_ph(expected: &str) {
+        let expected = strip_prefix(expected);
+        let puzzle_hash = decode_puzzle_hash(expected).unwrap();
+        let actual = encode_puzzle_hash(puzzle_hash, false);
+        assert_eq!(actual, expected);
+    }
+
+    fn check_addr(expected: &str) {
+        let (puzzle_hash, prefix) = decode_address(expected).unwrap();
+        let actual = encode_address(puzzle_hash, &prefix).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_strip_prefix() {
+        check_ph("0x2999682870bd24e7fd0ef6324c69794ff93fc41b016777d2edd5ea8575bdaa31");
+        check_ph("0x99619cc6888f1bd30acd6e8c1f4065dafeba2246bfc3465cddda4e6656083791");
+        check_ph("0X7cc6494dd96d32c97b5f6ba77caae269acd6c86593ada66f343050ce709e904a");
+        check_ph("0X9f057817ad576b24ec60a25ded08f5bde6db0aa0beeb0c099e3ce176866e1c4b");
+    }
+
+    #[test]
+    fn test_puzzle_hashes() {
+        check_ph(&hex::encode([0; 32]));
+        check_ph(&hex::encode([255; 32]));
+        check_ph(&hex::encode([127; 32]));
+        check_ph(&hex::encode([1; 32]));
+        check_ph("f46ec440aeb9b3baa19968810a8537ec4ff406c09c994dd7d3222b87258a52ff");
+        check_ph("2f981b2f9510ef9e62523e6b38fc933e2f060c411cfa64906413ddfd56be8dc1");
+        check_ph("3e09bdd6b19659555a7c8456c5af54d004d774f3d44689360d4778ce685201ad");
+        check_ph("d16c2ad7c5642532659e424dc0d7e4a85779c6dab801b5e6117a8c8587156472");
+    }
+
+    #[test]
+    fn test_invalid_puzzle_hashes() {
+        assert_eq!(
+            decode_puzzle_hash("ac4fd55996a1186fffc30c5b60385a88fd78d538f1c9febbfa9c8a9e9a170ad"),
+            Err(PuzzleHashError::Decode(FromHexError::OddLength))
+        );
+        assert_eq!(
+            decode_puzzle_hash(&hex::encode(hex!(
+                "
+            dfe399911acc4426f44bf31f4d817f6b69f244bbad138a28
+            25c05550f7d2ab70c35408f764281febd624ac8cdfc91817
+            "
+            ))),
+            Err(PuzzleHashError::WrongLength(48))
+        );
+        assert_eq!(
+            decode_puzzle_hash("hello there!"),
+            Err(PuzzleHashError::Decode(FromHexError::InvalidHexCharacter {
+                c: 'h',
+                index: 0
+            }))
+        );
+    }
+
+    #[test]
+    fn test_addresses() {
+        check_addr("xch1a0t57qn6uhe7tzjlxlhwy2qgmuxvvft8gnfzmg5detg0q9f3yc3s2apz0h");
+        check_addr("xch1ftxk2v033kv94ueucp0a34sgt9398vle7l7g3q9k4leedjmmdysqvv6q96");
+        check_addr("xch1ay273ctc9c6nxmzmzsup28scrce8ney84j4nlewdlaxqs22v53ksxgf38f");
+        check_addr("xch1avnwmy2fuesq7h2jnxehlrs9msrad9uuvrhms35k2pqwmjv56y5qk7zm6v");
+    }
+
+    #[test]
+    fn test_invalid_addresses() {
+        assert_eq!(
+            decode_address("hello there!"),
+            Err(AddressError::Decode(bech32::Error::MissingSeparator))
+        );
+        assert_eq!(
+            decode_address("bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq"),
+            Err(AddressError::InvalidFormat)
+        );
+    }
+}

src/lib.rs

@@ -7,6 +7,7 @@ mod condition;
 mod signer;
 mod spends;
 mod ssl;
+mod stores;
 mod utils;
 mod wallet;
 
@@ -15,6 +16,7 @@ pub use condition::*;
 pub use signer::*;
 pub use spends::*;
 pub use ssl::*;
+pub use stores::*;
 pub use wallet::*;
 
 #[cfg(test)]

src/signer.rs

@@ -1,6 +1,4 @@
-use std::future::Future;
-
-use chia_bls::{sign, PublicKey, SecretKey, Signature};
+use chia_bls::{sign, Signature};
 
 use chia_protocol::{CoinSpend, SpendBundle};
 use clvm_traits::{FromClvm, FromClvmError};
@@ -11,7 +9,7 @@ mod required_signature;
 
 pub use required_signature::*;
 
-use crate::Condition;
+use crate::{Condition, SecretKeyStore};
 
 /// An error that occurs while trying to sign a coin spend.
 #[derive(Debug, Error)]
@@ -29,15 +27,9 @@ pub enum SignSpendError {
     MissingKey,
 }
 
-/// Responsible for signing messages.
-pub trait Signer {
-    /// Gets the secret key for a given public key.
-    fn secret_key(&self, public_key: &PublicKey) -> impl Future<Output = Option<SecretKey>> + Send;
-}
-
 /// Signs each of the required messages in a coin spend.
 pub async fn sign_coin_spend(
-    signer: &impl Signer,
+    sk_store: &impl SecretKeyStore,
     allocator: &mut Allocator,
     coin_spend: &CoinSpend,
     agg_sig_me_extra_data: [u8; 32],
@@ -60,7 +52,7 @@ pub async fn sign_coin_spend(
             continue;
         };
 
-        let Some(sk) = signer.secret_key(required.public_key()).await else {
+        let Some(sk) = sk_store.to_secret_key(required.public_key()).await else {
             return Err(SignSpendError::MissingKey);
         };
 
@@ -72,15 +64,15 @@ pub async fn sign_coin_spend(
 
 /// Signs each of the coin spends in a spend bundle.
 pub async fn sign_spend_bundle(
-    signer: &impl Signer,
+    sk_store: &impl SecretKeyStore,
     allocator: &mut Allocator,
     spend_bundle: &SpendBundle,
     agg_sig_me_extra_data: [u8; 32],
 ) -> Result<Signature, SignSpendError> {
     let mut aggregate_signature = Signature::default();
     for coin_spend in &spend_bundle.coin_spends {
         let signature =
-            sign_coin_spend(signer, allocator, coin_spend, agg_sig_me_extra_data).await?;
+            sign_coin_spend(sk_store, allocator, coin_spend, agg_sig_me_extra_data).await?;
         aggregate_signature += &signature;
     }
     Ok(aggregate_signature)

src/spends/cat.rs

@@ -153,7 +153,7 @@ pub async fn spend_cat_coins(
         // Coin info.
         let puzzle_hash = &coin.puzzle_hash;
         let index = derivation_store
-            .index_of_puzzle_hash(puzzle_hash.into())
+            .index_of_ph(puzzle_hash.into())
             .await
             .expect("cannot spend coin with unknown puzzle hash");
 

src/spends/standard.rs

@@ -46,7 +46,7 @@ pub async fn spend_standard_coins(
     for (i, coin) in coins.into_iter().enumerate() {
         let puzzle_hash = &coin.puzzle_hash;
         let index = derivation_store
-            .index_of_puzzle_hash(puzzle_hash.into())
+            .index_of_ph(puzzle_hash.into())
             .await
             .expect("cannot spend coin with unknown puzzle hash");
 

src/stores.rs

@@ -0,0 +1,11 @@
+mod coin_store;
+mod derivation_store;
+mod public_key_store;
+mod secret_key_store;
+mod transaction_store;
+
+pub use coin_store::*;
+pub use derivation_store::*;
+pub use public_key_store::*;
+pub use secret_key_store::*;
+pub use transaction_store::*;