create-sia-app 0.1.1

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

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "2"
+members = ["sia_sdk", "sia_derive", "indexd", "indexd_ffi", "indexd_wasm"]

package/template/rust/sia-sdk-rs/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 The Sia Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/template/rust/sia-sdk-rs/README.md

@@ -0,0 +1,30 @@
+# Sia Core RS
+
+This is a Rust implementation of core Sia types. It is intended to be used as a 
+library for projects that need to interact with Sia at a low level. It is not 
+intended to be a full Sia node implementation.
+
+This project is currently in the early stages of development and is not yet ready 
+for production use. The API will have breaking changes.
+
+## Features
+- [x] BIP-39 Seeds
+- [x] Addresses
+- [x] Sia binary encoding
+- [ ] Sector roots
+- [ ] Merkle proofs
+
+### v1
+- [x] Unlock conditions
+- [x] Transaction signing
+
+### v2
+- [x] Spend policies
+- [ ] Transaction signing
+- [ ] RHP4
+- [ ] State tree verification
+
+## License
+This project makes use of the `webpki-roots` crate which contains data from
+Common CA Database (CCADB) and is used under the CDLA-2.0-Permissive license.
+The remaining code in this project is licensed under the MIT License.

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

@@ -0,0 +1,79 @@
+## 0.2.0 (2026-01-28)
+
+### Breaking Changes
+
+- Added missing SDK functionality.
+- Changed download function to borrow the writer.
+- Implemented new `indexd` authentication.
+- Merge SlabSlice and Slab types.
+- Reduced size of signed urls by shortening query parameter names and using base64 URL encoding instead of hex.
+- Renamed `key` to `id` in object event and cursor.
+
+### Features
+
+- Add optional host filters (offset/limit/service-account/protocol/country) plus distance sort
+- Exposed `Hosts` struct to deduplicate host selection and performance tracking for scenarios that can not use the QUIC client.
+- Implement upload packing
+- Track RPC failure rate when selecting hosts rather than raw RPCs.
+- Update the insufficient shard check in download_slab_shards.
+
+### Fixes
+
+- Fix decoding failing when encrypted metadata is null or missing
+- Fixed an issue with uploads stalling after resuming on some platforms.
+- Fixed progress callback not being called immediately leading to incorrect reporting.
+- Fixed signing when URLs have port number.
+- Improved upload performance by 75%.
+- Make use of goodForUpload field
+- Refactor the uploader and downloader to be transport agnostic to make it easier to add regression testing and benchmarks.
+- Remove service account fields
+- Remove SlabFetcher now that we have the full slab info in the object.
+- Update object listing endpoints to use events
+
+## 0.1.2 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.1.1 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+
+### Fixes
+
+- Fix path dependency versions.
+
+## 0.1.0 (2025-10-04)
+
+### Breaking Changes
+
+- Publish to cargo
+
+### Features
+
+- Add JSON serialization to ChainState
+
+## 0.0.2 (2025-10-04)
+
+### Features
+
+- Add JSON serialization to ChainState
+- Add account API endpoint to app_client and FFI implementation.
+- Add objects API to SDK and app client.
+- Add pin_slab and unpin_slab to FFI.
+- Add progress callback.
+- Add slab pruning
+- Encrypt object metadata.
+- Remove separate range methods.
+- Use randomly generated encryption keys.
+- Validate object key when fetching objects from indexd.
+- Add method for pinning multiple slabs
+
+### Fixes
+
+- Make upload progress more responsive.
+- Swap out 'time' dependency for 'chrono'.
+- Use PublicKey for account key type.

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

