@rougechain/sdk 0.9.0 → 1.1.0

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <strong>Build quantum-safe dApps on RougeChain</strong><br />
-  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Rollups · Dynamic Fees · Finality Proofs · WebSocket · Mail · Messenger
+  Transfers · DEX · NFTs · Social · Shielded Transactions · Bridge · Rollups · Dynamic Fees · Finality Proofs · WebSocket · Mail · Messenger
 </p>
 
 <p align="center">
@@ -62,6 +62,7 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **Shielded** | `rc.shielded` | Private transfers with zk-STARK proofs, shield/unshield XRGE |
 | **Bridge** | `rc.bridge` | ETH ↔ qETH, USDC ↔ qUSDC, XRGE bridge (Base Mainnet/Sepolia) |
 | **Rollup** | `rc` | zk-STARK batch proofs, rollup status, submit transfers |
+| **Social** | `rc.social` | Posts, timeline feed, reposts, likes, follows, comments |
 | **Mail** | `rc.mail` | On-chain encrypted email (`@rouge.quant`) |
 | **Messenger** | `rc.messenger` | E2E encrypted messaging with self-destruct |
 | **Address Resolution** | `rc` | O(1) rouge1↔pubkey resolution via on-chain index |
@@ -335,6 +336,79 @@ const batch = await rc.getRollupBatch(1);
 // { batch_id, transfer_count, proof_size_bytes, proof_time_ms, verified, ... }
 ```
 
+## Social (`rc.social`)
+
+On-chain social layer with posts, threaded replies, reposts, likes, follows, and comments. All write operations require a `wallet` parameter for ML-DSA-65 signed requests.
+
+### Posts & Timeline
+
+```typescript
+// Create a post (max 4000 chars)
+const { post } = await rc.social.createPost(wallet, "Hello RougeChain!");
+
+// Reply to a post (threaded)
+await rc.social.createPost(wallet, "Great point!", post.id);
+
+// Delete your own post
+await rc.social.deletePost(wallet, post.id);
+
+// Get a single post with stats
+const result = await rc.social.getPost(post.id, wallet.publicKey);
+// result.post, result.stats { likes, reposts, replies, liked, reposted }
+
+// Global timeline (all posts, newest first)
+const timeline = await rc.social.getGlobalTimeline(50, 0);
+
+// Following feed (posts from people you follow)
+const feed = await rc.social.getFollowingFeed(wallet, 50, 0);
+
+// User's posts
+const { posts, total } = await rc.social.getUserPosts(userPubKey);
+
+// Get replies to a post
+const replies = await rc.social.getPostReplies(post.id);
+```
+
+### Likes, Reposts & Follows
+
+```typescript
+// Like/unlike a post or track (toggle)
+await rc.social.toggleLike(wallet, postOrTrackId);
+
+// Repost/unrepost (toggle)
+await rc.social.toggleRepost(wallet, post.id);
+
+// Follow/unfollow (toggle)
+await rc.social.toggleFollow(wallet, artistPubKey);
+
+// Get stats
+const stats = await rc.social.getPostStats(post.id, wallet.publicKey);
+const artistStats = await rc.social.getArtistStats(pubkey, wallet.publicKey);
+```
+
+### Comments (Track-level)
+
+```typescript
+// Comment on a track
+const { comment } = await rc.social.postComment(wallet, trackId, "Fire track!");
+
+// Get comments
+const comments = await rc.social.getComments(trackId);
+
+// Delete your comment
+await rc.social.deleteComment(wallet, comment.id);
+```
+
+### Play Counts
+
+```typescript
+// Record a play (debounce client-side, one per session per track)
+await rc.social.recordPlay(wallet, trackId);
+
+// Get track stats (plays, likes, comments)
+const trackStats = await rc.social.getTrackStats(trackId, wallet.publicKey);
+```
+
 ## Mail (`rc.mail`)
 
 On-chain encrypted email with `@rouge.quant` / `@qwalla.mail` addresses. All write operations require a `wallet` parameter for ML-DSA-65 request signing — requests are authenticated via `/api/v2/` endpoints with anti-replay nonce protection.
@@ -364,7 +438,7 @@ const name = await rc.mail.reverseLookup(wallet.publicKey);
 // "alice"
 
 // Release a name (signed request)
-await rc.mail.releaseName(wallet, "alice", wallet.publicKey);
+await rc.mail.releaseName(wallet, "alice");
 ```
 
 ### Sending & Reading Mail
