@inversealtruism/cairn-sdk 0.1.0

package/dist/chain.cjs

@@ -0,0 +1,144 @@
+"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/chain.ts
+var chain_exports = {};
+__export(chain_exports, {
+  ADDR_RE: () => import_csd_crypto.ADDR_RE,
+  Chain: () => Chain,
+  CsdClient: () => import_csd_client.CsdClient,
+  LightClient: () => import_csd_light.LightClient,
+  addrFromPriv: () => import_csd_crypto.addrFromPriv,
+  addrFromPub: () => import_csd_crypto.addrFromPub,
+  buildAttest: () => import_csd_tx.buildAttest,
+  buildPropose: () => import_csd_tx.buildPropose,
+  buildSend: () => import_csd_tx.buildSend,
+  canonicalJson: () => import_csd_codec.canonicalJson,
+  deserialize: () => import_csd_codec.deserialize,
+  expectedBits: () => import_csd_light.expectedBits,
+  expectedBitsFromWindow: () => import_csd_light.expectedBitsFromWindow,
+  hash160: () => import_csd_crypto.hash160,
+  hb: () => import_csd_codec.hb,
+  headerHash: () => import_csd_codec.headerHash,
+  hx: () => import_csd_codec.hx,
+  isValidAddr: () => import_csd_crypto.isValidAddr,
+  isValidPriv: () => import_csd_crypto.isValidPriv,
+  keygen: () => import_csd_crypto.keygen,
+  merkleBranch: () => import_csd_codec.merkleBranch,
+  merkleRoot: () => import_csd_codec.merkleRoot,
+  payloadHash: () => import_csd_codec.payloadHash,
+  pubFromPriv: () => import_csd_crypto.pubFromPriv,
+  randomNonce: () => import_csd_crypto.randomNonce,
+  rpcHeaderToHeader: () => import_csd_client.rpcHeaderToHeader,
+  rpcTxToTx: () => import_csd_client.rpcTxToTx,
+  selectInputs: () => import_csd_tx.selectInputs,
+  serialize: () => import_csd_codec.serialize,
+  sha256d: () => import_csd_codec.sha256d,
+  sighash: () => import_csd_codec.sighash,
+  signDigest: () => import_csd_crypto.signDigest,
+  signTx: () => import_csd_tx.signTx,
+  strip0x: () => import_csd_codec.strip0x,
+  strippedTx: () => import_csd_codec.strippedTx,
+  txSize: () => import_csd_tx.txSize,
+  txToNodeJson: () => import_csd_tx.txToNodeJson,
+  txid: () => import_csd_codec.txid,
+  verifyContentBytes: () => import_csd_codec.verifyContentBytes,
+  verifyDigest: () => import_csd_crypto.verifyDigest,
+  verifyMerkleProof: () => import_csd_codec.verifyMerkleProof
+});
+module.exports = __toCommonJS(chain_exports);
+var import_csd_client = require("@inversealtruism/csd-client");
+var import_csd_tx = require("@inversealtruism/csd-tx");
+var import_csd_codec = require("@inversealtruism/csd-codec");
+var import_csd_crypto = require("@inversealtruism/csd-crypto");
+var import_csd_light = require("@inversealtruism/csd-light");
+var import_csd_client2 = require("@inversealtruism/csd-client");
+var import_csd_light2 = require("@inversealtruism/csd-light");
+var Chain = class {
+  client;
+  opts;
+  _light = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.client = new import_csd_client2.CsdClient({ baseUrl: opts.rpcUrl, fetch: opts.fetch, timeoutMs: opts.timeoutMs });
+  }
+  /** Current chain tip ({ tip, height, chainwork }). */
+  tip() {
+    return this.client.tip();
+  }
+  /** Spendable UTXOs + confirmed balance for an address. */
+  utxos(addr) {
+    return this.client.utxos(addr);
+  }
+  /** Submit a signed transaction (node-shaped JSON from `signTx().nodeJson`). */
+  submit(nodeJsonTx) {
+    return this.client.submit(nodeJsonTx);
+  }
+  /** A verifying light client over the same RPC (built once, reused). */
+  light() {
+    if (!this._light) {
+      this._light = new import_csd_light2.LightClient({ client: this.client });
+    }
+    return this._light;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADDR_RE,
+  Chain,
+  CsdClient,
+  LightClient,
+  addrFromPriv,
+  addrFromPub,
+  buildAttest,
+  buildPropose,
+  buildSend,
+  canonicalJson,
+  deserialize,
+  expectedBits,
+  expectedBitsFromWindow,
+  hash160,
+  hb,
+  headerHash,
+  hx,
+  isValidAddr,
+  isValidPriv,
+  keygen,
+  merkleBranch,
+  merkleRoot,
+  payloadHash,
+  pubFromPriv,
+  randomNonce,
+  rpcHeaderToHeader,
+  rpcTxToTx,
+  selectInputs,
+  serialize,
+  sha256d,
+  sighash,
+  signDigest,
+  signTx,
+  strip0x,
+  strippedTx,
+  txSize,
+  txToNodeJson,
+  txid,
+  verifyContentBytes,
+  verifyDigest,
+  verifyMerkleProof
+});

