@inversealtruism/csd-codec 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 InverseAltruism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,444 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CHAIN_ID: () => CHAIN_ID,
+  CHAIN_ID_HASH: () => CHAIN_ID_HASH,
+  COIN: () => COIN,
+  EPOCH_LEN: () => EPOCH_LEN,
+  GENESIS_HASH: () => GENESIS_HASH,
+  GENESIS_TIME: () => GENESIS_TIME,
+  HALVING_INTERVAL: () => HALVING_INTERVAL,
+  INITIAL_BITS: () => INITIAL_BITS,
+  INITIAL_REWARD: () => INITIAL_REWARD,
+  LWMA_SOLVETIME_MAX_FACTOR: () => LWMA_SOLVETIME_MAX_FACTOR,
+  LWMA_WINDOW: () => LWMA_WINDOW,
+  MAX_FUTURE_DRIFT_SECS: () => MAX_FUTURE_DRIFT_SECS,
+  MAX_HALVINGS: () => MAX_HALVINGS,
+  MAX_TX_INPUTS: () => MAX_TX_INPUTS,
+  MAX_TX_OUTPUTS: () => MAX_TX_OUTPUTS,
+  MIN_BLOCK_SPACING_SECS: () => MIN_BLOCK_SPACING_SECS,
+  MIN_FEE_ATTEST: () => MIN_FEE_ATTEST,
+  MIN_FEE_PROPOSE: () => MIN_FEE_PROPOSE,
+  MTP_WINDOW: () => MTP_WINDOW,
+  POW_LIMIT_BITS: () => POW_LIMIT_BITS,
+  TARGET_BLOCK_SECS: () => TARGET_BLOCK_SECS,
+  bigIntToTarget: () => bigIntToTarget,
+  bitsToTarget: () => bitsToTarget,
+  blockReward: () => blockReward,
+  bytesToHex: () => import_utils.bytesToHex,
+  canonicalJson: () => canonicalJson,
+  concatBytes: () => import_utils.concatBytes,
+  deserialize: () => deserialize,
+  hb: () => hb,
+  hbFixed: () => hbFixed,
+  headerHash: () => headerHash,
+  headerHashBytes: () => headerHashBytes,
+  hexToBytes: () => import_utils.hexToBytes,
+  hx: () => hx,
+  lenBytes: () => lenBytes,
+  merkleBranch: () => merkleBranch,
+  merkleRoot: () => merkleRoot,
+  payloadHash: () => payloadHash,
+  powOk: () => powOk,
+  serialize: () => serialize,
+  serializeHeader: () => serializeHeader,
+  sha256d: () => sha256d,
+  sighash: () => sighash,
+  strip0x: () => strip0x,
+  strippedTx: () => strippedTx,
+  taggedHash: () => taggedHash,
+  targetToBigInt: () => targetToBigInt,
+  targetToBits: () => targetToBits,
+  txid: () => txid,
+  u32: () => u32,
+  u64: () => u64,
+  utf8ToBytes: () => import_utils.utf8ToBytes,
+  verifyContentBytes: () => verifyContentBytes,
+  verifyMerkleProof: () => verifyMerkleProof,
+  workForBits: () => workForBits
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/bytes.ts
+var import_utils = require("@noble/hashes/utils");
+var import_sha256 = require("@noble/hashes/sha256");
+var strip0x = (h) => h.startsWith("0x") ? h.slice(2) : h;
+var hb = (h) => (0, import_utils.hexToBytes)(strip0x(h));
+var hx = (b) => "0x" + (0, import_utils.bytesToHex)(b);
+var sha256d = (b) => (0, import_sha256.sha256)((0, import_sha256.sha256)(b));
+function u32(n) {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, n >>> 0, true);
+  return b;
+}
+function u64(n) {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), true);
+  return b;
+}
+var lenBytes = (b) => (0, import_utils.concatBytes)(u64(b.length), b);
+function hbFixed(h, n) {
+  const b = hb(h);
+  if (b.length !== n) throw new Error(`expected a ${n}-byte (0x\u2026${n * 2}-hex) field, got ${b.length} bytes`);
+  return b;
+}
+
+// src/params.ts
+var import_utils2 = require("@noble/hashes/utils");
+var CHAIN_ID = "compute-substrate-mainnet";
+var CHAIN_ID_HASH = (0, import_utils2.hexToBytes)("1b17c7b04d05394674ca2c8e24f7433e251a1973cac2000c7b60966546e0b875");
+var GENESIS_HASH = "0x00000052c2821f71b19c3d79dfabfb12d4076ba15d83b47d008e582aad6c0d52";
+var GENESIS_TIME = 1777474800;
+var TARGET_BLOCK_SECS = 120;
+var INITIAL_BITS = 503382015;
+var POW_LIMIT_BITS = 503382015;
+var LWMA_WINDOW = 45;
+var LWMA_SOLVETIME_MAX_FACTOR = 12;
+var MAX_FUTURE_DRIFT_SECS = 2 * 60 * 60;
+var MTP_WINDOW = 11;
+var MIN_BLOCK_SPACING_SECS = 60;
+var EPOCH_LEN = 30;
+var COIN = 1e8;
+var INITIAL_REWARD = 50 * COIN;
+var HALVING_INTERVAL = 1051200;
+var MAX_HALVINGS = 64;
+var MIN_FEE_PROPOSE = 25e6;
+var MIN_FEE_ATTEST = 5e6;
+var MAX_TX_INPUTS = 512;
+var MAX_TX_OUTPUTS = 512;
+function blockReward(height) {
+  const halvings = Math.floor(height / HALVING_INTERVAL);
+  if (halvings >= MAX_HALVINGS) return 0;
+  return Math.floor(INITIAL_REWARD / 2 ** halvings);
+}
+
+// src/tx.ts
+var import_sha2562 = require("@noble/hashes/sha256");
+var import_utils3 = require("@noble/hashes/utils");
+var COINBASE_TXID = "0x" + "00".repeat(32);
+var COINBASE_VOUT = 4294967295;
+var isCoinbaseInput = (i) => i.prevTxid === COINBASE_TXID && i.vout === COINBASE_VOUT;
+function strippedTx(tx) {
+  return { ...tx, inputs: tx.inputs.map((i) => isCoinbaseInput(i) ? i : { ...i, scriptSig: "0x" }) };
+}
+function serializeApp(app) {
+  if (app.type === "None") return u32(0);
+  if (app.type === "Propose")
+    return (0, import_utils3.concatBytes)(u32(1), lenBytes((0, import_utils3.utf8ToBytes)(app.domain)), hbFixed(app.payloadHash, 32), lenBytes((0, import_utils3.utf8ToBytes)(app.uri)), u64(app.expiresEpoch));
+  return (0, import_utils3.concatBytes)(u32(2), hbFixed(app.proposalId, 32), u32(app.score), u32(app.confidence));
+}
+function serialize(tx) {
+  const parts = [u32(tx.version), u64(tx.inputs.length)];
+  for (const i of tx.inputs) parts.push(hbFixed(i.prevTxid, 32), u32(i.vout), lenBytes(hb(i.scriptSig)));
+  parts.push(u64(tx.outputs.length));
+  for (const o of tx.outputs) parts.push(u64(o.value), hbFixed(o.scriptPubkey, 20));
+  parts.push(u32(tx.locktime), serializeApp(tx.app));
+  return (0, import_utils3.concatBytes)(...parts);
+}
+function txid(tx) {
+  return hx(sha256d(serialize(strippedTx(tx))));
+}
+function taggedHash(tag, msg) {
+  const t = (0, import_sha2562.sha256)((0, import_utils3.utf8ToBytes)(tag));
+  return (0, import_sha2562.sha256)((0, import_utils3.concatBytes)(t, t, msg));
+}
+function sighash(tx) {
+  return hx(sha256d(taggedHash("CSD_SIG_V1", (0, import_utils3.concatBytes)(serialize(strippedTx(tx)), CHAIN_ID_HASH))));
+}
+var Reader = class {
+  constructor(b, dv = new DataView(b.buffer, b.byteOffset, b.byteLength)) {
+    this.b = b;
+    this.dv = dv;
+  }
+  b;
+  dv;
+  o = 0;
+  u32() {
+    const v = this.dv.getUint32(this.o, true);
+    this.o += 4;
+    return v;
+  }
+  u64() {
+    const v = this.dv.getBigUint64(this.o, true);
+    this.o += 8;
+    return v;
+  }
+  take(n) {
+    const v = this.b.subarray(this.o, this.o + n);
+    if (v.length !== n) throw new Error("unexpected end of bytes");
+    this.o += n;
+    return v;
+  }
+  vec() {
+    return this.take(Number(this.u64()));
+  }
+  fixedHex(n) {
+    return hx(this.take(n));
+  }
+  str() {
+    return new TextDecoder().decode(this.vec());
+  }
+  get offset() {
+    return this.o;
+  }
+  get length() {
+    return this.b.length;
+  }
+};
+function readApp(r) {
+  const tag = r.u32();
+  if (tag === 0) return { type: "None" };
+  if (tag === 1) return { type: "Propose", domain: r.str(), payloadHash: r.fixedHex(32), uri: r.str(), expiresEpoch: r.u64() };
+  if (tag === 2) return { type: "Attest", proposalId: r.fixedHex(32), score: r.u32(), confidence: r.u32() };
+  throw new Error(`unknown AppPayload variant ${tag}`);
+}
+function deserialize(bytes) {
+  const r = new Reader(bytes);
+  const version = r.u32();
+  const nIn = Number(r.u64());
+  const inputs = [];
+  for (let i = 0; i < nIn; i++) inputs.push({ prevTxid: r.fixedHex(32), vout: r.u32(), scriptSig: hx(r.vec()) });
+  const nOut = Number(r.u64());
+  const outputs = [];
+  for (let i = 0; i < nOut; i++) outputs.push({ value: r.u64(), scriptPubkey: r.fixedHex(20) });
+  const locktime = r.u32();
+  const app = readApp(r);
+  return { version, inputs, outputs, locktime, app };
+}
+
+// src/header.ts
+function serializeHeader(h) {
+  const buf = new Uint8Array(84);
+  buf.set(u32(h.version), 0);
+  buf.set(hbFixed(h.prev, 32), 4);
+  buf.set(hbFixed(h.merkle, 32), 36);
+  buf.set(u64(h.time), 68);
+  buf.set(u32(h.bits), 76);
+  buf.set(u32(h.nonce), 80);
+  return buf;
+}
+function headerHash(h) {
+  return hx(sha256d(serializeHeader(h)));
+}
+function headerHashBytes(h) {
+  return sha256d(serializeHeader(h));
+}
+function bitsToTarget(bits) {
+  const exp = bits >>> 24 & 255;
+  const mant = bits & 16777215;
+  const out = new Uint8Array(32);
+  if (exp === 0 || mant === 0) return out;
+  if ((mant & 8388608) !== 0) return out;
+  if (exp > 32) return out;
+  let target;
+  if (exp <= 3) target = BigInt(mant) >> BigInt(8 * (3 - exp));
+  else target = BigInt(mant) << BigInt(8 * (exp - 3));
+  if (target === 0n) return out;
+  if (target >= 1n << 256n) return out;
+  for (let i = 31; i >= 0 && target > 0n; i--) {
+    out[i] = Number(target & 0xffn);
+    target >>= 8n;
+  }
+  return out;
+}
+function targetToBigInt(target) {
+  let v = 0n;
+  for (const byte of target) v = v << 8n | BigInt(byte);
+  return v;
+}
+function bigIntToTarget(x) {
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0 && x > 0n; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+function minBE(x) {
+  if (x === 0n) return [];
+  const b = [];
+  while (x > 0n) {
+    b.unshift(Number(x & 0xffn));
+    x >>= 8n;
+  }
+  return b;
+}
+function targetToBits(target) {
+  const x = targetToBigInt(target);
+  if (x === 0n) return 0;
+  const bytes = minBE(x);
+  let exp = bytes.length;
+  let mant;
+  if (exp <= 3) {
+    const shift = BigInt(8 * (3 - exp));
+    mant = Number(x << shift & 0xffffffffn) & 16777215;
+  } else {
+    mant = (bytes[0] << 16 | bytes[1] << 8 | bytes[2]) >>> 0;
+  }
+  if ((mant & 8388608) !== 0) {
+    mant >>= 8;
+    exp += 1;
+  }
+  mant &= 16777215;
+  return (exp << 24 | mant) >>> 0;
+}
+function powOk(headerHashBE, bits) {
+  const target = bitsToTarget(bits);
+  if (target.every((b) => b === 0)) return false;
+  return targetToBigInt(headerHashBE) <= targetToBigInt(target);
+}
+function workForBits(bits) {
+  const target = targetToBigInt(bitsToTarget(bits));
+  if (target === 0n) return 0n;
+  return (1n << 256n) / (target + 1n);
+}
+function merkleRoot(txidsHex) {
+  if (txidsHex.length === 0) return "0x" + "00".repeat(32);
+  let layer = txidsHex.map(hb);
+  while (layer.length > 1) {
+    const next = [];
+    for (let i = 0; i < layer.length; i += 2) {
+      const left = layer[i];
+      const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+      const buf = new Uint8Array(64);
+      buf.set(left, 0);
+      buf.set(right, 32);
+      next.push(sha256d(buf));
+    }
+    layer = next;
+  }
+  return hx(layer[0]);
+}
+function verifyMerkleProof(txidHex, pos, branchHex, merkleRootHex) {
+  let cur = hb(txidHex);
+  let idx = pos;
+  for (const sibHex of branchHex) {
+    const sib = hb(sibHex);
+    const buf = new Uint8Array(64);
+    if (idx & 1) {
+      buf.set(sib, 0);
+      buf.set(cur, 32);
+    } else {
+      buf.set(cur, 0);
+      buf.set(sib, 32);
+    }
+    cur = sha256d(buf);
+    idx >>= 1;
+  }
+  return hx(cur).toLowerCase() === merkleRootHex.toLowerCase();
+}
+function merkleBranch(txidsHex, pos) {
+  let layer = txidsHex.map(hb);
+  const branch = [];
+  let idx = pos;
+  while (layer.length > 1) {
+    const sibIdx = idx ^ 1;
+    const sib = sibIdx < layer.length ? layer[sibIdx] : layer[idx];
+    branch.push(hx(sib));
+    const next = [];
+    for (let i = 0; i < layer.length; i += 2) {
+      const left = layer[i];
+      const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+      const buf = new Uint8Array(64);
+      buf.set(left, 0);
+      buf.set(right, 32);
+      next.push(sha256d(buf));
+    }
+    layer = next;
+    idx >>= 1;
+  }
+  return branch;
+}
+
+// src/content.ts
+var import_sha2563 = require("@noble/hashes/sha256");
+var import_utils4 = require("@noble/hashes/utils");
+function canonicalJson(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(canonicalJson).join(",") + "]";
+  const o = v;
+  return "{" + Object.keys(o).sort().map((k) => JSON.stringify(k) + ":" + canonicalJson(o[k])).join(",") + "}";
+}
+function payloadHash(content) {
+  return "0x" + (0, import_utils4.bytesToHex)((0, import_sha2563.sha256)((0, import_utils4.utf8ToBytes)(canonicalJson(content))));
+}
+function verifyContentBytes(bytes, payloadHashHex) {
+  return "0x" + (0, import_utils4.bytesToHex)((0, import_sha2563.sha256)(bytes)) === payloadHashHex.toLowerCase();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHAIN_ID,
+  CHAIN_ID_HASH,
+  COIN,
+  EPOCH_LEN,
+  GENESIS_HASH,
+  GENESIS_TIME,
+  HALVING_INTERVAL,
+  INITIAL_BITS,
+  INITIAL_REWARD,
+  LWMA_SOLVETIME_MAX_FACTOR,
+  LWMA_WINDOW,
+  MAX_FUTURE_DRIFT_SECS,
+  MAX_HALVINGS,
+  MAX_TX_INPUTS,
+  MAX_TX_OUTPUTS,
+  MIN_BLOCK_SPACING_SECS,
+  MIN_FEE_ATTEST,
+  MIN_FEE_PROPOSE,
+  MTP_WINDOW,
+  POW_LIMIT_BITS,
+  TARGET_BLOCK_SECS,
+  bigIntToTarget,
+  bitsToTarget,
+  blockReward,
+  bytesToHex,
+  canonicalJson,
+  concatBytes,
+  deserialize,
+  hb,
+  hbFixed,
+  headerHash,
+  headerHashBytes,
+  hexToBytes,
+  hx,
+  lenBytes,
+  merkleBranch,
+  merkleRoot,
+  payloadHash,
+  powOk,
+  serialize,
+  serializeHeader,
+  sha256d,
+  sighash,
+  strip0x,
+  strippedTx,
+  taggedHash,
+  targetToBigInt,
+  targetToBits,
+  txid,
+  u32,
+  u64,
+  utf8ToBytes,
+  verifyContentBytes,
+  verifyMerkleProof,
+  workForBits
+});