@@ -393,6 +467,25 @@ await rc.mail.markRead(wallet, messageId);
 await rc.mail.delete(wallet, messageId);
 ```
 
+### Unread Counts
+
+The SDK does not expose a dedicated unread-count endpoint. Derive unread totals client-side from inbox data:
+
+```typescript
+// Mail: count unread inbox items
+const inbox = await rc.mail.getInbox(wallet);
+const unreadMail = inbox.filter((m: any) => {
+  const label = m.label ?? {};
+  return !(label.is_read ?? label.isRead ?? true);
+}).length;
+
+// Messenger: sum unread_count across conversations
+const convos = await rc.messenger.getConversations(wallet);
+const unreadChats = convos.reduce((sum: number, c: any) => {
+  return sum + (c.unread_count ?? c.unreadCount ?? 0);
+}, 0);
+```
+
 ## Messenger (`rc.messenger`)
 
 End-to-end encrypted messaging with media and self-destruct support. All operations use ML-DSA-65 signed requests via `/api/v2/` endpoints with nonce-based anti-replay protection.
@@ -425,7 +518,7 @@ await rc.messenger.sendMessage(wallet, conversationId, encryptedContent, {
 const messages = await rc.messenger.getMessages(wallet, conversationId);
 
 // Delete a message (signed request)
-await rc.messenger.deleteMessage(wallet, messageId);
+await rc.messenger.deleteMessage(wallet, messageId, conversationId);
 
 // Delete a conversation (signed request)
 await rc.messenger.deleteConversation(wallet, conversationId);
@@ -450,7 +543,7 @@ const stats = await rc.shielded.getStats();
 // Check if a nullifier has been spent
 const { spent } = await rc.shielded.isNullifierSpent(note.nullifier);
 
-// Private transfer (requires STARK proof from Rust prover)
+// Private transfer (STARK proof generated by WASM prover in browser or Rust prover on node)
 await rc.shielded.transfer(wallet, {
   nullifiers: [note.nullifier],
   outputCommitments: [recipientCommitment],
@@ -548,6 +641,7 @@ import type {
   ShieldedNote,
   RollupStatus, RollupBatchResult, RollupSubmitParams, RollupSubmitResult,
   FeeInfo, FinalityProof, MintTokenParams, VoteMessage, WsSubscribeMessage,
+  SocialPost, PostStats, TrackStats, ArtistStats, SocialComment,
 } from "@rougechain/sdk";
 ```
 

package/dist/index.cjs

@@ -363,6 +363,7 @@ var RougeChain = class {
     this.mail = new MailClient(this);
     this.messenger = new MessengerClient(this);
     this.shielded = new ShieldedClient(this);
+    this.social = new SocialClient(this);
   }
   // ===== Internal helpers =====
   /** @internal */
@@ -994,14 +995,29 @@ var MailClient = class {
   }
   // --- Mail (signed) ---
   async send(wallet, params) {
+    const sigPayload = params.encrypted_subject + "|" + params.encrypted_body + (params.encrypted_attachment ? "|" + params.encrypted_attachment : "");
+    let contentSig = params.content_signature || "";
+    if (!contentSig && wallet.privateKey) {
+      try {
+        const { ml_dsa65: ml_dsa654 } = await import('@noble/post-quantum/ml-dsa.js');
+        const privKey = typeof wallet.privateKey === "string" ? hexToBytes(wallet.privateKey) : wallet.privateKey;
+        const sigBytes = ml_dsa654.sign(
+          new TextEncoder().encode(sigPayload),
+          privKey
+        );
+        contentSig = bytesToHex(sigBytes);
+      } catch {
+      }
+    }
     const signed = signRequest(wallet, {
       fromWalletId: params.from,
       toWalletIds: [params.to],
       subjectEncrypted: params.encrypted_subject,
       bodyEncrypted: params.encrypted_body,
-      contentSignature: params.body,
+      attachmentEncrypted: params.encrypted_attachment,
+      contentSignature: contentSig,
       replyToId: params.reply_to_id,
-      hasAttachment: false
+      hasAttachment: !!params.encrypted_attachment
     });
     return this.rc.submitTx("/v2/mail/send", signed);
   }
@@ -1213,6 +1229,106 @@ var ShieldedClient = class {
     return this.rc.get("/contracts");
   }
 };
