@inversealtruism/cairn-sdk 0.1.0

package/dist/connect.cjs

@@ -0,0 +1,177 @@
+"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/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  WalletConnection: () => WalletConnection,
+  connect: () => connect,
+  detectProvider: () => detectProvider,
+  getWallet: () => getWallet,
+  isInstalled: () => isInstalled
+});
+module.exports = __toCommonJS(connect_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);
+  }
+};
+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/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(txid) {
+    if (typeof txid !== "string" || !txid) {
+      return Promise.reject(new UnsupportedMethodError("revealClaim requires the sealing txid"));
+    }
+    return Promise.resolve(this.provider.revealClaim(txid)).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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WalletConnection,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+});

package/dist/connect.d.cts

@@ -0,0 +1,127 @@
+/** Result of `connect()` / `getAddress()`. */
+interface ConnectResult {
+    addr: string;
+}
+/** Generic on-chain submit result returned by signing methods (shape from the node/proxy). */
+interface TxResult {
+    ok?: boolean;
+    txid?: string;
+    [k: string]: unknown;
+}
+/** Sign-in (passwordless auth) result — a signature over a login nonce, never a tx sighash. */
+interface SignInResult {
+    addr?: string;
+    pub33?: string;
+    sig64?: string;
+    nonce?: string;
+    [k: string]: unknown;
+}
+/** Low-level Propose params (matches the wallet exactly). Prefer `cairn.board.propose()` for ergonomics. */
+interface ProposeParams {
+    domain: string;
+    payloadHash: string;
+    uri: string;
+    expiresEpoch: number;
+    fee: number;
+}
+/** Attest (support) params. */
+interface AttestParams {
+    proposalId: string;
+    score: number;
+    confidence: number;
+    fee: number;
+}
+/** Plain CSD transfer. The wallet always selects its own inputs and returns change to itself. */
+type SendParams = {
+    to: string;
+    amount: number;
+    fee?: number;
+} | {
+    outputs: {
+        to: string;
+        value: number;
+    }[];
+    fee?: number;
+};
+/** Commit-reveal sealed claim. The salt is generated inside the wallet and never leaves it. */
+interface SealClaimParams {
+    domain?: string;
+    claim: string;
+    fee?: number;
+}
+/** The raw provider object the extension injects at `window.cairn`. */
+interface CairnProvider {
+    isCairn: true;
+    version: string;
+    connect(): Promise<ProviderReply<ConnectResult>>;
+    getAddress(): Promise<ProviderReply<ConnectResult>>;
+    signIn(): Promise<ProviderReply<SignInResult>>;
+    propose(p: ProposeParams): Promise<ProviderReply<TxResult>>;
+    attest(p: AttestParams): Promise<ProviderReply<TxResult>>;
+    send(p: SendParams): Promise<ProviderReply<TxResult>>;
+    sealClaim(p: SealClaimParams): Promise<ProviderReply<TxResult>>;
+    revealClaim(txid: string): Promise<ProviderReply<TxResult>>;
+}
+/** Every provider call resolves to this discriminated reply (never rejects). */
+type ProviderReply<T> = {
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: string;
+};
+declare global {
+    interface Window {
+        cairn?: CairnProvider;
+    }
+}
+interface DetectOptions {
+    /** How long to wait for the provider to announce itself (ms, default 3000). */
+    timeoutMs?: number;
+}
+/**
+ * Resolve `window.cairn`, waiting for the wallet's `cairn#initialized` event if the
+ * content script hasn't injected yet. Throws `NotInstalledError` on timeout or
+ * outside a browser.
+ */
+declare function detectProvider(opts?: DetectOptions): Promise<CairnProvider>;
+/** True if the Cairn Wallet is already present (no waiting). */
+declare function isInstalled(): boolean;
+/**
+ * High-level, typed wallet handle. Construct via `connect()` or `new WalletConnection(provider)`.
+ * Methods throw `UserRejectedError` / `WalletLockedError` / `UnsupportedMethodError` on failure.
+ */
+declare class WalletConnection {
+    readonly provider: CairnProvider;
+    private _addr;
+    constructor(provider: CairnProvider);
+    /** The wallet's version string (e.g. "0.2.x"). */
+    get version(): string;
+    /** The connected address, if `connect()`/`getAddress()` has resolved. */
+    get address(): string | null;
+    /** Request connection. First time per origin prompts the user; afterwards may be silent. */
+    connect(): Promise<string>;
+    /** Get the connected address (does not force a new connection prompt if already consented). */
+    getAddress(): Promise<string>;
+    /** Passwordless sign-in: a signature over a login nonce (always prompts; structurally cannot sign a tx). */
+    signIn(): Promise<SignInResult>;
+    /** Send CSD (always prompts with clear-signing; wallet picks inputs + returns change to itself). */
+    send(params: SendParams): Promise<TxResult>;
+    /** Low-level Propose (always prompts). Prefer `cairn.board.propose()` which computes the hash/uri/expiry. */
+    propose(params: ProposeParams): Promise<TxResult>;
+    /** Attest/support a proposal (always prompts). */
+    attest(params: AttestParams): Promise<TxResult>;
+    /** Seal a commit-reveal claim (always prompts; salt stays inside the wallet). */
+    sealClaim(params: SealClaimParams): Promise<TxResult>;
+    /** Reveal a previously sealed claim by its sealing txid (always prompts). */
+    revealClaim(txid: string): Promise<TxResult>;
+}
+/** Detect the wallet and return a ready `WalletConnection` (does not auto-call connect()). */
+declare function getWallet(opts?: DetectOptions): Promise<WalletConnection>;
+/** Detect + connect in one step; resolves to the connected address. */
+declare function connect(opts?: DetectOptions): Promise<{
+    wallet: WalletConnection;
+    address: string;
+}>;
+
+export { type AttestParams, type CairnProvider, type ConnectResult, type DetectOptions, type ProposeParams, type ProviderReply, type SealClaimParams, type SendParams, type SignInResult, type TxResult, WalletConnection, connect, detectProvider, getWallet, isInstalled };

