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

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

@@ -1,28 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { toSafeSmartAccount } from 'permissionless/accounts';
-import { entryPoint07Address } from 'viem/account-abstraction';
-import { SMART_ACCOUNT } from './constants.js';
-
-class SafeSmartAccount {
-  constructor(options) {
-    _defineProperty(this, "name", SMART_ACCOUNT.SAFE);
-    _defineProperty(this, "options", void 0);
-    this.options = options;
-  }
-  async getSmartAccount(params) {
-    var _this$options, _this$options2, _this$options3;
-    return toSafeSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
-      entryPoint: {
-        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint07Address,
-        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.7"
-      },
-      version: ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.version) || "1.4.1"
-    }, params), {}, {
-      owners: [params.owner],
-      client: params.client
-    }));
-  }
-}
-
-export { SafeSmartAccount };

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

@@ -1,27 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { toTrustSmartAccount } from 'permissionless/accounts';
-import { entryPoint06Address } from 'viem/account-abstraction';
-import { SMART_ACCOUNT } from './constants.js';
-
-class TrustSmartAccount {
-  constructor(options) {
-    _defineProperty(this, "name", SMART_ACCOUNT.TRUST);
-    _defineProperty(this, "options", void 0);
-    this.options = options;
-  }
-  async getSmartAccount(params) {
-    var _this$options, _this$options2;
-    return toTrustSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
-      entryPoint: {
-        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint06Address,
-        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.6"
-      }
-    }, params), {}, {
-      owner: params.owner,
-      client: params.client
-    }));
-  }
-}
-
-export { TrustSmartAccount };

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

@@ -1,9 +0,0 @@
-const SMART_ACCOUNT = {
-  BICONOMY: "biconomy",
-  NEXUS: "nexus",
-  KERNEL: "kernel",
-  SAFE: "safe",
-  TRUST: "trust"
-};
-
-export { SMART_ACCOUNT };

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/EthereumPrivateKeyProvider.js

