use wasm_bindgen::prelude::*;
pub mod async_api;
pub mod peer_state;
pub mod storage;
pub mod webrtc;
#[cfg(target_arch = "wasm32")]
pub use webrtc::{IpfrsPeer, IpfrsPeerAnswerer};
#[wasm_bindgen(start)]
pub fn start() {
#[cfg(feature = "console_error_panic_hook")]
console_error_panic_hook::set_once();
}
fn cid_from_bytes(data: &[u8]) -> String {
use sha2::Digest;
let digest: [u8; 32] = sha2::Sha256::digest(data).into();
let mut multihash = Vec::with_capacity(34);
multihash.push(0x12u8); multihash.push(0x20u8); multihash.extend_from_slice(&digest);
let mut cid_bytes = Vec::with_capacity(36);
cid_bytes.push(0x01u8); cid_bytes.push(0x55u8); cid_bytes.extend_from_slice(&multihash);
let encoded = base32_lower(&cid_bytes);
format!("b{encoded}")
}
fn base32_lower(input: &[u8]) -> String {
const ALPHABET: &[u8] = b"abcdefghijklmnopqrstuvwxyz234567";
let mut output = Vec::with_capacity((input.len() * 8).div_ceil(5));
let mut buffer: u64 = 0;
let mut bits_left: u32 = 0;
for &byte in input {
buffer = (buffer << 8) | u64::from(byte);
bits_left += 8;
while bits_left >= 5 {
bits_left -= 5;
let idx = ((buffer >> bits_left) & 0x1f) as usize;
output.push(ALPHABET[idx]);
}
}
if bits_left > 0 {
let idx = ((buffer << (5 - bits_left)) & 0x1f) as usize;
output.push(ALPHABET[idx]);
}
String::from_utf8(output).unwrap_or_default()
}
struct InMemoryStore {
blocks: std::collections::HashMap<String, Vec<u8>>,
total_bytes: usize,
}
impl InMemoryStore {
fn new() -> Self {
Self {
blocks: std::collections::HashMap::new(),
total_bytes: 0,
}
}
fn put(&mut self, data: &[u8]) -> String {
let cid = cid_from_bytes(data);
self.blocks.entry(cid.clone()).or_insert_with(|| {
self.total_bytes += data.len();
data.to_vec()
});
cid
}
fn get(&self, cid: &str) -> Option<&Vec<u8>> {
self.blocks.get(cid)
}
fn has(&self, cid: &str) -> bool {
self.blocks.contains_key(cid)
}
fn delete(&mut self, cid: &str) -> bool {
if let Some(data) = self.blocks.remove(cid) {
self.total_bytes = self.total_bytes.saturating_sub(data.len());
true
} else {
false
}
}
fn list(&self) -> Vec<String> {
self.blocks.keys().cloned().collect()
}
fn total_bytes(&self) -> usize {
self.total_bytes
}
fn len(&self) -> usize {
self.blocks.len()
}
}
#[wasm_bindgen]
pub struct IpfrsClient {
store: InMemoryStore,
}
#[wasm_bindgen]
impl IpfrsClient {
#[wasm_bindgen(constructor)]
pub fn new() -> IpfrsClient {
IpfrsClient {
store: InMemoryStore::new(),
}
}
pub async fn add(&mut self, data: &[u8]) -> Result<String, JsValue> {
if data.is_empty() {
return Err(JsValue::from_str("data must not be empty"));
}
Ok(self.store.put(data))
}
pub async fn get(&self, cid: &str) -> Result<Vec<u8>, JsValue> {
self.store
.get(cid)
.cloned()
.ok_or_else(|| JsValue::from_str(&format!("CID not found: {cid}")))
}
pub fn has(&self, cid: &str) -> bool {
self.store.has(cid)
}
#[wasm_bindgen(js_name = listCids)]
pub fn list_cids(&self) -> Vec<String> {
self.store.list()
}
pub fn stats(&self) -> String {
format!(
r#"{{"block_count":{block_count},"total_bytes":{total_bytes}}}"#,
block_count = self.store.len(),
total_bytes = self.store.total_bytes(),
)
}
pub fn delete(&mut self, cid: &str) -> bool {
self.store.delete(cid)
}
}
impl Default for IpfrsClient {
fn default() -> Self {
Self::new()
}
}
#[wasm_bindgen]
pub fn compute_cid(data: &[u8]) -> String {
cid_from_bytes(data)
}
#[wasm_bindgen]
pub fn version() -> String {
"ipfrs-wasm 0.2.0".to_string()
}
#[wasm_bindgen]
pub fn verify_cid(cid: &str, data: &[u8]) -> bool {
cid_from_bytes(data) == cid
}
#[wasm_bindgen]
pub async fn add_bytes(data: &[u8]) -> Result<String, JsValue> {
if data.is_empty() {
return Err(JsValue::from_str("data must not be empty"));
}
Ok(cid_from_bytes(data))
}
#[wasm_bindgen]
pub async fn get_bytes(client: &IpfrsClient, cid: &str) -> Result<Option<Vec<u8>>, JsValue> {
Ok(client.store.get(cid).cloned())
}
#[cfg(target_arch = "wasm32")]
pub mod indexed_db {
use super::cid_from_bytes;
use js_sys::{Array, Uint8Array};
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::JsFuture;
use web_sys::{IdbDatabase, IdbOpenDbRequest, IdbTransactionMode};
const STORE_NAME: &str = "blocks";
async fn open_db(db_name: &str) -> Result<IdbDatabase, JsValue> {
let window = web_sys::window()
.ok_or_else(|| JsValue::from_str("no global window — are you in a browser?"))?;
let idb_factory = window
.indexed_db()?
.ok_or_else(|| JsValue::from_str("IndexedDB is not available in this browser"))?;
let open_req: IdbOpenDbRequest = idb_factory.open_with_u32(db_name, 1)?;
let on_upgrade = Closure::<dyn FnMut(web_sys::Event)>::new({
let req = open_req.clone();
move |_event: web_sys::Event| {
let db: IdbDatabase = req
.result()
.expect("IdbOpenDbRequest.result() inside onupgradeneeded")
.dyn_into()
.expect("result is IdbDatabase");
let store_names: Array = db.object_store_names().into();
let already_exists = (0..store_names.length())
.any(|i| store_names.get(i).as_string().as_deref() == Some(STORE_NAME));
if !already_exists {
db.create_object_store(STORE_NAME)
.expect("create_object_store failed");
}
}
});
open_req.set_onupgradeneeded(Some(on_upgrade.as_ref().unchecked_ref()));
on_upgrade.forget();
let db_value: JsValue = JsFuture::from(open_req).await?;
let db: IdbDatabase = db_value
.dyn_into()
.map_err(|_| JsValue::from_str("IdbOpenDbRequest result was not an IdbDatabase"))?;
Ok(db)
}
#[wasm_bindgen]
pub struct IndexedDbStore {
db_name: String,
}
#[wasm_bindgen]
impl IndexedDbStore {
#[wasm_bindgen]
pub async fn open(db_name: &str) -> Result<IndexedDbStore, JsValue> {
let _db = open_db(db_name).await?;
Ok(IndexedDbStore {
db_name: db_name.to_string(),
})
}
pub async fn put(&self, data: &[u8]) -> Result<String, JsValue> {
if data.is_empty() {
return Err(JsValue::from_str("data must not be empty"));
}
let cid = cid_from_bytes(data);
let db = open_db(&self.db_name).await?;
let tx = db.transaction_with_str_and_mode(STORE_NAME, IdbTransactionMode::Readwrite)?;
let store = tx.object_store(STORE_NAME)?;
let js_data = Uint8Array::from(data);
let cid_key = JsValue::from_str(&cid);
let put_req = store.put_with_key(&js_data, &cid_key)?;
JsFuture::from(put_req).await?;
Ok(cid)
}
pub async fn get(&self, cid: &str) -> Result<Option<Vec<u8>>, JsValue> {
let db = open_db(&self.db_name).await?;
let tx = db.transaction_with_str_and_mode(STORE_NAME, IdbTransactionMode::Readonly)?;
let store = tx.object_store(STORE_NAME)?;
let key = JsValue::from_str(cid);
let get_req = store.get(&key)?;
let result: JsValue = JsFuture::from(get_req).await?;
if result.is_undefined() || result.is_null() {
return Ok(None);
}
let arr: Uint8Array = result
.dyn_into()
.map_err(|_| JsValue::from_str("stored value is not a Uint8Array"))?;
Ok(Some(arr.to_vec()))
}
pub async fn has(&self, cid: &str) -> Result<bool, JsValue> {
Ok(self.get(cid).await?.is_some())
}
pub async fn delete(&self, cid: &str) -> Result<bool, JsValue> {
let existed = self.has(cid).await?;
if !existed {
return Ok(false);
}
let db = open_db(&self.db_name).await?;
let tx = db.transaction_with_str_and_mode(STORE_NAME, IdbTransactionMode::Readwrite)?;
let store = tx.object_store(STORE_NAME)?;
let key = JsValue::from_str(cid);
let del_req = store.delete(&key)?;
JsFuture::from(del_req).await?;
Ok(true)
}
pub async fn count(&self) -> Result<u32, JsValue> {
let db = open_db(&self.db_name).await?;
let tx = db.transaction_with_str_and_mode(STORE_NAME, IdbTransactionMode::Readonly)?;
let store = tx.object_store(STORE_NAME)?;
let count_req = store.count()?;
let result: JsValue = JsFuture::from(count_req).await?;
result
.as_f64()
.map(|n| n as u32)
.ok_or_else(|| JsValue::from_str("count() did not return a number"))
}
}
}
#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
pub struct IpfrsClientPersistent {
db_name: String,
}
#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
impl IpfrsClientPersistent {
#[wasm_bindgen(constructor)]
pub async fn new(db_name: &str) -> Result<IpfrsClientPersistent, JsValue> {
indexed_db::IndexedDbStore::open(db_name).await?;
Ok(IpfrsClientPersistent {
db_name: db_name.to_string(),
})
}
pub async fn add(&self, data: &[u8]) -> Result<String, JsValue> {
let store = indexed_db::IndexedDbStore::open(&self.db_name).await?;
store.put(data).await
}
pub async fn get(&self, cid: &str) -> Result<Option<Vec<u8>>, JsValue> {
let store = indexed_db::IndexedDbStore::open(&self.db_name).await?;
store.get(cid).await
}
pub async fn has(&self, cid: &str) -> Result<bool, JsValue> {
let store = indexed_db::IndexedDbStore::open(&self.db_name).await?;
store.has(cid).await
}
pub async fn delete(&self, cid: &str) -> Result<bool, JsValue> {
let store = indexed_db::IndexedDbStore::open(&self.db_name).await?;
store.delete(cid).await
}
pub async fn count(&self) -> Result<u32, JsValue> {
let store = indexed_db::IndexedDbStore::open(&self.db_name).await?;
store.count().await
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::*;
#[test]
fn test_in_memory_store_roundtrip() {
let mut store = InMemoryStore::new();
let data = b"hello wasm";
let cid = store.put(data);
assert!(store.has(&cid));
assert_eq!(store.get(&cid), Some(&data.to_vec()));
}
#[test]
fn test_in_memory_delete() {
let mut store = InMemoryStore::new();
let cid = store.put(b"delete me");
assert!(store.has(&cid));
assert!(store.delete(&cid));
assert!(!store.has(&cid));
assert!(!store.delete(&cid));
}
#[test]
fn test_cid_deterministic() {
let mut store = InMemoryStore::new();
let cid1 = store.put(b"same data");
let cid2 = store.put(b"same data");
assert_eq!(cid1, cid2, "same content must produce same CID");
assert_eq!(store.len(), 1);
}
#[test]
fn test_different_data_different_cid() {
let mut store = InMemoryStore::new();
let cid1 = store.put(b"alpha");
let cid2 = store.put(b"beta");
assert_ne!(cid1, cid2);
assert_eq!(store.len(), 2);
}
#[test]
fn test_total_bytes_accounting() {
let mut store = InMemoryStore::new();
store.put(b"abc"); store.put(b"defgh"); assert_eq!(store.total_bytes(), 8);
store.put(b"abc");
assert_eq!(store.total_bytes(), 8);
}
#[test]
fn test_total_bytes_after_delete() {
let mut store = InMemoryStore::new();
let cid = store.put(b"hello"); assert_eq!(store.total_bytes(), 5);
store.delete(&cid);
assert_eq!(store.total_bytes(), 0);
}
#[test]
fn test_list_cids() {
let mut store = InMemoryStore::new();
let c1 = store.put(b"one");
let c2 = store.put(b"two");
let mut listed = store.list();
listed.sort();
let mut expected = vec![c1, c2];
expected.sort();
assert_eq!(listed, expected);
}
#[test]
fn test_compute_cid_function() {
let cid = compute_cid(b"ipfrs wasm");
assert!(!cid.is_empty());
assert!(cid.starts_with('b'), "CID must start with 'b': {cid}");
}
#[test]
fn test_compute_cid_deterministic() {
assert_eq!(compute_cid(b"same"), compute_cid(b"same"));
assert_ne!(compute_cid(b"a"), compute_cid(b"b"));
}
#[test]
fn test_verify_cid() {
let data = b"verify me";
let cid = compute_cid(data);
assert!(verify_cid(&cid, data));
assert!(!verify_cid(&cid, b"different data"));
assert!(!verify_cid("bnotacid", data));
}
#[test]
fn test_store_stats() {
let mut store = InMemoryStore::new();
store.put(b"stats test data");
let stats_json = format!(
r#"{{"block_count":{block_count},"total_bytes":{total_bytes}}}"#,
block_count = store.len(),
total_bytes = store.total_bytes(),
);
assert!(stats_json.contains("\"block_count\":1"));
assert!(stats_json.contains("\"total_bytes\":15"));
}
#[test]
fn test_client_has_and_delete() {
let mut client = IpfrsClient::new();
let cid = client.store.put(b"hello client");
assert!(client.has(&cid));
assert!(client.delete(&cid));
assert!(!client.has(&cid));
}
#[test]
fn test_client_list_cids() {
let mut client = IpfrsClient::new();
client.store.put(b"item1");
client.store.put(b"item2");
assert_eq!(client.list_cids().len(), 2);
}
#[test]
fn test_client_stats_json() {
let mut client = IpfrsClient::new();
client.store.put(b"stat");
let stats = client.stats();
assert!(stats.contains("block_count"));
assert!(stats.contains("total_bytes"));
}
#[test]
fn test_version() {
let v = version();
assert!(v.contains("ipfrs-wasm"));
assert!(v.contains("0.2.0"));
}
#[test]
fn test_cid_starts_with_b() {
for payload in [b"a".as_ref(), b"hello world", b"\x00\xff\xfe"] {
let cid = cid_from_bytes(payload);
assert!(cid.starts_with('b'), "unexpected CID: {cid}");
}
}
#[test]
fn test_known_cid_vector() {
use sha2::Digest;
let data = b"Hello World";
let digest: [u8; 32] = sha2::Sha256::digest(data).into();
let expected_hex = "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e";
assert_eq!(hex::encode(digest), expected_hex);
let cid = cid_from_bytes(data);
assert!(cid.starts_with('b'));
assert!(!cid.is_empty());
}
#[test]
fn test_package_metadata() {
let pkg_json = include_str!("../pkg/package.json");
let parsed: serde_json::Value =
serde_json::from_str(pkg_json).expect("pkg/package.json must be valid JSON");
assert_eq!(parsed["name"], "@cool-japan/ipfrs");
assert_eq!(parsed["version"], "0.2.0");
assert_eq!(parsed["license"], "Apache-2.0");
let files = parsed["files"].as_array().expect("files must be an array");
let file_names: Vec<&str> = files.iter().filter_map(|v| v.as_str()).collect();
assert!(
file_names.contains(&"ipfrs_wasm.js"),
"ipfrs_wasm.js missing from files"
);
assert!(
file_names.contains(&"ipfrs_wasm_bg.wasm"),
"ipfrs_wasm_bg.wasm missing from files"
);
}
#[test]
fn test_compute_cid_stable() {
let cid = compute_cid(b"ipfrs stable vector");
assert!(cid.starts_with('b'), "CID must start with multibase 'b'");
let expected = cid_from_bytes(b"ipfrs stable vector");
assert_eq!(cid, expected);
}
}