@toruslabs/ethereum-controllers 4.5.2 → 4.7.0

package/src/Message/utils.ts

@@ -1,8 +1,16 @@
 import { addHexPrefix, bytesToHex, isValidAddress, stripHexPrefix } from "@ethereumjs/util";
 import { EthEncryptedData, TYPED_MESSAGE_SCHEMA, TypedDataV1Field, typedSignatureHash } from "@metamask/eth-sig-util";
+import { isHexString, JsonRpcProvider, toQuantity } from "ethers";
 import { validate } from "jsonschema";
 
-import { DecryptMessageParams, EncryptionPublicKeyParams, MessageParams, TypedMessageParams } from "../utils/interfaces";
+import {
+  AddChainMessageParams,
+  DecryptMessageParams,
+  EncryptionPublicKeyParams,
+  MessageParams,
+  SwitchChainMessageParams,
+  TypedMessageParams,
+} from "../utils/interfaces";
 
 const hexRe = /^[0-9A-Fa-f]+$/gu;
 
@@ -105,3 +113,43 @@ export function parseDecryptMessageData(data: string): EthEncryptedData {
   const buffer = Buffer.from(stripped, "hex");
   return JSON.parse(buffer.toString("utf8")) as EthEncryptedData;
 }
+
+export async function validateAddChainData(data: AddChainMessageParams) {
+  const { chainId, rpcUrls, nativeCurrency } = data || {};
+
+  if (!chainId) {
+    throw new Error("Invalid add chain params: please pass chainId in params");
+  }
+
+  if (!isHexString(chainId)) {
+    throw new Error("Invalid add chain params: please pass a valid hex chainId in params, for: ex: 0x1");
+  }
+
+  if (!rpcUrls || rpcUrls.length === 0) throw new Error("params.rpcUrls not provided");
+  if (!nativeCurrency) throw new Error("params.nativeCurrency not provided");
+  const { name, symbol, decimals } = nativeCurrency;
+
+  if (!name) throw new Error("params.nativeCurrency.name not provided");
+  if (!symbol) throw new Error("params.nativeCurrency.symbol not provided");
+  if (decimals === undefined) throw new Error("params.nativeCurrency.decimals not provided");
+
+  const _web3 = new JsonRpcProvider(rpcUrls[0], "any");
+  const { chainId: networkChainID } = await _web3.getNetwork();
+  if (Number.parseInt(networkChainID.toString()) !== Number.parseInt(chainId, 16)) {
+    throw new Error(
+      `Provided rpc url's chainId version is not matching with provided chainId, expected: ${toQuantity(networkChainID)}, received: ${chainId}`
+    );
+  }
+}
+
+export function validateSwitchChainData(data: SwitchChainMessageParams) {
+  const { chainId } = data || {};
+
+  if (!chainId) {
+    throw new Error("Invalid switch chain params: please pass chainId in params");
+  }
+
+  if (!isHexString(chainId)) {
+    throw new Error("Invalid switch chain params: please pass a valid hex chainId in params, for: ex: 0x1");
+  }
+}

package/src/Network/createEthereumMiddleware.ts

