@inversealtruism/cairn-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,873 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BoardClient: () => BoardClient,
+  Cairn: () => Cairn,
+  CairnError: () => CairnError,
+  Chain: () => Chain,
+  ContentClient: () => ContentClient,
+  ContentVerificationError: () => ContentVerificationError,
+  Http: () => Http,
+  HttpError: () => HttpError,
+  IndexerClient: () => IndexerClient,
+  NotInstalledError: () => NotInstalledError,
+  RegistryClient: () => RegistryClient,
+  UnsupportedMethodError: () => UnsupportedMethodError,
+  UserRejectedError: () => UserRejectedError,
+  WalletConnection: () => WalletConnection,
+  WalletLockedError: () => WalletLockedError,
+  connect: () => connect,
+  detectProvider: () => detectProvider,
+  getWallet: () => getWallet,
+  isInstalled: () => isInstalled
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CairnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var NotInstalledError = class extends CairnError {
+  constructor(message = "Cairn Wallet not detected. Install it from cairn-substrate.com.") {
+    super(message);
+  }
+};
+var UserRejectedError = class extends CairnError {
+  constructor(message = "Request rejected by user.") {
+    super(message);
+  }
+};
+var WalletLockedError = class extends CairnError {
+  constructor(message = "Wallet is locked.") {
+    super(message);
+  }
+};
+var UnsupportedMethodError = class extends CairnError {
+  constructor(message = "Method not supported by the wallet.") {
+    super(message);
+  }
+};
+var HttpError = class extends CairnError {
+  status;
+  url;
+  body;
+  constructor(status, url, body) {
+    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+};
+var ContentVerificationError = class extends CairnError {
+  expected;
+  constructor(expected) {
+    super(`Content does not match its payload hash ${expected} \u2014 bytes were tampered with in transit.`);
+    this.expected = expected;
+  }
+};
+function mapProviderError(error) {
+  const e = String(error || "").toLowerCase();
+  if (e.includes("rejected by user")) return new UserRejectedError(error);
+  if (e.includes("wallet locked")) return new WalletLockedError(error);
+  if (e.includes("unsupported dapp method")) return new UnsupportedMethodError(error);
+  return new CairnError(error || "Unknown wallet error");
+}
+
+// src/http.ts
+var Http = class {
+  baseUrl;
+  _fetch;
+  timeoutMs;
+  headers;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    const f = opts.fetch ?? globalThis.fetch;
+    if (!f) throw new Error("No fetch available \u2014 pass `fetch` in the SDK options.");
+    this._fetch = opts.fetch ? opts.fetch : f.bind(globalThis);
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.headers = opts.headers ?? {};
+  }
+  /** Build an absolute URL from a path + optional query params. */
+  url(path, query) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const u = new URL(this.baseUrl + p);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null) u.searchParams.set(k, String(v));
+      }
+    }
+    return u.toString();
+  }
+  async raw(method, path, opts) {
+    const url = this.url(path, opts?.query);
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await this._fetch(url, {
+        method,
+        signal: ctrl.signal,
+        headers: {
+          ...opts?.body !== void 0 ? { "content-type": "application/json" } : {},
+          ...this.headers,
+          ...opts?.headers ?? {}
+        },
+        body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+      });
+      return res;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async getJson(path, query) {
+    const res = await this.raw("GET", path, { query });
+    if (!res.ok) throw new HttpError(res.status, this.url(path, query), await safeText(res));
+    return await res.json();
+  }
+  async postJson(path, body, headers) {
+    const res = await this.raw("POST", path, { body, headers });
+    if (!res.ok) throw new HttpError(res.status, this.url(path), await safeText(res));
+    return await res.json();
+  }
+  /** GET raw bytes (for content retrieval). Returns null on 404. */
+  async getBytes(path) {
+    const res = await this.raw("GET", path);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new HttpError(res.status, this.url(path), await safeText(res));
+    const buf = new Uint8Array(await res.arrayBuffer());
+    return { bytes: buf, headers: res.headers };
+  }
+};
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+
+// src/chain.ts
+var import_csd_client = require("@inversealtruism/csd-client");
+var import_csd_tx = require("@inversealtruism/csd-tx");
+var import_csd_codec = require("@inversealtruism/csd-codec");
+var import_csd_crypto = require("@inversealtruism/csd-crypto");
+var import_csd_light = require("@inversealtruism/csd-light");
+var import_csd_client2 = require("@inversealtruism/csd-client");
+var import_csd_light2 = require("@inversealtruism/csd-light");
+var Chain = class {
+  client;
+  opts;
+  _light = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.client = new import_csd_client2.CsdClient({ baseUrl: opts.rpcUrl, fetch: opts.fetch, timeoutMs: opts.timeoutMs });
+  }
+  /** Current chain tip ({ tip, height, chainwork }). */
+  tip() {
+    return this.client.tip();
+  }
+  /** Spendable UTXOs + confirmed balance for an address. */
+  utxos(addr) {
+    return this.client.utxos(addr);
+  }
+  /** Submit a signed transaction (node-shaped JSON from `signTx().nodeJson`). */
+  submit(nodeJsonTx) {
+    return this.client.submit(nodeJsonTx);
+  }
+  /** A verifying light client over the same RPC (built once, reused). */
+  light() {
+    if (!this._light) {
+      this._light = new import_csd_light2.LightClient({ client: this.client });
+    }
+    return this._light;
+  }
+};
+
+// src/board.ts
+var import_csd_codec2 = require("@inversealtruism/csd-codec");
+var import_csd_codec3 = require("@inversealtruism/csd-codec");
+var BoardClient = class {
+  http;
+  wallet;
+  constructor(http, wallet) {
+    this.http = http;
+    this.wallet = wallet;
+  }
+  requireWallet() {
+    if (!this.wallet) {
+      throw new CairnError("This action needs a connected wallet. Construct Cairn with a wallet, or call cairn.connect() first.");
+    }
+    return this.wallet;
+  }
+  // ---- reads (public) ----------------------------------------------------
+  /** Ranked board for a domain + time window. */
+  board(opts = {}) {
+    return this.http.getJson("/api/board", { domain: opts.domain ?? "all", window: opts.window ?? "all" });
+  }
+  /** Alias for `board()` — the top items. */
+  top(opts = {}) {
+    return this.board(opts);
+  }
+  /** A single item with its supports + pledges + integrity flag. */
+  item(id) {
+    return this.http.getJson(`/api/item/${encodeURIComponent(id)}`);
+  }
+  /** Known + discovered domains. */
+  domains() {
+    return this.http.getJson("/api/domains");
+  }
+  /** All quests (work-graph items). */
+  quests() {
+    return this.http.getJson("/api/quests");
+  }
+  /** A single quest with claims/submissions/payouts. */
+  quest(id) {
+    return this.http.getJson(`/api/quest/${encodeURIComponent(id)}`);
+  }
+  /** An address's on-chain-derived profile + identity + reputation. */
+  profile(addr, opts = {}) {
+    return this.http.getJson(`/api/profile/${encodeURIComponent(addr)}`, opts.live ? { live: 1 } : void 0);
+  }
+  /** Reputation leaderboard (top 50). */
+  leaderboard() {
+    return this.http.getJson("/api/leaderboard");
+  }
+  /** Network dashboard snapshot. */
+  network() {
+    return this.http.getJson("/api/network");
+  }
+  /** Network time-series for charts. */
+  networkSeries(range = "24h") {
+    return this.http.getJson("/api/network/series", { range });
+  }
+  /** Recent blocks with miner/reward. */
+  networkBlocks(limit = 15) {
+    return this.http.getJson("/api/network/blocks", { limit });
+  }
+  /** Per-miner hashrate estimate. */
+  miner(addr) {
+    return this.http.getJson(`/api/miner/${encodeURIComponent(addr)}`);
+  }
+  /** Recent activity feed. */
+  activity() {
+    return this.http.getJson("/api/activity");
+  }
+  /** The gamified cairn wall. */
+  wall() {
+    return this.http.getJson("/api/wall");
+  }
+  /** Server health + chain reachability. */
+  health() {
+    return this.http.getJson("/api/health");
+  }
+  // ---- writes (wallet-signed) -------------------------------------------
+  /**
+   * Publish a board item: compute the canonical payload hash, have the WALLET
+   * build/sign/submit the Propose (clear-signed approval), then register the
+   * off-chain content. The payload hash is byte-identical to what the cairn
+   * server verifies (csd-codec.payloadHash over { v:1, domain, title, body, links }).
+   */
+  async propose(input) {
+    const wallet = this.requireWallet();
+    const content = {
+      v: 1,
+      domain: input.domain,
+      title: input.title,
+      body: input.body ?? "",
+      links: input.links ?? []
+    };
+    const ph = (0, import_csd_codec2.payloadHash)(content);
+    const uri = `cairn:v1:${ph.slice(2, 14)}`;
+    const lifetime = input.lifetimeEpochs ?? 720;
+    const height = await this.tipHeight();
+    const expiresEpoch = Math.floor(height / import_csd_codec3.EPOCH_LEN) + lifetime;
+    const fee = input.fee ?? import_csd_codec3.MIN_FEE_PROPOSE;
+    const r = await wallet.propose({ domain: content.domain, payloadHash: ph, uri, expiresEpoch, fee });
+    const txid2 = String(r.txid ?? "");
+    if (!txid2) throw new CairnError("Propose submitted but no txid was returned by the wallet.");
+    const reg = await this.tryRegister(content, txid2);
+    return { txid: txid2, payloadHash: ph, content, registered: reg.ok, registerError: reg.error };
+  }
+  /**
+   * Register off-chain content for an already-submitted proposal txid. Idempotent.
+   * Returns { ok } — the cairn server verifies sha256(canonical) == on-chain payload_hash.
+   */
+  async registerContent(content, txid2) {
+    try {
+      const res = await this.http.postJson("/api/content", {
+        domain: content.domain,
+        title: content.title,
+        body: content.body,
+        links: content.links,
+        txid: txid2
+      });
+      return { ok: !!res.ok, error: res.ok ? void 0 : res.error };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /** Support/attest a proposal (wallet-signed; always clear-signed). */
+  async support(proposalId, opts = {}) {
+    const wallet = this.requireWallet();
+    return wallet.attest({
+      proposalId,
+      score: opts.score ?? 80,
+      confidence: opts.confidence ?? 70,
+      fee: opts.fee ?? import_csd_codec3.MIN_FEE_ATTEST
+    });
+  }
+  // ---- internal ----------------------------------------------------------
+  async tipHeight() {
+    const tip = await this.http.getJson("/api/rpc/tip");
+    const h = Number(tip?.height);
+    if (!Number.isFinite(h)) throw new CairnError("Could not read chain tip height for expiry computation.");
+    return h;
+  }
+  async tryRegister(content, txid2) {
+    const delays = [0, 1500, 3e3, 5e3];
+    let last = { ok: false, error: "not attempted" };
+    for (const d of delays) {
+      if (d) await sleep(d);
+      last = await this.registerContent(content, txid2);
+      if (last.ok) return last;
+      if (!/not found yet|not found/i.test(last.error ?? "")) return last;
+    }
+    return last;
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/indexer.ts
+var import_csd_codec4 = require("@inversealtruism/csd-codec");
+var IndexerClient = class {
+  http;
+  opts;
+  constructor(http, opts = {}) {
+    this.http = http;
+    this.opts = opts;
+  }
+  // ---- REST --------------------------------------------------------------
+  health() {
+    return this.http.getJson("/health");
+  }
+  tipHeight() {
+    return this.http.getJson("/blocks/tip/height");
+  }
+  tipHash() {
+    return this.http.getJson("/blocks/tip/hash");
+  }
+  blockHashAtHeight(h) {
+    return this.http.getJson(`/block-height/${h}`);
+  }
+  block(hash) {
+    return this.http.getJson(`/block/${hash}`);
+  }
+  blockTxids(hash) {
+    return this.http.getJson(`/block/${hash}/txids`);
+  }
+  tx(id) {
+    return this.http.getJson(`/tx/${id}`);
+  }
+  txStatus(id) {
+    return this.http.getJson(`/tx/${id}/status`);
+  }
+  txMerkleProof(id) {
+    return this.http.getJson(`/tx/${id}/merkle-proof`);
+  }
+  address(a) {
+    return this.http.getJson(`/address/${a}`);
+  }
+  addressTxs(a) {
+    return this.http.getJson(`/address/${a}/txs`);
+  }
+  addressUtxo(a) {
+    return this.http.getJson(`/address/${a}/utxo`);
+  }
+  reputation(a) {
+    return this.http.getJson(`/address/${a}/reputation`);
+  }
+  domains() {
+    return this.http.getJson("/domains");
+  }
+  domainProposals(d) {
+    return this.http.getJson(`/domain/${encodeURIComponent(d)}/proposals`);
+  }
+  proposal(id) {
+    return this.http.getJson(`/proposal/${id}`);
+  }
+  attestations(id) {
+    return this.http.getJson(`/proposal/${id}/attestations`);
+  }
+  registryPeers() {
+    return this.http.getJson("/registry/peers");
+  }
+  registryGateways() {
+    return this.http.getJson("/registry/gateways");
+  }
+  identity(handle) {
+    return this.http.getJson(`/identity/${encodeURIComponent(handle)}`);
+  }
+  reverseIdentity(addr) {
+    return this.http.getJson(`/address/${addr}/identity`);
+  }
+  // ---- trust-minimized inclusion ----------------------------------------
+  /**
+   * Verify a tx is included in a block by folding its merkle branch to the root
+   * with csd-codec.verifyMerkleProof. If `headerMerkleAt` was provided, the
+   * proof's root is cross-checked against the ON-CHAIN header merkle at that
+   * height → trustLevel "verified-inclusion". Otherwise the proof is only
+   * internally consistent → "proof-consistent" (still useful, but the indexer is trusted).
+   */
+  async verifyInclusion(txid2) {
+    let proof;
+    try {
+      proof = await this.txMerkleProof(txid2);
+    } catch {
+      return { included: false, trustLevel: "not-found", reason: "no merkle proof (tx not indexed)" };
+    }
+    const folds = (0, import_csd_codec4.verifyMerkleProof)(txid2, proof.pos, proof.merkle, proof.merkle_root);
+    if (!folds) {
+      return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "merkle branch does not fold to the claimed root" };
+    }
+    if (this.opts.headerMerkleAt) {
+      try {
+        const onchain = await this.opts.headerMerkleAt(proof.block_height);
+        if (norm(onchain) !== norm(proof.merkle_root)) {
+          return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "proof root != on-chain header merkle (indexer disagrees with chain)" };
+        }
+        return { included: true, trustLevel: "verified-inclusion", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+      } catch {
+      }
+    }
+    return { included: true, trustLevel: "proof-consistent", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+  }
+  // ---- live streams ------------------------------------------------------
+  /** Stream all events (blocks, proposals, attestations, reorgs) via SSE. */
+  streamAll(handlers) {
+    return this.sse("/stream/all", handlers);
+  }
+  /** Stream blocks + reorgs only. */
+  streamBlocks(handlers) {
+    return this.sse("/stream/blocks", handlers);
+  }
+  /** Stream proposals (+ reorgs) for a domain. */
+  streamDomain(domain, handlers) {
+    return this.sse(`/stream/domain/${encodeURIComponent(domain)}`, handlers);
+  }
+  /**
+   * Subscribe over WebSocket with selective tracking. Returns a handle with
+   * `.close()`. `onEvent` receives every matching IndexEvent (incl. reorgs).
+   */
+  subscribe(sub, onEvent, onError) {
+    const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      throw new Error("No WebSocket available \u2014 pass WebSocketImpl in the indexer options (e.g. in older Node).");
+    }
+    const wsUrl = this.http.url("/ws").replace(/^http/, "ws");
+    let closed = false;
+    const ws = new WS(wsUrl);
+    ws.addEventListener("open", () => {
+      const msg = {};
+      if (sub.all) msg["track-all"] = true;
+      if (sub.domains?.length) msg["track-domain"] = sub.domains;
+      if (sub.addresses?.length) msg["track-address"] = sub.addresses;
+      if (sub.proposals?.length) msg["track-proposal"] = sub.proposals;
+      ws.send(JSON.stringify(Object.keys(msg).length ? msg : { "track-all": true }));
+    });
+    ws.addEventListener("message", (ev) => {
+      try {
+        const data = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+        if (data && data.kind) onEvent(data);
+      } catch {
+      }
+    });
+    if (onError) ws.addEventListener("error", (e) => onError(e));
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    };
+  }
+  // ---- internal SSE over fetch (portable + auto-reconnect) ---------------
+  sse(path, handlers) {
+    const fetchImpl = this.opts.fetch ?? globalThis.fetch;
+    const url = this.http.url(path);
+    let closed = false;
+    let ctrl = null;
+    const run = async () => {
+      while (!closed) {
+        ctrl = new AbortController();
+        try {
+          const res = await fetchImpl(url, { signal: ctrl.signal, headers: { accept: "text/event-stream" } });
+          if (!res.ok || !res.body) throw new Error(`SSE ${res.status}`);
+          handlers.onOpen?.();
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let buf = "";
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            buf += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n\n")) >= 0) {
+              const frame = buf.slice(0, idx);
+              buf = buf.slice(idx + 2);
+              dispatchFrame(frame, handlers);
+            }
+          }
+        } catch (err) {
+          if (closed) return;
+          handlers.onError?.(err);
+        }
+        if (closed) return;
+        await new Promise((r) => setTimeout(r, 2e3));
+      }
+    };
+    void run();
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ctrl?.abort();
+        } catch {
+        }
+      }
+    };
+  }
+};
+function dispatchFrame(frame, h) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of frame.split("\n")) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+  }
+  if (event === "hello" || dataLines.length === 0) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return;
+  }
+  h.onEvent?.(parsed);
+  if (parsed.kind === "block") h.onBlock?.(parsed);
+  else if (parsed.kind === "proposal") h.onProposal?.(parsed);
+  else if (parsed.kind === "attestation") h.onAttestation?.(parsed);
+  else if (parsed.kind === "reorg") h.onReorg?.(parsed);
+}
+function norm(h) {
+  return String(h).toLowerCase().replace(/^0x/, "");
+}
+
+// src/content.ts
+var import_csd_codec5 = require("@inversealtruism/csd-codec");
+var ContentClient = class {
+  sources;
+  constructor(opts) {
+    this.sources = [];
+    if (opts.swarm) this.sources.push({ name: "swarm", http: opts.swarm, path: (h) => `/content/${h}` });
+    if (opts.indexer) this.sources.push({ name: "indexer", http: opts.indexer, path: (h) => `/content/${h}` });
+    if (opts.cairn) this.sources.push({ name: "cairn", http: opts.cairn, path: (h) => `/content/${h}` });
+  }
+  /**
+   * Compute the canonical hash + bytes for an object, ready to anchor on-chain.
+   * This is byte-identical to what the cairn server and wallet compute.
+   */
+  prepare(obj) {
+    const canonical = (0, import_csd_codec5.canonicalJson)(obj);
+    return {
+      payloadHash: (0, import_csd_codec5.payloadHash)(obj),
+      canonical,
+      bytes: new TextEncoder().encode(canonical)
+    };
+  }
+  /** Alias for `prepare()` — emphasises this does not itself publish (anchor via board.propose). */
+  put(obj) {
+    return this.prepare(obj);
+  }
+  /** Just the payload hash for an object. */
+  hash(obj) {
+    return (0, import_csd_codec5.payloadHash)(obj);
+  }
+  /**
+   * Fetch content by hash and VERIFY it self-certifies (sha256(bytes) == hash).
+   * Tries each configured source in order. Returns raw bytes, or null if no
+   * source holds it. Throws ContentVerificationError if a source returns bytes
+   * that don't match the hash (tampering / wrong object).
+   */
+  async getBytes(hash) {
+    const h = normalizeHash(hash);
+    for (const src of this.sources) {
+      let got = null;
+      try {
+        got = await src.http.getBytes(src.path(h));
+      } catch {
+        continue;
+      }
+      if (!got) continue;
+      if (!(0, import_csd_codec5.verifyContentBytes)(got.bytes, h)) {
+        throw new ContentVerificationError(h);
+      }
+      return got.bytes;
+    }
+    return null;
+  }
+  /** Fetch + verify + parse as UTF-8 JSON. Returns null if not found. */
+  async get(hash) {
+    const bytes = await this.getBytes(hash);
+    if (!bytes) return null;
+    return JSON.parse(new TextDecoder().decode(bytes));
+  }
+  /** Verify already-fetched bytes against a hash (no network). */
+  verify(bytes, hash) {
+    return (0, import_csd_codec5.verifyContentBytes)(bytes, normalizeHash(hash));
+  }
+};
+function normalizeHash(hash) {
+  const h = hash.startsWith("0x") || hash.startsWith("0X") ? hash : `0x${hash}`;
+  return h.toLowerCase();
+}
+
+// src/registry.ts
+var import_csd_registry = require("@inversealtruism/csd-registry");
+var import_csd_registry2 = require("@inversealtruism/csd-registry");
+var RegistryClient = class {
+  src;
+  constructor(opts) {
+    this.src = { baseUrl: opts.baseUrl.replace(/\/+$/, ""), fetch: opts.fetch };
+  }
+  /** Discover ranked content/pin gateways (GET /registry/gateways). */
+  gateways() {
+    return (0, import_csd_registry.discoverGateways)(this.src);
+  }
+  /** Discover ranked libp2p peers (GET /registry/peers). */
+  peers() {
+    return (0, import_csd_registry.discoverPeers)(this.src);
+  }
+  /** Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved. */
+  resolveName(handle) {
+    return (0, import_csd_registry.resolveName)(this.src, handle);
+  }
+  /** Reverse-resolve an address → identity (GET /address/:addr/identity). */
+  reverseName(address) {
+    return (0, import_csd_registry.reverseName)(this.src, address);
+  }
+  /** The deterministic, client-side resolvers (recompute from raw ChainRecord[]). */
+  get fromRecords() {
+    return import_csd_registry.fromRecords;
+  }
+};
+
+// src/connect.ts
+function detectProvider(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 3e3;
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new NotInstalledError("Not running in a browser \u2014 `window.cairn` is unavailable."));
+      return;
+    }
+    if (window.cairn?.isCairn) {
+      resolve(window.cairn);
+      return;
+    }
+    let done = false;
+    const onInit = () => {
+      if (done) return;
+      if (window.cairn?.isCairn) {
+        done = true;
+        cleanup();
+        resolve(window.cairn);
+      }
+    };
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      cleanup();
+      reject(new NotInstalledError());
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      window.removeEventListener("cairn#initialized", onInit);
+    };
+    window.addEventListener("cairn#initialized", onInit);
+    onInit();
+  });
+}
+function isInstalled() {
+  return typeof window !== "undefined" && !!window.cairn?.isCairn;
+}
+function unwrap(reply) {
+  if (reply && reply.ok) return reply.result;
+  throw mapProviderError(reply?.error ?? "Unknown wallet error");
+}
+var WalletConnection = class {
+  provider;
+  _addr = null;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** The wallet's version string (e.g. "0.2.x"). */
+  get version() {
+    return this.provider.version;
+  }
+  /** The connected address, if `connect()`/`getAddress()` has resolved. */
+  get address() {
+    return this._addr;
+  }
+  /** Request connection. First time per origin prompts the user; afterwards may be silent. */
+  async connect() {
+    const { addr } = unwrap(await this.provider.connect());
+    this._addr = addr;
+    return addr;
+  }
+  /** Get the connected address (does not force a new connection prompt if already consented). */
+  async getAddress() {
+    const { addr } = unwrap(await this.provider.getAddress());
+    this._addr = addr;
+    return addr;
+  }
+  /** Passwordless sign-in: a signature over a login nonce (always prompts; structurally cannot sign a tx). */
+  signIn() {
+    return Promise.resolve(this.provider.signIn()).then(unwrap);
+  }
+  /** Send CSD (always prompts with clear-signing; wallet picks inputs + returns change to itself). */
+  send(params) {
+    return Promise.resolve(this.provider.send(params)).then(unwrap);
+  }
+  /** Low-level Propose (always prompts). Prefer `cairn.board.propose()` which computes the hash/uri/expiry. */
+  propose(params) {
+    return Promise.resolve(this.provider.propose(params)).then(unwrap);
+  }
+  /** Attest/support a proposal (always prompts). */
+  attest(params) {
+    return Promise.resolve(this.provider.attest(params)).then(unwrap);
+  }
+  /** Seal a commit-reveal claim (always prompts; salt stays inside the wallet). */
+  sealClaim(params) {
+    return Promise.resolve(this.provider.sealClaim(params)).then(unwrap);
+  }
+  /** Reveal a previously sealed claim by its sealing txid (always prompts). */
+  revealClaim(txid2) {
+    if (typeof txid2 !== "string" || !txid2) {
+      return Promise.reject(new UnsupportedMethodError("revealClaim requires the sealing txid"));
+    }
+    return Promise.resolve(this.provider.revealClaim(txid2)).then(unwrap);
+  }
+};
+async function getWallet(opts = {}) {
+  return new WalletConnection(await detectProvider(opts));
+}
+async function connect(opts = {}) {
+  const wallet = await getWallet(opts);
+  const address = await wallet.connect();
+  return { wallet, address };
+}
+
+// src/index.ts
+var DEFAULT_CAIRN = "https://cairn-substrate.com";
+var Cairn = class {
+  config;
+  chain;
+  index;
+  content;
+  registry;
+  board;
+  wallet;
+  cairnHttp;
+  constructor(config = {}) {
+    this.config = config;
+    const fetch = config.fetch;
+    const timeoutMs = config.timeoutMs;
+    const cairn = (config.baseUrls?.cairn ?? DEFAULT_CAIRN).replace(/\/+$/, "");
+    const rpc = config.baseUrls?.rpc ?? `${cairn}/api/rpc`;
+    const indexer = (config.baseUrls?.indexer ?? `${cairn}/explorer/api`).replace(/\/+$/, "");
+    this.cairnHttp = new Http({ baseUrl: cairn, fetch, timeoutMs });
+    const indexerHttp = new Http({ baseUrl: indexer, fetch, timeoutMs });
+    const swarmHttp = config.baseUrls?.swarm ? new Http({ baseUrl: config.baseUrls.swarm.replace(/\/+$/, ""), fetch, timeoutMs }) : void 0;
+    this.chain = new Chain({ rpcUrl: rpc, fetch, timeoutMs });
+    this.wallet = config.wallet;
+    this.board = new BoardClient(this.cairnHttp, this.wallet);
+    this.index = new IndexerClient(indexerHttp, {
+      fetch,
+      WebSocketImpl: config.WebSocketImpl,
+      // Upgrade inclusion proofs to fully trust-minimized by cross-checking the
+      // proof root against the on-chain header merkle at that height.
+      headerMerkleAt: async (h) => {
+        const block = await this.chain.client.blockByHeight(h);
+        return String(block.header.merkle);
+      }
+    });
+    this.content = new ContentClient({ swarm: swarmHttp, indexer: indexerHttp, cairn: this.cairnHttp });
+    this.registry = new RegistryClient({ baseUrl: indexer, fetch });
+  }
+  /**
+   * Detect + connect the Cairn Wallet (browser only). Wires the wallet into
+   * `cairn.board` for signed writes. Resolves to the connected address.
+   */
+  async connect(opts = {}) {
+    const { wallet, address } = await connect(opts);
+    this.attachWallet(wallet);
+    return address;
+  }
+  /** Attach an already-connected wallet (e.g. one you constructed yourself). */
+  attachWallet(wallet) {
+    this.wallet = wallet;
+    this.board = new BoardClient(this.cairnHttp, wallet);
+  }
+  /** True if a wallet is attached. */
+  get connected() {
+    return !!this.wallet;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoardClient,
+  Cairn,
+  CairnError,
+  Chain,
+  ContentClient,
+  ContentVerificationError,
+  Http,
+  HttpError,
+  IndexerClient,
+  NotInstalledError,
+  RegistryClient,
+  UnsupportedMethodError,
+  UserRejectedError,
+  WalletConnection,
+  WalletLockedError,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+});