@unicitylabs/sphere-sdk 0.1.2 → 0.1.4

package/dist/impl/browser/ipfs.cjs

@@ -0,0 +1,1112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// impl/browser/ipfs.ts
+var ipfs_exports = {};
+__export(ipfs_exports, {
+  IpfsStorageProvider: () => IpfsStorageProvider,
+  createIpfsStorageProvider: () => createIpfsStorageProvider
+});
+module.exports = __toCommonJS(ipfs_exports);
+
+// constants.ts
+var STORAGE_PREFIX = "sphere_";
+var STORAGE_KEYS = {
+  /** Encrypted BIP39 mnemonic */
+  MNEMONIC: `${STORAGE_PREFIX}mnemonic`,
+  /** Encrypted master private key */
+  MASTER_KEY: `${STORAGE_PREFIX}master_key`,
+  /** BIP32 chain code */
+  CHAIN_CODE: `${STORAGE_PREFIX}chain_code`,
+  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
+  DERIVATION_PATH: `${STORAGE_PREFIX}derivation_path`,
+  /** Base derivation path (like m/44'/0'/0' without chain/index) */
+  BASE_PATH: `${STORAGE_PREFIX}base_path`,
+  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
+  DERIVATION_MODE: `${STORAGE_PREFIX}derivation_mode`,
+  /** Wallet source: mnemonic, file, unknown */
+  WALLET_SOURCE: `${STORAGE_PREFIX}wallet_source`,
+  /** Wallet existence flag */
+  WALLET_EXISTS: `${STORAGE_PREFIX}wallet_exists`,
+  /** Registered nametag (legacy - single address) */
+  NAMETAG: `${STORAGE_PREFIX}nametag`,
+  /** Current active address index */
+  CURRENT_ADDRESS_INDEX: `${STORAGE_PREFIX}current_address_index`,
+  /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
+  ADDRESS_NAMETAGS: `${STORAGE_PREFIX}address_nametags`,
+  /** Token data */
+  TOKENS: `${STORAGE_PREFIX}tokens`,
+  /** Pending transfers */
+  PENDING_TRANSFERS: `${STORAGE_PREFIX}pending_transfers`,
+  /** Transfer outbox */
+  OUTBOX: `${STORAGE_PREFIX}outbox`,
+  /** Conversations */
+  CONVERSATIONS: `${STORAGE_PREFIX}conversations`,
+  /** Messages */
+  MESSAGES: `${STORAGE_PREFIX}messages`,
+  /** Transaction history */
+  TRANSACTION_HISTORY: `${STORAGE_PREFIX}transaction_history`,
+  /** Archived tokens (spent token history) */
+  ARCHIVED_TOKENS: `${STORAGE_PREFIX}archived_tokens`,
+  /** Tombstones (records of deleted/spent tokens) */
+  TOMBSTONES: `${STORAGE_PREFIX}tombstones`,
+  /** Forked tokens (alternative histories) */
+  FORKED_TOKENS: `${STORAGE_PREFIX}forked_tokens`
+};
+var DEFAULT_IPFS_GATEWAYS = [
+  "https://ipfs.unicity.network",
+  "https://dweb.link",
+  "https://ipfs.io"
+];
+var DEFAULT_IPFS_BOOTSTRAP_PEERS = [
+  "/dns4/unicity-ipfs2.dyndns.org/tcp/4001/p2p/12D3KooWLNi5NDPPHbrfJakAQqwBqymYTTwMQXQKEWuCrJNDdmfh",
+  "/dns4/unicity-ipfs3.dyndns.org/tcp/4001/p2p/12D3KooWQ4aujVE4ShLjdusNZBdffq3TbzrwT2DuWZY9H1Gxhwn6",
+  "/dns4/unicity-ipfs4.dyndns.org/tcp/4001/p2p/12D3KooWJ1ByPfUzUrpYvgxKU8NZrR8i6PU1tUgMEbQX9Hh2DEn1",
+  "/dns4/unicity-ipfs5.dyndns.org/tcp/4001/p2p/12D3KooWB1MdZZGHN5B8TvWXntbycfe7Cjcz7n6eZ9eykZadvmDv"
+];
+var DEFAULT_BASE_PATH = "m/44'/0'/0'";
+var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/hmac.js
+var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash(hash);
+    abytes(key, void 0, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    abytes(out, this.outputLen, "output");
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new _HMAC(hash, key);
+
+// node_modules/@noble/hashes/hkdf.js
+function extract(hash, ikm, salt) {
+  ahash(hash);
+  if (salt === void 0)
+    salt = new Uint8Array(hash.outputLen);
+  return hmac(hash, salt, ikm);
+}
+var HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+var EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+function expand(hash, prk, info, length = 32) {
+  ahash(hash);
+  anumber(length, "length");
+  const olen = hash.outputLen;
+  if (length > 255 * olen)
+    throw new Error("Length must be <= 255*HashLen");
+  const blocks = Math.ceil(length / olen);
+  if (info === void 0)
+    info = EMPTY_BUFFER;
+  else
+    abytes(info, void 0, "info");
+  const okm = new Uint8Array(blocks * olen);
+  const HMAC = hmac.create(hash, prk);
+  const HMACTmp = HMAC._cloneInto();
+  const T = new Uint8Array(HMAC.outputLen);
+  for (let counter = 0; counter < blocks; counter++) {
+    HKDF_COUNTER[0] = counter + 1;
+    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T);
+    okm.set(T, olen * counter);
+    HMAC._cloneInto(HMACTmp);
+  }
+  HMAC.destroy();
+  HMACTmp.destroy();
+  clean(T, HKDF_COUNTER);
+  return okm.slice(0, length);
+}
+var hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// impl/browser/storage/IpfsStorageProvider.ts
+var heliaModule = null;
+var heliaJsonModule = null;
+var libp2pBootstrapModule = null;
+var libp2pCryptoModule = null;
+var libp2pPeerIdModule = null;
+var multiformatsCidModule = null;
+async function loadHeliaModules() {
+  if (!heliaModule) {
+    [
+      heliaModule,
+      heliaJsonModule,
+      libp2pBootstrapModule,
+      libp2pCryptoModule,
+      libp2pPeerIdModule,
+      multiformatsCidModule
+    ] = await Promise.all([
+      import("helia"),
+      import("@helia/json"),
+      import("@libp2p/bootstrap"),
+      import("@libp2p/crypto/keys"),
+      import("@libp2p/peer-id"),
+      import("multiformats/cid")
+    ]);
+  }
+  return {
+    createHelia: heliaModule.createHelia,
+    json: heliaJsonModule.json,
+    bootstrap: libp2pBootstrapModule.bootstrap,
+    generateKeyPairFromSeed: libp2pCryptoModule.generateKeyPairFromSeed,
+    peerIdFromPrivateKey: libp2pPeerIdModule.peerIdFromPrivateKey,
+    CID: multiformatsCidModule.CID
+  };
+}
+var HKDF_INFO = new TextEncoder().encode("ipfs-storage-key");
+var IpfsStorageProvider = class {
+  id = "ipfs";
+  name = "IPFS Storage";
+  type = "p2p";
+  description = "Decentralized storage via IPFS/IPNS";
+  config;
+  identity = null;
+  status = "disconnected";
+  ipnsName = null;
+  lastCid = null;
+  eventCallbacks = /* @__PURE__ */ new Set();
+  // Helia instance for browser-based IPFS
+  helia = null;
+  heliaJson = null;
+  ipnsKeyPair = null;
+  /** Get the last published CID */
+  getLastCid() {
+    return this.lastCid;
+  }
+  // Local cache for faster loads
+  localCache = null;
+  cacheTimestamp = 0;
+  constructor(config) {
+    this.config = {
+      gateways: config?.gateways ?? [...DEFAULT_IPFS_GATEWAYS],
+      bootstrapPeers: config?.bootstrapPeers ?? [...DEFAULT_IPFS_BOOTSTRAP_PEERS],
+      enableIpns: config?.enableIpns ?? true,
+      ipnsTimeout: config?.ipnsTimeout ?? 3e4,
+      fetchTimeout: config?.fetchTimeout ?? 15e3,
+      debug: config?.debug ?? false
+    };
+  }
+  // ===========================================================================
+  // BaseProvider Implementation
+  // ===========================================================================
+  async connect() {
+    if (this.status === "connected") return;
+    this.status = "connecting";
+    try {
+      await this.testGatewayConnectivity();
+      await this.initializeHelia();
+      this.status = "connected";
+      this.log("Connected to IPFS gateways and Helia initialized");
+    } catch (error) {
+      this.status = "error";
+      throw new Error(`IPFS connection failed: ${error}`);
+    }
+  }
+  /**
+   * Initialize Helia browser IPFS node
+   */
+  async initializeHelia() {
+    if (this.helia) return;
+    try {
+      this.log("Initializing Helia with bootstrap peers...");
+      const { createHelia, json, bootstrap } = await loadHeliaModules();
+      this.helia = await createHelia({
+        libp2p: {
+          peerDiscovery: [
+            bootstrap({ list: this.config.bootstrapPeers })
+          ],
+          connectionManager: {
+            maxConnections: 10
+          }
+        }
+      });
+      this.heliaJson = json(this.helia);
+      const peerId = this.helia.libp2p.peerId.toString();
+      this.log("Helia initialized, browser peer ID:", peerId.slice(0, 20) + "...");
+      setTimeout(() => {
+        const connections = this.helia?.libp2p.getConnections() || [];
+        this.log(`Active Helia connections: ${connections.length}`);
+      }, 3e3);
+    } catch (error) {
+      this.log("Helia initialization failed (will use HTTP only):", error);
+    }
+  }
+  async disconnect() {
+    if (this.helia) {
+      try {
+        await this.helia.stop();
+      } catch (error) {
+        this.log("Error stopping Helia:", error);
+      }
+      this.helia = null;
+      this.heliaJson = null;
+    }
+    this.status = "disconnected";
+    this.localCache = null;
+    this.ipnsKeyPair = null;
+    this.log("Disconnected from IPFS");
+  }
+  isConnected() {
+    return this.status === "connected";
+  }
+  getStatus() {
+    return this.status;
+  }
+  // ===========================================================================
+  // TokenStorageProvider Implementation
+  // ===========================================================================
+  async setIdentity(identity) {
+    this.identity = identity;
+    try {
+      const { generateKeyPairFromSeed, peerIdFromPrivateKey } = await loadHeliaModules();
+      const walletSecret = this.hexToBytes(identity.privateKey);
+      const derivedKey = hkdf(sha256, walletSecret, void 0, HKDF_INFO, 32);
+      this.ipnsKeyPair = await generateKeyPairFromSeed("Ed25519", derivedKey);
+      const peerId = peerIdFromPrivateKey(this.ipnsKeyPair);
+      this.ipnsName = peerId.toString();
+      this.log("Identity set, IPNS name:", this.ipnsName);
+    } catch {
+      this.ipnsName = identity.ipnsName ?? this.deriveIpnsNameSimple(identity.privateKey);
+      this.log("Identity set with fallback IPNS name:", this.ipnsName);
+    }
+  }
+  async initialize() {
+    if (!this.identity) {
+      throw new Error("Identity must be set before initialization");
+    }
+    try {
+      await this.connect();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async shutdown() {
+    await this.disconnect();
+  }
+  async save(data) {
+    this.ensureReady();
+    this.emitEvent({ type: "storage:saving", timestamp: Date.now() });
+    try {
+      const dataToSave = {
+        ...data,
+        _meta: {
+          ...data._meta,
+          updatedAt: Date.now(),
+          ipnsName: this.ipnsName ?? void 0
+        }
+      };
+      const cid = await this.publishToGateways(dataToSave);
+      if (this.config.enableIpns && this.ipnsName) {
+        await this.publishIpns(cid);
+      }
+      this.localCache = dataToSave;
+      this.cacheTimestamp = Date.now();
+      this.lastCid = cid;
+      this.emitEvent({ type: "storage:saved", timestamp: Date.now(), data: { cid } });
+      return {
+        success: true,
+        cid,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.emitEvent({ type: "storage:error", timestamp: Date.now(), error: errorMsg });
+      return {
+        success: false,
+        error: errorMsg,
+        timestamp: Date.now()
+      };
+    }
+  }
+  async load(identifier) {
+    this.ensureReady();
+    this.emitEvent({ type: "storage:loading", timestamp: Date.now() });
+    try {
+      const cacheAge = Date.now() - this.cacheTimestamp;
+      if (this.localCache && cacheAge < 6e4) {
+        this.log("Returning cached data");
+        return {
+          success: true,
+          data: this.localCache,
+          source: "cache",
+          timestamp: Date.now()
+        };
+      }
+      let cid = identifier ?? null;
+      if (!cid && this.config.enableIpns && this.ipnsName) {
+        cid = await this.resolveIpns(this.ipnsName);
+      }
+      if (!cid) {
+        return {
+          success: true,
+          data: void 0,
+          source: "remote",
+          timestamp: Date.now()
+        };
+      }
+      const data = await this.fetchFromGateways(cid);
+      this.localCache = data;
+      this.cacheTimestamp = Date.now();
+      this.lastCid = cid;
+      this.emitEvent({ type: "storage:loaded", timestamp: Date.now() });
+      return {
+        success: true,
+        data,
+        source: "remote",
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.emitEvent({ type: "storage:error", timestamp: Date.now(), error: errorMsg });
+      if (this.localCache) {
+        return {
+          success: true,
+          data: this.localCache,
+          source: "cache",
+          timestamp: Date.now()
+        };
+      }
+      return {
+        success: false,
+        error: errorMsg,
+        source: "remote",
+        timestamp: Date.now()
+      };
+    }
+  }
+  async sync(localData) {
+    this.ensureReady();
+    this.emitEvent({ type: "sync:started", timestamp: Date.now() });
+    try {
+      const remoteResult = await this.load();
+      const remoteData = remoteResult.data;
+      if (!remoteData) {
+        await this.save(localData);
+        this.emitEvent({ type: "sync:completed", timestamp: Date.now() });
+        return {
+          success: true,
+          merged: localData,
+          added: 0,
+          removed: 0,
+          conflicts: 0
+        };
+      }
+      const mergeResult = this.mergeData(localData, remoteData);
+      await this.save(mergeResult.merged);
+      this.emitEvent({ type: "sync:completed", timestamp: Date.now() });
+      return {
+        success: true,
+        merged: mergeResult.merged,
+        added: mergeResult.added,
+        removed: mergeResult.removed,
+        conflicts: mergeResult.conflicts
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.emitEvent({ type: "sync:error", timestamp: Date.now(), error: errorMsg });
+      return {
+        success: false,
+        added: 0,
+        removed: 0,
+        conflicts: 0,
+        error: errorMsg
+      };
+    }
+  }
+  async exists() {
+    if (!this.ipnsName) return false;
+    try {
+      const cid = await this.resolveIpns(this.ipnsName);
+      return cid !== null;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    const emptyData = {
+      _meta: {
+        version: 0,
+        address: this.identity?.l1Address ?? "",
+        formatVersion: "2.0",
+        updatedAt: Date.now()
+      },
+      _tombstones: []
+    };
+    const result = await this.save(emptyData);
+    return result.success;
+  }
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => this.eventCallbacks.delete(callback);
+  }
+  // ===========================================================================
+  // Private: IPFS Operations
+  // ===========================================================================
+  async testGatewayConnectivity() {
+    const gateway = this.config.gateways[0];
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch(`${gateway}/api/v0/version`, {
+        method: "POST",
+        signal: controller.signal
+      });
+      if (!response.ok) throw new Error("Gateway not responding");
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async publishToGateways(data) {
+    const content = JSON.stringify(data);
+    const blob = new Blob([content], { type: "application/json" });
+    const promises = [];
+    for (const gateway of this.config.gateways) {
+      promises.push(this.publishToGateway(gateway, blob));
+    }
+    if (this.heliaJson) {
+      promises.push(this.publishToHelia(data));
+    }
+    try {
+      const cid = await Promise.any(promises);
+      this.log("Published to IPFS, CID:", cid);
+      return cid;
+    } catch {
+      throw new Error("All publish attempts failed");
+    }
+  }
+  /**
+   * Publish data via Helia (browser DHT)
+   */
+  async publishToHelia(data) {
+    if (!this.heliaJson) {
+      throw new Error("Helia not initialized");
+    }
+    const cid = await this.heliaJson.add(data);
+    this.log("Published via Helia, CID:", cid.toString());
+    return cid.toString();
+  }
+  async publishToGateway(gateway, blob) {
+    const formData = new FormData();
+    formData.append("file", blob);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
+    try {
+      const response = await fetch(`${gateway}/api/v0/add?pin=true`, {
+        method: "POST",
+        body: formData,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Gateway ${gateway} returned ${response.status}`);
+      }
+      const result = await response.json();
+      return result.Hash;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async publishIpns(cid) {
+    if (!this.identity) return;
+    const promises = this.config.gateways.map(
+      (gateway) => this.publishIpnsToGateway(gateway, cid).catch(() => null)
+    );
+    await Promise.allSettled(promises);
+    this.log("Published IPNS:", this.ipnsName, "->", cid);
+  }
+  async publishIpnsToGateway(gateway, cid) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.ipnsTimeout);
+    try {
+      const response = await fetch(
+        `${gateway}/api/v0/name/publish?arg=${cid}&key=${this.ipnsName}`,
+        {
+          method: "POST",
+          signal: controller.signal
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`IPNS publish failed: ${response.status}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async resolveIpns(name) {
+    for (const gateway of this.config.gateways) {
+      try {
+        return await this.resolveIpnsFromGateway(gateway, name);
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  async resolveIpnsFromGateway(gateway, name) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
+    try {
+      const response = await fetch(`${gateway}/api/v0/name/resolve?arg=${name}`, {
+        method: "POST",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`IPNS resolve failed: ${response.status}`);
+      }
+      const result = await response.json();
+      return result.Path.replace("/ipfs/", "");
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async fetchFromGateways(cid) {
+    const promises = [];
+    for (const gateway of this.config.gateways) {
+      promises.push(this.fetchFromGateway(gateway, cid));
+    }
+    if (this.heliaJson) {
+      promises.push(this.fetchFromHelia(cid));
+    }
+    return Promise.any(promises);
+  }
+  /**
+   * Fetch content via Helia (browser DHT)
+   */
+  async fetchFromHelia(cidString) {
+    if (!this.heliaJson) {
+      throw new Error("Helia not initialized");
+    }
+    const { CID } = await loadHeliaModules();
+    const cid = CID.parse(cidString);
+    const data = await this.heliaJson.get(cid);
+    this.log("Fetched via Helia, CID:", cidString);
+    return data;
+  }
+  async fetchFromGateway(gateway, cid) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
+    try {
+      const response = await fetch(`${gateway}/ipfs/${cid}`, {
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Fetch failed: ${response.status}`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  // ===========================================================================
+  // Private: Merge Logic
+  // ===========================================================================
+  mergeData(local, remote) {
+    const localVersion = local._meta?.version ?? 0;
+    const remoteVersion = remote._meta?.version ?? 0;
+    const baseMeta = remoteVersion > localVersion ? remote._meta : local._meta;
+    const tombstones = /* @__PURE__ */ new Map();
+    for (const t of local._tombstones ?? []) {
+      tombstones.set(t.tokenId, t);
+    }
+    for (const t of remote._tombstones ?? []) {
+      const existing = tombstones.get(t.tokenId);
+      if (!existing || t.timestamp > existing.timestamp) {
+        tombstones.set(t.tokenId, t);
+      }
+    }
+    const merged = {
+      _meta: {
+        ...baseMeta,
+        version: Math.max(localVersion, remoteVersion) + 1,
+        updatedAt: Date.now()
+      },
+      _tombstones: Array.from(tombstones.values())
+    };
+    let added = 0;
+    let conflicts = 0;
+    const processedKeys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(local)) {
+      if (!key.startsWith("_") || key === "_meta" || key === "_tombstones") continue;
+      processedKeys.add(key);
+      const tokenId = key.slice(1);
+      if (tombstones.has(tokenId)) continue;
+      const localToken = local[key];
+      const remoteToken = remote[key];
+      if (remoteToken) {
+        conflicts++;
+        merged[key] = localToken;
+      } else {
+        merged[key] = localToken;
+      }
+    }
+    for (const key of Object.keys(remote)) {
+      if (!key.startsWith("_") || key === "_meta" || key === "_tombstones") continue;
+      if (processedKeys.has(key)) continue;
+      const tokenId = key.slice(1);
+      if (tombstones.has(tokenId)) continue;
+      merged[key] = remote[key];
+      added++;
+    }
+    return { merged, added, removed: 0, conflicts };
+  }
+  // ===========================================================================
+  // Private: Helpers
+  // ===========================================================================
+  ensureReady() {
+    if (this.status !== "connected") {
+      throw new Error("IpfsStorageProvider not connected");
+    }
+    if (!this.identity) {
+      throw new Error("Identity not set");
+    }
+  }
+  /**
+   * Simple IPNS name derivation (fallback when libp2p is unavailable)
+   */
+  deriveIpnsNameSimple(privateKey) {
+    return `12D3KooW${privateKey.slice(0, 40)}`;
+  }
+  /**
+   * Convert hex string to Uint8Array
+   */
+  hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return bytes;
+  }
+  emitEvent(event) {
+    for (const callback of this.eventCallbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        console.error("[IpfsStorageProvider] Event callback error:", error);
+      }
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[IpfsStorageProvider]", ...args);
+    }
+  }
+};
+function createIpfsStorageProvider(config) {
+  return new IpfsStorageProvider(config);
+}
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=ipfs.cjs.map