astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es458.js

@@ -0,0 +1,1186 @@
+import V from "./astra-sdk.es457.js";
+import { Core as rt, RELAYER_DEFAULT_PROTOCOL as nt, TRANSPORT_TYPES as q, EVENT_CLIENT_SESSION_TRACES as C, EVENT_CLIENT_SESSION_ERRORS as j, EVENT_CLIENT_AUTHENTICATE_TRACES as Q, EVENT_CLIENT_AUTHENTICATE_ERRORS as se, EVENT_CLIENT_PAIRING_ERRORS as at, EVENT_CLIENT_PAIRING_TRACES as ot, RELAYER_EVENTS as Me, VERIFY_SERVER as ct, EXPIRER_EVENTS as lt, PAIRING_EVENTS as Le, Store as W } from "./astra-sdk.es953.js";
+import { getDefaultLoggerOptions as pt, generateChildLogger as ht, getLoggerContext as dt } from "./astra-sdk.es460.js";
+import { ISignClient as ut, IEngine as gt } from "./astra-sdk.es954.js";
+import { getAppMetadata as yt, calcExpiry as b, createDelayedPromise as z, engineEvent as g, getSdkError as O, getDeepLink as wt, handleDeeplinkRedirect as mt, getInternalError as u, isSessionCompatible as Et, hashKey as Re, parseChainId as Se, createEncodedRecap as _t, getRecapFromResources as Ie, mergeEncodedRecaps as ft, TYPE_2 as Rt, BASE64URL as ie, getLinkModeURL as le, validateSignedCacao as ke, getNamespacedDidChainId as $e, getDidAddress as Ue, getMethodsFromRecap as Ke, getChainsFromRecap as Fe, buildNamespacesFromAuth as Ge, formatMessage as St, BASE64 as pe, hashMessage as Y, isExpired as H, MemoryStore as re, isValidParams as D, isUndefined as ne, isValidRelays as It, isValidObject as je, isValidRequiredNamespaces as qt, isValidNamespaces as qe, isConformingNamespaces as Qe, isValidString as $, isValidErrorReason as Tt, isValidRelay as Nt, isValidController as vt, isValidNamespacesChainId as ze, isValidRequest as Pt, isValidNamespacesRequest as Ot, isValidRequestExpiry as At, isValidResponse as bt, isValidEvent as Vt, isValidNamespacesEvent as Ct, getSearchParamFromURL as Ye, isTestRun as Dt, isReactNative as xt, parseExpirerTarget as Mt, isValidId as Lt, TYPE_1 as Te } from "./astra-sdk.es459.js";
+import kt, { e as $t } from "./astra-sdk.es465.js";
+import { c as _ } from "./astra-sdk.es935.js";
+import "./astra-sdk.es463.js";
+import { getBigIntRpcId as he, formatJsonRpcRequest as de, formatJsonRpcError as Ut, payloadId as X, formatJsonRpcResult as Kt } from "./astra-sdk.es464.js";
+import { isJsonRpcResult as U, isJsonRpcError as K, isJsonRpcRequest as Ft, isJsonRpcResponse as Gt } from "./astra-sdk.es955.js";
+import jt from "./astra-sdk.es16.js";
+const We = "wc", Be = 2, Ze = "client", Pe = `${We}@${Be}:${Ze}:`, Ne = { name: Ze, logger: "error", controller: !1, relayUrl: "wss://relay.walletconnect.org" }, He = "WALLETCONNECT_DEEPLINK_CHOICE", Qt = "proposal", zt = "Proposal expired", Yt = "session", J = _.SEVEN_DAYS, Ht = "engine", T = { wc_sessionPropose: { req: { ttl: _.FIVE_MINUTES, prompt: !0, tag: 1100 }, res: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1101 }, reject: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1120 }, autoReject: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1121 } }, wc_sessionSettle: { req: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1102 }, res: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1103 } }, wc_sessionUpdate: { req: { ttl: _.ONE_DAY, prompt: !1, tag: 1104 }, res: { ttl: _.ONE_DAY, prompt: !1, tag: 1105 } }, wc_sessionExtend: { req: { ttl: _.ONE_DAY, prompt: !1, tag: 1106 }, res: { ttl: _.ONE_DAY, prompt: !1, tag: 1107 } }, wc_sessionRequest: { req: { ttl: _.FIVE_MINUTES, prompt: !0, tag: 1108 }, res: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1109 } }, wc_sessionEvent: { req: { ttl: _.FIVE_MINUTES, prompt: !0, tag: 1110 }, res: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1111 } }, wc_sessionDelete: { req: { ttl: _.ONE_DAY, prompt: !1, tag: 1112 }, res: { ttl: _.ONE_DAY, prompt: !1, tag: 1113 } }, wc_sessionPing: { req: { ttl: _.ONE_DAY, prompt: !1, tag: 1114 }, res: { ttl: _.ONE_DAY, prompt: !1, tag: 1115 } }, wc_sessionAuthenticate: { req: { ttl: _.ONE_HOUR, prompt: !0, tag: 1116 }, res: { ttl: _.ONE_HOUR, prompt: !1, tag: 1117 }, reject: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1118 }, autoReject: { ttl: _.FIVE_MINUTES, prompt: !1, tag: 1119 } } }, ve = { min: _.FIVE_MINUTES, max: _.SEVEN_DAYS }, k = { idle: "IDLE", active: "ACTIVE" }, Xt = "request", Jt = ["wc_sessionPropose", "wc_sessionRequest", "wc_authRequest", "wc_sessionAuthenticate"], Wt = "wc", Bt = "auth", Zt = "authKeys", es = "pairingTopics", ts = "requests", ge = `${Wt}@${1.5}:${Bt}:`, ue = `${ge}:PUB_KEY`;
+var ss = Object.defineProperty, is = Object.defineProperties, rs = Object.getOwnPropertyDescriptors, Xe = Object.getOwnPropertySymbols, ns = Object.prototype.hasOwnProperty, as = Object.prototype.propertyIsEnumerable, Je = (N, a, e) => a in N ? ss(N, a, { enumerable: !0, configurable: !0, writable: !0, value: e }) : N[a] = e, I = (N, a) => {
+  for (var e in a || (a = {})) ns.call(a, e) && Je(N, e, a[e]);
+  if (Xe) for (var e of Xe(a)) as.call(a, e) && Je(N, e, a[e]);
+  return N;
+}, x = (N, a) => is(N, rs(a));
+class os extends gt {
+  constructor(a) {
+    super(a), this.name = Ht, this.events = new kt(), this.initialized = !1, this.requestQueue = { state: k.idle, queue: [] }, this.sessionRequestQueue = { state: k.idle, queue: [] }, this.requestQueueDelay = _.ONE_SECOND, this.expectedPairingMethodMap = /* @__PURE__ */ new Map(), this.recentlyDeletedMap = /* @__PURE__ */ new Map(), this.recentlyDeletedLimit = 200, this.relayMessageCache = [], this.init = async () => {
+      this.initialized || (await this.cleanup(), this.registerRelayerEvents(), this.registerExpirerEvents(), this.registerPairingEvents(), await this.registerLinkModeListeners(), this.client.core.pairing.register({ methods: Object.keys(T) }), this.initialized = !0, setTimeout(() => {
+        this.sessionRequestQueue.queue = this.getPendingSessionRequests(), this.processSessionRequestQueue();
+      }, _.toMiliseconds(this.requestQueueDelay)));
+    }, this.connect = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      const t = x(I({}, e), { requiredNamespaces: e.requiredNamespaces || {}, optionalNamespaces: e.optionalNamespaces || {} });
+      await this.isValidConnect(t);
+      const { pairingTopic: s, requiredNamespaces: i, optionalNamespaces: r, sessionProperties: n, relays: o } = t;
+      let c = s, h, p = !1;
+      try {
+        c && (p = this.client.core.pairing.pairings.get(c).active);
+      } catch (f) {
+        throw this.client.logger.error(`connect() -> pairing.get(${c}) failed`), f;
+      }
+      if (!c || !p) {
+        const { topic: f, uri: S } = await this.client.core.pairing.create();
+        c = f, h = S;
+      }
+      if (!c) {
+        const { message: f } = u("NO_MATCHING_KEY", `connect() pairing topic: ${c}`);
+        throw new Error(f);
+      }
+      const d = await this.client.core.crypto.generateKeyPair(), l = T.wc_sessionPropose.req.ttl || _.FIVE_MINUTES, w = b(l), E = I({ requiredNamespaces: i, optionalNamespaces: r, relays: o ?? [{ protocol: nt }], proposer: { publicKey: d, metadata: this.client.metadata }, expiryTimestamp: w, pairingTopic: c }, n && { sessionProperties: n }), { reject: y, resolve: m, done: R } = z(l, zt);
+      this.events.once(g("session_connect"), async ({ error: f, session: S }) => {
+        if (f) y(f);
+        else if (S) {
+          S.self.publicKey = d;
+          const L = x(I({}, S), { pairingTopic: E.pairingTopic, requiredNamespaces: E.requiredNamespaces, optionalNamespaces: E.optionalNamespaces, transportType: q.relay });
+          await this.client.session.set(S.topic, L), await this.setExpiry(S.topic, S.expiry), c && await this.client.core.pairing.updateMetadata({ topic: c, metadata: S.peer.metadata }), this.cleanupDuplicatePairings(L), m(L);
+        }
+      });
+      const M = await this.sendRequest({ topic: c, method: "wc_sessionPropose", params: E, throwOnFailedPublish: !0 });
+      return await this.setProposal(M, I({ id: M }, E)), { uri: h, approval: R };
+    }, this.pair = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      try {
+        return await this.client.core.pairing.pair(e);
+      } catch (t) {
+        throw this.client.logger.error("pair() failed"), t;
+      }
+    }, this.approve = async (e) => {
+      var t, s, i;
+      const r = this.client.core.eventClient.createEvent({ properties: { topic: (t = e == null ? void 0 : e.id) == null ? void 0 : t.toString(), trace: [C.session_approve_started] } });
+      try {
+        this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      } catch (P) {
+        throw r.setError(j.no_internet_connection), P;
+      }
+      try {
+        await this.isValidProposalId(e == null ? void 0 : e.id);
+      } catch (P) {
+        throw this.client.logger.error(`approve() -> proposal.get(${e == null ? void 0 : e.id}) failed`), r.setError(j.proposal_not_found), P;
+      }
+      try {
+        await this.isValidApprove(e);
+      } catch (P) {
+        throw this.client.logger.error("approve() -> isValidApprove() failed"), r.setError(j.session_approve_namespace_validation_failure), P;
+      }
+      const { id: n, relayProtocol: o, namespaces: c, sessionProperties: h, sessionConfig: p } = e, d = this.client.proposal.get(n);
+      this.client.core.eventClient.deleteEvent({ eventId: r.eventId });
+      const { pairingTopic: l, proposer: w, requiredNamespaces: E, optionalNamespaces: y } = d;
+      let m = (s = this.client.core.eventClient) == null ? void 0 : s.getEvent({ topic: l });
+      m || (m = (i = this.client.core.eventClient) == null ? void 0 : i.createEvent({ type: C.session_approve_started, properties: { topic: l, trace: [C.session_approve_started, C.session_namespaces_validation_success] } }));
+      const R = await this.client.core.crypto.generateKeyPair(), M = w.publicKey, f = await this.client.core.crypto.generateSharedKey(R, M), S = I(I({ relay: { protocol: o ?? "irn" }, namespaces: c, controller: { publicKey: R, metadata: this.client.metadata }, expiry: b(J) }, h && { sessionProperties: h }), p && { sessionConfig: p }), L = q.relay;
+      m.addTrace(C.subscribing_session_topic);
+      try {
+        await this.client.core.relayer.subscribe(f, { transportType: L });
+      } catch (P) {
+        throw m.setError(j.subscribe_session_topic_failure), P;
+      }
+      m.addTrace(C.subscribe_session_topic_success);
+      const B = x(I({}, S), { topic: f, requiredNamespaces: E, optionalNamespaces: y, pairingTopic: l, acknowledged: !1, self: S.controller, peer: { publicKey: w.publicKey, metadata: w.metadata }, controller: R, transportType: q.relay });
+      await this.client.session.set(f, B), m.addTrace(C.store_session);
+      try {
+        m.addTrace(C.publishing_session_settle), await this.sendRequest({ topic: f, method: "wc_sessionSettle", params: S, throwOnFailedPublish: !0 }).catch((P) => {
+          throw m == null || m.setError(j.session_settle_publish_failure), P;
+        }), m.addTrace(C.session_settle_publish_success), m.addTrace(C.publishing_session_approve), await this.sendResult({ id: n, topic: l, result: { relay: { protocol: o ?? "irn" }, responderPublicKey: R }, throwOnFailedPublish: !0 }).catch((P) => {
+          throw m == null || m.setError(j.session_approve_publish_failure), P;
+        }), m.addTrace(C.session_approve_publish_success);
+      } catch (P) {
+        throw this.client.logger.error(P), this.client.session.delete(f, O("USER_DISCONNECTED")), await this.client.core.relayer.unsubscribe(f), P;
+      }
+      return this.client.core.eventClient.deleteEvent({ eventId: m.eventId }), await this.client.core.pairing.updateMetadata({ topic: l, metadata: w.metadata }), await this.client.proposal.delete(n, O("USER_DISCONNECTED")), await this.client.core.pairing.activate({ topic: l }), await this.setExpiry(f, b(J)), { topic: f, acknowledged: () => Promise.resolve(this.client.session.get(f)) };
+    }, this.reject = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      try {
+        await this.isValidReject(e);
+      } catch (r) {
+        throw this.client.logger.error("reject() -> isValidReject() failed"), r;
+      }
+      const { id: t, reason: s } = e;
+      let i;
+      try {
+        i = this.client.proposal.get(t).pairingTopic;
+      } catch (r) {
+        throw this.client.logger.error(`reject() -> proposal.get(${t}) failed`), r;
+      }
+      i && (await this.sendError({ id: t, topic: i, error: s, rpcOpts: T.wc_sessionPropose.reject }), await this.client.proposal.delete(t, O("USER_DISCONNECTED")));
+    }, this.update = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      try {
+        await this.isValidUpdate(e);
+      } catch (p) {
+        throw this.client.logger.error("update() -> isValidUpdate() failed"), p;
+      }
+      const { topic: t, namespaces: s } = e, { done: i, resolve: r, reject: n } = z(), o = X(), c = he().toString(), h = this.client.session.get(t).namespaces;
+      return this.events.once(g("session_update", o), ({ error: p }) => {
+        p ? n(p) : r();
+      }), await this.client.session.update(t, { namespaces: s }), await this.sendRequest({ topic: t, method: "wc_sessionUpdate", params: { namespaces: s }, throwOnFailedPublish: !0, clientRpcId: o, relayRpcId: c }).catch((p) => {
+        this.client.logger.error(p), this.client.session.update(t, { namespaces: h }), n(p);
+      }), { acknowledged: i };
+    }, this.extend = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      try {
+        await this.isValidExtend(e);
+      } catch (o) {
+        throw this.client.logger.error("extend() -> isValidExtend() failed"), o;
+      }
+      const { topic: t } = e, s = X(), { done: i, resolve: r, reject: n } = z();
+      return this.events.once(g("session_extend", s), ({ error: o }) => {
+        o ? n(o) : r();
+      }), await this.setExpiry(t, b(J)), this.sendRequest({ topic: t, method: "wc_sessionExtend", params: {}, clientRpcId: s, throwOnFailedPublish: !0 }).catch((o) => {
+        n(o);
+      }), { acknowledged: i };
+    }, this.request = async (e) => {
+      this.isInitialized();
+      try {
+        await this.isValidRequest(e);
+      } catch (w) {
+        throw this.client.logger.error("request() -> isValidRequest() failed"), w;
+      }
+      const { chainId: t, request: s, topic: i, expiry: r = T.wc_sessionRequest.req.ttl } = e, n = this.client.session.get(i);
+      (n == null ? void 0 : n.transportType) === q.relay && await this.confirmOnlineStateOrThrow();
+      const o = X(), c = he().toString(), { done: h, resolve: p, reject: d } = z(r, "Request expired. Please try again.");
+      this.events.once(g("session_request", o), ({ error: w, result: E }) => {
+        w ? d(w) : p(E);
+      });
+      const l = this.getAppLinkIfEnabled(n.peer.metadata, n.transportType);
+      return l ? (await this.sendRequest({ clientRpcId: o, relayRpcId: c, topic: i, method: "wc_sessionRequest", params: { request: x(I({}, s), { expiryTimestamp: b(r) }), chainId: t }, expiry: r, throwOnFailedPublish: !0, appLink: l }).catch((w) => d(w)), this.client.events.emit("session_request_sent", { topic: i, request: s, chainId: t, id: o }), await h()) : await Promise.all([new Promise(async (w) => {
+        await this.sendRequest({ clientRpcId: o, relayRpcId: c, topic: i, method: "wc_sessionRequest", params: { request: x(I({}, s), { expiryTimestamp: b(r) }), chainId: t }, expiry: r, throwOnFailedPublish: !0 }).catch((E) => d(E)), this.client.events.emit("session_request_sent", { topic: i, request: s, chainId: t, id: o }), w();
+      }), new Promise(async (w) => {
+        var E;
+        if (!((E = n.sessionConfig) != null && E.disableDeepLink)) {
+          const y = await wt(this.client.core.storage, He);
+          await mt({ id: o, topic: i, wcDeepLink: y });
+        }
+        w();
+      }), h()]).then((w) => w[2]);
+    }, this.respond = async (e) => {
+      this.isInitialized(), await this.isValidRespond(e);
+      const { topic: t, response: s } = e, { id: i } = s, r = this.client.session.get(t);
+      r.transportType === q.relay && await this.confirmOnlineStateOrThrow();
+      const n = this.getAppLinkIfEnabled(r.peer.metadata, r.transportType);
+      U(s) ? await this.sendResult({ id: i, topic: t, result: s.result, throwOnFailedPublish: !0, appLink: n }) : K(s) && await this.sendError({ id: i, topic: t, error: s.error, appLink: n }), this.cleanupAfterResponse(e);
+    }, this.ping = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow();
+      try {
+        await this.isValidPing(e);
+      } catch (s) {
+        throw this.client.logger.error("ping() -> isValidPing() failed"), s;
+      }
+      const { topic: t } = e;
+      if (this.client.session.keys.includes(t)) {
+        const s = X(), i = he().toString(), { done: r, resolve: n, reject: o } = z();
+        this.events.once(g("session_ping", s), ({ error: c }) => {
+          c ? o(c) : n();
+        }), await Promise.all([this.sendRequest({ topic: t, method: "wc_sessionPing", params: {}, throwOnFailedPublish: !0, clientRpcId: s, relayRpcId: i }), r()]);
+      } else this.client.core.pairing.pairings.keys.includes(t) && await this.client.core.pairing.ping({ topic: t });
+    }, this.emit = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow(), await this.isValidEmit(e);
+      const { topic: t, event: s, chainId: i } = e, r = he().toString();
+      await this.sendRequest({ topic: t, method: "wc_sessionEvent", params: { event: s, chainId: i }, throwOnFailedPublish: !0, relayRpcId: r });
+    }, this.disconnect = async (e) => {
+      this.isInitialized(), await this.confirmOnlineStateOrThrow(), await this.isValidDisconnect(e);
+      const { topic: t } = e;
+      if (this.client.session.keys.includes(t)) await this.sendRequest({ topic: t, method: "wc_sessionDelete", params: O("USER_DISCONNECTED"), throwOnFailedPublish: !0 }), await this.deleteSession({ topic: t, emitEvent: !1 });
+      else if (this.client.core.pairing.pairings.keys.includes(t)) await this.client.core.pairing.disconnect({ topic: t });
+      else {
+        const { message: s } = u("MISMATCHED_TOPIC", `Session or pairing topic not found: ${t}`);
+        throw new Error(s);
+      }
+    }, this.find = (e) => (this.isInitialized(), this.client.session.getAll().filter((t) => Et(t, e))), this.getPendingSessionRequests = () => this.client.pendingRequest.getAll(), this.authenticate = async (e, t) => {
+      var s;
+      this.isInitialized(), this.isValidAuthenticate(e);
+      const i = t && this.client.core.linkModeSupportedApps.includes(t) && ((s = this.client.metadata.redirect) == null ? void 0 : s.linkMode), r = i ? q.link_mode : q.relay;
+      r === q.relay && await this.confirmOnlineStateOrThrow();
+      const { chains: n, statement: o = "", uri: c, domain: h, nonce: p, type: d, exp: l, nbf: w, methods: E = [], expiry: y } = e, m = [...e.resources || []], { topic: R, uri: M } = await this.client.core.pairing.create({ methods: ["wc_sessionAuthenticate"], transportType: r });
+      this.client.logger.info({ message: "Generated new pairing", pairing: { topic: R, uri: M } });
+      const f = await this.client.core.crypto.generateKeyPair(), S = Re(f);
+      if (await Promise.all([this.client.auth.authKeys.set(ue, { responseTopic: S, publicKey: f }), this.client.auth.pairingTopics.set(S, { topic: S, pairingTopic: R })]), await this.client.core.relayer.subscribe(S, { transportType: r }), this.client.logger.info(`sending request to new pairing topic: ${R}`), E.length > 0) {
+        const { namespace: A } = Se(n[0]);
+        let v = _t(A, "request", E);
+        Ie(m) && (v = ft(v, m.pop())), m.push(v);
+      }
+      const L = y && y > T.wc_sessionAuthenticate.req.ttl ? y : T.wc_sessionAuthenticate.req.ttl, B = { authPayload: { type: d ?? "caip122", chains: n, statement: o, aud: c, domain: h, version: "1", nonce: p, iat: (/* @__PURE__ */ new Date()).toISOString(), exp: l, nbf: w, resources: m }, requester: { publicKey: f, metadata: this.client.metadata }, expiryTimestamp: b(L) }, P = { eip155: { chains: n, methods: [.../* @__PURE__ */ new Set(["personal_sign", ...E])], events: ["chainChanged", "accountsChanged"] } }, Oe = { requiredNamespaces: {}, optionalNamespaces: P, relays: [{ protocol: "irn" }], pairingTopic: R, proposer: { publicKey: f, metadata: this.client.metadata }, expiryTimestamp: b(T.wc_sessionPropose.req.ttl) }, { done: tt, resolve: Ae, reject: ye } = z(L, "Request expired"), ae = async ({ error: A, session: v }) => {
+        if (this.events.off(g("session_request", F), we), A) ye(A);
+        else if (v) {
+          v.self.publicKey = f, await this.client.session.set(v.topic, v), await this.setExpiry(v.topic, v.expiry), R && await this.client.core.pairing.updateMetadata({ topic: R, metadata: v.peer.metadata });
+          const oe = this.client.session.get(v.topic);
+          await this.deleteProposal(Z), Ae({ session: oe });
+        }
+      }, we = async (A) => {
+        var v, oe, Ve;
+        if (await this.deletePendingAuthRequest(F, { message: "fulfilled", code: 0 }), A.error) {
+          const te = O("WC_METHOD_UNSUPPORTED", "wc_sessionAuthenticate");
+          return A.error.code === te.code ? void 0 : (this.events.off(g("session_connect"), ae), ye(A.error.message));
+        }
+        await this.deleteProposal(Z), this.events.off(g("session_connect"), ae);
+        const { cacaos: Ce, responder: G } = A.result, me = [], De = [];
+        for (const te of Ce) {
+          await ke({ cacao: te, projectId: this.client.core.projectId }) || (this.client.logger.error(te, "Signature verification failed"), ye(O("SESSION_SETTLEMENT_FAILED", "Signature verification failed")));
+          const { p: Ee } = te, _e = Ie(Ee.resources), xe = [$e(Ee.iss)], st = Ue(Ee.iss);
+          if (_e) {
+            const fe = Ke(_e), it = Fe(_e);
+            me.push(...fe), xe.push(...it);
+          }
+          for (const fe of xe) De.push(`${fe}:${st}`);
+        }
+        const ee = await this.client.core.crypto.generateSharedKey(f, G.publicKey);
+        let ce;
+        me.length > 0 && (ce = { topic: ee, acknowledged: !0, self: { publicKey: f, metadata: this.client.metadata }, peer: G, controller: G.publicKey, expiry: b(J), requiredNamespaces: {}, optionalNamespaces: {}, relay: { protocol: "irn" }, pairingTopic: R, namespaces: Ge([...new Set(me)], [...new Set(De)]), transportType: r }, await this.client.core.relayer.subscribe(ee, { transportType: r }), await this.client.session.set(ee, ce), R && await this.client.core.pairing.updateMetadata({ topic: R, metadata: G.metadata }), ce = this.client.session.get(ee)), (v = this.client.metadata.redirect) != null && v.linkMode && (oe = G.metadata.redirect) != null && oe.linkMode && (Ve = G.metadata.redirect) != null && Ve.universal && t && (this.client.core.addLinkModeSupportedApp(G.metadata.redirect.universal), this.client.session.update(ee, { transportType: q.link_mode })), Ae({ auths: Ce, session: ce });
+      }, F = X(), Z = X();
+      this.events.once(g("session_connect"), ae), this.events.once(g("session_request", F), we);
+      let be;
+      try {
+        if (i) {
+          const A = de("wc_sessionAuthenticate", B, F);
+          this.client.core.history.set(R, A);
+          const v = await this.client.core.crypto.encode("", A, { type: Rt, encoding: ie });
+          be = le(t, R, v);
+        } else await Promise.all([this.sendRequest({ topic: R, method: "wc_sessionAuthenticate", params: B, expiry: e.expiry, throwOnFailedPublish: !0, clientRpcId: F }), this.sendRequest({ topic: R, method: "wc_sessionPropose", params: Oe, expiry: T.wc_sessionPropose.req.ttl, throwOnFailedPublish: !0, clientRpcId: Z })]);
+      } catch (A) {
+        throw this.events.off(g("session_connect"), ae), this.events.off(g("session_request", F), we), A;
+      }
+      return await this.setProposal(Z, I({ id: Z }, Oe)), await this.setAuthRequest(F, { request: x(I({}, B), { verifyContext: {} }), pairingTopic: R, transportType: r }), { uri: be ?? M, response: tt };
+    }, this.approveSessionAuthenticate = async (e) => {
+      const { id: t, auths: s } = e, i = this.client.core.eventClient.createEvent({ properties: { topic: t.toString(), trace: [Q.authenticated_session_approve_started] } });
+      try {
+        this.isInitialized();
+      } catch (y) {
+        throw i.setError(se.no_internet_connection), y;
+      }
+      const r = this.getPendingAuthRequest(t);
+      if (!r) throw i.setError(se.authenticated_session_pending_request_not_found), new Error(`Could not find pending auth request with id ${t}`);
+      const n = r.transportType || q.relay;
+      n === q.relay && await this.confirmOnlineStateOrThrow();
+      const o = r.requester.publicKey, c = await this.client.core.crypto.generateKeyPair(), h = Re(o), p = { type: Te, receiverPublicKey: o, senderPublicKey: c }, d = [], l = [];
+      for (const y of s) {
+        if (!await ke({ cacao: y, projectId: this.client.core.projectId })) {
+          i.setError(se.invalid_cacao);
+          const S = O("SESSION_SETTLEMENT_FAILED", "Signature verification failed");
+          throw await this.sendError({ id: t, topic: h, error: S, encodeOpts: p }), new Error(S.message);
+        }
+        i.addTrace(Q.cacaos_verified);
+        const { p: m } = y, R = Ie(m.resources), M = [$e(m.iss)], f = Ue(m.iss);
+        if (R) {
+          const S = Ke(R), L = Fe(R);
+          d.push(...S), M.push(...L);
+        }
+        for (const S of M) l.push(`${S}:${f}`);
+      }
+      const w = await this.client.core.crypto.generateSharedKey(c, o);
+      i.addTrace(Q.create_authenticated_session_topic);
+      let E;
+      if ((d == null ? void 0 : d.length) > 0) {
+        E = { topic: w, acknowledged: !0, self: { publicKey: c, metadata: this.client.metadata }, peer: { publicKey: o, metadata: r.requester.metadata }, controller: o, expiry: b(J), authentication: s, requiredNamespaces: {}, optionalNamespaces: {}, relay: { protocol: "irn" }, pairingTopic: r.pairingTopic, namespaces: Ge([...new Set(d)], [...new Set(l)]), transportType: n }, i.addTrace(Q.subscribing_authenticated_session_topic);
+        try {
+          await this.client.core.relayer.subscribe(w, { transportType: n });
+        } catch (y) {
+          throw i.setError(se.subscribe_authenticated_session_topic_failure), y;
+        }
+        i.addTrace(Q.subscribe_authenticated_session_topic_success), await this.client.session.set(w, E), i.addTrace(Q.store_authenticated_session), await this.client.core.pairing.updateMetadata({ topic: r.pairingTopic, metadata: r.requester.metadata });
+      }
+      i.addTrace(Q.publishing_authenticated_session_approve);
+      try {
+        await this.sendResult({ topic: h, id: t, result: { cacaos: s, responder: { publicKey: c, metadata: this.client.metadata } }, encodeOpts: p, throwOnFailedPublish: !0, appLink: this.getAppLinkIfEnabled(r.requester.metadata, n) });
+      } catch (y) {
+        throw i.setError(se.authenticated_session_approve_publish_failure), y;
+      }
+      return await this.client.auth.requests.delete(t, { message: "fulfilled", code: 0 }), await this.client.core.pairing.activate({ topic: r.pairingTopic }), this.client.core.eventClient.deleteEvent({ eventId: i.eventId }), { session: E };
+    }, this.rejectSessionAuthenticate = async (e) => {
+      this.isInitialized();
+      const { id: t, reason: s } = e, i = this.getPendingAuthRequest(t);
+      if (!i) throw new Error(`Could not find pending auth request with id ${t}`);
+      i.transportType === q.relay && await this.confirmOnlineStateOrThrow();
+      const r = i.requester.publicKey, n = await this.client.core.crypto.generateKeyPair(), o = Re(r), c = { type: Te, receiverPublicKey: r, senderPublicKey: n };
+      await this.sendError({ id: t, topic: o, error: s, encodeOpts: c, rpcOpts: T.wc_sessionAuthenticate.reject, appLink: this.getAppLinkIfEnabled(i.requester.metadata, i.transportType) }), await this.client.auth.requests.delete(t, { message: "rejected", code: 0 }), await this.client.proposal.delete(t, O("USER_DISCONNECTED"));
+    }, this.formatAuthMessage = (e) => {
+      this.isInitialized();
+      const { request: t, iss: s } = e;
+      return St(t, s);
+    }, this.processRelayMessageCache = () => {
+      setTimeout(async () => {
+        if (this.relayMessageCache.length !== 0) for (; this.relayMessageCache.length > 0; ) try {
+          const e = this.relayMessageCache.shift();
+          e && await this.onRelayMessage(e);
+        } catch (e) {
+          this.client.logger.error(e);
+        }
+      }, 50);
+    }, this.cleanupDuplicatePairings = async (e) => {
+      if (e.pairingTopic) try {
+        const t = this.client.core.pairing.pairings.get(e.pairingTopic), s = this.client.core.pairing.pairings.getAll().filter((i) => {
+          var r, n;
+          return ((r = i.peerMetadata) == null ? void 0 : r.url) && ((n = i.peerMetadata) == null ? void 0 : n.url) === e.peer.metadata.url && i.topic && i.topic !== t.topic;
+        });
+        if (s.length === 0) return;
+        this.client.logger.info(`Cleaning up ${s.length} duplicate pairing(s)`), await Promise.all(s.map((i) => this.client.core.pairing.disconnect({ topic: i.topic }))), this.client.logger.info("Duplicate pairings clean up finished");
+      } catch (t) {
+        this.client.logger.error(t);
+      }
+    }, this.deleteSession = async (e) => {
+      var t;
+      const { topic: s, expirerHasDeleted: i = !1, emitEvent: r = !0, id: n = 0 } = e, { self: o } = this.client.session.get(s);
+      await this.client.core.relayer.unsubscribe(s), await this.client.session.delete(s, O("USER_DISCONNECTED")), this.addToRecentlyDeleted(s, "session"), this.client.core.crypto.keychain.has(o.publicKey) && await this.client.core.crypto.deleteKeyPair(o.publicKey), this.client.core.crypto.keychain.has(s) && await this.client.core.crypto.deleteSymKey(s), i || this.client.core.expirer.del(s), this.client.core.storage.removeItem(He).catch((c) => this.client.logger.warn(c)), this.getPendingSessionRequests().forEach((c) => {
+        c.topic === s && this.deletePendingSessionRequest(c.id, O("USER_DISCONNECTED"));
+      }), s === ((t = this.sessionRequestQueue.queue[0]) == null ? void 0 : t.topic) && (this.sessionRequestQueue.state = k.idle), r && this.client.events.emit("session_delete", { id: n, topic: s });
+    }, this.deleteProposal = async (e, t) => {
+      if (t) try {
+        const s = this.client.proposal.get(e), i = this.client.core.eventClient.getEvent({ topic: s.pairingTopic });
+        i == null || i.setError(j.proposal_expired);
+      } catch {
+      }
+      await Promise.all([this.client.proposal.delete(e, O("USER_DISCONNECTED")), t ? Promise.resolve() : this.client.core.expirer.del(e)]), this.addToRecentlyDeleted(e, "proposal");
+    }, this.deletePendingSessionRequest = async (e, t, s = !1) => {
+      await Promise.all([this.client.pendingRequest.delete(e, t), s ? Promise.resolve() : this.client.core.expirer.del(e)]), this.addToRecentlyDeleted(e, "request"), this.sessionRequestQueue.queue = this.sessionRequestQueue.queue.filter((i) => i.id !== e), s && (this.sessionRequestQueue.state = k.idle, this.client.events.emit("session_request_expire", { id: e }));
+    }, this.deletePendingAuthRequest = async (e, t, s = !1) => {
+      await Promise.all([this.client.auth.requests.delete(e, t), s ? Promise.resolve() : this.client.core.expirer.del(e)]);
+    }, this.setExpiry = async (e, t) => {
+      this.client.session.keys.includes(e) && (this.client.core.expirer.set(e, t), await this.client.session.update(e, { expiry: t }));
+    }, this.setProposal = async (e, t) => {
+      this.client.core.expirer.set(e, b(T.wc_sessionPropose.req.ttl)), await this.client.proposal.set(e, t);
+    }, this.setAuthRequest = async (e, t) => {
+      const { request: s, pairingTopic: i, transportType: r = q.relay } = t;
+      this.client.core.expirer.set(e, s.expiryTimestamp), await this.client.auth.requests.set(e, { authPayload: s.authPayload, requester: s.requester, expiryTimestamp: s.expiryTimestamp, id: e, pairingTopic: i, verifyContext: s.verifyContext, transportType: r });
+    }, this.setPendingSessionRequest = async (e) => {
+      const { id: t, topic: s, params: i, verifyContext: r } = e, n = i.request.expiryTimestamp || b(T.wc_sessionRequest.req.ttl);
+      this.client.core.expirer.set(t, n), await this.client.pendingRequest.set(t, { id: t, topic: s, params: i, verifyContext: r });
+    }, this.sendRequest = async (e) => {
+      const { topic: t, method: s, params: i, expiry: r, relayRpcId: n, clientRpcId: o, throwOnFailedPublish: c, appLink: h } = e, p = de(s, i, o);
+      let d;
+      const l = !!h;
+      try {
+        const y = l ? ie : pe;
+        d = await this.client.core.crypto.encode(t, p, { encoding: y });
+      } catch (y) {
+        throw await this.cleanup(), this.client.logger.error(`sendRequest() -> core.crypto.encode() for topic ${t} failed`), y;
+      }
+      let w;
+      if (Jt.includes(s)) {
+        const y = Y(JSON.stringify(p)), m = Y(d);
+        w = await this.client.core.verify.register({ id: m, decryptedId: y });
+      }
+      const E = T[s].req;
+      if (E.attestation = w, r && (E.ttl = r), n && (E.id = n), this.client.core.history.set(t, p), l) {
+        const y = le(h, t, d);
+        await V.Linking.openURL(y, this.client.name);
+      } else {
+        const y = T[s].req;
+        r && (y.ttl = r), n && (y.id = n), c ? (y.internal = x(I({}, y.internal), { throwOnFailedPublish: !0 }), await this.client.core.relayer.publish(t, d, y)) : this.client.core.relayer.publish(t, d, y).catch((m) => this.client.logger.error(m));
+      }
+      return p.id;
+    }, this.sendResult = async (e) => {
+      const { id: t, topic: s, result: i, throwOnFailedPublish: r, encodeOpts: n, appLink: o } = e, c = Kt(t, i);
+      let h;
+      const p = o && typeof (V == null ? void 0 : V.Linking) < "u";
+      try {
+        const l = p ? ie : pe;
+        h = await this.client.core.crypto.encode(s, c, x(I({}, n || {}), { encoding: l }));
+      } catch (l) {
+        throw await this.cleanup(), this.client.logger.error(`sendResult() -> core.crypto.encode() for topic ${s} failed`), l;
+      }
+      let d;
+      try {
+        d = await this.client.core.history.get(s, t);
+      } catch (l) {
+        throw this.client.logger.error(`sendResult() -> history.get(${s}, ${t}) failed`), l;
+      }
+      if (p) {
+        const l = le(o, s, h);
+        await V.Linking.openURL(l, this.client.name);
+      } else {
+        const l = T[d.request.method].res;
+        r ? (l.internal = x(I({}, l.internal), { throwOnFailedPublish: !0 }), await this.client.core.relayer.publish(s, h, l)) : this.client.core.relayer.publish(s, h, l).catch((w) => this.client.logger.error(w));
+      }
+      await this.client.core.history.resolve(c);
+    }, this.sendError = async (e) => {
+      const { id: t, topic: s, error: i, encodeOpts: r, rpcOpts: n, appLink: o } = e, c = Ut(t, i);
+      let h;
+      const p = o && typeof (V == null ? void 0 : V.Linking) < "u";
+      try {
+        const l = p ? ie : pe;
+        h = await this.client.core.crypto.encode(s, c, x(I({}, r || {}), { encoding: l }));
+      } catch (l) {
+        throw await this.cleanup(), this.client.logger.error(`sendError() -> core.crypto.encode() for topic ${s} failed`), l;
+      }
+      let d;
+      try {
+        d = await this.client.core.history.get(s, t);
+      } catch (l) {
+        throw this.client.logger.error(`sendError() -> history.get(${s}, ${t}) failed`), l;
+      }
+      if (p) {
+        const l = le(o, s, h);
+        await V.Linking.openURL(l, this.client.name);
+      } else {
+        const l = n || T[d.request.method].res;
+        this.client.core.relayer.publish(s, h, l);
+      }
+      await this.client.core.history.resolve(c);
+    }, this.cleanup = async () => {
+      const e = [], t = [];
+      this.client.session.getAll().forEach((s) => {
+        let i = !1;
+        H(s.expiry) && (i = !0), this.client.core.crypto.keychain.has(s.topic) || (i = !0), i && e.push(s.topic);
+      }), this.client.proposal.getAll().forEach((s) => {
+        H(s.expiryTimestamp) && t.push(s.id);
+      }), await Promise.all([...e.map((s) => this.deleteSession({ topic: s })), ...t.map((s) => this.deleteProposal(s))]);
+    }, this.onRelayEventRequest = async (e) => {
+      this.requestQueue.queue.push(e), await this.processRequestsQueue();
+    }, this.processRequestsQueue = async () => {
+      if (this.requestQueue.state === k.active) {
+        this.client.logger.info("Request queue already active, skipping...");
+        return;
+      }
+      for (this.client.logger.info(`Request queue starting with ${this.requestQueue.queue.length} requests`); this.requestQueue.queue.length > 0; ) {
+        this.requestQueue.state = k.active;
+        const e = this.requestQueue.queue.shift();
+        if (e) try {
+          await this.processRequest(e);
+        } catch (t) {
+          this.client.logger.warn(t);
+        }
+      }
+      this.requestQueue.state = k.idle;
+    }, this.processRequest = async (e) => {
+      const { topic: t, payload: s, attestation: i, transportType: r, encryptedId: n } = e, o = s.method;
+      if (!this.shouldIgnorePairingRequest({ topic: t, requestMethod: o })) switch (o) {
+        case "wc_sessionPropose":
+          return await this.onSessionProposeRequest({ topic: t, payload: s, attestation: i, encryptedId: n });
+        case "wc_sessionSettle":
+          return await this.onSessionSettleRequest(t, s);
+        case "wc_sessionUpdate":
+          return await this.onSessionUpdateRequest(t, s);
+        case "wc_sessionExtend":
+          return await this.onSessionExtendRequest(t, s);
+        case "wc_sessionPing":
+          return await this.onSessionPingRequest(t, s);
+        case "wc_sessionDelete":
+          return await this.onSessionDeleteRequest(t, s);
+        case "wc_sessionRequest":
+          return await this.onSessionRequest({ topic: t, payload: s, attestation: i, encryptedId: n, transportType: r });
+        case "wc_sessionEvent":
+          return await this.onSessionEventRequest(t, s);
+        case "wc_sessionAuthenticate":
+          return await this.onSessionAuthenticateRequest({ topic: t, payload: s, attestation: i, encryptedId: n, transportType: r });
+        default:
+          return this.client.logger.info(`Unsupported request method ${o}`);
+      }
+    }, this.onRelayEventResponse = async (e) => {
+      const { topic: t, payload: s, transportType: i } = e, r = (await this.client.core.history.get(t, s.id)).request.method;
+      switch (r) {
+        case "wc_sessionPropose":
+          return this.onSessionProposeResponse(t, s, i);
+        case "wc_sessionSettle":
+          return this.onSessionSettleResponse(t, s);
+        case "wc_sessionUpdate":
+          return this.onSessionUpdateResponse(t, s);
+        case "wc_sessionExtend":
+          return this.onSessionExtendResponse(t, s);
+        case "wc_sessionPing":
+          return this.onSessionPingResponse(t, s);
+        case "wc_sessionRequest":
+          return this.onSessionRequestResponse(t, s);
+        case "wc_sessionAuthenticate":
+          return this.onSessionAuthenticateResponse(t, s);
+        default:
+          return this.client.logger.info(`Unsupported response method ${r}`);
+      }
+    }, this.onRelayEventUnknownPayload = (e) => {
+      const { topic: t } = e, { message: s } = u("MISSING_OR_INVALID", `Decoded payload on topic ${t} is not identifiable as a JSON-RPC request or a response.`);
+      throw new Error(s);
+    }, this.shouldIgnorePairingRequest = (e) => {
+      const { topic: t, requestMethod: s } = e, i = this.expectedPairingMethodMap.get(t);
+      return !i || i.includes(s) ? !1 : !!(i.includes("wc_sessionAuthenticate") && this.client.events.listenerCount("session_authenticate") > 0);
+    }, this.onSessionProposeRequest = async (e) => {
+      const { topic: t, payload: s, attestation: i, encryptedId: r } = e, { params: n, id: o } = s;
+      try {
+        const c = this.client.core.eventClient.getEvent({ topic: t });
+        this.isValidConnect(I({}, s.params));
+        const h = n.expiryTimestamp || b(T.wc_sessionPropose.req.ttl), p = I({ id: o, pairingTopic: t, expiryTimestamp: h }, n);
+        await this.setProposal(o, p);
+        const d = await this.getVerifyContext({ attestationId: i, hash: Y(JSON.stringify(s)), encryptedId: r, metadata: p.proposer.metadata });
+        this.client.events.listenerCount("session_proposal") === 0 && (console.warn("No listener for session_proposal event"), c == null || c.setError(at.proposal_listener_not_found)), c == null || c.addTrace(ot.emit_session_proposal), this.client.events.emit("session_proposal", { id: o, params: p, verifyContext: d });
+      } catch (c) {
+        await this.sendError({ id: o, topic: t, error: c, rpcOpts: T.wc_sessionPropose.autoReject }), this.client.logger.error(c);
+      }
+    }, this.onSessionProposeResponse = async (e, t, s) => {
+      const { id: i } = t;
+      if (U(t)) {
+        const { result: r } = t;
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", result: r });
+        const n = this.client.proposal.get(i);
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", proposal: n });
+        const o = n.proposer.publicKey;
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", selfPublicKey: o });
+        const c = r.responderPublicKey;
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", peerPublicKey: c });
+        const h = await this.client.core.crypto.generateSharedKey(o, c);
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", sessionTopic: h });
+        const p = await this.client.core.relayer.subscribe(h, { transportType: s });
+        this.client.logger.trace({ type: "method", method: "onSessionProposeResponse", subscriptionId: p }), await this.client.core.pairing.activate({ topic: e });
+      } else if (K(t)) {
+        await this.client.proposal.delete(i, O("USER_DISCONNECTED"));
+        const r = g("session_connect");
+        if (this.events.listenerCount(r) === 0) throw new Error(`emitting ${r} without any listeners, 954`);
+        this.events.emit(g("session_connect"), { error: t.error });
+      }
+    }, this.onSessionSettleRequest = async (e, t) => {
+      const { id: s, params: i } = t;
+      try {
+        this.isValidSessionSettleRequest(i);
+        const { relay: r, controller: n, expiry: o, namespaces: c, sessionProperties: h, sessionConfig: p } = t.params, d = x(I(I({ topic: e, relay: r, expiry: o, namespaces: c, acknowledged: !0, pairingTopic: "", requiredNamespaces: {}, optionalNamespaces: {}, controller: n.publicKey, self: { publicKey: "", metadata: this.client.metadata }, peer: { publicKey: n.publicKey, metadata: n.metadata } }, h && { sessionProperties: h }), p && { sessionConfig: p }), { transportType: q.relay }), l = g("session_connect");
+        if (this.events.listenerCount(l) === 0) throw new Error(`emitting ${l} without any listeners 997`);
+        this.events.emit(g("session_connect"), { session: d }), await this.sendResult({ id: t.id, topic: e, result: !0, throwOnFailedPublish: !0 });
+      } catch (r) {
+        await this.sendError({ id: s, topic: e, error: r }), this.client.logger.error(r);
+      }
+    }, this.onSessionSettleResponse = async (e, t) => {
+      const { id: s } = t;
+      U(t) ? (await this.client.session.update(e, { acknowledged: !0 }), this.events.emit(g("session_approve", s), {})) : K(t) && (await this.client.session.delete(e, O("USER_DISCONNECTED")), this.events.emit(g("session_approve", s), { error: t.error }));
+    }, this.onSessionUpdateRequest = async (e, t) => {
+      const { params: s, id: i } = t;
+      try {
+        const r = `${e}_session_update`, n = re.get(r);
+        if (n && this.isRequestOutOfSync(n, i)) {
+          this.client.logger.info(`Discarding out of sync request - ${i}`), this.sendError({ id: i, topic: e, error: O("INVALID_UPDATE_REQUEST") });
+          return;
+        }
+        this.isValidUpdate(I({ topic: e }, s));
+        try {
+          re.set(r, i), await this.client.session.update(e, { namespaces: s.namespaces }), await this.sendResult({ id: i, topic: e, result: !0, throwOnFailedPublish: !0 });
+        } catch (o) {
+          throw re.delete(r), o;
+        }
+        this.client.events.emit("session_update", { id: i, topic: e, params: s });
+      } catch (r) {
+        await this.sendError({ id: i, topic: e, error: r }), this.client.logger.error(r);
+      }
+    }, this.isRequestOutOfSync = (e, t) => parseInt(t.toString().slice(0, -3)) <= parseInt(e.toString().slice(0, -3)), this.onSessionUpdateResponse = (e, t) => {
+      const { id: s } = t, i = g("session_update", s);
+      if (this.events.listenerCount(i) === 0) throw new Error(`emitting ${i} without any listeners`);
+      U(t) ? this.events.emit(g("session_update", s), {}) : K(t) && this.events.emit(g("session_update", s), { error: t.error });
+    }, this.onSessionExtendRequest = async (e, t) => {
+      const { id: s } = t;
+      try {
+        this.isValidExtend({ topic: e }), await this.setExpiry(e, b(J)), await this.sendResult({ id: s, topic: e, result: !0, throwOnFailedPublish: !0 }), this.client.events.emit("session_extend", { id: s, topic: e });
+      } catch (i) {
+        await this.sendError({ id: s, topic: e, error: i }), this.client.logger.error(i);
+      }
+    }, this.onSessionExtendResponse = (e, t) => {
+      const { id: s } = t, i = g("session_extend", s);
+      if (this.events.listenerCount(i) === 0) throw new Error(`emitting ${i} without any listeners`);
+      U(t) ? this.events.emit(g("session_extend", s), {}) : K(t) && this.events.emit(g("session_extend", s), { error: t.error });
+    }, this.onSessionPingRequest = async (e, t) => {
+      const { id: s } = t;
+      try {
+        this.isValidPing({ topic: e }), await this.sendResult({ id: s, topic: e, result: !0, throwOnFailedPublish: !0 }), this.client.events.emit("session_ping", { id: s, topic: e });
+      } catch (i) {
+        await this.sendError({ id: s, topic: e, error: i }), this.client.logger.error(i);
+      }
+    }, this.onSessionPingResponse = (e, t) => {
+      const { id: s } = t, i = g("session_ping", s);
+      if (this.events.listenerCount(i) === 0) throw new Error(`emitting ${i} without any listeners`);
+      setTimeout(() => {
+        U(t) ? this.events.emit(g("session_ping", s), {}) : K(t) && this.events.emit(g("session_ping", s), { error: t.error });
+      }, 500);
+    }, this.onSessionDeleteRequest = async (e, t) => {
+      const { id: s } = t;
+      try {
+        this.isValidDisconnect({ topic: e, reason: t.params }), Promise.all([new Promise((i) => {
+          this.client.core.relayer.once(Me.publish, async () => {
+            i(await this.deleteSession({ topic: e, id: s }));
+          });
+        }), this.sendResult({ id: s, topic: e, result: !0, throwOnFailedPublish: !0 }), this.cleanupPendingSentRequestsForTopic({ topic: e, error: O("USER_DISCONNECTED") })]).catch((i) => this.client.logger.error(i));
+      } catch (i) {
+        this.client.logger.error(i);
+      }
+    }, this.onSessionRequest = async (e) => {
+      var t, s, i;
+      const { topic: r, payload: n, attestation: o, encryptedId: c, transportType: h } = e, { id: p, params: d } = n;
+      try {
+        await this.isValidRequest(I({ topic: r }, d));
+        const l = this.client.session.get(r), w = await this.getVerifyContext({ attestationId: o, hash: Y(JSON.stringify(de("wc_sessionRequest", d, p))), encryptedId: c, metadata: l.peer.metadata, transportType: h }), E = { id: p, topic: r, params: d, verifyContext: w };
+        await this.setPendingSessionRequest(E), h === q.link_mode && (t = l.peer.metadata.redirect) != null && t.universal && this.client.core.addLinkModeSupportedApp((s = l.peer.metadata.redirect) == null ? void 0 : s.universal), (i = this.client.signConfig) != null && i.disableRequestQueue ? this.emitSessionRequest(E) : (this.addSessionRequestToSessionRequestQueue(E), this.processSessionRequestQueue());
+      } catch (l) {
+        await this.sendError({ id: p, topic: r, error: l }), this.client.logger.error(l);
+      }
+    }, this.onSessionRequestResponse = (e, t) => {
+      const { id: s } = t, i = g("session_request", s);
+      if (this.events.listenerCount(i) === 0) throw new Error(`emitting ${i} without any listeners`);
+      U(t) ? this.events.emit(g("session_request", s), { result: t.result }) : K(t) && this.events.emit(g("session_request", s), { error: t.error });
+    }, this.onSessionEventRequest = async (e, t) => {
+      const { id: s, params: i } = t;
+      try {
+        const r = `${e}_session_event_${i.event.name}`, n = re.get(r);
+        if (n && this.isRequestOutOfSync(n, s)) {
+          this.client.logger.info(`Discarding out of sync request - ${s}`);
+          return;
+        }
+        this.isValidEmit(I({ topic: e }, i)), this.client.events.emit("session_event", { id: s, topic: e, params: i }), re.set(r, s);
+      } catch (r) {
+        await this.sendError({ id: s, topic: e, error: r }), this.client.logger.error(r);
+      }
+    }, this.onSessionAuthenticateResponse = (e, t) => {
+      const { id: s } = t;
+      this.client.logger.trace({ type: "method", method: "onSessionAuthenticateResponse", topic: e, payload: t }), U(t) ? this.events.emit(g("session_request", s), { result: t.result }) : K(t) && this.events.emit(g("session_request", s), { error: t.error });
+    }, this.onSessionAuthenticateRequest = async (e) => {
+      var t;
+      const { topic: s, payload: i, attestation: r, encryptedId: n, transportType: o } = e;
+      try {
+        const { requester: c, authPayload: h, expiryTimestamp: p } = i.params, d = await this.getVerifyContext({ attestationId: r, hash: Y(JSON.stringify(i)), encryptedId: n, metadata: c.metadata, transportType: o }), l = { requester: c, pairingTopic: s, id: i.id, authPayload: h, verifyContext: d, expiryTimestamp: p };
+        await this.setAuthRequest(i.id, { request: l, pairingTopic: s, transportType: o }), o === q.link_mode && (t = c.metadata.redirect) != null && t.universal && this.client.core.addLinkModeSupportedApp(c.metadata.redirect.universal), this.client.events.emit("session_authenticate", { topic: s, params: i.params, id: i.id, verifyContext: d });
+      } catch (c) {
+        this.client.logger.error(c);
+        const h = i.params.requester.publicKey, p = await this.client.core.crypto.generateKeyPair(), d = this.getAppLinkIfEnabled(i.params.requester.metadata, o), l = { type: Te, receiverPublicKey: h, senderPublicKey: p };
+        await this.sendError({ id: i.id, topic: s, error: c, encodeOpts: l, rpcOpts: T.wc_sessionAuthenticate.autoReject, appLink: d });
+      }
+    }, this.addSessionRequestToSessionRequestQueue = (e) => {
+      this.sessionRequestQueue.queue.push(e);
+    }, this.cleanupAfterResponse = (e) => {
+      this.deletePendingSessionRequest(e.response.id, { message: "fulfilled", code: 0 }), setTimeout(() => {
+        this.sessionRequestQueue.state = k.idle, this.processSessionRequestQueue();
+      }, _.toMiliseconds(this.requestQueueDelay));
+    }, this.cleanupPendingSentRequestsForTopic = ({ topic: e, error: t }) => {
+      const s = this.client.core.history.pending;
+      s.length > 0 && s.filter((i) => i.topic === e && i.request.method === "wc_sessionRequest").forEach((i) => {
+        const r = i.request.id, n = g("session_request", r);
+        if (this.events.listenerCount(n) === 0) throw new Error(`emitting ${n} without any listeners`);
+        this.events.emit(g("session_request", i.request.id), { error: t });
+      });
+    }, this.processSessionRequestQueue = () => {
+      if (this.sessionRequestQueue.state === k.active) {
+        this.client.logger.info("session request queue is already active.");
+        return;
+      }
+      const e = this.sessionRequestQueue.queue[0];
+      if (!e) {
+        this.client.logger.info("session request queue is empty.");
+        return;
+      }
+      try {
+        this.sessionRequestQueue.state = k.active, this.emitSessionRequest(e);
+      } catch (t) {
+        this.client.logger.error(t);
+      }
+    }, this.emitSessionRequest = (e) => {
+      this.client.events.emit("session_request", e);
+    }, this.onPairingCreated = (e) => {
+      if (e.methods && this.expectedPairingMethodMap.set(e.topic, e.methods), e.active) return;
+      const t = this.client.proposal.getAll().find((s) => s.pairingTopic === e.topic);
+      t && this.onSessionProposeRequest({ topic: e.topic, payload: de("wc_sessionPropose", { requiredNamespaces: t.requiredNamespaces, optionalNamespaces: t.optionalNamespaces, relays: t.relays, proposer: t.proposer, sessionProperties: t.sessionProperties }, t.id) });
+    }, this.isValidConnect = async (e) => {
+      if (!D(e)) {
+        const { message: o } = u("MISSING_OR_INVALID", `connect() params: ${JSON.stringify(e)}`);
+        throw new Error(o);
+      }
+      const { pairingTopic: t, requiredNamespaces: s, optionalNamespaces: i, sessionProperties: r, relays: n } = e;
+      if (ne(t) || await this.isValidPairingTopic(t), !It(n)) {
+        const { message: o } = u("MISSING_OR_INVALID", `connect() relays: ${n}`);
+        throw new Error(o);
+      }
+      !ne(s) && je(s) !== 0 && this.validateNamespaces(s, "requiredNamespaces"), !ne(i) && je(i) !== 0 && this.validateNamespaces(i, "optionalNamespaces"), ne(r) || this.validateSessionProps(r, "sessionProperties");
+    }, this.validateNamespaces = (e, t) => {
+      const s = qt(e, "connect()", t);
+      if (s) throw new Error(s.message);
+    }, this.isValidApprove = async (e) => {
+      if (!D(e)) throw new Error(u("MISSING_OR_INVALID", `approve() params: ${e}`).message);
+      const { id: t, namespaces: s, relayProtocol: i, sessionProperties: r } = e;
+      this.checkRecentlyDeleted(t), await this.isValidProposalId(t);
+      const n = this.client.proposal.get(t), o = qe(s, "approve()");
+      if (o) throw new Error(o.message);
+      const c = Qe(n.requiredNamespaces, s, "approve()");
+      if (c) throw new Error(c.message);
+      if (!$(i, !0)) {
+        const { message: h } = u("MISSING_OR_INVALID", `approve() relayProtocol: ${i}`);
+        throw new Error(h);
+      }
+      ne(r) || this.validateSessionProps(r, "sessionProperties");
+    }, this.isValidReject = async (e) => {
+      if (!D(e)) {
+        const { message: i } = u("MISSING_OR_INVALID", `reject() params: ${e}`);
+        throw new Error(i);
+      }
+      const { id: t, reason: s } = e;
+      if (this.checkRecentlyDeleted(t), await this.isValidProposalId(t), !Tt(s)) {
+        const { message: i } = u("MISSING_OR_INVALID", `reject() reason: ${JSON.stringify(s)}`);
+        throw new Error(i);
+      }
+    }, this.isValidSessionSettleRequest = (e) => {
+      if (!D(e)) {
+        const { message: c } = u("MISSING_OR_INVALID", `onSessionSettleRequest() params: ${e}`);
+        throw new Error(c);
+      }
+      const { relay: t, controller: s, namespaces: i, expiry: r } = e;
+      if (!Nt(t)) {
+        const { message: c } = u("MISSING_OR_INVALID", "onSessionSettleRequest() relay protocol should be a string");
+        throw new Error(c);
+      }
+      const n = vt(s, "onSessionSettleRequest()");
+      if (n) throw new Error(n.message);
+      const o = qe(i, "onSessionSettleRequest()");
+      if (o) throw new Error(o.message);
+      if (H(r)) {
+        const { message: c } = u("EXPIRED", "onSessionSettleRequest()");
+        throw new Error(c);
+      }
+    }, this.isValidUpdate = async (e) => {
+      if (!D(e)) {
+        const { message: o } = u("MISSING_OR_INVALID", `update() params: ${e}`);
+        throw new Error(o);
+      }
+      const { topic: t, namespaces: s } = e;
+      this.checkRecentlyDeleted(t), await this.isValidSessionTopic(t);
+      const i = this.client.session.get(t), r = qe(s, "update()");
+      if (r) throw new Error(r.message);
+      const n = Qe(i.requiredNamespaces, s, "update()");
+      if (n) throw new Error(n.message);
+    }, this.isValidExtend = async (e) => {
+      if (!D(e)) {
+        const { message: s } = u("MISSING_OR_INVALID", `extend() params: ${e}`);
+        throw new Error(s);
+      }
+      const { topic: t } = e;
+      this.checkRecentlyDeleted(t), await this.isValidSessionTopic(t);
+    }, this.isValidRequest = async (e) => {
+      if (!D(e)) {
+        const { message: o } = u("MISSING_OR_INVALID", `request() params: ${e}`);
+        throw new Error(o);
+      }
+      const { topic: t, request: s, chainId: i, expiry: r } = e;
+      this.checkRecentlyDeleted(t), await this.isValidSessionTopic(t);
+      const { namespaces: n } = this.client.session.get(t);
+      if (!ze(n, i)) {
+        const { message: o } = u("MISSING_OR_INVALID", `request() chainId: ${i}`);
+        throw new Error(o);
+      }
+      if (!Pt(s)) {
+        const { message: o } = u("MISSING_OR_INVALID", `request() ${JSON.stringify(s)}`);
+        throw new Error(o);
+      }
+      if (!Ot(n, i, s.method)) {
+        const { message: o } = u("MISSING_OR_INVALID", `request() method: ${s.method}`);
+        throw new Error(o);
+      }
+      if (r && !At(r, ve)) {
+        const { message: o } = u("MISSING_OR_INVALID", `request() expiry: ${r}. Expiry must be a number (in seconds) between ${ve.min} and ${ve.max}`);
+        throw new Error(o);
+      }
+    }, this.isValidRespond = async (e) => {
+      var t;
+      if (!D(e)) {
+        const { message: r } = u("MISSING_OR_INVALID", `respond() params: ${e}`);
+        throw new Error(r);
+      }
+      const { topic: s, response: i } = e;
+      try {
+        await this.isValidSessionTopic(s);
+      } catch (r) {
+        throw (t = e == null ? void 0 : e.response) != null && t.id && this.cleanupAfterResponse(e), r;
+      }
+      if (!bt(i)) {
+        const { message: r } = u("MISSING_OR_INVALID", `respond() response: ${JSON.stringify(i)}`);
+        throw new Error(r);
+      }
+    }, this.isValidPing = async (e) => {
+      if (!D(e)) {
+        const { message: s } = u("MISSING_OR_INVALID", `ping() params: ${e}`);
+        throw new Error(s);
+      }
+      const { topic: t } = e;
+      await this.isValidSessionOrPairingTopic(t);
+    }, this.isValidEmit = async (e) => {
+      if (!D(e)) {
+        const { message: n } = u("MISSING_OR_INVALID", `emit() params: ${e}`);
+        throw new Error(n);
+      }
+      const { topic: t, event: s, chainId: i } = e;
+      await this.isValidSessionTopic(t);
+      const { namespaces: r } = this.client.session.get(t);
+      if (!ze(r, i)) {
+        const { message: n } = u("MISSING_OR_INVALID", `emit() chainId: ${i}`);
+        throw new Error(n);
+      }
+      if (!Vt(s)) {
+        const { message: n } = u("MISSING_OR_INVALID", `emit() event: ${JSON.stringify(s)}`);
+        throw new Error(n);
+      }
+      if (!Ct(r, i, s.name)) {
+        const { message: n } = u("MISSING_OR_INVALID", `emit() event: ${JSON.stringify(s)}`);
+        throw new Error(n);
+      }
+    }, this.isValidDisconnect = async (e) => {
+      if (!D(e)) {
+        const { message: s } = u("MISSING_OR_INVALID", `disconnect() params: ${e}`);
+        throw new Error(s);
+      }
+      const { topic: t } = e;
+      await this.isValidSessionOrPairingTopic(t);
+    }, this.isValidAuthenticate = (e) => {
+      const { chains: t, uri: s, domain: i, nonce: r } = e;
+      if (!Array.isArray(t) || t.length === 0) throw new Error("chains is required and must be a non-empty array");
+      if (!$(s, !1)) throw new Error("uri is required parameter");
+      if (!$(i, !1)) throw new Error("domain is required parameter");
+      if (!$(r, !1)) throw new Error("nonce is required parameter");
+      if ([...new Set(t.map((o) => Se(o).namespace))].length > 1) throw new Error("Multi-namespace requests are not supported. Please request single namespace only.");
+      const { namespace: n } = Se(t[0]);
+      if (n !== "eip155") throw new Error("Only eip155 namespace is supported for authenticated sessions. Please use .connect() for non-eip155 chains.");
+    }, this.getVerifyContext = async (e) => {
+      const { attestationId: t, hash: s, encryptedId: i, metadata: r, transportType: n } = e, o = { verified: { verifyUrl: r.verifyUrl || ct, validation: "UNKNOWN", origin: r.url || "" } };
+      try {
+        if (n === q.link_mode) {
+          const h = this.getAppLinkIfEnabled(r, n);
+          return o.verified.validation = h && new URL(h).origin === new URL(r.url).origin ? "VALID" : "INVALID", o;
+        }
+        const c = await this.client.core.verify.resolve({ attestationId: t, hash: s, encryptedId: i, verifyUrl: r.verifyUrl });
+        c && (o.verified.origin = c.origin, o.verified.isScam = c.isScam, o.verified.validation = c.origin === new URL(r.url).origin ? "VALID" : "INVALID");
+      } catch (c) {
+        this.client.logger.warn(c);
+      }
+      return this.client.logger.debug(`Verify context: ${JSON.stringify(o)}`), o;
+    }, this.validateSessionProps = (e, t) => {
+      Object.values(e).forEach((s) => {
+        if (!$(s, !1)) {
+          const { message: i } = u("MISSING_OR_INVALID", `${t} must be in Record<string, string> format. Received: ${JSON.stringify(s)}`);
+          throw new Error(i);
+        }
+      });
+    }, this.getPendingAuthRequest = (e) => {
+      const t = this.client.auth.requests.get(e);
+      return typeof t == "object" ? t : void 0;
+    }, this.addToRecentlyDeleted = (e, t) => {
+      if (this.recentlyDeletedMap.set(e, t), this.recentlyDeletedMap.size >= this.recentlyDeletedLimit) {
+        let s = 0;
+        const i = this.recentlyDeletedLimit / 2;
+        for (const r of this.recentlyDeletedMap.keys()) {
+          if (s++ >= i) break;
+          this.recentlyDeletedMap.delete(r);
+        }
+      }
+    }, this.checkRecentlyDeleted = (e) => {
+      const t = this.recentlyDeletedMap.get(e);
+      if (t) {
+        const { message: s } = u("MISSING_OR_INVALID", `Record was recently deleted - ${t}: ${e}`);
+        throw new Error(s);
+      }
+    }, this.isLinkModeEnabled = (e, t) => {
+      var s, i, r, n, o, c, h, p, d;
+      return !e || t !== q.link_mode ? !1 : ((i = (s = this.client.metadata) == null ? void 0 : s.redirect) == null ? void 0 : i.linkMode) === !0 && ((n = (r = this.client.metadata) == null ? void 0 : r.redirect) == null ? void 0 : n.universal) !== void 0 && ((c = (o = this.client.metadata) == null ? void 0 : o.redirect) == null ? void 0 : c.universal) !== "" && ((h = e == null ? void 0 : e.redirect) == null ? void 0 : h.universal) !== void 0 && ((p = e == null ? void 0 : e.redirect) == null ? void 0 : p.universal) !== "" && ((d = e == null ? void 0 : e.redirect) == null ? void 0 : d.linkMode) === !0 && this.client.core.linkModeSupportedApps.includes(e.redirect.universal) && typeof (V == null ? void 0 : V.Linking) < "u";
+    }, this.getAppLinkIfEnabled = (e, t) => {
+      var s;
+      return this.isLinkModeEnabled(e, t) ? (s = e == null ? void 0 : e.redirect) == null ? void 0 : s.universal : void 0;
+    }, this.handleLinkModeMessage = ({ url: e }) => {
+      if (!e || !e.includes("wc_ev") || !e.includes("topic")) return;
+      const t = Ye(e, "topic") || "", s = decodeURIComponent(Ye(e, "wc_ev") || ""), i = this.client.session.keys.includes(t);
+      i && this.client.session.update(t, { transportType: q.link_mode }), this.client.core.dispatchEnvelope({ topic: t, message: s, sessionExists: i });
+    }, this.registerLinkModeListeners = async () => {
+      var e;
+      if (Dt() || xt() && (e = this.client.metadata.redirect) != null && e.linkMode) {
+        const t = V == null ? void 0 : V.Linking;
+        if (typeof t < "u") {
+          t.addEventListener("url", this.handleLinkModeMessage, this.client.name);
+          const s = await t.getInitialURL();
+          s && setTimeout(() => {
+            this.handleLinkModeMessage({ url: s });
+          }, 50);
+        }
+      }
+    };
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: a } = u("NOT_INITIALIZED", this.name);
+      throw new Error(a);
+    }
+  }
+  async confirmOnlineStateOrThrow() {
+    await this.client.core.relayer.confirmOnlineStateOrThrow();
+  }
+  registerRelayerEvents() {
+    this.client.core.relayer.on(Me.message, (a) => {
+      !this.initialized || this.relayMessageCache.length > 0 ? this.relayMessageCache.push(a) : this.onRelayMessage(a);
+    });
+  }
+  async onRelayMessage(a) {
+    const { topic: e, message: t, attestation: s, transportType: i } = a, { publicKey: r } = this.client.auth.authKeys.keys.includes(ue) ? this.client.auth.authKeys.get(ue) : { responseTopic: void 0, publicKey: void 0 }, n = await this.client.core.crypto.decode(e, t, { receiverPublicKey: r, encoding: i === q.link_mode ? ie : pe });
+    try {
+      Ft(n) ? (this.client.core.history.set(e, n), this.onRelayEventRequest({ topic: e, payload: n, attestation: s, transportType: i, encryptedId: Y(t) })) : Gt(n) ? (await this.client.core.history.resolve(n), await this.onRelayEventResponse({ topic: e, payload: n, transportType: i }), this.client.core.history.delete(e, n.id)) : this.onRelayEventUnknownPayload({ topic: e, payload: n, transportType: i });
+    } catch (o) {
+      this.client.logger.error(o);
+    }
+  }
+  registerExpirerEvents() {
+    this.client.core.expirer.on(lt.expired, async (a) => {
+      const { topic: e, id: t } = Mt(a.target);
+      if (t && this.client.pendingRequest.keys.includes(t)) return await this.deletePendingSessionRequest(t, u("EXPIRED"), !0);
+      if (t && this.client.auth.requests.keys.includes(t)) return await this.deletePendingAuthRequest(t, u("EXPIRED"), !0);
+      e ? this.client.session.keys.includes(e) && (await this.deleteSession({ topic: e, expirerHasDeleted: !0 }), this.client.events.emit("session_expire", { topic: e })) : t && (await this.deleteProposal(t, !0), this.client.events.emit("proposal_expire", { id: t }));
+    });
+  }
+  registerPairingEvents() {
+    this.client.core.pairing.events.on(Le.create, (a) => this.onPairingCreated(a)), this.client.core.pairing.events.on(Le.delete, (a) => {
+      this.addToRecentlyDeleted(a.topic, "pairing");
+    });
+  }
+  isValidPairingTopic(a) {
+    if (!$(a, !1)) {
+      const { message: e } = u("MISSING_OR_INVALID", `pairing topic should be a string: ${a}`);
+      throw new Error(e);
+    }
+    if (!this.client.core.pairing.pairings.keys.includes(a)) {
+      const { message: e } = u("NO_MATCHING_KEY", `pairing topic doesn't exist: ${a}`);
+      throw new Error(e);
+    }
+    if (H(this.client.core.pairing.pairings.get(a).expiry)) {
+      const { message: e } = u("EXPIRED", `pairing topic: ${a}`);
+      throw new Error(e);
+    }
+  }
+  async isValidSessionTopic(a) {
+    if (!$(a, !1)) {
+      const { message: e } = u("MISSING_OR_INVALID", `session topic should be a string: ${a}`);
+      throw new Error(e);
+    }
+    if (this.checkRecentlyDeleted(a), !this.client.session.keys.includes(a)) {
+      const { message: e } = u("NO_MATCHING_KEY", `session topic doesn't exist: ${a}`);
+      throw new Error(e);
+    }
+    if (H(this.client.session.get(a).expiry)) {
+      await this.deleteSession({ topic: a });
+      const { message: e } = u("EXPIRED", `session topic: ${a}`);
+      throw new Error(e);
+    }
+    if (!this.client.core.crypto.keychain.has(a)) {
+      const { message: e } = u("MISSING_OR_INVALID", `session topic does not exist in keychain: ${a}`);
+      throw await this.deleteSession({ topic: a }), new Error(e);
+    }
+  }
+  async isValidSessionOrPairingTopic(a) {
+    if (this.checkRecentlyDeleted(a), this.client.session.keys.includes(a)) await this.isValidSessionTopic(a);
+    else if (this.client.core.pairing.pairings.keys.includes(a)) this.isValidPairingTopic(a);
+    else if ($(a, !1)) {
+      const { message: e } = u("NO_MATCHING_KEY", `session or pairing topic doesn't exist: ${a}`);
+      throw new Error(e);
+    } else {
+      const { message: e } = u("MISSING_OR_INVALID", `session or pairing topic should be a string: ${a}`);
+      throw new Error(e);
+    }
+  }
+  async isValidProposalId(a) {
+    if (!Lt(a)) {
+      const { message: e } = u("MISSING_OR_INVALID", `proposal id should be a number: ${a}`);
+      throw new Error(e);
+    }
+    if (!this.client.proposal.keys.includes(a)) {
+      const { message: e } = u("NO_MATCHING_KEY", `proposal id doesn't exist: ${a}`);
+      throw new Error(e);
+    }
+    if (H(this.client.proposal.get(a).expiryTimestamp)) {
+      await this.deleteProposal(a);
+      const { message: e } = u("EXPIRED", `proposal id: ${a}`);
+      throw new Error(e);
+    }
+  }
+}
+class cs extends W {
+  constructor(a, e) {
+    super(a, e, Qt, Pe), this.core = a, this.logger = e;
+  }
+}
+class ls extends W {
+  constructor(a, e) {
+    super(a, e, Yt, Pe), this.core = a, this.logger = e;
+  }
+}
+class ps extends W {
+  constructor(a, e) {
+    super(a, e, Xt, Pe, (t) => t.id), this.core = a, this.logger = e;
+  }
+}
+class hs extends W {
+  constructor(a, e) {
+    super(a, e, Zt, ge, () => ue), this.core = a, this.logger = e;
+  }
+}
+class ds extends W {
+  constructor(a, e) {
+    super(a, e, es, ge), this.core = a, this.logger = e;
+  }
+}
+class us extends W {
+  constructor(a, e) {
+    super(a, e, ts, ge, (t) => t.id), this.core = a, this.logger = e;
+  }
+}
+class gs {
+  constructor(a, e) {
+    this.core = a, this.logger = e, this.authKeys = new hs(this.core, this.logger), this.pairingTopics = new ds(this.core, this.logger), this.requests = new us(this.core, this.logger);
+  }
+  async init() {
+    await this.authKeys.init(), await this.pairingTopics.init(), await this.requests.init();
+  }
+}
+class et extends ut {
+  constructor(a) {
+    super(a), this.protocol = We, this.version = Be, this.name = Ne.name, this.events = new $t.EventEmitter(), this.on = (t, s) => this.events.on(t, s), this.once = (t, s) => this.events.once(t, s), this.off = (t, s) => this.events.off(t, s), this.removeListener = (t, s) => this.events.removeListener(t, s), this.removeAllListeners = (t) => this.events.removeAllListeners(t), this.connect = async (t) => {
+      try {
+        return await this.engine.connect(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.pair = async (t) => {
+      try {
+        return await this.engine.pair(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.approve = async (t) => {
+      try {
+        return await this.engine.approve(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.reject = async (t) => {
+      try {
+        return await this.engine.reject(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.update = async (t) => {
+      try {
+        return await this.engine.update(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.extend = async (t) => {
+      try {
+        return await this.engine.extend(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.request = async (t) => {
+      try {
+        return await this.engine.request(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.respond = async (t) => {
+      try {
+        return await this.engine.respond(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.ping = async (t) => {
+      try {
+        return await this.engine.ping(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.emit = async (t) => {
+      try {
+        return await this.engine.emit(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.disconnect = async (t) => {
+      try {
+        return await this.engine.disconnect(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.find = (t) => {
+      try {
+        return this.engine.find(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.getPendingSessionRequests = () => {
+      try {
+        return this.engine.getPendingSessionRequests();
+      } catch (t) {
+        throw this.logger.error(t.message), t;
+      }
+    }, this.authenticate = async (t, s) => {
+      try {
+        return await this.engine.authenticate(t, s);
+      } catch (i) {
+        throw this.logger.error(i.message), i;
+      }
+    }, this.formatAuthMessage = (t) => {
+      try {
+        return this.engine.formatAuthMessage(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.approveSessionAuthenticate = async (t) => {
+      try {
+        return await this.engine.approveSessionAuthenticate(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.rejectSessionAuthenticate = async (t) => {
+      try {
+        return await this.engine.rejectSessionAuthenticate(t);
+      } catch (s) {
+        throw this.logger.error(s.message), s;
+      }
+    }, this.name = (a == null ? void 0 : a.name) || Ne.name, this.metadata = (a == null ? void 0 : a.metadata) || yt(), this.signConfig = a == null ? void 0 : a.signConfig;
+    const e = typeof (a == null ? void 0 : a.logger) < "u" && typeof (a == null ? void 0 : a.logger) != "string" ? a.logger : jt(pt({ level: (a == null ? void 0 : a.logger) || Ne.logger }));
+    this.core = (a == null ? void 0 : a.core) || new rt(a), this.logger = ht(e, this.name), this.session = new ls(this.core, this.logger), this.proposal = new cs(this.core, this.logger), this.pendingRequest = new ps(this.core, this.logger), this.engine = new os(this), this.auth = new gs(this.core, this.logger);
+  }
+  static async init(a) {
+    const e = new et(a);
+    return await e.initialize(), e;
+  }
+  get context() {
+    return dt(this.logger);
+  }
+  get pairing() {
+    return this.core.pairing.pairings;
+  }
+  async initialize() {
+    this.logger.trace("Initialized");
+    try {
+      await this.core.start(), await this.session.init(), await this.proposal.init(), await this.pendingRequest.init(), await this.auth.init(), await this.engine.init(), this.logger.info("SignClient Initialization Success"), this.engine.processRelayMessageCache();
+    } catch (a) {
+      throw this.logger.info("SignClient Initialization Failure"), this.logger.error(a.message), a;
+    }
+  }
+}
+export {
+  Bt as AUTH_CONTEXT,
+  Zt as AUTH_KEYS_CONTEXT,
+  es as AUTH_PAIRING_TOPIC_CONTEXT,
+  Wt as AUTH_PROTOCOL,
+  ue as AUTH_PUBLIC_KEY_NAME,
+  ts as AUTH_REQUEST_CONTEXT,
+  ge as AUTH_STORAGE_PREFIX,
+  Ht as ENGINE_CONTEXT,
+  k as ENGINE_QUEUE_STATES,
+  T as ENGINE_RPC_OPTS,
+  Jt as METHODS_TO_VERIFY,
+  Qt as PROPOSAL_CONTEXT,
+  zt as PROPOSAL_EXPIRY_MESSAGE,
+  Xt as REQUEST_CONTEXT,
+  Yt as SESSION_CONTEXT,
+  J as SESSION_EXPIRY,
+  ve as SESSION_REQUEST_EXPIRY_BOUNDARIES,
+  Ze as SIGN_CLIENT_CONTEXT,
+  Ne as SIGN_CLIENT_DEFAULT,
+  We as SIGN_CLIENT_PROTOCOL,
+  Pe as SIGN_CLIENT_STORAGE_PREFIX,
+  Be as SIGN_CLIENT_VERSION,
+  He as WALLETCONNECT_DEEPLINK_CHOICE,
+  et as default
+};