bton.min.js

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
}({});