package/dist/connect.d.ts

@@ -0,0 +1,127 @@
+/** Result of `connect()` / `getAddress()`. */
+interface ConnectResult {
+    addr: string;
+}
+/** Generic on-chain submit result returned by signing methods (shape from the node/proxy). */
+interface TxResult {
+    ok?: boolean;
+    txid?: string;
+    [k: string]: unknown;
+}
+/** Sign-in (passwordless auth) result — a signature over a login nonce, never a tx sighash. */
+interface SignInResult {
+    addr?: string;
+    pub33?: string;
+    sig64?: string;
+    nonce?: string;
+    [k: string]: unknown;
+}
+/** Low-level Propose params (matches the wallet exactly). Prefer `cairn.board.propose()` for ergonomics. */
+interface ProposeParams {
+    domain: string;
+    payloadHash: string;
+    uri: string;
+    expiresEpoch: number;
+    fee: number;
+}
+/** Attest (support) params. */
+interface AttestParams {
+    proposalId: string;
+    score: number;
+    confidence: number;
+    fee: number;
+}
+/** Plain CSD transfer. The wallet always selects its own inputs and returns change to itself. */
+type SendParams = {
+    to: string;
+    amount: number;
+    fee?: number;
+} | {
+    outputs: {
+        to: string;
+        value: number;
+    }[];
+    fee?: number;
+};
+/** Commit-reveal sealed claim. The salt is generated inside the wallet and never leaves it. */
+interface SealClaimParams {
+    domain?: string;
+    claim: string;
+    fee?: number;
+}
+/** The raw provider object the extension injects at `window.cairn`. */
+interface CairnProvider {
+    isCairn: true;
+    version: string;
+    connect(): Promise<ProviderReply<ConnectResult>>;
+    getAddress(): Promise<ProviderReply<ConnectResult>>;
+    signIn(): Promise<ProviderReply<SignInResult>>;
+    propose(p: ProposeParams): Promise<ProviderReply<TxResult>>;
+    attest(p: AttestParams): Promise<ProviderReply<TxResult>>;
+    send(p: SendParams): Promise<ProviderReply<TxResult>>;
+    sealClaim(p: SealClaimParams): Promise<ProviderReply<TxResult>>;
+    revealClaim(txid: string): Promise<ProviderReply<TxResult>>;
+}
+/** Every provider call resolves to this discriminated reply (never rejects). */
+type ProviderReply<T> = {
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: string;
+};
+declare global {
+    interface Window {
+        cairn?: CairnProvider;
+    }
+}
+interface DetectOptions {
+    /** How long to wait for the provider to announce itself (ms, default 3000). */
+    timeoutMs?: number;
+}
+/**
+ * Resolve `window.cairn`, waiting for the wallet's `cairn#initialized` event if the
+ * content script hasn't injected yet. Throws `NotInstalledError` on timeout or
+ * outside a browser.
+ */
+declare function detectProvider(opts?: DetectOptions): Promise<CairnProvider>;
+/** True if the Cairn Wallet is already present (no waiting). */
+declare function isInstalled(): boolean;
+/**
+ * High-level, typed wallet handle. Construct via `connect()` or `new WalletConnection(provider)`.
+ * Methods throw `UserRejectedError` / `WalletLockedError` / `UnsupportedMethodError` on failure.
+ */
+declare class WalletConnection {
+    readonly provider: CairnProvider;
+    private _addr;
+    constructor(provider: CairnProvider);
+    /** The wallet's version string (e.g. "0.2.x"). */
+    get version(): string;
+    /** The connected address, if `connect()`/`getAddress()` has resolved. */
+    get address(): string | null;
+    /** Request connection. First time per origin prompts the user; afterwards may be silent. */
+    connect(): Promise<string>;
+    /** Get the connected address (does not force a new connection prompt if already consented). */
+    getAddress(): Promise<string>;
+    /** Passwordless sign-in: a signature over a login nonce (always prompts; structurally cannot sign a tx). */
+    signIn(): Promise<SignInResult>;
+    /** Send CSD (always prompts with clear-signing; wallet picks inputs + returns change to itself). */
+    send(params: SendParams): Promise<TxResult>;
+    /** Low-level Propose (always prompts). Prefer `cairn.board.propose()` which computes the hash/uri/expiry. */
+    propose(params: ProposeParams): Promise<TxResult>;
+    /** Attest/support a proposal (always prompts). */
+    attest(params: AttestParams): Promise<TxResult>;
+    /** Seal a commit-reveal claim (always prompts; salt stays inside the wallet). */
+    sealClaim(params: SealClaimParams): Promise<TxResult>;
+    /** Reveal a previously sealed claim by its sealing txid (always prompts). */
+    revealClaim(txid: string): Promise<TxResult>;
+}
+/** Detect the wallet and return a ready `WalletConnection` (does not auto-call connect()). */
+declare function getWallet(opts?: DetectOptions): Promise<WalletConnection>;
+/** Detect + connect in one step; resolves to the connected address. */
+declare function connect(opts?: DetectOptions): Promise<{
+    wallet: WalletConnection;
+    address: string;
+}>;
+
+export { type AttestParams, type CairnProvider, type ConnectResult, type DetectOptions, type ProposeParams, type ProviderReply, type SealClaimParams, type SendParams, type SignInResult, type TxResult, WalletConnection, connect, detectProvider, getWallet, isInstalled };

