@btc-vision/bitcoin 6.4.10 → 6.5.1

package/browser/chunks/transaction-BiXwH2v4.js

@@ -0,0 +1,421 @@
+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;
+}
+function rt(f) {
+  const t = f.length;
+  return R(t) + f.reduce((e, s) => e + p(s), 0);
+}
+const H = a.allocUnsafe(0), T = [], k = a.from(
+  "0000000000000000000000000000000000000000000000000000000000000000",
+  "hex"
+), F = a.from(
+  "0000000000000000000000000000000000000000000000000000000000000001",
+  "hex"
+), nt = a.from("ffffffffffffffff", "hex"), ot = {
+  script: H,
+  valueBuffer: nt
+};
+function ht(f) {
+  return f.value !== void 0;
+}
+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 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();
+      i.ins.push({
+        hash: S,
+        index: U,
+        script: v,
+        sequence: L,
+        witness: T
+      });
+    }
+    const d = s.readVarInt();
+    for (let w = 0; w < d; ++w)
+      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 (!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(a.from(t, "hex"), !1);
+  }
+  static isCoinbaseHash(t) {
+    A(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 A(
+      C(
+        D,
+        b,
+        P(b),
+        P(_)
+      ),
+      arguments
+    ), $(s) && (s = o.DEFAULT_SEQUENCE), this.ins.push({
+      hash: t,
+      index: e,
+      script: i || H,
+      sequence: s,
+      witness: T
+    }) - 1;
+  }
+  addOutput(t, e) {
+    return A(C(_, W), arguments), 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) + 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);
+  }
+  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 (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 ((s & 31) === o.SIGHASH_NONE)
+      n.outs = [], n.ins.forEach((h, g) => {
+        g !== t && (h.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);
+      });
+    }
+    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);
+  }
+  hashForWitnessV1(t, e, s, i, n, r) {
+    if (A(
+      C(
+        b,
+        A.arrayOf(_),
+        A.arrayOf(W),
+        b
+      ),
+      arguments
+    ), 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());
+    }
+    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());
+      }
+    } 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 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);
+    } else
+      u.writeUInt32(t);
+    if (r) {
+      const c = m.withCapacity(p(r));
+      c.writeVarSlice(r), u.writeSlice(N(c.end()));
+    }
+    return S && u.writeSlice(G), n && (u.writeSlice(n), u.writeUInt8(0), u.writeUInt32(4294967295)), Z(
+      "TapSighash",
+      a.concat([a.from([0]), u.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);
+    } 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);
+    }
+    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);
+  }
+  getHash(t) {
+    return t && this.isCoinbase() ? a.alloc(32, 0) : I(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) {
+    A(C(V, _), arguments), this.ins[t].script = e;
+  }
+  setWitness(t, e) {
+    A(C(V, [_]), arguments), this.ins[t].witness = e;
+  }
+  __toBuffer(t, e, s = !1) {
+    t || (t = a.allocUnsafe(this.byteLength(s)));
+    const i = new m(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.slice(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 {
+  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();
+    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;
+    }, n = e.readVarInt();
+    s.transactions = [];
+    for (let h = 0; h < n; ++h) {
+      const g = i();
+      s.transactions.push(g);
+    }
+    const r = s.getWitnessCommit();
+    return r && (s.witnessCommit = r), s;
+  }
+  static fromHex(t) {
+    return y.fromBuffer(a.from(t, "hex"));
+  }
+  static calculateTarget(t) {
+    const e = ((t & 4278190080) >> 24) - 3, s = t & 8388607, i = a.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;
+  }
+  getWitnessCommit() {
+    if (!Y(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));
+    if (t.length === 0) return null;
+    const e = t[t.length - 1];
+    return e instanceof a && e.length === 32 ? e : null;
+  }
+  hasWitnessCommit() {
+    return this.witnessCommit instanceof a && 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 + R(this.transactions.length) + this.transactions.reduce((s, i) => s + i.byteLength(e), 0);
+  }
+  getHash() {
+    return I(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 = a.allocUnsafe(this.byteLength(t)), s = new m(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 = y.calculateTarget(this.bits);
+    return t.compare(e) <= 0;
+  }
+  __checkMerkleRoot() {
+    if (!this.transactions) throw B;
+    const t = y.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);
+    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 at(f) {
+  return f instanceof Array && f.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,
+  o as T,
+  wt as a
+};