@@ -0,0 +1,79 @@
+[package]
+name = "indexd"
+version = "0.2.0"
+edition = "2024"
+repository = "https://github.com/SiaFoundation/sia-sdk-rs"
+license = "MIT"
+description = "SDK for interacting with a Sia network indexer"
+authors = ["The Sia Foundation"]
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["sia", "decentralized", "blockchain", "depin", "storage"]
+
+[lib]
+name = "indexd"
+path = "src/lib.rs"
+crate-type = ["cdylib", "rlib"]  # cdylib for wasm-pack, rlib for normal use
+
+[dependencies]
+serde = "1.0.228"
+serde_json = "1.0.149"
+thiserror = "2.0.18"
+sia_sdk = { path = "../sia_sdk", version = "0.2.0" }
+rand = "0.10.0"
+blake2b_simd = "1.0.4"
+url = { version = "2.5.8", features = ["serde"] }
+log = "0.4.29"
+bytes = "1.11.1"
+tokio-util = { version = "0.7.18", features = ["rt"] }
+priority-queue = "2.7.0"
+serde_with = {version = "3.16.1", features = ["base64"]}
+hex = "0.4.3"
+chacha20poly1305 = "0.10.1"
+chrono = { version = "0.4.43", features = ["serde"] }
+blake2 = "0.10.6"
+hkdf = "0.12.4"
+base64 = "0.22.1"
+async-trait = "0.1.89"
+
+# Native-only dependencies
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio = { version = "1.49.0", features = ["fs", "sync", "io-util", "macros", "rt"] }
+# avoid rustls-platform-verifier until https://github.com/rustls/rustls-platform-verifier/issues/115 is resolved
+quinn = { version = "0.11.9", default-features = false, features = ["bloom", "log", "runtime-tokio", "rustls-ring"] }
+reqwest = { version = "0.12.28", default-features = false, features = ["charset", "http2", "json", "rustls-tls"] }
+rustls = { version = "0.23.36", default-features = false, features = ["ring", "logging", "std", "tls12"] }
+
+# WASM-only dependencies
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+tokio = { version = "1.49.0", features = ["sync", "io-util", "macros", "rt"] }
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = [
+    "WebTransport",
+    "WebTransportOptions",
+    "WebTransportBidirectionalStream",
+    "WebTransportReceiveStream",
+    "WebTransportSendStream",
+    "ReadableStream",
+    "ReadableStreamDefaultReader",
+    "WritableStream",
+    "WritableStreamDefaultWriter",
+] }
+getrandom_02 = { package = "getrandom", version = "0.2", features = ["js"] }
+getrandom = { version = "0.4", features = ["wasm_js"] }
+reqwest = { version = "0.12.28", default-features = false, features = ["json"] }
+
+[dev-dependencies]
+criterion = { version = "0.8.2", features = ["async_tokio"] }
+httptest = "0.16.4"
+rustls-platform-verifier = "0.6.2"
+tokio = { version = "1.49.0", features = ["macros"] }
+
+[features]
+mock = []
+
+[[bench]]
+name = "upload"
+harness = false
+required-features = ["mock"]

package/template/rust/sia-sdk-rs/indexd/benches/upload.rs

