@web3auth/no-modal 10.15.0 → 11.0.0-beta.0

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

@@ -1,258 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
-import { isHex, toHex } from 'viem';
-
-function createWalletMiddleware({
-  getAccounts,
-  getPrivateKey,
-  getPublicKey,
-  processEthSignMessage,
-  processPersonalMessage,
-  processTransaction,
-  processSignTransaction,
-  processTypedMessageV4,
-  processGetCapabilities,
-  processSendCalls,
-  processGetCallsStatus,
-  processShowCallsStatus
-}) {
-  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 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 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 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 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 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 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 rpcErrors.methodNotSupported();
-    }
-    res.result = await getPrivateKey(req);
-  }
-  async function fetchPublicKey(req, res) {
-    if (!getPublicKey) {
-      throw rpcErrors.methodNotSupported();
-    }
-    res.result = await getPublicKey(req);
-  }
-  async function getWalletCapabilitiesMiddleware(req, res) {
-    if (!processGetCapabilities) {
-      throw rpcErrors.methodNotSupported();
-    }
-    if (!Array.isArray(req.params) || req.params.length === 0) {
-      throw rpcErrors.invalidParams("Invalid parameters");
-    }
-    const account = req.params[0];
-    if (!isHex(account)) {
-      throw rpcErrors.invalidParams("Invalid account address");
-    }
-    let chainIds = req.params[1] || []; // if empty array is provided, the wallet will return capabilities for all supported chains
-    if (!Array.isArray(chainIds)) {
-      throw rpcErrors.invalidParams(`Invalid params, received: ${chainIds}. expected: Array`);
-    }
-
-    // format chain ids
-    chainIds = chainIds.map(chainId => isHex(chainId) ? chainId : toHex(chainId));
-    const getCapabilitiesParams = [account,
-    // account address
-    chainIds // [`0xstring`, `0xstring`, ...]
-    ];
-    res.result = await processGetCapabilities(getCapabilitiesParams);
-  }
-  async function walletSendCallsMiddleware(req, res) {
-    if (!processSendCalls) {
-      throw rpcErrors.methodNotSupported();
-    }
-    const params = Array.isArray(req.params) ? req.params[0] : req.params;
-    if (!params || typeof params !== "object") {
-      throw rpcErrors.invalidParams("Missing or invalid params for wallet_sendCalls");
-    }
-    if (!params.version || typeof params.version !== "string") {
-      throw rpcErrors.invalidParams(`Invalid version: expected string, got "${params.version || "undefined"}"`);
-    }
-    if (!params.chainId) {
-      throw rpcErrors.invalidParams("Missing required field: chainId");
-    }
-    if (!Array.isArray(params.calls) || params.calls.length === 0) {
-      throw rpcErrors.invalidParams("calls must be a non-empty array");
-    }
-    const from = params.from;
-    if (from) {
-      await validateAndNormalizeKeyholder(from, req);
-    }
-    const walletSendCallsParams = _objectSpread(_objectSpread({}, params), {}, {
-      chainId: isHex(params.chainId) ? params.chainId : toHex(params.chainId)
-    });
-    res.result = await processSendCalls(walletSendCallsParams);
-  }
-  async function walletBatchCallStatusMiddleware(req, res) {
-    if (!processGetCallsStatus) {
-      throw rpcErrors.methodNotSupported();
-    }
-    const batchId = Array.isArray(req.params) ? req.params[0] : req.params;
-    if (!batchId || typeof batchId !== "string") {
-      throw rpcErrors.invalidParams("Missing or invalid batchId");
-    }
-    res.result = await processGetCallsStatus(batchId);
-  }
-  async function walletShowCallsStatusMiddleware(req, res) {
-    if (!processShowCallsStatus) {
-      throw rpcErrors.methodNotSupported();
-    }
-    const batchId = Array.isArray(req.params) ? req.params[0] : req.params;
-    if (!batchId || typeof batchId !== "string") {
-      throw rpcErrors.invalidParams("Missing or invalid batchId");
-    }
-    await processShowCallsStatus(batchId);
-    res.result = true;
-  }
-  return createScaffoldMiddleware({
-    // account lookups
-    eth_accounts: createAsyncMiddleware(lookupAccounts),
-    eth_requestAccounts: createAsyncMiddleware(lookupAccounts),
-    eth_private_key: createAsyncMiddleware(fetchPrivateKey),
-    eth_public_key: createAsyncMiddleware(fetchPublicKey),
-    public_key: createAsyncMiddleware(fetchPublicKey),
-    private_key: createAsyncMiddleware(fetchPrivateKey),
-    // 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),
-    // EIP-5792
-    wallet_getCapabilities: createAsyncMiddleware(getWalletCapabilitiesMiddleware),
-    wallet_sendCalls: createAsyncMiddleware(walletSendCallsMiddleware),
-    wallet_getCallsStatus: createAsyncMiddleware(walletBatchCallStatusMiddleware),
-    wallet_showCallsStatus: createAsyncMiddleware(walletShowCallsStatusMiddleware)
-  });
-}
-
-export { createWalletMiddleware };

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

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

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

