@inversealtruism/cairn-sdk 0.4.0 → 0.4.1

package/dist/react.cjs

@@ -26,7 +26,7 @@ __export(react_exports, {
 module.exports = __toCommonJS(react_exports);
 
 // src/errors.ts
-var SDK_VERSION = "0.4.0";
+var SDK_VERSION = "0.4.1";
 var DOCS_BASE = "https://cairn-substrate.com/docs/sdk";
 var CairnError = class extends Error {
   /** Stable machine code for programmatic branching. */
@@ -213,12 +213,15 @@ var WalletConnection = class {
   // genuine wallet resolves quickly once the user acts; this only fires on a truly hung/absent response.
   call(op, label) {
     const ms = this._timeoutMs;
-    if (!Number.isFinite(ms) || ms <= 0) return Promise.resolve(op());
+    const invoke = () => new Promise((resolve) => {
+      resolve(op());
+    });
+    if (!Number.isFinite(ms) || ms <= 0) return invoke();
     let timer;
     const timeout = new Promise((_, reject) => {
       timer = setTimeout(() => reject(new CairnError(`the wallet did not respond to ${label} within ${ms}ms`, { retryable: false })), ms);
     });
-    return Promise.race([Promise.resolve(op()), timeout]).finally(() => clearTimeout(timer));
+    return Promise.race([invoke(), timeout]).finally(() => clearTimeout(timer));
   }
   /** The wallet's version string (e.g. "0.2.x"). */
   get version() {
@@ -291,8 +294,24 @@ var WalletConnection = class {
     if (typeof this.provider.fillOffer !== "function") {
       return Promise.reject(new UnsupportedMethodError("this wallet predates fillOffer() \u2014 ask the user to update the Cairn Wallet"));
     }
+    this.adviseFillSpvCapability();
     return this.call(() => this.provider.fillOffer(params), "fillOffer").then(unwrapWrite);
   }
+  // P75-5 MF-10: ONE capability advisory per connection. The wallet's on-device fill-SPV (0.2.60+) is the
+  // payment-grade fill boundary; when the provider SELF-REPORTS an older version, warn the integrator once
+  // and STILL RELAY. WARN, NEVER BLOCK: a hard version gate would decline honest fills (version strings are
+  // spoofable and unparseable forks exist), and the wallet itself is the enforcement point. Reads only the
+  // sync `provider.version`; never an awaited getCapabilities() round-trip on the fill hot path. An
+  // unparseable version never warns (no false alarms).
+  _fillSpvAdvised = false;
+  adviseFillSpvCapability() {
+    if (this._fillSpvAdvised) return;
+    this._fillSpvAdvised = true;
+    const m = /^(\d+)\.(\d+)\.(\d+)/.exec(String(this.provider?.version ?? ""));
+    if (!m) return;
+    const below = Number(m[1]) === 0 && (Number(m[2]) < 2 || Number(m[2]) === 2 && Number(m[3]) < 60);
+    if (below) console.warn(`[cairn-sdk] this Cairn Wallet (v${m[0]}) predates the on-device fill-SPV boundary (cairn-wallet 0.2.60+). The fill proceeds; suggest a wallet update for payment-grade offer verification.`);
+  }
   /** This origin's current permission grant (EIP-2255-style). Silent; [] if none / unsupported. */
   async getPermissions() {
     if (typeof this.provider.getPermissions !== "function") return [];
@@ -355,6 +374,9 @@ var DISCONNECTED = Object.freeze({ status: "disconnected", account: null, error:
 var CairnController = class {
   state = DISCONNECTED;
   conn = null;
+  // MF-15: connect/disconnect generation token. disconnect() bumps it; a connect() whose await straddled
+  // the bump must never commit "connected" over the torn-down session (a zombie null-connection session).
+  epoch = 0;
   listeners = /* @__PURE__ */ new Set();
   getWalletFn;
   detectOpts;
@@ -407,34 +429,43 @@ var CairnController = class {
   }
   /** Detect + connect (prompts the user the first time per origin). Resolves the connected address. */
   connect = async () => {
+    const epoch = this.epoch;
     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);
+      let conn = this.conn;
+      if (!conn) {
+        conn = await this.getWalletFn(this.detectOpts);
+        if (epoch !== this.epoch) throw new Error("connection was torn down while connecting - call connect() again");
+        conn.on("accountsChanged", this.onAccounts);
+        conn.on("disconnect", this.onDisconnect);
+        this.conn = conn;
       }
-      const addr = await this.conn.connect();
+      const addr = await conn.connect();
+      if (epoch !== this.epoch) throw new Error("connection was torn down while awaiting approval - call connect() again");
       this.setState({ status: "connected", account: addr, error: null });
       return addr;
     } catch (e) {
-      this.setState({ status: "disconnected", account: null, error: e?.message ?? String(e) });
+      if (epoch === this.epoch) 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). */
+  /** Forget the connection locally AND revoke this origin's wallet-side permission (best-effort).
+   *  Local teardown is IMMEDIATE and unconditional; the wallet-side revoke happens after, so a hung
+   *  provider can never hold a torn-down session in "connected". */
   disconnect = async () => {
-    try {
-      await this.conn?.revokePermissions();
-    } catch {
-    }
+    this.epoch++;
+    const conn = this.conn;
     this.detach();
     this.conn = null;
     this.setState({ status: "disconnected", account: null, error: null });
+    try {
+      await conn?.revokePermissions();
+    } catch {
+    }
   };
   /** 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()"));
+    if (!this.conn || this.state.status !== "connected") return Promise.reject(new Error("call connect() before signInWithCsd()"));
     return this.conn.signInWithCsd(params);
   };
 };

package/dist/react.js

@@ -1,8 +1,8 @@
 import {
   CairnController
-} from "./chunk-GTTLMWGY.js";
-import "./chunk-RKR3JMIA.js";
-import "./chunk-MREZG2HN.js";
+} from "./chunk-QATE6AIP.js";
+import "./chunk-PIPN6FSA.js";
+import "./chunk-ERBT4DFD.js";
 
 // src/react.ts
 function createCairnHooks(React, controllerOrOpts) {

package/dist/registry.cjs

@@ -34,19 +34,221 @@ __export(registry_exports, {
 });
 module.exports = __toCommonJS(registry_exports);
 var import_csd_registry = require("@inversealtruism/csd-registry");
+
+// src/errors.ts
+var SDK_VERSION = "0.4.1";
+var DOCS_BASE = "https://cairn-substrate.com/docs/sdk";
+var CairnError = class extends Error {
+  /** 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;
+  /**
+   * Whether a dApp may safely AUTO-retry this failure. `false` for fund-safety refusals and user-intent
+   * declines (the default); `true` only for provably transient infra faults where nothing was signed.
+   * A `SubmitInFlightError` is `false` too: reconcile its `txid`, never blind-retry.
+   */
+  retryable;
+  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;
+    this.retryable = opts.retryable ?? false;
+  }
+  /**
+   * 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 HttpError = class extends CairnError {
+  status;
+  url;
+  body;
+  constructor(status, url, body) {
+    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`, { code: "HTTP_ERROR" });
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+};
+
+// 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;
+  retries;
+  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.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    this.headers = opts.headers ?? {};
+    this.retries = Math.min(10, Math.max(0, Math.floor(opts.retries ?? 0)));
+  }
+  /** 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));
+      }
+    }
+    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);
+    }
+  }
+  // A malformed 2xx body must surface as a TYPED HttpError, not a leaked SyntaxError (B10: dApp
+  // code branches on `instanceof CairnError`; a raw parse error escaped that contract).
+  parseJson(res, text, url) {
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      throw new HttpError(res.status, url, `invalid JSON body: ${text.slice(0, 120)}`);
+    }
+  }
+  async getJson(path, query) {
+    const url = this.url(path, query);
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const res = await this.raw("GET", path, { query });
+        if (!res.ok) {
+          if (!(res.status >= 500 && attempt < this.retries)) throw new HttpError(res.status, url, await safeText(res));
+          res.body?.cancel().catch(() => {
+          });
+        } else {
+          return this.parseJson(res, new TextDecoder().decode(await readCapped(res, this.maxBytes)), url);
+        }
+      } catch (e) {
+        if (e instanceof HttpError && e.status < 500) throw e;
+        if (attempt >= this.retries) throw e;
+      }
+      await new Promise((r) => setTimeout(r, Math.floor(Math.random() * Math.min(4e3, 250 * 2 ** attempt))));
+    }
+  }
+  async postJson(path, body, headers) {
+    const url = this.url(path);
+    const res = await this.raw("POST", path, { body, headers });
+    if (!res.ok) throw new HttpError(res.status, url, await safeText(res));
+    return this.parseJson(res, new TextDecoder().decode(await readCapped(res, this.maxBytes)), url);
+  }
+  /** 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));
+    return { bytes: await readCapped(res, this.maxBytes), headers: res.headers };
+  }
+};
+async function safeText(res) {
+  try {
+    return new TextDecoder().decode(await readCapped(res, ERR_TEXT_CAP));
+  } catch {
+    return "";
+  }
+}
+
+// src/registry.ts
 var import_csd_registry2 = require("@inversealtruism/csd-registry");
 var RegistryClient = class {
-  src;
-  constructor(opts) {
-    this.src = { baseUrl: opts.baseUrl.replace(/\/+$/, ""), fetch: opts.fetch };
+  http;
+  /** Accepts the SDK's hardened Http directly (the Cairn facade path) or the legacy
+   *  { baseUrl, fetch } options (kept for direct constructors; they now get the same
+   *  hardened transport, built internally). */
+  constructor(src) {
+    this.http = src instanceof Http ? src : new Http({ baseUrl: src.baseUrl, fetch: src.fetch });
   }
   /** Discover ranked content/pin gateways (GET /registry/gateways). */
   gateways() {
-    return (0, import_csd_registry.discoverGateways)(this.src);
+    return this.http.getJson("/registry/gateways");
   }
   /** Discover ranked libp2p peers (GET /registry/peers). */
   peers() {
-    return (0, import_csd_registry.discoverPeers)(this.src);
+    return this.http.getJson("/registry/peers");
   }
   /**
    * Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved.
@@ -58,12 +260,22 @@ var RegistryClient = class {
    * 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);
+    return this.getOr404Null(`/identity/${encodeURIComponent(handle)}`);
   }
   /** 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);
+    return this.getOr404Null(`/address/${encodeURIComponent(address)}/identity`);
+  }
+  // MF-12: 404 → null (the preserved csd-registry contract for both name resolvers); every other
+  // failure rethrows the typed HttpError/CairnError the hardened Http raises.
+  async getOr404Null(path) {
+    try {
+      return await this.http.getJson(path);
+    } catch (e) {
+      if (e instanceof HttpError && e.status === 404) return null;
+      return Promise.reject(e);
+    }
   }
   /** The deterministic, client-side resolvers (recompute from raw ChainRecord[]). */
   get fromRecords() {

package/dist/registry.d.cts

@@ -1,6 +1,7 @@
 import * as _inversealtruism_csd_registry from '@inversealtruism/csd-registry';
+import { RankedGateway, RankedPeer, ResolvedIdentity } from '@inversealtruism/csd-registry';
 export { BuiltRecord, ChainRecord, DOMAINS, RankedGateway, RankedPeer, ResolveOpts, ResolvedIdentity, buildGatewayRecord, buildIdentityCommit, buildIdentityReveal, buildPeerRecord, epochOf, fromRecords, verifyGateway, verifyIdentitySig, verifyPeer } from '@inversealtruism/csd-registry';
-import { F as FetchLike } from './http-C9C4L4hz.cjs';
+import { H as Http, F as FetchLike } from './http-C9C4L4hz.cjs';
 
 interface RegistryClientOptions {
     /** Indexer base URL exposing /registry/* + /identity/* (e.g. https://cairn-substrate.com/indexer). */
@@ -8,12 +9,15 @@ interface RegistryClientOptions {
     fetch?: FetchLike;
 }
 declare class RegistryClient {
-    private readonly src;
-    constructor(opts: RegistryClientOptions);
+    private readonly http;
+    /** Accepts the SDK's hardened Http directly (the Cairn facade path) or the legacy
+     *  { baseUrl, fetch } options (kept for direct constructors; they now get the same
+     *  hardened transport, built internally). */
+    constructor(src: Http | RegistryClientOptions);
     /** Discover ranked content/pin gateways (GET /registry/gateways). */
-    gateways(): Promise<_inversealtruism_csd_registry.RankedGateway[]>;
+    gateways(): Promise<RankedGateway[]>;
     /** Discover ranked libp2p peers (GET /registry/peers). */
-    peers(): Promise<_inversealtruism_csd_registry.RankedPeer[]>;
+    peers(): Promise<RankedPeer[]>;
     /**
      * Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved.
      *
@@ -23,16 +27,17 @@ declare class RegistryClient {
      * 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: string): Promise<_inversealtruism_csd_registry.ResolvedIdentity | null>;
+    resolveName(handle: string): Promise<ResolvedIdentity | null>;
     /** 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: string): Promise<_inversealtruism_csd_registry.ResolvedIdentity | null>;
+    reverseName(address: string): Promise<ResolvedIdentity | null>;
+    private getOr404Null;
     /** The deterministic, client-side resolvers (recompute from raw ChainRecord[]). */
     get fromRecords(): {
-        peers: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.RankedPeer[];
-        gateways: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.RankedGateway[];
-        name: (records: _inversealtruism_csd_registry.ChainRecord[], handle: string, opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.ResolvedIdentity | null;
-        reverse: (records: _inversealtruism_csd_registry.ChainRecord[], address: string, opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.ResolvedIdentity | null;
+        peers: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => RankedPeer[];
+        gateways: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => RankedGateway[];
+        name: (records: _inversealtruism_csd_registry.ChainRecord[], handle: string, opts: _inversealtruism_csd_registry.ResolveOpts) => ResolvedIdentity | null;
+        reverse: (records: _inversealtruism_csd_registry.ChainRecord[], address: string, opts: _inversealtruism_csd_registry.ResolveOpts) => ResolvedIdentity | null;
     };
 }
 

package/dist/registry.d.ts

@@ -1,6 +1,7 @@
 import * as _inversealtruism_csd_registry from '@inversealtruism/csd-registry';
+import { RankedGateway, RankedPeer, ResolvedIdentity } from '@inversealtruism/csd-registry';
 export { BuiltRecord, ChainRecord, DOMAINS, RankedGateway, RankedPeer, ResolveOpts, ResolvedIdentity, buildGatewayRecord, buildIdentityCommit, buildIdentityReveal, buildPeerRecord, epochOf, fromRecords, verifyGateway, verifyIdentitySig, verifyPeer } from '@inversealtruism/csd-registry';
-import { F as FetchLike } from './http-C9C4L4hz.js';
+import { H as Http, F as FetchLike } from './http-C9C4L4hz.js';
 
 interface RegistryClientOptions {
     /** Indexer base URL exposing /registry/* + /identity/* (e.g. https://cairn-substrate.com/indexer). */
@@ -8,12 +9,15 @@ interface RegistryClientOptions {
     fetch?: FetchLike;
 }
 declare class RegistryClient {
-    private readonly src;
-    constructor(opts: RegistryClientOptions);
+    private readonly http;
+    /** Accepts the SDK's hardened Http directly (the Cairn facade path) or the legacy
+     *  { baseUrl, fetch } options (kept for direct constructors; they now get the same
+     *  hardened transport, built internally). */
+    constructor(src: Http | RegistryClientOptions);
     /** Discover ranked content/pin gateways (GET /registry/gateways). */
-    gateways(): Promise<_inversealtruism_csd_registry.RankedGateway[]>;
+    gateways(): Promise<RankedGateway[]>;
     /** Discover ranked libp2p peers (GET /registry/peers). */
-    peers(): Promise<_inversealtruism_csd_registry.RankedPeer[]>;
+    peers(): Promise<RankedPeer[]>;
     /**
      * Resolve a handle → identity (GET /identity/:handle). Returns null if unresolved.
      *
@@ -23,16 +27,17 @@ declare class RegistryClient {
      * 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: string): Promise<_inversealtruism_csd_registry.ResolvedIdentity | null>;
+    resolveName(handle: string): Promise<ResolvedIdentity | null>;
     /** 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: string): Promise<_inversealtruism_csd_registry.ResolvedIdentity | null>;
+    reverseName(address: string): Promise<ResolvedIdentity | null>;
+    private getOr404Null;
     /** The deterministic, client-side resolvers (recompute from raw ChainRecord[]). */
     get fromRecords(): {
-        peers: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.RankedPeer[];
-        gateways: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.RankedGateway[];
-        name: (records: _inversealtruism_csd_registry.ChainRecord[], handle: string, opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.ResolvedIdentity | null;
-        reverse: (records: _inversealtruism_csd_registry.ChainRecord[], address: string, opts: _inversealtruism_csd_registry.ResolveOpts) => _inversealtruism_csd_registry.ResolvedIdentity | null;
+        peers: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => RankedPeer[];
+        gateways: (records: _inversealtruism_csd_registry.ChainRecord[], opts: _inversealtruism_csd_registry.ResolveOpts) => RankedGateway[];
+        name: (records: _inversealtruism_csd_registry.ChainRecord[], handle: string, opts: _inversealtruism_csd_registry.ResolveOpts) => ResolvedIdentity | null;
+        reverse: (records: _inversealtruism_csd_registry.ChainRecord[], address: string, opts: _inversealtruism_csd_registry.ResolveOpts) => ResolvedIdentity | null;
     };
 }
 

package/dist/registry.js

@@ -10,7 +10,8 @@ import {
   verifyGateway,
   verifyIdentitySig,
   verifyPeer
-} from "./chunk-BGJZF7S2.js";
+} from "./chunk-7UOTIAYK.js";
+import "./chunk-ERBT4DFD.js";
 export {
   DOMAINS,
   RegistryClient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inversealtruism/cairn-sdk",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "The Compute Substrate dApp kit — one cohesive toolkit to connect the Cairn Wallet, read the chain/board, publish self-certifying content, and resolve registries. Composes the published csd-* primitives.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -59,16 +59,16 @@
     "README.md"
   ],
   "dependencies": {
-    "@inversealtruism/cairnx-core": "0.1.40",
+    "@inversealtruism/cairnx-core": "0.1.41",
     "@inversealtruism/csd-client": "0.1.15",
-    "@inversealtruism/csd-codec": "0.1.15",
+    "@inversealtruism/csd-codec": "0.1.16",
     "@inversealtruism/csd-crypto": "0.1.15",
-    "@inversealtruism/csd-light": "0.1.18",
-    "@inversealtruism/csd-registry": "0.1.16",
+    "@inversealtruism/csd-light": "0.1.19",
+    "@inversealtruism/csd-registry": "0.1.17",
     "@inversealtruism/csd-tx": "0.1.17"
   },
   "devDependencies": {
-    "@inversealtruism/csd-siwc": "0.1.15",
+    "@inversealtruism/csd-siwc": "0.1.16",
     "esbuild": "^0.27.0",
     "playwright-core": "^1.49.0",
     "tsup": "^8.5.1",

package/dist/chunk-BGJZF7S2.js

@@ -1,69 +0,0 @@
-// src/registry.ts
-import {
-  discoverPeers,
-  discoverGateways,
-  resolveName,
-  reverseName,
-  fromRecords
-} from "@inversealtruism/csd-registry";
-import {
-  fromRecords as fromRecords2,
-  verifyPeer as verifyPeer2,
-  verifyGateway as verifyGateway2,
-  verifyIdentitySig as verifyIdentitySig2,
-  DOMAINS as DOMAINS2,
-  buildPeerRecord,
-  buildGatewayRecord,
-  buildIdentityCommit,
-  buildIdentityReveal,
-  epochOf
-} from "@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 discoverGateways(this.src);
-  }
-  /** Discover ranked libp2p peers (GET /registry/peers). */
-  peers() {
-    return discoverPeers(this.src);
-  }
-  /**
-   * 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 resolveName(this.src, handle);
-  }
-  /** 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 reverseName(this.src, address);
-  }
-  /** The deterministic, client-side resolvers (recompute from raw ChainRecord[]). */
-  get fromRecords() {
-    return fromRecords;
-  }
-};
-
-export {
-  RegistryClient,
-  fromRecords2 as fromRecords,
-  verifyPeer2 as verifyPeer,
-  verifyGateway2 as verifyGateway,
-  verifyIdentitySig2 as verifyIdentitySig,
-  DOMAINS2 as DOMAINS,
-  buildPeerRecord,
-  buildGatewayRecord,
-  buildIdentityCommit,
-  buildIdentityReveal,
-  epochOf
-};