@btc-vision/bitcoin 6.4.11 → 6.5.1

package/browser/chunks/script-COWGdiOo.js

@@ -0,0 +1,318 @@
+import { B as _ } from "./crypto-C6FlKKmp.js";
+import { u as C, k as d, U as H, v as y, x as L, A as f, y as h, z as M, o as I, C as V, D as w, E as B, j as F, G as m, p as K } from "./utils-BKmkTzNZ.js";
+const o = {
+  OP_FALSE: 0,
+  OP_0: 0,
+  OP_PUSHDATA1: 76,
+  OP_PUSHDATA2: 77,
+  OP_PUSHDATA4: 78,
+  OP_1NEGATE: 79,
+  OP_RESERVED: 80,
+  OP_TRUE: 81,
+  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,
+  OP_NOP: 97,
+  OP_VER: 98,
+  OP_IF: 99,
+  OP_NOTIF: 100,
+  OP_VERIF: 101,
+  OP_VERNOTIF: 102,
+  OP_ELSE: 103,
+  OP_ENDIF: 104,
+  OP_VERIFY: 105,
+  OP_RETURN: 106,
+  OP_TOALTSTACK: 107,
+  OP_FROMALTSTACK: 108,
+  OP_2DROP: 109,
+  OP_2DUP: 110,
+  OP_3DUP: 111,
+  OP_2OVER: 112,
+  OP_2ROT: 113,
+  OP_2SWAP: 114,
+  OP_IFDUP: 115,
+  OP_DEPTH: 116,
+  OP_DROP: 117,
+  OP_DUP: 118,
+  OP_NIP: 119,
+  OP_OVER: 120,
+  OP_PICK: 121,
+  OP_ROLL: 122,
+  OP_ROT: 123,
+  OP_SWAP: 124,
+  OP_TUCK: 125,
+  OP_CAT: 126,
+  OP_SUBSTR: 127,
+  OP_LEFT: 128,
+  OP_RIGHT: 129,
+  OP_SIZE: 130,
+  OP_INVERT: 131,
+  OP_AND: 132,
+  OP_OR: 133,
+  OP_XOR: 134,
+  OP_EQUAL: 135,
+  OP_EQUALVERIFY: 136,
+  OP_RESERVED1: 137,
+  OP_RESERVED2: 138,
+  OP_1ADD: 139,
+  OP_1SUB: 140,
+  OP_2MUL: 141,
+  OP_2DIV: 142,
+  OP_NEGATE: 143,
+  OP_ABS: 144,
+  OP_NOT: 145,
+  OP_0NOTEQUAL: 146,
+  OP_ADD: 147,
+  OP_SUB: 148,
+  OP_MUL: 149,
+  OP_DIV: 150,
+  OP_MOD: 151,
+  OP_LSHIFT: 152,
+  OP_RSHIFT: 153,
+  OP_BOOLAND: 154,
+  OP_BOOLOR: 155,
+  OP_NUMEQUAL: 156,
+  OP_NUMEQUALVERIFY: 157,
+  OP_NUMNOTEQUAL: 158,
+  OP_LESSTHAN: 159,
+  OP_GREATERTHAN: 160,
+  OP_LESSTHANOREQUAL: 161,
+  OP_GREATERTHANOREQUAL: 162,
+  OP_MIN: 163,
+  OP_MAX: 164,
+  OP_WITHIN: 165,
+  OP_RIPEMD160: 166,
+  OP_SHA1: 167,
+  OP_SHA256: 168,
+  OP_HASH160: 169,
+  OP_HASH256: 170,
+  OP_CODESEPARATOR: 171,
+  OP_CHECKSIG: 172,
+  OP_CHECKSIGVERIFY: 173,
+  OP_CHECKMULTISIG: 174,
+  OP_CHECKMULTISIGVERIFY: 175,
+  OP_NOP1: 176,
+  OP_NOP2: 177,
+  OP_CHECKLOCKTIMEVERIFY: 177,
+  OP_NOP3: 178,
+  OP_CHECKSEQUENCEVERIFY: 178,
+  OP_NOP4: 179,
+  OP_NOP5: 180,
+  OP_NOP6: 181,
+  OP_NOP7: 182,
+  OP_NOP8: 183,
+  OP_NOP9: 184,
+  OP_NOP10: 185,
+  OP_CHECKSIGADD: 186,
+  OP_PUBKEYHASH: 253,
+  OP_PUBKEY: 254,
+  OP_INVALIDOPCODE: 255
+}, T = {};
+for (const t of Object.keys(o)) {
+  const e = o[t];
+  T[e] = t;
+}
+function G(t, e, n) {
+  e = e || 4, n = n === void 0 ? !0 : n;
+  const O = t.length;
+  if (O === 0) return 0;
+  if (O > e) throw new TypeError("Script number overflow");
+  if (n && (t[O - 1] & 127) === 0 && (O <= 1 || (t[O - 2] & 128) === 0))
+    throw new Error("Non-minimally encoded script number");
+  if (O === 5) {
+    const P = t.readUInt32LE(0), i = t.readUInt8(4);
+    return i & 128 ? -((i & -129) * 4294967296 + P) : i * 4294967296 + P;
+  }
+  let r = 0;
+  for (let P = 0; P < O; ++P)
+    r |= t[P] << 8 * P;
+  return t[O - 1] & 128 ? -(r & ~(128 << 8 * (O - 1))) : r;
+}
+function v(t) {
+  return t > 2147483647 ? 5 : t > 8388607 ? 4 : t > 32767 ? 3 : t > 127 ? 2 : t > 0 ? 1 : 0;
+}
+function R(t) {
+  let e = Math.abs(t);
+  const n = v(e), O = _.allocUnsafe(n), r = t < 0;
+  for (let P = 0; P < n; ++P)
+    O.writeUInt8(e & 255, P), e >>= 8;
+  return O[n - 1] & 128 ? O.writeUInt8(r ? 128 : 0, n - 1) : r && (O[n - 1] |= 128), O;
+}
+const j = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: G,
+  encode: R
+}, Symbol.toStringTag, { value: "Module" })), { typeforce: Q } = d, u = _.alloc(1, 0);
+function A(t) {
+  let e = 0;
+  for (; t[e] === 0; ) ++e;
+  return e === t.length ? u : (t = t.slice(e), t[0] & 128 ? _.concat([u, t], 1 + t.length) : t);
+}
+function S(t) {
+  t[0] === 0 && (t = t.slice(1));
+  const e = _.alloc(32, 0), n = Math.max(0, 32 - t.length);
+  return t.copy(e, n), e;
+}
+function Y(t) {
+  const e = t.readUInt8(t.length - 1);
+  if (!l(e))
+    throw new Error("Invalid hashType " + e);
+  const n = C(t.slice(0, -1)), O = S(n.r), r = S(n.s);
+  return { signature: _.concat([O, r], 64), hashType: e };
+}
+function z(t, e) {
+  if (Q(
+    {
+      signature: y(64),
+      hashType: H
+    },
+    { signature: t, hashType: e }
+  ), !l(e))
+    throw new Error("Invalid hashType " + e);
+  const n = _.allocUnsafe(1);
+  n.writeUInt8(e, 0);
+  const O = A(t.slice(0, 32)), r = A(t.slice(32, 64));
+  return _.concat([L(O, r), n]);
+}
+const $ = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: Y,
+  encode: z
+}, Symbol.toStringTag, { value: "Module" })), { typeforce: s } = d, U = o.OP_RESERVED;
+function b(t) {
+  return K(t) && (t === o.OP_0 || t >= o.OP_1 && t <= o.OP_16 || t === o.OP_1NEGATE);
+}
+function N(t) {
+  return I(t) || b(t);
+}
+function p(t) {
+  return f(t) && t.every(N);
+}
+function W(t) {
+  return t.length - t.filter(N).length;
+}
+function c(t) {
+  if (t.length === 0) return o.OP_0;
+  if (t.length === 1) {
+    if (t[0] >= 1 && t[0] <= 16) return U + t[0];
+    if (t[0] === 129) return o.OP_1NEGATE;
+  }
+}
+function D(t) {
+  return _.isBuffer(t);
+}
+function X(t) {
+  return f(t);
+}
+function E(t) {
+  return _.isBuffer(t);
+}
+function g(t) {
+  if (D(t)) return t;
+  s(f, t);
+  const e = t.reduce((r, P) => E(P) ? P.length === 1 && c(P) !== void 0 ? r + 1 : r + h(P.length) + P.length : r + 1, 0), n = _.allocUnsafe(e);
+  let O = 0;
+  if (t.forEach((r) => {
+    if (E(r)) {
+      const P = c(r);
+      if (P !== void 0) {
+        n.writeUInt8(P, O), O += 1;
+        return;
+      }
+      O += M(n, r.length, O), r.copy(n, O), O += r.length;
+    } else
+      n.writeUInt8(r, O), O += 1;
+  }), O !== n.length) throw new Error("Could not decode chunks");
+  return n;
+}
+function a(t) {
+  if (X(t)) return t;
+  s(I, t);
+  const e = [];
+  let n = 0;
+  for (; n < t.length; ) {
+    const O = t[n];
+    if (O > o.OP_0 && O <= o.OP_PUSHDATA4) {
+      const r = V(t, n);
+      if (r === null || (n += r.size, n + r.number > t.length)) return null;
+      const P = t.slice(n, n + r.number);
+      n += r.number;
+      const i = c(P);
+      i !== void 0 ? e.push(i) : e.push(P);
+    } else
+      e.push(O), n += 1;
+  }
+  return e;
+}
+function Z(t) {
+  if (D(t) && (t = a(t)), !t)
+    throw new Error("Could not convert invalid chunks to ASM");
+  return t.map((e) => {
+    if (E(e)) {
+      const n = c(e);
+      if (n === void 0) return e.toString("hex");
+      e = n;
+    }
+    return T[e];
+  }).join(" ");
+}
+function q(t) {
+  return s(w, t), g(
+    t.split(" ").map((e) => o[e] !== void 0 ? o[e] : (s(B, e), _.from(e, "hex")))
+  );
+}
+function J(t) {
+  return t = a(t), s(p, t), t.map((e) => E(e) ? e : e === o.OP_0 ? _.allocUnsafe(0) : R(e - U));
+}
+function x(t) {
+  return F(t);
+}
+function l(t) {
+  const e = t & -129;
+  return e > 0 && e < 4;
+}
+function k(t) {
+  return !_.isBuffer(t) || !l(t[t.length - 1]) ? !1 : m(t.slice(0, -1));
+}
+const tt = j, et = $, rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  compile: g,
+  countNonPushOnlyOPs: W,
+  decompile: a,
+  fromASM: q,
+  isCanonicalPubKey: x,
+  isCanonicalScriptSignature: k,
+  isDefinedHashType: l,
+  isPushOnly: p,
+  number: tt,
+  opcodes: o,
+  signature: et,
+  toASM: Z,
+  toStack: J
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  x as a,
+  rt as b,
+  g as c,
+  a as d,
+  W as e,
+  p as f,
+  J as g,
+  k as i,
+  o,
+  et as s,
+  Z as t
+};