package/dist/index.d.cts

@@ -0,0 +1,133 @@
+export { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+
+declare const strip0x: (h: string) => string;
+declare const hb: (h: string) => Uint8Array;
+declare const hx: (b: Uint8Array) => string;
+declare const sha256d: (b: Uint8Array) => Uint8Array;
+declare function u32(n: number): Uint8Array;
+declare function u64(n: number | bigint): Uint8Array;
+declare const lenBytes: (b: Uint8Array) => Uint8Array;
+declare function hbFixed(h: string, n: number): Uint8Array;
+
+/** CHAIN_ID = "compute-substrate-mainnet". */
+declare const CHAIN_ID = "compute-substrate-mainnet";
+/** sha256(CHAIN_ID) — domain-separation tail in the sighash preimage. */
+declare const CHAIN_ID_HASH: Uint8Array;
+/** Genesis block header hash (the chain's anchor; pin this in the light client). */
+declare const GENESIS_HASH = "0x00000052c2821f71b19c3d79dfabfb12d4076ba15d83b47d008e582aad6c0d52";
+declare const GENESIS_TIME = 1777474800;
+/** PoW / difficulty. */
+declare const TARGET_BLOCK_SECS = 120;
+declare const INITIAL_BITS = 503382015;
+declare const POW_LIMIT_BITS = 503382015;
+declare const LWMA_WINDOW = 45;
+declare const LWMA_SOLVETIME_MAX_FACTOR = 12;
+declare const MAX_FUTURE_DRIFT_SECS: number;
+declare const MTP_WINDOW = 11;
+declare const MIN_BLOCK_SPACING_SECS = 60;
+/** App layer. */
+declare const EPOCH_LEN = 30;
+/** Supply / fees (base units; 1 CSD = COIN). */
+declare const COIN = 100000000;
+declare const INITIAL_REWARD: number;
+declare const HALVING_INTERVAL = 1051200;
+declare const MAX_HALVINGS = 64;
+declare const MIN_FEE_PROPOSE = 25000000;
+declare const MIN_FEE_ATTEST = 5000000;
+/** Consensus tx limits. */
+declare const MAX_TX_INPUTS = 512;
+declare const MAX_TX_OUTPUTS = 512;
+/** block_reward(height) — INITIAL_REWARD halved every HALVING_INTERVAL, 0 after MAX_HALVINGS. */
+declare function blockReward(height: number): number;
+
+type App = {
+    type: "None";
+} | {
+    type: "Propose";
+    domain: string;
+    payloadHash: string;
+    uri: string;
+    expiresEpoch: number | bigint;
+} | {
+    type: "Attest";
+    proposalId: string;
+    score: number;
+    confidence: number;
+};
+interface TxInput {
+    prevTxid: string;
+    vout: number;
+    scriptSig: string;
+}
+interface TxOutput {
+    value: number | bigint;
+    scriptPubkey: string;
+}
+interface Tx {
+    version: number;
+    inputs: TxInput[];
+    outputs: TxOutput[];
+    locktime: number;
+    app: App;
+}
+/** Strip script_sig from every non-coinbase input (the txid/sighash preimage). */
+declare function strippedTx(tx: Tx): Tx;
+/** Consensus bincode serialization of a transaction (as-is — does NOT strip). */
+declare function serialize(tx: Tx): Uint8Array;
+/** txid = sha256d(bincode(stripped_tx)). */
+declare function txid(tx: Tx): string;
+/** tagged_hash(tag, msg) = sha256( sha256(tag) ‖ sha256(tag) ‖ msg ) — the frozen CSD construction. */
+declare function taggedHash(tag: string, msg: Uint8Array): Uint8Array;
+/** sighash = sha256d( tagged_hash("CSD_SIG_V1", bincode(stripped_tx) ‖ CHAIN_ID_HASH) ). */
+declare function sighash(tx: Tx): string;
+/** Parse consensus bincode bytes back into a Tx (mirror of `serialize`). */
+declare function deserialize(bytes: Uint8Array): Tx;
+
+interface BlockHeader {
+    version: number;
+    prev: string;
+    merkle: string;
+    time: number | bigint;
+    bits: number;
+    nonce: number;
+}
+/** Exact 84-byte LE header serialization. */
+declare function serializeHeader(h: BlockHeader): Uint8Array;
+/** Header hash = sha256d(serialize_header). Returned 0x-hex (big-endian byte order as hashed). */
+declare function headerHash(h: BlockHeader): string;
+declare function headerHashBytes(h: BlockHeader): Uint8Array;
+/**
+ * Decode Bitcoin-style compact `bits` to a 256-bit target as a 32-byte big-endian array.
+ * Mirrors pow.rs bits_to_target_bytes: returns all-zero (an impossible/invalid target) for
+ * the rejection cases (exp 0, mant 0, sign bit set, exp>32, overflow).
+ */
+declare function bitsToTarget(bits: number): Uint8Array;
+declare function targetToBigInt(target: Uint8Array): bigint;
+/** A 256-bit target value → 32-byte big-endian array (right-aligned; matches biguint_to_target_bytes). */
+declare function bigIntToTarget(x: bigint): Uint8Array;
+/**
+ * Encode a 32-byte BE target back to canonical compact `bits` (port of pow.rs
+ * target_bytes_to_bits). Needed by the LWMA re-derivation in @inversealtruism/csd-light.
+ */
+declare function targetToBits(target: Uint8Array): number;
+/** PoW validity: header hash ≤ target(bits), both compared as 32-byte big-endian. */
+declare function powOk(headerHashBE: Uint8Array, bits: number): boolean;
+/** Chainwork contributed by a header at difficulty `bits`: 2^256 / (target + 1). */
+declare function workForBits(bits: number): bigint;
+/** Compute the tx-merkle root from the ordered list of txids (0x-hex). */
+declare function merkleRoot(txidsHex: string[]): string;
+/**
+ * Verify a merkle inclusion proof (Electrum format): fold `txid` up the branch and assert it
+ * equals `merkleRootHex`. `pos` is the tx index in the block; its bits select sibling side.
+ */
+declare function verifyMerkleProof(txidHex: string, pos: number, branchHex: string[], merkleRootHex: string): boolean;
+/** Build the merkle branch for tx at index `pos` from the full ordered txid list. */
+declare function merkleBranch(txidsHex: string[], pos: number): string[];
+
+declare function canonicalJson(v: unknown): string;
+/** payload_hash for a content record (0x-hex sha256 of its canonical JSON). */
+declare function payloadHash(content: unknown): string;
+/** Verify served bytes match an on-chain payload_hash (self-certification). */
+declare function verifyContentBytes(bytes: Uint8Array, payloadHashHex: string): boolean;
+
+export { type App, type BlockHeader, CHAIN_ID, CHAIN_ID_HASH, COIN, EPOCH_LEN, GENESIS_HASH, GENESIS_TIME, HALVING_INTERVAL, INITIAL_BITS, INITIAL_REWARD, LWMA_SOLVETIME_MAX_FACTOR, LWMA_WINDOW, MAX_FUTURE_DRIFT_SECS, MAX_HALVINGS, MAX_TX_INPUTS, MAX_TX_OUTPUTS, MIN_BLOCK_SPACING_SECS, MIN_FEE_ATTEST, MIN_FEE_PROPOSE, MTP_WINDOW, POW_LIMIT_BITS, TARGET_BLOCK_SECS, type Tx, type TxInput, type TxOutput, bigIntToTarget, bitsToTarget, blockReward, canonicalJson, deserialize, hb, hbFixed, headerHash, headerHashBytes, hx, lenBytes, merkleBranch, merkleRoot, payloadHash, powOk, serialize, serializeHeader, sha256d, sighash, strip0x, strippedTx, taggedHash, targetToBigInt, targetToBits, txid, u32, u64, verifyContentBytes, verifyMerkleProof, workForBits };

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+export { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+
+declare const strip0x: (h: string) => string;
+declare const hb: (h: string) => Uint8Array;
+declare const hx: (b: Uint8Array) => string;
+declare const sha256d: (b: Uint8Array) => Uint8Array;
+declare function u32(n: number): Uint8Array;
+declare function u64(n: number | bigint): Uint8Array;
+declare const lenBytes: (b: Uint8Array) => Uint8Array;
+declare function hbFixed(h: string, n: number): Uint8Array;
+
+/** CHAIN_ID = "compute-substrate-mainnet". */
+declare const CHAIN_ID = "compute-substrate-mainnet";
+/** sha256(CHAIN_ID) — domain-separation tail in the sighash preimage. */
+declare const CHAIN_ID_HASH: Uint8Array;
+/** Genesis block header hash (the chain's anchor; pin this in the light client). */
+declare const GENESIS_HASH = "0x00000052c2821f71b19c3d79dfabfb12d4076ba15d83b47d008e582aad6c0d52";
+declare const GENESIS_TIME = 1777474800;
+/** PoW / difficulty. */
+declare const TARGET_BLOCK_SECS = 120;
+declare const INITIAL_BITS = 503382015;
+declare const POW_LIMIT_BITS = 503382015;
+declare const LWMA_WINDOW = 45;
+declare const LWMA_SOLVETIME_MAX_FACTOR = 12;
+declare const MAX_FUTURE_DRIFT_SECS: number;
+declare const MTP_WINDOW = 11;
+declare const MIN_BLOCK_SPACING_SECS = 60;
+/** App layer. */
+declare const EPOCH_LEN = 30;
+/** Supply / fees (base units; 1 CSD = COIN). */
+declare const COIN = 100000000;
+declare const INITIAL_REWARD: number;
+declare const HALVING_INTERVAL = 1051200;
+declare const MAX_HALVINGS = 64;
+declare const MIN_FEE_PROPOSE = 25000000;
+declare const MIN_FEE_ATTEST = 5000000;
+/** Consensus tx limits. */
+declare const MAX_TX_INPUTS = 512;
+declare const MAX_TX_OUTPUTS = 512;
+/** block_reward(height) — INITIAL_REWARD halved every HALVING_INTERVAL, 0 after MAX_HALVINGS. */
+declare function blockReward(height: number): number;
+
+type App = {
+    type: "None";
+} | {
+    type: "Propose";
+    domain: string;
+    payloadHash: string;
+    uri: string;
+    expiresEpoch: number | bigint;
+} | {
+    type: "Attest";
+    proposalId: string;
+    score: number;
+    confidence: number;
+};
+interface TxInput {
+    prevTxid: string;
+    vout: number;
+    scriptSig: string;
+}
+interface TxOutput {
+    value: number | bigint;
+    scriptPubkey: string;
+}
+interface Tx {
+    version: number;
+    inputs: TxInput[];
+    outputs: TxOutput[];
+    locktime: number;
+    app: App;
+}
+/** Strip script_sig from every non-coinbase input (the txid/sighash preimage). */
+declare function strippedTx(tx: Tx): Tx;
+/** Consensus bincode serialization of a transaction (as-is — does NOT strip). */
+declare function serialize(tx: Tx): Uint8Array;
+/** txid = sha256d(bincode(stripped_tx)). */
+declare function txid(tx: Tx): string;
+/** tagged_hash(tag, msg) = sha256( sha256(tag) ‖ sha256(tag) ‖ msg ) — the frozen CSD construction. */
+declare function taggedHash(tag: string, msg: Uint8Array): Uint8Array;
+/** sighash = sha256d( tagged_hash("CSD_SIG_V1", bincode(stripped_tx) ‖ CHAIN_ID_HASH) ). */
+declare function sighash(tx: Tx): string;
+/** Parse consensus bincode bytes back into a Tx (mirror of `serialize`). */
+declare function deserialize(bytes: Uint8Array): Tx;
+
+interface BlockHeader {
+    version: number;
+    prev: string;
+    merkle: string;
+    time: number | bigint;
+    bits: number;
+    nonce: number;
+}
+/** Exact 84-byte LE header serialization. */
+declare function serializeHeader(h: BlockHeader): Uint8Array;
+/** Header hash = sha256d(serialize_header). Returned 0x-hex (big-endian byte order as hashed). */
+declare function headerHash(h: BlockHeader): string;
+declare function headerHashBytes(h: BlockHeader): Uint8Array;
+/**
+ * Decode Bitcoin-style compact `bits` to a 256-bit target as a 32-byte big-endian array.
+ * Mirrors pow.rs bits_to_target_bytes: returns all-zero (an impossible/invalid target) for
+ * the rejection cases (exp 0, mant 0, sign bit set, exp>32, overflow).
+ */
+declare function bitsToTarget(bits: number): Uint8Array;
+declare function targetToBigInt(target: Uint8Array): bigint;
+/** A 256-bit target value → 32-byte big-endian array (right-aligned; matches biguint_to_target_bytes). */
+declare function bigIntToTarget(x: bigint): Uint8Array;
+/**
+ * Encode a 32-byte BE target back to canonical compact `bits` (port of pow.rs
+ * target_bytes_to_bits). Needed by the LWMA re-derivation in @inversealtruism/csd-light.
+ */
+declare function targetToBits(target: Uint8Array): number;
+/** PoW validity: header hash ≤ target(bits), both compared as 32-byte big-endian. */
+declare function powOk(headerHashBE: Uint8Array, bits: number): boolean;
+/** Chainwork contributed by a header at difficulty `bits`: 2^256 / (target + 1). */
+declare function workForBits(bits: number): bigint;
+/** Compute the tx-merkle root from the ordered list of txids (0x-hex). */
+declare function merkleRoot(txidsHex: string[]): string;
+/**
+ * Verify a merkle inclusion proof (Electrum format): fold `txid` up the branch and assert it
+ * equals `merkleRootHex`. `pos` is the tx index in the block; its bits select sibling side.
+ */
+declare function verifyMerkleProof(txidHex: string, pos: number, branchHex: string[], merkleRootHex: string): boolean;
+/** Build the merkle branch for tx at index `pos` from the full ordered txid list. */
+declare function merkleBranch(txidsHex: string[], pos: number): string[];
+
+declare function canonicalJson(v: unknown): string;
+/** payload_hash for a content record (0x-hex sha256 of its canonical JSON). */
+declare function payloadHash(content: unknown): string;
+/** Verify served bytes match an on-chain payload_hash (self-certification). */
+declare function verifyContentBytes(bytes: Uint8Array, payloadHashHex: string): boolean;
+
+export { type App, type BlockHeader, CHAIN_ID, CHAIN_ID_HASH, COIN, EPOCH_LEN, GENESIS_HASH, GENESIS_TIME, HALVING_INTERVAL, INITIAL_BITS, INITIAL_REWARD, LWMA_SOLVETIME_MAX_FACTOR, LWMA_WINDOW, MAX_FUTURE_DRIFT_SECS, MAX_HALVINGS, MAX_TX_INPUTS, MAX_TX_OUTPUTS, MIN_BLOCK_SPACING_SECS, MIN_FEE_ATTEST, MIN_FEE_PROPOSE, MTP_WINDOW, POW_LIMIT_BITS, TARGET_BLOCK_SECS, type Tx, type TxInput, type TxOutput, bigIntToTarget, bitsToTarget, blockReward, canonicalJson, deserialize, hb, hbFixed, headerHash, headerHashBytes, hx, lenBytes, merkleBranch, merkleRoot, payloadHash, powOk, serialize, serializeHeader, sha256d, sighash, strip0x, strippedTx, taggedHash, targetToBigInt, targetToBits, txid, u32, u64, verifyContentBytes, verifyMerkleProof, workForBits };

package/dist/index.js

@@ -0,0 +1,363 @@
+// src/bytes.ts
+import { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha256";
+var strip0x = (h) => h.startsWith("0x") ? h.slice(2) : h;
+var hb = (h) => hexToBytes(strip0x(h));
+var hx = (b) => "0x" + bytesToHex(b);
+var sha256d = (b) => sha256(sha256(b));
+function u32(n) {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, n >>> 0, true);
+  return b;
+}
+function u64(n) {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), true);
+  return b;
+}
+var lenBytes = (b) => concatBytes(u64(b.length), b);
+function hbFixed(h, n) {
+  const b = hb(h);
+  if (b.length !== n) throw new Error(`expected a ${n}-byte (0x\u2026${n * 2}-hex) field, got ${b.length} bytes`);
+  return b;
+}
+
+// src/params.ts
+import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
+var CHAIN_ID = "compute-substrate-mainnet";
+var CHAIN_ID_HASH = hexToBytes2("1b17c7b04d05394674ca2c8e24f7433e251a1973cac2000c7b60966546e0b875");
+var GENESIS_HASH = "0x00000052c2821f71b19c3d79dfabfb12d4076ba15d83b47d008e582aad6c0d52";
+var GENESIS_TIME = 1777474800;
+var TARGET_BLOCK_SECS = 120;
+var INITIAL_BITS = 503382015;
+var POW_LIMIT_BITS = 503382015;
+var LWMA_WINDOW = 45;
+var LWMA_SOLVETIME_MAX_FACTOR = 12;
+var MAX_FUTURE_DRIFT_SECS = 2 * 60 * 60;
+var MTP_WINDOW = 11;
+var MIN_BLOCK_SPACING_SECS = 60;
+var EPOCH_LEN = 30;
+var COIN = 1e8;
+var INITIAL_REWARD = 50 * COIN;
+var HALVING_INTERVAL = 1051200;
+var MAX_HALVINGS = 64;
+var MIN_FEE_PROPOSE = 25e6;
+var MIN_FEE_ATTEST = 5e6;
+var MAX_TX_INPUTS = 512;
+var MAX_TX_OUTPUTS = 512;
+function blockReward(height) {
+  const halvings = Math.floor(height / HALVING_INTERVAL);
+  if (halvings >= MAX_HALVINGS) return 0;
+  return Math.floor(INITIAL_REWARD / 2 ** halvings);
+}
+
+// src/tx.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { concatBytes as concatBytes2, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
+var COINBASE_TXID = "0x" + "00".repeat(32);
+var COINBASE_VOUT = 4294967295;
+var isCoinbaseInput = (i) => i.prevTxid === COINBASE_TXID && i.vout === COINBASE_VOUT;
+function strippedTx(tx) {
+  return { ...tx, inputs: tx.inputs.map((i) => isCoinbaseInput(i) ? i : { ...i, scriptSig: "0x" }) };
+}
+function serializeApp(app) {
+  if (app.type === "None") return u32(0);
+  if (app.type === "Propose")
+    return concatBytes2(u32(1), lenBytes(utf8ToBytes2(app.domain)), hbFixed(app.payloadHash, 32), lenBytes(utf8ToBytes2(app.uri)), u64(app.expiresEpoch));
+  return concatBytes2(u32(2), hbFixed(app.proposalId, 32), u32(app.score), u32(app.confidence));
+}
+function serialize(tx) {
+  const parts = [u32(tx.version), u64(tx.inputs.length)];
+  for (const i of tx.inputs) parts.push(hbFixed(i.prevTxid, 32), u32(i.vout), lenBytes(hb(i.scriptSig)));
+  parts.push(u64(tx.outputs.length));
+  for (const o of tx.outputs) parts.push(u64(o.value), hbFixed(o.scriptPubkey, 20));
+  parts.push(u32(tx.locktime), serializeApp(tx.app));
+  return concatBytes2(...parts);
+}
+function txid(tx) {
+  return hx(sha256d(serialize(strippedTx(tx))));
+}
+function taggedHash(tag, msg) {
+  const t = sha2562(utf8ToBytes2(tag));
+  return sha2562(concatBytes2(t, t, msg));
+}
+function sighash(tx) {
+  return hx(sha256d(taggedHash("CSD_SIG_V1", concatBytes2(serialize(strippedTx(tx)), CHAIN_ID_HASH))));
+}
+var Reader = class {
+  constructor(b, dv = new DataView(b.buffer, b.byteOffset, b.byteLength)) {
+    this.b = b;
+    this.dv = dv;
+  }
+  b;
+  dv;
+  o = 0;
+  u32() {
+    const v = this.dv.getUint32(this.o, true);
+    this.o += 4;
+    return v;
+  }
+  u64() {
+    const v = this.dv.getBigUint64(this.o, true);
+    this.o += 8;
+    return v;
+  }
+  take(n) {
+    const v = this.b.subarray(this.o, this.o + n);
+    if (v.length !== n) throw new Error("unexpected end of bytes");
+    this.o += n;
+    return v;
+  }
+  vec() {
+    return this.take(Number(this.u64()));
+  }
+  fixedHex(n) {
+    return hx(this.take(n));
+  }
+  str() {
+    return new TextDecoder().decode(this.vec());
+  }
+  get offset() {
+    return this.o;
+  }
+  get length() {
+    return this.b.length;
+  }
+};
+function readApp(r) {
+  const tag = r.u32();
+  if (tag === 0) return { type: "None" };
+  if (tag === 1) return { type: "Propose", domain: r.str(), payloadHash: r.fixedHex(32), uri: r.str(), expiresEpoch: r.u64() };
+  if (tag === 2) return { type: "Attest", proposalId: r.fixedHex(32), score: r.u32(), confidence: r.u32() };
+  throw new Error(`unknown AppPayload variant ${tag}`);
+}
+function deserialize(bytes) {
+  const r = new Reader(bytes);
+  const version = r.u32();
+  const nIn = Number(r.u64());
+  const inputs = [];
+  for (let i = 0; i < nIn; i++) inputs.push({ prevTxid: r.fixedHex(32), vout: r.u32(), scriptSig: hx(r.vec()) });
+  const nOut = Number(r.u64());
+  const outputs = [];
+  for (let i = 0; i < nOut; i++) outputs.push({ value: r.u64(), scriptPubkey: r.fixedHex(20) });
+  const locktime = r.u32();
+  const app = readApp(r);
+  return { version, inputs, outputs, locktime, app };
+}
+
+// src/header.ts
+function serializeHeader(h) {
+  const buf = new Uint8Array(84);
+  buf.set(u32(h.version), 0);
+  buf.set(hbFixed(h.prev, 32), 4);
+  buf.set(hbFixed(h.merkle, 32), 36);
+  buf.set(u64(h.time), 68);
+  buf.set(u32(h.bits), 76);
+  buf.set(u32(h.nonce), 80);
+  return buf;
+}
+function headerHash(h) {
+  return hx(sha256d(serializeHeader(h)));
+}
+function headerHashBytes(h) {
+  return sha256d(serializeHeader(h));
+}
+function bitsToTarget(bits) {
+  const exp = bits >>> 24 & 255;
+  const mant = bits & 16777215;
+  const out = new Uint8Array(32);
+  if (exp === 0 || mant === 0) return out;
+  if ((mant & 8388608) !== 0) return out;
+  if (exp > 32) return out;
+  let target;
+  if (exp <= 3) target = BigInt(mant) >> BigInt(8 * (3 - exp));
+  else target = BigInt(mant) << BigInt(8 * (exp - 3));
+  if (target === 0n) return out;
+  if (target >= 1n << 256n) return out;
+  for (let i = 31; i >= 0 && target > 0n; i--) {
+    out[i] = Number(target & 0xffn);
+    target >>= 8n;
+  }
+  return out;
+}
+function targetToBigInt(target) {
+  let v = 0n;
+  for (const byte of target) v = v << 8n | BigInt(byte);
+  return v;
+}
+function bigIntToTarget(x) {
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0 && x > 0n; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+function minBE(x) {
+  if (x === 0n) return [];
+  const b = [];
+  while (x > 0n) {
+    b.unshift(Number(x & 0xffn));
+    x >>= 8n;
+  }
+  return b;
+}
+function targetToBits(target) {
+  const x = targetToBigInt(target);
+  if (x === 0n) return 0;
+  const bytes = minBE(x);
+  let exp = bytes.length;
+  let mant;
+  if (exp <= 3) {
+    const shift = BigInt(8 * (3 - exp));
+    mant = Number(x << shift & 0xffffffffn) & 16777215;
+  } else {
+    mant = (bytes[0] << 16 | bytes[1] << 8 | bytes[2]) >>> 0;
+  }
+  if ((mant & 8388608) !== 0) {
+    mant >>= 8;
+    exp += 1;
+  }
+  mant &= 16777215;
+  return (exp << 24 | mant) >>> 0;
+}
+function powOk(headerHashBE, bits) {
+  const target = bitsToTarget(bits);
+  if (target.every((b) => b === 0)) return false;
+  return targetToBigInt(headerHashBE) <= targetToBigInt(target);
+}
+function workForBits(bits) {
+  const target = targetToBigInt(bitsToTarget(bits));
+  if (target === 0n) return 0n;
+  return (1n << 256n) / (target + 1n);
+}
+function merkleRoot(txidsHex) {
+  if (txidsHex.length === 0) return "0x" + "00".repeat(32);
+  let layer = txidsHex.map(hb);
+  while (layer.length > 1) {
+    const next = [];
+    for (let i = 0; i < layer.length; i += 2) {
+      const left = layer[i];
+      const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+      const buf = new Uint8Array(64);
+      buf.set(left, 0);
+      buf.set(right, 32);
+      next.push(sha256d(buf));
+    }
+    layer = next;
+  }
+  return hx(layer[0]);
+}
+function verifyMerkleProof(txidHex, pos, branchHex, merkleRootHex) {
+  let cur = hb(txidHex);
+  let idx = pos;
+  for (const sibHex of branchHex) {
+    const sib = hb(sibHex);
+    const buf = new Uint8Array(64);
+    if (idx & 1) {
+      buf.set(sib, 0);
+      buf.set(cur, 32);
+    } else {
+      buf.set(cur, 0);
+      buf.set(sib, 32);
+    }
+    cur = sha256d(buf);
+    idx >>= 1;
+  }
+  return hx(cur).toLowerCase() === merkleRootHex.toLowerCase();
+}
+function merkleBranch(txidsHex, pos) {
+  let layer = txidsHex.map(hb);
+  const branch = [];
+  let idx = pos;
+  while (layer.length > 1) {
+    const sibIdx = idx ^ 1;
+    const sib = sibIdx < layer.length ? layer[sibIdx] : layer[idx];
+    branch.push(hx(sib));
+    const next = [];
+    for (let i = 0; i < layer.length; i += 2) {
+      const left = layer[i];
+      const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+      const buf = new Uint8Array(64);
+      buf.set(left, 0);
+      buf.set(right, 32);
+      next.push(sha256d(buf));
+    }
+    layer = next;
+    idx >>= 1;
+  }
+  return branch;
+}
+
+// src/content.ts
+import { sha256 as sha2563 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex2, utf8ToBytes as utf8ToBytes3 } from "@noble/hashes/utils";
+function canonicalJson(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(canonicalJson).join(",") + "]";
+  const o = v;
+  return "{" + Object.keys(o).sort().map((k) => JSON.stringify(k) + ":" + canonicalJson(o[k])).join(",") + "}";
+}
+function payloadHash(content) {
+  return "0x" + bytesToHex2(sha2563(utf8ToBytes3(canonicalJson(content))));
+}
+function verifyContentBytes(bytes, payloadHashHex) {
+  return "0x" + bytesToHex2(sha2563(bytes)) === payloadHashHex.toLowerCase();
+}
+export {
+  CHAIN_ID,
+  CHAIN_ID_HASH,
+  COIN,
+  EPOCH_LEN,
+  GENESIS_HASH,
+  GENESIS_TIME,
+  HALVING_INTERVAL,
+  INITIAL_BITS,
+  INITIAL_REWARD,
+  LWMA_SOLVETIME_MAX_FACTOR,
+  LWMA_WINDOW,
+  MAX_FUTURE_DRIFT_SECS,
+  MAX_HALVINGS,
+  MAX_TX_INPUTS,
+  MAX_TX_OUTPUTS,
+  MIN_BLOCK_SPACING_SECS,
+  MIN_FEE_ATTEST,
+  MIN_FEE_PROPOSE,
+  MTP_WINDOW,
+  POW_LIMIT_BITS,
+  TARGET_BLOCK_SECS,
+  bigIntToTarget,
+  bitsToTarget,
+  blockReward,
+  bytesToHex,
+  canonicalJson,
+  concatBytes,
+  deserialize,
+  hb,
+  hbFixed,
+  headerHash,
+  headerHashBytes,
+  hexToBytes,
+  hx,
+  lenBytes,
+  merkleBranch,
+  merkleRoot,
+  payloadHash,
+  powOk,
+  serialize,
+  serializeHeader,
+  sha256d,
+  sighash,
+  strip0x,
+  strippedTx,
+  taggedHash,
+  targetToBigInt,
+  targetToBits,
+  txid,
+  u32,
+  u64,
+  utf8ToBytes,
+  verifyContentBytes,
+  verifyMerkleProof,
+  workForBits
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@inversealtruism/csd-codec",
+  "version": "0.1.0",
+  "description": "Compute Substrate consensus codec — bincode (fixint-LE) serialize/deserialize, txid, sighash (CSD_SIG_V1), header serialize/hash, compact-bits→target, merkle. Byte-identical to the Rust node (golden-vector-gated).",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@noble/hashes": "1.8.0"
+  },
+  "devDependencies": {
+    "@inversealtruism/csd-vectors": "0.1.0"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InverseAltruism/csd-sdk.git",
+    "directory": "packages/codec"
+  },
+  "homepage": "https://cairn-substrate.com",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "tsx test/codec.test.ts"
+  }
+}