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

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

@@ -0,0 +1,132 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { isHexString, addHexPrefix } from '@ethereumjs/util';
+import { providerErrors } from '@web3auth/auth';
+import { createWalletClient, http } from 'viem';
+import { log } from '../../../base/loglevel.js';
+
+function getProviderHandlers({
+  bundlerClient,
+  smartAccount,
+  chain,
+  eoaProvider
+}) {
+  const walletClient = createWalletClient({
+    account: smartAccount,
+    chain,
+    transport: http()
+  });
+  return {
+    getAccounts: async _ => {
+      const [smartAccounts, eoaAccounts] = await Promise.all([smartAccount.getAddress(), eoaProvider.request({
+        method: "eth_accounts"
+      })]);
+      log.info("smartAccounts", smartAccounts);
+      log.info("eoaAccounts", eoaAccounts);
+      return [smartAccounts, ...eoaAccounts];
+    },
+    getPrivateKey: async _ => {
+      throw providerErrors.custom({
+        message: "Smart accounts do not have private key",
+        code: 4903
+      });
+    },
+    getPublicKey: async _ => {
+      throw providerErrors.custom({
+        message: "Smart accounts do not have a public key. Use address instead.",
+        code: 4903
+      });
+    },
+    processTransaction: async txParams => {
+      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
+      const {
+        to,
+        value,
+        data
+      } = txParams;
+      // @ts-expect-error viem types are too deep
+      const userOperationParams = {
+        account: smartAccount,
+        calls: [{
+          to,
+          // Explicit conversation required to avoid value being passed as hex
+          value: BigInt(value),
+          data
+        }]
+        // should not use maxFeePerGas/maxPriorityFeePerGas from transaction params since that's fee for transaction not user operation and let bundler handle it instead
+      };
+      const userOpHash = await bundlerClient.sendUserOperation(userOperationParams);
+      const txReceipt = await bundlerClient.waitForUserOperationReceipt({
+        hash: userOpHash
+      });
+      if (!txReceipt.success) {
+        throw providerErrors.custom({
+          message: txReceipt.reason,
+          code: 4905
+        });
+      }
+      return txReceipt.receipt.transactionHash;
+    },
+    processSignTransaction: async txParams => {
+      const {
+        to,
+        value,
+        data
+      } = txParams;
+      const request = await bundlerClient.prepareUserOperation({
+        account: smartAccount,
+        calls: [{
+          to,
+          value: BigInt(value),
+          data
+        }]
+      });
+      const signature = await smartAccount.signUserOperation({
+        callData: request.callData,
+        callGasLimit: request.callGasLimit,
+        maxFeePerGas: request.maxFeePerGas,
+        maxPriorityFeePerGas: request.maxPriorityFeePerGas,
+        nonce: request.nonce,
+        preVerificationGas: request.preVerificationGas,
+        verificationGasLimit: request.verificationGasLimit,
+        signature: request.signature
+      });
+      return signature;
+    },
+    processEthSignMessage: async (_, req) => {
+      return eoaProvider.request(req);
+    },
+    processPersonalMessage: async (msgParams, _) => {
+      const message = msgParams.data;
+      return walletClient.signMessage({
+        account: smartAccount,
+        message: isHexString(message) ? {
+          raw: message
+        } : message
+      });
+    },
+    processTypedMessageV4: async (msgParams, _) => {
+      try {
+        const data = typeof msgParams.data === "string" ? JSON.parse(msgParams.data) : msgParams.data;
+        const signature = await walletClient.signTypedData({
+          account: smartAccount,
+          domain: _objectSpread(_objectSpread({}, data.domain), {}, {
+            verifyingContract: data.domain.verifyingContract,
+            salt: data.domain.salt,
+            chainId: Number(data.domain.chainId)
+          }),
+          primaryType: data.primaryType,
+          types: data.types,
+          message: data.message
+        });
+        return signature;
+      } catch (error) {
+        throw providerErrors.custom({
+          message: error instanceof Error ? error.message : "Failed to sign typed data",
+          code: 4905
+        });
+      }
+    }
+  };
+}
+
+export { getProviderHandlers };

package/dist/lib.esm/providers/account-abstraction-provider/rpc/ethRpcMiddlewares.js

