community: shared playlists, a signed revision and a pointer on the network, a reference over soulseek, an import through the normal door

src-tauri/src/commands.rs

@@ -930,6 +930,7 @@ pub async fn connect_and_login(
                     // never reach the Inbox (slsk_link.rs).
                     if crate::slsk_link::intercept_pm(&event_app, &username, &message).await
                         || crate::friends::intercept_pm(&event_app, &username, &message)
+                        || crate::shared_playlists::intercept_pm(&event_app, &username, &message)
                     {
                         continue;
                     }

src-tauri/src/lib.rs

@@ -21,6 +21,7 @@ mod playlists;
 mod provider_playlist;
 mod preview;
 mod setlist_scan;
+mod shared_playlists;
 mod shazam;
 mod slsk_link;
 mod smtc;
@@ -136,6 +137,14 @@ pub fn run() {
             friends::friend_decline,
             friends::friend_remove,
             friends::friend_forget,
+            shared_playlists::shared_playlists_mine,
+            shared_playlists::shared_playlist_publish,
+            shared_playlists::shared_playlist_withdraw,
+            shared_playlists::shared_playlist_fetch,
+            shared_playlists::shared_playlist_import,
+            shared_playlists::share_send,
+            shared_playlists::shares_inbox,
+            shared_playlists::share_dismiss,
             commands::buddy_list,
             commands::buddy_add,
             commands::buddy_remove,

src-tauri/src/shared_playlists.rs

@@ -0,0 +1,554 @@
+//! Shared playlists (F3 → the app): a playlist is published as an
+//! immutable, content-addressed REVISION (the portable manifest — entry
+//! occurrences with display fallbacks, never a path) plus an owner-signed
+//! POINTER to the current revision per (owner, playlist uuid). Editing
+//! publishes a new revision and bumps the pointer; withdrawing bumps the
+//! pointer to "none", and the truthful line stays: published revisions
+//! remain fetchable, nothing on the network is erased.
+//!
+//! Both contract wasms are bundled commitments like the persona ones
+//! (`assets/playlist_revision_contract.wasm`, `assets/playlist_pointer_
+//! contract.wasm`, from research/freenet-f3; code hashes pinned by tests).
+//!
+//! Sharing WITH someone sends an address, nothing else — `SSSHARE1?<ref>`
+//! over the same Soulseek PM channel the link proof and friends use. The
+//! recipient sees a card, fetches the manifest through their own node,
+//! verifies it against the owner's key, and imports it through the app's
+//! normal playlist-import path (the review resolves tracks against their
+//! library and the catalog, and unowned rows become Soulseek streams).
+
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use freenet_adapter::FreenetAdapter;
+use persona_state as ps;
+use persona_state::playlist as pl;
+use persona_state::slsk_link::normalize_username;
+use serde::{Deserialize, Serialize};
+use tauri::{Emitter, Manager, State};
+
+use crate::persona;
+use crate::pipeline::LibraryState;
+use crate::playlist_formats::{ParsedEntry, ParsedPlaylist};
+use crate::playlists::{self, ImportDraft};
+use crate::state::AppState;
+
+const REV_WASM: &[u8] = include_bytes!("../assets/playlist_revision_contract.wasm");
+const PTR_WASM: &[u8] = include_bytes!("../assets/playlist_pointer_contract.wasm");
+const SHARE_PREFIX: &str = "SSSHARE1?";
+pub const EVENT: &str = "community:shares";
+
+/// A playlist this device has published, by local playlist id.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Published {
+    pub playlist_id: i64,
+    pub uuid: String,
+    pub revision_seq: u64,
+    pub pointer_seq: u64,
+    /// The current revision's content hash (b58); stays after a withdraw so
+    /// the next publication still links to its predecessor.
+    pub current_hash: Option<String>,
+    pub name: String,
+    pub entry_count: u32,
+    pub withdrawn: bool,
+    pub published_at: u64,
+}
+
+/// A reference someone sent us: an address, plus what they said it was.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ShareCard {
+    pub id: String,
+    pub from_username: String,
+    pub owner_key: String,
+    pub playlist_uuid: String,
+    pub name: String,
+    pub entry_count: u32,
+    pub received_at: u64,
+}
+
+#[derive(Default, Serialize, Deserialize)]
+struct Ledger {
+    #[serde(default)]
+    published: BTreeMap<String, Published>,
+    #[serde(default)]
+    inbox: Vec<ShareCard>,
+}
+
+/// What travels in a share: the address and a display hint.
+#[derive(Serialize, Deserialize)]
+struct ShareRef {
+    owner: [u8; 32],
+    playlist_uuid: [u8; 16],
+    name: String,
+    entry_count: u32,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ShareEntry {
+    pub position: u32,
+    pub title: String,
+    pub artist: String,
+    pub album: String,
+    pub duration_secs: Option<u32>,
+    pub note: Option<String>,
+}
+
+/// A fetched, VERIFIED shared playlist as the reader sees it.
+#[derive(Debug, Serialize)]
+pub struct ShareView {
+    pub owner_key: String,
+    pub playlist_uuid: String,
+    pub name: String,
+    pub description: String,
+    pub revision_seq: u64,
+    pub content_hash: String,
+    pub withdrawn: bool,
+    pub entries: Vec<ShareEntry>,
+}
+
+fn now_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+fn rand16() -> [u8; 16] {
+    use rand::RngCore;
+    let mut n = [0u8; 16];
+    rand::thread_rng().fill_bytes(&mut n);
+    n
+}
+fn b58(bytes: &[u8]) -> String {
+    bs58::encode(bytes).into_string()
+}
+fn bytes32(b58s: &str) -> Result<[u8; 32], String> {
+    bs58::decode(b58s)
+        .into_vec()
+        .map_err(|e| format!("bad key: {e}"))?
+        .as_slice()
+        .try_into()
+        .map_err(|_| "not 32 bytes".to_string())
+}
+fn bytes16(b58s: &str) -> Result<[u8; 16], String> {
+    bs58::decode(b58s)
+        .into_vec()
+        .map_err(|e| format!("bad id: {e}"))?
+        .as_slice()
+        .try_into()
+        .map_err(|_| "not 16 bytes".to_string())
+}
+/// Cut to a byte cap on a char boundary.
+fn cap(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        return s.to_string();
+    }
+    let mut end = max;
+    while end > 0 && !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    s[..end].to_string()
+}
+
+fn path(app: &tauri::AppHandle) -> Result<PathBuf, String> {
+    Ok(app
+        .path()
+        .app_data_dir()
+        .map_err(|e| e.to_string())?
+        .join("freenet")
+        .join("playlists-ledger.json"))
+}
+fn load(app: &tauri::AppHandle) -> Ledger {
+    path(app)
+        .ok()
+        .and_then(|p| std::fs::read(p).ok())
+        .and_then(|b| serde_json::from_slice(&b).ok())
+        .unwrap_or_default()
+}
+fn save(app: &tauri::AppHandle, ledger: &Ledger) -> Result<(), String> {
+    let p = path(app)?;
+    if let Some(dir) = p.parent() {
+        std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
+    }
+    std::fs::write(&p, serde_json::to_vec_pretty(ledger).map_err(|e| e.to_string())?)
+        .map_err(|e| e.to_string())?;
+    let _ = app.emit(EVENT, ());
+    Ok(())
+}
+
+async fn own_key(app: &tauri::AppHandle) -> Result<[u8; 32], String> {
+    let adapter = app.state::<AppState>().freenet.clone();
+    let info = persona::current(&adapter)
+        .await?
+        .ok_or("create a SoulStream identity first")?;
+    bytes32(&info.public_key)
+}
+async fn send_pm(app: &tauri::AppHandle, to: &str, text: &str) -> Result<(), String> {
+    let st = app.state::<AppState>();
+    let guard = st.client.lock().await;
+    guard
+        .as_ref()
+        .ok_or("not connected to Soulseek")?
+        .message_user(to, text)
+        .map_err(|e| e.to_string())
+}
+
+// ---------------------------------------------------------------- publish
+
+/// Publish (or re-publish) a local playlist: a new signed revision and a
+/// pointer bump. Nothing about local files leaves the machine — entries
+/// carry titles, artists, albums, durations and a text hint only.
+pub async fn publish(app: &tauri::AppHandle, lib: &LibraryState, playlist_id: i64) -> Result<Published, String> {
+    let adapter: FreenetAdapter = app.state::<AppState>().freenet.clone();
+    let owner = own_key(app).await?;
+    let l = lib.library.clone();
+    let (meta, items) = tauri::async_runtime::spawn_blocking(move || -> Result<_, String> {
+        let meta = l
+            .list_playlists()
+            .map_err(|e| e.to_string())?
+            .into_iter()
+            .find(|p| p.id == playlist_id)
+            .ok_or("no such playlist")?;
+        let items = l.playlist_items(playlist_id).map_err(|e| e.to_string())?;
+        Ok((meta, items))
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+    if items.len() > pl::MAX_ENTRIES {
+        return Err(format!("{} entries is over the {} cap", items.len(), pl::MAX_ENTRIES));
+    }
+    let mut ledger = load(app);
+    let key = playlist_id.to_string();
+    let prev = ledger.published.get(&key).cloned();
+    let uuid = match &prev {
+        Some(p) => bytes16(&p.uuid)?,
+        None => rand16(),
+    };
+    let revision_seq = prev.as_ref().map(|p| p.revision_seq + 1).unwrap_or(1);
+    let prev_hash = match prev.as_ref().and_then(|p| p.current_hash.as_deref()) {
+        Some(h) => Some(bytes32(h)?),
+        None => None,
+    };
+    let entries: Vec<pl::EntryV1> = items
+        .iter()
+        .enumerate()
+        .map(|(i, it)| pl::EntryV1 {
+            entry_id: rand16(),
+            position: i as u32,
+            recording: pl::RecordingRef {
+                musicbrainz_recording_id: None,
+                isrcs: vec![],
+                deezer_id: None,
+                apple_music_id: None,
+                title: cap(&it.title, pl::MAX_FIELD_BYTES),
+                artists: vec![cap(&it.artist, pl::MAX_FIELD_BYTES)],
+                album: cap(it.album.as_deref().unwrap_or(""), pl::MAX_FIELD_BYTES),
+                duration_ms: it.duration_secs.map(|s| s.saturating_mul(1000)),
+                release_year: None,
+            },
+            note: it.note.as_deref().map(|n| cap(n, pl::MAX_NOTE_BYTES)),
+            slsk_hint: Some(cap(&format!("{} {}", it.artist, it.title), pl::MAX_FIELD_BYTES)),
+        })
+        .collect();
+    let mut m = pl::ManifestV1 {
+        schema_version: pl::SCHEMA_VERSION,
+        owner,
+        playlist_uuid: uuid,
+        revision_seq,
+        prev_revision_hash: prev_hash,
+        name: cap(&meta.name, pl::MAX_NAME_BYTES),
+        description: cap(meta.description.as_deref().unwrap_or(""), pl::MAX_DESC_BYTES),
+        artwork: None,
+        entries,
+        sig: vec![],
+    };
+    m.sig = persona::sign(&adapter, pl::SIGN_DOMAIN, pl::manifest_sign_payload(&m)).await?;
+    let bytes = bincode::serialize(&m).map_err(|e| e.to_string())?;
+    let hash = ps::content_hash(&bytes);
+    adapter
+        .contract_put(REV_WASM.to_vec(), &pl::make_rev_params(&owner, &hash), bytes.clone(), false)
+        .await
+        .map_err(|e| e.to_string())?;
+    let pointer_seq = prev.as_ref().map(|p| p.pointer_seq + 1).unwrap_or(1);
+    let mut p = pl::PointerState {
+        schema_version: pl::SCHEMA_VERSION,
+        owner,
+        playlist_uuid: uuid,
+        sequence: pointer_seq,
+        current: Some(pl::RevisionRef {
+            content_hash: hash,
+            revision_seq,
+            entry_count: m.entries.len() as u32,
+            byte_length: bytes.len() as u32,
+            name: m.name.clone(),
+        }),
+        withdrawn: false,
+        sig: vec![],
+    };
+    p.sig = persona::sign(&adapter, pl::SIGN_DOMAIN, pl::pointer_sign_payload(&p)).await?;
+    let pb = bincode::serialize(&p).map_err(|e| e.to_string())?;
+    let params = pl::make_ptr_params(&owner, &uuid);
+    if prev.is_some() {
+        adapter.contract_update(PTR_WASM.to_vec(), &params, pb).await.map(|_| ())
+    } else {
+        adapter.contract_put(PTR_WASM.to_vec(), &params, pb, false).await.map(|_| ())
+    }
+    .map_err(|e| e.to_string())?;
+    let rec = Published {
+        playlist_id,
+        uuid: b58(&uuid),
+        revision_seq,
+        pointer_seq,
+        current_hash: Some(b58(&hash)),
+        name: m.name.clone(),
+        entry_count: m.entries.len() as u32,
+        withdrawn: false,
+        published_at: now_secs(),
+    };
+    ledger.published.insert(key, rec.clone());
+    save(app, &ledger)?;
+    log::info!("shared playlists: published {:?} rev {} ({} entries)", rec.name, revision_seq, rec.entry_count);
+    Ok(rec)
+}
+
+/// Withdraw: the pointer moves to "none". Revisions already published stay
+/// fetchable on the network — the ledger keeps saying so.
+pub async fn withdraw(app: &tauri::AppHandle, playlist_id: i64) -> Result<Published, String> {
+    let adapter = app.state::<AppState>().freenet.clone();
+    let owner = own_key(app).await?;
+    let mut ledger = load(app);
+    let key = playlist_id.to_string();
+    let prev = ledger.published.get(&key).cloned().ok_or("that playlist was never published")?;
+    if prev.withdrawn {
+        return Ok(prev);
+    }
+    let uuid = bytes16(&prev.uuid)?;
+    let mut p = pl::PointerState {
+        schema_version: pl::SCHEMA_VERSION,
+        owner,
+        playlist_uuid: uuid,
+        sequence: prev.pointer_seq + 1,
+        current: None,
+        withdrawn: true,
+        sig: vec![],
+    };
+    p.sig = persona::sign(&adapter, pl::SIGN_DOMAIN, pl::pointer_sign_payload(&p)).await?;
+    let pb = bincode::serialize(&p).map_err(|e| e.to_string())?;
+    adapter
+        .contract_update(PTR_WASM.to_vec(), &pl::make_ptr_params(&owner, &uuid), pb)
+        .await
+        .map_err(|e| e.to_string())?;
+    let rec = Published { pointer_seq: prev.pointer_seq + 1, withdrawn: true, ..prev };
+    ledger.published.insert(key, rec.clone());
+    save(app, &ledger)?;
+    Ok(rec)
+}
+
+// ---------------------------------------------------------------- read
+
+/// Resolve (owner, uuid) through the network: pointer, then the revision it
+/// names, verified in the plan's order before anything is shown.
+pub async fn fetch(app: &tauri::AppHandle, owner_b58: &str, uuid_b58: &str) -> Result<ShareView, String> {
+    let adapter = app.state::<AppState>().freenet.clone();
+    let owner = bytes32(owner_b58)?;
+    let uuid = bytes16(uuid_b58)?;
+    let ptr_ids = FreenetAdapter::contract_ids(PTR_WASM.to_vec(), &pl::make_ptr_params(&owner, &uuid));
+    let pbytes = adapter.contract_get(&ptr_ids.instance, false).await.map_err(|e| {
+        if e.to_string().contains("not found") {
+            "no such shared playlist on the network (or not reachable yet)".to_string()
+        } else {
+            e.to_string()
+        }
+    })?;
+    let p = pl::validate_pointer(&owner, &uuid, &pbytes).map_err(|e| format!("pointer failed verification: {e}"))?;
+    let Some(r) = p.current.filter(|_| !p.withdrawn) else {
+        return Ok(ShareView {
+            owner_key: owner_b58.to_string(),
+            playlist_uuid: uuid_b58.to_string(),
+            name: String::new(),
+            description: String::new(),
+            revision_seq: 0,
+            content_hash: String::new(),
+            withdrawn: true,
+            entries: vec![],
+        });
+    };
+    let rev_ids = FreenetAdapter::contract_ids(REV_WASM.to_vec(), &pl::make_rev_params(&owner, &r.content_hash));
+    let rbytes = adapter.contract_get(&rev_ids.instance, false).await.map_err(|e| e.to_string())?;
+    let m = pl::validate_revision(&owner, &r.content_hash, &rbytes)
+        .map_err(|e| format!("revision failed verification: {e}"))?;
+    Ok(ShareView {
+        owner_key: owner_b58.to_string(),
+        playlist_uuid: uuid_b58.to_string(),
+        name: m.name,
+        description: m.description,
+        revision_seq: m.revision_seq,
+        content_hash: b58(&r.content_hash),
+        withdrawn: false,
+        entries: m
+            .entries
+            .into_iter()
+            .map(|e| ShareEntry {
+                position: e.position,
+                title: e.recording.title,
+                artist: e.recording.artists.join(", "),
+                album: e.recording.album,
+                duration_secs: e.recording.duration_ms.map(|ms| ms / 1000),
+                note: e.note,
+            })
+            .collect(),
+    })
+}
+
+/// A verified shared playlist staged through the app's own import path.
+pub async fn import(
+    app: &tauri::AppHandle,
+    lib: &State<'_, LibraryState>,
+    owner_b58: &str,
+    uuid_b58: &str,
+) -> Result<ImportDraft, String> {
+    let v = fetch(app, owner_b58, uuid_b58).await?;
+    if v.withdrawn {
+        return Err("the owner withdrew this playlist".into());
+    }
+    let parsed = ParsedPlaylist {
+        format: "soulstream".into(),
+        title: Some(v.name.clone()),
+        description: Some(v.description.clone()).filter(|d| !d.trim().is_empty()),
+        entries: v
+            .entries
+            .iter()
+            .map(|e| ParsedEntry {
+                ordinal: e.position + 1,
+                title: Some(e.title.clone()),
+                artist: Some(e.artist.clone()),
+                album: Some(e.album.clone()).filter(|a| !a.trim().is_empty()),
+                duration_secs: e.duration_secs,
+                location: None,
+                start_ms: None,
+                raw: format!("{} - {}", e.artist, e.title),
+            })
+            .collect(),
+        warnings: vec![],
+    };
+    playlists::resolve_draft(lib, parsed, format!("SoulStream · {}", v.name), None).await
+}
+
+// ---------------------------------------------------------------- share carry
+
+pub async fn send(app: &tauri::AppHandle, username: &str, playlist_id: i64) -> Result<(), String> {
+    let ledger = load(app);
+    let rec = ledger
+        .published
+        .get(&playlist_id.to_string())
+        .ok_or("publish the playlist first")?;
+    if rec.withdrawn {
+        return Err("that playlist is withdrawn — publish it again first".into());
+    }
+    let owner = own_key(app).await?;
+    let r = ShareRef {
+        owner,
+        playlist_uuid: bytes16(&rec.uuid)?,
+        name: rec.name.clone(),
+        entry_count: rec.entry_count,
+    };
+    use base64::Engine;
+    let bytes = bincode::serialize(&r).map_err(|e| e.to_string())?;
+    let text = format!("{SHARE_PREFIX}{}", base64::engine::general_purpose::STANDARD.encode(bytes));
+    send_pm(app, username, &text).await?;
+    log::info!("shared playlists: sent {:?} to {username}", rec.name);
+    Ok(())
+}
+
+/// The event pump hands private messages here after the link and friend
+/// handshakes. True means it was a share reference, now a card in the Inbox.
+pub fn intercept_pm(app: &tauri::AppHandle, from: &str, message: &str) -> bool {
+    let Some(rest) = message.trim().strip_prefix(SHARE_PREFIX) else { return false };
+    use base64::Engine;
+    let Ok(bytes) = base64::engine::general_purpose::STANDARD.decode(rest.trim()) else { return true };
+    let Ok(r) = bincode::deserialize::<ShareRef>(&bytes) else { return true };
+    let card = ShareCard {
+        id: format!("{}:{}:{}", normalize_username(from), b58(&r.owner), b58(&r.playlist_uuid)),
+        from_username: from.to_string(),
+        owner_key: b58(&r.owner),
+        playlist_uuid: b58(&r.playlist_uuid),
+        name: cap(&r.name, pl::MAX_NAME_BYTES),
+        entry_count: r.entry_count,
+        received_at: now_secs(),
+    };
+    let mut ledger = load(app);
+    ledger.inbox.retain(|c| c.id != card.id);
+    ledger.inbox.push(card);
+    if let Err(e) = save(app, &ledger) {
+        log::warn!("shared playlists: could not keep the share from {from}: {e}");
+    } else {
+        log::info!("shared playlists: share received from {from}");
+    }
+    true
+}
+
+// ---------------------------------------------------------------- commands
+
+#[tauri::command]
+pub fn shared_playlists_mine(app: tauri::AppHandle) -> Vec<Published> {
+    let mut v: Vec<_> = load(&app).published.into_values().collect();
+    v.sort_by(|a, b| b.published_at.cmp(&a.published_at));
+    v
+}
+#[tauri::command]
+pub async fn shared_playlist_publish(
+    app: tauri::AppHandle,
+    lib: State<'_, LibraryState>,
+    playlist_id: i64,
+) -> Result<Published, String> {
+    publish(&app, &lib, playlist_id).await
+}
+#[tauri::command]
+pub async fn shared_playlist_withdraw(app: tauri::AppHandle, playlist_id: i64) -> Result<Published, String> {
+    withdraw(&app, playlist_id).await
+}
+#[tauri::command]
+pub async fn shared_playlist_fetch(app: tauri::AppHandle, owner: String, uuid: String) -> Result<ShareView, String> {
+    fetch(&app, &owner, &uuid).await
+}
+#[tauri::command]
+pub async fn shared_playlist_import(
+    app: tauri::AppHandle,
+    lib: State<'_, LibraryState>,
+    owner: String,
+    uuid: String,
+) -> Result<ImportDraft, String> {
+    import(&app, &lib, &owner, &uuid).await
+}
+#[tauri::command]
+pub async fn share_send(app: tauri::AppHandle, username: String, playlist_id: i64) -> Result<(), String> {
+    send(&app, &username, playlist_id).await
+}
+#[tauri::command]
+pub fn shares_inbox(app: tauri::AppHandle) -> Vec<ShareCard> {
+    let mut v = load(&app).inbox;
+    v.sort_by(|a, b| b.received_at.cmp(&a.received_at));
+    v
+}
+#[tauri::command]
+pub fn share_dismiss(app: tauri::AppHandle, id: String) -> Result<(), String> {
+    let mut ledger = load(&app);
+    ledger.inbox.retain(|c| c.id != id);
+    save(&app, &ledger)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The bundled contracts are commitments (copy-forward is disabled
+    /// upstream): a changed wasm re-keys every published playlist.
+    #[test]
+    fn contract_generations_are_pinned() {
+        let owner = [7u8; 32];
+        let rev = FreenetAdapter::contract_ids(REV_WASM.to_vec(), &pl::make_rev_params(&owner, &[1u8; 32]));
+        let ptr = FreenetAdapter::contract_ids(PTR_WASM.to_vec(), &pl::make_ptr_params(&owner, &[2u8; 16]));
+        assert_eq!(rev.code_hash, "2JYdHHe3j59CVwCCKKeicjaF3rqoY2qjEbrYc95uUjkk");
+        assert_eq!(ptr.code_hash, "Daqn9EMctrTniK5s5x4m9QBHYixsf265UMUAmLPATg5S");
+    }
+}