astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es953.js

@@ -0,0 +1,1887 @@
+import _t, { e as B } from "./astra-sdk.es465.js";
+import { HeartBeat as wt, HEARTBEAT_EVENTS as X } from "./astra-sdk.es1082.js";
+import { KeyValueStorage as vt } from "./astra-sdk.es1083.js";
+import { generateChildLogger as I, getLoggerContext as S, getDefaultLoggerOptions as Ge, generatePlatformLogger as Et } from "./astra-sdk.es460.js";
+import { IStore as It, ICore as Tt, IRelayer as Ft, IJsonRpcHistory as Pt, IExpirer as St, IVerify as Rt, IEchoClient as xt, IEventClient as Ot, IMessageTracker as At, IPublisher as Ct, ISubscriber as Nt } from "./astra-sdk.es954.js";
+import { c as l } from "./astra-sdk.es935.js";
+import { safeJsonStringify as Dt, safeJsonParse as ye } from "./astra-sdk.es956.js";
+import { generateKeyPair as me, signJWT as zt } from "./astra-sdk.es1084.js";
+import { encodeIss as Lt, decodeJWT as fe } from "./astra-sdk.es949.js";
+import { isUndefined as ae, isProposalStruct as Mt, isSessionStruct as Ut, getInternalError as d, generateRandomBytes32 as oe, generateKeyPair as kt, deriveSymKey as Kt, hashKey as $t, validateEncoding as Bt, isTypeTwoEnvelope as be, encodeTypeTwoEnvelope as Vt, isTypeOneEnvelope as _e, encrypt as jt, validateDecoding as qt, decodeTypeTwoEnvelope as Ht, decrypt as Yt, deserialize as we, decodeTypeByte as Gt, BASE64 as ve, BASE16 as Jt, isNode as Ee, getBundleId as Wt, createExpiringPromise as $, isOnline as Ie, calcExpiry as W, formatRelayRpcUrl as Xt, subscribeToNetworkChange as Zt, TYPE_1 as Qt, formatUri as Te, parseUri as Fe, createDelayedPromise as ei, engineEvent as ie, getSdkError as G, isExpired as Pe, isValidParams as se, isValidUrl as ti, isValidString as ii, parseExpirerTarget as si, formatTopicTarget as ri, formatIdTarget as ni, isBrowser as ai, verifyP256Jwt as oi, isTestRun as Je, uuidv4 as Se, formatUA as hi, getAppMetadata as ci, mapToObj as We, objToMap as Xe, hashMessage as he, getRelayProtocolName as ce, getRelayProtocolApi as J, isValidArray as li } from "./astra-sdk.es459.js";
+import "./astra-sdk.es1085.js";
+import "./astra-sdk.es1086.js";
+import "./astra-sdk.es1087.js";
+import "./astra-sdk.es1088.js";
+import "./astra-sdk.es1089.js";
+import "./astra-sdk.es1090.js";
+import "./astra-sdk.es1091.js";
+import "./astra-sdk.es1092.js";
+import "./astra-sdk.es1093.js";
+import "./astra-sdk.es1094.js";
+import "./astra-sdk.es1095.js";
+import { toString as ui } from "./astra-sdk.es946.js";
+import { JsonRpcProvider as di } from "./astra-sdk.es462.js";
+import "./astra-sdk.es463.js";
+import { getBigIntRpcId as Ze, formatJsonRpcResult as Qe, formatJsonRpcError as gi, formatJsonRpcRequest as et } from "./astra-sdk.es464.js";
+import { isJsonRpcRequest as tt, isJsonRpcResponse as it, isJsonRpcResult as pi, isJsonRpcError as st } from "./astra-sdk.es955.js";
+import { WsConnection as yi } from "./astra-sdk.es1096.js";
+import mi from "./astra-sdk.es1097.js";
+import fi from "./astra-sdk.es16.js";
+const rt = "wc", nt = 2, ge = "core", D = `${rt}@2:${ge}:`, bi = { name: ge, logger: "error" }, _i = { database: ":memory:" }, wi = "crypto", Re = "client_ed25519_seed", vi = l.ONE_DAY, Ei = "keychain", Ii = "0.3", Ti = "messages", Fi = "0.3", Pi = l.SIX_HOURS, Si = "publisher", Ri = "irn", xi = "error", at = "wss://relay.walletconnect.org", Oi = "relayer", T = { message: "relayer_message", message_ack: "relayer_message_ack", connect: "relayer_connect", disconnect: "relayer_disconnect", error: "relayer_error", connection_stalled: "relayer_connection_stalled", transport_closed: "relayer_transport_closed", publish: "relayer_publish" }, Ai = "_subscription", P = { payload: "payload", connect: "connect", disconnect: "disconnect", error: "error" }, Ci = 0.1, le = "2.17.0", k = { link_mode: "link_mode", relay: "relay" }, Ni = "0.3", Di = "WALLETCONNECT_CLIENT_ID", xe = "WALLETCONNECT_LINK_MODE_APPS", N = { created: "subscription_created", deleted: "subscription_deleted", expired: "subscription_expired", disabled: "subscription_disabled", sync: "subscription_sync", resubscribed: "subscription_resubscribed" }, zi = "subscription", Li = "0.3", Mi = l.FIVE_SECONDS * 1e3, Ui = "pairing", ki = "0.3", j = { wc_pairingDelete: { req: { ttl: l.ONE_DAY, prompt: !1, tag: 1e3 }, res: { ttl: l.ONE_DAY, prompt: !1, tag: 1001 } }, wc_pairingPing: { req: { ttl: l.THIRTY_SECONDS, prompt: !1, tag: 1002 }, res: { ttl: l.THIRTY_SECONDS, prompt: !1, tag: 1003 } }, unregistered_method: { req: { ttl: l.ONE_DAY, prompt: !1, tag: 0 }, res: { ttl: l.ONE_DAY, prompt: !1, tag: 0 } } }, q = { create: "pairing_create", expire: "pairing_expire", delete: "pairing_delete", ping: "pairing_ping" }, x = { created: "history_created", updated: "history_updated", deleted: "history_deleted", sync: "history_sync" }, Ki = "history", $i = "0.3", Bi = "expirer", O = { created: "expirer_created", deleted: "expirer_deleted", expired: "expirer_expired", sync: "expirer_sync" }, Vi = "0.3", ji = "verify-api", qi = "https://verify.walletconnect.com", ot = "https://verify.walletconnect.org", ee = ot, Hi = `${ee}/v3`, Yi = [qi, ot], Gi = "echo", Ji = "https://echo.walletconnect.com", L = { pairing_started: "pairing_started", pairing_uri_validation_success: "pairing_uri_validation_success", pairing_uri_not_expired: "pairing_uri_not_expired", store_new_pairing: "store_new_pairing", subscribing_pairing_topic: "subscribing_pairing_topic", subscribe_pairing_topic_success: "subscribe_pairing_topic_success", existing_pairing: "existing_pairing", pairing_not_expired: "pairing_not_expired", emit_inactive_pairing: "emit_inactive_pairing", emit_session_proposal: "emit_session_proposal", subscribing_to_pairing_topic: "subscribing_to_pairing_topic" }, U = { no_wss_connection: "no_wss_connection", no_internet_connection: "no_internet_connection", malformed_pairing_uri: "malformed_pairing_uri", active_pairing_already_exists: "active_pairing_already_exists", subscribe_pairing_topic_failure: "subscribe_pairing_topic_failure", pairing_expired: "pairing_expired", proposal_expired: "proposal_expired", proposal_listener_not_found: "proposal_listener_not_found" }, $n = { session_approve_started: "session_approve_started", proposal_not_expired: "proposal_not_expired", session_namespaces_validation_success: "session_namespaces_validation_success", create_session_topic: "create_session_topic", subscribing_session_topic: "subscribing_session_topic", subscribe_session_topic_success: "subscribe_session_topic_success", publishing_session_approve: "publishing_session_approve", session_approve_publish_success: "session_approve_publish_success", store_session: "store_session", publishing_session_settle: "publishing_session_settle", session_settle_publish_success: "session_settle_publish_success" }, Bn = { no_internet_connection: "no_internet_connection", no_wss_connection: "no_wss_connection", proposal_expired: "proposal_expired", subscribe_session_topic_failure: "subscribe_session_topic_failure", session_approve_publish_failure: "session_approve_publish_failure", session_settle_publish_failure: "session_settle_publish_failure", session_approve_namespace_validation_failure: "session_approve_namespace_validation_failure", proposal_not_found: "proposal_not_found" }, Vn = { authenticated_session_approve_started: "authenticated_session_approve_started", authenticated_session_not_expired: "authenticated_session_not_expired", chains_caip2_compliant: "chains_caip2_compliant", chains_evm_compliant: "chains_evm_compliant", create_authenticated_session_topic: "create_authenticated_session_topic", cacaos_verified: "cacaos_verified", store_authenticated_session: "store_authenticated_session", subscribing_authenticated_session_topic: "subscribing_authenticated_session_topic", subscribe_authenticated_session_topic_success: "subscribe_authenticated_session_topic_success", publishing_authenticated_session_approve: "publishing_authenticated_session_approve", authenticated_session_approve_publish_success: "authenticated_session_approve_publish_success" }, jn = { no_internet_connection: "no_internet_connection", no_wss_connection: "no_wss_connection", missing_session_authenticate_request: "missing_session_authenticate_request", session_authenticate_request_expired: "session_authenticate_request_expired", chains_caip2_compliant_failure: "chains_caip2_compliant_failure", chains_evm_compliant_failure: "chains_evm_compliant_failure", invalid_cacao: "invalid_cacao", subscribe_authenticated_session_topic_failure: "subscribe_authenticated_session_topic_failure", authenticated_session_approve_publish_failure: "authenticated_session_approve_publish_failure", authenticated_session_pending_request_not_found: "authenticated_session_pending_request_not_found" }, Wi = 0.1, Xi = "event-client", Zi = 86400, Qi = "https://pulse.walletconnect.org/batch";
+function es(a, e) {
+  if (a.length >= 255) throw new TypeError("Alphabet too long");
+  for (var t = new Uint8Array(256), s = 0; s < t.length; s++) t[s] = 255;
+  for (var i = 0; i < a.length; i++) {
+    var r = a.charAt(i), n = r.charCodeAt(0);
+    if (t[n] !== 255) throw new TypeError(r + " is ambiguous");
+    t[n] = i;
+  }
+  var o = a.length, h = a.charAt(0), c = Math.log(o) / Math.log(256), g = Math.log(256) / Math.log(o);
+  function p(u) {
+    if (u instanceof Uint8Array || (ArrayBuffer.isView(u) ? u = new Uint8Array(u.buffer, u.byteOffset, u.byteLength) : Array.isArray(u) && (u = Uint8Array.from(u))), !(u instanceof Uint8Array)) throw new TypeError("Expected Uint8Array");
+    if (u.length === 0) return "";
+    for (var y = 0, E = 0, f = 0, w = u.length; f !== w && u[f] === 0; ) f++, y++;
+    for (var A = (w - f) * g + 1 >>> 0, F = new Uint8Array(A); f !== w; ) {
+      for (var C = u[f], M = 0, R = A - 1; (C !== 0 || M < E) && R !== -1; R--, M++) C += 256 * F[R] >>> 0, F[R] = C % o >>> 0, C = C / o >>> 0;
+      if (C !== 0) throw new Error("Non-zero carry");
+      E = M, f++;
+    }
+    for (var z = A - E; z !== A && F[z] === 0; ) z++;
+    for (var Q = h.repeat(y); z < A; ++z) Q += a.charAt(F[z]);
+    return Q;
+  }
+  function b(u) {
+    if (typeof u != "string") throw new TypeError("Expected String");
+    if (u.length === 0) return new Uint8Array();
+    var y = 0;
+    if (u[y] !== " ") {
+      for (var E = 0, f = 0; u[y] === h; ) E++, y++;
+      for (var w = (u.length - y) * c + 1 >>> 0, A = new Uint8Array(w); u[y]; ) {
+        var F = t[u.charCodeAt(y)];
+        if (F === 255) return;
+        for (var C = 0, M = w - 1; (F !== 0 || C < f) && M !== -1; M--, C++) F += o * A[M] >>> 0, A[M] = F % 256 >>> 0, F = F / 256 >>> 0;
+        if (F !== 0) throw new Error("Non-zero carry");
+        f = C, y++;
+      }
+      if (u[y] !== " ") {
+        for (var R = w - f; R !== w && A[R] === 0; ) R++;
+        for (var z = new Uint8Array(E + (w - R)), Q = E; R !== w; ) z[Q++] = A[R++];
+        return z;
+      }
+    }
+  }
+  function _(u) {
+    var y = b(u);
+    if (y) return y;
+    throw new Error(`Non-${e} character`);
+  }
+  return { encode: p, decodeUnsafe: b, decode: _ };
+}
+var ts = es, is = ts;
+const ht = (a) => {
+  if (a instanceof Uint8Array && a.constructor.name === "Uint8Array") return a;
+  if (a instanceof ArrayBuffer) return new Uint8Array(a);
+  if (ArrayBuffer.isView(a)) return new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+  throw new Error("Unknown type, must be binary type");
+}, ss = (a) => new TextEncoder().encode(a), rs = (a) => new TextDecoder().decode(a);
+class ns {
+  constructor(e, t, s) {
+    this.name = e, this.prefix = t, this.baseEncode = s;
+  }
+  encode(e) {
+    if (e instanceof Uint8Array) return `${this.prefix}${this.baseEncode(e)}`;
+    throw Error("Unknown type, must be binary type");
+  }
+}
+class as {
+  constructor(e, t, s) {
+    if (this.name = e, this.prefix = t, t.codePointAt(0) === void 0) throw new Error("Invalid prefix character");
+    this.prefixCodePoint = t.codePointAt(0), this.baseDecode = s;
+  }
+  decode(e) {
+    if (typeof e == "string") {
+      if (e.codePointAt(0) !== this.prefixCodePoint) throw Error(`Unable to decode multibase string ${JSON.stringify(e)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      return this.baseDecode(e.slice(this.prefix.length));
+    } else throw Error("Can only multibase decode strings");
+  }
+  or(e) {
+    return ct(this, e);
+  }
+}
+class os {
+  constructor(e) {
+    this.decoders = e;
+  }
+  or(e) {
+    return ct(this, e);
+  }
+  decode(e) {
+    const t = e[0], s = this.decoders[t];
+    if (s) return s.decode(e);
+    throw RangeError(`Unable to decode multibase string ${JSON.stringify(e)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+  }
+}
+const ct = (a, e) => new os({ ...a.decoders || { [a.prefix]: a }, ...e.decoders || { [e.prefix]: e } });
+class hs {
+  constructor(e, t, s, i) {
+    this.name = e, this.prefix = t, this.baseEncode = s, this.baseDecode = i, this.encoder = new ns(e, t, s), this.decoder = new as(e, t, i);
+  }
+  encode(e) {
+    return this.encoder.encode(e);
+  }
+  decode(e) {
+    return this.decoder.decode(e);
+  }
+}
+const te = ({ name: a, prefix: e, encode: t, decode: s }) => new hs(a, e, t, s), Z = ({ prefix: a, name: e, alphabet: t }) => {
+  const { encode: s, decode: i } = is(t, e);
+  return te({ prefix: a, name: e, encode: s, decode: (r) => ht(i(r)) });
+}, cs = (a, e, t, s) => {
+  const i = {};
+  for (let g = 0; g < e.length; ++g) i[e[g]] = g;
+  let r = a.length;
+  for (; a[r - 1] === "="; ) --r;
+  const n = new Uint8Array(r * t / 8 | 0);
+  let o = 0, h = 0, c = 0;
+  for (let g = 0; g < r; ++g) {
+    const p = i[a[g]];
+    if (p === void 0) throw new SyntaxError(`Non-${s} character`);
+    h = h << t | p, o += t, o >= 8 && (o -= 8, n[c++] = 255 & h >> o);
+  }
+  if (o >= t || 255 & h << 8 - o) throw new SyntaxError("Unexpected end of data");
+  return n;
+}, ls = (a, e, t) => {
+  const s = e[e.length - 1] === "=", i = (1 << t) - 1;
+  let r = "", n = 0, o = 0;
+  for (let h = 0; h < a.length; ++h) for (o = o << 8 | a[h], n += 8; n > t; ) n -= t, r += e[i & o >> n];
+  if (n && (r += e[i & o << t - n]), s) for (; r.length * t & 7; ) r += "=";
+  return r;
+}, v = ({ name: a, prefix: e, bitsPerChar: t, alphabet: s }) => te({ prefix: e, name: a, encode(i) {
+  return ls(i, s, t);
+}, decode(i) {
+  return cs(i, s, t, a);
+} }), us = te({ prefix: "\0", name: "identity", encode: (a) => rs(a), decode: (a) => ss(a) });
+var ds = Object.freeze({ __proto__: null, identity: us });
+const gs = v({ prefix: "0", name: "base2", alphabet: "01", bitsPerChar: 1 });
+var ps = Object.freeze({ __proto__: null, base2: gs });
+const ys = v({ prefix: "7", name: "base8", alphabet: "01234567", bitsPerChar: 3 });
+var ms = Object.freeze({ __proto__: null, base8: ys });
+const fs = Z({ prefix: "9", name: "base10", alphabet: "0123456789" });
+var bs = Object.freeze({ __proto__: null, base10: fs });
+const _s = v({ prefix: "f", name: "base16", alphabet: "0123456789abcdef", bitsPerChar: 4 }), ws = v({ prefix: "F", name: "base16upper", alphabet: "0123456789ABCDEF", bitsPerChar: 4 });
+var vs = Object.freeze({ __proto__: null, base16: _s, base16upper: ws });
+const Es = v({ prefix: "b", name: "base32", alphabet: "abcdefghijklmnopqrstuvwxyz234567", bitsPerChar: 5 }), Is = v({ prefix: "B", name: "base32upper", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", bitsPerChar: 5 }), Ts = v({ prefix: "c", name: "base32pad", alphabet: "abcdefghijklmnopqrstuvwxyz234567=", bitsPerChar: 5 }), Fs = v({ prefix: "C", name: "base32padupper", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=", bitsPerChar: 5 }), Ps = v({ prefix: "v", name: "base32hex", alphabet: "0123456789abcdefghijklmnopqrstuv", bitsPerChar: 5 }), Ss = v({ prefix: "V", name: "base32hexupper", alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV", bitsPerChar: 5 }), Rs = v({ prefix: "t", name: "base32hexpad", alphabet: "0123456789abcdefghijklmnopqrstuv=", bitsPerChar: 5 }), xs = v({ prefix: "T", name: "base32hexpadupper", alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=", bitsPerChar: 5 }), Os = v({ prefix: "h", name: "base32z", alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769", bitsPerChar: 5 });
+var As = Object.freeze({ __proto__: null, base32: Es, base32upper: Is, base32pad: Ts, base32padupper: Fs, base32hex: Ps, base32hexupper: Ss, base32hexpad: Rs, base32hexpadupper: xs, base32z: Os });
+const Cs = Z({ prefix: "k", name: "base36", alphabet: "0123456789abcdefghijklmnopqrstuvwxyz" }), Ns = Z({ prefix: "K", name: "base36upper", alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" });
+var Ds = Object.freeze({ __proto__: null, base36: Cs, base36upper: Ns });
+const zs = Z({ name: "base58btc", prefix: "z", alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" }), Ls = Z({ name: "base58flickr", prefix: "Z", alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ" });
+var Ms = Object.freeze({ __proto__: null, base58btc: zs, base58flickr: Ls });
+const Us = v({ prefix: "m", name: "base64", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", bitsPerChar: 6 }), ks = v({ prefix: "M", name: "base64pad", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", bitsPerChar: 6 }), Ks = v({ prefix: "u", name: "base64url", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", bitsPerChar: 6 }), $s = v({ prefix: "U", name: "base64urlpad", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=", bitsPerChar: 6 });
+var Bs = Object.freeze({ __proto__: null, base64: Us, base64pad: ks, base64url: Ks, base64urlpad: $s });
+const lt = Array.from("🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂"), Vs = lt.reduce((a, e, t) => (a[t] = e, a), []), js = lt.reduce((a, e, t) => (a[e.codePointAt(0)] = t, a), []);
+function qs(a) {
+  return a.reduce((e, t) => (e += Vs[t], e), "");
+}
+function Hs(a) {
+  const e = [];
+  for (const t of a) {
+    const s = js[t.codePointAt(0)];
+    if (s === void 0) throw new Error(`Non-base256emoji character: ${t}`);
+    e.push(s);
+  }
+  return new Uint8Array(e);
+}
+const Ys = te({ prefix: "🚀", name: "base256emoji", encode: qs, decode: Hs });
+var Gs = Object.freeze({ __proto__: null, base256emoji: Ys }), Js = ut, Oe = 128, Ws = -128, Xs = Math.pow(2, 31);
+function ut(a, e, t) {
+  e = e || [], t = t || 0;
+  for (var s = t; a >= Xs; ) e[t++] = a & 255 | Oe, a /= 128;
+  for (; a & Ws; ) e[t++] = a & 255 | Oe, a >>>= 7;
+  return e[t] = a | 0, ut.bytes = t - s + 1, e;
+}
+var Zs = ue, Qs = 128, Ae = 127;
+function ue(a, s) {
+  var t = 0, s = s || 0, i = 0, r = s, n, o = a.length;
+  do {
+    if (r >= o) throw ue.bytes = 0, new RangeError("Could not decode varint");
+    n = a[r++], t += i < 28 ? (n & Ae) << i : (n & Ae) * Math.pow(2, i), i += 7;
+  } while (n >= Qs);
+  return ue.bytes = r - s, t;
+}
+var er = Math.pow(2, 7), tr = Math.pow(2, 14), ir = Math.pow(2, 21), sr = Math.pow(2, 28), rr = Math.pow(2, 35), nr = Math.pow(2, 42), ar = Math.pow(2, 49), or = Math.pow(2, 56), hr = Math.pow(2, 63), cr = function(a) {
+  return a < er ? 1 : a < tr ? 2 : a < ir ? 3 : a < sr ? 4 : a < rr ? 5 : a < nr ? 6 : a < ar ? 7 : a < or ? 8 : a < hr ? 9 : 10;
+}, lr = { encode: Js, decode: Zs, encodingLength: cr }, dt = lr;
+const Ce = (a, e, t = 0) => (dt.encode(a, e, t), e), Ne = (a) => dt.encodingLength(a), de = (a, e) => {
+  const t = e.byteLength, s = Ne(a), i = s + Ne(t), r = new Uint8Array(i + t);
+  return Ce(a, r, 0), Ce(t, r, s), r.set(e, i), new ur(a, t, e, r);
+};
+class ur {
+  constructor(e, t, s, i) {
+    this.code = e, this.size = t, this.digest = s, this.bytes = i;
+  }
+}
+const gt = ({ name: a, code: e, encode: t }) => new dr(a, e, t);
+class dr {
+  constructor(e, t, s) {
+    this.name = e, this.code = t, this.encode = s;
+  }
+  digest(e) {
+    if (e instanceof Uint8Array) {
+      const t = this.encode(e);
+      return t instanceof Uint8Array ? de(this.code, t) : t.then((s) => de(this.code, s));
+    } else throw Error("Unknown type, must be binary type");
+  }
+}
+const pt = (a) => async (e) => new Uint8Array(await crypto.subtle.digest(a, e)), gr = gt({ name: "sha2-256", code: 18, encode: pt("SHA-256") }), pr = gt({ name: "sha2-512", code: 19, encode: pt("SHA-512") });
+var yr = Object.freeze({ __proto__: null, sha256: gr, sha512: pr });
+const yt = 0, mr = "identity", mt = ht, fr = (a) => de(yt, mt(a)), br = { code: yt, name: mr, encode: mt, digest: fr };
+var _r = Object.freeze({ __proto__: null, identity: br });
+new TextEncoder(), new TextDecoder();
+const De = { ...ds, ...ps, ...ms, ...bs, ...vs, ...As, ...Ds, ...Ms, ...Bs, ...Gs };
+({ ...yr, ..._r });
+function wr(a = 0) {
+  return globalThis.Buffer != null && globalThis.Buffer.allocUnsafe != null ? globalThis.Buffer.allocUnsafe(a) : new Uint8Array(a);
+}
+function ft(a, e, t, s) {
+  return { name: a, prefix: e, encoder: { name: a, prefix: e, encode: t }, decoder: { decode: s } };
+}
+const ze = ft("utf8", "u", (a) => "u" + new TextDecoder("utf8").decode(a), (a) => new TextEncoder().encode(a.substring(1))), re = ft("ascii", "a", (a) => {
+  let e = "a";
+  for (let t = 0; t < a.length; t++) e += String.fromCharCode(a[t]);
+  return e;
+}, (a) => {
+  a = a.substring(1);
+  const e = wr(a.length);
+  for (let t = 0; t < a.length; t++) e[t] = a.charCodeAt(t);
+  return e;
+}), vr = { utf8: ze, "utf-8": ze, hex: De.base16, latin1: re, ascii: re, binary: re, ...De };
+function Er(a, e = "utf8") {
+  const t = vr[e];
+  if (!t) throw new Error(`Unsupported encoding "${e}"`);
+  return (e === "utf8" || e === "utf-8") && globalThis.Buffer != null && globalThis.Buffer.from != null ? globalThis.Buffer.from(a, "utf8") : t.decoder.decode(`${t.prefix}${a}`);
+}
+class Ir {
+  constructor(e, t) {
+    this.core = e, this.logger = t, this.keychain = /* @__PURE__ */ new Map(), this.name = Ei, this.version = Ii, this.initialized = !1, this.storagePrefix = D, this.init = async () => {
+      if (!this.initialized) {
+        const s = await this.getKeyChain();
+        typeof s < "u" && (this.keychain = s), this.initialized = !0;
+      }
+    }, this.has = (s) => (this.isInitialized(), this.keychain.has(s)), this.set = async (s, i) => {
+      this.isInitialized(), this.keychain.set(s, i), await this.persist();
+    }, this.get = (s) => {
+      this.isInitialized();
+      const i = this.keychain.get(s);
+      if (typeof i > "u") {
+        const { message: r } = d("NO_MATCHING_KEY", `${this.name}: ${s}`);
+        throw new Error(r);
+      }
+      return i;
+    }, this.del = async (s) => {
+      this.isInitialized(), this.keychain.delete(s), await this.persist();
+    }, this.core = e, this.logger = I(t, this.name);
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//" + this.name;
+  }
+  async setKeyChain(e) {
+    await this.core.storage.setItem(this.storageKey, We(e));
+  }
+  async getKeyChain() {
+    const e = await this.core.storage.getItem(this.storageKey);
+    return typeof e < "u" ? Xe(e) : void 0;
+  }
+  async persist() {
+    await this.setKeyChain(this.keychain);
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+class Tr {
+  constructor(e, t, s) {
+    this.core = e, this.logger = t, this.name = wi, this.randomSessionIdentifier = oe(), this.initialized = !1, this.init = async () => {
+      this.initialized || (await this.keychain.init(), this.initialized = !0);
+    }, this.hasKeys = (i) => (this.isInitialized(), this.keychain.has(i)), this.getClientId = async () => {
+      this.isInitialized();
+      const i = await this.getClientSeed(), r = me(i);
+      return Lt(r.publicKey);
+    }, this.generateKeyPair = () => {
+      this.isInitialized();
+      const i = kt();
+      return this.setPrivateKey(i.publicKey, i.privateKey);
+    }, this.signJWT = async (i) => {
+      this.isInitialized();
+      const r = await this.getClientSeed(), n = me(r), o = this.randomSessionIdentifier;
+      return await zt(o, i, vi, n);
+    }, this.generateSharedKey = (i, r, n) => {
+      this.isInitialized();
+      const o = this.getPrivateKey(i), h = Kt(o, r);
+      return this.setSymKey(h, n);
+    }, this.setSymKey = async (i, r) => {
+      this.isInitialized();
+      const n = r || $t(i);
+      return await this.keychain.set(n, i), n;
+    }, this.deleteKeyPair = async (i) => {
+      this.isInitialized(), await this.keychain.del(i);
+    }, this.deleteSymKey = async (i) => {
+      this.isInitialized(), await this.keychain.del(i);
+    }, this.encode = async (i, r, n) => {
+      this.isInitialized();
+      const o = Bt(n), h = Dt(r);
+      if (be(o)) return Vt(h, n == null ? void 0 : n.encoding);
+      if (_e(o)) {
+        const b = o.senderPublicKey, _ = o.receiverPublicKey;
+        i = await this.generateSharedKey(b, _);
+      }
+      const c = this.getSymKey(i), { type: g, senderPublicKey: p } = o;
+      return jt({ type: g, symKey: c, message: h, senderPublicKey: p, encoding: n == null ? void 0 : n.encoding });
+    }, this.decode = async (i, r, n) => {
+      this.isInitialized();
+      const o = qt(r, n);
+      if (be(o)) {
+        const h = Ht(r, n == null ? void 0 : n.encoding);
+        return ye(h);
+      }
+      if (_e(o)) {
+        const h = o.receiverPublicKey, c = o.senderPublicKey;
+        i = await this.generateSharedKey(h, c);
+      }
+      try {
+        const h = this.getSymKey(i), c = Yt({ symKey: h, encoded: r, encoding: n == null ? void 0 : n.encoding });
+        return ye(c);
+      } catch (h) {
+        this.logger.error(`Failed to decode message from topic: '${i}', clientId: '${await this.getClientId()}'`), this.logger.error(h);
+      }
+    }, this.getPayloadType = (i, r = ve) => {
+      const n = we({ encoded: i, encoding: r });
+      return Gt(n.type);
+    }, this.getPayloadSenderPublicKey = (i, r = ve) => {
+      const n = we({ encoded: i, encoding: r });
+      return n.senderPublicKey ? ui(n.senderPublicKey, Jt) : void 0;
+    }, this.core = e, this.logger = I(t, this.name), this.keychain = s || new Ir(this.core, this.logger);
+  }
+  get context() {
+    return S(this.logger);
+  }
+  async setPrivateKey(e, t) {
+    return await this.keychain.set(e, t), e;
+  }
+  getPrivateKey(e) {
+    return this.keychain.get(e);
+  }
+  async getClientSeed() {
+    let e = "";
+    try {
+      e = this.keychain.get(Re);
+    } catch {
+      e = oe(), await this.keychain.set(Re, e);
+    }
+    return Er(e, "base16");
+  }
+  getSymKey(e) {
+    return this.keychain.get(e);
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+class Fr extends At {
+  constructor(e, t) {
+    super(e, t), this.logger = e, this.core = t, this.messages = /* @__PURE__ */ new Map(), this.name = Ti, this.version = Fi, this.initialized = !1, this.storagePrefix = D, this.init = async () => {
+      if (!this.initialized) {
+        this.logger.trace("Initialized");
+        try {
+          const s = await this.getRelayerMessages();
+          typeof s < "u" && (this.messages = s), this.logger.debug(`Successfully Restored records for ${this.name}`), this.logger.trace({ type: "method", method: "restore", size: this.messages.size });
+        } catch (s) {
+          this.logger.debug(`Failed to Restore records for ${this.name}`), this.logger.error(s);
+        } finally {
+          this.initialized = !0;
+        }
+      }
+    }, this.set = async (s, i) => {
+      this.isInitialized();
+      const r = he(i);
+      let n = this.messages.get(s);
+      return typeof n > "u" && (n = {}), typeof n[r] < "u" || (n[r] = i, this.messages.set(s, n), await this.persist()), r;
+    }, this.get = (s) => {
+      this.isInitialized();
+      let i = this.messages.get(s);
+      return typeof i > "u" && (i = {}), i;
+    }, this.has = (s, i) => {
+      this.isInitialized();
+      const r = this.get(s), n = he(i);
+      return typeof r[n] < "u";
+    }, this.del = async (s) => {
+      this.isInitialized(), this.messages.delete(s), await this.persist();
+    }, this.logger = I(e, this.name), this.core = t;
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//" + this.name;
+  }
+  async setRelayerMessages(e) {
+    await this.core.storage.setItem(this.storageKey, We(e));
+  }
+  async getRelayerMessages() {
+    const e = await this.core.storage.getItem(this.storageKey);
+    return typeof e < "u" ? Xe(e) : void 0;
+  }
+  async persist() {
+    await this.setRelayerMessages(this.messages);
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+class Pr extends Ct {
+  constructor(e, t) {
+    super(e, t), this.relayer = e, this.logger = t, this.events = new B.EventEmitter(), this.name = Si, this.queue = /* @__PURE__ */ new Map(), this.publishTimeout = l.toMiliseconds(l.ONE_MINUTE), this.failedPublishTimeout = l.toMiliseconds(l.ONE_SECOND), this.needsTransportRestart = !1, this.publish = async (s, i, r) => {
+      var n;
+      this.logger.debug("Publishing Payload"), this.logger.trace({ type: "method", method: "publish", params: { topic: s, message: i, opts: r } });
+      const o = (r == null ? void 0 : r.ttl) || Pi, h = ce(r), c = (r == null ? void 0 : r.prompt) || !1, g = (r == null ? void 0 : r.tag) || 0, p = (r == null ? void 0 : r.id) || Ze().toString(), b = { topic: s, message: i, opts: { ttl: o, relay: h, prompt: c, tag: g, id: p, attestation: r == null ? void 0 : r.attestation } }, _ = `Failed to publish payload, please try again. id:${p} tag:${g}`, u = Date.now();
+      let y, E = 1;
+      try {
+        for (; y === void 0; ) {
+          if (Date.now() - u > this.publishTimeout) throw new Error(_);
+          this.logger.trace({ id: p, attempts: E }, `publisher.publish - attempt ${E}`), y = await await $(this.rpcPublish(s, i, o, h, c, g, p, r == null ? void 0 : r.attestation).catch((f) => this.logger.warn(f)), this.publishTimeout, _), E++, y || await new Promise((f) => setTimeout(f, this.failedPublishTimeout));
+        }
+        this.relayer.events.emit(T.publish, b), this.logger.debug("Successfully Published Payload"), this.logger.trace({ type: "method", method: "publish", params: { id: p, topic: s, message: i, opts: r } });
+      } catch (f) {
+        if (this.logger.debug("Failed to Publish Payload"), this.logger.error(f), (n = r == null ? void 0 : r.internal) != null && n.throwOnFailedPublish) throw f;
+        this.queue.set(p, b);
+      }
+    }, this.on = (s, i) => {
+      this.events.on(s, i);
+    }, this.once = (s, i) => {
+      this.events.once(s, i);
+    }, this.off = (s, i) => {
+      this.events.off(s, i);
+    }, this.removeListener = (s, i) => {
+      this.events.removeListener(s, i);
+    }, this.relayer = e, this.logger = I(t, this.name), this.registerEventListeners();
+  }
+  get context() {
+    return S(this.logger);
+  }
+  rpcPublish(e, t, s, i, r, n, o, h) {
+    var c, g, p, b;
+    const _ = { method: J(i.protocol).publish, params: { topic: e, message: t, ttl: s, prompt: r, tag: n, attestation: h }, id: o };
+    return ae((c = _.params) == null ? void 0 : c.prompt) && ((g = _.params) == null || delete g.prompt), ae((p = _.params) == null ? void 0 : p.tag) && ((b = _.params) == null || delete b.tag), this.logger.debug("Outgoing Relay Payload"), this.logger.trace({ type: "message", direction: "outgoing", request: _ }), this.relayer.request(_);
+  }
+  removeRequestFromQueue(e) {
+    this.queue.delete(e);
+  }
+  checkQueue() {
+    this.queue.forEach(async (e) => {
+      const { topic: t, message: s, opts: i } = e;
+      await this.publish(t, s, i);
+    });
+  }
+  registerEventListeners() {
+    this.relayer.core.heartbeat.on(X.pulse, () => {
+      if (this.needsTransportRestart) {
+        this.needsTransportRestart = !1, this.relayer.events.emit(T.connection_stalled);
+        return;
+      }
+      this.checkQueue();
+    }), this.relayer.on(T.message_ack, (e) => {
+      this.removeRequestFromQueue(e.id.toString());
+    });
+  }
+}
+class Sr {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map(), this.set = (e, t) => {
+      const s = this.get(e);
+      this.exists(e, t) || this.map.set(e, [...s, t]);
+    }, this.get = (e) => this.map.get(e) || [], this.exists = (e, t) => this.get(e).includes(t), this.delete = (e, t) => {
+      if (typeof t > "u") {
+        this.map.delete(e);
+        return;
+      }
+      if (!this.map.has(e)) return;
+      const s = this.get(e);
+      if (!this.exists(e, t)) return;
+      const i = s.filter((r) => r !== t);
+      if (!i.length) {
+        this.map.delete(e);
+        return;
+      }
+      this.map.set(e, i);
+    }, this.clear = () => {
+      this.map.clear();
+    };
+  }
+  get topics() {
+    return Array.from(this.map.keys());
+  }
+}
+var Rr = Object.defineProperty, xr = Object.defineProperties, Or = Object.getOwnPropertyDescriptors, Le = Object.getOwnPropertySymbols, Ar = Object.prototype.hasOwnProperty, Cr = Object.prototype.propertyIsEnumerable, Me = (a, e, t) => e in a ? Rr(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, H = (a, e) => {
+  for (var t in e || (e = {})) Ar.call(e, t) && Me(a, t, e[t]);
+  if (Le) for (var t of Le(e)) Cr.call(e, t) && Me(a, t, e[t]);
+  return a;
+}, ne = (a, e) => xr(a, Or(e));
+class Nr extends Nt {
+  constructor(e, t) {
+    super(e, t), this.relayer = e, this.logger = t, this.subscriptions = /* @__PURE__ */ new Map(), this.topicMap = new Sr(), this.events = new B.EventEmitter(), this.name = zi, this.version = Li, this.pending = /* @__PURE__ */ new Map(), this.cached = [], this.initialized = !1, this.pendingSubscriptionWatchLabel = "pending_sub_watch_label", this.pollingInterval = 20, this.storagePrefix = D, this.subscribeTimeout = l.toMiliseconds(l.ONE_MINUTE), this.restartInProgress = !1, this.batchSubscribeTopicsLimit = 500, this.pendingBatchMessages = [], this.init = async () => {
+      this.initialized || (this.logger.trace("Initialized"), this.registerEventListeners(), this.clientId = await this.relayer.core.crypto.getClientId(), await this.restore()), this.initialized = !0;
+    }, this.subscribe = async (s, i) => {
+      this.isInitialized(), this.logger.debug("Subscribing Topic"), this.logger.trace({ type: "method", method: "subscribe", params: { topic: s, opts: i } });
+      try {
+        const r = ce(i), n = { topic: s, relay: r, transportType: i == null ? void 0 : i.transportType };
+        this.pending.set(s, n);
+        const o = await this.rpcSubscribe(s, r, i == null ? void 0 : i.transportType);
+        return typeof o == "string" && (this.onSubscribe(o, n), this.logger.debug("Successfully Subscribed Topic"), this.logger.trace({ type: "method", method: "subscribe", params: { topic: s, opts: i } })), o;
+      } catch (r) {
+        throw this.logger.debug("Failed to Subscribe Topic"), this.logger.error(r), r;
+      }
+    }, this.unsubscribe = async (s, i) => {
+      await this.restartToComplete(), this.isInitialized(), typeof (i == null ? void 0 : i.id) < "u" ? await this.unsubscribeById(s, i.id, i) : await this.unsubscribeByTopic(s, i);
+    }, this.isSubscribed = async (s) => {
+      if (this.topics.includes(s)) return !0;
+      const i = `${this.pendingSubscriptionWatchLabel}_${s}`;
+      return await new Promise((r, n) => {
+        const o = new l.Watch();
+        o.start(i);
+        const h = setInterval(() => {
+          !this.pending.has(s) && this.topics.includes(s) && (clearInterval(h), o.stop(i), r(!0)), o.elapsed(i) >= Mi && (clearInterval(h), o.stop(i), n(new Error("Subscription resolution timeout")));
+        }, this.pollingInterval);
+      }).catch(() => !1);
+    }, this.on = (s, i) => {
+      this.events.on(s, i);
+    }, this.once = (s, i) => {
+      this.events.once(s, i);
+    }, this.off = (s, i) => {
+      this.events.off(s, i);
+    }, this.removeListener = (s, i) => {
+      this.events.removeListener(s, i);
+    }, this.start = async () => {
+      await this.onConnect();
+    }, this.stop = async () => {
+      await this.onDisconnect();
+    }, this.restart = async () => {
+      this.restartInProgress = !0, await this.restore(), await this.reset(), this.restartInProgress = !1;
+    }, this.relayer = e, this.logger = I(t, this.name), this.clientId = "";
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.relayer.core.customStoragePrefix + "//" + this.name;
+  }
+  get length() {
+    return this.subscriptions.size;
+  }
+  get ids() {
+    return Array.from(this.subscriptions.keys());
+  }
+  get values() {
+    return Array.from(this.subscriptions.values());
+  }
+  get topics() {
+    return this.topicMap.topics;
+  }
+  hasSubscription(e, t) {
+    let s = !1;
+    try {
+      s = this.getSubscription(e).topic === t;
+    } catch {
+    }
+    return s;
+  }
+  onEnable() {
+    this.cached = [], this.initialized = !0;
+  }
+  onDisable() {
+    this.cached = this.values, this.subscriptions.clear(), this.topicMap.clear();
+  }
+  async unsubscribeByTopic(e, t) {
+    const s = this.topicMap.get(e);
+    await Promise.all(s.map(async (i) => await this.unsubscribeById(e, i, t)));
+  }
+  async unsubscribeById(e, t, s) {
+    this.logger.debug("Unsubscribing Topic"), this.logger.trace({ type: "method", method: "unsubscribe", params: { topic: e, id: t, opts: s } });
+    try {
+      const i = ce(s);
+      await this.rpcUnsubscribe(e, t, i);
+      const r = G("USER_DISCONNECTED", `${this.name}, ${e}`);
+      await this.onUnsubscribe(e, t, r), this.logger.debug("Successfully Unsubscribed Topic"), this.logger.trace({ type: "method", method: "unsubscribe", params: { topic: e, id: t, opts: s } });
+    } catch (i) {
+      throw this.logger.debug("Failed to Unsubscribe Topic"), this.logger.error(i), i;
+    }
+  }
+  async rpcSubscribe(e, t, s = k.relay) {
+    s === k.relay && await this.restartToComplete();
+    const i = { method: J(t.protocol).subscribe, params: { topic: e } };
+    this.logger.debug("Outgoing Relay Payload"), this.logger.trace({ type: "payload", direction: "outgoing", request: i });
+    try {
+      const r = he(e + this.clientId);
+      return s === k.link_mode ? (setTimeout(() => {
+        (this.relayer.connected || this.relayer.connecting) && this.relayer.request(i).catch((n) => this.logger.warn(n));
+      }, l.toMiliseconds(l.ONE_SECOND)), r) : await await $(this.relayer.request(i).catch((n) => this.logger.warn(n)), this.subscribeTimeout) ? r : null;
+    } catch {
+      this.logger.debug("Outgoing Relay Subscribe Payload stalled"), this.relayer.events.emit(T.connection_stalled);
+    }
+    return null;
+  }
+  async rpcBatchSubscribe(e) {
+    if (!e.length) return;
+    const t = e[0].relay, s = { method: J(t.protocol).batchSubscribe, params: { topics: e.map((i) => i.topic) } };
+    this.logger.debug("Outgoing Relay Payload"), this.logger.trace({ type: "payload", direction: "outgoing", request: s });
+    try {
+      return await await $(this.relayer.request(s).catch((i) => this.logger.warn(i)), this.subscribeTimeout);
+    } catch {
+      this.relayer.events.emit(T.connection_stalled);
+    }
+  }
+  async rpcBatchFetchMessages(e) {
+    if (!e.length) return;
+    const t = e[0].relay, s = { method: J(t.protocol).batchFetchMessages, params: { topics: e.map((r) => r.topic) } };
+    this.logger.debug("Outgoing Relay Payload"), this.logger.trace({ type: "payload", direction: "outgoing", request: s });
+    let i;
+    try {
+      i = await await $(this.relayer.request(s).catch((r) => this.logger.warn(r)), this.subscribeTimeout);
+    } catch {
+      this.relayer.events.emit(T.connection_stalled);
+    }
+    return i;
+  }
+  rpcUnsubscribe(e, t, s) {
+    const i = { method: J(s.protocol).unsubscribe, params: { topic: e, id: t } };
+    return this.logger.debug("Outgoing Relay Payload"), this.logger.trace({ type: "payload", direction: "outgoing", request: i }), this.relayer.request(i);
+  }
+  onSubscribe(e, t) {
+    this.setSubscription(e, ne(H({}, t), { id: e })), this.pending.delete(t.topic);
+  }
+  onBatchSubscribe(e) {
+    e.length && e.forEach((t) => {
+      this.setSubscription(t.id, H({}, t)), this.pending.delete(t.topic);
+    });
+  }
+  async onUnsubscribe(e, t, s) {
+    this.events.removeAllListeners(t), this.hasSubscription(t, e) && this.deleteSubscription(t, s), await this.relayer.messages.del(e);
+  }
+  async setRelayerSubscriptions(e) {
+    await this.relayer.core.storage.setItem(this.storageKey, e);
+  }
+  async getRelayerSubscriptions() {
+    return await this.relayer.core.storage.getItem(this.storageKey);
+  }
+  setSubscription(e, t) {
+    this.logger.debug("Setting subscription"), this.logger.trace({ type: "method", method: "setSubscription", id: e, subscription: t }), this.addSubscription(e, t);
+  }
+  addSubscription(e, t) {
+    this.subscriptions.set(e, H({}, t)), this.topicMap.set(t.topic, e), this.events.emit(N.created, t);
+  }
+  getSubscription(e) {
+    this.logger.debug("Getting subscription"), this.logger.trace({ type: "method", method: "getSubscription", id: e });
+    const t = this.subscriptions.get(e);
+    if (!t) {
+      const { message: s } = d("NO_MATCHING_KEY", `${this.name}: ${e}`);
+      throw new Error(s);
+    }
+    return t;
+  }
+  deleteSubscription(e, t) {
+    this.logger.debug("Deleting subscription"), this.logger.trace({ type: "method", method: "deleteSubscription", id: e, reason: t });
+    const s = this.getSubscription(e);
+    this.subscriptions.delete(e), this.topicMap.delete(s.topic, e), this.events.emit(N.deleted, ne(H({}, s), { reason: t }));
+  }
+  async persist() {
+    await this.setRelayerSubscriptions(this.values), this.events.emit(N.sync);
+  }
+  async reset() {
+    if (this.cached.length) {
+      const e = Math.ceil(this.cached.length / this.batchSubscribeTopicsLimit);
+      for (let t = 0; t < e; t++) {
+        const s = this.cached.splice(0, this.batchSubscribeTopicsLimit);
+        await this.batchFetchMessages(s), await this.batchSubscribe(s);
+      }
+    }
+    this.events.emit(N.resubscribed);
+  }
+  async restore() {
+    try {
+      const e = await this.getRelayerSubscriptions();
+      if (typeof e > "u" || !e.length) return;
+      if (this.subscriptions.size) {
+        const { message: t } = d("RESTORE_WILL_OVERRIDE", this.name);
+        throw this.logger.error(t), this.logger.error(`${this.name}: ${JSON.stringify(this.values)}`), new Error(t);
+      }
+      this.cached = e, this.logger.debug(`Successfully Restored subscriptions for ${this.name}`), this.logger.trace({ type: "method", method: "restore", subscriptions: this.values });
+    } catch (e) {
+      this.logger.debug(`Failed to Restore subscriptions for ${this.name}`), this.logger.error(e);
+    }
+  }
+  async batchSubscribe(e) {
+    if (!e.length) return;
+    const t = await this.rpcBatchSubscribe(e);
+    li(t) && this.onBatchSubscribe(t.map((s, i) => ne(H({}, e[i]), { id: s })));
+  }
+  async batchFetchMessages(e) {
+    if (!e.length) return;
+    this.logger.trace(`Fetching batch messages for ${e.length} subscriptions`);
+    const t = await this.rpcBatchFetchMessages(e);
+    t && t.messages && (this.pendingBatchMessages = this.pendingBatchMessages.concat(t.messages));
+  }
+  async onConnect() {
+    await this.restart(), this.onEnable();
+  }
+  onDisconnect() {
+    this.onDisable();
+  }
+  async checkPending() {
+    if (!this.initialized || !this.relayer.connected) return;
+    const e = [];
+    this.pending.forEach((t) => {
+      e.push(t);
+    }), await this.batchSubscribe(e), this.pendingBatchMessages.length && (await this.relayer.handleBatchMessageEvents(this.pendingBatchMessages), this.pendingBatchMessages = []);
+  }
+  registerEventListeners() {
+    this.relayer.core.heartbeat.on(X.pulse, async () => {
+      await this.checkPending();
+    }), this.events.on(N.created, async (e) => {
+      const t = N.created;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, data: e }), await this.persist();
+    }), this.events.on(N.deleted, async (e) => {
+      const t = N.deleted;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, data: e }), await this.persist();
+    });
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+  async restartToComplete() {
+    !this.relayer.connected && !this.relayer.connecting && await this.relayer.transportOpen(), this.restartInProgress && await new Promise((e) => {
+      const t = setInterval(() => {
+        this.restartInProgress || (clearInterval(t), e());
+      }, this.pollingInterval);
+    });
+  }
+}
+var Dr = Object.defineProperty, Ue = Object.getOwnPropertySymbols, zr = Object.prototype.hasOwnProperty, Lr = Object.prototype.propertyIsEnumerable, ke = (a, e, t) => e in a ? Dr(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, Mr = (a, e) => {
+  for (var t in e) zr.call(e, t) && ke(a, t, e[t]);
+  if (Ue) for (var t of Ue(e)) Lr.call(e, t) && ke(a, t, e[t]);
+  return a;
+};
+class Ur extends Ft {
+  constructor(e) {
+    super(e), this.protocol = "wc", this.version = 2, this.events = new B.EventEmitter(), this.name = Oi, this.transportExplicitlyClosed = !1, this.initialized = !1, this.connectionAttemptInProgress = !1, this.connectionStatusPollingInterval = 20, this.staleConnectionErrors = ["socket hang up", "stalled", "interrupted"], this.hasExperiencedNetworkDisruption = !1, this.requestsInFlight = /* @__PURE__ */ new Map(), this.heartBeatTimeout = l.toMiliseconds(l.THIRTY_SECONDS + l.ONE_SECOND), this.request = async (t) => {
+      var s, i;
+      this.logger.debug("Publishing Request Payload");
+      const r = t.id || Ze().toString();
+      await this.toEstablishConnection();
+      try {
+        const n = this.provider.request(t);
+        this.requestsInFlight.set(r, { promise: n, request: t }), this.logger.trace({ id: r, method: t.method, topic: (s = t.params) == null ? void 0 : s.topic }, "relayer.request - attempt to publish...");
+        const o = await new Promise(async (h, c) => {
+          const g = () => {
+            c(new Error(`relayer.request - publish interrupted, id: ${r}`));
+          };
+          this.provider.on(P.disconnect, g);
+          const p = await n;
+          this.provider.off(P.disconnect, g), h(p);
+        });
+        return this.logger.trace({ id: r, method: t.method, topic: (i = t.params) == null ? void 0 : i.topic }, "relayer.request - published"), o;
+      } catch (n) {
+        throw this.logger.debug(`Failed to Publish Request: ${r}`), n;
+      } finally {
+        this.requestsInFlight.delete(r);
+      }
+    }, this.resetPingTimeout = () => {
+      if (Ee()) try {
+        clearTimeout(this.pingTimeout), this.pingTimeout = setTimeout(() => {
+          var t, s, i;
+          (i = (s = (t = this.provider) == null ? void 0 : t.connection) == null ? void 0 : s.socket) == null || i.terminate();
+        }, this.heartBeatTimeout);
+      } catch (t) {
+        this.logger.warn(t);
+      }
+    }, this.onPayloadHandler = (t) => {
+      this.onProviderPayload(t), this.resetPingTimeout();
+    }, this.onConnectHandler = () => {
+      this.logger.trace("relayer connected"), this.startPingTimeout(), this.events.emit(T.connect);
+    }, this.onDisconnectHandler = () => {
+      this.logger.trace("relayer disconnected"), this.onProviderDisconnect();
+    }, this.onProviderErrorHandler = (t) => {
+      this.logger.error(t), this.events.emit(T.error, t), this.logger.info("Fatal socket error received, closing transport"), this.transportClose();
+    }, this.registerProviderListeners = () => {
+      this.provider.on(P.payload, this.onPayloadHandler), this.provider.on(P.connect, this.onConnectHandler), this.provider.on(P.disconnect, this.onDisconnectHandler), this.provider.on(P.error, this.onProviderErrorHandler);
+    }, this.core = e.core, this.logger = typeof e.logger < "u" && typeof e.logger != "string" ? I(e.logger, this.name) : fi(Ge({ level: e.logger || xi })), this.messages = new Fr(this.logger, e.core), this.subscriber = new Nr(this, this.logger), this.publisher = new Pr(this, this.logger), this.relayUrl = (e == null ? void 0 : e.relayUrl) || at, this.projectId = e.projectId, this.bundleId = Wt(), this.provider = {};
+  }
+  async init() {
+    if (this.logger.trace("Initialized"), this.registerEventListeners(), await Promise.all([this.messages.init(), this.subscriber.init()]), this.initialized = !0, this.subscriber.cached.length > 0) try {
+      await this.transportOpen();
+    } catch (e) {
+      this.logger.warn(e);
+    }
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get connected() {
+    var e, t, s;
+    return ((s = (t = (e = this.provider) == null ? void 0 : e.connection) == null ? void 0 : t.socket) == null ? void 0 : s.readyState) === 1;
+  }
+  get connecting() {
+    var e, t, s;
+    return ((s = (t = (e = this.provider) == null ? void 0 : e.connection) == null ? void 0 : t.socket) == null ? void 0 : s.readyState) === 0;
+  }
+  async publish(e, t, s) {
+    this.isInitialized(), await this.publisher.publish(e, t, s), await this.recordMessageEvent({ topic: e, message: t, publishedAt: Date.now(), transportType: k.relay });
+  }
+  async subscribe(e, t) {
+    var s;
+    this.isInitialized(), (t == null ? void 0 : t.transportType) === "relay" && await this.toEstablishConnection();
+    let i = ((s = this.subscriber.topicMap.get(e)) == null ? void 0 : s[0]) || "", r;
+    const n = (o) => {
+      o.topic === e && (this.subscriber.off(N.created, n), r());
+    };
+    return await Promise.all([new Promise((o) => {
+      r = o, this.subscriber.on(N.created, n);
+    }), new Promise(async (o) => {
+      i = await this.subscriber.subscribe(e, t) || i, o();
+    })]), i;
+  }
+  async unsubscribe(e, t) {
+    this.isInitialized(), await this.subscriber.unsubscribe(e, t);
+  }
+  on(e, t) {
+    this.events.on(e, t);
+  }
+  once(e, t) {
+    this.events.once(e, t);
+  }
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  removeListener(e, t) {
+    this.events.removeListener(e, t);
+  }
+  async transportDisconnect() {
+    if (!this.hasExperiencedNetworkDisruption && this.connected && this.requestsInFlight.size > 0) try {
+      await Promise.all(Array.from(this.requestsInFlight.values()).map((e) => e.promise));
+    } catch (e) {
+      this.logger.warn(e);
+    }
+    this.hasExperiencedNetworkDisruption || this.connected ? await $(this.provider.disconnect(), 2e3, "provider.disconnect()").catch(() => this.onProviderDisconnect()) : this.onProviderDisconnect();
+  }
+  async transportClose() {
+    this.transportExplicitlyClosed = !0, await this.transportDisconnect();
+  }
+  async transportOpen(e) {
+    await this.confirmOnlineStateOrThrow(), e && e !== this.relayUrl && (this.relayUrl = e, await this.transportDisconnect()), await this.createProvider(), this.connectionAttemptInProgress = !0, this.transportExplicitlyClosed = !1;
+    try {
+      await new Promise(async (t, s) => {
+        const i = () => {
+          this.provider.off(P.disconnect, i), s(new Error("Connection interrupted while trying to subscribe"));
+        };
+        this.provider.on(P.disconnect, i), await $(this.provider.connect(), l.toMiliseconds(l.ONE_MINUTE), `Socket stalled when trying to connect to ${this.relayUrl}`).catch((r) => {
+          s(r);
+        }).finally(() => {
+          clearTimeout(this.reconnectTimeout), this.reconnectTimeout = void 0;
+        }), this.subscriber.start().catch((r) => {
+          this.logger.error(r), this.onDisconnectHandler();
+        }), this.hasExperiencedNetworkDisruption = !1, t();
+      });
+    } catch (t) {
+      this.logger.error(t);
+      const s = t;
+      if (this.hasExperiencedNetworkDisruption = !0, !this.isConnectionStalled(s.message)) throw t;
+    } finally {
+      this.connectionAttemptInProgress = !1;
+    }
+  }
+  async restartTransport(e) {
+    this.connectionAttemptInProgress || (this.relayUrl = e || this.relayUrl, await this.confirmOnlineStateOrThrow(), await this.transportClose(), await this.transportOpen());
+  }
+  async confirmOnlineStateOrThrow() {
+    if (!await Ie()) throw new Error("No internet connection detected. Please restart your network and try again.");
+  }
+  async handleBatchMessageEvents(e) {
+    if ((e == null ? void 0 : e.length) === 0) {
+      this.logger.trace("Batch message events is empty. Ignoring...");
+      return;
+    }
+    const t = e.sort((s, i) => s.publishedAt - i.publishedAt);
+    this.logger.trace(`Batch of ${t.length} message events sorted`);
+    for (const s of t) try {
+      await this.onMessageEvent(s);
+    } catch (i) {
+      this.logger.warn(i);
+    }
+    this.logger.trace(`Batch of ${t.length} message events processed`);
+  }
+  async onLinkMessageEvent(e, t) {
+    const { topic: s } = e;
+    if (!t.sessionExists) {
+      const i = W(l.FIVE_MINUTES), r = { topic: s, expiry: i, relay: { protocol: "irn" }, active: !1 };
+      await this.core.pairing.pairings.set(s, r);
+    }
+    this.events.emit(T.message, e), await this.recordMessageEvent(e);
+  }
+  startPingTimeout() {
+    var e, t, s, i, r;
+    if (Ee()) try {
+      (t = (e = this.provider) == null ? void 0 : e.connection) != null && t.socket && ((r = (i = (s = this.provider) == null ? void 0 : s.connection) == null ? void 0 : i.socket) == null || r.once("ping", () => {
+        this.resetPingTimeout();
+      })), this.resetPingTimeout();
+    } catch (n) {
+      this.logger.warn(n);
+    }
+  }
+  isConnectionStalled(e) {
+    return this.staleConnectionErrors.some((t) => e.includes(t));
+  }
+  async createProvider() {
+    this.provider.connection && this.unregisterProviderListeners();
+    const e = await this.core.crypto.signJWT(this.relayUrl);
+    this.provider = new di(new yi(Xt({ sdkVersion: le, protocol: this.protocol, version: this.version, relayUrl: this.relayUrl, projectId: this.projectId, auth: e, useOnCloseEvent: !0, bundleId: this.bundleId }))), this.registerProviderListeners();
+  }
+  async recordMessageEvent(e) {
+    const { topic: t, message: s } = e;
+    await this.messages.set(t, s);
+  }
+  async shouldIgnoreMessageEvent(e) {
+    const { topic: t, message: s } = e;
+    if (!s || s.length === 0) return this.logger.debug(`Ignoring invalid/empty message: ${s}`), !0;
+    if (!await this.subscriber.isSubscribed(t)) return this.logger.debug(`Ignoring message for non-subscribed topic ${t}`), !0;
+    const i = this.messages.has(t, s);
+    return i && this.logger.debug(`Ignoring duplicate message: ${s}`), i;
+  }
+  async onProviderPayload(e) {
+    if (this.logger.debug("Incoming Relay Payload"), this.logger.trace({ type: "payload", direction: "incoming", payload: e }), tt(e)) {
+      if (!e.method.endsWith(Ai)) return;
+      const t = e.params, { topic: s, message: i, publishedAt: r, attestation: n } = t.data, o = { topic: s, message: i, publishedAt: r, transportType: k.relay, attestation: n };
+      this.logger.debug("Emitting Relayer Payload"), this.logger.trace(Mr({ type: "event", event: t.id }, o)), this.events.emit(t.id, o), await this.acknowledgePayload(e), await this.onMessageEvent(o);
+    } else it(e) && this.events.emit(T.message_ack, e);
+  }
+  async onMessageEvent(e) {
+    await this.shouldIgnoreMessageEvent(e) || (this.events.emit(T.message, e), await this.recordMessageEvent(e));
+  }
+  async acknowledgePayload(e) {
+    const t = Qe(e.id, !0);
+    await this.provider.connection.send(t);
+  }
+  unregisterProviderListeners() {
+    this.provider.off(P.payload, this.onPayloadHandler), this.provider.off(P.connect, this.onConnectHandler), this.provider.off(P.disconnect, this.onDisconnectHandler), this.provider.off(P.error, this.onProviderErrorHandler), clearTimeout(this.pingTimeout);
+  }
+  async registerEventListeners() {
+    let e = await Ie();
+    Zt(async (t) => {
+      e !== t && (e = t, t ? await this.restartTransport().catch((s) => this.logger.error(s)) : (this.hasExperiencedNetworkDisruption = !0, await this.transportDisconnect(), this.transportExplicitlyClosed = !1));
+    });
+  }
+  async onProviderDisconnect() {
+    await this.subscriber.stop(), this.requestsInFlight.clear(), clearTimeout(this.pingTimeout), this.events.emit(T.disconnect), this.connectionAttemptInProgress = !1, !this.transportExplicitlyClosed && (this.reconnectTimeout || (this.reconnectTimeout = setTimeout(async () => {
+      await this.transportOpen().catch((e) => this.logger.error(e));
+    }, l.toMiliseconds(Ci))));
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+  async toEstablishConnection() {
+    await this.confirmOnlineStateOrThrow(), !this.connected && (this.connectionAttemptInProgress && await new Promise((e) => {
+      const t = setInterval(() => {
+        this.connected && (clearInterval(t), e());
+      }, this.connectionStatusPollingInterval);
+    }), await this.transportOpen());
+  }
+}
+var kr = Object.defineProperty, Ke = Object.getOwnPropertySymbols, Kr = Object.prototype.hasOwnProperty, $r = Object.prototype.propertyIsEnumerable, $e = (a, e, t) => e in a ? kr(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, Be = (a, e) => {
+  for (var t in e || (e = {})) Kr.call(e, t) && $e(a, t, e[t]);
+  if (Ke) for (var t of Ke(e)) $r.call(e, t) && $e(a, t, e[t]);
+  return a;
+};
+class Br extends It {
+  constructor(e, t, s, i = D, r = void 0) {
+    super(e, t, s, i), this.core = e, this.logger = t, this.name = s, this.map = /* @__PURE__ */ new Map(), this.version = Ni, this.cached = [], this.initialized = !1, this.storagePrefix = D, this.recentlyDeleted = [], this.recentlyDeletedLimit = 200, this.init = async () => {
+      this.initialized || (this.logger.trace("Initialized"), await this.restore(), this.cached.forEach((n) => {
+        this.getKey && n !== null && !ae(n) ? this.map.set(this.getKey(n), n) : Mt(n) ? this.map.set(n.id, n) : Ut(n) && this.map.set(n.topic, n);
+      }), this.cached = [], this.initialized = !0);
+    }, this.set = async (n, o) => {
+      this.isInitialized(), this.map.has(n) ? await this.update(n, o) : (this.logger.debug("Setting value"), this.logger.trace({ type: "method", method: "set", key: n, value: o }), this.map.set(n, o), await this.persist());
+    }, this.get = (n) => (this.isInitialized(), this.logger.debug("Getting value"), this.logger.trace({ type: "method", method: "get", key: n }), this.getData(n)), this.getAll = (n) => (this.isInitialized(), n ? this.values.filter((o) => Object.keys(n).every((h) => mi(o[h], n[h]))) : this.values), this.update = async (n, o) => {
+      this.isInitialized(), this.logger.debug("Updating value"), this.logger.trace({ type: "method", method: "update", key: n, update: o });
+      const h = Be(Be({}, this.getData(n)), o);
+      this.map.set(n, h), await this.persist();
+    }, this.delete = async (n, o) => {
+      this.isInitialized(), this.map.has(n) && (this.logger.debug("Deleting value"), this.logger.trace({ type: "method", method: "delete", key: n, reason: o }), this.map.delete(n), this.addToRecentlyDeleted(n), await this.persist());
+    }, this.logger = I(t, this.name), this.storagePrefix = i, this.getKey = r;
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//" + this.name;
+  }
+  get length() {
+    return this.map.size;
+  }
+  get keys() {
+    return Array.from(this.map.keys());
+  }
+  get values() {
+    return Array.from(this.map.values());
+  }
+  addToRecentlyDeleted(e) {
+    this.recentlyDeleted.push(e), this.recentlyDeleted.length >= this.recentlyDeletedLimit && this.recentlyDeleted.splice(0, this.recentlyDeletedLimit / 2);
+  }
+  async setDataStore(e) {
+    await this.core.storage.setItem(this.storageKey, e);
+  }
+  async getDataStore() {
+    return await this.core.storage.getItem(this.storageKey);
+  }
+  getData(e) {
+    const t = this.map.get(e);
+    if (!t) {
+      if (this.recentlyDeleted.includes(e)) {
+        const { message: i } = d("MISSING_OR_INVALID", `Record was recently deleted - ${this.name}: ${e}`);
+        throw this.logger.error(i), new Error(i);
+      }
+      const { message: s } = d("NO_MATCHING_KEY", `${this.name}: ${e}`);
+      throw this.logger.error(s), new Error(s);
+    }
+    return t;
+  }
+  async persist() {
+    await this.setDataStore(this.values);
+  }
+  async restore() {
+    try {
+      const e = await this.getDataStore();
+      if (typeof e > "u" || !e.length) return;
+      if (this.map.size) {
+        const { message: t } = d("RESTORE_WILL_OVERRIDE", this.name);
+        throw this.logger.error(t), new Error(t);
+      }
+      this.cached = e, this.logger.debug(`Successfully Restored value for ${this.name}`), this.logger.trace({ type: "method", method: "restore", value: this.values });
+    } catch (e) {
+      this.logger.debug(`Failed to Restore value for ${this.name}`), this.logger.error(e);
+    }
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+class Vr {
+  constructor(e, t) {
+    this.core = e, this.logger = t, this.name = Ui, this.version = ki, this.events = new _t(), this.initialized = !1, this.storagePrefix = D, this.ignoredPayloadTypes = [Qt], this.registeredMethods = [], this.init = async () => {
+      this.initialized || (await this.pairings.init(), await this.cleanup(), this.registerRelayerEvents(), this.registerExpirerEvents(), this.initialized = !0, this.logger.trace("Initialized"));
+    }, this.register = ({ methods: s }) => {
+      this.isInitialized(), this.registeredMethods = [.../* @__PURE__ */ new Set([...this.registeredMethods, ...s])];
+    }, this.create = async (s) => {
+      this.isInitialized();
+      const i = oe(), r = await this.core.crypto.setSymKey(i), n = W(l.FIVE_MINUTES), o = { protocol: Ri }, h = { topic: r, expiry: n, relay: o, active: !1, methods: s == null ? void 0 : s.methods }, c = Te({ protocol: this.core.protocol, version: this.core.version, topic: r, symKey: i, relay: o, expiryTimestamp: n, methods: s == null ? void 0 : s.methods });
+      return this.events.emit(q.create, h), this.core.expirer.set(r, n), await this.pairings.set(r, h), await this.core.relayer.subscribe(r, { transportType: s == null ? void 0 : s.transportType }), { topic: r, uri: c };
+    }, this.pair = async (s) => {
+      this.isInitialized();
+      const i = this.core.eventClient.createEvent({ properties: { topic: s == null ? void 0 : s.uri, trace: [L.pairing_started] } });
+      this.isValidPair(s, i);
+      const { topic: r, symKey: n, relay: o, expiryTimestamp: h, methods: c } = Fe(s.uri);
+      i.props.properties.topic = r, i.addTrace(L.pairing_uri_validation_success), i.addTrace(L.pairing_uri_not_expired);
+      let g;
+      if (this.pairings.keys.includes(r)) {
+        if (g = this.pairings.get(r), i.addTrace(L.existing_pairing), g.active) throw i.setError(U.active_pairing_already_exists), new Error(`Pairing already exists: ${r}. Please try again with a new connection URI.`);
+        i.addTrace(L.pairing_not_expired);
+      }
+      const p = h || W(l.FIVE_MINUTES), b = { topic: r, relay: o, expiry: p, active: !1, methods: c };
+      this.core.expirer.set(r, p), await this.pairings.set(r, b), i.addTrace(L.store_new_pairing), s.activatePairing && await this.activate({ topic: r }), this.events.emit(q.create, b), i.addTrace(L.emit_inactive_pairing), this.core.crypto.keychain.has(r) || await this.core.crypto.setSymKey(n, r), i.addTrace(L.subscribing_pairing_topic);
+      try {
+        await this.core.relayer.confirmOnlineStateOrThrow();
+      } catch {
+        i.setError(U.no_internet_connection);
+      }
+      try {
+        await this.core.relayer.subscribe(r, { relay: o });
+      } catch (_) {
+        throw i.setError(U.subscribe_pairing_topic_failure), _;
+      }
+      return i.addTrace(L.subscribe_pairing_topic_success), b;
+    }, this.activate = async ({ topic: s }) => {
+      this.isInitialized();
+      const i = W(l.THIRTY_DAYS);
+      this.core.expirer.set(s, i), await this.pairings.update(s, { active: !0, expiry: i });
+    }, this.ping = async (s) => {
+      this.isInitialized(), await this.isValidPing(s);
+      const { topic: i } = s;
+      if (this.pairings.keys.includes(i)) {
+        const r = await this.sendRequest(i, "wc_pairingPing", {}), { done: n, resolve: o, reject: h } = ei();
+        this.events.once(ie("pairing_ping", r), ({ error: c }) => {
+          c ? h(c) : o();
+        }), await n();
+      }
+    }, this.updateExpiry = async ({ topic: s, expiry: i }) => {
+      this.isInitialized(), await this.pairings.update(s, { expiry: i });
+    }, this.updateMetadata = async ({ topic: s, metadata: i }) => {
+      this.isInitialized(), await this.pairings.update(s, { peerMetadata: i });
+    }, this.getPairings = () => (this.isInitialized(), this.pairings.values), this.disconnect = async (s) => {
+      this.isInitialized(), await this.isValidDisconnect(s);
+      const { topic: i } = s;
+      this.pairings.keys.includes(i) && (await this.sendRequest(i, "wc_pairingDelete", G("USER_DISCONNECTED")), await this.deletePairing(i));
+    }, this.formatUriFromPairing = (s) => {
+      this.isInitialized();
+      const { topic: i, relay: r, expiry: n, methods: o } = s, h = this.core.crypto.keychain.get(i);
+      return Te({ protocol: this.core.protocol, version: this.core.version, topic: i, symKey: h, relay: r, expiryTimestamp: n, methods: o });
+    }, this.sendRequest = async (s, i, r) => {
+      const n = et(i, r), o = await this.core.crypto.encode(s, n), h = j[i].req;
+      return this.core.history.set(s, n), this.core.relayer.publish(s, o, h), n.id;
+    }, this.sendResult = async (s, i, r) => {
+      const n = Qe(s, r), o = await this.core.crypto.encode(i, n), h = await this.core.history.get(i, s), c = j[h.request.method].res;
+      await this.core.relayer.publish(i, o, c), await this.core.history.resolve(n);
+    }, this.sendError = async (s, i, r) => {
+      const n = gi(s, r), o = await this.core.crypto.encode(i, n), h = await this.core.history.get(i, s), c = j[h.request.method] ? j[h.request.method].res : j.unregistered_method.res;
+      await this.core.relayer.publish(i, o, c), await this.core.history.resolve(n);
+    }, this.deletePairing = async (s, i) => {
+      await this.core.relayer.unsubscribe(s), await Promise.all([this.pairings.delete(s, G("USER_DISCONNECTED")), this.core.crypto.deleteSymKey(s), i ? Promise.resolve() : this.core.expirer.del(s)]);
+    }, this.cleanup = async () => {
+      const s = this.pairings.getAll().filter((i) => Pe(i.expiry));
+      await Promise.all(s.map((i) => this.deletePairing(i.topic)));
+    }, this.onRelayEventRequest = (s) => {
+      const { topic: i, payload: r } = s;
+      switch (r.method) {
+        case "wc_pairingPing":
+          return this.onPairingPingRequest(i, r);
+        case "wc_pairingDelete":
+          return this.onPairingDeleteRequest(i, r);
+        default:
+          return this.onUnknownRpcMethodRequest(i, r);
+      }
+    }, this.onRelayEventResponse = async (s) => {
+      const { topic: i, payload: r } = s, n = (await this.core.history.get(i, r.id)).request.method;
+      switch (n) {
+        case "wc_pairingPing":
+          return this.onPairingPingResponse(i, r);
+        default:
+          return this.onUnknownRpcMethodResponse(n);
+      }
+    }, this.onPairingPingRequest = async (s, i) => {
+      const { id: r } = i;
+      try {
+        this.isValidPing({ topic: s }), await this.sendResult(r, s, !0), this.events.emit(q.ping, { id: r, topic: s });
+      } catch (n) {
+        await this.sendError(r, s, n), this.logger.error(n);
+      }
+    }, this.onPairingPingResponse = (s, i) => {
+      const { id: r } = i;
+      setTimeout(() => {
+        pi(i) ? this.events.emit(ie("pairing_ping", r), {}) : st(i) && this.events.emit(ie("pairing_ping", r), { error: i.error });
+      }, 500);
+    }, this.onPairingDeleteRequest = async (s, i) => {
+      const { id: r } = i;
+      try {
+        this.isValidDisconnect({ topic: s }), await this.deletePairing(s), this.events.emit(q.delete, { id: r, topic: s });
+      } catch (n) {
+        await this.sendError(r, s, n), this.logger.error(n);
+      }
+    }, this.onUnknownRpcMethodRequest = async (s, i) => {
+      const { id: r, method: n } = i;
+      try {
+        if (this.registeredMethods.includes(n)) return;
+        const o = G("WC_METHOD_UNSUPPORTED", n);
+        await this.sendError(r, s, o), this.logger.error(o);
+      } catch (o) {
+        await this.sendError(r, s, o), this.logger.error(o);
+      }
+    }, this.onUnknownRpcMethodResponse = (s) => {
+      this.registeredMethods.includes(s) || this.logger.error(G("WC_METHOD_UNSUPPORTED", s));
+    }, this.isValidPair = (s, i) => {
+      var r;
+      if (!se(s)) {
+        const { message: o } = d("MISSING_OR_INVALID", `pair() params: ${s}`);
+        throw i.setError(U.malformed_pairing_uri), new Error(o);
+      }
+      if (!ti(s.uri)) {
+        const { message: o } = d("MISSING_OR_INVALID", `pair() uri: ${s.uri}`);
+        throw i.setError(U.malformed_pairing_uri), new Error(o);
+      }
+      const n = Fe(s == null ? void 0 : s.uri);
+      if (!((r = n == null ? void 0 : n.relay) != null && r.protocol)) {
+        const { message: o } = d("MISSING_OR_INVALID", "pair() uri#relay-protocol");
+        throw i.setError(U.malformed_pairing_uri), new Error(o);
+      }
+      if (!(n != null && n.symKey)) {
+        const { message: o } = d("MISSING_OR_INVALID", "pair() uri#symKey");
+        throw i.setError(U.malformed_pairing_uri), new Error(o);
+      }
+      if (n != null && n.expiryTimestamp && l.toMiliseconds(n == null ? void 0 : n.expiryTimestamp) < Date.now()) {
+        i.setError(U.pairing_expired);
+        const { message: o } = d("EXPIRED", "pair() URI has expired. Please try again with a new connection URI.");
+        throw new Error(o);
+      }
+    }, this.isValidPing = async (s) => {
+      if (!se(s)) {
+        const { message: r } = d("MISSING_OR_INVALID", `ping() params: ${s}`);
+        throw new Error(r);
+      }
+      const { topic: i } = s;
+      await this.isValidPairingTopic(i);
+    }, this.isValidDisconnect = async (s) => {
+      if (!se(s)) {
+        const { message: r } = d("MISSING_OR_INVALID", `disconnect() params: ${s}`);
+        throw new Error(r);
+      }
+      const { topic: i } = s;
+      await this.isValidPairingTopic(i);
+    }, this.isValidPairingTopic = async (s) => {
+      if (!ii(s, !1)) {
+        const { message: i } = d("MISSING_OR_INVALID", `pairing topic should be a string: ${s}`);
+        throw new Error(i);
+      }
+      if (!this.pairings.keys.includes(s)) {
+        const { message: i } = d("NO_MATCHING_KEY", `pairing topic doesn't exist: ${s}`);
+        throw new Error(i);
+      }
+      if (Pe(this.pairings.get(s).expiry)) {
+        await this.deletePairing(s);
+        const { message: i } = d("EXPIRED", `pairing topic: ${s}`);
+        throw new Error(i);
+      }
+    }, this.core = e, this.logger = I(t, this.name), this.pairings = new Br(this.core, this.logger, this.name, this.storagePrefix);
+  }
+  get context() {
+    return S(this.logger);
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+  registerRelayerEvents() {
+    this.core.relayer.on(T.message, async (e) => {
+      const { topic: t, message: s, transportType: i } = e;
+      if (!this.pairings.keys.includes(t) || i === k.link_mode || this.ignoredPayloadTypes.includes(this.core.crypto.getPayloadType(s))) return;
+      const r = await this.core.crypto.decode(t, s);
+      try {
+        tt(r) ? (this.core.history.set(t, r), this.onRelayEventRequest({ topic: t, payload: r })) : it(r) && (await this.core.history.resolve(r), await this.onRelayEventResponse({ topic: t, payload: r }), this.core.history.delete(t, r.id));
+      } catch (n) {
+        this.logger.error(n);
+      }
+    });
+  }
+  registerExpirerEvents() {
+    this.core.expirer.on(O.expired, async (e) => {
+      const { topic: t } = si(e.target);
+      t && this.pairings.keys.includes(t) && (await this.deletePairing(t, !0), this.events.emit(q.expire, { topic: t }));
+    });
+  }
+}
+class jr extends Pt {
+  constructor(e, t) {
+    super(e, t), this.core = e, this.logger = t, this.records = /* @__PURE__ */ new Map(), this.events = new B.EventEmitter(), this.name = Ki, this.version = $i, this.cached = [], this.initialized = !1, this.storagePrefix = D, this.init = async () => {
+      this.initialized || (this.logger.trace("Initialized"), await this.restore(), this.cached.forEach((s) => this.records.set(s.id, s)), this.cached = [], this.registerEventListeners(), this.initialized = !0);
+    }, this.set = (s, i, r) => {
+      if (this.isInitialized(), this.logger.debug("Setting JSON-RPC request history record"), this.logger.trace({ type: "method", method: "set", topic: s, request: i, chainId: r }), this.records.has(i.id)) return;
+      const n = { id: i.id, topic: s, request: { method: i.method, params: i.params || null }, chainId: r, expiry: W(l.THIRTY_DAYS) };
+      this.records.set(n.id, n), this.persist(), this.events.emit(x.created, n);
+    }, this.resolve = async (s) => {
+      if (this.isInitialized(), this.logger.debug("Updating JSON-RPC response history record"), this.logger.trace({ type: "method", method: "update", response: s }), !this.records.has(s.id)) return;
+      const i = await this.getRecord(s.id);
+      typeof i.response > "u" && (i.response = st(s) ? { error: s.error } : { result: s.result }, this.records.set(i.id, i), this.persist(), this.events.emit(x.updated, i));
+    }, this.get = async (s, i) => (this.isInitialized(), this.logger.debug("Getting record"), this.logger.trace({ type: "method", method: "get", topic: s, id: i }), await this.getRecord(i)), this.delete = (s, i) => {
+      this.isInitialized(), this.logger.debug("Deleting record"), this.logger.trace({ type: "method", method: "delete", id: i }), this.values.forEach((r) => {
+        if (r.topic === s) {
+          if (typeof i < "u" && r.id !== i) return;
+          this.records.delete(r.id), this.events.emit(x.deleted, r);
+        }
+      }), this.persist();
+    }, this.exists = async (s, i) => (this.isInitialized(), this.records.has(i) ? (await this.getRecord(i)).topic === s : !1), this.on = (s, i) => {
+      this.events.on(s, i);
+    }, this.once = (s, i) => {
+      this.events.once(s, i);
+    }, this.off = (s, i) => {
+      this.events.off(s, i);
+    }, this.removeListener = (s, i) => {
+      this.events.removeListener(s, i);
+    }, this.logger = I(t, this.name);
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//" + this.name;
+  }
+  get size() {
+    return this.records.size;
+  }
+  get keys() {
+    return Array.from(this.records.keys());
+  }
+  get values() {
+    return Array.from(this.records.values());
+  }
+  get pending() {
+    const e = [];
+    return this.values.forEach((t) => {
+      if (typeof t.response < "u") return;
+      const s = { topic: t.topic, request: et(t.request.method, t.request.params, t.id), chainId: t.chainId };
+      return e.push(s);
+    }), e;
+  }
+  async setJsonRpcRecords(e) {
+    await this.core.storage.setItem(this.storageKey, e);
+  }
+  async getJsonRpcRecords() {
+    return await this.core.storage.getItem(this.storageKey);
+  }
+  getRecord(e) {
+    this.isInitialized();
+    const t = this.records.get(e);
+    if (!t) {
+      const { message: s } = d("NO_MATCHING_KEY", `${this.name}: ${e}`);
+      throw new Error(s);
+    }
+    return t;
+  }
+  async persist() {
+    await this.setJsonRpcRecords(this.values), this.events.emit(x.sync);
+  }
+  async restore() {
+    try {
+      const e = await this.getJsonRpcRecords();
+      if (typeof e > "u" || !e.length) return;
+      if (this.records.size) {
+        const { message: t } = d("RESTORE_WILL_OVERRIDE", this.name);
+        throw this.logger.error(t), new Error(t);
+      }
+      this.cached = e, this.logger.debug(`Successfully Restored records for ${this.name}`), this.logger.trace({ type: "method", method: "restore", records: this.values });
+    } catch (e) {
+      this.logger.debug(`Failed to Restore records for ${this.name}`), this.logger.error(e);
+    }
+  }
+  registerEventListeners() {
+    this.events.on(x.created, (e) => {
+      const t = x.created;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, record: e });
+    }), this.events.on(x.updated, (e) => {
+      const t = x.updated;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, record: e });
+    }), this.events.on(x.deleted, (e) => {
+      const t = x.deleted;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, record: e });
+    }), this.core.heartbeat.on(X.pulse, () => {
+      this.cleanup();
+    });
+  }
+  cleanup() {
+    try {
+      this.isInitialized();
+      let e = !1;
+      this.records.forEach((t) => {
+        l.toMiliseconds(t.expiry || 0) - Date.now() <= 0 && (this.logger.info(`Deleting expired history log: ${t.id}`), this.records.delete(t.id), this.events.emit(x.deleted, t, !1), e = !0);
+      }), e && this.persist();
+    } catch (e) {
+      this.logger.warn(e);
+    }
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+class qr extends St {
+  constructor(e, t) {
+    super(e, t), this.core = e, this.logger = t, this.expirations = /* @__PURE__ */ new Map(), this.events = new B.EventEmitter(), this.name = Bi, this.version = Vi, this.cached = [], this.initialized = !1, this.storagePrefix = D, this.init = async () => {
+      this.initialized || (this.logger.trace("Initialized"), await this.restore(), this.cached.forEach((s) => this.expirations.set(s.target, s)), this.cached = [], this.registerEventListeners(), this.initialized = !0);
+    }, this.has = (s) => {
+      try {
+        const i = this.formatTarget(s);
+        return typeof this.getExpiration(i) < "u";
+      } catch {
+        return !1;
+      }
+    }, this.set = (s, i) => {
+      this.isInitialized();
+      const r = this.formatTarget(s), n = { target: r, expiry: i };
+      this.expirations.set(r, n), this.checkExpiry(r, n), this.events.emit(O.created, { target: r, expiration: n });
+    }, this.get = (s) => {
+      this.isInitialized();
+      const i = this.formatTarget(s);
+      return this.getExpiration(i);
+    }, this.del = (s) => {
+      if (this.isInitialized(), this.has(s)) {
+        const i = this.formatTarget(s), r = this.getExpiration(i);
+        this.expirations.delete(i), this.events.emit(O.deleted, { target: i, expiration: r });
+      }
+    }, this.on = (s, i) => {
+      this.events.on(s, i);
+    }, this.once = (s, i) => {
+      this.events.once(s, i);
+    }, this.off = (s, i) => {
+      this.events.off(s, i);
+    }, this.removeListener = (s, i) => {
+      this.events.removeListener(s, i);
+    }, this.logger = I(t, this.name);
+  }
+  get context() {
+    return S(this.logger);
+  }
+  get storageKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//" + this.name;
+  }
+  get length() {
+    return this.expirations.size;
+  }
+  get keys() {
+    return Array.from(this.expirations.keys());
+  }
+  get values() {
+    return Array.from(this.expirations.values());
+  }
+  formatTarget(e) {
+    if (typeof e == "string") return ri(e);
+    if (typeof e == "number") return ni(e);
+    const { message: t } = d("UNKNOWN_TYPE", `Target type: ${typeof e}`);
+    throw new Error(t);
+  }
+  async setExpirations(e) {
+    await this.core.storage.setItem(this.storageKey, e);
+  }
+  async getExpirations() {
+    return await this.core.storage.getItem(this.storageKey);
+  }
+  async persist() {
+    await this.setExpirations(this.values), this.events.emit(O.sync);
+  }
+  async restore() {
+    try {
+      const e = await this.getExpirations();
+      if (typeof e > "u" || !e.length) return;
+      if (this.expirations.size) {
+        const { message: t } = d("RESTORE_WILL_OVERRIDE", this.name);
+        throw this.logger.error(t), new Error(t);
+      }
+      this.cached = e, this.logger.debug(`Successfully Restored expirations for ${this.name}`), this.logger.trace({ type: "method", method: "restore", expirations: this.values });
+    } catch (e) {
+      this.logger.debug(`Failed to Restore expirations for ${this.name}`), this.logger.error(e);
+    }
+  }
+  getExpiration(e) {
+    const t = this.expirations.get(e);
+    if (!t) {
+      const { message: s } = d("NO_MATCHING_KEY", `${this.name}: ${e}`);
+      throw this.logger.warn(s), new Error(s);
+    }
+    return t;
+  }
+  checkExpiry(e, t) {
+    const { expiry: s } = t;
+    l.toMiliseconds(s) - Date.now() <= 0 && this.expire(e, t);
+  }
+  expire(e, t) {
+    this.expirations.delete(e), this.events.emit(O.expired, { target: e, expiration: t });
+  }
+  checkExpirations() {
+    this.core.relayer.connected && this.expirations.forEach((e, t) => this.checkExpiry(t, e));
+  }
+  registerEventListeners() {
+    this.core.heartbeat.on(X.pulse, () => this.checkExpirations()), this.events.on(O.created, (e) => {
+      const t = O.created;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, data: e }), this.persist();
+    }), this.events.on(O.expired, (e) => {
+      const t = O.expired;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, data: e }), this.persist();
+    }), this.events.on(O.deleted, (e) => {
+      const t = O.deleted;
+      this.logger.info(`Emitting ${t}`), this.logger.debug({ type: "event", event: t, data: e }), this.persist();
+    });
+  }
+  isInitialized() {
+    if (!this.initialized) {
+      const { message: e } = d("NOT_INITIALIZED", this.name);
+      throw new Error(e);
+    }
+  }
+}
+var m = {};
+Object.defineProperty(m, "__esModule", { value: !0 }), m.getLocalStorage = m.getLocalStorageOrThrow = m.getCrypto = m.getCryptoOrThrow = m.getLocation = m.getLocationOrThrow = m.getNavigator = m.getNavigatorOrThrow = bt = m.getDocument = m.getDocumentOrThrow = m.getFromWindowOrThrow = m.getFromWindow = void 0;
+function K(a) {
+  let e;
+  return typeof window < "u" && typeof window[a] < "u" && (e = window[a]), e;
+}
+m.getFromWindow = K;
+function V(a) {
+  const e = K(a);
+  if (!e) throw new Error(`${a} is not defined in Window`);
+  return e;
+}
+m.getFromWindowOrThrow = V;
+function Hr() {
+  return V("document");
+}
+m.getDocumentOrThrow = Hr;
+function Yr() {
+  return K("document");
+}
+var bt = m.getDocument = Yr;
+function Gr() {
+  return V("navigator");
+}
+m.getNavigatorOrThrow = Gr;
+function Jr() {
+  return K("navigator");
+}
+m.getNavigator = Jr;
+function Wr() {
+  return V("location");
+}
+m.getLocationOrThrow = Wr;
+function Xr() {
+  return K("location");
+}
+m.getLocation = Xr;
+function Zr() {
+  return V("crypto");
+}
+m.getCryptoOrThrow = Zr;
+function Qr() {
+  return K("crypto");
+}
+m.getCrypto = Qr;
+function en() {
+  return V("localStorage");
+}
+m.getLocalStorageOrThrow = en;
+function tn() {
+  return K("localStorage");
+}
+m.getLocalStorage = tn;
+class sn extends Rt {
+  constructor(e, t, s) {
+    super(e, t, s), this.core = e, this.logger = t, this.store = s, this.name = ji, this.verifyUrlV3 = Hi, this.storagePrefix = D, this.version = nt, this.init = async () => {
+      var i;
+      this.isDevEnv || (this.publicKey = await this.store.getItem(this.storeKey), this.publicKey && l.toMiliseconds((i = this.publicKey) == null ? void 0 : i.expiresAt) < Date.now() && (this.logger.debug("verify v2 public key expired"), await this.removePublicKey()));
+    }, this.register = async (i) => {
+      if (!ai() || this.isDevEnv) return;
+      const r = window.location.origin, { id: n, decryptedId: o } = i, h = `${this.verifyUrlV3}/attestation?projectId=${this.core.projectId}&origin=${r}&id=${n}&decryptedId=${o}`;
+      try {
+        const c = bt(), g = this.startAbortTimer(l.ONE_SECOND * 5), p = await new Promise((b, _) => {
+          const u = () => {
+            window.removeEventListener("message", E), c.body.removeChild(y), _("attestation aborted");
+          };
+          this.abortController.signal.addEventListener("abort", u);
+          const y = c.createElement("iframe");
+          y.src = h, y.style.display = "none", y.addEventListener("error", u, { signal: this.abortController.signal });
+          const E = (f) => {
+            if (f.data && typeof f.data == "string") try {
+              const w = JSON.parse(f.data);
+              if (w.type === "verify_attestation") {
+                if (fe(w.attestation).payload.id !== n) return;
+                clearInterval(g), c.body.removeChild(y), this.abortController.signal.removeEventListener("abort", u), window.removeEventListener("message", E), b(w.attestation === null ? "" : w.attestation);
+              }
+            } catch (w) {
+              this.logger.warn(w);
+            }
+          };
+          c.body.appendChild(y), window.addEventListener("message", E, { signal: this.abortController.signal });
+        });
+        return this.logger.debug("jwt attestation", p), p;
+      } catch (c) {
+        this.logger.warn(c);
+      }
+      return "";
+    }, this.resolve = async (i) => {
+      if (this.isDevEnv) return "";
+      const { attestationId: r, hash: n, encryptedId: o } = i;
+      if (r === "") {
+        this.logger.debug("resolve: attestationId is empty, skipping");
+        return;
+      }
+      if (r) {
+        if (fe(r).payload.id !== o) return;
+        const c = await this.isValidJwtAttestation(r);
+        if (c) {
+          if (!c.isVerified) {
+            this.logger.warn("resolve: jwt attestation: origin url not verified");
+            return;
+          }
+          return c;
+        }
+      }
+      if (!n) return;
+      const h = this.getVerifyUrl(i == null ? void 0 : i.verifyUrl);
+      return this.fetchAttestation(n, h);
+    }, this.fetchAttestation = async (i, r) => {
+      this.logger.debug(`resolving attestation: ${i} from url: ${r}`);
+      const n = this.startAbortTimer(l.ONE_SECOND * 5), o = await fetch(`${r}/attestation/${i}?v2Supported=true`, { signal: this.abortController.signal });
+      return clearTimeout(n), o.status === 200 ? await o.json() : void 0;
+    }, this.getVerifyUrl = (i) => {
+      let r = i || ee;
+      return Yi.includes(r) || (this.logger.info(`verify url: ${r}, not included in trusted list, assigning default: ${ee}`), r = ee), r;
+    }, this.fetchPublicKey = async () => {
+      try {
+        this.logger.debug(`fetching public key from: ${this.verifyUrlV3}`);
+        const i = this.startAbortTimer(l.FIVE_SECONDS), r = await fetch(`${this.verifyUrlV3}/public-key`, { signal: this.abortController.signal });
+        return clearTimeout(i), await r.json();
+      } catch (i) {
+        this.logger.warn(i);
+      }
+    }, this.persistPublicKey = async (i) => {
+      this.logger.debug("persisting public key to local storage", i), await this.store.setItem(this.storeKey, i), this.publicKey = i;
+    }, this.removePublicKey = async () => {
+      this.logger.debug("removing verify v2 public key from storage"), await this.store.removeItem(this.storeKey), this.publicKey = void 0;
+    }, this.isValidJwtAttestation = async (i) => {
+      const r = await this.getPublicKey();
+      try {
+        if (r) return this.validateAttestation(i, r);
+      } catch (o) {
+        this.logger.error(o), this.logger.warn("error validating attestation");
+      }
+      const n = await this.fetchAndPersistPublicKey();
+      try {
+        if (n) return this.validateAttestation(i, n);
+      } catch (o) {
+        this.logger.error(o), this.logger.warn("error validating attestation");
+      }
+    }, this.getPublicKey = async () => this.publicKey ? this.publicKey : await this.fetchAndPersistPublicKey(), this.fetchAndPersistPublicKey = async () => {
+      if (this.fetchPromise) return await this.fetchPromise, this.publicKey;
+      this.fetchPromise = new Promise(async (r) => {
+        const n = await this.fetchPublicKey();
+        n && (await this.persistPublicKey(n), r(n));
+      });
+      const i = await this.fetchPromise;
+      return this.fetchPromise = void 0, i;
+    }, this.validateAttestation = (i, r) => {
+      const n = oi(i, r.publicKey), o = { hasExpired: l.toMiliseconds(n.exp) < Date.now(), payload: n };
+      if (o.hasExpired) throw this.logger.warn("resolve: jwt attestation expired"), new Error("JWT attestation expired");
+      return { origin: o.payload.origin, isScam: o.payload.isScam, isVerified: o.payload.isVerified };
+    }, this.logger = I(t, this.name), this.abortController = new AbortController(), this.isDevEnv = Je(), this.init();
+  }
+  get storeKey() {
+    return this.storagePrefix + this.version + this.core.customStoragePrefix + "//verify:public:key";
+  }
+  get context() {
+    return S(this.logger);
+  }
+  startAbortTimer(e) {
+    return this.abortController = new AbortController(), setTimeout(() => this.abortController.abort(), l.toMiliseconds(e));
+  }
+}
+class rn extends xt {
+  constructor(e, t) {
+    super(e, t), this.projectId = e, this.logger = t, this.context = Gi, this.registerDeviceToken = async (s) => {
+      const { clientId: i, token: r, notificationType: n, enableEncrypted: o = !1 } = s, h = `${Ji}/${this.projectId}/clients`;
+      await fetch(h, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ client_id: i, type: n, token: r, always_raw: o }) });
+    }, this.logger = I(t, this.context);
+  }
+}
+var nn = Object.defineProperty, Ve = Object.getOwnPropertySymbols, an = Object.prototype.hasOwnProperty, on = Object.prototype.propertyIsEnumerable, je = (a, e, t) => e in a ? nn(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, Y = (a, e) => {
+  for (var t in e || (e = {})) an.call(e, t) && je(a, t, e[t]);
+  if (Ve) for (var t of Ve(e)) on.call(e, t) && je(a, t, e[t]);
+  return a;
+};
+class hn extends Ot {
+  constructor(e, t, s = !0) {
+    super(e, t, s), this.core = e, this.logger = t, this.context = Xi, this.storagePrefix = D, this.storageVersion = Wi, this.events = /* @__PURE__ */ new Map(), this.shouldPersist = !1, this.init = async () => {
+      if (!Je()) try {
+        const i = { eventId: Se(), timestamp: Date.now(), domain: this.getAppDomain(), props: { event: "INIT", type: "", properties: { client_id: await this.core.crypto.getClientId(), user_agent: hi(this.core.relayer.protocol, this.core.relayer.version, le) } } };
+        await this.sendEvent([i]);
+      } catch (i) {
+        this.logger.warn(i);
+      }
+    }, this.createEvent = (i) => {
+      const { event: r = "ERROR", type: n = "", properties: { topic: o, trace: h } } = i, c = Se(), g = this.core.projectId || "", p = Date.now(), b = Y({ eventId: c, timestamp: p, props: { event: r, type: n, properties: { topic: o, trace: h } }, bundleId: g, domain: this.getAppDomain() }, this.setMethods(c));
+      return this.telemetryEnabled && (this.events.set(c, b), this.shouldPersist = !0), b;
+    }, this.getEvent = (i) => {
+      const { eventId: r, topic: n } = i;
+      if (r) return this.events.get(r);
+      const o = Array.from(this.events.values()).find((h) => h.props.properties.topic === n);
+      if (o) return Y(Y({}, o), this.setMethods(o.eventId));
+    }, this.deleteEvent = (i) => {
+      const { eventId: r } = i;
+      this.events.delete(r), this.shouldPersist = !0;
+    }, this.setEventListeners = () => {
+      this.core.heartbeat.on(X.pulse, async () => {
+        this.shouldPersist && await this.persist(), this.events.forEach((i) => {
+          l.fromMiliseconds(Date.now()) - l.fromMiliseconds(i.timestamp) > Zi && (this.events.delete(i.eventId), this.shouldPersist = !0);
+        });
+      });
+    }, this.setMethods = (i) => ({ addTrace: (r) => this.addTrace(i, r), setError: (r) => this.setError(i, r) }), this.addTrace = (i, r) => {
+      const n = this.events.get(i);
+      n && (n.props.properties.trace.push(r), this.events.set(i, n), this.shouldPersist = !0);
+    }, this.setError = (i, r) => {
+      const n = this.events.get(i);
+      n && (n.props.type = r, n.timestamp = Date.now(), this.events.set(i, n), this.shouldPersist = !0);
+    }, this.persist = async () => {
+      await this.core.storage.setItem(this.storageKey, Array.from(this.events.values())), this.shouldPersist = !1;
+    }, this.restore = async () => {
+      try {
+        const i = await this.core.storage.getItem(this.storageKey) || [];
+        if (!i.length) return;
+        i.forEach((r) => {
+          this.events.set(r.eventId, Y(Y({}, r), this.setMethods(r.eventId)));
+        });
+      } catch (i) {
+        this.logger.warn(i);
+      }
+    }, this.submit = async () => {
+      if (!this.telemetryEnabled || this.events.size === 0) return;
+      const i = [];
+      for (const [r, n] of this.events) n.props.type && i.push(n);
+      if (i.length !== 0) try {
+        if ((await this.sendEvent(i)).ok) for (const r of i) this.events.delete(r.eventId), this.shouldPersist = !0;
+      } catch (r) {
+        this.logger.warn(r);
+      }
+    }, this.sendEvent = async (i) => {
+      const r = this.getAppDomain() ? "" : "&sp=desktop";
+      return await fetch(`${Qi}?projectId=${this.core.projectId}&st=events_sdk&sv=js-${le}${r}`, { method: "POST", body: JSON.stringify(i) });
+    }, this.getAppDomain = () => ci().url, this.logger = I(t, this.context), this.telemetryEnabled = s, s ? this.restore().then(async () => {
+      await this.submit(), this.setEventListeners();
+    }) : this.persist();
+  }
+  get storageKey() {
+    return this.storagePrefix + this.storageVersion + this.core.customStoragePrefix + "//" + this.context;
+  }
+}
+var cn = Object.defineProperty, qe = Object.getOwnPropertySymbols, ln = Object.prototype.hasOwnProperty, un = Object.prototype.propertyIsEnumerable, He = (a, e, t) => e in a ? cn(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, Ye = (a, e) => {
+  for (var t in e || (e = {})) ln.call(e, t) && He(a, t, e[t]);
+  if (qe) for (var t of qe(e)) un.call(e, t) && He(a, t, e[t]);
+  return a;
+};
+class pe extends Tt {
+  constructor(e) {
+    var t;
+    super(e), this.protocol = rt, this.version = nt, this.name = ge, this.events = new B.EventEmitter(), this.initialized = !1, this.on = (n, o) => this.events.on(n, o), this.once = (n, o) => this.events.once(n, o), this.off = (n, o) => this.events.off(n, o), this.removeListener = (n, o) => this.events.removeListener(n, o), this.dispatchEnvelope = ({ topic: n, message: o, sessionExists: h }) => {
+      if (!n || !o) return;
+      const c = { topic: n, message: o, publishedAt: Date.now(), transportType: k.link_mode };
+      this.relayer.onLinkMessageEvent(c, { sessionExists: h });
+    }, this.projectId = e == null ? void 0 : e.projectId, this.relayUrl = (e == null ? void 0 : e.relayUrl) || at, this.customStoragePrefix = e != null && e.customStoragePrefix ? `:${e.customStoragePrefix}` : "";
+    const s = Ge({ level: typeof (e == null ? void 0 : e.logger) == "string" && e.logger ? e.logger : bi.logger }), { logger: i, chunkLoggerController: r } = Et({ opts: s, maxSizeInBytes: e == null ? void 0 : e.maxLogBlobSizeInBytes, loggerOverride: e == null ? void 0 : e.logger });
+    this.logChunkController = r, (t = this.logChunkController) != null && t.downloadLogsBlobInBrowser && (window.downloadLogsBlobInBrowser = async () => {
+      var n, o;
+      (n = this.logChunkController) != null && n.downloadLogsBlobInBrowser && ((o = this.logChunkController) == null || o.downloadLogsBlobInBrowser({ clientId: await this.crypto.getClientId() }));
+    }), this.logger = I(i, this.name), this.heartbeat = new wt(), this.crypto = new Tr(this, this.logger, e == null ? void 0 : e.keychain), this.history = new jr(this, this.logger), this.expirer = new qr(this, this.logger), this.storage = e != null && e.storage ? e.storage : new vt(Ye(Ye({}, _i), e == null ? void 0 : e.storageOptions)), this.relayer = new Ur({ core: this, logger: this.logger, relayUrl: this.relayUrl, projectId: this.projectId }), this.pairing = new Vr(this, this.logger), this.verify = new sn(this, this.logger, this.storage), this.echoClient = new rn(this.projectId || "", this.logger), this.linkModeSupportedApps = [], this.eventClient = new hn(this, this.logger, e == null ? void 0 : e.telemetryEnabled);
+  }
+  static async init(e) {
+    const t = new pe(e);
+    await t.initialize();
+    const s = await t.crypto.getClientId();
+    return await t.storage.setItem(Di, s), t;
+  }
+  get context() {
+    return S(this.logger);
+  }
+  async start() {
+    this.initialized || await this.initialize();
+  }
+  async getLogsBlob() {
+    var e;
+    return (e = this.logChunkController) == null ? void 0 : e.logsToBlob({ clientId: await this.crypto.getClientId() });
+  }
+  async addLinkModeSupportedApp(e) {
+    this.linkModeSupportedApps.includes(e) || (this.linkModeSupportedApps.push(e), await this.storage.setItem(xe, this.linkModeSupportedApps));
+  }
+  async initialize() {
+    this.logger.trace("Initialized");
+    try {
+      await this.crypto.init(), await this.history.init(), await this.expirer.init(), await this.relayer.init(), await this.heartbeat.init(), await this.pairing.init(), this.eventClient.init(), this.linkModeSupportedApps = await this.storage.getItem(xe) || [], this.initialized = !0, this.logger.info("Core Initialization Success");
+    } catch (e) {
+      throw this.logger.warn(`Core Initialization Failure at epoch ${Date.now()}`, e), this.logger.error(e.message), e;
+    }
+  }
+}
+const qn = pe;
+export {
+  ge as CORE_CONTEXT,
+  bi as CORE_DEFAULT,
+  rt as CORE_PROTOCOL,
+  _i as CORE_STORAGE_OPTIONS,
+  D as CORE_STORAGE_PREFIX,
+  nt as CORE_VERSION,
+  Re as CRYPTO_CLIENT_SEED,
+  wi as CRYPTO_CONTEXT,
+  vi as CRYPTO_JWT_TTL,
+  qn as Core,
+  Tr as Crypto,
+  Gi as ECHO_CONTEXT,
+  Ji as ECHO_URL,
+  Qi as EVENTS_CLIENT_API_URL,
+  Zi as EVENTS_STORAGE_CLEANUP_INTERVAL,
+  Xi as EVENTS_STORAGE_CONTEXT,
+  Wi as EVENTS_STORAGE_VERSION,
+  jn as EVENT_CLIENT_AUTHENTICATE_ERRORS,
+  Vn as EVENT_CLIENT_AUTHENTICATE_TRACES,
+  U as EVENT_CLIENT_PAIRING_ERRORS,
+  L as EVENT_CLIENT_PAIRING_TRACES,
+  Bn as EVENT_CLIENT_SESSION_ERRORS,
+  $n as EVENT_CLIENT_SESSION_TRACES,
+  Bi as EXPIRER_CONTEXT,
+  O as EXPIRER_EVENTS,
+  Vi as EXPIRER_STORAGE_VERSION,
+  rn as EchoClient,
+  hn as EventClient,
+  qr as Expirer,
+  Ki as HISTORY_CONTEXT,
+  x as HISTORY_EVENTS,
+  $i as HISTORY_STORAGE_VERSION,
+  jr as JsonRpcHistory,
+  Ei as KEYCHAIN_CONTEXT,
+  Ii as KEYCHAIN_STORAGE_VERSION,
+  Ir as KeyChain,
+  Ti as MESSAGES_CONTEXT,
+  Fi as MESSAGES_STORAGE_VERSION,
+  Fr as MessageTracker,
+  Ui as PAIRING_CONTEXT,
+  q as PAIRING_EVENTS,
+  j as PAIRING_RPC_OPTS,
+  ki as PAIRING_STORAGE_VERSION,
+  Mi as PENDING_SUB_RESOLUTION_TIMEOUT,
+  Si as PUBLISHER_CONTEXT,
+  Pi as PUBLISHER_DEFAULT_TTL,
+  Vr as Pairing,
+  Oi as RELAYER_CONTEXT,
+  xi as RELAYER_DEFAULT_LOGGER,
+  Ri as RELAYER_DEFAULT_PROTOCOL,
+  at as RELAYER_DEFAULT_RELAY_URL,
+  T as RELAYER_EVENTS,
+  P as RELAYER_PROVIDER_EVENTS,
+  Ci as RELAYER_RECONNECT_TIMEOUT,
+  le as RELAYER_SDK_VERSION,
+  Ai as RELAYER_SUBSCRIBER_SUFFIX,
+  Ur as Relayer,
+  Ni as STORE_STORAGE_VERSION,
+  zi as SUBSCRIBER_CONTEXT,
+  N as SUBSCRIBER_EVENTS,
+  Li as SUBSCRIBER_STORAGE_VERSION,
+  Br as Store,
+  Nr as Subscriber,
+  k as TRANSPORT_TYPES,
+  Yi as TRUSTED_VERIFY_URLS,
+  ji as VERIFY_CONTEXT,
+  ee as VERIFY_SERVER,
+  Hi as VERIFY_SERVER_V3,
+  sn as Verify,
+  Di as WALLETCONNECT_CLIENT_ID,
+  xe as WALLETCONNECT_LINK_MODE_APPS,
+  pe as default
+};