@web3auth/no-modal 9.6.0 → 10.0.0-alpha.0

package/dist/lib.esm/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyUtils.js

@@ -0,0 +1,101 @@
+import { Keypair, VersionedTransaction } from '@solana/web3.js';
+import { sign } from '@toruslabs/tweetnacl-js';
+import { rpcErrors, providerErrors } from '@web3auth/auth';
+import bs58 from 'bs58';
+import { WalletInitializationError } from '../../../../base/errors/index.js';
+
+async function getProviderHandlers({
+  privKey,
+  keyExportEnabled,
+  getProviderEngineProxy
+}) {
+  const keyPairGenerator = () => {
+    return Keypair.fromSecretKey(Buffer.from(privKey, "hex"));
+  };
+  if (typeof privKey !== "string") throw WalletInitializationError.invalidParams("privKey must be a string");
+  const keyPair = keyPairGenerator();
+  const providerHandlers = {
+    requestAccounts: async () => {
+      return [keyPair.publicKey.toBase58()];
+    },
+    getAccounts: async () => [keyPair.publicKey.toBase58()],
+    getPublicKey: async () => keyPair.publicKey.toBase58(),
+    getPrivateKey: async () => {
+      if (!keyExportEnabled) {
+        throw providerErrors.custom({
+          message: "Private key export is disabled",
+          code: 4902
+        });
+      }
+      return privKey;
+    },
+    getSecretKey: async () => bs58.encode(keyPair.secretKey),
+    signTransaction: async req => {
+      var _req$params;
+      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const transaction = req.params.message;
+      if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
+        transaction.sign([keyPair]);
+      } else {
+        transaction.partialSign(keyPair);
+      }
+      return transaction;
+    },
+    signMessage: async req => {
+      var _req$params2;
+      if (!((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const signedMsg = sign.detached(req.params.message, keyPair.secretKey);
+      return signedMsg;
+    },
+    signAndSendTransaction: async req => {
+      var _req$params3;
+      if (!((_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const _providerEngineProxy = getProviderEngineProxy();
+      if (!_providerEngineProxy) throw providerErrors.custom({
+        message: "Provider is not initialized",
+        code: 4902
+      });
+      const transaction = req.params.message;
+      if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
+        transaction.sign([keyPair]);
+      } else {
+        transaction.partialSign(keyPair);
+      }
+      const sig = await _providerEngineProxy.request({
+        method: "sendTransaction",
+        params: [Buffer.from(transaction.serialize()).toString("base64"), {
+          encoding: "base64",
+          preflightCommitment: "confirmed"
+        }]
+      });
+      return {
+        signature: sig
+      };
+    },
+    signAllTransactions: async req => {
+      var _req$params4, _req$params5, _req$params6;
+      if (!((_req$params4 = req.params) !== null && _req$params4 !== void 0 && _req$params4.message) || !((_req$params5 = req.params) !== null && _req$params5 !== void 0 && _req$params5.message.length)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const txns = (_req$params6 = req.params) === null || _req$params6 === void 0 ? void 0 : _req$params6.message;
+      for (const tx of txns || []) {
+        const transaction = tx;
+        if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
+          transaction.sign([keyPair]);
+        } else {
+          transaction.partialSign(keyPair);
+        }
+      }
+      return txns;
+    }
+  };
+  return providerHandlers;
+}
+
+export { getProviderHandlers };

package/dist/lib.esm/providers/solana-provider/rpc/JrpcClient.js

@@ -0,0 +1,42 @@
+import { createFetchMiddleware } from '@toruslabs/base-controllers';
+import { mergeMiddleware } from '@web3auth/auth';
+
+function createSolanaChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "solana_chainId") {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createSolanaProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "solana_provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createConfigMiddleware(providerConfig) {
+  const {
+    chainId
+  } = providerConfig;
+  return mergeMiddleware([createSolanaChainIdMiddleware(chainId), createSolanaProviderConfigMiddleware(providerConfig)]);
+}
+function createSolanaJsonRpcClient(providerConfig) {
+  const {
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = mergeMiddleware([createConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+export { createConfigMiddleware, createSolanaChainIdMiddleware, createSolanaJsonRpcClient, createSolanaProviderConfigMiddleware };

package/dist/lib.esm/providers/solana-provider/rpc/solanaRpcMiddlewares.js

@@ -0,0 +1,89 @@
+import { createAsyncMiddleware, mergeMiddleware } from '@web3auth/auth';
+
+function createGetAccountsMiddleware({
+  getAccounts
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== "getAccounts") return next();
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+    // This calls from the prefs controller
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createGetPublicKeyMiddleware({
+  getPublicKey
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== "getPublicKey") return next();
+    if (!getPublicKey) throw new Error("WalletMiddleware - opts.getPublicKey not provided");
+    const publicKey = await getPublicKey(request);
+    response.result = publicKey;
+    return undefined;
+  });
+}
+function createRequestAccountsMiddleware({
+  requestAccounts
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== "requestAccounts") return next();
+    if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
+    // This calls the UI login function
+    const accounts = await requestAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createGenericJRPCMiddleware(targetMethod, handler) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== targetMethod) return next();
+    if (!handler) throw new Error(`WalletMiddleware - ${targetMethod} not provided`);
+    const result = await handler(request);
+    response.result = result;
+    return undefined;
+  });
+}
+function createSolanaMiddleware(providerHandlers) {
+  const {
+    getAccounts,
+    requestAccounts,
+    signTransaction,
+    signAndSendTransaction,
+    signAllTransactions,
+    signMessage,
+    getPrivateKey,
+    getSecretKey,
+    getPublicKey
+  } = providerHandlers;
+  return mergeMiddleware([createRequestAccountsMiddleware({
+    requestAccounts
+  }), createGetAccountsMiddleware({
+    getAccounts
+  }), createGenericJRPCMiddleware("signTransaction", signTransaction), createGenericJRPCMiddleware("signAndSendTransaction", signAndSendTransaction), createGenericJRPCMiddleware("signAllTransactions", signAllTransactions), createGenericJRPCMiddleware("signMessage", signMessage), createGenericJRPCMiddleware("solanaPrivateKey", getPrivateKey), createGenericJRPCMiddleware("private_key", getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
+}
+function createSolanaChainSwitchMiddleware({
+  addNewChainConfig,
+  switchSolanaChain
+}) {
+  return mergeMiddleware([createGenericJRPCMiddleware("addSolanaChain", addNewChainConfig), createGenericJRPCMiddleware("switchSolanaChain", switchSolanaChain)]);
+}
+function createSolanaAccountMiddleware({
+  updatePrivatekey
+}) {
+  return mergeMiddleware([createGenericJRPCMiddleware("updateAccount", updatePrivatekey)]);
+}
+
+export { createGenericJRPCMiddleware, createGetAccountsMiddleware, createGetPublicKeyMiddleware, createRequestAccountsMiddleware, createSolanaAccountMiddleware, createSolanaChainSwitchMiddleware, createSolanaMiddleware };

package/dist/lib.esm/providers/solana-provider/solanaWallet.js

@@ -0,0 +1,60 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+class SolanaWallet {
+  constructor(provider) {
+    _defineProperty(this, "provider", void 0);
+    this.provider = provider;
+  }
+  async requestAccounts() {
+    const accounts = await this.provider.request({
+      method: "requestAccounts"
+    });
+    return accounts;
+  }
+  async signAndSendTransaction(transaction) {
+    const {
+      signature
+    } = await this.provider.request({
+      method: "signAndSendTransaction",
+      params: {
+        message: transaction
+      }
+    });
+    return {
+      signature
+    };
+  }
+  async signTransaction(transaction) {
+    const signedTransaction = await this.provider.request({
+      method: "signTransaction",
+      params: {
+        message: transaction
+      }
+    });
+    return signedTransaction;
+  }
+  async signAllTransactions(transactions) {
+    const signedTransactions = await this.provider.request({
+      method: "signAllTransactions",
+      params: {
+        message: transactions
+      }
+    });
+    return signedTransactions;
+  }
+  async signMessage(data) {
+    const response = await this.provider.request({
+      method: "signMessage",
+      params: {
+        message: data
+      }
+    });
+    return response;
+  }
+  async request(args) {
+    const result = await this.provider.request(args);
+    return result;
+  }
+}
+
+export { SolanaWallet };

package/dist/lib.esm/providers/xrpl-provider/providers/privateKeyProviders/xrplPrivateKeyProvider.js

@@ -0,0 +1,156 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { providerErrors, JRPCEngine, providerFromEngine, rpcErrors } from '@web3auth/auth';
+import { CHAIN_NAMESPACES } from '../../../../base/chain/IChainInterface.js';
+import { WalletInitializationError } from '../../../../base/errors/index.js';
+import { createXrplJsonRpcClient } from '../../rpc/JrpcClient.js';
+import { RPC_METHODS, createXRPLMiddleware, creatXrplChainSwitchMiddleware } from '../../rpc/xrplRpcMiddlewares.js';
+import { getProviderHandlers } from './xrplWalletUtils.js';
+import { BaseProvider } from '../../../base-provider/baseProvider.js';
+
+var _XrplPrivateKeyProvider;
+class XrplPrivateKeyProvider extends BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", CHAIN_NAMESPACES.XRPL);
+  }
+  async enable() {
+    if (!this.state.privateKey) throw providerErrors.custom({
+      message: "Private key is not found in state, plz pass it in constructor state param",
+      code: 4902
+    });
+    await this.setupProvider(this.state.privateKey);
+    return this._providerEngineProxy.request({
+      method: RPC_METHODS.GET_ACCOUNTS
+    });
+  }
+  async setupProvider(privKey) {
+    const {
+      wsTarget,
+      chainNamespace
+    } = this.config.chainConfig;
+    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    if (!wsTarget) {
+      throw WalletInitializationError.invalidParams(`wsTarget is required in chainConfig for xrplProvider`);
+    }
+    const providerHandlers = await getProviderHandlers({
+      privKey,
+      chainConfig: this.config.chainConfig,
+      keyExportEnabled: this.config.keyExportEnabled
+    });
+    const xrplWalletMiddleware = createXRPLMiddleware(providerHandlers);
+    const engine = new JRPCEngine();
+    const {
+      networkMiddleware
+    } = createXrplJsonRpcClient(this.config.chainConfig);
+    engine.push(this.getChainSwitchMiddleware());
+    engine.push(xrplWalletMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    await this.lookupNetwork();
+  }
+  async switchChain(params) {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const chainConfig = this.getChainConfig(params.chainId);
+    this.update({
+      chainId: "loading"
+    });
+    this.configure({
+      chainConfig
+    });
+    const {
+      privateKey
+    } = await this._providerEngineProxy.request({
+      method: RPC_METHODS.GET_KEY_PAIR
+    });
+    await this.setupProvider(privateKey);
+  }
+  async lookupNetwork() {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const {
+      chainId
+    } = this.config.chainConfig;
+    if (!chainId) throw rpcErrors.invalidParams("chainId is required while lookupNetwork");
+    const pingResponse = await this._providerEngineProxy.request({
+      method: "ping",
+      params: []
+    });
+    if ((pingResponse === null || pingResponse === void 0 ? void 0 : pingResponse.status) !== "success") {
+      const {
+        chainConfig
+      } = this.config;
+      throw WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chainConfig.rpcTarget}`);
+    }
+    if (this.state.chainId !== chainId) {
+      this.emit("chainChanged", chainId);
+      this.emit("connect", {
+        chainId
+      });
+    }
+    this.update({
+      chainId
+    });
+  }
+  getChainSwitchMiddleware() {
+    const chainSwitchHandlers = {
+      addChainConfig: async req => {
+        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
+        const {
+          chainId,
+          ticker,
+          tickerName,
+          displayName,
+          rpcTarget,
+          wsTarget,
+          blockExplorerUrl,
+          logo
+        } = req.params;
+        if (!chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
+        if (!rpcTarget) throw rpcErrors.invalidParams("Missing rpcTarget in chainParams");
+        if (!wsTarget) throw rpcErrors.invalidParams("Missing wsTarget in chainParams");
+        this.addChain({
+          chainNamespace: CHAIN_NAMESPACES.XRPL,
+          chainId,
+          ticker: ticker || "XRP",
+          tickerName: tickerName || "XRPL",
+          displayName: displayName || "XRPL",
+          rpcTarget,
+          wsTarget,
+          blockExplorerUrl,
+          logo
+        });
+      },
+      switchChain: async req => {
+        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
+        if (!req.params.chainId) throw rpcErrors.invalidParams("Missing chainId");
+        await this.switchChain(req.params);
+      }
+    };
+    const chainSwitchMiddleware = creatXrplChainSwitchMiddleware(chainSwitchHandlers);
+    return chainSwitchMiddleware;
+  }
+}
+_XrplPrivateKeyProvider = XrplPrivateKeyProvider;
+_defineProperty(XrplPrivateKeyProvider, "getProviderInstance", async params => {
+  const providerFactory = new _XrplPrivateKeyProvider({
+    config: {
+      chainConfig: params.chainConfig
+    }
+  });
+  await providerFactory.setupProvider(params.privKey);
+  return providerFactory;
+});
+
+export { XrplPrivateKeyProvider };

package/dist/lib.esm/providers/xrpl-provider/providers/privateKeyProviders/xrplWalletUtils.js

@@ -0,0 +1,87 @@
+import { rpcErrors, providerErrors } from '@web3auth/auth';
+import { sign, generateSeed } from 'ripple-keypairs';
+import { Client, Wallet, deriveAddress } from 'xrpl';
+import ECDSA from 'xrpl/dist/npm/ECDSA';
+
+const deriveKeypair = web3authKey => {
+  const seed = generateSeed({
+    entropy: Buffer.from(web3authKey.padStart(64, "0"), "hex"),
+    algorithm: "ecdsa-secp256k1"
+  });
+  const wallet = Wallet.fromSecret(seed, {
+    algorithm: ECDSA.secp256k1
+  }); // web3auth network currently only supports the secp256k1 key
+  return {
+    privateKey: wallet.privateKey,
+    publicKey: wallet.publicKey
+  };
+};
+async function getProviderHandlers({
+  privKey: web3authKey,
+  chainConfig,
+  keyExportEnabled
+}) {
+  const client = new Client(chainConfig.wsTarget);
+  await client.connect();
+  return {
+    getAccounts: async _ => {
+      const {
+        publicKey
+      } = deriveKeypair(web3authKey);
+      const accAddress = deriveAddress(publicKey);
+      return [accAddress];
+    },
+    getKeyPair: async _ => {
+      if (!keyExportEnabled) throw providerErrors.custom({
+        message: "Private key export is disabled",
+        code: 4902
+      });
+      return deriveKeypair(web3authKey);
+    },
+    getPublicKey: async _ => {
+      const keyPair = deriveKeypair(web3authKey);
+      return keyPair.publicKey;
+    },
+    signTransaction: async req => {
+      const {
+        transaction,
+        multisign
+      } = req.params || {};
+      if (!transaction) throw rpcErrors.invalidParams("Invalid params, req.params.transaction is required");
+      const {
+        publicKey,
+        privateKey
+      } = deriveKeypair(web3authKey);
+      const wallet = new Wallet(publicKey, privateKey);
+      return wallet.sign(transaction, multisign);
+    },
+    submitTransaction: async req => {
+      const {
+        transaction
+      } = req.params || {};
+      if (!transaction) throw rpcErrors.invalidParams("Invalid params, req.params.transaction is required");
+      const {
+        publicKey,
+        privateKey
+      } = deriveKeypair(web3authKey);
+      const wallet = new Wallet(publicKey, privateKey);
+      const res = await client.submit(transaction, {
+        wallet
+      });
+      return res;
+    },
+    signMessage: async req => {
+      const {
+        message
+      } = req.params || {};
+      if (!message) throw rpcErrors.invalidParams("Invalid params, req.params.message is required");
+      const keyPair = deriveKeypair(web3authKey);
+      const signature = sign(message, keyPair.privateKey);
+      return {
+        signature
+      };
+    }
+  };
+}
+
+export { getProviderHandlers };

package/dist/lib.esm/providers/xrpl-provider/rpc/JrpcClient.js

@@ -0,0 +1,43 @@
+import { createFetchMiddleware } from '@toruslabs/base-controllers';
+import { mergeMiddleware } from '@web3auth/auth';
+import { RPC_METHODS } from './xrplRpcMiddlewares.js';
+
+function createXrplChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === RPC_METHODS.CHAIN_ID) {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createXrplProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === RPC_METHODS.PROVIDER_CHAIN_CONFIG) {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createConfigMiddleware(providerConfig) {
+  const {
+    chainId
+  } = providerConfig;
+  return mergeMiddleware([createXrplChainIdMiddleware(chainId), createXrplProviderConfigMiddleware(providerConfig)]);
+}
+function createXrplJsonRpcClient(providerConfig) {
+  const {
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = mergeMiddleware([createConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+export { createConfigMiddleware, createXrplChainIdMiddleware, createXrplJsonRpcClient, createXrplProviderConfigMiddleware };

package/dist/lib.esm/providers/xrpl-provider/rpc/xrplRpcMiddlewares.js

@@ -0,0 +1,67 @@
+import { randomId } from '@toruslabs/base-controllers';
+import { mergeMiddleware, createAsyncMiddleware } from '@web3auth/auth';
+
+const RPC_METHODS = {
+  GET_ACCOUNTS: "xrpl_getAccounts",
+  GET_KEY_PAIR: "xrpl_getKeyPair",
+  GET_PUBLIC_KEY: "xrpl_getPublicKey",
+  SIGN_MESSAGE: "xrpl_signMessage",
+  SIGN_TRANSACTION: "xrpl_signTransaction",
+  SUBMIT_TRANSACTION: "xrpl_submitTransaction",
+  ADD_CHAIN: "xrpl_addChain",
+  SWITCH_CHAIN: "xrpl_switchChain",
+  CHAIN_ID: "xrpl_chainId",
+  PROVIDER_CHAIN_CONFIG: "xrpl_providerChainConfig"
+};
+function createGetAccountsMiddleware({
+  getAccounts
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+
+    // hack to override big ids from fetch middleware which are not supported in xrpl servers
+    // TODO: fix this for xrpl controllers.
+    request.id = randomId();
+    if (method !== RPC_METHODS.GET_ACCOUNTS) return next();
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+    // This calls from the prefs controller
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createGenericJRPCMiddleware(targetMethod, handler) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== targetMethod) return next();
+    if (!handler) throw new Error(`WalletMiddleware - ${targetMethod} not provided`);
+    const result = await handler(request);
+    response.result = result;
+    return undefined;
+  });
+}
+function createXRPLMiddleware(providerHandlers) {
+  const {
+    getAccounts,
+    submitTransaction,
+    signTransaction,
+    signMessage,
+    getKeyPair,
+    getPublicKey
+  } = providerHandlers;
+  return mergeMiddleware([createGetAccountsMiddleware({
+    getAccounts
+  }), createGenericJRPCMiddleware(RPC_METHODS.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(RPC_METHODS.SUBMIT_TRANSACTION, submitTransaction), createGenericJRPCMiddleware(RPC_METHODS.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(RPC_METHODS.GET_KEY_PAIR, getKeyPair), createGenericJRPCMiddleware(RPC_METHODS.GET_PUBLIC_KEY, getPublicKey)]);
+}
+function creatXrplChainSwitchMiddleware({
+  addChainConfig,
+  switchChain
+}) {
+  return mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.ADD_CHAIN, addChainConfig), createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+}
+
+export { RPC_METHODS, creatXrplChainSwitchMiddleware, createGenericJRPCMiddleware, createGetAccountsMiddleware, createXRPLMiddleware };

package/dist/lib.esm/react/index.js

@@ -0,0 +1,5 @@
+export { useWeb3Auth } from './no-modal/hooks/useWeb3Auth.js';
+export { Web3AuthProvider } from './no-modal/Web3AuthProvider.js';
+export { useWalletServicesPlugin } from './wallet-services-plugin/hooks/useWalletServicesPlugin.js';
+export { WalletServicesContext, WalletServicesContextProvider } from './wallet-services-plugin/WalletServicesContext.js';
+export { WalletServicesProvider } from './wallet-services-plugin/WalletServicesProvider.js';