feat(wallets): add evm to phantom

wallets/provider-phantom/src/helpers.ts

@@ -1,11 +1,46 @@
-export function phantom() {
-  if ('phantom' in window) {
-    const instance = window.phantom?.solana;
+import type { Network, ProviderConnectResult } from '@rango-dev/wallets-shared';
 
-    if (instance?.isPhantom) {
-      return instance;
-    }
+import { Networks } from '@rango-dev/wallets-shared';
+
+type Provider = Map<Network, any>;
+
+export function phantomInstances(): Provider | null {
+  const { phantom } = window;
+
+  if (!phantom) {
+    return null;
+  }
+
+  const { solana, ethereum } = phantom;
+
+  const instances: Provider = new Map();
+
+  if (ethereum && ethereum.isPhantom) {
+    instances.set(Networks.ETHEREUM, ethereum);
+  }
+
+  if (solana && phantom.isPhantom) {
+    instances.set(Networks.SOLANA, solana);
+  }
+  return instances;
+}
+
+export async function getNonEvmAccounts(
+  instances: Provider
+): Promise<ProviderConnectResult[]> {
+  const solanaInstance = instances.get(Networks.SOLANA);
+  const results: ProviderConnectResult[] = [];
+
+  if (solanaInstance) {
+    const solanaResponse = await solanaInstance.connect();
+
+    const solanaAccounts: string = solanaResponse.publicKey.toString();
+
+    results.push({
+      accounts: [solanaAccounts],
+      chainId: Networks.SOLANA,
+    });
   }
 
-  return null;
+  return results;
 }

wallets/provider-phantom/src/index.ts

@@ -2,19 +2,28 @@ import type {
   CanEagerConnect,
   CanSwitchNetwork,
   Connect,
+  ProviderConnectResult,
   Subscribe,
   WalletInfo,
 } from '@rango-dev/wallets-shared';
 import type { BlockchainMeta, SignerFactory } from 'rango-types';
 
 import {
-  getSolanaAccounts,
+  canEagerlyConnectToEvm,
+  canSwitchNetworkToEvm,
+  chooseInstance,
+  getEvmAccounts,
   Networks,
   WalletTypes,
 } from '@rango-dev/wallets-shared';
-import { solanaBlockchain } from 'rango-types';
+import {
+  evmBlockchains,
+  isEvmBlockchain,
+  isSolanaBlockchain,
+  solanaBlockchain,
+} from 'rango-types';
 
-import { phantom as phantom_instance } from './helpers';
+import { getNonEvmAccounts, phantomInstances } from './helpers';
 import signer from './signer';
 
 const WALLET = WalletTypes.PHANTOM;
@@ -23,11 +32,47 @@ export const config = {
   type: WALLET,
 };
 
-export const getInstance = phantom_instance;
-export const connect: Connect = getSolanaAccounts;
+export const getInstance = phantomInstances;
+
+export const connect: Connect = async ({ instance, meta }) => {
+  const ethInstance = chooseInstance(instance, meta, Networks.ETHEREUM);
+
+  let results: ProviderConnectResult[] = [];
+
+  if (ethInstance) {
+    const evmResult = await getEvmAccounts(ethInstance);
+    results.push(evmResult);
+  }
+
+  const nonEvmResults = await getNonEvmAccounts(instance);
+  results = [...results, ...nonEvmResults];
+
+  return results;
+};
+
+export const subscribe: Subscribe = (options) => {
+  const { connect, updateAccounts, state, updateChainId, meta, instance } =
+    options;
+
+  const ethInstance = chooseInstance(instance, meta, Networks.ETHEREUM);
+  const solanaInstance = chooseInstance(instance, meta, Networks.SOLANA);
 
-export const subscribe: Subscribe = ({ instance, updateAccounts, connect }) => {
-  instance?.on('accountChanged', async (publicKey: string) => {
+  ethInstance?.on('accountsChanged', (addresses: string[]) => {
+    const eth_chainId = meta
+      .filter(isEvmBlockchain)
+      .find((blockchain) => blockchain.name === Networks.ETHEREUM)?.chainId;
+    if (state.connected) {
+      if (state.network != Networks.ETHEREUM && eth_chainId) {
+        updateChainId(eth_chainId);
+      }
+      updateAccounts(addresses);
+    }
+  });
+
+  solanaInstance?.on('accountChanged', async (publicKey: string) => {
+    if (state.network != Networks.SOLANA) {
+      updateChainId(meta.filter(isSolanaBlockchain)[0].chainId);
+    }
     const network = Networks.SOLANA;
     if (publicKey) {
       const account = publicKey.toString();
@@ -38,23 +83,35 @@ export const subscribe: Subscribe = ({ instance, updateAccounts, connect }) => {
   });
 };
 
-export const canSwitchNetworkTo: CanSwitchNetwork = () => false;
+export const canSwitchNetworkTo: CanSwitchNetwork = canSwitchNetworkToEvm;
 
 export const getSigners: (provider: any) => SignerFactory = signer;
 
-export const canEagerConnect: CanEagerConnect = async ({ instance }) => {
-  try {
-    const result = await instance.connect({ onlyIfTrusted: true });
-    return !!result;
-  } catch (error) {
-    return false;
+export const canEagerConnect: CanEagerConnect = async ({ instance, meta }) => {
+  const evm_instance = chooseInstance(instance, meta, Networks.ETHEREUM);
+  const solana_instance = chooseInstance(instance, meta, Networks.SOLANA);
+  if (evm_instance) {
+    return canEagerlyConnectToEvm({ instance: evm_instance, meta });
   }
+
+  if (solana_instance) {
+    try {
+      const result = await instance.connect({ onlyIfTrusted: true });
+      return !!result;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  return Promise.resolve(false);
 };
 
 export const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (
   allBlockChains
 ) => {
   const solana = solanaBlockchain(allBlockChains);
+  const evms = evmBlockchains(allBlockChains);
+
   return {
     name: 'Phantom',
     img: 'https://raw.githubusercontent.com/rango-exchange/rango-assets/main/wallets/phantom/icon.svg',
@@ -65,6 +122,6 @@ export const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (
       DEFAULT: 'https://phantom.app/',
     },
     color: '#4d40c6',
-    supportedChains: solana,
+    supportedChains: [...evms, ...solana],
   };
 };

wallets/provider-phantom/src/signer.ts

@@ -1,14 +1,15 @@
+import type { SignerFactory } from 'rango-types';
+
+import { DefaultEvmSigner } from '@rango-dev/signer-evm';
 import { DefaultSolanaSigner } from '@rango-dev/signer-solana';
-import { Networks, getNetworkInstance } from '@rango-dev/wallets-shared';
-import {
-  DefaultSignerFactory,
-  SignerFactory,
-  TransactionType as TxType,
-} from 'rango-types';
+import { getNetworkInstance, Networks } from '@rango-dev/wallets-shared';
+import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
 
 export default function getSigners(provider: any): SignerFactory {
+  const ethProvider = getNetworkInstance(provider, Networks.ETHEREUM);
   const solProvider = getNetworkInstance(provider, Networks.SOLANA);
   const signers = new DefaultSignerFactory();
+  signers.registerSigner(TxType.EVM, new DefaultEvmSigner(ethProvider));
   signers.registerSigner(TxType.SOLANA, new DefaultSolanaSigner(solProvider));
   return signers;
 }