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

package/dist/lib.cjs/providers/ethereum-provider/rpc/ethRpcMiddlewares.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var auth = require('@web3auth/auth');
+var walletMidddleware = require('./walletMidddleware.js');
+
+function createEthMiddleware(providerHandlers) {
+  const {
+    getAccounts,
+    getPrivateKey,
+    getPublicKey,
+    processTransaction,
+    processSignTransaction,
+    processEthSignMessage,
+    processTypedMessageV4,
+    processPersonalMessage
+  } = providerHandlers;
+  const ethMiddleware = auth.mergeMiddleware([auth.createScaffoldMiddleware({
+    eth_syncing: false
+  }), walletMidddleware.createWalletMiddleware({
+    getAccounts,
+    getPrivateKey,
+    getPublicKey,
+    processTransaction,
+    processEthSignMessage,
+    processSignTransaction,
+    processTypedMessageV4,
+    processPersonalMessage
+  })]);
+  return ethMiddleware;
+}
+function createEthChainSwitchMiddleware({
+  addChain,
+  switchChain
+}) {
+  async function addNewChain(req, res) {
+    var _req$params;
+    const chainParams = (_req$params = req.params) !== null && _req$params !== void 0 && _req$params.length ? req.params[0] : undefined;
+    if (!chainParams) throw auth.rpcErrors.invalidParams("Missing chain params");
+    if (!chainParams.chainId) throw auth.rpcErrors.invalidParams("Missing chainId in chainParams");
+    if (!chainParams.rpcUrls || chainParams.rpcUrls.length === 0) throw auth.rpcErrors.invalidParams("Missing rpcUrls in chainParams");
+    if (!chainParams.nativeCurrency) throw auth.rpcErrors.invalidParams("Missing nativeCurrency in chainParams");
+    res.result = await addChain(chainParams);
+  }
+  async function updateChain(req, res) {
+    var _req$params2;
+    const chainParams = (_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.length ? req.params[0] : undefined;
+    if (!chainParams) throw auth.rpcErrors.invalidParams("Missing chainId");
+    res.result = await switchChain(chainParams);
+  }
+  return auth.createScaffoldMiddleware({
+    wallet_addEthereumChain: auth.createAsyncMiddleware(addNewChain),
+    wallet_switchEthereumChain: auth.createAsyncMiddleware(updateChain)
+  });
+}
+
+// #region account middlewares
+function createEthAccountMiddleware({
+  updatePrivatekey
+}) {
+  async function updateAccount(req, res) {
+    var _req$params3;
+    const accountParams = (_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.length ? req.params[0] : undefined;
+    if (!(accountParams !== null && accountParams !== void 0 && accountParams.privateKey)) throw auth.rpcErrors.invalidParams("Missing privateKey");
+    res.result = await updatePrivatekey(accountParams);
+  }
+  return auth.createScaffoldMiddleware({
+    wallet_updateAccount: auth.createAsyncMiddleware(updateAccount)
+  });
+}
+
+// #endregion account middlewares
+
+exports.createEthAccountMiddleware = createEthAccountMiddleware;
+exports.createEthChainSwitchMiddleware = createEthChainSwitchMiddleware;
+exports.createEthMiddleware = createEthMiddleware;

package/dist/lib.cjs/providers/ethereum-provider/rpc/jrpcClient.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+
+function createEthChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_chainId") {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createEthProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createEthJsonRpcClient(providerConfig) {
+  const {
+    chainId,
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = baseControllers.createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = auth.mergeMiddleware([createEthChainIdMiddleware(chainId), createEthProviderConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+exports.createEthChainIdMiddleware = createEthChainIdMiddleware;
+exports.createEthJsonRpcClient = createEthJsonRpcClient;
+exports.createEthProviderConfigMiddleware = createEthProviderConfigMiddleware;

package/dist/lib.cjs/providers/ethereum-provider/rpc/walletMidddleware.js

@@ -0,0 +1,179 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var auth = require('@web3auth/auth');
+
+function createWalletMiddleware({
+  getAccounts,
+  getPrivateKey,
+  getPublicKey,
+  processEthSignMessage,
+  processPersonalMessage,
+  processTransaction,
+  processSignTransaction,
+  processTypedMessageV4
+}) {
+  if (!getAccounts) {
+    throw new Error("opts.getAccounts is required");
+  }
+
+  //
+  // utility
+  //
+
+  /**
+   * Validates the keyholder address, and returns a normalized (i.e. lowercase)
+   * copy of it.
+   *
+   * an error
+   */
+  async function validateAndNormalizeKeyholder(address, req) {
+    if (typeof address === "string" && address.length > 0) {
+      // ensure address is included in provided accounts
+      const accounts = await getAccounts(req);
+      const normalizedAccounts = accounts.map(_address => _address.toLowerCase());
+      const normalizedAddress = address.toLowerCase();
+      if (normalizedAccounts.includes(normalizedAddress)) {
+        return normalizedAddress;
+      }
+    }
+    throw auth.rpcErrors.invalidParams({
+      message: `Invalid parameters: must provide an Ethereum address.`
+    });
+  }
+
+  //
+  // account lookups
+  //
+
+  async function lookupAccounts(req, res) {
+    res.result = await getAccounts(req);
+  }
+
+  //
+  // transaction signatures
+  //
+
+  async function sendTransaction(req, res) {
+    if (!processTransaction) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    const txParams = req.params[0] || {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    res.result = await processTransaction(txParams, req);
+  }
+  async function signTransaction(req, res) {
+    if (!processSignTransaction) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    const txParams = req.params[0] || {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    res.result = await processSignTransaction(txParams, req);
+  }
+
+  //
+  // message signatures
+  //
+
+  async function ethSign(req, res) {
+    if (!processEthSignMessage) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    let msgParams = req.params;
+    const extraParams = req.params[2] || {};
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [address, message]`);
+      const params = req.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
+    res.result = await processEthSignMessage(msgParams, req);
+  }
+  async function signTypedDataV4(req, res) {
+    if (!processTypedMessageV4) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    if (!(req !== null && req !== void 0 && req.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = req.params;
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [address, typedData]`);
+      const params = req.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    res.result = await processTypedMessageV4(msgParams, req);
+  }
+  async function personalSign(req, res) {
+    if (!processPersonalMessage) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    let msgParams = req.params;
+    const extraParams = req.params[2] || {};
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [message, address]`);
+      const params = req.params;
+      if (typeof params[0] === "object") {
+        const {
+          challenge,
+          address
+        } = params[0];
+        msgParams = {
+          from: address,
+          data: challenge
+        };
+      } else {
+        const message = params[0];
+        const address = params[1];
+        msgParams = {
+          from: address,
+          data: message
+        };
+      }
+    }
+    msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
+    res.result = await processPersonalMessage(msgParams, req);
+  }
+  async function fetchPrivateKey(req, res) {
+    if (!getPrivateKey) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    res.result = await getPrivateKey(req);
+  }
+  async function fetchPublicKey(req, res) {
+    if (!getPublicKey) {
+      throw auth.rpcErrors.methodNotSupported();
+    }
+    res.result = await getPublicKey(req);
+  }
+  return auth.createScaffoldMiddleware({
+    // account lookups
+    eth_accounts: auth.createAsyncMiddleware(lookupAccounts),
+    eth_requestAccounts: auth.createAsyncMiddleware(lookupAccounts),
+    eth_private_key: auth.createAsyncMiddleware(fetchPrivateKey),
+    eth_public_key: auth.createAsyncMiddleware(fetchPublicKey),
+    public_key: auth.createAsyncMiddleware(fetchPublicKey),
+    private_key: auth.createAsyncMiddleware(fetchPrivateKey),
+    // tx signatures
+    eth_sendTransaction: auth.createAsyncMiddleware(sendTransaction),
+    eth_signTransaction: auth.createAsyncMiddleware(signTransaction),
+    // message signatures
+    eth_sign: auth.createAsyncMiddleware(ethSign),
+    eth_signTypedData_v4: auth.createAsyncMiddleware(signTypedDataV4),
+    personal_sign: auth.createAsyncMiddleware(personalSign)
+  });
+}
+
+exports.createWalletMiddleware = createWalletMiddleware;

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

@@ -0,0 +1,51 @@
+'use strict';
+
+var auth = require('@web3auth/auth');
+var index = require('../../../../../base/errors/index.js');
+var JrpcClient = require('../../../rpc/JrpcClient.js');
+var solanaRpcMiddlewares = require('../../../rpc/solanaRpcMiddlewares.js');
+var baseProvider = require('../../../../base-provider/baseProvider.js');
+
+class BaseInjectedProvider extends baseProvider.BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+  }
+  async switchChain(_) {
+    throw index.WalletLoginError.unsupportedOperation("Chain switching is not supported by this adapter");
+  }
+  async setupProvider(injectedProvider) {
+    const engine = new auth.JRPCEngine();
+    const providerHandlers = this.getProviderHandlers(injectedProvider);
+    const solanaMiddleware = solanaRpcMiddlewares.createSolanaMiddleware(providerHandlers);
+    engine.push(solanaMiddleware);
+    const configMiddleware = JrpcClient.createConfigMiddleware(this.config.chainConfig);
+    engine.push(configMiddleware);
+    const injectedProviderProxy = this.getInjectedProviderProxy(injectedProvider);
+    if (injectedProviderProxy) {
+      engine.push(injectedProviderProxy);
+    }
+    const provider = auth.providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    await this.lookupNetwork();
+  }
+  async lookupNetwork() {
+    const {
+      chainConfig
+    } = this.config;
+    this.update({
+      chainId: chainConfig.chainId
+    });
+    return chainConfig.chainId || "";
+  }
+  getInjectedProviderProxy(_) {
+    return undefined;
+  }
+}
+
+exports.BaseInjectedProvider = BaseInjectedProvider;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+var auth = require('@web3auth/auth');
+var bs58 = require('bs58');
+
+const getBaseProviderHandlers = injectedProvider => {
+  const providerHandlers = {
+    requestAccounts: async () => {
+      return injectedProvider.publicKey ? [bs58.encode(injectedProvider.publicKey.toBytes())] : [];
+    },
+    getPublicKey: async () => {
+      return injectedProvider.publicKey ? bs58.encode(injectedProvider.publicKey.toBytes()) : "";
+    },
+    getAccounts: async () => injectedProvider.publicKey ? [bs58.encode(injectedProvider.publicKey.toBytes())] : [],
+    getPrivateKey: async () => {
+      throw auth.rpcErrors.methodNotSupported();
+    },
+    getSecretKey: async () => {
+      throw auth.rpcErrors.methodNotSupported();
+    },
+    signTransaction: async req => {
+      const transaction = await injectedProvider.signTransaction(req.params.message);
+      return transaction;
+    },
+    signMessage: async req => {
+      const sigData = await injectedProvider.signMessage(req.params.message, req.params.display);
+      return sigData.signature;
+    },
+    signAllTransactions: async req => {
+      var _req$params, _req$params2;
+      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message) || !((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message.length)) {
+        throw auth.rpcErrors.invalidParams("message");
+      }
+      const transaction = await injectedProvider.signAllTransactions(req.params.message);
+      return transaction;
+    },
+    signAndSendTransaction: async req => {
+      const txRes = await injectedProvider.signAndSendTransaction(req.params.message);
+      return {
+        signature: txRes.signature
+      };
+    }
+  };
+  return providerHandlers;
+};
+
+exports.getBaseProviderHandlers = getBaseProviderHandlers;

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

@@ -0,0 +1,12 @@
+'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

@@ -0,0 +1,75 @@
+'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

@@ -0,0 +1,109 @@
+'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;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+var baseInjectedProvider = require('./base/baseInjectedProvider.js');
+var providerHandlers = require('./base/providerHandlers.js');
+
+class WalletStandardProvider extends baseInjectedProvider.BaseInjectedProvider {
+  getProviderHandlers(injectedProvider) {
+    return providerHandlers.getBaseProviderHandlers(injectedProvider);
+  }
+}
+
+exports.WalletStandardProvider = WalletStandardProvider;