feat: wallet manager package

packages/wallet-manager/package.json

@@ -11,12 +11,15 @@
     "dev": "tsc --build --clean && tsc --build ./tsconfig.json --watch",
     "clean": "rm -rf ./build",
     "lint": "eslint 'src/**/*.ts'",
-    "lint:fix": "yarn run lint --fix"
+    "lint:fix": "yarn run lint --fix",
+    "test": "vitest --config ./vite.config.ts"
   },
   "author": "Sygmaprotocol Product Team",
   "devDependencies": {
     "@polkadot/types": "10.7.2",
-    "typescript": "^5.2.2"
+    "jsdom": "^22.1.0",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.5"
   },
   "dependencies": {
     "@polkadot/api": "10.7.2",

packages/wallet-manager/src/index.ts

@@ -0,0 +1 @@
+export { EvmWallet, SubstrateWallet } from './wallets';

packages/wallet-manager/src/test/EvmWallet.test.ts

@@ -0,0 +1,27 @@
+import { ethers } from 'ethers';
+import { ExternalProvider } from '@ethersproject/providers';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EvmWallet } from '../';
+
+describe('EvmWallet', () => {
+  describe('EvmWallet + provider on window', () => {
+    beforeEach(() => {
+      window.ethereum = {
+        request: () => Promise.resolve(true),
+        on: vi.fn()
+      } as ExternalProvider & { on: () => void };
+    });
+    it('should be able to create an instance of EvmWallet passing a web3Provider', () => {
+      const w3Provider = new ethers.providers.Web3Provider(window.ethereum);
+      const evmWallet = EvmWallet.initFromWeb3Provider(w3Provider);
+
+      expect(evmWallet).toBeInstanceOf(EvmWallet);
+    });
+
+    it('should be able to create an instance of EvmWallet without passing a web3Provider', () => {
+      const evmWallet = EvmWallet.initFromWindow();
+
+      expect(evmWallet).toBeInstanceOf(EvmWallet);
+    });
+  });
+});

packages/wallet-manager/src/test/Substrate.test.ts

@@ -0,0 +1,37 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { SubstrateWallet } from '../wallets';
+
+vi.mock('@polkadot/api', async () => {
+  const mod =
+    await vi.importActual<typeof import('@polkadot/api')>('@polkadot/api');
+  const WsProviderMock = vi.fn();
+  const ApiPromiseMock = {
+    create: async () => {}
+  };
+  return {
+    ...mod,
+    WsProvider: WsProviderMock,
+    ApiPromise: ApiPromiseMock
+  };
+});
+
+describe('SubstrateWallet', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be able to create an instance of SubstrateWallet passing an ApiPromise', async () => {
+    const wsProvider = new WsProvider('wss:someurl');
+    const apiPromise = await ApiPromise.create({ provider: wsProvider });
+
+    const substrateWallet = SubstrateWallet.connectFromApiPromise(apiPromise);
+    expect(substrateWallet).toBeInstanceOf(SubstrateWallet);
+  });
+
+  it('should be able to create an instance of SubstrateWallet passing a wssProvider', async () => {
+    const substrateWallet =
+      await SubstrateWallet.connectFromWssProvider('wss:someurl');
+    expect(substrateWallet).toBeInstanceOf(SubstrateWallet);
+  });
+});

packages/wallet-manager/src/types.ts

@@ -0,0 +1,7 @@
+import { ExternalProvider } from '@ethersproject/providers';
+
+declare global {
+  interface Window {
+    ethereum: ExternalProvider;
+  }
+}

packages/wallet-manager/src/wallets/Evm/Evm.ts

