MetaMask · elribonazo · Jul 23, 2025 · Jul 22, 2025
diff --git a/packages/sdk-multichain/src/domain/errors/base.ts b/packages/sdk-multichain/src/domain/errors/base.ts
@@ -1,10 +1,10 @@
 import type { ErrorCodes } from "./types";
 
 export abstract class BaseErr<C extends string, T extends ErrorCodes> extends Error {
-  constructor(
-    public readonly message: `${C}Err${T}: ${string}`,
-    public readonly code: T,
-  ) {
-    super(message);
-  }
+	constructor(
+		public readonly message: `${C}Err${T}: ${string}`,
+		public readonly code: T,
+	) {
+		super(message);
+	}
 }
diff --git a/packages/sdk-multichain/src/domain/errors/index.ts b/packages/sdk-multichain/src/domain/errors/index.ts
@@ -1,2 +1,2 @@
-export * from './rpc'
-export * from './types';
+export * from "./rpc";
+export * from "./types";
diff --git a/packages/sdk-multichain/src/domain/errors/rpc.ts b/packages/sdk-multichain/src/domain/errors/rpc.ts
@@ -1,53 +1,34 @@
-
 import { BaseErr } from "./base";
 import type { RPCErrorCodes } from "./types";
 
-export class RPCHttpErr extends BaseErr<'RPC', RPCErrorCodes> {
-  static readonly code = 50;
-  constructor(
-     readonly rpcEndpoint: string,
-     readonly method: string,
-     readonly httpStatus: number,
-  ) {
-    super(
-      `RPCErr${RPCHttpErr.code}: ${httpStatus} on ${rpcEndpoint} for method ${method}`,
-      RPCHttpErr.code
-    );
-  }
+export class RPCHttpErr extends BaseErr<"RPC", RPCErrorCodes> {
+	static readonly code = 50;
+	constructor(
+		readonly rpcEndpoint: string,
+		readonly method: string,
+		readonly httpStatus: number,
+	) {
+		super(`RPCErr${RPCHttpErr.code}: ${httpStatus} on ${rpcEndpoint} for method ${method}`, RPCHttpErr.code);
+	}
 }
 
-export class RPCReadonlyResponseErr extends BaseErr<'RPC', RPCErrorCodes> {
-  static readonly code = 51;
-  constructor(
-    public readonly reason: string,
-  ) {
-    super(
-      `RPCErr${RPCReadonlyResponseErr.code}: RPC Client response reason ${reason}`,
-      RPCReadonlyResponseErr.code
-    );
-  }
+export class RPCReadonlyResponseErr extends BaseErr<"RPC", RPCErrorCodes> {
+	static readonly code = 51;
+	constructor(public readonly reason: string) {
+		super(`RPCErr${RPCReadonlyResponseErr.code}: RPC Client response reason ${reason}`, RPCReadonlyResponseErr.code);
+	}
 }
 
-export class RPCReadonlyRequestErr extends BaseErr<'RPC', RPCErrorCodes> {
-  static readonly code = 52;
-  constructor(
-    public readonly reason: string,
-  ) {
-    super(
-      `RPCErr${RPCReadonlyRequestErr.code}: RPC Client fetch reason ${reason}`,
-      RPCReadonlyRequestErr.code
-    );
-  }
+export class RPCReadonlyRequestErr extends BaseErr<"RPC", RPCErrorCodes> {
+	static readonly code = 52;
+	constructor(public readonly reason: string) {
+		super(`RPCErr${RPCReadonlyRequestErr.code}: RPC Client fetch reason ${reason}`, RPCReadonlyRequestErr.code);
+	}
 }
 
-export class RPCInvokeMethodErr extends BaseErr<'RPC', RPCErrorCodes> {
-  static readonly code = 53;
-  constructor(
-    public readonly reason: string,
-  ) {
-    super(
-      `RPCErr${RPCInvokeMethodErr.code}: RPC Client invoke method reason ${reason}`,
-      RPCInvokeMethodErr.code
-    );
-  }
+export class RPCInvokeMethodErr extends BaseErr<"RPC", RPCErrorCodes> {
+	static readonly code = 53;
+	constructor(public readonly reason: string) {
+		super(`RPCErr${RPCInvokeMethodErr.code}: RPC Client invoke method reason ${reason}`, RPCInvokeMethodErr.code);
+	}
 }
diff --git a/packages/sdk-multichain/src/domain/errors/storage.ts b/packages/sdk-multichain/src/domain/errors/storage.ts
@@ -1,45 +1,35 @@
-
 import { BaseErr } from "./base";
-import type {  StorageErrorCodes } from "./types";
+import type { StorageErrorCodes } from "./types";
 
-export class StorageGetErr extends BaseErr<'Storage', StorageErrorCodes> {
-  static readonly code = 60;
-  constructor(
-    public readonly platform: 'web' | 'rn' | 'node',
-    public readonly key: string,
-    public readonly reason: string,
-  ) {
-    super(
-      `StorageErr${StorageGetErr.code}: ${platform} storage get error in key: ${key} - ${reason}`,
-      StorageGetErr.code
-    );
-  }
+export class StorageGetErr extends BaseErr<"Storage", StorageErrorCodes> {
+	static readonly code = 60;
+	constructor(
+		public readonly platform: "web" | "rn" | "node",
+		public readonly key: string,
+		public readonly reason: string,
+	) {
+		super(`StorageErr${StorageGetErr.code}: ${platform} storage get error in key: ${key} - ${reason}`, StorageGetErr.code);
+	}
 }
 
-export class StorageSetErr extends BaseErr<'Storage', StorageErrorCodes> {
-  static readonly code = 61;
-  constructor(
-    public readonly platform: 'web' | 'rn' | 'node',
-    public readonly key: string,
-    public readonly reason: string,
-  ) {
-    super(
-      `StorageErr${StorageSetErr.code}: ${platform} storage set error in key: ${key} - ${reason}`,
-      StorageSetErr.code
-    );
-  }
+export class StorageSetErr extends BaseErr<"Storage", StorageErrorCodes> {
+	static readonly code = 61;
+	constructor(
+		public readonly platform: "web" | "rn" | "node",
+		public readonly key: string,
+		public readonly reason: string,
+	) {
+		super(`StorageErr${StorageSetErr.code}: ${platform} storage set error in key: ${key} - ${reason}`, StorageSetErr.code);
+	}
 }
 
-export class StorageDeleteErr extends BaseErr<'Storage', StorageErrorCodes> {
-  static readonly code = 62;
-  constructor(
-    public readonly platform: 'web' | 'rn' | 'node',
-    public readonly key: string,
-    public readonly reason: string,
-  ) {
-    super(
-      `StorageErr${StorageDeleteErr.code}: ${platform} storage delete error in key: ${key} - ${reason}`,
-      StorageDeleteErr.code
-    );
-  }
+export class StorageDeleteErr extends BaseErr<"Storage", StorageErrorCodes> {
+	static readonly code = 62;
+	constructor(
+		public readonly platform: "web" | "rn" | "node",
+		public readonly key: string,
+		public readonly reason: string,
+	) {
+		super(`StorageErr${StorageDeleteErr.code}: ${platform} storage delete error in key: ${key} - ${reason}`, StorageDeleteErr.code);
+	}
 }
diff --git a/packages/sdk-multichain/src/domain/errors/types.ts b/packages/sdk-multichain/src/domain/errors/types.ts
@@ -1,14 +1,9 @@
-export type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
-? Acc[number]
-: Enumerate<N, [...Acc, Acc['length']]>;
+export type Enumerate<N extends number, Acc extends number[] = []> = Acc["length"] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc["length"]]>;
 
 export type ErrorCodeRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
 
 export type DomainErrorCodes = ErrorCodeRange<1, 50>;
 export type RPCErrorCodes = ErrorCodeRange<50, 60>;
 export type StorageErrorCodes = ErrorCodeRange<60, 70>;
 
-export type ErrorCodes =
-  | DomainErrorCodes
-  | RPCErrorCodes
-  | StorageErrorCodes;
+export type ErrorCodes = DomainErrorCodes | RPCErrorCodes | StorageErrorCodes;
diff --git a/packages/sdk-multichain/src/domain/events/index.ts b/packages/sdk-multichain/src/domain/events/index.ts
@@ -1,7 +1,6 @@
-import { EventEmitter2 } from 'eventemitter2';
-
-import type { EventTypes } from './types';
+import { EventEmitter2 } from "eventemitter2";
 
+import type { EventTypes } from "./types";
 
 /**
  * A type-safe event emitter that provides a strongly-typed wrapper around EventEmitter2.
@@ -12,66 +11,54 @@ import type { EventTypes } from './types';
  * @template TEvents - A record type mapping event names to their argument types.
  *                    Each key represents an event name, and the value is a tuple of argument types.
  */
-export class EventEmitter<
-  TEvents extends Record<string, unknown[]> = EventTypes,
-> {
-  readonly #emitter = new EventEmitter2();
+export class EventEmitter<TEvents extends Record<string, unknown[]> = EventTypes> {
+	readonly #emitter = new EventEmitter2();
 
-  /**
-   * Emits an event with the specified name and arguments.
-   *
-   * @template TEventName - The name of the event to emit (must be a key of TEvents)
-   * @param eventName - The name of the event to emit
-   * @param eventArg - The arguments to pass to the event handlers
-   */
-  emit<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    ...eventArg: TEvents[TEventName]
-  ) {
-    this.#emitter.emit(eventName, ...eventArg);
-  }
+	/**
+	 * Emits an event with the specified name and arguments.
+	 *
+	 * @template TEventName - The name of the event to emit (must be a key of TEvents)
+	 * @param eventName - The name of the event to emit
+	 * @param eventArg - The arguments to pass to the event handlers
+	 */
+	emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]) {
+		this.#emitter.emit(eventName, ...eventArg);
+	}
 
-  /**
-   * Registers an event handler for the specified event.
-   *
-   * @template TEventName - The name of the event to listen for (must be a key of TEvents)
-   * @param eventName - The name of the event to listen for
-   * @param handler - The function to call when the event is emitted
-   */
-  on<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    handler: (...eventArg: TEvents[TEventName]) => void,
-  ) {
-    this.#emitter.on(eventName, handler);
-  }
+	/**
+	 * Registers an event handler for the specified event.
+	 *
+	 * @template TEventName - The name of the event to listen for (must be a key of TEvents)
+	 * @param eventName - The name of the event to listen for
+	 * @param handler - The function to call when the event is emitted
+	 */
+	on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void) {
+		this.#emitter.on(eventName, handler);
+	}
 
-  /**
-   * Sets the maximum number of listeners that can be registered for any single event.
-   *
-   * This is useful for preventing memory leaks when many listeners are registered.
-   * By default, EventEmitter2 will warn if more than 10 listeners are registered
-   * for a single event.
-   *
-   * @param maxListeners - The maximum number of listeners per event (0 means unlimited)
-   */
-  setMaxListeners(maxListeners: number) {
-    this.#emitter.setMaxListeners(maxListeners);
-  }
+	/**
+	 * Sets the maximum number of listeners that can be registered for any single event.
+	 *
+	 * This is useful for preventing memory leaks when many listeners are registered.
+	 * By default, EventEmitter2 will warn if more than 10 listeners are registered
+	 * for a single event.
+	 *
+	 * @param maxListeners - The maximum number of listeners per event (0 means unlimited)
+	 */
+	setMaxListeners(maxListeners: number) {
+		this.#emitter.setMaxListeners(maxListeners);
+	}
 
-  /**
-   * Removes a specific event handler for the specified event.
-   *
-   * @template TEventName - The name of the event to remove the handler from (must be a key of TEvents)
-   * @param eventName - The name of the event to remove the handler from
-   * @param handler - The specific handler function to remove
-   */
-  off<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    handler: (...eventArg: TEvents[TEventName]) => void,
-  ) {
-    this.#emitter.off(eventName, handler);
-  }
+	/**
+	 * Removes a specific event handler for the specified event.
+	 *
+	 * @template TEventName - The name of the event to remove the handler from (must be a key of TEvents)
+	 * @param eventName - The name of the event to remove the handler from
+	 * @param handler - The specific handler function to remove
+	 */
+	off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void) {
+		this.#emitter.off(eventName, handler);
+	}
 }
 
-
-export type * from './types';
+export type * from "./types";
diff --git a/packages/sdk-multichain/src/domain/events/types/extension.ts b/packages/sdk-multichain/src/domain/events/types/extension.ts
@@ -2,5 +2,5 @@
  * Extension native Events
  */
 export type ExtensionEvents = {
-  chainChanged: [evt: unknown];
+	chainChanged: [evt: unknown];
 };
diff --git a/packages/sdk-multichain/src/domain/events/types/index.ts b/packages/sdk-multichain/src/domain/events/types/index.ts
@@ -1,5 +1,5 @@
-import type { ExtensionEvents } from './extension';
-import type { SDKEvents } from './sdk';
+import type { ExtensionEvents } from "./extension";
+import type { SDKEvents } from "./sdk";
 
 export type EventTypes = SDKEvents | ExtensionEvents;
 export type { SDKEvents, ExtensionEvents };
diff --git a/packages/sdk-multichain/src/domain/events/types/sdk.ts b/packages/sdk-multichain/src/domain/events/types/sdk.ts
@@ -1,3 +1,3 @@
 export type SDKEvents = {
-  display_uri: [evt: string];
+	display_uri: [evt: string];
 };