utxo-descriptors 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1287 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/chains.ts
+var BITCOIN = {
+  name: "bitcoin",
+  bech32Hrp: "bc",
+  base58PubKeyHash: 0,
+  base58ScriptHash: 5
+};
+var BITCOIN_TESTNET = {
+  name: "bitcoin-testnet",
+  bech32Hrp: "tb",
+  base58PubKeyHash: 111,
+  base58ScriptHash: 196
+};
+var LITECOIN = {
+  name: "litecoin",
+  bech32Hrp: "ltc",
+  base58PubKeyHash: 48,
+  base58ScriptHash: 50
+};
+var LITECOIN_TESTNET = {
+  name: "litecoin-testnet",
+  bech32Hrp: "tltc",
+  base58PubKeyHash: 111,
+  base58ScriptHash: 58
+};
+
+// src/checksum.ts
+var INPUT_CHARSET = "0123456789()[],'/*abcdefgh@:$%{}IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";
+var CHECKSUM_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var GENERATOR = [0xf5dee51989n, 0xa9fdca3312n, 0x1bab10e32dn, 0x3706b1677an, 0x644d626ffdn];
+var CHECKSUM_LENGTH = 8;
+var GROUP_SIZE = 3;
+var GROUP_BITS = 5;
+var GROUP_MASK = 0x7ffffffffn;
+var TOP_SHIFT = 35n;
+var SYMBOL_MASK = 31;
+function polymod(symbols) {
+  let checksum = 1n;
+  for (const symbol of symbols) {
+    const top = checksum >> TOP_SHIFT;
+    checksum = (checksum & GROUP_MASK) << 5n ^ BigInt(symbol);
+    for (let bit = 0; bit < GENERATOR.length; bit += 1) {
+      const generatorValue = GENERATOR[bit];
+      if (generatorValue !== void 0 && (top >> BigInt(bit) & 1n) === 1n) {
+        checksum ^= generatorValue;
+      }
+    }
+  }
+  return checksum;
+}
+function expand(text) {
+  const symbols = [];
+  let groupAccumulator = 0;
+  let groupCount = 0;
+  for (const char of text) {
+    const value = INPUT_CHARSET.indexOf(char);
+    if (value === -1) {
+      return void 0;
+    }
+    symbols.push(value & SYMBOL_MASK);
+    groupAccumulator = groupAccumulator * GROUP_SIZE + (value >> GROUP_BITS);
+    groupCount += 1;
+    if (groupCount === GROUP_SIZE) {
+      symbols.push(groupAccumulator);
+      groupAccumulator = 0;
+      groupCount = 0;
+    }
+  }
+  if (groupCount > 0) {
+    symbols.push(groupAccumulator);
+  }
+  return symbols;
+}
+function checksumCreate(script) {
+  const symbols = expand(script);
+  if (symbols === void 0) {
+    return void 0;
+  }
+  const checksum = polymod([...symbols, 0, 0, 0, 0, 0, 0, 0, 0]) ^ 1n;
+  let result = "";
+  for (let index = 0; index < CHECKSUM_LENGTH; index += 1) {
+    const shift = BigInt(GROUP_BITS * (CHECKSUM_LENGTH - 1 - index));
+    const symbolIndex = Number(checksum >> shift & BigInt(SYMBOL_MASK));
+    result += CHECKSUM_CHARSET[symbolIndex];
+  }
+  return result;
+}
+function checksumVerify(script, checksum) {
+  if (checksum.length !== CHECKSUM_LENGTH) {
+    return false;
+  }
+  const scriptSymbols = expand(script);
+  if (scriptSymbols === void 0) {
+    return false;
+  }
+  const checksumSymbols = [];
+  for (const char of checksum) {
+    const value = CHECKSUM_CHARSET.indexOf(char);
+    if (value === -1) {
+      return false;
+    }
+    checksumSymbols.push(value);
+  }
+  return polymod([...scriptSymbols, ...checksumSymbols]) === 1n;
+}
+function hasValidCharset(text) {
+  return expand(text) !== void 0;
+}
+
+// src/base58.ts
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE = 58n;
+var BYTE_MAX_PLUS_ONE = 256n;
+var CHAR_TO_VALUE = new Map(
+  ALPHABET.split("").map((char, index) => [char, BigInt(index)])
+);
+function base58Decode(text) {
+  if (text.length === 0) {
+    return void 0;
+  }
+  let value = 0n;
+  for (const char of text) {
+    const digit = CHAR_TO_VALUE.get(char);
+    if (digit === void 0) {
+      return void 0;
+    }
+    value = value * BASE + digit;
+  }
+  const bytes = [];
+  while (value > 0n) {
+    bytes.unshift(Number(value % BYTE_MAX_PLUS_ONE));
+    value /= BYTE_MAX_PLUS_ONE;
+  }
+  for (const char of text) {
+    if (char !== "1") {
+      break;
+    }
+    bytes.unshift(0);
+  }
+  return Uint8Array.from(bytes);
+}
+
+// src/key-expression.ts
+var MAX_INDEX = 2147483647;
+var FINGERPRINT_PATTERN = /^[0-9a-fA-F]{8}$/;
+var STEP_PATTERN = /^([0-9]+)(h|')?$/;
+var EXTENDED_KEY_BYTES = 82;
+var WIF_UNCOMPRESSED_BYTES = 37;
+var WIF_COMPRESSED_BYTES = 38;
+var XPUB_VERSIONS = {
+  xpub: 76067358,
+  xprv: 76066276,
+  tpub: 70617039,
+  tprv: 70615956
+};
+function fail(message) {
+  return { ok: false, message };
+}
+function parseStep(segment) {
+  const match = STEP_PATTERN.exec(segment);
+  if (match === null) {
+    return void 0;
+  }
+  const [, digits, marker] = match;
+  const index = Number(digits);
+  if (!Number.isSafeInteger(index) || index > MAX_INDEX) {
+    return void 0;
+  }
+  return { index, hardened: marker !== void 0 };
+}
+function parseOrigin(bracketed) {
+  const segments = bracketed.split("/");
+  const [fingerprint, ...pathSegments] = segments;
+  if (fingerprint === void 0 || !FINGERPRINT_PATTERN.test(fingerprint)) {
+    return void 0;
+  }
+  const path = [];
+  for (const segment of pathSegments) {
+    const step = parseStep(segment);
+    if (step === void 0) {
+      return void 0;
+    }
+    path.push(step);
+  }
+  return { fingerprint: fingerprint.toLowerCase(), path };
+}
+function splitOrigin(text) {
+  if (!text.startsWith("[")) {
+    return { remainder: text };
+  }
+  const closeIndex = text.indexOf("]");
+  if (closeIndex === -1) {
+    return fail("unterminated key origin: missing ']'");
+  }
+  const origin = parseOrigin(text.slice(1, closeIndex));
+  if (origin === void 0) {
+    return fail(
+      "invalid key origin: expected an 8-character hex fingerprint and /NUM or /NUMh steps"
+    );
+  }
+  const remainder = text.slice(closeIndex + 1);
+  if (remainder.startsWith("[")) {
+    return fail("a key expression may only carry one key origin");
+  }
+  if (remainder.length === 0) {
+    return fail("key origin is not followed by a key");
+  }
+  return { origin, remainder };
+}
+function parseTrailingPath(text) {
+  if (text.length === 0) {
+    return { path: [], isRanged: false };
+  }
+  const segments = text.slice(1).split("/");
+  const path = [];
+  for (const [index, segment] of segments.entries()) {
+    const isLast = index === segments.length - 1;
+    if (isLast && /^\*(h|')?$/.test(segment)) {
+      return { path, isRanged: true };
+    }
+    if (segment.startsWith("<") && segment.endsWith(">")) {
+      const values = segment.slice(1, -1).split(";").map((part) => parseStep(part));
+      if (values.length < 2 || values.some((value) => value === void 0)) {
+        return void 0;
+      }
+      const resolved = values;
+      const seen = /* @__PURE__ */ new Set();
+      for (const value of resolved) {
+        const key = `${String(value.index)}:${String(value.hardened)}`;
+        if (seen.has(key)) {
+          return void 0;
+        }
+        seen.add(key);
+      }
+      path.push({ kind: "multipath", values: resolved });
+      continue;
+    }
+    const step = parseStep(segment);
+    if (step === void 0) {
+      return void 0;
+    }
+    path.push({ kind: "step", ...step });
+  }
+  return { path, isRanged: false };
+}
+function classifyKeyMaterial(keyBody) {
+  if (/^(02|03)[0-9a-fA-F]{64}$/.test(keyBody)) {
+    return "hex-compressed";
+  }
+  if (/^04[0-9a-fA-F]{128}$/.test(keyBody)) {
+    return "hex-uncompressed";
+  }
+  if (/^[0-9a-fA-F]{64}$/.test(keyBody)) {
+    return "hex-xonly";
+  }
+  const extendedPrefix = keyBody.slice(0, 4);
+  if (extendedPrefix in XPUB_VERSIONS) {
+    const decoded2 = base58Decode(keyBody);
+    const expectedVersion = XPUB_VERSIONS[extendedPrefix];
+    if (decoded2?.length === EXTENDED_KEY_BYTES && expectedVersion !== void 0) {
+      const version = decoded2[0] << 24 | decoded2[1] << 16 | decoded2[2] << 8 | decoded2[3];
+      if (version >>> 0 === expectedVersion >>> 0) {
+        return extendedPrefix === "xprv" || extendedPrefix === "tprv" ? "xprv" : "xpub";
+      }
+    }
+    return void 0;
+  }
+  const decoded = base58Decode(keyBody);
+  if (decoded?.length === WIF_COMPRESSED_BYTES) {
+    return "wif-compressed";
+  }
+  if (decoded?.length === WIF_UNCOMPRESSED_BYTES) {
+    return "wif-uncompressed";
+  }
+  return void 0;
+}
+function parseKeyExpression(raw, options) {
+  const split = splitOrigin(raw);
+  if ("ok" in split) {
+    return split;
+  }
+  const { origin, remainder } = split;
+  const slashIndex = remainder.indexOf("/");
+  const keyBody = slashIndex === -1 ? remainder : remainder.slice(0, slashIndex);
+  const trailingText = slashIndex === -1 ? "" : remainder.slice(slashIndex);
+  const kind = classifyKeyMaterial(keyBody);
+  if (kind === void 0) {
+    return fail(`unrecognized key material: ${keyBody}`);
+  }
+  if (kind === "hex-xonly" && !options.allowXOnly) {
+    return fail("bare x-only (64 hex character) keys are only valid inside tr()");
+  }
+  if (kind !== "xpub" && kind !== "xprv" && trailingText.length > 0) {
+    return fail("a derivation path is only allowed after an extended (xpub/xprv) key");
+  }
+  const trailing = parseTrailingPath(trailingText);
+  if (trailing === void 0) {
+    return fail(`invalid derivation path: ${trailingText}`);
+  }
+  const key = {
+    raw,
+    kind,
+    ...origin !== void 0 ? { origin } : {},
+    path: trailing.path,
+    isRanged: trailing.isRanged
+  };
+  return { ok: true, key };
+}
+
+// src/traverse.ts
+function forEachKey(node, visit) {
+  switch (node.kind) {
+    case "pk":
+    case "pkh":
+    case "wpkh":
+    case "combo":
+      visit(node.key);
+      break;
+    case "sh":
+    case "wsh":
+      forEachKey(node.inner, visit);
+      break;
+    case "multi":
+      node.keys.forEach(visit);
+      break;
+    case "raw":
+    case "addr":
+      break;
+    case "tr":
+      visit(node.internalKey);
+      if (node.tree !== void 0) {
+        forEachKeyInTree(node.tree, visit);
+      }
+      break;
+  }
+}
+function forEachKeyInTree(tree, visit) {
+  if (tree.kind === "leaf") {
+    visit(tree.script.key);
+    return;
+  }
+  forEachKeyInTree(tree.left, visit);
+  forEachKeyInTree(tree.right, visit);
+}
+function anyKeyRanged(node) {
+  let ranged = false;
+  forEachKey(node, (key) => {
+    if (key.isRanged) {
+      ranged = true;
+    }
+  });
+  return ranged;
+}
+function collectTapLeaves(tree, depth = 0) {
+  if (tree.kind === "leaf") {
+    return [{ key: tree.script.key, depth }];
+  }
+  return [...collectTapLeaves(tree.left, depth + 1), ...collectTapLeaves(tree.right, depth + 1)];
+}
+
+// src/multipath.ts
+function mapKeys(node, fn) {
+  switch (node.kind) {
+    case "pk":
+    case "pkh":
+    case "wpkh":
+    case "combo":
+      return { ...node, key: fn(node.key) };
+    case "sh":
+    case "wsh":
+      return { ...node, inner: mapKeys(node.inner, fn) };
+    case "multi":
+      return { ...node, keys: node.keys.map(fn) };
+    case "tr":
+      return {
+        ...node,
+        internalKey: fn(node.internalKey),
+        ...node.tree !== void 0 ? { tree: mapTapTree(node.tree, fn) } : {}
+      };
+  }
+}
+function mapTapTree(tree, fn) {
+  if (tree.kind === "leaf") {
+    const leaf = { kind: "pk", key: fn(tree.script.key) };
+    return { kind: "leaf", script: leaf };
+  }
+  return { kind: "branch", left: mapTapTree(tree.left, fn), right: mapTapTree(tree.right, fn) };
+}
+function replaceMultipathAt(key, index) {
+  const elementIndex = key.path.findIndex((element) => element.kind === "multipath");
+  if (elementIndex === -1) {
+    return key;
+  }
+  const path = key.path.map((element, position) => {
+    if (position !== elementIndex || element.kind !== "multipath") {
+      return element;
+    }
+    const value = element.values[index];
+    return { kind: "step", ...value };
+  });
+  return { ...key, path };
+}
+function expandMultipath(script) {
+  const lengths = /* @__PURE__ */ new Set();
+  forEachKey(script, (key) => {
+    for (const element of key.path) {
+      if (element.kind === "multipath") {
+        lengths.add(element.values.length);
+      }
+    }
+  });
+  if (lengths.size === 0) {
+    return { ok: true, descriptors: [script] };
+  }
+  if (lengths.size > 1) {
+    return {
+      ok: false,
+      message: "every multipath element in a descriptor must have the same number of values"
+    };
+  }
+  const [length] = [...lengths];
+  const descriptors = [];
+  for (let index = 0; index < length; index += 1) {
+    descriptors.push(mapKeys(script, (key) => replaceMultipathAt(key, index)));
+  }
+  return { ok: true, descriptors };
+}
+
+// src/tokenizer.ts
+var STRUCTURAL = {
+  "(": "lparen",
+  ")": "rparen",
+  ",": "comma",
+  "{": "lbrace",
+  "}": "rbrace"
+};
+function tokenize(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const structuralKind = STRUCTURAL[char];
+    if (structuralKind !== void 0) {
+      tokens.push({ kind: structuralKind, text: char, position: index });
+      index += 1;
+      continue;
+    }
+    const start = index;
+    let atom = "";
+    while (index < text.length && STRUCTURAL[text[index]] === void 0) {
+      const atomChar = text[index];
+      if (!hasValidCharset(atomChar)) {
+        return { ok: false, position: index };
+      }
+      atom += atomChar;
+      index += 1;
+    }
+    tokens.push({ kind: "atom", text: atom, position: start });
+  }
+  return { ok: true, tokens };
+}
+
+// src/parse.ts
+var CHECKSUM_LENGTH2 = 8;
+var HEX_PAIR = 2;
+function keyLimit(context) {
+  if (context.place === "top") {
+    return 3;
+  }
+  if (context.place === "sh") {
+    return 15;
+  }
+  return 20;
+}
+function requireCompressed(context) {
+  return context.place === "wsh";
+}
+function isCompressedCapable(key) {
+  return key.kind === "hex-compressed" || key.kind === "wif-compressed" || key.kind === "xpub" || key.kind === "xprv";
+}
+var Cursor = class {
+  constructor(tokens) {
+    __publicField(this, "tokens", tokens);
+    __publicField(this, "position", 0);
+  }
+  peek() {
+    return this.tokens[this.position];
+  }
+  advance() {
+    const token = this.tokens[this.position];
+    this.position += 1;
+    return token;
+  }
+  atEnd() {
+    return this.position >= this.tokens.length;
+  }
+};
+function fail2(reason, message, position) {
+  return { ok: false, reason, message, ...position !== void 0 ? { position } : {} };
+}
+function expectKind(cursor, kind, what) {
+  const token = cursor.advance();
+  if (token === void 0) {
+    return fail2("unexpected-token", `expected ${what} but reached the end of the descriptor`);
+  }
+  if (token.kind !== kind) {
+    return fail2("unexpected-token", `expected ${what}`, token.position);
+  }
+  return { ok: true, token };
+}
+function isFailure(value) {
+  return !value.ok;
+}
+function parseKey(cursor, allowXOnly) {
+  const token = cursor.advance();
+  if (token === void 0) {
+    return fail2(
+      "unexpected-token",
+      "expected a key expression but reached the end of the descriptor"
+    );
+  }
+  if (token.kind !== "atom") {
+    return fail2("unexpected-token", "expected a key expression", token.position);
+  }
+  const result = parseKeyExpression(token.text, { allowXOnly });
+  if (!result.ok) {
+    return fail2("invalid-key-expression", result.message, token.position);
+  }
+  return { ok: true, key: result.key };
+}
+function parseNumber(cursor) {
+  const token = cursor.advance();
+  if (token === void 0) {
+    return fail2("unexpected-token", "expected a number but reached the end of the descriptor");
+  }
+  if (token.kind !== "atom" || !/^[0-9]+$/.test(token.text) || !Number.isSafeInteger(Number(token.text))) {
+    return fail2("unexpected-token", "expected a number", token.position);
+  }
+  return { ok: true, value: Number(token.text) };
+}
+function parseSingleKeyNode(cursor, kind, context, position) {
+  const keyResult = parseKey(cursor, false);
+  if (isFailure(keyResult)) {
+    return keyResult;
+  }
+  if ((kind === "wpkh" || requireCompressed(context)) && !isCompressedCapable(keyResult.key)) {
+    return fail2("invalid-key-expression", `${kind}() requires a compressed key`, position);
+  }
+  const closeResult = expectKind(cursor, "rparen", `')' to close ${kind}(...)`);
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  return { ok: true, node: { kind, key: keyResult.key } };
+}
+function parseMultiNode(cursor, sorted, context, position) {
+  const thresholdResult = parseNumber(cursor);
+  if (isFailure(thresholdResult)) {
+    return thresholdResult;
+  }
+  const keys = [];
+  for (; ; ) {
+    const comma = expectKind(cursor, "comma", "',' before a key in multi(...)");
+    if (isFailure(comma)) {
+      return comma;
+    }
+    const keyResult = parseKey(cursor, false);
+    if (isFailure(keyResult)) {
+      return keyResult;
+    }
+    if (requireCompressed(context) && !isCompressedCapable(keyResult.key)) {
+      return fail2("invalid-key-expression", "keys inside wsh() must be compressed", position);
+    }
+    keys.push(keyResult.key);
+    if (cursor.peek()?.kind !== "comma") {
+      break;
+    }
+  }
+  const closeResult = expectKind(cursor, "rparen", "')' to close multi(...)");
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  const limit = keyLimit(context);
+  if (keys.length > limit) {
+    return fail2(
+      "key-count-exceeded",
+      `at most ${String(limit)} keys are allowed in this context`,
+      position
+    );
+  }
+  if (thresholdResult.value < 1 || thresholdResult.value > keys.length) {
+    return fail2("invalid-context", "threshold must be between 1 and the number of keys", position);
+  }
+  return { ok: true, node: { kind: "multi", threshold: thresholdResult.value, keys, sorted } };
+}
+function parseTapLeaf(cursor) {
+  const nameToken = cursor.advance();
+  if (nameToken === void 0) {
+    return fail2(
+      "unexpected-token",
+      "expected a tapscript leaf but reached the end of the descriptor"
+    );
+  }
+  if (nameToken.kind !== "atom" || nameToken.text !== "pk") {
+    return fail2(
+      "unsupported",
+      "tapscript leaves are limited to pk(KEY) in this version; other miniscript fragments are not yet supported",
+      nameToken.position
+    );
+  }
+  const lparen = expectKind(cursor, "lparen", "'(' after pk");
+  if (isFailure(lparen)) {
+    return lparen;
+  }
+  const keyResult = parseKey(cursor, true);
+  if (isFailure(keyResult)) {
+    return keyResult;
+  }
+  const closeResult = expectKind(cursor, "rparen", "')' to close pk(...)");
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  const leaf = { kind: "pk", key: keyResult.key };
+  return { ok: true, tree: { kind: "leaf", script: leaf } };
+}
+function parseTapTree(cursor) {
+  if (cursor.peek()?.kind === "lbrace") {
+    cursor.advance();
+    const leftResult = parseTapTree(cursor);
+    if (isFailure(leftResult)) {
+      return leftResult;
+    }
+    const comma = expectKind(cursor, "comma", "',' inside a tapscript tree branch");
+    if (isFailure(comma)) {
+      return comma;
+    }
+    const rightResult = parseTapTree(cursor);
+    if (isFailure(rightResult)) {
+      return rightResult;
+    }
+    const closeResult = expectKind(cursor, "rbrace", "'}' to close a tapscript tree branch");
+    if (isFailure(closeResult)) {
+      return closeResult;
+    }
+    return { ok: true, tree: { kind: "branch", left: leftResult.tree, right: rightResult.tree } };
+  }
+  return parseTapLeaf(cursor);
+}
+function parseTr(cursor) {
+  const keyResult = parseKey(cursor, true);
+  if (isFailure(keyResult)) {
+    return keyResult;
+  }
+  if (cursor.peek()?.kind === "rparen") {
+    cursor.advance();
+    return { ok: true, node: { kind: "tr", internalKey: keyResult.key } };
+  }
+  const comma = expectKind(cursor, "comma", "',' before the tapscript tree in tr(...)");
+  if (isFailure(comma)) {
+    return comma;
+  }
+  const treeResult = parseTapTree(cursor);
+  if (isFailure(treeResult)) {
+    return treeResult;
+  }
+  const closeResult = expectKind(cursor, "rparen", "')' to close tr(...)");
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  return { ok: true, node: { kind: "tr", internalKey: keyResult.key, tree: treeResult.tree } };
+}
+function parseRaw(cursor, position) {
+  const token = cursor.advance();
+  if (token === void 0) {
+    return fail2("unexpected-token", "expected hex data in raw(...)", position);
+  }
+  if (token.kind !== "atom" || !/^[0-9a-fA-F]+$/.test(token.text) || token.text.length % HEX_PAIR !== 0) {
+    return fail2("invalid-context", "raw() requires an even-length hex string", token.position);
+  }
+  const closeResult = expectKind(cursor, "rparen", "')' to close raw(...)");
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  return { ok: true, node: { kind: "raw", hex: token.text.toLowerCase() } };
+}
+function parseAddr(cursor, position) {
+  const token = cursor.advance();
+  if (token?.kind !== "atom") {
+    return fail2("unexpected-token", "expected an address in addr(...)", position);
+  }
+  const closeResult = expectKind(cursor, "rparen", "')' to close addr(...)");
+  if (isFailure(closeResult)) {
+    return closeResult;
+  }
+  return { ok: true, node: { kind: "addr", address: token.text } };
+}
+function parseScript(cursor, context) {
+  const nameToken = cursor.advance();
+  if (nameToken === void 0) {
+    return fail2(
+      "unexpected-token",
+      "expected a script expression but reached the end of the descriptor"
+    );
+  }
+  if (nameToken.kind !== "atom") {
+    return fail2("unexpected-token", "expected a function name", nameToken.position);
+  }
+  const name = nameToken.text;
+  const position = nameToken.position;
+  const lparen = expectKind(cursor, "lparen", `'(' after ${name}`);
+  if (isFailure(lparen)) {
+    return lparen;
+  }
+  switch (name) {
+    case "pk":
+    case "pkh":
+      return parseSingleKeyNode(cursor, name, context, position);
+    case "wpkh": {
+      if (context.place === "wsh") {
+        return fail2("invalid-context", "wpkh() is not allowed inside wsh()", position);
+      }
+      return parseSingleKeyNode(cursor, "wpkh", context, position);
+    }
+    case "sh": {
+      if (context.place !== "top") {
+        return fail2("invalid-context", "sh() is only allowed at the top level", position);
+      }
+      const innerResult = parseScript(cursor, { place: "sh" });
+      if (isFailure(innerResult)) {
+        return innerResult;
+      }
+      const closeResult = expectKind(cursor, "rparen", "')' to close sh(...)");
+      if (isFailure(closeResult)) {
+        return closeResult;
+      }
+      return { ok: true, node: { kind: "sh", inner: innerResult.node } };
+    }
+    case "wsh": {
+      if (context.place === "wsh") {
+        return fail2("invalid-context", "wsh() cannot be nested inside wsh()", position);
+      }
+      const innerResult = parseScript(cursor, { place: "wsh" });
+      if (isFailure(innerResult)) {
+        return innerResult;
+      }
+      const closeResult = expectKind(cursor, "rparen", "')' to close wsh(...)");
+      if (isFailure(closeResult)) {
+        return closeResult;
+      }
+      return { ok: true, node: { kind: "wsh", inner: innerResult.node } };
+    }
+    case "multi":
+    case "sortedmulti":
+      return parseMultiNode(cursor, name === "sortedmulti", context, position);
+    case "combo": {
+      if (context.place !== "top") {
+        return fail2("invalid-context", "combo() is only allowed at the top level", position);
+      }
+      const keyResult = parseKey(cursor, false);
+      if (isFailure(keyResult)) {
+        return keyResult;
+      }
+      const closeResult = expectKind(cursor, "rparen", "')' to close combo(...)");
+      if (isFailure(closeResult)) {
+        return closeResult;
+      }
+      return { ok: true, node: { kind: "combo", key: keyResult.key } };
+    }
+    case "raw": {
+      if (context.place !== "top") {
+        return fail2("invalid-context", "raw() is only allowed at the top level", position);
+      }
+      return parseRaw(cursor, position);
+    }
+    case "addr": {
+      if (context.place !== "top") {
+        return fail2("invalid-context", "addr() is only allowed at the top level", position);
+      }
+      return parseAddr(cursor, position);
+    }
+    case "tr": {
+      if (context.place !== "top") {
+        return fail2("invalid-context", "tr() is only allowed at the top level", position);
+      }
+      return parseTr(cursor);
+    }
+    case "musig":
+      return fail2("unsupported", "musig() (BIP-390) is not implemented", position);
+    case "sp":
+      return fail2("unsupported", "sp() (BIP-392, silent payments) is not implemented", position);
+    default:
+      return fail2("unknown-function", `unknown script expression: ${name}`, position);
+  }
+}
+function parseDescriptor(text) {
+  const hashIndex = text.indexOf("#");
+  const scriptText = hashIndex === -1 ? text : text.slice(0, hashIndex);
+  const tokenizeResult = tokenize(scriptText);
+  if (!tokenizeResult.ok) {
+    return fail2(
+      "invalid-character",
+      "the descriptor contains a character outside the allowed charset",
+      tokenizeResult.position
+    );
+  }
+  if (hashIndex !== -1) {
+    const checksumText = text.slice(hashIndex + 1);
+    if (checksumText.length !== CHECKSUM_LENGTH2 || !checksumVerify(scriptText, checksumText)) {
+      return fail2("invalid-checksum", "the descriptor checksum does not match its script");
+    }
+  }
+  const cursor = new Cursor(tokenizeResult.tokens);
+  const scriptResult = parseScript(cursor, { place: "top" });
+  if (isFailure(scriptResult)) {
+    return scriptResult;
+  }
+  if (!cursor.atEnd()) {
+    return fail2(
+      "unexpected-token",
+      "unexpected trailing content after the descriptor",
+      cursor.peek()?.position
+    );
+  }
+  const descriptor = {
+    script: scriptResult.node,
+    ...hashIndex !== -1 ? { checksum: text.slice(hashIndex + 1) } : {},
+    isRanged: anyKeyRanged(scriptResult.node)
+  };
+  return { ok: true, descriptor };
+}
+
+// src/bech32.ts
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_CONST = 1;
+var BECH32M_CONST = 734539939;
+var GENERATOR2 = [996825010, 642813549, 513874426, 1027748829, 705979059];
+var CHECKSUM_LENGTH3 = 6;
+var MIN_HRP_LENGTH = 1;
+function polymod2(values) {
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >>> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let bit = 0; bit < GENERATOR2.length; bit += 1) {
+      const generatorValue = GENERATOR2[bit];
+      if (generatorValue !== void 0 && (top >>> bit & 1) === 1) {
+        checksum ^= generatorValue;
+      }
+    }
+  }
+  return checksum >>> 0;
+}
+function hrpExpand(hrp) {
+  const high = [];
+  const low = [];
+  for (const char of hrp) {
+    const code = char.codePointAt(0);
+    high.push(code >> 5);
+    low.push(code & 31);
+  }
+  return [...high, 0, ...low];
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let accumulator = 0;
+  let bits = 0;
+  const result = [];
+  const maxValue = (1 << toBits) - 1;
+  for (const value of data) {
+    if (value < 0 || value >>> fromBits !== 0) {
+      return void 0;
+    }
+    accumulator = accumulator << fromBits | value;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      result.push(accumulator >>> bits & maxValue);
+    }
+  }
+  if (bits >= fromBits || (accumulator << toBits - bits & maxValue) !== 0) {
+    return void 0;
+  }
+  return result;
+}
+function bech32Decode(address) {
+  if (address !== address.toLowerCase() && address !== address.toUpperCase()) {
+    return void 0;
+  }
+  const lowered = address.toLowerCase();
+  const separatorIndex = lowered.lastIndexOf("1");
+  if (separatorIndex < MIN_HRP_LENGTH || lowered.length - separatorIndex - 1 < CHECKSUM_LENGTH3) {
+    return void 0;
+  }
+  const hrp = lowered.slice(0, separatorIndex);
+  const dataPart = lowered.slice(separatorIndex + 1);
+  const values = [];
+  for (const char of dataPart) {
+    const value = CHARSET.indexOf(char);
+    if (value === -1) {
+      return void 0;
+    }
+    values.push(value);
+  }
+  const checksum = polymod2([...hrpExpand(hrp), ...values]);
+  if (checksum !== BECH32_CONST && checksum !== BECH32M_CONST) {
+    return void 0;
+  }
+  const words = values.slice(0, values.length - CHECKSUM_LENGTH3);
+  const [witnessVersion, ...programWords] = words;
+  if (witnessVersion === void 0) {
+    return void 0;
+  }
+  const isBech32m = checksum === BECH32M_CONST;
+  if (witnessVersion === 0 === isBech32m) {
+    return void 0;
+  }
+  const program = convertBits(programWords, 5, 8);
+  if (program === void 0 || program.length < 2 || program.length > 40) {
+    return void 0;
+  }
+  return { hrp, witnessVersion, program: Uint8Array.from(program) };
+}
+
+// src/weights.ts
+var ECDSA_SINGLE_SIG_BYTES = 72;
+var ECDSA_MULTISIG_SIG_BYTES = 73;
+var SCHNORR_KEYPATH_SIG_BYTES = 64;
+var SCHNORR_SCRIPTPATH_SIG_BYTES = 65;
+var COMPRESSED_PUBKEY_BYTES = 33;
+var UNCOMPRESSED_PUBKEY_BYTES = 65;
+var XONLY_PUBKEY_BYTES = 32;
+var P2PKH_SCRIPT_BYTES = 25;
+var P2WPKH_SCRIPT_BYTES = 22;
+var P2SH_SCRIPT_BYTES = 23;
+var P2WSH_SCRIPT_BYTES = 34;
+var P2TR_SCRIPT_BYTES = 34;
+var BASE58_ADDRESS_BYTES = 25;
+var LEGACY_TX_OVERHEAD_BYTES = 40;
+var VOUT_OVERHEAD_BYTES = 8;
+var WEIGHT_SCALE = 4;
+var PUSHDATA_OP_MAX = 76;
+var PUSHDATA_UINT8_MAX = 255;
+var PUSHDATA_UINT16_MAX = 65535;
+var COMPACT_SIZE_UINT16_MIN = 253;
+var COMPACT_SIZE_UINT16_MAX = 65535;
+var COMPACT_SIZE_UINT32_MAX = 4294967295;
+function weightFail(reason, message) {
+  return { ok: false, reason, message };
+}
+function compactSizeBytes(value) {
+  if (value < COMPACT_SIZE_UINT16_MIN) {
+    return 1;
+  }
+  if (value <= COMPACT_SIZE_UINT16_MAX) {
+    return 3;
+  }
+  if (value <= COMPACT_SIZE_UINT32_MAX) {
+    return 5;
+  }
+  return 9;
+}
+function pushDataPrefixBytes(length) {
+  if (length < PUSHDATA_OP_MAX) {
+    return 1;
+  }
+  if (length <= PUSHDATA_UINT8_MAX) {
+    return 2;
+  }
+  if (length <= PUSHDATA_UINT16_MAX) {
+    return 3;
+  }
+  return 5;
+}
+function keyMaterialBytes(kind) {
+  switch (kind) {
+    case "hex-compressed":
+    case "wif-compressed":
+    case "xpub":
+    case "xprv":
+      return COMPRESSED_PUBKEY_BYTES;
+    case "hex-uncompressed":
+    case "wif-uncompressed":
+      return UNCOMPRESSED_PUBKEY_BYTES;
+    case "hex-xonly":
+      return XONLY_PUBKEY_BYTES;
+  }
+}
+function simpleOutputScriptBytes(node) {
+  switch (node.kind) {
+    case "pk":
+      return keyMaterialBytes(node.key.kind) + 2;
+    case "pkh":
+      return P2PKH_SCRIPT_BYTES;
+    case "wpkh":
+      return P2WPKH_SCRIPT_BYTES;
+    case "sh":
+      return P2SH_SCRIPT_BYTES;
+    case "wsh":
+      return P2WSH_SCRIPT_BYTES;
+    case "tr":
+      return P2TR_SCRIPT_BYTES;
+    case "multi": {
+      const perKey = node.keys.reduce((sum, key) => {
+        const bytes = keyMaterialBytes(key.kind);
+        return sum + pushDataPrefixBytes(bytes) + bytes;
+      }, 0);
+      return 1 + perKey + 2;
+    }
+  }
+}
+function leafInputCost(node) {
+  switch (node.kind) {
+    case "pk": {
+      const scriptSig = pushDataPrefixBytes(ECDSA_SINGLE_SIG_BYTES) + ECDSA_SINGLE_SIG_BYTES;
+      return { scriptSig, witness: 0 };
+    }
+    case "pkh": {
+      const keyBytes = keyMaterialBytes(node.key.kind);
+      const scriptSig = pushDataPrefixBytes(ECDSA_SINGLE_SIG_BYTES) + ECDSA_SINGLE_SIG_BYTES + pushDataPrefixBytes(keyBytes) + keyBytes;
+      return { scriptSig, witness: 0 };
+    }
+    case "wpkh": {
+      const keyBytes = keyMaterialBytes(node.key.kind);
+      const items = 2;
+      const witness = compactSizeBytes(items) + compactSizeBytes(ECDSA_SINGLE_SIG_BYTES) + ECDSA_SINGLE_SIG_BYTES + compactSizeBytes(keyBytes) + keyBytes;
+      return { scriptSig: 0, witness };
+    }
+    case "multi": {
+      const sigCost = pushDataPrefixBytes(ECDSA_MULTISIG_SIG_BYTES) + ECDSA_MULTISIG_SIG_BYTES;
+      return { scriptSig: 1 + node.threshold * sigCost, witness: 0 };
+    }
+  }
+}
+function segwitWitnessBytes(node) {
+  switch (node.kind) {
+    case "pk": {
+      const scriptBytes = simpleOutputScriptBytes(node);
+      const items = 2;
+      return compactSizeBytes(items) + compactSizeBytes(ECDSA_SINGLE_SIG_BYTES) + ECDSA_SINGLE_SIG_BYTES + compactSizeBytes(scriptBytes) + scriptBytes;
+    }
+    case "pkh": {
+      const keyBytes = keyMaterialBytes(node.key.kind);
+      const items = 3;
+      return compactSizeBytes(items) + compactSizeBytes(ECDSA_SINGLE_SIG_BYTES) + ECDSA_SINGLE_SIG_BYTES + compactSizeBytes(keyBytes) + keyBytes + compactSizeBytes(P2PKH_SCRIPT_BYTES) + P2PKH_SCRIPT_BYTES;
+    }
+    case "multi": {
+      const scriptBytes = simpleOutputScriptBytes(node);
+      const sigCost = compactSizeBytes(ECDSA_MULTISIG_SIG_BYTES) + ECDSA_MULTISIG_SIG_BYTES;
+      const items = node.threshold + 2;
+      return compactSizeBytes(items) + compactSizeBytes(0) + node.threshold * sigCost + compactSizeBytes(scriptBytes) + scriptBytes;
+    }
+  }
+}
+function computeTrCost(node) {
+  const keyPathWitness = compactSizeBytes(1) + compactSizeBytes(SCHNORR_KEYPATH_SIG_BYTES) + SCHNORR_KEYPATH_SIG_BYTES;
+  if (node.tree === void 0) {
+    return { scriptSig: 0, witness: keyPathWitness };
+  }
+  const leafWitnesses = collectTapLeaves(node.tree).map(({ depth }) => {
+    const leafScriptBytes = 1 + XONLY_PUBKEY_BYTES + 1;
+    const controlBlockBytes = 1 + XONLY_PUBKEY_BYTES + XONLY_PUBKEY_BYTES * depth;
+    const items = 3;
+    return compactSizeBytes(items) + compactSizeBytes(SCHNORR_SCRIPTPATH_SIG_BYTES) + SCHNORR_SCRIPTPATH_SIG_BYTES + compactSizeBytes(leafScriptBytes) + leafScriptBytes + compactSizeBytes(controlBlockBytes) + controlBlockBytes;
+  });
+  return { scriptSig: 0, witness: Math.max(keyPathWitness, ...leafWitnesses) };
+}
+function computeInputCost(node) {
+  switch (node.kind) {
+    case "pk":
+    case "pkh":
+    case "wpkh":
+    case "multi":
+      return { ok: true, ...leafInputCost(node) };
+    case "sh": {
+      const { inner } = node;
+      if (inner.kind === "wpkh") {
+        const redeemBytes = simpleOutputScriptBytes(inner);
+        return {
+          ok: true,
+          scriptSig: pushDataPrefixBytes(redeemBytes) + redeemBytes,
+          witness: leafInputCost(inner).witness
+        };
+      }
+      if (inner.kind === "wsh") {
+        const { inner: innerInner } = inner;
+        if (innerInner.kind !== "pk" && innerInner.kind !== "pkh" && innerInner.kind !== "multi") {
+          return weightFail(
+            "unsupported",
+            `sh(wsh(${innerInner.kind}(...))) is not a supported nesting`
+          );
+        }
+        const redeemBytes = P2WSH_SCRIPT_BYTES;
+        return {
+          ok: true,
+          scriptSig: pushDataPrefixBytes(redeemBytes) + redeemBytes,
+          witness: segwitWitnessBytes(innerInner)
+        };
+      }
+      if (inner.kind === "pk" || inner.kind === "pkh" || inner.kind === "multi") {
+        const redeemBytes = simpleOutputScriptBytes(inner);
+        return {
+          ok: true,
+          scriptSig: leafInputCost(inner).scriptSig + pushDataPrefixBytes(redeemBytes) + redeemBytes,
+          witness: 0
+        };
+      }
+      return weightFail("unsupported", `sh(${inner.kind}(...)) is not a supported nesting`);
+    }
+    case "wsh": {
+      const { inner } = node;
+      if (inner.kind === "pk" || inner.kind === "pkh" || inner.kind === "multi") {
+        return { ok: true, scriptSig: 0, witness: segwitWitnessBytes(inner) };
+      }
+      return weightFail("unsupported", `wsh(${inner.kind}(...)) is not a supported nesting`);
+    }
+    case "tr":
+      return { ok: true, ...computeTrCost(node) };
+    case "combo":
+      return weightFail(
+        "ambiguous-script-type",
+        "combo() represents multiple candidate script types; describe the specific script you intend to spend instead"
+      );
+    case "raw":
+      return weightFail(
+        "opaque-script",
+        "raw() has no known spending script, so its input weight cannot be determined"
+      );
+    case "addr":
+      return weightFail(
+        "opaque-script",
+        "addr() has no known spending script, so its input weight cannot be determined"
+      );
+  }
+}
+function decodeAddressScriptBytes(address, chain) {
+  const segwit = bech32Decode(address);
+  if (segwit !== void 0) {
+    return { ok: true, value: 2 + segwit.program.length };
+  }
+  const decoded = base58Decode(address);
+  if (decoded?.length === BASE58_ADDRESS_BYTES) {
+    const version = decoded[0];
+    if (version === chain.base58PubKeyHash) {
+      return { ok: true, value: P2PKH_SCRIPT_BYTES };
+    }
+    if (version === chain.base58ScriptHash) {
+      return { ok: true, value: P2SH_SCRIPT_BYTES };
+    }
+  }
+  return weightFail("unsupported", `unrecognized address for chain '${chain.name}': ${address}`);
+}
+function computeOutputScriptBytes(node, options) {
+  switch (node.kind) {
+    case "pk":
+    case "pkh":
+    case "wpkh":
+    case "sh":
+    case "wsh":
+    case "tr":
+    case "multi":
+      return { ok: true, value: simpleOutputScriptBytes(node) };
+    case "combo":
+      return weightFail(
+        "ambiguous-script-type",
+        "combo() represents multiple candidate scriptPubKeys; describe the specific script you intend to create instead"
+      );
+    case "raw":
+      if (node.hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(node.hex)) {
+        return weightFail("unsupported", "raw() requires an even-length hex string");
+      }
+      return { ok: true, value: node.hex.length / 2 };
+    case "addr":
+      return decodeAddressScriptBytes(node.address, options.chain ?? BITCOIN);
+  }
+}
+function inputWeight(node) {
+  const cost = computeInputCost(node);
+  if (!cost.ok) {
+    return cost;
+  }
+  const baseBytes = LEGACY_TX_OVERHEAD_BYTES + compactSizeBytes(cost.scriptSig) + cost.scriptSig;
+  return { ok: true, weight: baseBytes * WEIGHT_SCALE + cost.witness };
+}
+function outputWeight(node, options = {}) {
+  const scriptBytesResult = computeOutputScriptBytes(node, options);
+  if (!scriptBytesResult.ok) {
+    return scriptBytesResult;
+  }
+  const weight = (VOUT_OVERHEAD_BYTES + compactSizeBytes(scriptBytesResult.value) + scriptBytesResult.value) * WEIGHT_SCALE;
+  return { ok: true, weight };
+}
+function describeInput(node) {
+  const cost = computeInputCost(node);
+  if (!cost.ok) {
+    return cost;
+  }
+  if (node.kind === "pk") {
+    return { ok: true, description: "p2pk" };
+  }
+  if (node.kind === "pkh") {
+    return { ok: true, description: "p2pkh" };
+  }
+  if (node.kind === "wpkh") {
+    return { ok: true, description: "p2wpkh" };
+  }
+  if (node.kind === "tr" && node.tree === void 0) {
+    return { ok: true, description: "p2tr" };
+  }
+  if (node.kind === "sh" && node.inner.kind === "wpkh") {
+    return { ok: true, description: "p2sh-p2wpkh" };
+  }
+  if (node.kind === "sh" && node.inner.kind === "multi") {
+    return {
+      ok: true,
+      description: { type: "p2sh-multisig", m: node.inner.threshold, n: node.inner.keys.length }
+    };
+  }
+  if (node.kind === "wsh" && node.inner.kind === "multi") {
+    return {
+      ok: true,
+      description: { type: "p2wsh-multisig", m: node.inner.threshold, n: node.inner.keys.length }
+    };
+  }
+  if (node.kind === "sh" && node.inner.kind === "wsh" && node.inner.inner.kind === "multi") {
+    return {
+      ok: true,
+      description: {
+        type: "p2sh-p2wsh-multisig",
+        m: node.inner.inner.threshold,
+        n: node.inner.inner.keys.length
+      }
+    };
+  }
+  return {
+    ok: true,
+    description: { type: "raw", scriptSigBytes: cost.scriptSig, witnessBytes: cost.witness }
+  };
+}
+function describeOutput(node, options = {}) {
+  const scriptBytesResult = computeOutputScriptBytes(node, options);
+  if (!scriptBytesResult.ok) {
+    return scriptBytesResult;
+  }
+  const resolvedNode = node;
+  switch (resolvedNode.kind) {
+    case "pk":
+      return { ok: true, description: "p2pk" };
+    case "pkh":
+      return { ok: true, description: "p2pkh" };
+    case "wpkh":
+      return { ok: true, description: "p2wpkh" };
+    case "sh":
+      return { ok: true, description: "p2sh" };
+    case "wsh":
+      return { ok: true, description: "p2wsh" };
+    case "tr":
+      return { ok: true, description: "p2tr" };
+    case "multi":
+    case "raw":
+    case "addr":
+      return { ok: true, description: { type: "raw", scriptPubKeyBytes: scriptBytesResult.value } };
+  }
+}
+
+exports.BITCOIN = BITCOIN;
+exports.BITCOIN_TESTNET = BITCOIN_TESTNET;
+exports.LITECOIN = LITECOIN;
+exports.LITECOIN_TESTNET = LITECOIN_TESTNET;
+exports.anyKeyRanged = anyKeyRanged;
+exports.checksumCreate = checksumCreate;
+exports.checksumVerify = checksumVerify;
+exports.collectTapLeaves = collectTapLeaves;
+exports.describeInput = describeInput;
+exports.describeOutput = describeOutput;
+exports.expandMultipath = expandMultipath;
+exports.forEachKey = forEachKey;
+exports.hasValidCharset = hasValidCharset;
+exports.inputWeight = inputWeight;
+exports.outputWeight = outputWeight;
+exports.parseDescriptor = parseDescriptor;
+exports.parseKeyExpression = parseKeyExpression;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map