@@ -1,43 +0,0 @@
-import { bs58 } from '@toruslabs/bs58';
-import { rpcErrors } from '@web3auth/auth';
-
-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 rpcErrors.methodNotSupported();
-    },
-    getSecretKey: async () => {
-      throw 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.data, req.params.from, req.params.display);
-      return sigData;
-    },
-    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 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 txRes;
-    }
-  };
-  return providerHandlers;
-};
-
-export { getBaseProviderHandlers };

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

@@ -1,14 +0,0 @@
-const getSolanaChainByChainConfig = chainConfig => {
-  switch (chainConfig.chainId) {
-    case "0x65":
-      return "solana:mainnet";
-    case "0x66":
-      return "solana:testnet";
-    case "0x67":
-      return "solana:devnet";
-    default:
-      return null;
-  }
-};
-
-export { getSolanaChainByChainConfig };

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

@@ -1,91 +0,0 @@
-import { SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
-import { PublicKey, VersionedTransaction } from '@solana/web3.js';
-import { bs58 } from '@toruslabs/bs58';
-import { BaseInjectedProvider } from './base/baseInjectedProvider.js';
-import { getBaseProviderHandlers } from './base/providerHandlers.js';
-import { getSolanaChainByChainConfig } from './utils.js';
-import { WalletLoginError } from '../../../../base/errors/index.js';
-
-class WalletStandardProvider extends BaseInjectedProvider {
-  getProviderHandlers(wallet) {
-    const chainIdentifier = getSolanaChainByChainConfig(this.config.chain);
-    const currentAccount = () => {
-      const account = wallet === null || wallet === void 0 ? void 0 : wallet.accounts[0];
-      if (!account) throw WalletLoginError.notConnectedError();
-      return account;
-    };
-
-    /**
-     * Signs a message and returns the signature
-     * @param message - The message to sign
-     * @returns The signature of the message encoded in base58
-     */
-    const signMessage = async message => {
-      const account = currentAccount();
-      const uint8ArrayMessage = new Uint8Array(Buffer.from(message, "utf-8"));
-      const signature = await wallet.features[SolanaSignMessage].signMessage({
-        account,
-        message: uint8ArrayMessage
-      });
-      return bs58.encode(signature[0].signature);
-    };
-
-    /**
-     * Signs a transaction and returns the signature
-     * @param transaction - The transaction to sign
-     * @returns The signature of the transaction encoded in base58
-     */
-    const signTransaction = async transaction => {
-      const account = currentAccount();
-      const output = await wallet.features[SolanaSignTransaction].signTransaction({
-        account,
-        transaction: new Uint8Array(Buffer.from(transaction, "base64")),
-        chain: chainIdentifier
-      });
-      return bs58.encode(VersionedTransaction.deserialize(output[0].signedTransaction).signatures[0]);
-    };
-
-    /**
-     * Signs multiple transactions and returns the serialized transactions
-     * @param transactions - The transactions to sign
-     * @returns The serialized transactions encoded in base64
-     */
-    const signAllTransactions = async transactions => {
-      const account = currentAccount();
-      return Promise.all(transactions.map(async transaction => {
-        const output = await wallet.features[SolanaSignTransaction].signTransaction({
-          account,
-          transaction: new Uint8Array(Buffer.from(transaction, "base64")),
-          chain: chainIdentifier
-        });
-        return Buffer.from(output[0].signedTransaction).toString("base64");
-      }));
-    };
-
-    /**
-     * Signs a transaction and sends it to the network
-     * @param transaction - The transaction to sign and send
-     * @returns The signature of the transaction encoded in base58
-     */
-    const signAndSendTransaction = async transaction => {
-      const account = currentAccount();
-      const output = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
-        account,
-        transaction: new Uint8Array(Buffer.from(transaction, "base64")),
-        chain: chainIdentifier
-      });
-      return bs58.encode(output[0].signature);
-    };
-    return getBaseProviderHandlers({
-      get publicKey() {
-        return new PublicKey(currentAccount().publicKey);
-      },
-      signMessage,
-      signTransaction,
-      signAllTransactions,
-      signAndSendTransaction
-    });
-  }
-}
-
-export { WalletStandardProvider };

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

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

