create-sia-app 0.1.1

package/template/rust/sia-sdk-rs/sia_sdk/src/rhp/types.rs

@@ -0,0 +1,146 @@
+use crate::encoding::SiaEncodable;
+use crate::encoding_async::{AsyncSiaDecodable, AsyncSiaDecode, AsyncSiaEncodable, AsyncSiaEncode};
+use crate::types::v2::NetAddress;
+use blake2b_simd::Params;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::signing::{PrivateKey, PublicKey, Signature};
+use crate::types::{Address, Currency, Hash256};
+
+pub const SEGMENT_SIZE: usize = 64;
+pub const SECTOR_SIZE: usize = 1 << 22;
+pub const LEAVES_PER_SECTOR: usize = SECTOR_SIZE / SEGMENT_SIZE;
+
+/// Represents a host in the Sia network. The
+/// addresses can be used to connect to the host.
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Host {
+    pub public_key: PublicKey,
+    pub addresses: Vec<NetAddress>,
+    pub country_code: String,
+    pub latitude: f64,
+    pub longitude: f64,
+    pub good_for_upload: bool,
+}
+
+/// Contains the prices and parameters of a host.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, AsyncSiaEncode, AsyncSiaDecode)]
+#[serde(rename_all = "camelCase")]
+pub struct HostPrices {
+    /// The price of forming a new contract with the host.
+    pub contract_price: Currency,
+    /// The collateral per byte per block the host will
+    /// risk for stored data.
+    pub collateral: Currency,
+    /// The cost of storing a sector on the host per byte per block.
+    pub storage_price: Currency,
+    /// The cost of uploading data to the host per byte.
+    pub ingress_price: Currency,
+    /// The cost of downloading data from the host per byte.
+    pub egress_price: Currency,
+    /// The cost to remove a sector from a contract.
+    pub free_sector_price: Currency,
+    /// The current height of the host's blockchain.
+    pub tip_height: u64,
+    /// The time until which the prices are valid.
+    pub valid_until: DateTime<Utc>,
+
+    pub signature: Signature,
+}
+
+impl HostPrices {
+    /// Computes the signature hash for the host prices.
+    pub fn sig_hash(&self) -> Hash256 {
+        let mut state = Params::new().hash_length(32).to_state();
+        self.contract_price.encode(&mut state).unwrap();
+        self.collateral.encode(&mut state).unwrap();
+        self.storage_price.encode(&mut state).unwrap();
+        self.ingress_price.encode(&mut state).unwrap();
+        self.egress_price.encode(&mut state).unwrap();
+        self.free_sector_price.encode(&mut state).unwrap();
+        self.tip_height.encode(&mut state).unwrap();
+        self.valid_until.encode(&mut state).unwrap();
+        state.finalize().into()
+    }
+
+    /// Checks if the prices are valid for the given host key and timestamp.
+    pub fn is_valid(&self, host_key: &PublicKey, timestamp: DateTime<Utc>) -> bool {
+        self.valid_until > timestamp
+            && self.tip_height > 0
+            && host_key.verify(self.sig_hash().as_ref(), &self.signature)
+    }
+}
+
+/// Contains the settings of a host, including its prices and other parameters.
+#[derive(Debug, PartialEq, Serialize, Deserialize, AsyncSiaEncode, AsyncSiaDecode)]
+#[serde(rename_all = "camelCase")]
+pub struct HostSettings {
+    /// The version of the protocol the host is using.
+    pub protocol_version: [u8; 3],
+    /// The current release the host is running.
+    pub release: String,
+    /// The wallet address of the host to use for contract payments.
+    pub wallet_address: Address,
+    /// If the host is accepting new contracts.
+    pub accepting_contracts: bool,
+    /// The maximum amount of collateral that the host will accept for a
+    /// single contract.
+    pub max_collateral: Currency,
+    /// The maximum duration, in blocks, that the host will accept for a contract.
+    pub max_contract_duration: u64,
+    /// The amount of storage, in sectors, that the host has available.
+    pub remaining_storage: u64,
+    /// The total amount of storage, in sectors, that the host is offering.
+    pub total_storage: u64,
+    /// The current prices of the host
+    pub prices: HostPrices,
+}
+
+/// An account token is used to pay for RPC calls that do not
+/// require a contract.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, AsyncSiaEncode, AsyncSiaDecode)]
+#[serde(rename_all = "camelCase")]
+pub struct AccountToken {
+    pub host_key: PublicKey,
+    pub account: PublicKey,
+    pub valid_until: DateTime<Utc>,
+
+    pub signature: Signature,
+}
+
+impl AccountToken {
+    fn compute_sig_hash(
+        host_key: &PublicKey,
+        account: &PublicKey,
+        valid_until: &DateTime<Utc>,
+    ) -> Hash256 {
+        let mut state = Params::new().hash_length(32).to_state();
+        host_key.encode(&mut state).unwrap();
+        account.encode(&mut state).unwrap();
+        valid_until.encode(&mut state).unwrap();
+        state.finalize().into()
+    }
+
+    pub fn new(account_key: &PrivateKey, host_key: PublicKey) -> Self {
+        let expiration_time = chrono::Utc::now() + chrono::Duration::minutes(5);
+        let sig_hash =
+            Self::compute_sig_hash(&host_key, &account_key.public_key(), &expiration_time);
+        AccountToken {
+            host_key,
+            account: account_key.public_key(),
+            valid_until: expiration_time,
+
+            signature: account_key.sign(sig_hash.as_ref()),
+        }
+    }
+}
+
+/// An AccountDeposit is an amount of Siacoin to be deposited into an account.
+#[derive(Debug, PartialEq, Serialize, Deserialize, AsyncSiaEncode, AsyncSiaDecode)]
+#[serde(rename_all = "camelCase")]
+pub struct AccountDeposit {
+    pub account: PublicKey,
+    pub amount: Currency,
+}

