add Massa wallet support

packages/extension/src/libs/background/index.ts

@@ -48,6 +48,7 @@ class BackgroundHandler {
       [ProviderName.bitcoin]: {},
       [ProviderName.kadena]: {},
       [ProviderName.solana]: {},
+      [ProviderName.massa]: {},
     };
     this.#providers = Providers;
   }

packages/extension/src/libs/background/types.ts

@@ -3,6 +3,7 @@ import type EthereumProvider from '@/providers/ethereum';
 import type PolkadotProvider from '@/providers/polkadot';
 import type KadenaProvider from '@/providers/kadena';
 import SolanaProvider from '@/providers/solana';
+import MassaProvider from '@/providers/massa';
 
 export interface TabProviderType {
   [key: string]: Record<
@@ -12,6 +13,7 @@ export interface TabProviderType {
     | BitcoinProvider
     | KadenaProvider
     | SolanaProvider
+    | MassaProvider
   >;
 }
 export interface ProviderType {
@@ -20,7 +22,8 @@ export interface ProviderType {
     | typeof PolkadotProvider
     | typeof BitcoinProvider
     | typeof KadenaProvider
-    | typeof SolanaProvider;
+    | typeof SolanaProvider
+    | typeof MassaProvider;
 }
 export interface ExternalMessageOptions {
   savePersistentEvents: boolean;

packages/extension/src/libs/utils/initialize-wallet.ts

@@ -4,10 +4,12 @@ import PolkadotNetworks from '@/providers/polkadot/networks';
 import BitcoinNetworks from '@/providers/bitcoin/networks';
 import KadenaNetworks from '@/providers/kadena/networks';
 import SolanaNetworks from '@/providers/solana/networks';
+import MassaNetworks from '@/providers/massa/networks';
 import { NetworkNames, WalletType } from '@enkryptcom/types';
 import { getAccountsByNetworkName } from '@/libs/utils/accounts';
 import BackupState from '../backup-state';
 export const initAccounts = async (keyring: KeyRing) => {
+  console.log("<>>>>>>>>>>> YOOLOOOOOOO initAccounts",keyring)
   const secp256k1btc = (
     await getAccountsByNetworkName(NetworkNames.Bitcoin)
   ).filter(acc => !acc.isTestWallet);
@@ -23,6 +25,9 @@ export const initAccounts = async (keyring: KeyRing) => {
   const ed25519sol = (
     await getAccountsByNetworkName(NetworkNames.Solana)
   ).filter(acc => !acc.isTestWallet);
+  const ed25519massa = (
+    await getAccountsByNetworkName(NetworkNames.Massa)
+  ).filter(acc => !acc.isTestWallet);
   if (secp256k1.length == 0)
     await keyring.saveNewAccount({
       basePath: EthereumNetworks.ethereum.basePath,
@@ -58,6 +63,13 @@ export const initAccounts = async (keyring: KeyRing) => {
       signerType: SolanaNetworks.solana.signer[0],
       walletType: WalletType.mnemonic,
     });
+  if (ed25519massa.length == 0)
+    await keyring.saveNewAccount({
+      basePath: MassaNetworks.mainnet.basePath,
+      name: 'Massa Account 1',
+      signerType: MassaNetworks.mainnet.signer[0],
+      walletType: WalletType.mnemonic,
+    });
 };
 export const onboardInitializeWallets = async (options: {
   mnemonic: string;

packages/extension/src/libs/utils/networks.ts

@@ -13,13 +13,16 @@ import Polkadot from '@/providers/polkadot/networks/polkadot';
 import Bitcoin from '@/providers/bitcoin/networks/bitcoin';
 import Kadena from '@/providers/kadena/networks/kadena';
 import Solana from '@/providers/solana/networks/solana';
+import MassaNetworks from '@/providers/massa/networks';
+import Massa from '@/providers/massa/networks/mainnet';
 
 const providerNetworks: Record<ProviderName, Record<string, BaseNetwork>> = {
   [ProviderName.ethereum]: EthereumNetworks,
   [ProviderName.polkadot]: PolkadotNetworks,
   [ProviderName.bitcoin]: BitcoinNetworks,
   [ProviderName.kadena]: KadenaNetworks,
   [ProviderName.solana]: SolanaNetworks,
+  [ProviderName.massa]: MassaNetworks,
   [ProviderName.enkrypt]: {},
 };
 const getAllNetworks = async (includeCustom: boolean = true): Promise<BaseNetwork[]> => {
@@ -32,7 +35,9 @@ const getAllNetworks = async (includeCustom: boolean = true): Promise<BaseNetwor
     .concat(Object.values(PolkadotNetworks) as BaseNetwork[])
     .concat(Object.values(BitcoinNetworks) as BaseNetwork[])
     .concat(Object.values(KadenaNetworks) as BaseNetwork[])
-    .concat(Object.values(SolanaNetworks) as BaseNetwork[]);
+    .concat(Object.values(SolanaNetworks) as BaseNetwork[])
+    .concat(Object.values(MassaNetworks) as BaseNetwork[]);
+
   if (!includeCustom) {
     return allNetworks
   }
@@ -65,17 +70,20 @@ const DEFAULT_SUBSTRATE_NETWORK_NAME = NetworkNames.Polkadot;
 const DEFAULT_BTC_NETWORK_NAME = NetworkNames.Bitcoin;
 const DEFAULT_KADENA_NETWORK_NAME = NetworkNames.Kadena;
 const DEFAULT_SOLANA_NETWORK_NAME = NetworkNames.Solana;
+const DEFAULT_MASSA_NETWORK_NAME = NetworkNames.Massa;
 
 const DEFAULT_EVM_NETWORK = Ethereum;
 const DEFAULT_SUBSTRATE_NETWORK = Polkadot;
 const DEFAULT_BTC_NETWORK = Bitcoin;
 const DEFAULT_KADENA_NETWORK = Kadena;
 const DEFAULT_SOLANA_NETWORK = Solana;
+const DEFAULT_MASSA_NETWORK = Massa;
 
 const POPULAR_NAMES = [
   NetworkNames.Bitcoin,
   NetworkNames.Ethereum,
   NetworkNames.Solana,
+  NetworkNames.Massa,
   NetworkNames.Matic,
   NetworkNames.Polkadot,
   NetworkNames.Binance,
@@ -98,4 +106,6 @@ export {
   DEFAULT_KADENA_NETWORK_NAME,
   DEFAULT_SOLANA_NETWORK,
   DEFAULT_SOLANA_NETWORK_NAME,
+  DEFAULT_MASSA_NETWORK,
+  DEFAULT_MASSA_NETWORK_NAME,
 };

packages/extension/src/providers/index.ts

@@ -3,6 +3,7 @@ import PolkadotProvider from '@/providers/polkadot';
 import BitcoinProvider from '@/providers/bitcoin';
 import KadenaProvider from '@/providers/kadena';
 import SolanaProvider from '@/providers/solana';
+import MassaProvider from '@/providers/massa';
 import { ProviderName } from '@/types/provider';
 
 export default {
@@ -11,4 +12,5 @@ export default {
   [ProviderName.bitcoin]: BitcoinProvider,
   [ProviderName.kadena]: KadenaProvider,
   [ProviderName.solana]: SolanaProvider,
+  [ProviderName.massa]: MassaProvider,
 };

packages/extension/src/providers/massa/index.ts

@@ -0,0 +1,126 @@
+import { BaseNetwork } from '@/types/base-network';
+import getRequestProvider, { RequestClass } from '@enkryptcom/request';
+import { MiddlewareFunction, OnMessageResponse } from '@enkryptcom/types';
+import Middlewares from './methods';
+import EventEmitter from 'eventemitter3';
+import {
+  BackgroundProviderInterface,
+  ProviderName,
+  ProviderRPCRequest,
+} from '@/types/provider';
+import GetUIPath from '@/libs/utils/get-ui-path';
+import PublicKeyRing from '@/libs/keyring/public-keyring';
+import UIRoutes from './ui/routes/names';
+import MassaAPI from './libs/api';
+import { TransactionHandler } from './libs/transaction-handler';
+import { MessageHandler } from './libs/message-handler';
+import {  MassaTransactionOptions } from './types';
+import { JsonRPCClient } from '@massalabs/massa-web3/dist/esm/client/jsonRPCClient';
+import { RoutesType } from '@/types/ui';
+
+export default class MassaProvider
+  extends EventEmitter
+  implements BackgroundProviderInterface
+{
+  private api: MassaAPI;
+  private client: JsonRPCClient;
+  private transactionHandler: TransactionHandler;
+  private messageHandler: MessageHandler;
+  requestProvider: RequestClass;
+  middlewares: MiddlewareFunction[] = [];
+  namespace: string;
+  KeyRing: PublicKeyRing;
+  UIRoutes: RoutesType;
+  toWindow: (message: string) => void;
+
+  constructor(toWindow: (message: string) => void) {
+    super();
+    this.toWindow = toWindow;
+    this.setMiddleWares();
+    this.requestProvider = getRequestProvider('', this.middlewares);
+    this.requestProvider.on('notification', (notif: any) => {
+      this.sendNotification(JSON.stringify(notif));
+    });
+    this.namespace = ProviderName.massa;
+    this.KeyRing = new PublicKeyRing();
+    this.api = new MassaAPI('');
+    this.client = new JsonRPCClient('');
+    this.transactionHandler = new TransactionHandler(this.client);
+    this.messageHandler = new MessageHandler(this.client);
+    this.UIRoutes = UIRoutes;
+  }
+
+  private setMiddleWares(): void {
+    this.middlewares = Middlewares(this);
+  }
+
+  setRequestProvider(network: BaseNetwork): void {
+    this.api = new MassaAPI(network.node);
+    this.client = new JsonRPCClient(network.node);
+    this.transactionHandler = new TransactionHandler(this.client);
+    this.messageHandler = new MessageHandler(this.client);
+    this.requestProvider.changeNetwork(network.node);
+  }
+
+  async isPersistentEvent(): Promise<boolean> {
+    return false;
+  }
+
+  async sendNotification(notif: string): Promise<void> {
+    return this.toWindow(notif);
+  }
+
+  request(request: ProviderRPCRequest): Promise<OnMessageResponse> {
+    return this.requestProvider
+      .request(request)
+      .then(res => {
+        return {
+          result: JSON.stringify(res),
+        };
+      })
+      .catch(e => {
+        return {
+          error: JSON.stringify(e.message),
+        };
+      });
+  }
+
+  getUIPath(page: string): string {
+    return GetUIPath(page, this.namespace);
+  }
+
+  // Massa-specific methods
+  async getBalance(address: string): Promise<string> {
+    return this.api.getBalance(address);
+  }
+
+  async getTransactionStatus(opId: string): Promise<any> {
+    return this.api.getTransactionStatus(opId);
+  }
+
+  async createTransaction(
+    from: string,
+    to: string,
+    amount: string,
+    options: MassaTransactionOptions = {}
+  ): Promise<any> {
+    return this.transactionHandler.createTransaction(from, to, amount, options);
+  }
+
+  async sendTransaction(
+    from: string,
+    to: string,
+    amount: string,
+    options: MassaTransactionOptions = {}
+  ): Promise<string> {
+    return this.transactionHandler.sendTransaction(from, to, amount, options);
+  }
+
+  async getTransactionInfo(opId: string): Promise<any> {
+    return this.transactionHandler.getTransactionInfo(opId);
+  }
+
+  async estimateFee(): Promise<string> {
+    return this.transactionHandler.estimateFee();
+  }
+}