@@ -0,0 +1,258 @@
+use bytes::{Bytes, BytesMut};
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use indexd::mock::{MockDownloader, MockRHP4Client, MockUploader};
+use indexd::{DownloadOptions, Hosts, Object, UploadOptions};
+use rand::Rng;
+use sia::rhp::{Host, SECTOR_SIZE};
+use sia::signing::PrivateKey;
+use sia::types::v2::NetAddress;
+use std::io::Cursor;
+use std::sync::Arc;
+use tokio::io::{AsyncWrite, sink};
+use tokio::runtime;
+
+struct TtfbWriter {
+    start: std::time::Instant,
+    ttfb: Option<std::time::Duration>,
+}
+
+impl TtfbWriter {
+    fn new(start: std::time::Instant) -> Self {
+        Self { start, ttfb: None }
+    }
+
+    fn ttfb(&self) -> Option<std::time::Duration> {
+        self.ttfb
+    }
+}
+
+impl AsyncWrite for TtfbWriter {
+    fn poll_write(
+        mut self: std::pin::Pin<&mut Self>,
+        _: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        if self.ttfb.is_none() {
+            self.ttfb = Some(self.start.elapsed());
+        }
+        std::task::Poll::Ready(Ok(buf.len()))
+    }
+
+    fn poll_flush(
+        self: std::pin::Pin<&mut Self>,
+        _: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<std::io::Result<()>> {
+        std::task::Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(
+        self: std::pin::Pin<&mut Self>,
+        _: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<std::io::Result<()>> {
+        std::task::Poll::Ready(Ok(()))
+    }
+}
+
+async fn upload_object(uploader: Arc<MockUploader>, input: Bytes, opts: UploadOptions) -> Object {
+    let r = Cursor::new(input);
+    uploader.upload(r, opts).await.expect("upload failed")
+}
+
+fn upload_benchmark(c: &mut Criterion) {
+    let app_key = Arc::new(PrivateKey::from_seed(&rand::random()));
+    let transport = Arc::new(MockRHP4Client::new());
+    let hosts = Hosts::new();
+    hosts.update(
+        (0..90)
+            .map(|_| Host {
+                public_key: PrivateKey::from_seed(&rand::random()).public_key(),
+                addresses: vec![NetAddress {
+                    protocol: sia::types::v2::Protocol::QUIC,
+                    address: "localhost:1234".to_string(),
+                }],
+                country_code: "US".to_string(),
+                latitude: 0.0,
+                longitude: 0.0,
+                good_for_upload: true,
+            })
+            .collect(),
+    );
+
+    let uploader = Arc::new(MockUploader::new(
+        hosts.clone(),
+        transport.clone(),
+        app_key.clone(),
+    ));
+    let downloader = Arc::new(MockDownloader::new(
+        hosts.clone(),
+        transport.clone(),
+        app_key.clone(),
+    ));
+    let mut input = BytesMut::zeroed(SECTOR_SIZE * 30); // 3 full slabs
+    rand::rng().fill_bytes(&mut input);
+    let input = input.freeze();
+
+    let mut large_group = c.benchmark_group("120MiB");
+    large_group.throughput(Throughput::Bytes(input.len() as u64));
+
+    let runtime = runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .expect("failed to create global runtime");
+
+    // all shards in flight
+    large_group.bench_with_input(
+        BenchmarkId::new("upload", "90 inflight"),
+        &input,
+        |b, input| {
+            b.to_async(&runtime).iter(|| async {
+                upload_object(
+                    uploader.clone(),
+                    input.clone(),
+                    UploadOptions {
+                        max_inflight: 90,
+                        ..Default::default()
+                    },
+                )
+                .await;
+            });
+            transport.clear();
+        },
+    );
+
+    large_group.bench_with_input(
+        BenchmarkId::new("upload", "10 inflight"),
+        &input,
+        |b, input| {
+            b.to_async(&runtime).iter(|| async {
+                upload_object(
+                    uploader.clone(),
+                    input.clone(),
+                    UploadOptions {
+                        max_inflight: 10,
+                        ..Default::default()
+                    },
+                )
+                .await;
+            });
+            transport.clear();
+        },
+    );
+
+    large_group.bench_with_input(BenchmarkId::new("upload", "default"), &input, |b, input| {
+        b.to_async(&runtime).iter(|| async {
+            upload_object(uploader.clone(), input.clone(), UploadOptions::default()).await;
+        });
+        transport.clear();
+    });
+
+    let object = runtime.block_on(async {
+        upload_object(uploader.clone(), input.clone(), UploadOptions::default()).await
+    });
+
+    large_group.bench_with_input(
+        BenchmarkId::new("download", "30 inflight"),
+        &object,
+        |b, object| {
+            b.to_async(&runtime).iter(|| async {
+                downloader
+                    .download(
+                        &mut sink(),
+                        object,
+                        DownloadOptions {
+                            max_inflight: 30,
+                            ..Default::default()
+                        },
+                    )
+                    .await
+                    .expect("download to complete");
+            });
+        },
+    );
+
+    large_group.bench_with_input(
+        BenchmarkId::new("download", "10 inflight"),
+        &object,
+        |b, object| {
+            b.to_async(&runtime).iter(|| async {
+                downloader
+                    .download(
+                        &mut sink(),
+                        object,
+                        DownloadOptions {
+                            max_inflight: 10,
+                            ..Default::default()
+                        },
+                    )
+                    .await
+                    .expect("download to complete");
+            });
+        },
+    );
+
+    large_group.bench_with_input(
+        BenchmarkId::new("download", "default"),
+        &object,
+        |b, object| {
+            b.to_async(&runtime).iter(|| async {
+                downloader
+                    .download(&mut sink(), object, DownloadOptions::default())
+                    .await
+                    .expect("download to complete");
+            });
+        },
+    );
+
+    large_group.finish();
+
+    let mut ttfb_group = c.benchmark_group("ttfb");
+
+    ttfb_group.bench_function("120MiB", |b| {
+        b.to_async(&runtime).iter_custom(|iters| {
+            let downloader = downloader.clone();
+            let object = object.clone();
+            async move {
+                let mut total = std::time::Duration::ZERO;
+                for _ in 0..iters {
+                    let mut w = TtfbWriter::new(std::time::Instant::now());
+                    downloader
+                        .download(&mut w, &object, DownloadOptions::default())
+                        .await
+                        .expect("download to complete");
+                    total += w.ttfb().unwrap_or_else(|| w.start.elapsed());
+                }
+                total
+            }
+        });
+    });
+
+    ttfb_group.bench_function("64B", |b| {
+        b.to_async(&runtime).iter_custom(|iters| {
+            let downloader = downloader.clone();
+            let object = object.clone();
+            async move {
+                let mut total = std::time::Duration::ZERO;
+                for _ in 0..iters {
+                    let mut w = TtfbWriter::new(std::time::Instant::now());
+                    downloader
+                        .download(
+                            &mut w,
+                            &object,
+                            DownloadOptions {
+                                length: Some(64),
+                                ..Default::default()
+                            },
+                        )
+                        .await
+                        .expect("download to complete");
+                    total += w.ttfb().unwrap_or_else(|| w.start.elapsed());
+                }
+                total
+            }
+        });
+    });
+    ttfb_group.finish();
+}
+
+criterion_group!(benches, upload_benchmark);
+criterion_main!(benches);