"use strict";
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [2049],
  {
    54922: function (t, e, r) {
      r.d(e, {
        $r: function () {
          return rk;
        },
        BN: function () {
          return f.a;
        },
        Y7: function () {
          return ti;
        },
        rV: function () {
          return _;
        },
      });
      var n,
        i,
        o,
        s,
        a,
        c,
        u,
        l,
        d,
        h = r(57537),
        _ = r(87927),
        p = r(52776),
        f = r.n(p),
        R = r(14259),
        A = r.n(R),
        y = r(90222),
        E = r.n(y),
        O = r(39536),
        m = (r(46490), r(37680)),
        N = r(78103),
        g = r.n(N),
        T = r(57537).Buffer;
      let I = (t) => "version" in t;
      function v(t) {
        return A().encode(t);
      }
      function C(t) {
        return t.toString("base64");
      }
      function w(t) {
        return h.Buffer.from(t, "base64");
      }
      function S(t) {
        return "accounts" in t;
      }
      async function b(t) {
        let e = (await _.PublicKey.findProgramAddress([], t))[0];
        return await _.PublicKey.createWithSeed(e, "anchor:idl", t);
      }
      let M = O.n_([O.ZL("authority"), O.t3("data")]);
      function D(t, e, r, n) {
        return (null == t ? void 0 : t.length)
          ? t[0].name
            ? r(t)
            : n(t)
          : e();
      }
      function P(t) {
        return t instanceof _.PublicKey ? t : new _.PublicKey(t);
      }
      class x extends TypeError {
        constructor(t, e) {
          let r;
          let { message: n, ...i } = t,
            { path: o } = t;
          super(0 === o.length ? n : "At path: " + o.join(".") + " -- " + n),
            (this.value = void 0),
            (this.key = void 0),
            (this.type = void 0),
            (this.refinement = void 0),
            (this.path = void 0),
            (this.branch = void 0),
            (this.failures = void 0),
            Object.assign(this, i),
            (this.name = this.constructor.name),
            (this.failures = () => {
              var n;
              return null != (n = r) ? n : (r = [t, ...e()]);
            });
        }
      }
      function L(t) {
        return "object" == typeof t && null != t;
      }
      function H(t) {
        return "string" == typeof t ? JSON.stringify(t) : "" + t;
      }
      function* U(t, e, r, n) {
        var i;
        for (let o of ((L((i = t)) &&
          "function" == typeof i[Symbol.iterator]) ||
          (t = [t]),
        t)) {
          let t = (function (t, e, r, n) {
            if (!0 === t) return;
            !1 === t ? (t = {}) : "string" == typeof t && (t = { message: t });
            let { path: i, branch: o } = e,
              { type: s } = r,
              {
                refinement: a,
                message: c = "Expected a value of type `" +
                  s +
                  "`" +
                  (a ? " with refinement `" + a + "`" : "") +
                  ", but received: `" +
                  H(n) +
                  "`",
              } = t;
            return {
              value: n,
              type: s,
              refinement: a,
              key: i[i.length - 1],
              path: i,
              branch: o,
              ...t,
              message: c,
            };
          })(o, e, r, n);
          t && (yield t);
        }
      }
      function* k(t, e, r) {
        void 0 === r && (r = {});
        let { path: n = [], branch: i = [t], coerce: o = !1, mask: s = !1 } = r,
          a = { path: n, branch: i };
        if (
          o &&
          ((t = e.coercer(t, a)),
          s && "type" !== e.type && L(e.schema) && L(t) && !Array.isArray(t))
        )
          for (let r in t) void 0 === e.schema[r] && delete t[r];
        let c = !0;
        for (let r of e.validator(t, a)) (c = !1), yield [r, void 0];
        for (let [r, u, l] of e.entries(t, a))
          for (let e of k(u, l, {
            path: void 0 === r ? n : [...n, r],
            branch: void 0 === r ? i : [...i, u],
            coerce: o,
            mask: s,
          }))
            e[0]
              ? ((c = !1), yield [e[0], void 0])
              : o &&
                ((u = e[1]),
                void 0 === r
                  ? (t = u)
                  : t instanceof Map
                  ? t.set(r, u)
                  : t instanceof Set
                  ? t.add(u)
                  : L(t) && (t[r] = u));
        if (c) for (let r of e.refiner(t, a)) (c = !1), yield [r, void 0];
        c && (yield [void 0, t]);
      }
      class B {
        assert(t) {
          return (function (t, e) {
            let r = V(t, e);
            if (r[0]) throw r[0];
          })(t, this);
        }
        create(t) {
          return G(t, this);
        }
        is(t) {
          return !V(t, this)[0];
        }
        mask(t) {
          return (function (t, e) {
            let r = V(t, e, { coerce: !0, mask: !0 });
            if (!r[0]) return r[1];
            throw r[0];
          })(t, this);
        }
        validate(t, e) {
          return void 0 === e && (e = {}), V(t, this, e);
        }
        constructor(t) {
          (this.TYPE = void 0),
            (this.type = void 0),
            (this.schema = void 0),
            (this.coercer = void 0),
            (this.validator = void 0),
            (this.refiner = void 0),
            (this.entries = void 0);
          let {
            type: e,
            schema: r,
            validator: n,
            refiner: i,
            coercer: o = (t) => t,
            entries: s = function* () {},
          } = t;
          (this.type = e),
            (this.schema = r),
            (this.entries = s),
            (this.coercer = o),
            n
              ? (this.validator = (t, e) => U(n(t, e), e, this, t))
              : (this.validator = () => []),
            i
              ? (this.refiner = (t, e) => U(i(t, e), e, this, t))
              : (this.refiner = () => []);
        }
      }
      function G(t, e) {
        let r = V(t, e, { coerce: !0 });
        if (!r[0]) return r[1];
        throw r[0];
      }
      function V(t, e, r) {
        void 0 === r && (r = {});
        let n = k(t, e, r),
          i = (function (t) {
            let { done: e, value: r } = t.next();
            return e ? void 0 : r;
          })(n);
        return i[0]
          ? [
              new x(i[0], function* () {
                for (let t of n) t[0] && (yield t[0]);
              }),
              void 0,
            ]
          : [void 0, i[1]];
      }
      function K(t, e) {
        return new B({ type: t, schema: null, validator: e });
      }
      function z(t) {
        return new B({
          type: "array",
          schema: t,
          *entries(e) {
            if (t && Array.isArray(e))
              for (let [r, n] of e.entries()) yield [r, n, t];
          },
          coercer: (t) => (Array.isArray(t) ? t.slice() : t),
          validator: (t) =>
            Array.isArray(t) ||
            "Expected an array value, but received: " + H(t),
        });
      }
      function j(t) {
        let e = H(t),
          r = typeof t;
        return new B({
          type: "literal",
          schema:
            "string" === r || "number" === r || "boolean" === r ? t : null,
          validator: (r) =>
            r === t ||
            "Expected the literal `" + e + "`, but received: " + H(r),
        });
      }
      function q(t) {
        return new B({
          ...t,
          validator: (e, r) => null === e || t.validator(e, r),
          refiner: (e, r) => null === e || t.refiner(e, r),
        });
      }
      function F() {
        return K(
          "number",
          (t) =>
            ("number" == typeof t && !isNaN(t)) ||
            "Expected a number, but received: " + H(t)
        );
      }
      function X(t) {
        return new B({
          ...t,
          validator: (e, r) => void 0 === e || t.validator(e, r),
          refiner: (e, r) => void 0 === e || t.refiner(e, r),
        });
      }
      function Y() {
        return K(
          "string",
          (t) =>
            "string" == typeof t || "Expected a string, but received: " + H(t)
        );
      }
      function W(t) {
        let e = Object.keys(t);
        return new B({
          type: "type",
          schema: t,
          *entries(r) {
            if (L(r)) for (let n of e) yield [n, r[n], t[n]];
          },
          validator: (t) => L(t) || "Expected an object, but received: " + H(t),
        });
      }
      function Q(t) {
        let e = t.map((t) => t.type).join(" | ");
        return new B({
          type: "union",
          schema: null,
          coercer: (e, r) =>
            (
              t.find((t) => {
                let [r] = t.validate(e, { coerce: !0 });
                return !r;
              }) || Z()
            ).coercer(e, r),
          validator(r, n) {
            let i = [];
            for (let e of t) {
              let [...t] = k(r, e, n),
                [o] = t;
              if (!o[0]) return [];
              for (let [e] of t) e && i.push(e);
            }
            return [
              "Expected the value to satisfy a union of `" +
                e +
                "`, but received: " +
                H(r),
              ...i,
            ];
          },
        });
      }
      function Z() {
        return K("unknown", () => !0);
      }
      async function J(t, e, r) {
        if (e.length <= 99) return await $(t, e, r);
        {
          let n = Array.apply(0, Array(Math.ceil(e.length / 99))).map((t, r) =>
            e.slice(99 * r, (r + 1) * 99)
          );
          return (await Promise.all(n.map((e) => $(t, e, r)))).flat();
        }
      }
      async function $(t, e, r) {
        let n = null != r ? r : t.commitment,
          { value: i, context: o } = await t.getMultipleAccountsInfoAndContext(
            e,
            n
          );
        return i.map((t, r) =>
          null === t ? null : { publicKey: e[r], account: t, context: o }
        );
      }
      async function tt(t, e, r, n, i) {
        var o;
        r && r.length > 0 && e.sign(...r);
        let s = e._compile(),
          a = s.serialize(),
          c = e._serialize(a).toString("base64"),
          u = { encoding: "base64", commitment: null != n ? n : t.commitment };
        if (i) {
          let t = (Array.isArray(i) ? i : s.nonProgramIds()).map((t) =>
            t.toBase58()
          );
          u.accounts = { encoding: "base64", addresses: t };
        }
        r && r.length > 0 && (u.sigVerify = !0);
        let l = G(await t._rpcRequest("simulateTransaction", [c, u]), tn);
        if ("error" in l) {
          let t;
          if (
            "data" in l.error &&
            (t =
              null === (o = l.error.data) || void 0 === o ? void 0 : o.logs) &&
            Array.isArray(t)
          ) {
            let e = "\n    ",
              r = e + t.join(e);
            console.error(l.error.message, r);
          }
          throw new _.SendTransactionError(
            "failed to simulate transaction: " + l.error.message,
            t
          );
        }
        return l.result;
      }
      let te = tr(Z());
      function tr(t) {
        return Q([
          W({ jsonrpc: j("2.0"), id: Y(), result: t }),
          W({
            jsonrpc: j("2.0"),
            id: Y(),
            error: W({ code: Z(), message: Y(), data: X(K("any", () => !0)) }),
          }),
        ]);
      }
      let tn =
        ((n = W({
          err: q(Q([W({}), Y()])),
          logs: q(z(Y())),
          accounts: X(
            q(
              z(
                q(
                  W({
                    executable: K("boolean", (t) => "boolean" == typeof t),
                    owner: Y(),
                    lamports: F(),
                    data: z(Y()),
                    rentEpoch: X(F()),
                  })
                )
              )
            )
          ),
          unitsConsumed: X(F()),
        })),
        (o = tr((i = W({ context: W({ slot: F() }), value: n })))),
        (s = (t) => ("error" in t ? t : { ...t, result: G(t.result, i) })),
        new B({
          ...o,
          coercer: (t, e) =>
            V(t, te)[0] ? o.coercer(t, e) : o.coercer(s(t, e), e),
        }));
      class ti {
        static defaultOptions() {
          return { preflightCommitment: "processed", commitment: "processed" };
        }
        static local(t) {
          throw (
            (arguments.length > 1 && void 0 !== arguments[1]
              ? arguments[1]
              : ti.defaultOptions(),
            Error("Provider local is not available on browser."))
          );
        }
        static env() {
          throw Error("Provider env is not available on browser.");
        }
        async sendAndConfirm(t, e, r) {
          var n, i, o, s;
          if ((void 0 === r && (r = this.opts), I(t))) e && t.sign(e);
          else if (
            ((t.feePayer =
              null !== (n = t.feePayer) && void 0 !== n
                ? n
                : this.wallet.publicKey),
            (t.recentBlockhash = (
              await this.connection.getLatestBlockhash(r.preflightCommitment)
            ).blockhash),
            e)
          )
            for (let r of e) t.partialSign(r);
          let a = (t = await this.wallet.signTransaction(t)).serialize();
          try {
            return await ts(this.connection, a, r);
          } catch (e) {
            if (e instanceof ta) {
              let r = v(
                  I(t)
                    ? (null === (i = t.signatures) || void 0 === i
                        ? void 0
                        : i[0]) || new Uint8Array()
                    : null !== (o = t.signature) && void 0 !== o
                    ? o
                    : new Uint8Array()
                ),
                n = I(t) ? 0 : void 0,
                a = await this.connection.getTransaction(r, {
                  commitment: "confirmed",
                  maxSupportedTransactionVersion: n,
                });
              if (a) {
                let t =
                  null === (s = a.meta) || void 0 === s
                    ? void 0
                    : s.logMessages;
                throw t ? new _.SendTransactionError(e.message, t) : e;
              }
            }
            throw e;
          }
        }
        async sendAll(t, e) {
          var r, n, i;
          void 0 === e && (e = this.opts);
          let o = (
              await this.connection.getLatestBlockhash(e.preflightCommitment)
            ).blockhash,
            s = t.map((t) => {
              var e, r;
              if (I(t.tx)) {
                let e = t.tx;
                return t.signers && e.sign(t.signers), e;
              }
              {
                let n = t.tx,
                  i = null !== (e = t.signers) && void 0 !== e ? e : [];
                return (
                  (n.feePayer =
                    null !== (r = n.feePayer) && void 0 !== r
                      ? r
                      : this.wallet.publicKey),
                  (n.recentBlockhash = o),
                  i.forEach((t) => {
                    n.partialSign(t);
                  }),
                  n
                );
              }
            }),
            a = await this.wallet.signAllTransactions(s),
            c = [];
          for (let t = 0; t < s.length; t += 1) {
            let o = a[t],
              s = o.serialize();
            try {
              c.push(await ts(this.connection, s, e));
            } catch (t) {
              if (t instanceof ta) {
                let e = v(
                    I(o)
                      ? (null === (r = o.signatures) || void 0 === r
                          ? void 0
                          : r[0]) || new Uint8Array()
                      : null !== (n = o.signature) && void 0 !== n
                      ? n
                      : new Uint8Array()
                  ),
                  s = I(o) ? 0 : void 0,
                  a = await this.connection.getTransaction(e, {
                    commitment: "confirmed",
                    maxSupportedTransactionVersion: s,
                  });
                if (a) {
                  let e =
                    null === (i = a.meta) || void 0 === i
                      ? void 0
                      : i.logMessages;
                  throw e ? new _.SendTransactionError(t.message, e) : t;
                }
              }
              throw t;
            }
          }
          return c;
        }
        async simulate(t, e, r, n) {
          let i,
            o = (
              await this.connection.getLatestBlockhash(
                null != r ? r : this.connection.commitment
              )
            ).blockhash;
          if (
            (I(t)
              ? (e &&
                  e.length > 0 &&
                  (t.sign(e), (t = await this.wallet.signTransaction(t))),
                (i = await this.connection.simulateTransaction(t, {
                  commitment: r,
                })))
              : ((t.feePayer = t.feePayer || this.wallet.publicKey),
                (t.recentBlockhash = o),
                e && e.length > 0 && (t = await this.wallet.signTransaction(t)),
                (i = await tt(this.connection, t, e, r, n))),
            i.value.err)
          )
            throw new to(i.value);
          return i.value;
        }
        constructor(t, e, r = ti.defaultOptions()) {
          (this.connection = t),
            (this.wallet = e),
            (this.opts = r),
            (this.publicKey = null == e ? void 0 : e.publicKey);
        }
      }
      class to extends Error {
        constructor(t, e) {
          super(e), (this.simulationResponse = t);
        }
      }
      async function ts(t, e, r) {
        let n = r && {
            skipPreflight: r.skipPreflight,
            preflightCommitment: r.preflightCommitment || r.commitment,
          },
          i = await t.sendRawTransaction(e, n),
          o = (await t.confirmTransaction(i, r && r.commitment)).value;
        if (o.err)
          throw new ta(
            "Raw transaction "
              .concat(i, " failed (")
              .concat(JSON.stringify(o), ")")
          );
        return i;
      }
      class ta extends Error {
        constructor(t) {
          super(t);
        }
      }
      function tc() {
        return null === tu ? ti.local() : tu;
      }
      let tu = null;
      var tl = "undefined" != typeof globalThis ? globalThis : window,
        td = {};
      Object.defineProperty(td, "__esModule", { value: !0 });
      var th =
          (td.ANCHOR_ERROR__REQUIRE_EQ_VIOLATED =
          t9 =
          td.ANCHOR_ERROR__REQUIRE_VIOLATED =
          t5 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION_PROGRAM_ID =
          t4 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION_AUTHORITY =
          t6 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION =
          t8 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_PERMANENT_DELEGATE_EXTENSION_DELEGATE =
          t3 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_PERMANENT_DELEGATE_EXTENSION =
          t2 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_CLOSE_AUTHORITY_EXTENSION_AUTHORITY =
          t1 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_CLOSE_AUTHORITY_EXTENSION =
          t0 =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION_METADATA_ADDRESS =
          t$ =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION_AUTHORITY =
          tJ =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION =
          tZ =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION_MEMBER_ADDRESS =
          tQ =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION_AUTHORITY =
          tW =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION =
          tY =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION_GROUP_ADDRESS =
          tX =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION_AUTHORITY =
          tF =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION =
          tq =
          td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED_TOKEN_TOKEN_PROGRAM =
          tj =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_TOKEN_PROGRAM =
          tz =
          td.ANCHOR_ERROR__CONSTRAINT_TOKEN_TOKEN_PROGRAM =
          tK =
          td.ANCHOR_ERROR__CONSTRAINT_ACCOUNT_IS_NONE =
          tV =
          td.ANCHOR_ERROR__CONSTRAINT_SPACE =
          tG =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_DECIMALS =
          tB =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_FREEZE_AUTHORITY =
          tk =
          td.ANCHOR_ERROR__CONSTRAINT_MINT_MINT_AUTHORITY =
          tU =
          td.ANCHOR_ERROR__CONSTRAINT_TOKEN_OWNER =
          tH =
          td.ANCHOR_ERROR__CONSTRAINT_TOKEN_MINT =
          tL =
          td.ANCHOR_ERROR__CONSTRAINT_ZERO =
          tx =
          td.ANCHOR_ERROR__CONSTRAINT_ADDRESS =
          tP =
          td.ANCHOR_ERROR__CONSTRAINT_CLOSE =
          tD =
          td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED_INIT =
          tM =
          td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED =
          tb =
          td.ANCHOR_ERROR__CONSTRAINT_STATE =
          tS =
          td.ANCHOR_ERROR__CONSTRAINT_EXECUTABLE =
          tw =
          td.ANCHOR_ERROR__CONSTRAINT_SEEDS =
          tC =
          td.ANCHOR_ERROR__CONSTRAINT_RENT_EXEMPT =
          tv =
          td.ANCHOR_ERROR__CONSTRAINT_OWNER =
          tI =
          td.ANCHOR_ERROR__CONSTRAINT_RAW =
          tT =
          td.ANCHOR_ERROR__CONSTRAINT_SIGNER =
          tg =
          td.ANCHOR_ERROR__CONSTRAINT_HAS_ONE =
          tN =
          td.ANCHOR_ERROR__CONSTRAINT_MUT =
          tm =
          td.ANCHOR_ERROR__EVENT_INSTRUCTION_STUB =
          tO =
          td.ANCHOR_ERROR__IDL_ACCOUNT_NOT_EMPTY =
          tE =
          td.ANCHOR_ERROR__IDL_INSTRUCTION_INVALID_PROGRAM =
          ty =
          td.ANCHOR_ERROR__IDL_INSTRUCTION_STUB =
          tA =
          td.ANCHOR_ERROR__INSTRUCTION_DID_NOT_SERIALIZE =
          tR =
          td.ANCHOR_ERROR__INSTRUCTION_DID_NOT_DESERIALIZE =
          tf =
          td.ANCHOR_ERROR__INSTRUCTION_FALLBACK_NOT_FOUND =
          tp =
          td.ANCHOR_ERROR__INSTRUCTION_MISSING =
            void 0),
        t_ =
          (td.ANCHOR_ERROR__DEPRECATED =
          eT =
          td.ANCHOR_ERROR__INVALID_NUMERIC_CONVERSION =
          eg =
          td.ANCHOR_ERROR__TRYING_TO_INIT_PAYER_AS_PROGRAM_ACCOUNT =
          eN =
          td.ANCHOR_ERROR__DECLARED_PROGRAM_ID_MISMATCH =
          em =
          td.ANCHOR_ERROR__ACCOUNT_DUPLICATE_REALLOCS =
          eO =
          td.ANCHOR_ERROR__ACCOUNT_REALLOC_EXCEEDS_LIMIT =
          eE =
          td.ANCHOR_ERROR__ACCOUNT_SYSVAR_MISMATCH =
          ey =
          td.ANCHOR_ERROR__ACCOUNT_NOT_ASSOCIATED_TOKEN_ACCOUNT =
          eA =
          td.ANCHOR_ERROR__ACCOUNT_NOT_PROGRAM_DATA =
          eR =
          td.ANCHOR_ERROR__ACCOUNT_NOT_INITIALIZED =
          ef =
          td.ANCHOR_ERROR__ACCOUNT_NOT_SYSTEM_OWNED =
          ep =
          td.ANCHOR_ERROR__ACCOUNT_NOT_SIGNER =
          e_ =
          td.ANCHOR_ERROR__INVALID_PROGRAM_EXECUTABLE =
          eh =
          td.ANCHOR_ERROR__INVALID_PROGRAM_ID =
          ed =
          td.ANCHOR_ERROR__ACCOUNT_OWNED_BY_WRONG_PROGRAM =
          el =
          td.ANCHOR_ERROR__ACCOUNT_NOT_MUTABLE =
          eu =
          td.ANCHOR_ERROR__ACCOUNT_NOT_ENOUGH_KEYS =
          ec =
          td.ANCHOR_ERROR__ACCOUNT_DID_NOT_SERIALIZE =
          ea =
          td.ANCHOR_ERROR__ACCOUNT_DID_NOT_DESERIALIZE =
          es =
          td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_MISMATCH =
          eo =
          td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_NOT_FOUND =
          ei =
          td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_ALREADY_SET =
          en =
          td.ANCHOR_ERROR__REQUIRE_GTE_VIOLATED =
          er =
          td.ANCHOR_ERROR__REQUIRE_GT_VIOLATED =
          ee =
          td.ANCHOR_ERROR__REQUIRE_KEYS_NEQ_VIOLATED =
          et =
          td.ANCHOR_ERROR__REQUIRE_NEQ_VIOLATED =
          t7 =
          td.ANCHOR_ERROR__REQUIRE_KEYS_EQ_VIOLATED =
            void 0),
        tp = (td.ANCHOR_ERROR__INSTRUCTION_MISSING = 100),
        tf = (td.ANCHOR_ERROR__INSTRUCTION_FALLBACK_NOT_FOUND = 101),
        tR = (td.ANCHOR_ERROR__INSTRUCTION_DID_NOT_DESERIALIZE = 102),
        tA = (td.ANCHOR_ERROR__INSTRUCTION_DID_NOT_SERIALIZE = 103),
        ty = (td.ANCHOR_ERROR__IDL_INSTRUCTION_STUB = 1e3),
        tE = (td.ANCHOR_ERROR__IDL_INSTRUCTION_INVALID_PROGRAM = 1001),
        tO = (td.ANCHOR_ERROR__IDL_ACCOUNT_NOT_EMPTY = 1002),
        tm = (td.ANCHOR_ERROR__EVENT_INSTRUCTION_STUB = 1500),
        tN = (td.ANCHOR_ERROR__CONSTRAINT_MUT = 2e3),
        tg = (td.ANCHOR_ERROR__CONSTRAINT_HAS_ONE = 2001),
        tT = (td.ANCHOR_ERROR__CONSTRAINT_SIGNER = 2002),
        tI = (td.ANCHOR_ERROR__CONSTRAINT_RAW = 2003),
        tv = (td.ANCHOR_ERROR__CONSTRAINT_OWNER = 2004),
        tC = (td.ANCHOR_ERROR__CONSTRAINT_RENT_EXEMPT = 2005),
        tw = (td.ANCHOR_ERROR__CONSTRAINT_SEEDS = 2006),
        tS = (td.ANCHOR_ERROR__CONSTRAINT_EXECUTABLE = 2007),
        tb = (td.ANCHOR_ERROR__CONSTRAINT_STATE = 2008),
        tM = (td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED = 2009),
        tD = (td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED_INIT = 2010),
        tP = (td.ANCHOR_ERROR__CONSTRAINT_CLOSE = 2011),
        tx = (td.ANCHOR_ERROR__CONSTRAINT_ADDRESS = 2012),
        tL = (td.ANCHOR_ERROR__CONSTRAINT_ZERO = 2013),
        tH = (td.ANCHOR_ERROR__CONSTRAINT_TOKEN_MINT = 2014),
        tU = (td.ANCHOR_ERROR__CONSTRAINT_TOKEN_OWNER = 2015),
        tk = (td.ANCHOR_ERROR__CONSTRAINT_MINT_MINT_AUTHORITY = 2016),
        tB = (td.ANCHOR_ERROR__CONSTRAINT_MINT_FREEZE_AUTHORITY = 2017),
        tG = (td.ANCHOR_ERROR__CONSTRAINT_MINT_DECIMALS = 2018),
        tV = (td.ANCHOR_ERROR__CONSTRAINT_SPACE = 2019),
        tK = (td.ANCHOR_ERROR__CONSTRAINT_ACCOUNT_IS_NONE = 2020),
        tz = (td.ANCHOR_ERROR__CONSTRAINT_TOKEN_TOKEN_PROGRAM = 2021),
        tj = (td.ANCHOR_ERROR__CONSTRAINT_MINT_TOKEN_PROGRAM = 2022),
        tq =
          (td.ANCHOR_ERROR__CONSTRAINT_ASSOCIATED_TOKEN_TOKEN_PROGRAM = 2023),
        tF = (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION = 2024),
        tX =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION_AUTHORITY = 2025),
        tY =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_POINTER_EXTENSION_GROUP_ADDRESS = 2026),
        tW =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION = 2027),
        tQ =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION_AUTHORITY = 2028),
        tZ =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_GROUP_MEMBER_POINTER_EXTENSION_MEMBER_ADDRESS = 2029),
        tJ =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION = 2030),
        t$ =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION_AUTHORITY = 2031),
        t0 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_METADATA_POINTER_EXTENSION_METADATA_ADDRESS = 2032),
        t1 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_CLOSE_AUTHORITY_EXTENSION = 2033),
        t2 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_CLOSE_AUTHORITY_EXTENSION_AUTHORITY = 2034),
        t3 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_PERMANENT_DELEGATE_EXTENSION = 2035),
        t8 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_PERMANENT_DELEGATE_EXTENSION_DELEGATE = 2036),
        t6 = (td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION = 2037),
        t4 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION_AUTHORITY = 2038),
        t5 =
          (td.ANCHOR_ERROR__CONSTRAINT_MINT_TRANSFER_HOOK_EXTENSION_PROGRAM_ID = 2039),
        t9 = (td.ANCHOR_ERROR__REQUIRE_VIOLATED = 2500);
      th = td.ANCHOR_ERROR__REQUIRE_EQ_VIOLATED = 2501;
      var t7 = (td.ANCHOR_ERROR__REQUIRE_KEYS_EQ_VIOLATED = 2502),
        et = (td.ANCHOR_ERROR__REQUIRE_NEQ_VIOLATED = 2503),
        ee = (td.ANCHOR_ERROR__REQUIRE_KEYS_NEQ_VIOLATED = 2504),
        er = (td.ANCHOR_ERROR__REQUIRE_GT_VIOLATED = 2505),
        en = (td.ANCHOR_ERROR__REQUIRE_GTE_VIOLATED = 2506),
        ei = (td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_ALREADY_SET = 3e3),
        eo = (td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_NOT_FOUND = 3001),
        es = (td.ANCHOR_ERROR__ACCOUNT_DISCRIMINATOR_MISMATCH = 3002),
        ea = (td.ANCHOR_ERROR__ACCOUNT_DID_NOT_DESERIALIZE = 3003),
        ec = (td.ANCHOR_ERROR__ACCOUNT_DID_NOT_SERIALIZE = 3004),
        eu = (td.ANCHOR_ERROR__ACCOUNT_NOT_ENOUGH_KEYS = 3005),
        el = (td.ANCHOR_ERROR__ACCOUNT_NOT_MUTABLE = 3006),
        ed = (td.ANCHOR_ERROR__ACCOUNT_OWNED_BY_WRONG_PROGRAM = 3007),
        eh = (td.ANCHOR_ERROR__INVALID_PROGRAM_ID = 3008),
        e_ = (td.ANCHOR_ERROR__INVALID_PROGRAM_EXECUTABLE = 3009),
        ep = (td.ANCHOR_ERROR__ACCOUNT_NOT_SIGNER = 3010),
        ef = (td.ANCHOR_ERROR__ACCOUNT_NOT_SYSTEM_OWNED = 3011),
        eR = (td.ANCHOR_ERROR__ACCOUNT_NOT_INITIALIZED = 3012),
        eA = (td.ANCHOR_ERROR__ACCOUNT_NOT_PROGRAM_DATA = 3013),
        ey = (td.ANCHOR_ERROR__ACCOUNT_NOT_ASSOCIATED_TOKEN_ACCOUNT = 3014),
        eE = (td.ANCHOR_ERROR__ACCOUNT_SYSVAR_MISMATCH = 3015),
        eO = (td.ANCHOR_ERROR__ACCOUNT_REALLOC_EXCEEDS_LIMIT = 3016),
        em = (td.ANCHOR_ERROR__ACCOUNT_DUPLICATE_REALLOCS = 3017),
        eN = (td.ANCHOR_ERROR__DECLARED_PROGRAM_ID_MISMATCH = 4100),
        eg = (td.ANCHOR_ERROR__TRYING_TO_INIT_PAYER_AS_PROGRAM_ACCOUNT = 4101),
        eT = (td.ANCHOR_ERROR__INVALID_NUMERIC_CONVERSION = 4102);
      t_ = td.ANCHOR_ERROR__DEPRECATED = 5e3;
      let eI = new Map();
      function ev(t) {
        return void 0 !== eI.get(t);
      }
      class eC extends Error {
        constructor(t) {
          super(t), (this.name = "IdlError");
        }
      }
      class ew {
        static parse(t) {
          var e;
          let r = /^Program (\w*) invoke/,
            n = /^Program \w* success/,
            i = [];
          for (let o = 0; o < t.length; o++) {
            if (n.exec(t[o])) {
              i.pop();
              continue;
            }
            let s = null === (e = r.exec(t[o])) || void 0 === e ? void 0 : e[1];
            s && i.push(new _.PublicKey(s));
          }
          return new ew(i);
        }
        constructor(t) {
          this.stack = t;
        }
      }
      class eS extends Error {
        static parse(t) {
          let e;
          if (!t) return null;
          let r = t.findIndex((t) => t.startsWith("Program log: AnchorError"));
          if (-1 === r) return null;
          let n = t[r],
            i = [n];
          if (r + 1 < t.length) {
            if ("Program log: Left:" === t[r + 1]) {
              let n = /^Program log: (.*)$/,
                o = n.exec(t[r + 2])[1],
                s = n.exec(t[r + 4])[1];
              (e = [new _.PublicKey(o), new _.PublicKey(s)]),
                i.push(...t.slice(r + 1, r + 5));
            } else if (t[r + 1].startsWith("Program log: Left:")) {
              let n = /^Program log: (Left|Right): (.*)$/,
                o = n.exec(t[r + 1])[2],
                s = n.exec(t[r + 2])[2];
              i.push(...t.slice(r + 1, r + 3)), (e = [o, s]);
            }
          }
          let o =
              /^Program log: AnchorError occurred\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec(
                n
              ),
            s =
              /^Program log: AnchorError thrown in (.*):(\d*)\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec(
                n
              ),
            a =
              /^Program log: AnchorError caused by account: (.*)\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec(
                n
              );
          if (o) {
            let [r, n, s] = o.slice(1, 4);
            return new eS({ code: r, number: parseInt(n) }, s, i, t, void 0, e);
          }
          if (s) {
            let [r, n, o, a, c] = s.slice(1, 6);
            return new eS(
              { code: o, number: parseInt(a) },
              c,
              i,
              t,
              { file: r, line: parseInt(n) },
              e
            );
          }
          if (!a) return null;
          {
            let [r, n, o, s] = a.slice(1, 5);
            return new eS({ code: n, number: parseInt(o) }, s, i, t, r, e);
          }
        }
        get program() {
          return this._programErrorStack.stack[
            this._programErrorStack.stack.length - 1
          ];
        }
        get programErrorStack() {
          return this._programErrorStack.stack;
        }
        toString() {
          return this.message;
        }
        constructor(t, e, r, n, i, o) {
          super(r.join("\n").replace("Program log: ", "")),
            (this.errorLogs = r),
            (this.logs = n),
            (this.error = {
              errorCode: t,
              errorMessage: e,
              comparedValues: o,
              origin: i,
            }),
            (this._programErrorStack = ew.parse(n));
        }
      }
      class eb extends Error {
        static parse(t, e) {
          let r, n;
          let i = t.toString();
          if (i.includes("custom program error:")) {
            let t = i.split("custom program error: ");
            if (2 !== t.length) return null;
            r = t[1];
          } else {
            let t = i.match(/"Custom":([0-9]+)}/g);
            if (!t || t.length > 1) return null;
            r = t[0].match(/([0-9]+)/g)[0];
          }
          try {
            n = parseInt(r);
          } catch (t) {
            return null;
          }
          let o = e.get(n);
          return void 0 !== o || void 0 !== (o = eP.get(n))
            ? new eb(n, o, t.logs)
            : null;
        }
        get program() {
          var t;
          return null === (t = this._programErrorStack) || void 0 === t
            ? void 0
            : t.stack[this._programErrorStack.stack.length - 1];
        }
        get programErrorStack() {
          var t;
          return null === (t = this._programErrorStack) || void 0 === t
            ? void 0
            : t.stack;
        }
        toString() {
          return this.msg;
        }
        constructor(t, e, r) {
          super(),
            (this.code = t),
            (this.msg = e),
            (this.logs = r),
            r && (this._programErrorStack = ew.parse(r));
        }
      }
      function eM(t, e) {
        ev("debug-logs") && console.log("Translating error:", t);
        let r = eS.parse(t.logs);
        return r
          ? r
          : eb.parse(t, e) ||
              (t.logs
                ? ((t.programErrorStack = ew.parse(t.logs)),
                  new Proxy(t, {
                    get: function (e, r) {
                      return "programErrorStack" === r
                        ? e.programErrorStack.stack
                        : "program" === r
                        ? e.programErrorStack.stack[
                            t.programErrorStack.stack.length - 1
                          ]
                        : Reflect.get(...arguments);
                    },
                  }))
                : t);
      }
      let eD = {
          InstructionMissing: tp,
          InstructionFallbackNotFound: tf,
          InstructionDidNotDeserialize: tR,
          InstructionDidNotSerialize: tA,
          IdlInstructionStub: ty,
          IdlInstructionInvalidProgram: tE,
          IdlAccountNotEmpty: tO,
          EventInstructionStub: tm,
          ConstraintMut: tN,
          ConstraintHasOne: tg,
          ConstraintSigner: tT,
          ConstraintRaw: tI,
          ConstraintOwner: tv,
          ConstraintRentExempt: tC,
          ConstraintSeeds: tw,
          ConstraintExecutable: tS,
          ConstraintState: tb,
          ConstraintAssociated: tM,
          ConstraintAssociatedInit: tD,
          ConstraintClose: tP,
          ConstraintAddress: tx,
          ConstraintZero: tL,
          ConstraintTokenMint: tH,
          ConstraintTokenOwner: tU,
          ConstraintMintMintAuthority: tk,
          ConstraintMintFreezeAuthority: tB,
          ConstraintMintDecimals: tG,
          ConstraintSpace: tV,
          ConstraintAccountIsNone: tK,
          ConstraintTokenTokenProgram: tz,
          ConstraintMintTokenProgram: tj,
          ConstraintAssociatedTokenTokenProgram: tq,
          ConstraintMintGroupPointerExtension: tF,
          ConstraintMintGroupPointerExtensionAuthority: tX,
          ConstraintMintGroupPointerExtensionGroupAddress: tY,
          ConstraintMintGroupMemberPointerExtension: tW,
          ConstraintMintGroupMemberPointerExtensionAuthority: tQ,
          ConstraintMintGroupMemberPointerExtensionMemberAddress: tZ,
          ConstraintMintMetadataPointerExtension: tJ,
          ConstraintMintMetadataPointerExtensionAuthority: t$,
          ConstraintMintMetadataPointerExtensionMetadataAddress: t0,
          ConstraintMintCloseAuthorityExtension: t1,
          ConstraintMintCloseAuthorityExtensionAuthority: t2,
          ConstraintMintPermanentDelegateExtension: t3,
          ConstraintMintPermanentDelegateExtensionDelegate: t8,
          ConstraintMintTransferHookExtension: t6,
          ConstraintMintTransferHookExtensionAuthority: t4,
          ConstraintMintTransferHookExtensionProgramId: t5,
          RequireViolated: t9,
          RequireEqViolated: th,
          RequireKeysEqViolated: t7,
          RequireNeqViolated: et,
          RequireKeysNeqViolated: ee,
          RequireGtViolated: er,
          RequireGteViolated: en,
          AccountDiscriminatorAlreadySet: ei,
          AccountDiscriminatorNotFound: eo,
          AccountDiscriminatorMismatch: es,
          AccountDidNotDeserialize: ea,
          AccountDidNotSerialize: ec,
          AccountNotEnoughKeys: eu,
          AccountNotMutable: el,
          AccountOwnedByWrongProgram: ed,
          InvalidProgramId: eh,
          InvalidProgramExecutable: e_,
          AccountNotSigner: ep,
          AccountNotSystemOwned: ef,
          AccountNotInitialized: eR,
          AccountNotProgramData: eA,
          AccountNotAssociatedTokenAccount: ey,
          AccountSysvarMismatch: eE,
          AccountReallocExceedsLimit: eO,
          AccountDuplicateReallocs: em,
          DeclaredProgramIdMismatch: eN,
          TryingToInitPayerAsProgramAccount: eg,
          InvalidNumericConversion: eT,
          Deprecated: t_,
        },
        eP = new Map([
          [eD.InstructionMissing, "8 byte instruction identifier not provided"],
          [
            eD.InstructionFallbackNotFound,
            "Fallback functions are not supported",
          ],
          [
            eD.InstructionDidNotDeserialize,
            "The program could not deserialize the given instruction",
          ],
          [
            eD.InstructionDidNotSerialize,
            "The program could not serialize the given instruction",
          ],
          [
            eD.IdlInstructionStub,
            "The program was compiled without idl instructions",
          ],
          [
            eD.IdlInstructionInvalidProgram,
            "The transaction was given an invalid program for the IDL instruction",
          ],
          [
            eD.IdlAccountNotEmpty,
            "IDL account must be empty in order to resize, try closing first",
          ],
          [
            eD.EventInstructionStub,
            "The program was compiled without `event-cpi` feature",
          ],
          [eD.ConstraintMut, "A mut constraint was violated"],
          [eD.ConstraintHasOne, "A has one constraint was violated"],
          [eD.ConstraintSigner, "A signer constraint was violated"],
          [eD.ConstraintRaw, "A raw constraint was violated"],
          [eD.ConstraintOwner, "An owner constraint was violated"],
          [eD.ConstraintRentExempt, "A rent exemption constraint was violated"],
          [eD.ConstraintSeeds, "A seeds constraint was violated"],
          [eD.ConstraintExecutable, "An executable constraint was violated"],
          [
            eD.ConstraintState,
            "Deprecated Error, feel free to replace with something else",
          ],
          [eD.ConstraintAssociated, "An associated constraint was violated"],
          [
            eD.ConstraintAssociatedInit,
            "An associated init constraint was violated",
          ],
          [eD.ConstraintClose, "A close constraint was violated"],
          [eD.ConstraintAddress, "An address constraint was violated"],
          [eD.ConstraintZero, "Expected zero account discriminant"],
          [eD.ConstraintTokenMint, "A token mint constraint was violated"],
          [eD.ConstraintTokenOwner, "A token owner constraint was violated"],
          [
            eD.ConstraintMintMintAuthority,
            "A mint mint authority constraint was violated",
          ],
          [
            eD.ConstraintMintFreezeAuthority,
            "A mint freeze authority constraint was violated",
          ],
          [
            eD.ConstraintMintDecimals,
            "A mint decimals constraint was violated",
          ],
          [eD.ConstraintSpace, "A space constraint was violated"],
          [
            eD.ConstraintAccountIsNone,
            "A required account for the constraint is None",
          ],
          [
            eD.ConstraintTokenTokenProgram,
            "A token account token program constraint was violated",
          ],
          [
            eD.ConstraintMintTokenProgram,
            "A mint token program constraint was violated",
          ],
          [
            eD.ConstraintAssociatedTokenTokenProgram,
            "An associated token account token program constraint was violated",
          ],
          [
            eD.ConstraintMintGroupPointerExtension,
            "A group pointer extension constraint was violated",
          ],
          [
            eD.ConstraintMintGroupPointerExtensionAuthority,
            "A group pointer extension authority constraint was violated",
          ],
          [
            eD.ConstraintMintGroupPointerExtensionGroupAddress,
            "A group pointer extension group address constraint was violated",
          ],
          [
            eD.ConstraintMintGroupMemberPointerExtension,
            "A group member pointer extension constraint was violated",
          ],
          [
            eD.ConstraintMintGroupMemberPointerExtensionAuthority,
            "A group member pointer extension authority constraint was violated",
          ],
          [
            eD.ConstraintMintGroupMemberPointerExtensionMemberAddress,
            "A group member pointer extension group address constraint was violated",
          ],
          [
            eD.ConstraintMintMetadataPointerExtension,
            "A metadata pointer extension constraint was violated",
          ],
          [
            eD.ConstraintMintMetadataPointerExtensionAuthority,
            "A metadata pointer extension authority constraint was violated",
          ],
          [
            eD.ConstraintMintMetadataPointerExtensionMetadataAddress,
            "A metadata pointer extension metadata address constraint was violated",
          ],
          [
            eD.ConstraintMintCloseAuthorityExtension,
            "A close authority constraint was violated",
          ],
          [
            eD.ConstraintMintCloseAuthorityExtensionAuthority,
            "A close authority extension authority constraint was violated",
          ],
          [
            eD.ConstraintMintPermanentDelegateExtension,
            "A permanent delegate extension constraint was violated",
          ],
          [
            eD.ConstraintMintPermanentDelegateExtensionDelegate,
            "A permanent delegate extension delegate constraint was violated",
          ],
          [
            eD.ConstraintMintTransferHookExtension,
            "A transfer hook extension constraint was violated",
          ],
          [
            eD.ConstraintMintTransferHookExtensionAuthority,
            "A transfer hook extension authority constraint was violated",
          ],
          [
            eD.ConstraintMintTransferHookExtensionProgramId,
            "A transfer hook extension transfer hook program id constraint was violated",
          ],
          [eD.RequireViolated, "A require expression was violated"],
          [eD.RequireEqViolated, "A require_eq expression was violated"],
          [
            eD.RequireKeysEqViolated,
            "A require_keys_eq expression was violated",
          ],
          [eD.RequireNeqViolated, "A require_neq expression was violated"],
          [
            eD.RequireKeysNeqViolated,
            "A require_keys_neq expression was violated",
          ],
          [eD.RequireGtViolated, "A require_gt expression was violated"],
          [eD.RequireGteViolated, "A require_gte expression was violated"],
          [
            eD.AccountDiscriminatorAlreadySet,
            "The account discriminator was already set on this account",
          ],
          [
            eD.AccountDiscriminatorNotFound,
            "No 8 byte discriminator was found on the account",
          ],
          [
            eD.AccountDiscriminatorMismatch,
            "8 byte discriminator did not match what was expected",
          ],
          [eD.AccountDidNotDeserialize, "Failed to deserialize the account"],
          [eD.AccountDidNotSerialize, "Failed to serialize the account"],
          [
            eD.AccountNotEnoughKeys,
            "Not enough account keys given to the instruction",
          ],
          [eD.AccountNotMutable, "The given account is not mutable"],
          [
            eD.AccountOwnedByWrongProgram,
            "The given account is owned by a different program than expected",
          ],
          [eD.InvalidProgramId, "Program ID was not as expected"],
          [eD.InvalidProgramExecutable, "Program account is not executable"],
          [eD.AccountNotSigner, "The given account did not sign"],
          [
            eD.AccountNotSystemOwned,
            "The given account is not owned by the system program",
          ],
          [
            eD.AccountNotInitialized,
            "The program expected this account to be already initialized",
          ],
          [
            eD.AccountNotProgramData,
            "The given account is not a program data account",
          ],
          [
            eD.AccountNotAssociatedTokenAccount,
            "The given account is not the associated token account",
          ],
          [
            eD.AccountSysvarMismatch,
            "The given public key does not match the required sysvar",
          ],
          [
            eD.AccountReallocExceedsLimit,
            "The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit",
          ],
          [
            eD.AccountDuplicateReallocs,
            "The account was duplicated for more than one reallocation",
          ],
          [
            eD.DeclaredProgramIdMismatch,
            "The declared program id does not match the actual program id",
          ],
          [
            eD.TryingToInitPayerAsProgramAccount,
            "You cannot/should not initialize the payer account as a program account",
          ],
          [
            eD.InvalidNumericConversion,
            "The program could not perform the numeric conversion, out of range integral type conversion attempted",
          ],
          [
            eD.Deprecated,
            "The API being used is deprecated and should no longer be used",
          ],
        ]);
      class ex {
        static fieldLayout(t) {
          let e =
              arguments.length > 1 && void 0 !== arguments[1]
                ? arguments[1]
                : [],
            r = arguments.length > 2 ? arguments[2] : void 0,
            n = t.name;
          switch (t.type) {
            case "bool":
              return O.Xg(n);
            case "u8":
              return O.u8(n);
            case "i8":
              return O.i8(n);
            case "u16":
              return O.KB(n);
            case "i16":
              return O.TQ(n);
            case "u32":
              return O.Jq(n);
            case "i32":
              return O.kx(n);
            case "f32":
              return O.xn(n);
            case "u64":
              return O.AW(n);
            case "i64":
              return O.fO(n);
            case "f64":
              return O.eh(n);
            case "u128":
              return O.z7(n);
            case "i128":
              return O.bH(n);
            case "u256":
              return O.Ks(n);
            case "i256":
              return O.jn(n);
            case "bytes":
              return O.t3(n);
            case "string":
              return O.Bd(n);
            case "pubkey":
              return O.ZL(n);
            default:
              if ("option" in t.type)
                return O.Kw(ex.fieldLayout({ type: t.type.option }, e, r), n);
              if ("vec" in t.type)
                return O.Bh(ex.fieldLayout({ type: t.type.vec }, e, r), n);
              if ("array" in t.type) {
                let [i, o] = t.type.array;
                return (
                  (o = ex.resolveArrayLen(o, r)),
                  O.IX(ex.fieldLayout({ type: i }, e, r), o, n)
                );
              }
              if ("defined" in t.type) {
                if (!e) throw new eC("User defined types not provided");
                let i = t.type.defined.name,
                  o = e.find((t) => t.name === i);
                if (!o) throw new eC("Type not found: ".concat(t.name));
                return ex.typeDefLayout({
                  typeDef: o,
                  types: e,
                  genericArgs: null != r ? r : t.type.defined.generics,
                  name: n,
                });
              }
              if ("generic" in t.type) {
                let n = null == r ? void 0 : r.at(0);
                if ((null == n ? void 0 : n.kind) !== "type")
                  throw new eC("Invalid generic field: ".concat(t.name));
                return ex.fieldLayout({ ...t, type: n.type }, e);
              }
              throw new eC(
                "Not yet implemented: ".concat(JSON.stringify(t.type))
              );
          }
        }
        static typeDefLayout(t) {
          let { typeDef: e, types: r, name: n, genericArgs: i } = t;
          switch (e.type.kind) {
            case "struct": {
              let t = D(
                e.type.fields,
                () => [],
                (t) =>
                  t.map((t) => {
                    let n = i
                      ? ex.resolveGenericArgs({
                          type: t.type,
                          typeDef: e,
                          genericArgs: i,
                        })
                      : i;
                    return ex.fieldLayout(t, r, n);
                  }),
                (t) =>
                  t.map((t, n) => {
                    let o = i
                      ? ex.resolveGenericArgs({
                          type: t,
                          typeDef: e,
                          genericArgs: i,
                        })
                      : i;
                    return ex.fieldLayout(
                      { name: n.toString(), type: t },
                      r,
                      o
                    );
                  })
              );
              return O.n_(t, n);
            }
            case "enum": {
              let t = e.type.variants.map((t) => {
                let n = D(
                  t.fields,
                  () => [],
                  (t) =>
                    t.map((t) => {
                      let n = i
                        ? ex.resolveGenericArgs({
                            type: t.type,
                            typeDef: e,
                            genericArgs: i,
                          })
                        : i;
                      return ex.fieldLayout(t, r, n);
                    }),
                  (t) =>
                    t.map((t, n) => {
                      let o = i
                        ? ex.resolveGenericArgs({
                            type: t,
                            typeDef: e,
                            genericArgs: i,
                          })
                        : i;
                      return ex.fieldLayout(
                        { name: n.toString(), type: t },
                        r,
                        o
                      );
                    })
                );
                return O.n_(n, t.name);
              });
              if (void 0 !== n) return O.Ez(t).replicate(n);
              return O.Ez(t, n);
            }
            case "type":
              return ex.fieldLayout({ type: e.type.alias, name: n }, r);
          }
        }
        static typeSize(t, e, r) {
          var n;
          switch (t) {
            case "bool":
            case "u8":
            case "i8":
            case "bytes":
            case "string":
              return 1;
            case "i16":
            case "u16":
              return 2;
            case "u32":
            case "i32":
            case "f32":
              return 4;
            case "u64":
            case "i64":
            case "f64":
              return 8;
            case "u128":
            case "i128":
              return 16;
            case "u256":
            case "i256":
            case "pubkey":
              return 32;
            default:
              if ("option" in t) return 1 + ex.typeSize(t.option, e, r);
              if ("coption" in t) return 4 + ex.typeSize(t.coption, e, r);
              if ("vec" in t) return 1;
              if ("array" in t) {
                let [n, i] = t.array;
                return (i = ex.resolveArrayLen(i, r)), ex.typeSize(n, e, r) * i;
              }
              if ("defined" in t) {
                let i =
                  null === (n = e.types) || void 0 === n
                    ? void 0
                    : n.find((e) => e.name === t.defined.name);
                if (!i)
                  throw new eC("Type not found: ".concat(JSON.stringify(t)));
                let o = (n) => {
                  let o = null != r ? r : t.defined.generics,
                    s = o
                      ? ex.resolveGenericArgs({
                          type: n,
                          typeDef: i,
                          genericArgs: o,
                        })
                      : o;
                  return ex.typeSize(n, e, s);
                };
                switch (i.type.kind) {
                  case "struct":
                    return D(
                      i.type.fields,
                      () => [0],
                      (t) => t.map((t) => o(t.type)),
                      (t) => t.map((t) => o(t))
                    ).reduce((t, e) => t + e, 0);
                  case "enum":
                    return (
                      Math.max(
                        ...i.type.variants.map((t) =>
                          D(
                            t.fields,
                            () => [0],
                            (t) => t.map((t) => o(t.type)),
                            (t) => t.map((t) => o(t))
                          ).reduce((t, e) => t + e, 0)
                        )
                      ) + 1
                    );
                  case "type":
                    return ex.typeSize(i.type.alias, e, r);
                }
              }
              if ("generic" in t) {
                let n = null == r ? void 0 : r.at(0);
                if ((null == n ? void 0 : n.kind) !== "type")
                  throw new eC("Invalid generic: ".concat(t.generic));
                return ex.typeSize(n.type, e, r);
              }
              throw Error("Invalid type ".concat(JSON.stringify(t)));
          }
        }
        static resolveArrayLen(t, e) {
          if ("number" == typeof t) return t;
          if (e) {
            let r = e.find((t) => "const" === t.kind);
            (null == r ? void 0 : r.kind) === "const" && (t = +r.value);
          }
          if ("number" != typeof t)
            throw new eC("Generic array length did not resolve");
          return t;
        }
        static resolveGenericArgs(t) {
          let { type: e, typeDef: r, genericArgs: n, isDefined: i } = t;
          if ("object" != typeof e) return null;
          for (let t in r.generics) {
            let o = r.generics[t];
            if ("generic" in e && o.name === e.generic) return [n[t]];
            if ("option" in e) {
              let t = ex.resolveGenericArgs({
                type: e.option,
                typeDef: r,
                genericArgs: n,
                isDefined: i,
              });
              if (!t || !i) return t;
              if ("type" === t[0].kind)
                return [{ kind: "type", type: { option: t[0].type } }];
            }
            if ("vec" in e) {
              let t = ex.resolveGenericArgs({
                type: e.vec,
                typeDef: r,
                genericArgs: n,
                isDefined: i,
              });
              if (!t || !i) return t;
              if ("type" === t[0].kind)
                return [{ kind: "type", type: { vec: t[0].type } }];
            }
            if ("array" in e) {
              let [s, a] = e.array,
                c = "object" == typeof a,
                u = ex.resolveGenericArgs({
                  type: s,
                  typeDef: r,
                  genericArgs: n,
                  isDefined: i,
                });
              if (u) {
                for (let e in r.generics.slice(+t)) {
                  let i = +t + +e;
                  c && r.generics[i].name === a.generic && u.push(n[i]);
                }
                if (!i) return u;
                if ("type" === u[0].kind && "const" === u[1].kind)
                  return [
                    { kind: "type", type: { array: [u[0].type, +u[1].value] } },
                  ];
              }
              if (c && o.name === a.generic) {
                let e = n[t];
                if (!i) return [e];
                return [{ kind: "type", type: { array: [s, +e.value] } }];
              }
              break;
            }
            if ("defined" in e) {
              if (!e.defined.generics) return null;
              return e.defined.generics
                .flatMap((t) => {
                  switch (t.kind) {
                    case "type":
                      return ex.resolveGenericArgs({
                        type: t.type,
                        typeDef: r,
                        genericArgs: n,
                        isDefined: !0,
                      });
                    case "const":
                      return [t];
                  }
                })
                .filter((t) => null !== t);
            }
          }
          return null;
        }
      }
      class eL {
        encode(t, e) {
          let r = h.Buffer.alloc(1e3),
            n = this.ixLayouts.get(t);
          if (!n) throw Error("Unknown method: ".concat(t));
          let i = n.layout.encode(e, r),
            o = r.slice(0, i);
          return h.Buffer.concat([h.Buffer.from(n.discriminator), o]);
        }
        decode(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1]
              ? arguments[1]
              : "hex";
          "string" == typeof t &&
            (t = "hex" === e ? h.Buffer.from(t, "hex") : A().decode(t));
          let r = t.slice(0, eU),
            n = t.slice(eU),
            i = this.sighashLayouts.get(A().encode(r));
          return i ? { name: i.name, data: i.layout.decode(n) } : null;
        }
        format(t, e) {
          return eH.format(t, e, this.idl);
        }
        constructor(t) {
          this.idl = t;
          let e = t.instructions.map((e) => {
            let r = e.name,
              n = e.args.map((e) => ex.fieldLayout(e, t.types)),
              i = O.n_(n, r);
            return [r, { discriminator: e.discriminator, layout: i }];
          });
          this.ixLayouts = new Map(e);
          let r = e.map((t) => {
            let [e, { discriminator: r, layout: n }] = t;
            return [A().encode(r), { name: e, layout: n }];
          });
          this.sighashLayouts = new Map(r);
        }
      }
      class eH {
        static format(t, e, r) {
          let n = r.instructions.find((e) => t.name === e.name);
          if (!n) return console.error("Invalid instruction given"), null;
          let i = n.args.map((e) => ({
              name: e.name,
              type: eH.formatIdlType(e.type),
              data: eH.formatIdlData(e, t.data[e.name], r.types),
            })),
            o = eH.flattenIdlAccounts(n.accounts);
          return {
            args: i,
            accounts: e.map((t, e) =>
              e < o.length ? { name: o[e].name, ...t } : { name: void 0, ...t }
            ),
          };
        }
        static formatIdlType(t) {
          if ("string" == typeof t) return t;
          if ("option" in t)
            return "Option<".concat(this.formatIdlType(t.option), ">");
          if ("coption" in t)
            return "COption<".concat(this.formatIdlType(t.coption), ">");
          if ("vec" in t) return "Vec<".concat(this.formatIdlType(t.vec), ">");
          if ("array" in t)
            return "Array<".concat(t.array[0], "; ").concat(t.array[1], ">");
          if ("defined" in t) {
            let e = t.defined.name;
            if (t.defined.generics) {
              let r = t.defined.generics
                .map((t) => {
                  switch (t.kind) {
                    case "type":
                      return eH.formatIdlType(t.type);
                    case "const":
                      return t.value;
                  }
                })
                .join(", ");
              return "".concat(e, "<").concat(r, ">");
            }
            return e;
          }
          throw Error("Unknown IDL type: ".concat(t));
        }
        static formatIdlData(t, e, r) {
          if ("string" == typeof t.type) return e.toString();
          if ("vec" in t.type)
            return (
              "[" +
              e
                .map((e) =>
                  this.formatIdlData({ name: "", type: t.type.vec }, e, r)
                )
                .join(", ") +
              "]"
            );
          if ("option" in t.type)
            return null === e
              ? "null"
              : this.formatIdlData({ name: "", type: t.type.option }, e, r);
          if ("defined" in t.type) {
            if (!r) throw Error("User defined types not provided");
            let n = t.type.defined.name,
              i = r.find((t) => t.name === n);
            if (!i) throw Error("Type not found: ".concat(n));
            return eH.formatIdlDataDefined(i, e, r);
          }
          return "unknown";
        }
        static formatIdlDataDefined(t, e, r) {
          switch (t.type.kind) {
            case "struct":
              return (
                "{ " +
                D(
                  t.type.fields,
                  () => "",
                  (t) =>
                    Object.entries(e)
                      .map((e) => {
                        let [n, i] = e,
                          o = t.find((t) => t.name === n);
                        if (!o) throw Error("Field not found: ".concat(n));
                        return n + ": " + eH.formatIdlData(o, i, r);
                      })
                      .join(", "),
                  (t) =>
                    Object.entries(e)
                      .map((e) => {
                        let [n, i] = e;
                        return (
                          n +
                          ": " +
                          eH.formatIdlData({ name: "", type: t[n] }, i, r)
                        );
                      })
                      .join(", ")
                ) +
                " }"
              );
            case "enum": {
              let n = Object.keys(e)[0],
                i = t.type.variants.find((t) => t.name === n);
              if (!i) throw Error("Unable to find variant: ".concat(n));
              let o = e[n];
              return D(
                i.fields,
                () => n,
                (t) => {
                  let e = Object.keys(o)
                    .map((e) => {
                      let n = o[e],
                        i = t.find((t) => t.name === e);
                      if (!i) throw Error("Field not found: ".concat(e));
                      return e + ": " + eH.formatIdlData(i, n, r);
                    })
                    .join(", ");
                  return "".concat(n, " { ").concat(e, " }");
                },
                (t) => {
                  let e = Object.entries(o)
                    .map((e) => {
                      let [n, i] = e;
                      return (
                        n +
                        ": " +
                        eH.formatIdlData({ name: "", type: t[n] }, i, r)
                      );
                    })
                    .join(", ");
                  return "".concat(n, " { ").concat(e, " }");
                }
              );
            }
            case "type":
              return eH.formatIdlType(t.type.alias);
          }
        }
        static flattenIdlAccounts(t, e) {
          return t
            .map((t) => {
              let r = (function (t) {
                let e = t.replace(/([A-Z])/g, " $1");
                return e.charAt(0).toUpperCase() + e.slice(1);
              })(t.name);
              if (!t.hasOwnProperty("accounts"))
                return { ...t, name: e ? "".concat(e, " > ").concat(r) : r };
              {
                let n = e ? "".concat(e, " > ").concat(r) : r;
                return eH.flattenIdlAccounts(t.accounts, n);
              }
            })
            .flat();
        }
      }
      let eU = 8;
      class ek {
        async encode(t, e) {
          let r = h.Buffer.alloc(1e3),
            n = this.accountLayouts.get(t);
          if (!n) throw Error("Unknown account: ".concat(t));
          let i = n.encode(e, r),
            o = r.slice(0, i),
            s = this.accountDiscriminator(t);
          return h.Buffer.concat([s, o]);
        }
        decode(t, e) {
          if (this.accountDiscriminator(t).compare(e.slice(0, eU)))
            throw Error("Invalid account discriminator");
          return this.decodeUnchecked(t, e);
        }
        decodeAny(t) {
          let e = t.slice(0, eU),
            r = Array.from(this.accountLayouts.keys()).find((t) =>
              this.accountDiscriminator(t).equals(e)
            );
          if (!r) throw Error("Account not found");
          return this.decodeUnchecked(r, t);
        }
        decodeUnchecked(t, e) {
          let r = e.subarray(eU),
            n = this.accountLayouts.get(t);
          if (!n) throw Error("Unknown account: ".concat(t));
          return n.decode(r);
        }
        memcmp(t, e) {
          let r = this.accountDiscriminator(t);
          return {
            offset: 0,
            bytes: A().encode(e ? h.Buffer.concat([r, e]) : r),
          };
        }
        size(t) {
          return eU + ex.typeSize({ defined: { name: t } }, this.idl);
        }
        accountDiscriminator(t) {
          var e;
          let r =
            null === (e = this.idl.accounts) || void 0 === e
              ? void 0
              : e.find((e) => e.name === t);
          if (!r) throw Error("Account not found: ".concat(t));
          return h.Buffer.from(r.discriminator);
        }
        constructor(t) {
          if (((this.idl = t), !t.accounts)) {
            this.accountLayouts = new Map();
            return;
          }
          let e = t.types;
          if (!e) throw Error("Accounts require `idl.types`");
          let r = t.accounts.map((t) => {
            let r = e.find((e) => e.name === t.name);
            if (!r) throw Error("Account not found: ".concat(t.name));
            return [t.name, ex.typeDefLayout({ typeDef: r, types: e })];
          });
          this.accountLayouts = new Map(r);
        }
      }
      class eB {
        decode(t) {
          let e;
          try {
            e = w(t);
          } catch (t) {
            return null;
          }
          let r = C(e.slice(0, 8)),
            n = this.discriminators.get(r);
          if (!n) return null;
          let i = this.layouts.get(n);
          if (!i) throw Error("Unknown event: ".concat(n));
          return { data: i.decode(e.slice(8)), name: n };
        }
        constructor(t) {
          var e;
          if (!t.events) {
            this.layouts = new Map();
            return;
          }
          let r = t.types;
          if (!r) throw Error("Events require `idl.types`");
          let n = t.events.map((t) => {
            let e = r.find((e) => e.name === t.name);
            if (!e) throw Error("Event not found: ".concat(t.name));
            return [t.name, ex.typeDefLayout({ typeDef: e, types: r })];
          });
          (this.layouts = new Map(n)),
            (this.discriminators = new Map(
              (null !== (e = t.events) && void 0 !== e ? e : []).map((t) => [
                C(h.Buffer.from(t.discriminator)),
                t.name,
              ])
            ));
        }
      }
      class eG {
        encode(t, e) {
          let r = h.Buffer.alloc(1e3),
            n = this.typeLayouts.get(t);
          if (!n) throw Error("Unknown type: ".concat(t));
          let i = n.encode(e, r);
          return r.slice(0, i);
        }
        decode(t, e) {
          let r = this.typeLayouts.get(t);
          if (!r) throw Error("Unknown type: ".concat(t));
          return r.decode(e);
        }
        constructor(t) {
          let e = t.types;
          if (!e) {
            this.typeLayouts = new Map();
            return;
          }
          let r = e
            .filter((t) => !t.generics)
            .map((t) => [t.name, ex.typeDefLayout({ typeDef: t, types: e })]);
          this.typeLayouts = new Map(r);
        }
      }
      class eV {
        constructor(t) {
          (this.instruction = new eL(t)),
            (this.accounts = new ek(t)),
            (this.events = new eB(t)),
            (this.types = new eG(t));
        }
      }
      class eK {
        makeDestinationObject() {
          return {};
        }
        decode(t, e) {
          throw Error("Layout is abstract");
        }
        encode(t, e, r) {
          throw Error("Layout is abstract");
        }
        getSpan(t, e) {
          if (0 > this.span) throw RangeError("indeterminate span");
          return this.span;
        }
        replicate(t) {
          let e = Object.create(this.constructor.prototype);
          return Object.assign(e, this), (e.property = t), e;
        }
        fromArray(t) {}
        constructor(t, e) {
          if (!Number.isInteger(t)) throw TypeError("span must be an integer");
          (this.span = t), (this.property = e);
        }
      }
      var ez = eK;
      class ej extends eK {
        isCount() {
          throw Error("ExternalLayout is abstract");
        }
      }
      class eq extends ej {
        isCount() {
          return this.layout instanceof eF || this.layout instanceof eX;
        }
        decode(t, e) {
          return (
            void 0 === e && (e = 0), this.layout.decode(t, e + this.offset)
          );
        }
        encode(t, e, r) {
          return (
            void 0 === r && (r = 0), this.layout.encode(t, e, r + this.offset)
          );
        }
        constructor(t, e, r) {
          if (!(t instanceof eK)) throw TypeError("layout must be a Layout");
          if (void 0 === e) e = 0;
          else if (!Number.isInteger(e))
            throw TypeError("offset must be integer or undefined");
          super(t.span, r || t.property), (this.layout = t), (this.offset = e);
        }
      }
      class eF extends eK {
        decode(t, e) {
          return void 0 === e && (e = 0), t.readUIntLE(e, this.span);
        }
        encode(t, e, r) {
          return (
            void 0 === r && (r = 0), e.writeUIntLE(t, r, this.span), this.span
          );
        }
        constructor(t, e) {
          if ((super(t, e), 6 < this.span))
            throw RangeError("span must not exceed 6 bytes");
        }
      }
      class eX extends eK {
        decode(t, e) {
          return void 0 === e && (e = 0), t.readUIntBE(e, this.span);
        }
        encode(t, e, r) {
          return (
            void 0 === r && (r = 0), e.writeUIntBE(t, r, this.span), this.span
          );
        }
        constructor(t, e) {
          if ((super(t, e), 6 < this.span))
            throw RangeError("span must not exceed 6 bytes");
        }
      }
      function eY(t) {
        let e = Math.floor(t / 4294967296);
        return { hi32: e, lo32: t - 4294967296 * e };
      }
      function eW(t, e) {
        return 4294967296 * t + e;
      }
      class eQ extends eK {
        decode(t, e) {
          void 0 === e && (e = 0);
          let r = t.readUInt32LE(e);
          return eW(t.readUInt32LE(e + 4), r);
        }
        encode(t, e, r) {
          void 0 === r && (r = 0);
          let n = eY(t);
          return e.writeUInt32LE(n.lo32, r), e.writeUInt32LE(n.hi32, r + 4), 8;
        }
        constructor(t) {
          super(8, t);
        }
      }
      class eZ extends eK {
        decode(t, e) {
          void 0 === e && (e = 0);
          let r = t.readUInt32LE(e);
          return eW(t.readInt32LE(e + 4), r);
        }
        encode(t, e, r) {
          void 0 === r && (r = 0);
          let n = eY(t);
          return e.writeUInt32LE(n.lo32, r), e.writeInt32LE(n.hi32, r + 4), 8;
        }
        constructor(t) {
          super(8, t);
        }
      }
      class eJ extends eK {
        getSpan(t, e) {
          if (0 <= this.span) return this.span;
          void 0 === e && (e = 0);
          let r = 0;
          try {
            r = this.fields.reduce((r, n) => {
              let i = n.getSpan(t, e);
              return (e += i), r + i;
            }, 0);
          } catch (t) {
            throw RangeError("indeterminate span");
          }
          return r;
        }
        decode(t, e) {
          void 0 === e && (e = 0);
          let r = this.makeDestinationObject();
          for (let n of this.fields)
            if (
              (void 0 !== n.property && (r[n.property] = n.decode(t, e)),
              (e += n.getSpan(t, e)),
              this.decodePrefixes && t.length === e)
            )
              break;
          return r;
        }
        encode(t, e, r) {
          void 0 === r && (r = 0);
          let n = r,
            i = 0,
            o = 0;
          for (let n of this.fields) {
            let s = n.span;
            if (((o = 0 < s ? s : 0), void 0 !== n.property)) {
              let i = t[n.property];
              void 0 !== i &&
                ((o = n.encode(i, e, r)), 0 > s && (s = n.getSpan(e, r)));
            }
            (i = r), (r += s);
          }
          return i + o - n;
        }
        fromArray(t) {
          let e = this.makeDestinationObject();
          for (let r of this.fields)
            void 0 !== r.property &&
              0 < t.length &&
              (e[r.property] = t.shift());
          return e;
        }
        layoutFor(t) {
          if ("string" != typeof t) throw TypeError("property must be string");
          for (let e of this.fields) if (e.property === t) return e;
        }
        offsetOf(t) {
          if ("string" != typeof t) throw TypeError("property must be string");
          let e = 0;
          for (let r of this.fields) {
            if (r.property === t) return e;
            0 > r.span ? (e = -1) : 0 <= e && (e += r.span);
          }
        }
        constructor(t, e, r) {
          if (
            !(Array.isArray(t) && t.reduce((t, e) => t && e instanceof eK, !0))
          )
            throw TypeError("fields must be array of Layout instances");
          for (let n of ("boolean" == typeof e &&
            void 0 === r &&
            ((r = e), (e = void 0)),
          t))
            if (0 > n.span && void 0 === n.property)
              throw Error(
                "fields cannot contain unnamed variable-length layout"
              );
          let n = -1;
          try {
            n = t.reduce((t, e) => t + e.getSpan(), 0);
          } catch (t) {}
          super(n, e), (this.fields = t), (this.decodePrefixes = !!r);
        }
      }
      class e$ {
        decode() {
          throw Error("UnionDiscriminator is abstract");
        }
        encode() {
          throw Error("UnionDiscriminator is abstract");
        }
        constructor(t) {
          this.property = t;
        }
      }
      class e0 extends e$ {
        decode(t, e) {
          return this.layout.decode(t, e);
        }
        encode(t, e, r) {
          return this.layout.encode(t, e, r);
        }
        constructor(t, e) {
          if (!(t instanceof ej && t.isCount()))
            throw TypeError(
              "layout must be an unsigned integer ExternalLayout"
            );
          super(e || t.property || "variant"), (this.layout = t);
        }
      }
      class e1 extends eK {
        getSpan(t, e) {
          if (0 <= this.span) return this.span;
          void 0 === e && (e = 0);
          let r = this.getVariant(t, e);
          if (!r)
            throw Error("unable to determine span for unrecognized variant");
          return r.getSpan(t, e);
        }
        defaultGetSourceVariant(t) {
          if (t.hasOwnProperty(this.discriminator.property)) {
            if (
              this.defaultLayout &&
              t.hasOwnProperty(this.defaultLayout.property)
            )
              return;
            let e = this.registry[t[this.discriminator.property]];
            if (e && (!e.layout || t.hasOwnProperty(e.property))) return e;
          } else
            for (let e in this.registry) {
              let r = this.registry[e];
              if (t.hasOwnProperty(r.property)) return r;
            }
          throw Error("unable to infer src variant");
        }
        decode(t, e) {
          let r;
          void 0 === e && (e = 0);
          let n = this.discriminator,
            i = n.decode(t, e),
            o = this.registry[i];
          if (void 0 === o) {
            let s = 0;
            (o = this.defaultLayout),
              this.usesPrefixDiscriminator && (s = n.layout.span),
              ((r = this.makeDestinationObject())[n.property] = i),
              (r[o.property] = this.defaultLayout.decode(t, e + s));
          } else r = o.decode(t, e);
          return r;
        }
        encode(t, e, r) {
          void 0 === r && (r = 0);
          let n = this.getSourceVariant(t);
          if (void 0 === n) {
            let n = this.discriminator,
              i = this.defaultLayout,
              o = 0;
            return (
              this.usesPrefixDiscriminator && (o = n.layout.span),
              n.encode(t[n.property], e, r),
              o + i.encode(t[i.property], e, r + o)
            );
          }
          return n.encode(t, e, r);
        }
        addVariant(t, e, r) {
          let n = new e2(this, t, e, r);
          return (this.registry[t] = n), n;
        }
        getVariant(t, e) {
          let r = t;
          return (
            T.isBuffer(t) &&
              (void 0 === e && (e = 0), (r = this.discriminator.decode(t, e))),
            this.registry[r]
          );
        }
        constructor(t, e, r) {
          let n = t instanceof eF || t instanceof eX;
          if (n) t = new e0(new eq(t));
          else if (t instanceof ej && t.isCount()) t = new e0(t);
          else if (!(t instanceof e$))
            throw TypeError(
              "discr must be a UnionDiscriminator or an unsigned integer layout"
            );
          if ((void 0 === e && (e = null), !(null === e || e instanceof eK)))
            throw TypeError("defaultLayout must be null or a Layout");
          if (null !== e) {
            if (0 > e.span)
              throw Error("defaultLayout must have constant span");
            void 0 === e.property && (e = e.replicate("content"));
          }
          let i = -1;
          e && 0 <= (i = e.span) && n && (i += t.layout.span),
            super(i, r),
            (this.discriminator = t),
            (this.usesPrefixDiscriminator = n),
            (this.defaultLayout = e),
            (this.registry = {});
          let o = this.defaultGetSourceVariant.bind(this);
          (this.getSourceVariant = function (t) {
            return o(t);
          }),
            (this.configGetSourceVariant = function (t) {
              o = t.bind(this);
            });
        }
      }
      class e2 extends eK {
        getSpan(t, e) {
          if (0 <= this.span) return this.span;
          void 0 === e && (e = 0);
          let r = 0;
          return (
            this.union.usesPrefixDiscriminator &&
              (r = this.union.discriminator.layout.span),
            r + this.layout.getSpan(t, e + r)
          );
        }
        decode(t, e) {
          let r = this.makeDestinationObject();
          if ((void 0 === e && (e = 0), this !== this.union.getVariant(t, e)))
            throw Error("variant mismatch");
          let n = 0;
          return (
            this.union.usesPrefixDiscriminator &&
              (n = this.union.discriminator.layout.span),
            this.layout
              ? (r[this.property] = this.layout.decode(t, e + n))
              : this.property
              ? (r[this.property] = !0)
              : this.union.usesPrefixDiscriminator &&
                (r[this.union.discriminator.property] = this.variant),
            r
          );
        }
        encode(t, e, r) {
          void 0 === r && (r = 0);
          let n = 0;
          if (
            (this.union.usesPrefixDiscriminator &&
              (n = this.union.discriminator.layout.span),
            this.layout && !t.hasOwnProperty(this.property))
          )
            throw TypeError("variant lacks property " + this.property);
          this.union.discriminator.encode(this.variant, e, r);
          let i = n;
          if (
            this.layout &&
            (this.layout.encode(t[this.property], e, r + n),
            (i += this.layout.getSpan(e, r + n)),
            0 <= this.union.span && i > this.union.span)
          )
            throw Error("encoded variant overruns containing union");
          return i;
        }
        fromArray(t) {
          if (this.layout) return this.layout.fromArray(t);
        }
        constructor(t, e, r, n) {
          if (!(t instanceof e1)) throw TypeError("union must be a Union");
          if (!Number.isInteger(e) || 0 > e)
            throw TypeError("variant must be a (non-negative) integer");
          if (
            ("string" == typeof r && void 0 === n && ((n = r), (r = null)), r)
          ) {
            if (!(r instanceof eK)) throw TypeError("layout must be a Layout");
            if (
              null !== t.defaultLayout &&
              0 <= r.span &&
              r.span > t.defaultLayout.span
            )
              throw Error("variant span exceeds span of containing union");
            if ("string" != typeof n)
              throw TypeError("variant must have a String property");
          }
          let i = t.span;
          0 > t.span &&
            0 <= (i = r ? r.span : 0) &&
            t.usesPrefixDiscriminator &&
            (i += t.discriminator.layout.span),
            super(i, n),
            (this.union = t),
            (this.variant = e),
            (this.layout = r || null);
        }
      }
      class e3 extends eK {
        getSpan(t, e) {
          let r = this.span;
          return 0 > r && (r = this.length.decode(t, e)), r;
        }
        decode(t, e) {
          void 0 === e && (e = 0);
          let r = this.span;
          return 0 > r && (r = this.length.decode(t, e)), t.slice(e, e + r);
        }
        encode(t, e, r) {
          let n = this.length;
          if (
            (this.length instanceof ej && (n = t.length),
            !(T.isBuffer(t) && n === t.length))
          ) {
            var i;
            throw TypeError(
              ((i = "Blob.encode"),
              (this.property ? i + "[" + this.property + "]" : i) +
                " requires (length " +
                n +
                ") Buffer as src")
            );
          }
          if (r + n > e.length) throw RangeError("encoding overruns Buffer");
          return (
            e.write(t.toString("hex"), r, n, "hex"),
            this.length instanceof ej && this.length.encode(n, e, r),
            n
          );
        }
        constructor(t, e) {
          if (
            !(
              (t instanceof ej && t.isCount()) ||
              (Number.isInteger(t) && 0 <= t)
            )
          )
            throw TypeError(
              "length must be positive integer or an unsigned integer ExternalLayout"
            );
          let r = -1;
          t instanceof ej || (r = t), super(r, e), (this.length = t);
        }
      }
      var e8 = (t, e, r) => new eq(t, e, r),
        e6 = (t) => new eF(1, t),
        e4 = (t) => new eF(4, t),
        e5 = (t) => new eZ(t),
        e9 = (t, e, r) => new eJ(t, e, r),
        e7 = (t, e, r) => new e1(t, e, r),
        rt = (t, e) => new e3(t, e);
      class re extends ez {
        encode(t, e) {
          let r =
            arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0;
          if (null == t) return this.layout.span;
          let n = { chars: T.from(t, "utf8") };
          return this.layout.encode(n, e, r);
        }
        decode(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
          return this.layout.decode(t, e).chars.toString();
        }
        getSpan(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
          return (
            e4().span +
            e4().span +
            new (f())(new Uint8Array(t).slice(e, e + 4), 10, "le").toNumber()
          );
        }
        constructor(t) {
          super(-1, t),
            (this.property = t),
            (this.layout = e9(
              [e4("length"), e4("lengthPadding"), rt(e8(e4(), -8), "chars")],
              this.property
            ));
        }
      }
      function rr(t) {
        return new re(t);
      }
      function rn(t) {
        return rt(32, t);
      }
      let ri = e7(e4("instruction"));
      ri.addVariant(
        0,
        e9([e5("lamports"), e5("space"), rn("owner")]),
        "createAccount"
      ),
        ri.addVariant(1, e9([rn("owner")]), "assign"),
        ri.addVariant(2, e9([e5("lamports")]), "transfer"),
        ri.addVariant(
          3,
          e9([
            rn("base"),
            rr("seed"),
            e5("lamports"),
            e5("space"),
            rn("owner"),
          ]),
          "createAccountWithSeed"
        ),
        ri.addVariant(4, e9([rn("authorized")]), "advanceNonceAccount"),
        ri.addVariant(5, e9([e5("lamports")]), "withdrawNonceAccount"),
        ri.addVariant(6, e9([rn("authorized")]), "initializeNonceAccount"),
        ri.addVariant(7, e9([rn("authorized")]), "authorizeNonceAccount"),
        ri.addVariant(8, e9([e5("space")]), "allocate"),
        ri.addVariant(
          9,
          e9([rn("base"), rr("seed"), e5("space"), rn("owner")]),
          "allocateWithSeed"
        ),
        ri.addVariant(
          10,
          e9([rn("base"), rr("seed"), rn("owner")]),
          "assignWithSeed"
        ),
        ri.addVariant(
          11,
          e9([e5("lamports"), rr("seed"), rn("owner")]),
          "transferWithSeed"
        ),
        Object.values(ri.registry).map((t) => t.span);
      class ro extends ez {
        decode(t, e) {
          return this.decoder(this.layout.decode(t, e));
        }
        encode(t, e, r) {
          return this.layout.encode(this.encoder(t), e, r);
        }
        getSpan(t, e) {
          return this.layout.getSpan(t, e);
        }
        constructor(t, e, r, n) {
          super(t.span, n),
            (this.layout = t),
            (this.decoder = e),
            (this.encoder = r);
        }
      }
      function rs(t) {
        return new ro(
          rt(32),
          (t) => new _.PublicKey(t),
          (t) => t.toBuffer(),
          t
        );
      }
      e9([
        e4("version"),
        e4("state"),
        rs("authorizedPubkey"),
        rs("nonce"),
        e9([new eQ("lamportsPerSignature")], "feeCalculator"),
      ]),
        new _.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
        new _.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
      var ra = { exports: {} };
      (a = ra.exports),
        (c = "undefined" != typeof self ? self : tl),
        (l = u =
          (function () {
            function t() {
              (this.fetch = !1), (this.DOMException = c.DOMException);
            }
            return (t.prototype = c), new t();
          })()),
        (function (t) {
          var e = {
            searchParams: "URLSearchParams" in l,
            iterable: "Symbol" in l && "iterator" in Symbol,
            blob:
              "FileReader" in l &&
              "Blob" in l &&
              (function () {
                try {
                  return new Blob(), !0;
                } catch (t) {
                  return !1;
                }
              })(),
            formData: "FormData" in l,
            arrayBuffer: "ArrayBuffer" in l,
          };
          if (e.arrayBuffer)
            var r = [
                "[object Int8Array]",
                "[object Uint8Array]",
                "[object Uint8ClampedArray]",
                "[object Int16Array]",
                "[object Uint16Array]",
                "[object Int32Array]",
                "[object Uint32Array]",
                "[object Float32Array]",
                "[object Float64Array]",
              ],
              n =
                ArrayBuffer.isView ||
                function (t) {
                  return t && r.indexOf(Object.prototype.toString.call(t)) > -1;
                };
          function i(t) {
            if (
              ("string" != typeof t && (t = String(t)),
              /[^a-z0-9\-#$%&'*+.^_`|~]/i.test(t))
            )
              throw TypeError("Invalid character in header field name");
            return t.toLowerCase();
          }
          function o(t) {
            return "string" != typeof t && (t = String(t)), t;
          }
          function s(t) {
            var r = {
              next: function () {
                var e = t.shift();
                return { done: void 0 === e, value: e };
              },
            };
            return (
              e.iterable &&
                (r[Symbol.iterator] = function () {
                  return r;
                }),
              r
            );
          }
          function a(t) {
            (this.map = {}),
              t instanceof a
                ? t.forEach(function (t, e) {
                    this.append(e, t);
                  }, this)
                : Array.isArray(t)
                ? t.forEach(function (t) {
                    this.append(t[0], t[1]);
                  }, this)
                : t &&
                  Object.getOwnPropertyNames(t).forEach(function (e) {
                    this.append(e, t[e]);
                  }, this);
          }
          function c(t) {
            if (t.bodyUsed) return Promise.reject(TypeError("Already read"));
            t.bodyUsed = !0;
          }
          function u(t) {
            return new Promise(function (e, r) {
              (t.onload = function () {
                e(t.result);
              }),
                (t.onerror = function () {
                  r(t.error);
                });
            });
          }
          function d(t) {
            var e = new FileReader(),
              r = u(e);
            return e.readAsArrayBuffer(t), r;
          }
          function h(t) {
            if (t.slice) return t.slice(0);
            var e = new Uint8Array(t.byteLength);
            return e.set(new Uint8Array(t)), e.buffer;
          }
          function _() {
            return (
              (this.bodyUsed = !1),
              (this._initBody = function (t) {
                if (((this._bodyInit = t), t)) {
                  if ("string" == typeof t) this._bodyText = t;
                  else if (e.blob && Blob.prototype.isPrototypeOf(t))
                    this._bodyBlob = t;
                  else if (e.formData && FormData.prototype.isPrototypeOf(t))
                    this._bodyFormData = t;
                  else if (
                    e.searchParams &&
                    URLSearchParams.prototype.isPrototypeOf(t)
                  )
                    this._bodyText = t.toString();
                  else {
                    var r;
                    e.arrayBuffer &&
                    e.blob &&
                    (r = t) &&
                    DataView.prototype.isPrototypeOf(r)
                      ? ((this._bodyArrayBuffer = h(t.buffer)),
                        (this._bodyInit = new Blob([this._bodyArrayBuffer])))
                      : e.arrayBuffer &&
                        (ArrayBuffer.prototype.isPrototypeOf(t) || n(t))
                      ? (this._bodyArrayBuffer = h(t))
                      : (this._bodyText = t =
                          Object.prototype.toString.call(t));
                  }
                } else this._bodyText = "";
                !this.headers.get("content-type") &&
                  ("string" == typeof t
                    ? this.headers.set(
                        "content-type",
                        "text/plain;charset=UTF-8"
                      )
                    : this._bodyBlob && this._bodyBlob.type
                    ? this.headers.set("content-type", this._bodyBlob.type)
                    : e.searchParams &&
                      URLSearchParams.prototype.isPrototypeOf(t) &&
                      this.headers.set(
                        "content-type",
                        "application/x-www-form-urlencoded;charset=UTF-8"
                      ));
              }),
              e.blob &&
                ((this.blob = function () {
                  var t = c(this);
                  if (t) return t;
                  if (this._bodyBlob) return Promise.resolve(this._bodyBlob);
                  if (this._bodyArrayBuffer)
                    return Promise.resolve(new Blob([this._bodyArrayBuffer]));
                  if (!this._bodyFormData)
                    return Promise.resolve(new Blob([this._bodyText]));
                  throw Error("could not read FormData body as blob");
                }),
                (this.arrayBuffer = function () {
                  return this._bodyArrayBuffer
                    ? c(this) || Promise.resolve(this._bodyArrayBuffer)
                    : this.blob().then(d);
                })),
              (this.text = function () {
                var t,
                  e,
                  r,
                  n = c(this);
                if (n) return n;
                if (this._bodyBlob)
                  return (
                    (t = this._bodyBlob),
                    (r = u((e = new FileReader()))),
                    e.readAsText(t),
                    r
                  );
                if (this._bodyArrayBuffer)
                  return Promise.resolve(
                    (function (t) {
                      for (
                        var e = new Uint8Array(t), r = Array(e.length), n = 0;
                        n < e.length;
                        n++
                      )
                        r[n] = String.fromCharCode(e[n]);
                      return r.join("");
                    })(this._bodyArrayBuffer)
                  );
                if (!this._bodyFormData) return Promise.resolve(this._bodyText);
                throw Error("could not read FormData body as text");
              }),
              e.formData &&
                (this.formData = function () {
                  return this.text().then(R);
                }),
              (this.json = function () {
                return this.text().then(JSON.parse);
              }),
              this
            );
          }
          (a.prototype.append = function (t, e) {
            (t = i(t)), (e = o(e));
            var r = this.map[t];
            this.map[t] = r ? r + ", " + e : e;
          }),
            (a.prototype.delete = function (t) {
              delete this.map[i(t)];
            }),
            (a.prototype.get = function (t) {
              return (t = i(t)), this.has(t) ? this.map[t] : null;
            }),
            (a.prototype.has = function (t) {
              return this.map.hasOwnProperty(i(t));
            }),
            (a.prototype.set = function (t, e) {
              this.map[i(t)] = o(e);
            }),
            (a.prototype.forEach = function (t, e) {
              for (var r in this.map)
                this.map.hasOwnProperty(r) && t.call(e, this.map[r], r, this);
            }),
            (a.prototype.keys = function () {
              var t = [];
              return (
                this.forEach(function (e, r) {
                  t.push(r);
                }),
                s(t)
              );
            }),
            (a.prototype.values = function () {
              var t = [];
              return (
                this.forEach(function (e) {
                  t.push(e);
                }),
                s(t)
              );
            }),
            (a.prototype.entries = function () {
              var t = [];
              return (
                this.forEach(function (e, r) {
                  t.push([r, e]);
                }),
                s(t)
              );
            }),
            e.iterable && (a.prototype[Symbol.iterator] = a.prototype.entries);
          var p = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
          function f(t, e) {
            var r,
              n,
              i = (e = e || {}).body;
            if (t instanceof f) {
              if (t.bodyUsed) throw TypeError("Already read");
              (this.url = t.url),
                (this.credentials = t.credentials),
                e.headers || (this.headers = new a(t.headers)),
                (this.method = t.method),
                (this.mode = t.mode),
                (this.signal = t.signal),
                i ||
                  null == t._bodyInit ||
                  ((i = t._bodyInit), (t.bodyUsed = !0));
            } else this.url = String(t);
            if (
              ((this.credentials =
                e.credentials || this.credentials || "same-origin"),
              (e.headers || !this.headers) && (this.headers = new a(e.headers)),
              (this.method =
                ((n = (r = e.method || this.method || "GET").toUpperCase()),
                p.indexOf(n) > -1 ? n : r)),
              (this.mode = e.mode || this.mode || null),
              (this.signal = e.signal || this.signal),
              (this.referrer = null),
              ("GET" === this.method || "HEAD" === this.method) && i)
            )
              throw TypeError("Body not allowed for GET or HEAD requests");
            this._initBody(i);
          }
          function R(t) {
            var e = new FormData();
            return (
              t
                .trim()
                .split("&")
                .forEach(function (t) {
                  if (t) {
                    var r = t.split("="),
                      n = r.shift().replace(/\+/g, " "),
                      i = r.join("=").replace(/\+/g, " ");
                    e.append(decodeURIComponent(n), decodeURIComponent(i));
                  }
                }),
              e
            );
          }
          function A(t, e) {
            e || (e = {}),
              (this.type = "default"),
              (this.status = void 0 === e.status ? 200 : e.status),
              (this.ok = this.status >= 200 && this.status < 300),
              (this.statusText = "statusText" in e ? e.statusText : "OK"),
              (this.headers = new a(e.headers)),
              (this.url = e.url || ""),
              this._initBody(t);
          }
          (f.prototype.clone = function () {
            return new f(this, { body: this._bodyInit });
          }),
            _.call(f.prototype),
            _.call(A.prototype),
            (A.prototype.clone = function () {
              return new A(this._bodyInit, {
                status: this.status,
                statusText: this.statusText,
                headers: new a(this.headers),
                url: this.url,
              });
            }),
            (A.error = function () {
              var t = new A(null, { status: 0, statusText: "" });
              return (t.type = "error"), t;
            });
          var y = [301, 302, 303, 307, 308];
          (A.redirect = function (t, e) {
            if (-1 === y.indexOf(e)) throw RangeError("Invalid status code");
            return new A(null, { status: e, headers: { location: t } });
          }),
            (t.DOMException = l.DOMException);
          try {
            new t.DOMException();
          } catch (e) {
            (t.DOMException = function (t, e) {
              (this.message = t), (this.name = e);
              var r = Error(t);
              this.stack = r.stack;
            }),
              (t.DOMException.prototype = Object.create(Error.prototype)),
              (t.DOMException.prototype.constructor = t.DOMException);
          }
          function E(r, n) {
            return new Promise(function (i, o) {
              var s = new f(r, n);
              if (s.signal && s.signal.aborted)
                return o(new t.DOMException("Aborted", "AbortError"));
              var c = new XMLHttpRequest();
              function u() {
                c.abort();
              }
              (c.onload = function () {
                var t,
                  e,
                  r = {
                    status: c.status,
                    statusText: c.statusText,
                    headers:
                      ((t = c.getAllResponseHeaders() || ""),
                      (e = new a()),
                      t
                        .replace(/\r?\n[\t ]+/g, " ")
                        .split(/\r?\n/)
                        .forEach(function (t) {
                          var r = t.split(":"),
                            n = r.shift().trim();
                          if (n) {
                            var i = r.join(":").trim();
                            e.append(n, i);
                          }
                        }),
                      e),
                  };
                (r.url =
                  "responseURL" in c
                    ? c.responseURL
                    : r.headers.get("X-Request-URL")),
                  i(new A("response" in c ? c.response : c.responseText, r));
              }),
                (c.onerror = function () {
                  o(TypeError("Network request failed"));
                }),
                (c.ontimeout = function () {
                  o(TypeError("Network request failed"));
                }),
                (c.onabort = function () {
                  o(new t.DOMException("Aborted", "AbortError"));
                }),
                c.open(s.method, s.url, !0),
                "include" === s.credentials
                  ? (c.withCredentials = !0)
                  : "omit" === s.credentials && (c.withCredentials = !1),
                "responseType" in c && e.blob && (c.responseType = "blob"),
                s.headers.forEach(function (t, e) {
                  c.setRequestHeader(e, t);
                }),
                s.signal &&
                  (s.signal.addEventListener("abort", u),
                  (c.onreadystatechange = function () {
                    4 === c.readyState &&
                      s.signal.removeEventListener("abort", u);
                  })),
                c.send(void 0 === s._bodyInit ? null : s._bodyInit);
            });
          }
          (E.polyfill = !0),
            l.fetch ||
              ((l.fetch = E),
              (l.Headers = a),
              (l.Request = f),
              (l.Response = A)),
            (t.Headers = a),
            (t.Request = f),
            (t.Response = A),
            (t.fetch = E),
            Object.defineProperty(t, "__esModule", { value: !0 });
        })({}),
        (u.fetch.ponyfill = !0),
        delete u.fetch.polyfill,
        ((a = u.fetch).default = u.fetch),
        (a.fetch = u.fetch),
        (a.Headers = u.Headers),
        (a.Request = u.Request),
        (a.Response = u.Response),
        (ra.exports = a),
        (d = ra.exports) &&
          d.__esModule &&
          Object.prototype.hasOwnProperty.call(d, "default") &&
          d.default;
      let rc = O.Ez(
        [
          O.n_([], "uninitialized"),
          O.n_([O.Kw(O.ZL(), "authorityAddress")], "buffer"),
          O.n_([O.ZL("programdataAddress")], "program"),
          O.n_(
            [O.AW("slot"), O.Kw(O.ZL(), "upgradeAuthorityAddress")],
            "programData"
          ),
        ],
        void 0,
        O.Jq()
      );
      function ru(t, e) {
        var r, n;
        let i = {},
          o = t.args ? t.args.length : 0;
        if (e.length > o) {
          if (e.length !== o + 1)
            throw Error(
              "provided too many arguments "
                .concat(e, " to instruction ")
                .concat(null == t ? void 0 : t.name, " expecting: ")
                .concat(
                  null !==
                    (n =
                      null === (r = t.args) || void 0 === r
                        ? void 0
                        : r.map((t) => t.name)) && void 0 !== n
                    ? n
                    : []
                )
            );
          i = e.pop();
        }
        return [e, i];
      }
      class rl {
        static build(t, e, r) {
          if ("_inner" === t.name) throw new eC("the _inner name is reserved");
          let n = function () {
            for (var i = arguments.length, o = Array(i), s = 0; s < i; s++)
              o[s] = arguments[s];
            let [a, c] = ru(t, [...o]);
            !(function t(e) {
              let r =
                arguments.length > 1 && void 0 !== arguments[1]
                  ? arguments[1]
                  : {};
              e.forEach((e) => {
                if (S(e)) t(e.accounts, r[e.name]);
                else if (!r[e.name])
                  throw Error("Account `".concat(e.name, "` not provided."));
              });
            })(t.accounts, c.accounts),
              (function (t) {
                for (
                  var e = arguments.length, r = Array(e > 1 ? e - 1 : 0), n = 1;
                  n < e;
                  n++
                )
                  r[n - 1] = arguments[n];
              })(t, ...o);
            let u = n.accounts(c.accounts);
            return (
              void 0 !== c.remainingAccounts && u.push(...c.remainingAccounts),
              ev("debug-logs") && console.log("Outgoing account metas:", u),
              new _.TransactionInstruction({
                keys: u,
                programId: r,
                data: e(
                  t.name,
                  (function (t) {
                    for (
                      var e = arguments.length,
                        r = Array(e > 1 ? e - 1 : 0),
                        n = 1;
                      n < e;
                      n++
                    )
                      r[n - 1] = arguments[n];
                    if (t.args.length != r.length)
                      throw Error("Invalid argument length");
                    let i = {},
                      o = 0;
                    return (
                      t.args.forEach((t) => {
                        (i[t.name] = r[o]), (o += 1);
                      }),
                      i
                    );
                  })(t, ...a)
                ),
              })
            );
          };
          return (
            (n.accounts = (e) => rl.accountsArray(e, t.accounts, r, t.name)), n
          );
        }
        static accountsArray(t, e, r, n) {
          return t
            ? e
                .map((e) => {
                  let i;
                  if (S(e)) {
                    let i = t[e.name];
                    return rl.accountsArray(i, e.accounts, r, n).flat();
                  }
                  try {
                    i = P(t[e.name]);
                  } catch (t) {
                    throw Error(
                      'Wrong input type for account "'
                        .concat(e.name, '" in the instruction accounts object')
                        .concat(
                          void 0 !== n ? ' for instruction "' + n + '"' : "",
                          ". Expected PublicKey or string."
                        )
                    );
                  }
                  let o = e.optional && i.equals(r);
                  return {
                    pubkey: i,
                    isWritable: !!(e.writable && !o),
                    isSigner: !!(e.signer && !o),
                  };
                })
                .flat()
            : [];
        }
      }
      class rd {
        static build(t, e) {
          return function () {
            for (
              var r, n, i, o = arguments.length, s = Array(o), a = 0;
              a < o;
              a++
            )
              s[a] = arguments[a];
            let [, c] = ru(t, [...s]),
              u = new _.Transaction();
            if (c.preInstructions && c.instructions)
              throw Error("instructions is deprecated, use preInstructions");
            return (
              null === (r = c.preInstructions) ||
                void 0 === r ||
                r.forEach((t) => u.add(t)),
              null === (n = c.instructions) ||
                void 0 === n ||
                n.forEach((t) => u.add(t)),
              u.add(e(...s)),
              null === (i = c.postInstructions) ||
                void 0 === i ||
                i.forEach((t) => u.add(t)),
              u
            );
          };
        }
      }
      class rh {
        static build(t, e, r, n) {
          return async function () {
            for (var i, o = arguments.length, s = Array(o), a = 0; a < o; a++)
              s[a] = arguments[a];
            let c = e(...s),
              [, u] = ru(t, [...s]);
            if (void 0 === n.sendAndConfirm)
              throw Error(
                "This function requires 'Provider.sendAndConfirm' to be implemented."
              );
            try {
              return await n.sendAndConfirm(
                c,
                null !== (i = u.signers) && void 0 !== i ? i : [],
                u.options
              );
            } catch (t) {
              throw eM(t, r);
            }
          };
        }
      }
      class r_ {
        static build(t, e, r, n) {
          var i;
          return (null !== (i = t.accounts) && void 0 !== i ? i : []).reduce(
            (i, o) => ((i[o.name] = new rp(t, o, r, n, e)), i),
            {}
          );
        }
      }
      class rp {
        get size() {
          return this._size;
        }
        get programId() {
          return this._programId;
        }
        get provider() {
          return this._provider;
        }
        get coder() {
          return this._coder;
        }
        async fetchNullable(t, e) {
          let { data: r } = await this.fetchNullableAndContext(t, e);
          return r;
        }
        async fetchNullableAndContext(t, e) {
          let { value: r, context: n } = await this.getAccountInfoAndContext(
            t,
            e
          );
          return {
            data:
              r && 0 !== r.data.length
                ? this._coder.accounts.decode(this._idlAccount.name, r.data)
                : null,
            context: n,
          };
        }
        async fetch(t, e) {
          let { data: r } = await this.fetchNullableAndContext(t, e);
          if (null === r)
            throw Error(
              "Account does not exist or has no data ".concat(t.toString())
            );
          return r;
        }
        async fetchAndContext(t, e) {
          let { data: r, context: n } = await this.fetchNullableAndContext(
            t,
            e
          );
          if (null === r)
            throw Error("Account does not exist ".concat(t.toString()));
          return { data: r, context: n };
        }
        async fetchMultiple(t, e) {
          return (await this.fetchMultipleAndContext(t, e)).map((t) =>
            t ? t.data : null
          );
        }
        async fetchMultipleAndContext(t, e) {
          return (
            await J(
              this._provider.connection,
              t.map((t) => P(t)),
              e
            )
          ).map((t) => {
            if (null == t) return null;
            let { account: e, context: r } = t;
            return {
              data: this._coder.accounts.decode(this._idlAccount.name, e.data),
              context: r,
            };
          });
        }
        async all(t) {
          let e = this.coder.accounts.memcmp(
              this._idlAccount.name,
              t instanceof T ? t : void 0
            ),
            r = [];
          return (
            (null == e ? void 0 : e.offset) != void 0 &&
              (null == e ? void 0 : e.bytes) != void 0 &&
              r.push({ memcmp: { offset: e.offset, bytes: e.bytes } }),
            (null == e ? void 0 : e.dataSize) != void 0 &&
              r.push({ dataSize: e.dataSize }),
            (
              await this._provider.connection.getProgramAccounts(
                this._programId,
                {
                  commitment: this._provider.connection.commitment,
                  filters: [...r, ...(Array.isArray(t) ? t : [])],
                }
              )
            ).map((t) => {
              let { pubkey: e, account: r } = t;
              return {
                publicKey: e,
                account: this._coder.accounts.decode(
                  this._idlAccount.name,
                  r.data
                ),
              };
            })
          );
        }
        subscribe(t, e) {
          let r = rf.get(t.toString());
          if (r) return r.ee;
          let n = new (g())();
          t = P(t);
          let i = this._provider.connection.onAccountChange(
            t,
            (t) => {
              let e = this._coder.accounts.decode(
                this._idlAccount.name,
                t.data
              );
              n.emit("change", e);
            },
            e
          );
          return rf.set(t.toString(), { ee: n, listener: i }), n;
        }
        async unsubscribe(t) {
          let e = rf.get(t.toString());
          if (!e) {
            console.warn("Address is not subscribed");
            return;
          }
          rf &&
            (await this._provider.connection
              .removeAccountChangeListener(e.listener)
              .then(() => {
                rf.delete(t.toString());
              })
              .catch(console.error));
        }
        async createInstruction(t, e) {
          let r = this.size;
          if (void 0 === this._provider.publicKey)
            throw Error(
              "This function requires the Provider interface implementor to have a 'publicKey' field."
            );
          return _.SystemProgram.createAccount({
            fromPubkey: this._provider.publicKey,
            newAccountPubkey: t.publicKey,
            space: null != e ? e : r,
            lamports:
              await this._provider.connection.getMinimumBalanceForRentExemption(
                null != e ? e : r
              ),
            programId: this._programId,
          });
        }
        async getAccountInfo(t, e) {
          return await this._provider.connection.getAccountInfo(P(t), e);
        }
        async getAccountInfoAndContext(t, e) {
          return await this._provider.connection.getAccountInfoAndContext(
            P(t),
            e
          );
        }
        constructor(t, e, r, n, i) {
          (this._idlAccount = e),
            (this._programId = r),
            (this._provider = null != n ? n : tc()),
            (this._coder = null != i ? i : new eV(t)),
            (this._size = this._coder.accounts.size(e.name));
        }
      }
      let rf = new Map(),
        rR = "Program log: ",
        rA = "Program data: ",
        ry = rR.length,
        rE = rA.length;
      class rO {
        addEventListener(t, e) {
          var r;
          let n = this._listenerIdCount;
          return (
            (this._listenerIdCount += 1),
            this._eventListeners.has(t) || this._eventListeners.set(t, []),
            this._eventListeners.set(
              t,
              (null !== (r = this._eventListeners.get(t)) && void 0 !== r
                ? r
                : []
              ).concat(n)
            ),
            this._eventCallbacks.set(n, [t, e]),
            void 0 !== this._onLogsSubscriptionId ||
              (this._onLogsSubscriptionId = this._provider.connection.onLogs(
                this._programId,
                (t, e) => {
                  if (!t.err)
                    for (let r of this._eventParser.parseLogs(t.logs)) {
                      let n = this._eventListeners.get(r.name);
                      n &&
                        n.forEach((n) => {
                          let i = this._eventCallbacks.get(n);
                          if (i) {
                            let [, n] = i;
                            n(r.data, e.slot, t.signature);
                          }
                        });
                    }
                }
              )),
            n
          );
        }
        async removeEventListener(t) {
          let e = this._eventCallbacks.get(t);
          if (!e) throw Error("Event listener ".concat(t, " doesn't exist!"));
          let [r] = e,
            n = this._eventListeners.get(r);
          if (!n)
            throw Error("Event listeners don't exist for ".concat(r, "!"));
          if (
            (this._eventCallbacks.delete(t),
            (n = n.filter((e) => e !== t)),
            this._eventListeners.set(r, n),
            0 === n.length && this._eventListeners.delete(r),
            0 === this._eventCallbacks.size)
          ) {
            if (0 !== this._eventListeners.size)
              throw Error(
                "Expected event listeners size to be 0 but got ".concat(
                  this._eventListeners.size
                )
              );
            void 0 !== this._onLogsSubscriptionId &&
              (await this._provider.connection.removeOnLogsListener(
                this._onLogsSubscriptionId
              ),
              (this._onLogsSubscriptionId = void 0));
          }
        }
        constructor(t, e, r) {
          (this._programId = t),
            (this._provider = e),
            (this._eventParser = new rm(t, r)),
            (this._eventCallbacks = new Map()),
            (this._eventListeners = new Map()),
            (this._listenerIdCount = 0);
        }
      }
      class rm {
        *parseLogs(t) {
          let e =
              arguments.length > 1 && void 0 !== arguments[1] && arguments[1],
            r = new rg(t),
            n = new rN(),
            i = r.next();
          for (; null !== i; ) {
            let [t, o, s] = this.handleLog(n, i, e);
            t && (yield t), o && n.push(o), s && n.pop(), (i = r.next());
          }
        }
        handleLog(t, e, r) {
          return t.stack.length > 0 && t.program() === this.programId.toString()
            ? this.handleProgramLog(e, r)
            : [null, ...this.handleSystemLog(e)];
        }
        handleProgramLog(t, e) {
          if (!(t.startsWith(rR) || t.startsWith(rA)))
            return [null, ...this.handleSystemLog(t)];
          {
            let r = t.startsWith(rR) ? t.slice(ry) : t.slice(rE),
              n = this.coder.events.decode(r);
            if (e && null === n)
              throw Error("Unable to decode event ".concat(r));
            return [n, null, !1];
          }
        }
        handleSystemLog(t) {
          let e = t.split(":")[0];
          return null !== e.match(/^Program (.*) success/g)
            ? [null, !0]
            : e.startsWith(
                "Program ".concat(this.programId.toString(), " invoke")
              )
            ? [this.programId.toString(), !1]
            : e.includes("invoke")
            ? ["cpi", !1]
            : [null, !1];
        }
        constructor(t, e) {
          (this.coder = e), (this.programId = t);
        }
      }
      class rN {
        program() {
          if (!this.stack.length)
            throw Error("Expected the stack to have elements");
          return this.stack[this.stack.length - 1];
        }
        push(t) {
          this.stack.push(t);
        }
        pop() {
          if (!this.stack.length)
            throw Error("Expected the stack to have elements");
          this.stack.pop();
        }
        constructor() {
          this.stack = [];
        }
      }
      class rg {
        next() {
          if (0 === this.logs.length) return null;
          let t = this.logs[0];
          return (this.logs = this.logs.slice(1)), t;
        }
        constructor(t) {
          this.logs = t;
        }
      }
      class rT {
        static build(t, e, r, n, i, o, s) {
          return async function () {
            let a;
            for (var c, u = arguments.length, l = Array(u), d = 0; d < u; d++)
              l[d] = arguments[d];
            let h = e(...l),
              [, _] = ru(t, [...l]);
            if (void 0 === n.simulate)
              throw Error(
                "This function requires 'Provider.simulate' to be implemented."
              );
            try {
              a = await n.simulate(
                h,
                _.signers,
                null === (c = _.options) || void 0 === c ? void 0 : c.commitment
              );
            } catch (t) {
              throw eM(t, r);
            }
            if (void 0 === a) throw Error("Unable to simulate transaction");
            let p = a.logs;
            if (!p) throw Error("Simulated logs not found");
            let f = [];
            if (s.events) for (let t of new rm(o, i).parseLogs(p)) f.push(t);
            return { events: f, raw: p };
          };
        }
      }
      function rI(t) {
        return new rC(
          rt(8),
          (t) => rS.fromBuffer(t),
          (t) => t.toBuffer(),
          t
        );
      }
      function rv(t) {
        return new rC(
          rt(32),
          (t) => new _.PublicKey(t),
          (t) => t.toBuffer(),
          t
        );
      }
      class rC extends ez {
        decode(t, e) {
          return this.decoder(this.layout.decode(t, e));
        }
        encode(t, e, r) {
          return this.layout.encode(this.encoder(t), e, r);
        }
        getSpan(t, e) {
          return this.layout.getSpan(t, e);
        }
        constructor(t, e, r, n) {
          super(t.span, n),
            (this.layout = t),
            (this.decoder = e),
            (this.encoder = r);
        }
      }
      class rw extends ez {
        encode(t, e) {
          let r =
            arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0;
          return null == t
            ? this.layout.span + this.discriminator.encode(0, e, r)
            : (this.discriminator.encode(1, e, r),
              this.layout.encode(t, e, r + 4) + 4);
        }
        decode(t) {
          let e =
              arguments.length > 1 && void 0 !== arguments[1]
                ? arguments[1]
                : 0,
            r = this.discriminator.decode(t, e);
          if (0 === r) return null;
          if (1 === r) return this.layout.decode(t, e + 4);
          throw Error("Invalid coption " + this.layout.property);
        }
        getSpan(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
          return this.layout.getSpan(t, e + 4) + 4;
        }
        constructor(t, e) {
          super(-1, e), (this.layout = t), (this.discriminator = e4());
        }
      }
      class rS extends f() {
        toBuffer() {
          let t = super.toArray().reverse(),
            e = T.from(t);
          if (8 === e.length) return e;
          if (e.length >= 8) throw Error("u64 too large");
          let r = T.alloc(8);
          return e.copy(r), r;
        }
        static fromBuffer(t) {
          if (8 !== t.length)
            throw Error("Invalid buffer length: ".concat(t.length));
          return new rS(
            [...t]
              .reverse()
              .map((t) => "00".concat(t.toString(16)).slice(-2))
              .join(""),
            16
          );
        }
      }
      let rb = e9([
        rv("mint"),
        rv("owner"),
        rI("amount"),
        new rw(rv(), "delegate"),
        ((t) => {
          let e = e7(e6("discriminator"), null, t);
          return (
            e.addVariant(0, e9([]), "uninitialized"),
            e.addVariant(1, e9([]), "initialized"),
            e.addVariant(2, e9([]), "frozen"),
            e
          );
        })("state"),
        new rw(rI(), "isNative"),
        rI("delegatedAmount"),
        new rw(rv(), "closeAuthority"),
      ]);
      class rM {
        args(t) {
          this._args = t;
        }
        async resolve() {
          this.resolveEventCpi(this._idlIx.accounts),
            this.resolveConst(this._idlIx.accounts);
          let t = 0;
          for (
            ;
            (await this.resolvePdasAndRelations(this._idlIx.accounts)) +
              (await this.resolveCustom()) >
            0;

          )
            if (16 == ++t)
              throw Error("Reached maximum depth for account resolution");
        }
        resolveOptionals(t) {
          Object.assign(
            this._accounts,
            this.resolveOptionalsHelper(t, this._idlIx.accounts)
          );
        }
        get(t) {
          let e = t.reduce((t, e) => t && t[e], this._accounts);
          if (e && e.toBase58) return e;
        }
        set(t, e) {
          let r = this._accounts;
          t.forEach((n, i) => {
            var o;
            i === t.length - 1 && (r[n] = e),
              (r[n] = null !== (o = r[n]) && void 0 !== o ? o : {}),
              (r = r[n]);
          });
        }
        resolveOptionalsHelper(t, e) {
          let r = {};
          for (let n of e) {
            let e = n.name,
              i = t[e];
            void 0 !== i &&
              (rx(i)
                ? S(n)
                  ? (r[e] = this.resolveOptionalsHelper(i, n.accounts))
                  : (r[e] = (function t(e, r) {
                      let n = {};
                      for (let i in e) {
                        let o = e[i];
                        if (null === o) {
                          if (r)
                            throw Error(
                              "Failed to resolve optionals due to IDL type mismatch with input accounts!"
                            );
                          continue;
                        }
                        n[i] = rx(o) ? t(o, !0) : P(o);
                      }
                      return n;
                    })(i, !0))
                : null !== i
                ? (r[e] = P(i))
                : n.optional && (r[e] = this._programId));
          }
          return r;
        }
        async resolveCustom() {
          if (this._customResolver) {
            let { accounts: t, resolved: e } = await this._customResolver({
              args: this._args,
              accounts: this._accounts,
              provider: this._provider,
              programId: this._programId,
              idlIx: this._idlIx,
            });
            return (this._accounts = t), e;
          }
          return 0;
        }
        resolveEventCpi(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
          for (let r in t) {
            let n = t[r];
            S(n) && this.resolveEventCpi(n.accounts, [...e, n.name]);
            let i = +r + 1;
            if (i === t.length) return;
            let o = t[r].name,
              s = t[i].name;
            if ("eventAuthority" === o && "program" === s) {
              let t = [...e, o],
                r = [...e, s];
              this.get(t) ||
                this.set(
                  t,
                  _.PublicKey.findProgramAddressSync(
                    [T.from("__event_authority")],
                    this._programId
                  )[0]
                ),
                this.get(r) || this.set(r, this._programId);
              return;
            }
          }
        }
        resolveConst(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
          for (let r of t) {
            let t = r.name;
            if (S(r)) this.resolveConst(r.accounts, [...e, t]);
            else if ((r.signer || r.address) && !this.get([...e, t])) {
              if (r.signer) {
                if (!this._provider.wallet)
                  throw Error(
                    "This function requires the `Provider` interface implementor to have a `wallet` field."
                  );
                this.set([...e, t], this._provider.wallet.publicKey);
              }
              r.address && this.set([...e, t], P(r.address));
            }
          }
        }
        async resolvePdasAndRelations(t) {
          let e =
              arguments.length > 1 && void 0 !== arguments[1]
                ? arguments[1]
                : [],
            r = 0;
          for (let n of t) {
            let t = n.name;
            if (S(n))
              r += await this.resolvePdasAndRelations(n.accounts, [...e, t]);
            else if ((n.pda || n.relations) && !this.get([...e, t])) {
              r++;
              try {
                if (n.pda) {
                  let r = await Promise.all(
                    n.pda.seeds.map((t) => this.toBuffer(t, e))
                  );
                  if (r.some((t) => !t)) continue;
                  let i = await this.parseProgramId(n, e),
                    [o] = _.PublicKey.findProgramAddressSync(r, i);
                  this.set([...e, t], o);
                }
              } catch (t) {}
              try {
                if (n.relations) {
                  let r = this.get([...e, n.relations[0]]);
                  if (r) {
                    let n = await this._accountStore.fetchAccount({
                      publicKey: r,
                    });
                    this.set([...e, t], n[t]);
                  }
                }
              } catch (t) {}
            }
          }
          return r;
        }
        async parseProgramId(t) {
          var e;
          let r =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
          if (!(null === (e = t.pda) || void 0 === e ? void 0 : e.program))
            return this._programId;
          let n = await this.toBuffer(t.pda.program, r);
          if (!n) throw Error("Program seed not resolved: ".concat(t.name));
          return new _.PublicKey(n);
        }
        async toBuffer(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
          switch (t.kind) {
            case "const":
              return this.toBufferConst(t);
            case "arg":
              return await this.toBufferArg(t);
            case "account":
              return await this.toBufferAccount(t, e);
            default:
              throw Error("Unexpected seed: ".concat(t));
          }
        }
        toBufferConst(t) {
          return this.toBufferValue("bytes", t.value);
        }
        async toBufferArg(t) {
          let [e, ...r] = t.path.split("."),
            n = this._idlIx.args.findIndex((t) => t.name === e);
          if (-1 === n)
            throw Error("Unable to find argument for seed: ".concat(e));
          let i = r.reduce((t, e) => (null != t ? t : {})[e], this._args[n]);
          if (void 0 === i) return;
          let o = this.getType(this._idlIx.args[n].type, r);
          return this.toBufferValue(o, i);
        }
        async toBufferAccount(t) {
          let e =
              arguments.length > 1 && void 0 !== arguments[1]
                ? arguments[1]
                : [],
            [r, ...n] = t.path.split("."),
            i = this.get([...e, r]);
          if (!i) return;
          if (!n.length) return this.toBufferValue("pubkey", i);
          if (!t.account)
            throw Error(
              "Seed account is required in order to resolve type: ".concat(
                t.path
              )
            );
          let o = await this._accountStore.fetchAccount({
              publicKey: i,
              name: t.account,
            }),
            s = n;
          for (; s.length > 0; ) (o = o[s[0]]), (s = s.slice(1));
          if (void 0 === o) return;
          let a = this.getType({ defined: { name: t.account } }, n);
          return this.toBufferValue(a, o);
        }
        toBufferValue(t, e) {
          switch (t) {
            case "u8":
            case "i8":
              return T.from([e]);
            case "u16":
            case "i16":
              return new (f())(e).toArrayLike(T, "le", 2);
            case "u32":
            case "i32":
              return new (f())(e).toArrayLike(T, "le", 4);
            case "u64":
            case "i64":
              return new (f())(e).toArrayLike(T, "le", 8);
            case "u128":
            case "i128":
              return new (f())(e).toArrayLike(T, "le", 16);
            case "u256":
            case "i256":
              return new (f())(e).toArrayLike(T, "le", 32);
            case "string":
            case "bytes":
              return T.from(e);
            case "pubkey":
              return e.toBuffer();
            default:
              if (null == t ? void 0 : t.array) return T.from(e);
              throw Error("Unexpected seed type: ".concat(t));
          }
        }
        getType(t) {
          var e;
          let r =
              arguments.length > 1 && void 0 !== arguments[1]
                ? arguments[1]
                : [],
            n =
              null === (e = null == t ? void 0 : t.defined) || void 0 === e
                ? void 0
                : e.name;
          if (n) {
            if ("tokenAccount" === n)
              switch (r.at(0)) {
                case "mint":
                case "owner":
                  return "pubkey";
                case "amount":
                case "delagatedAmount":
                  return "u64";
                default:
                  throw Error("Unknown token account path: ".concat(r));
              }
            let t = this._idlTypes.find((t) => t.name === n);
            if (!t) throw Error("Type not found: ".concat(n));
            let [e, ...i] = r,
              o = t.type.fields.find((t) => t.name === e);
            if (!o) throw Error("Field not found: ".concat(e));
            return this.getType(o.type, i);
          }
          return t;
        }
        constructor(t, e, r, n, i, o, s, a) {
          (this._args = t),
            (this._accounts = e),
            (this._provider = r),
            (this._programId = n),
            (this._idlIx = i),
            (this._idlTypes = s),
            (this._customResolver = a),
            (this._accountStore = new rD(r, o, n));
        }
      }
      class rD {
        async fetchAccount(t) {
          let { publicKey: e, name: r } = t,
            n = e.toBase58();
          if (!this._cache.has(n)) {
            let t = await this._provider.connection.getAccountInfo(e);
            if (null === t) throw Error("Account not found: ".concat(n));
            if ("tokenAccount" === r) {
              var i;
              let e = ((i = t.data), rb.decode(i));
              this._cache.set(n, e);
            } else {
              let e = await this.getAccountsNs(t.owner);
              if (e) {
                let r = Object.values(e)[0];
                if (r) {
                  let e = r.coder.accounts.decodeAny(t.data);
                  this._cache.set(n, e);
                }
              }
            }
          }
          return this._cache.get(n);
        }
        async getAccountsNs(t) {
          let e = t.toBase58();
          if (!this._idls[e]) {
            let r = await rk.fetchIdl(t, this._provider);
            if (r) {
              let t = new rk(r, this._provider);
              this._idls[e] = t.account;
            }
          }
          return this._idls[e];
        }
        constructor(t, e, r) {
          (this._provider = t),
            (this._cache = new Map()),
            (this._idls = {}),
            (this._idls[r.toBase58()] = e);
        }
      }
      class rP {
        static build(t, e, r, n, i, o, s, a, c, u, l) {
          return function () {
            for (var d = arguments.length, h = Array(d), _ = 0; _ < d; _++)
              h[_] = arguments[_];
            return new rL(h, n, i, o, s, a, t, e, r, c, u, l);
          };
        }
      }
      function rx(t) {
        return "object" == typeof t && null !== t && !("_bn" in t);
      }
      class rL {
        args(t) {
          (this._args = t), this._accountsResolver.args(t);
        }
        accounts(t) {
          return this.accountsPartial(t);
        }
        accountsPartial(t) {
          return (
            (this._resolveAccounts = !0),
            this._accountsResolver.resolveOptionals(t),
            this
          );
        }
        accountsStrict(t) {
          return (
            (this._resolveAccounts = !1),
            this._accountsResolver.resolveOptionals(t),
            this
          );
        }
        signers(t) {
          return (this._signers = this._signers.concat(t)), this;
        }
        remainingAccounts(t) {
          return (
            (this._remainingAccounts = this._remainingAccounts.concat(t)), this
          );
        }
        preInstructions(t) {
          let e =
            arguments.length > 1 && void 0 !== arguments[1] && arguments[1];
          return (
            e
              ? (this._preInstructions = t.concat(this._preInstructions))
              : (this._preInstructions = this._preInstructions.concat(t)),
            this
          );
        }
        postInstructions(t) {
          return (
            (this._postInstructions = this._postInstructions.concat(t)), this
          );
        }
        async pubkeys() {
          return (
            this._resolveAccounts && (await this._accountsResolver.resolve()),
            this._accounts
          );
        }
        async rpc(t) {
          return (
            this._resolveAccounts && (await this._accountsResolver.resolve()),
            this._rpcFn(...this._args, {
              accounts: this._accounts,
              signers: this._signers,
              remainingAccounts: this._remainingAccounts,
              preInstructions: this._preInstructions,
              postInstructions: this._postInstructions,
              options: t,
            })
          );
        }
        async rpcAndKeys(t) {
          return {
            pubkeys: await this.pubkeys(),
            signature: await this.rpc(t),
          };
        }
        async view(t) {
          if (
            (this._resolveAccounts && (await this._accountsResolver.resolve()),
            !this._viewFn)
          )
            throw Error("Method does not support views");
          return this._viewFn(...this._args, {
            accounts: this._accounts,
            signers: this._signers,
            remainingAccounts: this._remainingAccounts,
            preInstructions: this._preInstructions,
            postInstructions: this._postInstructions,
            options: t,
          });
        }
        async simulate(t) {
          return (
            this._resolveAccounts && (await this._accountsResolver.resolve()),
            this._simulateFn(...this._args, {
              accounts: this._accounts,
              signers: this._signers,
              remainingAccounts: this._remainingAccounts,
              preInstructions: this._preInstructions,
              postInstructions: this._postInstructions,
              options: t,
            })
          );
        }
        async instruction() {
          return (
            this._resolveAccounts && (await this._accountsResolver.resolve()),
            this._ixFn(...this._args, {
              accounts: this._accounts,
              signers: this._signers,
              remainingAccounts: this._remainingAccounts,
              preInstructions: this._preInstructions,
              postInstructions: this._postInstructions,
            })
          );
        }
        async prepare() {
          return {
            instruction: await this.instruction(),
            pubkeys: await this.pubkeys(),
            signers: this._signers,
          };
        }
        async transaction() {
          return (
            this._resolveAccounts && (await this._accountsResolver.resolve()),
            this._txFn(...this._args, {
              accounts: this._accounts,
              signers: this._signers,
              remainingAccounts: this._remainingAccounts,
              preInstructions: this._preInstructions,
              postInstructions: this._postInstructions,
            })
          );
        }
        constructor(t, e, r, n, i, o, s, a, c, u, l, d) {
          (this._args = t),
            (this._ixFn = e),
            (this._txFn = r),
            (this._rpcFn = n),
            (this._simulateFn = i),
            (this._viewFn = o),
            (this._accounts = {}),
            (this._remainingAccounts = []),
            (this._signers = []),
            (this._preInstructions = []),
            (this._postInstructions = []),
            (this._resolveAccounts = !0),
            (this._accountsResolver = new rM(
              t,
              this._accounts,
              s,
              a,
              c,
              u,
              l,
              d
            ));
        }
      }
      class rH {
        static build(t, e, r, n) {
          let i = e.accounts.find((t) => t.writable),
            o = !!e.returns;
          if (!i && o)
            return async function () {
              for (var i = arguments.length, o = Array(i), s = 0; s < i; s++)
                o[s] = arguments[s];
              let a = await r(...o),
                c = "Program return: ".concat(t, " "),
                u = a.raw.find((t) => t.startsWith(c));
              if (!u) throw Error("View expected return log");
              let l = w(u.slice(c.length)),
                d = e.returns;
              if (!d) throw Error("View expected return type");
              return ex.fieldLayout({ type: d }, n.types).decode(l);
            };
        }
      }
      class rU {
        static build(t, e, r, n, i) {
          let o = {},
            s = {},
            a = {},
            c = {},
            u = {},
            l = {},
            d = (function (t) {
              let e = new Map();
              return (
                t.errors &&
                  t.errors.forEach((t) => {
                    var r;
                    let n = null !== (r = t.msg) && void 0 !== r ? r : t.name;
                    e.set(t.code, n);
                  }),
                e
              );
            })(t),
            h = t.accounts ? r_.build(t, e, r, n) : {};
          return (
            t.instructions.forEach((_) => {
              let p = rl.build(_, (t, r) => e.instruction.encode(t, r), r),
                f = rd.build(_, p),
                R = rh.build(_, f, d, n),
                A = rT.build(_, f, d, n, e, r, t),
                y = rH.build(r, _, A, t),
                E = rP.build(
                  n,
                  r,
                  _,
                  p,
                  f,
                  R,
                  A,
                  y,
                  h,
                  t.types || [],
                  null == i ? void 0 : i(_)
                ),
                O = _.name;
              (s[O] = p),
                (a[O] = f),
                (o[O] = R),
                (c[O] = A),
                (u[O] = E),
                y && (l[O] = y);
            }),
            [o, s, a, h, c, u, l]
          );
        }
      }
      class rk {
        get programId() {
          return this._programId;
        }
        get idl() {
          return this._idl;
        }
        get rawIdl() {
          return this._rawIdl;
        }
        get coder() {
          return this._coder;
        }
        get provider() {
          return this._provider;
        }
        static async at(t, e) {
          let r = P(t),
            n = await rk.fetchIdl(r, e);
          if (!n)
            throw Error("IDL not found for program: ".concat(t.toString()));
          return new rk(n, e);
        }
        static async fetchIdl(t, e) {
          var r, n;
          e = null != e ? e : tc();
          let i = P(t),
            o = await b(i),
            s = await e.connection.getAccountInfo(o);
          if (!s) return null;
          let a = ((r = s.data.slice(8)), M.decode(r));
          return JSON.parse(
            ((n = (0, m.rr)(a.data)), new TextDecoder("utf-8").decode(n))
          );
        }
        addEventListener(t, e) {
          return this._events.addEventListener(t, e);
        }
        async removeEventListener(t) {
          return await this._events.removeEventListener(t);
        }
        constructor(t, e = tc(), r, n) {
          let i = (function (t) {
            let e = ["name", "path", "account", "relations", "generic"],
              r = (t) => t.split(".").map(E()).join("."),
              n = (t) => {
                for (let i in t) {
                  let o = t[i];
                  e.includes(i)
                    ? (t[i] = Array.isArray(o) ? o.map(r) : r(o))
                    : "object" == typeof o && n(o);
                }
              },
              i = structuredClone(t);
            return n(i), i;
          })(t);
          (this._idl = i),
            (this._rawIdl = t),
            (this._provider = e),
            (this._programId = P(t.address)),
            (this._coder = null != r ? r : new eV(i)),
            (this._events = new rO(this._programId, e, this._coder));
          let [o, s, a, c, u, l, d] = rU.build(
            i,
            this._coder,
            this._programId,
            e,
            n
          );
          (this.rpc = o),
            (this.instruction = s),
            (this.transaction = a),
            (this.account = c),
            (this.simulate = u),
            (this.methods = l),
            (this.views = d);
        }
      }
      new _.PublicKey("11111111111111111111111111111111");
    },
  },
]);