package/dist/chain.d.cts

@@ -0,0 +1,36 @@
+import * as _inversealtruism_csd_client from '@inversealtruism/csd-client';
+import { CsdClient } from '@inversealtruism/csd-client';
+export { ClientOptions, CsdClient, RpcBlock, RpcHeaderJson, RpcSubmit, RpcTip, RpcTxJson, RpcUtxo, RpcUtxos, rpcHeaderToHeader, rpcTxToTx } from '@inversealtruism/csd-client';
+export { BuildResult, Selection, Signed, Utxo, buildAttest, buildPropose, buildSend, selectInputs, signTx, txSize, txToNodeJson } from '@inversealtruism/csd-tx';
+export { App, BlockHeader, Tx, TxInput, TxOutput, canonicalJson, deserialize, hb, headerHash, hx, merkleBranch, merkleRoot, payloadHash, serialize, sha256d, sighash, strip0x, strippedTx, txid, verifyContentBytes, verifyMerkleProof } from '@inversealtruism/csd-codec';
+export { ADDR_RE, addrFromPriv, addrFromPub, hash160, isValidAddr, isValidPriv, keygen, pubFromPriv, randomNonce, signDigest, verifyDigest } from '@inversealtruism/csd-crypto';
+import { LightClient } from '@inversealtruism/csd-light';
+export { InclusionResult, LightClient, ReorgResult, TrustLevel, VerifiedHeader, expectedBits, expectedBitsFromWindow } from '@inversealtruism/csd-light';
+import { F as FetchLike } from './http-D2CzfOsm.cjs';
+
+interface ChainOptions {
+    /** Node RPC base URL — defaults to the public Cairn proxy (no local node needed). */
+    rpcUrl: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+}
+/**
+ * Convenience handle over a CSD node RPC. `client` is the full typed RPC client;
+ * `light()` lazily builds a verifying light client over the same endpoint.
+ */
+declare class Chain {
+    readonly client: CsdClient;
+    private readonly opts;
+    private _light;
+    constructor(opts: ChainOptions);
+    /** Current chain tip ({ tip, height, chainwork }). */
+    tip(): Promise<_inversealtruism_csd_client.RpcTip>;
+    /** Spendable UTXOs + confirmed balance for an address. */
+    utxos(addr: string): Promise<_inversealtruism_csd_client.RpcUtxos>;
+    /** Submit a signed transaction (node-shaped JSON from `signTx().nodeJson`). */
+    submit(nodeJsonTx: unknown): Promise<_inversealtruism_csd_client.RpcSubmit>;
+    /** A verifying light client over the same RPC (built once, reused). */
+    light(): LightClient;
+}
+
+export { Chain, type ChainOptions };

package/dist/chain.d.ts