package/template/rust/sia-sdk-rs/sia_sdk/src/rhp.rs

@@ -0,0 +1,7 @@
+mod merkle;
+mod rpc;
+mod types;
+
+pub use merkle::*;
+pub use rpc::*;
+pub use types::*;

package/template/rust/sia-sdk-rs/sia_sdk/src/seed.rs

@@ -0,0 +1,278 @@
+use std::fmt::Display;
+
+use crate::blake2::Blake2b256;
+use crate::signing::PrivateKey;
+use bip39::{Error as MnemonicError, Language, Mnemonic};
+use sha2::Digest;
+use thiserror::Error;
+use zeroize::ZeroizeOnDrop;
+
+#[derive(ZeroizeOnDrop)]
+pub struct Seed {
+    seed: [u8; 16],
+    entropy: [u8; 32],
+}
+
+#[derive(Debug, PartialEq, Error)]
+pub enum SeedError {
+    #[error("failed to parse recovery phrase")]
+    MnemonicError(#[from] MnemonicError),
+    #[error("invalid length of entropy, must be 16 bytes")]
+    InvalidLength,
+}
+
+impl Seed {
+    pub fn new(s: &str) -> Result<Self, SeedError> {
+        let m = Mnemonic::parse_in(Language::English, s)?;
+        let buf = m.to_entropy();
+        if buf.len() != 16 {
+            return Err(SeedError::InvalidLength);
+        }
+        let mut seed = [0u8; 16];
+        seed.copy_from_slice(&buf);
+        Ok(Self::from_seed(seed))
+    }
+
+    pub fn from_seed(seed: [u8; 16]) -> Self {
+        let mut h = Blake2b256::new();
+        h.update(seed);
+
+        let entropy: [u8; 32] = h.finalize().into();
+        Seed { seed, entropy }
+    }
+
+    pub fn entropy(&self) -> &[u8] {
+        &self.entropy
+    }
+
+    /// Derive a private key from the seed
+    pub fn private_key(&self, index: u64) -> PrivateKey {
+        let mut h = Blake2b256::new();
+        h.update(self.entropy());
+        h.update(index.to_le_bytes());
+        let hash: [u8; 32] = h.finalize().into();
+
+        PrivateKey::from_seed(&hash)
+    }
+}
+
+impl Display for Seed {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let m = Mnemonic::from_entropy(&self.seed).expect("invalid seed");
+        write!(f, "{}", m)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_seed_from_entropy() {
+        let test_cases = vec![
+            (
+                [
+                    23, 154, 249, 239, 129, 81, 216, 147, 144, 163, 207, 136, 238, 88, 11, 253,
+                ],
+                "bleak style know actor budget endorse dream ketchup material index actual wide",
+            ),
+            (
+                [
+                    125, 190, 141, 81, 70, 235, 204, 217, 162, 19, 65, 96, 237, 125, 157, 255,
+                ],
+                "laundry virtual february miss rubber holiday marriage habit genius hip guess yard",
+            ),
+            (
+                [
+                    56, 47, 30, 87, 122, 143, 19, 221, 189, 249, 105, 45, 161, 38, 172, 91,
+                ],
+                "deal jump noise vital van uphold wave coffee color ankle prison repeat",
+            ),
+            (
+                [
+                    68, 205, 7, 92, 32, 16, 228, 222, 144, 102, 94, 12, 179, 15, 67, 251,
+                ],
+                "dynamic habit strike dizzy atom hungry dose slim arrow observe special wash",
+            ),
+            (
+                [
+                    113, 45, 77, 233, 42, 222, 26, 5, 158, 171, 102, 114, 10, 7, 178, 19,
+                ],
+                "illness heavy kid fiber ticket actress kingdom holiday improve expand uncle chest",
+            ),
+            (
+                [
+                    189, 194, 141, 142, 240, 157, 147, 143, 61, 104, 167, 223, 33, 191, 95, 226,
+                ],
+                "saddle behave glove thrive summer shy volcano belt tennis assume subject series",
+            ),
+            (
+                [
+                    156, 21, 48, 230, 15, 181, 230, 46, 105, 106, 91, 163, 205, 77, 45, 150,
+                ],
+                "orchard praise define buyer fury blame pizza enter phrase heavy enter collect",
+            ),
+            (
+                [
+                    14, 38, 59, 189, 192, 248, 53, 60, 139, 36, 93, 58, 42, 156, 174, 238,
+                ],
+                "athlete crack urge limit local oxygen clutch merry demand female close talent",
+            ),
+            (
+                [
+                    141, 252, 20, 155, 232, 12, 56, 225, 252, 11, 92, 219, 9, 189, 23, 179,
+                ],
+                "mistake thing cheap source seminar ill usual high swallow evil echo grid",
+            ),
+            (
+                [
+                    25, 192, 89, 200, 149, 97, 136, 115, 38, 103, 19, 229, 88, 165, 62, 169,
+                ],
+                "border actress impulse client blush define office tiny torch share exile famous",
+            ),
+            (
+                [
+                    255, 43, 106, 70, 38, 84, 73, 72, 184, 0, 154, 228, 158, 156, 171, 32,
+                ],
+                "you forget muscle erosion duty picture theme battle tonight visual client double",
+            ),
+            (
+                [
+                    222, 237, 244, 22, 242, 80, 27, 122, 27, 91, 110, 101, 44, 200, 107, 151,
+                ],
+                "ten hurry aisle tool accuse rug hope horse gown green brain comfort",
+            ),
+            (
+                [
+                    96, 74, 173, 157, 208, 13, 130, 1, 168, 248, 254, 178, 92, 220, 59, 233,
+                ],
+                "gate fever guess parade subway absorb physical cabin rather tragic auction spread",
+            ),
+            (
+                [
+                    176, 115, 232, 168, 178, 206, 187, 177, 117, 105, 82, 1, 211, 62, 184, 132,
+                ],
+                "race palm clay grain two suffer stick clean achieve okay purchase anger",
+            ),
+            (
+                [
+                    162, 226, 161, 55, 247, 115, 251, 40, 6, 205, 151, 77, 203, 35, 63, 198,
+                ],
+                "pepper bench evil upon distance neglect brass real evidence flip soup mind",
+            ),
+            (
+                [
+                    199, 68, 177, 121, 94, 197, 135, 255, 140, 56, 181, 119, 99, 179, 124, 65,
+                ],
+                "shrug cereal furnace rural flash zone couch birth jazz budget tenant lock",
+            ),
+            (
+                [
+                    149, 139, 33, 29, 170, 228, 57, 90, 209, 219, 67, 202, 162, 198, 242, 138,
+                ],
+                "night flip electric fiction drum pulp electric half skirt bike royal benefit",
+            ),
+            (
+                [
+                    32, 138, 79, 90, 166, 241, 239, 197, 108, 63, 107, 211, 140, 3, 80, 129,
+                ],
+                "calm fame stove evil bus tired rail uniform squeeze gas stage acoustic",
+            ),
+            (
+                [
+                    231, 198, 66, 33, 240, 199, 105, 69, 236, 87, 87, 250, 128, 220, 227, 145,
+                ],
+                "treat craft mask thunder isolate pepper rally turtle whisper alone decline card",
+            ),
+            (
+                [
+                    130, 4, 98, 53, 124, 85, 66, 215, 112, 229, 188, 157, 95, 195, 49, 201,
+                ],
+                "link cart minute weather feature hill seminar resource outer wrap small narrow",
+            ),
+            (
+                [
+                    228, 84, 238, 177, 92, 231, 129, 253, 139, 4, 83, 68, 252, 160, 139, 22,
+                ],
+                "tone polar proof right job yard clown media eager topic carpet cluster",
+            ),
+            (
+                [
+                    227, 39, 94, 239, 75, 67, 63, 122, 188, 27, 58, 162, 126, 135, 55, 250,
+                ],
+                "tobacco depend rookie notable crop run vacant guard pen vintage social visual",
+            ),
+            (
+                [
+                    228, 96, 128, 106, 248, 223, 176, 232, 179, 247, 6, 219, 81, 173, 27, 141,
+                ],
+                "tongue advice boy vast wild inmate sound this swap miracle eight bottom",
+            ),
+            (
+                [
+                    204, 38, 228, 251, 95, 106, 131, 62, 103, 254, 162, 86, 97, 48, 254, 222,
+                ],
+                "slow damp disagree salute popular palace paper stairs filter another distance sadness",
+            ),
+        ];
+
+        for (entropy, expected) in test_cases {
+            let seed = Seed::from_seed(entropy);
+            assert_eq!(seed.to_string(), expected.to_string());
+        }
+    }
+
+    #[test]
+    fn test_seed_private_key() {
+        const PHRASE: &str =
+            "wealth salon venue abstract blossom hollow south over accuse bunker guide saddle";
+        let test_addresses = vec![
+			(0, hex::decode("e313a1aa2dbe411b5335ced5592e87cb002f47a874e27e9cb90eab285c675e366d29b52b7b312fb5e4f657afd0105d3d6dcc5c326131a033597501d25612789f").unwrap()),
+			(1, hex::decode("0a909bf1d36c876cb776b81e19c8b4a1351c644e329db3be07f6dfce59b75f4d3fa53cfea6763b07cc4202a0ba36574d99fa6ca3f807dbff2f2266c4d0a0a76d").unwrap()),
+			(2, hex::decode("866b40a6ee117ab8e65ee0772ca4e463e98edbf0793beae08a784745e7f10554294324450371bb263bc02c4536a04afa355ca490ef6481fd682dfd44bdb0f464").unwrap()),
+			(3, hex::decode("f713e2a9cc2415d7069d136c73dd3a67c5f2a63cc04f1106b980d6d6cd816f6bf710d69b256ae23f4b28d1f02f714fed04ea2c9268598835713eec36697bf179").unwrap()),
+			(4, hex::decode("433b5bf2c3ec44895af7299148ba38deaa7324c5146821fcef407708abc211bcb12b2a480977ffdc4c3801752b0e2bee06219311b7bdce80189be961f47d7ac9").unwrap()),
+			(5, hex::decode("48a4765ece4d7e6b12f4f8b20caaca4b2249654ada2b9d0d31d855517244b1ed8850f06b52e7ce6b5ea061ac6b69f3febb3fc96e58c590c975300fb20f317dcc").unwrap()),
+			(6, hex::decode("2de36d94f299ab39511e9eb3fe0cf5cc989b25e2943ca9c3a87ac592831791d76b0ee63d4be3b5296fe3961150b6bc3dd5f0acc56235fb8a62143a7eb73bdaa7").unwrap()),
+			(7, hex::decode("ecbd64189b9429583ad62173035cf3680238e5d90727220f55d466e88dc631b70299cbd2b777df0e62099f3f5f913692d022a3faabd461a2933754ec3aa35c21").unwrap()),
+			(8, hex::decode("5e836458fccb204dfe0e300c66ca2c47ad7efe9f835cda99d1a3cf22cf642634d53903b6ba22cf84adcae25f3d27d90323017ff793115b559df26fc0a4450cf4").unwrap()),
+			(9, hex::decode("9abd3e40d6d3b10d36966cec65861d7f08c6aa7f2d2845b0e9f10e15cc9e9f28eb63b79a7719c1a8323fe2d3da06d121ccbda1342d9f0913860f5e0817af1390").unwrap()),
+			(4294967295, hex::decode("71945cbc310c189f01fe8727a0060c007528aa0fd4812e4c5c7aa8b0e518906fc7dcf5e7623152e310ed440b8abf02e02fbead45553f13b3e8a7bea78a16d1b8").unwrap()),
+			(4294967296, hex::decode("41602321666c7ba93b05729208897ddf89940afdf02c38ebbd88f0a4906839232cd126afb5ccaef91ab77fcc27d076d94c5d152729bde3794bcd03226679889c").unwrap()),
+			(18446744073709551615, hex::decode("c03b2570cb69e300cd4ccbe0c4d8ee7b8ccfad7383f10aa2df52a4a9d05ab843d39fbd56458e94d711061748a051d434d2200e1af71df56070d2df0883453b2c").unwrap()),
+		];
+
+        let seed = Seed::new(PHRASE).unwrap();
+        for (i, expected) in test_addresses {
+            let pk = seed.private_key(i);
+            assert_eq!(pk.as_ref(), expected, "index {i}");
+        }
+    }
+
+    #[test]
+    fn test_seed_public_key() {
+        const PHRASE: &str =
+            "wealth salon venue abstract blossom hollow south over accuse bunker guide saddle";
+        let test_addresses = vec![
+			(0, hex::decode("e313a1aa2dbe411b5335ced5592e87cb002f47a874e27e9cb90eab285c675e366d29b52b7b312fb5e4f657afd0105d3d6dcc5c326131a033597501d25612789f").unwrap()),
+			(1, hex::decode("0a909bf1d36c876cb776b81e19c8b4a1351c644e329db3be07f6dfce59b75f4d3fa53cfea6763b07cc4202a0ba36574d99fa6ca3f807dbff2f2266c4d0a0a76d").unwrap()),
+			(2, hex::decode("866b40a6ee117ab8e65ee0772ca4e463e98edbf0793beae08a784745e7f10554294324450371bb263bc02c4536a04afa355ca490ef6481fd682dfd44bdb0f464").unwrap()),
+			(3, hex::decode("f713e2a9cc2415d7069d136c73dd3a67c5f2a63cc04f1106b980d6d6cd816f6bf710d69b256ae23f4b28d1f02f714fed04ea2c9268598835713eec36697bf179").unwrap()),
+			(4, hex::decode("433b5bf2c3ec44895af7299148ba38deaa7324c5146821fcef407708abc211bcb12b2a480977ffdc4c3801752b0e2bee06219311b7bdce80189be961f47d7ac9").unwrap()),
+			(5, hex::decode("48a4765ece4d7e6b12f4f8b20caaca4b2249654ada2b9d0d31d855517244b1ed8850f06b52e7ce6b5ea061ac6b69f3febb3fc96e58c590c975300fb20f317dcc").unwrap()),
+			(6, hex::decode("2de36d94f299ab39511e9eb3fe0cf5cc989b25e2943ca9c3a87ac592831791d76b0ee63d4be3b5296fe3961150b6bc3dd5f0acc56235fb8a62143a7eb73bdaa7").unwrap()),
+			(7, hex::decode("ecbd64189b9429583ad62173035cf3680238e5d90727220f55d466e88dc631b70299cbd2b777df0e62099f3f5f913692d022a3faabd461a2933754ec3aa35c21").unwrap()),
+			(8, hex::decode("5e836458fccb204dfe0e300c66ca2c47ad7efe9f835cda99d1a3cf22cf642634d53903b6ba22cf84adcae25f3d27d90323017ff793115b559df26fc0a4450cf4").unwrap()),
+			(9, hex::decode("9abd3e40d6d3b10d36966cec65861d7f08c6aa7f2d2845b0e9f10e15cc9e9f28eb63b79a7719c1a8323fe2d3da06d121ccbda1342d9f0913860f5e0817af1390").unwrap()),
+			(4294967295, hex::decode("71945cbc310c189f01fe8727a0060c007528aa0fd4812e4c5c7aa8b0e518906fc7dcf5e7623152e310ed440b8abf02e02fbead45553f13b3e8a7bea78a16d1b8").unwrap()),
+			(4294967296, hex::decode("41602321666c7ba93b05729208897ddf89940afdf02c38ebbd88f0a4906839232cd126afb5ccaef91ab77fcc27d076d94c5d152729bde3794bcd03226679889c").unwrap()),
+			(18446744073709551615, hex::decode("c03b2570cb69e300cd4ccbe0c4d8ee7b8ccfad7383f10aa2df52a4a9d05ab843d39fbd56458e94d711061748a051d434d2200e1af71df56070d2df0883453b2c").unwrap()),
+		];
+
+        let seed = Seed::new(PHRASE).unwrap();
+        for (i, expected) in test_addresses {
+            let pk = seed.private_key(i).public_key();
+            assert_eq!(pk.as_ref(), &expected[32..], "index {i}");
+        }
+    }
+}

package/template/rust/sia-sdk-rs/sia_sdk/src/signing.rs

@@ -0,0 +1,236 @@
+use core::fmt;
+
+use crate::encoding::{self, SiaDecodable, SiaDecode, SiaEncodable, SiaEncode};
+use crate::encoding_async::{AsyncSiaDecodable, AsyncSiaDecode, AsyncSiaEncodable, AsyncSiaEncode};
+use crate::types::{Hash256, HexParseError};
+use ed25519_dalek::{Signature as ED25519Signature, Signer, SigningKey, Verifier, VerifyingKey};
+use serde::de::Error;
+use serde::{Deserialize, Serialize};
+use zeroize::ZeroizeOnDrop;
+
+/// An ed25519 public key that can be used to verify a signature
+#[derive(
+    Debug, Eq, Hash, PartialEq, Clone, Copy, SiaEncode, SiaDecode, AsyncSiaDecode, AsyncSiaEncode,
+)]
+pub struct PublicKey([u8; 32]);
+
+impl PublicKey {
+    const PREFIX: &'static str = "ed25519:";
+}
+
+impl Serialize for PublicKey {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        String::serialize(&self.to_string(), serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for PublicKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let result = s.parse().map_err(|e| Error::custom(format!("{e:?}")))?;
+        Ok(result)
+    }
+}
+
+impl std::str::FromStr for PublicKey {
+    type Err = crate::types::HexParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s
+            .strip_prefix(Self::PREFIX)
+            .ok_or(HexParseError::MissingPrefix)?;
+        let mut pk = [0; 32];
+        hex::decode_to_slice(s, &mut pk)?;
+        Ok(Self::new(pk))
+    }
+}
+
+impl fmt::Display for PublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}{}", Self::PREFIX, hex::encode(self.0))
+    }
+}
+
+impl PublicKey {
+    pub const fn new(buf: [u8; 32]) -> Self {
+        PublicKey(buf)
+    }
+
+    /// verifies a message against the signature using this public key
+    pub fn verify(&self, msg: &[u8], signature: &Signature) -> bool {
+        let pk = VerifyingKey::from_bytes(&self.0).unwrap();
+        pk.verify(msg, &ED25519Signature::from_bytes(signature.as_ref()))
+            .is_ok()
+    }
+}
+
+impl From<PublicKey> for [u8; 32] {
+    fn from(val: PublicKey) -> Self {
+        val.0
+    }
+}
+
+impl AsRef<[u8]> for PublicKey {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// An ed25519 private key that can be used to sign a hash
+#[derive(Debug, PartialEq, Clone, ZeroizeOnDrop)]
+pub struct PrivateKey([u8; 64]);
+
+impl PrivateKey {
+    pub fn from_seed(seed: &[u8; 32]) -> Self {
+        let sk = SigningKey::from_bytes(seed);
+        PrivateKey(sk.to_keypair_bytes())
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        let mut buf = [0u8; 32];
+        buf.copy_from_slice(&self.0[32..]);
+        PublicKey::new(buf)
+    }
+
+    pub fn sign(&self, h: &[u8]) -> Signature {
+        let sk = SigningKey::from_bytes(&self.0[..32].try_into().unwrap());
+        Signature::new(sk.sign(h).to_bytes())
+    }
+}
+
+impl AsRef<[u8]> for PrivateKey {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl From<[u8; 64]> for PrivateKey {
+    fn from(key: [u8; 64]) -> Self {
+        PrivateKey(key)
+    }
+}
+
+impl From<Hash256> for PrivateKey {
+    fn from(hash: Hash256) -> Self {
+        PrivateKey::from_seed(hash.as_ref())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, SiaEncode, SiaDecode, AsyncSiaEncode, AsyncSiaDecode)]
+pub struct Signature([u8; 64]);
+
+impl Serialize for Signature {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        String::serialize(&hex::encode(self.0), serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for Signature {
+    fn deserialize<D>(deserializer: D) -> Result<Signature, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let buf = hex::decode(String::deserialize(deserializer)?)
+            .map_err(|e| D::Error::custom(format!("{e:?}")))?;
+        if buf.len() != 64 {
+            return Err(D::Error::custom("Invalid signature length"));
+        }
+        Ok(Signature(buf.try_into().unwrap()))
+    }
+}
+
+impl Signature {
+    pub const fn new(sig: [u8; 64]) -> Self {
+        Signature(sig)
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Default for Signature {
+    fn default() -> Self {
+        Signature([0; 64])
+    }
+}
+
+impl AsRef<[u8; 64]> for Signature {
+    fn as_ref(&self) -> &[u8; 64] {
+        &self.0
+    }
+}
+
+impl From<[u8; 64]> for Signature {
+    fn from(buf: [u8; 64]) -> Self {
+        Signature(buf)
+    }
+}
+
+impl std::str::FromStr for Signature {
+    type Err = crate::types::HexParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let data = hex::decode(s).map_err(HexParseError::HexError)?;
+        if data.len() != 64 {
+            return Err(HexParseError::InvalidLength(data.len()));
+        }
+
+        let mut sig = [0u8; 64];
+        sig.copy_from_slice(&data);
+        Ok(Signature(sig))
+    }
+}
+
+/// Converts a slice of bytes into a Signature.
+/// # Errors
+/// Returns an error if the slice is not exactly 64 bytes long.
+impl TryFrom<&[u8]> for Signature {
+    type Error = encoding::Error;
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if value.len() != 64 {
+            return Err(encoding::Error::InvalidLength(value.len()));
+        }
+        let mut sig = [0u8; 64];
+        sig.copy_from_slice(value);
+        Ok(Signature(sig))
+    }
+}
+
+impl fmt::Display for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", hex::encode(self.0))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_serialize_publickey() {
+        let public_key_str = "9aac1ffb1cfd1079a8c6c87b47da1d567e35b97234993c288c1ad0db1d1ce1b6";
+        let public_key = PublicKey::new(hex::decode(public_key_str).unwrap().try_into().unwrap());
+
+        // binary
+        let mut public_key_serialized = Vec::new();
+        public_key.encode(&mut public_key_serialized).unwrap();
+        assert_eq!(public_key_serialized, hex::decode(public_key_str).unwrap());
+        let public_key_deserialized =
+            PublicKey::decode(&mut public_key_serialized.as_slice()).unwrap();
+        assert_eq!(public_key_deserialized, public_key);
+
+        // json
+        let public_key_serialized = serde_json::to_string(&public_key).unwrap();
+        let public_key_deserialized: PublicKey =
+            serde_json::from_str(&public_key_serialized).unwrap();
+        assert_eq!(
+            public_key_serialized,
+            format!("\"ed25519:{public_key_str}\"")
+        );
+        assert_eq!(public_key_deserialized, public_key);
+    }
+}