From 0ea5e423292ef441a0ffe0d2c5f575cd9a104c2c Mon Sep 17 00:00:00 2001 From: Markus Bopp Date: Thu, 23 Mar 2023 17:03:42 +0100 Subject: [PATCH] + added a modified (hacked) version of BTON 1.0.3 that is now shopped with the app instead of linked. This version allows the encoding of large scripts and leafs # changed uploader and sats registration to allow multiple items. --- bton.min.js | 2713 +++++++++++++++++++++++++++++++++++++++++++++++++++ signet.html | 388 ++++---- 2 files changed, 2878 insertions(+), 223 deletions(-) create mode 100644 bton.min.js diff --git a/bton.min.js b/bton.min.js new file mode 100644 index 0000000..7f27011 --- /dev/null +++ b/bton.min.js @@ -0,0 +1,2713 @@ +var bton = function (t) { + "use strict"; + const n = new TextEncoder, + e = [{name: "base58", charset: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"}, { + name: "base64", + charset: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" + }, {name: "base64url", charset: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"}]; + + function r(t) { + for (const n of e) if (n.name === t) return n.charset; + throw TypeError("Charset does not exist: " + t) + } + + const i = { + encode: function (t, e, i = !1) { + "string" == typeof t && (t = n.encode(t)); + const o = r(e), s = o.length, a = []; + let c, u, f, h = "", l = 0; + for (c = 0; c < t.length; c++) for (l = 0, u = t[c], h += u > 0 || (h.length ^ c) > 0 ? "" : "1"; l in a || u > 0;) f = a[l], f = f > 0 ? 256 * f + u : u, u = f / s | 0, a[l] = f % s, l++; + for (; l-- > 0;) h += o[a[l]]; + return i && h.length % 4 > 0 ? h + "=".repeat(4 - h.length % 4) : h + }, decode: function (t, n) { + const e = r(n), i = e.length, o = [], s = []; + t = t.replace("=", ""); + let a, c, u, f = 0; + for (a = 0; a < t.length; a++) { + if (f = 0, c = e.indexOf(t[a]), c < 0) throw new Error(`Character range out of bounds: ${c}`); + for (c > 0 || (s.length ^ a) > 0 || s.push(0); f in o || c > 0;) u = o[f], u = u > 0 ? u * i + c : c, c = u >> 8, o[f] = u % 256, f++ + } + for (; f-- > 0;) s.push(o[f]); + return new Uint8Array(s) + } + }, o = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", s = [996825010, 642813549, 513874426, 1027748829, 705979059], + a = {BECH32: "bech32", BECH32M: "bech32m"}; + + function c(t) { + switch (t) { + case a.BECH32: + return 1; + case a.BECH32M: + return 734539939; + default: + throw new Error(`Unrecognized encoding: ${t}`) + } + } + + function u(t) { + let n = 1; + for (let e = 0; e < t.length; ++e) { + const r = n >> 25; + n = (33554431 & n) << 5 ^ t[e]; + for (let t = 0; t < 5; ++t) (r >> t & 1) > 0 && (n ^= s[t]) + } + return n + } + + function f(t) { + const n = []; + let e; + for (e = 0; e < t.length; ++e) n.push(t.charCodeAt(e) >> 5); + for (n.push(0), e = 0; e < t.length; ++e) n.push(31 & t.charCodeAt(e)); + return n + } + + function h(t, n, e, r = !0) { + const i = []; + let o = 0, s = 0; + const a = (1 << e) - 1, c = (1 << n + e - 1) - 1; + for (const r of t) { + if (r < 0 || r >> n > 0) return []; + for (o = (o << n | r) & c, s += n; s >= e;) s -= e, i.push(o >> s & a) + } + if (r) s > 0 && i.push(o << e - s & a); else if (s >= n || (o << e - s & a) > 0) return []; + return i + } + + function l(t, n, e) { + const r = n.concat(function (t, n, e) { + const r = u(f(t).concat(n).concat([0, 0, 0, 0, 0, 0])) ^ c(e), i = []; + for (let t = 0; t < 6; ++t) i.push(r >> 5 * (5 - t) & 31); + return i + }(t, n, e)); + let i = t + "1"; + for (let t = 0; t < r.length; ++t) i += o.charAt(r[t]); + return i + } + + function d(t, n) { + const e = n > 0 ? "bech32m" : "bech32"; + if (!function (t) { + let n, e, r = !1, i = !1; + for (n = 0; n < t.length; ++n) { + if (e = t.charCodeAt(n), e < 33 || e > 126) return !1; + e >= 97 && e <= 122 && (r = !0), e >= 65 && e <= 90 && (i = !0) + } + return !(r && i) + }(t)) return {hrp: null, data: [255]}; + if (!function (t) { + const n = t.lastIndexOf("1"); + return !(n < 1 || n + 7 > t.length || t.length > 90) + }(t = t.toLowerCase())) return {hrp: null, data: [255]}; + const r = [], i = t.lastIndexOf("1"), s = t.substring(0, i); + for (let n = i + 1; n < t.length; ++n) { + const e = o.indexOf(t.charAt(n)); + if (-1 === e) return {hrp: null, data: [255]}; + r.push(e) + } + return function (t, n, e) { + return u(f(t).concat(n)) === c(e) + }(s, r, e) ? {hrp: s, data: r.slice(0, r.length - 6)} : {hrp: null, data: [255]} + } + + function w(t, n = 0) { + const e = t.split("1", 1)[0], {hrp: r, data: i} = d(t, n), o = h(i.slice(1), 5, 8, !1), s = o.length; + switch (!0) { + case e !== r: + throw new Error("Returned hrp string is invalid."); + case null === o || s < 2 || s > 40: + throw new Error("Decoded string is invalid or out of spec."); + case i[0] > 16: + throw new Error("Returned version bit is out of range."); + case 0 === i[0] && 20 !== s && 32 !== s: + throw new Error("Decoded string does not match version 0 spec."); + case 0 === i[0] && 0 !== n: + case 0 !== i[0] && 1 !== n: + throw new Error("Decoded version bit does not match."); + default: + return Uint8Array.from(o) + } + } + + const y = { + encode: function (t, n = "bch", e = 0) { + const r = l(n, [e, ...h([...t], 8, 5)], e > 0 ? "bech32m" : "bech32"); + return w(r, e), r + }, decode: w + }, g = new TextEncoder, p = new TextDecoder; + + function m(t) { + return g.encode(t) + } + + function b(t) { + const n = []; + let e, r = 0; + if (t.length % 2 > 0) throw new Error(`Invalid hex string length: ${t.length}`); + for (e = 0; e < t.length; e += 2) n[r] = parseInt(t.slice(e, e + 2), 16), r += 1; + return Uint8Array.from(n) + } + + function A(t) { + if (0 === t) return Uint8Array.of(0); + const n = []; + for (; t > 0;) { + const e = 255 & t; + n.push(e), t = (t - e) / 256 + } + return Uint8Array.from(n) + } + + function x(t) { + if (0n === t) return Uint8Array.of(0); + const n = []; + for (; t > 0n;) { + const e = 0xffn & t; + n.push(Number(e)), t = (t - e) / 256n + } + return Uint8Array.from(n) + } + + function E(t) { + return p.decode(t) + } + + function v(t) { + let n, e = 0; + for (n = t.length - 1; n >= 0; n--) e = 256 * e + t[n]; + return Number(e) + } + + function S(t) { + let n, e = 0n; + for (n = t.length - 1; n >= 0; n--) e = 256n * e + BigInt(t[n]); + return BigInt(e) + } + + async function P(t) { + return crypto.subtle.digest("SHA-256", t).then((t => new Uint8Array(t))) + } + + async function O(t) { + return P(await P(t)) + } + + const {crypto: U} = globalThis; + let _ = class extends Uint8Array { + static { + this.num = (t, n, e = "le") => { + const r = new _(A(t), n); + return "le" === e ? r.reverse() : r + } + } + static { + this.big = (t, n, e = "le") => { + const r = new _(x(t), n); + return "le" === e ? r.reverse() : r + } + } + + static async b58check(t) { + const n = i.decode(t, "base58"); + return new _(await async function (t) { + const n = t.slice(0, -4), e = t.slice(-4); + if ((await O(n)).slice(0, 4).toString() !== e.toString()) throw new Error("Invalid checksum!"); + return n + }(n)) + } + + static { + this.any = (t, n) => new _(function (t) { + if (t instanceof ArrayBuffer) return new Uint8Array(t); + if (t instanceof Uint8Array) return t; + const n = typeof t; + switch (n) { + case"bigint": + return x(t); + case"boolean": + return Uint8Array.of(t); + case"number": + return A(t); + case"string": + return null !== t.match(/^(02|03)*[0-9a-fA-F]{64}$/) ? b(t) : g.encode(t); + default: + throw TypeError("Unsupported format:" + n) + } + }(t), n) + } + static { + this.raw = (t, n) => new _(t, n) + } + static { + this.str = (t, n) => new _(m(t), n) + } + static { + this.hex = (t, n) => new _(b(t), n) + } + static { + this.json = t => new _(m(JSON.stringify(t))) + } + static { + this.base64 = t => new _(i.decode(t, "base64")) + } + static { + this.b64url = t => new _(i.decode(t, "base64url")) + } + static { + this.bech32 = (t, n = 0) => new _(y.decode(t, n)) + } + + constructor(t, n) { + if (void 0 !== n) { + const e = new Uint8Array(n).fill(0); + e.set(new Uint8Array(t)), t = e.buffer + } + return super(t), this + } + + get num() { + return this.toNum() + } + + get big() { + return this.toBig() + } + + get arr() { + return this.toArr() + } + + get str() { + return this.toStr() + } + + get hex() { + return this.toHex() + } + + get raw() { + return new Uint8Array(this) + } + + get base64() { + return this.toBase64() + } + + get b64url() { + return this.toB64url() + } + + get digest() { + return this.toDigest() + } + + get id() { + return this.toDigest().then((t => new _(t).hex)) + } + + toNum(t = "le") { + return v("le" === t ? this.reverse() : this) + } + + toBig(t = "le") { + return S("le" === t ? this.reverse() : this) + } + + async toDigest(t = "SHA-256") { + return U.subtle.digest(t, this.raw).then((t => new Uint8Array(t))) + } + + async tob58check() { + return i.encode(await async function (t) { + const n = await O(t); + return Uint8Array.of(...t, ...n.slice(0, 4)) + }(this), "base58") + } + + toArr() { + return Array.from(this) + } + + toStr() { + return E(this) + } + + toHex() { + return function (t) { + const n = []; + let e; + for (e = 0; e < t.length; e++) n.push(t[e].toString(16).padStart(2, "0")); + return n.join("") + }(this) + } + + toJson() { + return JSON.parse(E(this)) + } + + toBytes() { + return new Uint8Array(this) + } + + toB64url() { + return i.encode(this, "base64url") + } + + toBase64(t) { + return i.encode(this, "base64", t) + } + + toBech32(t, n = 0) { + return y.encode(this, t, n) + } + + prepend(t) { + return _.of(...t, ...this) + } + + append(t) { + return _.of(...this, ...t) + } + + slice(t, n) { + return new _(new Uint8Array(this).slice(t, n)) + } + + reverse() { + return new _(new Uint8Array(this).reverse()) + } + + write(t, n) { + this.set(t, n) + } + + prefixSize2(t) { + return _.of(..._.readSize(this.length, t), ...this) + } + + // Rarity Garden Hack + prefixSize(t) { + + const sized = _.readSize(this.length, t); + const thised = this; + + var uint8 = new Uint8Array(sized.length + thised.length); + uint8.set(sized); + uint8.set(thised, sized.length); + + return new _(uint8) + } + + static from(t) { + return new _(Uint8Array.from(t)) + } + + static of2(...t) { + return new _(Uint8Array.of(...t)) + } + + // Rarity Garden Hack + static of(...t) { + + const uint8 = new Uint8Array(t.length); + + for(let i = 0; i < uint8.length; i++) + { + uint8[i] = t[i]; + } + + return new _(uint8) + } + + static join(t) { + let n, e = 0; + const r = t.reduce(((t, n) => t + n.length), 0), i = new Uint8Array(r); + for (const r of t) for (n = 0; n < r.length; e++, n++) i[e] = r[n]; + return new _(i, r) + } + + static readSize(t, n) { + if (t < 253) return _.num(t, 1); + if (t < 65536) return _.of(253, ..._.num(t, 2, n)); + if (t < 4294967296) return _.of(254, ..._.num(t, 4, n)); + if (t < 0x10000000000000000) return _.of(255, ..._.num(t, 8, n)); + throw new Error(`Value is too large: ${t}`) + } + + static random(t = 32) { + return new _(U.getRandomValues(new Uint8Array(t))) + } + + static { + this.encode = m + } + static { + this.decode = E + } + + static normalize(t, n) { + if (t instanceof Uint8Array) return t; + if ("string" == typeof t) return _.hex(t, n).raw; + if ("number" == typeof t) return _.num(t, n).raw; + if ("bigint" == typeof t) return _.big(t, n).raw; + throw TypeError("Unrecognized format: " + typeof t) + } + + static serialize(t) { + if ("string" == typeof t) return _.str(t).raw; + if ("object" == typeof t) { + if (t instanceof Uint8Array) return t; + try { + return _.json(t).raw + } catch { + throw TypeError("Object is not serializable.") + } + } + throw TypeError("Unrecognized format: " + typeof t) + } + + static revitalize(t) { + if (t instanceof Uint8Array && (t = E(t)), "string" == typeof t) try { + return JSON.parse(t) + } catch { + return t + } + return t + } + }; + + class B { + constructor(t) { + this.data = new Uint8Array(t), this.size = this.data.length + } + + peek(t) { + if (t > this.size) throw new Error(`Size greater than stream: ${t} > ${this.size}`); + return new _(this.data.slice(0, t).buffer) + } + + read(t) { + t = t ?? this.readSize(); + const n = this.peek(t); + return this.data = this.data.slice(t), this.size = this.data.length, n + } + + readSize() { + const t = this.read(1).toNum(); + switch (!0) { + case t >= 0 && t < 253: + return t; + case 253 === t: + return this.read(2).toNum(); + case 254 === t: + return this.read(4).toNum(); + case 255 === t: + return this.read(8).toNum(); + default: + throw new Error(`Varint is out of range: ${t}`) + } + } + } + + const I = { + OP_0: 0, + OP_PUSHDATA1: 76, + OP_PUSHDATA2: 77, + OP_PUSHDATA4: 78, + OP_1NEGATE: 79, + 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_IF: 99, + OP_NOTIF: 100, + 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_SIZE: 130, + OP_EQUAL: 135, + OP_EQUALVERIFY: 136, + OP_1ADD: 139, + OP_1SUB: 140, + OP_NEGATE: 143, + OP_ABS: 144, + OP_NOT: 145, + OP_0NOTEQUAL: 146, + OP_ADD: 147, + OP_SUB: 148, + 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_CHECKLOCKTIMEVERIFY: 177, + OP_CHECKSEQUENCEVERIFY: 178, + OP_NOP4: 179, + OP_NOP5: 180, + OP_NOP6: 181, + OP_NOP7: 182, + OP_NOP8: 183, + OP_NOP9: 184, + OP_NOP10: 185 + }; + + function H(t) { + for (const [n, e] of Object.entries(I)) if (e === t) return n; + throw new Error("OPCODE not found:" + String(t)) + } + + const z = 520; + + function N(t = [], n = !0) { + let e = _.num(0); + return Array.isArray(t) && (e = _.raw(T(t))), "string" == typeof t && (e = _.hex(t)), t instanceof Uint8Array && (e = _.raw(t)), n && (e = e.prefixSize("be")), e.raw + } + + function T(t) { + const n = []; + for (const e of t) n.push(R(e)); + return n.length > 0 ? _.join(n) : new Uint8Array + } + + function R(t) { + let n = new Uint8Array; + if ("string" == typeof t) { + if (t.startsWith("OP_")) return _.num(function (t) { + for (const [n, e] of Object.entries(I)) if (n === t) return Number(e); + throw new Error("OPCODE not found:" + t) + }(t), 1); + t.startsWith("STR_") && (n = _.str(t.slice(3))), n = _.hex(t) + } + if ("number" == typeof t && (n = _.num(t)), t instanceof Uint8Array && (n = t), n.length > z) { + const t = function (t) { + const n = [], e = new B(t); + for (; e.size > z;) n.push(e.read(z)); + return n.push(e.read(e.size)), n + }(n); + return T(t) + } + return _.of(...function (t) { + const n = _.num(76, 1), e = _.num(77, 1); + switch (!0) { + case t <= 75: + return _.num(t); + case t > 75 && t < 256: + return _.join([n, _.num(t, 1)]); + case t >= 256 && t <= z: + return _.join([e, _.num(t, 2, "be")]); + default: + throw new Error("Invalid word size:" + t.toString()) + } + }(n.length), ...n) + } + + function k(t) { + return _.num(t, 4).reverse() + } + + function C(t) { + return _.hex(t, 32).reverse() + } + + function D(t) { + return _.num(t, 4).reverse() + } + + function K(t = 4294967295) { + return ("string" == typeof t ? _.hex(t, 4) : _.num(t, 4)).reverse() + } + + function j(t) { + return "number" == typeof t && (t = BigInt(t)), _.big(t, 8).reverse() + } + + function $(t) { + const n = []; + if (Array.isArray(t)) { + n.push(_.readSize(t.length)); + for (const e of t) n.push(N(e)); + return _.join(n) + } + return _.normalize(t) + } + + function V(t) { + return _.num(t, 4).reverse() + } + + function L(t) { + "string" == typeof t && (t = _.hex(t).raw); + const n = new B(t), e = function (t) { + return t.read(4).reverse().toNum() + }(n), r = function (t) { + const [n, e] = [...t.peek(2)]; + if (0 === n) { + if (t.read(2), 1 === e) return !0; + throw new Error(`Invalid witness flag: ${e}`) + } + return !1 + }(n), i = function (t) { + const n = [], e = t.readSize(); + for (let r = 0; r < e; r++) n.push(q(t)); + return n + }(n), o = function (t) { + const n = [], e = t.readSize(); + for (let r = 0; r < e; r++) n.push(F(t)); + return n + }(n); + if (r) for (const t of i) t.witness = M(n); + const s = function (t) { + return t.read(4).reverse().toNum() + }(n); + return {version: e, input: i, output: o, locktime: s} + } + + function q(t) { + return { + txid: t.read(32).reverse().toHex(), + vout: t.read(4).reverse().toNum(), + scriptSig: Y(t, !0), + sequence: t.read(4).reverse().toHex() + } + } + + function F(t) { + return {value: t.read(8).reverse().big, scriptPubKey: Y(t, !0)} + } + + function M(t) { + const n = [], e = t.readSize(); + for (let r = 0; r < e; r++) { + const e = Y(t, !0); + n.push(e) + } + return n + } + + function Y(t, n) { + const e = !0 === n ? t.readSize() : t.size; + return e > 0 ? t.read(e).toHex() : _.num(0).toHex() + } + + function Z(t) { + if (void 0 === t) throw new Error("Script data is undefined!"); + if (Array.isArray(t)) throw new Error("Script data is an array!"); + return _.normalize(t) + } + + function W(t) { + switch (!0) { + case 0 === t: + return "opcode"; + case t >= 1 && t <= 75: + return "varint"; + case 76 === t: + return "pushdata1"; + case 77 === t: + return "pushdata2"; + case 78 === t: + return "pushdata4"; + case t <= 185: + return "opcode"; + default: + throw new Error(`Invalid word range: ${t}`) + } + } + + function G(t) { + switch (!0) { + case"number" != typeof t: + return !1; + case 0 === t: + return !0; + case[126, 127, 128, 129, 131, 132, 133, 134, 141, 142, 149, 150, 151, 152, 153].includes(t): + return !1; + case 75 < t && t < 186: + return !0; + default: + return !1 + } + } + + /*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */ + const {crypto: X} = globalThis, J = BigInt(0), Q = BigInt(1), tt = BigInt(2), nt = BigInt(3), et = BigInt(8), + rt = Object.freeze({ + a: J, + b: BigInt(7), + P: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), + n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), + h: Q, + Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"), + Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"), + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee") + }), it = (t, n) => (t + n / tt) / n, ot = { + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), splitScalar(t) { + const {n: n} = rt, e = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), + r = -Q * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), + i = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), o = e, + s = BigInt("0x100000000000000000000000000000000"), a = it(o * t, n), c = it(-r * t, n); + let u = Tt(t - a * e - c * i, n), f = Tt(-a * r - c * o, n); + const h = u > s, l = f > s; + if (h && (u = n - u), l && (f = n - f), u > s || f > s) throw new Error("splitScalarEndo: Endomorphism failed, k=" + t); + return {k1neg: h, k1: u, k2neg: l, k2: f} + } + }, st = 32, at = 32, ct = 32, ut = st + 1, ft = 2 * st + 1; + + function ht(t) { + const {a: n, b: e} = rt, r = Tt(t * t), i = Tt(r * t); + return Tt(i + n * t + e) + } + + const lt = rt.a === J; + + class dt extends Error { + constructor(t) { + super(t) + } + } + + function wt(t) { + if (!(t instanceof yt)) throw new TypeError("JacobianPoint expected") + } + + class yt { + constructor(t, n, e) { + this.x = t, this.y = n, this.z = e + } + + static get BASE() { + return new yt(rt.Gx, rt.Gy, Q) + } + + static get ZERO() { + return new yt(J, Q, J) + } + + static fromAffine(t) { + if (!(t instanceof mt)) throw new TypeError("JacobianPoint#fromAffine: expected Point"); + return t.equals(mt.ZERO) ? yt.ZERO : new yt(t.x, t.y, Q) + } + + static toAffineBatch(t) { + const n = function (t, n = rt.P) { + const e = new Array(t.length), + r = kt(t.reduce(((t, r, i) => r === J ? t : (e[i] = t, Tt(t * r, n))), Q), n); + return t.reduceRight(((t, r, i) => r === J ? t : (e[i] = Tt(t * e[i], n), Tt(t * r, n))), r), e + }(t.map((t => t.z))); + return t.map(((t, e) => t.toAffine(n[e]))) + } + + static normalizeZ(t) { + return yt.toAffineBatch(t).map(yt.fromAffine) + } + + equals(t) { + wt(t); + const {x: n, y: e, z: r} = this, {x: i, y: o, z: s} = t, a = Tt(r * r), c = Tt(s * s), u = Tt(n * c), + f = Tt(i * a), h = Tt(Tt(e * s) * c), l = Tt(Tt(o * r) * a); + return u === f && h === l + } + + negate() { + return new yt(this.x, Tt(-this.y), this.z) + } + + double() { + const {x: t, y: n, z: e} = this, r = Tt(t * t), i = Tt(n * n), o = Tt(i * i), s = t + i, + a = Tt(tt * (Tt(s * s) - r - o)), c = Tt(nt * r), u = Tt(c * c), f = Tt(u - tt * a), + h = Tt(c * (a - f) - et * o), l = Tt(tt * n * e); + return new yt(f, h, l) + } + + add(t) { + wt(t); + const {x: n, y: e, z: r} = this, {x: i, y: o, z: s} = t; + if (i === J || o === J) return this; + if (n === J || e === J) return t; + const a = Tt(r * r), c = Tt(s * s), u = Tt(n * c), f = Tt(i * a), h = Tt(Tt(e * s) * c), + l = Tt(Tt(o * r) * a), d = Tt(f - u), w = Tt(l - h); + if (d === J) return w === J ? this.double() : yt.ZERO; + const y = Tt(d * d), g = Tt(d * y), p = Tt(u * y), m = Tt(w * w - g - tt * p), b = Tt(w * (p - m) - h * g), + A = Tt(r * s * d); + return new yt(m, b, A) + } + + subtract(t) { + return this.add(t.negate()) + } + + multiplyUnsafe(t) { + const n = yt.ZERO; + if ("bigint" == typeof t && t === J) return n; + let e = Nt(t); + if (e === Q) return this; + if (!lt) { + let t = n, r = this; + for (; e > J;) e & Q && (t = t.add(r)), r = r.double(), e >>= Q; + return t + } + let {k1neg: r, k1: i, k2neg: o, k2: s} = ot.splitScalar(e), a = n, c = n, u = this; + for (; i > J || s > J;) i & Q && (a = a.add(u)), s & Q && (c = c.add(u)), u = u.double(), i >>= Q, s >>= Q; + return r && (a = a.negate()), o && (c = c.negate()), c = new yt(Tt(c.x * ot.beta), c.y, c.z), a.add(c) + } + + precomputeWindow(t) { + const n = lt ? 128 / t + 1 : 256 / t + 1, e = []; + let r = this, i = r; + for (let o = 0; o < n; o++) { + i = r, e.push(i); + for (let n = 1; n < 2 ** (t - 1); n++) i = i.add(r), e.push(i); + r = i.double() + } + return e + } + + wNAF(t, n) { + !n && this.equals(yt.BASE) && (n = mt.BASE); + const e = n && n._WINDOW_SIZE || 1; + if (256 % e) throw new Error("Point#wNAF: Invalid precomputation window, must be power of 2"); + let r = n && pt.get(n); + r || (r = this.precomputeWindow(e), n && 1 !== e && (r = yt.normalizeZ(r), pt.set(n, r))); + let i = yt.ZERO, o = yt.BASE; + const s = 1 + (lt ? 128 / e : 256 / e), a = 2 ** (e - 1), c = BigInt(2 ** e - 1), u = 2 ** e, f = BigInt(e); + for (let n = 0; n < s; n++) { + const e = n * a; + let s = Number(t & c); + t >>= f, s > a && (s -= u, t += Q); + const h = e, l = e + Math.abs(s) - 1, d = n % 2 != 0, w = s < 0; + 0 === s ? o = o.add(gt(d, r[h])) : i = i.add(gt(w, r[l])) + } + return {p: i, f: o} + } + + multiply(t, n) { + let e, r, i = Nt(t); + if (lt) { + const {k1neg: t, k1: o, k2neg: s, k2: a} = ot.splitScalar(i); + let {p: c, f: u} = this.wNAF(o, n), {p: f, f: h} = this.wNAF(a, n); + c = gt(t, c), f = gt(s, f), f = new yt(Tt(f.x * ot.beta), f.y, f.z), e = c.add(f), r = u.add(h) + } else { + const {p: t, f: o} = this.wNAF(i, n); + e = t, r = o + } + return yt.normalizeZ([e, r])[0] + } + + toAffine(t) { + const {x: n, y: e, z: r} = this, i = this.equals(yt.ZERO); + null == t && (t = i ? et : kt(r)); + const o = t, s = Tt(o * o), a = Tt(s * o), c = Tt(n * s), u = Tt(e * a), f = Tt(r * o); + if (i) return mt.ZERO; + if (f !== Q) throw new Error("invZ was invalid"); + return new mt(c, u) + } + } + + function gt(t, n) { + const e = n.negate(); + return t ? e : n + } + + const pt = new WeakMap; + let mt = class { + constructor(t, n) { + this.x = t, this.y = n + } + + _setWindowSize(t) { + this._WINDOW_SIZE = t, pt.delete(this) + } + + static get BASE() { + return new mt(rt.Gx, rt.Gy) + } + + static get ZERO() { + return new mt(J, J) + } + + hasEvenY() { + return this.y % tt === J + } + + static fromCompressedHex(t) { + const n = 32 === t.length, e = Ht(n ? t : t.subarray(1)); + if (!Vt(e)) throw new Error("Point is not on curve"); + let r = function (t) { + const {P: n} = rt, e = BigInt(6), r = BigInt(11), i = BigInt(22), o = BigInt(23), s = BigInt(44), + a = BigInt(88), c = t * t * t % n, u = c * c * t % n, f = Rt(u, nt) * u % n, h = Rt(f, nt) * u % n, + l = Rt(h, tt) * c % n, d = Rt(l, r) * l % n, w = Rt(d, i) * d % n, y = Rt(w, s) * w % n, + g = Rt(y, a) * y % n, p = Rt(g, s) * w % n, m = Rt(p, nt) * u % n, b = Rt(m, o) * d % n, + A = Rt(b, e) * c % n, x = Rt(A, tt); + if (x * x % n !== t) throw new Error("Cannot find square root"); + return x + }(ht(e)); + const i = (r & Q) === Q; + if (n) i && (r = Tt(-r)); else { + 1 == (1 & t[0]) !== i && (r = Tt(-r)) + } + const o = new mt(e, r); + return o.assertValidity(), o + } + + static fromUncompressedHex(t) { + const n = Ht(t.subarray(1, st + 1)), e = Ht(t.subarray(st + 1, 2 * st + 1)), r = new mt(n, e); + return r.assertValidity(), r + } + + static fromHex(t) { + const n = zt(t), e = n.length, r = n[0]; + if (e === st) return this.fromCompressedHex(n); + if (e === ut && (2 === r || 3 === r)) return this.fromCompressedHex(n); + if (e === ft && 4 === r) return this.fromUncompressedHex(n); + throw new Error(`Point.fromHex: received invalid point. Expected 32-${ut} compressed bytes or ${ft} uncompressed bytes, not ${e}`) + } + + static fromPrivateKey(t) { + return mt.BASE.multiply(qt(t)) + } + + static fromSignature(t, n, e) { + const {r: r, s: i} = Mt(n); + if (![0, 1, 2, 3].includes(e)) throw new Error("Cannot recover: invalid recovery bit"); + const o = Ct(zt(t)), {n: s} = rt, a = 2 === e || 3 === e ? r + s : r, c = kt(a, s), u = Tt(-o * c, s), + f = Tt(i * c, s), h = 1 & e ? "03" : "02", l = mt.fromHex(h + Ot(a)), + d = mt.BASE.multiplyAndAddUnsafe(l, u, f); + if (!d) throw new Error("Cannot recover signature: point at infinify"); + return d.assertValidity(), d + } + + toRawBytes(t = !1) { + return It(this.toHex(t)) + } + + toHex(t = !1) { + const n = Ot(this.x); + if (t) { + return `${this.hasEvenY() ? "02" : "03"}${n}` + } + return `04${n}${Ot(this.y)}` + } + + toHexX() { + return this.toHex(!0).slice(2) + } + + toRawX() { + return this.toRawBytes(!0).slice(1) + } + + assertValidity() { + const t = "Point is not on elliptic curve", {x: n, y: e} = this; + if (!Vt(n) || !Vt(e)) throw new Error(t); + const r = Tt(e * e); + if (Tt(r - ht(n)) !== J) throw new Error(t) + } + + equals(t) { + return this.x === t.x && this.y === t.y + } + + negate() { + return new mt(this.x, Tt(-this.y)) + } + + double() { + return yt.fromAffine(this).double().toAffine() + } + + add(t) { + return yt.fromAffine(this).add(yt.fromAffine(t)).toAffine() + } + + subtract(t) { + return this.add(t.negate()) + } + + multiply(t) { + return yt.fromAffine(this).multiply(t, this).toAffine() + } + + multiplyAndAddUnsafe(t, n, e) { + const r = yt.fromAffine(this), + i = n === J || n === Q || this !== mt.BASE ? r.multiplyUnsafe(n) : r.multiply(n), + o = yt.fromAffine(t).multiplyUnsafe(e), s = i.add(o); + return s.equals(yt.ZERO) ? void 0 : s.toAffine() + } + }; + + function bt(t) { + return Number.parseInt(t[0], 16) >= 8 ? "00" + t : t + } + + function At(t) { + if (t.length < 2 || 2 !== t[0]) throw new Error(`Invalid signature integer tag: ${St(t)}`); + const n = t[1], e = t.subarray(2, n + 2); + if (!n || e.length !== n) throw new Error("Invalid signature integer: wrong length"); + if (0 === e[0] && e[1] <= 127) throw new Error("Invalid signature integer: trailing length"); + return {data: Ht(e), left: t.subarray(n + 2)} + } + + class xt { + constructor(t, n) { + this.r = t, this.s = n, this.assertValidity() + } + + static fromCompact(t) { + const n = t instanceof Uint8Array, e = "Signature.fromCompact"; + if ("string" != typeof t && !n) throw new TypeError(`${e}: Expected string or Uint8Array`); + const r = n ? St(t) : t; + if (128 !== r.length) throw new Error(`${e}: Expected 64-byte hex`); + return new xt(Bt(r.slice(0, 64)), Bt(r.slice(64, 128))) + } + + static fromDER(t) { + const n = t instanceof Uint8Array; + if ("string" != typeof t && !n) throw new TypeError("Signature.fromDER: Expected string or Uint8Array"); + const {r: e, s: r} = function (t) { + if (t.length < 2 || 48 != t[0]) throw new Error(`Invalid signature tag: ${St(t)}`); + if (t[1] !== t.length - 2) throw new Error("Invalid signature: incorrect length"); + const {data: n, left: e} = At(t.subarray(2)), {data: r, left: i} = At(e); + if (i.length) throw new Error(`Invalid signature: left bytes after parsing: ${St(i)}`); + return {r: n, s: r} + }(n ? t : It(t)); + return new xt(e, r) + } + + static fromHex(t) { + return this.fromDER(t) + } + + assertValidity() { + const {r: t, s: n} = this; + if (!$t(t)) throw new Error("Invalid Signature: r must be 0 < r < n"); + if (!$t(n)) throw new Error("Invalid Signature: s must be 0 < s < n") + } + + hasHighS() { + const t = rt.n >> Q; + return this.s > t + } + + normalizeS() { + return this.hasHighS() ? new xt(this.r, Tt(-this.s, rt.n)) : this + } + + toDERRawBytes() { + return It(this.toDERHex()) + } + + toDERHex() { + const t = bt(_t(this.s)), n = bt(_t(this.r)), e = t.length / 2, r = n.length / 2, i = _t(e), o = _t(r); + return `30${_t(r + e + 4)}02${o}${n}02${i}${t}` + } + + toRawBytes() { + return this.toDERRawBytes() + } + + toHex() { + return this.toDERHex() + } + + toCompactRawBytes() { + return It(this.toCompactHex()) + } + + toCompactHex() { + return Ot(this.r) + Ot(this.s) + } + } + + function Et(...t) { + if (!t.every((t => t instanceof Uint8Array))) throw new Error("Uint8Array list expected"); + if (1 === t.length) return t[0]; + const n = t.reduce(((t, n) => t + n.length), 0), e = new Uint8Array(n); + for (let n = 0, r = 0; n < t.length; n++) { + const i = t[n]; + e.set(i, r), r += i.length + } + return e + } + + const vt = Array.from({length: 256}, ((t, n) => n.toString(16).padStart(2, "0"))); + + function St(t) { + if (!(t instanceof Uint8Array)) throw new Error("Expected Uint8Array"); + let n = ""; + for (let e = 0; e < t.length; e++) n += vt[t[e]]; + return n + } + + const Pt = BigInt("0x10000000000000000000000000000000000000000000000000000000000000000"); + + function Ot(t) { + if ("bigint" != typeof t) throw new Error("Expected bigint"); + if (!(J <= t && t < Pt)) throw new Error("Expected number 0 <= n < 2^256"); + return t.toString(16).padStart(64, "0") + } + + function Ut(t) { + const n = It(Ot(t)); + if (32 !== n.length) throw new Error("Error: expected 32 bytes"); + return n + } + + function _t(t) { + const n = t.toString(16); + return 1 & n.length ? `0${n}` : n + } + + function Bt(t) { + if ("string" != typeof t) throw new TypeError("hexToNumber: expected string, got " + typeof t); + return BigInt(`0x${t}`) + } + + function It(t) { + if ("string" != typeof t) throw new TypeError("hexToBytes: expected string, got " + typeof t); + if (t.length % 2) throw new Error("hexToBytes: received invalid unpadded hex" + t.length); + const n = new Uint8Array(t.length / 2); + for (let e = 0; e < n.length; e++) { + const r = 2 * e, i = t.slice(r, r + 2), o = Number.parseInt(i, 16); + if (Number.isNaN(o) || o < 0) throw new Error("Invalid byte sequence"); + n[e] = o + } + return n + } + + function Ht(t) { + return Bt(St(t)) + } + + function zt(t) { + return t instanceof Uint8Array ? Uint8Array.from(t) : It(t) + } + + function Nt(t) { + if ("number" == typeof t && Number.isSafeInteger(t) && t > 0) return BigInt(t); + if ("bigint" == typeof t && $t(t)) return t; + throw new TypeError("Expected valid private scalar: 0 < scalar < curve.n") + } + + function Tt(t, n = rt.P) { + const e = t % n; + return e >= J ? e : n + e + } + + function Rt(t, n) { + const {P: e} = rt; + let r = t; + for (; n-- > J;) r *= r, r %= e; + return r + } + + function kt(t, n = rt.P) { + if (t === J || n <= J) throw new Error(`invert: expected positive integers, got n=${t} mod=${n}`); + let e = Tt(t, n), r = n, i = J, o = Q; + for (; e !== J;) { + const t = r % e, n = i - o * (r / e); + r = e, e = t, i = o, o = n + } + if (r !== Q) throw new Error("invert: does not exist"); + return Tt(i, n) + } + + function Ct(t, n = !1) { + const e = function (t) { + const n = 8 * t.length - 8 * at, e = Ht(t); + return n > 0 ? e >> BigInt(n) : e + }(t); + if (n) return e; + const {n: r} = rt; + return e >= r ? e - r : e + } + + let Dt, Kt; + + class jt { + constructor(t, n) { + if (this.hashLen = t, this.qByteLen = n, "number" != typeof t || t < 2) throw new Error("hashLen must be a number"); + if ("number" != typeof n || n < 2) throw new Error("qByteLen must be a number"); + this.v = new Uint8Array(t).fill(1), this.k = new Uint8Array(t).fill(0), this.counter = 0 + } + + hmac(...t) { + return ln.hmacSha256(this.k, ...t) + } + + hmacSync(...t) { + return Kt(this.k, ...t) + } + + checkSync() { + if ("function" != typeof Kt) throw new dt("hmacSha256Sync needs to be set") + } + + incr() { + if (this.counter >= 1e3) throw new Error("Tried 1,000 k values for sign(), all were invalid"); + this.counter += 1 + } + + async reseed(t = new Uint8Array) { + this.k = await this.hmac(this.v, Uint8Array.from([0]), t), this.v = await this.hmac(this.v), 0 !== t.length && (this.k = await this.hmac(this.v, Uint8Array.from([1]), t), this.v = await this.hmac(this.v)) + } + + reseedSync(t = new Uint8Array) { + this.checkSync(), this.k = this.hmacSync(this.v, Uint8Array.from([0]), t), this.v = this.hmacSync(this.v), 0 !== t.length && (this.k = this.hmacSync(this.v, Uint8Array.from([1]), t), this.v = this.hmacSync(this.v)) + } + + async generate() { + this.incr(); + let t = 0; + const n = []; + for (; t < this.qByteLen;) { + this.v = await this.hmac(this.v); + const e = this.v.slice(); + n.push(e), t += this.v.length + } + return Et(...n) + } + + generateSync() { + this.checkSync(), this.incr(); + let t = 0; + const n = []; + for (; t < this.qByteLen;) { + this.v = this.hmacSync(this.v); + const e = this.v.slice(); + n.push(e), t += this.v.length + } + return Et(...n) + } + } + + function $t(t) { + return J < t && t < rt.n + } + + function Vt(t) { + return J < t && t < rt.P + } + + function Lt(t, n, e, r = !0) { + const {n: i} = rt, o = Ct(t, !0); + if (!$t(o)) return; + const s = kt(o, i), a = mt.BASE.multiply(o), c = Tt(a.x, i); + if (c === J) return; + const u = Tt(s * Tt(n + e * c, i), i); + if (u === J) return; + let f = new xt(c, u), h = (a.x === f.r ? 0 : 2) | Number(a.y & Q); + return r && f.hasHighS() && (f = f.normalizeS(), h ^= 1), {sig: f, recovery: h} + } + + function qt(t) { + let n; + if ("bigint" == typeof t) n = t; else if ("number" == typeof t && Number.isSafeInteger(t) && t > 0) n = BigInt(t); else if ("string" == typeof t) { + if (t.length !== 2 * at) throw new Error("Expected 32 bytes of private key"); + n = Bt(t) + } else { + if (!(t instanceof Uint8Array)) throw new TypeError("Expected valid private key"); + if (t.length !== at) throw new Error("Expected 32 bytes of private key"); + n = Ht(t) + } + if (!$t(n)) throw new Error("Expected private key: 0 < key < n"); + return n + } + + function Ft(t) { + return t instanceof mt ? (t.assertValidity(), t) : mt.fromHex(t) + } + + function Mt(t) { + if (t instanceof xt) return t.assertValidity(), t; + try { + return xt.fromDER(t) + } catch (n) { + return xt.fromCompact(t) + } + } + + function Yt(t) { + const n = t instanceof Uint8Array, e = "string" == typeof t, r = (n || e) && t.length; + return n ? r === ut || r === ft : e ? r === 2 * ut || r === 2 * ft : t instanceof mt + } + + function Zt(t, n, e = !1) { + if (Yt(t)) throw new TypeError("getSharedSecret: first arg must be private key"); + if (!Yt(n)) throw new TypeError("getSharedSecret: second arg must be public key"); + const r = Ft(n); + return r.assertValidity(), r.multiply(qt(t)).toRawBytes(e) + } + + function Wt(t) { + return Ht(t.length > st ? t.slice(0, st) : t) + } + + function Gt(t) { + const n = Wt(t), e = Tt(n, rt.n); + return Xt(e < J ? n : e) + } + + function Xt(t) { + return Ut(t) + } + + function Jt(t, n, e) { + if (null == t) throw new Error(`sign: expected valid message hash, not "${t}"`); + const r = zt(t), i = qt(n), o = [Xt(i), Gt(r)]; + if (null != e) { + !0 === e && (e = ln.randomBytes(st)); + const t = zt(e); + if (t.length !== st) throw new Error(`sign: Expected ${st} bytes of extra data`); + o.push(t) + } + return {seed: Et(...o), m: Wt(r), d: i} + } + + function Qt(t, n) { + const {sig: e, recovery: r} = t, {der: i, recovered: o} = Object.assign({canonical: !0, der: !0}, n), + s = i ? e.toDERRawBytes() : e.toCompactRawBytes(); + return o ? [s, r] : s + } + + const tn = {strict: !0}; + + function nn(t) { + return Tt(Ht(t), rt.n) + } + + class en { + constructor(t, n) { + this.r = t, this.s = n, this.assertValidity() + } + + static fromHex(t) { + const n = zt(t); + if (64 !== n.length) throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${n.length}`); + const e = Ht(n.subarray(0, 32)), r = Ht(n.subarray(32, 64)); + return new en(e, r) + } + + assertValidity() { + const {r: t, s: n} = this; + if (!Vt(t) || !$t(n)) throw new Error("Invalid signature") + } + + toHex() { + return Ot(this.r) + Ot(this.s) + } + + toRawBytes() { + return It(this.toHex()) + } + } + + class rn { + constructor(t, n, e = ln.randomBytes()) { + if (null == t) throw new TypeError(`sign: Expected valid message, not "${t}"`); + this.m = zt(t); + const {x: r, scalar: i} = this.getScalar(qt(n)); + if (this.px = r, this.d = i, this.rand = zt(e), 32 !== this.rand.length) throw new TypeError("sign: Expected 32 bytes of aux randomness") + } + + getScalar(t) { + const n = mt.fromPrivateKey(t), e = n.hasEvenY() ? t : rt.n - t; + return {point: n, scalar: e, x: n.toRawX()} + } + + initNonce(t, n) { + return Ut(t ^ Ht(n)) + } + + finalizeNonce(t) { + const n = Tt(Ht(t), rt.n); + if (n === J) throw new Error("sign: Creation of signature failed. k is zero"); + const {point: e, x: r, scalar: i} = this.getScalar(n); + return {R: e, rx: r, k: i} + } + + finalizeSig(t, n, e, r) { + return new en(t.x, Tt(n + e * r, rt.n)).toRawBytes() + } + + error() { + throw new Error("sign: Invalid signature produced") + } + + async calc() { + const {m: t, d: n, px: e, rand: r} = this, i = ln.taggedHash, o = this.initNonce(n, await i(fn.aux, r)), { + R: s, + rx: a, + k: c + } = this.finalizeNonce(await i(fn.nonce, o, e, t)), u = nn(await i(fn.challenge, a, e, t)), + f = this.finalizeSig(s, c, u, n); + return await an(f, t, e) || this.error(), f + } + + calcSync() { + const {m: t, d: n, px: e, rand: r} = this, i = ln.taggedHashSync, + o = this.initNonce(n, i(fn.aux, r)), {R: s, rx: a, k: c} = this.finalizeNonce(i(fn.nonce, o, e, t)), + u = nn(i(fn.challenge, a, e, t)), f = this.finalizeSig(s, c, u, n); + return cn(f, t, e) || this.error(), f + } + } + + function on(t, n, e) { + const r = t instanceof en, i = r ? t : en.fromHex(t); + return r && i.assertValidity(), {...i, m: zt(n), P: Ft(e)} + } + + function sn(t, n, e, r) { + const i = mt.BASE.multiplyAndAddUnsafe(n, qt(e), Tt(-r, rt.n)); + return !(!i || !i.hasEvenY() || i.x !== t) + } + + async function an(t, n, e) { + try { + const {r: r, s: i, m: o, P: s} = on(t, n, e), + a = nn(await ln.taggedHash(fn.challenge, Ut(r), s.toRawX(), o)); + return sn(r, s, i, a) + } catch (t) { + return !1 + } + } + + function cn(t, n, e) { + try { + const {r: r, s: i, m: o, P: s} = on(t, n, e), a = nn(ln.taggedHashSync(fn.challenge, Ut(r), s.toRawX(), o)); + return sn(r, s, i, a) + } catch (t) { + if (t instanceof dt) throw t; + return !1 + } + } + + const un = { + Signature: en, getPublicKey: function (t) { + return mt.fromPrivateKey(t).toRawX() + }, sign: async function (t, n, e) { + return new rn(t, n, e).calc() + }, verify: an, signSync: function (t, n, e) { + return new rn(t, n, e).calcSync() + }, verifySync: cn + }; + mt.BASE._setWindowSize(8); + const fn = {challenge: "BIP0340/challenge", aux: "BIP0340/aux", nonce: "BIP0340/nonce"}, hn = {}, ln = { + bytesToHex: St, + hexToBytes: It, + concatBytes: Et, + mod: Tt, + invert: kt, + isValidPrivateKey(t) { + try { + return qt(t), !0 + } catch (t) { + return !1 + } + }, + _bigintTo32Bytes: Ut, + _normalizePrivateKey: qt, + hashToPrivateKey: t => { + t = zt(t); + const n = at + 8; + if (t.length < n || t.length > 1024) throw new Error("Expected valid bytes of private key as per FIPS 186"); + return Ut(Tt(Ht(t), rt.n - Q) + Q) + }, + randomBytes: (t = 32) => X.getRandomValues(new Uint8Array(t)), + randomPrivateKey: () => ln.hashToPrivateKey(ln.randomBytes(at + 8)), + precompute(t = 8, n = mt.BASE) { + const e = n === mt.BASE ? n : new mt(n.x, n.y); + return e._setWindowSize(t), e.multiply(nt), e + }, + sha256: async (...t) => { + const n = await X.subtle.digest("SHA-256", Et(...t)); + return new Uint8Array(n) + }, + hmacSha256: async (t, ...n) => { + const e = await X.subtle.importKey("raw", t, {name: "HMAC", hash: {name: "SHA-256"}}, !1, ["sign"]), + r = Et(...n), i = await X.subtle.sign("HMAC", e, r); + return new Uint8Array(i) + }, + sha256Sync: void 0, + hmacSha256Sync: void 0, + taggedHash: async (t, ...n) => { + let e = hn[t]; + if (void 0 === e) { + const n = await ln.sha256(Uint8Array.from(t, (t => t.charCodeAt(0)))); + e = Et(n, n), hn[t] = e + } + return ln.sha256(e, ...n) + }, + taggedHashSync: (t, ...n) => { + if ("function" != typeof Dt) throw new dt("sha256Sync is undefined, you need to set it"); + let e = hn[t]; + if (void 0 === e) { + const n = Dt(Uint8Array.from(t, (t => t.charCodeAt(0)))); + e = Et(n, n), hn[t] = e + } + return Dt(e, ...n) + }, + _JacobianPoint: yt + }; + Object.defineProperties(ln, { + sha256Sync: { + configurable: !1, get: () => Dt, set(t) { + Dt || (Dt = t) + } + }, hmacSha256Sync: { + configurable: !1, get: () => Kt, set(t) { + Kt || (Kt = t) + } + } + }); + var dn = Object.freeze({ + __proto__: null, CURVE: rt, Point: mt, Signature: xt, getPublicKey: function (t, n = !1) { + return mt.fromPrivateKey(t).toRawBytes(n) + }, getSharedSecret: Zt, recoverPublicKey: function (t, n, e, r = !1) { + return mt.fromSignature(t, n, e).toRawBytes(r) + }, schnorr: un, sign: async function (t, n, e = {}) { + const {seed: r, m: i, d: o} = Jt(t, n, e.extraEntropy), s = new jt(ct, at); + let a; + for (await s.reseed(r); !(a = Lt(await s.generate(), i, o, e.canonical));) await s.reseed(); + return Qt(a, e) + }, signSync: function (t, n, e = {}) { + const {seed: r, m: i, d: o} = Jt(t, n, e.extraEntropy), s = new jt(ct, at); + let a; + for (s.reseedSync(r); !(a = Lt(s.generateSync(), i, o, e.canonical));) s.reseedSync(); + return Qt(a, e) + }, utils: ln, verify: function (t, n, e, r = tn) { + let i; + try { + i = Mt(t), n = zt(n) + } catch (t) { + return !1 + } + const {r: o, s: s} = i; + if (r.strict && i.hasHighS()) return !1; + const a = Ct(n); + let c; + try { + c = Ft(e) + } catch (t) { + return !1 + } + const {n: u} = rt, f = kt(s, u), h = Tt(a * f, u), l = Tt(o * f, u), + d = mt.BASE.multiplyAndAddUnsafe(c, h, l); + return !!d && Tt(d.x, u) === o + } + }); + const wn = new TextEncoder, + yn = [{name: "base58", charset: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"}, { + name: "base64", + charset: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" + }, {name: "base64url", charset: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"}]; + + function gn(t) { + for (const n of yn) if (n.name === t) return n.charset; + throw TypeError("Charset does not exist: " + t) + } + + const pn = { + encode: function (t, n, e = !1) { + "string" == typeof t && (t = wn.encode(t)); + const r = gn(n), i = r.length, o = []; + let s, a, c, u = "", f = 0; + for (s = 0; s < t.length; s++) for (f = 0, a = t[s], u += a > 0 || (u.length ^ s) > 0 ? "" : "1"; f in o || a > 0;) c = o[f], c = c > 0 ? 256 * c + a : a, a = c / i | 0, o[f] = c % i, f++; + for (; f-- > 0;) u += r[o[f]]; + return e && u.length % 4 > 0 ? u + "=".repeat(4 - u.length % 4) : u + }, decode: function (t, n) { + const e = gn(n), r = e.length, i = [], o = []; + t = t.replace("=", ""); + let s, a, c, u = 0; + for (s = 0; s < t.length; s++) { + if (u = 0, a = e.indexOf(t[s]), a < 0) throw new Error(`Character range out of bounds: ${a}`); + for (a > 0 || (o.length ^ s) > 0 || o.push(0); u in i || a > 0;) c = i[u], c = c > 0 ? c * r + a : a, a = c >> 8, i[u] = c % 256, u++ + } + for (; u-- > 0;) o.push(i[u]); + return new Uint8Array(o) + } + }, mn = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", bn = [996825010, 642813549, 513874426, 1027748829, 705979059], + An = {BECH32: "bech32", BECH32M: "bech32m"}; + + function xn(t) { + switch (t) { + case An.BECH32: + return 1; + case An.BECH32M: + return 734539939; + default: + throw new Error(`Unrecognized encoding: ${t}`) + } + } + + function En(t) { + let n = 1; + for (let e = 0; e < t.length; ++e) { + const r = n >> 25; + n = (33554431 & n) << 5 ^ t[e]; + for (let t = 0; t < 5; ++t) (r >> t & 1) > 0 && (n ^= bn[t]) + } + return n + } + + function vn(t) { + const n = []; + let e; + for (e = 0; e < t.length; ++e) n.push(t.charCodeAt(e) >> 5); + for (n.push(0), e = 0; e < t.length; ++e) n.push(31 & t.charCodeAt(e)); + return n + } + + function Sn(t, n, e, r = !0) { + const i = []; + let o = 0, s = 0; + const a = (1 << e) - 1, c = (1 << n + e - 1) - 1; + for (const r of t) { + if (r < 0 || r >> n > 0) return []; + for (o = (o << n | r) & c, s += n; s >= e;) s -= e, i.push(o >> s & a) + } + if (r) s > 0 && i.push(o << e - s & a); else if (s >= n || (o << e - s & a) > 0) return []; + return i + } + + function Pn(t, n, e) { + const r = n.concat(function (t, n, e) { + const r = En(vn(t).concat(n).concat([0, 0, 0, 0, 0, 0])) ^ xn(e), i = []; + for (let t = 0; t < 6; ++t) i.push(r >> 5 * (5 - t) & 31); + return i + }(t, n, e)); + let i = t + "1"; + for (let t = 0; t < r.length; ++t) i += mn.charAt(r[t]); + return i + } + + function On(t, n) { + const e = n > 0 ? "bech32m" : "bech32"; + if (!function (t) { + let n, e, r = !1, i = !1; + for (n = 0; n < t.length; ++n) { + if (e = t.charCodeAt(n), e < 33 || e > 126) return !1; + e >= 97 && e <= 122 && (r = !0), e >= 65 && e <= 90 && (i = !0) + } + return !(r && i) + }(t)) return {hrp: null, data: [255]}; + if (!function (t) { + const n = t.lastIndexOf("1"); + return !(n < 1 || n + 7 > t.length || t.length > 90) + }(t = t.toLowerCase())) return {hrp: null, data: [255]}; + const r = [], i = t.lastIndexOf("1"), o = t.substring(0, i); + for (let n = i + 1; n < t.length; ++n) { + const e = mn.indexOf(t.charAt(n)); + if (-1 === e) return {hrp: null, data: [255]}; + r.push(e) + } + return function (t, n, e) { + return En(vn(t).concat(n)) === xn(e) + }(o, r, e) ? {hrp: o, data: r.slice(0, r.length - 6)} : {hrp: null, data: [255]} + } + + function Un(t, n = 0) { + const e = t.split("1", 1)[0], {hrp: r, data: i} = On(t, n), o = Sn(i.slice(1), 5, 8, !1), s = o.length; + switch (!0) { + case e !== r: + throw new Error("Returned hrp string is invalid."); + case null === o || s < 2 || s > 40: + throw new Error("Decoded string is invalid or out of spec."); + case i[0] > 16: + throw new Error("Returned version bit is out of range."); + case 0 === i[0] && 20 !== s && 32 !== s: + throw new Error("Decoded string does not match version 0 spec."); + case 0 === i[0] && 0 !== n: + case 0 !== i[0] && 1 !== n: + throw new Error("Decoded version bit does not match."); + default: + return Uint8Array.from(o) + } + } + + const _n = { + encode: function (t, n = "bch", e = 0) { + const r = Pn(n, [e, ...Sn([...t], 8, 5)], e > 0 ? "bech32m" : "bech32"); + return Un(r, e), r + }, decode: Un + }, Bn = new TextEncoder, In = new TextDecoder; + + function Hn(t) { + return Bn.encode(t) + } + + function zn(t) { + const n = []; + let e, r = 0; + if (t.length % 2 > 0) throw new Error(`Invalid hex string length: ${t.length}`); + for (e = 0; e < t.length; e += 2) n[r] = parseInt(t.slice(e, e + 2), 16), r += 1; + return Uint8Array.from(n) + } + + function Nn(t) { + const n = []; + for (; t > 0;) { + const e = 255 & t; + n.push(e), t = (t - e) / 256 + } + return Uint8Array.from(n) + } + + function Tn(t) { + const n = []; + for (; t > 0n;) { + const e = 0xffn & t; + n.push(Number(e)), t = (t - e) / 256n + } + return Uint8Array.from(n) + } + + function Rn(t) { + return In.decode(t) + } + + function kn(t) { + let n, e = 0; + for (n = t.length - 1; n >= 0; n--) e = 256 * e + t[n]; + return Number(e) + } + + function Cn(t) { + let n, e = 0n; + for (n = t.length - 1; n >= 0; n--) e = 256n * e + BigInt(t[n]); + return BigInt(e) + } + + async function Dn(t) { + return crypto.subtle.digest("SHA-256", t).then((t => new Uint8Array(t))) + } + + async function Kn(t) { + return Dn(await Dn(t)) + } + + const {crypto: jn} = globalThis; + + class $n extends Uint8Array { + static { + this.num = (t, n, e = "le") => new $n(Nn(t), n, e) + } + static { + this.big = (t, n, e = "le") => new $n(Tn(t), n, e) + } + + static async b58check(t) { + const n = pn.decode(t, "base58"); + return new $n(await async function (t) { + const n = t.slice(0, -4), e = t.slice(-4); + if ((await Kn(n)).slice(0, 4).toString() !== e.toString()) throw new Error("Invalid checksum!"); + return n + }(n)) + } + + static { + this.buff = (t, n) => new $n(function (t) { + if (t instanceof ArrayBuffer) return new Uint8Array(t); + if (t instanceof Uint8Array) return t; + const n = typeof t; + switch (n) { + case"bigint": + return Tn(t); + case"boolean": + return Uint8Array.of(t); + case"number": + return Nn(t); + case"string": + return null !== t.match(/^(02|03)*[0-9a-fA-F]{64}$/) ? zn(t) : Bn.encode(t); + default: + throw TypeError("Unsupported format:" + n) + } + }(t), n) + } + static { + this.raw = (t, n) => new $n(t, n) + } + static { + this.str = (t, n) => new $n(Hn(t), n) + } + static { + this.hex = (t, n) => new $n(zn(t), n) + } + static { + this.json = t => new $n(Hn(JSON.stringify(t))) + } + static { + this.base64 = t => new $n(pn.decode(t, "base64")) + } + static { + this.b64url = t => new $n(pn.decode(t, "base64url")) + } + static { + this.bech32 = (t, n) => new $n(_n.decode(t, n)) + } + + constructor(t, n = null, e = "be") { + if (null !== n) { + const e = new Uint8Array(n).fill(0); + e.set(new Uint8Array(t)), t = e.buffer + } + return super(t = "le" === e ? new Uint8Array(t).reverse() : t), this + } + + get num() { + return this.toNum() + } + + get big() { + return this.toBig() + } + + get arr() { + return this.toArr() + } + + get str() { + return this.toStr() + } + + get hex() { + return this.toHex() + } + + get raw() { + return new Uint8Array(this) + } + + get hash() { + return this.toHash() + } + + get id() { + return this.toHash().then((t => new $n(t).hex)) + } + + toNum(t = "le") { + return kn("le" === t ? this.reverse() : this) + } + + toBig(t = "le") { + return Cn("le" === t ? this.reverse() : this) + } + + async toHash() { + return jn.subtle.digest("SHA-256", this.raw).then((t => new Uint8Array(t))) + } + + async tob58check() { + return pn.encode(await async function (t) { + const n = await Kn(t); + return Uint8Array.of(...t, ...n.slice(0, 4)) + }(this), "base58") + } + + toArr() { + return Array.from(this) + } + + toStr() { + return Rn(this) + } + + toHex() { + return function (t) { + const n = []; + let e; + for (e = 0; e < t.length; e++) n.push(t[e].toString(16).padStart(2, "0")); + return n.join("") + }(this) + } + + toJson() { + return JSON.parse(Rn(this)) + } + + toBytes() { + return new Uint8Array(this) + } + + toB64url() { + return pn.encode(this, "base64url") + } + + toBase64(t) { + return pn.encode(this, "base64", t) + } + + toBech32(t, n) { + return _n.encode(this, t, n) + } + + prepend(t) { + return $n.of(...t, ...this) + } + + append(t) { + return $n.of(...this, ...t) + } + + slice(t, n) { + return new $n(new Uint8Array(this).slice(t, n)) + } + + reverse() { + return new $n(new Uint8Array(this).reverse()) + } + + write(t, n) { + this.set(t, n) + } + + prependVarint(t = this.length) { + return $n.of(...$n.readVarint(t), ...this) + } + + static from(t) { + return new $n(Uint8Array.from(t)) + } + + static of(...t) { + return new $n(Uint8Array.of(...t)) + } + + static join(t) { + let n, e = 0; + const r = t.reduce(((t, n) => t + n.length), 0), i = new Uint8Array(r); + for (const r of t) for (n = 0; n < r.length; e++, n++) i[e] = r[n]; + return new $n(i, r) + } + + static readVarint(t) { + if (t < 253) return $n.num(t, 1); + if (t < 65536) return $n.of(253, ...$n.num(t, 2)); + if (t < 4294967296) return $n.of(254, ...$n.num(t, 4)); + if (t < 0x10000000000000000) return $n.of(255, ...$n.num(t, 8)); + throw new Error(`Value is too large: ${t}`) + } + + static random(t = 32) { + return new $n(jn.getRandomValues(new Uint8Array(t))) + } + + static { + this.encode = Hn + } + static { + this.decode = Rn + } + + static normalize(t, n) { + if (t instanceof Uint8Array) return t; + if ("string" == typeof t) return $n.hex(t, n).toBytes(); + if ("number" == typeof t) return $n.num(t, n).toBytes(); + if ("bigint" == typeof t) return $n.big(t, n).toBytes(); + throw TypeError("Unrecognized format: " + typeof t) + } + + static serialize(t) { + if ("string" == typeof t) return $n.str(t).toBytes(); + if ("object" == typeof t) { + if (t instanceof Uint8Array) return t; + try { + return $n.json(t).toBytes() + } catch { + throw TypeError("Object is not serializable.") + } + } + throw TypeError("Unrecognized format: " + typeof t) + } + + static revitalize(t) { + if (t instanceof Uint8Array && (t = Rn(t)), "string" == typeof t) try { + return JSON.parse(t) + } catch { + return t + } + return t + } + } + + const Vn = globalThis.crypto; + + async function Ln(t, n) { + return Zt($n.normalize(t), $n.normalize(n), !0) + } + + async function qn(t) { + return Vn.subtle.importKey("raw", $n.normalize(t), {name: "AES-CBC"}, !0, ["encrypt", "decrypt"]) + } + + const Fn = { + ecdh: Ln, import: qn, export: async function (t) { + return Vn.subtle.exportKey("raw", t).then((t => new Uint8Array(t))) + }, hmac: async function (t, n = "SHA-256") { + const e = {name: "HMAC", hash: n}; + return Vn.subtle.importKey("raw", $n.normalize(t), e, !1, ["sign", "verify"]) + }, shared: async function (t, n) { + return qn((await Ln(t, n)).slice(1, 33)) + }, generate: async function () { + return qn($n.random(32)) + }, normalize: async function (t) { + return t instanceof CryptoKey ? t : Fn.import(t) + } + }; + + class Mn extends Uint8Array { + static { + this.N = rt.n + } + + static mod(t, n = Mn.N) { + return ln.mod(t, n) + } + + static { + this.isField = t => t instanceof Mn + } + + static normalize(t) { + return t = Zn(t), t = Mn.mod(t), t = ln._normalizePrivateKey(t), $n.big(t, 32).raw + } + + static validate(t) { + return ln.isValidPrivateKey(t) + } + + constructor(t) { + super(t = Mn.normalize(t)) + } + + get buff() { + return new $n(this) + } + + get raw() { + return this + } + + get num() { + return this.buff.toBig() + } + + get point() { + return Yn.fromNum(this.num) + } + + get hasOddY() { + return this.point.hasOddY + } + + get negated() { + return this.hasOddY ? this.negate() : this + } + + gt(t) { + return new Mn(t).num > this.num + } + + lt(t) { + return new Mn(t).num < this.num + } + + eq(t) { + return new Mn(t).num === this.num + } + + ne(t) { + return new Mn(t).num !== this.num + } + + add(t) { + const n = new Mn(t); + return new Mn(this.num + n.num) + } + + sub(t) { + const n = new Mn(t); + return new Mn(this.num - n.num) + } + + mul(t) { + const n = new Mn(t); + return new Mn(this.num * n.num) + } + + pow(t, n = Mn.N - 1n) { + const e = new Mn(t), r = Mn.mod(e.num, n); + return new Mn(this.num ** r) + } + + div(t) { + const n = new Mn(t), e = this.pow(n.num, Mn.N - 2n); + return new Mn(this.num * e.num) + } + + negate() { + return new Mn(Mn.N - this.num) + } + } + + class Yn { + static { + this.N = rt.n + } + + static validate(t) { + try { + t = Zn(t); + const n = $n.big(t).toHex(); + return mt.fromHex(n).assertValidity(), !0 + } catch { + return !1 + } + } + + static fromNum(t) { + t = Zn(t); + const n = ln.mod(t, Yn.N), e = mt.BASE.multiply(n); + return new Yn(e.x, e.y) + } + + static fromX(t) { + t = Zn(t); + const n = $n.big(t).toHex(); + return Yn.from(mt.fromHex(n)) + } + + static from(t) { + return new Yn(t.x, t.y) + } + + constructor(t, n) { + this.__p = new mt(t, n), this.__x = this.__p.x, this.__y = this.__p.y, this.__p.assertValidity() + } + + get p() { + return this.__p + } + + get buff() { + return new $n(this.rawX.slice(1)) + } + + get hex() { + return this.buff.hex + } + + get hasOddY() { + return !this.__p.hasEvenY() + } + + get rawX() { + const t = this.__p.hasEvenY() ? 2 : 3, n = $n.big(this.__x); + return Uint8Array.of(t, ...n) + } + + get rawY() { + return $n.big(this.__y) + } + + get x() { + return this.__x + } + + get y() { + return this.__y + } + + eq(t) { + return t instanceof Yn ? this.p.equals(new mt(t.x, t.y)) : t instanceof Uint8Array ? this.x.toString() === t.toString() : "number" == typeof t ? BigInt(t) === this.x : t === this.x + } + + add(t) { + return t instanceof Yn ? Yn.from(this.p.add(t.p)) : Yn.from(this.p.add(Yn.fromNum(t).p)) + } + + sub(t) { + return t instanceof Yn ? Yn.from(this.p.subtract(t.p)) : Yn.from(this.p.subtract(Yn.fromNum(t).p)) + } + + mul(t) { + return t instanceof Yn ? Yn.from(this.p.multiply(t.x)) : Yn.from(this.p.multiply(Zn(t))) + } + + negate() { + return Yn.from(this.__p.negate()) + } + } + + function Zn(t) { + if (t instanceof Uint8Array) return $n.raw(t).big; + if ("string" == typeof t) return $n.hex(t).big; + if ("number" == typeof t) return BigInt(t); + if ("bigint" == typeof t) return t; + throw TypeError("Invalid input type:" + typeof t) + } + + function Wn(t) { + let n = 0n; + for (let e = t.length - 1; e >= 0; e--) n = 256n * n + BigInt(t[e]); + return BigInt(n) + } + + function Gn(t, n = 0) { + const e = []; + for (; t > 0;) { + const n = 0xffn & t; + e.push(n), t = (t - n) / 256n + } + let r = Uint8Array.from(e.map((t => Number(t)))); + if (0 !== n) { + const t = new Uint8Array(n); + t.set(r), r = t + } + return r + } + + const Xn = [0n, 1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 10n, 11n, 12n, 13n, 14n, 15n, 7n, 4n, 13n, 1n, 10n, 6n, 15n, 3n, 12n, 0n, 9n, 5n, 2n, 14n, 11n, 8n, 3n, 10n, 14n, 4n, 9n, 15n, 8n, 1n, 2n, 7n, 0n, 6n, 13n, 11n, 5n, 12n, 1n, 9n, 11n, 10n, 0n, 8n, 12n, 4n, 13n, 3n, 7n, 15n, 14n, 5n, 6n, 2n, 4n, 0n, 5n, 9n, 7n, 12n, 2n, 10n, 14n, 1n, 3n, 8n, 11n, 6n, 15n, 13n], + Jn = [5n, 14n, 7n, 0n, 9n, 2n, 11n, 4n, 13n, 6n, 15n, 8n, 1n, 10n, 3n, 12n, 6n, 11n, 3n, 7n, 0n, 13n, 5n, 10n, 14n, 15n, 8n, 12n, 4n, 9n, 1n, 2n, 15n, 5n, 1n, 3n, 7n, 14n, 6n, 9n, 11n, 8n, 12n, 2n, 10n, 0n, 4n, 13n, 8n, 6n, 4n, 1n, 3n, 11n, 15n, 0n, 5n, 12n, 2n, 13n, 9n, 7n, 10n, 14n, 12n, 15n, 10n, 4n, 1n, 5n, 8n, 7n, 6n, 2n, 13n, 14n, 0n, 3n, 9n, 11n], + Qn = [11n, 14n, 15n, 12n, 5n, 8n, 7n, 9n, 11n, 13n, 14n, 15n, 6n, 7n, 9n, 8n, 7n, 6n, 8n, 13n, 11n, 9n, 7n, 15n, 7n, 12n, 15n, 9n, 11n, 7n, 13n, 12n, 11n, 13n, 6n, 7n, 14n, 9n, 13n, 15n, 14n, 8n, 13n, 6n, 5n, 12n, 7n, 5n, 11n, 12n, 14n, 15n, 14n, 15n, 9n, 8n, 9n, 14n, 5n, 6n, 8n, 6n, 5n, 12n, 9n, 15n, 5n, 11n, 6n, 8n, 13n, 12n, 5n, 12n, 13n, 14n, 11n, 8n, 5n, 6n], + te = [8n, 9n, 9n, 11n, 13n, 15n, 15n, 5n, 7n, 7n, 8n, 11n, 14n, 14n, 12n, 6n, 9n, 13n, 15n, 7n, 12n, 8n, 9n, 11n, 7n, 7n, 12n, 7n, 6n, 15n, 13n, 11n, 9n, 7n, 15n, 11n, 8n, 6n, 6n, 14n, 12n, 13n, 5n, 14n, 13n, 13n, 7n, 5n, 15n, 5n, 8n, 11n, 14n, 14n, 6n, 14n, 6n, 9n, 12n, 9n, 12n, 5n, 15n, 8n, 8n, 5n, 12n, 9n, 12n, 5n, 14n, 6n, 8n, 13n, 6n, 5n, 15n, 13n, 11n, 11n], + ne = [0n, 0x5a827999n, 0x6ed9eba1n, 0x8f1bbcdcn, 0xa953fd4en], + ee = [0x50a28be6n, 0x5c4dd124n, 0x6d703ef3n, 0x7a6d76e9n, 0n]; + + function re(t, n, e, r) { + switch (!0) { + case 0n === r: + return t ^ n ^ e; + case 1n === r: + return t & n | ~t & e; + case 2n === r: + return (t | ~n) ^ e; + case 3n === r: + return t & e | n & ~e; + case 4n === r: + return t ^ (n | ~e); + default: + throw new TypeError("Unknown I value: " + String(r)) + } + } + + function ie(t, n) { + return 0xffffffffn & (t << n | (0xffffffffn & t) >> 32n - n) + } + + function oe(t, n, e, r, i, o) { + const s = []; + let a, c, u, f, h, l, d, w = t, y = n, g = e, p = r, m = i, b = t, A = n, x = e, E = r, v = i; + for (let t = 0; t < 16; t++) { + const n = Wn(o.slice(4 * t, 4 * (t + 1))); + s.push(n) + } + for (let t = 0; t < 80; t++) a = BigInt(t) >> 4n, f = s[Number(Xn[t])], h = ne[Number(a)], l = s[Number(Jn[t])], d = ee[Number(a)], w = ie(w + re(y, g, p, a) + f + h, Qn[t]) + m, c = m, m = p, p = ie(g, 10n), g = y, y = w, w = c, b = ie(b + re(A, x, E, 4n - a) + l + d, te[t]) + v, u = v, v = E, E = ie(x, 10n), x = A, A = b, b = u; + return [n + g + E, e + p + v, r + m + b, i + w + A, t + y + x] + } + + const se = globalThis.crypto; + + async function ae(t, n = "SHA-256", e = 1, r = (t => t)) { + let i, o = t instanceof ArrayBuffer ? t : $n.normalize(t).buffer; + for (i = 0; i < e; i++) o = await se.subtle.digest(n, o), r(o); + return new Uint8Array(o) + } + + async function ce(t) { + return ae(t, "SHA-256") + } + + function ue(t) { + return function (t) { + let n = [0x67452301n, 0xefcdab89n, 0x98badcfen, 0x10325476n, 0xc3d2e1f0n]; + for (let e = 0; e < t.length >> 6; e++) n = oe(...n, t.slice(64 * e, 64 * (e + 1))); + const e = [128, ...new Array(119 - t.length & 63).fill(0)], + r = Uint8Array.from([...t.slice(-64 & t.length), ...e, ...Gn(BigInt(8 * t.length), 8)]); + for (let t = 0; t < r.length >> 6; t++) n = oe(...n, r.slice(64 * t, 64 * (t + 1))); + const i = []; + for (let t = 0; t < n.length; t++) { + const e = 0xffffffffn & n[t]; + i.push(...Gn(e, 4)) + } + return Uint8Array.from(i) + }(t = $n.normalize(t)) + } + + const fe = { + data: async function (t) { + return ce($n.serialize(t)).then((t => new Uint8Array(t))) + }, digest: ae, ripe160: ue, sha256: ce, sha512: async function (t) { + return ae(t, "SHA-512") + }, hash160: async function (t) { + return ue(await ce(t)) + }, hash256: async function (t) { + return ae(t, "SHA-256", 2) + }, hmac256: async function (t, n) { + const e = await Fn.hmac(t, "SHA-256"); + return se.subtle.sign("HMAC", e, $n.normalize(n)).then((t => new Uint8Array(t))) + }, hmac512: async function (t, n) { + const e = await Fn.hmac(t, "SHA-512"); + return se.subtle.sign("HMAC", e, $n.normalize(n)).then((t => new Uint8Array(t))) + } + }, he = [1, 2, 3, 129, 130, 131]; + + function le(t, n) { + if (n) throw new Error(t); + return !1 + } + + const de = 192, we = new TextEncoder; + + function ye(t, n) { + let e = new Mn(t); + return e.point.hasOddY && (e = e.negate()), e.add(n) + } + + function ge(t, n) { + return Yn.fromX(t).add(n).rawX + } + + async function pe(t, n = [], e = !1) { + const r = _.normalize(t), i = n.length > 0 ? await me(n) : new Uint8Array, + o = e ? dn.getPublicKey(r, !0).slice(1) : r, s = await Ee(o, i); + if (e) return [_.raw(ye(r, s)).hex, 0]; + { + const t = _.raw(ge(r, s)); + return [t.slice(1).hex, t.slice(0, 1).num] + } + } + + async function me(t) { + return Se(t).then((t => _.hex(t[0]))) + } + + async function be(t) { + const n = await fe.sha256(we.encode(t)); + return Uint8Array.of(...n, ...n) + } + + // Rarity Garden Hack + async function Ae(t, n = de) { + + let leafed = await be("TapLeaf"); + const uint8 = new Uint8Array(leafed.length); + + for(let i = 0; i < leafed.length; i++) + { + uint8[i] = leafed[i]; + } + + let tn = function (t = 192) { + return 254 & t + }(n); + + const uint8_tn = new Uint8Array(1); + uint8_tn[0] = tn; + + let normed = _.normalize(t); + const uint8_normed = new Uint8Array(normed.length); + + for(let i = 0; i < uint8_normed.length; i++) + { + uint8_normed[i] = normed[i]; + } + + var uint8_new = new Uint8Array(uint8.length + uint8_normed.length + uint8_tn.length); + uint8_new.set(uint8); + uint8_new.set(uint8_tn, uint8.length); + uint8_new.set(uint8_normed, uint8.length + uint8_tn.length); + + return fe.sha256(uint8_new).then((t => _.raw(t).hex)) + } + + async function Ae2(t, n = de) { + return fe.sha256(Uint8Array.of(...await be("TapLeaf"), function (t = 192) { + return 254 & t + }(n), ..._.normalize(t))).then((t => _.raw(t).hex)) + } + + async function xe(t, n) { + return n < t && ([t, n] = [n, t]), fe.sha256(Uint8Array.of(...await be("TapBranch"), ..._.hex(t).raw, ..._.hex(n).raw)).then((t => _.raw(t).hex)) + } + + async function Ee(t, n) { + return fe.sha256(Uint8Array.of(...await be("TapTweak"), ..._.normalize(t), ..._.normalize(n))) + } + + async function ve(t, n, e) { + const r = new B(_.normalize(n)), [i, o] = (s = r.read(1).num) % 2 == 0 ? [s, 2] : [s - 1, 3]; + var s; + const a = r.read(32), c = _.of(o, ..._.normalize(t)), u = []; + let f = e; + for (; r.size >= 32;) u.push(r.read(32).hex); + if (0 !== r.size) throw new Error("Invalid control block size!"); + for (const t of u) f = await xe(f, t); + const h = ge(a, await Ee(a, _.hex(f))); + return _.raw(h).hex === _.raw(c).hex + } + + async function Se(t, n = null, e = []) { + const r = [], i = []; + for (let i = 0; i < t.length; i++) { + const o = t[i]; + if (Array.isArray(o)) { + const [t, i, s] = await Se(o, n); + r.push(t), n = i, e.push(...s) + } else r.push(o) + } + if (1 === r.length) return [r[0], n, e]; + r.sort(), r.length % 2 != 0 && r.push(r[r.length - 1]); + for (let t = 0; t < r.length - 1; t += 2) { + const o = await xe(r[t], r[t + 1]); + i.push(o), "string" == typeof n && (n === r[t] ? (e.push(r[t + 1]), n = o) : n === r[t + 1] && (e.push(r[t]), n = o)) + } + return Se(i, n, e) + } + + const Pe = [0, 1, 2, 3, 129, 130, 131]; + + async function Oe(t, n, e = {}) { + ("string" == typeof t || t instanceof Uint8Array) && (t = L(t)); + const { + extention: r, + sigflag: i = 0, + extflag: o = 0, + key_version: s = 0, + separator_pos: a = 4294967295 + } = e, {version: c, input: u = [], output: f = [], locktime: h} = t; + if (n >= u.length) throw new Error("Index out of bounds: " + String(n)); + if (!Pe.includes(i)) throw new Error("Invalid hash type: " + String(i)); + if (o < 0 || o > 127) throw new Error("Extention flag out of range: " + String(o)); + const {txid: l, vout: d, sequence: w, witness: y = []} = u[n], g = 128 == (128 & i), + p = await async function (t) { + if (void 0 === t) return; + if (t.length < 2) return; + let n = t.at(-1); + "string" == typeof n && (n = _.hex(n)); + if (n instanceof Uint8Array && 80 === n[0]) return _.raw(n).prefixSize("be").digest; + return + }(y), m = 2 * (o + (void 0 !== r ? 1 : 0)) + (void 0 !== p ? 1 : 0), + b = [await be("TapSighash"), _.num(0, 1), _.num(i, 1), k(c), V(h)]; + if (!g) { + const t = u.map((t => Ue(t))); + b.push(await async function (t) { + const n = []; + for (const {txid: e, vout: r} of t) n.push(C(e)), n.push(D(r)); + return fe.sha256(_.join(n)) + }(u), await async function (t) { + const n = []; + for (const {value: e} of t) n.push(j(e)); + return fe.sha256(_.join(n)) + }(t), await async function (t) { + const n = []; + for (const {scriptPubKey: e} of t) n.push(N(e)); + return fe.sha256(_.join(n)) + }(t), await async function (t) { + const n = []; + for (const {sequence: e} of t) n.push(K(e)); + return fe.sha256(_.join(n)) + }(u)) + } + if (((3 & i) < 2 || (3 & i) > 3) && b.push(await async function (t) { + const n = []; + for (const {value: e, scriptPubKey: r} of t) n.push(j(e)), n.push(N(r)); + return fe.sha256(_.join(n)) + }(f)), b.push(_.num(m, 1)), g) { + const {value: t, scriptPubKey: e} = Ue(u[n]); + b.push(C(l), D(d), j(t), N(e), K(w)) + } else b.push(_.num(n, 4).reverse()); + return void 0 !== p && b.push(p), 3 == (3 & i) && b.push(await async function (t) { + return fe.sha256(_.of(...j(t.value), ...N(t.scriptPubKey))) + }(f[n])), void 0 !== r && b.push(_.normalize(r), _.num(s), _.num(a, 4)), fe.sha256(_.join(b)) + } + + function Ue(t) { + if (void 0 === t.prevout) throw new Error("Prevout data missing for input: " + String(t.txid)); + return t.prevout + } + + const _e = { + encode: N, decode: function (t) { + return function (t, n = "asm") { + const e = new B(t), r = [], i = e.size; + let o, s, a, c = 0; + for (; c < i;) switch (o = e.read(1).num, s = W(o), c++, s) { + case"varint": + r.push(e.read(o).toHex()), c += o; + break; + case"pushdata1": + a = e.read(1).reverse().num, r.push(e.read(a).toHex()), c += a + 1; + break; + case"pushdata2": + a = e.read(2).reverse().num, r.push(e.read(a).toHex()), c += a + 2; + break; + case"pushdata4": + a = e.read(4).reverse().num, r.push(e.read(a).toHex()), c += a + 4; + break; + case"opcode": + if (!G(o)) throw new Error(`Invalid OPCODE: ${o}`); + "asm" === n ? r.push(H(o)) : r.push(o); + break; + default: + throw new Error(`Word type undefined: ${o}`) + } + return r + }(_.normalize(t)) + } + }, Be = { + segwit: { + hash: async function (t, n, e, r, i) { + if (!he.includes(i)) throw new Error("Invalid hash type: " + String(i)); + const {version: o, input: s, output: a, locktime: c} = t, {txid: u, vout: f, sequence: h} = s[n], + l = i > 128, d = [k(o)]; + return d.push(await async function (t, n) { + if (!0 === n) return _.num(0, 32); + const e = []; + for (const {txid: n, vout: r} of t) e.push(C(n)), e.push(D(r)); + return fe.hash256(_.join(e)) + }(s, l), await async function (t, n) { + if (1 !== n) return _.num(0, 32); + const e = []; + for (const {sequence: n} of t) e.push(K(n)); + return fe.hash256(_.join(e)) + }(s, i), C(u), D(f), N(r, !0), j(e), K(h), await async function (t, n, e) { + const r = []; + if (1 === e) { + for (const {value: n, scriptPubKey: e} of t) r.push(j(n)), r.push(N(e)); + return fe.hash256(_.join(r)) + } + if (3 === e && n < t.length) { + const {value: e, scriptPubKey: i} = t[n]; + return r.push(j(e)), r.push(N(i)), fe.hash256(_.join(r)) + } + return _.num(0, 32) + }(a, n, i), V(c), _.num(i, 4).reverse()), fe.hash256(_.join(d)) + } + }, taproot: { + hash: Oe, sign: async function (t, n, e, r = {}) { + const {sigflag: i = 0} = r, o = dn.schnorr.sign, s = await Oe(n, e, r), a = await o(s, t); + return 0 === i ? _.raw(a).hex : _.of(...a, i).hex + }, verify: async function (t, n, e = {}, r = !1) { + const i = function (t) { + return ("string" == typeof t || t instanceof Uint8Array) && (t = L(t)), {...t} + }(t), {witness: o} = i.input[n]; + if (!Array.isArray(o) || o.length < 1) return le("Invalid witness data: " + String(o), r); + if (80 === Z(o[o.length - 1])[0] && o.pop(), o.length < 1) return le("Invalid witness data: " + String(o), r); + const s = new B(Z(o[0])), a = s.read(64), c = i.input[n].prevout, u = Z(c?.scriptPubKey).slice(2); + let f, h; + if (1 === s.size && (e.sigflag = s.read(1).num, 0 === e.sigflag)) return le("0x00 is not a valid appended sigflag!", r); + if (o.length > 1 && (h = Z(o.pop())), o.length > 1 && h instanceof Uint8Array) { + const t = N(o.pop()), n = 254 & h[0]; + f = await Ae(t, n), e.extention = f + } + const l = await Oe(i, n, e), d = dn.schnorr.verify; + return await d(a, l, u) ? !(void 0 !== h && void 0 !== f && !await ve(u, h, f)) || le("Invalid cblock!", r) : le("Invalid signature!", r) + } + } + }, Ie = { + getTag: be, getLeaf: Ae, getBranch: xe, getRoot: me, getTweak: Ee, getPubkey: async function (t, n = []) { + return pe(t, n) + }, getSeckey: async function (t, n = []) { + return pe(t, n, !0).then((t => t[0])) + }, getPath: async function t(n, e, r = [e], i = de, o = 0) { + const s = _.normalize(n), [a, c, u] = await Se(r, e), f = [_.num(i + function (t = 2) { + if (0 === t || 1 === t) return t; + if (2 === t || "02" === t) return 0; + if (3 === t || "03" === t) return 1; + throw new Error("Invalid parity bit:" + String(t)) + }(o)), _.normalize(n)]; + r.length > 1 && u.forEach((t => f.push(_.hex(t)))); + const h = _.join(f), l = ge(s, await Ee(s, _.hex(a))).slice(1); + if (!await ve(l, h, e)) { + if (0 === o) return t(n, e, r, i, 1); + throw new Error("Path checking failed! Unable to generate path.") + } + return h.hex + }, checkPath: ve, tweakSeckey: ye, tweakPubkey: ge, encodeAddress: function (t, n = "bc") { + return (t = _.normalize(t)).length > 32 && (t = t.slice(1, 33)), _.raw(t).toBech32(n, 1) + }, decodeAddress: function (t) { + return _.bech32(t, 1) + } + }, He = { + encode: function (t, n) { + const {version: e, input: r, output: i, locktime: o} = t, s = !0 !== n && function (t) { + for (const n of t) { + const {witness: t} = n; + if ("string" == typeof t || t instanceof Uint8Array || Array.isArray(t) && t.length > 0) return !0 + } + return !1 + }(r), a = [k(e)]; + s && a.push(_.hex("0001")), a.push(function (t) { + const n = [_.readSize(t.length)]; + for (const e of t) { + const {txid: t, vout: r, scriptSig: i, sequence: o} = e; + n.push(C(t)), n.push(D(r)), n.push(N(i)), n.push(K(o)) + } + return _.join(n) + }(r)), a.push(function (t) { + const n = [_.readSize(t.length)]; + for (const e of t) { + const {address: t, value: r, scriptPubKey: i} = e; + n.push(j(r)), void 0 !== t ? n.push(_.bech32(t).raw) : n.push(N(i)) + } + return _.join(n) + }(i)); + for (const t of r) s && void 0 !== t?.witness && a.push($(t.witness)); + return a.push(V(o)), _.join(a).hex + }, decode: L + }; + return t.Script = _e, t.Sig = Be, t.Tap = Ie, t.Tx = He, t +}({}); \ No newline at end of file diff --git a/signet.html b/signet.html index 5a452a2..e45c692 100644 --- a/signet.html +++ b/signet.html @@ -105,7 +105,7 @@ @media screen and (max-width: 600px) { } - + @@ -122,14 +122,7 @@ function encodeBase64( file ) { return new Promise( function( resolve, reject ) { //the next three lines handle the case where an image is passed in from an external site - if ( "files" in file ) { - file = file.files[ 0 ]; - } - var mimetype = file.type; - if ( mimetype.includes( "text/plain" ) ) { - mimetype += ";charset=utf-8"; - } - sessionStorage[ "mimetype" ] = mimetype; + var imgReader = new FileReader(); imgReader.onloadend = function() { resolve( imgReader.result.toString() ); @@ -227,8 +220,8 @@

