@inversealtruism/cairn-sdk 0.1.0

package/dist/chunk-ETZYBDFC.js

@@ -0,0 +1,232 @@
+// src/indexer.ts
+import { verifyMerkleProof } from "@inversealtruism/csd-codec";
+var IndexerClient = class {
+  http;
+  opts;
+  constructor(http, opts = {}) {
+    this.http = http;
+    this.opts = opts;
+  }
+  // ---- REST --------------------------------------------------------------
+  health() {
+    return this.http.getJson("/health");
+  }
+  tipHeight() {
+    return this.http.getJson("/blocks/tip/height");
+  }
+  tipHash() {
+    return this.http.getJson("/blocks/tip/hash");
+  }
+  blockHashAtHeight(h) {
+    return this.http.getJson(`/block-height/${h}`);
+  }
+  block(hash) {
+    return this.http.getJson(`/block/${hash}`);
+  }
+  blockTxids(hash) {
+    return this.http.getJson(`/block/${hash}/txids`);
+  }
+  tx(id) {
+    return this.http.getJson(`/tx/${id}`);
+  }
+  txStatus(id) {
+    return this.http.getJson(`/tx/${id}/status`);
+  }
+  txMerkleProof(id) {
+    return this.http.getJson(`/tx/${id}/merkle-proof`);
+  }
+  address(a) {
+    return this.http.getJson(`/address/${a}`);
+  }
+  addressTxs(a) {
+    return this.http.getJson(`/address/${a}/txs`);
+  }
+  addressUtxo(a) {
+    return this.http.getJson(`/address/${a}/utxo`);
+  }
+  reputation(a) {
+    return this.http.getJson(`/address/${a}/reputation`);
+  }
+  domains() {
+    return this.http.getJson("/domains");
+  }
+  domainProposals(d) {
+    return this.http.getJson(`/domain/${encodeURIComponent(d)}/proposals`);
+  }
+  proposal(id) {
+    return this.http.getJson(`/proposal/${id}`);
+  }
+  attestations(id) {
+    return this.http.getJson(`/proposal/${id}/attestations`);
+  }
+  registryPeers() {
+    return this.http.getJson("/registry/peers");
+  }
+  registryGateways() {
+    return this.http.getJson("/registry/gateways");
+  }
+  identity(handle) {
+    return this.http.getJson(`/identity/${encodeURIComponent(handle)}`);
+  }
+  reverseIdentity(addr) {
+    return this.http.getJson(`/address/${addr}/identity`);
+  }
+  // ---- trust-minimized inclusion ----------------------------------------
+  /**
+   * Verify a tx is included in a block by folding its merkle branch to the root
+   * with csd-codec.verifyMerkleProof. If `headerMerkleAt` was provided, the
+   * proof's root is cross-checked against the ON-CHAIN header merkle at that
+   * height → trustLevel "verified-inclusion". Otherwise the proof is only
+   * internally consistent → "proof-consistent" (still useful, but the indexer is trusted).
+   */
+  async verifyInclusion(txid) {
+    let proof;
+    try {
+      proof = await this.txMerkleProof(txid);
+    } catch {
+      return { included: false, trustLevel: "not-found", reason: "no merkle proof (tx not indexed)" };
+    }
+    const folds = verifyMerkleProof(txid, proof.pos, proof.merkle, proof.merkle_root);
+    if (!folds) {
+      return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "merkle branch does not fold to the claimed root" };
+    }
+    if (this.opts.headerMerkleAt) {
+      try {
+        const onchain = await this.opts.headerMerkleAt(proof.block_height);
+        if (norm(onchain) !== norm(proof.merkle_root)) {
+          return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "proof root != on-chain header merkle (indexer disagrees with chain)" };
+        }
+        return { included: true, trustLevel: "verified-inclusion", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+      } catch {
+      }
+    }
+    return { included: true, trustLevel: "proof-consistent", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+  }
+  // ---- live streams ------------------------------------------------------
+  /** Stream all events (blocks, proposals, attestations, reorgs) via SSE. */
+  streamAll(handlers) {
+    return this.sse("/stream/all", handlers);
+  }
+  /** Stream blocks + reorgs only. */
+  streamBlocks(handlers) {
+    return this.sse("/stream/blocks", handlers);
+  }
+  /** Stream proposals (+ reorgs) for a domain. */
+  streamDomain(domain, handlers) {
+    return this.sse(`/stream/domain/${encodeURIComponent(domain)}`, handlers);
+  }
+  /**
+   * Subscribe over WebSocket with selective tracking. Returns a handle with
+   * `.close()`. `onEvent` receives every matching IndexEvent (incl. reorgs).
+   */
+  subscribe(sub, onEvent, onError) {
+    const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      throw new Error("No WebSocket available \u2014 pass WebSocketImpl in the indexer options (e.g. in older Node).");
+    }
+    const wsUrl = this.http.url("/ws").replace(/^http/, "ws");
+    let closed = false;
+    const ws = new WS(wsUrl);
+    ws.addEventListener("open", () => {
+      const msg = {};
+      if (sub.all) msg["track-all"] = true;
+      if (sub.domains?.length) msg["track-domain"] = sub.domains;
+      if (sub.addresses?.length) msg["track-address"] = sub.addresses;
+      if (sub.proposals?.length) msg["track-proposal"] = sub.proposals;
+      ws.send(JSON.stringify(Object.keys(msg).length ? msg : { "track-all": true }));
+    });
+    ws.addEventListener("message", (ev) => {
+      try {
+        const data = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+        if (data && data.kind) onEvent(data);
+      } catch {
+      }
+    });
+    if (onError) ws.addEventListener("error", (e) => onError(e));
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    };
+  }
+  // ---- internal SSE over fetch (portable + auto-reconnect) ---------------
+  sse(path, handlers) {
+    const fetchImpl = this.opts.fetch ?? globalThis.fetch;
+    const url = this.http.url(path);
+    let closed = false;
+    let ctrl = null;
+    const run = async () => {
+      while (!closed) {
+        ctrl = new AbortController();
+        try {
+          const res = await fetchImpl(url, { signal: ctrl.signal, headers: { accept: "text/event-stream" } });
+          if (!res.ok || !res.body) throw new Error(`SSE ${res.status}`);
+          handlers.onOpen?.();
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let buf = "";
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            buf += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n\n")) >= 0) {
+              const frame = buf.slice(0, idx);
+              buf = buf.slice(idx + 2);
+              dispatchFrame(frame, handlers);
+            }
+          }
+        } catch (err) {
+          if (closed) return;
+          handlers.onError?.(err);
+        }
+        if (closed) return;
+        await new Promise((r) => setTimeout(r, 2e3));
+      }
+    };
+    void run();
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ctrl?.abort();
+        } catch {
+        }
+      }
+    };
+  }
+};
+function dispatchFrame(frame, h) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of frame.split("\n")) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+  }
+  if (event === "hello" || dataLines.length === 0) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return;
+  }
+  h.onEvent?.(parsed);
+  if (parsed.kind === "block") h.onBlock?.(parsed);
+  else if (parsed.kind === "proposal") h.onProposal?.(parsed);
+  else if (parsed.kind === "attestation") h.onAttestation?.(parsed);
+  else if (parsed.kind === "reorg") h.onReorg?.(parsed);
+}
+function norm(h) {
+  return String(h).toLowerCase().replace(/^0x/, "");
+}
+
+export {
+  IndexerClient
+};

