Create a Chain Agnostic Web3 Wallet with PnP no-modal SDK

import { Web3AuthNoModal } from "@web3auth/no-modal";
import { OpenloginAdapter } from "@web3auth/openlogin-adapter";
import { CHAIN_NAMESPACES, IProvider, WALLET_ADAPTERS } from "@web3auth/base";
import { EthereumPrivateKeyProvider } from "@web3auth/ethereum-provider";
import { web3AuthConfig, openloginAdapterConfig } from "./config/web3auth";

import StartkNetRPC from "./RPC/startkNetRPC"; // for using starkex
import EthereumRPC from "./RPC/ethRPC-web3"; // for using web3.js
import SolanaRPC from "./RPC/solanaRPC"; // for using solana
import TezosRPC from "./RPC/tezosRPC"; // for using tezos
import PolkadotRPC from "./RPC/polkadotRPC"; // for using polkadot

import { CHAIN_NAMESPACES, WEB3AUTH_NETWORK, UX_MODE, Web3AuthNoModalOptions } from "@web3auth/base";
import { OpenloginAdapterOptions } from "@web3auth/openlogin-adapter";
import { EthereumPrivateKeyProvider } from "@web3auth/ethereum-provider";

const clientId = "BPi5PB_UiIZ-cPz1GtV5i1I2iOSOHuimiXBI0e-Oe_u6X3oVAbCiAZOTEBtTXw4tsluTITPqA8zMsfxIKMjiqNQ"; // get from https://dashboard.web3auth.io

const chainConfig = {
    chainNamespace: CHAIN_NAMESPACES.EIP155,
    chainId: "0x1",
    rpcTarget: "https://rpc.ankr.com/eth",
    displayName: "Ethereum Mainnet",
    blockExplorerUrl: "https://etherscan.io",
    ticker: "ETH",
    tickerName: "Ethereum",
    logo: "https://cryptologos.cc/logos/ethereum-eth-logo.png",
  };

const privateKeyProvider = new EthereumPrivateKeyProvider({ config: { chainConfig } });

export const web3AuthConfig: Web3AuthNoModalOptions = {
    clientId,
  privateKeyProvider,
  web3AuthNetwork: WEB3AUTH_NETWORK.SAPPHIRE_MAINNET,
};


export const openloginAdapterConfig: OpenloginAdapterOptions ={
    adapterSettings: {
      uxMode: UX_MODE.REDIRECT,
    },
  };

// StarkEx and StarkNet
//@ts-ignore
import { ec } from "@starkware-industries/starkware-crypto-utils";

import type {IProvider} from '@web3auth/base'
import Web3 from 'web3'

import { SolanaPrivateKeyProvider, SolanaWallet } from "@web3auth/solana-provider";
import { CHAIN_NAMESPACES } from "@web3auth/base";
import { Connection, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction } from "@solana/web3.js";

// Tezos
//@ts-ignore
import * as tezosCrypto from "@tezos-core-tools/crypto-utils";
import { hex2buf } from "@taquito/utils";
import { TezosToolkit } from "@taquito/taquito";

// Polkadot
import { Keyring, ApiPromise, WsProvider } from "@polkadot/api";
import { cryptoWaitReady } from "@polkadot/util-crypto";

const rpcETH = new EthereumRPC(provider!);
const address = await rpcETH.getAccounts();

export default class EthereumRPC{
  private provider: IProvider

  constructor(provider: IProvider) {
    this.provider = provider
  }

  // Get user's Ethereum public address
  public async getAccounts(): Promise<any> {
    try {
      const web3 = new Web3(this.provider as any)

      // Get user's Ethereum public address
      const address = (await web3.eth.getAccounts())[0]

      return address
    } catch (error) {
      return error
    }
  }

}

    const rpcETH = new EthereumRPC(provider!);
    const privateKey = await rpcETH.getPrivateKey();

    // Get user's Solana public address
    const solanaRPC = new SolanaRPC(privateKey);
    const solana_address = await solanaRPC.getAccounts();

export default class SolanaRPC {
    private provider: SolanaPrivateKeyProvider;
    private privateKey: string;

    constructor(privateKey: string) {
       this.provider = new SolanaPrivateKeyProvider({
            config: {
                chainConfig: {
                chainNamespace: CHAIN_NAMESPACES.SOLANA,
                chainId: "0x3",
                rpcTarget: "https://api.devnet.solana.com",
                displayName: "Solana Mainnet",
                blockExplorerUrl: "https://explorer.solana.com/",
                ticker: "SOL",
                tickerName: "Solana",
                logo: "",
                },
            },
            });
      this.privateKey = privateKey;
    }

