@inversealtruism/cairn-sdk 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -22,51 +22,88 @@ var index_exports = {};
 __export(index_exports, {
   BoardClient: () => BoardClient,
   Cairn: () => Cairn,
+  CairnController: () => CairnController,
   CairnError: () => CairnError,
   Chain: () => Chain,
   ContentClient: () => ContentClient,
   ContentVerificationError: () => ContentVerificationError,
+  DEFAULT_SPV_CHECKPOINT: () => DEFAULT_SPV_CHECKPOINT,
   Http: () => Http,
   HttpError: () => HttpError,
   IndexerClient: () => IndexerClient,
   NotInstalledError: () => NotInstalledError,
   RegistryClient: () => RegistryClient,
+  SDK_VERSION: () => SDK_VERSION,
   UnsupportedMethodError: () => UnsupportedMethodError,
   UserRejectedError: () => UserRejectedError,
   WalletConnection: () => WalletConnection,
   WalletLockedError: () => WalletLockedError,
   connect: () => connect,
   detectProvider: () => detectProvider,
+  discoverProviders: () => discoverProviders,
+  errorCode: () => errorCode,
   getWallet: () => getWallet,
-  isInstalled: () => isInstalled
+  isInstalled: () => isInstalled,
+  mapProviderError: () => mapProviderError
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/errors.ts
+var SDK_VERSION = "0.1.4";
+var DOCS_BASE = "https://cairn-substrate.com/docs/sdk";
 var CairnError = class extends Error {
-  constructor(message) {
-    super(message);
+  /** Stable machine code for programmatic branching. */
+  code;
+  /** The human message without the appended docs/version footer. */
+  shortMessage;
+  /** Relative docs path (under the SDK docs base), if any. */
+  docsPath;
+  /** The cairn-sdk version that produced this error. */
+  version = SDK_VERSION;
+  constructor(shortMessage, opts = {}) {
+    const docs = opts.docsPath;
+    super(
+      [shortMessage, docs ? `Docs: ${DOCS_BASE}${docs}` : "", `Version: cairn-sdk@${SDK_VERSION}`].filter(Boolean).join("\n"),
+      { cause: opts.cause }
+    );
     this.name = new.target.name;
+    this.code = opts.code ?? "UNKNOWN";
+    this.shortMessage = shortMessage;
+    this.docsPath = docs;
+  }
+  /**
+   * Walk the `cause` chain. With a predicate, returns the FIRST matching error (or null). Without one,
+   * returns the DEEPEST cause (the root). Mirrors viem's `BaseError.walk()`.
+   */
+  walk(fn) {
+    let current = this;
+    let last = this;
+    while (current != null) {
+      if (fn && fn(current)) return current;
+      last = current;
+      current = current?.cause;
+    }
+    return fn ? null : last;
   }
 };
 var NotInstalledError = class extends CairnError {
   constructor(message = "Cairn Wallet not detected. Install it from cairn-substrate.com.") {
-    super(message);
+    super(message, { code: "NOT_INSTALLED", docsPath: "/install" });
   }
 };
 var UserRejectedError = class extends CairnError {
   constructor(message = "Request rejected by user.") {
-    super(message);
+    super(message, { code: "USER_REJECTED", docsPath: "/errors#user-rejected" });
   }
 };
 var WalletLockedError = class extends CairnError {
   constructor(message = "Wallet is locked.") {
-    super(message);
+    super(message, { code: "WALLET_LOCKED", docsPath: "/errors#wallet-locked" });
   }
 };
 var UnsupportedMethodError = class extends CairnError {
   constructor(message = "Method not supported by the wallet.") {
-    super(message);
+    super(message, { code: "UNSUPPORTED_METHOD", docsPath: "/errors#unsupported-method" });
   }
 };
 var HttpError = class extends CairnError {
@@ -74,7 +111,7 @@ var HttpError = class extends CairnError {
   url;
   body;
   constructor(status, url, body) {
-    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`);
+    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`, { code: "HTTP_ERROR" });
     this.status = status;
     this.url = url;
     this.body = body;
@@ -83,7 +120,7 @@ var HttpError = class extends CairnError {
 var ContentVerificationError = class extends CairnError {
   expected;
   constructor(expected) {
-    super(`Content does not match its payload hash ${expected} \u2014 bytes were tampered with in transit.`);
+    super(`Content does not match its payload hash ${expected} \u2014 bytes were tampered with in transit.`, { code: "CONTENT_VERIFICATION", docsPath: "/content#verification" });
     this.expected = expected;
   }
 };
@@ -91,15 +128,56 @@ 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);
+  if (e.includes("unsupported dapp method") || e.includes("predates") || e.includes("too old")) return new UnsupportedMethodError(error);
   return new CairnError(error || "Unknown wallet error");
 }
+function errorCode(err) {
+  return err instanceof CairnError ? err.code : "UNKNOWN";
+}
 
 // src/http.ts
+var DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
+var ERR_TEXT_CAP = 8 * 1024;
+async function readCapped(res, maxBytes) {
+  const cl = Number(res.headers.get("content-length"));
+  if (Number.isFinite(cl) && cl > maxBytes) throw new HttpError(res.status, res.url, `response too large (content-length ${cl} > ${maxBytes})`);
+  const body = res.body;
+  if (!body || typeof body.getReader !== "function") {
+    const buf = new Uint8Array(await res.arrayBuffer());
+    if (buf.byteLength > maxBytes) throw new HttpError(res.status, res.url, `response too large (${buf.byteLength} > ${maxBytes})`);
+    return buf;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      total += value.byteLength;
+      if (total > maxBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        throw new HttpError(res.status, res.url, `response exceeded ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  }
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.byteLength;
+  }
+  return out;
+}
 var Http = class {
   baseUrl;
   _fetch;
   timeoutMs;
+  maxBytes;
   headers;
   constructor(opts) {
     this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
@@ -107,12 +185,17 @@ var Http = class {
     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.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
     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);
+    const basePath = new URL(this.baseUrl + "/").pathname;
+    if (basePath !== "/" && !(u.pathname + "/").startsWith(basePath)) {
+      throw new Error(`illegal path '${path}' \u2014 escapes base ${basePath}`);
+    }
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0 && v !== null) u.searchParams.set(k, String(v));
@@ -143,25 +226,24 @@ var Http = class {
   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();
+    return JSON.parse(new TextDecoder().decode(await readCapped(res, this.maxBytes)));
   }
   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();
+    return JSON.parse(new TextDecoder().decode(await readCapped(res, this.maxBytes)));
   }
   /** 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 };
+    return { bytes: await readCapped(res, this.maxBytes), headers: res.headers };
   }
 };
 async function safeText(res) {
   try {
-    return await res.text();
+    return new TextDecoder().decode(await readCapped(res, ERR_TEXT_CAP));
   } catch {
     return "";
   }
@@ -175,6 +257,8 @@ 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 import_csd_tx2 = require("@inversealtruism/csd-tx");
+var import_csd_crypto2 = require("@inversealtruism/csd-crypto");
 var Chain = class {
   client;
   opts;
@@ -195,6 +279,29 @@ var Chain = class {
   submit(nodeJsonTx) {
     return this.client.submit(nodeJsonTx);
   }
+  /**
+   * Build + sign (+ optionally broadcast) a transfer with INPUT-VALUE VERIFICATION (the H2-safe send).
+   * Fetches the signer's UTXOs, selects, then re-verifies each selected input's REAL value against the
+   * chain (`verifyInputValues` recomputes each source tx's txid, so a lying RPC can't under-report) and
+   * computes change from the VERIFIED total — closing the UTXO-VALUE-1 implicit-fee-burn. Fail-closed:
+   * if any source can't be verified it signs nothing. Prefer this over the pure `buildSend`. Pass
+   * `broadcast:false` to get the signed tx back without submitting.
+   */
+  async send(p) {
+    const from = (0, import_csd_crypto2.addrFromPriv)(p.priv);
+    const u = await this.client.utxos(from);
+    const built = await (0, import_csd_tx2.buildSendVerified)({
+      outputs: p.outputs,
+      fee: p.fee,
+      utxos: u.utxos,
+      priv: p.priv,
+      maxFee: p.maxFee,
+      verify: (inputs) => (0, import_csd_client2.verifyInputValues)(this.client, inputs)
+    });
+    if (!built.ok || p.broadcast === false) return built;
+    const submitResult = await this.client.submit(built.nodeJson);
+    return { ...built, ok: built.ok && submitResult.ok !== false, submitResult };
+  }
   /** A verifying light client over the same RPC (built once, reused). */
   light() {
     if (!this._light) {
@@ -362,6 +469,13 @@ function sleep(ms) {
 
 // src/indexer.ts
 var import_csd_codec4 = require("@inversealtruism/csd-codec");
+var HEX64 = /^0x[0-9a-fA-F]{64}$/;
+var MAX_SSE_BUF = 1024 * 1024;
+function isValidMerkleProof(p) {
+  if (!p || typeof p !== "object") return false;
+  const m = p;
+  return Number.isInteger(m.block_height) && m.block_height >= 0 && Number.isInteger(m.pos) && m.pos >= 0 && typeof m.merkle_root === "string" && HEX64.test(m.merkle_root) && Array.isArray(m.merkle) && m.merkle.every((x) => typeof x === "string" && HEX64.test(x));
+}
 var IndexerClient = class {
   http;
   opts;
@@ -382,32 +496,35 @@ var IndexerClient = class {
   blockHashAtHeight(h) {
     return this.http.getJson(`/block-height/${h}`);
   }
+  // CAIRNSDK-CONTENT-HASH-PATH-1: encode every caller-supplied id segment. Raw interpolation let an id like
+  // `../../api/rpc/tip` walk `new URL` to a DIFFERENT same-origin endpoint whose body was then returned
+  // verbatim as the requested object (worse than the content case, which discards the walked-to response).
   block(hash) {
-    return this.http.getJson(`/block/${hash}`);
+    return this.http.getJson(`/block/${encodeURIComponent(hash)}`);
   }
   blockTxids(hash) {
-    return this.http.getJson(`/block/${hash}/txids`);
+    return this.http.getJson(`/block/${encodeURIComponent(hash)}/txids`);
   }
   tx(id) {
-    return this.http.getJson(`/tx/${id}`);
+    return this.http.getJson(`/tx/${encodeURIComponent(id)}`);
   }
   txStatus(id) {
-    return this.http.getJson(`/tx/${id}/status`);
+    return this.http.getJson(`/tx/${encodeURIComponent(id)}/status`);
   }
   txMerkleProof(id) {
-    return this.http.getJson(`/tx/${id}/merkle-proof`);
+    return this.http.getJson(`/tx/${encodeURIComponent(id)}/merkle-proof`);
   }
   address(a) {
-    return this.http.getJson(`/address/${a}`);
+    return this.http.getJson(`/address/${encodeURIComponent(a)}`);
   }
   addressTxs(a) {
-    return this.http.getJson(`/address/${a}/txs`);
+    return this.http.getJson(`/address/${encodeURIComponent(a)}/txs`);
   }
   addressUtxo(a) {
-    return this.http.getJson(`/address/${a}/utxo`);
+    return this.http.getJson(`/address/${encodeURIComponent(a)}/utxo`);
   }
   reputation(a) {
-    return this.http.getJson(`/address/${a}/reputation`);
+    return this.http.getJson(`/address/${encodeURIComponent(a)}/reputation`);
   }
   domains() {
     return this.http.getJson("/domains");
@@ -416,10 +533,10 @@ var IndexerClient = class {
     return this.http.getJson(`/domain/${encodeURIComponent(d)}/proposals`);
   }
   proposal(id) {
-    return this.http.getJson(`/proposal/${id}`);
+    return this.http.getJson(`/proposal/${encodeURIComponent(id)}`);
   }
   attestations(id) {
-    return this.http.getJson(`/proposal/${id}/attestations`);
+    return this.http.getJson(`/proposal/${encodeURIComponent(id)}/attestations`);
   }
   registryPeers() {
     return this.http.getJson("/registry/peers");
@@ -431,7 +548,7 @@ var IndexerClient = class {
     return this.http.getJson(`/identity/${encodeURIComponent(handle)}`);
   }
   reverseIdentity(addr) {
-    return this.http.getJson(`/address/${addr}/identity`);
+    return this.http.getJson(`/address/${encodeURIComponent(addr)}/identity`);
   }
   // ---- trust-minimized inclusion ----------------------------------------
   /**
@@ -440,9 +557,11 @@ var IndexerClient = class {
    * proof's root is cross-checked against the header merkle at that height →
    * trustLevel "verified-inclusion" (only as trustworthy as that header source —
    * see headerMerkleAt). Otherwise the proof is only internally consistent →
-   * "proof-consistent" (still useful, but the indexer is trusted). The Cairn
-   * facade wires headerMerkleAt ONLY when the node RPC is an independent origin
-   * from the indexer, so the default same-origin setup stays at "proof-consistent".
+   * "proof-consistent" (still useful, but the indexer is trusted). INDEXER-DOC-STALE-1: the Cairn facade now
+   * wires headerMerkleAt UNCONDITIONALLY via a PoW-verifying checkpoint light client (index.ts), so the
+   * default reaches "verified-inclusion" when the proof root matches the PoW-verified header — what makes a
+   * same-origin RPC safe is the forward PoW re-verification, not an origin gate (which no longer exists).
+   * Fails closed: a malformed proof or a chain-disagreement returns "not-found" (the latter with equivocation:true).
    */
   async verifyInclusion(txid2) {
     let proof;
@@ -451,7 +570,15 @@ var IndexerClient = class {
     } 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 (!isValidMerkleProof(proof)) {
+      return { included: false, trustLevel: "not-found", reason: "malformed merkle proof" };
+    }
+    let folds = false;
+    try {
+      folds = (0, import_csd_codec4.verifyMerkleProof)(txid2, proof.pos, proof.merkle, proof.merkle_root);
+    } catch {
+      return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "malformed merkle proof" };
+    }
     if (!folds) {
       return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "merkle branch does not fold to the claimed root" };
     }
@@ -459,7 +586,7 @@ var IndexerClient = class {
       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: false, trustLevel: "not-found", equivocation: true, 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 {
@@ -483,6 +610,11 @@ var IndexerClient = class {
   /**
    * Subscribe over WebSocket with selective tracking. Returns a handle with
    * `.close()`. `onEvent` receives every matching IndexEvent (incl. reorgs).
+   *
+   * WS-NORECONNECT-1: unlike the SSE feeds (streamAll/streamBlocks/streamDomain, which auto-reconnect with
+   * backoff), this WebSocket subscription does NOT auto-reconnect — it surfaces a terminal error via
+   * `onError` (when provided) and stops. A consumer tracking reorgs over WS MUST re-`subscribe()` on error
+   * to avoid a silently-stale view; for built-in reconnect prefer the SSE `stream*` methods.
    */
   subscribe(sub, onEvent, onError) {
     const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
@@ -545,6 +677,13 @@ var IndexerClient = class {
               buf = buf.slice(idx + 2);
               dispatchFrame(frame, handlers);
             }
+            if (buf.length > MAX_SSE_BUF) {
+              try {
+                await reader.cancel();
+              } catch {
+              }
+              throw new Error(`SSE buffer exceeded ${MAX_SSE_BUF} bytes with no frame delimiter \u2014 aborting`);
+            }
           }
         } catch (err) {
           if (closed) return;
@@ -657,8 +796,9 @@ var ContentClient = class {
   }
 };
 function normalizeHash(hash) {
-  const h = hash.startsWith("0x") || hash.startsWith("0X") ? hash : `0x${hash}`;
-  return h.toLowerCase();
+  const h = (hash.startsWith("0x") || hash.startsWith("0X") ? hash : `0x${hash}`).toLowerCase();
+  if (!/^0x[0-9a-f]{64}$/.test(h)) throw new Error(`invalid content hash: ${hash}`);
+  return h;
 }
 
 // src/registry.ts
@@ -677,11 +817,20 @@ var RegistryClient = class {
   peers() {
     return (0, import_csd_registry.discoverPeers)(this.src);
   }
-  /** Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved. */
+  /**
+   * Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved.
+   *
+   * ⚠ TRUST (CAIRN-SDK-RESOLVE-VERIFIED-FOOTGUN): the returned `verified` flag is the INDEXER's assertion,
+   * NOT a client-side proof. A hostile/compromised indexer (or a MITM of the read proxy) can return
+   * `verified:true` for a wrong address. Do NOT use this directly as a payee/login target without either (a)
+   * recomputing from raw records via `fromRecords.name(...)`, or (b) cross-checking a second independent
+   * source (the wallet's namespv union cure). Treat `verified` here as a hint, not a guarantee.
+   */
   resolveName(handle) {
     return (0, import_csd_registry.resolveName)(this.src, handle);
   }
-  /** Reverse-resolve an address → identity (GET /address/:addr/identity). */
+  /** Reverse-resolve an address → identity (GET /address/:addr/identity).
+   *  ⚠ Same indexer-trust caveat as resolveName — `verified` is the indexer's claim, not a client proof. */
   reverseName(address) {
     return (0, import_csd_registry.reverseName)(this.src, address);
   }
@@ -692,6 +841,26 @@ var RegistryClient = class {
 };
 
 // src/connect.ts
+function discoverProviders(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 1e3;
+  return new Promise((resolve) => {
+    if (typeof window === "undefined") {
+      resolve([]);
+      return;
+    }
+    const found = /* @__PURE__ */ new Map();
+    const onAnnounce = (ev) => {
+      const d = ev?.detail;
+      if (d?.info?.uuid && d?.provider?.isCairn) found.set(d.info.uuid, d);
+    };
+    window.addEventListener("csd:announceProvider", onAnnounce);
+    window.dispatchEvent(new CustomEvent("csd:requestProvider"));
+    setTimeout(() => {
+      window.removeEventListener("csd:announceProvider", onAnnounce);
+      resolve([...found.values()]);
+    }, timeoutMs);
+  });
+}
 function detectProvider(opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 3e3;
   return new Promise((resolve, reject) => {
@@ -699,18 +868,19 @@ function detectProvider(opts = {}) {
       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 = () => {
+    const finish = (p) => {
       if (done) return;
-      if (window.cairn?.isCairn) {
-        done = true;
-        cleanup();
-        resolve(window.cairn);
-      }
+      done = true;
+      cleanup();
+      resolve(p);
+    };
+    const onInit = () => {
+      if (!done && window.cairn?.isCairn) finish(window.cairn);
+    };
+    const onAnnounce = (ev) => {
+      const p = ev?.detail?.provider;
+      if (p?.isCairn) finish(p);
     };
     const timer = setTimeout(() => {
       if (done) return;
@@ -721,8 +891,15 @@ function detectProvider(opts = {}) {
     const cleanup = () => {
       clearTimeout(timer);
       window.removeEventListener("cairn#initialized", onInit);
+      window.removeEventListener("csd:announceProvider", onAnnounce);
     };
     window.addEventListener("cairn#initialized", onInit);
+    window.addEventListener("csd:announceProvider", onAnnounce);
+    if (window.cairn?.isCairn) {
+      finish(window.cairn);
+      return;
+    }
+    window.dispatchEvent(new CustomEvent("csd:requestProvider"));
     onInit();
   });
 }
@@ -759,10 +936,76 @@ var WalletConnection = class {
     this._addr = addr;
     return addr;
   }
-  /** Passwordless sign-in: a signature over a login nonce (always prompts; structurally cannot sign a tx). */
+  /**
+   * @deprecated First-party-only legacy login (it authenticates against the wallet's own configured
+   * server and is rejected from third-party origins). Use {@link signInWithCsd} for any site.
+   * 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);
   }
+  /**
+   * Audience-bound "Sign in with CSD" (SIWC) — the secure, replay-resistant third-party login.
+   * The wallet binds the REAL requesting origin + your single-use server `nonce` into the signed
+   * message and returns the artifact; it never mints a session. VERIFY the result SERVER-SIDE with
+   * `verifySiwc` from `@inversealtruism/csd-siwc` (domain/nonce/chain/time/signature/account), then
+   * issue your OWN session. The signature is proof-of-control, NOT a bearer token. Always prompts.
+   */
+  signInWithCsd(params) {
+    if (!params || typeof params.nonce !== "string" || !params.nonce) {
+      return Promise.reject(new UnsupportedMethodError("signInWithCsd requires a server-issued { nonce }"));
+    }
+    if (typeof this.provider.signInWithCsd !== "function") {
+      return Promise.reject(new UnsupportedMethodError("this wallet predates Sign-in-with-CSD \u2014 ask the user to update the Cairn Wallet"));
+    }
+    return Promise.resolve(this.provider.signInWithCsd(params)).then(unwrap);
+  }
+  /** True if this wallet supports audience-bound SIWC (safe to call `signInWithCsd`). */
+  get supportsSiwc() {
+    return typeof this.provider.signInWithCsd === "function";
+  }
+  /** Feature/capability detection. Returns null if the wallet predates `getCapabilities`. */
+  async getCapabilities() {
+    if (typeof this.provider.getCapabilities !== "function") return null;
+    try {
+      return await this.provider.getCapabilities();
+    } catch {
+      return null;
+    }
+  }
+  /** Atomic fill (CairnX DvP): pay + attest in ONE tx. Always prompts with clear-signing. */
+  fillOffer(params) {
+    return Promise.resolve(this.provider.fillOffer(params)).then(unwrap);
+  }
+  /** This origin's current permission grant (EIP-2255-style). Silent; [] if none / unsupported. */
+  async getPermissions() {
+    if (typeof this.provider.getPermissions !== "function") return [];
+    return unwrap(await this.provider.getPermissions());
+  }
+  /** Explicitly request permission to see the address (prompts, like connect). */
+  requestPermissions() {
+    if (typeof this.provider.requestPermissions !== "function") {
+      return Promise.reject(new UnsupportedMethodError("this wallet predates requestPermissions \u2014 use connect()"));
+    }
+    return Promise.resolve(this.provider.requestPermissions()).then(unwrap);
+  }
+  /** Revoke THIS origin's own access (silent). Returns { revoked }. Safe no-op on older wallets. */
+  async revokePermissions() {
+    if (typeof this.provider.revokePermissions !== "function") return { revoked: false };
+    return unwrap(await this.provider.revokePermissions());
+  }
+  /**
+   * Subscribe to provider events. `accountsChanged` fires with `[]` when this site loses access
+   * (wallet lock / account switch / revoke) — re-call connect() to (re)share; `disconnect` likewise.
+   * No-op if the wallet predates events. Use the SAME handler reference with off() to unsubscribe.
+   */
+  on(event, handler) {
+    this.provider.on?.(event, handler);
+  }
+  /** Remove a previously-added event handler (must be the same reference passed to on()). */
+  off(event, handler) {
+    this.provider.removeListener?.(event, handler);
+  }
   /** 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);
@@ -796,6 +1039,95 @@ async function connect(opts = {}) {
   return { wallet, address };
 }
 
+// src/controller.ts
+var DISCONNECTED = Object.freeze({ status: "disconnected", account: null, error: null });
+var CairnController = class {
+  state = DISCONNECTED;
+  conn = null;
+  listeners = /* @__PURE__ */ new Set();
+  getWalletFn;
+  detectOpts;
+  constructor(opts = {}) {
+    const { getWallet: gw, ...detect } = opts;
+    this.getWalletFn = gw ?? getWallet;
+    this.detectOpts = detect;
+  }
+  /** useSyncExternalStore-compatible. Returns an unsubscribe fn. */
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  };
+  /** useSyncExternalStore-compatible snapshot — stable reference until the state actually changes. */
+  getSnapshot = () => this.state;
+  /** The underlying WalletConnection (for advanced use: send/propose/permissions/…). Null until connect(). */
+  get connection() {
+    return this.conn;
+  }
+  setState(patch) {
+    const next = { ...this.state, ...patch };
+    if (next.status === this.state.status && next.account === this.state.account && next.error === this.state.error) return;
+    this.state = Object.freeze(next);
+    for (const l of [...this.listeners]) l();
+  }
+  onAccounts = (accounts) => {
+    if (!Array.isArray(accounts) || accounts.length === 0) {
+      this.setState({ status: "disconnected", account: null });
+      return;
+    }
+    const next = String(accounts[0]);
+    if (this.state.status === "connected" && this.state.account && next.toLowerCase() === this.state.account.toLowerCase()) {
+      this.setState({ status: "connected", account: next, error: null });
+    } else {
+      this.setState({ status: "disconnected", account: null });
+    }
+  };
+  onDisconnect = () => {
+    this.setState({ status: "disconnected", account: null });
+  };
+  // Detach the provider listeners (ghost-reconnect fix). Idempotent + best-effort.
+  detach() {
+    try {
+      this.conn?.off?.("accountsChanged", this.onAccounts);
+      this.conn?.off?.("disconnect", this.onDisconnect);
+    } catch {
+    }
+  }
+  /** Detect + connect (prompts the user the first time per origin). Resolves the connected address. */
+  connect = async () => {
+    this.setState({ status: "connecting", error: null });
+    try {
+      if (!this.conn) {
+        this.conn = await this.getWalletFn(this.detectOpts);
+        this.conn.on("accountsChanged", this.onAccounts);
+        this.conn.on("disconnect", this.onDisconnect);
+      }
+      const addr = await this.conn.connect();
+      this.setState({ status: "connected", account: addr, error: null });
+      return addr;
+    } catch (e) {
+      this.setState({ status: "disconnected", account: null, error: e?.message ?? String(e) });
+      throw e;
+    }
+  };
+  /** Forget the connection locally AND revoke this origin's wallet-side permission (best-effort). */
+  disconnect = async () => {
+    try {
+      await this.conn?.revokePermissions();
+    } catch {
+    }
+    this.detach();
+    this.conn = null;
+    this.setState({ status: "disconnected", account: null, error: null });
+  };
+  /** Audience-bound sign-in (must connect() first). Returns the signed artifact to verify server-side. */
+  signInWithCsd = (params) => {
+    if (!this.conn) return Promise.reject(new Error("call connect() before signInWithCsd()"));
+    return this.conn.signInWithCsd(params);
+  };
+};
+
 // src/index.ts
 var DEFAULT_SPV_CHECKPOINT = { height: 31310, hash: "0x000000000000138bd3eee4b8d2fbacb8d5433ac3040ddbf1c45a5e3e0cc9e814" };
 var DEFAULT_CAIRN = "https://cairn-substrate.com";
@@ -880,21 +1212,27 @@ var Cairn = class {
 0 && (module.exports = {
   BoardClient,
   Cairn,
+  CairnController,
   CairnError,
   Chain,
   ContentClient,
   ContentVerificationError,
+  DEFAULT_SPV_CHECKPOINT,
   Http,
   HttpError,
   IndexerClient,
   NotInstalledError,
   RegistryClient,
+  SDK_VERSION,
   UnsupportedMethodError,
   UserRejectedError,
   WalletConnection,
   WalletLockedError,
   connect,
   detectProvider,
+  discoverProviders,
+  errorCode,
   getWallet,
-  isInstalled
+  isInstalled,
+  mapProviderError
 });