utxo-descriptors 0.1.0

package/dist/parse.cjs

@@ -0,0 +1,725 @@
+'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/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 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/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/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;
+}
+
+// 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 };
+}
+
+exports.parseDescriptor = parseDescriptor;
+//# sourceMappingURL=parse.cjs.map
+//# sourceMappingURL=parse.cjs.map