@@ -1,183 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { isHexString } from '@ethereumjs/util';
-import { providerErrors, JRPCEngine, providerFromEngine, rpcErrors } from '@web3auth/auth';
-import { CHAIN_NAMESPACES } from '../../../../base/chain/IChainInterface.js';
-import { WalletInitializationError } from '../../../../base/errors/index.js';
-import { createEthMiddleware, createEthChainSwitchMiddleware, createEthAccountMiddleware } from '../../rpc/ethRpcMiddlewares.js';
-import { createEthJsonRpcClient } from '../../rpc/jrpcClient.js';
-import { getProviderHandlers } from './ethPrivatekeyUtils.js';
-import { TransactionFormatter } from './TransactionFormatter/formatter.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
-
-var _EthereumPrivateKeyProvider;
-class EthereumPrivateKeyProvider extends BaseProvider {
-  constructor({
-    config,
-    state
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", CHAIN_NAMESPACES.EIP155);
-  }
-  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: "eth_accounts"
-    });
-  }
-  async setupProvider(privKey) {
-    const {
-      chainNamespace
-    } = this.config.chainConfig;
-    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
-    const txFormatter = new TransactionFormatter({
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this)
-    });
-    const providerHandlers = getProviderHandlers({
-      txFormatter,
-      privKey,
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this),
-      keyExportEnabled: this.config.keyExportEnabled
-    });
-    const ethMiddleware = createEthMiddleware(providerHandlers);
-    const chainSwitchMiddleware = this.getChainSwitchMiddleware();
-    const engine = new JRPCEngine();
-    // Not a partial anymore because of checks in ctor
-    const {
-      networkMiddleware
-    } = createEthJsonRpcClient(this.config.chainConfig);
-    engine.push(ethMiddleware);
-    engine.push(chainSwitchMiddleware);
-    engine.push(this.getAccountMiddleware());
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
-    this.updateProviderEngineProxy(provider);
-    await txFormatter.init();
-    await this.lookupNetwork();
-  }
-  async updateAccount(params) {
-    if (!this._providerEngineProxy) throw providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    const existingKey = await this._providerEngineProxy.request({
-      method: "eth_private_key"
-    });
-    if (existingKey !== params.privateKey) {
-      await this.setupProvider(params.privateKey);
-      const accounts = await this._providerEngineProxy.request({
-        method: "eth_accounts"
-      });
-      this.emit("accountsChanged", accounts);
-    }
-  }
-  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 privKey = await this._providerEngineProxy.request({
-      method: "eth_private_key"
-    });
-    await this.setupProvider(privKey);
-  }
-  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 network = await this._providerEngineProxy.request({
-      method: "net_version",
-      params: []
-    });
-    const finalNetwork = isHexString(network) ? parseInt(network, 16) : parseInt(network, 10);
-    if (parseInt(chainId, 16) !== finalNetwork) throw providerErrors.chainDisconnected(`Invalid network, net_version is: ${network}`);
-    if (this.state.chainId !== chainId) {
-      this.emit("chainChanged", chainId);
-      this.emit("connect", {
-        chainId
-      });
-    }
-    this.update({
-      chainId
-    });
-    return network;
-  }
-  getChainSwitchMiddleware() {
-    const chainSwitchHandlers = {
-      addChain: async params => {
-        const {
-          chainId,
-          chainName,
-          rpcUrls,
-          blockExplorerUrls,
-          nativeCurrency,
-          iconUrls
-        } = params;
-        this.addChain({
-          chainNamespace: CHAIN_NAMESPACES.EIP155,
-          chainId,
-          ticker: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.symbol) || "ETH",
-          tickerName: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.name) || "Ether",
-          displayName: chainName,
-          rpcTarget: rpcUrls[0],
-          blockExplorerUrl: (blockExplorerUrls === null || blockExplorerUrls === void 0 ? void 0 : blockExplorerUrls[0]) || "",
-          decimals: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.decimals) || 18,
-          logo: (iconUrls === null || iconUrls === void 0 ? void 0 : iconUrls[0]) || "https://images.toruswallet.io/eth.svg"
-        });
-      },
-      switchChain: async params => {
-        const {
-          chainId
-        } = params;
-        await this.switchChain({
-          chainId
-        });
-      }
-    };
-    const chainSwitchMiddleware = createEthChainSwitchMiddleware(chainSwitchHandlers);
-    return chainSwitchMiddleware;
-  }
-  getAccountMiddleware() {
-    const accountHandlers = {
-      updatePrivatekey: async params => {
-        const {
-          privateKey
-        } = params;
-        await this.updateAccount({
-          privateKey
-        });
-      }
-    };
-    return createEthAccountMiddleware(accountHandlers);
-  }
-}
-_EthereumPrivateKeyProvider = EthereumPrivateKeyProvider;
-_defineProperty(EthereumPrivateKeyProvider, "getProviderInstance", async params => {
-  const providerFactory = new _EthereumPrivateKeyProvider({
-    config: {
-      chainConfig: params.chainConfig
-    }
-  });
-  await providerFactory.setupProvider(params.privKey);
-  return providerFactory;
-});
-
-export { EthereumPrivateKeyProvider };

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/ethPrivatekeyUtils.js

