OpenSocial Protocol Reimagined on ICP - Platform-Agnostic Social Infrastructure with CanDB

		// Universal Profile Structure
type UniversalProfile = {
  principal: Principal;           // Internet Identity
  displayName: ?Text;              // User's chosen name
  bio: ?Text;                      // Bio across all apps
  avatar: ?Text;                   // Profile picture (IPFS hash)
  created: Time.Time;              // Account creation
 
  // Social connections
  followers: [Principal];          // Who follows you
  following: [Principal];          // Who you follow
 
  // Cross-app reputation
  karma: Nat;                      // Aggregated across all apps
  badges: [Badge];                 // Achievements from any dApp
 
  // Privacy controls
  visibility: VisibilitySettings;
  permissions: [AppPermission];    // Granular per-app access
};
	

		// When posting on Seachan
public shared(msg) func createPost(
  boardId: Text,
  content: Text,
  isAnonymous: Bool
) : async Result<PostId, Error> {
 
  let caller = msg.caller;
 
  // Check user's reputation from Social Backbone
  let profile = await SocialBackbone.getProfile(caller);
 
  if (profile.karma < 10 and not isAnonymous) {
    // Low karma users post with "new user" badge
    // Prevents spam while allowing new users
  };
 
  // Create post, update karma if quality content
  let postId = await createPostInternal(content);
 
  // Update Social Backbone
  await SocialBackbone.updateKarma(caller, +5);
  await SocialBackbone.recordActivity(caller, #SeachanPost(postId));
 
  // Other apps can now see this activity!
};
	

		// Creating a DJ profile on Honk FM
public shared(msg) func createDJProfile(
  djName: Text,
  genre: [Text]
) : async Result<DJProfile, Error> {
 
  let caller = msg.caller;
 
  // Load existing profile from Social Backbone
  let universalProfile = await SocialBackbone.getProfile(caller);
 
  // DJ profile inherits trust
  let djProfile = {
    id = caller;
    name = djName;
    genre = genre;
 
    // Reputation from across DappJak ecosystem!
    karma = universalProfile.karma;
    badges = universalProfile.badges;
 
    // Followers carry over!
    followers = universalProfile.followers;
 
    // Bio and avatar reused
    bio = universalProfile.bio;
    avatar = universalProfile.avatar;
  };
 
  // Notify ALL followers across ALL apps
  await SocialBackbone.notifyFollowers(
    caller,
    #NewActivity("Started DJing on Honk FM!")
  );
};
	

		// Editing a knowledge article
public shared(msg) func editArticle(
  articleId: Text,
  newContent: Text,
  editSummary: Text
) : async Result<RevisionId, Error> {
 
  let caller = msg.caller;
  let profile = await SocialBackbone.getProfile(caller);
 
  // High karma users = trusted editors
  // Their edits go live immediately
  let requiresReview = profile.karma < 100;
 
  let revision = await createRevision(
    articleId,
    newContent,
    requiresReview
  );
 
  // Update expertise tracking
  await SocialBackbone.addExpertise(
    caller,
    extractTopics(articleId)
  );
 
  // Earn reputation for contributions
  await SocialBackbone.updateKarma(caller, +15);
  await SocialBackbone.awardBadge(
    caller,
    #KnowledgeContributor
  );
};
	

		// Tribe (Community) Structure
type Tribe = {
  id: Text;
  name: Text;
  description: Text;
  creator: Principal;
  members: [Principal];
  moderators: [Principal];
 
  // Cross-app presence
  seachanBoard: ?Text;      // Optional board on Seachan
  honkFmStation: ?Text;     // Optional radio station
  atlasNamespace: ?Text;    // Optional knowledge namespace
 
  // Unified features
  chat: ChatChannel;
  events: [Event];
  sharedContent: [Content];
};
	

		// Megaphone a post across apps
public shared(msg) func megaphoneContent(
  contentId: Text,
  sourceApp: AppType,
  targetApps: [AppType]
) : async Result<(), Error> {
 
  let caller = msg.caller;
  let profile = await SocialBackbone.getProfile(caller);
 
  // Requires karma threshold
  if (profile.karma < 50) {
    return #err(#InsufficientKarma);
  };
 
  // Get original content
  let content = await getContent(sourceApp, contentId);
 
  // Broadcast to follower feeds across ALL selected apps
  for (app in targetApps.vals()) {
    await app.amplifyToFeeds(
      content,
      profile.followers,
      #Megaphone(caller)
    );
  };
 
  // Cost karma to prevent spam
  await SocialBackbone.updateKarma(caller, -10);
};
	

		// User can set per-app permissions
let permissions = {
  seachan = {
    showProfile = false;     // Anonymous posting
    showActivity = false;
    showKarma = true;        // But karma visible for trust
  };
  honkFm = {
    showProfile = true;      // Public DJ profile
    showActivity = true;
    showFollowers = true;
  };
  atlasNetwork = {
    showProfile = true;
    showExpertise = true;    // Display knowledge areas
    showActivity = false;    // But hide other activities
  };
};
	

		// Example: Build a "Seachan to Atlas" bridge
 
// Reference Seachan thread in Atlas article
public func citeSeachanThread(
  articleId: Text,
  threadId: Text
) : async Result<Citation, Error> {
 
  // Verify thread exists on Seachan
  let thread = await Seachan.getThread(threadId);
 
  // Create citation in Atlas
  let citation = {
    source = #Seachan(threadId);
    preview = thread.summary;
    author = thread.creator;  // Social Backbone Principal
  };
 
  // Cross-app reputation boost
  await SocialBackbone.updateKarma(
    thread.creator,
    +20  // Cited in knowledge base!
  );
};
	

		// Simplified Social Backbone implementation
actor SocialBackbone {
 
  // Storage
  private stable var profiles = TrieMap.TrieMap<Principal, Profile>(
    Principal.equal,
    Principal.hash
  );
 
  private stable var socialGraph = TrieMap.TrieMap<Principal, Connections>(
    Principal.equal,
    Principal.hash
  );
 
  // Core API
  public shared(msg) func getProfile(
    user: Principal
  ) : async ?Profile {
    profiles.get(user)
  };
 
  public shared(msg) func updateProfile(
    updates: ProfileUpdates
  ) : async Result<(), Error> {
    let caller = msg.caller;
 
    switch (profiles.get(caller)) {
      case null { #err(#NotFound) };
      case (?profile) {
        let updated = applyUpdates(profile, updates);
        profiles.put(caller, updated);
        #ok()
      };
    }
  };
 
  public shared(msg) func follow(
    target: Principal
  ) : async Result<(), Error> {
    let caller = msg.caller;
 
    // Update both sides of relationship
    await addFollower(target, caller);
    await addFollowing(caller, target);
 
    // Notify target
    await notifyUser(target, #NewFollower(caller));
 
    #ok()
  };
 
  public shared(msg) func updateKarma(
    user: Principal,
    delta: Int
  ) : async Result<(), Error> {
    // Only authorized apps can update karma
    assert(isAuthorizedApp(msg.caller));
 
    switch (profiles.get(user)) {
      case null { #err(#NotFound) };
      case (?profile) {
        let newKarma = Int.max(0, profile.karma + delta);
        let updated = { profile with karma = newKarma };
        profiles.put(user, updated);
 
        // Check for badge eligibility
        await checkBadges(user, updated);
 
        #ok()
      };
    }
  };
 
  public query func getActivityFeed(
    user: Principal,
    limit: Nat
  ) : async [Activity] {
    // Aggregate activity from all authorized apps
    let activities = Buffer.Buffer<Activity>(limit);
 
    for (app in authorizedApps.vals()) {
      let appActivities = await app.getUserActivity(user);
      activities.append(appActivities);
    };
 
    // Sort by timestamp, return latest
    Array.sort(
      Buffer.toArray(activities),
      compareTimestamp
    )
    |> Array.take(_, limit)
  };
};
	

		// In your dApp
import SocialBackbone "canister:social-backbone";
 
actor MyDApp {
 
  public shared(msg) func performAction() : async Result<(), Error> {
    let user = msg.caller;
 
    // Load user context
    let profile = await SocialBackbone.getProfile(user);
 
    // Check permissions
    if (not hasPermission(profile, #MyDApp)) {
      return #err(#Unauthorized);
    };
 
    // Do your app logic...
 
    // Update user's social data
    await SocialBackbone.recordActivity(user, #MyDAppAction);
    await SocialBackbone.updateKarma(user, +10);
 
    // Notify followers
    await SocialBackbone.notifyFollowers(
      user,
      #NewActivity("Did something on MyDApp!")
    );
 
    #ok()
  };
};
	

		public query(msg) func exportMyData() : async ExportPackage {
  let caller = msg.caller;
 
  {
    profile = await getProfile(caller);
    connections = await getConnections(caller);
    activities = await getAllActivities(caller);
 
    // Data from all apps
    seachanData = await Seachan.exportUserData(caller);
    honkFmData = await HonkFM.exportUserData(caller);
    atlasData = await AtlasNetwork.exportUserData(caller);
 
    // Metadata
    exportedAt = Time.now();
    format = "DappJak-Export-v1.0";
  }
};
	

		// social-backbone-storage/main.mo
import CanDB "mo:candb/CanDB";
import Entity "mo:candb/Entity";
 
actor class SocialBackboneStorage() {
 
  // CanDB instance with auto-scaling
  stable var db : CanDB.DB = CanDB.init({
    pk = "user#";           // Partition key prefix
    scalingOptions = {
      autoScalingHook = autoScale;
      sizeLimit = #heapSize(400_000_000); // ~400MB per partition
      // When partition fills, auto-create new one
    };
  });
 
  // Store user profile as JSON-serializable entity
  public shared(msg) func storeProfile(
    profile: {
      displayName: ?Text;
      bio: ?Text;
      avatar: ?Text;      // IPFS hash or data URL
      metadata: [(Text, Text)];  // Custom key-value pairs
    }
  ) : async Result<(), Error> {
 
    let caller = msg.caller;
    let pk = "user#" # Principal.toText(caller);
 
    // Store as Entity (auto-partitioned by CanDB)
    await* db.put({
      pk = pk;
      sk = "profile";      // Sort key
      attributes = [
        ("displayName", #text(Option.get(profile.displayName, ""))),
        ("bio", #text(Option.get(profile.bio, ""))),
        ("avatar", #text(Option.get(profile.avatar, ""))),
        ("metadata", #tuple(profile.metadata)),
        ("updatedAt", #int(Time.now()))
      ];
    });
 
    #ok()
  };
 
  // Store user post (can be JSON or media reference)
  public shared(msg) func storePost(
    content: {
      text: ?Text;
      media: ?{
        type_: Text;     // "image/png", "video/mp4", etc.
        url: Text;       // IPFS hash or IC asset URL
        thumbnail: ?Text;
      };
      metadata: [(Text, Text)];  // Tags, mentions, etc.
    }
  ) : async Result<PostId, Error> {
 
    let caller = msg.caller;
    let postId = generateId();
    let pk = "user#" # Principal.toText(caller);
    let sk = "post#" # postId;
 
    let attributes = Buffer.Buffer<(Text, Entity.AttributeValue)>(10);
    attributes.add(("postId", #text(postId)));
    attributes.add(("createdAt", #int(Time.now())));
 
    switch (content.text) {
      case (?text) { attributes.add(("text", #text(text))) };
      case null {};
    };
 
    switch (content.media) {
      case (?media) {
        attributes.add(("mediaType", #text(media.type_)));
        attributes.add(("mediaUrl", #text(media.url)));
        switch (media.thumbnail) {
          case (?thumb) { attributes.add(("thumbnail", #text(thumb))) };
          case null {};
        };
      };
      case null {};
    };
 
    for ((key, value) in content.metadata.vals()) {
      attributes.add((key, #text(value)));
    };
 
    await* db.put({
      pk = pk;
      sk = sk;
      attributes = Buffer.toArray(attributes);
    });
 
    #ok(postId)
  };
 
  // Get user profile as JSON
  public query func getProfileJSON(
    user: Principal
  ) : async ?Text {
 
    let pk = "user#" # Principal.toText(user);
 
    switch (await db.get({ pk = pk; sk = "profile" })) {
      case null { null };
      case (?entity) {
        // Convert entity to JSON
        let json = entityToJSON(entity);
        ?json
      };
    }
  };
 
  // Get user posts as JSON array
  public query func getPostsJSON(
    user: Principal,
    limit: Nat
  ) : async Text {
 
    let pk = "user#" # Principal.toText(user);
 
    // Scan for all posts
    let posts = await db.scan({
      pk = pk;
      skLowerBound = "post#";
      skUpperBound = "post#~";  // Scan all posts
      limit = limit;
      ascending = false;  // Newest first
    });
 
    // Convert to JSON array
    let jsonArray = postsToJSONArray(posts.entities);
    jsonArray
  };
 
  // Helper: Convert Entity to JSON string
  private func entityToJSON(entity: Entity.Entity) : Text {
    var json = "{";
    var first = true;
 
    for ((key, value) in entity.attributes.vals()) {
      if (not first) { json #= "," };
      first := false;
 
      json #= """ # key # "":";
 
      switch (value) {
        case (#text(t)) { json #= """ # escapeJSON(t) # """ };
        case (#int(i)) { json #= Int.toText(i) };
        case (#bool(b)) { json #= Bool.toText(b) };
        case (#float(f)) { json #= Float.toText(f) };
        case _ { json #= "null" };
      };
    };
 
    json #= "}";
    json
  };
 
  private func postsToJSONArray(entities: [Entity.Entity]) : Text {
    var json = "[";
    var first = true;
 
    for (entity in entities.vals()) {
      if (not first) { json #= "," };
      first := false;
      json #= entityToJSON(entity);
    };
 
    json #= "]";
    json
  };
};
	

		// social-backbone-api/main.mo
// Candid interface that returns JSON
 
actor SocialBackboneAPI {
 
  // Returns profile as JSON string
  public query func getProfile(user: Principal) : async ?Text {
    await Storage.getProfileJSON(user)
  };
 
  // Returns posts array as JSON string
  public query func getPosts(user: Principal, limit: Nat) : async Text {
    await Storage.getPostsJSON(user, limit)
  };
 
  // Returns followers as JSON array
  public query func getFollowers(user: Principal) : async Text {
    let pk = "user#" # Principal.toText(user);
    let followers = await Storage.getFollowersList(pk);
    followersToJSON(followers)
  };
 
  // Returns following as JSON array
  public query func getFollowing(user: Principal) : async Text {
    let pk = "user#" # Principal.toText(user);
    let following = await Storage.getFollowingList(pk);
    followingToJSON(following)
  };
 
  // Update methods (authenticated)
  public shared(msg) func updateProfile(
    displayName: ?Text,
    bio: ?Text,
    avatar: ?Text
  ) : async Result<(), Error> {
    await Storage.storeProfile({
      displayName = displayName;
      bio = bio;
      avatar = avatar;
      metadata = [];
    })
  };
 
  public shared(msg) func createPost(
    text: ?Text,
    mediaType: ?Text,
    mediaUrl: ?Text
  ) : async Result<Text, Error> {
    let media = switch (mediaType, mediaUrl) {
      case (?t, ?u) {
        ?{
          type_ = t;
          url = u;
          thumbnail = null;
        }
      };
      case _ { null };
    };
 
    await Storage.storePost({
      text = text;
      media = media;
      metadata = [];
    })
  };
};
	

		type Profile = record {
  displayName : opt text;
  bio : opt text;
  avatar : opt text;
};
 
type Result = variant {
  ok : text;
  err : Error;
};
 
type Error = variant {
  NotFound;
  Unauthorized;
  InvalidInput : text;
};
 
service : {
  // Query methods (fast, cached)
  getProfile : (principal) -> (opt text) query;
  getPosts : (principal, nat) -> (text) query;
  getFollowers : (principal) -> (text) query;
  getFollowing : (principal) -> (text) query;
 
  // Update methods (authenticated)
  updateProfile : (opt text, opt text, opt text) -> (Result);
  createPost : (opt text, opt text, opt text) -> (Result);
}
	

		// social-backbone-client/src/index.ts
import { Actor, HttpAgent } from '@dfinity/agent';
import { Principal } from '@dfinity/principal';
import { idlFactory } from './social-backbone.did.js';
 
// Auto-generated from Candid
interface SocialBackboneService {
  getProfile: (user: Principal) => Promise<string | null>;
  getPosts: (user: Principal, limit: bigint) => Promise<string>;
  getFollowers: (user: Principal) => Promise<string>;
  getFollowing: (user: Principal) => Promise<string>;
  updateProfile: (
    displayName: string | null,
    bio: string | null,
    avatar: string | null
  ) => Promise<{ ok: string } | { err: Error }>;
  createPost: (
    text: string | null,
    mediaType: string | null,
    mediaUrl: string | null
  ) => Promise<{ ok: string } | { err: Error }>;
}
 
export class SocialBackboneClient {
  private actor: SocialBackboneService;
 
  constructor(canisterId: string, identity?: any) {
    const agent = new HttpAgent({
      host: 'https://ic0.app',
      identity,
    });
 
    this.actor = Actor.createActor<SocialBackboneService>(idlFactory, {
      agent,
      canisterId,
    });
  }
 
  /**
   * Get user profile - returns parsed JSON object
   */
  async getProfile(principal: string | Principal): Promise<UserProfile | null> {
    const p = typeof principal === 'string'
      ? Principal.fromText(principal)
      : principal;
 
    const jsonString = await this.actor.getProfile(p);
 
    if (!jsonString) return null;
 
    return JSON.parse(jsonString) as UserProfile;
  }
 
  /**
   * Get user posts - returns parsed JSON array
   */
  async getPosts(principal: string | Principal, limit = 50): Promise<Post[]> {
    const p = typeof principal === 'string'
      ? Principal.fromText(principal)
      : principal;
 
    const jsonString = await this.actor.getPosts(p, BigInt(limit));
 
    return JSON.parse(jsonString) as Post[];
  }
 
  /**
   * Get user followers
   */
  async getFollowers(principal: string | Principal): Promise<Follower[]> {
    const p = typeof principal === 'string'
      ? Principal.fromText(principal)
      : principal;
 
    const jsonString = await this.actor.getFollowers(p);
 
    return JSON.parse(jsonString) as Follower[];
  }
 
  /**
   * Update your profile (requires authentication)
   */
  async updateProfile(profile: {
    displayName?: string;
    bio?: string;
    avatar?: string;
  }): Promise<void> {
    const result = await this.actor.updateProfile(
      profile.displayName ?? null,
      profile.bio ?? null,
      profile.avatar ?? null
    );
 
    if ('err' in result) {
      throw new Error(`Failed to update profile: ${JSON.stringify(result.err)}`);
    }
  }
 
  /**
   * Create a post (requires authentication)
   */
  async createPost(post: {
    text?: string;
    media?: { type: string; url: string };
  }): Promise<string> {
    const result = await this.actor.createPost(
      post.text ?? null,
      post.media?.type ?? null,
      post.media?.url ?? null
    );
 
    if ('err' in result) {
      throw new Error(`Failed to create post: ${JSON.stringify(result.err)}`);
    }
 
    return result.ok;
  }
}
 
// TypeScript types for the returned JSON
export interface UserProfile {
  displayName: string;
  bio: string;
  avatar: string;
  updatedAt: number;
}
 
export interface Post {
  postId: string;
  text?: string;
  mediaType?: string;
  mediaUrl?: string;
  thumbnail?: string;
  createdAt: number;
  [key: string]: any; // Custom metadata
}
 
export interface Follower {
  principal: string;
  displayName: string;
  avatar?: string;
  followedAt: number;
}
 
// Export singleton for easy import
export const socialBackbone = new SocialBackboneClient(
  process.env.SOCIAL_BACKBONE_CANISTER_ID || ''
);
	

		// app/profile/[principal]/page.tsx
import { socialBackbone } from '@dappjak/social-backbone-client';
 
export default async function ProfilePage({
  params
}: {
  params: { principal: string }
}) {
  // Fetch on server or client - works everywhere!
  const profile = await socialBackbone.getProfile(params.principal);
  const posts = await socialBackbone.getPosts(params.principal, 20);
 
  if (!profile) {
    return <div>Profile not found</div>;
  }
 
  return (
    <div>
      <h1>{profile.displayName}</h1>
      <p>{profile.bio}</p>
      <img src={profile.avatar} alt={profile.displayName} />
 
      <h2>Posts</h2>
      {posts.map(post => (
        <article key={post.postId}>
          <p>{post.text}</p>
          {post.mediaUrl && <img src={post.mediaUrl} />}
          <time>{new Date(post.createdAt).toLocaleString()}</time>
        </article>
      ))}
    </div>
  );
}
 
// No blockchain complexity - just async/await!
	

		// screens/ProfileScreen.tsx
import { useEffect, useState } from 'react';
import { View, Text, Image, FlatList } from 'react-native';
import { socialBackbone } from '@dappjak/social-backbone-client';
 
export function ProfileScreen({ route }) {
  const { principal } = route.params;
  const [profile, setProfile] = useState(null);
  const [posts, setPosts] = useState([]);
 
  useEffect(() => {
    async function load() {
      // Same client works on React Native!
      const [profileData, postsData] = await Promise.all([
        socialBackbone.getProfile(principal),
        socialBackbone.getPosts(principal, 50),
      ]);
 
      setProfile(profileData);
      setPosts(postsData);
    }
 
    load();
  }, [principal]);
 
  if (!profile) return <Text>Loading...</Text>;
 
  return (
    <View>
      <Image source={{ uri: profile.avatar }} />
      <Text style={styles.name}>{profile.displayName}</Text>
      <Text>{profile.bio}</Text>
 
      <FlatList
        data={posts}
        renderItem={({ item }) => (
          <View>
            <Text>{item.text}</Text>
            {item.mediaUrl && <Image source={{ uri: item.mediaUrl }} />}
          </View>
        )}
      />
    </View>
  );
}
 
// Same TypeScript client, works on iOS & Android!
	

		// src/main/services/social.ts
import { socialBackbone } from '@dappjak/social-backbone-client';
 
// Electron main process
export class SocialService {
  async getUserData(principal: string) {
    // Same client works in Electron!
    const [profile, posts, followers] = await Promise.all([
      socialBackbone.getProfile(principal),
      socialBackbone.getPosts(principal),
      socialBackbone.getFollowers(principal),
    ]);
 
    return { profile, posts, followers };
  }
 
  async updateProfile(data: {
    displayName?: string;
    bio?: string;
    avatar?: string;
  }) {
    await socialBackbone.updateProfile(data);
  }
}
 
// IPC handler
ipcMain.handle('social:getProfile', async (event, principal) => {
  return socialBackbone.getProfile(principal);
});
	

		// scripts/export-profile.ts
import { socialBackbone } from '@dappjak/social-backbone-client';
import { writeFile } from 'fs/promises';
 
// CLI tool to export user data
async function exportUserData(principal: string) {
  console.log(`Exporting data for ${principal}...`);
 
  const [profile, posts, followers, following] = await Promise.all([
    socialBackbone.getProfile(principal),
    socialBackbone.getPosts(principal, 1000),
    socialBackbone.getFollowers(principal),
    socialBackbone.getFollowing(principal),
  ]);
 
  const exportData = {
    exportedAt: new Date().toISOString(),
    principal,
    profile,
    posts,
    followers,
    following,
  };
 
  await writeFile(
    `${principal}-export.json`,
    JSON.stringify(exportData, null, 2)
  );
 
  console.log(`✅ Exported to ${principal}-export.json`);
}
 
// Run with: npx tsx export-profile.ts <principal>
exportUserData(process.argv[2]);
 
// Same client works in Node.js, Deno, Bun!
	

		# python/social_client.py
import json
import subprocess
 
class SocialBackboneClient:
    """Python wrapper using Node.js bridge"""
 
    def get_profile(self, principal: str) -> dict:
        result = subprocess.run(
            ['node', 'bridge.js', 'getProfile', principal],
            capture_output=True,
            text=True
        )
        return json.loads(result.stdout)
 
    def get_posts(self, principal: str, limit: int = 50) -> list:
        result = subprocess.run(
            ['node', 'bridge.js', 'getPosts', principal, str(limit)],
            capture_output=True,
            text=True
        )
        return json.loads(result.stdout)
 
# Usage
client = SocialBackboneClient()
profile = client.get_profile("abc123...")
posts = client.get_posts("abc123...", 20)
	

		// iOS/SocialBackboneClient.swift
import WebKit
 
class SocialBackboneClient {
    private let webView = WKWebView()
 
    func getProfile(principal: String) async throws -> UserProfile {
        let script = """
        import { socialBackbone } from '@dappjak/social-backbone-client';
        const profile = await socialBackbone.getProfile('(principal)');
        return JSON.stringify(profile);
        """
 
        let result = try await webView.evaluateJavaScript(script)
        let data = (result as! String).data(using: .utf8)!
        return try JSONDecoder().decode(UserProfile.self, from: data)
    }
}
	

		// When user uploads media
public shared(msg) func uploadMedia(
  data: Blob,
  contentType: Text
) : async Result<MediaReference, Error> {
 
  let caller = msg.caller;
 
  // Option 1: Store directly in canister (small files < 1MB)
  if (data.size() < 1_000_000) {
    let mediaId = generateId();
    await storeInCanister(caller, mediaId, data, contentType);
 
    return #ok({
      url = "https://social-backbone.ic0.app/media/" # mediaId;
      type_ = contentType;
    });
  }
 
  // Option 2: Store in IPFS (large files)
  else {
    let ipfsHash = await uploadToIPFS(data);
 
    // Store reference in CanDB
    await storeMediaReference(caller, {
      ipfsHash = ipfsHash;
      contentType = contentType;
      size = data.size();
    });
 
    return #ok({
      url = "ipfs://" # ipfsHash;
      type_ = contentType;
    });
  };
};
 
// Serve media via HTTP
public query func http_request_media(mediaId: Text) : async Http.Response {
  switch (await getMediaFromCanister(mediaId)) {
    case null { /* 404 */ };
    case (?(data, contentType)) {
      return {
        status_code = 200;
        headers = [
          ("Content-Type", contentType),
          ("Cache-Control", "public, max-age=31536000"),  // 1 year
          ("Access-Control-Allow-Origin", "*")
        ];
        body = data;
      };
    };
  };
};
	

		// Install the package
npm install @dappjak/social-backbone-client
 
// Import and use - that's it!
import { socialBackbone } from '@dappjak/social-backbone-client';
 
const profile = await socialBackbone.getProfile(principal);
const posts = await socialBackbone.getPosts(principal, 50);
	

		// User can export ALL their data
public query(msg) func exportMyData() : async Blob {
  let caller = msg.caller;
  let pk = "user#" # Principal.toText(caller);
 
  // Get all entities for this user
  let allData = await db.scanAll(pk);
 
  // Serialize to JSON
  let json = entitiesToJSON(allData);
 
  // Return as downloadable blob
  Text.encodeUtf8(json)
};
	

		# Initialize your project
npm create vite@latest dappjak-reader -- --template react-ts
cd dappjak-reader
 
# Install the Social Backbone client - that's it!
npm install @dappjak/social-backbone-client
	

		// src/App.tsx
import { useEffect, useState } from 'react';
import { socialBackbone } from '@dappjak/social-backbone-client';
 
// You DON'T need to:
// ❌ Deploy your own canisters
// ❌ Learn Motoko or Candid
// ❌ Set up Internet Identity (for read-only)
// ❌ Pay for cycles
// ❌ Understand blockchain internals
 
// You just:
// ✅ npm install the client
// ✅ Import and use
// ✅ Build your UI
// ✅ Ship your app
 
function App() {
  const [profile, setProfile] = useState(null);
  const [posts, setPosts] = useState([]);
 
  useEffect(() => {
    async function loadData() {
      const principal = 'xyz123...'; // From URL params or search
 
      // Simple async/await - just like any API!
      const [profileData, postsData] = await Promise.all([
        socialBackbone.getProfile(principal),
        socialBackbone.getPosts(principal, 50),
      ]);
 
      setProfile(profileData);
      setPosts(postsData);
    }
 
    loadData();
  }, []);
 
  if (!profile) return <div>Loading...</div>;
 
  return (
    <div>
      <header>
        <img src={profile.avatar} alt={profile.displayName} />
        <h1>{profile.displayName}</h1>
        <p>{profile.bio}</p>
      </header>
 
      <main>
        {posts.map(post => (
          <article key={post.postId}>
            <p>{post.text}</p>
            {post.mediaUrl && <img src={post.mediaUrl} alt="" />}
            <time>{new Date(post.createdAt).toLocaleString()}</time>
          </article>
        ))}
      </main>
    </div>
  );
}
 
export default App;