@@ -1,3 +1,4 @@
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
 import { InPageWalletProviderState, PROVIDER_JRPC_METHODS } from "@toruslabs/base-controllers";
 import {
   createAsyncMiddleware,
@@ -12,10 +13,12 @@ import {
 
 import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES } from "../utils/constants";
 import {
+  AddChainMessageParams,
   BlockParams,
   EncryptionPublicKeyParams,
   EthereumTransactionMeta,
   MessageParams,
+  SwitchChainMessageParams,
   TransactionParams,
   TransactionRPCMeta,
   TypedMessageParams,
@@ -30,17 +33,18 @@ export interface IProviderHandlers {
   // All operations which open popup window or modal should operate with a windowId parameter
   processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
 
-  processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
-  processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-  processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-  processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-  processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+  processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
 
-  processEncryptionPublicKey?: (
-    msgParams: EncryptionPublicKeyParams,
-    req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams
-  ) => Promise<string>;
-  processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processEncryptionPublicKey?: (msgParams: EncryptionPublicKeyParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+  processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+
+  processSwitchEthereumChain?: (msgParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+
+  processAddEthereumChain?: (msgParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
 
   getPendingNonce?: (
     nonceParams: { address: string; blockReference: string },
@@ -87,14 +91,30 @@ export function createProcessEthSignMessage({
   processEthSignMessage,
 }: {
   processEthSignMessage: IProviderHandlers["processEthSignMessage"];
-}): JRPCMiddleware<MessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
     const { method } = request;
     if (method !== METHOD_TYPES.ETH_SIGN) return next();
 
     if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: MessageParams = request.params as MessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, message]`);
 
-    response.result = await processEthSignMessage(request.params, request);
+      const params = request.params as [string, string];
+      const address = params[0];
+      const message = params[1];
+
+      msgParams = {
+        from: address,
+        data: message,
+      };
+    }
+
+    response.result = await processEthSignMessage(msgParams, request);
   });
 }
 
@@ -102,13 +122,31 @@ export function createProcessTypedMessage({
   processTypedMessage,
 }: {
   processTypedMessage: IProviderHandlers["processTypedMessage"];
-}): JRPCMiddleware<TypedMessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
     const { method } = request;
     if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA) return next();
 
     if (!processTypedMessage) throw new Error("WalletMiddleware - opts.processTypedMessage not  provided");
-    response.result = await processTypedMessage(request.params, request);
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: TypedMessageParams = request.params as TypedMessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [typedData, address]`);
+
+      const params = request.params as [Record<string, unknown>[], string];
+      const message = params[0];
+      const address = params[1];
+
+      msgParams = {
+        from: address,
+        data: message,
+        version: SignTypedDataVersion.V1,
+      };
+    }
+
+    response.result = await processTypedMessage(msgParams, request);
   });
 }
 
@@ -116,14 +154,31 @@ export function createProcessTypedMessageV3({
   processTypedMessageV3,
 }: {
   processTypedMessageV3: IProviderHandlers["processTypedMessageV3"];
-}): JRPCMiddleware<TypedMessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
     const { method } = request;
     if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V3) return next();
 
     if (!processTypedMessageV3) throw new Error("WalletMiddleware - opts.processTypedMessageV3 is not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: TypedMessageParams = request.params as TypedMessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
+
+      const params = request.params as [string, string];
+      const address = params[0];
+      const message = JSON.parse(params[1]);
 
-    response.result = await processTypedMessageV3(request.params, request);
+      msgParams = {
+        from: address,
+        data: message,
+        version: SignTypedDataVersion.V3,
+      };
+    }
+
+    response.result = await processTypedMessageV3(msgParams, request);
   });
 }
 
@@ -131,14 +186,31 @@ export function createProcessTypedMessageV4({
   processTypedMessageV4,
 }: {
   processTypedMessageV4: IProviderHandlers["processTypedMessageV4"];
-}): JRPCMiddleware<TypedMessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
     const { method } = request;
     if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
 
     if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: TypedMessageParams = request.params as TypedMessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
+
+      const params = request.params as [string, string];
+      const address = params[0];
+      const message = JSON.parse(params[1]);
 
-    response.result = await processTypedMessageV4(request.params, request);
+      msgParams = {
+        from: address,
+        data: message,
+        version: SignTypedDataVersion.V4,
+      };
+    }
+
+    response.result = await processTypedMessageV4(msgParams, request);
   });
 }
 
@@ -146,14 +218,30 @@ export function createProcessPersonalMessage({
   processPersonalMessage,
 }: {
   processPersonalMessage: IProviderHandlers["processPersonalMessage"];
-}): JRPCMiddleware<MessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
     const { method } = request;
     if (method !== METHOD_TYPES.PERSONAL_SIGN) return next();
 
     if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: MessageParams = request.params as MessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
 