    async getAccounts(): Promise<any> {
      const { getED25519Key } = await import("@toruslabs/openlogin-ed25519");
      const ed25519key = getED25519Key(this.privateKey).sk.toString("hex");
      console.log(ed25519key);
      // Get user's Solana's public address
      await this.provider.setupProvider(ed25519key);
      const solanaWallet = new SolanaWallet(this.provider as SolanaPrivateKeyProvider);
      const solana_address = await solanaWallet.requestAccounts();
      return solana_address[0];
    }

}

export default class EthereumRPC{
  private provider: IProvider

  constructor(provider: IProvider) {
    this.provider = provider
  }

  // Get user's Ethereum private key
  async getPrivateKey(): Promise<any> {
    try {
      const privateKey = await this.provider.request({
        method: 'eth_private_key',
      })

      return privateKey
    } catch (error) {
      return error as string
    }
  }

}

    const rpcETH = new EthereumRPC(provider!);
    const privateKey = await rpcETH.getPrivateKey();

    // Get user's Tezos public address
    const tezosRPC = new TezosRPC(privateKey);
    const tezos_address = await tezosRPC.getAccounts();

export default class TezosRPC {
    private provider: TezosToolkit;
    private privateKey: string;

    constructor(privateKey: string) {
      this.privateKey = privateKey;
      this.provider = new TezosToolkit("https://ghostnet.ecadinfra.com");
    }

    async getAccounts(): Promise<any> {
      // Get user's Tezos public address
      const keyPairTezos = tezosCrypto.utils.seedToKeyPair(hex2buf(this.privateKey));
      const address = keyPairTezos?.pkh;
      return address;
    }

}

export default class EthereumRPC{
  private provider: IProvider

  constructor(provider: IProvider) {
    this.provider = provider
  }

  // Get user's Ethereum private key
  async getPrivateKey(): Promise<any> {
    try {
      const privateKey = await this.provider.request({
        method: 'eth_private_key',
      })

      return privateKey
    } catch (error) {
      return error as string
    }
  }

}

    const rpcETH = new EthereumRPC(provider!);
    const privateKey = await rpcETH.getPrivateKey();

    // Get user's starkNet public address
    const starkNetRPC = new StartkNetRPC(privateKey);
    const stark_address = await starkNetRPC.getAccounts();

export default class StartkNetRPC {
  private privateKey: string;

  constructor(privateKey: string) {
    this.privateKey = privateKey;
  }

  // Get user's starkNet public address
  async getAccounts(): Promise<any> {
        const keyPairStarkNet = ec.keyFromPrivate(this.privateKey, "hex");
        const starknet_account = ec.keyFromPublic(keyPairStarkNet.getPublic(true, "hex"), "hex");
        const address = starknet_account.pub.getX().toString("hex");
        return address;
  }

}

export default class EthereumRPC{
  private provider: IProvider

  constructor(provider: IProvider) {
    this.provider = provider
  }

  // Get user's Ethereum private key
  async getPrivateKey(): Promise<any> {
    try {
      const privateKey = await this.provider.request({
        method: 'eth_private_key',
      })

      return privateKey
    } catch (error) {
      return error as string
    }
  }

}

    const rpcETH = new EthereumRPC(provider!);
    const privateKey = await rpcETH.getPrivateKey();

    // Get user's Polkadot public address
    const polkadotRPC = new PolkadotRPC(privateKey);
    const polkadot_address = await polkadotRPC.getAccounts();

export default class PolkadotRPC {
  private provider: WsProvider;
  private privateKey: string;

  constructor(privateKey: string) {
    this.provider = new WsProvider('wss://rpc.polkadot.io'); // Kusama	wss://kusama-rpc.polkadot.io
    this.privateKey = privateKey;
  }

  // Get user's Polkadot public key
  async getAccounts(): Promise<any> {
      await cryptoWaitReady();

      const keyring = new Keyring({ ss58Format: 42, type: "sr25519" });

      const keyPair = keyring.addFromUri("0x" + this.privateKey);
      const address = keyPair.address;
      return address;
  }

}

export default class EthereumRPC{
  private provider: IProvider

  constructor(provider: IProvider) {
    this.provider = provider
  }

  // Get user's Ethereum private key
  async getPrivateKey(): Promise<any> {
    try {
      const privateKey = await this.provider.request({
        method: 'eth_private_key',
      })

      return privateKey
    } catch (error) {
      return error as string
    }
  }

}