Then upload a file you want that address to own or click here to register a domain name

-

-

+

+

61

Select a feerate (measured in sats per byte)

...
Min
...
Mid
...
Max
@@ -273,47 +266,70 @@ showUploader(); - $( '.form' ).addEventListener( "change", async function() { - if ( this.files[ 0 ].size >= 120000 && this.files[ 0 ].size < 350000 ) { - var conf = confirm( "You exceeded the 120 kb size limit. Click ok to override this warning or click cancel to try again." ); - if ( conf ) { - var b64 = await encodeBase64( this ); - } else { - this.value = null; - } - } else if ( this.files[ 0 ].size >= 350000 ) { - alert( "You exceeded this software's hard size limit of 350 kb files. Modify the code to override the limit." ) - this.value = null; - } else { - var b64 = await encodeBase64( this ); - } - var base64 = b64.substring( b64.indexOf( "base64," ) + 7 ); - var hex = base64ToHex( base64 ); - // console.log( "hex:", hex ); - // console.log( "bytes:", hexToBytes( hex ) ); - $( '.file' ).innerText = hex; - }); + let files = []; + $( '.form' ).addEventListener( "change", async function() { + + for(let i = 0; i < this.files.length; i++) + { + + var b64; + var mimetype = this.files[i].type; + + if ( mimetype.includes( "text/plain" ) ) { + + mimetype += ";charset=utf-8"; + } + + if ( this.files[ i ].size >= 120000 && this.files[ i ].size < 350000 ) { + + var conf = confirm( "You exceeded the 120 kb size limit. Click ok to override this warning or click cancel to try again." ); + + if ( conf ) { + + b64 = await encodeBase64( this.files[i] ); + } + + } else if ( this.files[ 0 ].size >= 350000 ) { + + alert( "You exceeded this software's hard size limit of 350 kb files. Modify the code to override the limit." ) + + } else { + + b64 = await encodeBase64( this.files[i] ); + } + + var base64 = b64.substring( b64.indexOf( "base64," ) + 7 ); + var hex = base64ToHex( base64 ); + + console.log( "hex:", hex ); + console.log( "bytes:", hexToBytes( hex ) ); + + files.push({hex: hex, mimetype : mimetype}); + } + }); $( '.submit' ).addEventListener( "click", async function() { if ( $( '.file_form' ).style.display == "none" ) { - sessionStorage[ "mimetype" ] = "text/plain;charset=utf-8"; - var domain = {"p":"sns","op":"reg","name":$( '.dns' ).value} - $( '.file' ).innerText = textToHex( JSON.stringify( domain ) ); - } + let sats_domains = $( '.dns' ).value.split("\n"); - const ec = new TextEncoder(); - const hex = $( '.file' ).innerText; - const data = hexToBytes( hex ); + for(let sats_domain in sats_domains) + { + let mimetype = "text/plain;charset=utf-8"; + var domain = {"p":"sns","op":"reg","name":sats_domains[sats_domain].trim()}; + console.log(domain); + files.push({hex: textToHex( JSON.stringify( domain ) ), mimetype : mimetype}); + } + } const KeyPair = cryptoUtils.KeyPair; const seckey = new KeyPair(privkey); const pubkey = seckey.pub.rawX; - const mimetype = ec.encode( sessionStorage[ "mimetype" ] ); + const ec = new TextEncoder(); - const init_script = [ + const init_script = [ pubkey, 'OP_CHECKSIG' ]; @@ -322,63 +338,85 @@ const [ init_tapkey ] = await BTON.Tap.getPubkey(pubkey, [ init_leaf ]); const init_cblock = await BTON.Tap.getPath(pubkey, init_leaf); - const script = [ - pubkey, - 'OP_CHECKSIG', - 'OP_0', - 'OP_IF', - ec.encode('ord'), - '01', - mimetype, - 'OP_0', - data, - 'OP_ENDIF' - ]; + let inscriptions = []; + let total_fee = 0; - const leaf = await BTON.Tap.getLeaf(BTON.Script.encode(script)); - const [ tapkey ] = await BTON.Tap.getPubkey(pubkey, [ leaf ]); - const cblock = await BTON.Tap.getPath(pubkey, leaf); + for(let i = 0; i < files.length; i++) + { + const hex = files[i].hex; + const data = hexToBytes( hex ); + const mimetype = ec.encode( files[i].mimetype ); - console.log('Tapkey:', tapkey); + const script = [ + pubkey, + 'OP_CHECKSIG', + 'OP_0', + 'OP_IF', + ec.encode('ord'), + '01', + mimetype, + 'OP_0', + data, + 'OP_ENDIF' + ]; + + const leaf = await BTON.Tap.getLeaf(BTON.Script.encode(script)); + const [ tapkey ] = await BTON.Tap.getPubkey(pubkey, [ leaf ]); + const cblock = await BTON.Tap.getPath(pubkey, leaf); + var inscriptionAddress = BTON.Tap.encodeAddress( tapkey, 'tb' ); + + console.log('Inscription address: ', inscriptionAddress ); + console.log('Tapkey:', tapkey); + + var txsize = 200 + ( hex.length / 2 ); + + var feerate = await getMinFeeRate(); + sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; + + if ( sessionStorage[ "feerate" ] ) { + + feerate = Number( sessionStorage[ "feerate" ] ); + sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; + } + + var fee = feerate * txsize; + total_fee += fee; + + inscriptions.push( + { + leaf: leaf, + tapkey : tapkey, + cblock : cblock, + inscriptionAddress : inscriptionAddress, + txsize : txsize, + fee : fee, + script : script + } + ); + } var fundingAddress = BTON.Tap.encodeAddress( init_tapkey, 'tb' ); console.log('Funding address: ', fundingAddress ); - var inscriptionAddress = BTON.Tap.encodeAddress( tapkey, 'tb' ); - console.log('Inscription address: ', inscriptionAddress ); - var toAddress = $( '.address' ).value; console.log('Address that will receive the inscription:', toAddress ); var decodedToAddress = "5120" + BTON.Tap.decodeAddress( toAddress ).hex; console.log('To address decoded:', decodedToAddress ); - var txsize = 200 + ( hex.length / 2 ); - - if ( sessionStorage[ "feerate" ] ) { - - var feerate = Number( sessionStorage[ "feerate" ] ); - sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; - - } else { - - var feerate = await getMinFeeRate(); - sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; - } - - var fee = feerate * txsize; - var sats_price = await satsToDollars( fee + 1000 ); + let total_fees = total_fee + ( 1000 * inscriptions.length ); + var sats_price = await satsToDollars( total_fees ); sats_price = Math.floor( sats_price * 100 ) / 100; - var html = `

Please send at least ${fee + 1000} sats ($${sats_price}) to this address:

${fundingAddress}

`; + var html = `

Please send at least ${total_fees} sats ($${sats_price}) to this address:

${fundingAddress}

`; $( '.display' ).innerHTML = html; - var qr_value = "bitcoin:" + fundingAddress + "?amount=" + satsToBitcoin( fee + 1000 ); + var qr_value = "bitcoin:" + fundingAddress + "?amount=" + satsToBitcoin( total_fees ); console.log( "qr:", qr_value ); $( '.display' ).append( createQR( qr_value ) ); $( '.display' ).innerHTML += `

Checking the mempool.

`; - $( '.display' ).innerHTML += `

1000 sats will go to the address

${fee} sats will go to miners as a mining fee

`; + $( '.display' ).innerHTML += `

' + ( 1000 * inscriptions.length ) + ' sats will go to the address

${total_fee} sats will go to miners as a mining fee

`; $( '.display' ).style.display = "block"; await loopTilAddressReceivesMoney( fundingAddress, true ); @@ -391,17 +429,18 @@ console.log( "yay! txid:", txid, "vout:", vout, "amount:", amt ); - if ( sessionStorage[ "determined_feerate" ] ) { - feerate = Number( sessionStorage[ "determined_feerate" ] ); - } else { - feerate = await getMinFeeRate(); + let outputs = []; + + for(let i = 0; i < inscriptions.length; i++) + { + outputs.push( + { + value: 1000 + inscriptions[i].fee, + scriptPubKey: '5120' + inscriptions[i].tapkey + } + ); } - var fee = feerate * txsize; - - console.log( "feerate:", feerate, "txsize:", txsize, "fee:", fee ); - console.log( "fee:", fee ); - const init_redeemtx = { version: 2, input: [{ @@ -410,10 +449,7 @@ prevout: { value: amt, scriptPubKey: '5120' + init_tapkey }, witness: [] }], - output:[{ - value: amt - fee, - scriptPubKey: '5120' + tapkey - }], + output: outputs, locktime: 0 }; @@ -427,149 +463,55 @@ // seeder received everything, now it is time to populate the others - await loopTilAddressReceivesMoney( inscriptionAddress, false ); - await waitSomeSeconds( 2 ); - var txinfo2 = await addressReceivedMoneyInThisTx( inscriptionAddress ); + async function inscribe(inscription) + { - var txid2 = txinfo2[ 0 ]; - var vout2 = txinfo2[ 1 ]; - var amt2 = txinfo2[ 2 ]; + await loopTilAddressReceivesMoney( inscription.inscriptionAddress, false ); + await waitSomeSeconds( 2 ); + var txinfo2 = await addressReceivedMoneyInThisTx( inscription.inscriptionAddress ); - const redeemtx = { - version: 2, - input: [{ - txid: txid2, - vout: vout2, - prevout: { value: amt2, scriptPubKey: '5120' + tapkey }, - witness: [] - }], - output:[{ - value: amt2 - fee, - scriptPubKey: decodedToAddress - }], - locktime: 0 - }; + var txid2 = txinfo2[ 0 ]; + var vout2 = txinfo2[ 1 ]; + var amt2 = txinfo2[ 2 ]; - const sig = await BTON.Sig.taproot.sign(seckey.raw, redeemtx, 0, { extention: leaf }); - redeemtx.input[0].witness = [ sig, script, cblock ]; + const redeemtx = { + version: 2, + input: [{ + txid: txid2, + vout: vout2, + prevout: { value: amt2, scriptPubKey: '5120' + inscription.tapkey }, + witness: [] + }], + output:[{ + value: amt2 - inscription.fee, + scriptPubKey: decodedToAddress + }], + locktime: 0 + }; - console.dir(redeemtx, { depth: null }); + const sig = await BTON.Sig.taproot.sign(seckey.raw, redeemtx, 0, { extention: inscription.leaf }); + redeemtx.input[0].witness = [ sig, inscription.script, inscription.cblock ]; - var rawtx2 = BTON.Tx.encode(redeemtx); - var _txid2 = await pushBTCpmt( rawtx2 ); + console.dir(redeemtx, { depth: null }); - var html = `

Success! Your file will shortly be inscribed on the bitcoin blockchain in this transaction:

https://mempool.space/signet/tx/${_txid2}

`; - html += `

When your transaction confirms you can view it on the ordinals explorer here:

https://ordinals.com/inscription/${_txid2}i0

`; + var rawtx2 = BTON.Tx.encode(redeemtx); + var _txid2 = await pushBTCpmt( rawtx2 ); - $( '.modal' ).innerHTML = html; - $( '.modal' ).style.display = "block"; - $( '.black-bg' ).style.display = "block"; + var html = `

Success! Your file will shortly be inscribed on the bitcoin blockchain in this transaction:

https://mempool.space/signet/tx/${_txid2}

`; + html += `

When your transaction confirms you can view it on the ordinals explorer here:

https://ordinals.com/inscription/${_txid2}i0

`; + html += '
'; + $( '.modal' ).innerHTML += html; + $( '.modal' ).style.display = "block"; + $( '.black-bg' ).style.display = "block"; + } + + for(let i = 0; i < inscriptions.length; i++) + { + inscribe(inscriptions[i]); + } }); - - $( '.submit' ).addEventListener( "click2", async function() { - if ( $( '.file_form' ).style.display == "none" ) { - sessionStorage[ "mimetype" ] = "text/plain;charset=utf-8"; - var domain = {"p":"sns","op":"reg","name":$( '.dns' ).value} - $( '.file' ).innerText = textToHex( JSON.stringify( domain ) ); - } - const ec = new TextEncoder(); - const hex = $( '.file' ).innerText; - console.log("HEX?", hex); - const data = hexToBytes( hex ); - const KeyPair = cryptoUtils.KeyPair; - const seckey = new KeyPair(privkey); - const pubkey = seckey.pub.rawX; - const mimetype = ec.encode( sessionStorage[ "mimetype" ] ); - const script = [ pubkey, 'OP_CHECKSIG', 'OP_0', 'OP_IF', ec.encode('ord'), '01', mimetype, 'OP_0', data, 'OP_ENDIF' ]; - const leaf = await BTON.Tap.getLeaf(BTON.Script.encode(script)); - const [ tapkey ] = await BTON.Tap.getPubkey(pubkey, [ leaf ]); - const cblock = await BTON.Tap.getPath(pubkey, leaf); - console.log('Tapkey:', tapkey); - var fundingAddress = BTON.Tap.encodeAddress( tapkey, 'tb' ); - console.log('Funding address: ', fundingAddress ); - //var toAddress = prompt( "give me the address you your inscription to arrive in and consider using this one: tb1padwymyc6x2dfc3cwzvpxxcqsr3c46cjx9zxg0jmcuf44fjuwljxs7x68fm" ); - //var toAddress = "tb1padwymyc6x2dfc3cwzvpxxcqsr3c46cjx9zxg0jmcuf44fjuwljxs7x68fm"; - var toAddress = $( '.address' ).value; - console.log('Address that will receive the inscription:', toAddress ); - var decodedToAddress = "5120" + BTON.Tap.decodeAddress( toAddress ).hex; - console.log('To address decoded:', decodedToAddress ); - var txsize = 200 + ( hex.length / 2 ); - if ( sessionStorage[ "feerate" ] ) { - var feerate = Number( sessionStorage[ "feerate" ] ); - sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; - } else { - var feerate = await getMinFeeRate(); - sessionStorage[ "determined_feerate" ] = sessionStorage[ "feerate" ]; - } - var fee = feerate * txsize; - var btc_price = sessionStorage[ "bitcoin_price" ]; - var sats_price = await satsToDollars( fee + 1000 ); - sats_price = Math.floor( sats_price * 100 ) / 100; - var html = `

Please send at least ${fee + 1000} sats ($${sats_price}) to this address:

${fundingAddress}

`; - $( '.display' ).innerHTML = html; - var qr_value = "bitcoin:" + fundingAddress + "?amount=" + satsToBitcoin( fee + 1000 ); - console.log( "qr:", qr_value ); - $( '.display' ).append( createQR( qr_value ) ); - $( '.display' ).innerHTML += `

Checking the mempool.

`; - $( '.display' ).innerHTML += `

1000 sats will go to the address

${fee} sats will go to miners as a mining fee

`; - $( '.display' ).style.display = "block"; - await loopTilAddressReceivesMoney( fundingAddress ); - await waitSomeSeconds( 2 ); - var txinfo = await addressReceivedMoneyInThisTx( fundingAddress ); - var txid = txinfo[ 0 ]; - var vout = txinfo[ 1 ]; - var amt = txinfo[ 2 ]; - // if ( !txid || !vout || !amt ) { - // await waitSomeSeconds( 2 ); - // txinfo = await addressReceivedMoneyInThisTx( fundingAddress ); - // txid = txinfo[ 0 ]; - // vout = txinfo[ 1 ]; - // amt = txinfo[ 2 ]; - // } - // var amt = prompt( "give me the amount you sent" ); - // amt = Number( amt ); - // var txid = prompt( "give me the txid" ); - // var vout = prompt( "give me the vout" ); - // vout = Number( vout ); - console.log( "yay! txid:", txid, "vout:", vout, "amount:", amt ); - if ( sessionStorage[ "determined_feerate" ] ) { - feerate = Number( sessionStorage[ "determined_feerate" ] ); - } else { - feerate = await getMinFeeRate(); - } - var fee = feerate * txsize; - console.log( "feerate:", feerate, "txsize:", txsize, "fee:", fee ); - console.log( "fee:", fee ); - const redeemtx = { - version: 2, - input: [{ - txid: txid, - vout: vout, - prevout: { value: amt, scriptPubKey: '5120' + tapkey }, - witness: [] - }], - output:[{ - value: amt - fee, - scriptPubKey: decodedToAddress - }], - locktime: 0 - } - const sec = await BTON.Tap.getSeckey(seckey.raw, [ leaf ]); - const sig = await BTON.Sig.taproot.sign(seckey.raw, redeemtx, 0, { extention: leaf }); - redeemtx.input[0].witness = [ sig, script, cblock ]; - console.dir(redeemtx, { depth: null }); - //await BTON.Sig.taproot.verify(redeemtx, 0, {extension: leaf}, true); - var rawtx = BTON.Tx.encode(redeemtx); - console.log('Txdata:', rawtx ); - var txid = await pushBTCpmt( rawtx ); - var html = `

Success! Your file will shortly be inscribed on the bitcoin blockchain in this transaction:

https://mempool.space/signet/tx/${txid}

`; - html += `

When your transaction confirms you can view it on the ordinals explorer here:

https://ordinals.com/inscription/${txid}i0

`; - $( '.modal' ).innerHTML = html; - $( '.modal' ).style.display = "block"; - $( '.black-bg' ).style.display = "block"; - }); async function getMaxFeeRate() { var fees = await getData( "https://mempool.space/signet/api/v1/fees/recommended" ); fees = JSON.parse( fees );