@@ -0,0 +1,171 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
+
+async function createAaMiddleware({
+  eoaProvider,
+  handlers
+}) {
+  const [eoaAddress] = await eoaProvider.request({
+    method: "eth_accounts"
+  });
+
+  /**
+   * 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 handlers.getAccounts(req);
+      const normalizedAccounts = accounts.map(_address => _address.toLowerCase());
+      const normalizedAddress = address.toLowerCase();
+      if (normalizedAccounts.includes(normalizedAddress)) {
+        return normalizedAddress;
+      }
+    }
+    throw rpcErrors.invalidParams({
+      message: `Invalid parameters: must provide an Ethereum address.`
+    });
+  }
+  async function normalizeSignSenderAddress(address, req) {
+    // sender is EOA address
+    if (address.toLowerCase() === eoaAddress.toLowerCase()) {
+      return eoaAddress;
+    }
+    const [smartAccountAddress] = await handlers.getAccounts(req);
+    // sender is smart account address
+    if (address.toLowerCase() === smartAccountAddress.toLowerCase()) {
+      // use EOA address as sender for signing
+      return eoaAddress;
+    }
+    throw rpcErrors.invalidParams({
+      message: `Invalid parameters: must provide valid sender address.`
+    });
+  }
+  async function lookupAccounts(req, res) {
+    res.result = await handlers.getAccounts(req);
+  }
+  async function fetchPrivateKey(req, res) {
+    if (!handlers.getPrivateKey) {
+      throw rpcErrors.methodNotSupported();
+    }
+    res.result = await handlers.getPrivateKey(req);
+  }
+  async function sendTransaction(req, res) {
+    if (!handlers.processTransaction) {
+      throw rpcErrors.methodNotSupported();
+    }
+    const txParams = req.params[0] || {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    res.result = handlers.processTransaction(txParams, req);
+  }
+  async function signTransaction(req, res) {
+    const txParams = req.params[0] || {
+      from: ""
+    };
+
+    // normalize sender address
+    if (txParams.from) {
+      txParams.from = await normalizeSignSenderAddress(txParams.from, req);
+    }
+    res.result = await handlers.processSignTransaction(txParams, req);
+  }
+  async function ethSign(req, res) {
+    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 handlers.processEthSignMessage(msgParams, req);
+  }
+  async function signTypedDataV4(req, res) {
+    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 handlers.processTypedMessageV4(msgParams, req);
+  }
+  async function personalSign(req, res) {
+    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 handlers.processPersonalMessage(msgParams, req);
+  }
+  async function fetchPublicKey(req, res) {
+    if (!handlers.getPublicKey) {
+      throw rpcErrors.methodNotSupported();
+    }
+    res.result = await handlers.getPublicKey(req);
+  }
+  return createScaffoldMiddleware({
+    // account lookups
+    eth_accounts: createAsyncMiddleware(lookupAccounts),
+    eth_requestAccounts: createAsyncMiddleware(lookupAccounts),
+    eth_private_key: createAsyncMiddleware(fetchPrivateKey),
+    private_key: createAsyncMiddleware(fetchPrivateKey),
+    eth_public_key: createAsyncMiddleware(fetchPublicKey),
+    public_key: createAsyncMiddleware(fetchPublicKey),
+    // tx signatures
+    eth_sendTransaction: createAsyncMiddleware(sendTransaction),
+    eth_signTransaction: createAsyncMiddleware(signTransaction),
+    // message signatures
+    eth_sign: createAsyncMiddleware(ethSign),
+    eth_signTypedData_v4: createAsyncMiddleware(signTypedDataV4),
+    personal_sign: createAsyncMiddleware(personalSign)
+  });
+}
+function eoaProviderAsMiddleware(provider) {
+  return async (req, res, _next, end) => {
+    // send request to provider
+    try {
+      const providerRes = await provider.request(req);
+      res.result = providerRes;
+      return end();
+    } catch (error) {
+      return end(error);
+    }
+  };
+}
+
+export { createAaMiddleware, eoaProviderAsMiddleware };

package/dist/lib.esm/providers/base-provider/CommonJRPCProvider.js

@@ -0,0 +1,72 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { BaseProvider } from './baseProvider.js';
+import { createJsonRpcClient } from './jrpcClient.js';
+
+var _CommonJRPCProvider;
+class CommonJRPCProvider extends BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+  }
+  async setupProvider(chainId) {
+    const chain = this.getChain(chainId);
+    if (!chain) throw providerErrors.custom({
+      message: "Chain not found",
+      code: 4902
+    });
+    const {
+      networkMiddleware
+    } = createJsonRpcClient(chain);
+    const engine = new JRPCEngine();
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    this.emit("chainChanged", chainId);
+    this.emit("connect", {
+      chainId
+    });
+    this.update({
+      chainId
+    });
+  }
+  async switchChain(params) {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const newChainId = params.chainId;
+    if (this.chainId === newChainId) return;
+    this.update({
+      chainId: "loading"
+    });
+    await this.setupProvider(newChainId);
+  }
+  getProviderEngineProxy() {
+    return this._providerEngineProxy;
+  }
+  lookupNetwork() {
+    throw new Error("Method not implemented.");
+  }
+}
+_CommonJRPCProvider = CommonJRPCProvider;
+_defineProperty(CommonJRPCProvider, "getProviderInstance", async params => {
+  const providerFactory = new _CommonJRPCProvider({
+    config: {
+      chain: params.chain,
+      chains: params.chains
+    }
+  });
+  const {
+    chainId
+  } = params.chain;
+  await providerFactory.setupProvider(chainId);
+  return providerFactory;
+});
+
+export { CommonJRPCProvider };

package/dist/lib.esm/providers/base-provider/baseProvider.js

@@ -0,0 +1,130 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { BaseController, createEventEmitterProxy } from '@toruslabs/base-controllers';
+import { rpcErrors } from '@web3auth/auth';
+import { WalletInitializationError, WalletProviderError } from '../../base/errors/index.js';
+
+class BaseProvider extends BaseController {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    // should be Assigned in setupProvider
+    _defineProperty(this, "_providerEngineProxy", null);
+    // set to true when the keyExportEnabled flag is set by code.
+    // This is to prevent the flag from being overridden by the dashboard config.
+    _defineProperty(this, "keyExportFlagSetByCode", false);
+    const {
+      chain
+    } = config;
+    if (!chain) throw WalletInitializationError.invalidProviderConfigError("Please provide chain");
+    if (!chain.chainId) throw WalletInitializationError.invalidProviderConfigError("Please provide chainId inside chain");
+    if (!chain.rpcTarget) throw WalletInitializationError.invalidProviderConfigError("Please provide rpcTarget inside chain");
+    if (typeof config.keyExportEnabled === "boolean") this.keyExportFlagSetByCode = true;
+    this.defaultState = {
+      chainId: "loading"
+    };
+    this.defaultConfig = {
+      chain: config.chain,
+      chains: config.chains,
+      keyExportEnabled: typeof config.keyExportEnabled === "boolean" ? config.keyExportEnabled : true
+    };
+    super.initialize();
+  }
+  get currentChain() {
+    return this.config.chains.find(chain => chain.chainId === this.state.chainId);
+  }
+  get provider() {
+    return this._providerEngineProxy;
+  }
+  get chainId() {
+    return this.state.chainId;
+  }
+  set provider(_) {
+    throw new Error("Method not implemented.");
+  }
+  async request(args) {
+    var _this$provider;
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw rpcErrors.invalidRequest({
+        message: WalletProviderError.invalidRequestArgs().message,
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: WalletProviderError.invalidRequestArgs().message
+        })
+      });
+    }
+    const {
+      method,
+      params
+    } = args;
+    if (typeof method !== "string" || method.length === 0) {
+      throw rpcErrors.invalidRequest({
+        message: WalletProviderError.invalidRequestMethod().message,
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: WalletProviderError.invalidRequestMethod().message
+        })
+      });
+    }
+    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw rpcErrors.invalidRequest({
+        message: WalletProviderError.invalidRequestParams().message,
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: WalletProviderError.invalidRequestParams().message
+        })
+      });
+    }
+    return (_this$provider = this.provider) === null || _this$provider === void 0 ? void 0 : _this$provider.request(args);
+  }
+  sendAsync(req, callback) {
+    if (callback) return this.send(req, callback);
+    return this.request(req);
+  }
+  send(req, callback) {
+    this.request(req).then(res => callback(null, {
+      result: res
+    })).catch(err => callback(err, null));
+  }
+  updateProviderEngineProxy(provider) {
+    if (this._providerEngineProxy) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this._providerEngineProxy.setTarget(provider);
+      // re-emit events from provider
+      this._providerEngineProxy.eventNames().forEach(event => {
+        provider.on(event, (...args) => {
+          // eslint-disable-next-line
+          this.emit(event, ...args);
+        });
+      });
+      this.handleChainChangedProvider();
+    } else {
+      this._providerEngineProxy = createEventEmitterProxy(provider);
+    }
+  }
+  setKeyExportFlag(flag) {
+    if (!this.keyExportFlagSetByCode) {
+      this.configure({
+        keyExportEnabled: flag
+      });
+    }
+  }
+  getProviderEngineProxy() {
+    return this._providerEngineProxy;
+  }
+  getChain(chainId) {
+    return this.config.chains.find(chain => chain.chainId === chainId);
+  }
+  handleChainChangedProvider() {
+    // This is only added because we don't have ethereum and solana private key providers anymore
+    this.provider.on("chainChanged", chainId => {
+      this.update({
+        chainId
+      });
+    });
+  }
+}
+
+export { BaseProvider };

package/dist/lib.esm/providers/base-provider/commonPrivateKeyProvider.js

@@ -0,0 +1,76 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { JRPCEngine, providerFromEngine, createScaffoldMiddleware, createAsyncMiddleware } from '@web3auth/auth';
+import { BaseProvider } from './baseProvider.js';
+
+var _CommonPrivateKeyProvider;
+class CommonPrivateKeyProvider extends BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    // should be Assigned in setupProvider
+    _defineProperty(this, "_providerEngineProxy", null);
+  }
+  get provider() {
+    return this._providerEngineProxy;
+  }
+  set provider(_) {
+    throw new Error("Method not implemented.");
+  }
+  async setupProvider(privKey) {
+    const privKeyMiddleware = this.getPrivKeyMiddleware(privKey);
+    const engine = new JRPCEngine();
+    engine.push(privKeyMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+  }
+  async switchChain(_) {
+    return Promise.resolve();
+  }
+  getProviderEngineProxy() {
+    return this._providerEngineProxy;
+  }
+  async lookupNetwork() {
+    return Promise.resolve("");
+  }
+  getPrivKeyMiddleware(privKey) {
+    const middleware = {
+      getPrivatekey: async () => {
+        if (!this.config.keyExportEnabled) throw new Error("Exporting private key is disabled. Please enable it in the provider config");
+        return privKey;
+      }
+    };
+    return this.createPrivKeyMiddleware(middleware);
+  }
+  createPrivKeyMiddleware({
+    getPrivatekey
+  }) {
+    async function getPrivatekeyHandler(_, res) {
+      try {
+        res.result = await getPrivatekey();
+      } catch (error) {
+        res.error = error instanceof Error ? error.message : error;
+      }
+    }
+    return createScaffoldMiddleware({
+      private_key: createAsyncMiddleware(getPrivatekeyHandler)
+    });
+  }
+}
+_CommonPrivateKeyProvider = CommonPrivateKeyProvider;
+_defineProperty(CommonPrivateKeyProvider, "getProviderInstance", async params => {
+  const providerFactory = new _CommonPrivateKeyProvider({
+    config: {
+      chain: params.chain,
+      chains: params.chains
+    }
+  });
+  await providerFactory.setupProvider(params.privKey);
+  return providerFactory;
+});
+
+export { CommonPrivateKeyProvider };

package/dist/lib.esm/providers/base-provider/index.js

@@ -0,0 +1,5 @@
+export { BaseProvider } from './baseProvider.js';
+export { CommonJRPCProvider } from './CommonJRPCProvider.js';
+export { CommonPrivateKeyProvider } from './commonPrivateKeyProvider.js';
+export { createRandomId } from './utils.js';
+export { getED25519Key } from '@web3auth/auth';

package/dist/lib.esm/providers/base-provider/jrpcClient.js

@@ -0,0 +1,37 @@
+import { createFetchMiddleware } from '@toruslabs/base-controllers';
+import { mergeMiddleware } from '@web3auth/auth';
+
+function createChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "chainId") {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createJsonRpcClient(providerConfig) {
+  const {
+    chainId,
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+export { createChainIdMiddleware, createJsonRpcClient, createProviderConfigMiddleware };

package/dist/lib.esm/providers/base-provider/utils.js

@@ -0,0 +1,6 @@
+import getCreateRandomId from 'json-rpc-random-id';
+export { getED25519Key } from '@web3auth/auth';
+
+const createRandomId = getCreateRandomId();
+
+export { createRandomId };