@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/prefix-config.type-BP_PoMwo.js

@@ -0,0 +1,2391 @@
+import { r as ripemd160$1 } from './legacy-2kU1YJKP.js';
+import { s as sha256 } from './sha256-BFiHgz55.js';
+import './index-DiZOBxXK.js';
+import { e as writeUInt16$1, w as writeUInt32$1, g as writeUInt64, h as readUInt16$1, r as readUInt32$1, i as readUInt64 } from './browser-D9H9snNo.js';
+
+/**
+ * Represents the Bitcoin network configuration.
+ */
+const bitcoin = {
+  /**
+   * The message prefix used for signing Bitcoin messages.
+   */
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  /**
+   * The Bech32 prefix used for Bitcoin addresses.
+   */
+  bech32: 'bc',
+  /**
+   * The BIP32 key prefixes for Bitcoin.
+   */
+  bip32: {
+    /**
+     * The public key prefix for BIP32 extended public keys.
+     */
+    public: 0x0488b21e,
+    /**
+     * The private key prefix for BIP32 extended private keys.
+     */
+    private: 0x0488ade4,
+  },
+  /**
+   * The prefix for Bitcoin public key hashes.
+   */
+  pubKeyHash: 0x00,
+  /**
+   * The prefix for Bitcoin script hashes.
+   */
+  scriptHash: 0x05,
+  /**
+   * The prefix for Bitcoin Wallet Import Format (WIF) private keys.
+   */
+  wif: 0x80,
+};
+/**
+ * Represents the regtest network configuration.
+ */
+const regtest = {
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'bcrt',
+  bip32: {
+    public: 0x043587cf,
+    private: 0x04358394,
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+/**
+ * Represents the testnet network configuration.
+ */
+const testnet = {
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'tb',
+  bip32: {
+    public: 0x043587cf,
+    private: 0x04358394,
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+
+// Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
+// Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+// NOTE: SIGHASH byte ignored AND restricted, truncate before use
+/**
+ * Checks if the given buffer is a valid BIP66-encoded signature.
+ *
+ * @param buffer - The buffer to check.
+ * @returns A boolean indicating whether the buffer is a valid BIP66-encoded signature.
+ */
+function check(buffer) {
+  if (buffer.length < 8) return false;
+  if (buffer.length > 72) return false;
+  if (buffer[0] !== 0x30) return false;
+  if (buffer[1] !== buffer.length - 2) return false;
+  if (buffer[2] !== 0x02) return false;
+  const lenR = buffer[3];
+  if (lenR === 0) return false;
+  if (5 + lenR >= buffer.length) return false;
+  if (buffer[4 + lenR] !== 0x02) return false;
+  const lenS = buffer[5 + lenR];
+  if (lenS === 0) return false;
+  if (6 + lenR + lenS !== buffer.length) return false;
+  if (buffer[4] & 0x80) return false;
+  if (lenR > 1 && buffer[4] === 0x00 && !(buffer[5] & 0x80)) return false;
+  if (buffer[lenR + 6] & 0x80) return false;
+  if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
+    return false;
+  return true;
+}
+
+// Define OPS enum
+var OPS$1;
+(function (OPS) {
+  OPS[(OPS['OP_FALSE'] = 0)] = 'OP_FALSE';
+  OPS[(OPS['OP_0'] = 0)] = 'OP_0';
+  OPS[(OPS['OP_PUSHDATA1'] = 76)] = 'OP_PUSHDATA1';
+  OPS[(OPS['OP_PUSHDATA2'] = 77)] = 'OP_PUSHDATA2';
+  OPS[(OPS['OP_PUSHDATA4'] = 78)] = 'OP_PUSHDATA4';
+  OPS[(OPS['OP_1NEGATE'] = 79)] = 'OP_1NEGATE';
+  OPS[(OPS['OP_RESERVED'] = 80)] = 'OP_RESERVED';
+  OPS[(OPS['OP_TRUE'] = 81)] = 'OP_TRUE';
+  OPS[(OPS['OP_1'] = 81)] = 'OP_1';
+  OPS[(OPS['OP_2'] = 82)] = 'OP_2';
+  OPS[(OPS['OP_3'] = 83)] = 'OP_3';
+  OPS[(OPS['OP_4'] = 84)] = 'OP_4';
+  OPS[(OPS['OP_5'] = 85)] = 'OP_5';
+  OPS[(OPS['OP_6'] = 86)] = 'OP_6';
+  OPS[(OPS['OP_7'] = 87)] = 'OP_7';
+  OPS[(OPS['OP_8'] = 88)] = 'OP_8';
+  OPS[(OPS['OP_9'] = 89)] = 'OP_9';
+  OPS[(OPS['OP_10'] = 90)] = 'OP_10';
+  OPS[(OPS['OP_11'] = 91)] = 'OP_11';
+  OPS[(OPS['OP_12'] = 92)] = 'OP_12';
+  OPS[(OPS['OP_13'] = 93)] = 'OP_13';
+  OPS[(OPS['OP_14'] = 94)] = 'OP_14';
+  OPS[(OPS['OP_15'] = 95)] = 'OP_15';
+  OPS[(OPS['OP_16'] = 96)] = 'OP_16';
+  OPS[(OPS['OP_NOP'] = 97)] = 'OP_NOP';
+  OPS[(OPS['OP_VER'] = 98)] = 'OP_VER';
+  OPS[(OPS['OP_IF'] = 99)] = 'OP_IF';
+  OPS[(OPS['OP_NOTIF'] = 100)] = 'OP_NOTIF';
+  OPS[(OPS['OP_VERIF'] = 101)] = 'OP_VERIF';
+  OPS[(OPS['OP_VERNOTIF'] = 102)] = 'OP_VERNOTIF';
+  OPS[(OPS['OP_ELSE'] = 103)] = 'OP_ELSE';
+  OPS[(OPS['OP_ENDIF'] = 104)] = 'OP_ENDIF';
+  OPS[(OPS['OP_VERIFY'] = 105)] = 'OP_VERIFY';
+  OPS[(OPS['OP_RETURN'] = 106)] = 'OP_RETURN';
+  OPS[(OPS['OP_TOALTSTACK'] = 107)] = 'OP_TOALTSTACK';
+  OPS[(OPS['OP_FROMALTSTACK'] = 108)] = 'OP_FROMALTSTACK';
+  OPS[(OPS['OP_2DROP'] = 109)] = 'OP_2DROP';
+  OPS[(OPS['OP_2DUP'] = 110)] = 'OP_2DUP';
+  OPS[(OPS['OP_3DUP'] = 111)] = 'OP_3DUP';
+  OPS[(OPS['OP_2OVER'] = 112)] = 'OP_2OVER';
+  OPS[(OPS['OP_2ROT'] = 113)] = 'OP_2ROT';
+  OPS[(OPS['OP_2SWAP'] = 114)] = 'OP_2SWAP';
+  OPS[(OPS['OP_IFDUP'] = 115)] = 'OP_IFDUP';
+  OPS[(OPS['OP_DEPTH'] = 116)] = 'OP_DEPTH';
+  OPS[(OPS['OP_DROP'] = 117)] = 'OP_DROP';
+  OPS[(OPS['OP_DUP'] = 118)] = 'OP_DUP';
+  OPS[(OPS['OP_NIP'] = 119)] = 'OP_NIP';
+  OPS[(OPS['OP_OVER'] = 120)] = 'OP_OVER';
+  OPS[(OPS['OP_PICK'] = 121)] = 'OP_PICK';
+  OPS[(OPS['OP_ROLL'] = 122)] = 'OP_ROLL';
+  OPS[(OPS['OP_ROT'] = 123)] = 'OP_ROT';
+  OPS[(OPS['OP_SWAP'] = 124)] = 'OP_SWAP';
+  OPS[(OPS['OP_TUCK'] = 125)] = 'OP_TUCK';
+  OPS[(OPS['OP_CAT'] = 126)] = 'OP_CAT';
+  OPS[(OPS['OP_SUBSTR'] = 127)] = 'OP_SUBSTR';
+  OPS[(OPS['OP_LEFT'] = 128)] = 'OP_LEFT';
+  OPS[(OPS['OP_RIGHT'] = 129)] = 'OP_RIGHT';
+  OPS[(OPS['OP_SIZE'] = 130)] = 'OP_SIZE';
+  OPS[(OPS['OP_INVERT'] = 131)] = 'OP_INVERT';
+  OPS[(OPS['OP_AND'] = 132)] = 'OP_AND';
+  OPS[(OPS['OP_OR'] = 133)] = 'OP_OR';
+  OPS[(OPS['OP_XOR'] = 134)] = 'OP_XOR';
+  OPS[(OPS['OP_EQUAL'] = 135)] = 'OP_EQUAL';
+  OPS[(OPS['OP_EQUALVERIFY'] = 136)] = 'OP_EQUALVERIFY';
+  OPS[(OPS['OP_RESERVED1'] = 137)] = 'OP_RESERVED1';
+  OPS[(OPS['OP_RESERVED2'] = 138)] = 'OP_RESERVED2';
+  OPS[(OPS['OP_1ADD'] = 139)] = 'OP_1ADD';
+  OPS[(OPS['OP_1SUB'] = 140)] = 'OP_1SUB';
+  OPS[(OPS['OP_2MUL'] = 141)] = 'OP_2MUL';
+  OPS[(OPS['OP_2DIV'] = 142)] = 'OP_2DIV';
+  OPS[(OPS['OP_NEGATE'] = 143)] = 'OP_NEGATE';
+  OPS[(OPS['OP_ABS'] = 144)] = 'OP_ABS';
+  OPS[(OPS['OP_NOT'] = 145)] = 'OP_NOT';
+  OPS[(OPS['OP_0NOTEQUAL'] = 146)] = 'OP_0NOTEQUAL';
+  OPS[(OPS['OP_ADD'] = 147)] = 'OP_ADD';
+  OPS[(OPS['OP_SUB'] = 148)] = 'OP_SUB';
+  OPS[(OPS['OP_MUL'] = 149)] = 'OP_MUL';
+  OPS[(OPS['OP_DIV'] = 150)] = 'OP_DIV';
+  OPS[(OPS['OP_MOD'] = 151)] = 'OP_MOD';
+  OPS[(OPS['OP_LSHIFT'] = 152)] = 'OP_LSHIFT';
+  OPS[(OPS['OP_RSHIFT'] = 153)] = 'OP_RSHIFT';
+  OPS[(OPS['OP_BOOLAND'] = 154)] = 'OP_BOOLAND';
+  OPS[(OPS['OP_BOOLOR'] = 155)] = 'OP_BOOLOR';
+  OPS[(OPS['OP_NUMEQUAL'] = 156)] = 'OP_NUMEQUAL';
+  OPS[(OPS['OP_NUMEQUALVERIFY'] = 157)] = 'OP_NUMEQUALVERIFY';
+  OPS[(OPS['OP_NUMNOTEQUAL'] = 158)] = 'OP_NUMNOTEQUAL';
+  OPS[(OPS['OP_LESSTHAN'] = 159)] = 'OP_LESSTHAN';
+  OPS[(OPS['OP_GREATERTHAN'] = 160)] = 'OP_GREATERTHAN';
+  OPS[(OPS['OP_LESSTHANOREQUAL'] = 161)] = 'OP_LESSTHANOREQUAL';
+  OPS[(OPS['OP_GREATERTHANOREQUAL'] = 162)] = 'OP_GREATERTHANOREQUAL';
+  OPS[(OPS['OP_MIN'] = 163)] = 'OP_MIN';
+  OPS[(OPS['OP_MAX'] = 164)] = 'OP_MAX';
+  OPS[(OPS['OP_WITHIN'] = 165)] = 'OP_WITHIN';
+  OPS[(OPS['OP_RIPEMD160'] = 166)] = 'OP_RIPEMD160';
+  OPS[(OPS['OP_SHA1'] = 167)] = 'OP_SHA1';
+  OPS[(OPS['OP_SHA256'] = 168)] = 'OP_SHA256';
+  OPS[(OPS['OP_HASH160'] = 169)] = 'OP_HASH160';
+  OPS[(OPS['OP_HASH256'] = 170)] = 'OP_HASH256';
+  OPS[(OPS['OP_CODESEPARATOR'] = 171)] = 'OP_CODESEPARATOR';
+  OPS[(OPS['OP_CHECKSIG'] = 172)] = 'OP_CHECKSIG';
+  OPS[(OPS['OP_CHECKSIGVERIFY'] = 173)] = 'OP_CHECKSIGVERIFY';
+  OPS[(OPS['OP_CHECKMULTISIG'] = 174)] = 'OP_CHECKMULTISIG';
+  OPS[(OPS['OP_CHECKMULTISIGVERIFY'] = 175)] = 'OP_CHECKMULTISIGVERIFY';
+  OPS[(OPS['OP_NOP1'] = 176)] = 'OP_NOP1';
+  OPS[(OPS['OP_CHECKLOCKTIMEVERIFY'] = 177)] = 'OP_CHECKLOCKTIMEVERIFY';
+  OPS[(OPS['OP_NOP2'] = 177)] = 'OP_NOP2';
+  OPS[(OPS['OP_CHECKSEQUENCEVERIFY'] = 178)] = 'OP_CHECKSEQUENCEVERIFY';
+  OPS[(OPS['OP_NOP3'] = 178)] = 'OP_NOP3';
+  OPS[(OPS['OP_NOP4'] = 179)] = 'OP_NOP4';
+  OPS[(OPS['OP_NOP5'] = 180)] = 'OP_NOP5';
+  OPS[(OPS['OP_NOP6'] = 181)] = 'OP_NOP6';
+  OPS[(OPS['OP_NOP7'] = 182)] = 'OP_NOP7';
+  OPS[(OPS['OP_NOP8'] = 183)] = 'OP_NOP8';
+  OPS[(OPS['OP_NOP9'] = 184)] = 'OP_NOP9';
+  OPS[(OPS['OP_NOP10'] = 185)] = 'OP_NOP10';
+  OPS[(OPS['OP_CHECKSIGADD'] = 186)] = 'OP_CHECKSIGADD';
+  OPS[(OPS['OP_PUBKEYHASH'] = 253)] = 'OP_PUBKEYHASH';
+  OPS[(OPS['OP_PUBKEY'] = 254)] = 'OP_PUBKEY';
+  OPS[(OPS['OP_INVALIDOPCODE'] = 255)] = 'OP_INVALIDOPCODE';
+})(OPS$1 || (OPS$1 = {}));
+
+const HEX_STRINGS = "0123456789abcdefABCDEF";
+const HEX_CODES = HEX_STRINGS.split("").map((c) => c.codePointAt(0));
+const HEX_CODEPOINTS = Array(256)
+    .fill(true)
+    .map((_, i) => {
+    const s = String.fromCodePoint(i);
+    const index = HEX_STRINGS.indexOf(s);
+    // ABCDEF will use 10 - 15
+    return index < 0 ? undefined : index < 16 ? index : index - 6;
+});
+const ENCODER = new TextEncoder();
+const DECODER = new TextDecoder();
+function concat(arrays) {
+    const totalLength = arrays.reduce((a, b) => a + b.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+// There are two implementations.
+// One optimizes for length of the bytes, and uses TextDecoder.
+// One optimizes for iteration count, and appends strings.
+// This removes the overhead of TextDecoder.
+function toHex(bytes) {
+    const b = bytes || new Uint8Array();
+    return b.length > 512 ? _toHexLengthPerf(b) : _toHexIterPerf(b);
+}
+function _toHexIterPerf(bytes) {
+    let s = "";
+    for (let i = 0; i < bytes.length; ++i) {
+        s += HEX_STRINGS[HEX_CODEPOINTS[HEX_CODES[bytes[i] >> 4]]];
+        s += HEX_STRINGS[HEX_CODEPOINTS[HEX_CODES[bytes[i] & 15]]];
+    }
+    return s;
+}
+function _toHexLengthPerf(bytes) {
+    const hexBytes = new Uint8Array(bytes.length * 2);
+    for (let i = 0; i < bytes.length; ++i) {
+        hexBytes[i * 2] = HEX_CODES[bytes[i] >> 4];
+        hexBytes[i * 2 + 1] = HEX_CODES[bytes[i] & 15];
+    }
+    return DECODER.decode(hexBytes);
+}
+// Mimics Buffer.from(x, 'hex') logic
+// Stops on first non-hex string and returns
+// https://github.com/nodejs/node/blob/v14.18.1/src/string_bytes.cc#L246-L261
+function fromHex(hexString) {
+    const hexBytes = ENCODER.encode(hexString || "");
+    const resultBytes = new Uint8Array(Math.floor(hexBytes.length / 2));
+    let i;
+    for (i = 0; i < resultBytes.length; i++) {
+        const a = HEX_CODEPOINTS[hexBytes[i * 2]];
+        const b = HEX_CODEPOINTS[hexBytes[i * 2 + 1]];
+        if (a === undefined || b === undefined) {
+            break;
+        }
+        resultBytes[i] = (a << 4) | b;
+    }
+    return i === resultBytes.length ? resultBytes : resultBytes.slice(0, i);
+}
+// Same behavior as Buffer.compare()
+function compare(v1, v2) {
+    const minLength = Math.min(v1.length, v2.length);
+    for (let i = 0; i < minLength; ++i) {
+        if (v1[i] !== v2[i]) {
+            return v1[i] < v2[i] ? -1 : 1;
+        }
+    }
+    return v1.length === v2.length ? 0 : v1.length > v2.length ? 1 : -1;
+}
+function writeUInt8(buffer, offset, value) {
+    if (offset + 1 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    if (value > 0xff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xff}. Received ${value}`);
+    }
+    buffer[offset] = value;
+    return offset + 1;
+}
+function writeUInt16(buffer, offset, value, littleEndian) {
+    if (offset + 2 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (value > 0xffff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xffff}. Received ${value}`);
+    }
+    if (littleEndian === "LE") {
+        buffer[offset] = value & 0xff;
+        buffer[offset + 1] = (value >> 8) & 0xff;
+    }
+    else {
+        buffer[offset] = (value >> 8) & 0xff;
+        buffer[offset + 1] = value & 0xff;
+    }
+    return offset + 2;
+}
+function writeUInt32(buffer, offset, value, littleEndian) {
+    if (offset + 4 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (value > 0xffffffff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xffffffff}. Received ${value}`);
+    }
+    if (littleEndian === "LE") {
+        buffer[offset] = value & 0xff;
+        buffer[offset + 1] = (value >> 8) & 0xff;
+        buffer[offset + 2] = (value >> 16) & 0xff;
+        buffer[offset + 3] = (value >> 24) & 0xff;
+    }
+    else {
+        buffer[offset] = (value >> 24) & 0xff;
+        buffer[offset + 1] = (value >> 16) & 0xff;
+        buffer[offset + 2] = (value >> 8) & 0xff;
+        buffer[offset + 3] = value & 0xff;
+    }
+    return offset + 4;
+}
+function readUInt8(buffer, offset) {
+    if (offset + 1 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    return buffer[offset];
+}
+function readUInt16(buffer, offset, littleEndian) {
+    if (offset + 2 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (littleEndian === "LE") {
+        let num = 0;
+        num = (num << 8) + buffer[offset + 1];
+        num = (num << 8) + buffer[offset];
+        return num;
+    }
+    else {
+        let num = 0;
+        num = (num << 8) + buffer[offset];
+        num = (num << 8) + buffer[offset + 1];
+        return num;
+    }
+}
+function readUInt32(buffer, offset, littleEndian) {
+    if (offset + 4 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (littleEndian === "LE") {
+        let num = 0;
+        num = ((num << 8) + buffer[offset + 3]) >>> 0;
+        num = ((num << 8) + buffer[offset + 2]) >>> 0;
+        num = ((num << 8) + buffer[offset + 1]) >>> 0;
+        num = ((num << 8) + buffer[offset]) >>> 0;
+        return num;
+    }
+    else {
+        let num = 0;
+        num = ((num << 8) + buffer[offset]) >>> 0;
+        num = ((num << 8) + buffer[offset + 1]) >>> 0;
+        num = ((num << 8) + buffer[offset + 2]) >>> 0;
+        num = ((num << 8) + buffer[offset + 3]) >>> 0;
+        return num;
+    }
+}
+
+/**
+ * Calculates the encoding length of a number used for push data in Bitcoin transactions.
+ * @param i The number to calculate the encoding length for.
+ * @returns The encoding length of the number.
+ */
+function encodingLength$1(i) {
+  return i < OPS$1.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
+}
+/**
+ * Encodes a number into a buffer using a variable-length encoding scheme.
+ * The encoded buffer is written starting at the specified offset.
+ * Returns the size of the encoded buffer.
+ *
+ * @param buffer - The buffer to write the encoded data into.
+ * @param num - The number to encode.
+ * @param offset - The offset at which to start writing the encoded buffer.
+ * @returns The size of the encoded buffer.
+ */
+function encode$2(buffer, num, offset) {
+  const size = encodingLength$1(num);
+  // ~6 bit
+  if (size === 1) {
+    writeUInt8(buffer, offset, num);
+    // 8 bit
+  } else if (size === 2) {
+    writeUInt8(buffer, offset, OPS$1.OP_PUSHDATA1);
+    writeUInt8(buffer, offset + 1, num);
+    // 16 bit
+  } else if (size === 3) {
+    writeUInt8(buffer, offset, OPS$1.OP_PUSHDATA2);
+    writeUInt16(buffer, offset + 1, num, 'LE');
+    // 32 bit
+  } else {
+    writeUInt8(buffer, offset, OPS$1.OP_PUSHDATA4);
+    writeUInt32(buffer, offset + 1, num, 'LE');
+  }
+  return size;
+}
+/**
+ * Decodes a buffer and returns information about the opcode, number, and size.
+ * @param buffer - The buffer to decode.
+ * @param offset - The offset within the buffer to start decoding.
+ * @returns An object containing the opcode, number, and size, or null if decoding fails.
+ */
+function decode$2(buffer, offset) {
+  const opcode = readUInt8(buffer, offset);
+  let num;
+  let size;
+  // ~6 bit
+  if (opcode < OPS$1.OP_PUSHDATA1) {
+    num = opcode;
+    size = 1;
+    // 8 bit
+  } else if (opcode === OPS$1.OP_PUSHDATA1) {
+    if (offset + 2 > buffer.length) return null;
+    num = readUInt8(buffer, offset + 1);
+    size = 2;
+    // 16 bit
+  } else if (opcode === OPS$1.OP_PUSHDATA2) {
+    if (offset + 3 > buffer.length) return null;
+    num = readUInt16(buffer, offset + 1, 'LE');
+    size = 3;
+    // 32 bit
+  } else {
+    if (offset + 5 > buffer.length) return null;
+    if (opcode !== OPS$1.OP_PUSHDATA4) throw new Error('Unexpected opcode');
+    num = readUInt32(buffer, offset + 1, 'LE');
+    size = 5;
+  }
+  return {
+    opcode,
+    number: num,
+    size,
+  };
+}
+
+/**
+ * Decodes a script number from a buffer.
+ *
+ * @param buffer - The buffer containing the script number.
+ * @param maxLength - The maximum length of the script number. Defaults to 4.
+ * @param minimal - Whether the script number should be minimal. Defaults to true.
+ * @returns The decoded script number.
+ * @throws {TypeError} If the script number overflows the maximum length.
+ * @throws {Error} If the script number is not minimally encoded when minimal is true.
+ */
+function decode$1(buffer, maxLength, minimal) {
+  maxLength = maxLength || 4;
+  minimal = minimal === undefined ? true : minimal;
+  const length = buffer.length;
+  if (length === 0) return 0;
+  if (length > maxLength) throw new TypeError('Script number overflow');
+  if (minimal) {
+    if ((buffer[length - 1] & 0x7f) === 0) {
+      if (length <= 1 || (buffer[length - 2] & 0x80) === 0)
+        throw new Error('Non-minimally encoded script number');
+    }
+  }
+  // 40-bit
+  if (length === 5) {
+    const a = readUInt32(buffer, 0, 'LE');
+    const b = readUInt8(buffer, 4);
+    if (b & 0x80) return -((b & -129) * 0x100000000 + a);
+    return b * 0x100000000 + a;
+  }
+  // 32-bit / 24-bit / 16-bit / 8-bit
+  let result = 0;
+  for (let i = 0; i < length; ++i) {
+    result |= buffer[i] << (8 * i);
+  }
+  if (buffer[length - 1] & 0x80)
+    return -(result & ~(0x80 << (8 * (length - 1))));
+  return result;
+}
+function scriptNumSize(i) {
+  return i > 0x7fffffff
+    ? 5
+    : i > 0x7fffff
+      ? 4
+      : i > 0x7fff
+        ? 3
+        : i > 0x7f
+          ? 2
+          : i > 0x00
+            ? 1
+            : 0;
+}
+/**
+ * Encodes a number into a Uint8Array using a specific format.
+ *
+ * @param _number - The number to encode.
+ * @returns The encoded number as a Uint8Array.
+ */
+function encode$1(_number) {
+  let value = Math.abs(_number);
+  const size = scriptNumSize(value);
+  const buffer = new Uint8Array(size);
+  const negative = _number < 0;
+  for (let i = 0; i < size; ++i) {
+    writeUInt8(buffer, i, value & 0xff);
+    value >>= 8;
+  }
+  if (buffer[size - 1] & 0x80) {
+    writeUInt8(buffer, size - 1, negative ? 0x80 : 0x00);
+  } else if (negative) {
+    buffer[size - 1] |= 0x80;
+  }
+  return buffer;
+}
+
+//#region src/storages/globalConfig/globalConfig.ts
+let store$4;
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	return {
+		lang: config$1?.lang ?? store$4?.lang,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+		abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+	};
+}
+
+//#endregion
+//#region src/storages/globalMessage/globalMessage.ts
+let store$3;
+/**
+* Returns a global error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store$3?.get(lang);
+}
+
+//#endregion
+//#region src/storages/schemaMessage/schemaMessage.ts
+let store$2;
+/**
+* Returns a schema error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store$2?.get(lang);
+}
+
+//#endregion
+//#region src/storages/specificMessage/specificMessage.ts
+let store$1;
+/**
+* Returns a specific error message.
+*
+* @param reference The identifier reference.
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store$1?.get(reference)?.get(lang);
+}
+
+//#endregion
+//#region src/utils/_stringify/_stringify.ts
+/**
+* Stringifies an unknown input to a literal or type string.
+*
+* @param input The unknown input.
+*
+* @returns A literal or type string.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+
+//#endregion
+//#region src/utils/_addIssue/_addIssue.ts
+/**
+* Adds an issue to the dataset.
+*
+* @param context The issue context.
+* @param label The issue label.
+* @param dataset The input dataset.
+* @param config The configuration.
+* @param other The optional props.
+*
+* @internal
+*/
+function _addIssue(context, label, dataset, config$1, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config$1.lang,
+		abortEarly: config$1.abortEarly,
+		abortPipeEarly: config$1.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+
+//#endregion
+//#region src/utils/_getStandardProps/_getStandardProps.ts
+/**
+* Returns the Standard Schema properties.
+*
+* @param context The schema context.
+*
+* @returns The Standard Schema properties.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value$1) {
+			return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/_joinExpects/_joinExpects.ts
+/**
+* Joins multiple `expects` values with the given separator.
+*
+* @param values The `expects` values.
+* @param separator The separator.
+*
+* @returns The joined `expects` property.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values$1, separator) {
+	const list = [...new Set(values$1)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+
+//#endregion
+//#region src/utils/ValiError/ValiError.ts
+/**
+* A Valibot error with useful information.
+*/
+var ValiError = class extends Error {
+	/**
+	* Creates a Valibot error with useful information.
+	*
+	* @param issues The error issues.
+	*/
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
+};
+
+//#endregion
+//#region src/actions/everyItem/everyItem.ts
+/* @__NO_SIDE_EFFECTS__ */
+function everyItem(requirement, message$1) {
+	return {
+		kind: "validation",
+		type: "every_item",
+		reference: everyItem,
+		async: false,
+		expects: null,
+		requirement,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (dataset.typed && !dataset.value.every(this.requirement)) _addIssue(this, "item", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/actions/length/length.ts
+/* @__NO_SIDE_EFFECTS__ */
+function length(requirement, message$1) {
+	return {
+		kind: "validation",
+		type: "length",
+		reference: length,
+		async: false,
+		expects: `${requirement}`,
+		requirement,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (dataset.typed && dataset.value.length !== this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/methods/getFallback/getFallback.ts
+/**
+* Returns the fallback value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The output dataset if available.
+* @param config The config if available.
+*
+* @returns The fallback value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config$1) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+
+//#endregion
+//#region src/methods/getDefault/getDefault.ts
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+
+//#endregion
+//#region src/methods/is/is.ts
+/**
+* Checks if the input matches the schema. By using a type predicate, this
+* function can be used as a type guard.
+*
+* @param schema The schema to be used.
+* @param input The input to be tested.
+*
+* @returns Whether the input matches the schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function is(schema, input) {
+	return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
+}
+
+//#endregion
+//#region src/schemas/any/any.ts
+/**
+* Creates an any schema.
+*
+* Hint: This schema function exists only for completeness and is not
+* recommended in practice. Instead, `unknown` should be used to accept
+* unknown data.
+*
+* @returns An any schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function any() {
+	return {
+		kind: "schema",
+		type: "any",
+		reference: any,
+		expects: "any",
+		async: false,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset) {
+			dataset.typed = true;
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/array/array.ts
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message$1) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/custom/custom.ts
+/* @__NO_SIDE_EFFECTS__ */
+function custom(check$1, message$1) {
+	return {
+		kind: "schema",
+		type: "custom",
+		reference: custom,
+		expects: "unknown",
+		async: false,
+		check: check$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (this.check(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/instance/instance.ts
+/* @__NO_SIDE_EFFECTS__ */
+function instance(class_, message$1) {
+	return {
+		kind: "schema",
+		type: "instance",
+		reference: instance,
+		expects: class_.name,
+		async: false,
+		class: class_,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value instanceof this.class) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/nullish/nullish.ts
+/* @__NO_SIDE_EFFECTS__ */
+function nullish(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "nullish",
+		reference: nullish,
+		expects: `(${wrapped.expects} | null | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === null || dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === null || dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/number/number.ts
+/* @__NO_SIDE_EFFECTS__ */
+function number(message$1) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/object/object.ts
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries$1, message$1) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/optional/optional.ts
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/string/string.ts
+/* @__NO_SIDE_EFFECTS__ */
+function string(message$1) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/schemas/union/utils/_subIssues/_subIssues.ts
+/**
+* Returns the sub issues of the provided datasets for the union issue.
+*
+* @param datasets The datasets.
+*
+* @returns The sub issues.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
+}
+
+//#endregion
+//#region src/schemas/union/union.ts
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message$1) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+
+//#endregion
+//#region src/methods/parse/parse.ts
+/**
+* Parses an unknown input based on a schema.
+*
+* @param schema The schema to be used.
+* @param input The input to be parsed.
+* @param config The parse configuration.
+*
+* @returns The parsed input.
+*/
+function parse(schema, input, config$1) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+	if (dataset.issues) throw new ValiError(dataset.issues);
+	return dataset.value;
+}
+
+//#endregion
+//#region src/methods/partial/partial.ts
+/* @__NO_SIDE_EFFECTS__ */
+function partial(schema, keys) {
+	const entries$1 = {};
+	for (const key in schema.entries) entries$1[key] = /* @__PURE__ */ optional(schema.entries[key]) ;
+	return {
+		...schema,
+		entries: entries$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		}
+	};
+}
+
+//#endregion
+//#region src/methods/pipe/pipe.ts
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe$1) {
+	return {
+		...pipe$1[0],
+		pipe: pipe$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			for (const item of pipe$1) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+			}
+			return dataset;
+		}
+	};
+}
+
+const ZERO32 = new Uint8Array(32);
+const EC_P = fromHex(
+  'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
+);
+const NBufferSchemaFactory = size =>
+  pipe(instance(Uint8Array), length(size));
+/**
+ * Checks if two arrays of Buffers are equal.
+ * @param a - The first array of Buffers.
+ * @param b - The second array of Buffers.
+ * @returns True if the arrays are equal, false otherwise.
+ */
+function stacksEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((x, i) => {
+    return compare(x, b[i]) === 0;
+  });
+}
+/**
+ * Checks if the given value is a valid elliptic curve point.
+ * @param p - The value to check.
+ * @returns True if the value is a valid elliptic curve point, false otherwise.
+ */
+function isPoint(p) {
+  if (!(p instanceof Uint8Array)) return false;
+  if (p.length < 33) return false;
+  const t = p[0];
+  const x = p.slice(1, 33);
+  if (compare(ZERO32, x) === 0) return false;
+  if (compare(x, EC_P) >= 0) return false;
+  if ((t === 0x02 || t === 0x03) && p.length === 33) {
+    return true;
+  }
+  const y = p.slice(33);
+  if (compare(ZERO32, y) === 0) return false;
+  if (compare(y, EC_P) >= 0) return false;
+  if (t === 0x04 && p.length === 65) return true;
+  return false;
+}
+const TAPLEAF_VERSION_MASK = 0xfe;
+function isTapleaf(o) {
+  if (!o || !('output' in o)) return false;
+  if (!(o.output instanceof Uint8Array)) return false;
+  if (o.version !== undefined)
+    return (o.version & TAPLEAF_VERSION_MASK) === o.version;
+  return true;
+}
+function isTaptree(scriptTree) {
+  if (!Array.isArray(scriptTree)) return isTapleaf(scriptTree);
+  if (scriptTree.length !== 2) return false;
+  return scriptTree.every(t => isTaptree(t));
+}
+const Buffer256bitSchema = NBufferSchemaFactory(32);
+const Hash160bitSchema = NBufferSchemaFactory(20);
+const BufferSchema = instance(Uint8Array);
+const NullablePartial = a =>
+  object(
+    Object.entries(a).reduce(
+      (acc, next) => ({ ...acc, [next[0]]: nullish(next[1]) }),
+      {},
+    ),
+  );
+
+/**
+ * Script tools module for working with Bitcoin scripts.
+ * Provides utilities such as decompiling, compiling, converting to/from ASM, stack manipulation,
+ * and script validation functions.
+ *
+ * @packageDocumentation
+ */
+/** Base opcode for OP_INT values. */
+const OP_INT_BASE$1 = OPS$1.OP_RESERVED; // OP_1 - 1
+/** Validation schema for a Bitcoin script stack. */
+const StackSchema = array(union([instance(Uint8Array), number()]));
+/**
+ * Determines if a value corresponds to an OP_INT opcode.
+ *
+ * @param value - The opcode to check.
+ * @returns True if the value is an OP_INT, false otherwise.
+ */
+function isOPInt(value) {
+  return (
+    is(number(), value) &&
+    (value === OPS$1.OP_0 ||
+      (value >= OPS$1.OP_1 && value <= OPS$1.OP_16) ||
+      value === OPS$1.OP_1NEGATE)
+  );
+}
+/**
+ * Checks if a script chunk is push-only (contains only data or OP_INT opcodes).
+ *
+ * @param value - The chunk to check.
+ * @returns True if the chunk is push-only, false otherwise.
+ */
+function isPushOnlyChunk(value) {
+  return is(BufferSchema, value) || isOPInt(value);
+}
+/**
+ * Determines if a stack consists of only push operations.
+ *
+ * @param value - The stack to check.
+ * @returns True if all elements in the stack are push-only, false otherwise.
+ */
+function isPushOnly(value) {
+  return is(pipe(any(), everyItem(isPushOnlyChunk)), value);
+}
+/**
+ * Counts the number of non-push-only opcodes in a stack.
+ *
+ * @param value - The stack to analyze.
+ * @returns The count of non-push-only opcodes.
+ */
+function countNonPushOnlyOPs(value) {
+  return value.length - value.filter(isPushOnlyChunk).length;
+}
+/**
+ * Converts a minimal script buffer to its corresponding opcode, if applicable.
+ *
+ * @param buffer - The buffer to check.
+ * @returns The corresponding opcode or undefined if not minimal.
+ */
+function asMinimalOP(buffer) {
+  if (buffer.length === 0) return OPS$1.OP_0;
+  if (buffer.length !== 1) return;
+  if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE$1 + buffer[0];
+  if (buffer[0] === 0x81) return OPS$1.OP_1NEGATE;
+}
+/**
+ * Determines if a buffer or stack is a Uint8Array.
+ *
+ * @param buf - The buffer or stack to check.
+ * @returns True if the input is a Uint8Array, false otherwise.
+ */
+function chunksIsBuffer(buf) {
+  return buf instanceof Uint8Array;
+}
+/**
+ * Determines if a buffer or stack is a valid stack.
+ *
+ * @param buf - The buffer or stack to check.
+ * @returns True if the input is a stack, false otherwise.
+ */
+function chunksIsArray(buf) {
+  return is(StackSchema, buf);
+}
+/**
+ * Determines if a single chunk is a Uint8Array.
+ *
+ * @param buf - The chunk to check.
+ * @returns True if the chunk is a Uint8Array, false otherwise.
+ */
+function singleChunkIsBuffer(buf) {
+  return buf instanceof Uint8Array;
+}
+/**
+ * Compiles an array of script chunks into a Uint8Array.
+ *
+ * @param chunks - The chunks to compile.
+ * @returns The compiled script as a Uint8Array.
+ * @throws Error if compilation fails.
+ */
+function compile(chunks) {
+  if (chunksIsBuffer(chunks)) return chunks;
+  parse(StackSchema, chunks);
+  const bufferSize = chunks.reduce((accum, chunk) => {
+    if (singleChunkIsBuffer(chunk)) {
+      // adhere to BIP62.3, minimal push policy
+      if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
+        return accum + 1;
+      }
+      return accum + encodingLength$1(chunk.length) + chunk.length;
+    }
+    return accum + 1;
+  }, 0);
+  const buffer = new Uint8Array(bufferSize);
+  let offset = 0;
+  chunks.forEach(chunk => {
+    if (singleChunkIsBuffer(chunk)) {
+      // adhere to BIP62.3, minimal push policy
+      const opcode = asMinimalOP(chunk);
+      if (opcode !== undefined) {
+        writeUInt8(buffer, offset, opcode);
+        offset += 1;
+        return;
+      }
+      offset += encode$2(buffer, chunk.length, offset);
+      buffer.set(chunk, offset);
+      offset += chunk.length;
+      // opcode
+    } else {
+      writeUInt8(buffer, offset, chunk);
+      offset += 1;
+    }
+  });
+  if (offset !== buffer.length) throw new Error('Could not decode chunks');
+  return buffer;
+}
+/**
+ * Decompiles a script buffer into an array of chunks.
+ *
+ * @param buffer - The script buffer to decompile.
+ * @returns The decompiled chunks or null if decompilation fails.
+ */
+function decompile(buffer) {
+  if (chunksIsArray(buffer)) return buffer;
+  parse(BufferSchema, buffer);
+  const chunks = [];
+  let i = 0;
+  while (i < buffer.length) {
+    const opcode = buffer[i];
+    if (opcode > OPS$1.OP_0 && opcode <= OPS$1.OP_PUSHDATA4) {
+      const d = decode$2(buffer, i);
+      // did reading a pushDataInt fail?
+      if (d === null) return null;
+      i += d.size;
+      // attempt to read too much data?
+      if (i + d.number > buffer.length) return null;
+      const data = buffer.slice(i, i + d.number);
+      i += d.number;
+      // decompile minimally
+      const op = asMinimalOP(data);
+      if (op !== undefined) {
+        chunks.push(op);
+      } else {
+        chunks.push(data);
+      }
+    } else {
+      chunks.push(opcode);
+      i += 1;
+    }
+  }
+  return chunks;
+}
+/**
+ * Converts the given chunks into a stack of buffers.
+ *
+ * @param chunks - The chunks to convert.
+ * @returns The stack of buffers.
+ */
+function toStack(chunks) {
+  chunks = decompile(chunks);
+  parse(custom(isPushOnly), chunks);
+  return chunks.map(op => {
+    if (singleChunkIsBuffer(op)) return op;
+    if (op === OPS$1.OP_0) return new Uint8Array(0);
+    return encode$1(op - OP_INT_BASE$1);
+  });
+}
+/**
+ * Checks if the provided hash type is defined.
+ *
+ * A hash type is considered defined if its modified value (after masking with ~0x80)
+ * is greater than 0x00 and less than 0x04.
+ *
+ * @param hashType - The hash type to check.
+ * @returns True if the hash type is defined, false otherwise.
+ */
+function isDefinedHashType(hashType) {
+  const hashTypeMod = hashType & -129;
+  return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
+/**
+ * Checks if the provided buffer is a canonical script signature.
+ *
+ * A canonical script signature is a valid DER-encoded signature followed by a valid hash type byte.
+ *
+ * @param buffer - The buffer to check.
+ * @returns `true` if the buffer is a canonical script signature, `false` otherwise.
+ */
+function isCanonicalScriptSignature(buffer) {
+  if (!(buffer instanceof Uint8Array)) return false;
+  if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
+  return check(buffer.slice(0, -1));
+}
+
+function prop(object, name, f) {
+  Object.defineProperty(object, name, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const _value = f.call(this);
+      this[name] = _value;
+      return _value;
+    },
+    set(_value) {
+      Object.defineProperty(this, name, {
+        configurable: true,
+        enumerable: true,
+        value: _value,
+        writable: true,
+      });
+    },
+  });
+}
+function value(f) {
+  let _value;
+  return () => {
+    if (_value !== undefined) return _value;
+    _value = f();
+    return _value;
+  };
+}
+
+const OPS = OPS$1;
+const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
+function encodeSmallOrScriptNum(n) {
+  return n <= 16 ? OP_INT_BASE + n : encode$1(n);
+}
+function decodeSmallOrScriptNum(chunk) {
+  if (typeof chunk === 'number') {
+    const val = chunk - OP_INT_BASE;
+    if (val < 1 || val > 16)
+      throw new TypeError(`Invalid opcode: expected OP_1–OP_16, got ${chunk}`);
+    return val;
+  } else return decode$1(chunk);
+}
+function isSmallOrScriptNum(chunk) {
+  if (typeof chunk === 'number')
+    return chunk - OP_INT_BASE >= 1 && chunk - OP_INT_BASE <= 16;
+  else return Number.isInteger(decode$1(chunk));
+}
+// input: OP_0 [signatures ...]
+// output: m [pubKeys ...] n OP_CHECKMULTISIG
+/**
+ * Represents a function that creates a Pay-to-Multisig (P2MS) payment object.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The created payment object.
+ * @throws {TypeError} If the provided data is not valid.
+ */
+function p2ms(a, opts) {
+  if (
+    !a.input &&
+    !a.output &&
+    !(a.pubkeys && a.m !== undefined) &&
+    !a.signatures
+  )
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  function isAcceptableSignature(x) {
+    return (
+      isCanonicalScriptSignature(x) ||
+      (opts.allowIncomplete && x === OPS.OP_0) !== undefined
+    );
+  }
+  parse(
+    partial(
+      object({
+        network: object({}),
+        m: number(),
+        n: number(),
+        output: BufferSchema,
+        pubkeys: array(custom(isPoint), 'Received invalid pubkey'),
+        signatures: array(
+          custom(isAcceptableSignature),
+          'Expected signature to be of type isAcceptableSignature',
+        ),
+        input: BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const network = a.network || bitcoin;
+  const o = { network };
+  let chunks = [];
+  let decoded = false;
+  function decode(output) {
+    if (decoded) return;
+    decoded = true;
+    chunks = decompile(output);
+    if (chunks.length < 3) throw new TypeError('Output is invalid');
+    o.m = decodeSmallOrScriptNum(chunks[0]);
+    o.n = decodeSmallOrScriptNum(chunks[chunks.length - 2]);
+    o.pubkeys = chunks.slice(1, -2);
+  }
+  prop(o, 'output', () => {
+    if (!a.m) return;
+    if (!o.n) return;
+    if (!a.pubkeys) return;
+    return compile(
+      [].concat(
+        encodeSmallOrScriptNum(a.m),
+        a.pubkeys,
+        encodeSmallOrScriptNum(o.n),
+        OPS.OP_CHECKMULTISIG,
+      ),
+    );
+  });
+  prop(o, 'm', () => {
+    if (!o.output) return;
+    decode(o.output);
+    return o.m;
+  });
+  prop(o, 'n', () => {
+    if (!o.pubkeys) return;
+    return o.pubkeys.length;
+  });
+  prop(o, 'pubkeys', () => {
+    if (!a.output) return;
+    decode(a.output);
+    return o.pubkeys;
+  });
+  prop(o, 'signatures', () => {
+    if (!a.input) return;
+    return decompile(a.input).slice(1);
+  });
+  prop(o, 'input', () => {
+    if (!a.signatures) return;
+    return compile([OPS.OP_0].concat(a.signatures));
+  });
+  prop(o, 'witness', () => {
+    if (!o.input) return;
+    return [];
+  });
+  prop(o, 'name', () => {
+    if (!o.m || !o.n) return;
+    return `p2ms(${o.m} of ${o.n})`;
+  });
+  // extended validation
+  if (opts.validate) {
+    if (a.output) {
+      decode(a.output);
+      if (!isSmallOrScriptNum(chunks[0]))
+        throw new TypeError('Output is invalid');
+      if (!isSmallOrScriptNum(chunks[chunks.length - 2]))
+        throw new TypeError('Output is invalid');
+      if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG)
+        throw new TypeError('Output is invalid');
+      if (o.m <= 0 || o.n > 20 || o.m > o.n || o.n !== chunks.length - 3)
+        throw new TypeError('Output is invalid');
+      if (!o.pubkeys.every(x => isPoint(x)))
+        throw new TypeError('Output is invalid');
+      if (a.m !== undefined && a.m !== o.m) throw new TypeError('m mismatch');
+      if (a.n !== undefined && a.n !== o.n) throw new TypeError('n mismatch');
+      if (a.pubkeys && !stacksEqual(a.pubkeys, o.pubkeys))
+        throw new TypeError('Pubkeys mismatch');
+    }
+    if (a.pubkeys) {
+      if (a.n !== undefined && a.n !== a.pubkeys.length)
+        throw new TypeError('Pubkey count mismatch');
+      o.n = a.pubkeys.length;
+      if (o.n < o.m) throw new TypeError('Pubkey count cannot be less than m');
+    }
+    if (a.signatures) {
+      if (a.signatures.length < o.m)
+        throw new TypeError('Not enough signatures provided');
+      if (a.signatures.length > o.m)
+        throw new TypeError('Too many signatures provided');
+    }
+    if (a.input) {
+      if (a.input[0] !== OPS.OP_0) throw new TypeError('Input is invalid');
+      if (
+        o.signatures.length === 0 ||
+        !o.signatures.every(isAcceptableSignature)
+      )
+        throw new TypeError('Input has invalid signature(s)');
+      if (a.signatures && !stacksEqual(a.signatures, o.signatures))
+        throw new TypeError('Signature mismatch');
+      if (a.m !== undefined && a.m !== a.signatures.length)
+        throw new TypeError('Signature count mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}
+
+/**
+ * RIPEMD-160 legacy hash function.
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/legacy` module */
+const ripemd160 = ripemd160$1;
+
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+/**
+ * Computes the HASH160 (RIPEMD-160 after SHA-256) of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The HASH160 of the input buffer.
+ */
+function hash160(buffer) {
+  return ripemd160(sha256(buffer));
+}
+/**
+ * A collection of tagged hash prefixes used in various BIP (Bitcoin Improvement Proposals)
+ * and Taproot-related operations. Each prefix is represented as a `Uint8Array`.
+ *
+ * @constant
+ * @type {TaggedHashPrefixes}
+ *
+ * @property {'BIP0340/challenge'} - Prefix for BIP0340 challenge.
+ * @property {'BIP0340/aux'} - Prefix for BIP0340 auxiliary data.
+ * @property {'BIP0340/nonce'} - Prefix for BIP0340 nonce.
+ * @property {TapLeaf} - Prefix for Taproot leaf.
+ * @property {TapBranch} - Prefix for Taproot branch.
+ * @property {TapSighash} - Prefix for Taproot sighash.
+ * @property {TapTweak} - Prefix for Taproot tweak.
+ * @property {'KeyAgg list'} - Prefix for key aggregation list.
+ * @property {'KeyAgg coefficient'} - Prefix for key aggregation coefficient.
+ */
+const TAGGED_HASH_PREFIXES = {
+  'BIP0340/challenge': Uint8Array.from([
+    123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+    210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124,
+    123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+    210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124,
+  ]),
+  'BIP0340/aux': Uint8Array.from([
+    241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+    105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144,
+    241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+    105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144,
+  ]),
+  'BIP0340/nonce': Uint8Array.from([
+    7, 73, 119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244,
+    52, 215, 62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47, 7, 73,
+    119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244, 52, 215,
+    62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47,
+  ]),
+  TapLeaf: Uint8Array.from([
+    174, 234, 143, 220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211,
+    95, 28, 181, 64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238, 174, 234, 143,
+    220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211, 95, 28, 181,
+    64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238,
+  ]),
+  TapBranch: Uint8Array.from([
+    25, 65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247,
+    33, 111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21, 25,
+    65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247, 33,
+    111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21,
+  ]),
+  TapSighash: Uint8Array.from([
+    244, 10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61,
+    149, 253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49, 244,
+    10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61, 149,
+    253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49,
+  ]),
+  TapTweak: Uint8Array.from([
+    232, 15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66,
+    156, 188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233, 232,
+    15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66, 156,
+    188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233,
+  ]),
+  'KeyAgg list': Uint8Array.from([
+    72, 28, 151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126,
+    215, 49, 156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240, 72, 28,
+    151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126, 215, 49,
+    156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240,
+  ]),
+  'KeyAgg coefficient': Uint8Array.from([
+    191, 201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100,
+    130, 78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129, 191,
+    201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100, 130,
+    78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129,
+  ]),
+};
+/**
+ * Computes a tagged hash using the specified prefix and data.
+ *
+ * @param prefix - The prefix to use for the tagged hash. This should be one of the values from the `TaggedHashPrefix` enum.
+ * @param data - The data to hash, provided as a `Uint8Array`.
+ * @returns The resulting tagged hash as a `Uint8Array`.
+ */
+function taggedHash(prefix, data) {
+  return sha256(concat([TAGGED_HASH_PREFIXES[prefix], data]));
+}
+
+var dist = {};
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	Object.defineProperty(dist, "__esModule", { value: true });
+	dist.bech32m = dist.bech32 = void 0;
+	const ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+	const ALPHABET_MAP = {};
+	for (let z = 0; z < ALPHABET.length; z++) {
+	    const x = ALPHABET.charAt(z);
+	    ALPHABET_MAP[x] = z;
+	}
+	function polymodStep(pre) {
+	    const b = pre >> 25;
+	    return (((pre & 0x1ffffff) << 5) ^
+	        (-((b >> 0) & 1) & 0x3b6a57b2) ^
+	        (-((b >> 1) & 1) & 0x26508e6d) ^
+	        (-((b >> 2) & 1) & 0x1ea119fa) ^
+	        (-((b >> 3) & 1) & 0x3d4233dd) ^
+	        (-((b >> 4) & 1) & 0x2a1462b3));
+	}
+	function prefixChk(prefix) {
+	    let chk = 1;
+	    for (let i = 0; i < prefix.length; ++i) {
+	        const c = prefix.charCodeAt(i);
+	        if (c < 33 || c > 126)
+	            return 'Invalid prefix (' + prefix + ')';
+	        chk = polymodStep(chk) ^ (c >> 5);
+	    }
+	    chk = polymodStep(chk);
+	    for (let i = 0; i < prefix.length; ++i) {
+	        const v = prefix.charCodeAt(i);
+	        chk = polymodStep(chk) ^ (v & 0x1f);
+	    }
+	    return chk;
+	}
+	function convert(data, inBits, outBits, pad) {
+	    let value = 0;
+	    let bits = 0;
+	    const maxV = (1 << outBits) - 1;
+	    const result = [];
+	    for (let i = 0; i < data.length; ++i) {
+	        value = (value << inBits) | data[i];
+	        bits += inBits;
+	        while (bits >= outBits) {
+	            bits -= outBits;
+	            result.push((value >> bits) & maxV);
+	        }
+	    }
+	    if (pad) {
+	        if (bits > 0) {
+	            result.push((value << (outBits - bits)) & maxV);
+	        }
+	    }
+	    else {
+	        if (bits >= inBits)
+	            return 'Excess padding';
+	        if ((value << (outBits - bits)) & maxV)
+	            return 'Non-zero padding';
+	    }
+	    return result;
+	}
+	function toWords(bytes) {
+	    return convert(bytes, 8, 5, true);
+	}
+	function fromWordsUnsafe(words) {
+	    const res = convert(words, 5, 8, false);
+	    if (Array.isArray(res))
+	        return res;
+	}
+	function fromWords(words) {
+	    const res = convert(words, 5, 8, false);
+	    if (Array.isArray(res))
+	        return res;
+	    throw new Error(res);
+	}
+	function getLibraryFromEncoding(encoding) {
+	    let ENCODING_CONST;
+	    if (encoding === 'bech32') {
+	        ENCODING_CONST = 1;
+	    }
+	    else {
+	        ENCODING_CONST = 0x2bc830a3;
+	    }
+	    function encode(prefix, words, LIMIT) {
+	        LIMIT = LIMIT || 90;
+	        if (prefix.length + 7 + words.length > LIMIT)
+	            throw new TypeError('Exceeds length limit');
+	        prefix = prefix.toLowerCase();
+	        // determine chk mod
+	        let chk = prefixChk(prefix);
+	        if (typeof chk === 'string')
+	            throw new Error(chk);
+	        let result = prefix + '1';
+	        for (let i = 0; i < words.length; ++i) {
+	            const x = words[i];
+	            if (x >> 5 !== 0)
+	                throw new Error('Non 5-bit word');
+	            chk = polymodStep(chk) ^ x;
+	            result += ALPHABET.charAt(x);
+	        }
+	        for (let i = 0; i < 6; ++i) {
+	            chk = polymodStep(chk);
+	        }
+	        chk ^= ENCODING_CONST;
+	        for (let i = 0; i < 6; ++i) {
+	            const v = (chk >> ((5 - i) * 5)) & 0x1f;
+	            result += ALPHABET.charAt(v);
+	        }
+	        return result;
+	    }
+	    function __decode(str, LIMIT) {
+	        LIMIT = LIMIT || 90;
+	        if (str.length < 8)
+	            return str + ' too short';
+	        if (str.length > LIMIT)
+	            return 'Exceeds length limit';
+	        // don't allow mixed case
+	        const lowered = str.toLowerCase();
+	        const uppered = str.toUpperCase();
+	        if (str !== lowered && str !== uppered)
+	            return 'Mixed-case string ' + str;
+	        str = lowered;
+	        const split = str.lastIndexOf('1');
+	        if (split === -1)
+	            return 'No separator character for ' + str;
+	        if (split === 0)
+	            return 'Missing prefix for ' + str;
+	        const prefix = str.slice(0, split);
+	        const wordChars = str.slice(split + 1);
+	        if (wordChars.length < 6)
+	            return 'Data too short';
+	        let chk = prefixChk(prefix);
+	        if (typeof chk === 'string')
+	            return chk;
+	        const words = [];
+	        for (let i = 0; i < wordChars.length; ++i) {
+	            const c = wordChars.charAt(i);
+	            const v = ALPHABET_MAP[c];
+	            if (v === undefined)
+	                return 'Unknown character ' + c;
+	            chk = polymodStep(chk) ^ v;
+	            // not in the checksum?
+	            if (i + 6 >= wordChars.length)
+	                continue;
+	            words.push(v);
+	        }
+	        if (chk !== ENCODING_CONST)
+	            return 'Invalid checksum for ' + str;
+	        return { prefix, words };
+	    }
+	    function decodeUnsafe(str, LIMIT) {
+	        const res = __decode(str, LIMIT);
+	        if (typeof res === 'object')
+	            return res;
+	    }
+	    function decode(str, LIMIT) {
+	        const res = __decode(str, LIMIT);
+	        if (typeof res === 'object')
+	            return res;
+	        throw new Error(res);
+	    }
+	    return {
+	        decodeUnsafe,
+	        decode,
+	        encode,
+	        toWords,
+	        fromWordsUnsafe,
+	        fromWords,
+	    };
+	}
+	dist.bech32 = getLibraryFromEncoding('bech32');
+	dist.bech32m = getLibraryFromEncoding('bech32m');
+	return dist;
+}
+
+var distExports = requireDist();
+
+const checkUInt64 = (n) => {
+    if (n < 0 || n > 0xffffffffffffffffn) {
+        throw new RangeError('value out of range');
+    }
+};
+function checkUInt53(n) {
+    if (n < 0 || n > Number.MAX_SAFE_INTEGER || n % 1 !== 0)
+        throw new RangeError('value out of range');
+}
+function checkUint53OrUint64(n) {
+    if (typeof n === 'number')
+        checkUInt53(n);
+    else
+        checkUInt64(n);
+}
+function encode(n, buffer, offset) {
+    checkUint53OrUint64(n);
+    if (offset === undefined)
+        offset = 0;
+    if (buffer === undefined) {
+        buffer = new Uint8Array(encodingLength(n));
+    }
+    let bytes = 0;
+    // 8 bit
+    if (n < 0xfd) {
+        buffer.set([Number(n)], offset);
+        bytes = 1;
+        // 16 bit
+    }
+    else if (n <= 0xffff) {
+        buffer.set([0xfd], offset);
+        writeUInt16$1(buffer, offset + 1, Number(n), 'LE');
+        bytes = 3;
+        // 32 bit
+    }
+    else if (n <= 0xffffffff) {
+        buffer.set([0xfe], offset);
+        writeUInt32$1(buffer, offset + 1, Number(n), 'LE');
+        bytes = 5;
+        // 64 bit
+    }
+    else {
+        buffer.set([0xff], offset);
+        writeUInt64(buffer, offset + 1, BigInt(n), 'LE');
+        bytes = 9;
+    }
+    return { buffer, bytes };
+}
+function decode(buffer, offset) {
+    if (offset === undefined)
+        offset = 0;
+    const first = buffer.at(offset);
+    if (first === undefined)
+        throw new Error('buffer too small');
+    // 8 bit
+    if (first < 0xfd) {
+        return { numberValue: first, bigintValue: BigInt(first), bytes: 1 };
+        // 16 bit
+    }
+    else if (first === 0xfd) {
+        const val = readUInt16$1(buffer, offset + 1, 'LE');
+        return {
+            numberValue: val,
+            bigintValue: BigInt(val),
+            bytes: 3
+        };
+        // 32 bit
+    }
+    else if (first === 0xfe) {
+        const val = readUInt32$1(buffer, offset + 1, 'LE');
+        return {
+            numberValue: val,
+            bigintValue: BigInt(val),
+            bytes: 5
+        };
+        // 64 bit
+    }
+    else {
+        const number = readUInt64(buffer, offset + 1, 'LE');
+        return { numberValue: number <= Number.MAX_SAFE_INTEGER ? Number(number) : null, bigintValue: number, bytes: 9 };
+    }
+}
+function encodingLength(n) {
+    checkUint53OrUint64(n);
+    return n < 0xfd ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9;
+}
+
+fromHex(
+  '0000000000000000000000000000000000000000000000000000000000000000',
+);
+fromHex(
+  '0000000000000000000000000000000000000000000000000000000000000001',
+);
+fromHex('ffffffffffffffff');
+
+var GlobalTypes;
+(function(GlobalTypes) {
+  GlobalTypes[(GlobalTypes['UNSIGNED_TX'] = 0)] = 'UNSIGNED_TX';
+  GlobalTypes[(GlobalTypes['GLOBAL_XPUB'] = 1)] = 'GLOBAL_XPUB';
+})(GlobalTypes || (GlobalTypes = {}));
+var InputTypes;
+(function(InputTypes) {
+  InputTypes[(InputTypes['NON_WITNESS_UTXO'] = 0)] = 'NON_WITNESS_UTXO';
+  InputTypes[(InputTypes['WITNESS_UTXO'] = 1)] = 'WITNESS_UTXO';
+  InputTypes[(InputTypes['PARTIAL_SIG'] = 2)] = 'PARTIAL_SIG';
+  InputTypes[(InputTypes['SIGHASH_TYPE'] = 3)] = 'SIGHASH_TYPE';
+  InputTypes[(InputTypes['REDEEM_SCRIPT'] = 4)] = 'REDEEM_SCRIPT';
+  InputTypes[(InputTypes['WITNESS_SCRIPT'] = 5)] = 'WITNESS_SCRIPT';
+  InputTypes[(InputTypes['BIP32_DERIVATION'] = 6)] = 'BIP32_DERIVATION';
+  InputTypes[(InputTypes['FINAL_SCRIPTSIG'] = 7)] = 'FINAL_SCRIPTSIG';
+  InputTypes[(InputTypes['FINAL_SCRIPTWITNESS'] = 8)] = 'FINAL_SCRIPTWITNESS';
+  InputTypes[(InputTypes['POR_COMMITMENT'] = 9)] = 'POR_COMMITMENT';
+  InputTypes[(InputTypes['TAP_KEY_SIG'] = 19)] = 'TAP_KEY_SIG';
+  InputTypes[(InputTypes['TAP_SCRIPT_SIG'] = 20)] = 'TAP_SCRIPT_SIG';
+  InputTypes[(InputTypes['TAP_LEAF_SCRIPT'] = 21)] = 'TAP_LEAF_SCRIPT';
+  InputTypes[(InputTypes['TAP_BIP32_DERIVATION'] = 22)] =
+    'TAP_BIP32_DERIVATION';
+  InputTypes[(InputTypes['TAP_INTERNAL_KEY'] = 23)] = 'TAP_INTERNAL_KEY';
+  InputTypes[(InputTypes['TAP_MERKLE_ROOT'] = 24)] = 'TAP_MERKLE_ROOT';
+})(InputTypes || (InputTypes = {}));
+var OutputTypes;
+(function(OutputTypes) {
+  OutputTypes[(OutputTypes['REDEEM_SCRIPT'] = 0)] = 'REDEEM_SCRIPT';
+  OutputTypes[(OutputTypes['WITNESS_SCRIPT'] = 1)] = 'WITNESS_SCRIPT';
+  OutputTypes[(OutputTypes['BIP32_DERIVATION'] = 2)] = 'BIP32_DERIVATION';
+  OutputTypes[(OutputTypes['TAP_INTERNAL_KEY'] = 5)] = 'TAP_INTERNAL_KEY';
+  OutputTypes[(OutputTypes['TAP_TREE'] = 6)] = 'TAP_TREE';
+  OutputTypes[(OutputTypes['TAP_BIP32_DERIVATION'] = 7)] =
+    'TAP_BIP32_DERIVATION';
+})(OutputTypes || (OutputTypes = {}));
+
+const range = n => [...Array(n).keys()];
+const isValidDERKey = pubkey =>
+  (pubkey.length === 33 && [2, 3].includes(pubkey[0])) ||
+  (pubkey.length === 65 && 4 === pubkey[0]);
+function makeConverter$4(TYPE_BYTE, isValidPubkey = isValidDERKey) {
+  function decode(keyVal) {
+    if (keyVal.key[0] !== TYPE_BYTE) {
+      throw new Error(
+        'Decode Error: could not decode bip32Derivation with key 0x' +
+          toHex(keyVal.key),
+      );
+    }
+    const pubkey = keyVal.key.slice(1);
+    if (!isValidPubkey(pubkey)) {
+      throw new Error(
+        'Decode Error: bip32Derivation has invalid pubkey in key 0x' +
+          toHex(keyVal.key),
+      );
+    }
+    if ((keyVal.value.length / 4) % 1 !== 0) {
+      throw new Error(
+        'Decode Error: Input BIP32_DERIVATION value length should be multiple of 4',
+      );
+    }
+    const data = {
+      masterFingerprint: keyVal.value.slice(0, 4),
+      pubkey,
+      path: 'm',
+    };
+    for (const i of range(keyVal.value.length / 4 - 1)) {
+      const val = readUInt32(keyVal.value, i * 4 + 4, 'LE');
+      const isHard = !!(val & 0x80000000);
+      const idx = val & 0x7fffffff;
+      data.path += '/' + idx.toString(10) + (isHard ? "'" : '');
+    }
+    return data;
+  }
+  function encode(data) {
+    const head = Uint8Array.from([TYPE_BYTE]);
+    const key = concat([head, data.pubkey]);
+    const splitPath = data.path.split('/');
+    const value = new Uint8Array(splitPath.length * 4);
+    value.set(data.masterFingerprint, 0);
+    let offset = 4;
+    splitPath.slice(1).forEach(level => {
+      const isHard = level.slice(-1) === "'";
+      let num = 0x7fffffff & parseInt(isHard ? level.slice(0, -1) : level, 10);
+      if (isHard) num += 0x80000000;
+      writeUInt32(value, offset, num, 'LE');
+      offset += 4;
+    });
+    return {
+      key,
+      value,
+    };
+  }
+  const expected =
+    '{ masterFingerprint: Uint8Array; pubkey: Uint8Array; path: string; }';
+  function check(data) {
+    return (
+      data.pubkey instanceof Uint8Array &&
+      data.masterFingerprint instanceof Uint8Array &&
+      typeof data.path === 'string' &&
+      isValidPubkey(data.pubkey) &&
+      data.masterFingerprint.length === 4
+    );
+  }
+  function canAddToArray(array, item, dupeSet) {
+    const dupeString = toHex(item.pubkey);
+    if (dupeSet.has(dupeString)) return false;
+    dupeSet.add(dupeString);
+    return (
+      array.filter(v => compare(v.pubkey, item.pubkey) === 0).length === 0
+    );
+  }
+  return {
+    decode,
+    encode,
+    check,
+    expected,
+    canAddToArray,
+  };
+}
+
+function makeChecker(pubkeyTypes) {
+  return checkPubkey;
+  function checkPubkey(keyVal) {
+    let pubkey;
+    if (pubkeyTypes.includes(keyVal.key[0])) {
+      pubkey = keyVal.key.slice(1);
+      if (
+        !(pubkey.length === 33 || pubkey.length === 65) ||
+        ![2, 3, 4].includes(pubkey[0])
+      ) {
+        throw new Error(
+          'Format Error: invalid pubkey in key 0x' + toHex(keyVal.key),
+        );
+      }
+    }
+    return pubkey;
+  }
+}
+
+function makeConverter$3(TYPE_BYTE) {
+  function decode(keyVal) {
+    if (keyVal.key[0] !== TYPE_BYTE) {
+      throw new Error(
+        'Decode Error: could not decode redeemScript with key 0x' +
+          toHex(keyVal.key),
+      );
+    }
+    return keyVal.value;
+  }
+  function encode(data) {
+    const key = Uint8Array.from([TYPE_BYTE]);
+    return {
+      key,
+      value: data,
+    };
+  }
+  const expected = 'Uint8Array';
+  function check(data) {
+    return data instanceof Uint8Array;
+  }
+  function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.redeemScript === undefined;
+  }
+  return {
+    decode,
+    encode,
+    check,
+    expected,
+    canAdd,
+  };
+}
+
+const isValidBIP340Key = pubkey => pubkey.length === 32;
+function makeConverter$2(TYPE_BYTE) {
+  const parent = makeConverter$4(TYPE_BYTE, isValidBIP340Key);
+  function decode$1(keyVal) {
+    const { numberValue: nHashes, bytes: nHashesLen } = decode(
+      keyVal.value,
+    );
+    const base = parent.decode({
+      key: keyVal.key,
+      value: keyVal.value.slice(nHashesLen + Number(nHashes) * 32),
+    });
+    const leafHashes = new Array(Number(nHashes));
+    for (let i = 0, _offset = nHashesLen; i < nHashes; i++, _offset += 32) {
+      leafHashes[i] = keyVal.value.slice(_offset, _offset + 32);
+    }
+    return { ...base, leafHashes };
+  }
+  function encode$1(data) {
+    const base = parent.encode(data);
+    const nHashesLen = encodingLength(data.leafHashes.length);
+    const nHashesBuf = new Uint8Array(nHashesLen);
+    encode(data.leafHashes.length, nHashesBuf);
+    const value = concat([nHashesBuf, ...data.leafHashes, base.value]);
+    return { ...base, value };
+  }
+  const expected =
+    '{ ' +
+    'masterFingerprint: Uint8Array; ' +
+    'pubkey: Uint8Array; ' +
+    'path: string; ' +
+    'leafHashes: Uint8Array[]; ' +
+    '}';
+  function check(data) {
+    return (
+      Array.isArray(data.leafHashes) &&
+      data.leafHashes.every(
+        leafHash => leafHash instanceof Uint8Array && leafHash.length === 32,
+      ) &&
+      parent.check(data)
+    );
+  }
+  return {
+    decode: decode$1,
+    encode: encode$1,
+    check,
+    expected,
+    canAddToArray: parent.canAddToArray,
+  };
+}
+
+function makeConverter$1(TYPE_BYTE) {
+  function decode(keyVal) {
+    if (keyVal.key[0] !== TYPE_BYTE || keyVal.key.length !== 1) {
+      throw new Error(
+        'Decode Error: could not decode tapInternalKey with key 0x' +
+          toHex(keyVal.key),
+      );
+    }
+    if (keyVal.value.length !== 32) {
+      throw new Error(
+        'Decode Error: tapInternalKey not a 32-byte x-only pubkey',
+      );
+    }
+    return keyVal.value;
+  }
+  function encode(value) {
+    const key = Uint8Array.from([TYPE_BYTE]);
+    return { key, value };
+  }
+  const expected = 'Uint8Array';
+  function check(data) {
+    return data instanceof Uint8Array && data.length === 32;
+  }
+  function canAdd(currentData, newData) {
+    return (
+      !!currentData && !!newData && currentData.tapInternalKey === undefined
+    );
+  }
+  return {
+    decode,
+    encode,
+    check,
+    expected,
+    canAdd,
+  };
+}
+
+function makeConverter(TYPE_BYTE) {
+  function decode(keyVal) {
+    if (keyVal.key[0] !== TYPE_BYTE) {
+      throw new Error(
+        'Decode Error: could not decode witnessScript with key 0x' +
+          toHex(keyVal.key),
+      );
+    }
+    return keyVal.value;
+  }
+  function encode(data) {
+    const key = Uint8Array.from([TYPE_BYTE]);
+    return {
+      key,
+      value: data,
+    };
+  }
+  const expected = 'Uint8Array';
+  function check(data) {
+    return data instanceof Uint8Array;
+  }
+  function canAdd(currentData, newData) {
+    return (
+      !!currentData && !!newData && currentData.witnessScript === undefined
+    );
+  }
+  return {
+    decode,
+    encode,
+    check,
+    expected,
+    canAdd,
+  };
+}
+
+({
+  bip32Derivation: makeConverter$4(InputTypes.BIP32_DERIVATION),
+  redeemScript: makeConverter$3(InputTypes.REDEEM_SCRIPT),
+  witnessScript: makeConverter(InputTypes.WITNESS_SCRIPT),
+  checkPubkey: makeChecker([
+    InputTypes.PARTIAL_SIG,
+    InputTypes.BIP32_DERIVATION,
+  ]),
+  tapBip32Derivation: makeConverter$2(
+    InputTypes.TAP_BIP32_DERIVATION,
+  ),
+  tapInternalKey: makeConverter$1(InputTypes.TAP_INTERNAL_KEY)});
+({
+  bip32Derivation: makeConverter$4(OutputTypes.BIP32_DERIVATION),
+  redeemScript: makeConverter$3(OutputTypes.REDEEM_SCRIPT),
+  witnessScript: makeConverter(OutputTypes.WITNESS_SCRIPT),
+  checkPubkey: makeChecker([OutputTypes.BIP32_DERIVATION]),
+  tapBip32Derivation: makeConverter$2(
+    OutputTypes.TAP_BIP32_DERIVATION,
+  ),
+  tapInternalKey: makeConverter$1(OutputTypes.TAP_INTERNAL_KEY),
+});
+
+export { taggedHash as A, BufferSchema as B, concat as C, encodingLength as D, encode as E, isTapleaf as F, number as G, Hash160bitSchema as H, isTaptree as I, union as J, fromHex as K, testnet as L, regtest as M, NBufferSchemaFactory as N, OPS$1 as O, TAPLEAF_VERSION_MASK as T, parse as a, bitcoin as b, prop as c, compare as d, decompile as e, countNonPushOnlyOPs as f, partial as g, hash160 as h, isPushOnly as i, array as j, string as k, compile as l, isPoint as m, isCanonicalScriptSignature as n, object as o, p2ms as p, custom as q, readUInt8 as r, stacksEqual as s, distExports as t, NullablePartial as u, value as v, writeUInt8 as w, Buffer256bitSchema as x, toStack as y, ripemd160 as z };