@inversealtruism/cairn-sdk 0.3.2 → 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.3.2";
+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. */
@@ -100,7 +100,7 @@ var SubmitInFlightError = class extends CairnError {
     this.txid = txid;
   }
 };
-var NATIVE_CODES = /* @__PURE__ */ new Set(["ACCOUNT_CHANGED", "FIRST_PARTY_ONLY", "RATE_LIMITED", "APPROVAL_CLOSED", "FORBIDDEN", "INTERNAL"]);
+var NATIVE_CODES = /* @__PURE__ */ new Set(["FIRST_PARTY_ONLY", "RATE_LIMITED", "FORBIDDEN", "INTERNAL"]);
 var NESTED_TRANSIENT = /* @__PURE__ */ new Set(["VERIFY_UNAVAILABLE", "OFFER_UNKNOWN"]);
 var NESTED_TERMINAL = /* @__PURE__ */ new Set([
   "FILL_UNSAFE",
@@ -144,6 +144,7 @@ function mapSubmitResultError(result) {
 }
 
 // src/connect.ts
+var DEFAULT_PROVIDER_TIMEOUT_MS = 10 * 6e4;
 function detectProvider(opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 3e3;
   return new Promise((resolve, reject) => {
@@ -200,8 +201,27 @@ function unwrapWrite(reply) {
 var WalletConnection = class {
   provider;
   _addr = null;
-  constructor(provider) {
+  /** B7c: per-call provider timeout (ms). GENEROUS by default so it never rejects an in-flight human
+   *  approval; 0 disables it. Every provider call (writes especially) races against it. */
+  _timeoutMs;
+  constructor(provider, opts = {}) {
     this.provider = provider;
+    this._timeoutMs = opts.timeoutMs ?? DEFAULT_PROVIDER_TIMEOUT_MS;
+  }
+  // B7c: race a provider call against the per-call timeout. On timeout, throw a fail-closed CairnError
+  // (retryable:false: a write may already have reached the wallet, so never invite a blind auto-retry). The
+  // genuine wallet resolves quickly once the user acts; this only fires on a truly hung/absent response.
+  call(op, label) {
+    const ms = this._timeoutMs;
+    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([invoke(), timeout]).finally(() => clearTimeout(timer));
   }
   /** The wallet's version string (e.g. "0.2.x"). */
   get version() {
@@ -213,13 +233,13 @@ var WalletConnection = class {
   }
   /** Request connection. First time per origin prompts the user; afterwards may be silent. */
   async connect() {
-    const { addr } = unwrap(await this.provider.connect());
+    const { addr } = unwrap(await this.call(() => this.provider.connect(), "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());
+    const { addr } = unwrap(await this.call(() => this.provider.getAddress(), "getAddress"));
     this._addr = addr;
     return addr;
   }
@@ -232,7 +252,7 @@ var WalletConnection = class {
     if (typeof this.provider.signIn !== "function") {
       return Promise.reject(new UnsupportedMethodError("this wallet does not expose signIn()"));
     }
-    return Promise.resolve(this.provider.signIn()).then(unwrap);
+    return this.call(() => this.provider.signIn(), "signIn").then(unwrap);
   }
   /**
    * Audience-bound "Sign in with CSD" (SIWC) — the secure, replay-resistant third-party login.
@@ -248,7 +268,7 @@ var WalletConnection = class {
     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);
+    return this.call(() => this.provider.signInWithCsd(params), "signInWithCsd").then(unwrap);
   }
   /** True if this wallet supports audience-bound SIWC (safe to call `signInWithCsd`). */
   get supportsSiwc() {
@@ -258,7 +278,7 @@ var WalletConnection = class {
   async getCapabilities() {
     if (typeof this.provider.getCapabilities !== "function") return null;
     try {
-      return await this.provider.getCapabilities();
+      return await this.call(() => this.provider.getCapabilities(), "getCapabilities");
     } catch {
       return null;
     }
@@ -274,24 +294,40 @@ 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"));
     }
-    return Promise.resolve(this.provider.fillOffer(params)).then(unwrapWrite);
+    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 [];
-    return unwrap(await this.provider.getPermissions());
+    return unwrap(await this.call(() => this.provider.getPermissions(), "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);
+    return this.call(() => this.provider.requestPermissions(), "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());
+    return unwrap(await this.call(() => this.provider.revokePermissions(), "revokePermissions"));
   }
   /**
    * Subscribe to provider events. `accountsChanged` fires with `[]` when this site loses access
@@ -307,26 +343,26 @@ var WalletConnection = class {
   }
   /** Send CSD (always prompts with clear-signing; wallet picks inputs + returns change to itself). */
   send(params) {
-    return Promise.resolve(this.provider.send(params)).then(unwrapWrite);
+    return this.call(() => this.provider.send(params), "send").then(unwrapWrite);
   }
   /** 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(unwrapWrite);
+    return this.call(() => this.provider.propose(params), "propose").then(unwrapWrite);
   }
   /** Attest/support a proposal (always prompts). */
   attest(params) {
-    return Promise.resolve(this.provider.attest(params)).then(unwrapWrite);
+    return this.call(() => this.provider.attest(params), "attest").then(unwrapWrite);
   }
   /** Seal a commit-reveal claim (always prompts; salt stays inside the wallet). */
   sealClaim(params) {
-    return Promise.resolve(this.provider.sealClaim(params)).then(unwrapWrite);
+    return this.call(() => this.provider.sealClaim(params), "sealClaim").then(unwrapWrite);
   }
   /** Reveal a previously sealed claim by its sealing txid (always prompts). */
   revealClaim(txid) {
     if (typeof txid !== "string" || !txid) {
       return Promise.reject(new UnsupportedMethodError("revealClaim requires the sealing txid"));
     }
-    return Promise.resolve(this.provider.revealClaim(txid)).then(unwrapWrite);
+    return this.call(() => this.provider.revealClaim(txid), "revealClaim").then(unwrapWrite);
   }
 };
 async function getWallet(opts = {}) {
@@ -338,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;
@@ -390,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-AGU6K5EZ.js";
-import "./chunk-BN3PFJDY.js";
-import "./chunk-FMXNJQWL.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,