package/dist/connect.js

@@ -0,0 +1,15 @@
+import {
+  WalletConnection,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+} from "./chunk-SMAPCKVG.js";
+import "./chunk-PHMU3CG5.js";
+export {
+  WalletConnection,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+};

package/dist/content.cjs

@@ -0,0 +1,113 @@
+"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/content.ts
+var content_exports = {};
+__export(content_exports, {
+  ContentClient: () => ContentClient
+});
+module.exports = __toCommonJS(content_exports);
+var import_csd_codec = require("@inversealtruism/csd-codec");
+
+// src/errors.ts
+var CairnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+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;
+  }
+};
+
+// src/content.ts
+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_codec.canonicalJson)(obj);
+    return {
+      payloadHash: (0, import_csd_codec.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_codec.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_codec.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_codec.verifyContentBytes)(bytes, normalizeHash(hash));
+  }
+};
+function normalizeHash(hash) {
+  const h = hash.startsWith("0x") || hash.startsWith("0X") ? hash : `0x${hash}`;
+  return h.toLowerCase();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentClient
+});

package/dist/content.d.cts

@@ -0,0 +1,44 @@
+import { H as Http } from './http-D2CzfOsm.cjs';
+
+interface ContentClientOptions {
+    /** Swarm gateway HTTP client (e.g. https://cairn-substrate.com/swarm). */
+    swarm?: Http;
+    /** Cairn origin HTTP client (serves /content as origin + fallback). */
+    cairn?: Http;
+    /** Indexer HTTP client (also joins the swarm gateway at /content). */
+    indexer?: Http;
+}
+interface PreparedContent {
+    /** The 0x-prefixed sha256 payload hash that goes on-chain. */
+    payloadHash: string;
+    /** The exact canonical JSON string that was hashed. */
+    canonical: string;
+    /** UTF-8 bytes of the canonical JSON (what the swarm stores / serves). */
+    bytes: Uint8Array;
+}
+declare class ContentClient {
+    private readonly sources;
+    constructor(opts: ContentClientOptions);
+    /**
+     * 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: unknown): PreparedContent;
+    /** Alias for `prepare()` — emphasises this does not itself publish (anchor via board.propose). */
+    put(obj: unknown): PreparedContent;
+    /** Just the payload hash for an object. */
+    hash(obj: unknown): string;
+    /**
+     * 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).
+     */
+    getBytes(hash: string): Promise<Uint8Array | null>;
+    /** Fetch + verify + parse as UTF-8 JSON. Returns null if not found. */
+    get<T = unknown>(hash: string): Promise<T | null>;
+    /** Verify already-fetched bytes against a hash (no network). */
+    verify(bytes: Uint8Array, hash: string): boolean;
+}
+
+export { ContentClient, type ContentClientOptions, type PreparedContent };

