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

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

@@ -1,11 +0,0 @@
-'use strict';
-
-const SMART_ACCOUNT = {
-  BICONOMY: "biconomy",
-  NEXUS: "nexus",
-  KERNEL: "kernel",
-  SAFE: "safe",
-  TRUST: "trust"
-};
-
-exports.SMART_ACCOUNT = SMART_ACCOUNT;

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

@@ -1,185 +0,0 @@
-'use strict';
-
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var util = require('@ethereumjs/util');
-var auth = require('@web3auth/auth');
-var IChainInterface = require('../../../../base/chain/IChainInterface.js');
-var index = require('../../../../base/errors/index.js');
-var ethRpcMiddlewares = require('../../rpc/ethRpcMiddlewares.js');
-var jrpcClient = require('../../rpc/jrpcClient.js');
-var ethPrivatekeyUtils = require('./ethPrivatekeyUtils.js');
-var formatter = require('./TransactionFormatter/formatter.js');
-var baseProvider = require('../../../base-provider/baseProvider.js');
-
-var _EthereumPrivateKeyProvider;
-class EthereumPrivateKeyProvider extends baseProvider.BaseProvider {
-  constructor({
-    config,
-    state
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", IChainInterface.CHAIN_NAMESPACES.EIP155);
-  }
-  async enable() {
-    if (!this.state.privateKey) throw auth.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 index.WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
-    const txFormatter = new formatter.TransactionFormatter({
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this)
-    });
-    const providerHandlers = ethPrivatekeyUtils.getProviderHandlers({
-      txFormatter,
-      privKey,
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this),
-      keyExportEnabled: this.config.keyExportEnabled
-    });
-    const ethMiddleware = ethRpcMiddlewares.createEthMiddleware(providerHandlers);
-    const chainSwitchMiddleware = this.getChainSwitchMiddleware();
-    const engine = new auth.JRPCEngine();
-    // Not a partial anymore because of checks in ctor
-    const {
-      networkMiddleware
-    } = jrpcClient.createEthJsonRpcClient(this.config.chainConfig);
-    engine.push(ethMiddleware);
-    engine.push(chainSwitchMiddleware);
-    engine.push(this.getAccountMiddleware());
-    engine.push(networkMiddleware);
-    const provider = auth.providerFromEngine(engine);
-    this.updateProviderEngineProxy(provider);
-    await txFormatter.init();
-    await this.lookupNetwork();
-  }
-  async updateAccount(params) {
-    if (!this._providerEngineProxy) throw auth.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 auth.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 auth.providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    const {
-      chainId
-    } = this.config.chainConfig;
-    if (!chainId) throw auth.rpcErrors.invalidParams("chainId is required while lookupNetwork");
-    const network = await this._providerEngineProxy.request({
-      method: "net_version",
-      params: []
-    });
-    const finalNetwork = util.isHexString(network) ? parseInt(network, 16) : parseInt(network, 10);
-    if (parseInt(chainId, 16) !== finalNetwork) throw auth.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: IChainInterface.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 = ethRpcMiddlewares.createEthChainSwitchMiddleware(chainSwitchHandlers);
-    return chainSwitchMiddleware;
-  }
-  getAccountMiddleware() {
-    const accountHandlers = {
-      updatePrivatekey: async params => {
-        const {
-          privateKey
-        } = params;
-        await this.updateAccount({
-          privateKey
-        });
-      }
-    };
-    return ethRpcMiddlewares.createEthAccountMiddleware(accountHandlers);
-  }
-}
-_EthereumPrivateKeyProvider = EthereumPrivateKeyProvider;
-_defineProperty(EthereumPrivateKeyProvider, "getProviderInstance", async params => {
-  const providerFactory = new _EthereumPrivateKeyProvider({
-    config: {
-      chainConfig: params.chainConfig
-    }
-  });
-  await providerFactory.setupProvider(params.privKey);
-  return providerFactory;
-});
-
-exports.EthereumPrivateKeyProvider = EthereumPrivateKeyProvider;

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