@@ -0,0 +1,36 @@
+import * as _inversealtruism_csd_client from '@inversealtruism/csd-client';
+import { CsdClient } from '@inversealtruism/csd-client';
+export { ClientOptions, CsdClient, RpcBlock, RpcHeaderJson, RpcSubmit, RpcTip, RpcTxJson, RpcUtxo, RpcUtxos, rpcHeaderToHeader, rpcTxToTx } from '@inversealtruism/csd-client';
+export { BuildResult, Selection, Signed, Utxo, buildAttest, buildPropose, buildSend, selectInputs, signTx, txSize, txToNodeJson } from '@inversealtruism/csd-tx';
+export { App, BlockHeader, Tx, TxInput, TxOutput, canonicalJson, deserialize, hb, headerHash, hx, merkleBranch, merkleRoot, payloadHash, serialize, sha256d, sighash, strip0x, strippedTx, txid, verifyContentBytes, verifyMerkleProof } from '@inversealtruism/csd-codec';
+export { ADDR_RE, addrFromPriv, addrFromPub, hash160, isValidAddr, isValidPriv, keygen, pubFromPriv, randomNonce, signDigest, verifyDigest } from '@inversealtruism/csd-crypto';
+import { LightClient } from '@inversealtruism/csd-light';
+export { InclusionResult, LightClient, ReorgResult, TrustLevel, VerifiedHeader, expectedBits, expectedBitsFromWindow } from '@inversealtruism/csd-light';
+import { F as FetchLike } from './http-D2CzfOsm.js';
+
+interface ChainOptions {
+    /** Node RPC base URL — defaults to the public Cairn proxy (no local node needed). */
+    rpcUrl: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+}
+/**
+ * Convenience handle over a CSD node RPC. `client` is the full typed RPC client;
+ * `light()` lazily builds a verifying light client over the same endpoint.
+ */
+declare class Chain {
+    readonly client: CsdClient;
+    private readonly opts;
+    private _light;
+    constructor(opts: ChainOptions);
+    /** Current chain tip ({ tip, height, chainwork }). */
+    tip(): Promise<_inversealtruism_csd_client.RpcTip>;
+    /** Spendable UTXOs + confirmed balance for an address. */
+    utxos(addr: string): Promise<_inversealtruism_csd_client.RpcUtxos>;
+    /** Submit a signed transaction (node-shaped JSON from `signTx().nodeJson`). */
+    submit(nodeJsonTx: unknown): Promise<_inversealtruism_csd_client.RpcSubmit>;
+    /** A verifying light client over the same RPC (built once, reused). */
+    light(): LightClient;
+}
+
+export { Chain, type ChainOptions };

package/dist/chain.js

@@ -0,0 +1,86 @@
+import {
+  ADDR_RE,
+  Chain,
+  CsdClient,
+  LightClient,
+  addrFromPriv,
+  addrFromPub,
+  buildAttest,
+  buildPropose,
+  buildSend,
+  canonicalJson,
+  deserialize,
+  expectedBits,
+  expectedBitsFromWindow,
+  hash160,
+  hb,
+  headerHash,
+  hx,
+  isValidAddr,
+  isValidPriv,
+  keygen,
+  merkleBranch,
+  merkleRoot,
+  payloadHash,
+  pubFromPriv,
+  randomNonce,
+  rpcHeaderToHeader,
+  rpcTxToTx,
+  selectInputs,
+  serialize,
+  sha256d,
+  sighash,
+  signDigest,
+  signTx,
+  strip0x,
+  strippedTx,
+  txSize,
+  txToNodeJson,
+  txid,
+  verifyContentBytes,
+  verifyDigest,
+  verifyMerkleProof
+} from "./chunk-6VWLWF7R.js";
+export {
+  ADDR_RE,
+  Chain,
+  CsdClient,
+  LightClient,
+  addrFromPriv,
+  addrFromPub,
+  buildAttest,
+  buildPropose,
+  buildSend,
+  canonicalJson,
+  deserialize,
+  expectedBits,
+  expectedBitsFromWindow,
+  hash160,
+  hb,
+  headerHash,
+  hx,
+  isValidAddr,
+  isValidPriv,
+  keygen,
+  merkleBranch,
+  merkleRoot,
+  payloadHash,
+  pubFromPriv,
+  randomNonce,
+  rpcHeaderToHeader,
+  rpcTxToTx,
+  selectInputs,
+  serialize,
+  sha256d,
+  sighash,
+  signDigest,
+  signTx,
+  strip0x,
+  strippedTx,
+  txSize,
+  txToNodeJson,
+  txid,
+  verifyContentBytes,
+  verifyDigest,
+  verifyMerkleProof
+};

