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

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

@@ -0,0 +1,134 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var loglevel = require('loglevel');
+var enums = require('./enums.js');
+var utils = require('./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 = enums.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", baseControllers.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 = enums.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(enums.NFT_CHECKOUT_URLS[this.buildEnv]);
+    const hashParams = new URLSearchParams();
+    hashParams.append("origin", window.location.origin);
+    nftCheckoutIframeUrl.hash = hashParams.toString();
+
+    // create iframe
+    const colorScheme = utils.getTheme((whiteLabel === null || whiteLabel === void 0 ? void 0 : whiteLabel.mode) || auth.THEME_MODES.light);
+    const nftCheckoutIframe = utils.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 === enums.NFT_CHECKOUT_EMBED_MESSAGE_TYPES.SETUP_COMPLETE) {
+            // send init params here
+            nftCheckoutIframe.contentWindow.postMessage({
+              type: enums.NFT_CHECKOUT_EMBED_MESSAGE_TYPES.INIT,
+              clientId: this.clientId,
+              whiteLabel
+            }, nftCheckoutIframeUrl.origin);
+            this.isInitialized = true;
+            resolve();
+          } else if (ev.data.type === enums.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(enums.NFT_CHECKOUT_URLS[this.buildEnv]).origin;
+    nftCheckoutIframe.contentWindow.postMessage({
+      type: enums.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;
+  }
+}
+
+exports.NFTCheckoutEmbed = NFTCheckoutEmbed;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+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"
+};
+
+exports.NFT_CHECKOUT_BUILD_ENV = NFT_CHECKOUT_BUILD_ENV;
+exports.NFT_CHECKOUT_EMBED_MESSAGE_TYPES = NFT_CHECKOUT_EMBED_MESSAGE_TYPES;
+exports.NFT_CHECKOUT_URLS = NFT_CHECKOUT_URLS;

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

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

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var auth = require('@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 === auth.THEME_MODES.light) return "light";
+  if (theme === auth.THEME_MODES.dark) return "dark";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+};
+
+exports.getTheme = getTheme;
+exports.htmlToElement = htmlToElement;

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

@@ -0,0 +1,129 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var auth = require('@web3auth/auth');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var loglevel = require('../../base/loglevel.js');
+var index = require('../../base/wallet/index.js');
+var wsEmbed = require('@web3auth/ws-embed');
+var errors = require('../../base/plugin/errors.js');
+var IPlugin = require('../../base/plugin/IPlugin.js');
+var constants = require('../../base/connector/constants.js');
+
+// TODO: support project config items here. incl. key export flag, multiple chains
+class WalletServicesPlugin extends auth.SafeEventEmitter {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", IPlugin.EVM_PLUGINS.WALLET_SERVICES);
+    _defineProperty(this, "status", IPlugin.PLUGIN_STATUS.DISCONNECTED);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", [index.WALLET_CONNECTORS.AUTH, index.WALLET_CONNECTORS.SFA]);
+    _defineProperty(this, "pluginNamespace", IPlugin.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 errors.WalletServicesPluginError.web3authRequired();
+    if (web3auth.provider && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw errors.WalletServicesPluginError.notInitialized();
+    const currentChainConfig = web3auth.currentChain;
+    if (![IChainInterface.CHAIN_NAMESPACES.EIP155, IChainInterface.CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig.chainNamespace)) throw errors.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(index.WALLET_CONNECTORS.AUTH);
+    if (!authInstance || !authInstance.wsEmbed) throw errors.WalletServicesPluginError.web3AuthNotConnected();
+    this.wsEmbedInstance = authInstance.wsEmbed;
+    this.isInitialized = true;
+    this.status = IPlugin.PLUGIN_STATUS.READY;
+    this.emit(IPlugin.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 errors.WalletServicesPluginError.notInitialized();
+    this.emit(IPlugin.PLUGIN_EVENTS.CONNECTING);
+    this.status = IPlugin.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 !== constants.CONNECTOR_STATUS.CONNECTED) {
+      throw errors.WalletServicesPluginError.web3AuthNotConnected();
+    } else if (!this.web3auth.provider) {
+      throw errors.WalletServicesPluginError.providerRequired();
+    }
+    try {
+      this.emit(IPlugin.PLUGIN_EVENTS.CONNECTED);
+      this.status = IPlugin.PLUGIN_STATUS.CONNECTED;
+    } catch (error) {
+      loglevel.log.error(error);
+      this.status = IPlugin.PLUGIN_STATUS.ERRORED;
+      this.emit(IPlugin.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 errors.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 errors.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 errors.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 errors.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 !== IPlugin.PLUGIN_STATUS.CONNECTED) throw errors.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(IPlugin.PLUGIN_EVENTS.DISCONNECTED);
+    this.status = IPlugin.PLUGIN_STATUS.DISCONNECTED;
+  }
+}
+const walletServicesPlugin = () => {
+  return () => {
+    return new WalletServicesPlugin();
+  };
+};
+
+Object.defineProperty(exports, "BUTTON_POSITION", {
+  enumerable: true,
+  get: function () { return wsEmbed.BUTTON_POSITION; }
+});
+Object.defineProperty(exports, "CONFIRMATION_STRATEGY", {
+  enumerable: true,
+  get: function () { return wsEmbed.CONFIRMATION_STRATEGY; }
+});
+exports.walletServicesPlugin = walletServicesPlugin;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var AccountAbstractionProvider = require('./providers/AccountAbstractionProvider.js');
+var ethereumControllers = require('@toruslabs/ethereum-controllers');
+
+
+
+exports.accountAbstractionProvider = AccountAbstractionProvider.accountAbstractionProvider;
+Object.defineProperty(exports, "BiconomySmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.BiconomySmartAccount; }
+});
+Object.defineProperty(exports, "KernelSmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.KernelSmartAccount; }
+});
+Object.defineProperty(exports, "NexusSmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.NexusSmartAccount; }
+});
+Object.defineProperty(exports, "SMART_ACCOUNT", {
+	enumerable: true,
+	get: function () { return ethereumControllers.SMART_ACCOUNT; }
+});
+Object.defineProperty(exports, "SafeSmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.SafeSmartAccount; }
+});
+Object.defineProperty(exports, "TrustSmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.TrustSmartAccount; }
+});

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

