@web3auth/no-modal 9.7.0 → 10.0.0-alpha.1

package/dist/lib.esm/plugins/nft-checkout-plugin/embed.js

@@ -0,0 +1,132 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { randomId } from '@toruslabs/base-controllers';
+import { THEME_MODES } from '@web3auth/auth';
+import loglevel from 'loglevel';
+import { NFT_CHECKOUT_BUILD_ENV, NFT_CHECKOUT_URLS, NFT_CHECKOUT_EMBED_MESSAGE_TYPES } from './enums.js';
+import { getTheme, htmlToElement } from './utils.js';
+
+// preload for iframe doesn't work https://bugs.chromium.org/p/chromium/issues/detail?id=593267
+(async function preLoadIframe() {
+  try {
+    if (typeof document === "undefined") return;
+    const nftCheckoutIframeHtml = document.createElement("link");
+    const nftCheckoutUrl = NFT_CHECKOUT_URLS.testing; // TODO: use production by default once we have it
+    nftCheckoutIframeHtml.href = `${nftCheckoutUrl}`;
+    nftCheckoutIframeHtml.crossOrigin = "anonymous";
+    nftCheckoutIframeHtml.type = "text/html";
+    nftCheckoutIframeHtml.rel = "prefetch";
+    if (nftCheckoutIframeHtml.relList && nftCheckoutIframeHtml.relList.supports) {
+      if (nftCheckoutIframeHtml.relList.supports("prefetch")) {
+        document.head.appendChild(nftCheckoutIframeHtml);
+      }
+    }
+  } catch (error) {
+    loglevel.warn(error);
+  }
+})();
+class NFTCheckoutEmbed {
+  constructor({
+    modalZIndex = 99999,
+    clientId
+  }) {
+    _defineProperty(this, "clientId", void 0);
+    _defineProperty(this, "isInitialized", void 0);
+    _defineProperty(this, "modalZIndex", void 0);
+    _defineProperty(this, "buildEnv", void 0);
+    _defineProperty(this, "embedNonce", randomId());
+    this.isInitialized = false;
+    this.modalZIndex = modalZIndex;
+    this.clientId = clientId;
+  }
+  async init(params) {
+    if (this.isInitialized) throw new Error("Already initialized");
+    if (this.getIframe()) throw new Error("Already initialized NFT Checkout iframe");
+    const {
+      buildEnv = NFT_CHECKOUT_BUILD_ENV.TESTING,
+      // TODO: use production by default once we have it
+      whiteLabel
+    } = params || {};
+    this.buildEnv = buildEnv;
+
+    // construct nft checkout url
+    const nftCheckoutIframeUrl = new URL(NFT_CHECKOUT_URLS[this.buildEnv]);
+    const hashParams = new URLSearchParams();
+    hashParams.append("origin", window.location.origin);
+    nftCheckoutIframeUrl.hash = hashParams.toString();
+
+    // create iframe
+    const colorScheme = getTheme((whiteLabel === null || whiteLabel === void 0 ? void 0 : whiteLabel.mode) || THEME_MODES.light);
+    const nftCheckoutIframe = htmlToElement(`<iframe
+        id="nftCheckoutIframe-${this.embedNonce}"
+        class="nftCheckoutIframe-${this.embedNonce}"
+        sandbox="allow-popups allow-scripts allow-same-origin allow-forms allow-modals allow-downloads allow-popups-to-escape-sandbox"
+        src="${nftCheckoutIframeUrl.href}"
+        style="display: none; position: fixed; top: 0; right: 0; width: 100%;
+        height: 100%; border: none; border-radius: 0; z-index: ${this.modalZIndex.toString()};
+        color-scheme: ${colorScheme}"
+        allow="clipboard-write"
+      ></iframe>`);
+    return new Promise((resolve, reject) => {
+      try {
+        window.document.body.appendChild(nftCheckoutIframe);
+        const handleMessage = async ev => {
+          if (ev.origin !== nftCheckoutIframeUrl.origin) return;
+          if (ev.data.type === NFT_CHECKOUT_EMBED_MESSAGE_TYPES.SETUP_COMPLETE) {
+            // send init params here
+            nftCheckoutIframe.contentWindow.postMessage({
+              type: NFT_CHECKOUT_EMBED_MESSAGE_TYPES.INIT,
+              clientId: this.clientId,
+              whiteLabel
+            }, nftCheckoutIframeUrl.origin);
+            this.isInitialized = true;
+            resolve();
+          } else if (ev.data.type === NFT_CHECKOUT_EMBED_MESSAGE_TYPES.HIDE_NFT_CHECKOUT) {
+            this.hide();
+          }
+        };
+        window.addEventListener("message", handleMessage);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  show({
+    receiverAddress,
+    contractId
+  }) {
+    if (!this.isInitialized) throw new Error("Call init() first");
+    const nftCheckoutIframe = this.getIframe();
+    if (!nftCheckoutIframe) throw new Error("Iframe is not initialized");
+
+    // send message to iframe
+    const nftCheckoutOrigin = new URL(NFT_CHECKOUT_URLS[this.buildEnv]).origin;
+    nftCheckoutIframe.contentWindow.postMessage({
+      type: NFT_CHECKOUT_EMBED_MESSAGE_TYPES.SHOW_NFT_CHECKOUT,
+      contractId,
+      receiverAddress
+    }, nftCheckoutOrigin);
+    // show iframe
+    nftCheckoutIframe.style.display = "block";
+  }
+  hide() {
+    if (!this.isInitialized) throw new Error("Call init() first");
+    const nftCheckoutIframe = this.getIframe();
+    if (!nftCheckoutIframe) throw new Error("Iframe is not initialized");
+    // hide iframe
+    nftCheckoutIframe.style.display = "none";
+  }
+  cleanup() {
+    const nftCheckoutIframe = this.getIframe();
+    if (nftCheckoutIframe) nftCheckoutIframe.remove();
+  }
+  getIframe() {
+    function isElement(element) {
+      return element instanceof Element || element instanceof Document;
+    }
+    const nftCheckoutIframe = window.document.getElementById(`nftCheckoutIframe-${this.embedNonce}`);
+    if (!isElement(nftCheckoutIframe)) return null;
+    return nftCheckoutIframe;
+  }
+}
+
+export { NFTCheckoutEmbed };

package/dist/lib.esm/plugins/nft-checkout-plugin/enums.js

@@ -0,0 +1,20 @@
+const NFT_CHECKOUT_BUILD_ENV = {
+  PRODUCTION: "production",
+  STAGING: "staging",
+  DEVELOPMENT: "development",
+  TESTING: "testing"
+};
+const NFT_CHECKOUT_URLS = {
+  [NFT_CHECKOUT_BUILD_ENV.DEVELOPMENT]: "http://localhost:4050",
+  [NFT_CHECKOUT_BUILD_ENV.TESTING]: "https://develop-nft-checkout.web3auth.io",
+  [NFT_CHECKOUT_BUILD_ENV.STAGING]: "https://staging-nft-checkout.web3auth.io",
+  [NFT_CHECKOUT_BUILD_ENV.PRODUCTION]: "https://nft-checkout.web3auth.io"
+};
+const NFT_CHECKOUT_EMBED_MESSAGE_TYPES = {
+  INIT: "init",
+  SETUP_COMPLETE: "setup_complete",
+  SHOW_NFT_CHECKOUT: "show_nft_checkout",
+  HIDE_NFT_CHECKOUT: "hide_nft_checkout"
+};
+
+export { NFT_CHECKOUT_BUILD_ENV, NFT_CHECKOUT_EMBED_MESSAGE_TYPES, NFT_CHECKOUT_URLS };

package/dist/lib.esm/plugins/nft-checkout-plugin/plugin.js

@@ -0,0 +1,74 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { SafeEventEmitter } from '@web3auth/auth';
+import { NFTCheckoutEmbed } from './embed.js';
+import { EVM_PLUGINS, PLUGIN_STATUS, PLUGIN_NAMESPACES, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import { NFTCheckoutPluginError } from '../../base/plugin/errors.js';
+import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
+
+class NFTCheckoutPlugin extends SafeEventEmitter {
+  constructor(params) {
+    super();
+    _defineProperty(this, "name", EVM_PLUGINS.NFT_CHECKOUT);
+    _defineProperty(this, "status", PLUGIN_STATUS.DISCONNECTED);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", ["all"]);
+    _defineProperty(this, "pluginNamespace", PLUGIN_NAMESPACES.EIP155);
+    _defineProperty(this, "web3auth", null);
+    _defineProperty(this, "nftCheckoutEmbedInstance", null);
+    _defineProperty(this, "isInitialized", false);
+    _defineProperty(this, "receiverAddress", null);
+    this.nftCheckoutEmbedInstance = new NFTCheckoutEmbed(params);
+  }
+  async initWithWeb3Auth(web3auth, whiteLabel) {
+    if (this.isInitialized) return;
+    if (!web3auth) throw NFTCheckoutPluginError.web3authRequired();
+    this.web3auth = web3auth;
+    await this.nftCheckoutEmbedInstance.init({
+      whiteLabel
+    });
+    this.isInitialized = true;
+    this.status = PLUGIN_STATUS.READY;
+    this.emit(PLUGIN_EVENTS.READY);
+  }
+  async connect() {
+    if (!this.isInitialized) throw NFTCheckoutPluginError.notInitialized();
+    this.emit(PLUGIN_EVENTS.CONNECTING);
+    this.status = PLUGIN_STATUS.CONNECTING;
+    if (this.web3auth.status !== CONNECTOR_STATUS.CONNECTED) throw NFTCheckoutPluginError.web3AuthNotConnected();
+    if (!this.web3auth.provider) throw NFTCheckoutPluginError.providerRequired();
+    const accounts = await this.web3auth.provider.request({
+      method: "eth_accounts"
+    });
+    if (accounts.length === 0) throw NFTCheckoutPluginError.web3AuthNotConnected();
+    this.receiverAddress = accounts[0];
+    this.emit(PLUGIN_EVENTS.CONNECTED);
+    this.status = PLUGIN_STATUS.CONNECTED;
+  }
+  async show({
+    contractId
+  }) {
+    if (this.status !== PLUGIN_STATUS.CONNECTED) NFTCheckoutPluginError.pluginNotConnected();
+    return this.nftCheckoutEmbedInstance.show({
+      receiverAddress: this.receiverAddress,
+      contractId
+    });
+  }
+  disconnect() {
+    if (this.status !== PLUGIN_STATUS.CONNECTED) NFTCheckoutPluginError.pluginNotConnected();
+    this.emit(PLUGIN_EVENTS.DISCONNECTED);
+    this.status = PLUGIN_STATUS.DISCONNECTED;
+    return Promise.resolve();
+  }
+  cleanup() {
+    this.nftCheckoutEmbedInstance.cleanup();
+    this.receiverAddress = null;
+    this.isInitialized = false;
+    return Promise.resolve();
+  }
+}
+const nftCheckoutPlugin = params => {
+  return () => {
+    return new NFTCheckoutPlugin(params);
+  };
+};
+
+export { nftCheckoutPlugin };

package/dist/lib.esm/plugins/nft-checkout-plugin/utils.js

@@ -0,0 +1,15 @@
+import { THEME_MODES } from '@web3auth/auth';
+
+const htmlToElement = html => {
+  const template = window.document.createElement("template");
+  const trimmedHtml = html.trim(); // Never return a text node of whitespace as the result
+  template.innerHTML = trimmedHtml;
+  return template.content.firstChild;
+};
+const getTheme = theme => {
+  if (theme === THEME_MODES.light) return "light";
+  if (theme === THEME_MODES.dark) return "dark";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+};
+
+export { getTheme, htmlToElement };

package/dist/lib.esm/plugins/wallet-services-plugin/plugin.js

@@ -0,0 +1,119 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { SafeEventEmitter } from '@web3auth/auth';
+import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { log } from '../../base/loglevel.js';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import { EVM_PLUGINS, PLUGIN_STATUS, PLUGIN_NAMESPACES, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
+
+// TODO: support project config items here. incl. key export flag, multiple chains
+class WalletServicesPlugin extends SafeEventEmitter {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", EVM_PLUGINS.WALLET_SERVICES);
+    _defineProperty(this, "status", PLUGIN_STATUS.DISCONNECTED);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", [WALLET_CONNECTORS.AUTH, WALLET_CONNECTORS.SFA]);
+    _defineProperty(this, "pluginNamespace", PLUGIN_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "wsEmbedInstance", void 0);
+    _defineProperty(this, "provider", null);
+    _defineProperty(this, "web3auth", null);
+    _defineProperty(this, "isInitialized", false);
+  }
+  get proxyProvider() {
+    var _this$wsEmbedInstance;
+    return (_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider ? this.wsEmbedInstance.provider : null;
+  }
+  async initWithWeb3Auth(web3auth, _whiteLabel) {
+    if (this.isInitialized) return;
+    if (!web3auth) throw WalletServicesPluginError.web3authRequired();
+    if (web3auth.provider && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw WalletServicesPluginError.notInitialized();
+    const currentChainConfig = web3auth.currentChain;
+    if (![CHAIN_NAMESPACES.EIP155, CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig.chainNamespace)) throw WalletServicesPluginError.unsupportedChainNamespace();
+
+    // Not connected yet to auth
+    if (web3auth.provider) {
+      this.provider = web3auth.provider;
+    }
+    this.web3auth = web3auth;
+
+    // Auth connector uses WS embed
+    const authInstance = web3auth.getConnector(WALLET_CONNECTORS.AUTH);
+    if (!authInstance || !authInstance.wsEmbed) throw WalletServicesPluginError.web3AuthNotConnected();
+    this.wsEmbedInstance = authInstance.wsEmbed;
+    this.isInitialized = true;
+    this.status = PLUGIN_STATUS.READY;
+    this.emit(PLUGIN_EVENTS.READY);
+  }
+  initWithProvider() {
+    throw new Error("Method not implemented.");
+  }
+  async connect() {
+    // if web3auth is being used and connected to unsupported connector throw error
+    if (!this.isInitialized) throw WalletServicesPluginError.notInitialized();
+    this.emit(PLUGIN_EVENTS.CONNECTING);
+    this.status = PLUGIN_STATUS.CONNECTING;
+    if (!this.provider) {
+      var _this$web3auth;
+      if ((_this$web3auth = this.web3auth) !== null && _this$web3auth !== void 0 && _this$web3auth.provider) {
+        this.provider = this.web3auth.provider;
+      }
+    }
+    if (this.web3auth.status !== CONNECTOR_STATUS.CONNECTED) {
+      throw WalletServicesPluginError.web3AuthNotConnected();
+    } else if (!this.web3auth.provider) {
+      throw WalletServicesPluginError.providerRequired();
+    }
+    try {
+      this.emit(PLUGIN_EVENTS.CONNECTED);
+      this.status = PLUGIN_STATUS.CONNECTED;
+    } catch (error) {
+      log.error(error);
+      this.status = PLUGIN_STATUS.ERRORED;
+      this.emit(PLUGIN_EVENTS.ERRORED, {
+        error: error.message || "Something went wrong"
+      });
+    }
+  }
+  async showWalletConnectScanner(showWalletConnectParams) {
+    var _this$wsEmbedInstance2;
+    if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    return this.wsEmbedInstance.showWalletConnectScanner(showWalletConnectParams);
+  }
+  async showCheckout(showCheckoutParams) {
+    var _this$wsEmbedInstance3;
+    if (!((_this$wsEmbedInstance3 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance3 !== void 0 && _this$wsEmbedInstance3.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    return this.wsEmbedInstance.showCheckout(showCheckoutParams);
+  }
+  async showWalletUi(showWalletUiParams) {
+    var _this$wsEmbedInstance4;
+    if (!((_this$wsEmbedInstance4 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance4 !== void 0 && _this$wsEmbedInstance4.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    return this.wsEmbedInstance.showWalletUi(showWalletUiParams);
+  }
+  async showSwap(showSwapParams) {
+    var _this$wsEmbedInstance5;
+    if (!((_this$wsEmbedInstance5 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance5 !== void 0 && _this$wsEmbedInstance5.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    return this.wsEmbedInstance.showSwap(showSwapParams);
+  }
+  async cleanup() {
+    var _this$wsEmbedInstance6;
+    return (_this$wsEmbedInstance6 = this.wsEmbedInstance) === null || _this$wsEmbedInstance6 === void 0 ? void 0 : _this$wsEmbedInstance6.cleanUp();
+  }
+  async disconnect() {
+    var _this$wsEmbedInstance7;
+    if (this.status !== PLUGIN_STATUS.CONNECTED) throw WalletServicesPluginError.invalidSession("Wallet Services plugin is not connected");
+    if ((_this$wsEmbedInstance7 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance7 !== void 0 && _this$wsEmbedInstance7.isLoggedIn) {
+      await this.wsEmbedInstance.logout();
+    }
+    this.emit(PLUGIN_EVENTS.DISCONNECTED);
+    this.status = PLUGIN_STATUS.DISCONNECTED;
+  }
+}
+const walletServicesPlugin = () => {
+  return () => {
+    return new WalletServicesPlugin();
+  };
+};
+
+export { walletServicesPlugin };

package/dist/lib.esm/providers/account-abstraction-provider/index.js

@@ -0,0 +1,2 @@
+export { accountAbstractionProvider } from './providers/AccountAbstractionProvider.js';
+export { BiconomySmartAccount, KernelSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';

package/dist/lib.esm/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -0,0 +1,227 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { SMART_ACCOUNT } from '@toruslabs/ethereum-controllers';
+export { SMART_ACCOUNT } from '@toruslabs/ethereum-controllers';
+import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { defineChain, createPublicClient, http } from 'viem';
+import { createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
+import { CHAIN_NAMESPACES } from '../../../base/chain/IChainInterface.js';
+import { WalletInitializationError } from '../../../base/errors/index.js';
+import { BaseProvider } from '../../base-provider/baseProvider.js';
+import { createAaMiddleware, eoaProviderAsMiddleware } from '../rpc/ethRpcMiddlewares.js';
+import { getProviderHandlers } from './utils.js';
+
+var _AccountAbstractionProvider;
+class AccountAbstractionProvider extends BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "_smartAccount", void 0);
+    _defineProperty(this, "_publicClient", void 0);
+    _defineProperty(this, "_bundlerClient", void 0);
+    _defineProperty(this, "_paymasterClient", void 0);
+    this.update({
+      chainId: config.chain.chainId
+    });
+  }
+  get smartAccount() {
+    return this._smartAccount;
+  }
+  get bundlerClient() {
+    return this._bundlerClient;
+  }
+  get paymasterClient() {
+    return this._paymasterClient;
+  }
+  get publicClient() {
+    return this._publicClient;
+  }
+  async enable() {
+    if (!this.state.eoaProvider) throw providerErrors.custom({
+      message: "eoaProvider is not found in state, please pass it",
+      code: 4902
+    });
+    await this.setupProvider(this.state.eoaProvider);
+    return this._providerEngineProxy.request({
+      method: "eth_accounts"
+    });
+  }
+  async setupProvider(eoaProvider) {
+    var _this$config$bundlerC;
+    const {
+      currentChain
+    } = this;
+    const {
+      chainNamespace
+    } = currentChain;
+    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    const chain = defineChain({
+      id: Number.parseInt(currentChain.chainId, 16),
+      // id in number form
+      name: currentChain.displayName,
+      rpcUrls: {
+        default: {
+          http: [currentChain.rpcTarget],
+          webSocket: [currentChain.wsTarget]
+        }
+      },
+      blockExplorers: currentChain.blockExplorerUrl ? {
+        default: {
+          name: "explorer",
+          // TODO: correct name if chain config has it
+          url: currentChain.blockExplorerUrl
+        }
+      } : undefined,
+      nativeCurrency: {
+        name: currentChain.tickerName,
+        symbol: currentChain.ticker,
+        decimals: currentChain.decimals || 18
+      }
+    });
+    // setup public client for viem smart account
+    this._publicClient = createPublicClient({
+      chain,
+      transport: http(currentChain.rpcTarget)
+    });
+    this._smartAccount = await this.config.smartAccountInit.getSmartAccount({
+      owner: eoaProvider,
+      client: this._publicClient
+    });
+
+    // setup bundler and paymaster
+    if (this.config.paymasterConfig) {
+      var _this$config$paymaste;
+      this._paymasterClient = createPaymasterClient(_objectSpread(_objectSpread({}, this.config.paymasterConfig), {}, {
+        transport: (_this$config$paymaste = this.config.paymasterConfig.transport) !== null && _this$config$paymaste !== void 0 ? _this$config$paymaste : http(this.config.paymasterConfig.url)
+      }));
+    }
+    this._bundlerClient = createBundlerClient(_objectSpread(_objectSpread({}, this.config.bundlerConfig), {}, {
+      account: this.smartAccount,
+      client: this._publicClient,
+      transport: (_this$config$bundlerC = this.config.bundlerConfig.transport) !== null && _this$config$bundlerC !== void 0 ? _this$config$bundlerC : http(this.config.bundlerConfig.url),
+      paymaster: this._paymasterClient
+    }));
+    const providerHandlers = getProviderHandlers({
+      bundlerClient: this._bundlerClient,
+      smartAccount: this._smartAccount,
+      chain,
+      eoaProvider
+    });
+
+    // setup rpc engine and AA middleware
+    const engine = new JRPCEngine();
+    const aaMiddleware = await createAaMiddleware({
+      eoaProvider,
+      handlers: providerHandlers
+    });
+    engine.push(aaMiddleware);
+    const eoaMiddleware = eoaProviderAsMiddleware(eoaProvider);
+    engine.push(eoaMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    eoaProvider.once("chainChanged", chainId => {
+      this.update({
+        chainId
+      });
+      this.setupChainSwitchMiddleware();
+      this.emit("chainChanged", chainId);
+    });
+  }
+  async updateAccount(_params) {
+    throw providerErrors.unsupportedMethod("updateAccount. Please call it on eoaProvider");
+  }
+  async switchChain(_params) {
+    throw providerErrors.unsupportedMethod("switchChain. Please call it on eoaProvider");
+  }
+  async lookupNetwork() {
+    throw providerErrors.unsupportedMethod("lookupNetwork. Please call it on eoaProvider");
+  }
+  async setupChainSwitchMiddleware() {
+    return this.setupProvider(this.state.eoaProvider);
+  }
+}
+_AccountAbstractionProvider = AccountAbstractionProvider;
+_defineProperty(AccountAbstractionProvider, "getProviderInstance", async params => {
+  const providerInstance = new _AccountAbstractionProvider({
+    config: params
+  });
+  await providerInstance.setupProvider(params.eoaProvider);
+  providerInstance.update({
+    eoaProvider: params.eoaProvider
+  });
+  return providerInstance;
+});
+const accountAbstractionProvider = async ({
+  accountAbstractionConfig,
+  chain,
+  chains,
+  provider
+}) => {
+  let smartAccountInit;
+  const {
+    smartAccountType,
+    smartAccountConfig,
+    bundlerConfig,
+    paymasterConfig
+  } = accountAbstractionConfig;
+  switch (smartAccountType) {
+    case SMART_ACCOUNT.BICONOMY:
+      {
+        const {
+          BiconomySmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new BiconomySmartAccount(smartAccountConfig);
+        break;
+      }
+    case SMART_ACCOUNT.KERNEL:
+      {
+        const {
+          KernelSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new KernelSmartAccount(smartAccountConfig);
+        break;
+      }
+    case SMART_ACCOUNT.NEXUS:
+      {
+        const {
+          NexusSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new NexusSmartAccount(smartAccountConfig);
+        break;
+      }
+    case SMART_ACCOUNT.SAFE:
+      {
+        const {
+          SafeSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new SafeSmartAccount(smartAccountConfig);
+        break;
+      }
+    case SMART_ACCOUNT.TRUST:
+      {
+        const {
+          TrustSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new TrustSmartAccount(smartAccountConfig);
+        break;
+      }
+    default:
+      throw new Error("Smart account type not supported");
+  }
+  return AccountAbstractionProvider.getProviderInstance({
+    eoaProvider: provider,
+    smartAccountInit,
+    chain,
+    chains,
+    bundlerConfig,
+    paymasterConfig
+  });
+};
+
+export { accountAbstractionProvider };