@le-space/orbitdb-storage-bridge 0.10.0

package/dist/components/storacha-backup.js

@@ -0,0 +1,325 @@
+/**
+ * Storacha Authentication and Management Functions for Demo
+ *
+ * Provides various authentication methods for Storacha:
+ * - Email-based account creation
+ * - Key/Proof credentials
+ * - UCAN delegation
+ * - Seed phrase derived identities
+ */
+
+import * as Client from "@storacha/client";
+import { StoreMemory } from "@storacha/client/stores/memory";
+import { Signer } from "@storacha/client/principal/ed25519";
+import * as Proof from "@storacha/client/proof";
+import * as Delegation from "@ucanto/core/delegation";
+import * as ed25519 from "@ucanto/principal/ed25519";
+import { generateMnemonic, mnemonicToSeedSync } from "@scure/bip39";
+import { wordlist as english } from "@scure/bip39/wordlists/english";
+import { createHash } from "crypto";
+import { logger } from '../../lib/logger.js'
+
+/**
+ * Initialize Storacha client with key/proof credentials
+ */
+export async function initializeStorachaClient(storachaKey, storachaProof) {
+  try {
+    logger.info("🔐 Initializing Storacha client with credentials...");
+
+    const principal = Signer.parse(storachaKey);
+    const store = new StoreMemory();
+    const client = await Client.create({ principal, store });
+
+    const proof = await Proof.parse(storachaProof);
+    const space = await client.addSpace(proof);
+    await client.setCurrentSpace(space.did());
+
+    logger.info(`✅ Storacha client initialized with space: ${space.did()}`);
+    return client;
+  } catch (error) {
+    logger.error("❌ Failed to initialize Storacha client:", error);
+    throw error;
+  }
+}
+
+/**
+ * Initialize Storacha client with UCAN delegation
+ */
+export async function initializeStorachaClientWithUCAN(
+  ucanToken,
+  recipientKey,
+) {
+  try {
+    logger.info("🔐 Initializing Storacha client with UCAN...");
+
+    // Parse recipient identity from JSON archive
+    const recipientKeyData = JSON.parse(recipientKey);
+    const fixedArchive = {
+      id: recipientKeyData.id,
+      keys: {
+        [recipientKeyData.id]: new Uint8Array(
+          Object.values(recipientKeyData.keys[recipientKeyData.id]),
+        ),
+      },
+    };
+
+    const recipientPrincipal = Signer.from(fixedArchive);
+    const store = new StoreMemory();
+    const client = await Client.create({
+      principal: recipientPrincipal,
+      store,
+    });
+
+    // Parse delegation token
+    const delegationBytes = Buffer.from(ucanToken, "base64");
+    const delegation = await Delegation.extract(delegationBytes);
+
+    if (!delegation.ok) {
+      throw new Error("Failed to extract delegation from token");
+    }
+
+    // Add space using delegation
+    const space = await client.addSpace(delegation.ok);
+    await client.setCurrentSpace(space.did());
+
+    logger.info(
+      `✅ Storacha client initialized with UCAN space: ${space.did()}`,
+    );
+    return client;
+  } catch (error) {
+    logger.error("❌ Failed to initialize Storacha client with UCAN:", error);
+    throw error;
+  }
+}
+
+/**
+ * Convert 64-bit seed to 32-bit seed (same as deContact)
+ */
+function convertTo32BitSeed(origSeed) {
+  const hash = createHash("sha256");
+  hash.update(Buffer.from(origSeed, "hex"));
+  return hash.digest();
+}
+
+// Convert Uint8Array to hex (browser-safe)
+function toHex(u8) {
+  return Array.from(u8)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/**
+ * Generate master seed from mnemonic
+ */
+function generateMasterSeed(mnemonicSeedphrase, password = "password") {
+  return toHex(mnemonicToSeedSync(mnemonicSeedphrase, password));
+}
+
+/**
+ * Create Storacha identity from seed phrase
+ */
+export async function createStorachaIdentityFromSeed(
+  seedPhrase,
+  password = "password",
+  derivationIndex = 1,
+) {
+  try {
+    logger.info("🌱 Creating Storacha identity from seed phrase...");
+
+    const masterSeed = generateMasterSeed(seedPhrase, password);
+    const seed32 = convertTo32BitSeed(masterSeed);
+
+    // Create derived seed for Storacha (different from OrbitDB)
+    const derivedSeed = new Uint8Array(32);
+    derivedSeed.set(seed32);
+    derivedSeed[31] ^= derivationIndex; // Derivation index
+
+    const principal = await ed25519.derive(derivedSeed);
+    const signer = Signer.from(principal.toArchive());
+
+    logger.info(`✅ Storacha identity created: ${signer.did()}`);
+    return {
+      principal: signer,
+      did: signer.did(),
+      privateKey: signer.toArchive(),
+      seedPhrase,
+      masterSeed,
+    };
+  } catch (error) {
+    logger.error("❌ Failed to create Storacha identity from seed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Initialize Storacha client with seed-derived identity and delegation
+ */
+export async function initializeStorachaClientWithSeed(
+  seedPhrase,
+  password = "password",
+  delegationToken = null,
+) {
+  try {
+    logger.info("🌱 Initializing Storacha client with seed phrase...");
+
+    const identity = await createStorachaIdentityFromSeed(seedPhrase, password);
+    const store = new StoreMemory();
+    const client = await Client.create({
+      principal: identity.principal,
+      store,
+    });
+
+    if (delegationToken) {
+      // Use provided delegation
+      const delegationBytes = Buffer.from(delegationToken, "base64");
+      const delegation = await Delegation.extract(delegationBytes);
+
+      if (!delegation.ok) {
+        throw new Error("Failed to extract delegation from token");
+      }
+
+      const space = await client.addSpace(delegation.ok);
+      await client.setCurrentSpace(space.did());
+
+      logger.info(
+        `✅ Storacha client initialized with seed + delegation: ${space.did()}`,
+      );
+    } else {
+      logger.info(
+        `✅ Storacha client initialized with seed identity: ${identity.did}`,
+      );
+      logger.info("⚠️ No delegation provided - limited functionality");
+    }
+
+    return { client, identity };
+  } catch (error) {
+    logger.error("❌ Failed to initialize Storacha client with seed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Create new Storacha account with email (placeholder - requires w3 CLI integration)
+ */
+export async function createStorachaAccount(email) {
+  try {
+    logger.info(`📧 Creating Storacha account for: ${email}`);
+
+    // This is a placeholder - in reality, this would integrate with w3 CLI
+    // or require the user to manually create an account
+    return {
+      success: false,
+      message:
+        "Account creation requires manual setup. Please visit web3.storage to create an account and get your credentials.",
+      error: "Manual setup required",
+    };
+  } catch (error) {
+    logger.error("❌ Failed to create Storacha account:", error);
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * List spaces for authenticated client
+ */
+export async function listSpaces(client) {
+  try {
+    logger.info("📋 Listing Storacha spaces...");
+
+    const spaces = [];
+
+    // Try to get current space
+    const currentSpace = client.currentSpace();
+    if (currentSpace) {
+      spaces.push({
+        did: currentSpace.did(),
+        name: currentSpace.name || "Current Space",
+      });
+    }
+
+    // Try to get accounts and their spaces
+    try {
+      const accounts = client.accounts();
+      for (const account of accounts) {
+        const accountSpaces = account.spaces();
+        for (const space of accountSpaces) {
+          const spaceInfo = {
+            did: space.did(),
+            name: space.name || "Unnamed Space",
+          };
+
+          // Avoid duplicates
+          if (!spaces.find((s) => s.did === spaceInfo.did)) {
+            spaces.push(spaceInfo);
+          }
+        }
+      }
+    } catch (accountError) {
+      logger.warn("⚠️ Could not list account spaces:", accountError.message);
+    }
+
+    logger.info(`✅ Found ${spaces.length} spaces`);
+    return spaces;
+  } catch (error) {
+    logger.error("❌ Failed to list spaces:", error);
+    throw error;
+  }
+}
+
+/**
+ * Create new space
+ */
+export async function createSpace(client, spaceName) {
+  try {
+    logger.info(`🆕 Creating space: ${spaceName}`);
+
+    // This requires account-based authentication
+    const accounts = client.accounts();
+    if (accounts.length === 0) {
+      throw new Error(
+        "No accounts found - space creation requires account-based authentication",
+      );
+    }
+
+    const account = accounts[0];
+    const space = await account.createSpace(spaceName);
+
+    logger.info(`✅ Space created: ${space.did()}`);
+    return {
+      success: true,
+      space: {
+        did: space.did(),
+        name: spaceName,
+      },
+    };
+  } catch (error) {
+    logger.error("❌ Failed to create space:", error);
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * Generate a new seed phrase
+ */
+export function generateSeedPhrase() {
+  return generateMnemonic(english);
+}
+
+/**
+ * Validate seed phrase
+ */
+export function validateSeedPhrase(seedPhrase) {
+  try {
+    // Basic validation - check if it's a valid mnemonic
+    const words = seedPhrase.trim().split(/\s+/);
+    return words.length >= 12 && words.length <= 24;
+  } catch (error) {
+    return false;
+  }
+}

package/dist/components/theme.js

@@ -0,0 +1,79 @@
+import { writable } from "svelte/store";
+import { logger } from '../../lib/logger.js'
+
+// Create a writable store for the theme
+function createThemeStore() {
+  // Initialize theme based on system preference or localStorage
+  const getInitialTheme = () => {
+    const stored = localStorage.getItem("carbon-theme");
+    if (stored) return stored;
+
+    // Check system preference
+    if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+      return "g100"; // Carbon dark theme
+    }
+
+    return "white"; // Carbon light theme
+  };
+
+  const { subscribe, set, update } = writable(getInitialTheme());
+
+  return {
+    subscribe,
+    set: (newTheme) => {
+      localStorage.setItem("carbon-theme", newTheme);
+      document.documentElement.setAttribute("theme", newTheme);
+      document.documentElement.style.setProperty(
+        "color-scheme",
+        newTheme === "g100" ? "dark" : "light",
+      );
+      logger.info("Theme set to:", newTheme);
+      set(newTheme);
+    },
+    toggle: () => {
+      let currentTheme;
+      update((theme) => {
+        currentTheme = theme === "white" ? "g100" : "white";
+        localStorage.setItem("carbon-theme", currentTheme);
+        document.documentElement.setAttribute("theme", currentTheme);
+        document.documentElement.style.setProperty(
+          "color-scheme",
+          currentTheme === "g100" ? "dark" : "light",
+        );
+        logger.info("Theme toggled to:", currentTheme);
+        return currentTheme;
+      });
+    },
+    init: () => {
+      const initialTheme = getInitialTheme();
+      logger.info("Initializing theme:", initialTheme);
+
+      // Apply theme to document
+      document.documentElement.setAttribute("theme", initialTheme);
+      document.documentElement.style.setProperty(
+        "color-scheme",
+        initialTheme === "g100" ? "dark" : "light",
+      );
+
+      // Update store
+      set(initialTheme);
+
+      // Listen for system theme changes if the user hasn't chosen a theme
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      mediaQuery.addEventListener("change", (e) => {
+        if (!localStorage.getItem("carbon-theme")) {
+          const newTheme = e.matches ? "g100" : "white";
+          logger.info("System theme changed to:", newTheme);
+          document.documentElement.setAttribute("theme", newTheme);
+          document.documentElement.style.setProperty(
+            "color-scheme",
+            newTheme === "g100" ? "dark" : "light",
+          );
+          set(newTheme);
+        }
+      });
+    },
+  };
+}
+
+export const theme = createThemeStore();

package/lib/backends/aleph-pin.js

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Making Aleph keep something: the STORE message, and nothing else.
+ *
+ * `createAlephBackend` stores without a key and says plainly that it does not
+ * retain. This is the other half — and it is deliberately a separate module,
+ * because the two have different requirements and only one of them needs a
+ * wallet. An application that only ever reads, or only ever uploads, should
+ * never have to load this file.
+ *
+ * ## No tokens move
+ *
+ * The wallet **signs a string**. Aleph then checks that the signing address has
+ * enough balance or credit to cover what it is being asked to keep. There is no
+ * transaction, no gas and no transfer: the token is the evidence, not the
+ * payment. Worth stating because "pay for storage with a wallet" reads as the
+ * opposite.
+ *
+ * ## Injected, not imported
+ *
+ * `sign` has the shape of `personal_sign` — `(address, message) => signature` —
+ * which is what a browser wallet provides and what a Node signer can wrap. So
+ * this module imports no wallet, no SDK and no key, and **no key ever passes
+ * through the library**. In a browser the key never leaves the wallet at all.
+ *
+ * ## The format, and where each part was established
+ *
+ * The envelope, the hash and the signing payload are taken from `relay-button`,
+ * which posts INSTANCE and AGGREGATE messages through the same route:
+ *
+ *     item_content = JSON.stringify(content)
+ *     item_hash    = sha256hex(item_content)
+ *     signed       = sign(sender, [chain, sender, type, item_hash].join("\n"))
+ *
+ * The STORE *content* is the one part not in that codebase, and was confirmed
+ * against `api2.aleph.im` on 2026-09-09 — a correctly shaped message with a
+ * deliberately invalid signature is accepted with **202** and left pending,
+ * which separates "the schema is wrong" from "the signature is wrong".
+ *
+ * One trap, since it costs nothing to name: the content carries its *own*
+ * `item_type` and `item_hash`, and they mean something different from the
+ * envelope's. In the envelope they say "the message body is inline". In the
+ * content they say "the thing to keep is this IPFS CID".
+ *
+ * @author @NiKrause
+ * @requires ./aleph.js - the backend this supplies `pin` to
+ */
+
+import { BackendError } from "./types.js";
+
+export const DEFAULT_ALEPH_API_HOST = "https://api2.aleph.im";
+export const DEFAULT_ALEPH_CHANNEL = "ALEPH-CLOUDSOLUTIONS";
+
+/** Hex sha-256 of a string, via WebCrypto — present in browsers and in Node 18+. */
+async function sha256Hex(payload) {
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(payload),
+  );
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+/**
+ * Build the unsigned STORE message for a CID.
+ *
+ * Exported so it can be tested without a wallet, and read without running one.
+ *
+ * @param {object} args
+ * @param {string} args.sender - the wallet address
+ * @param {string} args.cid - what to keep
+ * @param {string} [args.channel]
+ * @param {number} [args.now] - seconds; injected so a test is not a clock
+ * @param {(payload: string) => Promise<string>} [args.hasher]
+ */
+export async function buildStoreMessage({ sender, cid, channel = DEFAULT_ALEPH_CHANNEL, now, hasher = sha256Hex }) {
+  const time = now ?? Date.now() / 1000;
+  const content = {
+    address: sender,
+    // "the thing to keep is an IPFS CID" — not the envelope's item_type
+    item_type: "ipfs",
+    item_hash: cid,
+    time,
+  };
+  const item_content = JSON.stringify(content);
+
+  return {
+    sender,
+    chain: "ETH",
+    type: "STORE",
+    item_hash: await hasher(item_content),
+    item_type: "inline",
+    item_content,
+    time,
+    channel,
+  };
+}
+
+/** What the wallet actually puts its name to. */
+export const signaturePayload = (message) =>
+  [message.chain, message.sender, message.type, message.item_hash].join("\n");
+
+/**
+ * A `pin` function for {@link createAlephBackend}.
+ *
+ * @param {object} options
+ * @param {string} options.sender - the wallet address doing the keeping
+ * @param {(address: string, message: string) => Promise<string>} options.sign -
+ *   `personal_sign`, or anything shaped like it. The library never sees a key.
+ * @param {string} [options.apiHost]
+ * @param {string} [options.channel]
+ * @param {(payload: string) => Promise<string>} [options.hasher]
+ * @param {typeof fetch} [options.fetch]
+ * @param {() => number} [options.now] - seconds
+ * @returns {(cid: string, meta?: object) => Promise<{ itemHash: string, status: string }>}
+ */
+export function createAlephPin(options = {}) {
+  const { sender, sign } = options;
+  const apiHost = options.apiHost || DEFAULT_ALEPH_API_HOST;
+  const channel = options.channel || DEFAULT_ALEPH_CHANNEL;
+  const hasher = options.hasher || sha256Hex;
+  const doFetch = options.fetch || globalThis.fetch;
+  const now = options.now;
+
+  if (!sender) throw new BackendError("INVALID_BACKEND", "createAlephPin needs the wallet address as `sender`");
+  if (typeof sign !== "function") throw new BackendError("INVALID_BACKEND", "createAlephPin needs a `sign` function");
+  if (typeof doFetch !== "function") throw new BackendError("INVALID_BACKEND", "createAlephPin needs fetch");
+
+  return async function pin(cid) {
+    const unsigned = await buildStoreMessage({ sender, cid, channel, hasher, now: now?.() });
+    const signature = await sign(sender, signaturePayload(unsigned));
+    const message = {
+      ...unsigned,
+      signature: signature.startsWith("0x") ? signature : `0x${signature}`,
+    };
+
+    const response = await doFetch(`${apiHost}/api/v0/messages`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ message, sync: true }),
+    });
+
+    // 202 means Aleph took the message, not that it kept the file: the
+    // signature and the balance are checked afterwards. Reporting it as done
+    // would be the exact lie this module exists to avoid, so the caller gets
+    // the status it was given.
+    if (!response.ok && response.status !== 202) {
+      const detail = await response.text().catch(() => "");
+      throw new BackendError(
+        "UNSUPPORTED",
+        `Aleph refused the STORE message: ${response.status} ${detail.slice(0, 200)}`,
+      );
+    }
+
+    const body = await response.json().catch(() => ({}));
+    return {
+      itemHash: unsigned.item_hash,
+      status: body?.message_status ?? "pending",
+    };
+  };
+}
+
+export default createAlephPin;