@qntx/wallet-worker 0.2.0 → 0.3.0

package/dist/worker-7sztn879.js

@@ -0,0 +1,4446 @@
+import {
+  anumber,
+  concatBytes,
+  sha256,
+  abytes2,
+  bytesToNumberBE,
+  numberToBytesBE,
+  validateObject,
+  secp256k1,
+  schnorr,
+  createBase58check,
+  bech32,
+  bech32m,
+  utf8,
+  hex,
+  ripemd160
+} from "./worker-nhrchcf5.js";
+
+// ../../node_modules/.bun/micro-packed@0.11.1/node_modules/micro-packed/index.js
+var EMPTY = /* @__PURE__ */ Uint8Array.of();
+var NULL = /* @__PURE__ */ Uint8Array.of(0);
+var restrictedKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var validateFieldName = (name, label) => {
+  if (typeof name !== "string")
+    throw new Error(`${label} should be string, got ${typeof name}`);
+  if (name.includes(".."))
+    throw new TypeError(`${label} ${name} cannot contain path parent ..`);
+  if (name.includes("/"))
+    throw new TypeError(`${label} ${name} cannot contain path separator /`);
+  if (restrictedKeys.has(name))
+    throw new Error(`${label} ${name} is reserved`);
+};
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+}
+function createFindBytes(needle) {
+  if (needle.length === 1) {
+    const byte = needle[0];
+    return (data, pos = 0) => {
+      const idx = data.indexOf(byte, pos);
+      return idx === -1 ? undefined : idx;
+    };
+  }
+  const back = new Uint32Array(needle.length);
+  for (let i = 1, j = 0;i < needle.length; i++) {
+    while (j && needle[i] !== needle[j])
+      j = back[j - 1];
+    if (needle[i] === needle[j])
+      back[i] = ++j;
+  }
+  return (data, pos = 0) => {
+    for (let i = pos, j = 0;i < data.length; i++) {
+      while (j && data[i] !== needle[j])
+        j = back[j - 1];
+      if (data[i] !== needle[j])
+        continue;
+      if (++j === needle.length)
+        return i - needle.length + 1;
+    }
+    return;
+  };
+}
+var findBytes = (needle, data, pos = 0) => createFindBytes(needle)(data, pos);
+function equal(a, b) {
+  const aBytes = isBytes(a);
+  const bBytes = isBytes(b);
+  if (aBytes || bBytes)
+    return aBytes && bBytes && equalBytes(a, b);
+  return a === b;
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function concatBytes2(...arrays) {
+  let sum = 0;
+  for (let i = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    if (!isBytes(a))
+      throw new Error("Uint8Array expected");
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var _0n = /* @__PURE__ */ BigInt(0);
+var _1n = /* @__PURE__ */ BigInt(1);
+var _2n = /* @__PURE__ */ BigInt(2);
+var _8n = /* @__PURE__ */ BigInt(8);
+var _10n = /* @__PURE__ */ BigInt(10);
+var _255n = /* @__PURE__ */ BigInt(255);
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isNum(num) {
+  return Number.isSafeInteger(num);
+}
+var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var utils = /* @__PURE__ */ Object.freeze({
+  equalBytes,
+  isBytes,
+  isCoder,
+  checkBounds,
+  concatBytes: concatBytes2,
+  createView,
+  isPlainObject
+});
+var lengthCoder = (len) => {
+  if (len !== null && typeof len !== "string" && !isCoder(len) && !isBytes(len) && !isNum(len)) {
+    throw new TypeError(`lengthCoder: expected null | number | Uint8Array | CoderType, got ${len} (${typeof len})`);
+  }
+  if (typeof len === "number" && len < 0)
+    throw new Error(`lengthCoder: wrong length=${len}`);
+  if (isBytes(len) && !len.length)
+    throw new Error("lengthCoder: empty terminator");
+  return {
+    encodeStream(w, value) {
+      if (len === null)
+        return;
+      if (isCoder(len))
+        return len.encodeStream(w, value);
+      let byteLen;
+      if (typeof len === "number")
+        byteLen = len;
+      else if (typeof len === "string")
+        byteLen = Path.resolve(w.stack, len);
+      if (typeof byteLen === "bigint")
+        byteLen = Number(byteLen);
+      if (!isNum(byteLen) || byteLen < 0 || byteLen !== value)
+        throw w.err(`Wrong length: ${byteLen} len=${len} exp=${value} (${typeof value})`);
+    },
+    decodeStream(r) {
+      let byteLen;
+      if (isCoder(len))
+        byteLen = len.decodeStream(r);
+      else if (typeof len === "number")
+        byteLen = len;
+      else if (typeof len === "string")
+        byteLen = Path.resolve(r.stack, len);
+      if (typeof byteLen === "bigint")
+        byteLen = Number(byteLen);
+      else if (typeof byteLen !== "number")
+        throw r.err(`Wrong length: ${byteLen}`);
+      if (!isNum(byteLen) || byteLen < 0)
+        throw r.err(`Wrong length: ${byteLen}`);
+      return byteLen;
+    }
+  };
+};
+var Bitset = /* @__PURE__ */ Object.freeze({
+  BITS: 32,
+  FULL_MASK: -1 >>> 0,
+  len: (len) => {
+    if (!isNum(len) || len < 0)
+      throw new Error(`wrong len=${len}`);
+    return Math.ceil(len / 32);
+  },
+  create: (len) => new Uint32Array(Bitset.len(len)),
+  clean: (bs) => bs.fill(0),
+  debug: (bs) => Array.from(bs).map((i) => (i >>> 0).toString(2).padStart(32, "0")),
+  checkLen: (bs, len) => {
+    if (Bitset.len(len) === bs.length)
+      return;
+    throw new Error(`wrong length=${bs.length}. Expected: ${Bitset.len(len)}`);
+  },
+  chunkLen: (bsLen, pos, len) => {
+    if (!isNum(bsLen) || bsLen < 0)
+      throw new Error(`wrong bsLen=${bsLen}`);
+    if (!isNum(pos) || pos < 0)
+      throw new Error(`wrong pos=${pos}`);
+    if (!isNum(len) || len < 0)
+      throw new Error(`wrong len=${len}`);
+    if (pos > bsLen - len)
+      throw new Error(`wrong range=${pos}/${len} of ${bsLen}`);
+  },
+  set: (bs, chunk, value, allowRewrite = true) => {
+    if (!isNum(chunk) || chunk < 0 || chunk >= bs.length)
+      return false;
+    if (!allowRewrite && (bs[chunk] & value) !== 0)
+      return false;
+    bs[chunk] |= value;
+    return true;
+  },
+  pos: (pos, i) => ({
+    chunk: Math.floor((pos + i) / 32),
+    mask: 1 << 32 - (pos + i) % 32 - 1
+  }),
+  indices: (bs, len, invert = false) => {
+    Bitset.checkLen(bs, len);
+    const { FULL_MASK, BITS } = Bitset;
+    const left = BITS - len % BITS;
+    const lastMask = left ? FULL_MASK >>> left << left : FULL_MASK;
+    const res = [];
+    for (let i = 0;i < bs.length; i++) {
+      let c = bs[i];
+      if (invert)
+        c = ~c;
+      if (i === bs.length - 1)
+        c &= lastMask;
+      if (c === 0)
+        continue;
+      for (let j = 0;j < BITS; j++) {
+        const m = 1 << BITS - j - 1;
+        if (c & m)
+          res.push(i * BITS + j);
+      }
+    }
+    return res;
+  },
+  range: (arr) => {
+    const res = [];
+    let cur;
+    for (const i of arr) {
+      if (cur === undefined || i !== cur.pos + cur.length)
+        res.push(cur = { pos: i, length: 1 });
+      else
+        cur.length += 1;
+    }
+    return res;
+  },
+  rangeDebug: (bs, len, invert = false) => `[${Bitset.range(Bitset.indices(bs, len, invert)).map((i) => `(${i.pos}/${i.length})`).join(", ")}]`,
+  setRange: (bs, bsLen, pos, len, allowRewrite = true) => {
+    Bitset.chunkLen(bsLen, pos, len);
+    if (len === 0)
+      return true;
+    const { FULL_MASK, BITS } = Bitset;
+    const first = pos % BITS ? Math.floor(pos / BITS) : undefined;
+    const lastPos = pos + len;
+    const last = lastPos % BITS ? Math.floor(lastPos / BITS) : undefined;
+    const canSet = (chunk, value) => chunk >= 0 && chunk < bs.length && (bs[chunk] & value) === 0;
+    if (!allowRewrite) {
+      if (first !== undefined && first === last) {
+        if (!canSet(first, FULL_MASK >>> BITS - len << BITS - len - pos))
+          return false;
+      } else {
+        if (first !== undefined && !canSet(first, FULL_MASK >>> pos % BITS))
+          return false;
+        const start = first !== undefined ? first + 1 : pos / BITS;
+        const end = last !== undefined ? last : lastPos / BITS;
+        for (let i = start;i < end; i++)
+          if (!canSet(i, FULL_MASK))
+            return false;
+        if (last !== undefined && first !== last) {
+          if (!canSet(last, FULL_MASK << BITS - lastPos % BITS))
+            return false;
+        }
+      }
+    }
+    if (first !== undefined && first === last)
+      return Bitset.set(bs, first, FULL_MASK >>> BITS - len << BITS - len - pos, allowRewrite);
+    if (first !== undefined) {
+      if (!Bitset.set(bs, first, FULL_MASK >>> pos % BITS, allowRewrite))
+        return false;
+    }
+    const start = first !== undefined ? first + 1 : pos / BITS;
+    const end = last !== undefined ? last : lastPos / BITS;
+    for (let i = start;i < end; i++)
+      if (!Bitset.set(bs, i, FULL_MASK, allowRewrite))
+        return false;
+    if (last !== undefined && first !== last) {
+      if (!Bitset.set(bs, last, FULL_MASK << BITS - lastPos % BITS, allowRewrite))
+        return false;
+    }
+    return true;
+  }
+});
+var Path = /* @__PURE__ */ Object.freeze({
+  pushObj: (stack, obj, objFn) => {
+    stack.push({ obj });
+    objFn();
+    stack.pop();
+  },
+  path: (stack) => {
+    const res = [];
+    for (const i of stack)
+      if (i.field !== undefined)
+        res.push(i.field === "" ? '""' : `${i.field}`);
+    return res.join("/");
+  },
+  err: (name, stack, msg) => {
+    const text = `${name}(${Path.path(stack)}): ${typeof msg === "string" ? msg : msg.message}`;
+    const err = msg instanceof TypeError ? new TypeError(text) : msg instanceof RangeError ? new RangeError(text) : new Error(text);
+    if (msg instanceof Error && msg.stack) {
+      const from = `${msg.name}: ${msg.message}`;
+      const to = `${err.name}: ${err.message}`;
+      err.stack = msg.stack.startsWith(from) ? `${to}${msg.stack.slice(from.length)}` : msg.stack;
+    }
+    return err;
+  },
+  resolve: (stack, path) => {
+    const parts = path.split("/");
+    const objPath = stack.map((i) => i.obj);
+    let i = 0;
+    for (;i < parts.length; i++) {
+      if (parts[i] === "..")
+        objPath.pop();
+      else
+        break;
+    }
+    let cur = objPath.pop();
+    for (;i < parts.length; i++) {
+      if (!cur || cur[parts[i]] === undefined)
+        return;
+      cur = cur[parts[i]];
+    }
+    return cur;
+  }
+});
+
+class _Reader {
+  pos = 0;
+  data;
+  opts;
+  stack;
+  parent;
+  parentOffset;
+  bitBuf = 0;
+  bitPos = 0;
+  bs;
+  view;
+  constructor(data, opts = {}, stack = [], parent = undefined, parentOffset = 0) {
+    if (!isBytes(data))
+      throw new TypeError(`Reader: expected Uint8Array, got ${typeof data}`);
+    if (!isPlainObject(opts))
+      throw new TypeError(`ReaderOpts: expected plain object, got ${opts}`);
+    if (opts.allowUnreadBytes !== undefined && typeof opts.allowUnreadBytes !== "boolean")
+      throw new TypeError(`ReaderOpts.allowUnreadBytes: expected boolean, got ${typeof opts.allowUnreadBytes}`);
+    if (opts.allowMultipleReads !== undefined && typeof opts.allowMultipleReads !== "boolean")
+      throw new TypeError(`ReaderOpts.allowMultipleReads: expected boolean, got ${typeof opts.allowMultipleReads}`);
+    this.data = data;
+    this.opts = opts;
+    this.stack = stack;
+    this.parent = parent;
+    this.parentOffset = parentOffset;
+    this.view = createView(data);
+  }
+  _enablePointers() {
+    if (this.parent)
+      return this.parent._enablePointers();
+    if (this.bs)
+      return;
+    this.bs = Bitset.create(this.data.length);
+    Bitset.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads);
+  }
+  markBytesBS(pos, len) {
+    if (this.parent)
+      return this.parent.markBytesBS(this.parentOffset + pos, len);
+    if (!len)
+      return true;
+    if (!this.bs)
+      return true;
+    return Bitset.setRange(this.bs, this.data.length, pos, len, false);
+  }
+  markBytes(len) {
+    const pos = this.pos;
+    const res = this.markBytesBS(pos, len);
+    if (!this.opts.allowMultipleReads && !res)
+      throw this.err(`multiple read pos=${pos} len=${len}`);
+    this.pos += len;
+    return res;
+  }
+  pushObj(obj, objFn) {
+    return Path.pushObj(this.stack, obj, objFn);
+  }
+  enterField(field) {
+    const last = this.stack[this.stack.length - 1];
+    if (last === undefined || last.field !== undefined)
+      throw this.err(`enterField: invalid stack state, field=${field}`);
+    last.field = field;
+  }
+  exitField() {
+    this.stack[this.stack.length - 1].field = undefined;
+  }
+  readView(n, fn) {
+    if (!isNum(n) || n < 0)
+      throw this.err(`readView: wrong length=${n}`);
+    if (this.pos + n > this.data.length)
+      throw this.err("readView: Unexpected end of buffer");
+    const res = fn(this.view, this.pos);
+    this.markBytes(n);
+    return res;
+  }
+  absBytes(n) {
+    if (!isNum(n) || n < 0 || n > this.data.length)
+      throw new Error("Unexpected end of buffer");
+    return this.data.subarray(n);
+  }
+  finish() {
+    if (this.opts.allowUnreadBytes)
+      return;
+    if (this.bitPos) {
+      throw this.err(`${this.bitPos} bits left after unpack: ${hex.encode(this.data.subarray(this.pos))}`);
+    }
+    if (this.bs && !this.parent) {
+      const notRead = Bitset.indices(this.bs, this.data.length, true);
+      if (notRead.length) {
+        const formatted = Bitset.range(notRead).map(({ pos, length }) => `(${pos}/${length})[${hex.encode(this.data.subarray(pos, pos + length))}]`).join(", ");
+        throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
+      } else
+        return;
+    }
+    if (!this.isEnd()) {
+      throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${hex.encode(this.data.subarray(this.pos))}`);
+    }
+  }
+  err(msg) {
+    return Path.err("Reader", this.stack, msg);
+  }
+  offsetReader(n) {
+    if (!isNum(n) || n < 0 || n > this.data.length)
+      throw this.err("offsetReader: Unexpected end of buffer");
+    return new _Reader(this.absBytes(n), this.opts, this.stack, this, n);
+  }
+  bytes(n, peek = false) {
+    if (this.bitPos)
+      throw this.err("readBytes: bitPos not empty");
+    if (!isNum(n) || n < 0)
+      throw this.err(`readBytes: wrong length=${n}`);
+    if (this.pos + n > this.data.length)
+      throw this.err("readBytes: Unexpected end of buffer");
+    const slice = this.data.subarray(this.pos, this.pos + n);
+    if (!peek)
+      this.markBytes(n);
+    return slice;
+  }
+  byte(peek = false) {
+    if (this.bitPos)
+      throw this.err("readByte: bitPos not empty");
+    if (this.pos + 1 > this.data.length)
+      throw this.err("readByte: Unexpected end of buffer");
+    const data = this.data[this.pos];
+    if (!peek)
+      this.markBytes(1);
+    return data;
+  }
+  get leftBytes() {
+    return this.data.length - this.pos;
+  }
+  get totalBytes() {
+    return this.data.length;
+  }
+  isEnd() {
+    return this.pos >= this.data.length && !this.bitPos;
+  }
+  progress() {
+    return this.pos * 8 - this.bitPos;
+  }
+  bits(bits) {
+    if (!isNum(bits) || bits < 0)
+      throw this.err(`BitReader: wrong length=${bits}`);
+    if (bits > 32)
+      throw this.err("BitReader: cannot read more than 32 bits in single call");
+    let out = 0;
+    while (bits) {
+      if (!this.bitPos) {
+        this.bitBuf = this.byte();
+        this.bitPos = 8;
+      }
+      const take = Math.min(bits, this.bitPos);
+      this.bitPos -= take;
+      out = out << take | this.bitBuf >> this.bitPos & 2 ** take - 1;
+      this.bitBuf &= 2 ** this.bitPos - 1;
+      bits -= take;
+    }
+    return out >>> 0;
+  }
+  find(needle, pos = this.pos) {
+    if (!isBytes(needle))
+      throw this.err(`find: needle is not bytes! ${needle}`);
+    if (this.bitPos)
+      throw this.err("find: bitPos not empty");
+    if (!needle.length)
+      throw this.err(`find: needle is empty`);
+    if (!isNum(pos) || pos < 0)
+      throw this.err(`find: wrong pos=${pos}`);
+    return findBytes(needle, this.data, pos);
+  }
+}
+
+class _Writer {
+  pos = 0;
+  stack;
+  buffers = [];
+  chunks = [];
+  chunk;
+  chunkView;
+  chunkPos = 0;
+  run;
+  nextChunkSize = 0;
+  ptrs = [];
+  bitBuf = 0;
+  bitPos = 0;
+  finished = false;
+  constructor(stack = []) {
+    this.stack = stack;
+  }
+  carve(len) {
+    if (this.chunk === undefined || this.chunk.length - this.chunkPos < len) {
+      const size = Math.max(len, this.nextChunkSize, 64);
+      this.nextChunkSize = Math.min(size * 8, 4096);
+      this.chunk = new Uint8Array(size);
+      this.chunkView = undefined;
+      this.chunkPos = 0;
+      this.run = undefined;
+      this.chunks.push(this.chunk);
+    }
+    const pos = this.chunkPos;
+    if (this.run === undefined) {
+      this.run = { chunk: this.chunk, start: pos, end: pos + len };
+      this.buffers.push(this.run);
+    } else
+      this.run.end += len;
+    this.chunkPos = pos + len;
+    this.pos += len;
+    return pos;
+  }
+  pushObj(obj, objFn) {
+    return Path.pushObj(this.stack, obj, objFn);
+  }
+  enterField(field) {
+    const last = this.stack[this.stack.length - 1];
+    if (last === undefined || last.field !== undefined)
+      throw this.err(`enterField: invalid stack state, field=${field}`);
+    last.field = field;
+  }
+  exitField() {
+    this.stack[this.stack.length - 1].field = undefined;
+  }
+  writeView(len, fn) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (!isNum(len) || len < 0 || len > 8)
+      throw new Error(`wrong writeView length=${len}`);
+    if (this.bitPos)
+      throw this.err("writeBytes: ends with non-empty bit buffer");
+    const pos = this.carve(len);
+    if (this.chunkView === undefined)
+      this.chunkView = createView(this.chunk);
+    fn(this.chunkView, pos);
+  }
+  err(msg) {
+    return Path.err("Writer", this.stack, msg);
+  }
+  bytes(b) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeBytes: ends with non-empty bit buffer");
+    if (!isBytes(b))
+      throw this.err(`writeBytes: expected Uint8Array, got ${typeof b}`);
+    this.buffers.push(b);
+    this.run = undefined;
+    this.pos += b.length;
+  }
+  byte(b) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeByte: ends with non-empty bit buffer");
+    if (!isNum(b) || b < 0 || b > 255)
+      throw this.err(`writeByte: wrong value=${b}`);
+    const pos = this.carve(1);
+    this.chunk[pos] = b;
+  }
+  finish(clean = true) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("buffer: ends with non-empty bit buffer");
+    const buffers = this.buffers;
+    let sum = 0;
+    for (let i = 0;i < buffers.length; i++) {
+      const b = buffers[i];
+      sum += isBytes(b) ? b.length : b.end - b.start;
+    }
+    for (let i = 0;i < this.ptrs.length; i++)
+      sum += this.ptrs[i].buffer.length;
+    const buf = new Uint8Array(sum);
+    let pad = 0;
+    for (let i = 0;i < buffers.length; i++) {
+      const b = buffers[i];
+      if (isBytes(b)) {
+        buf.set(b, pad);
+        pad += b.length;
+      } else {
+        buf.set(b.chunk.subarray(b.start, b.end), pad);
+        pad += b.end - b.start;
+      }
+    }
+    for (let i = 0;i < this.ptrs.length; i++) {
+      buf.set(this.ptrs[i].buffer, pad);
+      pad += this.ptrs[i].buffer.length;
+    }
+    for (let pos = this.pos, i = 0;i < this.ptrs.length; i++) {
+      const ptr = this.ptrs[i];
+      buf.set(ptr.ptr.encode(pos), ptr.pos);
+      pos += ptr.buffer.length;
+    }
+    if (clean) {
+      for (const c of this.chunks)
+        c.fill(0);
+      this.chunks = [];
+      this.chunk = undefined;
+      this.chunkView = undefined;
+      this.chunkPos = 0;
+      this.run = undefined;
+      this.buffers = [];
+      for (const p of this.ptrs)
+        p.buffer.fill(0);
+      this.ptrs = [];
+      this.finished = true;
+      this.bitBuf = 0;
+    }
+    return buf;
+  }
+  bits(value, bits) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (!isNum(bits) || bits < 0)
+      throw this.err(`writeBits: wrong length=${bits}`);
+    if (bits > 32)
+      throw this.err("writeBits: cannot write more than 32 bits in single call");
+    if (!isNum(value) || value < 0)
+      throw this.err(`writeBits: wrong value=${value}`);
+    if (value >= 2 ** bits)
+      throw this.err(`writeBits: value (${value}) >= 2**bits (${bits})`);
+    while (bits) {
+      const take = Math.min(bits, 8 - this.bitPos);
+      this.bitBuf = this.bitBuf << take | value >> bits - take;
+      this.bitPos += take;
+      bits -= take;
+      value &= 2 ** bits - 1;
+      if (this.bitPos === 8) {
+        this.bitPos = 0;
+        const pos = this.carve(1);
+        this.chunk[pos] = this.bitBuf;
+      }
+    }
+  }
+}
+var swapEndianness = (b) => Uint8Array.from(b).reverse();
+function checkMinimalBigintBytes(value, le, signed, err) {
+  if (!value.length)
+    return;
+  const b = le ? swapEndianness(value) : value;
+  const fail = () => {
+    throw err("bigint: non-minimal encoding");
+  };
+  if (!signed) {
+    if (b[0] === 0)
+      fail();
+    return;
+  }
+  if (b[0] === 0 && (b.length === 1 || (b[1] & 128) === 0))
+    fail();
+  if (b.length > 1 && b[0] === 255 && (b[1] & 128) !== 0)
+    fail();
+}
+function checkBounds(value, bits, signed) {
+  if (signed) {
+    if (bits <= _0n)
+      throw new Error(`checkBounds: signed bits must be positive, got ${bits}`);
+    const signBit = _2n ** (bits - _1n);
+    if (value < -signBit || value >= signBit)
+      throw new Error(`value out of signed bounds. Expected ${-signBit} <= ${value} < ${signBit}`);
+  } else {
+    const max = _2n ** bits;
+    if (_0n > value || value >= max)
+      throw new Error(`value out of unsigned bounds. Expected 0 <= ${value} < ${max}`);
+  }
+}
+function _wrap(inner) {
+  const _inner = inner;
+  return {
+    encodeStream: _inner.encodeStream,
+    decodeStream: _inner.decodeStream,
+    size: _inner.size,
+    encode: (value) => {
+      const w = new _Writer;
+      _inner.encodeStream(w, value);
+      return w.finish();
+    },
+    decode: (data, opts = {}) => {
+      if (!isBytes(data))
+        throw new TypeError(`decode: expected Uint8Array, got ${typeof data}`);
+      const r = new _Reader(data, opts);
+      const res = _inner.decodeStream(r);
+      r.finish();
+      return res;
+    }
+  };
+}
+function validate(inner, fn) {
+  if (!isCoder(inner))
+    throw new TypeError(`validate: invalid inner value ${inner}`);
+  if (typeof fn !== "function")
+    throw new TypeError("validate: fn should be function");
+  return _wrap({
+    size: inner.size,
+    encodeStream: (w, value) => {
+      let res;
+      try {
+        res = fn(value);
+      } catch (e) {
+        throw w.err(e);
+      }
+      inner.encodeStream(w, res);
+    },
+    decodeStream: (r) => {
+      const res = inner.decodeStream(r);
+      try {
+        return fn(res);
+      } catch (e) {
+        throw r.err(e);
+      }
+    }
+  });
+}
+var wrap = (inner) => {
+  const _inner = inner;
+  if (!isPlainObject(_inner))
+    throw new TypeError(`wrap: invalid inner value ${_inner}`);
+  if (typeof _inner.encodeStream !== "function")
+    throw new TypeError("wrap: encodeStream should be function");
+  if (typeof _inner.decodeStream !== "function")
+    throw new TypeError("wrap: decodeStream should be function");
+  if (_inner.size !== undefined && (!isNum(_inner.size) || _inner.size < 0))
+    throw new TypeError(`wrap: invalid size ${_inner.size}`);
+  if (_inner.validate !== undefined && typeof _inner.validate !== "function")
+    throw new TypeError("wrap: validate should be function");
+  const res = _wrap(_inner);
+  return _inner.validate !== undefined ? validate(res, _inner.validate) : res;
+};
+var isBaseCoder = (elm) => isPlainObject(elm) && typeof elm.decode === "function" && typeof elm.encode === "function";
+function isCoder(elm) {
+  return isPlainObject(elm) && isBaseCoder(elm) && typeof elm.encodeStream === "function" && typeof elm.decodeStream === "function" && (elm.size === undefined || isNum(elm.size) && elm.size >= 0);
+}
+function dict() {
+  return {
+    encode: (from) => {
+      if (!Array.isArray(from))
+        throw new Error("array expected");
+      const to = {};
+      const seen = new Set;
+      for (const item of from) {
+        if (!Array.isArray(item) || item.length !== 2)
+          throw new Error(`array of two elements expected`);
+        const name = item[0];
+        const value = item[1];
+        validateFieldName(name, "dict: key");
+        if (seen.has(name))
+          throw new Error(`key(${name}) appears twice in struct`);
+        seen.add(name);
+        to[name] = value;
+      }
+      return to;
+    },
+    decode: (to) => {
+      if (!isPlainObject(to))
+        throw new Error(`expected plain object, got ${to}`);
+      for (const name in to)
+        validateFieldName(name, "dict: key");
+      return Object.entries(to);
+    }
+  };
+}
+var numberBigint = /* @__PURE__ */ Object.freeze({
+  encode: (from) => {
+    if (typeof from !== "bigint")
+      throw new Error(`expected bigint, got ${typeof from}`);
+    if (from > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error(`element bigger than MAX_SAFE_INTEGER=${from}`);
+    if (from < BigInt(Number.MIN_SAFE_INTEGER))
+      throw new Error(`element smaller than MIN_SAFE_INTEGER=${from}`);
+    return Number(from);
+  },
+  decode: (to) => {
+    if (!isNum(to))
+      throw new Error("element is not a safe integer");
+    return BigInt(to);
+  }
+});
+function tsEnum(e) {
+  if (!isPlainObject(e))
+    throw new Error("plain object expected");
+  return {
+    encode: (from) => {
+      if (!isNum(from) || !(from in e))
+        throw new Error(`wrong value ${from}`);
+      return e[from];
+    },
+    decode: (to) => {
+      if (typeof to !== "string")
+        throw new Error(`wrong value ${typeof to}`);
+      const value = e[to];
+      if (!hasOwn(e, to) || !isNum(value))
+        throw new Error(`wrong value ${to}`);
+      return value;
+    }
+  };
+}
+function decimal(precision, round = false) {
+  if (!isNum(precision) || precision < 0)
+    throw new Error(`decimal/precision: wrong value ${precision}`);
+  if (typeof round !== "boolean")
+    throw new Error(`decimal/round: expected boolean, got ${typeof round}`);
+  const decimalMask = _10n ** BigInt(precision);
+  return {
+    encode: (from) => {
+      if (typeof from !== "bigint")
+        throw new Error(`expected bigint, got ${typeof from}`);
+      let s = (from < _0n ? -from : from).toString(10);
+      let sep = s.length - precision;
+      if (sep < 0) {
+        s = s.padStart(s.length - sep, "0");
+        sep = 0;
+      }
+      let i = s.length - 1;
+      for (;i >= sep && s[i] === "0"; i--)
+        ;
+      let int = s.slice(0, sep);
+      let frac = s.slice(sep, i + 1);
+      if (!int)
+        int = "0";
+      if (from < _0n)
+        int = "-" + int;
+      if (!frac)
+        return int;
+      return `${int}.${frac}`;
+    },
+    decode: (to) => {
+      if (typeof to !== "string")
+        throw new Error(`expected string, got ${typeof to}`);
+      let neg = false;
+      if (to.startsWith("-")) {
+        neg = true;
+        to = to.slice(1);
+      }
+      if (!/^(0|[1-9]\d*)(\.\d+)?$/.test(to))
+        throw new Error(`wrong string value=${to}`);
+      let sep = to.indexOf(".");
+      sep = sep === -1 ? to.length : sep;
+      const intS = to.slice(0, sep);
+      const fracS = to.slice(sep + 1).replace(/0+$/, "");
+      const int = BigInt(intS) * decimalMask;
+      if (!round && fracS.length > precision) {
+        throw new Error(`fractional part cannot be represented with this precision (num=${to}, prec=${precision})`);
+      }
+      const fracLen = Math.min(fracS.length, precision);
+      const frac = BigInt(fracS.slice(0, fracLen)) * _10n ** BigInt(precision - fracLen);
+      const value = int + frac;
+      if (neg && value === _0n)
+        throw new Error(`negative zero is not allowed`);
+      return neg ? -value : value;
+    }
+  };
+}
+function match(lst) {
+  if (!Array.isArray(lst))
+    throw new Error(`expected array, got ${typeof lst}`);
+  for (const i of lst)
+    if (!isBaseCoder(i))
+      throw new Error(`wrong base coder ${i}`);
+  return {
+    encode: (from) => {
+      for (const c of lst) {
+        let elm;
+        try {
+          elm = c.encode(from);
+        } catch {
+          continue;
+        }
+        if (elm !== undefined)
+          return elm;
+      }
+      throw new Error(`match/encode: cannot find match in ${from}`);
+    },
+    decode: (to) => {
+      for (const c of lst) {
+        let elm;
+        try {
+          elm = c.decode(to);
+        } catch {
+          continue;
+        }
+        if (elm !== undefined)
+          return elm;
+      }
+      throw new Error(`match/decode: cannot find match in ${to}`);
+    }
+  };
+}
+var reverse = (coder) => {
+  if (!isBaseCoder(coder))
+    throw new Error("BaseCoder expected");
+  return { encode: (to) => coder.decode(to), decode: (from) => coder.encode(from) };
+};
+var coders = /* @__PURE__ */ Object.freeze({ dict, numberBigint, tsEnum, decimal, match, reverse });
+var bigint = (size, le = false, signed = false, sized = true, minimal = false) => {
+  if (!isNum(size) || size <= 0)
+    throw new Error(`bigint/size: wrong value ${size}`);
+  if (typeof le !== "boolean")
+    throw new Error(`bigint/le: expected boolean, got ${typeof le}`);
+  if (typeof signed !== "boolean")
+    throw new Error(`bigint/signed: expected boolean, got ${typeof signed}`);
+  if (typeof sized !== "boolean")
+    throw new Error(`bigint/sized: expected boolean, got ${typeof sized}`);
+  if (typeof minimal !== "boolean")
+    throw new Error(`bigint/minimal: expected boolean, got ${typeof minimal}`);
+  const bLen = BigInt(size);
+  const signBit = _2n ** (_8n * bLen - _1n);
+  return wrap({
+    size: sized ? size : undefined,
+    encodeStream: (w, value) => {
+      const zero = value === _0n;
+      if (signed && value < 0)
+        value = value | signBit;
+      let res = new Uint8Array(size);
+      for (let i = size - 1;i >= 0; i--) {
+        res[i] = Number(value & _255n);
+        value >>= _8n;
+      }
+      if (!sized) {
+        let pos = 0;
+        if (signed) {
+          for (;pos < res.length - 1; pos++) {
+            const next = res[pos + 1];
+            if (res[pos] === 0 && (next & 128) === 0)
+              continue;
+            if (res[pos] === 255 && (next & 128) !== 0)
+              continue;
+            break;
+          }
+          res = zero ? res.subarray(res.length) : res.subarray(pos);
+        } else {
+          for (;pos < res.length; pos++)
+            if (res[pos] !== 0)
+              break;
+          res = res.subarray(pos);
+        }
+      }
+      w.bytes(le ? res.reverse() : res);
+    },
+    decodeStream: (r) => {
+      const value = r.bytes(sized ? size : Math.min(size, r.leftBytes));
+      if (!sized && minimal)
+        checkMinimalBigintBytes(value, le, signed, (msg) => r.err(msg));
+      let res = _0n;
+      if (le)
+        for (let i = value.length - 1;i >= 0; i--)
+          res = res << _8n | BigInt(value[i]);
+      else
+        for (let i = 0;i < value.length; i++)
+          res = res << _8n | BigInt(value[i]);
+      const sBit = sized || !value.length ? signBit : _2n ** (_8n * BigInt(value.length) - _1n);
+      if (signed && res & sBit)
+        res = (res ^ sBit) - sBit;
+      return res;
+    },
+    validate: (value) => {
+      if (typeof value !== "bigint")
+        throw new Error(`bigint: invalid value: ${value}`);
+      checkBounds(value, _8n * bLen, !!signed);
+      return value;
+    }
+  });
+};
+var U256LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ bigint(32, true));
+var U64LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ bigint(8, true));
+var I64LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ bigint(8, true, true));
+var view = (len, opts) => wrap({
+  size: len,
+  encodeStream: (w, value) => w.writeView(len, (view, pos) => opts.write(view, pos, value)),
+  decodeStream: (r) => r.readView(len, opts.read),
+  validate: (value) => {
+    if (typeof value !== "number")
+      throw new TypeError(`viewCoder: expected number, got ${typeof value}`);
+    if (opts.validate)
+      opts.validate(value);
+    return value;
+  }
+});
+var intView = (len, signed, opts) => {
+  const bits = len * 8;
+  const signBit = 2 ** (bits - 1);
+  const validateSigned = (value) => {
+    if (!isNum(value))
+      throw new TypeError(`sintView: value is not safe integer: ${value}`);
+    if (value < -signBit || value >= signBit) {
+      throw new RangeError(`sintView: value out of bounds. Expected ${-signBit} <= ${value} < ${signBit}`);
+    }
+  };
+  const maxVal = 2 ** bits;
+  const validateUnsigned = (value) => {
+    if (!isNum(value))
+      throw new TypeError(`uintView: value is not safe integer: ${value}`);
+    if (0 > value || value >= maxVal) {
+      throw new RangeError(`uintView: value out of bounds. Expected 0 <= ${value} < ${maxVal}`);
+    }
+  };
+  return view(len, {
+    write: opts.write,
+    read: opts.read,
+    validate: signed ? validateSigned : validateUnsigned
+  });
+};
+var U32LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ intView(4, false, {
+  read: (view, pos) => view.getUint32(pos, true),
+  write: (view, pos, value) => view.setUint32(pos, value, true)
+}));
+var U32BE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ intView(4, false, {
+  read: (view, pos) => view.getUint32(pos, false),
+  write: (view, pos, value) => view.setUint32(pos, value, false)
+}));
+var I32LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ intView(4, true, {
+  read: (view, pos) => view.getInt32(pos, true),
+  write: (view, pos, value) => view.setInt32(pos, value, true)
+}));
+var U16LE = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ intView(2, false, {
+  read: (view, pos) => view.getUint16(pos, true),
+  write: (view, pos, value) => view.setUint16(pos, value, true)
+}));
+var U8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ intView(1, false, {
+  read: (view, pos) => view.getUint8(pos),
+  write: (view, pos, value) => view.setUint8(pos, value)
+}));
+var createBytes = (len, le = false) => {
+  if (typeof le !== "boolean")
+    throw new TypeError(`bytes/le: expected boolean, got ${typeof le}`);
+  const _length = lengthCoder(len);
+  const _isb = isBytes(len);
+  const terminator = _isb ? Uint8Array.from(len) : undefined;
+  const findTerminator = terminator && terminator.length ? createFindBytes(terminator) : undefined;
+  return wrap({
+    size: typeof len === "number" ? len : undefined,
+    encodeStream: (w, value) => {
+      if (!_isb)
+        _length.encodeStream(w, value.length);
+      w.bytes(le ? swapEndianness(value) : value);
+      if (terminator)
+        w.bytes(terminator);
+    },
+    decodeStream: (r) => {
+      let bytes;
+      if (terminator) {
+        const tPos = r.find(terminator);
+        if (tPos === undefined)
+          throw r.err(`bytes: cannot find terminator`);
+        bytes = r.bytes(tPos - r.pos);
+        r.bytes(terminator.length);
+      } else {
+        bytes = r.bytes(len === null ? r.leftBytes : _length.decodeStream(r));
+      }
+      return le ? swapEndianness(bytes) : bytes;
+    },
+    validate: (value) => {
+      if (!isBytes(value))
+        throw new TypeError(`bytes: invalid value ${value}`);
+      if (findTerminator) {
+        const data = le ? swapEndianness(value) : value;
+        if (findTerminator(data) !== undefined)
+          throw new Error("bytes: value contains terminator");
+      }
+      return value;
+    }
+  });
+};
+function prefix(len, inner) {
+  if (!isCoder(inner))
+    throw new TypeError(`prefix: invalid inner value ${inner}`);
+  return apply(createBytes(len), reverse(inner));
+}
+var string = (len, le = false) => validate(apply(createBytes(len, le), utf8), (value) => {
+  if (typeof value !== "string")
+    throw new Error(`expected string, got ${typeof value}`);
+  return value;
+});
+function apply(inner, base) {
+  if (!isCoder(inner))
+    throw new TypeError(`apply: invalid inner value ${inner}`);
+  if (!isBaseCoder(base))
+    throw new TypeError(`apply: invalid base value ${base}`);
+  return wrap({
+    size: inner.size,
+    encodeStream: (w, value) => {
+      let innerValue;
+      try {
+        innerValue = base.decode(value);
+      } catch (e) {
+        throw w.err("" + e);
+      }
+      return inner.encodeStream(w, innerValue);
+    },
+    decodeStream: (r) => {
+      const innerValue = inner.decodeStream(r);
+      try {
+        return base.encode(innerValue);
+      } catch (e) {
+        throw r.err("" + e);
+      }
+    }
+  });
+}
+var flag = (flagValue, xor = false) => {
+  if (!isBytes(flagValue))
+    throw new TypeError(`flag/flagValue: expected Uint8Array, got ${typeof flagValue}`);
+  if (flagValue.length === 0)
+    throw new Error("flag/flagValue: empty marker");
+  if (typeof xor !== "boolean")
+    throw new TypeError(`flag/xor: expected boolean, got ${typeof xor}`);
+  const marker = Uint8Array.from(flagValue);
+  return wrap({
+    size: undefined,
+    encodeStream: (w, value) => {
+      if (!!value !== xor)
+        w.bytes(marker);
+    },
+    decodeStream: (r) => {
+      let hasFlag = r.leftBytes >= marker.length;
+      if (hasFlag) {
+        hasFlag = equalBytes(r.bytes(marker.length, true), marker);
+        if (hasFlag)
+          r.bytes(marker.length);
+      }
+      return hasFlag !== xor;
+    },
+    validate: (value) => {
+      if (value !== undefined && typeof value !== "boolean")
+        throw new Error(`flag: expected boolean value or undefined, got ${typeof value}`);
+      return value;
+    }
+  });
+};
+function validateDefaultSlot(r, value, def) {
+  const valueObj = value !== null && typeof value === "object" && !isBytes(value);
+  const defObj = def !== null && typeof def === "object" && !isBytes(def);
+  const nan = typeof value === "number" && typeof def === "number" && Number.isNaN(value) && Number.isNaN(def);
+  if ((!valueObj || !defObj) && !equal(value, def) && !nan)
+    throw r.err(`default: invalid value ${value} !== ${def}`);
+}
+function flagged(path, inner, def) {
+  if (typeof path !== "string" && !isCoder(path))
+    throw new TypeError(`flagged: wrong path=${path}`);
+  if (!isCoder(inner))
+    throw new TypeError(`flagged: invalid inner value ${inner}`);
+  const hasDef = def !== undefined;
+  return wrap({
+    encodeStream: (w, value) => {
+      if (typeof path === "string") {
+        if (Path.resolve(w.stack, path))
+          inner.encodeStream(w, value);
+        else if (hasDef)
+          inner.encodeStream(w, def);
+      } else {
+        const present = value !== undefined;
+        path.encodeStream(w, present);
+        if (present)
+          inner.encodeStream(w, value);
+        else if (hasDef)
+          inner.encodeStream(w, def);
+      }
+    },
+    decodeStream: (r) => {
+      let hasFlag = false;
+      if (typeof path === "string")
+        hasFlag = !!Path.resolve(r.stack, path);
+      else
+        hasFlag = path.decodeStream(r);
+      if (hasFlag)
+        return inner.decodeStream(r);
+      else if (hasDef)
+        validateDefaultSlot(r, inner.decodeStream(r), def);
+      return;
+    }
+  });
+}
+function magic(inner, constant, check = true) {
+  if (!isCoder(inner))
+    throw new TypeError(`magic: invalid inner value ${inner}`);
+  if (typeof check !== "boolean")
+    throw new TypeError(`magic: expected boolean, got ${typeof check}`);
+  return wrap({
+    size: inner.size,
+    encodeStream: (w, _value) => inner.encodeStream(w, constant),
+    decodeStream: (r) => {
+      const value = inner.decodeStream(r);
+      const valueObj = value !== null && typeof value === "object" && !isBytes(value);
+      const constantObj = constant !== null && typeof constant === "object" && !isBytes(constant);
+      const canCompare = !valueObj || !constantObj;
+      if (check && canCompare && !equal(value, constant)) {
+        throw r.err(`magic: invalid value: ${value} !== ${constant}`);
+      }
+      return;
+    },
+    validate: (value) => {
+      if (value !== undefined)
+        throw new Error(`magic: wrong value=${typeof value}`);
+      return value;
+    }
+  });
+}
+function sizeof(fields) {
+  let size = 0;
+  for (const f of fields) {
+    if (f.size === undefined)
+      return;
+    if (!isNum(f.size))
+      throw new Error(`sizeof: wrong element size=${f.size}`);
+    size += f.size;
+  }
+  return size;
+}
+function struct(fields) {
+  if (!isPlainObject(fields))
+    throw new TypeError(`struct: expected plain object, got ${fields}`);
+  const coders = [];
+  for (const name in fields) {
+    validateFieldName(name, "struct: field");
+    if (!isCoder(fields[name]))
+      throw new TypeError(`struct: field ${name} is not CoderType`);
+    coders.push(fields[name]);
+  }
+  return wrap({
+    size: sizeof(coders),
+    encodeStream: (w, value) => {
+      const _w = w;
+      _w.pushObj(value, () => {
+        for (const name in fields) {
+          _w.enterField(name);
+          fields[name].encodeStream(w, value[name]);
+          _w.exitField();
+        }
+      });
+    },
+    decodeStream: (r) => {
+      const res = {};
+      const _r = r;
+      _r.pushObj(res, () => {
+        for (const name in fields) {
+          _r.enterField(name);
+          res[name] = fields[name].decodeStream(r);
+          _r.exitField();
+        }
+      });
+      return res;
+    },
+    validate: (value) => {
+      if (typeof value !== "object" || value === null)
+        throw new Error(`struct: invalid value ${value}`);
+      return value;
+    }
+  });
+}
+function array(len, inner) {
+  if (!isCoder(inner))
+    throw new TypeError(`array: invalid inner value ${inner}`);
+  const terminator = isBytes(len) ? Uint8Array.from(len) : undefined;
+  const _length = lengthCoder(typeof len === "string" ? `../${len}` : terminator || len);
+  if (len === null && inner.size === 0)
+    throw new Error("array: null length cannot use zero-size inner");
+  if ((isCoder(len) || typeof len === "string") && inner.size === 0)
+    throw new Error("array: dynamic length cannot use zero-size inner");
+  return wrap({
+    size: typeof len === "number" && inner.size !== undefined ? len * inner.size : undefined,
+    encodeStream: (w, value) => {
+      const _w = w;
+      _w.pushObj(value, () => {
+        if (!terminator)
+          _length.encodeStream(w, value.length);
+        for (let i = 0;i < value.length; i++) {
+          _w.enterField(i);
+          const elm = value[i];
+          const startPos = _w.pos;
+          inner.encodeStream(w, elm);
+          if (terminator && terminator.length <= _w.pos - startPos) {
+            const data = _w.finish(false).subarray(startPos, _w.pos);
+            if (equalBytes(data.subarray(0, terminator.length), terminator))
+              throw _w.err(`array: inner element encoding same as separator. elm=${elm} data=${data}`);
+          }
+          _w.exitField();
+        }
+      });
+      if (terminator)
+        w.bytes(terminator);
+    },
+    decodeStream: (r) => {
+      const res = [];
+      const _r = r;
+      _r.pushObj(res, () => {
+        if (len === null) {
+          for (let i = 0;!r.isEnd(); i++) {
+            _r.enterField(i);
+            const progress = _r.progress();
+            res.push(inner.decodeStream(r));
+            if (_r.progress() === progress)
+              throw r.err("array: inner decoder did not consume input");
+            _r.exitField();
+            if (inner.size && r.leftBytes < inner.size)
+              break;
+          }
+        } else if (terminator) {
+          for (let i = 0;; i++) {
+            if (equalBytes(r.bytes(terminator.length, true), terminator)) {
+              r.bytes(terminator.length);
+              break;
+            }
+            _r.enterField(i);
+            const progress = _r.progress();
+            res.push(inner.decodeStream(r));
+            if (_r.progress() === progress)
+              throw r.err("array: inner decoder did not consume input");
+            _r.exitField();
+          }
+        } else {
+          _r.enterField("arrayLen");
+          const length = _length.decodeStream(r);
+          _r.exitField();
+          if (inner.size && length * inner.size > r.leftBytes)
+            throw r.err(`array: length=${length} elements of size=${inner.size} exceed ${r.leftBytes} bytes left`);
+          for (let i = 0;i < length; i++) {
+            _r.enterField(i);
+            res.push(inner.decodeStream(r));
+            _r.exitField();
+          }
+        }
+      });
+      return res;
+    },
+    validate: (value) => {
+      if (!Array.isArray(value))
+        throw new Error(`array: invalid value ${value}`);
+      return value;
+    }
+  });
+}
+// ../../node_modules/.bun/@scure+btc-signer@2.4.1/node_modules/@scure/btc-signer/utils.js
+function abigint(n, title = "value") {
+  if (typeof n !== "bigint")
+    throw new TypeError(`"${title}" expected bigint, got type=${typeof n}`);
+  if (n < _0n2)
+    throw new RangeError(`"${title}" expected non-negative bigint, got ${n}`);
+  return n;
+}
+function aarray(item, title, inner = () => {}) {
+  if (!Array.isArray(item))
+    throw new TypeError(`"${title}" expected array, got type=${typeof item}`);
+  for (let i = 0;i < item.length; i++)
+    inner(item[i], `${title}[${i}]`);
+  return item;
+}
+function astring(value, title = "") {
+  if (typeof value !== "string") {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(prefix + "expected string, got type=" + typeof value);
+  }
+  return value;
+}
+function validateObject2(object, fields = {}, optFields = {}, _title = "object") {
+  return validateObject(object, fields, optFields);
+}
+var Point = /* @__PURE__ */ (() => secp256k1.Point)();
+var Fn = /* @__PURE__ */ (() => Point.Fn)();
+var CURVE_ORDER = /* @__PURE__ */ (() => Point.Fn.ORDER)();
+var _0n2 = /* @__PURE__ */ BigInt(0);
+var _2n2 = /* @__PURE__ */ BigInt(2);
+var hasEven = (y) => y % _2n2 === _0n2;
+var isBytes2 = /* @__PURE__ */ (() => utils.isBytes)();
+var concatBytes3 = /* @__PURE__ */ (() => utils.concatBytes)();
+var equalBytes2 = /* @__PURE__ */ (() => utils.equalBytes)();
+var sha2562 = /* @__PURE__ */ (() => sha256)();
+var hash160 = (msg) => ripemd160(sha2562(msg));
+var sha256x2 = (...msgs) => sha2562(sha2562(concatBytes3(...msgs)));
+var pubSchnorr = (priv) => schnorr.getPublicKey(priv);
+var pubECDSA = (privateKey, isCompressed) => secp256k1.getPublicKey(privateKey, isCompressed);
+var LOW_R_BOUND = /* @__PURE__ */ (() => CURVE_ORDER / _2n2)();
+var hasLowR = (sig) => sig.r < LOW_R_BOUND;
+function signECDSA(hash, privateKey, lowR = false) {
+  abytes2(hash, 32, "hash");
+  let sig = secp256k1.Signature.fromBytes(secp256k1.sign(hash, privateKey, { prehash: false }));
+  if (lowR && !hasLowR(sig)) {
+    const extraEntropy = new Uint8Array(32);
+    let counter = 0;
+    while (!hasLowR(sig)) {
+      extraEntropy.set(U32LE.encode(counter++));
+      sig = secp256k1.Signature.fromBytes(secp256k1.sign(hash, privateKey, { prehash: false, extraEntropy }));
+      if (counter > 4294967295)
+        throw new Error("lowR counter overflow: report the error");
+    }
+  }
+  return sig.toBytes("der");
+}
+var signSchnorr = (message, secretKey, auxRand) => schnorr.sign(message, secretKey, auxRand);
+var tagSchnorr = (tag, ...messages) => schnorr.utils.taggedHash(tag, ...messages);
+var PubT = /* @__PURE__ */ (() => Object.freeze({
+  ecdsa: 0,
+  schnorr: 1
+}))();
+function validatePubkey(pub, type) {
+  const len = pub.length;
+  if (type === PubT.ecdsa) {
+    if (len === 32)
+      throw new RangeError("Expected non-Schnorr key");
+    Point.fromBytes(pub);
+    return pub;
+  } else if (type === PubT.schnorr) {
+    if (len !== 32)
+      throw new RangeError("Expected 32-byte Schnorr key");
+    schnorr.utils.lift_x(bytesToNumberBE(pub));
+    return pub;
+  } else {
+    throw new TypeError("Unknown key type");
+  }
+}
+function tapTweak(a, b) {
+  const u = schnorr.utils;
+  const t = u.taggedHash("TapTweak", a, b);
+  const tn = bytesToNumberBE(t);
+  if (tn >= CURVE_ORDER)
+    throw new Error("tweak higher than curve order");
+  return tn;
+}
+function taprootTweakPrivKey(privKey, merkleRoot = Uint8Array.of()) {
+  const u = schnorr.utils;
+  abytes2(privKey, 32, "privKey");
+  const seckey0 = bytesToNumberBE(privKey);
+  const P = Point.BASE.multiply(seckey0);
+  const seckey = hasEven(P.y) ? seckey0 : Fn.neg(seckey0);
+  const xP = u.pointToBytes(P);
+  const t = tapTweak(xP, merkleRoot);
+  return numberToBytesBE(Fn.add(seckey, t), 32);
+}
+function taprootTweakPubkey(pubKey, h) {
+  const u = schnorr.utils;
+  abytes2(pubKey, 32, "pubKey");
+  const t = tapTweak(pubKey, h);
+  const P = u.lift_x(bytesToNumberBE(pubKey));
+  const Q = P.add(Point.BASE.multiply(t));
+  const parity = hasEven(Q.y) ? 0 : 1;
+  return [u.pointToBytes(Q), parity];
+}
+var INTERNAL_TAPROOT_NUMS = /* @__PURE__ */ (() => sha2562(Point.BASE.toBytes(false)))();
+function taprootNumsKey() {
+  return Uint8Array.from(INTERNAL_TAPROOT_NUMS);
+}
+var NETWORK2 = /* @__PURE__ */ Object.freeze({
+  bech32: "bc",
+  pubKeyHash: 0,
+  scriptHash: 5,
+  wif: 128
+});
+var TEST_NETWORK2 = /* @__PURE__ */ Object.freeze({
+  bech32: "tb",
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+});
+function compareBytes(a, b) {
+  if (!isBytes2(a) || !isBytes2(b))
+    throw new TypeError(`cmp: wrong type a=${typeof a} b=${typeof b}`);
+  const len = Math.min(a.length, b.length);
+  for (let i = 0;i < len; i++)
+    if (a[i] != b[i])
+      return Math.sign(a[i] - b[i]);
+  return Math.sign(a.length - b.length);
+}
+function reverseObject(obj) {
+  const res = Object.create(null);
+  for (const k in obj) {
+    if (res[obj[k]] !== undefined)
+      throw new Error("duplicate key");
+    res[obj[k]] = k;
+  }
+  return res;
+}
+
+// ../../node_modules/.bun/@scure+btc-signer@2.4.1/node_modules/@scure/btc-signer/script.js
+var _0n3 = /* @__PURE__ */ BigInt(0);
+var _1n2 = /* @__PURE__ */ BigInt(1);
+var _2n3 = /* @__PURE__ */ BigInt(2);
+var _8n2 = /* @__PURE__ */ BigInt(8);
+var U8_MAX = /* @__PURE__ */ BigInt(255);
+var COMPACT_DIRECT_MAX = /* @__PURE__ */ BigInt(252);
+var OP = /* @__PURE__ */ Object.freeze({
+  OP_0: 0,
+  PUSHDATA1: 76,
+  PUSHDATA2: 77,
+  PUSHDATA4: 78,
+  "1NEGATE": 79,
+  RESERVED: 80,
+  OP_1: 81,
+  OP_2: 82,
+  OP_3: 83,
+  OP_4: 84,
+  OP_5: 85,
+  OP_6: 86,
+  OP_7: 87,
+  OP_8: 88,
+  OP_9: 89,
+  OP_10: 90,
+  OP_11: 91,
+  OP_12: 92,
+  OP_13: 93,
+  OP_14: 94,
+  OP_15: 95,
+  OP_16: 96,
+  NOP: 97,
+  VER: 98,
+  IF: 99,
+  NOTIF: 100,
+  VERIF: 101,
+  VERNOTIF: 102,
+  ELSE: 103,
+  ENDIF: 104,
+  VERIFY: 105,
+  RETURN: 106,
+  TOALTSTACK: 107,
+  FROMALTSTACK: 108,
+  "2DROP": 109,
+  "2DUP": 110,
+  "3DUP": 111,
+  "2OVER": 112,
+  "2ROT": 113,
+  "2SWAP": 114,
+  IFDUP: 115,
+  DEPTH: 116,
+  DROP: 117,
+  DUP: 118,
+  NIP: 119,
+  OVER: 120,
+  PICK: 121,
+  ROLL: 122,
+  ROT: 123,
+  SWAP: 124,
+  TUCK: 125,
+  CAT: 126,
+  SUBSTR: 127,
+  LEFT: 128,
+  RIGHT: 129,
+  SIZE: 130,
+  INVERT: 131,
+  AND: 132,
+  OR: 133,
+  XOR: 134,
+  EQUAL: 135,
+  EQUALVERIFY: 136,
+  RESERVED1: 137,
+  RESERVED2: 138,
+  "1ADD": 139,
+  "1SUB": 140,
+  "2MUL": 141,
+  "2DIV": 142,
+  NEGATE: 143,
+  ABS: 144,
+  NOT: 145,
+  "0NOTEQUAL": 146,
+  ADD: 147,
+  SUB: 148,
+  MUL: 149,
+  DIV: 150,
+  MOD: 151,
+  LSHIFT: 152,
+  RSHIFT: 153,
+  BOOLAND: 154,
+  BOOLOR: 155,
+  NUMEQUAL: 156,
+  NUMEQUALVERIFY: 157,
+  NUMNOTEQUAL: 158,
+  LESSTHAN: 159,
+  GREATERTHAN: 160,
+  LESSTHANOREQUAL: 161,
+  GREATERTHANOREQUAL: 162,
+  MIN: 163,
+  MAX: 164,
+  WITHIN: 165,
+  RIPEMD160: 166,
+  SHA1: 167,
+  SHA256: 168,
+  HASH160: 169,
+  HASH256: 170,
+  CODESEPARATOR: 171,
+  CHECKSIG: 172,
+  CHECKSIGVERIFY: 173,
+  CHECKMULTISIG: 174,
+  CHECKMULTISIGVERIFY: 175,
+  NOP1: 176,
+  CHECKLOCKTIMEVERIFY: 177,
+  CHECKSEQUENCEVERIFY: 178,
+  NOP4: 179,
+  NOP5: 180,
+  NOP6: 181,
+  NOP7: 182,
+  NOP8: 183,
+  NOP9: 184,
+  NOP10: 185,
+  CHECKSIGADD: 186,
+  INVALID: 255
+});
+var OPNames = /* @__PURE__ */ (() => Object.freeze(reverseObject(OP)))();
+function ScriptNum2(bytesLimit = 6, forceMinimal = false) {
+  return wrap({
+    encodeStream: (w, value) => {
+      if (value === _0n3)
+        return;
+      const neg = value < 0;
+      const val = BigInt(value);
+      const nums = [];
+      for (let abs = neg ? -val : val;abs; abs >>= _8n2)
+        nums.push(Number(abs & U8_MAX));
+      if (nums[nums.length - 1] >= 128)
+        nums.push(neg ? 128 : 0);
+      else if (neg)
+        nums[nums.length - 1] |= 128;
+      w.bytes(new Uint8Array(nums));
+    },
+    decodeStream: (r) => {
+      const len = r.leftBytes;
+      if (len > bytesLimit)
+        throw new Error(`ScriptNum: number (${len}) bigger than limit=${bytesLimit}`);
+      if (len === 0)
+        return _0n3;
+      const data = r.bytes(len);
+      if (forceMinimal) {
+        if ((data[len - 1] & 127) === 0) {
+          if (len <= 1 || (data[len - 2] & 128) === 0)
+            throw new Error("Non-minimally encoded ScriptNum");
+        }
+      }
+      let res = _0n3;
+      for (let i = 0;i < len; ++i)
+        res |= BigInt(data[i]) << _8n2 * BigInt(i);
+      if (data[len - 1] >= 128) {
+        res &= _2n3 ** BigInt(len * 8) - _1n2 >> _1n2;
+        res = -res;
+      }
+      return res;
+    }
+  });
+}
+function OpToNum(op, bytesLimit = 4, forceMinimal = true) {
+  if (typeof op === "number")
+    return op;
+  if (isBytes2(op)) {
+    try {
+      const val = ScriptNum2(bytesLimit, forceMinimal).decode(op);
+      if (val > Number.MAX_SAFE_INTEGER || val < -Number.MAX_SAFE_INTEGER)
+        return;
+      return Number(val);
+    } catch (e) {
+      return;
+    }
+  }
+  return;
+}
+var scriptPushLen = (op, read) => {
+  if (!(OP.OP_0 < op && op <= OP.PUSHDATA4))
+    return;
+  if (op < OP.PUSHDATA1)
+    return op;
+  if (op === OP.PUSHDATA1)
+    return read(1);
+  if (op === OP.PUSHDATA2)
+    return read(2);
+  if (op === OP.PUSHDATA4)
+    return read(4);
+  throw new Error("Should be not possible");
+};
+var Script2 = /* @__PURE__ */ (() => Object.freeze(wrap({
+  encodeStream: (w, value) => {
+    aarray(value, "value");
+    for (let o of value) {
+      if (typeof o === "string") {
+        const op = OP[o];
+        if (typeof op !== "number")
+          throw new Error(`Unknown opcode=${o}`);
+        w.byte(op);
+        continue;
+      } else if (typeof o === "number") {
+        if (o === 0) {
+          w.byte(0);
+          continue;
+        } else if (o === -1) {
+          w.byte(OP["1NEGATE"]);
+          continue;
+        } else if (1 <= o && o <= 16) {
+          w.byte(OP.OP_1 - 1 + o);
+          continue;
+        }
+      }
+      if (typeof o === "number")
+        o = ScriptNum2().encode(BigInt(o));
+      abytes2(o, undefined, "value");
+      const len = o.length;
+      if (len < OP.PUSHDATA1)
+        w.byte(len);
+      else if (len <= 255) {
+        w.byte(OP.PUSHDATA1);
+        w.byte(len);
+      } else if (len <= 65535) {
+        w.byte(OP.PUSHDATA2);
+        w.bytes(U16LE.encode(len));
+      } else {
+        w.byte(OP.PUSHDATA4);
+        w.bytes(U32LE.encode(len));
+      }
+      w.bytes(o);
+    }
+  },
+  decodeStream: (r) => {
+    const out = [];
+    while (!r.isEnd()) {
+      const cur = r.byte();
+      const len = scriptPushLen(cur, (bytes) => {
+        if (bytes === 1)
+          return U8.decodeStream(r);
+        if (bytes === 2)
+          return U16LE.decodeStream(r);
+        return U32LE.decodeStream(r);
+      });
+      if (len !== undefined) {
+        out.push(r.bytes(len));
+      } else if (cur === 0) {
+        out.push(0);
+      } else if (OP.OP_1 <= cur && cur <= OP.OP_16) {
+        out.push(cur - (OP.OP_1 - 1));
+      } else {
+        const op = OPNames[cur];
+        if (op === undefined)
+          throw new Error(`Unknown opcode=${cur.toString(16)}`);
+        out.push(op);
+      }
+    }
+    return out;
+  }
+})))();
+var CompactSize = /* @__PURE__ */ (() => {
+  const limits = {
+    253: [253, 2, BigInt(253), BigInt(65535)],
+    254: [254, 4, BigInt(65536), BigInt(4294967295)],
+    255: [255, 8, BigInt(4294967296), BigInt("0xffffffffffffffff")]
+  };
+  const limitsList = Object.values(limits);
+  return Object.freeze(wrap({
+    encodeStream: (w, value) => {
+      if (typeof value === "number")
+        value = BigInt(value);
+      if (_0n3 <= value && value <= COMPACT_DIRECT_MAX)
+        return w.byte(Number(value));
+      for (const [flag, bytes, start, stop] of limitsList) {
+        if (start > value || value > stop)
+          continue;
+        w.byte(flag);
+        for (let i = 0;i < bytes; i++)
+          w.byte(Number(value >> _8n2 * BigInt(i) & U8_MAX));
+        return;
+      }
+      throw w.err(`VarInt too big: ${value}`);
+    },
+    decodeStream: (r) => {
+      const b0 = r.byte();
+      if (b0 <= 252)
+        return BigInt(b0);
+      const [_, bytes, start] = limits[b0];
+      let num = _0n3;
+      for (let i = 0;i < bytes; i++)
+        num |= BigInt(r.byte()) << _8n2 * BigInt(i);
+      if (num < start)
+        throw r.err(`Wrong CompactSize(${8 * bytes})`);
+      return num;
+    }
+  }));
+})();
+var CompactSizeLen = /* @__PURE__ */ (() => Object.freeze(apply(CompactSize, coders.numberBigint)))();
+var _VarBytes = /* @__PURE__ */ (() => Object.freeze(createBytes(CompactSize)))();
+var VarBytes = _VarBytes;
+var _RawWitness = /* @__PURE__ */ (() => Object.freeze(array(CompactSizeLen, _VarBytes)))();
+var RawWitness = _RawWitness;
+var BTCArray = (t) => array(CompactSize, t);
+var RawInput = /* @__PURE__ */ (() => Object.freeze(struct({
+  txid: createBytes(32, true),
+  index: U32LE,
+  finalScriptSig: _VarBytes,
+  sequence: U32LE
+})))();
+var RawOutput = /* @__PURE__ */ (() => Object.freeze(struct({ amount: U64LE, script: _VarBytes })))();
+var _RawTx = /* @__PURE__ */ (() => struct({
+  version: I32LE,
+  segwitFlag: flag(new Uint8Array([0, 1])),
+  inputs: BTCArray(RawInput),
+  outputs: BTCArray(RawOutput),
+  witnesses: flagged("segwitFlag", array("inputs/length", _RawWitness)),
+  lockTime: U32LE
+}))();
+function validateRawTx(tx) {
+  if (tx.segwitFlag && tx.witnesses && tx.witnesses.every((w) => !w.length))
+    throw new Error("Segwit flag with only empty witness fields");
+  return tx;
+}
+var RawTx = /* @__PURE__ */ (() => Object.freeze(validate(_RawTx, validateRawTx)))();
+var RawOldTx = /* @__PURE__ */ (() => Object.freeze(struct({
+  version: I32LE,
+  inputs: BTCArray(RawInput),
+  outputs: BTCArray(RawOutput),
+  lockTime: U32LE
+})))();
+
+// ../../node_modules/.bun/@scure+btc-signer@2.4.1/node_modules/@scure/btc-signer/psbt.js
+var unknowns = (mode, name) => {
+  if (mode === true)
+    return "ignore";
+  if (mode === false)
+    return "strip";
+  if (mode === "ignore" || mode === "strip" || mode === "strict")
+    return mode;
+  throw new Error(`PSBT: invalid ${name} policy=${mode}`);
+};
+var _0n4 = /* @__PURE__ */ BigInt(0);
+var _1n3 = /* @__PURE__ */ BigInt(1);
+var PubKeyECDSA = /* @__PURE__ */ (() => validate(createBytes(null), (pub) => validatePubkey(pub, PubT.ecdsa)))();
+var PubKeyECDSACompressed = /* @__PURE__ */ (() => validate(createBytes(33), (pub) => validatePubkey(pub, PubT.ecdsa)))();
+var PubKeySchnorr = /* @__PURE__ */ (() => validate(createBytes(32), (pub) => validatePubkey(pub, PubT.schnorr)))();
+var SignatureSchnorr = /* @__PURE__ */ (() => validate(createBytes(null), (sig) => {
+  if (sig.length !== 64 && sig.length !== 65)
+    throw new Error("Schnorr signature should be 64 or 65 bytes long");
+  return sig;
+}))();
+var RawWitnessWire = RawWitness;
+var BIP32Der = /* @__PURE__ */ (() => struct({
+  fingerprint: U32BE,
+  path: array(null, U32LE)
+}))();
+var TaprootBIP32Der = /* @__PURE__ */ (() => struct({
+  hashes: array(CompactSizeLen, createBytes(32)),
+  der: BIP32Der
+}))();
+var GlobalXPUB = /* @__PURE__ */ (() => validate(struct({
+  version: U32BE,
+  depth: U8,
+  parentFingerprint: U32BE,
+  childNumber: U32BE,
+  chainCode: createBytes(32),
+  publicKey: PubKeyECDSACompressed
+}), (xpub) => {
+  if (xpub.depth === 0 && xpub.parentFingerprint !== 0)
+    throw new Error("GlobalXPUB: depth=0 requires parentFingerprint=0");
+  if (xpub.depth === 0 && xpub.childNumber !== 0)
+    throw new Error("GlobalXPUB: depth=0 requires childNumber=0");
+  return xpub;
+}))();
+var tapScriptSigKey = /* @__PURE__ */ (() => struct({ pubKey: PubKeySchnorr, leafHash: createBytes(32) }))();
+var _TaprootControlBlock = /* @__PURE__ */ (() => struct({
+  version: U8,
+  internalKey: createBytes(32),
+  merklePath: array(null, createBytes(32))
+}))();
+var TaprootControlBlock2 = /* @__PURE__ */ (() => Object.freeze(validate(_TaprootControlBlock, (cb) => {
+  if (cb.merklePath.length > 128)
+    throw new Error("TaprootControlBlock: merklePath should be of length 0..128 (inclusive)");
+  return cb;
+})))();
+var tapTree = /* @__PURE__ */ (() => validate(array(null, struct({
+  depth: U8,
+  version: U8,
+  script: VarBytes
+})), (tree) => {
+  if (tree.length < 1)
+    throw new Error("tapTree: expected at least one tuple");
+  let path = Array(tree[0].depth).fill(0);
+  let maxDepth = tree[0].depth;
+  for (let i = 1;i < tree.length; i++) {
+    const { depth } = tree[i];
+    if (depth > maxDepth)
+      maxDepth = depth;
+    let j = path.length - 1;
+    while (j >= 0 && path[j] === 1)
+      j--;
+    if (j < 0)
+      throw new Error("tapTree: tuples must be in DFS order");
+    const next = path.slice(0, j);
+    next.push(1);
+    if (depth < next.length)
+      throw new Error("tapTree: tuples must be in DFS order");
+    while (next.length < depth)
+      next.push(0);
+    path = next;
+  }
+  let leaves = _0n4;
+  for (let i = 0;i < tree.length; i++)
+    leaves += _1n3 << BigInt(maxDepth - tree[i].depth);
+  if (leaves !== _1n3 << BigInt(maxDepth))
+    throw new Error("tapTree: tuples must describe a complete binary tree");
+  return tree;
+}))();
+var BytesInf = /* @__PURE__ */ createBytes(null);
+var ProprietaryKey = /* @__PURE__ */ (() => {
+  const suffix = struct({
+    identifier: createBytes(CompactSizeLen),
+    subtype: CompactSizeLen,
+    data: BytesInf
+  });
+  return validate(BytesInf, (key) => {
+    try {
+      suffix.decode(key);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Proprietary key: expected BIP174 identifier and subtype, got ${message}`);
+    }
+    return key;
+  });
+})();
+var Bytes20 = /* @__PURE__ */ createBytes(20);
+var Bytes32 = /* @__PURE__ */ createBytes(32);
+var Bytes64 = /* @__PURE__ */ createBytes(64);
+var Bytes66 = /* @__PURE__ */ createBytes(66);
+var MuSig2Participants = /* @__PURE__ */ (() => array(null, PubKeyECDSACompressed))();
+var MuSig2Key = /* @__PURE__ */ (() => apply(BytesInf, {
+  decode: (key) => {
+    const _key = key;
+    return concatBytes(PubKeyECDSACompressed.encode(_key.participantPubkey), PubKeyECDSACompressed.encode(_key.aggregatePubkey), _key.leafHash === undefined ? EMPTY : Bytes32.encode(_key.leafHash));
+  },
+  encode: (raw) => {
+    const _raw = raw;
+    if (_raw.length !== 66 && _raw.length !== 98)
+      throw new Error(`MuSig2 key: expected 66 or 98 bytes, got ${_raw.length}`);
+    const key = {
+      participantPubkey: PubKeyECDSACompressed.decode(_raw.subarray(0, 33)),
+      aggregatePubkey: PubKeyECDSACompressed.decode(_raw.subarray(33, 66))
+    };
+    if (_raw.length === 98)
+      key.leafHash = Bytes32.decode(_raw.subarray(66));
+    return key;
+  }
+}))();
+var SilentPaymentInfo = /* @__PURE__ */ (() => struct({ scanKey: PubKeyECDSACompressed, spendKey: PubKeyECDSACompressed }))();
+var DNSSECProof = /* @__PURE__ */ (() => struct({ name: createBytes(U8), proof: BytesInf }))();
+var PSBTInfo = (type, kc, vc, reqInc, allowInc, silentIgnore) => /* @__PURE__ */ Object.freeze([
+  type,
+  kc && typeof kc === "object" ? Object.freeze(kc) : kc,
+  vc && typeof vc === "object" ? Object.freeze(vc) : vc,
+  Object.freeze([...reqInc]),
+  Object.freeze([...allowInc]),
+  silentIgnore
+]);
+var PSBTGlobal = /* @__PURE__ */ (() => Object.freeze({
+  unsignedTx: PSBTInfo(0, false, RawOldTx, [0], [0], false),
+  xpub: PSBTInfo(1, GlobalXPUB, BIP32Der, [], [0, 2], false),
+  txVersion: PSBTInfo(2, false, U32LE, [2], [2], false),
+  fallbackLocktime: PSBTInfo(3, false, U32LE, [], [2], false),
+  inputCount: PSBTInfo(4, false, CompactSizeLen, [2], [2], false),
+  outputCount: PSBTInfo(5, false, CompactSizeLen, [2], [2], false),
+  txModifiable: PSBTInfo(6, false, U8, [], [2], false),
+  spEcdhShare: PSBTInfo(7, PubKeyECDSACompressed, PubKeyECDSACompressed, [], [2], false),
+  spDleq: PSBTInfo(8, PubKeyECDSACompressed, Bytes64, [], [2], false),
+  genericSignedMessage: PSBTInfo(9, false, BytesInf, [], [0, 2], false),
+  version: PSBTInfo(251, false, U32LE, [], [0, 2], false),
+  proprietary: PSBTInfo(252, ProprietaryKey, BytesInf, [], [0, 2], false)
+}))();
+var PSBTInput = /* @__PURE__ */ (() => Object.freeze({
+  nonWitnessUtxo: PSBTInfo(0, false, RawTx, [], [0, 2], false),
+  witnessUtxo: PSBTInfo(1, false, RawOutput, [], [0, 2], false),
+  partialSig: PSBTInfo(2, PubKeyECDSA, BytesInf, [], [0, 2], false),
+  sighashType: PSBTInfo(3, false, U32LE, [], [0, 2], false),
+  redeemScript: PSBTInfo(4, false, BytesInf, [], [0, 2], false),
+  witnessScript: PSBTInfo(5, false, BytesInf, [], [0, 2], false),
+  bip32Derivation: PSBTInfo(6, PubKeyECDSA, BIP32Der, [], [0, 2], false),
+  finalScriptSig: PSBTInfo(7, false, BytesInf, [], [0, 2], false),
+  finalScriptWitness: PSBTInfo(8, false, RawWitnessWire, [], [0, 2], false),
+  porCommitment: PSBTInfo(9, false, BytesInf, [], [0, 2], false),
+  ripemd160: PSBTInfo(10, Bytes20, BytesInf, [], [0, 2], false),
+  sha256: PSBTInfo(11, Bytes32, BytesInf, [], [0, 2], false),
+  hash160: PSBTInfo(12, Bytes20, BytesInf, [], [0, 2], false),
+  hash256: PSBTInfo(13, Bytes32, BytesInf, [], [0, 2], false),
+  txid: PSBTInfo(14, false, createBytes(32, true), [2], [2], true),
+  index: PSBTInfo(15, false, U32LE, [2], [2], true),
+  sequence: PSBTInfo(16, false, U32LE, [], [2], true),
+  requiredTimeLocktime: PSBTInfo(17, false, U32LE, [], [2], false),
+  requiredHeightLocktime: PSBTInfo(18, false, U32LE, [], [2], false),
+  tapKeySig: PSBTInfo(19, false, SignatureSchnorr, [], [0, 2], false),
+  tapScriptSig: PSBTInfo(20, tapScriptSigKey, SignatureSchnorr, [], [0, 2], false),
+  tapLeafScript: PSBTInfo(21, TaprootControlBlock2, BytesInf, [], [0, 2], false),
+  tapBip32Derivation: PSBTInfo(22, PubKeySchnorr, TaprootBIP32Der, [], [0, 2], false),
+  tapInternalKey: PSBTInfo(23, false, PubKeySchnorr, [], [0, 2], false),
+  tapMerkleRoot: PSBTInfo(24, false, Bytes32, [], [0, 2], false),
+  p2cKeyTweak: PSBTInfo(25, PubKeyECDSACompressed, Bytes32, [], [0, 2], false),
+  musig2ParticipantPubkeys: PSBTInfo(26, PubKeyECDSACompressed, MuSig2Participants, [], [0, 2], false),
+  musig2PubNonce: PSBTInfo(27, MuSig2Key, Bytes66, [], [0, 2], false),
+  musig2PartialSig: PSBTInfo(28, MuSig2Key, Bytes32, [], [0, 2], false),
+  spEcdhShare: PSBTInfo(29, PubKeyECDSACompressed, PubKeyECDSACompressed, [], [2], false),
+  spDleq: PSBTInfo(30, PubKeyECDSACompressed, Bytes64, [], [2], false),
+  spSpendBip32Derivation: PSBTInfo(31, PubKeyECDSACompressed, BIP32Der, [], [2], false),
+  spTweak: PSBTInfo(32, false, Bytes32, [], [2], false),
+  proprietary: PSBTInfo(252, ProprietaryKey, BytesInf, [], [0, 2], false)
+}))();
+var PSBTInputFinalKeys = /* @__PURE__ */ Object.freeze([
+  "txid",
+  "sequence",
+  "index",
+  "witnessUtxo",
+  "nonWitnessUtxo",
+  "requiredTimeLocktime",
+  "requiredHeightLocktime",
+  "finalScriptSig",
+  "finalScriptWitness",
+  "unknown"
+]);
+var PSBTInputSignatureKeys = /* @__PURE__ */ Object.freeze([
+  "partialSig",
+  "finalScriptSig",
+  "finalScriptWitness",
+  "tapKeySig",
+  "tapScriptSig"
+]);
+var PSBTOutput = /* @__PURE__ */ (() => Object.freeze({
+  redeemScript: PSBTInfo(0, false, BytesInf, [], [0, 2], false),
+  witnessScript: PSBTInfo(1, false, BytesInf, [], [0, 2], false),
+  bip32Derivation: PSBTInfo(2, PubKeyECDSA, BIP32Der, [], [0, 2], false),
+  amount: PSBTInfo(3, false, I64LE, [2], [2], true),
+  script: PSBTInfo(4, false, BytesInf, [2], [2], true),
+  tapInternalKey: PSBTInfo(5, false, PubKeySchnorr, [], [0, 2], false),
+  tapTree: PSBTInfo(6, false, tapTree, [], [0, 2], false),
+  tapBip32Derivation: PSBTInfo(7, PubKeySchnorr, TaprootBIP32Der, [], [0, 2], false),
+  musig2ParticipantPubkeys: PSBTInfo(8, PubKeyECDSACompressed, MuSig2Participants, [], [0, 2], false),
+  spV0Info: PSBTInfo(9, false, SilentPaymentInfo, [], [2], false),
+  spV0Label: PSBTInfo(10, false, U32LE, [], [2], false),
+  dnssecProof: PSBTInfo(53, false, DNSSECProof, [], [0, 2], false),
+  proprietary: PSBTInfo(252, ProprietaryKey, BytesInf, [], [0, 2], false)
+}))();
+var PSBTOutputUnsignedKeys = /* @__PURE__ */ Object.freeze([]);
+var PSBTKeyPair = /* @__PURE__ */ (() => array(NULL, struct({
+  key: prefix(CompactSizeLen, struct({ type: CompactSizeLen, key: createBytes(null) })),
+  value: createBytes(CompactSizeLen)
+})))();
+function PSBTKeyInfo(info) {
+  const [type, kc, vc, reqInc, allowInc, silentIgnore] = info;
+  return { type, kc, vc, reqInc, allowInc, silentIgnore };
+}
+var PSBTUnknownKey = /* @__PURE__ */ (() => struct({ type: CompactSizeLen, key: createBytes(null) }))();
+function PSBTKeyMap(psbtEnum) {
+  const byType = {};
+  for (const k in psbtEnum) {
+    const [num, kc, vc] = psbtEnum[k];
+    byType[num] = [k, kc, vc];
+  }
+  return wrap({
+    encodeStream: (w, value) => {
+      const _value = value;
+      let out = [];
+      const seen = {};
+      const add = (key, value) => {
+        const _value = value;
+        const kStr = hex.encode(PSBTUnknownKey.encode(key));
+        if (seen[kStr])
+          throw new Error(`PSBT: duplicate key=${kStr}`);
+        seen[kStr] = true;
+        out.push({ key, value: _value });
+      };
+      for (const name in psbtEnum) {
+        const val = _value[name];
+        if (val === undefined)
+          continue;
+        const [type, kc, vc] = psbtEnum[name];
+        if (!kc) {
+          add({ type, key: EMPTY }, vc.encode(val));
+        } else {
+          const kv = val.map(([k, v]) => [
+            kc.encode(k),
+            vc.encode(v)
+          ]);
+          kv.sort((a, b) => compareBytes(a[0], b[0]));
+          for (const [key, value] of kv)
+            add({ key, type }, value);
+        }
+      }
+      if (_value.unknown) {
+        _value.unknown.sort((a, b) => compareBytes(a[0].key, b[0].key));
+        for (const [k, v] of _value.unknown)
+          add(k, v);
+      }
+      PSBTKeyPair.encodeStream(w, out);
+    },
+    decodeStream: (r) => {
+      const raw = PSBTKeyPair.decodeStream(r);
+      const out = {};
+      const noKey = {};
+      const seen = {};
+      for (const elm of raw) {
+        const kStr = hex.encode(PSBTUnknownKey.encode(elm.key));
+        if (seen[kStr])
+          throw new Error(`PSBT: duplicate key=${kStr}`);
+        seen[kStr] = true;
+        let name = "unknown";
+        let key = elm.key.key;
+        let value = elm.value;
+        if (byType[elm.key.type]) {
+          const [_name, kc, vc] = byType[elm.key.type];
+          name = _name;
+          if (!kc && key.length) {
+            throw new Error(`PSBT: Non-empty key for ${name} (key=${hex.encode(key)} value=${hex.encode(value)}`);
+          }
+          key = kc ? kc.decode(key) : undefined;
+          value = vc.decode(value);
+          if (!kc) {
+            if (out[name])
+              throw new Error(`PSBT: Same keys: ${name} (key=${key} value=${value})`);
+            out[name] = value;
+            noKey[name] = true;
+            continue;
+          }
+        } else {
+          key = { type: elm.key.type, key: elm.key.key };
+        }
+        if (noKey[name])
+          throw new Error(`PSBT: Key type with empty key and no key=${name} val=${value}`);
+        if (!out[name])
+          out[name] = [];
+        out[name].push([key, value]);
+      }
+      return out;
+    }
+  });
+}
+var PSBTInputCoder = /* @__PURE__ */ (() => Object.freeze(validate(PSBTKeyMap(PSBTInput), (i) => {
+  if (i.finalScriptWitness && !i.finalScriptWitness.length)
+    throw new Error("validateInput: empty finalScriptWitness");
+  if (i.partialSig && !i.partialSig.length)
+    throw new Error("Empty partialSig");
+  if (i.partialSig)
+    for (const [k] of i.partialSig)
+      validatePubkey(k, PubT.ecdsa);
+  if (i.bip32Derivation)
+    for (const [k] of i.bip32Derivation)
+      validatePubkey(k, PubT.ecdsa);
+  if (i.requiredTimeLocktime !== undefined && i.requiredTimeLocktime < 500000000)
+    throw new Error(`validateInput: wrong timeLocktime=${i.requiredTimeLocktime}`);
+  if (i.requiredHeightLocktime !== undefined && (i.requiredHeightLocktime <= 0 || i.requiredHeightLocktime >= 500000000))
+    throw new Error(`validateInput: wrong heighLocktime=${i.requiredHeightLocktime}`);
+  if (i.tapLeafScript) {
+    for (const [k, v] of i.tapLeafScript) {
+      if ((k.version & 254) !== v[v.length - 1])
+        throw new Error("validateInput: tapLeafScript version mimatch");
+      if (v[v.length - 1] & 1)
+        throw new Error("validateInput: tapLeafScript version has parity bit!");
+    }
+  }
+  return i;
+})))();
+var PSBTOutputCoder = /* @__PURE__ */ (() => Object.freeze(validate(PSBTKeyMap(PSBTOutput), (o) => {
+  if (o.amount !== undefined && o.amount < _0n4)
+    throw new Error(`validateOutput: wrong amount=${o.amount}`);
+  if (o.bip32Derivation)
+    for (const [k] of o.bip32Derivation)
+      validatePubkey(k, PubT.ecdsa);
+  return o;
+})))();
+var PSBTGlobalCoder = /* @__PURE__ */ (() => validate(PSBTKeyMap(PSBTGlobal), (g) => {
+  const version = g.version || 0;
+  if (version === 0) {
+    if (!g.unsignedTx)
+      throw new Error("PSBTv0: missing unsignedTx");
+    for (const inp of g.unsignedTx.inputs)
+      if (inp.finalScriptSig && inp.finalScriptSig.length)
+        throw new Error("PSBTv0: input scriptSig found in unsignedTx");
+  }
+  for (const [xpub, der] of g.xpub || []) {
+    if (xpub.depth !== der.path.length)
+      throw new Error(`PSBT_GLOBAL_XPUB: xpub depth=${xpub.depth} must match derivation path length=${der.path.length}`);
+  }
+  return g;
+}))();
+var _RawPSBTV0 = /* @__PURE__ */ (() => Object.freeze(struct({
+  magic: magic(string(new Uint8Array([255])), "psbt"),
+  global: PSBTGlobalCoder,
+  inputs: array("global/unsignedTx/inputs/length", PSBTInputCoder),
+  outputs: array(null, PSBTOutputCoder)
+})))();
+var _RawPSBTV2 = /* @__PURE__ */ (() => Object.freeze(struct({
+  magic: magic(string(new Uint8Array([255])), "psbt"),
+  global: PSBTGlobalCoder,
+  inputs: array("global/inputCount", PSBTInputCoder),
+  outputs: array("global/outputCount", PSBTOutputCoder)
+})))();
+function validatePSBTFields(version, info, lst) {
+  const _lst = lst;
+  for (const k in _lst) {
+    if (k === "unknown")
+      continue;
+    if (!info[k])
+      continue;
+    const { allowInc } = PSBTKeyInfo(info[k]);
+    if (!allowInc.includes(version))
+      throw new Error(`PSBTv${version}: field ${k} is not allowed`);
+  }
+  for (const k in info) {
+    const { reqInc } = PSBTKeyInfo(info[k]);
+    if (reqInc.includes(version) && _lst[k] === undefined)
+      throw new Error(`PSBTv${version}: missing required field ${k}`);
+  }
+}
+function cleanPSBTFields(version, info, lst) {
+  anumber(version, "version");
+  validateObject2(info, {}, {}, "info");
+  validateObject2(lst, {}, {}, "lst");
+  const _lst = lst;
+  const out = {};
+  for (const _k in _lst) {
+    const k = _k;
+    if (k !== "unknown") {
+      if (!info[k])
+        continue;
+      const { allowInc, silentIgnore } = PSBTKeyInfo(info[k]);
+      if (!allowInc.includes(version)) {
+        if (silentIgnore)
+          continue;
+        throw new Error(`Failed to serialize in PSBTv${version}: ${k} but versions allows inclusion=${allowInc}`);
+      }
+    }
+    out[k] = _lst[k];
+  }
+  return out;
+}
+function validatePSBT(tx) {
+  const version = tx && tx.global && tx.global.version || 0;
+  validatePSBTFields(version, PSBTGlobal, tx.global);
+  for (const i of tx.inputs)
+    validatePSBTFields(version, PSBTInput, i);
+  for (const o of tx.outputs)
+    validatePSBTFields(version, PSBTOutput, o);
+  const inputCount = !version ? tx.global.unsignedTx.inputs.length : tx.global.inputCount;
+  if (tx.inputs.length !== inputCount)
+    throw new Error(`Wrong number of input maps=${tx.inputs.length}, expected=${inputCount}`);
+  const outputCount = !version ? tx.global.unsignedTx.outputs.length : tx.global.outputCount;
+  if (tx.outputs.length < outputCount)
+    throw new Error("Not outputs inputs");
+  const hasBip174InputMap = version === 0 && inputCount === 0 && Object.keys(tx.outputs[0] || {}).length === 0 && (outputCount > 0 && tx.outputs.length === outputCount + 1 || outputCount === 0 && tx.outputs.length === 2 && Object.keys(tx.outputs[1]).length === 0);
+  if (hasBip174InputMap)
+    return tx;
+  const outputsLeft = tx.outputs.slice(outputCount);
+  if (outputsLeft.length > 1 || outputsLeft.length && (version !== 0 || Object.keys(outputsLeft[0]).length))
+    throw new Error(`Unexpected outputs left in tx=${outputsLeft}`);
+  return tx;
+}
+function mergeKeyMap(psbtEnum, val, cur, allowedFields, unknown = "strip", proprietary = "strip") {
+  validateObject2(psbtEnum, {}, {}, "psbtEnum");
+  validateObject2(val, {}, {}, "val");
+  if (cur !== undefined)
+    validateObject2(cur, {}, {}, "cur");
+  if (allowedFields !== undefined)
+    aarray(allowedFields, "allowedFields");
+  const _val = val;
+  const _cur = cur;
+  const _allowedFields = allowedFields;
+  const unknownMode = unknowns(unknown, "unknown");
+  const proprietaryMode = unknowns(proprietary, "proprietary");
+  for (const [name, mode] of [
+    ["unknown", unknownMode],
+    ["proprietary", proprietaryMode]
+  ]) {
+    if (mode !== "strict")
+      continue;
+    if (_val[name]?.length || _cur?.[name]?.length)
+      throw new Error(`PSBT: ${name} PSBT field is not allowed in strict mode`);
+  }
+  const res = { ..._cur, ..._val };
+  for (const k in psbtEnum) {
+    const key = k;
+    if (k === "proprietary" && proprietaryMode !== "ignore")
+      continue;
+    const [_, kC, vC] = psbtEnum[key];
+    const cannotChange = _allowedFields && !_allowedFields.includes(k);
+    if (_val[k] === undefined && k in _val) {
+      if (cannotChange)
+        throw new Error(`Cannot remove signed field=${k}`);
+      delete res[k];
+    } else if (kC) {
+      const oldKV = _cur && _cur[k] ? _cur[k] : [];
+      let newKV = _val[key];
+      if (newKV) {
+        if (!Array.isArray(newKV))
+          throw new Error(`keyMap(${k}): KV pairs should be [k, v][]`);
+        newKV = newKV.map((val) => {
+          if (val.length !== 2)
+            throw new Error(`keyMap(${k}): KV pairs should be [k, v][]`);
+          return [
+            typeof val[0] === "string" ? kC.decode(hex.decode(val[0])) : val[0],
+            typeof val[1] === "string" ? vC.decode(hex.decode(val[1])) : val[1]
+          ];
+        });
+        const map = {};
+        const add = (kStr, k, v) => {
+          if (map[kStr] === undefined) {
+            map[kStr] = [k, v];
+            return;
+          }
+          const oldVal = hex.encode(vC.encode(map[kStr][1]));
+          const newVal = hex.encode(vC.encode(v));
+          if (oldVal !== newVal)
+            throw new Error(`keyMap(${key}): same key=${kStr} oldVal=${oldVal} newVal=${newVal}`);
+        };
+        for (const [k, v] of oldKV) {
+          const kStr = hex.encode(kC.encode(k));
+          add(kStr, k, v);
+        }
+        for (const [k, v] of newKV) {
+          const kStr = hex.encode(kC.encode(k));
+          if (v === undefined) {
+            if (cannotChange)
+              throw new Error(`Cannot remove signed field=${key}/${k}`);
+            delete map[kStr];
+          } else {
+            if (cannotChange && map[kStr] === undefined)
+              throw new Error(`Cannot add signed field=${key}/${kStr}`);
+            add(kStr, k, v);
+          }
+        }
+        res[key] = Object.values(map);
+      }
+    } else {
+      if (typeof res[k] === "string")
+        res[k] = vC.decode(hex.decode(res[k]));
+      if (cannotChange && k in _val) {
+        if (!_cur || _cur[k] === undefined)
+          throw new Error(`Cannot add signed field=${k}`);
+        let current = _cur[k];
+        if (typeof current === "string")
+          current = vC.decode(hex.decode(current));
+        if (!equalBytes2(vC.encode(res[k]), vC.encode(current)))
+          throw new Error(`Cannot change signed field=${k}`);
+      }
+    }
+  }
+  if (unknownMode === "ignore" && _val.unknown) {
+    const map = {};
+    for (const [k, v] of _cur?.unknown || [])
+      map[hex.encode(PSBTUnknownKey.encode(k))] = [k, v];
+    for (const [k, v] of _val.unknown) {
+      const kStr = hex.encode(PSBTUnknownKey.encode(k));
+      if (map[kStr] === undefined) {
+        map[kStr] = [k, v];
+        continue;
+      }
+      const oldVal = hex.encode(BytesInf.encode(map[kStr][1]));
+      const newVal = hex.encode(BytesInf.encode(v));
+      if (oldVal !== newVal)
+        throw new Error(`keyMap(unknown): same key=${kStr} oldVal=${oldVal} newVal=${newVal}`);
+    }
+    res.unknown = Object.values(map);
+  }
+  for (const k in res) {
+    if (!psbtEnum[k]) {
+      if (unknownMode === "ignore" && k === "unknown")
+        continue;
+      delete res[k];
+    }
+  }
+  if (unknownMode !== "ignore")
+    delete res.unknown;
+  if (proprietaryMode !== "ignore")
+    delete res.proprietary;
+  return res;
+}
+function combineKeyMap(psbtEnum, current, other, unknown = "strip", proprietary = "strip") {
+  validateObject2(psbtEnum, {}, {}, "psbtEnum");
+  validateObject2(current, {}, {}, "current");
+  validateObject2(other, {}, {}, "other");
+  const _current = current;
+  const _other = other;
+  for (const k in psbtEnum) {
+    const key = k;
+    const [_, keyCoder, valueCoder] = psbtEnum[key];
+    if (keyCoder || _current[key] === undefined || _other[key] === undefined)
+      continue;
+    let a = _current[key];
+    let b = _other[key];
+    if (typeof a === "string")
+      a = valueCoder.decode(hex.decode(a));
+    if (typeof b === "string")
+      b = valueCoder.decode(hex.decode(b));
+    if (!equalBytes2(valueCoder.encode(a), valueCoder.encode(b)))
+      throw new Error(`Cannot combine conflicting field=${k}`);
+  }
+  return mergeKeyMap(psbtEnum, _other, _current, undefined, unknown, proprietary);
+}
+var RawPSBTV0 = /* @__PURE__ */ (() => Object.freeze(validate(_RawPSBTV0, validatePSBT)))();
+var RawPSBTV2 = /* @__PURE__ */ (() => Object.freeze(validate(_RawPSBTV2, validatePSBT)))();
+
+// ../../node_modules/.bun/@scure+btc-signer@2.4.1/node_modules/@scure/btc-signer/payment.js
+var P2A_PROGRAM = /* @__PURE__ */ Uint8Array.from([78, 115]);
+var OutP2A = {
+  encode(from) {
+    if (from.length !== 2 || from[0] !== 1 || !isBytes2(from[1]) || !equalBytes2(from[1], P2A_PROGRAM))
+      return;
+    return { type: "p2a", script: Script2.encode(from) };
+  },
+  decode: (to) => {
+    if (to.type !== "p2a")
+      return;
+    return [1, Uint8Array.from(P2A_PROGRAM)];
+  }
+};
+function isValidPubkey(pub, type) {
+  try {
+    validatePubkey(pub, type);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+var OutPK = {
+  encode(from) {
+    if (from.length !== 2 || !isBytes2(from[0]) || !isValidPubkey(from[0], PubT.ecdsa) || from[1] !== "CHECKSIG")
+      return;
+    return { type: "pk", pubkey: from[0] };
+  },
+  decode: (to) => {
+    if (to.type !== "pk")
+      return;
+    return [to.pubkey, "CHECKSIG"];
+  }
+};
+var OutPKH = {
+  encode(from) {
+    if (from.length !== 5 || from[0] !== "DUP" || from[1] !== "HASH160" || !isBytes2(from[2]))
+      return;
+    if (from[2].length !== 20)
+      return;
+    if (from[3] !== "EQUALVERIFY" || from[4] !== "CHECKSIG")
+      return;
+    return { type: "pkh", hash: from[2] };
+  },
+  decode: (to) => to.type === "pkh" ? ["DUP", "HASH160", to.hash, "EQUALVERIFY", "CHECKSIG"] : undefined
+};
+var OutSH = {
+  encode(from) {
+    if (from.length !== 3 || from[0] !== "HASH160" || !isBytes2(from[1]) || from[2] !== "EQUAL")
+      return;
+    if (from[1].length !== 20)
+      return;
+    return { type: "sh", hash: from[1] };
+  },
+  decode: (to) => to.type === "sh" ? ["HASH160", to.hash, "EQUAL"] : undefined
+};
+var OutWSH = {
+  encode(from) {
+    if (from.length !== 2 || from[0] !== 0 || !isBytes2(from[1]))
+      return;
+    if (from[1].length !== 32)
+      return;
+    return { type: "wsh", hash: from[1] };
+  },
+  decode: (to) => to.type === "wsh" ? [0, to.hash] : undefined
+};
+var OutWPKH = {
+  encode(from) {
+    if (from.length !== 2 || from[0] !== 0 || !isBytes2(from[1]))
+      return;
+    if (from[1].length !== 20)
+      return;
+    return { type: "wpkh", hash: from[1] };
+  },
+  decode: (to) => to.type === "wpkh" ? [0, to.hash] : undefined
+};
+var OutMS = {
+  encode(from) {
+    const last = from.length - 1;
+    if (from[last] !== "CHECKMULTISIG")
+      return;
+    const m = from[0];
+    const n = from[last - 1];
+    if (typeof m !== "number" || typeof n !== "number")
+      return;
+    const pubkeys = from.slice(1, -2);
+    if (n !== pubkeys.length)
+      return;
+    for (const pub of pubkeys)
+      if (!isBytes2(pub) || !isValidPubkey(pub, PubT.ecdsa))
+        return;
+    if (!Number.isSafeInteger(m) || m < 1 || m > n)
+      return;
+    return { type: "ms", m, pubkeys };
+  },
+  decode: (to) => to.type === "ms" ? [to.m, ...to.pubkeys, to.pubkeys.length, "CHECKMULTISIG"] : undefined
+};
+var OutTR = {
+  encode(from) {
+    if (from.length !== 2 || from[0] !== 1 || !isBytes2(from[1]) || from[1].length !== 32)
+      return;
+    if (!isValidPubkey(from[1], PubT.schnorr))
+      return;
+    return { type: "tr", pubkey: from[1] };
+  },
+  decode: (to) => to.type === "tr" ? [1, to.pubkey] : undefined
+};
+var OutTRNS = {
+  encode(from) {
+    const last = from.length - 1;
+    if (from[last] !== "CHECKSIG")
+      return;
+    const pubkeys = [];
+    for (let i = 0;i < last; i++) {
+      const elm = from[i];
+      if (i & 1) {
+        if (elm !== "CHECKSIGVERIFY" || i === last - 1)
+          return;
+        continue;
+      }
+      if (!isBytes2(elm) || !isValidPubkey(elm, PubT.schnorr))
+        return;
+      pubkeys.push(elm);
+    }
+    if (!pubkeys.length || pubkeys.length > 999)
+      return;
+    return { type: "tr_ns", pubkeys };
+  },
+  decode: (to) => {
+    if (to.type !== "tr_ns")
+      return;
+    const out = [];
+    for (let i = 0;i < to.pubkeys.length - 1; i++)
+      out.push(to.pubkeys[i], "CHECKSIGVERIFY");
+    out.push(to.pubkeys[to.pubkeys.length - 1], "CHECKSIG");
+    return out;
+  }
+};
+var OutTRMS = {
+  encode(from) {
+    const last = from.length - 1;
+    if (from[last] !== "NUMEQUAL" || from[1] !== "CHECKSIG")
+      return;
+    const pubkeys = [];
+    const m = OpToNum(from[last - 1]);
+    if (typeof m !== "number")
+      return;
+    for (let i = 0;i < last - 1; i++) {
+      const elm = from[i];
+      if (i & 1) {
+        if (elm !== (i === 1 ? "CHECKSIG" : "CHECKSIGADD"))
+          return;
+        continue;
+      }
+      if (!isBytes2(elm) || !isValidPubkey(elm, PubT.schnorr))
+        return;
+      pubkeys.push(elm);
+    }
+    if (!Number.isSafeInteger(m) || m < 1 || m > pubkeys.length || pubkeys.length > 999)
+      return;
+    return { type: "tr_ms", pubkeys, m };
+  },
+  decode: (to) => {
+    if (to.type !== "tr_ms")
+      return;
+    const out = [to.pubkeys[0], "CHECKSIG"];
+    for (let i = 1;i < to.pubkeys.length; i++)
+      out.push(to.pubkeys[i], "CHECKSIGADD");
+    out.push(to.m, "NUMEQUAL");
+    return out;
+  }
+};
+var OutUnknown = {
+  encode(from) {
+    return { type: "unknown", script: Script2.encode(from) };
+  },
+  decode: (to) => to.type === "unknown" ? Script2.decode(to.script) : undefined
+};
+var OutScripts = /* @__PURE__ */ (() => [
+  OutP2A,
+  OutPK,
+  OutPKH,
+  OutSH,
+  OutWSH,
+  OutWPKH,
+  OutMS,
+  OutTR,
+  OutTRNS,
+  OutTRMS,
+  OutUnknown
+])();
+var _OutScript = /* @__PURE__ */ (() => apply(Script2, coders.match(OutScripts)))();
+var OutScript2 = /* @__PURE__ */ (() => Object.freeze(validate(_OutScript, (i) => {
+  if (i.type === "pk" && !isValidPubkey(i.pubkey, PubT.ecdsa))
+    throw new Error("OutScript/pk: wrong key");
+  if ((i.type === "pkh" || i.type === "sh" || i.type === "wpkh") && (!isBytes2(i.hash) || i.hash.length !== 20))
+    throw new Error(`OutScript/${i.type}: wrong hash`);
+  if (i.type === "wsh" && (!isBytes2(i.hash) || i.hash.length !== 32))
+    throw new Error(`OutScript/wsh: wrong hash`);
+  if (i.type === "tr" && (!isBytes2(i.pubkey) || !isValidPubkey(i.pubkey, PubT.schnorr)))
+    throw new Error("OutScript/tr: wrong taproot public key");
+  if (i.type === "ms" || i.type === "tr_ns" || i.type === "tr_ms") {
+    if (!Array.isArray(i.pubkeys))
+      throw new Error("OutScript/multisig: wrong pubkeys array");
+  }
+  if (i.type === "ms") {
+    const n = i.pubkeys.length;
+    for (const p of i.pubkeys)
+      if (!isValidPubkey(p, PubT.ecdsa))
+        throw new Error("OutScript/multisig: wrong pubkey");
+    anumber(i.m, "m");
+    if (i.m <= 0 || n > 16 || i.m > n)
+      throw new Error("OutScript/multisig: invalid params");
+  }
+  if (i.type === "tr_ns" || i.type === "tr_ms") {
+    const n = i.pubkeys.length;
+    if (n > 999)
+      throw new Error(`OutScript/${i.type}: invalid params`);
+    for (const p of i.pubkeys)
+      if (!isValidPubkey(p, PubT.schnorr))
+        throw new Error(`OutScript/${i.type}: wrong pubkey`);
+  }
+  if (i.type === "tr_ms") {
+    const n = i.pubkeys.length;
+    anumber(i.m, "m");
+    if (i.m <= 0 || i.m > n)
+      throw new Error("OutScript/tr_ms: invalid params");
+  }
+  return i;
+})))();
+var _WitnessOutScript = /* @__PURE__ */ (() => Object.freeze(wrap({
+  encodeStream: (w, value) => OutScript2.encodeStream(w, value),
+  decodeStream: (r) => {
+    const raw = r.bytes(r.leftBytes);
+    const out = OutScript2.decode(raw);
+    if (out && (out.type === "p2a" || out.type === "wpkh" || out.type === "wsh" || out.type === "tr") && !equalBytes2(raw, OutScript2.encode(out)))
+      throw new Error("OutScript: non-canonical witness program");
+    return out;
+  }
+})))();
+function checkWSH(s, witnessScript) {
+  if (!equalBytes2(s.hash, sha2562(witnessScript)))
+    throw new Error("checkScript: wsh wrong witnessScript hash");
+  const w = OutScript2.decode(witnessScript);
+  if (w.type === "tr" || w.type === "tr_ns" || w.type === "tr_ms")
+    throw new Error(`checkScript: P2${w.type} cannot be wrapped in P2SH`);
+  if (w.type === "wpkh" || w.type === "wsh" || w.type === "sh")
+    throw new Error(`checkScript: P2${w.type} cannot be wrapped in P2WSH`);
+}
+function checkScript(script, redeemScript, witnessScript) {
+  let hasWsh = false;
+  let r = undefined;
+  if (script) {
+    const s = _WitnessOutScript.decode(script);
+    if (s.type === "tr_ns" || s.type === "tr_ms" || s.type === "ms" || s.type == "pk")
+      throw new Error(`checkScript: non-wrapped ${s.type}`);
+    if (redeemScript) {
+      if (s.type !== "sh")
+        throw new Error("checkScript: redeemScript without P2SH");
+      if (!equalBytes2(s.hash, hash160(redeemScript)))
+        throw new Error("checkScript: sh wrong redeemScript hash");
+      r = _WitnessOutScript.decode(redeemScript);
+      if (r?.type === "tr" || r?.type === "tr_ns" || r?.type === "tr_ms")
+        throw new Error(`checkScript: P2${r.type} cannot be wrapped in P2SH`);
+      if (r?.type === "sh")
+        throw new Error("checkScript: P2SH cannot be wrapped in P2SH");
+    }
+    if (s.type === "wsh") {
+      hasWsh = true;
+      if (witnessScript)
+        checkWSH(s, witnessScript);
+    }
+  }
+  if (redeemScript) {
+    if (r === undefined)
+      r = _WitnessOutScript.decode(redeemScript);
+    if (r?.type === "wsh") {
+      hasWsh = true;
+      if (witnessScript)
+        checkWSH(r, witnessScript);
+    }
+  }
+  if (witnessScript && !hasWsh)
+    throw new Error("checkScript: witnessScript without P2WSH");
+}
+function checkTaprootScript(script, internalPubKey, allowUnknownOutputs = false, customScripts) {
+  const out = OutScript2.decode(script);
+  if (out.type === "unknown") {
+    if (customScripts) {
+      const cs = apply(Script2, coders.match(customScripts));
+      let c;
+      try {
+        c = cs.decode(script);
+      } catch (e) {
+        c = undefined;
+      }
+      if (c !== undefined) {
+        if (!astring(c.type, "c.type").startsWith("tr_"))
+          throw new Error(`P2TR: invalid custom type=${c.type}`);
+        return;
+      }
+    }
+    if (allowUnknownOutputs)
+      return;
+  }
+  if (!["tr_ns", "tr_ms"].includes(out.type))
+    throw new Error(`P2TR: invalid leaf script=${out.type}`);
+  const outms = out;
+  if (!allowUnknownOutputs && outms.pubkeys) {
+    for (const p of outms.pubkeys) {
+      if (equalBytes2(p, taprootNumsKey()))
+        throw new Error("Unspendable taproot key in leaf script");
+      if (equalBytes2(p, internalPubKey)) {
+        throw new Error("Using P2TR with leaf script with same key as internal key is not supported");
+      }
+    }
+  }
+}
+function taprootListToTree2(taprootList) {
+  aarray(taprootList, "taprootList", (leaf, title) => {
+    if (Array.isArray(leaf))
+      return;
+    validateObject2(leaf, {}, {}, title);
+    if (leaf.weight !== undefined)
+      anumber(leaf.weight, title + ".weight");
+  });
+  if (!taprootList.length)
+    throw new Error("taprootListToTree: empty tree");
+  const lst = Array.from(taprootList);
+  while (lst.length >= 2) {
+    lst.sort((a, b) => (b.weight || 1) - (a.weight || 1));
+    const b = lst.pop();
+    const a = lst.pop();
+    const weight = (a?.weight || 1) + (b?.weight || 1);
+    lst.push({
+      weight,
+      childs: [a?.childs || a, b?.childs || b]
+    });
+  }
+  const last = lst[0];
+  return last?.childs || last;
+}
+function taprootAddPath(tree, path = []) {
+  if (!tree)
+    throw new Error(`taprootAddPath: empty tree`);
+  if (tree.type === "leaf")
+    return { ...tree, path };
+  if (tree.type !== "branch")
+    throw new Error(`taprootAddPath: wrong type=${tree}`);
+  return {
+    ...tree,
+    path,
+    left: taprootAddPath(tree.left, [tree.right.hash, ...path]),
+    right: taprootAddPath(tree.right, [tree.left.hash, ...path])
+  };
+}
+function taprootWalkTree(tree) {
+  if (!tree)
+    throw new Error(`taprootAddPath: empty tree`);
+  if (tree.type === "leaf")
+    return [tree];
+  if (tree.type !== "branch")
+    throw new Error(`taprootWalkTree: wrong type=${tree}`);
+  return [...taprootWalkTree(tree.left), ...taprootWalkTree(tree.right)];
+}
+var TAPROOT_MAX_DEPTH = 128;
+function taprootHashTree(tree, internalPubKey, allowUnknownOutputs = false, customScripts, depth = 0) {
+  if (depth > TAPROOT_MAX_DEPTH)
+    throw new RangeError(`P2TR: tree depth exceeds ${TAPROOT_MAX_DEPTH}`);
+  if (tree === undefined)
+    throw new Error("taprootHashTree: empty tree");
+  if (!Array.isArray(tree) && !utils.isPlainObject(tree))
+    throw new TypeError('"tree" expected object or array, got type=' + typeof tree);
+  if (Array.isArray(tree) && tree.length === 1)
+    tree = tree[0];
+  if (!Array.isArray(tree)) {
+    validateObject2(tree, {}, {}, "tree");
+    const version = tree.leafVersion;
+    const { script: leafScript } = tree;
+    if (tree.tapLeafScript || tree.tapMerkleRoot && !equalBytes2(tree.tapMerkleRoot, EMPTY))
+      throw new Error("P2TR: tapRoot leafScript cannot have tree");
+    const script = typeof leafScript === "string" ? hex.decode(leafScript) : abytes2(leafScript, undefined, "tree.script");
+    checkTaprootScript(script, internalPubKey, allowUnknownOutputs, customScripts);
+    return {
+      type: "leaf",
+      version,
+      script,
+      hash: tapLeafHash(script, tapLeafVersion(version))
+    };
+  }
+  if (tree.length !== 2)
+    tree = taprootListToTree2(tree);
+  if (tree.length !== 2)
+    throw new Error("hashTree: non binary tree!");
+  const left = taprootHashTree(tree[0], internalPubKey, allowUnknownOutputs, customScripts, depth + 1);
+  const right = taprootHashTree(tree[1], internalPubKey, allowUnknownOutputs, customScripts, depth + 1);
+  let [lH, rH] = [left.hash, right.hash];
+  if (compareBytes(rH, lH) === -1)
+    [lH, rH] = [rH, lH];
+  return {
+    type: "branch",
+    left,
+    right,
+    hash: tagSchnorr("TapBranch", lH, rH)
+  };
+}
+var TAP_LEAF_VERSION = 192;
+var tapLeafVersion = (version) => {
+  if (version === undefined)
+    return TAP_LEAF_VERSION;
+  anumber(version, "leafVersion");
+  if (version > 254 || version === 80 || !!(version & 1))
+    throw new Error(`P2TR: invalid leafVersion=${version}`);
+  return version;
+};
+var tapLeafHash = (script, version = TAP_LEAF_VERSION) => tagSchnorr("TapLeaf", new Uint8Array([tapLeafVersion(version)]), VarBytes.encode(script));
+function p2tr2(internalPubKey, tree, network = NETWORK2, allowUnknownOutputs = false, customScripts) {
+  if (!internalPubKey && !tree)
+    throw new Error("p2tr: should have pubKey or scriptTree (or both)");
+  const pubKey = typeof internalPubKey === "string" ? hex.decode(internalPubKey) : internalPubKey ?? taprootNumsKey();
+  if (!isValidPubkey(pubKey, PubT.schnorr))
+    throw new Error("p2tr: non-schnorr pubkey");
+  if (tree) {
+    let hashedTree = taprootAddPath(taprootHashTree(tree, pubKey, allowUnknownOutputs, customScripts));
+    const tapMerkleRoot = hashedTree.hash;
+    const [tweakedPubkey, parity] = taprootTweakPubkey(pubKey, tapMerkleRoot);
+    const tapLeafScript = [];
+    const leaves = taprootWalkTree(hashedTree).map((l) => {
+      const version = tapLeafVersion(l.version);
+      const controlBlock = {
+        version: version + parity,
+        internalKey: pubKey,
+        merklePath: l.path
+      };
+      tapLeafScript.push([controlBlock, concatBytes3(l.script, new Uint8Array([version]))]);
+      return { ...l, controlBlock: TaprootControlBlock2.encode(controlBlock) };
+    });
+    return {
+      type: "tr",
+      script: OutScript2.encode({ type: "tr", pubkey: tweakedPubkey }),
+      address: Address2(network).encode({ type: "tr", pubkey: tweakedPubkey }),
+      tweakedPubkey,
+      tapInternalKey: pubKey,
+      leaves,
+      tapLeafScript,
+      tapMerkleRoot
+    };
+  } else {
+    const tweakedPubkey = taprootTweakPubkey(pubKey, EMPTY)[0];
+    return {
+      type: "tr",
+      script: OutScript2.encode({ type: "tr", pubkey: tweakedPubkey }),
+      address: Address2(network).encode({ type: "tr", pubkey: tweakedPubkey }),
+      tweakedPubkey,
+      tapInternalKey: pubKey
+    };
+  }
+}
+var base58check = /* @__PURE__ */ createBase58check(sha2562);
+function validateWitness(version, data) {
+  if (data.length < 2 || data.length > 40)
+    throw new Error("Witness: invalid length");
+  if (version > 16)
+    throw new Error("Witness: invalid version");
+  if (version === 0 && !(data.length === 20 || data.length === 32))
+    throw new Error("Witness: invalid length for version");
+}
+function programToWitness(version, data, network = NETWORK2) {
+  validateWitness(version, data);
+  const coder = version === 0 ? bech32 : bech32m;
+  return coder.encode(network.bech32, [version].concat(coder.toWords(data)));
+}
+function formatKey(hashed, prefix) {
+  return base58check.encode(concatBytes3(Uint8Array.from(prefix), hashed));
+}
+function Address2(network = NETWORK2) {
+  validateObject2(network, {}, {}, "network");
+  return {
+    encode(from) {
+      validateObject2(from, {}, {}, "from");
+      const { type } = from;
+      astring(type, "from.type");
+      if (type === "wpkh")
+        return programToWitness(0, from.hash, network);
+      else if (type === "wsh")
+        return programToWitness(0, from.hash, network);
+      else if (type === "tr")
+        return programToWitness(1, from.pubkey, network);
+      else if (type === "p2a")
+        return programToWitness(1, P2A_PROGRAM, network);
+      else if (type === "pkh")
+        return formatKey(from.hash, [network.pubKeyHash]);
+      else if (type === "sh")
+        return formatKey(from.hash, [network.scriptHash]);
+      throw new Error(`Unknown address type=${type}`);
+    },
+    decode(address) {
+      astring(address, "address");
+      if (address.length < 14 || address.length > 74)
+        throw new Error("Invalid address length");
+      if (network.bech32 && address.toLowerCase().startsWith(`${network.bech32}1`)) {
+        let res;
+        try {
+          res = bech32.decode(address);
+          if (res.words[0] !== 0)
+            throw new Error(`bech32: wrong version=${res.words[0]}`);
+        } catch (_) {
+          res = bech32m.decode(address);
+          if (res.words[0] === 0)
+            throw new Error(`bech32m: wrong version=${res.words[0]}`);
+        }
+        if (res.prefix !== network.bech32)
+          throw new Error(`wrong bech32 prefix=${res.prefix}`);
+        const [version, ...program] = res.words;
+        const data = bech32.fromWords(program);
+        validateWitness(version, data);
+        if (version === 0 && data.length === 32)
+          return { type: "wsh", hash: data };
+        else if (version === 0 && data.length === 20)
+          return { type: "wpkh", hash: data };
+        else if (version === 1 && data.length === 32)
+          return { type: "tr", pubkey: data };
+        else if (version === 1 && equalBytes2(data, P2A_PROGRAM))
+          return { type: "p2a", script: Script2.encode([1, data]) };
+        else
+          throw new Error("Unknown witness program");
+      }
+      const data = base58check.decode(address);
+      if (data.length !== 21)
+        throw new Error("Invalid base58 address");
+      if (data[0] === network.pubKeyHash) {
+        return { type: "pkh", hash: data.slice(1) };
+      } else if (data[0] === network.scriptHash) {
+        return {
+          type: "sh",
+          hash: data.slice(1)
+        };
+      }
+      throw new Error(`Invalid address prefix=${data[0]}`);
+    }
+  };
+}
+// ../../node_modules/.bun/@scure+btc-signer@2.4.1/node_modules/@scure/btc-signer/transaction.js
+var _0n5 = /* @__PURE__ */ BigInt(0);
+var _1n4 = /* @__PURE__ */ BigInt(1);
+var U64_MAX = /* @__PURE__ */ BigInt("0xffffffffffffffff");
+var EMPTY32 = /* @__PURE__ */ new Uint8Array(32);
+var EMPTY_OUTPUT = {
+  amount: U64_MAX,
+  script: EMPTY
+};
+var toVsize = (weight) => Math.ceil(weight / 4);
+var stripCodeSeparator = (script) => {
+  let start = 0;
+  const out = [];
+  for (let i = 0;i < script.length; ) {
+    const pos = i;
+    const op = script[i++];
+    if (op === OP.CODESEPARATOR) {
+      if (start < pos)
+        out.push(script.subarray(start, pos));
+      start = i;
+      continue;
+    }
+    const len = scriptPushLen(op, (bytes) => {
+      if (i + bytes > script.length)
+        throw new Error("Unexpected end of script");
+      let len = 0;
+      for (let j = 0;j < bytes; j++)
+        len |= script[i + j] << 8 * j;
+      i += bytes;
+      return len;
+    });
+    if (len === undefined)
+      continue;
+    i += len;
+    if (i > script.length)
+      throw new Error("Unexpected end of script");
+  }
+  if (start === 0)
+    return script;
+  if (start < script.length)
+    out.push(script.subarray(start));
+  return out.length ? concatBytes3(...out) : EMPTY;
+};
+var DEFAULT_VERSION = 2;
+var DEFAULT_LOCKTIME = 0;
+var DEFAULT_SEQUENCE = 4294967295;
+var def = (value, def) => value === undefined ? def : value;
+function cloneDeep(obj) {
+  if (Array.isArray(obj))
+    return obj.map((i) => cloneDeep(i));
+  else if (isBytes2(obj))
+    return Uint8Array.from(obj);
+  else if (["number", "bigint", "boolean", "string", "undefined"].includes(typeof obj))
+    return obj;
+  else if (obj === null)
+    return obj;
+  else if (typeof obj === "object") {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, cloneDeep(v)]));
+  }
+  throw new Error(`cloneDeep: unknown type=${typeof obj}`);
+}
+var SignatureHash = /* @__PURE__ */ (() => Object.freeze({
+  DEFAULT: 0,
+  ALL: 1,
+  NONE: 2,
+  SINGLE: 3,
+  ANYONECANPAY: 128
+}))();
+var SigHash2 = /* @__PURE__ */ (() => Object.freeze({
+  DEFAULT: SignatureHash.DEFAULT,
+  ALL: SignatureHash.ALL,
+  NONE: SignatureHash.NONE,
+  SINGLE: SignatureHash.SINGLE,
+  ALL_ANYONECANPAY: SignatureHash.ALL | SignatureHash.ANYONECANPAY,
+  NONE_ANYONECANPAY: SignatureHash.NONE | SignatureHash.ANYONECANPAY,
+  SINGLE_ANYONECANPAY: SignatureHash.SINGLE | SignatureHash.ANYONECANPAY
+}))();
+var SigHashNames = /* @__PURE__ */ (() => Object.freeze(reverseObject(SigHash2)))();
+function getTaprootKeys(privKey, pubKey, internalKey, merkleRoot = EMPTY) {
+  if (equalBytes2(internalKey, pubKey)) {
+    privKey = taprootTweakPrivKey(privKey, merkleRoot);
+    pubKey = pubSchnorr(privKey);
+  }
+  return { privKey, pubKey };
+}
+function outputBeforeSign(i) {
+  if (i.script === undefined || i.amount === undefined)
+    throw new Error("Transaction/output: script and amount required");
+  return { script: i.script, amount: i.amount };
+}
+function inputBeforeSign(i) {
+  validateObject2(i, {}, {}, "i");
+  if (i.txid === undefined || i.index === undefined)
+    throw new Error("Transaction/input: txid and index required");
+  const res = {
+    txid: i.txid,
+    index: i.index,
+    sequence: def(i.sequence, DEFAULT_SEQUENCE),
+    finalScriptSig: def(i.finalScriptSig, EMPTY)
+  };
+  RawInput.encode(res);
+  return res;
+}
+var cleanExtensions = (map, unknownMode, proprietaryMode, rejectStrip = false) => {
+  const out = { ...map };
+  for (const [name, mode] of [
+    ["unknown", unknownMode],
+    ["proprietary", proprietaryMode]
+  ]) {
+    const value = out[name];
+    if (value !== undefined)
+      aarray(value, `${name} PSBT field`);
+    const rows = value;
+    if (!rows?.length) {
+      delete out[name];
+      continue;
+    }
+    if (mode === "strict")
+      throw new Error(`PSBT: ${name} PSBT field is not allowed in strict mode`);
+    if (mode === "strip") {
+      if (rejectStrip)
+        throw new Error(`PSBT: ${name} PSBT field cannot be supplied when policy is strip`);
+      delete out[name];
+    }
+  }
+  return out;
+};
+var cleanTxModifiable = (value, mode) => {
+  if (value === undefined || !(value & ~7))
+    return value;
+  if (mode === "strict")
+    throw new Error("PSBT: unknown txModifiable bits in strict mode");
+  return mode === "strip" ? value & 7 : value;
+};
+function cleanFinalInput(i, unknownMode = "strip", proprietaryMode = "strip") {
+  const _i = i;
+  const extensions = cleanExtensions(_i, unknownMode, proprietaryMode);
+  if (extensions.unknown)
+    _i.unknown = extensions.unknown;
+  else
+    delete _i.unknown;
+  if (extensions.proprietary)
+    _i.proprietary = extensions.proprietary;
+  else
+    delete _i.proprietary;
+  for (const _k in _i) {
+    const k = _k;
+    if (proprietaryMode === "ignore" && k === "proprietary" && _i.proprietary?.length)
+      continue;
+    if (!PSBTInputFinalKeys.includes(k))
+      delete _i[k];
+  }
+}
+var TxHashIdx = /* @__PURE__ */ (() => struct({ txid: createBytes(32, true), index: U32LE }))();
+function validateSigHash(s) {
+  if (typeof s !== "number" || typeof SigHashNames[s] !== "string")
+    throw new Error(`Invalid SigHash=${s}`);
+  return s;
+}
+function unpackSighash(hashType) {
+  const masked = hashType & 31;
+  return {
+    isAny: !!(hashType & SignatureHash.ANYONECANPAY),
+    isNone: masked === SignatureHash.NONE,
+    isSingle: masked === SignatureHash.SINGLE
+  };
+}
+var sighashScope = (sighash) => ({
+  sigInputs: sighash & SignatureHash.ANYONECANPAY,
+  sigOutputs: sighash === SignatureHash.DEFAULT ? SignatureHash.ALL : sighash & 3
+});
+var normalizeUnknowns = (name, mode, legacy, fallback = "strip") => {
+  const alias = legacy === undefined ? undefined : legacy ? "ignore" : "strip";
+  if (mode !== undefined && mode !== "ignore" && mode !== "strip" && mode !== "strict")
+    throw new Error(`Transaction options wrong value: ${name}=${mode}`);
+  if (mode !== undefined && alias !== undefined && mode !== alias)
+    throw new Error(`Transaction options: conflicting ${name} options`);
+  return mode || alias || fallback;
+};
+function validateOpts(opts) {
+  if (opts !== undefined)
+    validateObject2(opts, {}, {}, "opts");
+  const _opts = {
+    ...opts,
+    version: def(opts.version, DEFAULT_VERSION),
+    lockTime: def(opts.lockTime, 0),
+    PSBTVersion: def(opts.PSBTVersion, 0)
+  };
+  if (typeof _opts.allowUnknowInput !== "undefined")
+    _opts.allowUnknownInputs = _opts.allowUnknowInput;
+  if (typeof _opts.allowUnknowOutput !== "undefined")
+    _opts.allowUnknownOutputs = _opts.allowUnknowOutput;
+  if (_opts.allowMissingTxModifiable === undefined)
+    _opts.allowMissingTxModifiable = true;
+  if (typeof _opts.lockTime !== "number")
+    throw new Error("Transaction lock time should be number");
+  U32LE.encode(_opts.lockTime);
+  if (_opts.PSBTVersion !== 0 && _opts.PSBTVersion !== 2)
+    throw new Error(`Unknown PSBT version ${_opts.PSBTVersion}`);
+  for (const k of [
+    "allowUnknownVersion",
+    "allowUnknownOutputs",
+    "allowUnknownInputs",
+    "disableScriptCheck",
+    "bip174jsCompat",
+    "allowLegacyWitnessUtxo",
+    "strictPrevoutValidation",
+    "lowR",
+    "allowUnknown",
+    "allowMissingTxModifiable"
+  ]) {
+    const v = _opts[k];
+    if (v === undefined)
+      continue;
+    if (typeof v !== "boolean")
+      throw new Error(`Transation options wrong type: ${k}=${v} (${typeof v})`);
+  }
+  _opts.unknown = normalizeUnknowns("unknown", _opts.unknown, _opts.allowUnknown);
+  _opts.proprietary = normalizeUnknowns("proprietary", _opts.proprietary, undefined, _opts.unknown);
+  if (_opts.allowUnknownVersion ? typeof _opts.version !== "number" : ![-1, 0, 1, 2, 3].includes(_opts.version))
+    throw new Error(`Unknown version: ${_opts.version}`);
+  I32LE.encode(_opts.version);
+  if (_opts.customScripts !== undefined) {
+    const cs = _opts.customScripts;
+    if (!Array.isArray(cs)) {
+      throw new Error(`wrong custom scripts type (expected array): customScripts=${cs} (${typeof cs})`);
+    }
+    for (const s of cs) {
+      if (typeof s.encode !== "function" || typeof s.decode !== "function")
+        throw new Error(`wrong script=${s} (${typeof s})`);
+      if (s.finalizeTaproot !== undefined && typeof s.finalizeTaproot !== "function")
+        throw new Error(`wrong script=${s} (${typeof s})`);
+    }
+  }
+  return Object.freeze(_opts);
+}
+function checkTaprootInputCommitments(input, prevScript) {
+  const output = _WitnessOutScript.decode(prevScript);
+  const hasTaprootCommitments = input.tapInternalKey !== undefined || input.tapMerkleRoot !== undefined || !!input.tapLeafScript?.length;
+  if (output.type !== "tr") {
+    if (hasTaprootCommitments)
+      throw new Error("validateInput: Taproot metadata without P2TR previous output");
+    return;
+  }
+  const checkOutputKey = (internalKey, merkleRoot, parity) => {
+    const [outputKey, outputParity] = taprootTweakPubkey(internalKey, merkleRoot);
+    if (!equalBytes2(outputKey, output.pubkey))
+      throw new Error("validateInput: Taproot commitment does not match previous output");
+    if (parity !== undefined && outputParity !== parity)
+      throw new Error("validateInput: Taproot control-block parity does not match previous output");
+  };
+  if (input.tapLeafScript) {
+    for (const [controlBlock, scriptWithVersion] of input.tapLeafScript) {
+      const leafVersion = scriptWithVersion[scriptWithVersion.length - 1];
+      const script = scriptWithVersion.subarray(0, -1);
+      let merkleRoot = tapLeafHash(script, leafVersion);
+      for (const sibling of controlBlock.merklePath) {
+        merkleRoot = compareBytes(sibling, merkleRoot) === -1 ? tagSchnorr("TapBranch", sibling, merkleRoot) : tagSchnorr("TapBranch", merkleRoot, sibling);
+      }
+      checkOutputKey(controlBlock.internalKey, merkleRoot, controlBlock.version & 1);
+      if (input.tapInternalKey && !equalBytes2(input.tapInternalKey, controlBlock.internalKey))
+        throw new Error("validateInput: tapInternalKey does not match Taproot control block");
+      if (input.tapMerkleRoot && !equalBytes2(input.tapMerkleRoot, merkleRoot))
+        throw new Error("validateInput: tapMerkleRoot does not match Taproot control block");
+    }
+  }
+  if (input.tapInternalKey && (input.tapMerkleRoot || !input.tapLeafScript?.length))
+    checkOutputKey(input.tapInternalKey, input.tapMerkleRoot || EMPTY);
+}
+var LOCKTIME_THRESHOLD = 500000000;
+function validateRequiredLocktimes(input) {
+  const height = input.requiredHeightLocktime;
+  if (height !== undefined) {
+    anumber(height, "requiredHeightLocktime");
+    if (height === 0 || height >= LOCKTIME_THRESHOLD)
+      throw new RangeError(`requiredHeightLocktime must be between 1 and ${LOCKTIME_THRESHOLD - 1}, got ${height}`);
+  }
+  const time = input.requiredTimeLocktime;
+  if (time !== undefined) {
+    anumber(time, "requiredTimeLocktime");
+    if (time < LOCKTIME_THRESHOLD || time > 4294967295)
+      throw new RangeError(`requiredTimeLocktime must be between ${LOCKTIME_THRESHOLD} and 4294967295, got ${time}`);
+  }
+}
+function resolvePSBTLocktime(inputs, fallback = DEFAULT_LOCKTIME) {
+  let height = DEFAULT_LOCKTIME;
+  let time = DEFAULT_LOCKTIME;
+  let hasRequirements = false;
+  let heightSupported = true;
+  let timeSupported = true;
+  for (const input of inputs) {
+    validateRequiredLocktimes(input);
+    const hasHeight = input.requiredHeightLocktime !== undefined;
+    const hasTime = input.requiredTimeLocktime !== undefined;
+    if (!hasHeight && !hasTime)
+      continue;
+    hasRequirements = true;
+    if (hasHeight)
+      height = Math.max(height, input.requiredHeightLocktime);
+    else
+      heightSupported = false;
+    if (hasTime)
+      time = Math.max(time, input.requiredTimeLocktime);
+    else
+      timeSupported = false;
+  }
+  if (!hasRequirements)
+    return fallback;
+  if (heightSupported)
+    return height;
+  if (timeSupported)
+    return time;
+  throw new Error("PSBTv2: incompatible height-based and time-based locktime requirements");
+}
+function validateInput(i, disableScriptCheck = false) {
+  validateObject2(i, {}, {}, "i");
+  const _i = i;
+  validateRequiredLocktimes(_i);
+  let prevOut;
+  if (_i.nonWitnessUtxo && _i.index !== undefined) {
+    const last = _i.nonWitnessUtxo.outputs.length - 1;
+    if (_i.index > last)
+      throw new Error(`validateInput: index(${_i.index}) not in nonWitnessUtxo`);
+    prevOut = _i.nonWitnessUtxo.outputs[_i.index];
+    if (_i.witnessUtxo && (!equalBytes2(_i.witnessUtxo.script, prevOut.script) || _i.witnessUtxo.amount !== prevOut.amount))
+      throw new Error("validateInput: witnessUtxo different from nonWitnessUtxo");
+    if (_i.txid) {
+      const outputs = _i.nonWitnessUtxo.outputs;
+      if (outputs.length - 1 < _i.index)
+        throw new Error("nonWitnessUtxo: incorect output index");
+      const tx = Transaction2.fromRaw(RawTx.encode(_i.nonWitnessUtxo), {
+        allowUnknownOutputs: true,
+        disableScriptCheck: true,
+        allowUnknownInputs: true,
+        allowUnknownVersion: true
+      });
+      const txid = hex.encode(_i.txid);
+      if (tx.id !== txid)
+        throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
+    }
+  } else if (_i.witnessUtxo)
+    prevOut = _i.witnessUtxo;
+  if (prevOut && !disableScriptCheck) {
+    checkScript(prevOut.script, _i.redeemScript, _i.witnessScript);
+    checkTaprootInputCommitments(_i, prevOut.script);
+  }
+  return _i;
+}
+var inputSignatures = (input) => {
+  const _input = input;
+  const res = [];
+  const add = (signature, taproot, scriptPath = false) => {
+    const sig = signature;
+    if (!sig.length)
+      return;
+    const sighash = taproot && sig.length === 64 ? SignatureHash.DEFAULT : sig[sig.length - 1];
+    res.push({ sighash, taproot, scriptPath });
+  };
+  for (const [, signature] of _input.partialSig || [])
+    add(signature, false);
+  if (_input.tapKeySig)
+    add(_input.tapKeySig, true);
+  for (const [, signature] of _input.tapScriptSig || [])
+    add(signature, true, true);
+  return res;
+};
+var inputSignedKeys = {
+  self: ["txid", "index", "sequence", "nonWitnessUtxo", "witnessUtxo", "sighashType"],
+  ecdsa: ["redeemScript", "witnessScript"],
+  tapscript: ["tapLeafScript"],
+  cross: ["txid", "index"],
+  prevout: ["nonWitnessUtxo", "witnessUtxo"]
+};
+function getPrevOut(input) {
+  validateObject2(input, {}, {}, "input");
+  const _input = input;
+  if (_input.nonWitnessUtxo) {
+    if (_input.index === undefined)
+      throw new Error("Unknown input index");
+    if (!Number.isSafeInteger(_input.index) || _input.index < 0 || _input.index >= _input.nonWitnessUtxo.outputs.length)
+      throw new Error(`Wrong input index=${_input.index}`);
+    return _input.nonWitnessUtxo.outputs[_input.index];
+  } else if ("witnessUtxo" in _input) {
+    const prev = _input.witnessUtxo;
+    validateObject2(prev, {}, {}, "input.witnessUtxo");
+    abigint(prev.amount, "input.witnessUtxo.amount");
+    if (!isBytes2(prev.script))
+      throw new TypeError('"input.witnessUtxo.script" expected Uint8Array, got type=' + typeof prev.script);
+    return prev;
+  } else
+    throw new Error("Cannot find previous output info");
+}
+function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, unknown = "strip", proprietary = "strip") {
+  validateObject2(i, {}, {}, "i");
+  if (cur !== undefined)
+    validateObject2(cur, {}, {}, "cur");
+  if (allowedFields !== undefined)
+    aarray(allowedFields, "allowedFields");
+  const _i = i;
+  const _cur = cur;
+  const _allowedFields = allowedFields;
+  let { nonWitnessUtxo, txid } = _i;
+  if (typeof nonWitnessUtxo === "string")
+    nonWitnessUtxo = hex.decode(nonWitnessUtxo);
+  if (isBytes2(nonWitnessUtxo))
+    nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);
+  if (!("nonWitnessUtxo" in _i) && nonWitnessUtxo === undefined)
+    nonWitnessUtxo = _cur?.nonWitnessUtxo;
+  if (typeof txid === "string")
+    txid = hex.decode(txid);
+  if (txid === undefined)
+    txid = _cur?.txid;
+  let res = { ..._cur, ..._i, nonWitnessUtxo, txid };
+  if (!("nonWitnessUtxo" in _i) && res.nonWitnessUtxo === undefined)
+    delete res.nonWitnessUtxo;
+  if (res.sequence === undefined)
+    res.sequence = DEFAULT_SEQUENCE;
+  if (res.tapMerkleRoot === null)
+    delete res.tapMerkleRoot;
+  res = mergeKeyMap(PSBTInput, res, _cur, _allowedFields, unknown, proprietary);
+  if (Array.isArray(res.tapLeafScript) && !res.tapLeafScript.length)
+    delete res.tapLeafScript;
+  validateRequiredLocktimes(res);
+  PSBTInputCoder.encode(res);
+  return validateInput(res, disableScriptCheck);
+}
+function getInputType(input, allowLegacyWitnessUtxo = false) {
+  const _input = input;
+  let txType = "legacy";
+  let defaultSighash = SignatureHash.ALL;
+  const prevOut = getPrevOut(_input);
+  const first = _WitnessOutScript.decode(prevOut.script);
+  let type = first.type;
+  let cur = first;
+  const stack = [first];
+  let lastScript = prevOut.script;
+  if (first.type === "tr") {
+    defaultSighash = SignatureHash.DEFAULT;
+    return {
+      txType: "taproot",
+      type: "tr",
+      last: first,
+      lastScript: prevOut.script,
+      defaultSighash,
+      sighash: _input.sighashType || defaultSighash
+    };
+  } else {
+    if (first.type === "wpkh" || first.type === "wsh")
+      txType = "segwit";
+    if (first.type === "sh") {
+      if (!_input.redeemScript)
+        throw new Error("inputType: sh without redeemScript");
+      let child = _WitnessOutScript.decode(_input.redeemScript);
+      if (child.type === "wpkh" || child.type === "wsh")
+        txType = "segwit";
+      stack.push(child);
+      cur = child;
+      lastScript = _input.redeemScript;
+      type += `-${child.type}`;
+    }
+    if (cur.type === "wsh") {
+      if (!_input.witnessScript)
+        throw new Error("inputType: wsh without witnessScript");
+      let child = OutScript2.decode(_input.witnessScript);
+      if (child.type === "wsh")
+        txType = "segwit";
+      stack.push(child);
+      cur = child;
+      lastScript = _input.witnessScript;
+      type += `-${child.type}`;
+    }
+    const last = stack[stack.length - 1];
+    if (last.type === "sh" || last.type === "wsh")
+      throw new Error("inputType: sh/wsh cannot be terminal type");
+    const res = {
+      type,
+      txType,
+      last,
+      lastScript,
+      defaultSighash,
+      sighash: _input.sighashType || defaultSighash
+    };
+    if (txType === "legacy" && !allowLegacyWitnessUtxo && !_input.nonWitnessUtxo) {
+      throw new Error(`Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`);
+    }
+    return res;
+  }
+}
+
+class Transaction2 {
+  global = {};
+  inputs = [];
+  outputs = [];
+  opts;
+  constructor(opts = {}) {
+    const _opts = this.opts = validateOpts(opts);
+    this.global.fallbackLocktime = _opts.lockTime;
+    this.global.txVersion = _opts.version;
+    if (_opts.PSBTVersion === 2)
+      this.global.txModifiable = 3;
+  }
+  isPSBTv2() {
+    return (this.global.version ?? this.opts.PSBTVersion) === 2;
+  }
+  requireTxModifiable(bit, kind) {
+    if (!this.isPSBTv2())
+      return;
+    if (!(this.txModifiablePolicy() & bit))
+      throw new Error(`PSBTv2: ${kind} are not modifiable`);
+  }
+  txModifiablePolicy(allowMissing = this.opts.allowMissingTxModifiable, unknownMode = this.opts.unknown) {
+    if (!this.isPSBTv2())
+      return 3;
+    if (this.global.txModifiable !== undefined)
+      return cleanTxModifiable(this.global.txModifiable, unknownMode);
+    return allowMissing ? 3 : 0;
+  }
+  modifiable(allowMissing = this.opts.allowMissingTxModifiable, unknownMode = this.opts.unknown) {
+    let flags = this.txModifiablePolicy(allowMissing, unknownMode);
+    let hasOpaqueFinal = false;
+    let hasSingle = false;
+    for (let idx = 0;idx < this.inputs.length; idx++) {
+      const signatures = inputSignatures(this.inputs[idx]);
+      if (!signatures.length && this.inputStatus(idx) === "finalized")
+        hasOpaqueFinal = true;
+      for (const { sighash } of signatures) {
+        const { isAny, isNone, isSingle } = unpackSighash(sighash);
+        if (!isAny)
+          flags &= ~1;
+        if (!isNone)
+          flags &= ~2;
+        if (isSingle)
+          hasSingle = true;
+      }
+    }
+    if (hasSingle)
+      flags |= 4;
+    if (hasOpaqueFinal && this.global.txModifiable === undefined)
+      flags &= ~3;
+    return flags;
+  }
+  get txModifiable() {
+    return this.modifiable();
+  }
+  static fromRaw(raw, opts = {}) {
+    const parsed = RawTx.decode(raw);
+    const tx = new Transaction2({ ...opts, version: parsed.version, lockTime: parsed.lockTime });
+    for (const o of parsed.outputs)
+      tx.addOutput(o);
+    tx.outputs = parsed.outputs;
+    tx.inputs = parsed.inputs;
+    if (parsed.witnesses) {
+      for (let i = 0;i < parsed.witnesses.length; i++)
+        tx.inputs[i].finalScriptWitness = parsed.witnesses[i];
+    }
+    return tx;
+  }
+  static fromPSBT(psbt_, opts = {}) {
+    let parsed;
+    try {
+      parsed = RawPSBTV0.decode(psbt_);
+    } catch (e0) {
+      try {
+        parsed = RawPSBTV2.decode(psbt_);
+      } catch (e2) {
+        throw e0;
+      }
+    }
+    const PSBTVersion = parsed.global.version || 0;
+    if (PSBTVersion !== 0 && PSBTVersion !== 2)
+      throw new Error(`Wrong PSBT version=${PSBTVersion}`);
+    const unsigned = parsed.global.unsignedTx;
+    const version = PSBTVersion === 0 ? unsigned?.version : parsed.global.txVersion;
+    const lockTime = PSBTVersion === 0 ? unsigned?.lockTime : parsed.global.fallbackLocktime;
+    const tx = new Transaction2({ ...opts, version, lockTime, PSBTVersion });
+    const inputCount = PSBTVersion === 0 ? unsigned?.inputs.length : parsed.global.inputCount;
+    tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) => {
+      const input = {
+        ...parsed.global.unsignedTx?.inputs[j],
+        ...i
+      };
+      if (!i.finalScriptSig?.length)
+        delete input.finalScriptSig;
+      return validateInput(input, tx.opts.disableScriptCheck);
+    });
+    const outputCount = PSBTVersion === 0 ? unsigned?.outputs.length : parsed.global.outputCount;
+    const hasBip174InputMap = PSBTVersion === 0 && inputCount === 0 && Object.keys(parsed.outputs[0] || {}).length === 0 && (outputCount > 0 && parsed.outputs.length === outputCount + 1 || outputCount === 0 && parsed.outputs.length === 2 && Object.keys(parsed.outputs[1]).length === 0);
+    const outputStart = hasBip174InputMap ? 1 : 0;
+    tx.outputs = parsed.outputs.slice(outputStart, outputStart + outputCount).map((i, j) => ({
+      ...i,
+      ...parsed.global.unsignedTx?.outputs[j]
+    }));
+    const unknownMode = tx.opts.unknown;
+    const proprietaryMode = tx.opts.proprietary;
+    tx.global = cleanExtensions({ ...parsed.global, txVersion: version }, unknownMode, proprietaryMode);
+    tx.inputs = tx.inputs.map((input) => cleanExtensions(input, unknownMode, proprietaryMode));
+    tx.outputs = tx.outputs.map((output) => cleanExtensions(output, unknownMode, proprietaryMode));
+    if (tx.global.txModifiable !== undefined)
+      tx.global.txModifiable = cleanTxModifiable(tx.global.txModifiable, unknownMode);
+    resolvePSBTLocktime(tx.inputs, tx.global.fallbackLocktime ?? DEFAULT_LOCKTIME);
+    if (PSBTVersion === 0)
+      tx.global.fallbackLocktime = def(lockTime, DEFAULT_LOCKTIME);
+    return tx;
+  }
+  toPSBT(PSBTVersion = this.global.version || this.opts.PSBTVersion) {
+    if (PSBTVersion !== undefined)
+      anumber(PSBTVersion, "PSBTVersion");
+    if (PSBTVersion !== 0 && PSBTVersion !== 2)
+      throw new Error(`Wrong PSBT version=${PSBTVersion}`);
+    const inputs = this.inputs.map((i) => cleanExtensions(cleanPSBTFields(PSBTVersion, PSBTInput, validateInput(i, this.opts.disableScriptCheck)), this.opts.unknown, this.opts.proprietary));
+    for (const inp of inputs) {
+      if (inp.partialSig && !inp.partialSig.length)
+        delete inp.partialSig;
+      if (inp.finalScriptSig && !inp.finalScriptSig.length)
+        delete inp.finalScriptSig;
+      if (inp.finalScriptWitness && !inp.finalScriptWitness.length)
+        delete inp.finalScriptWitness;
+    }
+    const outputs = this.outputs.map((i) => cleanExtensions(cleanPSBTFields(PSBTVersion, PSBTOutput, i), this.opts.unknown, this.opts.proprietary));
+    const global = cleanExtensions({ ...this.global }, this.opts.unknown, this.opts.proprietary);
+    if (global.txModifiable !== undefined)
+      global.txModifiable = cleanTxModifiable(global.txModifiable, this.opts.unknown);
+    if (PSBTVersion === 0) {
+      global.unsignedTx = RawOldTx.decode(RawOldTx.encode({
+        version: this.version,
+        lockTime: this.lockTime,
+        inputs: this.inputs.map((i) => inputBeforeSign(i)).map((i) => ({
+          ...i,
+          finalScriptSig: EMPTY
+        })),
+        outputs: this.outputs.map((o) => outputBeforeSign(o))
+      }));
+      delete global.fallbackLocktime;
+      delete global.txVersion;
+      delete global.inputCount;
+      delete global.outputCount;
+      delete global.version;
+      delete global.txModifiable;
+    } else {
+      delete global.unsignedTx;
+      global.version = PSBTVersion;
+      global.txVersion = this.version;
+      global.inputCount = this.inputs.length;
+      global.outputCount = this.outputs.length;
+      if (!this.isPSBTv2() || global.txModifiable === undefined && this.opts.allowMissingTxModifiable)
+        global.txModifiable = this.txModifiable;
+    }
+    if (this.opts.bip174jsCompat && PSBTVersion === 0 && !outputs.length)
+      outputs.push({});
+    const raw = { global, inputs, outputs };
+    return PSBTVersion === 0 ? RawPSBTV0.encode(raw) : RawPSBTV2.encode(raw);
+  }
+  get lockTime() {
+    return resolvePSBTLocktime(this.inputs, this.global.fallbackLocktime ?? DEFAULT_LOCKTIME);
+  }
+  get version() {
+    if (this.global.txVersion === undefined)
+      throw new Error("No global.txVersion");
+    return this.global.txVersion;
+  }
+  inputStatus(idx) {
+    this.checkInputIdx(idx);
+    const input = this.inputs[idx];
+    if (input.finalScriptSig && input.finalScriptSig.length)
+      return "finalized";
+    if (input.finalScriptWitness && input.finalScriptWitness.length)
+      return "finalized";
+    if (input.tapKeySig)
+      return "signed";
+    if (input.tapScriptSig && input.tapScriptSig.length)
+      return "signed";
+    if (input.partialSig && input.partialSig.length)
+      return "signed";
+    return "unsigned";
+  }
+  cleanFinalInput(input) {
+    cleanFinalInput(input, this.opts.unknown, this.opts.proprietary);
+    if (this.global.txModifiable !== undefined)
+      this.global.txModifiable = cleanTxModifiable(this.global.txModifiable, this.opts.unknown);
+  }
+  inputSighash(idx) {
+    this.checkInputIdx(idx);
+    const inputSighash = this.inputs[idx].sighashType;
+    const sighash = inputSighash === undefined ? SignatureHash.DEFAULT : inputSighash;
+    return sighashScope(sighash);
+  }
+  signatures() {
+    const res = [];
+    for (let idx = 0;idx < this.inputs.length; idx++) {
+      const actual = inputSignatures(this.inputs[idx]);
+      for (const signature of actual)
+        res.push({ idx, ...signature });
+      if (actual.length || this.inputStatus(idx) !== "finalized")
+        continue;
+      let taproot = true;
+      try {
+        taproot = _WitnessOutScript.decode(getPrevOut(this.inputs[idx]).script).type === "tr";
+      } catch {}
+      const declared = this.inputs[idx].sighashType;
+      const sighash = declared === undefined ? SignatureHash.DEFAULT : declared;
+      res.push({ idx, sighash, taproot, scriptPath: taproot });
+    }
+    return res;
+  }
+  signedInputKeys(idx, signatures = this.signatures()) {
+    const res = new Set;
+    const add = (keys) => {
+      for (const key of keys)
+        res.add(key);
+    };
+    for (const signature of signatures) {
+      const { isAny, isNone, isSingle } = unpackSighash(signature.sighash);
+      if (signature.idx === idx) {
+        add(inputSignedKeys.self);
+        if (signature.taproot) {
+          if (signature.scriptPath)
+            add(inputSignedKeys.tapscript);
+        } else
+          add(inputSignedKeys.ecdsa);
+      } else if (!isAny) {
+        add(inputSignedKeys.cross);
+        if (signature.taproot || !isNone && !isSingle)
+          res.add("sequence");
+        if (signature.taproot)
+          add(inputSignedKeys.prevout);
+      }
+    }
+    return [...res];
+  }
+  signStatus(signatures = this.signatures()) {
+    let addInput = true, addOutput = true;
+    let inputs = [], outputs = [];
+    for (const { idx, sighash } of signatures) {
+      const { sigInputs, sigOutputs } = sighashScope(sighash);
+      if (sigInputs === SignatureHash.ANYONECANPAY) {
+        if (!inputs.includes(idx))
+          inputs.push(idx);
+      } else
+        addInput = false;
+      if (sigOutputs === SignatureHash.ALL)
+        addOutput = false;
+      else if (sigOutputs === SignatureHash.SINGLE) {
+        if (!outputs.includes(idx))
+          outputs.push(idx);
+      } else if (sigOutputs === SignatureHash.NONE) {} else
+        throw new Error(`Wrong signature hash output type: ${sigOutputs}`);
+    }
+    return { addInput, addOutput, inputs, outputs };
+  }
+  get isFinal() {
+    for (let idx = 0;idx < this.inputs.length; idx++)
+      if (this.inputStatus(idx) !== "finalized")
+        return false;
+    return true;
+  }
+  get hasWitnesses() {
+    for (const i of this.inputs)
+      if (i.finalScriptWitness && i.finalScriptWitness.length)
+        return true;
+    return false;
+  }
+  get weight() {
+    if (!this.isFinal)
+      throw new Error("Transaction is not finalized");
+    const varLen = (dataLen) => CompactSizeLen.encode(dataLen).length + dataLen;
+    const hasWitnesses = this.hasWitnesses;
+    let out = 32;
+    const outputs = this.outputs.map(outputBeforeSign);
+    out += 4 * CompactSizeLen.encode(this.outputs.length).length;
+    for (const o of outputs)
+      out += 32 + 4 * varLen(o.script.length);
+    if (hasWitnesses)
+      out += 2;
+    out += 4 * CompactSizeLen.encode(this.inputs.length).length;
+    for (const i of this.inputs) {
+      out += 160 + 4 * varLen((i.finalScriptSig || EMPTY).length);
+      if (hasWitnesses) {
+        const witness = i.finalScriptWitness || [];
+        out += CompactSizeLen.encode(witness.length).length;
+        for (const w of witness)
+          out += varLen(w.length);
+      }
+    }
+    return out;
+  }
+  get vsize() {
+    return toVsize(this.weight);
+  }
+  toBytes(withScriptSig = false, withWitness = false) {
+    return RawTx.encode({
+      version: this.version,
+      lockTime: this.lockTime,
+      inputs: this.inputs.map(inputBeforeSign).map((i) => ({
+        ...i,
+        finalScriptSig: withScriptSig && i.finalScriptSig || EMPTY
+      })),
+      outputs: this.outputs.map(outputBeforeSign),
+      witnesses: this.inputs.map((i) => i.finalScriptWitness || []),
+      segwitFlag: withWitness && this.hasWitnesses
+    });
+  }
+  get unsignedTx() {
+    return this.toBytes(false, false);
+  }
+  get hex() {
+    return hex.encode(this.toBytes(true, this.hasWitnesses));
+  }
+  get hash() {
+    return hex.encode(sha256x2(this.toBytes(true)));
+  }
+  get id() {
+    return hex.encode(sha256x2(this.toBytes(true)).reverse());
+  }
+  checkInputIdx(idx) {
+    anumber(idx, "idx");
+    if (idx >= this.inputs.length)
+      throw new Error(`Wrong input index=${idx}`);
+  }
+  validatePrevoutsForSigning() {
+    if (!this.opts.strictPrevoutValidation)
+      return;
+    for (let i = 0;i < this.inputs.length; i++) {
+      const input = this.inputs[i];
+      if (!input.nonWitnessUtxo) {
+        throw new Error(`Transaction/sign: strictPrevoutValidation requires nonWitnessUtxo for input=${i}`);
+      }
+      if (input.txid === undefined || input.index === undefined) {
+        throw new Error(`Transaction/sign: strictPrevoutValidation requires an outpoint for input=${i}`);
+      }
+      validateInput(input, this.opts.disableScriptCheck);
+    }
+  }
+  getInput(idx) {
+    this.checkInputIdx(idx);
+    return cloneDeep(this.inputs[idx]);
+  }
+  get inputsLength() {
+    return this.inputs.length;
+  }
+  addInput(input, _ignoreSignStatus = false) {
+    validateObject2(input, {}, {}, "input");
+    cleanExtensions(input, this.opts.unknown, this.opts.proprietary, true);
+    this.requireTxModifiable(1, "inputs");
+    const signatures = _ignoreSignStatus ? undefined : this.signatures();
+    const status = signatures && this.signStatus(signatures);
+    if (status && !status.addInput)
+      throw new Error("Tx has signed inputs, cannot add new one");
+    const normalized = cloneDeep(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck, this.opts.unknown, this.opts.proprietary));
+    const nextLockTime = resolvePSBTLocktime([...this.inputs, normalized], this.global.fallbackLocktime ?? DEFAULT_LOCKTIME);
+    if (signatures?.length && nextLockTime !== this.lockTime)
+      throw new Error("Tx has signed inputs, cannot change lockTime");
+    this.inputs.push(normalized);
+    return this.inputs.length - 1;
+  }
+  updateInput(idx, input, _ignoreSignStatus = false) {
+    this.checkInputIdx(idx);
+    cleanExtensions(input, this.opts.unknown, this.opts.proprietary, true);
+    let allowedFields;
+    const signatures = _ignoreSignStatus ? undefined : this.signatures();
+    if (signatures?.length) {
+      if (this.inputStatus(idx) === "finalized") {
+        allowedFields = PSBTInputSignatureKeys.filter((key) => this.inputs[idx][key] !== undefined);
+      } else {
+        const signed = new Set(this.signedInputKeys(idx, signatures));
+        if (signed.size)
+          allowedFields = Object.keys(PSBTInput).filter((key) => !signed.has(key));
+      }
+    }
+    const normalized = cloneDeep(normalizeInput(input, this.inputs[idx], allowedFields, this.opts.disableScriptCheck, this.opts.unknown, this.opts.proprietary));
+    const inputs = this.inputs.slice();
+    inputs[idx] = normalized;
+    const nextLockTime = resolvePSBTLocktime(inputs, this.global.fallbackLocktime ?? DEFAULT_LOCKTIME);
+    if (signatures?.length && nextLockTime !== this.lockTime)
+      throw new Error("Tx has signed inputs, cannot change lockTime");
+    const current = this.inputs[idx];
+    const transactionChanged = current.index !== normalized.index || def(current.sequence, DEFAULT_SEQUENCE) !== def(normalized.sequence, DEFAULT_SEQUENCE) || (current.txid === undefined ? normalized.txid !== undefined : normalized.txid === undefined || !equalBytes2(current.txid, normalized.txid)) || nextLockTime !== this.lockTime;
+    if (transactionChanged)
+      this.requireTxModifiable(1, "inputs");
+    this.inputs[idx] = normalized;
+  }
+  checkOutputIdx(idx) {
+    anumber(idx, "idx");
+    if (idx >= this.outputs.length)
+      throw new Error(`Wrong output index=${idx}`);
+  }
+  getOutput(idx) {
+    this.checkOutputIdx(idx);
+    return cloneDeep(this.outputs[idx]);
+  }
+  getOutputAddress(idx, network = NETWORK2) {
+    const out = this.getOutput(idx);
+    if (!out.script)
+      return;
+    return Address2(network).encode(_WitnessOutScript.decode(out.script));
+  }
+  get outputsLength() {
+    return this.outputs.length;
+  }
+  normalizeOutput(o, cur, allowedFields) {
+    validateObject2(o, {}, {}, "o");
+    let { amount, script } = o;
+    if (amount === undefined)
+      amount = cur?.amount;
+    amount = abigint(amount, "o.amount");
+    if (typeof script === "string")
+      script = hex.decode(script);
+    if (script === undefined)
+      script = cur?.script;
+    let res = { ...cur, ...o, amount, script };
+    if (res.amount === undefined)
+      delete res.amount;
+    res = mergeKeyMap(PSBTOutput, res, cur, allowedFields, this.opts.unknown, this.opts.proprietary);
+    PSBTOutputCoder.encode(res);
+    if (res.script && !this.opts.allowUnknownOutputs && _WitnessOutScript.decode(res.script).type === "unknown") {
+      throw new Error("Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure");
+    }
+    if (!this.opts.disableScriptCheck)
+      checkScript(res.script, res.redeemScript, res.witnessScript);
+    return res;
+  }
+  addOutput(o, _ignoreSignStatus = false) {
+    cleanExtensions(o, this.opts.unknown, this.opts.proprietary, true);
+    this.requireTxModifiable(2, "outputs");
+    const status = _ignoreSignStatus ? undefined : this.signStatus();
+    if (status && (!status.addOutput || status.outputs.includes(this.outputs.length)))
+      throw new Error("Tx has signed outputs, cannot add new one");
+    this.outputs.push(cloneDeep(this.normalizeOutput(o)));
+    return this.outputs.length - 1;
+  }
+  updateOutput(idx, output, _ignoreSignStatus = false) {
+    this.checkOutputIdx(idx);
+    cleanExtensions(output, this.opts.unknown, this.opts.proprietary, true);
+    let allowedFields = undefined;
+    if (!_ignoreSignStatus) {
+      const status = this.signStatus();
+      if (!status.addOutput || status.outputs.includes(idx))
+        allowedFields = PSBTOutputUnsignedKeys;
+    }
+    const current = this.outputs[idx];
+    const normalized = cloneDeep(this.normalizeOutput(output, current, allowedFields));
+    const transactionChanged = current.amount !== normalized.amount || (current.script === undefined ? normalized.script !== undefined : normalized.script === undefined || !equalBytes2(current.script, normalized.script));
+    if (transactionChanged)
+      this.requireTxModifiable(2, "outputs");
+    this.outputs[idx] = normalized;
+  }
+  addOutputAddress(address, amount, network = NETWORK2) {
+    return this.addOutput({
+      script: OutScript2.encode(Address2(network).decode(address)),
+      amount
+    });
+  }
+  get fee() {
+    let res = _0n5;
+    for (const i of this.inputs) {
+      const prevOut = getPrevOut(i);
+      if (!prevOut)
+        throw new Error("Empty input amount");
+      res += prevOut.amount;
+    }
+    const outputs = this.outputs.map(outputBeforeSign);
+    for (const o of outputs)
+      res -= o.amount;
+    return res;
+  }
+  preimageLegacy(idx, prevOutScript, hashType) {
+    const { isAny, isNone, isSingle } = unpackSighash(hashType);
+    if (idx < 0 || !Number.isSafeInteger(idx))
+      throw new Error(`Invalid input idx=${idx}`);
+    if (isSingle && idx >= this.outputs.length || idx >= this.inputs.length)
+      return U256LE.encode(_1n4);
+    prevOutScript = stripCodeSeparator(prevOutScript);
+    let inputs = this.inputs.map(inputBeforeSign).map((input, inputIdx) => ({
+      ...input,
+      finalScriptSig: inputIdx === idx ? prevOutScript : EMPTY
+    }));
+    if (isAny)
+      inputs = [inputs[idx]];
+    else if (isNone || isSingle) {
+      inputs = inputs.map((input, inputIdx) => ({
+        ...input,
+        sequence: inputIdx === idx ? input.sequence : 0
+      }));
+    }
+    let outputs = this.outputs.map(outputBeforeSign);
+    if (isNone)
+      outputs = [];
+    else if (isSingle) {
+      outputs = outputs.slice(0, idx).fill(EMPTY_OUTPUT).concat([outputs[idx]]);
+    }
+    const tmpTx = RawTx.encode({
+      lockTime: this.lockTime,
+      version: this.version,
+      segwitFlag: false,
+      inputs,
+      outputs
+    });
+    return sha256x2(tmpTx, I32LE.encode(hashType));
+  }
+  preimageWitnessV0(idx, prevOutScript, hashType, amount) {
+    anumber(idx, "idx");
+    if (idx >= this.inputs.length)
+      throw new Error(`Invalid input idx=${idx}`);
+    const { isAny, isNone, isSingle } = unpackSighash(hashType);
+    let inputHash = EMPTY32;
+    let sequenceHash = EMPTY32;
+    let outputHash = EMPTY32;
+    const inputs = this.inputs.map(inputBeforeSign);
+    const outputs = this.outputs.map(outputBeforeSign);
+    if (!isAny)
+      inputHash = sha256x2(...inputs.map(TxHashIdx.encode));
+    if (!isAny && !isSingle && !isNone)
+      sequenceHash = sha256x2(...inputs.map((i) => U32LE.encode(i.sequence)));
+    if (!isSingle && !isNone) {
+      outputHash = sha256x2(...outputs.map(RawOutput.encode));
+    } else if (isSingle && idx < outputs.length)
+      outputHash = sha256x2(RawOutput.encode(outputs[idx]));
+    const input = inputs[idx];
+    return sha256x2(I32LE.encode(this.version), inputHash, sequenceHash, createBytes(32, true).encode(input.txid), U32LE.encode(input.index), VarBytes.encode(prevOutScript), U64LE.encode(amount), U32LE.encode(input.sequence), outputHash, U32LE.encode(this.lockTime), U32LE.encode(hashType));
+  }
+  preimageWitnessV1(idx, prevOutScript, hashType, amount, codeSeparator = -1, leafScript, leafVer = 192, annex) {
+    anumber(idx, "idx");
+    if (idx >= this.inputs.length)
+      throw new Error(`Invalid input idx=${idx}`);
+    aarray(amount, "amount");
+    aarray(prevOutScript, "prevOutScript");
+    if (this.inputs.length !== amount.length)
+      throw new Error(`Invalid amounts array=${amount}`);
+    if (this.inputs.length !== prevOutScript.length)
+      throw new Error(`Invalid prevOutScript array=${prevOutScript}`);
+    const out = [
+      U8.encode(0),
+      U8.encode(hashType),
+      I32LE.encode(this.version),
+      U32LE.encode(this.lockTime)
+    ];
+    const outType = hashType === SignatureHash.DEFAULT ? SignatureHash.ALL : hashType & 3;
+    const inType = hashType & SignatureHash.ANYONECANPAY;
+    const inputs = this.inputs.map(inputBeforeSign);
+    const outputs = this.outputs.map(outputBeforeSign);
+    if (outType === SignatureHash.SINGLE && idx >= outputs.length) {
+      throw new Error(`Input with sighash SINGLE, but there is no output with corresponding index=${idx}`);
+    }
+    if (inType !== SignatureHash.ANYONECANPAY) {
+      out.push(...[
+        inputs.map(TxHashIdx.encode),
+        amount.map(U64LE.encode),
+        prevOutScript.map(VarBytes.encode),
+        inputs.map((i) => U32LE.encode(i.sequence))
+      ].map((i) => sha2562(concatBytes3(...i))));
+    }
+    if (outType === SignatureHash.ALL) {
+      out.push(sha2562(concatBytes3(...outputs.map(RawOutput.encode))));
+    }
+    const spendType = (annex ? 1 : 0) | (leafScript ? 2 : 0);
+    out.push(new Uint8Array([spendType]));
+    if (inType === SignatureHash.ANYONECANPAY) {
+      const inp = inputs[idx];
+      out.push(TxHashIdx.encode(inp), U64LE.encode(amount[idx]), VarBytes.encode(prevOutScript[idx]), U32LE.encode(inp.sequence));
+    } else
+      out.push(U32LE.encode(idx));
+    if (spendType & 1)
+      out.push(sha2562(VarBytes.encode(annex || EMPTY)));
+    if (outType === SignatureHash.SINGLE)
+      out.push(sha2562(RawOutput.encode(outputs[idx])));
+    if (leafScript)
+      out.push(tapLeafHash(leafScript, leafVer), U8.encode(0), I32LE.encode(codeSeparator));
+    return tagSchnorr("TapSighash", ...out);
+  }
+  signIdx(privateKey, idx, allowedSighash, _auxRand) {
+    if (!isBytes2(privateKey)) {
+      if (!privateKey || typeof privateKey !== "object" || typeof privateKey.deriveChild !== "function")
+        throw new TypeError('"privateKey" expected Uint8Array or HDKey, got type=' + typeof privateKey);
+    }
+    this.checkInputIdx(idx);
+    this.validatePrevoutsForSigning();
+    const input = validateInput(this.inputs[idx], this.opts.disableScriptCheck);
+    const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
+    const canSign = (privateKey) => {
+      if (inputType.txType === "taproot") {
+        const pubKey = pubSchnorr(privateKey);
+        if (input.tapInternalKey && equalBytes2(pubKey, input.tapInternalKey))
+          return true;
+        if (!input.tapLeafScript)
+          return false;
+        for (const [_, leaf] of input.tapLeafScript) {
+          for (const op of Script2.decode(leaf.subarray(0, -1))) {
+            if (isBytes2(op) && equalBytes2(op, pubKey))
+              return true;
+          }
+        }
+        return false;
+      }
+      const pubKey = pubECDSA(privateKey);
+      const pubKeyHash = hash160(pubKey);
+      for (const op of Script2.decode(inputType.lastScript)) {
+        if (isBytes2(op) && (equalBytes2(op, pubKey) || equalBytes2(op, pubKeyHash)))
+          return true;
+      }
+      return false;
+    };
+    if (!isBytes2(privateKey)) {
+      const root = privateKey;
+      const deriveSigners = (label, rows, pubKey) => {
+        if (!rows || !rows.length)
+          throw new Error(`${label}: empty`);
+        const signers = rows.filter((row) => row.fingerprint == root.fingerprint).map((row) => {
+          let s = root;
+          for (const i of row.path)
+            s = s.deriveChild(i);
+          if (!equalBytes2(pubKey(s), row.pubKey))
+            throw new Error(`${label}: wrong pubKey`);
+          if (!s.privateKey)
+            throw new Error(`${label}: no privateKey`);
+          return s;
+        });
+        if (!signers.length)
+          throw new Error(`${label}: no items with fingerprint=${root.fingerprint}`);
+        return signers;
+      };
+      const signers = inputType.txType === "taproot" ? deriveSigners("tapBip32Derivation", input.tapBip32Derivation?.map(([pubKey, { der }]) => ({
+        pubKey,
+        fingerprint: der.fingerprint,
+        path: der.path
+      })), (s) => s.publicKey.slice(1)) : deriveSigners("bip32Derivation", input.bip32Derivation?.map(([pubKey, der]) => ({
+        pubKey,
+        fingerprint: der.fingerprint,
+        path: der.path
+      })), (s) => s.publicKey);
+      let signed = false;
+      for (const s of signers) {
+        if (!canSign(s.privateKey))
+          continue;
+        if (this.signIdx(s.privateKey, idx, allowedSighash, _auxRand))
+          signed = true;
+      }
+      if (signed)
+        return true;
+      if (inputType.txType === "taproot")
+        throw new Error("No taproot scripts signed");
+      throw new Error(`Input script doesn't have pubKey: ${inputType.lastScript}`);
+    }
+    if (!allowedSighash)
+      allowedSighash = [inputType.defaultSighash];
+    else
+      allowedSighash.forEach(validateSigHash);
+    const sighash = inputType.sighash;
+    if (!allowedSighash.includes(sighash)) {
+      throw new Error(`Input with not allowed sigHash=${sighash}. Allowed: ${allowedSighash.join(", ")}`);
+    }
+    const { sigOutputs } = this.inputSighash(idx);
+    if (sigOutputs === SignatureHash.SINGLE && idx >= this.outputs.length) {
+      throw new Error(`Input with sighash SINGLE, but there is no output with corresponding index=${idx}`);
+    }
+    const prevOut = getPrevOut(input);
+    if (inputType.txType === "taproot") {
+      const prevOuts = this.inputs.map(getPrevOut);
+      const prevOutScript = prevOuts.map((i) => i.script);
+      const amount = prevOuts.map((i) => i.amount);
+      let signed = false;
+      let schnorrPub = pubSchnorr(privateKey);
+      let merkleRoot = input.tapMerkleRoot || EMPTY;
+      if (input.tapInternalKey) {
+        const { pubKey, privKey } = getTaprootKeys(privateKey, schnorrPub, input.tapInternalKey, merkleRoot);
+        const [taprootPubKey, _] = taprootTweakPubkey(input.tapInternalKey, merkleRoot);
+        if (equalBytes2(taprootPubKey, pubKey)) {
+          const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);
+          const sig = concatBytes3(signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : EMPTY);
+          this.updateInput(idx, { tapKeySig: sig }, true);
+          signed = true;
+        }
+      }
+      if (input.tapLeafScript) {
+        input.tapScriptSig = input.tapScriptSig || [];
+        for (const [_, _script] of input.tapLeafScript) {
+          const script = _script.subarray(0, -1);
+          const scriptDecoded = Script2.decode(script);
+          const ver = _script[_script.length - 1];
+          const hash = tapLeafHash(script, ver);
+          const pos = scriptDecoded.findIndex((i) => isBytes2(i) && equalBytes2(i, schnorrPub));
+          if (pos === -1)
+            continue;
+          const msg = this.preimageWitnessV1(idx, prevOutScript, sighash, amount, undefined, script, ver);
+          const sig = concatBytes3(signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : EMPTY);
+          this.updateInput(idx, { tapScriptSig: [[{ pubKey: schnorrPub, leafHash: hash }, sig]] }, true);
+          signed = true;
+        }
+      }
+      if (!signed)
+        throw new Error("No taproot scripts signed");
+      return true;
+    } else {
+      const pubKey = pubECDSA(privateKey);
+      let hasPubkey = false;
+      const pubKeyHash = hash160(pubKey);
+      for (const i of Script2.decode(inputType.lastScript)) {
+        if (isBytes2(i) && (equalBytes2(i, pubKey) || equalBytes2(i, pubKeyHash)))
+          hasPubkey = true;
+      }
+      if (!hasPubkey)
+        throw new Error(`Input script doesn't have pubKey: ${inputType.lastScript}`);
+      let hash;
+      if (inputType.txType === "legacy") {
+        hash = this.preimageLegacy(idx, inputType.lastScript, sighash);
+      } else if (inputType.txType === "segwit") {
+        let script = inputType.lastScript;
+        if (inputType.last.type === "wpkh")
+          script = OutScript2.encode({ type: "pkh", hash: inputType.last.hash });
+        hash = this.preimageWitnessV0(idx, script, sighash, prevOut.amount);
+      } else
+        throw new Error(`Transaction/sign: unknown tx type: ${inputType.txType}`);
+      const sig = signECDSA(hash, privateKey, this.opts.lowR);
+      this.updateInput(idx, {
+        partialSig: [[pubKey, concatBytes3(sig, new Uint8Array([sighash]))]]
+      }, true);
+    }
+    return true;
+  }
+  sign(privateKey, allowedSighash, _auxRand) {
+    this.validatePrevoutsForSigning();
+    let num = 0;
+    for (let i = 0;i < this.inputs.length; i++) {
+      try {
+        if (this.signIdx(privateKey, i, allowedSighash, _auxRand))
+          num++;
+      } catch (e) {}
+    }
+    if (!num)
+      throw new Error("No inputs signed");
+    return num;
+  }
+  finalizeIdx(idx) {
+    this.checkInputIdx(idx);
+    if (this.fee < _0n5)
+      throw new Error("Outputs spends more than inputs amount");
+    const input = this.inputs[idx];
+    cleanExtensions(input, this.opts.unknown, this.opts.proprietary);
+    cleanTxModifiable(this.global.txModifiable, this.opts.unknown);
+    const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
+    if (inputType.txType === "taproot") {
+      if (input.tapKeySig)
+        input.finalScriptWitness = [input.tapKeySig];
+      else if (input.tapLeafScript && input.tapScriptSig) {
+        const leafs = input.tapLeafScript.slice().sort((a, b) => TaprootControlBlock2.encode(a[0]).length - TaprootControlBlock2.encode(b[0]).length);
+        let smallest;
+        let smallestSize = Number.POSITIVE_INFINITY;
+        let unsupported = false;
+        for (const [cb, _script] of leafs) {
+          const script = _script.slice(0, -1);
+          const ver = _script[_script.length - 1];
+          const outScript = OutScript2.decode(script);
+          const hash = tapLeafHash(script, ver);
+          const scriptSig = input.tapScriptSig.filter((i) => equalBytes2(i[0].leafHash, hash));
+          let signatures = [];
+          let witness;
+          if (outScript.type === "tr_ms") {
+            const m = outScript.m;
+            const pubkeys = outScript.pubkeys;
+            let added = 0;
+            for (const pub of pubkeys) {
+              const sigIdx = scriptSig.findIndex((i) => equalBytes2(i[0].pubKey, pub));
+              if (added === m || sigIdx === -1) {
+                signatures.push(EMPTY);
+                continue;
+              }
+              signatures.push(scriptSig[sigIdx][1]);
+              added++;
+            }
+            if (added !== m)
+              continue;
+          } else if (outScript.type === "tr_ns") {
+            for (const pub of outScript.pubkeys) {
+              const sigIdx = scriptSig.findIndex((i) => equalBytes2(i[0].pubKey, pub));
+              if (sigIdx === -1)
+                continue;
+              signatures.push(scriptSig[sigIdx][1]);
+            }
+            if (signatures.length !== outScript.pubkeys.length)
+              continue;
+          } else if (outScript.type === "unknown" && this.opts.allowUnknownInputs) {
+            const scriptDecoded = Script2.decode(script);
+            signatures = scriptSig.map(([{ pubKey }, signature]) => {
+              const pos = scriptDecoded.findIndex((i) => isBytes2(i) && equalBytes2(i, pubKey));
+              if (pos === -1)
+                throw new Error("finalize/taproot: cannot find position of pubkey in script");
+              return { signature, pos };
+            }).sort((a, b) => a.pos - b.pos).map((i) => i.signature);
+            if (!signatures.length)
+              continue;
+          } else {
+            const custom = this.opts.customScripts;
+            let recognized = false;
+            if (custom) {
+              for (const c of custom) {
+                if (!c.finalizeTaproot)
+                  continue;
+                const scriptDecoded = Script2.decode(script);
+                const csEncoded = c.encode(scriptDecoded);
+                if (csEncoded === undefined)
+                  continue;
+                recognized = true;
+                const finalized = c.finalizeTaproot(script, csEncoded, scriptSig);
+                if (!finalized)
+                  continue;
+                witness = finalized.concat(TaprootControlBlock2.encode(cb));
+                break;
+              }
+            }
+            if (!witness && !recognized && scriptSig.length)
+              unsupported = true;
+            if (!witness)
+              continue;
+          }
+          witness ||= signatures.reverse().concat([script, TaprootControlBlock2.encode(cb)]);
+          const size = RawWitness.encode(witness).length;
+          if (size >= smallestSize)
+            continue;
+          smallest = witness;
+          smallestSize = size;
+        }
+        if (!smallest && unsupported)
+          throw new Error("Finalize: Unknown tapLeafScript");
+        if (!smallest)
+          throw new Error("finalize/taproot: empty witness");
+        input.finalScriptWitness = smallest;
+      } else
+        throw new Error("finalize/taproot: unknown input");
+      delete input.finalScriptSig;
+      this.cleanFinalInput(input);
+      return;
+    }
+    if (!input.partialSig || !input.partialSig.length)
+      throw new Error("Not enough partial sign");
+    let inputScript = EMPTY;
+    let witness = [];
+    if (inputType.last.type === "ms") {
+      const m = inputType.last.m;
+      const pubkeys = inputType.last.pubkeys;
+      let signatures = [];
+      for (const pub of pubkeys) {
+        const sign = input.partialSig.find((s) => equalBytes2(pub, s[0]));
+        if (!sign)
+          continue;
+        signatures.push(sign[1]);
+      }
+      signatures = signatures.slice(0, m);
+      if (signatures.length !== m) {
+        throw new Error(`Multisig: wrong signatures count, m=${m} n=${pubkeys.length} signatures=${signatures.length}`);
+      }
+      inputScript = Script2.encode([0, ...signatures]);
+    } else if (inputType.last.type === "pk") {
+      inputScript = Script2.encode([input.partialSig[0][1]]);
+    } else if (inputType.last.type === "pkh") {
+      inputScript = Script2.encode([input.partialSig[0][1], input.partialSig[0][0]]);
+    } else if (inputType.last.type === "wpkh") {
+      inputScript = EMPTY;
+      witness = [input.partialSig[0][1], input.partialSig[0][0]];
+    } else if (inputType.last.type === "unknown" && !this.opts.allowUnknownInputs)
+      throw new Error("Unknown inputs not allowed");
+    let finalScriptSig, finalScriptWitness;
+    if (inputType.type.includes("wsh-")) {
+      if (inputScript.length && inputType.lastScript.length) {
+        witness = Script2.decode(inputScript).map((i) => {
+          if (i === 0)
+            return EMPTY;
+          if (isBytes2(i))
+            return i;
+          throw new Error(`Wrong witness op=${i}`);
+        });
+      }
+      witness = witness.concat(inputType.lastScript);
+    }
+    if (inputType.txType === "segwit")
+      finalScriptWitness = witness;
+    if (inputType.type.startsWith("sh-wsh-")) {
+      finalScriptSig = Script2.encode([Script2.encode([0, sha2562(inputType.lastScript)])]);
+    } else if (inputType.type.startsWith("sh-")) {
+      finalScriptSig = Script2.encode([...Script2.decode(inputScript), inputType.lastScript]);
+    } else if (inputType.type.startsWith("wsh-")) {} else if (inputType.txType !== "segwit")
+      finalScriptSig = inputScript;
+    if (!finalScriptSig && !finalScriptWitness)
+      throw new Error("Unknown error finalizing input");
+    if (finalScriptSig)
+      input.finalScriptSig = finalScriptSig;
+    if (finalScriptWitness)
+      input.finalScriptWitness = finalScriptWitness;
+    this.cleanFinalInput(input);
+  }
+  finalize() {
+    for (let i = 0;i < this.inputs.length; i++)
+      this.finalizeIdx(i);
+  }
+  extract() {
+    if (!this.isFinal)
+      throw new Error("Transaction has unfinalized inputs");
+    if (!this.outputs.length)
+      throw new Error("Transaction has no outputs");
+    if (this.fee < _0n5)
+      throw new Error("Outputs spends more than inputs amount");
+    return this.toBytes(true, true);
+  }
+  combine(other) {
+    if (!(other instanceof Transaction2))
+      throw new TypeError('"other" expected Transaction, got type=' + typeof other);
+    const opts = this.opts;
+    const PSBTVersion = Math.max(this.opts.PSBTVersion || 0, other.opts.PSBTVersion || 0);
+    if (this.opts.version !== other.opts.version)
+      throw new Error(`Transaction/combine: different version this=${this.opts.version} ` + `other=${other.opts.version}`);
+    const thisV2 = this.isPSBTv2();
+    const otherV2 = other.isPSBTv2();
+    if (!thisV2 || !otherV2) {
+      const thisLockTime = this.lockTime;
+      const otherLockTime = other.lockTime;
+      if (thisLockTime !== otherLockTime)
+        throw new Error(`Transaction/combine: different lockTime this=${thisLockTime} other=${otherLockTime}`);
+    }
+    for (const k of ["inputs", "outputs"]) {
+      if (this[k].length !== other[k].length) {
+        throw new Error(`Transaction/combine: different ${k} length this=${this[k].length} other=${other[k].length}`);
+      }
+    }
+    const unsignedTx = this.unsignedTx;
+    if (!equalBytes2(unsignedTx, other.unsignedTx))
+      throw new Error(`Transaction/combine: different unsigned tx`);
+    let txModifiable;
+    if (thisV2 && otherV2) {
+      const policy = (tx) => {
+        if (tx.global.txModifiable !== undefined)
+          return cleanTxModifiable(tx.global.txModifiable, opts.unknown);
+        return opts.allowMissingTxModifiable ? tx.modifiable(true, opts.unknown) : 0;
+      };
+      const a = policy(this);
+      const b = policy(other);
+      if ((a & ~7) !== (b & ~7))
+        throw new Error("Transaction/combine: conflicting unknown txModifiable flags");
+      txModifiable = a & ~7 | a & b & 3 | (a | b) & 4;
+      if (txModifiable === 0 && this.global.txModifiable === undefined && other.global.txModifiable === undefined && !opts.allowMissingTxModifiable)
+        txModifiable = undefined;
+    } else if (thisV2)
+      txModifiable = this.modifiable(opts.allowMissingTxModifiable, opts.unknown);
+    else if (otherV2)
+      txModifiable = other.modifiable(opts.allowMissingTxModifiable, opts.unknown);
+    const thisGlobal = { ...this.global };
+    const otherGlobal = { ...other.global };
+    if (thisV2 !== otherV2) {
+      if (!thisV2)
+        delete thisGlobal.fallbackLocktime;
+      if (!otherV2)
+        delete otherGlobal.fallbackLocktime;
+      if (!thisV2)
+        delete thisGlobal.version;
+      if (!otherV2)
+        delete otherGlobal.version;
+    }
+    const fallbackLocktime = thisGlobal.fallbackLocktime !== undefined ? thisGlobal.fallbackLocktime : otherGlobal.fallbackLocktime;
+    delete thisGlobal.txModifiable;
+    delete otherGlobal.txModifiable;
+    delete thisGlobal.fallbackLocktime;
+    delete otherGlobal.fallbackLocktime;
+    const global = combineKeyMap(PSBTGlobal, thisGlobal, otherGlobal, opts.unknown, opts.proprietary);
+    if (fallbackLocktime !== undefined)
+      global.fallbackLocktime = fallbackLocktime;
+    if (PSBTVersion)
+      global.version = PSBTVersion;
+    if (txModifiable === undefined)
+      delete global.txModifiable;
+    else
+      global.txModifiable = txModifiable;
+    let hasOpaqueFinalizedV0 = false;
+    const inputs = this.inputs.map((current, i) => {
+      const currentFinal = this.inputStatus(i) === "finalized";
+      const otherFinal = other.inputStatus(i) === "finalized";
+      if (!thisV2 && currentFinal || !otherV2 && otherFinal)
+        hasOpaqueFinalizedV0 = true;
+      if (currentFinal && otherFinal) {
+        for (const k of ["finalScriptSig", "finalScriptWitness"]) {
+          const currentHas = !!this.inputs[i][k]?.length;
+          const otherHas = !!other.inputs[i][k]?.length;
+          if (currentHas !== otherHas)
+            throw new Error(`Transaction/combine: different finalized field=${k} input=${i}`);
+        }
+      }
+      const combined = combineKeyMap(PSBTInput, current, other.inputs[i], opts.unknown, opts.proprietary);
+      if (currentFinal || otherFinal)
+        cleanFinalInput(combined, opts.unknown, opts.proprietary);
+      return cloneDeep(normalizeInput(combined, undefined, undefined, opts.disableScriptCheck, opts.unknown, opts.proprietary));
+    });
+    if (hasOpaqueFinalizedV0 && global.txModifiable !== undefined)
+      global.txModifiable &= ~3;
+    const candidate = new Transaction2({ ...opts, PSBTVersion });
+    const outputs = this.outputs.map((current, i) => {
+      const combined = combineKeyMap(PSBTOutput, current, other.outputs[i], opts.unknown, opts.proprietary);
+      return cloneDeep(candidate.normalizeOutput(combined));
+    });
+    candidate.global = global;
+    candidate.inputs = inputs;
+    candidate.outputs = outputs;
+    if ((!thisV2 || !otherV2) && candidate.isPSBTv2())
+      candidate.global.txModifiable = candidate.txModifiable;
+    if (!equalBytes2(candidate.unsignedTx, unsignedTx))
+      throw new Error("Transaction/combine: combined unsigned tx differs");
+    this.global = candidate.global;
+    this.inputs = candidate.inputs;
+    this.outputs = candidate.outputs;
+    return this;
+  }
+  clone() {
+    return Transaction2.fromPSBT(this.toPSBT(), this.opts);
+  }
+}
+export { taprootTweakPrivKey, NETWORK2, TEST_NETWORK2, ScriptNum2, Script2, TaprootControlBlock2, OutScript2, taprootListToTree2, p2tr2, Address2, SigHash2, Transaction2 };