@btc-vision/bitcoin 6.5.1 → 6.5.2

package/browser/chunks/{transaction-BiXwH2v4.js → transaction-DchBu35N.js}

@@ -1,27 +1,27 @@
-import { B as a, d as I, b as N, t as Z } from "./crypto-C6FlKKmp.js";
-import { f as z, k as K, l as D, a as C, m as b, n as P, o as _, N as $, S as W, g as R, p as V, B as m, r as M, F as Q, q as J, h as tt } from "./utils-BKmkTzNZ.js";
-import { c as et, d as st, o as it } from "./script-COWGdiOo.js";
-const { typeforce: A } = K;
-function p(f) {
-  const t = f.length;
-  return R(t) + t;
+import { B as c, b as U, a as N, t as $ } from "./crypto-0PweVewC.js";
+import { f as z, k as K, l as D, a as C, m as b, n as P, o as _, N as Q, S as W, g as v, p as V, B as A, r as M, F as J, q as x, h as tt } from "./utils-CO5kmxe9.js";
+import { d as et, c as st, o as it } from "./script-CROJPzz_.js";
+const { typeforce: p } = K;
+function I(l) {
+  const t = l.length;
+  return v(t) + t;
 }
-function rt(f) {
-  const t = f.length;
-  return R(t) + f.reduce((e, s) => e + p(s), 0);
+function rt(l) {
+  const t = l.length;
+  return v(t) + l.reduce((e, s) => e + I(s), 0);
 }
-const H = a.allocUnsafe(0), T = [], k = a.from(
+const d = c.allocUnsafe(0), F = [], k = c.from(
   "0000000000000000000000000000000000000000000000000000000000000000",
   "hex"
-), F = a.from(
+), T = c.from(
   "0000000000000000000000000000000000000000000000000000000000000001",
   "hex"
-), nt = a.from("ffffffffffffffff", "hex"), ot = {
-  script: H,
+), nt = c.from("ffffffffffffffff", "hex"), ot = {
+  script: d,
   valueBuffer: nt
 };
-function ht(f) {
-  return f.value !== void 0;
+function ht(l) {
+  return "value" in l;
 }
 class o {
   constructor() {
@@ -70,28 +70,28 @@ class o {
     const s = new z(t), i = new o();
     i.version = s.readInt32();
     const n = s.readUInt8(), r = s.readUInt8();
-    let h = !1;
-    n === o.ADVANCED_TRANSACTION_MARKER && r === o.ADVANCED_TRANSACTION_FLAG ? h = !0 : s.offset -= 2;
-    const g = s.readVarInt();
-    for (let w = 0; w < g; ++w) {
-      const S = s.readSlice(32), U = s.readUInt32(), v = s.readVarSlice(), L = s.readUInt32();
+    let f = !1;
+    n === o.ADVANCED_TRANSACTION_MARKER && r === o.ADVANCED_TRANSACTION_FLAG ? f = !0 : s.offset -= 2;
+    const u = s.readVarInt();
+    for (let S = 0; S < u; ++S) {
+      const m = s.readSlice(32), E = s.readUInt32(), y = s.readVarSlice(), L = s.readUInt32();
       i.ins.push({
-        hash: S,
-        index: U,
-        script: v,
+        hash: m,
+        index: E,
+        script: y,
         sequence: L,
-        witness: T
+        witness: F
       });
     }
-    const d = s.readVarInt();
-    for (let w = 0; w < d; ++w)
+    const g = s.readVarInt();
+    for (let S = 0; S < g; ++S)
       i.outs.push({
         value: s.readUInt64(),
         script: s.readVarSlice()
       });
-    if (h) {
-      for (let w = 0; w < g; ++w)
-        i.ins[w].witness = s.readVector();
+    if (f) {
+      for (let S = 0; S < u; ++S)
+        i.ins[S].witness = s.readVector();
       if (!i.hasWitnesses()) throw new Error("Transaction has superfluous witness data");
     }
     if (i.locktime = s.readUInt32(), e) return i;
@@ -100,10 +100,10 @@ class o {
     return i;
   }
   static fromHex(t) {
-    return o.fromBuffer(a.from(t, "hex"), !1);
+    return o.fromBuffer(c.from(t, "hex"), !1);
   }
   static isCoinbaseHash(t) {
-    A(D, t);
+    p(D, t);
     for (let e = 0; e < 32; ++e)
       if (t[e] !== 0) return !1;
     return !0;
@@ -112,24 +112,24 @@ class o {
     return this.ins.length === 1 && o.isCoinbaseHash(this.ins[0].hash);
   }
   addInput(t, e, s, i) {
-    return A(
+    return p(
       C(
         D,
         b,
         P(b),
         P(_)
       ),
-      arguments
-    ), $(s) && (s = o.DEFAULT_SEQUENCE), this.ins.push({
+      [t, e, s, i]
+    ), Q(s) && (s = o.DEFAULT_SEQUENCE), this.ins.push({
       hash: t,
       index: e,
-      script: i || H,
+      script: i || d,
       sequence: s,
-      witness: T
+      witness: F
     }) - 1;
   }
   addOutput(t, e) {
-    return A(C(_, W), arguments), this.outs.push({
+    return p(C(_, W), [t, e]), this.outs.push({
       script: t,
       value: e
     }) - 1;
@@ -146,7 +146,7 @@ class o {
   }
   byteLength(t = !0) {
     const e = t && this.hasWitnesses();
-    return (e ? 10 : 8) + R(this.ins.length) + R(this.outs.length) + this.ins.reduce((s, i) => s + 40 + p(i.script), 0) + this.outs.reduce((s, i) => s + 8 + p(i.script), 0) + (e ? this.ins.reduce((s, i) => s + rt(i.witness), 0) : 0);
+    return (e ? 10 : 8) + v(this.ins.length) + v(this.outs.length) + this.ins.reduce((s, i) => s + 40 + I(i.script), 0) + this.outs.reduce((s, i) => s + 8 + I(i.script), 0) + (e ? this.ins.reduce((s, i) => s + rt(i.witness), 0) : 0);
   }
   clone() {
     const t = new o();
@@ -170,108 +170,116 @@ class o {
    * This hash can then be used to sign the provided transaction input.
    */
   hashForSignature(t, e, s) {
-    if (A(
-      C(
-        b,
-        _,
-        /* types.UInt8 */
-        V
-      ),
-      arguments
-    ), t >= this.ins.length) return F;
-    const i = et(
-      st(e).filter((h) => h !== it.OP_CODESEPARATOR)
-    ), n = this.clone();
+    if (p(C(
+      b,
+      _,
+      /* types.UInt8 */
+      V
+    ), [
+      t,
+      e,
+      s
+    ]), t >= this.ins.length) return T;
+    const i = et(e);
+    if (!i) throw new Error("Could not decompile prevOutScript");
+    const n = st(
+      i.filter((u) => u !== it.OP_CODESEPARATOR)
+    ), r = this.clone();
     if ((s & 31) === o.SIGHASH_NONE)
-      n.outs = [], n.ins.forEach((h, g) => {
-        g !== t && (h.sequence = 0);
+      r.outs = [], r.ins.forEach((u, g) => {
+        g !== t && (u.sequence = 0);
       });
     else if ((s & 31) === o.SIGHASH_SINGLE) {
-      if (t >= this.outs.length) return F;
-      n.outs.length = t + 1;
-      for (let h = 0; h < t; h++)
-        n.outs[h] = ot;
-      n.ins.forEach((h, g) => {
-        g !== t && (h.sequence = 0);
+      if (t >= this.outs.length) return T;
+      r.outs.length = t + 1;
+      for (let u = 0; u < t; u++)
+        r.outs[u] = ot;
+      r.ins.forEach((u, g) => {
+        g !== t && (u.sequence = 0);
       });
     }
-    s & o.SIGHASH_ANYONECANPAY ? (n.ins = [n.ins[t]], n.ins[0].script = i) : (n.ins.forEach((h) => {
-      h.script = H;
-    }), n.ins[t].script = i);
-    const r = a.allocUnsafe(n.byteLength(!1) + 4);
-    return r.writeInt32LE(s, r.length - 4), n.__toBuffer(r, 0, !1), I(r);
+    s & o.SIGHASH_ANYONECANPAY ? (r.ins = [r.ins[t]], r.ins[0].script = n) : (r.ins.forEach((u) => {
+      u.script = d;
+    }), r.ins[t].script = n);
+    const f = c.allocUnsafe(r.byteLength(!1) + 4);
+    return f.writeInt32LE(s, f.length - 4), r.__toBuffer(f, 0, !1), U(f);
   }
   hashForWitnessV1(t, e, s, i, n, r) {
-    if (A(
+    if (p(
       C(
         b,
-        A.arrayOf(_),
-        A.arrayOf(W),
+        p.arrayOf(_),
+        p.arrayOf(W),
         b
       ),
-      arguments
+      [t, e, s, i]
     ), s.length !== this.ins.length || e.length !== this.ins.length)
       throw new Error("Must supply prevout script and value for all inputs");
-    const h = i === o.SIGHASH_DEFAULT ? o.SIGHASH_ALL : i & o.SIGHASH_OUTPUT_MASK, d = (i & o.SIGHASH_INPUT_MASK) === o.SIGHASH_ANYONECANPAY, w = h === o.SIGHASH_NONE, S = h === o.SIGHASH_SINGLE;
-    let U = H, v = H, L = H, O = H, G = H;
-    if (!d) {
-      let c = m.withCapacity(36 * this.ins.length);
-      this.ins.forEach((l) => {
-        c.writeSlice(l.hash), c.writeUInt32(l.index);
-      }), U = N(c.end()), c = m.withCapacity(8 * this.ins.length), s.forEach((l) => c.writeUInt64(l)), v = N(c.end()), c = m.withCapacity(
-        e.map(p).reduce((l, E) => l + E)
-      ), e.forEach((l) => c.writeVarSlice(l)), L = N(c.end()), c = m.withCapacity(4 * this.ins.length), this.ins.forEach((l) => c.writeUInt32(l.sequence)), O = N(c.end());
+    const f = i === o.SIGHASH_DEFAULT ? o.SIGHASH_ALL : i & o.SIGHASH_OUTPUT_MASK, g = (i & o.SIGHASH_INPUT_MASK) === o.SIGHASH_ANYONECANPAY, S = f === o.SIGHASH_NONE, m = f === o.SIGHASH_SINGLE;
+    let E = d, y = d, L = d, O = d, G = d;
+    if (!g) {
+      let h = A.withCapacity(36 * this.ins.length);
+      this.ins.forEach((w) => {
+        h.writeSlice(w.hash), h.writeUInt32(w.index);
+      }), E = N(h.end()), h = A.withCapacity(8 * this.ins.length), s.forEach((w) => h.writeUInt64(w)), y = N(h.end()), h = A.withCapacity(
+        e.map(I).reduce((w, H) => w + H)
+      ), e.forEach((w) => h.writeVarSlice(w)), L = N(h.end()), h = A.withCapacity(4 * this.ins.length), this.ins.forEach((w) => h.writeUInt32(w.sequence)), O = N(h.end());
     }
-    if (w || S) {
-      if (S && t < this.outs.length) {
-        const c = this.outs[t], l = m.withCapacity(8 + p(c.script));
-        l.writeUInt64(c.value), l.writeVarSlice(c.script), G = N(l.end());
+    if (S || m) {
+      if (m && t < this.outs.length) {
+        const h = this.outs[t], w = A.withCapacity(8 + I(h.script));
+        w.writeUInt64(h.value), w.writeVarSlice(h.script), G = N(w.end());
       }
     } else {
       if (!this.outs.length)
         throw new Error("Add outputs to the transaction before signing.");
-      const c = this.outs.map((E) => 8 + p(E.script)).reduce((E, X) => E + X), l = m.withCapacity(c);
-      this.outs.forEach((E) => {
-        l.writeUInt64(E.value), l.writeVarSlice(E.script);
-      }), G = N(l.end());
+      const h = this.outs.map((H) => 8 + I(H.script)).reduce((H, Z) => H + Z), w = A.withCapacity(h);
+      this.outs.forEach((H) => {
+        w.writeUInt64(H.value), w.writeVarSlice(H.script);
+      }), G = N(w.end());
     }
-    const j = (n ? 2 : 0) + (r ? 1 : 0), x = 174 - (d ? 49 : 0) - (w ? 32 : 0) + (r ? 32 : 0) + (n ? 37 : 0), u = m.withCapacity(x);
-    if (u.writeUInt8(i), u.writeInt32(this.version), u.writeUInt32(this.locktime), u.writeSlice(U), u.writeSlice(v), u.writeSlice(L), u.writeSlice(O), w || S || u.writeSlice(G), u.writeUInt8(j), d) {
-      const c = this.ins[t];
-      u.writeSlice(c.hash), u.writeUInt32(c.index), u.writeUInt64(s[t]), u.writeVarSlice(e[t]), u.writeUInt32(c.sequence);
+    const j = (n ? 2 : 0) + (r ? 1 : 0), X = 174 - (g ? 49 : 0) - (S ? 32 : 0) + (r ? 32 : 0) + (n ? 37 : 0), a = A.withCapacity(X);
+    if (a.writeUInt8(i), a.writeInt32(this.version), a.writeUInt32(this.locktime), a.writeSlice(E), a.writeSlice(y), a.writeSlice(L), a.writeSlice(O), S || m || a.writeSlice(G), a.writeUInt8(j), g) {
+      const h = this.ins[t];
+      a.writeSlice(h.hash), a.writeUInt32(h.index), a.writeUInt64(s[t]), a.writeVarSlice(e[t]), a.writeUInt32(h.sequence);
     } else
-      u.writeUInt32(t);
+      a.writeUInt32(t);
     if (r) {
-      const c = m.withCapacity(p(r));
-      c.writeVarSlice(r), u.writeSlice(N(c.end()));
+      const h = A.withCapacity(I(r));
+      h.writeVarSlice(r), a.writeSlice(N(h.end()));
     }
-    return S && u.writeSlice(G), n && (u.writeSlice(n), u.writeUInt8(0), u.writeUInt32(4294967295)), Z(
+    return m && a.writeSlice(G), n && (a.writeSlice(n), a.writeUInt8(0), a.writeUInt32(4294967295)), $(
       "TapSighash",
-      a.concat([a.from([0]), u.end()])
+      c.concat([c.from([0]), a.end()])
     );
   }
   hashForWitnessV0(t, e, s, i) {
-    A(C(b, _, W, b), arguments);
-    let n = a.from([]), r, h = k, g = k, d = k;
-    if (i & o.SIGHASH_ANYONECANPAY || (n = a.allocUnsafe(36 * this.ins.length), r = new m(n, 0), this.ins.forEach((S) => {
-      r.writeSlice(S.hash), r.writeUInt32(S.index);
-    }), g = I(n)), !(i & o.SIGHASH_ANYONECANPAY) && (i & 31) !== o.SIGHASH_SINGLE && (i & 31) !== o.SIGHASH_NONE && (n = a.allocUnsafe(4 * this.ins.length), r = new m(n, 0), this.ins.forEach((S) => {
-      r.writeUInt32(S.sequence);
-    }), d = I(n)), (i & 31) !== o.SIGHASH_SINGLE && (i & 31) !== o.SIGHASH_NONE) {
-      const S = this.outs.reduce((U, v) => U + 8 + p(v.script), 0);
-      n = a.allocUnsafe(S), r = new m(n, 0), this.outs.forEach((U) => {
-        r.writeUInt64(U.value), r.writeVarSlice(U.script);
-      }), h = I(n);
+    p(C(b, _, W, b), [
+      t,
+      e,
+      s,
+      i
+    ]);
+    let n = c.from([]), r, f = k, u = k, g = k;
+    if (i & o.SIGHASH_ANYONECANPAY || (n = c.allocUnsafe(36 * this.ins.length), r = new A(n, 0), this.ins.forEach((m) => {
+      r.writeSlice(m.hash), r.writeUInt32(m.index);
+    }), u = U(n)), !(i & o.SIGHASH_ANYONECANPAY) && (i & 31) !== o.SIGHASH_SINGLE && (i & 31) !== o.SIGHASH_NONE && (n = c.allocUnsafe(4 * this.ins.length), r = new A(n, 0), this.ins.forEach((m) => {
+      r.writeUInt32(m.sequence);
+    }), g = U(n)), (i & 31) !== o.SIGHASH_SINGLE && (i & 31) !== o.SIGHASH_NONE) {
+      const m = this.outs.reduce((E, y) => E + 8 + I(y.script), 0);
+      n = c.allocUnsafe(m), r = new A(n, 0), this.outs.forEach((E) => {
+        r.writeUInt64(E.value), r.writeVarSlice(E.script);
+      }), f = U(n);
     } else if ((i & 31) === o.SIGHASH_SINGLE && t < this.outs.length) {
-      const S = this.outs[t];
-      n = a.allocUnsafe(8 + p(S.script)), r = new m(n, 0), r.writeUInt64(S.value), r.writeVarSlice(S.script), h = I(n);
+      const m = this.outs[t];
+      n = c.allocUnsafe(8 + I(m.script)), r = new A(n, 0), r.writeUInt64(m.value), r.writeVarSlice(m.script), f = U(n);
     }
-    n = a.allocUnsafe(156 + p(e)), r = new m(n, 0);
-    const w = this.ins[t];
-    return r.writeInt32(this.version), r.writeSlice(g), r.writeSlice(d), r.writeSlice(w.hash), r.writeUInt32(w.index), r.writeVarSlice(e), r.writeUInt64(s), r.writeUInt32(w.sequence), r.writeSlice(h), r.writeUInt32(this.locktime), r.writeUInt32(i), I(n);
+    n = c.allocUnsafe(156 + I(e)), r = new A(n, 0);
+    const S = this.ins[t];
+    return r.writeInt32(this.version), r.writeSlice(u), r.writeSlice(g), r.writeSlice(S.hash), r.writeUInt32(S.index), r.writeVarSlice(e), r.writeUInt64(s), r.writeUInt32(S.sequence), r.writeSlice(f), r.writeUInt32(this.locktime), r.writeUInt32(i), U(n);
   }
   getHash(t) {
-    return t && this.isCoinbase() ? a.alloc(32, 0) : I(this.__toBuffer(void 0, void 0, t));
+    return t && this.isCoinbase() ? c.alloc(32, 0) : U(this.__toBuffer(void 0, void 0, t));
   }
   getId() {
     return M(this.getHash(!1)).toString("hex");
@@ -283,14 +291,14 @@ class o {
     return this.toBuffer(void 0, void 0).toString("hex");
   }
   setInputScript(t, e) {
-    A(C(V, _), arguments), this.ins[t].script = e;
+    p(C(V, _), [t, e]), this.ins[t].script = e;
   }
   setWitness(t, e) {
-    A(C(V, [_]), arguments), this.ins[t].witness = e;
+    p(C(V, [_]), [t, e]), this.ins[t].witness = e;
   }
   __toBuffer(t, e, s = !1) {
-    t || (t = a.allocUnsafe(this.byteLength(s)));
-    const i = new m(t, e || 0);
+    t || (t = c.allocUnsafe(this.byteLength(s)));
+    const i = new A(t, e || 0);
     i.writeInt32(this.version);
     const n = s && this.hasWitnesses();
     return n && (i.writeUInt8(o.ADVANCED_TRANSACTION_MARKER), i.writeUInt8(o.ADVANCED_TRANSACTION_FLAG)), i.writeVarInt(this.ins.length), this.ins.forEach((r) => {
@@ -299,57 +307,60 @@ class o {
       ht(r) ? i.writeUInt64(r.value) : i.writeSlice(r.valueBuffer), i.writeVarSlice(r.script);
     }), n && this.ins.forEach((r) => {
       i.writeVector(r.witness);
-    }), i.writeUInt32(this.locktime), e !== void 0 ? t.slice(e, i.offset) : t;
+    }), i.writeUInt32(this.locktime), e !== void 0 ? t.subarray(e, i.offset) : t;
   }
 }
 const wt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Transaction: o
-}, Symbol.toStringTag, { value: "Module" })), { typeforce: ct } = K, B = new TypeError("Cannot compute merkle root for zero transactions"), q = new TypeError("Cannot compute witness commit for non-segwit block");
-class y {
+}, Symbol.toStringTag, { value: "Module" })), { typeforce: ct } = K, B = new TypeError("Cannot compute merkle root for zero transactions"), Y = new TypeError("Cannot compute witness commit for non-segwit block");
+class R {
   constructor() {
     this.version = 1, this.prevHash = void 0, this.merkleRoot = void 0, this.timestamp = 0, this.witnessCommit = void 0, this.bits = 0, this.nonce = 0, this.transactions = void 0;
   }
   static fromBuffer(t) {
     if (t.length < 80) throw new Error("Buffer too small (< 80 bytes)");
-    const e = new z(t), s = new y();
+    const e = new z(t), s = new R();
     if (s.version = e.readInt32(), s.prevHash = e.readSlice(32), s.merkleRoot = e.readSlice(32), s.timestamp = e.readUInt32(), s.bits = e.readUInt32(), s.nonce = e.readUInt32(), t.length === 80) return s;
     const i = () => {
-      const h = o.fromBuffer(e.buffer.slice(e.offset), !0);
-      return e.offset += h.byteLength(), h;
+      const f = o.fromBuffer(
+        e.buffer.subarray(e.offset),
+        !0
+      );
+      return e.offset += f.byteLength(), f;
     }, n = e.readVarInt();
     s.transactions = [];
-    for (let h = 0; h < n; ++h) {
-      const g = i();
-      s.transactions.push(g);
+    for (let f = 0; f < n; ++f) {
+      const u = i();
+      s.transactions.push(u);
     }
     const r = s.getWitnessCommit();
     return r && (s.witnessCommit = r), s;
   }
   static fromHex(t) {
-    return y.fromBuffer(a.from(t, "hex"));
+    return R.fromBuffer(c.from(t, "hex"));
   }
   static calculateTarget(t) {
-    const e = ((t & 4278190080) >> 24) - 3, s = t & 8388607, i = a.alloc(32, 0);
+    const e = ((t & 4278190080) >> 24) - 3, s = t & 8388607, i = c.alloc(32, 0);
     return i.writeUIntBE(s, 29 - e, 3), i;
   }
   static calculateMerkleRoot(t, e) {
-    if (ct([{ getHash: Q }], t), t.length === 0) throw B;
-    if (e && !Y(t)) throw q;
-    const s = t.map((n) => n.getHash(e)), i = J(s, I);
-    return e ? I(a.concat([i, t[0].ins[0].witness[0]])) : i;
+    if (ct([{ getHash: J }], t), t.length === 0) throw B;
+    if (e && !q(t)) throw Y;
+    const s = t.map((n) => n.getHash(e)), i = x(s, U);
+    return e ? U(c.concat([i, t[0].ins[0].witness[0]])) : i;
   }
   getWitnessCommit() {
-    if (!Y(this.transactions)) return null;
+    if (!q(this.transactions)) return null;
     const t = this.transactions[0].outs.filter(
-      (s) => s.script.slice(0, 6).equals(a.from("6a24aa21a9ed", "hex"))
-    ).map((s) => s.script.slice(6, 38));
+      (s) => s.script.subarray(0, 6).equals(c.from("6a24aa21a9ed", "hex"))
+    ).map((s) => s.script.subarray(6, 38));
     if (t.length === 0) return null;
     const e = t[t.length - 1];
-    return e instanceof a && e.length === 32 ? e : null;
+    return e instanceof c && e.length === 32 ? e : null;
   }
   hasWitnessCommit() {
-    return this.witnessCommit instanceof a && this.witnessCommit.length === 32 || this.getWitnessCommit() !== null;
+    return this.witnessCommit instanceof c && this.witnessCommit.length === 32 || this.getWitnessCommit() !== null;
   }
   hasWitness() {
     return at(this.transactions);
@@ -359,10 +370,10 @@ class y {
     return t * 3 + e;
   }
   byteLength(t, e = !0) {
-    return t || !this.transactions ? 80 : 80 + R(this.transactions.length) + this.transactions.reduce((s, i) => s + i.byteLength(e), 0);
+    return t || !this.transactions ? 80 : 80 + v(this.transactions.length) + this.transactions.reduce((s, i) => s + i.byteLength(e), 0);
   }
   getHash() {
-    return I(this.toBuffer(!0));
+    return U(this.toBuffer(!0));
   }
   getId() {
     return M(this.getHash()).toString("hex");
@@ -373,7 +384,7 @@ class y {
   }
   // TODO: buffer, offset compatibility
   toBuffer(t) {
-    const e = a.allocUnsafe(this.byteLength(t)), s = new m(e);
+    const e = c.allocUnsafe(this.byteLength(t)), s = new A(e);
     if (s.writeInt32(this.version), s.writeSlice(this.prevHash), s.writeSlice(this.merkleRoot), s.writeUInt32(this.timestamp), s.writeUInt32(this.bits), s.writeUInt32(this.nonce), t || !this.transactions) return e;
     const i = tt(this.transactions.length, e, s.offset);
     return s.offset += i.bytes, this.transactions.forEach((n) => {
@@ -389,33 +400,33 @@ class y {
     return !t && this.hasWitness() ? !1 : this.__checkMerkleRoot() && (t ? this.__checkWitnessCommit() : !0);
   }
   checkProofOfWork() {
-    const t = M(this.getHash()), e = y.calculateTarget(this.bits);
+    const t = M(this.getHash()), e = R.calculateTarget(this.bits);
     return t.compare(e) <= 0;
   }
   __checkMerkleRoot() {
     if (!this.transactions) throw B;
-    const t = y.calculateMerkleRoot(this.transactions);
+    const t = R.calculateMerkleRoot(this.transactions);
     return this.merkleRoot.compare(t) === 0;
   }
   __checkWitnessCommit() {
     if (!this.transactions) throw B;
-    if (!this.hasWitnessCommit()) throw q;
-    const t = y.calculateMerkleRoot(this.transactions, !0);
+    if (!this.hasWitnessCommit()) throw Y;
+    const t = R.calculateMerkleRoot(this.transactions, !0);
     return this.witnessCommit.compare(t) === 0;
   }
 }
-function Y(f) {
-  return f instanceof Array && f[0] && f[0].ins && f[0].ins instanceof Array && f[0].ins[0] && f[0].ins[0].witness && f[0].ins[0].witness instanceof Array && f[0].ins[0].witness.length > 0;
+function q(l) {
+  return l instanceof Array && l[0] && l[0].ins && l[0].ins instanceof Array && l[0].ins[0] && l[0].ins[0].witness && l[0].ins[0].witness instanceof Array && l[0].ins[0].witness.length > 0;
 }
-function at(f) {
-  return f instanceof Array && f.some(
+function at(l) {
+  return l instanceof Array && l.some(
     (t) => typeof t == "object" && t.ins instanceof Array && t.ins.some(
       (e) => typeof e == "object" && e.witness instanceof Array && e.witness.length > 0
     )
   );
 }
 export {
-  y as B,
+  R as B,
   o as T,
   wt as a
 };