refactor(sia): Sia http client refactor and

mm2src/coins/sia.rs

@@ -32,7 +32,10 @@ pub mod blake2b_internal;
 pub mod encoding;
 pub mod http_client;
 use http_client::{SiaApiClient, SiaApiClientError};
+pub mod http_endpoints;
+pub mod specifier;
 pub mod spend_policy;
+pub mod transaction;
 
 #[derive(Clone)]
 pub struct SiaCoin(SiaArc);
@@ -57,7 +60,7 @@ pub struct SiaCoinConf {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct SiaHttpConf {
     pub url: Url,
-    pub auth: String,
+    pub password: String,
 }
 
 // TODO see https://github.com/KomodoPlatform/komodo-defi-framework/pull/2086#discussion_r1521660384
@@ -174,8 +177,9 @@ impl<'a> SiaCoinBuilder<'a> {
         let conf = SiaConfBuilder::new(self.conf, self.ticker()).build()?;
         let sia_fields = SiaCoinFields {
             conf,
-            http_client: SiaApiClient::new(self.ticker(), self.params.http_conf.clone())
-                .map_err(SiaCoinBuildError::ClientError)?,
+            http_client: SiaApiClient::new(self.params.http_conf.clone())
+                .map_err(SiaCoinBuildError::ClientError)
+                .await?,
             priv_key_policy: PrivKeyPolicy::Iguana(self.key_pair),
         };
         let sia_arc = SiaArc::new(sia_fields);
@@ -359,7 +363,7 @@ impl MarketCoinOps for SiaCoin {
     fn current_block(&self) -> Box<dyn Future<Item = u64, Error = String> + Send> {
         let http_client = self.0.http_client.clone(); // Clone the client
 
-        let height_fut = async move { http_client.get_height().await.map_err(|e| e.to_string()) }
+        let height_fut = async move { http_client.current_height().await.map_err(|e| e.to_string()) }
             .boxed() // Make the future 'static by boxing
             .compat(); // Convert to a futures 0.1-compatible future
 

mm2src/coins/sia/address.rs

@@ -1,4 +1,5 @@
 use crate::sia::blake2b_internal::standard_unlock_hash;
+use crate::sia::encoding::{Encodable, Encoder};
 use blake2b_simd::Params;
 use ed25519_dalek::PublicKey;
 use hex::FromHexError;
@@ -10,7 +11,7 @@ use std::str::FromStr;
 
 // TODO this could probably include the checksum within the data type
 // generating the checksum on the fly is how Sia Go does this however
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct Address(pub H256);
 
 impl Address {
@@ -21,6 +22,10 @@ impl Address {
     }
 }
 
+impl Encodable for Address {
+    fn encode(&self, encoder: &mut Encoder) { encoder.write_slice(self.0 .0.as_ref()); }
+}
+
 impl fmt::Display for Address {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "addr:{}", self.str_without_prefix()) }
 }
@@ -36,7 +41,6 @@ pub enum ParseAddressError {
     InvalidHexEncoding(String),
     InvalidChecksum,
     InvalidLength,
-    // Add other error kinds as needed
 }
 
 impl From<FromHexError> for ParseAddressError {
@@ -165,3 +169,17 @@ fn test_address_str_without_prefix() {
         "591fcf237f8854b5653d1ac84ae4c107b37f148c3c7b413f292d48db0c25a8840be0653e411f"
     );
 }
+
+#[test]
+fn test_address_encode() {
+    let pubkey = PublicKey::from_bytes(
+        &hex::decode("0102030000000000000000000000000000000000000000000000000000000000").unwrap(),
+    )
+    .unwrap();
+    let address = v1_standard_address_from_pubkey(&pubkey);
+
+    let hash = Encoder::encode_and_hash(&address);
+    let expected = H256::from("d64b9a56043a909494f07520915e10dae62d75dba24b17c8414f8f3f30c53425");
+
+    assert_eq!(hash, expected);
+}

mm2src/coins/sia/blake2b_internal.rs

@@ -1,3 +1,4 @@
+use crate::sia::specifier::Identifier;
 use blake2b_simd::Params;
 use ed25519_dalek::PublicKey;
 use rpc::v1::types::H256;
@@ -9,10 +10,6 @@ use std::default::Default;
 const LEAF_HASH_PREFIX: [u8; 1] = [0u8];
 const NODE_HASH_PREFIX: [u8; 1] = [1u8];
 
-pub const ED25519_IDENTIFIER: [u8; 16] = [
-    0x65, 0x64, 0x32, 0x35, 0x35, 0x31, 0x39, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-];
-
 // Precomputed hash values used for all standard v1 addresses
 // a standard address has 1 ed25519 public key, requires 1 signature and has a timelock of 0
 // https://github.com/SiaFoundation/core/blob/b5b08cde6b7d0f1b3a6f09b8aa9d0b817e769efb/types/hash.go#L94
@@ -88,7 +85,7 @@ pub fn sigs_required_leaf(sigs_required: u64) -> H256 {
 pub fn public_key_leaf(pubkey: &PublicKey) -> H256 {
     let mut combined = Vec::new();
     combined.extend_from_slice(&LEAF_HASH_PREFIX);
-    combined.extend_from_slice(&ED25519_IDENTIFIER);
+    combined.extend_from_slice(Identifier::Ed25519.as_bytes());
     combined.extend_from_slice(&32u64.to_le_bytes());
     combined.extend_from_slice(pubkey.as_bytes());
     hash_blake2b_single(&combined)
@@ -281,17 +278,6 @@ fn test_hash_blake2b_pair() {
     assert_eq!(hash, expected)
 }
 
-#[test]
-fn test_create_ed25519_identifier() {
-    let mut ed25519_identifier: [u8; 16] = [0; 16];
-
-    let bytes = "ed25519".as_bytes();
-    for (i, &byte) in bytes.iter().enumerate() {
-        ed25519_identifier[i] = byte;
-    }
-    assert_eq!(ed25519_identifier, ED25519_IDENTIFIER);
-}
-
 #[test]
 fn test_timelock_leaf() {
     let hash = timelock_leaf(0);

mm2src/coins/sia/encoding.rs

@@ -8,6 +8,14 @@ pub struct Encoder {
     pub buffer: Vec<u8>,
 }
 
+pub trait Encodable {
+    fn encode(&self, encoder: &mut Encoder);
+}
+
+impl Encodable for H256 {
+    fn encode(&self, encoder: &mut Encoder) { encoder.write_slice(&self.0); }
+}
+
 impl Encoder {
     pub fn reset(&mut self) { self.buffer.clear(); }
 
@@ -28,6 +36,13 @@ impl Encoder {
     pub fn write_bool(&mut self, b: bool) { self.buffer.push(b as u8) }
 
     pub fn hash(&self) -> H256 { hash_blake2b_single(&self.buffer) }
+
+    // Utility method to create, encode, and hash
+    pub fn encode_and_hash<T: Encodable>(item: &T) -> H256 {
+        let mut encoder = Encoder::default();
+        item.encode(&mut encoder);
+        encoder.hash()
+    }
 }
 
 #[test]