create-sia-app 0.1.1

package/template/rust/sia-sdk-rs/knope.toml

@@ -0,0 +1,54 @@
+[packages.sia_sdk]
+versioned_files = [
+    "sia_sdk/Cargo.toml",
+    { path = "indexd/Cargo.toml", dependency = "sia_sdk" },
+    { path = "indexd_ffi/Cargo.toml", dependency = "sia_sdk" },
+    { path = "Cargo.lock", dependency = "sia_sdk" }
+]
+changelog = "sia_sdk/CHANGELOG.md"
+
+[packages.sia_sdk_derive]
+versioned_files = [
+    "sia_derive/Cargo.toml",
+    { path = "sia_sdk/Cargo.toml", dependency = "sia-sdk-derive" },
+    { path = "Cargo.lock", dependency = "sia-sdk-derive" }
+]
+changelog = "sia_derive/CHANGELOG.md"
+
+[packages.indexd]
+versioned_files = [
+    "indexd/Cargo.toml",
+    { path = "indexd_ffi/Cargo.toml", dependency = "indexd" },
+    { path = "Cargo.lock", dependency = "indexd" }
+]
+changelog = "indexd/CHANGELOG.md"
+
+[packages.indexd_ffi]
+versioned_files = [
+    "indexd_ffi/Cargo.toml",
+    { path = "Cargo.lock", dependency = "indexd_ffi" }
+]
+changelog = "indexd_ffi/CHANGELOG.md"
+
+[[workflows]]
+name = "document-change"
+
+[[workflows.steps]]
+type = "CreateChangeFile"
+
+[[workflows]]
+name = "prepare-release"
+ignore_conventional_commits = true
+
+[[workflows.steps]]
+type = "PrepareRelease"
+
+[[workflows]]
+name = "release"
+
+[[workflows.steps]]
+type = "Release"
+
+[github]
+owner = "SiaFoundation"
+repo = "sia-sdk-rs"

package/template/rust/sia-sdk-rs/sia_derive/CHANGELOG.md

@@ -0,0 +1,38 @@
+## 0.0.6 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.0.5 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.0.4 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.0.3 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+- Add account API endpoint to app_client and FFI implementation.
+- Add pin_slab and unpin_slab to FFI.
+- Added AsyncSiaEncodable and AsyncSiaDecodable traits.
+- Use randomly generated encryption keys.
+
+### Fixes
+
+- Swap out 'time' dependency for 'chrono'.
+- Use PublicKey for account key type.
+
+## 0.0.2 (2025-07-21)
+
+### Features
+
+- Add JSON serialization to ChainState

package/template/rust/sia-sdk-rs/sia_derive/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "sia-sdk-derive"
+version = "0.0.6"
+edition = "2024"
+repository = "https://github.com/SiaFoundation/sia-sdk-rs"
+license = "MIT"
+description = "Macro implementations for sia-sdk"
+authors = ["The Sia Foundation"]
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["sia", "decentralized", "blockchain", "depin", "storage"]
+
+[lib]
+proc-macro = true
+name = "sia_derive"
+
+[dependencies]
+syn = "2.0"
+quote = "1.0"
+proc-macro2 = "1.0"

package/template/rust/sia-sdk-rs/sia_derive/src/lib.rs