package/dist/content.d.ts

@@ -0,0 +1,44 @@
+import { H as Http } from './http-D2CzfOsm.js';
+
+interface ContentClientOptions {
+    /** Swarm gateway HTTP client (e.g. https://cairn-substrate.com/swarm). */
+    swarm?: Http;
+    /** Cairn origin HTTP client (serves /content as origin + fallback). */
+    cairn?: Http;
+    /** Indexer HTTP client (also joins the swarm gateway at /content). */
+    indexer?: Http;
+}
+interface PreparedContent {
+    /** The 0x-prefixed sha256 payload hash that goes on-chain. */
+    payloadHash: string;
+    /** The exact canonical JSON string that was hashed. */
+    canonical: string;
+    /** UTF-8 bytes of the canonical JSON (what the swarm stores / serves). */
+    bytes: Uint8Array;
+}
+declare class ContentClient {
+    private readonly sources;
+    constructor(opts: ContentClientOptions);
+    /**
+     * 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: unknown): PreparedContent;
+    /** Alias for `prepare()` — emphasises this does not itself publish (anchor via board.propose). */
+    put(obj: unknown): PreparedContent;
+    /** Just the payload hash for an object. */
+    hash(obj: unknown): string;
+    /**
+     * 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).
+     */
+    getBytes(hash: string): Promise<Uint8Array | null>;
+    /** Fetch + verify + parse as UTF-8 JSON. Returns null if not found. */
+    get<T = unknown>(hash: string): Promise<T | null>;
+    /** Verify already-fetched bytes against a hash (no network). */
+    verify(bytes: Uint8Array, hash: string): boolean;
+}
+
+export { ContentClient, type ContentClientOptions, type PreparedContent };

package/dist/content.js

@@ -0,0 +1,7 @@
+import {
+  ContentClient
+} from "./chunk-BZVJVL4Q.js";
+import "./chunk-PHMU3CG5.js";
+export {
+  ContentClient
+};

package/dist/http-D2CzfOsm.d.cts

@@ -0,0 +1,30 @@
+type FetchLike = typeof fetch;
+interface HttpOptions {
+    /** Base URL with no trailing slash, e.g. "https://cairn-substrate.com". */
+    baseUrl: string;
+    /** Custom fetch (defaults to global fetch). */
+    fetch?: FetchLike;
+    /** Per-request timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** Extra headers sent on every request. */
+    headers?: Record<string, string>;
+}
+declare class Http {
+    readonly baseUrl: string;
+    private readonly _fetch;
+    private readonly timeoutMs;
+    private readonly headers;
+    constructor(opts: HttpOptions);
+    /** Build an absolute URL from a path + optional query params. */
+    url(path: string, query?: Record<string, string | number | boolean | undefined>): string;
+    private raw;
+    getJson<T = unknown>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    postJson<T = unknown>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
+    /** GET raw bytes (for content retrieval). Returns null on 404. */
+    getBytes(path: string): Promise<{
+        bytes: Uint8Array;
+        headers: Headers;
+    } | null>;
+}
+
+export { type FetchLike as F, Http as H, type HttpOptions as a };