dcr-ts 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2424 @@
+'use strict';
+
+var ripemd160 = require('@noble/hashes/ripemd160');
+var secp256k1 = require('@noble/curves/secp256k1');
+var ed25519 = require('@noble/curves/ed25519');
+var hmac = require('@noble/hashes/hmac');
+var sha512 = require('@noble/hashes/sha512');
+var bip39 = require('@scure/bip39');
+var english = require('@scure/bip39/wordlists/english');
+
+// src/errors.ts
+var BRAND = /* @__PURE__ */ Symbol.for("dcr-ts.DcrError");
+var DcrError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    Object.defineProperty(this, BRAND, { value: true });
+  }
+  code;
+  name = "DcrError";
+};
+function isDcrError(e) {
+  return e instanceof DcrError || typeof e === "object" && e !== null && BRAND in e;
+}
+function hasErrorCode(e, code) {
+  return isDcrError(e) && e.code === code;
+}
+function err(code, who, message) {
+  return new DcrError(code, `${who}: ${message}`);
+}
+
+// src/bytes.ts
+function copyOf(src, off, n) {
+  if (!Number.isInteger(off) || !Number.isInteger(n) || off < 0 || n < 0) {
+    throw err(
+      "not-an-integer",
+      "copyOf",
+      `offset and length must be non-negative integers, got ${shown(off)}, ${shown(n)}`
+    );
+  }
+  if (off + n > src.length) {
+    throw err(
+      "out-of-range",
+      "copyOf",
+      `reading ${n} bytes at ${off} overruns a ${src.length}-byte source`
+    );
+  }
+  const out = new Uint8Array(n);
+  out.set(src.subarray(off, off + n));
+  return out;
+}
+function isBytes(v) {
+  return Object.prototype.toString.call(v) === "[object Uint8Array]";
+}
+function typeName(v) {
+  return Object.prototype.toString.call(v).slice(8, -1).toLowerCase();
+}
+var MAX_SHOWN_LENGTH = 32;
+function shown(v) {
+  if (typeof v === "string") {
+    const head = v.length > MAX_SHOWN_LENGTH ? v.slice(0, MAX_SHOWN_LENGTH) : v;
+    let out = "";
+    for (const ch of head) {
+      const c = ch.codePointAt(0);
+      out += c < 32 || c === 127 ? `\\u${c.toString(16).padStart(4, "0")}` : ch;
+    }
+    const clipped = v.length > MAX_SHOWN_LENGTH ? `\u2026 (${v.length} characters)` : "";
+    return `"${out}"${clipped}`;
+  }
+  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean" || v === null || v === void 0) {
+    return String(v);
+  }
+  return typeName(v);
+}
+function checkUint(v, bits, who) {
+  if (!Number.isInteger(v) || v < 0 || v > (bits === 32 ? 4294967295 : (1 << bits) - 1)) {
+    throw err(
+      Number.isInteger(v) ? "out-of-range" : "not-an-integer",
+      `Writer.${who}`,
+      `expected an integer in 0..2^${bits}-1, got ${shown(v)}`
+    );
+  }
+}
+var Writer = class {
+  buf = new Uint8Array(256);
+  view = new DataView(this.buf.buffer);
+  len = 0;
+  ensure(extra) {
+    if (this.len + extra <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.len + extra) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+    this.view = new DataView(next.buffer);
+  }
+  u8(v) {
+    checkUint(v, 8, "u8");
+    this.ensure(1);
+    this.buf[this.len++] = v;
+    return this;
+  }
+  u16(v) {
+    checkUint(v, 16, "u16");
+    this.ensure(2);
+    this.view.setUint16(this.len, v, true);
+    this.len += 2;
+    return this;
+  }
+  u32(v) {
+    checkUint(v, 32, "u32");
+    this.ensure(4);
+    this.view.setUint32(this.len, v, true);
+    this.len += 4;
+    return this;
+  }
+  // The 64-bit paths go through DataView rather than eight BigInt shift/mask
+  // steps. Every input amount and output value in a transaction crosses one of
+  // these, and the loop version measured ~33x slower on the primitive.
+  u64(v) {
+    if (v < 0n || v > 0xffffffffffffffffn) throw err("out-of-range", "Writer.u64", "value must fit in an unsigned 64-bit integer");
+    this.ensure(8);
+    this.view.setBigUint64(this.len, v, true);
+    this.len += 8;
+    return this;
+  }
+  /** Signed 64-bit little-endian (two's complement). Used for atom amounts. */
+  i64(v) {
+    if (v < -(1n << 63n) || v >= 1n << 63n) throw err("out-of-range", "Writer.i64", "value must fit in a signed 64-bit integer");
+    this.ensure(8);
+    this.view.setBigInt64(this.len, v, true);
+    this.len += 8;
+    return this;
+  }
+  bytes(b) {
+    this.ensure(b.length);
+    this.buf.set(b, this.len);
+    this.len += b.length;
+    return this;
+  }
+  /** Compact-size varint. */
+  varInt(v) {
+    if (typeof v === "number") {
+      if (!Number.isInteger(v)) {
+        throw err("not-an-integer", "Writer.varInt", `expected an integer, got ${v}`);
+      }
+      if (v < 0) throw err("out-of-range", "Writer.varInt", "value must not be negative");
+      if (v < 253) return this.u8(v);
+      if (v <= 65535) return this.u8(253).u16(v);
+      if (v <= 4294967295) return this.u8(254).u32(v);
+      return this.u8(255).u64(BigInt(v));
+    }
+    if (typeof v !== "bigint") {
+      throw err("not-an-integer", "Writer.varInt", `expected an integer, got ${typeName(v)}`);
+    }
+    const n = v;
+    if (n < 0n) throw err("out-of-range", "Writer.varInt", "value must not be negative");
+    if (n < 0xfdn) return this.u8(Number(n));
+    if (n <= 0xffffn) return this.u8(253).u16(Number(n));
+    if (n <= 0xffffffffn) return this.u8(254).u32(Number(n));
+    return this.u8(255).u64(n);
+  }
+  /** A varint length prefix followed by the bytes themselves. */
+  varBytes(b) {
+    return this.varInt(b.length).bytes(b);
+  }
+  finish() {
+    return this.buf.slice(0, this.len);
+  }
+};
+var Reader = class {
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  data;
+  off = 0;
+  view;
+  get offset() {
+    return this.off;
+  }
+  get remaining() {
+    return this.data.length - this.off;
+  }
+  need(n) {
+    if (this.off + n > this.data.length) throw err("unexpected-end", "Reader", `wanted ${n} more byte(s), ${this.data.length - this.off} remain`);
+  }
+  u8() {
+    this.need(1);
+    return this.data[this.off++];
+  }
+  u16() {
+    this.need(2);
+    const v = this.data[this.off] | this.data[this.off + 1] << 8;
+    this.off += 2;
+    return v >>> 0;
+  }
+  u32() {
+    this.need(4);
+    const v = (this.data[this.off] | this.data[this.off + 1] << 8 | this.data[this.off + 2] << 16 | this.data[this.off + 3] << 24) >>> 0;
+    this.off += 4;
+    return v;
+  }
+  u64() {
+    this.need(8);
+    const v = this.view.getBigUint64(this.off, true);
+    this.off += 8;
+    return v;
+  }
+  /** Signed 64-bit little-endian (two's complement). */
+  i64() {
+    this.need(8);
+    const v = this.view.getBigInt64(this.off, true);
+    this.off += 8;
+    return v;
+  }
+  bytes(n) {
+    if (!Number.isInteger(n) || n < 0) throw err(Number.isInteger(n) ? "out-of-range" : "not-an-integer", "Reader.bytes", `bad length ${n}`);
+    this.need(n);
+    const out = copyOf(this.data, this.off, n);
+    this.off += n;
+    return out;
+  }
+  /**
+   * Compact-size varint. Rejects non-canonical encodings (a value that could
+   * have been encoded in fewer bytes), matching dcrd's `ErrNonCanonicalVarInt`.
+   * Without this check two distinct byte strings could parse to the same
+   * transaction while hashing to different ids.
+   */
+  varInt() {
+    const first = this.u8();
+    if (first < 253) return first;
+    if (first === 253) {
+      const v = this.u16();
+      if (v < 253) throw err("non-canonical-varint", "Reader.varInt", "value could have been encoded in fewer bytes");
+      return v;
+    }
+    if (first === 254) {
+      const v = this.u32();
+      if (v < 65536) throw err("non-canonical-varint", "Reader.varInt", "value could have been encoded in fewer bytes");
+      return v;
+    }
+    const big = this.u64();
+    if (big < 0x100000000n) throw err("non-canonical-varint", "Reader.varInt", "value could have been encoded in fewer bytes");
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) throw err("out-of-range", "Reader.varInt", "value exceeds Number.MAX_SAFE_INTEGER");
+    return Number(big);
+  }
+  varBytes() {
+    return this.bytes(this.varInt());
+  }
+};
+
+// src/blake256.ts
+var IV = Uint32Array.of(
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+);
+var C = Uint32Array.of(
+  608135816,
+  2242054355,
+  320440878,
+  57701188,
+  2752067618,
+  698298832,
+  137296536,
+  3964562569,
+  1160258022,
+  953160567,
+  3193202383,
+  887688300,
+  3232508343,
+  3380367581,
+  1065670069,
+  3041331479
+);
+var SIGMA = Uint8Array.of(
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9,
+  12,
+  5,
+  1,
+  15,
+  14,
+  13,
+  4,
+  10,
+  0,
+  7,
+  6,
+  3,
+  9,
+  2,
+  8,
+  11,
+  13,
+  11,
+  7,
+  14,
+  12,
+  1,
+  3,
+  9,
+  5,
+  0,
+  15,
+  4,
+  8,
+  6,
+  2,
+  10,
+  6,
+  15,
+  14,
+  9,
+  11,
+  3,
+  0,
+  8,
+  12,
+  2,
+  13,
+  7,
+  1,
+  4,
+  10,
+  5,
+  10,
+  2,
+  8,
+  4,
+  7,
+  6,
+  1,
+  5,
+  15,
+  11,
+  9,
+  14,
+  3,
+  12,
+  13,
+  0
+);
+var ROUNDS = 14;
+var BLAKE256_DIGEST_LENGTH = 32;
+var BLAKE256_BLOCK_LENGTH = 64;
+var V = new Uint32Array(16);
+var M = new Uint32Array(16);
+function compress(h, block, offset, t0, t1, nullt) {
+  for (let i = 0; i < 16; i++) {
+    const j = offset + i * 4;
+    M[i] = (block[j] << 24 | block[j + 1] << 16 | block[j + 2] << 8 | block[j + 3]) >>> 0;
+  }
+  V[0] = h[0];
+  V[1] = h[1];
+  V[2] = h[2];
+  V[3] = h[3];
+  V[4] = h[4];
+  V[5] = h[5];
+  V[6] = h[6];
+  V[7] = h[7];
+  V[8] = C[0];
+  V[9] = C[1];
+  V[10] = C[2];
+  V[11] = C[3];
+  V[12] = C[4];
+  V[13] = C[5];
+  V[14] = C[6];
+  V[15] = C[7];
+  if (!nullt) {
+    V[12] ^= t0;
+    V[13] ^= t0;
+    V[14] ^= t1;
+    V[15] ^= t1;
+  }
+  let p, s0, s1;
+  let va, vb, vc, vd, t;
+  for (let r = 0; r < ROUNDS; r++) {
+    const s = r % 10 * 16;
+    p = s + 0;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[0];
+    vb = V[4];
+    vc = V[8];
+    vd = V[12];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[0] = va;
+    V[4] = vb;
+    V[8] = vc;
+    V[12] = vd;
+    p = s + 2;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[1];
+    vb = V[5];
+    vc = V[9];
+    vd = V[13];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[1] = va;
+    V[5] = vb;
+    V[9] = vc;
+    V[13] = vd;
+    p = s + 4;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[2];
+    vb = V[6];
+    vc = V[10];
+    vd = V[14];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[2] = va;
+    V[6] = vb;
+    V[10] = vc;
+    V[14] = vd;
+    p = s + 6;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[3];
+    vb = V[7];
+    vc = V[11];
+    vd = V[15];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[3] = va;
+    V[7] = vb;
+    V[11] = vc;
+    V[15] = vd;
+    p = s + 8;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[0];
+    vb = V[5];
+    vc = V[10];
+    vd = V[15];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[0] = va;
+    V[5] = vb;
+    V[10] = vc;
+    V[15] = vd;
+    p = s + 10;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[1];
+    vb = V[6];
+    vc = V[11];
+    vd = V[12];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[1] = va;
+    V[6] = vb;
+    V[11] = vc;
+    V[12] = vd;
+    p = s + 12;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[2];
+    vb = V[7];
+    vc = V[8];
+    vd = V[13];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[2] = va;
+    V[7] = vb;
+    V[8] = vc;
+    V[13] = vd;
+    p = s + 14;
+    s0 = SIGMA[p];
+    s1 = SIGMA[p + 1];
+    va = V[3];
+    vb = V[4];
+    vc = V[9];
+    vd = V[14];
+    va = va + vb + ((M[s0] ^ C[s1]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 16 | t << 16;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 12 | t << 20;
+    va = va + vb + ((M[s1] ^ C[s0]) >>> 0) >>> 0;
+    t = vd ^ va;
+    vd = t >>> 8 | t << 24;
+    vc = vc + vd >>> 0;
+    t = vb ^ vc;
+    vb = t >>> 7 | t << 25;
+    V[3] = va;
+    V[4] = vb;
+    V[9] = vc;
+    V[14] = vd;
+  }
+  for (let i = 0; i < 8; i++) {
+    h[i] = (h[i] ^ V[i] ^ V[i + 8]) >>> 0;
+  }
+}
+var Blake256 = class {
+  h = IV.slice();
+  buf = new Uint8Array(BLAKE256_BLOCK_LENGTH);
+  buflen = 0;
+  /** Total message bytes fed in (used for the final length encoding). */
+  total = 0;
+  /** Message bytes already absorbed by the compression function. */
+  compressed = 0;
+  finished = false;
+  update(data) {
+    if (this.finished) throw err("invalid-argument", "Blake256", "update after digest");
+    if (!isBytes(data)) {
+      throw err("invalid-argument", "Blake256", `data must be a Uint8Array, got ${typeName(data)}`);
+    }
+    let i = 0;
+    const n = data.length;
+    this.total += n;
+    if (this.buflen > 0) {
+      const need = BLAKE256_BLOCK_LENGTH - this.buflen;
+      const take = Math.min(need, n);
+      this.buf.set(data.subarray(0, take), this.buflen);
+      this.buflen += take;
+      i = take;
+      if (this.buflen === BLAKE256_BLOCK_LENGTH) {
+        this.compressed += BLAKE256_BLOCK_LENGTH;
+        compress(this.h, this.buf, 0, lo32(this.compressed), hi32(this.compressed), false);
+        this.buflen = 0;
+      }
+    }
+    while (n - i >= BLAKE256_BLOCK_LENGTH) {
+      this.compressed += BLAKE256_BLOCK_LENGTH;
+      compress(this.h, data, i, lo32(this.compressed), hi32(this.compressed), false);
+      i += BLAKE256_BLOCK_LENGTH;
+    }
+    if (i < n) {
+      this.buf.set(data.subarray(i), this.buflen);
+      this.buflen += n - i;
+    }
+    return this;
+  }
+  digest() {
+    if (this.finished) throw err("invalid-argument", "Blake256", "digest called twice");
+    this.finished = true;
+    const rem = this.buflen;
+    const block = new Uint8Array(BLAKE256_BLOCK_LENGTH);
+    block.set(this.buf.subarray(0, rem));
+    if (rem <= 55) {
+      block[rem] = 128;
+      block[55] |= 1;
+      writeLen(block, this.total);
+      if (rem === 0) compress(this.h, block, 0, 0, 0, true);
+      else compress(this.h, block, 0, lo32(this.total), hi32(this.total), false);
+    } else {
+      block[rem] = 128;
+      compress(this.h, block, 0, lo32(this.total), hi32(this.total), false);
+      const tail = new Uint8Array(BLAKE256_BLOCK_LENGTH);
+      tail[55] = 1;
+      writeLen(tail, this.total);
+      compress(this.h, tail, 0, 0, 0, true);
+    }
+    const out = new Uint8Array(BLAKE256_DIGEST_LENGTH);
+    for (let i = 0; i < 8; i++) {
+      const v = this.h[i];
+      out[i * 4] = v >>> 24 & 255;
+      out[i * 4 + 1] = v >>> 16 & 255;
+      out[i * 4 + 2] = v >>> 8 & 255;
+      out[i * 4 + 3] = v & 255;
+    }
+    return out;
+  }
+};
+function lo32(bytes) {
+  return bytes * 8 >>> 0;
+}
+function hi32(bytes) {
+  return Math.floor(bytes * 8 / 4294967296) >>> 0;
+}
+function writeLen(block, totalBytes) {
+  const h = hi32(totalBytes);
+  const l = lo32(totalBytes);
+  block[56] = h >>> 24 & 255;
+  block[57] = h >>> 16 & 255;
+  block[58] = h >>> 8 & 255;
+  block[59] = h & 255;
+  block[60] = l >>> 24 & 255;
+  block[61] = l >>> 16 & 255;
+  block[62] = l >>> 8 & 255;
+  block[63] = l & 255;
+}
+function blake256(data) {
+  return new Blake256().update(data).digest();
+}
+
+// src/hash.ts
+function hash256(data) {
+  return blake256(blake256(data));
+}
+function hash160(data) {
+  return ripemd160.ripemd160(blake256(data));
+}
+
+// src/base58.ts
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE = 58n;
+var INDEX = new Uint8Array(128).fill(255);
+for (let i = 0; i < ALPHABET.length; i++) {
+  INDEX[ALPHABET.charCodeAt(i)] = i;
+}
+function base58Encode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  let num = 0n;
+  for (const b of bytes) num = num * 256n + BigInt(b);
+  let out = "";
+  while (num > 0n) {
+    const rem = num % BASE;
+    num = num / BASE;
+    out = ALPHABET[Number(rem)] + out;
+  }
+  return "1".repeat(zeros) + out;
+}
+function maxBase58Length(decodedLen) {
+  return Math.floor(decodedLen * 137 / 100) + 1;
+}
+function base58Decode(str) {
+  let zeros = 0;
+  while (zeros < str.length && str[zeros] === "1") zeros++;
+  let num = 0n;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    const val = code < 128 ? INDEX[code] : 255;
+    if (val === 255) throw err("invalid-base58", "base58Decode", `invalid character ${shown(str[i])} at index ${i}`);
+    num = num * BASE + BigInt(val);
+  }
+  const tail = [];
+  while (num > 0n) {
+    tail.push(Number(num % 256n));
+    num = num / 256n;
+  }
+  tail.reverse();
+  const out = new Uint8Array(zeros + tail.length);
+  out.set(tail, zeros);
+  return out;
+}
+function checkEncode(data) {
+  const checksum = hash256(data).subarray(0, 4);
+  const full = new Uint8Array(data.length + 4);
+  full.set(data);
+  full.set(checksum, data.length);
+  return base58Encode(full);
+}
+function checkDecode(str) {
+  const full = base58Decode(str);
+  if (full.length < 4) throw err("bad-length", "base58check", "input is shorter than the 4-byte checksum");
+  const data = full.subarray(0, full.length - 4);
+  const checksum = full.subarray(full.length - 4);
+  const expected = hash256(data).subarray(0, 4);
+  for (let i = 0; i < 4; i++) {
+    if (checksum[i] !== expected[i]) throw err("bad-checksum", "base58check", "checksum does not match");
+  }
+  return data.slice();
+}
+
+// src/networks.ts
+var mainnet = {
+  name: "mainnet",
+  net: 3652452601,
+  addressPrefix: "D",
+  pubKeyAddrId: [19, 134],
+  pubKeyHashAddrId: [7, 63],
+  pubKeyHashEdwardsAddrId: [7, 31],
+  pubKeyHashSchnorrAddrId: [7, 1],
+  scriptHashAddrId: [7, 26],
+  privateKeyId: [34, 222],
+  hdPrivateKeyId: [2, 253, 164, 232],
+  hdPublicKeyId: [2, 253, 169, 38],
+  slip44: 42
+};
+var testnet3 = {
+  name: "testnet3",
+  net: 2979310197,
+  addressPrefix: "T",
+  pubKeyAddrId: [40, 247],
+  pubKeyHashAddrId: [15, 33],
+  pubKeyHashEdwardsAddrId: [15, 1],
+  pubKeyHashSchnorrAddrId: [14, 227],
+  scriptHashAddrId: [14, 252],
+  privateKeyId: [35, 14],
+  hdPrivateKeyId: [4, 53, 131, 151],
+  hdPublicKeyId: [4, 53, 135, 209],
+  slip44: 1
+};
+var simnet = {
+  name: "simnet",
+  net: 303307798,
+  addressPrefix: "S",
+  pubKeyAddrId: [39, 111],
+  pubKeyHashAddrId: [14, 145],
+  pubKeyHashEdwardsAddrId: [14, 113],
+  pubKeyHashSchnorrAddrId: [14, 83],
+  scriptHashAddrId: [14, 108],
+  privateKeyId: [35, 7],
+  hdPrivateKeyId: [4, 32, 185, 3],
+  hdPublicKeyId: [4, 32, 189, 61],
+  slip44: 1
+};
+var regnet = {
+  name: "regnet",
+  net: 3669295354,
+  addressPrefix: "R",
+  pubKeyAddrId: [37, 229],
+  pubKeyHashAddrId: [14, 0],
+  pubKeyHashEdwardsAddrId: [13, 224],
+  pubKeyHashSchnorrAddrId: [13, 194],
+  scriptHashAddrId: [13, 219],
+  privateKeyId: [34, 254],
+  hdPrivateKeyId: [234, 180, 4, 72],
+  hdPublicKeyId: [234, 180, 249, 135],
+  slip44: 1
+};
+var networks = { mainnet, testnet3, simnet, regnet };
+var CURVE_ORDER = secp256k1.secp256k1.CURVE.n;
+var ED25519_CURVE_ORDER = 2n ** 252n + 27742317777372353535851937790883648493n;
+function isValidPrivateKey(key) {
+  if (!isBytes(key) || key.length !== 32) return false;
+  const n = bytesToBigInt(key);
+  return n > 0n && n < CURVE_ORDER;
+}
+function assertPrivateKey(key, who) {
+  if (!isBytes(key)) {
+    throw err("invalid-argument", who, `private key must be a Uint8Array, got ${typeName(key)}`);
+  }
+  if (key.length !== 32) {
+    throw err("bad-length", who, `private key must be 32 bytes, got ${key.length}`);
+  }
+  if (!isValidPrivateKey(key)) {
+    throw err("invalid-private-key", who, "private key is zero, or at or above the group order");
+  }
+}
+function publicKeyFromPrivate(privateKey, compressed = true) {
+  assertPrivateKey(privateKey, "publicKeyFromPrivate");
+  return secp256k1.secp256k1.getPublicKey(privateKey, compressed);
+}
+function isValidPublicKey(key) {
+  try {
+    secp256k1.secp256k1.ProjectivePoint.fromHex(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidEd25519PublicKey(key) {
+  if (!isBytes(key) || key.length !== 32) return false;
+  try {
+    const point = ed25519.ed25519.ExtendedPoint.fromHex(key, true);
+    return !(point.toAffine().x === 0n && (key[31] & 128) !== 0);
+  } catch {
+    return false;
+  }
+}
+function assertCompressedPubKey(key, who) {
+  if (!isBytes(key)) {
+    throw err("invalid-argument", who, `public key must be a Uint8Array, got ${typeName(key)}`);
+  }
+  if (key.length !== 33) {
+    throw err("invalid-public-key", who, `public key must be 33 compressed bytes, got ${key.length}`);
+  }
+  if (key[0] !== 2 && key[0] !== 3) {
+    throw err(
+      "invalid-public-key",
+      who,
+      `public key must start with 0x02 or 0x03, got 0x${key[0].toString(16).padStart(2, "0")}`
+    );
+  }
+  if (!isValidPublicKey(key)) {
+    throw err("invalid-public-key", who, "public key is not a point on the secp256k1 curve");
+  }
+}
+function assertPubKey(key, who) {
+  if (!isBytes(key)) {
+    throw err("invalid-argument", who, `public key must be a Uint8Array, got ${typeName(key)}`);
+  }
+  if (key.length !== 33 && key.length !== 65) {
+    throw err(
+      "invalid-public-key",
+      who,
+      `public key must be 33 (compressed) or 65 (uncompressed) bytes, got ${key.length}`
+    );
+  }
+  const prefix = key[0];
+  const ok = key.length === 33 ? prefix === 2 || prefix === 3 : prefix === 4;
+  if (!ok) {
+    throw err(
+      "invalid-public-key",
+      who,
+      `public key has prefix 0x${prefix.toString(16).padStart(2, "0")}, which is not valid for a ${key.length}-byte key`
+    );
+  }
+  if (!isValidPublicKey(key)) {
+    throw err("invalid-public-key", who, "public key is not a point on the secp256k1 curve");
+  }
+}
+function scalarToBytes(x) {
+  const out = new Uint8Array(32);
+  let v = x;
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function bytesToBigInt(b) {
+  let v = 0n;
+  for (const x of b) v = v << 8n | BigInt(x);
+  return v;
+}
+function privateKeyTweakAdd(kPar, il) {
+  const ilInt = bytesToBigInt(il);
+  if (ilInt === 0n || ilInt >= CURVE_ORDER) return null;
+  const child = (ilInt + bytesToBigInt(kPar)) % CURVE_ORDER;
+  if (child === 0n) return null;
+  return scalarToBytes(child);
+}
+function parsePublicKeyPoint(key) {
+  try {
+    return secp256k1.secp256k1.ProjectivePoint.fromHex(key);
+  } catch {
+    return null;
+  }
+}
+function publicKeyTweakAddPoint(parent, il) {
+  const ilInt = bytesToBigInt(il);
+  if (ilInt >= CURVE_ORDER || ilInt === 0n) return null;
+  const P = secp256k1.secp256k1.ProjectivePoint;
+  try {
+    const child = P.BASE.multiply(ilInt).add(parent);
+    if (child.equals(P.ZERO)) return null;
+    return child.toRawBytes(true);
+  } catch {
+    return null;
+  }
+}
+
+// src/script.ts
+var OP = {
+  OP_0: 0,
+  DATA_20: 20,
+  DATA_32: 32,
+  DATA_33: 33,
+  PUSHDATA1: 76,
+  PUSHDATA2: 77,
+  PUSHDATA4: 78,
+  OP_1NEGATE: 79,
+  OP_1: 81,
+  OP_2: 82,
+  OP_16: 96,
+  DUP: 118,
+  EQUAL: 135,
+  EQUALVERIFY: 136,
+  HASH160: 169,
+  CHECKSIG: 172,
+  CHECKSIGALT: 190
+};
+var MAX_SCRIPT_ELEMENT_SIZE = 2048;
+function pushData(data) {
+  if (!isBytes(data)) {
+    throw err("invalid-argument", "pushData", `data must be a Uint8Array, got ${typeName(data)}`);
+  }
+  const n = data.length;
+  if (n > MAX_SCRIPT_ELEMENT_SIZE) {
+    throw err(
+      "element-too-large",
+      "pushData",
+      `${n} bytes exceeds MaxScriptElementSize (${MAX_SCRIPT_ELEMENT_SIZE})`
+    );
+  }
+  if (n === 1) {
+    const b = data[0];
+    if (b === 0) return Uint8Array.of(OP.OP_0);
+    if (b >= 1 && b <= 16) return Uint8Array.of(OP.OP_1 + b - 1);
+    if (b === 129) return Uint8Array.of(OP.OP_1NEGATE);
+  }
+  if (n < OP.PUSHDATA1) {
+    const out2 = new Uint8Array(1 + n);
+    out2[0] = n;
+    out2.set(data, 1);
+    return out2;
+  }
+  if (n <= 255) {
+    const out2 = new Uint8Array(2 + n);
+    out2[0] = OP.PUSHDATA1;
+    out2[1] = n;
+    out2.set(data, 2);
+    return out2;
+  }
+  const out = new Uint8Array(3 + n);
+  out[0] = OP.PUSHDATA2;
+  out[1] = n & 255;
+  out[2] = n >>> 8 & 255;
+  out.set(data, 3);
+  return out;
+}
+function scriptParses(script) {
+  if (!isBytes(script)) return false;
+  let i = 0;
+  while (i < script.length) {
+    const op = script[i];
+    if (op >= 1 && op <= 75) {
+      if (script.length - i < op + 1) return false;
+      i += op + 1;
+    } else if (op === OP.PUSHDATA1 || op === OP.PUSHDATA2 || op === OP.PUSHDATA4) {
+      const lenSize = op === OP.PUSHDATA1 ? 1 : op === OP.PUSHDATA2 ? 2 : 4;
+      if (script.length - (i + 1) < lenSize) return false;
+      let dataLen = 0;
+      for (let b = 0; b < lenSize; b++) dataLen |= script[i + 1 + b] << 8 * b;
+      if (dataLen < 0 || dataLen > script.length - (i + 1 + lenSize)) return false;
+      i += 1 + lenSize + dataLen;
+    } else {
+      i += 1;
+    }
+  }
+  return true;
+}
+function assertHash160(hash1602, who) {
+  if (!isBytes(hash1602)) {
+    throw err("invalid-argument", who, `hash must be a Uint8Array, got ${typeName(hash1602)}`);
+  }
+}
+function payToPubKeyHashScript(hash1602) {
+  assertHash160(hash1602, "payToPubKeyHash");
+  if (hash1602.length !== 20) throw err("bad-length", "payToPubKeyHash", `hash must be 20 bytes, got ${hash1602.length}`);
+  const out = new Uint8Array(25);
+  out[0] = OP.DUP;
+  out[1] = OP.HASH160;
+  out[2] = OP.DATA_20;
+  out.set(hash1602, 3);
+  out[23] = OP.EQUALVERIFY;
+  out[24] = OP.CHECKSIG;
+  return out;
+}
+function payToPubKeyHashAltScript(hash1602, sigType) {
+  assertHash160(hash1602, "payToPubKeyHashAlt");
+  if (hash1602.length !== 20) throw err("bad-length", "payToPubKeyHashAlt", `hash must be 20 bytes, got ${hash1602.length}`);
+  if (sigType !== 1 && sigType !== 2) throw err("unsupported-signature-type", "payToPubKeyHashAlt", `sigType must be 1 or 2, got ${shown(sigType)}`);
+  const out = new Uint8Array(26);
+  out[0] = OP.DUP;
+  out[1] = OP.HASH160;
+  out[2] = OP.DATA_20;
+  out.set(hash1602, 3);
+  out[23] = OP.EQUALVERIFY;
+  out[24] = sigType === 1 ? OP.OP_1 : OP.OP_2;
+  out[25] = OP.CHECKSIGALT;
+  return out;
+}
+function payToScriptHashScript(hash1602) {
+  assertHash160(hash1602, "payToScriptHash");
+  if (hash1602.length !== 20) throw err("bad-length", "payToScriptHash", `hash must be 20 bytes, got ${hash1602.length}`);
+  const out = new Uint8Array(23);
+  out[0] = OP.HASH160;
+  out[1] = OP.DATA_20;
+  out.set(hash1602, 2);
+  out[22] = OP.EQUAL;
+  return out;
+}
+function payToPubKeyScript(compressedPubKey) {
+  assertCompressedPubKey(compressedPubKey, "payToPubKey");
+  const out = new Uint8Array(35);
+  out[0] = OP.DATA_33;
+  out.set(compressedPubKey, 1);
+  out[34] = OP.CHECKSIG;
+  return out;
+}
+function payToPubKeyAltScript(pubKey, sigType) {
+  if (sigType === 1) {
+    if (pubKey.length !== 32) {
+      throw err(
+        "invalid-public-key",
+        "payToPubKeyAlt",
+        `an Ed25519 public key must be 32 bytes, got ${pubKey.length}`
+      );
+    }
+    if (!isValidEd25519PublicKey(pubKey)) {
+      throw err("invalid-public-key", "payToPubKeyAlt", "public key is not a valid Ed25519 curve point");
+    }
+    const out2 = new Uint8Array(35);
+    out2[0] = OP.DATA_32;
+    out2.set(pubKey, 1);
+    out2[33] = OP.OP_1;
+    out2[34] = OP.CHECKSIGALT;
+    return out2;
+  }
+  if (sigType !== 2) throw err("unsupported-signature-type", "payToPubKeyAlt", `sigType must be 1 or 2, got ${shown(sigType)}`);
+  assertCompressedPubKey(pubKey, "payToPubKeyAlt");
+  const out = new Uint8Array(36);
+  out[0] = OP.DATA_33;
+  out.set(pubKey, 1);
+  out[34] = OP.OP_2;
+  out[35] = OP.CHECKSIGALT;
+  return out;
+}
+function isPayToPubKeyHash(script) {
+  return isBytes(script) && script.length === 25 && script[0] === OP.DUP && script[1] === OP.HASH160 && script[2] === OP.DATA_20 && script[23] === OP.EQUALVERIFY && script[24] === OP.CHECKSIG;
+}
+function isPayToScriptHash(script) {
+  return isBytes(script) && script.length === 23 && script[0] === OP.HASH160 && script[1] === OP.DATA_20 && script[22] === OP.EQUAL;
+}
+function extractHash160(script) {
+  if (isPayToPubKeyHash(script)) return copyOf(script, 3, 20);
+  if (isPayToScriptHash(script)) return copyOf(script, 2, 20);
+  return null;
+}
+function classifyScript(script) {
+  if (!isBytes(script)) return null;
+  if (isPayToPubKeyHash(script)) return { kind: "pubkeyhash-ecdsa", hash: copyOf(script, 3, 20) };
+  if (isPayToScriptHash(script)) return { kind: "scripthash", hash: copyOf(script, 2, 20) };
+  if (script.length === 26 && script[0] === OP.DUP && script[1] === OP.HASH160 && script[2] === OP.DATA_20 && script[23] === OP.EQUALVERIFY && script[25] === OP.CHECKSIGALT) {
+    if (script[24] === OP.OP_1) {
+      return { kind: "pubkeyhash-ed25519", hash: copyOf(script, 3, 20) };
+    }
+    if (script[24] === OP.OP_2) {
+      return { kind: "pubkeyhash-schnorr", hash: copyOf(script, 3, 20) };
+    }
+  }
+  return null;
+}
+
+// src/address.ts
+var MAX_ADDRESS_LENGTH = maxBase58Length(33 + 2 + 4);
+var PREFIXES = [];
+for (const network of Object.values(networks)) {
+  PREFIXES.push(
+    { network, kind: "pubkeyhash-ecdsa", prefix: network.pubKeyHashAddrId },
+    { network, kind: "pubkeyhash-ed25519", prefix: network.pubKeyHashEdwardsAddrId },
+    { network, kind: "pubkeyhash-schnorr", prefix: network.pubKeyHashSchnorrAddrId },
+    { network, kind: "scripthash", prefix: network.scriptHashAddrId },
+    { network, kind: "pubkey-ecdsa", prefix: network.pubKeyAddrId }
+  );
+}
+function encode(prefix, payload) {
+  const data = new Uint8Array(2 + payload.length);
+  data[0] = prefix[0];
+  data[1] = prefix[1];
+  data.set(payload, 2);
+  return checkEncode(data);
+}
+function pubKeyHashAddress(hash, network) {
+  if (hash.length !== 20) throw err("bad-length", "pubKeyHashAddress", `hash must be 20 bytes, got ${hash.length}`);
+  return encode(network.pubKeyHashAddrId, hash);
+}
+function scriptHashAddress(hash, network) {
+  if (hash.length !== 20) throw err("bad-length", "scriptHashAddress", `hash must be 20 bytes, got ${hash.length}`);
+  return encode(network.scriptHashAddrId, hash);
+}
+function pubKeyHashEd25519Address(hash, network) {
+  if (hash.length !== 20) throw err("bad-length", "pubKeyHashEd25519Address", `hash must be 20 bytes, got ${hash.length}`);
+  return encode(network.pubKeyHashEdwardsAddrId, hash);
+}
+function pubKeyHashSchnorrAddress(hash, network) {
+  if (hash.length !== 20) throw err("bad-length", "pubKeyHashSchnorrAddress", `hash must be 20 bytes, got ${hash.length}`);
+  return encode(network.pubKeyHashSchnorrAddrId, hash);
+}
+var SIG_TYPE_ODD_FLAG = 128;
+function encodePubKeyData(compressedPubKey) {
+  assertCompressedPubKey(compressedPubKey, "pubKeyAddress");
+  const prefix = compressedPubKey[0];
+  const data = new Uint8Array(33);
+  data[0] = SignatureTypeEcdsa | (prefix === 3 ? SIG_TYPE_ODD_FLAG : 0);
+  data.set(compressedPubKey.subarray(1), 1);
+  return data;
+}
+function decodePubKeyData(data) {
+  const sigType = data[0] & ~SIG_TYPE_ODD_FLAG;
+  const odd = (data[0] & SIG_TYPE_ODD_FLAG) !== 0;
+  if (sigType === SignatureTypeEd25519) {
+    const pubKey2 = copyOf(data, 1, 32);
+    if (!isValidEd25519PublicKey(pubKey2)) {
+      throw err("invalid-public-key", "decodeAddress", "pubkey is not a valid Ed25519 curve point");
+    }
+    return { kind: "pubkey-ed25519", pubKey: pubKey2 };
+  }
+  if (sigType !== SignatureTypeEcdsa && sigType !== SignatureTypeSchnorr) {
+    throw err("unsupported-signature-type", "decodeAddress", `unsupported pubkey signature type ${sigType}`);
+  }
+  const pubKey = new Uint8Array(33);
+  pubKey[0] = odd ? 3 : 2;
+  pubKey.set(data.subarray(1), 1);
+  if (!isValidPublicKey(pubKey)) {
+    throw err("invalid-public-key", "decodeAddress", "pubkey is not a valid curve point");
+  }
+  return { kind: sigType === SignatureTypeEcdsa ? "pubkey-ecdsa" : "pubkey-schnorr", pubKey };
+}
+var SignatureTypeEcdsa = 0;
+var SignatureTypeEd25519 = 1;
+var SignatureTypeSchnorr = 2;
+function pubKeyAddress(compressedPubKey, network) {
+  return encode(network.pubKeyAddrId, encodePubKeyData(compressedPubKey));
+}
+function pubKeyEd25519Address(pubKey, network) {
+  if (pubKey.length !== 32) {
+    throw err("invalid-public-key", "pubKeyEd25519Address", `an Ed25519 public key must be 32 bytes, got ${pubKey.length}`);
+  }
+  if (!isValidEd25519PublicKey(pubKey)) {
+    throw err("invalid-public-key", "pubKeyEd25519Address", "public key is not a valid Ed25519 curve point");
+  }
+  const data = new Uint8Array(33);
+  data[0] = SignatureTypeEd25519;
+  data.set(pubKey, 1);
+  return encode(network.pubKeyAddrId, data);
+}
+function pubKeySchnorrAddress(compressedPubKey, network) {
+  assertCompressedPubKey(compressedPubKey, "pubKeySchnorrAddress");
+  const data = new Uint8Array(33);
+  data[0] = SignatureTypeSchnorr | (compressedPubKey[0] === 3 ? SIG_TYPE_ODD_FLAG : 0);
+  data.set(compressedPubKey.subarray(1), 1);
+  return encode(network.pubKeyAddrId, data);
+}
+function addressFromPubKey(pubKey, network) {
+  assertPubKey(pubKey, "addressFromPubKey");
+  return pubKeyHashAddress(hash160(pubKey), network);
+}
+function addressFromScript(redeemScript, network) {
+  return scriptHashAddress(hash160(redeemScript), network);
+}
+function decodeAddress(address, network) {
+  if (typeof address !== "string") {
+    throw err("invalid-argument", "decodeAddress", `address must be a string, got ${typeName(address)}`);
+  }
+  if (address.length > MAX_ADDRESS_LENGTH) {
+    throw err(
+      "input-too-long",
+      "decodeAddress",
+      `${address.length} characters exceeds the ${MAX_ADDRESS_LENGTH}-character maximum`
+    );
+  }
+  const data = checkDecode(address);
+  if (data.length < 3) throw err("bad-length", "decodeAddress", `payload is ${data.length} bytes, too short to hold a prefix and data`);
+  const prefix = [data[0], data[1]];
+  const payload = data.subarray(2);
+  const match = PREFIXES.find(
+    (e) => e.prefix[0] === prefix[0] && e.prefix[1] === prefix[1] && (!network || e.network === network)
+  );
+  if (!match) {
+    const hex = `0x${prefix[0].toString(16).padStart(2, "0")}${prefix[1].toString(16).padStart(2, "0")}`;
+    const onAnotherNetwork = network && PREFIXES.find((e) => e.prefix[0] === prefix[0] && e.prefix[1] === prefix[1]);
+    if (onAnotherNetwork) {
+      throw err(
+        "wrong-network",
+        "decodeAddress",
+        `address is a ${onAnotherNetwork.kind} address for ${onAnotherNetwork.network.name}, not ${network.name}`
+      );
+    }
+    throw err("unknown-prefix", "decodeAddress", `unknown address prefix ${hex}`);
+  }
+  if (match.kind === "pubkey-ecdsa") {
+    if (payload.length !== 33) throw err("bad-length", "decodeAddress", `pay-to-pubkey payload must be 33 bytes, got ${payload.length}`);
+    const { kind, pubKey } = decodePubKeyData(payload);
+    return { network: match.network, kind, pubKey, address };
+  }
+  if (payload.length !== 20) throw err("bad-length", "decodeAddress", `hash payload must be 20 bytes, got ${payload.length}`);
+  return {
+    network: match.network,
+    kind: match.kind,
+    hash: copyOf(payload, 0, 20),
+    address
+  };
+}
+function isValidAddress(address, network) {
+  try {
+    decodeAddress(address, network);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function addressToScript(address, network) {
+  if (!network || typeof network.name !== "string") {
+    throw err(
+      "invalid-argument",
+      "addressToScript",
+      "a network is required (pass mainnet, testnet3, simnet or regnet)"
+    );
+  }
+  const d = decodeAddress(address, network);
+  switch (d.kind) {
+    case "pubkeyhash-ecdsa":
+      return payToPubKeyHashScript(d.hash);
+    // The alternative signature suites use OP_CHECKSIGALT with the signature
+    // type pushed as a small integer (Ed25519 = 1, Schnorr = 2).
+    case "pubkeyhash-ed25519":
+      return payToPubKeyHashAltScript(d.hash, 1);
+    case "pubkeyhash-schnorr":
+      return payToPubKeyHashAltScript(d.hash, 2);
+    case "scripthash":
+      return payToScriptHashScript(d.hash);
+    case "pubkey-ecdsa":
+      return payToPubKeyScript(d.pubKey);
+    case "pubkey-ed25519":
+      return payToPubKeyAltScript(d.pubKey, 1);
+    case "pubkey-schnorr":
+      return payToPubKeyAltScript(d.pubKey, 2);
+  }
+}
+
+// src/wif.ts
+var SignatureType = /* @__PURE__ */ ((SignatureType2) => {
+  SignatureType2[SignatureType2["Ecdsa"] = 0] = "Ecdsa";
+  SignatureType2[SignatureType2["Ed25519"] = 1] = "Ed25519";
+  SignatureType2[SignatureType2["SchnorrSecp256k1"] = 2] = "SchnorrSecp256k1";
+  return SignatureType2;
+})(SignatureType || {});
+function wifChecksum(data) {
+  return blake256(data).subarray(0, 4);
+}
+function assertWifScalar(privateKey, signatureType, who) {
+  if (signatureType !== 1 /* Ed25519 */) return;
+  const scalar = bytesToBigInt(privateKey);
+  if (scalar === 0n || scalar > ED25519_CURVE_ORDER) {
+    throw err("invalid-private-key", who, "Ed25519 scalar is zero or above the group order");
+  }
+}
+function encodeWif(privateKey, network, signatureType = 0 /* Ecdsa */) {
+  if (!isBytes(privateKey)) throw err("invalid-argument", "encodeWif", "private key must be a Uint8Array");
+  if (privateKey.length !== 32) throw err("bad-length", "encodeWif", `private key must be 32 bytes, got ${privateKey.length}`);
+  if (!Number.isInteger(signatureType) || SignatureType[signatureType] === void 0) {
+    throw err("unsupported-signature-type", "encodeWif", `unknown signature type ${signatureType}`);
+  }
+  assertWifScalar(privateKey, signatureType, "encodeWif");
+  const payload = new Uint8Array(3 + 32);
+  payload[0] = network.privateKeyId[0];
+  payload[1] = network.privateKeyId[1];
+  payload[2] = signatureType;
+  payload.set(privateKey, 3);
+  const full = new Uint8Array(payload.length + 4);
+  full.set(payload);
+  full.set(wifChecksum(payload), payload.length);
+  return base58Encode(full);
+}
+var MAX_WIF_LENGTH = maxBase58Length(39);
+function decodeWif(wif) {
+  if (typeof wif !== "string") {
+    throw err("invalid-argument", "decodeWif", `WIF must be a string, got ${typeName(wif)}`);
+  }
+  if (wif.length > MAX_WIF_LENGTH) {
+    throw err(
+      "input-too-long",
+      "decodeWif",
+      `${wif.length} characters exceeds the ${MAX_WIF_LENGTH}-character maximum`
+    );
+  }
+  const full = base58Decode(wif);
+  if (full.length !== 39) throw err("bad-length", "decodeWif", `decoded to ${full.length} bytes, expected 39`);
+  const data = full.subarray(0, 35);
+  const checksum = full.subarray(35);
+  const expected = wifChecksum(data);
+  for (let i = 0; i < 4; i++) {
+    if (checksum[i] !== expected[i]) throw err("bad-checksum", "decodeWif", "checksum does not match");
+  }
+  const prefix = [data[0], data[1]];
+  const signatureType = data[2];
+  const privateKey = data.slice(3);
+  const network = Object.values(networks).find(
+    (n) => n.privateKeyId[0] === prefix[0] && n.privateKeyId[1] === prefix[1]
+  );
+  if (!network) throw err("unknown-prefix", "decodeWif", `no network has the private-key prefix 0x${prefix[0].toString(16).padStart(2, "0")}${prefix[1].toString(16).padStart(2, "0")}`);
+  if (SignatureType[signatureType] === void 0) {
+    throw err("unsupported-signature-type", "decodeWif", `unknown signature type ${signatureType}`);
+  }
+  assertWifScalar(privateKey, signatureType, "decodeWif");
+  return { privateKey, network, signatureType };
+}
+var HARDENED_OFFSET = 2147483648;
+var MASTER_HMAC_KEY = new TextEncoder().encode("Bitcoin seed");
+var SERIALIZED_LENGTH = 78;
+var MAX_EXTENDED_KEY_LENGTH = maxBase58Length(SERIALIZED_LENGTH + 4);
+function hardened(index) {
+  if (!Number.isInteger(index) || index < 0 || index >= HARDENED_OFFSET) {
+    throw err(Number.isInteger(index) ? "out-of-range" : "not-an-integer", "hardened", `index must be an integer in 0..2^31-1, got ${shown(index)}`);
+  }
+  return index + HARDENED_OFFSET >>> 0;
+}
+function ser32(value) {
+  return Uint8Array.of(
+    value >>> 24 & 255,
+    value >>> 16 & 255,
+    value >>> 8 & 255,
+    value & 255
+  );
+}
+function leadingZeros(key) {
+  let n = 0;
+  while (n < key.length && key[n] === 0) n++;
+  return n;
+}
+var ExtendedKey = class _ExtendedKey {
+  constructor(network, isPrivate, privateKey, compressedPublicKey, chainCodeBytes, depth, parentFingerprintBytes, childNumber, scalarStripped = false) {
+    this.network = network;
+    this.isPrivate = isPrivate;
+    this.privateKey = privateKey;
+    this.compressedPublicKey = compressedPublicKey;
+    this.chainCodeBytes = chainCodeBytes;
+    this.depth = depth;
+    this.parentFingerprintBytes = parentFingerprintBytes;
+    this.childNumber = childNumber;
+    this.scalarStripped = scalarStripped;
+  }
+  network;
+  isPrivate;
+  privateKey;
+  compressedPublicKey;
+  chainCodeBytes;
+  depth;
+  parentFingerprintBytes;
+  childNumber;
+  scalarStripped;
+  /** Memoized hash160 of the public key; see {@link identifier}. */
+  cachedIdentifier = void 0;
+  /**
+   * Memoized decompression of {@link compressedPublicKey}, so deriving a chain of
+   * public children does the modular square root once instead of per step. Only
+   * populated on the public-derivation path.
+   */
+  cachedPoint = void 0;
+  /** Derive a master key from a BIP32 seed (16–64 bytes). */
+  static fromSeed(seed, network) {
+    if (seed.length < 16 || seed.length > 64) {
+      throw err("out-of-range", "ExtendedKey.fromSeed", `seed must be 16..64 bytes, got ${seed.length}`);
+    }
+    const I = hmac.hmac(sha512.sha512, MASTER_HMAC_KEY, seed);
+    const il = I.subarray(0, 32);
+    const ir = I.subarray(32, 64);
+    if (!isValidPrivateKey(il)) throw err("invalid-private-key", "ExtendedKey.fromSeed", "seed produced an unusable master key; retry with a new seed");
+    return new _ExtendedKey(
+      network,
+      true,
+      il.slice(),
+      publicKeyFromPrivate(il),
+      ir.slice(),
+      0,
+      new Uint8Array(4),
+      0
+    );
+  }
+  /** The compressed public key (33 bytes). */
+  publicKey() {
+    return this.compressedPublicKey.slice();
+  }
+  /** The 32-byte private scalar. Throws for a public key. */
+  privateKeyBytes() {
+    if (!this.privateKey) throw err("not-a-private-key", "ExtendedKey.privateKeyBytes", "this is a public (neutered) key");
+    return this.privateKey.slice();
+  }
+  /**
+   * The 32-byte chain code. A copy: the key's own derivation reads the internal
+   * bytes, so handing out a live view would let a caller change what this key
+   * derives.
+   */
+  get chainCode() {
+    return copyOf(this.chainCodeBytes, 0, 32);
+  }
+  /** The parent's 4-byte fingerprint, or four zero bytes for a master key. A copy. */
+  get parentFingerprint() {
+    return copyOf(this.parentFingerprintBytes, 0, 4);
+  }
+  /**
+   * Identifier = hash160(compressed pubkey); the fingerprint is its first 4 bytes.
+   *
+   * Memoized, because `derive` needs the parent fingerprint for every child and
+   * would otherwise recompute a BLAKE-256 plus a RIPEMD-160 of the same key at
+   * every step. Both accessors return copies: the memo turned what used to be a
+   * per-call throwaway digest into long-lived shared state, so handing out a view
+   * would let one caller's write corrupt the cache, this key's own fingerprint,
+   * every sibling's `parentFingerprint` and every child derived afterwards.
+   */
+  identifier() {
+    return copyOf(this.identifierBytes(), 0, 20);
+  }
+  fingerprint() {
+    return copyOf(this.identifierBytes(), 0, 4);
+  }
+  /** The memoized digest itself. Never escapes this class. */
+  identifierBytes() {
+    if (this.cachedIdentifier === void 0) {
+      this.cachedIdentifier = hash160(this.compressedPublicKey);
+    }
+    return this.cachedIdentifier;
+  }
+  /**
+   * Derive a child key by index, the **Decred way** — the equivalent of dcrd
+   * `hdkeychain.Child`, and what dcrwallet and Decrediton derive with for the
+   * whole wallet path. Use {@link hardened} for hardened indices.
+   *
+   * This is the default because it is what the Decred ecosystem derives; see
+   * {@link deriveBip32Std} for the strict form and the module docs for why they
+   * differ.
+   */
+  derive(index) {
+    return this.deriveInner(index, false);
+  }
+  /**
+   * Derive a child key by **strict BIP32** — the equivalent of dcrd
+   * `hdkeychain.ChildBIP32Std`, retaining the leading zero bytes of the parent
+   * private key that {@link derive} strips.
+   *
+   * Produces different hardened children from {@link derive} for any parent
+   * scalar with a leading zero byte, which is about 1 key in 256 at each
+   * hardened step. Use it only when strict BIP32 is what you want; anything that
+   * has to agree with a dcrwallet or Decrediton seed must not.
+   */
+  deriveBip32Std(index) {
+    return this.deriveInner(index, true);
+  }
+  deriveInner(index, strictBip32) {
+    if (this.depth >= 255) throw err("max-depth", "ExtendedKey.derive", "cannot derive beyond depth 255, which is all a single byte can serialize");
+    if (!Number.isInteger(index)) throw err("not-an-integer", "ExtendedKey.derive", `index must be an integer, got ${shown(index)}`);
+    if (index < 0 || index > 4294967295) throw err("out-of-range", "ExtendedKey.derive", `index ${index} is outside 0..2^32-1`);
+    const idx = index >>> 0;
+    const isHardened = idx >= HARDENED_OFFSET;
+    const data = new Uint8Array(37);
+    if (isHardened) {
+      if (!this.privateKey) {
+        throw err("hardened-from-public", "ExtendedKey.derive", "cannot derive a hardened child from a public key");
+      }
+      const skip = this.scalarStripped ? leadingZeros(this.privateKey) : 0;
+      data.set(this.privateKey.subarray(skip), 1);
+    } else {
+      data.set(this.compressedPublicKey, 0);
+    }
+    data.set(ser32(idx), 33);
+    const I = hmac.hmac(sha512.sha512, this.chainCodeBytes, data);
+    const il = I.subarray(0, 32);
+    const childChainCode = I.subarray(32, 64).slice();
+    const parentFp = this.fingerprint();
+    const childDepth = this.depth + 1;
+    if (this.privateKey) {
+      const childPriv = privateKeyTweakAdd(this.privateKey, il);
+      if (!childPriv) throw err("invalid-child", "ExtendedKey.derive", "derived an invalid child key; retry with the next index");
+      return new _ExtendedKey(
+        this.network,
+        true,
+        childPriv,
+        publicKeyFromPrivate(childPriv),
+        childChainCode,
+        childDepth,
+        parentFp,
+        idx,
+        // dcrd's `child` strips the derived scalar unless strict BIP32 was asked
+        // for, and that state is what the next hardened step reads.
+        !strictBip32
+      );
+    }
+    if (this.cachedPoint === void 0) {
+      const parsed = parsePublicKeyPoint(this.compressedPublicKey);
+      if (parsed === null) throw err("invalid-public-key", "ExtendedKey.derive", "public key is not a valid curve point");
+      this.cachedPoint = parsed;
+    }
+    const childPub = publicKeyTweakAddPoint(this.cachedPoint, il);
+    if (!childPub) throw err("invalid-child", "ExtendedKey.derive", "derived an invalid child key; retry with the next index");
+    return new _ExtendedKey(
+      this.network,
+      false,
+      null,
+      childPub,
+      childChainCode,
+      childDepth,
+      parentFp,
+      idx
+    );
+  }
+  /**
+   * Derive along a path like `m/44'/42'/0'/0/0`, the **Decred way** (see
+   * {@link derive}). An apostrophe or `h` marks a hardened index.
+   */
+  derivePath(path) {
+    return this.derivePathInner(path, false);
+  }
+  /**
+   * Derive along a path using **strict BIP32** (see {@link deriveBip32Std}).
+   * Diverges from {@link derivePath} below any hardened step whose parent scalar
+   * has a leading zero byte, so do not use it to reproduce a wallet seed.
+   */
+  derivePathBip32Std(path) {
+    return this.derivePathInner(path, true);
+  }
+  derivePathInner(path, strictBip32) {
+    const parts = path.trim().split("/");
+    if (parts[0] === "m" || parts[0] === "M") parts.shift();
+    let key = this;
+    for (const raw of parts) {
+      const isH = raw.endsWith("'") || raw.endsWith("h") || raw.endsWith("H");
+      const numStr = isH ? raw.slice(0, -1) : raw;
+      if (!/^\d+$/.test(numStr)) {
+        throw err("invalid-path", "ExtendedKey.derivePath", `invalid path element ${shown(raw)}`);
+      }
+      const n = Number(numStr);
+      if (n >= HARDENED_OFFSET) {
+        throw err("invalid-path", "ExtendedKey.derivePath", `path index ${n} is at or above the hardened offset; write it as ${n - HARDENED_OFFSET}' instead`);
+      }
+      const idx = isH ? hardened(n) : n;
+      key = strictBip32 ? key.deriveBip32Std(idx) : key.derive(idx);
+    }
+    return key;
+  }
+  /** Return the public (watch-only) version of this key. */
+  neuter() {
+    if (!this.isPrivate) return this;
+    return new _ExtendedKey(
+      this.network,
+      false,
+      null,
+      this.compressedPublicKey,
+      this.chainCodeBytes,
+      this.depth,
+      this.parentFingerprintBytes,
+      this.childNumber
+    );
+  }
+  /** The standard P2PKH address for this key on its network. */
+  address(network = this.network) {
+    return pubKeyHashAddress(hash160(this.compressedPublicKey), network);
+  }
+  /** Serialize to the 78-byte BIP32 form (without the base58check checksum). */
+  serialize() {
+    const version = this.isPrivate ? this.network.hdPrivateKeyId : this.network.hdPublicKeyId;
+    const out = new Uint8Array(SERIALIZED_LENGTH);
+    out[0] = version[0];
+    out[1] = version[1];
+    out[2] = version[2];
+    out[3] = version[3];
+    out[4] = this.depth & 255;
+    out.set(this.parentFingerprintBytes, 5);
+    out.set(ser32(this.childNumber), 9);
+    out.set(this.chainCodeBytes, 13);
+    if (this.isPrivate) {
+      out[45] = 0;
+      out.set(this.privateKey, 46);
+    } else {
+      out.set(this.compressedPublicKey, 45);
+    }
+    return out;
+  }
+  /** Encode as a `dprv`/`dpub` (or per-network) base58check string. */
+  toString() {
+    return checkEncode(this.serialize());
+  }
+  /** Parse an extended key string, validating the checksum and version. */
+  static fromString(str) {
+    if (typeof str !== "string") {
+      throw err(
+        "invalid-argument",
+        "ExtendedKey.fromString",
+        `extended key must be a string, got ${typeName(str)}`
+      );
+    }
+    if (str.length > MAX_EXTENDED_KEY_LENGTH) {
+      throw err(
+        "input-too-long",
+        "ExtendedKey.fromString",
+        `${str.length} characters exceeds the ${MAX_EXTENDED_KEY_LENGTH}-character maximum`
+      );
+    }
+    const data = checkDecode(str);
+    return _ExtendedKey.fromSerialized(data);
+  }
+  /**
+   * Parse a raw 78-byte serialization (checksum already verified/absent).
+   *
+   * Every field is copied out of `data`, so the returned key does not alias the
+   * caller's buffer — which matters most here, because a caller doing the right
+   * thing and wiping the serialization after parsing would otherwise destroy the
+   * key it just parsed. See {@link copyOf}.
+   */
+  static fromSerialized(data) {
+    if (data.length !== SERIALIZED_LENGTH) throw err("bad-length", "ExtendedKey.fromSerialized", `expected ${SERIALIZED_LENGTH} bytes, got ${data.length}`);
+    const version = [data[0], data[1], data[2], data[3]];
+    const depth = data[4];
+    const parentFingerprint = copyOf(data, 5, 4);
+    const childNumber = (data[9] << 24 | data[10] << 16 | data[11] << 8 | data[12]) >>> 0;
+    const chainCode = copyOf(data, 13, 32);
+    const keyData = copyOf(data, 45, 33);
+    const found = matchVersion(version);
+    if (!found) throw err("unknown-version", "ExtendedKey.fromSerialized", `no network has the extended-key version 0x${version.map((b) => b.toString(16).padStart(2, "0")).join("")}`);
+    const { network, isPrivate } = found;
+    if (isPrivate) {
+      if (keyData[0] !== 0) throw err("invalid-private-key", "ExtendedKey.fromSerialized", `a private key must be padded with a leading 0x00, got 0x${keyData[0].toString(16).padStart(2, "0")}`);
+      const priv = copyOf(keyData, 1, 32);
+      if (!isValidPrivateKey(priv)) throw err("invalid-private-key", "ExtendedKey.fromSerialized", "not a valid secp256k1 scalar");
+      return new _ExtendedKey(
+        network,
+        true,
+        priv,
+        publicKeyFromPrivate(priv),
+        chainCode,
+        depth,
+        parentFingerprint,
+        childNumber
+      );
+    }
+    if (keyData[0] !== 2 && keyData[0] !== 3) {
+      throw err("invalid-public-key", "ExtendedKey.fromSerialized", `a compressed public key must start with 0x02 or 0x03, got 0x${keyData[0].toString(16).padStart(2, "0")}`);
+    }
+    if (!isValidPublicKey(keyData)) {
+      throw err("invalid-public-key", "ExtendedKey.fromSerialized", "public key is not a valid curve point");
+    }
+    return new _ExtendedKey(
+      network,
+      false,
+      null,
+      keyData,
+      chainCode,
+      depth,
+      parentFingerprint,
+      childNumber
+    );
+  }
+};
+function matchVersion(v) {
+  for (const network of Object.values(networks)) {
+    if (eq4(v, network.hdPrivateKeyId)) return { network, isPrivate: true };
+    if (eq4(v, network.hdPublicKeyId)) return { network, isPrivate: false };
+  }
+  return null;
+}
+function eq4(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+}
+var englishWordlist = english.wordlist;
+var MNEMONIC_WORD_COUNTS = [12, 15, 18, 21, 24];
+function assertMnemonicString(mnemonic, who) {
+  if (typeof mnemonic !== "string") {
+    throw err("invalid-argument", who, `mnemonic must be a string, got ${typeof mnemonic}`);
+  }
+}
+function assertWordlist(wordlist, who) {
+  if (wordlist.length !== 2048) {
+    throw err("invalid-argument", who, `wordlist must hold 2048 words, got ${wordlist.length}`);
+  }
+}
+function generateMnemonic(strength = 128, wordlist = english.wordlist) {
+  if (!Number.isInteger(strength) || strength < 128 || strength > 256 || strength % 32 !== 0) {
+    throw err(
+      Number.isInteger(strength) ? "out-of-range" : "not-an-integer",
+      "generateMnemonic",
+      `strength must be 128, 160, 192, 224 or 256 bits, got ${shown(strength)}`
+    );
+  }
+  assertWordlist(wordlist, "generateMnemonic");
+  return bip39.generateMnemonic(wordlist, strength);
+}
+function validateMnemonic(mnemonic, wordlist = english.wordlist) {
+  return bip39.validateMnemonic(mnemonic, wordlist);
+}
+function mnemonicToEntropy(mnemonic, wordlist = english.wordlist) {
+  assertMnemonicString(mnemonic, "mnemonicToEntropy");
+  assertWordlist(wordlist, "mnemonicToEntropy");
+  try {
+    return bip39.mnemonicToEntropy(mnemonic, wordlist);
+  } catch {
+    throw err(
+      "invalid-mnemonic",
+      "mnemonicToEntropy",
+      "bad checksum, wrong word count, or a word not in the wordlist \u2014 pass the matching wordlist for a non-English phrase"
+    );
+  }
+}
+function entropyToMnemonic(entropy, wordlist = english.wordlist) {
+  if (entropy.length < 16 || entropy.length > 32 || entropy.length % 4 !== 0) {
+    throw err(
+      "bad-length",
+      "entropyToMnemonic",
+      `entropy must be 16\u201332 bytes and a multiple of 4, got ${entropy.length}`
+    );
+  }
+  assertWordlist(wordlist, "entropyToMnemonic");
+  return bip39.entropyToMnemonic(entropy, wordlist);
+}
+function mnemonicToSeed(mnemonic, passphrase = "") {
+  assertMnemonicString(mnemonic, "mnemonicToSeed");
+  const words = mnemonic.normalize("NFKD").split(" ").length;
+  if (!MNEMONIC_WORD_COUNTS.includes(words)) {
+    throw err(
+      "invalid-mnemonic",
+      "mnemonicToSeed",
+      `a mnemonic is 12, 15, 18, 21 or 24 words, got ${words}`
+    );
+  }
+  return bip39.mnemonicToSeedSync(mnemonic, passphrase);
+}
+function mnemonicToMasterKey(mnemonic, network, passphrase = "", wordlist = english.wordlist) {
+  assertMnemonicString(mnemonic, "mnemonicToMasterKey");
+  assertWordlist(wordlist, "mnemonicToMasterKey");
+  if (!validateMnemonic(mnemonic, wordlist)) {
+    throw err(
+      "invalid-mnemonic",
+      "mnemonicToMasterKey",
+      "bad checksum, or a word not in the wordlist \u2014 pass the matching wordlist for a non-English phrase"
+    );
+  }
+  return ExtendedKey.fromSeed(mnemonicToSeed(mnemonic, passphrase), network);
+}
+
+// src/tx.ts
+var TxSerializeType = /* @__PURE__ */ ((TxSerializeType2) => {
+  TxSerializeType2[TxSerializeType2["Full"] = 0] = "Full";
+  TxSerializeType2[TxSerializeType2["NoWitness"] = 1] = "NoWitness";
+  TxSerializeType2[TxSerializeType2["OnlyWitness"] = 2] = "OnlyWitness";
+  return TxSerializeType2;
+})(TxSerializeType || {});
+var MAX_SERIALIZE_TYPE = 3;
+var TxTree = /* @__PURE__ */ ((TxTree2) => {
+  TxTree2[TxTree2["Regular"] = 0] = "Regular";
+  TxTree2[TxTree2["Stake"] = 1] = "Stake";
+  return TxTree2;
+})(TxTree || {});
+var DEFAULT_TX_VERSION = 1;
+var MAX_SEQUENCE = 4294967295;
+var NULL_VALUE_IN = -1n;
+var NULL_BLOCK_HEIGHT = 0;
+var NULL_BLOCK_INDEX = 4294967295;
+function reverse(bytes) {
+  const out = new Uint8Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) out[i] = bytes[bytes.length - 1 - i];
+  return out;
+}
+function toHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function packVersion(version, serType) {
+  if (!Number.isInteger(version) || version < 0 || version > 65535) {
+    throw err(
+      Number.isInteger(version) ? "out-of-range" : "not-an-integer",
+      "tx.version",
+      `expected an integer in 0..2^16-1, got ${shown(version)}`
+    );
+  }
+  if (!Number.isInteger(serType) || serType < 0 || serType > MAX_SERIALIZE_TYPE) {
+    throw err(
+      Number.isInteger(serType) ? "out-of-range" : "not-an-integer",
+      "tx.serializeType",
+      `expected an integer in 0..${MAX_SERIALIZE_TYPE}, got ${shown(serType)}`
+    );
+  }
+  return (serType << 16 | version) >>> 0;
+}
+var Transaction = class _Transaction {
+  version = DEFAULT_TX_VERSION;
+  inputs = [];
+  outputs = [];
+  lockTime = 0;
+  expiry = 0;
+  /**
+   * Add an input. Witness fields default to the "unsigned/unknown" sentinels.
+   *
+   * The outpoint and signature script are copied, so a caller that reuses or
+   * scrubs its own buffers afterwards cannot silently rewrite this transaction's
+   * bytes — which would change its txid and invalidate every signature already
+   * computed over it, with nothing to detect the change.
+   */
+  addInput(previousOutPoint, opts = {}) {
+    if (previousOutPoint === null || typeof previousOutPoint !== "object") {
+      throw err(
+        "invalid-argument",
+        "tx.addInput",
+        `outpoint must be an object, got ${typeName(previousOutPoint)}`
+      );
+    }
+    if (!isBytes(previousOutPoint.hash)) {
+      throw err(
+        "invalid-argument",
+        "tx.addInput",
+        `outpoint hash must be a Uint8Array, got ${typeName(previousOutPoint.hash)}`
+      );
+    }
+    if (previousOutPoint.hash.length !== 32) {
+      throw err(
+        "bad-length",
+        "tx.addInput",
+        `outpoint hash must be 32 bytes, got ${previousOutPoint.hash.length}`
+      );
+    }
+    if (previousOutPoint.tree !== 0 /* Regular */ && previousOutPoint.tree !== 1 /* Stake */) {
+      throw err(
+        "out-of-range",
+        "tx.addInput",
+        `outpoint tree must be ${0 /* Regular */} (regular) or ${1 /* Stake */} (stake), got ${shown(previousOutPoint.tree)}`
+      );
+    }
+    this.inputs.push({
+      previousOutPoint: {
+        hash: copyOf(previousOutPoint.hash, 0, 32),
+        index: previousOutPoint.index,
+        tree: previousOutPoint.tree
+      },
+      sequence: opts.sequence ?? MAX_SEQUENCE,
+      valueIn: opts.valueIn ?? NULL_VALUE_IN,
+      blockHeight: opts.blockHeight ?? NULL_BLOCK_HEIGHT,
+      blockIndex: opts.blockIndex ?? NULL_BLOCK_INDEX,
+      signatureScript: opts.signatureScript ? copyOf(opts.signatureScript, 0, opts.signatureScript.length) : new Uint8Array(0)
+    });
+    return this;
+  }
+  /** Add an output. The script is copied; see {@link addInput}. */
+  addOutput(value, pkScript, version = 0) {
+    if (!isBytes(pkScript)) {
+      throw err(
+        "invalid-argument",
+        "tx.addOutput",
+        `pkScript must be a Uint8Array, got ${typeName(pkScript)}`
+      );
+    }
+    this.outputs.push({ value, version, pkScript: copyOf(pkScript, 0, pkScript.length) });
+    return this;
+  }
+  writeVersion(w, serType) {
+    w.u32(packVersion(this.version, serType));
+  }
+  writePrefixBody(w) {
+    w.varInt(this.inputs.length);
+    for (const input of this.inputs) {
+      const op = input.previousOutPoint;
+      if (op.hash.length !== 32) throw err("bad-length", "tx", `outpoint hash must be 32 bytes, got ${op.hash.length}`);
+      w.bytes(op.hash).u32(op.index).u8(op.tree).u32(input.sequence);
+    }
+    w.varInt(this.outputs.length);
+    for (const out of this.outputs) {
+      w.i64(out.value).u16(out.version).varBytes(out.pkScript);
+    }
+    w.u32(this.lockTime).u32(this.expiry);
+  }
+  writeWitnessBody(w) {
+    w.varInt(this.inputs.length);
+    for (const input of this.inputs) {
+      w.i64(input.valueIn).u32(input.blockHeight).u32(input.blockIndex).varBytes(input.signatureScript);
+    }
+  }
+  /** Serialize as prefix ‖ witness (the full form). */
+  serialize() {
+    const w = new Writer();
+    this.writeVersion(w, 0 /* Full */);
+    this.writePrefixBody(w);
+    this.writeWitnessBody(w);
+    return w.finish();
+  }
+  /** Serialize the prefix only (no witness). This is what the txid hashes. */
+  serializePrefix() {
+    const w = new Writer();
+    this.writeVersion(w, 1 /* NoWitness */);
+    this.writePrefixBody(w);
+    return w.finish();
+  }
+  /** Serialize the witness only. */
+  serializeWitness() {
+    const w = new Writer();
+    this.writeVersion(w, 2 /* OnlyWitness */);
+    this.writeWitnessBody(w);
+    return w.finish();
+  }
+  /** Raw 32-byte prefix hash (internal byte order). */
+  hash() {
+    return blake256(this.serializePrefix());
+  }
+  /** The transaction id (reversed-hex display form of the prefix hash). */
+  txid() {
+    return toHex(reverse(this.hash()));
+  }
+  /** The witness hash id (display form). */
+  witnessTxid() {
+    return toHex(reverse(blake256(this.serializeWitness())));
+  }
+  /** The full hash id: `blake256(prefixHash ‖ witnessHash)`, display form. */
+  fullTxid() {
+    const concat = new Uint8Array(64);
+    concat.set(blake256(this.serializePrefix()), 0);
+    concat.set(blake256(this.serializeWitness()), 32);
+    return toHex(reverse(blake256(concat)));
+  }
+  /**
+   * Parse a full (prefix ‖ witness) serialization.
+   *
+   * The declared input and output counts are deliberately **not** capped, where
+   * dcrd's `decodePrefix` and `decodeWitness` reject anything above
+   * `maxTxInPerMessage` (780336) or `maxTxOutPerMessage` (3728271) — the counts
+   * that could fit a 32 MiB `MaxMessagePayload`. Those bounds exist because dcrd
+   * decodes from an `io.Reader` of unknown length and sizes `make([]TxIn, count)`
+   * from the count *before* reading an input; here the argument is a `Uint8Array`
+   * whose length is already the bound, and nothing is sized from a count —
+   * `Reader` checks every read against the bytes that remain, so an inflated
+   * count fails at the first short read having allocated nothing. The only
+   * observable difference is that a blob of ~43 MiB or larger declaring more than
+   * 780336 inputs parses here and does not in dcrd; such a transaction is neither
+   * relayable (over `MaxMessagePayload`) nor valid (mainnet `MaxTxSize` is 393216
+   * bytes, 115x smaller). On a *truncated* blob both reject, only with different
+   * errors: dcrd's `ErrTooManyTxs` against this library's `unexpected-end`.
+   *
+   * Cost is still linear in `bytes.length`, so cap the size of untrusted input at
+   * the call site. dcrd's count limits would not help with that: 32 MiB holds
+   * 818400 minimal prefix inputs and the cap is 780336, so a buffer at the wire
+   * maximum stays under it.
+   */
+  static fromBytes(bytes) {
+    const r = new Reader(bytes);
+    const versionWord = r.u32();
+    const serType = versionWord >>> 16;
+    if (serType !== 0 /* Full */) {
+      throw err("invalid-argument", "tx.fromBytes", `expects the full serialization, got serialization type ${serType}`);
+    }
+    const tx = new _Transaction();
+    tx.version = versionWord & 65535;
+    const numIn = r.varInt();
+    const prefixes = [];
+    const sequences = [];
+    for (let i = 0; i < numIn; i++) {
+      const hash = r.bytes(32);
+      const index = r.u32();
+      const tree = r.u8();
+      const sequence = r.u32();
+      prefixes.push({ hash, index, tree });
+      sequences.push(sequence);
+    }
+    const numOut = r.varInt();
+    for (let i = 0; i < numOut; i++) {
+      const value = r.i64();
+      const version = r.u16();
+      const pkScript = r.varBytes();
+      tx.outputs.push({ value, version, pkScript });
+    }
+    tx.lockTime = r.u32();
+    tx.expiry = r.u32();
+    const numWit = r.varInt();
+    if (numWit !== numIn) throw err("bad-length", "tx.fromBytes", `witness declares ${numWit} inputs, prefix declares ${numIn}`);
+    for (let i = 0; i < numIn; i++) {
+      const valueIn = r.i64();
+      const blockHeight = r.u32();
+      const blockIndex = r.u32();
+      const signatureScript2 = r.varBytes();
+      tx.inputs.push({
+        previousOutPoint: prefixes[i],
+        sequence: sequences[i],
+        valueIn,
+        blockHeight,
+        blockIndex,
+        signatureScript: signatureScript2
+      });
+    }
+    if (r.remaining !== 0) throw err("trailing-bytes", "tx.fromBytes", `${r.remaining} byte(s) remain after the transaction`);
+    return tx;
+  }
+};
+function outPointFromTxid(txid, index, tree = 0 /* Regular */) {
+  if (!/^[0-9a-fA-F]{64}$/.test(txid)) {
+    throw err("invalid-argument", "outPointFromTxid", "txid must be 64 hex characters");
+  }
+  const display = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) display[i] = parseInt(txid.slice(i * 2, i * 2 + 2), 16);
+  return { hash: reverse(display), index, tree };
+}
+
+// src/sighash.ts
+var SigHashType = /* @__PURE__ */ ((SigHashType2) => {
+  SigHashType2[SigHashType2["All"] = 1] = "All";
+  SigHashType2[SigHashType2["None"] = 2] = "None";
+  SigHashType2[SigHashType2["Single"] = 3] = "Single";
+  SigHashType2[SigHashType2["AnyOneCanPay"] = 128] = "AnyOneCanPay";
+  return SigHashType2;
+})(SigHashType || {});
+var SIG_HASH_MASK = 31;
+var SIG_HASH_SERIALIZE_PREFIX = 1;
+var SIG_HASH_SERIALIZE_WITNESS = 3;
+function isSignableSigHashType(hashType) {
+  if (!Number.isInteger(hashType) || hashType < 0 || hashType > 255) return false;
+  const masked = hashType & 127;
+  return masked >= 1 /* All */ && masked <= 3 /* Single */;
+}
+function assertSignableSigHashType(hashType) {
+  if (!isSignableSigHashType(hashType)) {
+    const label = Number.isInteger(hashType) ? `0x${Number(hashType).toString(16)}` : shown(hashType);
+    throw err(
+      "invalid-hash-type",
+      "sighash",
+      `hash type ${label} is not one dcrd accepts (All/None/Single, optionally |AnyOneCanPay)`
+    );
+  }
+}
+function sigHashPrefixAll(tx) {
+  return tx.hash();
+}
+function calcSignatureHash(subScript, hashType, tx, idx, cachedPrefix) {
+  if (!Number.isInteger(hashType) || hashType < 0 || hashType > 255) {
+    throw err("invalid-hash-type", "sighash", `hash type must be a byte (0..255), got ${shown(hashType)}`);
+  }
+  if (!Number.isInteger(idx)) {
+    throw err("not-an-integer", "sighash", `input index must be an integer, got ${shown(idx)}`);
+  }
+  const masked = hashType & SIG_HASH_MASK;
+  const anyoneCanPay = (hashType & 128 /* AnyOneCanPay */) !== 0;
+  if (!scriptParses(subScript)) {
+    throw err("malformed-script", "sighash", "subScript does not tokenize (malformed data push)");
+  }
+  if (masked === 3 /* Single */ && idx >= tx.outputs.length) {
+    throw err(
+      "out-of-range",
+      "sighash",
+      `SigHashSingle input ${idx} has no corresponding output`
+    );
+  }
+  if (idx < 0 || idx >= tx.inputs.length) {
+    throw err("out-of-range", "sighash", `input index ${idx} out of range`);
+  }
+  const inputs = anyoneCanPay ? [tx.inputs[idx]] : tx.inputs;
+  const signInIdx = anyoneCanPay ? 0 : idx;
+  const prefixIsInputIndependent = masked === 1 /* All */ && !anyoneCanPay;
+  let prefixHash;
+  if (cachedPrefix !== void 0 && prefixIsInputIndependent) {
+    if (cachedPrefix.length !== 32) {
+      throw err("bad-length", "sighash", `cachedPrefix must be 32 bytes, got ${cachedPrefix.length}`);
+    }
+    prefixHash = cachedPrefix;
+  } else {
+    const pw = new Writer();
+    pw.u32(packVersion(tx.version, SIG_HASH_SERIALIZE_PREFIX));
+    pw.varInt(inputs.length);
+    for (let i = 0; i < inputs.length; i++) {
+      const input = inputs[i];
+      const op = input.previousOutPoint;
+      pw.bytes(op.hash).u32(op.index).u8(op.tree);
+      let sequence = input.sequence;
+      if ((masked === 2 /* None */ || masked === 3 /* Single */) && i !== signInIdx) {
+        sequence = 0;
+      }
+      pw.u32(sequence);
+    }
+    let outputs = tx.outputs;
+    if (masked === 2 /* None */) outputs = [];
+    else if (masked === 3 /* Single */) outputs = tx.outputs.slice(0, idx + 1);
+    pw.varInt(outputs.length);
+    for (let i = 0; i < outputs.length; i++) {
+      const out = outputs[i];
+      if (masked === 3 /* Single */ && i !== idx) {
+        pw.i64(-1n).u16(out.version).varInt(0);
+      } else {
+        pw.i64(out.value).u16(out.version).varBytes(out.pkScript);
+      }
+    }
+    pw.u32(tx.lockTime).u32(tx.expiry);
+    prefixHash = blake256(pw.finish());
+  }
+  const ww = new Writer();
+  ww.u32(packVersion(tx.version, SIG_HASH_SERIALIZE_WITNESS));
+  ww.varInt(inputs.length);
+  for (let i = 0; i < inputs.length; i++) {
+    if (i === signInIdx) ww.varBytes(subScript);
+    else ww.varInt(0);
+  }
+  const witnessHash = blake256(ww.finish());
+  const fw = new Writer();
+  fw.u32(hashType >>> 0).bytes(prefixHash).bytes(witnessHash);
+  return blake256(fw.finish());
+}
+function assertHash32(hash, who) {
+  if (!isBytes(hash)) {
+    throw err("invalid-argument", who, "signature hash must be a Uint8Array");
+  }
+  if (hash.length !== 32) {
+    throw err("bad-length", who, `signature hash must be 32 bytes, got ${hash.length}`);
+  }
+}
+function signHash(hash, privateKey) {
+  assertHash32(hash, "signHash");
+  assertPrivateKey(privateKey, "signHash");
+  const sig = secp256k1.secp256k1.sign(hash, privateKey, { lowS: true });
+  return sig.toDERRawBytes();
+}
+function verifyHash(hash, derSignature, publicKey) {
+  assertHash32(hash, "verifyHash");
+  try {
+    const sig = secp256k1.secp256k1.Signature.fromDER(derSignature);
+    const canonical = sig.toDERRawBytes();
+    if (canonical.length !== derSignature.length) return false;
+    for (let i = 0; i < canonical.length; i++) {
+      if (canonical[i] !== derSignature[i]) return false;
+    }
+    if (sig.hasHighS()) return false;
+    return secp256k1.secp256k1.verify(sig.toCompactRawBytes(), hash, publicKey, { lowS: true });
+  } catch {
+    return false;
+  }
+}
+function rawTxInSignature(tx, idx, subScript, hashType, privateKey, cachedPrefix) {
+  assertSignableSigHashType(hashType);
+  const hash = calcSignatureHash(subScript, hashType, tx, idx, cachedPrefix);
+  const der = signHash(hash, privateKey);
+  const out = new Uint8Array(der.length + 1);
+  out.set(der);
+  out[der.length] = hashType & 255;
+  return out;
+}
+function signatureScript(tx, idx, subScript, hashType, privateKey, compressed = true, cachedPrefix) {
+  const rawSig = rawTxInSignature(tx, idx, subScript, hashType, privateKey, cachedPrefix);
+  const pubKey = publicKeyFromPrivate(privateKey, compressed);
+  const a = pushData(rawSig);
+  const b = pushData(pubKey);
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
+function signP2PKHInput(tx, idx, subScript, privateKey, hashType = 1 /* All */, compressed = true) {
+  tx.inputs[idx].signatureScript = signatureScript(
+    tx,
+    idx,
+    subScript,
+    hashType,
+    privateKey,
+    compressed
+  );
+  return tx;
+}
+function signP2PKHInputs(tx, toSign, hashType = 1 /* All */) {
+  assertSignableSigHashType(hashType);
+  const cachedPrefix = sigHashPrefixAll(tx);
+  for (const { idx, subScript, privateKey, compressed = true } of toSign) {
+    tx.inputs[idx].signatureScript = signatureScript(
+      tx,
+      idx,
+      subScript,
+      hashType,
+      privateKey,
+      compressed,
+      cachedPrefix
+    );
+  }
+  return tx;
+}
+
+// src/amount.ts
+var ATOMS_PER_COIN = 100000000n;
+var COIN_DECIMALS = 8;
+function dcrToAtoms(dcr) {
+  const s = dcr.trim();
+  if (!/^-?\d+(\.\d+)?$/.test(s)) throw err("invalid-amount", "dcrToAtoms", `cannot parse ${shown(dcr)}`);
+  const negative = s.startsWith("-");
+  const body = negative ? s.slice(1) : s;
+  const [intPart = "0", fracPart = ""] = body.split(".");
+  if (fracPart.length > COIN_DECIMALS) {
+    throw err("invalid-amount", "dcrToAtoms", `more than ${COIN_DECIMALS} decimal places`);
+  }
+  const frac = (fracPart + "00000000").slice(0, COIN_DECIMALS);
+  const atoms = BigInt(intPart) * ATOMS_PER_COIN + BigInt(frac);
+  return negative ? -atoms : atoms;
+}
+function atomsToDcr(atoms) {
+  const negative = atoms < 0n;
+  const a = negative ? -atoms : atoms;
+  const intPart = a / ATOMS_PER_COIN;
+  const frac = (a % ATOMS_PER_COIN).toString().padStart(COIN_DECIMALS, "0");
+  return `${negative ? "-" : ""}${intPart.toString()}.${frac}`;
+}
+
+exports.ATOMS_PER_COIN = ATOMS_PER_COIN;
+exports.BLAKE256_BLOCK_LENGTH = BLAKE256_BLOCK_LENGTH;
+exports.BLAKE256_DIGEST_LENGTH = BLAKE256_DIGEST_LENGTH;
+exports.Blake256 = Blake256;
+exports.COIN_DECIMALS = COIN_DECIMALS;
+exports.CURVE_ORDER = CURVE_ORDER;
+exports.DEFAULT_TX_VERSION = DEFAULT_TX_VERSION;
+exports.DcrError = DcrError;
+exports.ExtendedKey = ExtendedKey;
+exports.HARDENED_OFFSET = HARDENED_OFFSET;
+exports.MAX_ADDRESS_LENGTH = MAX_ADDRESS_LENGTH;
+exports.MAX_EXTENDED_KEY_LENGTH = MAX_EXTENDED_KEY_LENGTH;
+exports.MAX_SCRIPT_ELEMENT_SIZE = MAX_SCRIPT_ELEMENT_SIZE;
+exports.MAX_SEQUENCE = MAX_SEQUENCE;
+exports.MAX_WIF_LENGTH = MAX_WIF_LENGTH;
+exports.NULL_BLOCK_HEIGHT = NULL_BLOCK_HEIGHT;
+exports.NULL_BLOCK_INDEX = NULL_BLOCK_INDEX;
+exports.NULL_VALUE_IN = NULL_VALUE_IN;
+exports.OP = OP;
+exports.Reader = Reader;
+exports.SigHashType = SigHashType;
+exports.SignatureType = SignatureType;
+exports.Transaction = Transaction;
+exports.TxSerializeType = TxSerializeType;
+exports.TxTree = TxTree;
+exports.Writer = Writer;
+exports.addressFromPubKey = addressFromPubKey;
+exports.addressFromScript = addressFromScript;
+exports.addressToScript = addressToScript;
+exports.assertCompressedPubKey = assertCompressedPubKey;
+exports.assertPrivateKey = assertPrivateKey;
+exports.assertPubKey = assertPubKey;
+exports.assertSignableSigHashType = assertSignableSigHashType;
+exports.atomsToDcr = atomsToDcr;
+exports.base58Decode = base58Decode;
+exports.base58Encode = base58Encode;
+exports.blake256 = blake256;
+exports.calcSignatureHash = calcSignatureHash;
+exports.checkDecode = checkDecode;
+exports.checkEncode = checkEncode;
+exports.classifyScript = classifyScript;
+exports.copyOf = copyOf;
+exports.dcrToAtoms = dcrToAtoms;
+exports.decodeAddress = decodeAddress;
+exports.decodeWif = decodeWif;
+exports.encodeWif = encodeWif;
+exports.englishWordlist = englishWordlist;
+exports.entropyToMnemonic = entropyToMnemonic;
+exports.extractHash160 = extractHash160;
+exports.generateMnemonic = generateMnemonic;
+exports.hardened = hardened;
+exports.hasErrorCode = hasErrorCode;
+exports.hash160 = hash160;
+exports.hash256 = hash256;
+exports.isDcrError = isDcrError;
+exports.isPayToPubKeyHash = isPayToPubKeyHash;
+exports.isPayToScriptHash = isPayToScriptHash;
+exports.isSignableSigHashType = isSignableSigHashType;
+exports.isValidAddress = isValidAddress;
+exports.isValidEd25519PublicKey = isValidEd25519PublicKey;
+exports.isValidPrivateKey = isValidPrivateKey;
+exports.isValidPublicKey = isValidPublicKey;
+exports.mainnet = mainnet;
+exports.maxBase58Length = maxBase58Length;
+exports.mnemonicToEntropy = mnemonicToEntropy;
+exports.mnemonicToMasterKey = mnemonicToMasterKey;
+exports.mnemonicToSeed = mnemonicToSeed;
+exports.networks = networks;
+exports.outPointFromTxid = outPointFromTxid;
+exports.payToPubKeyAltScript = payToPubKeyAltScript;
+exports.payToPubKeyHashAltScript = payToPubKeyHashAltScript;
+exports.payToPubKeyHashScript = payToPubKeyHashScript;
+exports.payToPubKeyScript = payToPubKeyScript;
+exports.payToScriptHashScript = payToScriptHashScript;
+exports.pubKeyAddress = pubKeyAddress;
+exports.pubKeyEd25519Address = pubKeyEd25519Address;
+exports.pubKeyHashAddress = pubKeyHashAddress;
+exports.pubKeyHashEd25519Address = pubKeyHashEd25519Address;
+exports.pubKeyHashSchnorrAddress = pubKeyHashSchnorrAddress;
+exports.pubKeySchnorrAddress = pubKeySchnorrAddress;
+exports.publicKeyFromPrivate = publicKeyFromPrivate;
+exports.pushData = pushData;
+exports.rawTxInSignature = rawTxInSignature;
+exports.regnet = regnet;
+exports.scriptHashAddress = scriptHashAddress;
+exports.scriptParses = scriptParses;
+exports.sigHashPrefixAll = sigHashPrefixAll;
+exports.signHash = signHash;
+exports.signP2PKHInput = signP2PKHInput;
+exports.signP2PKHInputs = signP2PKHInputs;
+exports.signatureScript = signatureScript;
+exports.simnet = simnet;
+exports.testnet3 = testnet3;
+exports.validateMnemonic = validateMnemonic;
+exports.verifyHash = verifyHash;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map