package/dist/chunk-G7FABIF4.js

@@ -0,0 +1,60 @@
+// 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. */
+  resolveName(handle) {
+    return resolveName(this.src, handle);
+  }
+  /** Reverse-resolve an address → identity (GET /address/:addr/identity). */
+  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
+};

package/dist/chunk-OGP2W7DL.js

@@ -0,0 +1,163 @@
+import {
+  CairnError
+} from "./chunk-PHMU3CG5.js";
+
+// src/board.ts
+import { payloadHash } from "@inversealtruism/csd-codec";
+import { MIN_FEE_PROPOSE, MIN_FEE_ATTEST, EPOCH_LEN } from "@inversealtruism/csd-codec";
+var BoardClient = class {
+  http;
+  wallet;
+  constructor(http, wallet) {
+    this.http = http;
+    this.wallet = wallet;
+  }
+  requireWallet() {
+    if (!this.wallet) {
+      throw new CairnError("This action needs a connected wallet. Construct Cairn with a wallet, or call cairn.connect() first.");
+    }
+    return this.wallet;
+  }
+  // ---- reads (public) ----------------------------------------------------
+  /** Ranked board for a domain + time window. */
+  board(opts = {}) {
+    return this.http.getJson("/api/board", { domain: opts.domain ?? "all", window: opts.window ?? "all" });
+  }
+  /** Alias for `board()` — the top items. */
+  top(opts = {}) {
+    return this.board(opts);
+  }
+  /** A single item with its supports + pledges + integrity flag. */
+  item(id) {
+    return this.http.getJson(`/api/item/${encodeURIComponent(id)}`);
+  }
+  /** Known + discovered domains. */
+  domains() {
+    return this.http.getJson("/api/domains");
+  }
+  /** All quests (work-graph items). */
+  quests() {
+    return this.http.getJson("/api/quests");
+  }
+  /** A single quest with claims/submissions/payouts. */
+  quest(id) {
+    return this.http.getJson(`/api/quest/${encodeURIComponent(id)}`);
+  }
+  /** An address's on-chain-derived profile + identity + reputation. */
+  profile(addr, opts = {}) {
+    return this.http.getJson(`/api/profile/${encodeURIComponent(addr)}`, opts.live ? { live: 1 } : void 0);
+  }
+  /** Reputation leaderboard (top 50). */
+  leaderboard() {
+    return this.http.getJson("/api/leaderboard");
+  }
+  /** Network dashboard snapshot. */
+  network() {
+    return this.http.getJson("/api/network");
+  }
+  /** Network time-series for charts. */
+  networkSeries(range = "24h") {
+    return this.http.getJson("/api/network/series", { range });
+  }
+  /** Recent blocks with miner/reward. */
+  networkBlocks(limit = 15) {
+    return this.http.getJson("/api/network/blocks", { limit });
+  }
+  /** Per-miner hashrate estimate. */
+  miner(addr) {
+    return this.http.getJson(`/api/miner/${encodeURIComponent(addr)}`);
+  }
+  /** Recent activity feed. */
+  activity() {
+    return this.http.getJson("/api/activity");
+  }
+  /** The gamified cairn wall. */
+  wall() {
+    return this.http.getJson("/api/wall");
+  }
+  /** Server health + chain reachability. */
+  health() {
+    return this.http.getJson("/api/health");
+  }
+  // ---- writes (wallet-signed) -------------------------------------------
+  /**
+   * Publish a board item: compute the canonical payload hash, have the WALLET
+   * build/sign/submit the Propose (clear-signed approval), then register the
+   * off-chain content. The payload hash is byte-identical to what the cairn
+   * server verifies (csd-codec.payloadHash over { v:1, domain, title, body, links }).
+   */
+  async propose(input) {
+    const wallet = this.requireWallet();
+    const content = {
+      v: 1,
+      domain: input.domain,
+      title: input.title,
+      body: input.body ?? "",
+      links: input.links ?? []
+    };
+    const ph = payloadHash(content);
+    const uri = `cairn:v1:${ph.slice(2, 14)}`;
+    const lifetime = input.lifetimeEpochs ?? 720;
+    const height = await this.tipHeight();
+    const expiresEpoch = Math.floor(height / EPOCH_LEN) + lifetime;
+    const fee = input.fee ?? MIN_FEE_PROPOSE;
+    const r = await wallet.propose({ domain: content.domain, payloadHash: ph, uri, expiresEpoch, fee });
+    const txid = String(r.txid ?? "");
+    if (!txid) throw new CairnError("Propose submitted but no txid was returned by the wallet.");
+    const reg = await this.tryRegister(content, txid);
+    return { txid, payloadHash: ph, content, registered: reg.ok, registerError: reg.error };
+  }
+  /**
+   * Register off-chain content for an already-submitted proposal txid. Idempotent.
+   * Returns { ok } — the cairn server verifies sha256(canonical) == on-chain payload_hash.
+   */
+  async registerContent(content, txid) {
+    try {
+      const res = await this.http.postJson("/api/content", {
+        domain: content.domain,
+        title: content.title,
+        body: content.body,
+        links: content.links,
+        txid
+      });
+      return { ok: !!res.ok, error: res.ok ? void 0 : res.error };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /** Support/attest a proposal (wallet-signed; always clear-signed). */
+  async support(proposalId, opts = {}) {
+    const wallet = this.requireWallet();
+    return wallet.attest({
+      proposalId,
+      score: opts.score ?? 80,
+      confidence: opts.confidence ?? 70,
+      fee: opts.fee ?? MIN_FEE_ATTEST
+    });
+  }
+  // ---- internal ----------------------------------------------------------
+  async tipHeight() {
+    const tip = await this.http.getJson("/api/rpc/tip");
+    const h = Number(tip?.height);
+    if (!Number.isFinite(h)) throw new CairnError("Could not read chain tip height for expiry computation.");
+    return h;
+  }
+  async tryRegister(content, txid) {
+    const delays = [0, 1500, 3e3, 5e3];
+    let last = { ok: false, error: "not attempted" };
+    for (const d of delays) {
+      if (d) await sleep(d);
+      last = await this.registerContent(content, txid);
+      if (last.ok) return last;
+      if (!/not found yet|not found/i.test(last.error ?? "")) return last;
+    }
+    return last;
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+export {
+  BoardClient
+};

package/dist/chunk-PHMU3CG5.js

@@ -0,0 +1,63 @@
+// src/errors.ts
+var CairnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var NotInstalledError = class extends CairnError {
+  constructor(message = "Cairn Wallet not detected. Install it from cairn-substrate.com.") {
+    super(message);
+  }
+};
+var UserRejectedError = class extends CairnError {
+  constructor(message = "Request rejected by user.") {
+    super(message);
+  }
+};
+var WalletLockedError = class extends CairnError {
+  constructor(message = "Wallet is locked.") {
+    super(message);
+  }
+};
+var UnsupportedMethodError = class extends CairnError {
+  constructor(message = "Method not supported by the wallet.") {
+    super(message);
+  }
+};
+var HttpError = class extends CairnError {
+  status;
+  url;
+  body;
+  constructor(status, url, body) {
+    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+};
+var ContentVerificationError = class extends CairnError {
+  expected;
+  constructor(expected) {
+    super(`Content does not match its payload hash ${expected} \u2014 bytes were tampered with in transit.`);
+    this.expected = expected;
+  }
+};
+function mapProviderError(error) {
+  const e = String(error || "").toLowerCase();
+  if (e.includes("rejected by user")) return new UserRejectedError(error);
+  if (e.includes("wallet locked")) return new WalletLockedError(error);
+  if (e.includes("unsupported dapp method")) return new UnsupportedMethodError(error);
+  return new CairnError(error || "Unknown wallet error");
+}
+
+export {
+  CairnError,
+  NotInstalledError,
+  UserRejectedError,
+  WalletLockedError,
+  UnsupportedMethodError,
+  HttpError,
+  ContentVerificationError,
+  mapProviderError
+};

package/dist/chunk-SMAPCKVG.js

@@ -0,0 +1,118 @@
+import {
+  NotInstalledError,
+  UnsupportedMethodError,
+  mapProviderError
+} from "./chunk-PHMU3CG5.js";
+
+// 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 };
+}
+
+export {
+  detectProvider,
+  isInstalled,
+  WalletConnection,
+  getWallet,
+  connect
+};