@multiversx/sdk-dapp-liquidity 0.2.0-alpha.1

package/react-B9sQBOh0.mjs

@@ -0,0 +1,3040 @@
+import { aR as ConstantsUtil, aU as W3mFrameHelpers, aV as W3mFrameSchema, aW as W3mFrameConstants, aX as SECURE_SITE_SDK, aY as SECURE_SITE_SDK_VERSION, aZ as k, a_ as DEFAULT_LOG_LEVEL, a$ as A, b0 as E, b1 as W3mFrameStorage, b2 as W3mFrameRpcConstants, b3 as ConstantsUtil$1, b4 as EnsController, b5 as solanaDevnet, b6 as solana, aO as SIWXUtil, aD as AccountController, aH as OptionsController, aC as CoreHelperUtil, b7 as ConstantsUtil$2, aA as ChainController, b8 as bs58, b9 as StorageUtil, az as ProviderUtil, aI as ModalController, aB as ConnectorController, aE as ConnectionController, ba as BlockchainApiController, aK as AssetUtil, bb as PublicStateController, bc as EventsController, bd as AlertController, aP as ThemeController, s as setColorTheme, a as setThemeVariables, aQ as SnackController, aN as RouterController, be as WalletUtil, aJ as ApiController, bf as getW3mThemeVariables, bg as NetworkUtil, bh as M } from "./index-DSnomXRI.mjs";
+import { b as useAppKitNetworkCore } from "./react-CSQpf1zk.mjs";
+import { http, fallback, toHex } from "viem";
+import "viem/chains";
+import { g as getAppKit } from "./index-BXwpbIDQ.mjs";
+const ParseUtil = {
+  validateCaipAddress(address) {
+    var _a;
+    if (((_a = address.split(":")) == null ? void 0 : _a.length) !== 3) {
+      throw new Error("Invalid CAIP Address");
+    }
+    return address;
+  },
+  parseCaipAddress(caipAddress) {
+    const parts = caipAddress.split(":");
+    if (parts.length !== 3) {
+      throw new Error(`Invalid CAIP-10 address: ${caipAddress}`);
+    }
+    const [chainNamespace, chainId, address] = parts;
+    if (!chainNamespace || !chainId || !address) {
+      throw new Error(`Invalid CAIP-10 address: ${caipAddress}`);
+    }
+    return {
+      chainNamespace,
+      chainId,
+      address
+    };
+  },
+  parseCaipNetworkId(caipNetworkId) {
+    const parts = caipNetworkId.split(":");
+    if (parts.length !== 2) {
+      throw new Error(`Invalid CAIP-2 network id: ${caipNetworkId}`);
+    }
+    const [chainNamespace, chainId] = parts;
+    if (!chainNamespace || !chainId) {
+      throw new Error(`Invalid CAIP-2 network id: ${caipNetworkId}`);
+    }
+    return {
+      chainNamespace,
+      chainId
+    };
+  }
+};
+function shouldHandleEvent(eventKey, data = {}) {
+  var _a;
+  return typeof (data == null ? void 0 : data.type) === "string" && ((_a = data == null ? void 0 : data.type) == null ? void 0 : _a.includes(eventKey));
+}
+class W3mFrame {
+  constructor({ projectId, isAppClient = false, chainId = "eip155:1", enableLogger = true }) {
+    this.iframe = null;
+    this.rpcUrl = ConstantsUtil.BLOCKCHAIN_API_RPC_URL;
+    this.initFrame = () => {
+      const isFrameInitialized = document.getElementById("w3m-iframe");
+      if (this.iframe && !isFrameInitialized) {
+        document.body.appendChild(this.iframe);
+      }
+    };
+    this.events = {
+      registerFrameEventHandler: (id, callback, signal) => {
+        function eventHandler({ data }) {
+          if (!shouldHandleEvent(W3mFrameConstants.FRAME_EVENT_KEY, data)) {
+            return;
+          }
+          const frameEvent = W3mFrameSchema.frameEvent.parse(data);
+          if (frameEvent.id === id) {
+            callback(frameEvent);
+            window.removeEventListener("message", eventHandler);
+          }
+        }
+        if (W3mFrameHelpers.isClient) {
+          window.addEventListener("message", eventHandler);
+          signal.addEventListener("abort", () => {
+            window.removeEventListener("message", eventHandler);
+          });
+        }
+      },
+      onFrameEvent: (callback) => {
+        if (W3mFrameHelpers.isClient) {
+          window.addEventListener("message", ({ data }) => {
+            if (!shouldHandleEvent(W3mFrameConstants.FRAME_EVENT_KEY, data)) {
+              return;
+            }
+            const frameEvent = W3mFrameSchema.frameEvent.parse(data);
+            callback(frameEvent);
+          });
+        }
+      },
+      onAppEvent: (callback) => {
+        if (W3mFrameHelpers.isClient) {
+          window.addEventListener("message", ({ data }) => {
+            if (!shouldHandleEvent(W3mFrameConstants.APP_EVENT_KEY, data)) {
+              return;
+            }
+            const appEvent = W3mFrameSchema.appEvent.parse(data);
+            callback(appEvent);
+          });
+        }
+      },
+      postAppEvent: (event) => {
+        var _a;
+        if (W3mFrameHelpers.isClient) {
+          if (!((_a = this.iframe) == null ? void 0 : _a.contentWindow)) {
+            throw new Error("W3mFrame: iframe is not set");
+          }
+          W3mFrameSchema.appEvent.parse(event);
+          this.iframe.contentWindow.postMessage(event, "*");
+        }
+      },
+      postFrameEvent: (event) => {
+        if (W3mFrameHelpers.isClient) {
+          if (!parent) {
+            throw new Error("W3mFrame: parent is not set");
+          }
+          W3mFrameSchema.frameEvent.parse(event);
+          parent.postMessage(event, "*");
+        }
+      }
+    };
+    this.projectId = projectId;
+    this.frameLoadPromise = new Promise((resolve, reject) => {
+      this.frameLoadPromiseResolver = { resolve, reject };
+    });
+    if (isAppClient) {
+      this.frameLoadPromise = new Promise((resolve, reject) => {
+        this.frameLoadPromiseResolver = { resolve, reject };
+      });
+      if (W3mFrameHelpers.isClient) {
+        const iframe = document.createElement("iframe");
+        iframe.id = "w3m-iframe";
+        iframe.src = `${SECURE_SITE_SDK}?projectId=${projectId}&chainId=${chainId}&version=${SECURE_SITE_SDK_VERSION}&enableLogger=${enableLogger}`;
+        iframe.name = "w3m-secure-iframe";
+        iframe.style.position = "fixed";
+        iframe.style.zIndex = "999999";
+        iframe.style.display = "none";
+        iframe.style.animationDelay = "0s, 50ms";
+        iframe.style.borderBottomLeftRadius = `clamp(0px, var(--wui-border-radius-l), 44px)`;
+        iframe.style.borderBottomRightRadius = `clamp(0px, var(--wui-border-radius-l), 44px)`;
+        this.iframe = iframe;
+        this.iframe.onerror = () => {
+          var _a;
+          (_a = this.frameLoadPromiseResolver) == null ? void 0 : _a.reject("Unable to load email login dependency");
+        };
+        this.events.onFrameEvent((event) => {
+          var _a;
+          if (event.type === "@w3m-frame/READY") {
+            (_a = this.frameLoadPromiseResolver) == null ? void 0 : _a.resolve(void 0);
+          }
+        });
+      }
+    }
+  }
+  get networks() {
+    const data = [
+      "eip155:1",
+      "eip155:5",
+      "eip155:11155111",
+      "eip155:10",
+      "eip155:420",
+      "eip155:42161",
+      "eip155:421613",
+      "eip155:137",
+      "eip155:80001",
+      "eip155:42220",
+      "eip155:1313161554",
+      "eip155:1313161555",
+      "eip155:56",
+      "eip155:97",
+      "eip155:43114",
+      "eip155:43113",
+      "eip155:324",
+      "eip155:280",
+      "eip155:100",
+      "eip155:8453",
+      "eip155:84531",
+      "eip155:84532",
+      "eip155:7777777",
+      "eip155:999",
+      "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+      "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
+      "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+    ].map((id) => ({
+      [id]: {
+        rpcUrl: `${this.rpcUrl}/v1/?chainId=${id}&projectId=${this.projectId}`,
+        chainId: id
+      }
+    }));
+    return Object.assign({}, ...data);
+  }
+}
+class W3mFrameLogger {
+  constructor(projectId) {
+    var _a;
+    const loggerOptions = k({
+      level: DEFAULT_LOG_LEVEL
+    });
+    const { logger, chunkLoggerController } = A({
+      opts: loggerOptions
+    });
+    this.logger = E(logger, this.constructor.name);
+    this.chunkLoggerController = chunkLoggerController;
+    if (typeof window !== "undefined" && ((_a = this.chunkLoggerController) == null ? void 0 : _a.downloadLogsBlobInBrowser)) {
+      if (!window.downloadAppKitLogsBlob) {
+        window.downloadAppKitLogsBlob = {};
+      }
+      window.downloadAppKitLogsBlob["sdk"] = () => {
+        var _a2;
+        if ((_a2 = this.chunkLoggerController) == null ? void 0 : _a2.downloadLogsBlobInBrowser) {
+          this.chunkLoggerController.downloadLogsBlobInBrowser({
+            projectId
+          });
+        }
+      };
+    }
+  }
+}
+class W3mFrameProvider {
+  constructor({ projectId, chainId, enableLogger = true, onTimeout }) {
+    this.openRpcRequests = [];
+    if (enableLogger) {
+      this.w3mLogger = new W3mFrameLogger(projectId);
+    }
+    this.w3mFrame = new W3mFrame({ projectId, isAppClient: true, chainId, enableLogger });
+    this.onTimeout = onTimeout;
+    if (this.getLoginEmailUsed()) {
+      this.w3mFrame.initFrame();
+    }
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_GET_USER_SUCCESS) {
+        this.user = event.payload;
+      }
+    });
+  }
+  getLoginEmailUsed() {
+    return Boolean(W3mFrameStorage.get(W3mFrameConstants.EMAIL_LOGIN_USED_KEY));
+  }
+  getEmail() {
+    return W3mFrameStorage.get(W3mFrameConstants.EMAIL);
+  }
+  getUsername() {
+    return W3mFrameStorage.get(W3mFrameConstants.SOCIAL_USERNAME);
+  }
+  async reload() {
+    var _a;
+    try {
+      this.w3mFrame.initFrame();
+      await this.appEvent({
+        type: W3mFrameConstants.APP_RELOAD
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error reloading iframe");
+      throw error;
+    }
+  }
+  async connectEmail(payload) {
+    var _a;
+    try {
+      W3mFrameHelpers.checkIfAllowedToTriggerEmail();
+      this.w3mFrame.initFrame();
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_CONNECT_EMAIL,
+        payload
+      });
+      this.setNewLastEmailLoginTime();
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting email");
+      throw error;
+    }
+  }
+  async connectDevice() {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_CONNECT_DEVICE
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting device");
+      throw error;
+    }
+  }
+  async connectOtp(payload) {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_CONNECT_OTP,
+        payload
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting otp");
+      throw error;
+    }
+  }
+  async isConnected() {
+    var _a;
+    try {
+      if (!this.getLoginEmailUsed()) {
+        return { isConnected: false };
+      }
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_IS_CONNECTED
+      });
+      if (!response.isConnected) {
+        this.deleteAuthLoginCache();
+      }
+      return response;
+    } catch (error) {
+      this.deleteAuthLoginCache();
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error checking connection");
+      throw error;
+    }
+  }
+  async getChainId() {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_GET_CHAIN_ID
+      });
+      this.setLastUsedChainId(response.chainId);
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error getting chain id");
+      throw error;
+    }
+  }
+  async getSocialRedirectUri(payload) {
+    var _a;
+    try {
+      this.w3mFrame.initFrame();
+      return this.appEvent({
+        type: W3mFrameConstants.APP_GET_SOCIAL_REDIRECT_URI,
+        payload
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error getting social redirect uri");
+      throw error;
+    }
+  }
+  async updateEmail(payload) {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_UPDATE_EMAIL,
+        payload
+      });
+      this.setNewLastEmailLoginTime();
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error updating email");
+      throw error;
+    }
+  }
+  async updateEmailPrimaryOtp(payload) {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_UPDATE_EMAIL_PRIMARY_OTP,
+        payload
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error updating email primary otp");
+      throw error;
+    }
+  }
+  async updateEmailSecondaryOtp(payload) {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_UPDATE_EMAIL_SECONDARY_OTP,
+        payload
+      });
+      this.setLoginSuccess(response.newEmail);
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error updating email secondary otp");
+      throw error;
+    }
+  }
+  async syncTheme(payload) {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_SYNC_THEME,
+        payload
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error syncing theme");
+      throw error;
+    }
+  }
+  async syncDappData(payload) {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_SYNC_DAPP_DATA,
+        payload
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error syncing dapp data");
+      throw error;
+    }
+  }
+  async getSmartAccountEnabledNetworks() {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_GET_SMART_ACCOUNT_ENABLED_NETWORKS
+      });
+      this.persistSmartAccountEnabledNetworks(response.smartAccountEnabledNetworks);
+      return response;
+    } catch (error) {
+      this.persistSmartAccountEnabledNetworks([]);
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error getting smart account enabled networks");
+      throw error;
+    }
+  }
+  async setPreferredAccount(type) {
+    var _a;
+    try {
+      return this.appEvent({
+        type: W3mFrameConstants.APP_SET_PREFERRED_ACCOUNT,
+        payload: { type }
+      });
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error setting preferred account");
+      throw error;
+    }
+  }
+  async connect(payload) {
+    var _a;
+    try {
+      const chainId = (payload == null ? void 0 : payload.chainId) || this.getLastUsedChainId() || 1;
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_GET_USER,
+        payload: { ...payload, chainId }
+      });
+      this.setLoginSuccess(response.email);
+      this.setLastUsedChainId(response.chainId);
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting");
+      throw error;
+    }
+  }
+  async getUser(payload) {
+    var _a;
+    try {
+      const chainId = (payload == null ? void 0 : payload.chainId) || this.getLastUsedChainId() || 1;
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_GET_USER,
+        payload: { ...payload, chainId }
+      });
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting");
+      throw error;
+    }
+  }
+  async connectSocial(uri) {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_CONNECT_SOCIAL,
+        payload: { uri }
+      });
+      if (response.userName) {
+        this.setSocialLoginSuccess(response.userName);
+      }
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting social");
+      throw error;
+    }
+  }
+  async getFarcasterUri() {
+    var _a;
+    try {
+      this.w3mFrame.initFrame();
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_GET_FARCASTER_URI
+      });
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error getting farcaster uri");
+      throw error;
+    }
+  }
+  async connectFarcaster() {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_CONNECT_FARCASTER
+      });
+      if (response.userName) {
+        this.setSocialLoginSuccess(response.userName);
+      }
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error connecting farcaster");
+      throw error;
+    }
+  }
+  async switchNetwork(chainId) {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_SWITCH_NETWORK,
+        payload: { chainId }
+      });
+      this.setLastUsedChainId(response.chainId);
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error switching network");
+      throw error;
+    }
+  }
+  async disconnect() {
+    var _a;
+    try {
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_SIGN_OUT
+      });
+      this.deleteAuthLoginCache();
+      return response;
+    } catch (error) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error }, "Error disconnecting");
+      throw error;
+    }
+  }
+  async request(req) {
+    var _a, _b, _c, _d;
+    try {
+      if (W3mFrameRpcConstants.GET_CHAIN_ID === req.method) {
+        return this.getLastUsedChainId();
+      }
+      (_a = this.rpcRequestHandler) == null ? void 0 : _a.call(this, req);
+      const response = await this.appEvent({
+        type: W3mFrameConstants.APP_RPC_REQUEST,
+        payload: req
+      });
+      (_b = this.rpcSuccessHandler) == null ? void 0 : _b.call(this, response, req);
+      return response;
+    } catch (error) {
+      (_c = this.rpcErrorHandler) == null ? void 0 : _c.call(this, error, req);
+      (_d = this.w3mLogger) == null ? void 0 : _d.logger.error({ error }, "Error requesting");
+      throw error;
+    }
+  }
+  onRpcRequest(callback) {
+    this.rpcRequestHandler = callback;
+  }
+  onRpcSuccess(callback) {
+    this.rpcSuccessHandler = callback;
+  }
+  onRpcError(callback) {
+    this.rpcErrorHandler = callback;
+  }
+  onIsConnected(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_IS_CONNECTED_SUCCESS && event.payload.isConnected) {
+        callback();
+      }
+    });
+  }
+  onNotConnected(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_IS_CONNECTED_ERROR) {
+        callback();
+      }
+      if (event.type === W3mFrameConstants.FRAME_IS_CONNECTED_SUCCESS && !event.payload.isConnected) {
+        callback();
+      }
+    });
+  }
+  onConnect(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_GET_USER_SUCCESS) {
+        callback(event.payload);
+      }
+    });
+  }
+  onSocialConnected(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_CONNECT_SOCIAL_SUCCESS) {
+        callback(event.payload);
+      }
+    });
+  }
+  async getCapabilities() {
+    try {
+      const capabilities = await this.request({
+        method: "wallet_getCapabilities"
+      });
+      return capabilities || {};
+    } catch {
+      return {};
+    }
+  }
+  onSetPreferredAccount(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_SET_PREFERRED_ACCOUNT_SUCCESS) {
+        callback(event.payload);
+      } else if (event.type === W3mFrameConstants.FRAME_SET_PREFERRED_ACCOUNT_ERROR) {
+        callback({ type: W3mFrameRpcConstants.ACCOUNT_TYPES.EOA });
+      }
+    });
+  }
+  onGetSmartAccountEnabledNetworks(callback) {
+    this.w3mFrame.events.onFrameEvent((event) => {
+      if (event.type === W3mFrameConstants.FRAME_GET_SMART_ACCOUNT_ENABLED_NETWORKS_SUCCESS) {
+        callback(event.payload.smartAccountEnabledNetworks);
+      } else if (event.type === W3mFrameConstants.FRAME_GET_SMART_ACCOUNT_ENABLED_NETWORKS_ERROR) {
+        callback([]);
+      }
+    });
+  }
+  getAvailableChainIds() {
+    return Object.keys(this.w3mFrame.networks);
+  }
+  rejectRpcRequests() {
+    var _a;
+    try {
+      this.openRpcRequests.forEach(({ abortController, method }) => {
+        if (!W3mFrameRpcConstants.SAFE_RPC_METHODS.includes(method)) {
+          abortController.abort();
+        }
+      });
+      this.openRpcRequests = [];
+    } catch (e) {
+      (_a = this.w3mLogger) == null ? void 0 : _a.logger.error({ error: e }, "Error aborting RPC request");
+    }
+  }
+  async appEvent(event) {
+    await this.w3mFrame.frameLoadPromise;
+    let timer = void 0;
+    function replaceEventType(type2) {
+      return type2.replace("@w3m-app/", "");
+    }
+    const abortController = new AbortController();
+    const type = replaceEventType(event.type);
+    const shouldCheckForTimeout = [
+      W3mFrameConstants.APP_CONNECT_EMAIL,
+      W3mFrameConstants.APP_CONNECT_DEVICE,
+      W3mFrameConstants.APP_CONNECT_OTP,
+      W3mFrameConstants.APP_CONNECT_SOCIAL,
+      W3mFrameConstants.APP_GET_SOCIAL_REDIRECT_URI
+    ].map(replaceEventType).includes(type);
+    if (shouldCheckForTimeout) {
+      timer = setTimeout(() => {
+        var _a;
+        (_a = this.onTimeout) == null ? void 0 : _a.call(this);
+        abortController.abort();
+      }, 3e4);
+    }
+    return new Promise((resolve, reject) => {
+      var _a, _b, _c;
+      const id = Math.random().toString(36).substring(7);
+      (_c = (_a = this.w3mLogger) == null ? void 0 : (_b = _a.logger).info) == null ? void 0 : _c.call(_b, { event, id }, "Sending app event");
+      this.w3mFrame.events.postAppEvent({ ...event, id });
+      if (type === "RPC_REQUEST") {
+        const rpcEvent = event;
+        this.openRpcRequests = [...this.openRpcRequests, { ...rpcEvent.payload, abortController }];
+      }
+      abortController.signal.addEventListener("abort", () => {
+        if (type === "RPC_REQUEST") {
+          reject(new Error("Request was aborted"));
+        } else if (type !== "GET_FARCASTER_URI") {
+          reject(new Error("Something went wrong"));
+        }
+      });
+      function handler(framEvent, logger) {
+        var _a2, _b2, _c2;
+        if (framEvent.id !== id) {
+          return;
+        }
+        (_b2 = logger == null ? void 0 : (_a2 = logger.logger).info) == null ? void 0 : _b2.call(_a2, { framEvent, id }, "Received frame response");
+        if (framEvent.type === `@w3m-frame/${type}_SUCCESS`) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          if ("payload" in framEvent) {
+            resolve(framEvent.payload);
+          }
+          resolve(void 0);
+        } else if (framEvent.type === `@w3m-frame/${type}_ERROR`) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          if ("payload" in framEvent) {
+            reject(new Error(((_c2 = framEvent.payload) == null ? void 0 : _c2.message) || "An error occurred"));
+          }
+          reject(new Error("An error occurred"));
+        }
+      }
+      this.w3mFrame.events.registerFrameEventHandler(id, (frameEvent) => handler(frameEvent, this.w3mLogger), abortController.signal);
+    });
+  }
+  setNewLastEmailLoginTime() {
+    W3mFrameStorage.set(W3mFrameConstants.LAST_EMAIL_LOGIN_TIME, Date.now().toString());
+  }
+  setSocialLoginSuccess(username) {
+    W3mFrameStorage.set(W3mFrameConstants.SOCIAL_USERNAME, username);
+  }
+  setLoginSuccess(email) {
+    if (email) {
+      W3mFrameStorage.set(W3mFrameConstants.EMAIL, email);
+    }
+    W3mFrameStorage.set(W3mFrameConstants.EMAIL_LOGIN_USED_KEY, "true");
+    W3mFrameStorage.delete(W3mFrameConstants.LAST_EMAIL_LOGIN_TIME);
+  }
+  deleteAuthLoginCache() {
+    W3mFrameStorage.delete(W3mFrameConstants.EMAIL_LOGIN_USED_KEY);
+    W3mFrameStorage.delete(W3mFrameConstants.EMAIL);
+    W3mFrameStorage.delete(W3mFrameConstants.LAST_USED_CHAIN_KEY);
+    W3mFrameStorage.delete(W3mFrameConstants.SOCIAL_USERNAME);
+  }
+  setLastUsedChainId(chainId) {
+    if (chainId) {
+      W3mFrameStorage.set(W3mFrameConstants.LAST_USED_CHAIN_KEY, String(chainId));
+    }
+  }
+  getLastUsedChainId() {
+    const chainId = W3mFrameStorage.get(W3mFrameConstants.LAST_USED_CHAIN_KEY) ?? void 0;
+    const numberChainId = Number(chainId);
+    return isNaN(numberChainId) ? chainId : numberChainId;
+  }
+  persistSmartAccountEnabledNetworks(networks) {
+    W3mFrameStorage.set(W3mFrameConstants.SMART_ACCOUNT_ENABLED_NETWORKS, networks.join(","));
+  }
+}
+const PresetsUtil = {
+  NetworkImageIds: {
+    1: "ba0ba0cd-17c6-4806-ad93-f9d174f17900",
+    42161: "3bff954d-5cb0-47a0-9a23-d20192e74600",
+    43114: "30c46e53-e989-45fb-4549-be3bd4eb3b00",
+    56: "93564157-2e8e-4ce7-81df-b264dbee9b00",
+    250: "06b26297-fe0c-4733-5d6b-ffa5498aac00",
+    10: "ab9c186a-c52f-464b-2906-ca59d760a400",
+    137: "41d04d42-da3b-4453-8506-668cc0727900",
+    100: "02b53f6a-e3d4-479e-1cb4-21178987d100",
+    9001: "f926ff41-260d-4028-635e-91913fc28e00",
+    324: "b310f07f-4ef7-49f3-7073-2a0a39685800",
+    314: "5a73b3dd-af74-424e-cae0-0de859ee9400",
+    4689: "34e68754-e536-40da-c153-6ef2e7188a00",
+    1088: "3897a66d-40b9-4833-162f-a2c90531c900",
+    1284: "161038da-44ae-4ec7-1208-0ea569454b00",
+    1285: "f1d73bb6-5450-4e18-38f7-fb6484264a00",
+    7777777: "845c60df-d429-4991-e687-91ae45791600",
+    42220: "ab781bbc-ccc6-418d-d32d-789b15da1f00",
+    8453: "7289c336-3981-4081-c5f4-efc26ac64a00",
+    1313161554: "3ff73439-a619-4894-9262-4470c773a100",
+    2020: "b8101fc0-9c19-4b6f-ec65-f6dfff106e00",
+    2021: "b8101fc0-9c19-4b6f-ec65-f6dfff106e00",
+    "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": "a1b58899-f671-4276-6a5e-56ca5bd59700",
+    "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z": "a1b58899-f671-4276-6a5e-56ca5bd59700",
+    EtWTRABZaYq6iMfeYKouRu166VU2xqa1: "a1b58899-f671-4276-6a5e-56ca5bd59700",
+    "000000000019d6689c085ae165831e93": "21c895fa-e105-4829-9434-378bb54fa600",
+    "000000000933ea01ad0ee984209779ba": "220bcb01-ba47-41d3-fe5b-e29bbc4a4b00"
+  },
+  ConnectorImageIds: {
+    [ConstantsUtil.CONNECTOR_ID.COINBASE]: "0c2840c3-5b04-4c44-9661-fbd4b49e1800",
+    [ConstantsUtil.CONNECTOR_ID.COINBASE_SDK]: "0c2840c3-5b04-4c44-9661-fbd4b49e1800",
+    [ConstantsUtil.CONNECTOR_ID.SAFE]: "461db637-8616-43ce-035a-d89b8a1d5800",
+    [ConstantsUtil.CONNECTOR_ID.LEDGER]: "54a1aa77-d202-4f8d-0fb2-5d2bb6db0300",
+    [ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT]: "ef1a1fcf-7fe8-4d69-bd6d-fda1345b4400",
+    [ConstantsUtil.CONNECTOR_ID.INJECTED]: "07ba87ed-43aa-4adf-4540-9e6a2b9cae00"
+  },
+  ConnectorNamesMap: {
+    [ConstantsUtil.CONNECTOR_ID.INJECTED]: "Browser Wallet",
+    [ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT]: "WalletConnect",
+    [ConstantsUtil.CONNECTOR_ID.COINBASE]: "Coinbase",
+    [ConstantsUtil.CONNECTOR_ID.COINBASE_SDK]: "Coinbase",
+    [ConstantsUtil.CONNECTOR_ID.LEDGER]: "Ledger",
+    [ConstantsUtil.CONNECTOR_ID.SAFE]: "Safe"
+  }
+};
+const HelpersUtil = {
+  getCaipTokens(tokens) {
+    if (!tokens) {
+      return void 0;
+    }
+    const caipTokens = {};
+    Object.entries(tokens).forEach(([id, token]) => {
+      caipTokens[`${ConstantsUtil$1.EIP155}:${id}`] = token;
+    });
+    return caipTokens;
+  },
+  isLowerCaseMatch(str1, str2) {
+    return (str1 == null ? void 0 : str1.toLowerCase()) === (str2 == null ? void 0 : str2.toLowerCase());
+  }
+};
+const ErrorUtil = {
+  UniversalProviderErrors: {
+    UNAUTHORIZED_DOMAIN_NOT_ALLOWED: {
+      message: "Unauthorized: origin not allowed",
+      alertErrorKey: "INVALID_APP_CONFIGURATION"
+    },
+    JWT_VALIDATION_ERROR: {
+      message: "JWT validation error: JWT Token is not yet valid",
+      alertErrorKey: "JWT_TOKEN_NOT_VALID"
+    },
+    INVALID_KEY: {
+      message: "Unauthorized: invalid key",
+      alertErrorKey: "INVALID_PROJECT_ID"
+    }
+  },
+  ALERT_ERRORS: {
+    SWITCH_NETWORK_NOT_FOUND: {
+      shortMessage: "Network Not Found",
+      longMessage: "Network not found - please make sure it is included in 'networks' array in createAppKit function"
+    },
+    INVALID_APP_CONFIGURATION: {
+      shortMessage: "Invalid App Configuration",
+      longMessage: () => `Origin ${isSafe() ? window.origin : "unknown"} not found on Allowlist - update configuration on cloud.reown.com`
+    },
+    SOCIALS_TIMEOUT: {
+      shortMessage: "Invalid App Configuration",
+      longMessage: () => "There was an issue loading the embedded wallet. Please verify that your domain is allowed at cloud.reown.com"
+    },
+    JWT_TOKEN_NOT_VALID: {
+      shortMessage: "Session Expired",
+      longMessage: "Invalid session found on UniversalProvider - please check your time settings and connect again"
+    },
+    INVALID_PROJECT_ID: {
+      shortMessage: "Invalid App Configuration",
+      longMessage: "Invalid Project ID - update configuration"
+    },
+    PROJECT_ID_NOT_CONFIGURED: {
+      shortMessage: "Project ID Not Configured",
+      longMessage: "Project ID Not Configured - update configuration on cloud.reown.com"
+    }
+  }
+};
+function isSafe() {
+  return typeof window !== "undefined";
+}
+const LoggerUtil = {
+  createLogger(onError, level = "error") {
+    const loggerOptions = k({
+      level
+    });
+    const { logger } = A({
+      opts: loggerOptions
+    });
+    logger.error = (...args) => {
+      for (const arg of args) {
+        if (arg instanceof Error) {
+          onError(arg, ...args);
+          return;
+        }
+      }
+      onError(void 0, ...args);
+    };
+    return logger;
+  }
+};
+const RPC_URL_HOST = "rpc.walletconnect.org";
+function getBlockchainApiRpcUrl(caipNetworkId, projectId) {
+  const url = new URL("https://rpc.walletconnect.org/v1/");
+  url.searchParams.set("chainId", caipNetworkId);
+  url.searchParams.set("projectId", projectId);
+  return url.toString();
+}
+const WC_HTTP_RPC_SUPPORTED_CHAINS = [
+  "near:mainnet",
+  "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "eip155:1101",
+  "eip155:56",
+  "eip155:42161",
+  "eip155:7777777",
+  "eip155:59144",
+  "eip155:324",
+  "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  "eip155:5000",
+  "solana:4sgjmw1sunhzsxgspuhpqldx6wiyjntz",
+  "eip155:80084",
+  "eip155:5003",
+  "eip155:100",
+  "eip155:8453",
+  "eip155:42220",
+  "eip155:1313161555",
+  "eip155:17000",
+  "eip155:1",
+  "eip155:300",
+  "eip155:1313161554",
+  "eip155:1329",
+  "eip155:84532",
+  "eip155:421614",
+  "eip155:11155111",
+  "eip155:8217",
+  "eip155:43114",
+  "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
+  "eip155:999999999",
+  "eip155:11155420",
+  "eip155:80002",
+  "eip155:97",
+  "eip155:43113",
+  "eip155:137",
+  "eip155:10",
+  "eip155:1301",
+  "bip122:000000000019d6689c085ae165831e93",
+  "bip122:000000000933ea01ad0ee984209779ba"
+];
+const CaipNetworksUtil = {
+  extendRpcUrlWithProjectId(rpcUrl, projectId) {
+    let isReownUrl = false;
+    try {
+      const url = new URL(rpcUrl);
+      isReownUrl = url.host === RPC_URL_HOST;
+    } catch (e) {
+      isReownUrl = false;
+    }
+    if (isReownUrl) {
+      const url = new URL(rpcUrl);
+      if (!url.searchParams.has("projectId")) {
+        url.searchParams.set("projectId", projectId);
+      }
+      return url.toString();
+    }
+    return rpcUrl;
+  },
+  isCaipNetwork(network) {
+    return "chainNamespace" in network && "caipNetworkId" in network;
+  },
+  getChainNamespace(network) {
+    if (this.isCaipNetwork(network)) {
+      return network.chainNamespace;
+    }
+    return ConstantsUtil.CHAIN.EVM;
+  },
+  getCaipNetworkId(network) {
+    if (this.isCaipNetwork(network)) {
+      return network.caipNetworkId;
+    }
+    return `${ConstantsUtil.CHAIN.EVM}:${network.id}`;
+  },
+  getDefaultRpcUrl(caipNetwork, caipNetworkId, projectId) {
+    var _a, _b, _c;
+    const defaultRpcUrl = (_c = (_b = (_a = caipNetwork.rpcUrls) == null ? void 0 : _a.default) == null ? void 0 : _b.http) == null ? void 0 : _c[0];
+    if (WC_HTTP_RPC_SUPPORTED_CHAINS.includes(caipNetworkId)) {
+      return getBlockchainApiRpcUrl(caipNetworkId, projectId);
+    }
+    return defaultRpcUrl || "";
+  },
+  extendCaipNetwork(caipNetwork, { customNetworkImageUrls, projectId, customRpc }) {
+    var _a, _b, _c, _d;
+    const caipNetworkId = this.getCaipNetworkId(caipNetwork);
+    const chainNamespace = this.getChainNamespace(caipNetwork);
+    const chainDefaultUrl = (_c = (_b = (_a = caipNetwork == null ? void 0 : caipNetwork.rpcUrls) == null ? void 0 : _a["chainDefault"]) == null ? void 0 : _b.http) == null ? void 0 : _c[0];
+    let rpcUrl = "";
+    if (customRpc) {
+      rpcUrl = ((_d = caipNetwork.rpcUrls.default.http) == null ? void 0 : _d[0]) || "";
+    } else {
+      rpcUrl = this.getDefaultRpcUrl(caipNetwork, caipNetworkId, projectId);
+    }
+    return {
+      ...caipNetwork,
+      chainNamespace,
+      caipNetworkId,
+      assets: {
+        imageId: PresetsUtil.NetworkImageIds[caipNetwork.id],
+        imageUrl: customNetworkImageUrls == null ? void 0 : customNetworkImageUrls[caipNetwork.id]
+      },
+      rpcUrls: {
+        ...caipNetwork.rpcUrls,
+        default: {
+          http: [rpcUrl]
+        },
+        chainDefault: {
+          http: [chainDefaultUrl || caipNetwork.rpcUrls.default.http[0] || ""]
+        }
+      }
+    };
+  },
+  extendCaipNetworks(caipNetworks, { customNetworkImageUrls, projectId, customRpcChainIds }) {
+    return caipNetworks.map((caipNetwork) => CaipNetworksUtil.extendCaipNetwork(caipNetwork, {
+      customNetworkImageUrls,
+      projectId,
+      customRpc: customRpcChainIds == null ? void 0 : customRpcChainIds.includes(caipNetwork.id)
+    }));
+  },
+  getViemTransport(caipNetwork) {
+    var _a;
+    const defaultRpcUrl = (_a = caipNetwork.rpcUrls.default.http) == null ? void 0 : _a[0];
+    if (!WC_HTTP_RPC_SUPPORTED_CHAINS.includes(caipNetwork.caipNetworkId)) {
+      return http(defaultRpcUrl);
+    }
+    return fallback([
+      http(defaultRpcUrl, {
+        fetchOptions: {
+          headers: {
+            "Content-Type": "text/plain"
+          }
+        }
+      }),
+      http(defaultRpcUrl)
+    ]);
+  }
+};
+class W3mFrameProviderSingleton {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- This is a singleton
+  constructor() {
+  }
+  static getInstance({ projectId, chainId, enableLogger, onTimeout }) {
+    if (!W3mFrameProviderSingleton.instance) {
+      W3mFrameProviderSingleton.instance = new W3mFrameProvider({
+        projectId,
+        chainId,
+        enableLogger,
+        onTimeout
+      });
+    }
+    return W3mFrameProviderSingleton.instance;
+  }
+}
+const WcConstantsUtil = {
+  ERROR_CODE_UNRECOGNIZED_CHAIN_ID: 4902,
+  ERROR_CODE_DEFAULT: 5e3
+};
+const WcHelpersUtil = {
+  getMethodsByChainNamespace(chainNamespace) {
+    switch (chainNamespace) {
+      case "solana":
+        return [
+          "solana_signMessage",
+          "solana_signTransaction",
+          "solana_requestAccounts",
+          "solana_getAccounts",
+          "solana_signAllTransactions",
+          "solana_signAndSendTransaction"
+        ];
+      case "eip155":
+        return [
+          "personal_sign",
+          "eth_sign",
+          "eth_signTransaction",
+          "eth_signTypedData",
+          "eth_signTypedData_v3",
+          "eth_signTypedData_v4",
+          "eth_sendRawTransaction",
+          "eth_sendTransaction",
+          "wallet_getCapabilities",
+          "wallet_sendCalls",
+          "wallet_showCallsStatus",
+          "wallet_getCallsStatus",
+          "wallet_grantPermissions",
+          "wallet_revokePermissions",
+          "wallet_switchEthereumChain",
+          //EIP-7811
+          "wallet_getAssets"
+        ];
+      case "bip122":
+        return ["sendTransfer", "signMessage", "signPsbt", "getAccountAddresses"];
+      default:
+        return [];
+    }
+  },
+  createNamespaces(caipNetworks) {
+    return caipNetworks.reduce((acc, chain) => {
+      const { id, chainNamespace, rpcUrls } = chain;
+      const rpcUrl = rpcUrls.default.http[0];
+      const methods = this.getMethodsByChainNamespace(chainNamespace);
+      if (!acc[chainNamespace]) {
+        acc[chainNamespace] = {
+          methods,
+          events: ["accountsChanged", "chainChanged"],
+          chains: [],
+          rpcMap: {}
+        };
+      }
+      const caipNetworkId = `${chainNamespace}:${id}`;
+      const namespace = acc[chainNamespace];
+      namespace.chains.push(caipNetworkId);
+      switch (caipNetworkId) {
+        case solana.caipNetworkId:
+          namespace.chains.push(solana.deprecatedCaipNetworkId);
+          break;
+        case solanaDevnet.caipNetworkId:
+          namespace.chains.push(solanaDevnet.deprecatedCaipNetworkId);
+          break;
+      }
+      if ((namespace == null ? void 0 : namespace.rpcMap) && rpcUrl) {
+        namespace.rpcMap[id] = rpcUrl;
+      }
+      return acc;
+    }, {});
+  },
+  resolveReownName: async (name) => {
+    var _a;
+    const wcNameAddress = await EnsController.resolveName(name);
+    const networkNameAddresses = Object.values(wcNameAddress == null ? void 0 : wcNameAddress.addresses) || [];
+    return ((_a = networkNameAddresses[0]) == null ? void 0 : _a.address) || false;
+  },
+  getChainsFromNamespaces(namespaces = {}) {
+    return Object.values(namespaces).flatMap((namespace) => {
+      const chains = namespace.chains || [];
+      const accountsChains = namespace.accounts.map((account) => {
+        const [chainNamespace, chainId] = account.split(":");
+        return `${chainNamespace}:${chainId}`;
+      });
+      return Array.from(/* @__PURE__ */ new Set([...chains, ...accountsChains]));
+    });
+  },
+  isSessionEventData(data) {
+    return typeof data === "object" && data !== null && "id" in data && "topic" in data && "params" in data && typeof data.params === "object" && data.params !== null && "chainId" in data.params && "event" in data.params && typeof data.params.event === "object" && data.params.event !== null;
+  }
+};
+class WalletConnectConnector {
+  constructor({ provider, caipNetworks, namespace }) {
+    this.id = ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
+    this.name = PresetsUtil.ConnectorNamesMap[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
+    this.type = "WALLET_CONNECT";
+    this.imageId = PresetsUtil.ConnectorImageIds[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
+    this.caipNetworks = caipNetworks;
+    this.provider = provider;
+    this.chain = namespace;
+  }
+  get chains() {
+    return this.caipNetworks;
+  }
+  async connectWalletConnect() {
+    const isAuthenticated = await this.authenticate();
+    if (!isAuthenticated) {
+      await this.provider.connect({
+        optionalNamespaces: WcHelpersUtil.createNamespaces(this.caipNetworks)
+      });
+    }
+    return {
+      clientId: await this.provider.client.core.crypto.getClientId(),
+      session: this.provider.session
+    };
+  }
+  async disconnect() {
+    await this.provider.disconnect();
+  }
+  async authenticate() {
+    const chains = this.chains.map((network) => network.caipNetworkId);
+    return SIWXUtil.universalProviderAuthenticate({
+      universalProvider: this.provider,
+      chains,
+      methods: OPTIONAL_METHODS
+    });
+  }
+}
+const OPTIONAL_METHODS = [
+  "eth_accounts",
+  "eth_requestAccounts",
+  "eth_sendRawTransaction",
+  "eth_sign",
+  "eth_signTransaction",
+  "eth_signTypedData",
+  "eth_signTypedData_v3",
+  "eth_signTypedData_v4",
+  "eth_sendTransaction",
+  "personal_sign",
+  "wallet_switchEthereumChain",
+  "wallet_addEthereumChain",
+  "wallet_getPermissions",
+  "wallet_requestPermissions",
+  "wallet_registerOnboarding",
+  "wallet_watchAsset",
+  "wallet_scanQRCode",
+  // EIP-5792
+  "wallet_getCallsStatus",
+  "wallet_sendCalls",
+  "wallet_getCapabilities",
+  // EIP-7715
+  "wallet_grantPermissions",
+  "wallet_revokePermissions",
+  //EIP-7811
+  "wallet_getAssets"
+];
+class AdapterBlueprint {
+  /**
+   * Creates an instance of AdapterBlueprint.
+   * @param {AdapterBlueprint.Params} params - The parameters for initializing the adapter
+   */
+  constructor(params) {
+    this.availableConnectors = [];
+    this.eventListeners = /* @__PURE__ */ new Map();
+    if (params) {
+      this.construct(params);
+    }
+  }
+  /**
+   * Initializes the adapter with the given parameters.
+   * @param {AdapterBlueprint.Params} params - The parameters for initializing the adapter
+   */
+  construct(params) {
+    this.caipNetworks = params.networks;
+    this.projectId = params.projectId;
+    this.namespace = params.namespace;
+  }
+  /**
+   * Gets the available connectors.
+   * @returns {Connector[]} An array of available connectors
+   */
+  get connectors() {
+    return this.availableConnectors;
+  }
+  /**
+   * Gets the supported networks.
+   * @returns {CaipNetwork[]} An array of supported networks
+   */
+  get networks() {
+    return this.caipNetworks || [];
+  }
+  /**
+   * Sets the auth provider.
+   * @param {W3mFrameProvider} authProvider - The auth provider instance
+   */
+  setAuthProvider(authProvider) {
+    this.addConnector({
+      id: ConstantsUtil.CONNECTOR_ID.AUTH,
+      type: "AUTH",
+      name: ConstantsUtil.CONNECTOR_NAMES.AUTH,
+      provider: authProvider,
+      imageId: PresetsUtil.ConnectorImageIds[ConstantsUtil.CONNECTOR_ID.AUTH],
+      chain: this.namespace,
+      chains: []
+    });
+  }
+  /**
+   * Adds one or more connectors to the available connectors list.
+   * @param {...Connector} connectors - The connectors to add
+   */
+  addConnector(...connectors) {
+    const connectorsAdded = /* @__PURE__ */ new Set();
+    this.availableConnectors = [...connectors, ...this.availableConnectors].filter((connector) => {
+      if (connectorsAdded.has(connector.id)) {
+        return false;
+      }
+      connectorsAdded.add(connector.id);
+      return true;
+    });
+    this.emit("connectors", this.availableConnectors);
+  }
+  setStatus(status, chainNamespace) {
+    AccountController.setStatus(status, chainNamespace);
+  }
+  /**
+   * Adds an event listener for a specific event.
+   * @template T
+   * @param {T} eventName - The name of the event
+   * @param {EventCallback<T>} callback - The callback function to be called when the event is emitted
+   */
+  on(eventName, callback) {
+    var _a;
+    if (!this.eventListeners.has(eventName)) {
+      this.eventListeners.set(eventName, /* @__PURE__ */ new Set());
+    }
+    (_a = this.eventListeners.get(eventName)) == null ? void 0 : _a.add(callback);
+  }
+  /**
+   * Removes an event listener for a specific event.
+   * @template T
+   * @param {T} eventName - The name of the event
+   * @param {EventCallback<T>} callback - The callback function to be removed
+   */
+  off(eventName, callback) {
+    const listeners = this.eventListeners.get(eventName);
+    if (listeners) {
+      listeners.delete(callback);
+    }
+  }
+  /**
+   * Removes all event listeners.
+   */
+  removeAllEventListeners() {
+    this.eventListeners.forEach((listeners) => {
+      listeners.clear();
+    });
+  }
+  /**
+   * Emits an event with the given name and optional data.
+   * @template T
+   * @param {T} eventName - The name of the event to emit
+   * @param {EventData[T]} [data] - The optional data to be passed to the event listeners
+   */
+  emit(eventName, data) {
+    const listeners = this.eventListeners.get(eventName);
+    if (listeners) {
+      listeners.forEach((callback) => callback(data));
+    }
+  }
+  /**
+   * Connects to WalletConnect.
+   * @param {number | string} [_chainId] - Optional chain ID to connect to
+   */
+  async connectWalletConnect(_chainId) {
+    const connector = this.getWalletConnectConnector();
+    const result = await connector.connectWalletConnect();
+    return { clientId: result.clientId };
+  }
+  /**
+   * Switches the network.
+   * @param {AdapterBlueprint.SwitchNetworkParams} params - Network switching parameters
+   */
+  async switchNetwork(params) {
+    const { caipNetwork, providerType } = params;
+    if (!params.provider) {
+      return;
+    }
+    const provider = "provider" in params.provider ? params.provider.provider : params.provider;
+    if (providerType === "WALLET_CONNECT") {
+      provider.setDefaultChain(caipNetwork.caipNetworkId);
+      return;
+    }
+    if (provider && providerType === "AUTH") {
+      const authProvider = provider;
+      await authProvider.switchNetwork(caipNetwork.caipNetworkId);
+      const user = await authProvider.getUser({
+        chainId: caipNetwork.caipNetworkId,
+        preferredAccountType: OptionsController.state.defaultAccountTypes[caipNetwork.chainNamespace]
+      });
+      this.emit("switchNetwork", user);
+    }
+  }
+  getWalletConnectConnector() {
+    const connector = this.connectors.find((c) => c instanceof WalletConnectConnector);
+    if (!connector) {
+      throw new Error("WalletConnectConnector not found");
+    }
+    return connector;
+  }
+}
+class UniversalAdapter extends AdapterBlueprint {
+  setUniversalProvider(universalProvider) {
+    this.addConnector(new WalletConnectConnector({
+      provider: universalProvider,
+      caipNetworks: this.caipNetworks || [],
+      namespace: this.namespace
+    }));
+  }
+  async connect(params) {
+    return Promise.resolve({
+      id: "WALLET_CONNECT",
+      type: "WALLET_CONNECT",
+      chainId: Number(params.chainId),
+      provider: this.provider,
+      address: ""
+    });
+  }
+  async disconnect() {
+    try {
+      const connector = this.getWalletConnectConnector();
+      await connector.disconnect();
+    } catch (error) {
+      console.warn("UniversalAdapter:disconnect - error", error);
+    }
+  }
+  async getAccounts({ namespace }) {
+    var _a, _b, _c, _d;
+    const provider = this.provider;
+    const addresses = ((_d = (_c = (_b = (_a = provider == null ? void 0 : provider.session) == null ? void 0 : _a.namespaces) == null ? void 0 : _b[namespace]) == null ? void 0 : _c.accounts) == null ? void 0 : _d.map((account) => {
+      const [, , address] = account.split(":");
+      return address;
+    }).filter((address, index, self) => self.indexOf(address) === index)) || [];
+    return Promise.resolve({
+      accounts: addresses.map((address) => CoreHelperUtil.createAccount(namespace, address, namespace === "bip122" ? "payment" : "eoa"))
+    });
+  }
+  async syncConnectors() {
+    return Promise.resolve();
+  }
+  async getBalance(params) {
+    var _a, _b, _c, _d, _e;
+    const isBalanceSupported = params.caipNetwork && ConstantsUtil$2.BALANCE_SUPPORTED_CHAINS.includes((_a = params.caipNetwork) == null ? void 0 : _a.chainNamespace);
+    if (!isBalanceSupported || ((_b = params.caipNetwork) == null ? void 0 : _b.testnet)) {
+      return {
+        balance: "0.00",
+        symbol: ((_c = params.caipNetwork) == null ? void 0 : _c.nativeCurrency.symbol) || ""
+      };
+    }
+    if (AccountController.state.balanceLoading && params.chainId === ((_d = ChainController.state.activeCaipNetwork) == null ? void 0 : _d.id)) {
+      return {
+        balance: AccountController.state.balance || "0.00",
+        symbol: AccountController.state.balanceSymbol || ""
+      };
+    }
+    const balances = await AccountController.fetchTokenBalance();
+    const balance = balances.find((b) => {
+      var _a2, _b2;
+      return b.chainId === `${(_a2 = params.caipNetwork) == null ? void 0 : _a2.chainNamespace}:${params.chainId}` && b.symbol === ((_b2 = params.caipNetwork) == null ? void 0 : _b2.nativeCurrency.symbol);
+    });
+    return {
+      balance: (balance == null ? void 0 : balance.quantity.numeric) || "0.00",
+      symbol: (balance == null ? void 0 : balance.symbol) || ((_e = params.caipNetwork) == null ? void 0 : _e.nativeCurrency.symbol) || ""
+    };
+  }
+  async signMessage(params) {
+    var _a, _b, _c;
+    const { provider, message, address } = params;
+    if (!provider) {
+      throw new Error("UniversalAdapter:signMessage - provider is undefined");
+    }
+    let signature = "";
+    if (((_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.chainNamespace) === ConstantsUtil.CHAIN.SOLANA) {
+      const response = await provider.request({
+        method: "solana_signMessage",
+        params: {
+          message: bs58.encode(new TextEncoder().encode(message)),
+          pubkey: address
+        }
+      }, (_b = ChainController.state.activeCaipNetwork) == null ? void 0 : _b.caipNetworkId);
+      signature = response.signature;
+    } else {
+      signature = await provider.request({
+        method: "personal_sign",
+        params: [message, address]
+      }, (_c = ChainController.state.activeCaipNetwork) == null ? void 0 : _c.caipNetworkId);
+    }
+    return { signature };
+  }
+  // -- Transaction methods ---------------------------------------------------
+  /**
+   *
+   * These methods are supported only on `wagmi` and `ethers` since the Solana SDK does not support them in the same way.
+   * These function definition is to have a type parity between the clients. Currently not in use.
+   */
+  async estimateGas() {
+    return Promise.resolve({
+      gas: BigInt(0)
+    });
+  }
+  async getProfile() {
+    return Promise.resolve({
+      profileImage: "",
+      profileName: ""
+    });
+  }
+  async sendTransaction() {
+    return Promise.resolve({
+      hash: ""
+    });
+  }
+  async writeContract() {
+    return Promise.resolve({
+      hash: ""
+    });
+  }
+  async getEnsAddress() {
+    return Promise.resolve({
+      address: false
+    });
+  }
+  parseUnits() {
+    return 0n;
+  }
+  formatUnits() {
+    return "0";
+  }
+  async getCapabilities() {
+    return Promise.resolve({});
+  }
+  async grantPermissions() {
+    return Promise.resolve({});
+  }
+  async revokePermissions() {
+    return Promise.resolve("0x");
+  }
+  async syncConnection() {
+    return Promise.resolve({
+      id: "WALLET_CONNECT",
+      type: "WALLET_CONNECT",
+      chainId: 1,
+      provider: this.provider,
+      address: ""
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async switchNetwork(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { caipNetwork } = params;
+    const connector = this.getWalletConnectConnector();
+    if (caipNetwork.chainNamespace === ConstantsUtil.CHAIN.EVM) {
+      try {
+        await ((_a = connector.provider) == null ? void 0 : _a.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: toHex(caipNetwork.id) }]
+        }));
+      } catch (switchError) {
+        if (switchError.code === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID || switchError.code === WcConstantsUtil.ERROR_CODE_DEFAULT || ((_c = (_b = switchError == null ? void 0 : switchError.data) == null ? void 0 : _b.originalError) == null ? void 0 : _c.code) === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID) {
+          try {
+            await ((_f = connector.provider) == null ? void 0 : _f.request({
+              method: "wallet_addEthereumChain",
+              params: [
+                {
+                  chainId: toHex(caipNetwork.id),
+                  rpcUrls: [(_d = caipNetwork == null ? void 0 : caipNetwork.rpcUrls["chainDefault"]) == null ? void 0 : _d.http],
+                  chainName: caipNetwork.name,
+                  nativeCurrency: caipNetwork.nativeCurrency,
+                  blockExplorerUrls: [(_e = caipNetwork.blockExplorers) == null ? void 0 : _e.default.url]
+                }
+              ]
+            }));
+          } catch (error) {
+            throw new Error("Chain is not supported");
+          }
+        }
+      }
+    }
+    connector.provider.setDefaultChain(caipNetwork.caipNetworkId);
+  }
+  getWalletConnectProvider() {
+    const connector = this.connectors.find((c) => c.type === "WALLET_CONNECT");
+    const provider = connector == null ? void 0 : connector.provider;
+    return provider;
+  }
+}
+let isInitialized = false;
+class AppKit {
+  constructor(options) {
+    var _a;
+    this.chainNamespaces = [];
+    this.initPromise = void 0;
+    this.reportedAlertErrors = {};
+    this.setStatus = (status, chain) => {
+      StorageUtil.setConnectionStatus(status);
+      AccountController.setStatus(status, chain);
+    };
+    this.getIsConnectedState = () => Boolean(ChainController.state.activeCaipAddress);
+    this.setAllAccounts = (addresses, chain) => {
+      AccountController.setAllAccounts(addresses, chain);
+      OptionsController.setHasMultipleAddresses((addresses == null ? void 0 : addresses.length) > 1);
+    };
+    this.addAddressLabel = (address, label, chain) => {
+      AccountController.addAddressLabel(address, label, chain);
+    };
+    this.removeAddressLabel = (address, chain) => {
+      AccountController.removeAddressLabel(address, chain);
+    };
+    this.getCaipAddress = (chainNamespace) => {
+      if (ChainController.state.activeChain === chainNamespace || !chainNamespace) {
+        return ChainController.state.activeCaipAddress;
+      }
+      return ChainController.getAccountProp("caipAddress", chainNamespace);
+    };
+    this.getAddressByChainNamespace = (chainNamespace) => ChainController.getAccountProp("address", chainNamespace);
+    this.getAddress = (chainNamespace) => {
+      if (ChainController.state.activeChain === chainNamespace || !chainNamespace) {
+        return AccountController.state.address;
+      }
+      return ChainController.getAccountProp("address", chainNamespace);
+    };
+    this.getProvider = (namespace) => ProviderUtil.getProvider(namespace);
+    this.getProviderType = (namespace) => ProviderUtil.state.providerIds[namespace];
+    this.getPreferredAccountType = () => AccountController.state.preferredAccountType;
+    this.setCaipAddress = (caipAddress, chain) => {
+      AccountController.setCaipAddress(caipAddress, chain);
+    };
+    this.setBalance = (balance, balanceSymbol, chain) => {
+      AccountController.setBalance(balance, balanceSymbol, chain);
+    };
+    this.setProfileName = (profileName, chain) => {
+      AccountController.setProfileName(profileName, chain);
+    };
+    this.setProfileImage = (profileImage, chain) => {
+      AccountController.setProfileImage(profileImage, chain);
+    };
+    this.setUser = (user) => {
+      AccountController.setUser(user);
+      if (OptionsController.state.enableEmbedded) {
+        ModalController.close();
+      }
+    };
+    this.resetAccount = (chain) => {
+      AccountController.resetAccount(chain);
+    };
+    this.setCaipNetwork = (caipNetwork) => {
+      ChainController.setActiveCaipNetwork(caipNetwork);
+    };
+    this.getCaipNetwork = (chainNamespace) => {
+      var _a2;
+      if (chainNamespace) {
+        return (_a2 = ChainController.getRequestedCaipNetworks(chainNamespace).filter((c) => c.chainNamespace === chainNamespace)) == null ? void 0 : _a2[0];
+      }
+      return ChainController.state.activeCaipNetwork || this.defaultCaipNetwork;
+    };
+    this.getCaipNetworkId = () => {
+      const network = this.getCaipNetwork();
+      if (network) {
+        return network.id;
+      }
+      return void 0;
+    };
+    this.getCaipNetworks = (namespace) => ChainController.getRequestedCaipNetworks(namespace);
+    this.getActiveChainNamespace = () => ChainController.state.activeChain;
+    this.setRequestedCaipNetworks = (requestedCaipNetworks, chain) => {
+      ChainController.setRequestedCaipNetworks(requestedCaipNetworks, chain);
+    };
+    this.getApprovedCaipNetworkIds = () => ChainController.getAllApprovedCaipNetworkIds();
+    this.setApprovedCaipNetworksData = (namespace) => ChainController.setApprovedCaipNetworksData(namespace);
+    this.resetNetwork = (namespace) => {
+      ChainController.resetNetwork(namespace);
+    };
+    this.setConnectors = (connectors) => {
+      const allConnectors = [...ConnectorController.getConnectors(), ...connectors];
+      ConnectorController.setConnectors(allConnectors);
+    };
+    this.addConnector = (connector) => {
+      ConnectorController.addConnector(connector);
+    };
+    this.getConnectors = () => ConnectorController.getConnectors();
+    this.resetWcConnection = () => {
+      ConnectionController.resetWcConnection();
+    };
+    this.fetchIdentity = (request) => BlockchainApiController.fetchIdentity(request);
+    this.setAddressExplorerUrl = (addressExplorerUrl, chain) => {
+      AccountController.setAddressExplorerUrl(addressExplorerUrl, chain);
+    };
+    this.setSmartAccountDeployed = (isDeployed, chain) => {
+      AccountController.setSmartAccountDeployed(isDeployed, chain);
+    };
+    this.setConnectedWalletInfo = (connectedWalletInfo, chain) => {
+      AccountController.setConnectedWalletInfo(connectedWalletInfo, chain);
+    };
+    this.setSmartAccountEnabledNetworks = (smartAccountEnabledNetworks, chain) => {
+      ChainController.setSmartAccountEnabledNetworks(smartAccountEnabledNetworks, chain);
+    };
+    this.setPreferredAccountType = (preferredAccountType, chain) => {
+      AccountController.setPreferredAccountType(preferredAccountType, chain);
+    };
+    this.getReownName = (address) => EnsController.getNamesForAddress(address);
+    this.setEIP6963Enabled = (enabled) => {
+      OptionsController.setEIP6963Enabled(enabled);
+    };
+    this.setClientId = (clientId) => {
+      BlockchainApiController.setClientId(clientId);
+    };
+    this.getConnectorImage = (connector) => AssetUtil.getConnectorImage(connector);
+    this.handleUnsafeRPCRequest = () => {
+      if (this.isOpen()) {
+        if (this.isTransactionStackEmpty()) {
+          return;
+        }
+        this.redirect("ApproveTransaction");
+      } else {
+        this.open({ view: "ApproveTransaction" });
+      }
+    };
+    this.options = options;
+    this.version = options.sdkVersion;
+    this.caipNetworks = this.extendCaipNetworks(options);
+    this.chainNamespaces = [
+      ...new Set((_a = this.caipNetworks) == null ? void 0 : _a.map((caipNetwork) => caipNetwork.chainNamespace))
+    ];
+    this.defaultCaipNetwork = this.extendDefaultCaipNetwork(options);
+    this.chainAdapters = this.createAdapters(options.adapters);
+    this.initialize(options);
+    this.sendInitializeEvent(options);
+  }
+  static getInstance() {
+    return this.instance;
+  }
+  async initialize(options) {
+    this.initControllers(options);
+    await this.initChainAdapters();
+    await this.injectModalUi();
+    await this.syncExistingConnection();
+    PublicStateController.set({ initialized: true });
+  }
+  sendInitializeEvent(options) {
+    var _a;
+    const { ...optionsCopy } = options;
+    delete optionsCopy.adapters;
+    EventsController.sendEvent({
+      type: "track",
+      event: "INITIALIZE",
+      properties: {
+        ...optionsCopy,
+        networks: options.networks.map((n) => n.id),
+        siweConfig: {
+          options: ((_a = options.siweConfig) == null ? void 0 : _a.options) || {}
+        }
+      }
+    });
+  }
+  // -- Public -------------------------------------------------------------------
+  async open(options) {
+    await this.injectModalUi();
+    if ((options == null ? void 0 : options.uri) && this.universalProvider) {
+      ConnectionController.setUri(options.uri);
+    }
+    if (options == null ? void 0 : options.namespace) {
+      ConnectorController.setFilterByNamespace(options.namespace);
+    }
+    await ModalController.open(options);
+  }
+  async close() {
+    await this.injectModalUi();
+    ModalController.close();
+  }
+  setLoading(loading) {
+    ModalController.setLoading(loading);
+  }
+  // -- Adapter Methods ----------------------------------------------------------
+  getError() {
+    return "";
+  }
+  getChainId() {
+    var _a;
+    return (_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.id;
+  }
+  switchNetwork(appKitNetwork) {
+    var _a;
+    const network = (_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.id === appKitNetwork.id);
+    if (!network) {
+      AlertController.open(ErrorUtil.ALERT_ERRORS.SWITCH_NETWORK_NOT_FOUND, "error");
+      return;
+    }
+    ChainController.switchActiveNetwork(network);
+  }
+  getWalletProvider() {
+    return ChainController.state.activeChain ? ProviderUtil.state.providers[ChainController.state.activeChain] : null;
+  }
+  getWalletProviderType() {
+    return ChainController.state.activeChain ? ProviderUtil.state.providerIds[ChainController.state.activeChain] : null;
+  }
+  subscribeProviders(callback) {
+    return ProviderUtil.subscribeProviders(callback);
+  }
+  getThemeMode() {
+    return ThemeController.state.themeMode;
+  }
+  getThemeVariables() {
+    return ThemeController.state.themeVariables;
+  }
+  setThemeMode(themeMode) {
+    ThemeController.setThemeMode(themeMode);
+    setColorTheme(ThemeController.state.themeMode);
+  }
+  setTermsConditionsUrl(termsConditionsUrl) {
+    OptionsController.setTermsConditionsUrl(termsConditionsUrl);
+  }
+  setPrivacyPolicyUrl(privacyPolicyUrl) {
+    OptionsController.setPrivacyPolicyUrl(privacyPolicyUrl);
+  }
+  setThemeVariables(themeVariables) {
+    ThemeController.setThemeVariables(themeVariables);
+    setThemeVariables(ThemeController.state.themeVariables);
+  }
+  subscribeTheme(callback) {
+    return ThemeController.subscribe(callback);
+  }
+  getWalletInfo() {
+    return AccountController.state.connectedWalletInfo;
+  }
+  subscribeAccount(callback) {
+    function updateVal() {
+      const authConnector = ConnectorController.getAuthConnector();
+      callback({
+        allAccounts: AccountController.state.allAccounts,
+        caipAddress: ChainController.state.activeCaipAddress,
+        address: CoreHelperUtil.getPlainAddress(ChainController.state.activeCaipAddress),
+        isConnected: Boolean(ChainController.state.activeCaipAddress),
+        status: AccountController.state.status,
+        embeddedWalletInfo: authConnector ? {
+          user: AccountController.state.user,
+          authProvider: AccountController.state.socialProvider || "email",
+          accountType: AccountController.state.preferredAccountType,
+          isSmartAccountDeployed: Boolean(AccountController.state.smartAccountDeployed)
+        } : void 0
+      });
+    }
+    ChainController.subscribe(updateVal);
+    AccountController.subscribe(updateVal);
+    ConnectorController.subscribe(updateVal);
+  }
+  subscribeNetwork(callback) {
+    return ChainController.subscribe(({ activeCaipNetwork }) => {
+      callback({
+        caipNetwork: activeCaipNetwork,
+        chainId: activeCaipNetwork == null ? void 0 : activeCaipNetwork.id,
+        caipNetworkId: activeCaipNetwork == null ? void 0 : activeCaipNetwork.caipNetworkId
+      });
+    });
+  }
+  subscribeWalletInfo(callback) {
+    return AccountController.subscribeKey("connectedWalletInfo", callback);
+  }
+  subscribeShouldUpdateToAddress(callback) {
+    AccountController.subscribeKey("shouldUpdateToAddress", callback);
+  }
+  subscribeCaipNetworkChange(callback) {
+    ChainController.subscribeKey("activeCaipNetwork", callback);
+  }
+  getState() {
+    return PublicStateController.state;
+  }
+  subscribeState(callback) {
+    return PublicStateController.subscribe(callback);
+  }
+  showErrorMessage(message) {
+    SnackController.showError(message);
+  }
+  showSuccessMessage(message) {
+    SnackController.showSuccess(message);
+  }
+  getEvent() {
+    return { ...EventsController.state };
+  }
+  subscribeEvents(callback) {
+    return EventsController.subscribe(callback);
+  }
+  replace(route) {
+    RouterController.replace(route);
+  }
+  redirect(route) {
+    RouterController.push(route);
+  }
+  popTransactionStack(cancel) {
+    RouterController.popTransactionStack(cancel);
+  }
+  isOpen() {
+    return ModalController.state.open;
+  }
+  isTransactionStackEmpty() {
+    return RouterController.state.transactionStack.length === 0;
+  }
+  updateFeatures(newFeatures) {
+    OptionsController.setFeatures(newFeatures);
+  }
+  updateOptions(newOptions) {
+    const currentOptions = OptionsController.state || {};
+    const updatedOptions = { ...currentOptions, ...newOptions };
+    OptionsController.setOptions(updatedOptions);
+  }
+  setConnectMethodsOrder(connectMethodsOrder) {
+    OptionsController.setConnectMethodsOrder(connectMethodsOrder);
+  }
+  setWalletFeaturesOrder(walletFeaturesOrder) {
+    OptionsController.setWalletFeaturesOrder(walletFeaturesOrder);
+  }
+  setCollapseWallets(collapseWallets) {
+    OptionsController.setCollapseWallets(collapseWallets);
+  }
+  setSocialsOrder(socialsOrder) {
+    OptionsController.setSocialsOrder(socialsOrder);
+  }
+  async disconnect() {
+    await ConnectionController.disconnect();
+  }
+  getConnectMethodsOrder() {
+    return WalletUtil.getConnectOrderMethod(OptionsController.state.features, ConnectorController.getConnectors());
+  }
+  /**
+   * Removes an adapter from the AppKit.
+   * @param namespace - The namespace of the adapter to remove.
+   */
+  removeAdapter(namespace) {
+    var _a;
+    const isConnected = this.getIsConnectedState();
+    const adapter = this.getAdapter(namespace);
+    if (!adapter || !this.chainAdapters || isConnected) {
+      return;
+    }
+    const newCaipNetworks = (_a = this.caipNetworks) == null ? void 0 : _a.filter((network) => network.chainNamespace !== namespace);
+    ChainController.removeAdapter(namespace);
+    ConnectorController.removeAdapter(namespace);
+    this.chainNamespaces = this.chainNamespaces.filter((n) => n !== namespace);
+    this.caipNetworks = newCaipNetworks;
+    adapter.removeAllEventListeners();
+    Reflect.deleteProperty(this.chainAdapters, namespace);
+  }
+  /**
+   * Adds an adapter to the AppKit.
+   * @param adapter - The adapter instance.
+   * @param networks - The list of networks that this adapter supports / uses.
+   */
+  addAdapter(adapter, networks) {
+    const namespace = adapter.namespace;
+    if (!this.connectionControllerClient || !this.networkControllerClient) {
+      return;
+    }
+    if (!this.chainAdapters || !namespace) {
+      return;
+    }
+    const extendedAdapterNetworks = this.extendCaipNetworks({ ...this.options, networks });
+    this.caipNetworks = [...this.caipNetworks || [], ...extendedAdapterNetworks];
+    this.createAdapter(adapter);
+    this.initChainAdapter(namespace);
+    ChainController.addAdapter(adapter, {
+      connectionControllerClient: this.connectionControllerClient,
+      networkControllerClient: this.networkControllerClient
+    }, extendedAdapterNetworks);
+  }
+  /**
+   * Adds a network to an existing adapter in AppKit.
+   * @param namespace - The chain namespace to add the network to (e.g. 'eip155', 'solana')
+   * @param network - The network configuration to add
+   * @throws Error if adapter for namespace doesn't exist
+   */
+  addNetwork(namespace, network) {
+    var _a;
+    if (this.chainAdapters && !this.chainAdapters[namespace]) {
+      throw new Error(`Adapter for namespace ${namespace} doesn't exist`);
+    }
+    const extendedNetwork = this.extendCaipNetwork(network, this.options);
+    if (this.caipNetworks && !((_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.id === extendedNetwork.id))) {
+      this.caipNetworks.push(extendedNetwork);
+      ChainController.addNetwork(extendedNetwork);
+    }
+  }
+  /**
+   * Removes a network from an existing adapter in AppKit.
+   * @param namespace - The chain namespace the network belongs to
+   * @param networkId - The network ID to remove
+   * @throws Error if adapter for namespace doesn't exist or if removing last network
+   */
+  removeNetwork(namespace, networkId) {
+    var _a;
+    if (this.chainAdapters && !this.chainAdapters[namespace]) {
+      throw new Error(`Adapter for namespace ${namespace} doesn't exist`);
+    }
+    const networkToRemove = (_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.id === networkId);
+    if (!networkToRemove) {
+      throw new Error(`Network with ID ${networkId} not found`);
+    }
+    if (!this.caipNetworks) {
+      return;
+    }
+    const remainingAllNetworks = this.caipNetworks.filter((n) => n.id !== networkId);
+    const remainingNamespaceNetworks = this.caipNetworks.filter((n) => n.id !== networkId && n.chainNamespace === namespace);
+    if (!(remainingNamespaceNetworks == null ? void 0 : remainingNamespaceNetworks.length)) {
+      throw new Error("Cannot remove last network for a namespace");
+    }
+    ChainController.removeNetwork(namespace, networkId);
+    this.caipNetworks = [...remainingAllNetworks];
+  }
+  // -- Private ------------------------------------------------------------------
+  initializeOptionsController(options) {
+    var _a;
+    OptionsController.setDebug(options.debug !== false);
+    if (!options.projectId) {
+      AlertController.open(ErrorUtil.ALERT_ERRORS.PROJECT_ID_NOT_CONFIGURED, "error");
+      return;
+    }
+    OptionsController.setEnableWalletConnect(options.enableWalletConnect !== false);
+    OptionsController.setEnableWalletGuide(options.enableWalletGuide !== false);
+    OptionsController.setEnableWallets(options.enableWallets !== false);
+    OptionsController.setEIP6963Enabled(options.enableEIP6963 !== false);
+    OptionsController.setEnableAuthLogger(options.enableAuthLogger !== false);
+    OptionsController.setSdkVersion(options.sdkVersion);
+    OptionsController.setProjectId(options.projectId);
+    OptionsController.setEnableEmbedded(options.enableEmbedded);
+    OptionsController.setAllWallets(options.allWallets);
+    OptionsController.setIncludeWalletIds(options.includeWalletIds);
+    OptionsController.setExcludeWalletIds(options.excludeWalletIds);
+    OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
+    OptionsController.setTokens(options.tokens);
+    OptionsController.setTermsConditionsUrl(options.termsConditionsUrl);
+    OptionsController.setPrivacyPolicyUrl(options.privacyPolicyUrl);
+    OptionsController.setCustomWallets(options.customWallets);
+    OptionsController.setFeatures(options.features);
+    OptionsController.setAllowUnsupportedChain(options.allowUnsupportedChain);
+    OptionsController.setDefaultAccountTypes(options.defaultAccountTypes);
+    const defaultMetaData = this.getDefaultMetaData();
+    if (!options.metadata && defaultMetaData) {
+      options.metadata = defaultMetaData;
+    }
+    OptionsController.setMetadata(options.metadata);
+    OptionsController.setDisableAppend(options.disableAppend);
+    OptionsController.setEnableEmbedded(options.enableEmbedded);
+    OptionsController.setSIWX(options.siwx);
+    const evmAdapter = (_a = options.adapters) == null ? void 0 : _a.find((adapter) => adapter.namespace === ConstantsUtil.CHAIN.EVM);
+    if (evmAdapter) {
+      if (options.siweConfig) {
+        if (options.siwx) {
+          throw new Error("Cannot set both `siweConfig` and `siwx` options");
+        }
+        OptionsController.setSIWX(options.siweConfig.mapToSIWX());
+      }
+    }
+  }
+  initializeThemeController(options) {
+    if (options.themeMode) {
+      ThemeController.setThemeMode(options.themeMode);
+    }
+    if (options.themeVariables) {
+      ThemeController.setThemeVariables(options.themeVariables);
+    }
+  }
+  initializeChainController(options) {
+    if (!this.connectionControllerClient || !this.networkControllerClient) {
+      throw new Error("ConnectionControllerClient and NetworkControllerClient must be set");
+    }
+    ChainController.initialize(options.adapters ?? [], this.caipNetworks, {
+      connectionControllerClient: this.connectionControllerClient,
+      networkControllerClient: this.networkControllerClient
+    });
+    const network = this.getDefaultNetwork();
+    if (network) {
+      ChainController.setActiveCaipNetwork(network);
+    }
+  }
+  async initializeBlockchainApiController(options) {
+    await BlockchainApiController.getSupportedNetworks({
+      projectId: options.projectId
+    });
+  }
+  initControllers(options) {
+    this.initializeOptionsController(options);
+    this.initializeChainController(options);
+    this.initializeThemeController(options);
+    this.initializeBlockchainApiController(options);
+    if (options.excludeWalletIds) {
+      ApiController.initializeExcludedWalletRdns({ ids: options.excludeWalletIds });
+    }
+  }
+  getDefaultMetaData() {
+    var _a, _b, _c, _d;
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      return {
+        name: ((_b = (_a = document.getElementsByTagName("title")) == null ? void 0 : _a[0]) == null ? void 0 : _b.textContent) || "",
+        description: ((_c = document.querySelector('meta[property="og:description"]')) == null ? void 0 : _c.content) || "",
+        url: window.location.origin,
+        icons: [((_d = document.querySelector('link[rel~="icon"]')) == null ? void 0 : _d.href) || ""]
+      };
+    }
+    return null;
+  }
+  setUnsupportedNetwork(chainId) {
+    const namespace = this.getActiveChainNamespace();
+    if (namespace) {
+      const unsupportedNetwork = this.getUnsupportedNetwork(`${namespace}:${chainId}`);
+      ChainController.setActiveCaipNetwork(unsupportedNetwork);
+    }
+  }
+  extendCaipNetwork(network, options) {
+    const extendedNetwork = CaipNetworksUtil.extendCaipNetwork(network, {
+      customNetworkImageUrls: options.chainImages,
+      projectId: options.projectId
+    });
+    return extendedNetwork;
+  }
+  extendCaipNetworks(options) {
+    const extendedNetworks = CaipNetworksUtil.extendCaipNetworks(options.networks, {
+      customNetworkImageUrls: options.chainImages,
+      projectId: options.projectId
+    });
+    return extendedNetworks;
+  }
+  extendDefaultCaipNetwork(options) {
+    const defaultNetwork = options.networks.find((n) => {
+      var _a;
+      return n.id === ((_a = options.defaultNetwork) == null ? void 0 : _a.id);
+    });
+    const extendedNetwork = defaultNetwork ? CaipNetworksUtil.extendCaipNetwork(defaultNetwork, {
+      customNetworkImageUrls: options.chainImages,
+      projectId: options.projectId
+    }) : void 0;
+    return extendedNetwork;
+  }
+  createClients() {
+    this.connectionControllerClient = {
+      connectWalletConnect: async () => {
+        var _a;
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        if (!adapter) {
+          throw new Error("Adapter not found");
+        }
+        const result = await adapter.connectWalletConnect((_a = this.getCaipNetwork()) == null ? void 0 : _a.id);
+        this.close();
+        this.setClientId((result == null ? void 0 : result.clientId) || null);
+        StorageUtil.setConnectedNamespaces([...ChainController.state.chains.keys()]);
+        await this.syncWalletConnectAccount();
+      },
+      connectExternal: async ({ id, info, type, provider, chain, caipNetwork }) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+        const activeChain = ChainController.state.activeChain;
+        const chainToUse = chain || activeChain;
+        const adapter = this.getAdapter(chainToUse);
+        if (chain && chain !== activeChain && !caipNetwork) {
+          const toConnectNetwork = (_a = this.caipNetworks) == null ? void 0 : _a.find((network) => network.chainNamespace === chain);
+          if (toConnectNetwork) {
+            this.setCaipNetwork(toConnectNetwork);
+          }
+        }
+        if (!adapter) {
+          throw new Error("Adapter not found");
+        }
+        const res = await adapter.connect({
+          id,
+          info,
+          type,
+          provider,
+          chainId: (caipNetwork == null ? void 0 : caipNetwork.id) || ((_b = this.getCaipNetwork()) == null ? void 0 : _b.id),
+          rpcUrl: ((_e = (_d = (_c = caipNetwork == null ? void 0 : caipNetwork.rpcUrls) == null ? void 0 : _c.default) == null ? void 0 : _d.http) == null ? void 0 : _e[0]) || ((_i = (_h = (_g = (_f = this.getCaipNetwork()) == null ? void 0 : _f.rpcUrls) == null ? void 0 : _g.default) == null ? void 0 : _h.http) == null ? void 0 : _i[0])
+        });
+        if (!res) {
+          return;
+        }
+        StorageUtil.addConnectedNamespace(chainToUse);
+        this.syncProvider({ ...res, chainNamespace: chainToUse });
+        await this.syncAccount({ ...res, chainNamespace: chainToUse });
+        const { accounts } = await adapter.getAccounts({ namespace: chainToUse, id });
+        this.setAllAccounts(accounts, chainToUse);
+      },
+      reconnectExternal: async ({ id, info, type, provider }) => {
+        var _a;
+        const namespace = ChainController.state.activeChain;
+        const adapter = this.getAdapter(namespace);
+        if (adapter == null ? void 0 : adapter.reconnect) {
+          await (adapter == null ? void 0 : adapter.reconnect({ id, info, type, provider, chainId: (_a = this.getCaipNetwork()) == null ? void 0 : _a.id }));
+          StorageUtil.addConnectedNamespace(namespace);
+        }
+      },
+      disconnect: async () => {
+        const namespace = ChainController.state.activeChain;
+        const adapter = this.getAdapter(namespace);
+        const provider = ProviderUtil.getProvider(namespace);
+        const providerType = ProviderUtil.state.providerIds[namespace];
+        await (adapter == null ? void 0 : adapter.disconnect({ provider, providerType }));
+        StorageUtil.removeConnectedNamespace(namespace);
+        ProviderUtil.resetChain(namespace);
+        this.setUser(void 0);
+        this.setStatus("disconnected", namespace);
+      },
+      checkInstalled: (ids) => {
+        if (!ids) {
+          return Boolean(window.ethereum);
+        }
+        return ids.some((id) => {
+          var _a;
+          return Boolean((_a = window.ethereum) == null ? void 0 : _a[String(id)]);
+        });
+      },
+      signMessage: async (message) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        const result = await (adapter == null ? void 0 : adapter.signMessage({
+          message,
+          address: AccountController.state.address,
+          provider: ProviderUtil.getProvider(ChainController.state.activeChain)
+        }));
+        return (result == null ? void 0 : result.signature) || "";
+      },
+      sendTransaction: async (args) => {
+        if (args.chainNamespace === ConstantsUtil.CHAIN.EVM) {
+          const adapter = this.getAdapter(ChainController.state.activeChain);
+          const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
+          const result = await (adapter == null ? void 0 : adapter.sendTransaction({ ...args, provider }));
+          return (result == null ? void 0 : result.hash) || "";
+        }
+        return "";
+      },
+      estimateGas: async (args) => {
+        if (args.chainNamespace === ConstantsUtil.CHAIN.EVM) {
+          const adapter = this.getAdapter(ChainController.state.activeChain);
+          const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
+          const caipNetwork = this.getCaipNetwork();
+          if (!caipNetwork) {
+            throw new Error("CaipNetwork is undefined");
+          }
+          const result = await (adapter == null ? void 0 : adapter.estimateGas({
+            ...args,
+            provider,
+            caipNetwork
+          }));
+          return (result == null ? void 0 : result.gas) || 0n;
+        }
+        return 0n;
+      },
+      getEnsAvatar: async () => {
+        var _a;
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        const result = await (adapter == null ? void 0 : adapter.getProfile({
+          address: AccountController.state.address,
+          chainId: Number((_a = this.getCaipNetwork()) == null ? void 0 : _a.id)
+        }));
+        return (result == null ? void 0 : result.profileImage) || false;
+      },
+      getEnsAddress: async (name) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        const caipNetwork = this.getCaipNetwork();
+        if (!caipNetwork) {
+          return false;
+        }
+        const result = await (adapter == null ? void 0 : adapter.getEnsAddress({
+          name,
+          caipNetwork
+        }));
+        return (result == null ? void 0 : result.address) || false;
+      },
+      writeContract: async (args) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        const caipNetwork = this.getCaipNetwork();
+        const caipAddress = this.getCaipAddress();
+        const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
+        if (!caipNetwork || !caipAddress) {
+          throw new Error("CaipNetwork or CaipAddress is undefined");
+        }
+        const result = await (adapter == null ? void 0 : adapter.writeContract({ ...args, caipNetwork, provider, caipAddress }));
+        return result == null ? void 0 : result.hash;
+      },
+      parseUnits: (value, decimals) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        return (adapter == null ? void 0 : adapter.parseUnits({ value, decimals })) ?? 0n;
+      },
+      formatUnits: (value, decimals) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        return (adapter == null ? void 0 : adapter.formatUnits({ value, decimals })) ?? "0";
+      },
+      getCapabilities: async (params) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        await (adapter == null ? void 0 : adapter.getCapabilities(params));
+      },
+      grantPermissions: async (params) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        return await (adapter == null ? void 0 : adapter.grantPermissions(params));
+      },
+      revokePermissions: async (params) => {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        if (adapter == null ? void 0 : adapter.revokePermissions) {
+          return await adapter.revokePermissions(params);
+        }
+        return "0x";
+      }
+    };
+    this.networkControllerClient = {
+      switchCaipNetwork: async (caipNetwork) => {
+        var _a, _b;
+        if (!caipNetwork) {
+          return;
+        }
+        if (AccountController.state.address && caipNetwork.chainNamespace === ChainController.state.activeChain) {
+          const adapter = this.getAdapter(ChainController.state.activeChain);
+          const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
+          const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+          await (adapter == null ? void 0 : adapter.switchNetwork({ caipNetwork, provider, providerType }));
+          this.setCaipNetwork(caipNetwork);
+          await this.syncAccount({
+            address: AccountController.state.address,
+            chainId: caipNetwork.id,
+            chainNamespace: caipNetwork.chainNamespace
+          });
+        } else if (AccountController.state.address) {
+          const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+          if (providerType === ConstantsUtil$1.CONNECTOR_TYPE_AUTH) {
+            try {
+              ChainController.state.activeChain = caipNetwork.chainNamespace;
+              await ((_b = (_a = this.connectionControllerClient) == null ? void 0 : _a.connectExternal) == null ? void 0 : _b.call(_a, {
+                id: ConstantsUtil.CONNECTOR_ID.AUTH,
+                provider: this.authProvider,
+                chain: caipNetwork.chainNamespace,
+                chainId: caipNetwork.id,
+                type: ConstantsUtil$1.CONNECTOR_TYPE_AUTH,
+                caipNetwork
+              }));
+              this.setCaipNetwork(caipNetwork);
+            } catch (error) {
+              const adapter = this.getAdapter(caipNetwork.chainNamespace);
+              await (adapter == null ? void 0 : adapter.switchNetwork({
+                caipNetwork,
+                provider: this.authProvider,
+                providerType
+              }));
+            }
+          } else if (providerType === "WALLET_CONNECT") {
+            this.setCaipNetwork(caipNetwork);
+            this.syncWalletConnectAccount();
+          } else {
+            this.setCaipNetwork(caipNetwork);
+            const address = this.getAddressByChainNamespace(caipNetwork.chainNamespace);
+            if (address) {
+              this.syncAccount({
+                address,
+                chainId: caipNetwork.id,
+                chainNamespace: caipNetwork.chainNamespace
+              });
+            }
+          }
+        } else {
+          this.setCaipNetwork(caipNetwork);
+        }
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      getApprovedCaipNetworksData: async () => {
+        var _a, _b, _c, _d, _e;
+        const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+        if (providerType === ConstantsUtil$1.CONNECTOR_TYPE_WALLET_CONNECT) {
+          const namespaces = (_b = (_a = this.universalProvider) == null ? void 0 : _a.session) == null ? void 0 : _b.namespaces;
+          return {
+            /*
+             * MetaMask Wallet only returns 1 namespace in the session object. This makes it imposible
+             * to switch to other networks. Setting supportsAllNetworks to true for MetaMask Wallet
+             * will make it possible to switch to other networks.
+             */
+            supportsAllNetworks: ((_e = (_d = (_c = this.universalProvider) == null ? void 0 : _c.session) == null ? void 0 : _d.peer) == null ? void 0 : _e.metadata.name) === "MetaMask Wallet",
+            approvedCaipNetworkIds: this.getChainsFromNamespaces(namespaces)
+          };
+        }
+        return { supportsAllNetworks: true, approvedCaipNetworkIds: [] };
+      }
+    };
+    ConnectionController.setClient(this.connectionControllerClient);
+  }
+  setupAuthConnectorListeners(provider) {
+    provider.onRpcRequest((request) => {
+      if (W3mFrameHelpers.checkIfRequestExists(request)) {
+        if (!W3mFrameHelpers.checkIfRequestIsSafe(request)) {
+          this.handleUnsafeRPCRequest();
+        }
+      } else {
+        this.open();
+        console.error(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_MESSAGE, {
+          method: request.method
+        });
+        setTimeout(() => {
+          this.showErrorMessage(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_UI_MESSAGE);
+        }, 300);
+        provider.rejectRpcRequests();
+      }
+    });
+    provider.onRpcError(() => {
+      const isModalOpen = this.isOpen();
+      if (isModalOpen) {
+        if (this.isTransactionStackEmpty()) {
+          this.close();
+        } else {
+          this.popTransactionStack(true);
+        }
+      }
+    });
+    provider.onRpcSuccess((_, request) => {
+      var _a;
+      const isSafeRequest = W3mFrameHelpers.checkIfRequestIsSafe(request);
+      if (isSafeRequest) {
+        return;
+      }
+      if (AccountController.state.address && ((_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.id)) {
+        this.updateNativeBalance();
+      }
+      if (this.isTransactionStackEmpty()) {
+        this.close();
+      } else {
+        this.popTransactionStack();
+      }
+    });
+    provider.onNotConnected(() => {
+      const namespace = ChainController.state.activeChain;
+      const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+      const isConnectedWithAuth = connectorId === ConstantsUtil.CONNECTOR_ID.AUTH;
+      if (isConnectedWithAuth) {
+        this.setCaipAddress(void 0, namespace);
+        this.setLoading(false);
+      }
+    });
+    provider.onConnect(async (user) => {
+      var _a;
+      const namespace = ChainController.state.activeChain;
+      const caipAddress = namespace === ConstantsUtil.CHAIN.EVM ? `eip155:${user.chainId}:${user.address}` : `${user.chainId}:${user.address}`;
+      this.setSmartAccountDeployed(Boolean(user.smartAccountDeployed), namespace);
+      if (!HelpersUtil.isLowerCaseMatch(user.address, AccountController.state.address)) {
+        this.syncIdentity({
+          address: user.address,
+          chainId: user.chainId,
+          chainNamespace: namespace
+        });
+      }
+      this.setCaipAddress(caipAddress, namespace);
+      this.setUser({ ...AccountController.state.user || {}, email: user.email });
+      const preferredAccountType = user.preferredAccountType || OptionsController.state.defaultAccountTypes[namespace];
+      this.setPreferredAccountType(preferredAccountType, namespace);
+      const userAccounts = (_a = user.accounts) == null ? void 0 : _a.map((account) => CoreHelperUtil.createAccount(namespace, account.address, account.type || OptionsController.state.defaultAccountTypes[namespace]));
+      this.setAllAccounts(userAccounts || [
+        CoreHelperUtil.createAccount(namespace, user.address, preferredAccountType)
+      ], namespace);
+      await provider.getSmartAccountEnabledNetworks();
+      this.setLoading(false);
+    });
+    provider.onSocialConnected(({ userName }) => {
+      this.setUser({ ...AccountController.state.user || {}, username: userName });
+    });
+    provider.onGetSmartAccountEnabledNetworks((networks) => {
+      this.setSmartAccountEnabledNetworks(networks, ChainController.state.activeChain);
+    });
+    provider.onSetPreferredAccount(({ address, type }) => {
+      if (!address) {
+        return;
+      }
+      this.setPreferredAccountType(type, ChainController.state.activeChain);
+    });
+  }
+  async syncAuthConnector(provider) {
+    var _a, _b, _c, _d;
+    this.setLoading(true);
+    const isLoginEmailUsed = provider.getLoginEmailUsed();
+    this.setLoading(isLoginEmailUsed);
+    if (isLoginEmailUsed) {
+      this.setStatus("connecting", ChainController.state.activeChain);
+    }
+    const email = provider.getEmail();
+    const username = provider.getUsername();
+    this.setUser({ ...((_a = AccountController.state) == null ? void 0 : _a.user) || {}, username, email });
+    this.setupAuthConnectorListeners(provider);
+    const { isConnected } = await provider.isConnected();
+    const theme = ThemeController.getSnapshot();
+    const options = OptionsController.getSnapshot();
+    provider.syncDappData({
+      metadata: options.metadata,
+      sdkVersion: options.sdkVersion,
+      projectId: options.projectId,
+      sdkType: options.sdkType
+    });
+    provider.syncTheme({
+      themeMode: theme.themeMode,
+      themeVariables: theme.themeVariables,
+      w3mThemeVariables: getW3mThemeVariables(theme.themeVariables, theme.themeMode)
+    });
+    const namespace = StorageUtil.getActiveNamespace();
+    if (namespace) {
+      if (isConnected && ((_b = this.connectionControllerClient) == null ? void 0 : _b.connectExternal)) {
+        await ((_d = this.connectionControllerClient) == null ? void 0 : _d.connectExternal({
+          id: ConstantsUtil.CONNECTOR_ID.AUTH,
+          info: { name: ConstantsUtil.CONNECTOR_ID.AUTH },
+          type: ConstantsUtil$1.CONNECTOR_TYPE_AUTH,
+          provider,
+          chainId: (_c = ChainController.state.activeCaipNetwork) == null ? void 0 : _c.id,
+          chain: namespace
+        }));
+        this.setStatus("connected", namespace);
+      } else if (StorageUtil.getConnectedConnectorId(namespace) === ConstantsUtil.CONNECTOR_ID.AUTH) {
+        this.setStatus("disconnected", namespace);
+        StorageUtil.removeConnectedNamespace(namespace);
+      }
+    }
+    this.setLoading(false);
+  }
+  listenWalletConnect() {
+    if (this.universalProvider) {
+      this.universalProvider.on("display_uri", (uri) => {
+        ConnectionController.setUri(uri);
+      });
+      this.universalProvider.on("disconnect", () => {
+        this.chainNamespaces.forEach((namespace) => {
+          this.resetAccount(namespace);
+        });
+        ConnectionController.resetWcConnection();
+      });
+      this.universalProvider.on("chainChanged", (chainId) => {
+        var _a;
+        const caipNetwork = (_a = this.caipNetworks) == null ? void 0 : _a.find((c) => c.id == chainId);
+        const currentCaipNetwork = this.getCaipNetwork();
+        if (!caipNetwork) {
+          this.setUnsupportedNetwork(chainId);
+          return;
+        }
+        if ((currentCaipNetwork == null ? void 0 : currentCaipNetwork.id) !== (caipNetwork == null ? void 0 : caipNetwork.id)) {
+          this.setCaipNetwork(caipNetwork);
+        }
+      });
+      this.universalProvider.on("session_event", (callbackData) => {
+        if (WcHelpersUtil.isSessionEventData(callbackData)) {
+          const { name, data } = callbackData.params.event;
+          if (name === "accountsChanged" && Array.isArray(data) && CoreHelperUtil.isCaipAddress(data[0])) {
+            this.syncAccount(ParseUtil.parseCaipAddress(data[0]));
+          }
+        }
+      });
+    }
+  }
+  listenAdapter(chainNamespace) {
+    const adapter = this.getAdapter(chainNamespace);
+    if (!adapter) {
+      return;
+    }
+    const connectionStatus = StorageUtil.getConnectionStatus();
+    if (connectionStatus === "connected") {
+      this.setStatus("connecting", chainNamespace);
+    } else {
+      this.setStatus(connectionStatus, chainNamespace);
+    }
+    adapter.on("switchNetwork", ({ address, chainId }) => {
+      var _a;
+      if (chainId && ((_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.id === chainId || n.caipNetworkId === chainId))) {
+        if (ChainController.state.activeChain === chainNamespace && address) {
+          this.syncAccount({ address, chainId, chainNamespace });
+        } else if (ChainController.state.activeChain === chainNamespace && AccountController.state.address) {
+          this.syncAccount({
+            address: AccountController.state.address,
+            chainId,
+            chainNamespace
+          });
+        }
+      } else {
+        this.setUnsupportedNetwork(chainId);
+      }
+    });
+    adapter.on("disconnect", this.disconnect.bind(this));
+    adapter.on("pendingTransactions", () => {
+      const address = AccountController.state.address;
+      const activeCaipNetwork = ChainController.state.activeCaipNetwork;
+      if (!address || !(activeCaipNetwork == null ? void 0 : activeCaipNetwork.id)) {
+        return;
+      }
+      this.updateNativeBalance();
+    });
+    adapter.on("accountChanged", ({ address, chainId }) => {
+      var _a, _b;
+      if (ChainController.state.activeChain === chainNamespace && chainId) {
+        this.syncAccount({
+          address,
+          chainId,
+          chainNamespace
+        });
+      } else if (ChainController.state.activeChain === chainNamespace && ((_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.id)) {
+        this.syncAccount({
+          address,
+          chainId: (_b = ChainController.state.activeCaipNetwork) == null ? void 0 : _b.id,
+          chainNamespace
+        });
+      }
+    });
+  }
+  async updateNativeBalance() {
+    var _a;
+    const adapter = this.getAdapter(ChainController.state.activeChain);
+    if (adapter && ChainController.state.activeChain && AccountController.state.address) {
+      const balance = await adapter.getBalance({
+        address: AccountController.state.address,
+        chainId: (_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.id,
+        caipNetwork: this.getCaipNetwork(),
+        tokens: this.options.tokens
+      });
+      this.setBalance(balance.balance, balance.symbol, ChainController.state.activeChain);
+    }
+  }
+  getChainsFromNamespaces(namespaces = {}) {
+    return Object.values(namespaces).flatMap((namespace) => {
+      const chains = namespace.chains || [];
+      const accountsChains = namespace.accounts.map((account) => {
+        const { chainId, chainNamespace } = ParseUtil.parseCaipAddress(account);
+        return `${chainNamespace}:${chainId}`;
+      });
+      return Array.from(/* @__PURE__ */ new Set([...chains, ...accountsChains]));
+    });
+  }
+  async syncWalletConnectAccount() {
+    const adapter = this.getAdapter(ChainController.state.activeChain);
+    this.chainNamespaces.forEach(async (chainNamespace) => {
+      var _a, _b, _c, _d, _e, _f;
+      const namespaceAccounts = ((_d = (_c = (_b = (_a = this.universalProvider) == null ? void 0 : _a.session) == null ? void 0 : _b.namespaces) == null ? void 0 : _c[chainNamespace]) == null ? void 0 : _d.accounts) || [];
+      const activeChainId = (_e = ChainController.state.activeCaipNetwork) == null ? void 0 : _e.id;
+      const sessionAddress = namespaceAccounts.find((account) => {
+        const { chainId } = ParseUtil.parseCaipAddress(account);
+        return chainId === (activeChainId == null ? void 0 : activeChainId.toString());
+      }) || namespaceAccounts[0];
+      if (sessionAddress) {
+        const caipAddress = ParseUtil.validateCaipAddress(sessionAddress);
+        const { chainId, address } = ParseUtil.parseCaipAddress(caipAddress);
+        ProviderUtil.setProviderId(chainNamespace, ConstantsUtil$1.CONNECTOR_TYPE_WALLET_CONNECT);
+        if (this.caipNetworks && ChainController.state.activeCaipNetwork && (adapter == null ? void 0 : adapter.namespace) !== ConstantsUtil.CHAIN.EVM) {
+          const provider = adapter == null ? void 0 : adapter.getWalletConnectProvider({
+            caipNetworks: this.caipNetworks,
+            provider: this.universalProvider,
+            activeCaipNetwork: ChainController.state.activeCaipNetwork
+          });
+          ProviderUtil.setProvider(chainNamespace, provider);
+        } else {
+          ProviderUtil.setProvider(chainNamespace, this.universalProvider);
+        }
+        StorageUtil.setConnectedConnectorId(chainNamespace, ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT);
+        StorageUtil.addConnectedNamespace(chainNamespace);
+        if ((adapter == null ? void 0 : adapter.adapterType) === "wagmi") {
+          try {
+            await (adapter == null ? void 0 : adapter.connect({
+              id: "walletConnect",
+              type: "WALLET_CONNECT",
+              chainId: (_f = ChainController.state.activeCaipNetwork) == null ? void 0 : _f.id
+            }));
+          } catch (error) {
+            if (adapter == null ? void 0 : adapter.reconnect) {
+              adapter == null ? void 0 : adapter.reconnect({
+                id: "walletConnect",
+                type: "WALLET_CONNECT"
+              });
+            }
+          }
+        }
+        this.syncWalletConnectAccounts(chainNamespace);
+        await this.syncAccount({
+          address,
+          chainId,
+          chainNamespace
+        });
+      }
+    });
+    await ChainController.setApprovedCaipNetworksData(ChainController.state.activeChain);
+  }
+  syncWalletConnectAccounts(chainNamespace) {
+    var _a, _b, _c, _d, _e;
+    const addresses = (_e = (_d = (_c = (_b = (_a = this.universalProvider) == null ? void 0 : _a.session) == null ? void 0 : _b.namespaces) == null ? void 0 : _c[chainNamespace]) == null ? void 0 : _d.accounts) == null ? void 0 : _e.map((account) => {
+      const { address } = ParseUtil.parseCaipAddress(account);
+      return address;
+    }).filter((address, index, self) => self.indexOf(address) === index);
+    if (addresses) {
+      this.setAllAccounts(addresses.map((address) => CoreHelperUtil.createAccount(chainNamespace, address, chainNamespace === "bip122" ? "payment" : "eoa")), chainNamespace);
+    }
+  }
+  syncProvider({ type, provider, id, chainNamespace }) {
+    ProviderUtil.setProviderId(chainNamespace, type);
+    ProviderUtil.setProvider(chainNamespace, provider);
+    StorageUtil.setConnectedConnectorId(chainNamespace, id);
+  }
+  async syncAccount(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { address, chainId, chainNamespace } = params;
+    const { chainId: activeChainId } = StorageUtil.getActiveNetworkProps();
+    const chainIdToUse = chainId || activeChainId;
+    const isUnsupportedNetwork = ((_a = ChainController.state.activeCaipNetwork) == null ? void 0 : _a.name) === ConstantsUtil.UNSUPPORTED_NETWORK_NAME;
+    const shouldSupportAllNetworks = ChainController.getNetworkProp("supportsAllNetworks", chainNamespace);
+    this.setStatus("connected", chainNamespace);
+    if (isUnsupportedNetwork && !shouldSupportAllNetworks) {
+      return;
+    }
+    if (chainIdToUse) {
+      let caipNetwork = (_b = this.caipNetworks) == null ? void 0 : _b.find((n) => n.id.toString() === chainIdToUse.toString());
+      let fallbackCaipNetwork = (_c = this.caipNetworks) == null ? void 0 : _c.find((n) => n.chainNamespace === chainNamespace);
+      if (!shouldSupportAllNetworks && !caipNetwork && !fallbackCaipNetwork) {
+        const caipNetworkIds = this.getApprovedCaipNetworkIds() || [];
+        const caipNetworkId = caipNetworkIds.find((id) => {
+          var _a2;
+          return ((_a2 = ParseUtil.parseCaipNetworkId(id)) == null ? void 0 : _a2.chainId) === chainIdToUse.toString();
+        });
+        const fallBackCaipNetworkId = caipNetworkIds.find((id) => {
+          var _a2;
+          return ((_a2 = ParseUtil.parseCaipNetworkId(id)) == null ? void 0 : _a2.chainNamespace) === chainNamespace;
+        });
+        caipNetwork = (_d = this.caipNetworks) == null ? void 0 : _d.find((n) => n.caipNetworkId === caipNetworkId);
+        fallbackCaipNetwork = (_e = this.caipNetworks) == null ? void 0 : _e.find((n) => n.caipNetworkId === fallBackCaipNetworkId || // This is a workaround used in Solana network to support deprecated caipNetworkId
+        "deprecatedCaipNetworkId" in n && n.deprecatedCaipNetworkId === fallBackCaipNetworkId);
+      }
+      const network = caipNetwork || fallbackCaipNetwork;
+      if ((network == null ? void 0 : network.chainNamespace) === ChainController.state.activeChain) {
+        if (!OptionsController.state.allowUnsupportedChain && ((_f = ChainController.state.activeCaipNetwork) == null ? void 0 : _f.name) === ConstantsUtil.UNSUPPORTED_NETWORK_NAME) {
+          ChainController.showUnsupportedChainUI();
+        } else {
+          this.setCaipNetwork(network);
+        }
+      }
+      this.syncConnectedWalletInfo(chainNamespace);
+      if (!HelpersUtil.isLowerCaseMatch(address, AccountController.state.address)) {
+        this.setCaipAddress(`${chainNamespace}:${network == null ? void 0 : network.id}:${address}`, chainNamespace);
+        await this.syncIdentity({
+          address,
+          chainId: network == null ? void 0 : network.id,
+          chainNamespace
+        });
+      }
+      await this.syncBalance({ address, chainId: network == null ? void 0 : network.id, chainNamespace });
+    }
+  }
+  async syncBalance(params) {
+    const caipNetwork = NetworkUtil.getNetworksByNamespace(this.caipNetworks, params.chainNamespace).find((n) => {
+      var _a;
+      return n.id.toString() === ((_a = params.chainId) == null ? void 0 : _a.toString());
+    });
+    if (!caipNetwork) {
+      return;
+    }
+    await this.updateNativeBalance();
+  }
+  syncConnectedWalletInfo(chainNamespace) {
+    var _a;
+    const connectorId = StorageUtil.getConnectedConnectorId(chainNamespace);
+    const providerType = ProviderUtil.getProviderId(chainNamespace);
+    if (providerType === ConstantsUtil$1.CONNECTOR_TYPE_ANNOUNCED || providerType === ConstantsUtil$1.CONNECTOR_TYPE_INJECTED) {
+      if (connectorId) {
+        const connector = this.getConnectors().find((c) => c.id === connectorId);
+        if (connector) {
+          const { info, name, imageUrl } = connector;
+          const icon = imageUrl || this.getConnectorImage(connector);
+          this.setConnectedWalletInfo({ name, icon, ...info }, chainNamespace);
+        }
+      }
+    } else if (providerType === ConstantsUtil$1.CONNECTOR_TYPE_WALLET_CONNECT) {
+      const provider = ProviderUtil.getProvider(chainNamespace);
+      if (provider == null ? void 0 : provider.session) {
+        this.setConnectedWalletInfo({
+          ...provider.session.peer.metadata,
+          name: provider.session.peer.metadata.name,
+          icon: (_a = provider.session.peer.metadata.icons) == null ? void 0 : _a[0]
+        }, chainNamespace);
+      }
+    } else if (connectorId) {
+      if (connectorId === ConstantsUtil.CONNECTOR_ID.COINBASE) {
+        const connector = this.getConnectors().find((c) => c.id === ConstantsUtil.CONNECTOR_ID.COINBASE);
+        this.setConnectedWalletInfo({ name: "Coinbase Wallet", icon: this.getConnectorImage(connector) }, chainNamespace);
+      }
+      this.setConnectedWalletInfo({ name: connectorId }, chainNamespace);
+    }
+  }
+  async syncIdentity({ address, chainId, chainNamespace }) {
+    var _a;
+    const activeCaipNetwork = (_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.caipNetworkId === `${chainNamespace}:${chainId}`);
+    if (chainNamespace !== ConstantsUtil.CHAIN.EVM || (activeCaipNetwork == null ? void 0 : activeCaipNetwork.testnet)) {
+      return;
+    }
+    try {
+      const { name, avatar } = await this.fetchIdentity({
+        address
+      });
+      this.setProfileName(name, chainNamespace);
+      this.setProfileImage(avatar, chainNamespace);
+      if (!name) {
+        await this.syncReownName(address, chainNamespace);
+        const adapter = this.getAdapter(chainNamespace);
+        const result = await (adapter == null ? void 0 : adapter.getProfile({
+          address,
+          chainId: Number(chainId)
+        }));
+        if (result == null ? void 0 : result.profileName) {
+          this.setProfileName(result.profileName, chainNamespace);
+          if (result.profileImage) {
+            this.setProfileImage(result.profileImage, chainNamespace);
+          }
+        } else {
+          await this.syncReownName(address, chainNamespace);
+          this.setProfileImage(null, chainNamespace);
+        }
+      }
+    } catch {
+      if (chainId === 1) {
+        await this.syncReownName(address, chainNamespace);
+      } else {
+        await this.syncReownName(address, chainNamespace);
+        this.setProfileImage(null, chainNamespace);
+      }
+    }
+  }
+  async syncReownName(address, chainNamespace) {
+    try {
+      const registeredWcNames = await this.getReownName(address);
+      if (registeredWcNames[0]) {
+        const wcName = registeredWcNames[0];
+        this.setProfileName(wcName.name, chainNamespace);
+      } else {
+        this.setProfileName(null, chainNamespace);
+      }
+    } catch {
+      this.setProfileName(null, chainNamespace);
+    }
+  }
+  async syncAdapterConnection(namespace) {
+    var _a, _b, _c;
+    const adapter = this.getAdapter(namespace);
+    const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+    const caipNetwork = this.getCaipNetwork();
+    try {
+      if (!adapter || !connectorId) {
+        throw new Error(`Adapter or connectorId not found for namespace ${namespace}`);
+      }
+      const connection = await (adapter == null ? void 0 : adapter.syncConnection({
+        namespace,
+        id: connectorId,
+        chainId: caipNetwork == null ? void 0 : caipNetwork.id,
+        rpcUrl: (_c = (_b = (_a = caipNetwork == null ? void 0 : caipNetwork.rpcUrls) == null ? void 0 : _a.default) == null ? void 0 : _b.http) == null ? void 0 : _c[0]
+      }));
+      if (connection) {
+        const accounts = await (adapter == null ? void 0 : adapter.getAccounts({
+          namespace,
+          id: connectorId
+        }));
+        if (accounts && accounts.accounts.length > 0) {
+          this.setAllAccounts(accounts.accounts, namespace);
+        } else {
+          this.setAllAccounts([CoreHelperUtil.createAccount(namespace, connection.address, "eoa")], namespace);
+        }
+        this.syncProvider({ ...connection, chainNamespace: namespace });
+        await this.syncAccount({ ...connection, chainNamespace: namespace });
+        this.setStatus("connected", namespace);
+      } else {
+        this.setStatus("disconnected", namespace);
+      }
+    } catch (e) {
+      StorageUtil.deleteConnectedConnectorId(namespace);
+      this.setStatus("disconnected", namespace);
+    }
+  }
+  async syncNamespaceConnection(namespace) {
+    var _a;
+    try {
+      const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+      const isEmailUsed = (_a = this.authProvider) == null ? void 0 : _a.getLoginEmailUsed();
+      if (isEmailUsed) {
+        return;
+      }
+      this.setStatus("connecting", namespace);
+      switch (connectorId) {
+        case ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT:
+          await this.syncWalletConnectAccount();
+          break;
+        case ConstantsUtil.CONNECTOR_ID.AUTH:
+          break;
+        default:
+          await this.syncAdapterConnection(namespace);
+      }
+    } catch (err) {
+      console.warn("AppKit couldn't sync existing connection", err);
+      StorageUtil.deleteConnectedConnectorId(namespace);
+      this.setStatus("disconnected", namespace);
+    }
+  }
+  async syncExistingConnection() {
+    await Promise.allSettled(this.chainNamespaces.map((namespace) => this.syncNamespaceConnection(namespace)));
+  }
+  getAdapter(namespace) {
+    var _a;
+    if (!namespace) {
+      return void 0;
+    }
+    return (_a = this.chainAdapters) == null ? void 0 : _a[namespace];
+  }
+  createUniversalProvider() {
+    var _a;
+    if (!this.universalProviderInitPromise && CoreHelperUtil.isClient() && ((_a = this.options) == null ? void 0 : _a.projectId)) {
+      this.universalProviderInitPromise = this.initializeUniversalAdapter();
+    }
+    return this.universalProviderInitPromise;
+  }
+  handleAlertError(error) {
+    const matchedUniversalProviderError = Object.entries(ErrorUtil.UniversalProviderErrors).find(([, { message: message2 }]) => error.message.includes(message2));
+    const [errorKey, errorValue] = matchedUniversalProviderError ?? [];
+    const { message, alertErrorKey } = errorValue ?? {};
+    if (errorKey && message && !this.reportedAlertErrors[errorKey]) {
+      const alertError = ErrorUtil.ALERT_ERRORS[alertErrorKey];
+      if (alertError) {
+        AlertController.open(alertError, "error");
+        this.reportedAlertErrors[errorKey] = true;
+      }
+    }
+  }
+  async initializeUniversalAdapter() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const logger = LoggerUtil.createLogger((error, ...args) => {
+      if (error) {
+        this.handleAlertError(error);
+      }
+      console.error(...args);
+    });
+    const universalProviderOptions = {
+      projectId: (_a = this.options) == null ? void 0 : _a.projectId,
+      metadata: {
+        name: ((_b = this.options) == null ? void 0 : _b.metadata) ? (_c = this.options) == null ? void 0 : _c.metadata.name : "",
+        description: ((_d = this.options) == null ? void 0 : _d.metadata) ? (_e = this.options) == null ? void 0 : _e.metadata.description : "",
+        url: ((_f = this.options) == null ? void 0 : _f.metadata) ? (_g = this.options) == null ? void 0 : _g.metadata.url : "",
+        icons: ((_h = this.options) == null ? void 0 : _h.metadata) ? (_i = this.options) == null ? void 0 : _i.metadata.icons : [""]
+      },
+      logger
+    };
+    OptionsController.setUsingInjectedUniversalProvider(Boolean((_j = this.options) == null ? void 0 : _j.universalProvider));
+    this.universalProvider = this.options.universalProvider ?? await M.init(universalProviderOptions);
+    this.listenWalletConnect();
+  }
+  async getUniversalProvider() {
+    if (!this.universalProvider) {
+      try {
+        await this.createUniversalProvider();
+      } catch (error) {
+        throw new Error("AppKit:getUniversalProvider - Cannot create provider");
+      }
+    }
+    return this.universalProvider;
+  }
+  createAuthProvider() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    const isEmailEnabled = ((_b = (_a = this.options) == null ? void 0 : _a.features) == null ? void 0 : _b.email) === void 0 ? ConstantsUtil$2.DEFAULT_FEATURES.email : (_d = (_c = this.options) == null ? void 0 : _c.features) == null ? void 0 : _d.email;
+    const isSocialsEnabled = ((_f = (_e = this.options) == null ? void 0 : _e.features) == null ? void 0 : _f.socials) ? ((_i = (_h = (_g = this.options) == null ? void 0 : _g.features) == null ? void 0 : _h.socials) == null ? void 0 : _i.length) > 0 : ConstantsUtil$2.DEFAULT_FEATURES.socials;
+    const isAuthEnabled = isEmailEnabled || isSocialsEnabled;
+    if (!this.authProvider && ((_j = this.options) == null ? void 0 : _j.projectId) && isAuthEnabled) {
+      this.authProvider = W3mFrameProviderSingleton.getInstance({
+        projectId: this.options.projectId,
+        enableLogger: this.options.enableAuthLogger,
+        chainId: (_k = this.getCaipNetwork()) == null ? void 0 : _k.caipNetworkId,
+        onTimeout: () => {
+          AlertController.open(ErrorUtil.ALERT_ERRORS.SOCIALS_TIMEOUT, "error");
+        }
+      });
+      this.subscribeState((val) => {
+        var _a2;
+        if (!val.open) {
+          (_a2 = this.authProvider) == null ? void 0 : _a2.rejectRpcRequests();
+        }
+      });
+      this.syncAuthConnector(this.authProvider);
+    }
+  }
+  async createUniversalProviderForAdapter(chainNamespace) {
+    var _a, _b, _c;
+    await this.getUniversalProvider();
+    if (this.universalProvider) {
+      (_c = (_b = (_a = this.chainAdapters) == null ? void 0 : _a[chainNamespace]) == null ? void 0 : _b.setUniversalProvider) == null ? void 0 : _c.call(_b, this.universalProvider);
+    }
+  }
+  createAuthProviderForAdapter(chainNamespace) {
+    var _a, _b, _c;
+    this.createAuthProvider();
+    if (this.authProvider) {
+      (_c = (_b = (_a = this.chainAdapters) == null ? void 0 : _a[chainNamespace]) == null ? void 0 : _b.setAuthProvider) == null ? void 0 : _c.call(_b, this.authProvider);
+    }
+  }
+  createAdapter(blueprint) {
+    var _a;
+    if (!blueprint) {
+      return;
+    }
+    const namespace = blueprint.namespace;
+    if (!namespace) {
+      return;
+    }
+    this.createClients();
+    const adapterBlueprint = blueprint;
+    adapterBlueprint.namespace = namespace;
+    adapterBlueprint.construct({
+      namespace,
+      projectId: (_a = this.options) == null ? void 0 : _a.projectId,
+      networks: this.caipNetworks
+    });
+    if (!this.chainNamespaces.includes(namespace)) {
+      this.chainNamespaces.push(namespace);
+    }
+    if (this.chainAdapters) {
+      this.chainAdapters[namespace] = adapterBlueprint;
+    }
+  }
+  createAdapters(blueprints) {
+    this.createClients();
+    return this.chainNamespaces.reduce((adapters, namespace) => {
+      var _a;
+      const blueprint = blueprints == null ? void 0 : blueprints.find((b) => b.namespace === namespace);
+      if (blueprint) {
+        adapters[namespace] = blueprint;
+        adapters[namespace].namespace = namespace;
+        adapters[namespace].construct({
+          namespace,
+          projectId: (_a = this.options) == null ? void 0 : _a.projectId,
+          networks: this.caipNetworks
+        });
+      } else {
+        adapters[namespace] = new UniversalAdapter({
+          namespace,
+          networks: this.caipNetworks
+        });
+      }
+      return adapters;
+    }, {});
+  }
+  onConnectors(chainNamespace) {
+    const adapter = this.getAdapter(chainNamespace);
+    adapter == null ? void 0 : adapter.on("connectors", this.setConnectors.bind(this));
+  }
+  async initChainAdapter(namespace) {
+    var _a;
+    this.onConnectors(namespace);
+    this.listenAdapter(namespace);
+    (_a = this.chainAdapters) == null ? void 0 : _a[namespace].syncConnectors(this.options, this);
+    await this.createUniversalProviderForAdapter(namespace);
+    this.createAuthProviderForAdapter(namespace);
+  }
+  async initChainAdapters() {
+    await Promise.all(this.chainNamespaces.map(async (namespace) => {
+      await this.initChainAdapter(namespace);
+    }));
+  }
+  getUnsupportedNetwork(caipNetworkId) {
+    return {
+      id: caipNetworkId.split(":")[1],
+      caipNetworkId,
+      name: ConstantsUtil.UNSUPPORTED_NETWORK_NAME,
+      chainNamespace: caipNetworkId.split(":")[0],
+      nativeCurrency: {
+        name: "",
+        decimals: 0,
+        symbol: ""
+      },
+      rpcUrls: {
+        default: {
+          http: []
+        }
+      }
+    };
+  }
+  getDefaultNetwork() {
+    var _a, _b;
+    const caipNetworkId = StorageUtil.getActiveCaipNetworkId();
+    if (caipNetworkId) {
+      const caipNetwork = (_a = this.caipNetworks) == null ? void 0 : _a.find((n) => n.caipNetworkId === caipNetworkId);
+      if (caipNetwork) {
+        return caipNetwork;
+      }
+      return this.getUnsupportedNetwork(caipNetworkId);
+    }
+    return (_b = this.caipNetworks) == null ? void 0 : _b[0];
+  }
+  async injectModalUi() {
+    if (!this.initPromise && !isInitialized && CoreHelperUtil.isClient()) {
+      isInitialized = true;
+      this.initPromise = new Promise(async (resolve) => {
+        await Promise.all([
+          import("./index-B9WqxUXM.mjs"),
+          import("./w3m-modal-DK3G5GJp.mjs")
+        ]);
+        const modal2 = document.createElement("w3m-modal");
+        if (!OptionsController.state.disableAppend && !OptionsController.state.enableEmbedded) {
+          document.body.insertAdjacentElement("beforeend", modal2);
+        }
+        resolve();
+      });
+    }
+    return this.initPromise;
+  }
+}
+const PACKAGE_VERSION = "1.6.8";
+let modal = void 0;
+function createAppKit(options) {
+  if (!modal) {
+    modal = new AppKit({
+      ...options,
+      sdkVersion: CoreHelperUtil.generateSdkVersion(options.adapters ?? [], "react", PACKAGE_VERSION)
+    });
+    getAppKit(modal);
+  }
+  return modal;
+}
+function useAppKitNetwork() {
+  const { caipNetwork, caipNetworkId, chainId } = useAppKitNetworkCore();
+  function switchNetwork(network) {
+    modal == null ? void 0 : modal.switchNetwork(network);
+  }
+  return {
+    caipNetwork,
+    caipNetworkId,
+    chainId,
+    switchNetwork
+  };
+}
+export {
+  createAppKit as c,
+  useAppKitNetwork as u
+};