@@ -0,0 +1,232 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var ethereumControllers = require('@toruslabs/ethereum-controllers');
+var auth = require('@web3auth/auth');
+var viem = require('viem');
+var accountAbstraction = require('viem/account-abstraction');
+var IChainInterface = require('../../../base/chain/IChainInterface.js');
+var index = require('../../../base/errors/index.js');
+var baseProvider = require('../../base-provider/baseProvider.js');
+var ethRpcMiddlewares = require('../rpc/ethRpcMiddlewares.js');
+var utils = require('./utils.js');
+
+var _AccountAbstractionProvider;
+class AccountAbstractionProvider extends baseProvider.BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", IChainInterface.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 auth.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 index.WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    const chain = viem.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 = viem.createPublicClient({
+      chain,
+      transport: viem.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 = accountAbstraction.createPaymasterClient(_objectSpread(_objectSpread({}, this.config.paymasterConfig), {}, {
+        transport: (_this$config$paymaste = this.config.paymasterConfig.transport) !== null && _this$config$paymaste !== void 0 ? _this$config$paymaste : viem.http(this.config.paymasterConfig.url)
+      }));
+    }
+    this._bundlerClient = accountAbstraction.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 : viem.http(this.config.bundlerConfig.url),
+      paymaster: this._paymasterClient
+    }));
+    const providerHandlers = utils.getProviderHandlers({
+      bundlerClient: this._bundlerClient,
+      smartAccount: this._smartAccount,
+      chain,
+      eoaProvider
+    });
+
+    // setup rpc engine and AA middleware
+    const engine = new auth.JRPCEngine();
+    const aaMiddleware = await ethRpcMiddlewares.createAaMiddleware({
+      eoaProvider,
+      handlers: providerHandlers
+    });
+    engine.push(aaMiddleware);
+    const eoaMiddleware = ethRpcMiddlewares.eoaProviderAsMiddleware(eoaProvider);
+    engine.push(eoaMiddleware);
+    const provider = auth.providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    eoaProvider.once("chainChanged", chainId => {
+      this.update({
+        chainId
+      });
+      this.setupChainSwitchMiddleware();
+      this.emit("chainChanged", chainId);
+    });
+  }
+  async updateAccount(_params) {
+    throw auth.providerErrors.unsupportedMethod("updateAccount. Please call it on eoaProvider");
+  }
+  async switchChain(_params) {
+    throw auth.providerErrors.unsupportedMethod("switchChain. Please call it on eoaProvider");
+  }
+  async lookupNetwork() {
+    throw auth.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 ethereumControllers.SMART_ACCOUNT.BICONOMY:
+      {
+        const {
+          BiconomySmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new BiconomySmartAccount(smartAccountConfig);
+        break;
+      }
+    case ethereumControllers.SMART_ACCOUNT.KERNEL:
+      {
+        const {
+          KernelSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new KernelSmartAccount(smartAccountConfig);
+        break;
+      }
+    case ethereumControllers.SMART_ACCOUNT.NEXUS:
+      {
+        const {
+          NexusSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new NexusSmartAccount(smartAccountConfig);
+        break;
+      }
+    case ethereumControllers.SMART_ACCOUNT.SAFE:
+      {
+        const {
+          SafeSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new SafeSmartAccount(smartAccountConfig);
+        break;
+      }
+    case ethereumControllers.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
+  });
+};
+
+Object.defineProperty(exports, "SMART_ACCOUNT", {
+  enumerable: true,
+  get: function () { return ethereumControllers.SMART_ACCOUNT; }
+});
+exports.accountAbstractionProvider = accountAbstractionProvider;