@@ -1,106 +0,0 @@
-'use strict';
-
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var util = require('@ethereumjs/util');
-var baseControllers = require('@toruslabs/base-controllers');
-var eccrypto = require('@toruslabs/eccrypto');
-var auth = require('@web3auth/auth');
-var ethers = require('ethers');
-var viem = require('viem');
-var loglevel = require('../../../../base/loglevel.js');
-var utils = require('./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 ethers.SigningKey(util.addHexPrefix(privKey));
-  ethTx.signature = signKey.sign(ethTx.unsignedHash);
-  return ethTx.serialized;
-}
-function getProviderHandlers({
-  txFormatter,
-  privKey,
-  keyExportEnabled,
-  getProviderEngineProxy
-}) {
-  return {
-    getAccounts: async _ => [`0x${Buffer.from(util.privateToAddress(Buffer.from(privKey, "hex"))).toString("hex")}`],
-    getPublicKey: async _ => {
-      const publicKey = eccrypto.getPublicCompressed(Buffer.from(util.stripHexPrefix(privKey), "hex"));
-      return `0x${Buffer.from(publicKey).toString("hex")}`;
-    },
-    getPrivateKey: async _ => {
-      if (!keyExportEnabled) throw auth.providerErrors.custom({
-        message: "Private key export is disabled",
-        code: 4902
-      });
-      return privKey;
-    },
-    processTransaction: async (txParams, _) => {
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw auth.providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      if (txParams.input && !txParams.data) txParams.data = util.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 auth.providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      if (txParams.input && !txParams.data) txParams.data = util.addHexPrefix(txParams.input);
-      const serializedTx = await signTx(txParams, privKey, txFormatter);
-      return serializedTx;
-    },
-    processEthSignMessage: async (msgParams, _) => {
-      const rawMessageSig = baseControllers.signMessage(privKey, msgParams.data);
-      return rawMessageSig;
-    },
-    processPersonalMessage: async (msgParams, _) => {
-      const privKeyBuffer = Buffer.from(privKey, "hex");
-      const ethersKey = new ethers.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 = util.isHexString(data) ? Buffer.from(util.stripHexPrefix(data), "hex") : Buffer.from(data);
-      const signature = ethersKey.sign(ethers.hashMessage(message));
-      return signature.serialized;
-    },
-    processTypedMessageV4: async (msgParams, _) => {
-      loglevel.log.debug("processTypedMessageV4", msgParams);
-      const privKeyBuffer = Buffer.from(privKey, "hex");
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw auth.providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      const chainId = await providerEngineProxy.request({
-        method: "eth_chainId"
-      });
-      await utils.validateTypedSignMessageDataV4(msgParams, chainId);
-      const data = typeof msgParams.data === "string" ? JSON.parse(msgParams.data) : msgParams.data;
-      const ethersPrivateKey = new ethers.SigningKey(privKeyBuffer);
-      viem.validateTypedData(data);
-      const signature = ethersPrivateKey.sign(viem.hashTypedData(data)).serialized;
-      return signature;
-    }
-  };
-}
-
-exports.getProviderHandlers = getProviderHandlers;

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

@@ -1,12 +0,0 @@
-'use strict';
-
-var auth = require('@web3auth/auth');
-
-function createInjectedProviderProxyMiddleware(provider) {
-  return auth.createAsyncMiddleware(async (req, res, _next) => {
-    const result = await provider.request(req);
-    res.result = result;
-  });
-}
-
-exports.createInjectedProviderProxyMiddleware = createInjectedProviderProxyMiddleware;

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

@@ -1,75 +0,0 @@
-'use strict';
-
-var auth = require('@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 auth.rpcErrors.methodNotSupported();
-    },
-    getSecretKey: async () => {
-      throw auth.rpcErrors.methodNotSupported();
-    },
-    signMessage: async req => {
-      var _req$params;
-      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message)) {
-        throw auth.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 auth.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 auth.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 auth.rpcErrors.invalidParams("message");
-      }
-      const transactions = req.params.message;
-      const response = await injectedProvider.signAllTransactions(transactions);
-      return response;
-    }
-  };
-  return providerHandlers;
-};
-
-exports.getTorusHandlers = getTorusHandlers;

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

@@ -1,109 +0,0 @@
-'use strict';
-
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var auth = require('@web3auth/auth');
-var index = require('../../../../../base/errors/index.js');
-var utils = require('../../../../../base/utils.js');
-var solanaRpcMiddlewares = require('../../../rpc/solanaRpcMiddlewares.js');
-var injectedProviderProxy = require('../injectedProviderProxy.js');
-var providerHandlers = require('./providerHandlers.js');
-var baseProvider = require('../../../../base-provider/baseProvider.js');
-
-class TorusInjectedProvider extends baseProvider.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 index.WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
-    await this.setupEngine(injectedProvider);
-  }
-  async lookupNetwork() {
-    if (!this.provider) throw auth.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 = utils.isHexStrict(connectedChainId.toString()) ? connectedChainId : `0x${parseInt(connectedChainId, 10).toString(16)}`;
-    if (chainId !== connectedHexChainId) throw index.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$1 = providerHandlers.getTorusHandlers(injectedProvider);
-    const solanaMiddleware = solanaRpcMiddlewares.createSolanaMiddleware(providerHandlers$1);
-    const injectedProviderProxy$1 = injectedProviderProxy.createInjectedProviderProxyMiddleware(injectedProvider);
-    const engine = new auth.JRPCEngine();
-    engine.push(solanaMiddleware);
-    engine.push(injectedProviderProxy$1);
-    const provider = auth.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 = utils.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);
-    });
-  }
-}
-
-exports.TorusInjectedProvider = TorusInjectedProvider;