package/dist/chunk-6VWLWF7R.js

@@ -0,0 +1,121 @@
+// src/chain.ts
+import {
+  CsdClient,
+  rpcTxToTx,
+  rpcHeaderToHeader
+} from "@inversealtruism/csd-client";
+import {
+  selectInputs,
+  txSize,
+  txToNodeJson,
+  signTx,
+  buildSend,
+  buildPropose,
+  buildAttest
+} from "@inversealtruism/csd-tx";
+import {
+  payloadHash,
+  canonicalJson,
+  verifyContentBytes,
+  txid,
+  sighash,
+  serialize,
+  deserialize,
+  strippedTx,
+  merkleRoot,
+  merkleBranch,
+  verifyMerkleProof,
+  headerHash,
+  hb,
+  hx,
+  strip0x,
+  sha256d
+} from "@inversealtruism/csd-codec";
+import {
+  keygen,
+  pubFromPriv,
+  addrFromPriv,
+  addrFromPub,
+  hash160,
+  isValidAddr,
+  isValidPriv,
+  signDigest,
+  verifyDigest,
+  randomNonce,
+  ADDR_RE
+} from "@inversealtruism/csd-crypto";
+import { LightClient, expectedBits, expectedBitsFromWindow } from "@inversealtruism/csd-light";
+import { CsdClient as CsdClient2 } from "@inversealtruism/csd-client";
+import { LightClient as LightClient2 } from "@inversealtruism/csd-light";
+var Chain = class {
+  client;
+  opts;
+  _light = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.client = new CsdClient2({ baseUrl: opts.rpcUrl, fetch: opts.fetch, timeoutMs: opts.timeoutMs });
+  }
+  /** Current chain tip ({ tip, height, chainwork }). */
+  tip() {
+    return this.client.tip();
+  }
+  /** Spendable UTXOs + confirmed balance for an address. */
+  utxos(addr) {
+    return this.client.utxos(addr);
+  }
+  /** Submit a signed transaction (node-shaped JSON from `signTx().nodeJson`). */
+  submit(nodeJsonTx) {
+    return this.client.submit(nodeJsonTx);
+  }
+  /** A verifying light client over the same RPC (built once, reused). */
+  light() {
+    if (!this._light) {
+      this._light = new LightClient2({ client: this.client });
+    }
+    return this._light;
+  }
+};
+
+export {
+  Chain,
+  CsdClient,
+  rpcTxToTx,
+  rpcHeaderToHeader,
+  selectInputs,
+  txSize,
+  txToNodeJson,
+  signTx,
+  buildSend,
+  buildPropose,
+  buildAttest,
+  payloadHash,
+  canonicalJson,
+  verifyContentBytes,
+  txid,
+  sighash,
+  serialize,
+  deserialize,
+  strippedTx,
+  merkleRoot,
+  merkleBranch,
+  verifyMerkleProof,
+  headerHash,
+  hb,
+  hx,
+  strip0x,
+  sha256d,
+  keygen,
+  pubFromPriv,
+  addrFromPriv,
+  addrFromPub,
+  hash160,
+  isValidAddr,
+  isValidPriv,
+  signDigest,
+  verifyDigest,
+  randomNonce,
+  ADDR_RE,
+  LightClient,
+  expectedBits,
+  expectedBitsFromWindow
+};

package/dist/chunk-BZVJVL4Q.js

@@ -0,0 +1,76 @@
+import {
+  ContentVerificationError
+} from "./chunk-PHMU3CG5.js";
+
+// src/content.ts
+import { payloadHash, canonicalJson, verifyContentBytes } from "@inversealtruism/csd-codec";
+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 = canonicalJson(obj);
+    return {
+      payloadHash: 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 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 (!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 verifyContentBytes(bytes, normalizeHash(hash));
+  }
+};
+function normalizeHash(hash) {
+  const h = hash.startsWith("0x") || hash.startsWith("0X") ? hash : `0x${hash}`;
+  return h.toLowerCase();
+}
+
+export {
+  ContentClient
+};