@btc-vision/bitcoin 6.4.11 → 6.5.2

package/browser/chunks/transaction-DchBu35N.js

@@ -0,0 +1,432 @@
+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(l) {
+  const t = l.length;
+  return v(t) + l.reduce((e, s) => e + I(s), 0);
+}
+const d = c.allocUnsafe(0), F = [], k = c.from(
+  "0000000000000000000000000000000000000000000000000000000000000000",
+  "hex"
+), T = c.from(
+  "0000000000000000000000000000000000000000000000000000000000000001",
+  "hex"
+), nt = c.from("ffffffffffffffff", "hex"), ot = {
+  script: d,
+  valueBuffer: nt
+};
+function ht(l) {
+  return "value" in l;
+}
+class o {
+  constructor() {
+    this.version = 1, this.locktime = 0, this.ins = [], this.outs = [];
+  }
+  static {
+    this.DEFAULT_SEQUENCE = 4294967295;
+  }
+  static {
+    this.SIGHASH_DEFAULT = 0;
+  }
+  static {
+    this.SIGHASH_ALL = 1;
+  }
+  static {
+    this.SIGHASH_NONE = 2;
+  }
+  static {
+    this.SIGHASH_SINGLE = 3;
+  }
+  static {
+    this.SIGHASH_ANYONECANPAY = 128;
+  }
+  static {
+    this.SIGHASH_OUTPUT_MASK = 3;
+  }
+  static {
+    this.SIGHASH_INPUT_MASK = 128;
+  }
+  static {
+    this.ADVANCED_TRANSACTION_MARKER = 0;
+  }
+  static {
+    this.ADVANCED_TRANSACTION_FLAG = 1;
+  }
+  static {
+    this.TRUC_VERSION = 3;
+  }
+  static {
+    this.TRUC_MAX_VSIZE = 1e4;
+  }
+  static {
+    this.TRUC_CHILD_MAX_VSIZE = 1e3;
+  }
+  static fromBuffer(t, e) {
+    const s = new z(t), i = new o();
+    i.version = s.readInt32();
+    const n = s.readUInt8(), r = s.readUInt8();
+    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: m,
+        index: E,
+        script: y,
+        sequence: L,
+        witness: F
+      });
+    }
+    const g = s.readVarInt();
+    for (let S = 0; S < g; ++S)
+      i.outs.push({
+        value: s.readUInt64(),
+        script: s.readVarSlice()
+      });
+    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;
+    if (s.offset !== t.length)
+      throw new Error("Transaction has unexpected data");
+    return i;
+  }
+  static fromHex(t) {
+    return o.fromBuffer(c.from(t, "hex"), !1);
+  }
+  static isCoinbaseHash(t) {
+    p(D, t);
+    for (let e = 0; e < 32; ++e)
+      if (t[e] !== 0) return !1;
+    return !0;
+  }
+  isCoinbase() {
+    return this.ins.length === 1 && o.isCoinbaseHash(this.ins[0].hash);
+  }
+  addInput(t, e, s, i) {
+    return p(
+      C(
+        D,
+        b,
+        P(b),
+        P(_)
+      ),
+      [t, e, s, i]
+    ), Q(s) && (s = o.DEFAULT_SEQUENCE), this.ins.push({
+      hash: t,
+      index: e,
+      script: i || d,
+      sequence: s,
+      witness: F
+    }) - 1;
+  }
+  addOutput(t, e) {
+    return p(C(_, W), [t, e]), this.outs.push({
+      script: t,
+      value: e
+    }) - 1;
+  }
+  hasWitnesses() {
+    return this.ins.some((t) => t.witness.length !== 0);
+  }
+  weight() {
+    const t = this.byteLength(!1), e = this.byteLength(!0);
+    return t * 3 + e;
+  }
+  virtualSize() {
+    return Math.ceil(this.weight() / 4);
+  }
+  byteLength(t = !0) {
+    const e = t && this.hasWitnesses();
+    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();
+    return t.version = this.version, t.locktime = this.locktime, t.ins = this.ins.map((e) => ({
+      hash: e.hash,
+      index: e.index,
+      script: e.script,
+      sequence: e.sequence,
+      witness: e.witness
+    })), t.outs = this.outs.map((e) => ({
+      script: e.script,
+      value: e.value
+    })), t;
+  }
+  /**
+   * Hash transaction for signing a specific input.
+   *
+   * Bitcoin uses a different hash for each signed transaction input.
+   * This method copies the transaction, makes the necessary changes based on the
+   * hashType, and then hashes the result.
+   * This hash can then be used to sign the provided transaction input.
+   */
+  hashForSignature(t, e, s) {
+    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)
+      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 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 ? (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 (p(
+      C(
+        b,
+        p.arrayOf(_),
+        p.arrayOf(W),
+        b
+      ),
+      [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 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 (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 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 - (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
+      a.writeUInt32(t);
+    if (r) {
+      const h = A.withCapacity(I(r));
+      h.writeVarSlice(r), a.writeSlice(N(h.end()));
+    }
+    return m && a.writeSlice(G), n && (a.writeSlice(n), a.writeUInt8(0), a.writeUInt32(4294967295)), $(
+      "TapSighash",
+      c.concat([c.from([0]), a.end()])
+    );
+  }
+  hashForWitnessV0(t, e, s, i) {
+    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 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 = 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() ? c.alloc(32, 0) : U(this.__toBuffer(void 0, void 0, t));
+  }
+  getId() {
+    return M(this.getHash(!1)).toString("hex");
+  }
+  toBuffer(t, e) {
+    return this.__toBuffer(t, e, !0);
+  }
+  toHex() {
+    return this.toBuffer(void 0, void 0).toString("hex");
+  }
+  setInputScript(t, e) {
+    p(C(V, _), [t, e]), this.ins[t].script = e;
+  }
+  setWitness(t, e) {
+    p(C(V, [_]), [t, e]), this.ins[t].witness = e;
+  }
+  __toBuffer(t, e, s = !1) {
+    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) => {
+      i.writeSlice(r.hash), i.writeUInt32(r.index), i.writeVarSlice(r.script), i.writeUInt32(r.sequence);
+    }), i.writeVarInt(this.outs.length), this.outs.forEach((r) => {
+      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.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"), 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 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 f = o.fromBuffer(
+        e.buffer.subarray(e.offset),
+        !0
+      );
+      return e.offset += f.byteLength(), f;
+    }, n = e.readVarInt();
+    s.transactions = [];
+    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 R.fromBuffer(c.from(t, "hex"));
+  }
+  static calculateTarget(t) {
+    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: 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 (!q(this.transactions)) return null;
+    const t = this.transactions[0].outs.filter(
+      (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 c && e.length === 32 ? e : null;
+  }
+  hasWitnessCommit() {
+    return this.witnessCommit instanceof c && this.witnessCommit.length === 32 || this.getWitnessCommit() !== null;
+  }
+  hasWitness() {
+    return at(this.transactions);
+  }
+  weight() {
+    const t = this.byteLength(!1, !1), e = this.byteLength(!1, !0);
+    return t * 3 + e;
+  }
+  byteLength(t, e = !0) {
+    return t || !this.transactions ? 80 : 80 + v(this.transactions.length) + this.transactions.reduce((s, i) => s + i.byteLength(e), 0);
+  }
+  getHash() {
+    return U(this.toBuffer(!0));
+  }
+  getId() {
+    return M(this.getHash()).toString("hex");
+  }
+  getUTCDate() {
+    const t = /* @__PURE__ */ new Date(0);
+    return t.setUTCSeconds(this.timestamp), t;
+  }
+  // TODO: buffer, offset compatibility
+  toBuffer(t) {
+    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) => {
+      const r = n.byteLength();
+      n.toBuffer(e, s.offset), s.offset += r;
+    }), e;
+  }
+  toHex(t) {
+    return this.toBuffer(t).toString("hex");
+  }
+  checkTxRoots() {
+    const t = this.hasWitnessCommit();
+    return !t && this.hasWitness() ? !1 : this.__checkMerkleRoot() && (t ? this.__checkWitnessCommit() : !0);
+  }
+  checkProofOfWork() {
+    const t = M(this.getHash()), e = R.calculateTarget(this.bits);
+    return t.compare(e) <= 0;
+  }
+  __checkMerkleRoot() {
+    if (!this.transactions) throw B;
+    const t = R.calculateMerkleRoot(this.transactions);
+    return this.merkleRoot.compare(t) === 0;
+  }
+  __checkWitnessCommit() {
+    if (!this.transactions) throw B;
+    if (!this.hasWitnessCommit()) throw Y;
+    const t = R.calculateMerkleRoot(this.transactions, !0);
+    return this.witnessCommit.compare(t) === 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(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 {
+  R as B,
+  o as T,
+  wt as a
+};