@@ -1,89 +0,0 @@
-import { createAsyncMiddleware, mergeMiddleware } from '@web3auth/auth';
-import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
-
-function createGetAccountsMiddleware({
-  getAccounts
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== SOLANA_METHOD_TYPES.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 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 !== SOLANA_METHOD_TYPES.SOLANA_REQUEST_ACCOUNTS) 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(SOLANA_METHOD_TYPES.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SEND_TRANSACTION, signAndSendTransaction), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS, signAllTransactions), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY, getPrivateKey), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.PRIVATE_KEY, getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
-}
-function createSolanaChainSwitchMiddleware({
-  switchSolanaChain
-}) {
-  return mergeMiddleware([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

@@ -1,92 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { VersionedTransaction } from '@solana/web3.js';
-import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
-
-class SolanaWallet {
-  constructor(provider) {
-    _defineProperty(this, "provider", void 0);
-    this.provider = provider;
-  }
-  async requestAccounts() {
-    const accounts = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.SOLANA_REQUEST_ACCOUNTS
-    });
-    return accounts;
-  }
-  async getAccounts() {
-    const accounts = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
-    });
-    return accounts;
-  }
-  async signAndSendTransaction(transaction) {
-    const signature = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.SEND_TRANSACTION,
-      params: {
-        message: this.serializeTransaction(transaction)
-      }
-    });
-    return signature;
-  }
-
-  /**
-   * Signs a transaction and returns the signature
-   * @param transaction - The transaction to sign
-   * @returns The signature of the transaction encoded in base58
-   */
-  async signTransaction(transaction) {
-    const signature = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.SIGN_TRANSACTION,
-      params: {
-        message: this.serializeTransaction(transaction)
-      }
-    });
-    return signature;
-  }
-
-  /**
-   * Signs multiple transactions and returns the serialized transactions
-   * @param transactions - The transactions to sign
-   * @returns The serialized transactions encoded in base64
-   */
-  async signAllTransactions(transactions) {
-    const serializedTransactions = transactions.map(tx => this.serializeTransaction(tx));
-    const signedTransactions = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS,
-      params: {
-        message: serializedTransactions
-      }
-    });
-    return signedTransactions;
-  }
-
-  /**
-   * Signs a message and returns the signature
-   * @param message - The message to sign
-   * @returns The signature of the message encoded in base58
-   */
-  async signMessage(message, pubKey) {
-    const response = await this.provider.request({
-      method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
-      params: {
-        data: message,
-        from: pubKey
-      }
-    });
-    return response;
-  }
-  async request(args) {
-    const result = await this.provider.request(args);
-    return result;
-  }
-  serializeTransaction(transaction) {
-    if (transaction instanceof VersionedTransaction) {
-      return Buffer.from(transaction.serialize()).toString("base64");
-    }
-    return Buffer.from(transaction.serialize({
-      requireAllSignatures: false
-    })).toString("base64");
-  }
-}
-
-export { SolanaWallet };