@@ -1,104 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { isHexString, stripHexPrefix, addHexPrefix, privateToAddress } from '@ethereumjs/util';
-import { signMessage } from '@toruslabs/base-controllers';
-import { getPublicCompressed } from '@toruslabs/eccrypto';
-import { providerErrors } from '@web3auth/auth';
-import { SigningKey, hashMessage } from 'ethers';
-import { validateTypedData, hashTypedData } from 'viem';
-import { log } from '../../../../base/loglevel.js';
-import { validateTypedSignMessageDataV4 } from './TransactionFormatter/utils.js';
-
-async function signTx(txParams, privKey, txFormatter) {
-  const finalTxParams = await txFormatter.formatTransaction(txParams);
-  const {
-    Transaction
-  } = await import('ethers');
-  const ethTx = Transaction.from(_objectSpread(_objectSpread({}, finalTxParams), {}, {
-    from: undefined // from is already calculated inside Transaction.from and is not allowed to be passed in
-  }));
-  const signKey = new SigningKey(addHexPrefix(privKey));
-  ethTx.signature = signKey.sign(ethTx.unsignedHash);
-  return ethTx.serialized;
-}
-function getProviderHandlers({
-  txFormatter,
-  privKey,
-  keyExportEnabled,
-  getProviderEngineProxy
-}) {
-  return {
-    getAccounts: async _ => [`0x${Buffer.from(privateToAddress(Buffer.from(privKey, "hex"))).toString("hex")}`],
-    getPublicKey: async _ => {
-      const publicKey = getPublicCompressed(Buffer.from(stripHexPrefix(privKey), "hex"));
-      return `0x${Buffer.from(publicKey).toString("hex")}`;
-    },
-    getPrivateKey: async _ => {
-      if (!keyExportEnabled) throw providerErrors.custom({
-        message: "Private key export is disabled",
-        code: 4902
-      });
-      return privKey;
-    },
-    processTransaction: async (txParams, _) => {
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
-      const serializedTx = await signTx(txParams, privKey, txFormatter);
-      const txHash = await providerEngineProxy.request({
-        method: "eth_sendRawTransaction",
-        params: [serializedTx]
-      });
-      return txHash;
-    },
-    processSignTransaction: async (txParams, _) => {
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
-      const serializedTx = await signTx(txParams, privKey, txFormatter);
-      return serializedTx;
-    },
-    processEthSignMessage: async (msgParams, _) => {
-      const rawMessageSig = signMessage(privKey, msgParams.data);
-      return rawMessageSig;
-    },
-    processPersonalMessage: async (msgParams, _) => {
-      const privKeyBuffer = Buffer.from(privKey, "hex");
-      const ethersKey = new SigningKey(privKeyBuffer);
-      const {
-        data
-      } = msgParams;
-      // we need to check if the data is hex or not
-      // For historical reasons, you must submit the message to sign in hex-encoded UTF-8.
-      // https://docs.metamask.io/wallet/how-to/sign-data/#use-personal_sign
-      const message = isHexString(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
-      const signature = ethersKey.sign(hashMessage(message));
-      return signature.serialized;
-    },
-    processTypedMessageV4: async (msgParams, _) => {
-      log.debug("processTypedMessageV4", msgParams);
-      const privKeyBuffer = Buffer.from(privKey, "hex");
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      const chainId = await providerEngineProxy.request({
-        method: "eth_chainId"
-      });
-      await validateTypedSignMessageDataV4(msgParams, chainId);
-      const data = typeof msgParams.data === "string" ? JSON.parse(msgParams.data) : msgParams.data;
-      const ethersPrivateKey = new SigningKey(privKeyBuffer);
-      validateTypedData(data);
-      const signature = ethersPrivateKey.sign(hashTypedData(data)).serialized;
-      return signature;
-    }
-  };
-}
-
-export { getProviderHandlers };

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/injectedProviderProxy.js

@@ -1,10 +0,0 @@
-import { createAsyncMiddleware } from '@web3auth/auth';
-
-function createInjectedProviderProxyMiddleware(provider) {
-  return createAsyncMiddleware(async (req, res, _next) => {
-    const result = await provider.request(req);
-    res.result = result;
-  });
-}
-
-export { createInjectedProviderProxyMiddleware };

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/torus/providerHandlers.js

@@ -1,73 +0,0 @@
-import { rpcErrors } from '@web3auth/auth';
-
-const getTorusHandlers = injectedProvider => {
-  const providerHandlers = {
-    requestAccounts: async () => {
-      const accounts = await injectedProvider.request({
-        method: "solana_requestAccounts",
-        params: {}
-      });
-      return accounts;
-    },
-    getPublicKey: async () => {
-      const publicKeys = await injectedProvider.request({
-        method: "solana_requestAccounts",
-        params: {}
-      });
-      return publicKeys[0];
-    },
-    getAccounts: async () => {
-      const accounts = await injectedProvider.request({
-        method: "solana_requestAccounts",
-        params: {}
-      });
-      return accounts;
-    },
-    getPrivateKey: async () => {
-      throw rpcErrors.methodNotSupported();
-    },
-    getSecretKey: async () => {
-      throw rpcErrors.methodNotSupported();
-    },
-    signMessage: async req => {
-      var _req$params;
-      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message)) {
-        throw rpcErrors.invalidParams("message");
-      }
-      const message = await injectedProvider.signMessage(req.params.message);
-      return message;
-    },
-    signTransaction: async req => {
-      var _req$params2;
-      if (!((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message)) {
-        throw rpcErrors.invalidParams("message");
-      }
-      const txMessage = req.params.message;
-      const response = await injectedProvider.signTransaction(txMessage);
-      return response;
-    },
-    signAndSendTransaction: async req => {
-      var _req$params3;
-      if (!((_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.message)) {
-        throw rpcErrors.invalidParams("message");
-      }
-      const txMessage = req.params.message;
-      const response = await injectedProvider.sendTransaction(txMessage);
-      return {
-        signature: response
-      };
-    },
-    signAllTransactions: async req => {
-      var _req$params4, _req$params5;
-      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 transactions = req.params.message;
-      const response = await injectedProvider.signAllTransactions(transactions);
-      return response;
-    }
-  };
-  return providerHandlers;
-};
-
-export { getTorusHandlers };

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/torus/torusInjectedProvider.js

@@ -1,107 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
-import { WalletInitializationError } from '../../../../../base/errors/index.js';
-import { isHexStrict } from '../../../../../base/utils.js';
-import { createSolanaMiddleware } from '../../../rpc/solanaRpcMiddlewares.js';
-import { createInjectedProviderProxyMiddleware } from '../injectedProviderProxy.js';
-import { getTorusHandlers } from './providerHandlers.js';
-import { BaseProvider } from '../../../../base-provider/baseProvider.js';
-
-class TorusInjectedProvider extends BaseProvider {
-  constructor({
-    config,
-    state
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", "solana");
-  }
-  async switchChain(params) {
-    // overrides the base provider implementation
-    await this.provider.request({
-      method: "switchSolanaChain",
-      params: [{
-        chainId: params.chainId
-      }]
-    });
-  }
-  async addChain(chainConfig) {
-    super.addChain(chainConfig);
-    await this.provider.request({
-      method: "addNewChainConfig",
-      params: [{
-        chainId: chainConfig.chainId,
-        chainName: chainConfig.displayName,
-        rpcUrls: [chainConfig.rpcTarget],
-        blockExplorerUrls: [chainConfig.blockExplorerUrl],
-        iconUrls: [chainConfig.logo],
-        nativeCurrency: {
-          name: chainConfig.tickerName,
-          symbol: chainConfig.ticker,
-          decimals: chainConfig.decimals || 18
-        }
-      }]
-    });
-  }
-  async setupProvider(injectedProvider) {
-    this.handleInjectedProviderUpdate(injectedProvider);
-    const {
-      chainNamespace
-    } = this.config.chainConfig;
-    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
-    await this.setupEngine(injectedProvider);
-  }
-  async lookupNetwork() {
-    if (!this.provider) throw providerErrors.custom({
-      message: "Torus solana provider is not initialized",
-      code: 4902
-    });
-    const {
-      chainId
-    } = this.config.chainConfig;
-    const connectedChainId = await this.provider.request({
-      method: "solana_chainId"
-    });
-    const connectedHexChainId = isHexStrict(connectedChainId.toString()) ? connectedChainId : `0x${parseInt(connectedChainId, 10).toString(16)}`;
-    if (chainId !== connectedHexChainId) throw WalletInitializationError.rpcConnectionError(`Invalid network, net_version is: ${connectedHexChainId}, expected: ${chainId}`);
-    this.update({
-      chainId: connectedHexChainId
-    });
-    this.emit("connect", {
-      chainId: this.state.chainId
-    });
-    this.emit("chainChanged", this.state.chainId);
-    return this.state.chainId;
-  }
-  async setupEngine(injectedProvider) {
-    const providerHandlers = getTorusHandlers(injectedProvider);
-    const solanaMiddleware = createSolanaMiddleware(providerHandlers);
-    const injectedProviderProxy = createInjectedProviderProxyMiddleware(injectedProvider);
-    const engine = new JRPCEngine();
-    engine.push(solanaMiddleware);
-    engine.push(injectedProviderProxy);
-    const provider = providerFromEngine(engine);
-    this.updateProviderEngineProxy(provider);
-    await this.lookupNetwork();
-  }
-  async handleInjectedProviderUpdate(injectedProvider) {
-    injectedProvider.on("accountsChanged", async accounts => {
-      this.emit("accountsChanged", accounts);
-    });
-    injectedProvider.on("chainChanged", async chainId => {
-      const connectedHexChainId = isHexStrict(chainId) ? chainId : `0x${parseInt(chainId, 10).toString(16)}`;
-      // Check if chainId changed and trigger event
-      this.configure({
-        chainConfig: _objectSpread(_objectSpread({}, this.config.chainConfig), {}, {
-          chainId: connectedHexChainId
-        })
-      });
-      await this.setupProvider(injectedProvider);
-    });
-  }
-}
-
-export { TorusInjectedProvider };