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

import { Web3AuthNoModal } from "@web3auth/no-modal";
import { AuthAdapter } from "@web3auth/auth-adapter";
import { CHAIN_NAMESPACES, IProvider, WALLET_ADAPTERS } from "@web3auth/base";
import { EthereumPrivateKeyProvider } from "@web3auth/ethereum-provider";
import { web3AuthConfig, authAdapterConfig } 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 { AuthAdapterOptions } from "@web3auth/auth-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 authAdapterConfig: AuthAdapterOptions = {
  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("@web3auth/auth-adapter");
    const ed25519key = getED25519Key(this.privateKey).sk.toString("hex");
    // 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;
    }
  }
}