@@ -0,0 +1,167 @@
+import { ethers } from 'ethers';
+import events from 'events';
+import type {
+  Web3Provider,
+  ExternalProvider,
+  Provider
+} from '@ethersproject/providers';
+import { IEvmWallet } from '../interfaces';
+
+class EvmWallet extends events.EventEmitter implements IEvmWallet {
+  public account: string | undefined;
+  public web3Provider!: Web3Provider;
+  public windowConnector: Provider;
+
+  constructor(provider?: Web3Provider) {
+    super();
+
+    if (!window.ethereum) {
+      throw new Error('window.ethereum is not defined.');
+    } else {
+      this.windowConnector = window.ethereum as Provider;
+    }
+    if (!provider) {
+      this.web3Provider = new ethers.providers.Web3Provider(
+        this.windowConnector as ExternalProvider
+      );
+    } else {
+      this.web3Provider = provider;
+    }
+    this.appendProviderEvents();
+  }
+
+  static initFromWeb3Provider(web3Provider: Web3Provider) {
+    return new EvmWallet(web3Provider);
+  }
+
+  static initFromWindow() {
+    return new EvmWallet();
+  }
+
+  private async calculateAccountData(accounts?: string[]) {
+    if (accounts?.length) {
+      this.account = accounts[0];
+    }
+
+    const _accounts = await this.web3Provider.listAccounts();
+
+    if (!_accounts.length) {
+      return;
+    }
+
+    this.account = _accounts![0];
+  }
+
+  private reConnectToProvider() {
+    this.web3Provider = new ethers.providers.Web3Provider(
+      this.windowConnector as ExternalProvider
+    );
+  }
+
+  private appendProviderEvents(): void {
+    try {
+      this.checkWindow();
+    } catch (e) {
+      throw e;
+    }
+    this.windowConnector.on('connect', async () => {
+      this.reConnectToProvider();
+      await this.calculateAccountData();
+    });
+
+    this.windowConnector.on(
+      'disconnect',
+      async (error: Error & { code: number; data?: unknown }) => {
+        console.log(error);
+        this.reConnectToProvider();
+        await this.calculateAccountData();
+      }
+    );
+
+    this.windowConnector.on('chainChanged', async () => {
+      this.reConnectToProvider();
+      await this.calculateAccountData();
+
+      this.emit('walletChainChanged', this.web3Provider);
+    });
+
+    this.windowConnector.on('accountsChanged', async (accounts: string[]) => {
+      this.reConnectToProvider();
+      await this.calculateAccountData(accounts);
+
+      this.emit('walletAccountChanged', this.account);
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  private checkWindow() {
+    if (window === undefined) {
+      throw new Error('window object is not defined.');
+    }
+  }
+
+  public async connect() {
+    try {
+      this.checkWindow();
+    } catch (e) {
+      throw e;
+    }
+
+    try {
+      const accounts = await (this.windowConnector as ExternalProvider)
+        .request!({
+        method: 'eth_requestAccounts'
+      });
+      this.account = accounts[0];
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  public async addChain({
+    chainId,
+    chainName,
+    rpcUrl,
+    nativeCurrency
+  }: {
+    chainId: number;
+    rpcUrl: string;
+    chainName: string;
+    nativeCurrency: {
+      name: string;
+      symbol: string;
+      decimals: number;
+    };
+  }): Promise<void> {
+    this.checkWindow();
+
+    try {
+      await (this.windowConnector as ExternalProvider).request!({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: `0x${chainId.toString(16)}` }]
+      });
+    } catch (switchError: unknown) {
+      if ((switchError as { code: number }).code === 4902) {
+        try {
+          await (this.windowConnector as ExternalProvider).request!({
+            method: 'wallet_addEthereumChain',
+            params: [
+              {
+                chainId: `0x${chainId.toString(16)}`,
+                rpcUrls: [rpcUrl],
+                chainName,
+                nativeCurrency
+              }
+            ]
+          });
+        } catch (addError: unknown) {
+          if ((addError as { code: number }).code !== 4001) {
+            throw addError;
+          }
+        }
+      }
+    }
+  }
+}
+
+export { EvmWallet };

packages/wallet-manager/src/wallets/Evm/index.ts

@@ -0,0 +1 @@
+export { EvmWallet } from './Evm';

packages/wallet-manager/src/wallets/Substrate/Substrate.ts

@@ -0,0 +1,44 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { web3Accounts, web3Enable } from '@polkadot/extension-dapp';
+
+class SubstrateWallet {
+  substrateAccount?: string;
+  apiPromise?: ApiPromise;
+  wssProvider?: WsProvider;
+
+  constructor(apiPromise?: ApiPromise) {
+    this.apiPromise = apiPromise;
+  }
+
+  static async connectFromWssProvider(wssProvider: string) {
+    const wsProvider = await SubstrateWallet.conntectToApi(wssProvider);
+    const apiPromise = await ApiPromise.create({ provider: wsProvider });
+    return new SubstrateWallet(apiPromise);
+  }
+
+  static connectFromApiPromise(apiPromise: ApiPromise) {
+    return new SubstrateWallet(apiPromise);
+  }
+
+  static async conntectToApi(wssProvider: string): Promise<WsProvider> {
+    const wsProvider = new WsProvider(wssProvider);
+    return wsProvider;
+  }
+
+  public async connect() {
+    const injectors = await web3Enable('Polkadot Wallet');
+    // using polkadot-js extension
+    const polkadotInjector = injectors.find(
+      (injector) => injector.name === 'polkadot-js'
+    );
+
+    if (polkadotInjector) {
+      // eslint-disable-next-line no-console
+      console.log('polkadot-js extension found');
+      const allAccounts = await web3Accounts();
+      this.substrateAccount = allAccounts[0].address;
+    }
+  }
+}
+
+export { SubstrateWallet };

packages/wallet-manager/src/wallets/Substrate/index.ts

@@ -0,0 +1 @@
+export { SubstrateWallet } from './Substrate';

packages/wallet-manager/src/wallets/index.ts

@@ -0,0 +1,2 @@
+export { EvmWallet } from './Evm';
+export { SubstrateWallet } from './Substrate';

packages/wallet-manager/src/wallets/interfaces/index.ts

@@ -0,0 +1,36 @@
+import { Provider, Web3Provider } from '@ethersproject/providers';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+
+export interface SupportedWallet {
+  id: string;
+  name: string;
+  icon: string;
+  providerName: string;
+}
+
+export interface IEvmWallet {
+  web3Provider: Web3Provider;
+  windowConnector: Provider;
+  account?: string;
+  connect(): Promise<void>;
+  addChain({
+    chainId,
+    rpcUrl,
+    chainName
+  }: {
+    chainId: number;
+    rpcUrl: string;
+    chainName: string;
+    nativeCurrency: {
+      name: string;
+      symbol: string;
+      decimals: number;
+    };
+  }): Promise<void>;
+}
+
+export interface SusbtrateWallet {
+  wssProvider?: WsProvider;
+  apiPromise?: ApiPromise;
+  substrateAccount?: string;
+}

packages/wallet-manager/vite.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'jsdom',
+    exclude: ['**/node_modules/**', '**/dist/**', '**/build/**']
+  }
+});