+var SocialClient = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  async recordPlay(wallet, trackId) {
+    const signed = signRequest(wallet, { trackId });
+    return this.rc.submitTx("/v2/social/play", signed);
+  }
+  async toggleLike(wallet, trackId) {
+    const signed = signRequest(wallet, { trackId });
+    return this.rc.submitTx("/v2/social/like", signed);
+  }
+  async postComment(wallet, trackId, body) {
+    const signed = signRequest(wallet, { trackId, body });
+    return this.rc.submitTx("/v2/social/comment", signed);
+  }
+  async deleteComment(wallet, commentId) {
+    const signed = signRequest(wallet, { commentId });
+    return this.rc.submitTx("/v2/social/comment/delete", signed);
+  }
+  async toggleFollow(wallet, artistPubkey) {
+    const signed = signRequest(wallet, { artistPubkey });
+    return this.rc.submitTx("/v2/social/follow", signed);
+  }
+  async getTrackStats(trackId, viewerPubkey) {
+    const q = viewerPubkey ? `?viewer=${encodeURIComponent(viewerPubkey)}` : "";
+    return this.rc.get(`/social/track/${encodeURIComponent(trackId)}/stats${q}`);
+  }
+  async getComments(trackId, limit = 50, offset = 0) {
+    const data = await this.rc.get(
+      `/social/track/${encodeURIComponent(trackId)}/comments?limit=${limit}&offset=${offset}`
+    );
+    return data.comments ?? [];
+  }
+  async getArtistStats(pubkey, viewerPubkey) {
+    const q = viewerPubkey ? `?viewer=${encodeURIComponent(viewerPubkey)}` : "";
+    return this.rc.get(`/social/artist/${encodeURIComponent(pubkey)}/stats${q}`);
+  }
+  async getUserLikes(pubkey) {
+    const data = await this.rc.get(`/social/user/${encodeURIComponent(pubkey)}/likes`);
+    return data.trackIds ?? [];
+  }
+  async getUserFollowing(pubkey) {
+    const data = await this.rc.get(`/social/user/${encodeURIComponent(pubkey)}/following`);
+    return data.artists ?? [];
+  }
+  // ── Posts ──────────────────────────────────────────────
+  async createPost(wallet, body, replyToId) {
+    const payload = { body };
+    if (replyToId) payload.replyToId = replyToId;
+    const signed = signRequest(wallet, payload);
+    return this.rc.submitTx("/v2/social/post", signed);
+  }
+  async deletePost(wallet, postId) {
+    const signed = signRequest(wallet, { postId });
+    return this.rc.submitTx("/v2/social/post/delete", signed);
+  }
+  async toggleRepost(wallet, postId) {
+    const signed = signRequest(wallet, { postId });
+    return this.rc.submitTx("/v2/social/repost", signed);
+  }
+  async getPost(postId, viewerPubkey) {
+    const q = viewerPubkey ? `?viewer=${encodeURIComponent(viewerPubkey)}` : "";
+    try {
+      return await this.rc.get(`/social/post/${encodeURIComponent(postId)}${q}`);
+    } catch {
+      return null;
+    }
+  }
+  async getPostStats(postId, viewerPubkey) {
+    const q = viewerPubkey ? `?viewer=${encodeURIComponent(viewerPubkey)}` : "";
+    return this.rc.get(`/social/post/${encodeURIComponent(postId)}/stats${q}`);
+  }
+  async getPostReplies(postId, limit = 50, offset = 0) {
+    const data = await this.rc.get(
+      `/social/post/${encodeURIComponent(postId)}/replies?limit=${limit}&offset=${offset}`
+    );
+    return data.replies ?? [];
+  }
+  async getUserPosts(pubkey, limit = 50, offset = 0) {
+    return this.rc.get(
+      `/social/user/${encodeURIComponent(pubkey)}/posts?limit=${limit}&offset=${offset}`
+    );
+  }
+  async getGlobalTimeline(limit = 50, offset = 0) {
+    const data = await this.rc.get(
+      `/social/timeline?limit=${limit}&offset=${offset}`
+    );
+    return data.posts ?? [];
+  }
+  async getFollowingFeed(wallet, limit = 50, offset = 0) {
+    const signed = signRequest(wallet, { limit, offset });
+    try {
+      const data = await this.rc.submitTx("/v2/social/feed", signed);
+      return data.posts ?? [];
+    } catch {
+      return [];
+    }
+  }
+};
 
 // src/address.ts
 var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";