-    response.result = await processPersonalMessage(request.params, request);
+      const params = request.params as [string, string];
+      const message = params[0];
+      const address = params[1];
+
+      msgParams = {
+        from: address,
+        data: message,
+      };
+    }
+
+    response.result = await processPersonalMessage(msgParams, request);
   });
 }
 
@@ -230,14 +318,25 @@ export function createProcessEncryptionPublicKeyMiddleware({
   processEncryptionPublicKey,
 }: {
   processEncryptionPublicKey: IProviderHandlers["processEncryptionPublicKey"];
-}): JRPCMiddleware<EncryptionPublicKeyParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
-    const { params, method } = request;
+    const { method } = request;
     if (method !== METHOD_TYPES.ETH_GET_ENCRYPTION_PUBLIC_KEY) return next();
 
     if (!processEncryptionPublicKey) throw new Error("WalletMiddleware - opts.processEncryptionPublicKey not provided");
 
-    response.result = await processEncryptionPublicKey(params, request);
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: EncryptionPublicKeyParams = request.params as EncryptionPublicKeyParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address]`);
+
+      const [address] = request.params as [string];
+      msgParams = { data: address, from: address };
+    }
+
+    response.result = await processEncryptionPublicKey(msgParams, request);
   });
 }
 
@@ -245,14 +344,75 @@ export function createProcessDecryptMessageMiddleware({
   processDecryptMessage,
 }: {
   processDecryptMessage: IProviderHandlers["processDecryptMessage"];
-}): JRPCMiddleware<MessageParams, string> {
+}): JRPCMiddleware<unknown, string> {
   return createAsyncMiddleware(async (request, response, next) => {
-    const { params, method } = request;
+    const { method } = request;
     if (method !== METHOD_TYPES.ETH_DECRYPT) return next();
 
     if (!processDecryptMessage) throw new Error("WalletMiddleware - opts.processDecryptMessage not provided");
 
-    response.result = await processDecryptMessage(params, request);
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: MessageParams = request.params as MessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
+
+      const [message, address] = request.params as [string, string];
+      msgParams = { data: message, from: address };
+    }
+
+    response.result = await processDecryptMessage(msgParams, request);
+  });
+}
+
+export function createProcessSwitchEthereumChain({
+  processSwitchEthereumChain,
+}: {
+  processSwitchEthereumChain: IProviderHandlers["processSwitchEthereumChain"];
+}): JRPCMiddleware<unknown, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.SWITCH_CHAIN) return next();
+
+    if (!processSwitchEthereumChain) throw new Error("WalletMiddleware - opts.processSwitchEthereumChain not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: SwitchChainMessageParams = request.params as SwitchChainMessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+
+      const [message] = request.params as [SwitchChainMessageParams];
+      msgParams = message;
+    }
+
+    response.result = await processSwitchEthereumChain(msgParams, request);
+  });
+}
+
+export function createProcessAddEthereumChain({
+  processAddEthereumChain,
+}: {
+  processAddEthereumChain: IProviderHandlers["processAddEthereumChain"];
+}): JRPCMiddleware<unknown, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ADD_CHAIN) return next();
+
+    if (!processAddEthereumChain) throw new Error("WalletMiddleware - opts.processAddEthereumChain not provided");
+    if (!request?.params) throw new Error("WalletMiddleware - missing params");
+
+    let msgParams: AddChainMessageParams = request.params as AddChainMessageParams;
+
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+
+      const [message] = request.params as [AddChainMessageParams];
+      msgParams = message;
+    }
+
+    response.result = await processAddEthereumChain(msgParams, request);
   });
 }
 
@@ -287,6 +447,8 @@ export function createEthereumMiddleware(providerHandlers: IProviderHandlers): J
     getPendingTransactionByHash,
     processEncryptionPublicKey,
     processDecryptMessage,
+    processSwitchEthereumChain,
+    processAddEthereumChain,
     getProviderState,
     version,
   } = providerHandlers;
@@ -307,5 +469,7 @@ export function createEthereumMiddleware(providerHandlers: IProviderHandlers): J
     createPendingTxMiddleware({ getPendingTransactionByHash }) as JRPCMiddleware<unknown, unknown>,
     createProcessEncryptionPublicKeyMiddleware({ processEncryptionPublicKey }) as JRPCMiddleware<unknown, unknown>,
     createProcessDecryptMessageMiddleware({ processDecryptMessage }) as JRPCMiddleware<unknown, unknown>,
+    createProcessSwitchEthereumChain({ processSwitchEthereumChain }) as JRPCMiddleware<unknown, unknown>,
+    createProcessAddEthereumChain({ processAddEthereumChain }) as JRPCMiddleware<unknown, unknown>,
   ]);
 }

package/src/Preferences/PreferencesController.ts

@@ -22,10 +22,12 @@ import NetworkController from "../Network/NetworkController";
 import { SUPPORTED_NETWORKS } from "../utils/constants";
 import { formatDate, formatPastTx, formatTime, getEthTxStatus } from "../utils/helpers";
 import type {
+  AddChainMessageParams,
   CustomNetworkPayload,
   CustomNetworks,
   CustomNftInfo,
   CustomTokenInfo,
+  EthereumProviderConfig,
   EthereumUser,
   ExtendedAddressPreferences,
   FetchCommonTransaction,
@@ -42,6 +44,7 @@ interface IPreferencesControllerOptions {
   blockTracker?: PollingBlockTracker;
   signAuthMessage?: KeyringController["signAuthMessage"];
   getProviderConfig?: NetworkController["getProviderConfig"];
+  setProviderConfig?: NetworkController["setProviderConfig"];
 }
 
 export default class PreferencesController
@@ -54,14 +57,17 @@ export default class PreferencesController
 
   private getProviderConfig: NetworkController["getProviderConfig"];
 
+  private setProviderConfig: NetworkController["setProviderConfig"];
+
   private provider: SafeEventEmitterProvider;
 
   private blockTracker: PollingBlockTracker;
 
-  constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig }: IPreferencesControllerOptions) {
+  constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig, setProviderConfig }: IPreferencesControllerOptions) {
     super({ config, state, defaultPreferences: { formattedPastTransactions: [], fetchedPastTx: [], paymentTx: [] }, signAuthMessage });
     this.provider = provider;
     this.getProviderConfig = getProviderConfig;
+    this.setProviderConfig = setProviderConfig;
     this.blockTracker = blockTracker;
     log.info(this.blockTracker);
   }
@@ -261,6 +267,36 @@ export default class PreferencesController
     return this.getAddressState(address)?.customNfts ?? [];
   }
 
+  public async addChain(network: AddChainMessageParams): Promise<void> {
+    const approveChainOptions = this.getChainOptions();
+    const providerConfig = approveChainOptions.find((x) => x.chainId === network.chainId);
+
+    if (providerConfig) {
+      throw new Error(`chainId ${network.chainId} already exists`);
+    }
+
+    const newNetwork: CustomNetworkPayload = {
+      displayName: network.chainName,
+      rpcTarget: network.rpcUrls[0],
+      ticker: network.nativeCurrency.symbol,
+      chainId: network.chainId,
+      blockExplorerUrl: network.blockExplorerUrls[0],
+    };
+
+    const isSuccess = await this.addCustomNetwork({ type: "rpc", network: newNetwork });
+    if (!isSuccess) throw new Error("unable to add custom network");
+  }
+
+  switchChain(data: { chainId: string }) {
+    const chainOptions = this.getChainOptions();
+    const providerConfig = chainOptions.find((x) => x.chainId === data.chainId);
+    if (providerConfig) {
+      this.setProviderConfig(providerConfig);
+    } else {
+      throw new Error(`chainId ${data.chainId} is not supported`);
+    }
+  }
+
   // Custom Network methods
   public async addCustomNetwork({ type, network }: { type: string; network: CustomNetworkPayload }): Promise<number> {
     try {
@@ -354,6 +390,35 @@ export default class PreferencesController
     this.updateState({ paymentTx: accumulator }, address);
   }
 
+  private getChainOptions(): EthereumProviderConfig[] {
+    const { selectedAddress, identities } = this.state;
+    const customNetworks = identities[selectedAddress]?.customNetworks ?? [];
+
+    const custom: EthereumProviderConfig[] = Object.values(customNetworks).reduce((chains, network) => {
+      const networkItem = {
+        blockExplorerUrl: network.block_explorer_url,
+        chainId: network.chain_id,
+        displayName: network.network_name,
+        logo: "eth.svg",
+        rpcTarget: network.rpc_url,
+        ticker: network.symbol,
+        tickerName: network.symbol.toUpperCase(),
+        isCustom: true,
+        id: network.id,
+      };
+      if (Object.keys(SUPPORTED_NETWORKS).includes(networkItem.chainId)) return chains;
+      chains.push(networkItem);
+      return chains;
+    }, []);
+
+    const supported = Object.values(SUPPORTED_NETWORKS).reduce((chains, network) => {
+      chains.push(network);
+      return chains;
+    }, []);
+
+    return [...supported, ...custom];
+  }
+
   private async calculatePastTx(txs: FetchedTransaction[], address: string) {
     const pastTx = [];
     const pendingTx = [];

package/src/index.ts

@@ -5,10 +5,12 @@ export { default as GasFeeController } from "./Gas/GasFeeController";
 export * from "./Gas/IGasFeeController";
 export { default as KeyringController } from "./Keyring/KeyringController";
 export * from "./Message/AbstractMessageController";
+export * from "./Message/AddChainController";
 export * from "./Message/DecryptMessageController";
 export * from "./Message/EncryptionPublicKeyController";
 export * from "./Message/MessageController";
 export * from "./Message/PersonalMessageController";
+export * from "./Message/SwitchChainController";
 export * from "./Message/TypedMessageController";
 export * from "./Message/utils";
 export * from "./Network/createEthereumMiddleware";

package/src/utils/constants.ts

@@ -193,6 +193,8 @@ export const METHOD_TYPES = {
   ETH_GET_BLOCK_BY_HASH: "eth_getBlockByHash",
   ETH_GET_CODE: "eth_getCode",
   ETH_GET_GAS_PRICE: "eth_gasPrice",
+  SWITCH_CHAIN: "wallet_switchEthereumChain",
+  ADD_CHAIN: "wallet_addEthereumChain",
 } as const;
 
 export const TRANSACTION_ENVELOPE_TYPES = {

package/src/utils/interfaces.ts

@@ -73,7 +73,7 @@ export interface BaseRequestParams {
   /**
    * Unique id for each request
    */
-  id: string;
+  id?: string;
   /**
    * Address to send this transaction from.
    */
@@ -115,6 +115,31 @@ export type SignTypedDataMessageV3V4 = {
   message: unknown;
 };
 
+export interface SwitchChainMessageParams extends BaseRequestParams {
+  chainId: string;
+  displayName?: string;
+}
+
+export interface SwitchChainMessage extends AbstractMessage {
+  messageParams: SwitchChainMessageParams;
+}
+
+export interface AddChainMessageParams extends BaseRequestParams {
+  chainId: string;
+  chainName: string;
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  rpcUrls: string[];
+  blockExplorerUrls?: string[];
+}
+
+export interface AddChainMessage extends AbstractMessage {
+  messageParams: AddChainMessageParams;
+}
+
 export interface TypedMessageParams extends BaseRequestParams {
   data: Record<string, unknown>[] | string | SignTypedDataMessageV3V4;
   version?: SignTypedDataVersion;