@@ -0,0 +1,278 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, parse_macro_input};
+
+#[proc_macro_derive(SiaEncode)]
+pub fn derive_sia_encode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let encode_impl = match &input.data {
+        Data::Struct(data) => {
+            let fields = match &data.fields {
+                Fields::Named(fields) => {
+                    let encodes = fields.named.iter().filter_map(|f| match f.vis {
+                        syn::Visibility::Public(_) => {
+                            let name = &f.ident;
+                            Some(quote! { self.#name.encode(w)?; })
+                        }
+                        _ => None,
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unnamed(fields) => {
+                    let encodes = fields.unnamed.iter().enumerate().map(|(i, _)| {
+                        let index = syn::Index::from(i);
+                        quote! { self.#index.encode(w)?; }
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unit => quote! {},
+            };
+            quote! {
+                #fields
+                Ok(())
+            }
+        }
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl SiaEncodable for #name {
+            fn encode<W: std::io::Write>(&self, w: &mut W) -> sia::encoding::Result<()> {
+                #encode_impl
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+#[proc_macro_derive(SiaDecode)]
+pub fn derive_sia_decode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let decode_impl = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => {
+                let decodes = fields.named.iter().filter_map(|f| match f.vis {
+                    syn::Visibility::Public(_) => {
+                        let name = &f.ident;
+                        let ty = &f.ty;
+                        Some(quote! { #name: <#ty>::decode(r)?, })
+                    }
+                    _ => None,
+                });
+                quote! {
+                    Ok(Self {
+                        #(#decodes)*
+                    })
+                }
+            }
+            Fields::Unnamed(fields) => {
+                let decodes = fields.unnamed.iter().map(|f| {
+                    let ty = &f.ty;
+                    quote! { <#ty>::decode(r)?, }
+                });
+                quote! {
+                    Ok(Self(#(#decodes)*))
+                }
+            }
+            Fields::Unit => quote! { Ok(Self) },
+        },
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl SiaDecodable for #name {
+            fn decode<R: std::io::Read>(r: &mut R) -> sia::encoding::Result<Self> {
+                #decode_impl
+            }
+        }
+    };
+    TokenStream::from(expanded)
+}
+
+#[proc_macro_derive(V1SiaEncode)]
+pub fn derive_v1_sia_encode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let encode_impl = match &input.data {
+        Data::Struct(data) => {
+            let fields = match &data.fields {
+                Fields::Named(fields) => {
+                    let encodes = fields.named.iter().map(|f| {
+                        let name = &f.ident;
+                        quote! { self.#name.encode_v1(enc)?; }
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unnamed(fields) => {
+                    let encodes = fields.unnamed.iter().enumerate().map(|(i, _)| {
+                        let index = syn::Index::from(i);
+                        quote! { self.#index.encode_v1(enc)?; }
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unit => quote! {},
+            };
+            quote! {
+                #fields
+                Ok(())
+            }
+        }
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl V1SiaEncodable for #name {
+            fn encode_v1<W: std::io::Write>(&self, enc: &mut W) -> crate::encoding::Result<()> {
+                #encode_impl
+            }
+        }
+    };
+    TokenStream::from(expanded)
+}
+
+#[proc_macro_derive(V1SiaDecode)]
+pub fn derive_v1_sia_decode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let decode_impl = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => {
+                let decodes = fields.named.iter().map(|f| {
+                    let name = &f.ident;
+                    let ty = &f.ty;
+                    quote! { #name: <#ty>::decode_v1(r)?, }
+                });
+                quote! {
+                    Ok(Self {
+                        #(#decodes)*
+                    })
+                }
+            }
+            Fields::Unnamed(fields) => {
+                let decodes = fields.unnamed.iter().map(|f| {
+                    let ty = &f.ty;
+                    quote! { <#ty>::decode_v1(r)?, }
+                });
+                quote! {
+                    Ok(Self(#(#decodes)*))
+                }
+            }
+            Fields::Unit => quote! { Ok(Self) },
+        },
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl V1SiaDecodable for #name {
+            fn decode_v1<R: std::io::Read>(r: &mut R) -> crate::encoding::Result<Self> {
+                #decode_impl
+            }
+        }
+    };
+    TokenStream::from(expanded)
+}
+
+#[proc_macro_derive(AsyncSiaEncode)]
+pub fn derive_async_sia_encode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let encode_impl = match &input.data {
+        Data::Struct(data) => {
+            let fields = match &data.fields {
+                Fields::Named(fields) => {
+                    let encodes = fields.named.iter().filter_map(|f| match f.vis {
+                        syn::Visibility::Public(_) => {
+                            let name = &f.ident;
+                            Some(quote! { self.#name.encode_async(e).await?; })
+                        }
+                        _ => None,
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unnamed(fields) => {
+                    let encodes = fields.unnamed.iter().enumerate().map(|(i, _)| {
+                        let index = syn::Index::from(i);
+                        quote! { self.#index.encode_async(e).await?; }
+                    });
+                    quote! { #(#encodes)* }
+                }
+                Fields::Unit => quote! {},
+            };
+            quote! {
+                #fields
+                Ok(())
+            }
+        }
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl AsyncSiaEncodable for #name {
+            async fn encode_async<E: crate::encoding_async::AsyncEncoder>(&self, e: &mut E) -> Result<(), E::Error> {
+                #encode_impl
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+#[proc_macro_derive(AsyncSiaDecode)]
+pub fn derive_async_sia_decode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let decode_impl = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => {
+                let decodes = fields.named.iter().filter_map(|f| match f.vis {
+                    syn::Visibility::Public(_) => {
+                        let name = &f.ident;
+                        let ty = &f.ty;
+                        Some(quote! { #name: <#ty>::decode_async(d).await?, })
+                    }
+                    _ => None,
+                });
+                quote! {
+                    Ok(Self {
+                        #(#decodes)*
+                    })
+                }
+            }
+            Fields::Unnamed(fields) => {
+                let decodes = fields.unnamed.iter().map(|f| {
+                    let ty = &f.ty;
+                    quote! { <#ty>::decode_async(d).await?, }
+                });
+                quote! {
+                    Ok(Self(#(#decodes)*))
+                }
+            }
+            Fields::Unit => quote! { Ok(Self) },
+        },
+        Data::Enum(_) => panic!("enums not supported"),
+        Data::Union(_) => panic!("unions not supported"),
+    };
+
+    let expanded = quote! {
+        impl AsyncSiaDecodable for #name {
+            async fn decode_async<D: crate::encoding_async::AsyncDecoder>(d: &mut D) -> Result<Self, D::Error> {
+                #decode_impl
+            }
+        }
+    };
+    TokenStream::from(expanded)
+}

package/template/rust/sia-sdk-rs/sia_sdk/CHANGELOG.md

@@ -0,0 +1,91 @@
+## 0.2.0 (2026-01-28)
+
+### Breaking Changes
+
+- Changes the Seed constructor to accept a mnemonic instead of raw entropy and adds `Seed::from_seed` to replace the old constructor.
+- Merge SlabSlice and Slab types.
+
+### Features
+
+- Added signature macro for testing.
+
+### Fixes
+
+- Fix release registry
+- Make use of goodForUpload field
+
+## 0.1.3 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+### Fixes
+
+- Fixed release workflow.
+
+## 0.1.2 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+### Fixes
+
+- Fix path dependency versions.
+
+## 0.1.1 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.1.0 (2025-10-04)
+
+### Breaking Changes
+
+- Change signing code to borrow.
+
+### Features
+
+- Add JSON serialization to ChainState
+- Add account API endpoint to app_client and FFI implementation.
+- Add generic support for reading and writing erasure-coded slabs.
+- Add method to generate object URLs.
+- Add object methods to FFI crate.
+- Add pin_slab and unpin_slab to FFI.
+- Add an SDK client that exposes an upload and download method.
+- Add slab downloader.
+- Add support for encrypting and decrypting shards.
+- Add support for ReedSolomon erasure coding.
+- Added AsyncSiaEncodable and AsyncSiaDecodable traits.
+- Added object uploading.
+- Added RHP4 request and response types.
+- Added RHP4 RPC usage and helpers.
+- Implement client-side encryption for quic uploads and downloads.
+- Support download range requests.
+- Use randomly generated encryption keys.
+- Verify proofs in RPCWriteSector and RPCReadSector.
+
+### Fixes
+
+- Add V2 host announcement support.
+- Fixed RPC write sector encoding.
+- Swap out 'time' dependency for 'chrono'.
+- Use PublicKey for account key type.
+
+## 0.0.2 (2025-07-21)
+
+### Features
+
+- Add JSON serialization to ChainState
+- Add ID derivation helpers to transactions, blocks, and siafund claims
+- v2 signing implemented
+
+#### Refactor V1 transaction signing
+
+Replaced `v1::Transaction::sign` with `v1::Transaction::whole_sig_hash` and `v1::Transaction::partial_sig_hash`. This change is primarily to provide a more consistent experience with `core` and the V2::Transaction API.
+
+### Fixes
+
+- Fix element accumulator encoding

package/template/rust/sia-sdk-rs/sia_sdk/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "sia_sdk"
+version = "0.2.0"
+edition = "2024"
+repository = "https://github.com/SiaFoundation/sia-sdk-rs"
+license = "MIT"
+description = "Low-level SDK for interacting with the Sia decentralized storage network"
+authors = ["The Sia Foundation"]
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["sia", "decentralized", "blockchain", "depin", "storage"]
+
+[lib]
+name = "sia"
+path = "src/lib.rs"
+
+[dependencies]
+base64 = "0.22.1"
+bip39 = "2.2.2"
+blake2 = "0.10.6"
+blake2b_simd = "1.0.4"
+bytes = "1.11.1"
+chacha20 = { version = "0.10.0", features = ["xchacha"] }
+chrono = { version = "0.4.43", features = ["serde"] }
+ed25519-dalek = "2.2.0"
+hex = "0.4.3"
+num-bigint = "0.4.6"
+num-rational = { version = "0.4.2", features = ["num-bigint"] }
+num-traits = "0.2.19"
+rayon = "1.11.0"
+reed-solomon-erasure = "6.0.0"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.149"
+sha2 = "0.10.9"
+sia-sdk-derive = { version = "0.0.6", path = "../sia_derive" }
+thiserror = "2.0.18"
+tokio = { version = "1.49.0", features = [
+    "macros",
+    "rt",
+    "sync",
+    "io-util",
+    "time",
+] }
+uint = "0.10.0"
+zeroize = { version = "1.8.1", features = ["zeroize_derive"] }
+
+[dev-dependencies]
+criterion = { version = "0.8", features = ["async_tokio"] }
+tokio = { version = "1.49.0", features = [
+    "macros",
+    "rt-multi-thread",
+    "sync",
+    "io-util",
+] }
+rustls-platform-verifier = "0.6.2"
+rand = "0.10.0"
+
+[[bench]]
+name = "merkle_root"
+harness = false

package/template/rust/sia-sdk-rs/sia_sdk/benches/merkle_root.rs

@@ -0,0 +1,12 @@
+use criterion::{Criterion, criterion_group, criterion_main};
+use std::hint::black_box;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let sector = [0u8; 1 << 22];
+    c.bench_function("sector_root", |b| {
+        b.iter(|| sia::rhp::sector_root(black_box(&sector)))
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

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

@@ -0,0 +1,22 @@
+use blake2::Blake2b;
+use blake2::digest::consts::U32;
+
+pub use blake2::digest::Digest;
+pub type Output = blake2::digest::Output<Blake2b256>;
+pub type Blake2b256 = Blake2b<U32>;
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    pub fn test_blake2b256() {
+        let mut hasher = Blake2b256::new();
+        hasher.update(b"hello, world!");
+        let result = hasher.finalize();
+        let expected =
+            hex::decode("480a927c7e3f9430f03141250f1def67380fec3943accb4575e568750a103638")
+                .unwrap();
+        assert_eq!(result.to_vec(), expected);
+    }
+}