@imtbl/wallet 2.10.7-alpha.2

package/src/zkEvm/walletHelpers.ts

@@ -0,0 +1,243 @@
+import { walletContracts } from '@0xsequence/abi';
+import { v1 as sequenceCoreV1 } from '@0xsequence/core';
+import {
+  BigNumberish, Contract, getBytes, hashMessage,
+  Interface, keccak256, Signer, solidityPacked, ZeroAddress,
+  TypedDataEncoder, JsonRpcProvider, AbiCoder,
+  isError,
+} from 'ethers';
+import { MetaTransaction, MetaTransactionNormalised, TypedDataPayload } from './types';
+
+const SIGNATURE_WEIGHT = 1; // Weight of a single signature in the multi-sig
+const TRANSACTION_SIGNATURE_THRESHOLD = 1; // Total required weight in the multi-sig for a transaction
+const PACKED_SIGNATURE_THRESHOLD = 2; // Total required weight in the multi-sig for data signing
+
+const ETH_SIGN_FLAG = '02';
+const ETH_SIGN_PREFIX = '\x19\x01';
+const META_TRANSACTIONS_TYPE = `tuple(
+  bool delegateCall,
+  bool revertOnError,
+  uint256 gasLimit,
+  address target,
+  uint256 value,
+  bytes data
+)[]`;
+
+export const getNormalisedTransactions = (txs: MetaTransaction[]): MetaTransactionNormalised[] => txs.map((t) => ({
+  delegateCall: t.delegateCall === true,
+  revertOnError: t.revertOnError === true,
+  gasLimit: t.gasLimit ?? BigInt(0),
+  target: t.to ?? ZeroAddress,
+  value: t.value ?? BigInt(0),
+  data: t.data ?? '0x',
+}));
+
+export const digestOfTransactionsAndNonce = (
+  nonce: BigNumberish,
+  normalisedTransactions: MetaTransactionNormalised[],
+): string => {
+  const packMetaTransactionsNonceData = AbiCoder.defaultAbiCoder().encode(
+    ['uint256', META_TRANSACTIONS_TYPE],
+    [nonce, normalisedTransactions],
+  );
+  return keccak256(packMetaTransactionsNonceData);
+};
+
+export const encodedTransactions = (
+  normalisedTransactions: MetaTransactionNormalised[],
+): string => AbiCoder.defaultAbiCoder().encode(
+  [META_TRANSACTIONS_TYPE],
+  [normalisedTransactions],
+);
+
+/**
+ * This helper function is used to coerce the type <BigNumber | undefined> to BigNumber for the
+ * getNonce function above.
+ * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @returns {BigNumber} The passed in nonceSpace or instead initialises the nonce to 0.
+ */
+export const coerceNonceSpace = (nonceSpace?: bigint): bigint => nonceSpace || 0n;
+
+/**
+ * This helper function is used to encode the nonce into a 256 bit value where the space is encoded into
+ * the first 160 bits, and the nonce the remaining 96 bits.
+ * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @param nonce {BigNumber} nonce - Sequential number starting at 0, and incrementing in single steps e.g. 0,1,2,...
+ * @returns {BigNumber} The encoded value where the space is left shifted 96 bits, and the nonce is in the first 96 bits.
+ */
+export const encodeNonce = (nonceSpace: bigint, nonce: bigint): bigint => {
+  const shiftedSpace = BigInt(nonceSpace) * (2n ** 96n);
+  return BigInt(nonce) + (shiftedSpace);
+};
+
+/**
+ * When we retrieve a nonce for a smart contract wallet we can retrieve the nonce in a given 256 bit space.
+ * Nonces in each 256 bit space need to be sequential per wallet address. Nonces across 256 bit spaces per
+ * wallet address do not. This function overload can be used to invoke transactions in parallel per smart
+ * contract wallet if required.
+ */
+export const getNonce = async (
+  rpcProvider: JsonRpcProvider,
+  smartContractWalletAddress: string,
+  nonceSpace?: bigint,
+): Promise<bigint> => {
+  try {
+    const contract = new Contract(
+      smartContractWalletAddress,
+      walletContracts.mainModule.abi,
+      rpcProvider,
+    );
+    const space: bigint = coerceNonceSpace(nonceSpace); // Default nonce space is 0
+    const result = await contract.readNonce(space);
+    if (typeof result === 'bigint') {
+      return encodeNonce(space, result);
+    }
+    throw new Error('Unexpected result from contract.nonce() call.');
+  } catch (error) {
+    if (isError(error, 'BAD_DATA')) {
+      // The most likely reason for a BAD_DATA error is that the smart contract wallet
+      // has not been deployed yet, so we should default to a nonce of 0.
+      return BigInt(0);
+    }
+
+    throw error;
+  }
+};
+
+export const encodeMessageSubDigest = (chainId: bigint, walletAddress: string, digest: string): string => (
+  solidityPacked(
+    ['string', 'uint256', 'address', 'bytes32'],
+    [ETH_SIGN_PREFIX, chainId, walletAddress, digest],
+  )
+);
+
+export const signMetaTransactions = async (
+  metaTransactions: MetaTransaction[],
+  nonce: BigNumberish,
+  chainId: bigint,
+  walletAddress: string,
+  signer: Signer,
+): Promise<string> => {
+  const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
+
+  // Get the hash
+  const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
+  const completePayload = encodeMessageSubDigest(chainId, walletAddress, digest);
+
+  const hash = keccak256(completePayload);
+
+  // Sign the digest
+  const hashArray = getBytes(hash);
+  const ethsigNoType = await signer.signMessage(hashArray);
+  const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
+
+  // Add metadata
+  const encodedSignature = sequenceCoreV1.signature.encodeSignature({
+    version: 1,
+    threshold: TRANSACTION_SIGNATURE_THRESHOLD,
+    signers: [
+      {
+        isDynamic: false,
+        unrecovered: true,
+        weight: SIGNATURE_WEIGHT,
+        signature: signedDigest,
+      },
+    ],
+  });
+
+  // Encode the transaction;
+  const walletInterface = new Interface(walletContracts.mainModule.abi);
+  return walletInterface.encodeFunctionData(walletInterface.getFunction('execute') ?? '', [
+    normalisedMetaTransactions,
+    nonce,
+    encodedSignature,
+  ]);
+};
+
+const decodeRelayerSignature = (relayerSignature: string) => {
+  const signatureWithThreshold = `0x0000${relayerSignature}`;
+  return sequenceCoreV1.signature.decodeSignature(signatureWithThreshold);
+};
+
+export const packSignatures = (
+  EOASignature: string,
+  EOAAddress: string,
+  relayerSignature: string,
+): string => {
+  const signedDigest = `${EOASignature}${ETH_SIGN_FLAG}`;
+
+  // Combine the relayer and user signatures; sort by address to match the imageHash order
+  const { signers: relayerSigners } = decodeRelayerSignature(relayerSignature);
+  const combinedSigners = [
+    ...relayerSigners,
+    {
+      isDynamic: false,
+      unrecovered: true,
+      weight: SIGNATURE_WEIGHT,
+      signature: signedDigest,
+      address: EOAAddress,
+    },
+  ];
+  const sortedSigners = combinedSigners.sort((a, b) => {
+    const bigA = BigInt(a.address ?? 0);
+    const bigB = BigInt(b.address ?? 0);
+
+    if (bigA <= bigB) {
+      return -1;
+    } if (bigA === bigB) {
+      return 0;
+    }
+    return 1;
+  });
+
+  return sequenceCoreV1.signature.encodeSignature({
+    version: 1,
+    threshold: PACKED_SIGNATURE_THRESHOLD,
+    signers: sortedSigners,
+  });
+};
+
+export const signAndPackTypedData = async (
+  typedData: TypedDataPayload,
+  relayerSignature: string,
+  chainId: bigint,
+  walletAddress: string,
+  signer: Signer,
+): Promise<string> => {
+  // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
+  const types = { ...typedData.types };
+  // @ts-ignore
+  delete types.EIP712Domain;
+
+  // Hash the EIP712 payload and generate the complete payload
+  const typedDataHash = TypedDataEncoder.hash(typedData.domain, types, typedData.message);
+  const messageSubDigest = encodeMessageSubDigest(chainId, walletAddress, typedDataHash);
+  const hash = keccak256(messageSubDigest);
+
+  // Sign the sub digest
+  // https://github.com/immutable/wallet-contracts/blob/7824b5f24b2e0eb2dc465ecb5cd71f3984556b73/src/contracts/modules/commons/ModuleAuth.sol#L155
+  const hashArray = getBytes(hash);
+  const eoaSignature = await signer.signMessage(hashArray);
+  const eoaAddress = await signer.getAddress();
+
+  return packSignatures(eoaSignature, eoaAddress, relayerSignature);
+};
+
+export const signERC191Message = async (
+  chainId: bigint,
+  payload: string,
+  signer: Signer,
+  walletAddress: string,
+): Promise<string> => {
+  // Generate digest
+  const digest = hashMessage(payload);
+
+  // Generate subDigest
+  const subDigest = encodeMessageSubDigest(chainId, walletAddress, digest);
+  const subDigestHash = keccak256(subDigest);
+  const subDigestHashArray = getBytes(subDigestHash);
+
+  return signer.signMessage(subDigestHashArray);
+};
+
+export const getEip155ChainId = (chainId: number) => `eip155:${chainId}`;

package/src/zkEvm/zkEvmProvider.ts

@@ -0,0 +1,453 @@
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import {
+  Flow, identify, trackError, trackFlow,
+} from '@imtbl/metrics';
+import {
+  JsonRpcProvider, Signer, toBeHex,
+} from 'ethers';
+import {
+  Provider,
+  ProviderEvent,
+  ProviderEventMap,
+  RequestArguments,
+} from './types';
+import { AuthManager } from '@imtbl/auth';
+import TypedEventEmitter from '../utils/typedEventEmitter';
+import { WalletConfiguration } from '../config';
+import {
+  PassportEventMap, PassportEvents, User, UserZkEvm,
+} from '../types';
+import { RelayerClient } from './relayerClient';
+import { JsonRpcError, ProviderErrorCode, RpcErrorCode } from './JsonRpcError';
+import { registerZkEvmUser } from './user';
+import { sendTransaction } from './sendTransaction';
+import GuardianClient from '../guardian';
+import { signTypedDataV4 } from './signTypedDataV4';
+import { personalSign } from './personalSign';
+import { trackSessionActivity } from './sessionActivity/sessionActivity';
+import { getNonce } from './walletHelpers';
+import { sendDeployTransactionAndPersonalSign } from './sendDeployTransactionAndPersonalSign';
+import { signEjectionTransaction } from './signEjectionTransaction';
+
+export type ZkEvmProviderInput = {
+  authManager: AuthManager;
+  config: WalletConfiguration;
+  multiRollupApiClients: MultiRollupApiClients;
+  passportEventEmitter: TypedEventEmitter<PassportEventMap>;
+  guardianClient: GuardianClient;
+  ethSigner: Signer;
+  user: User | null;
+};
+
+const isZkEvmUser = (user: User): user is UserZkEvm => 'zkEvm' in user;
+
+export class ZkEvmProvider implements Provider {
+  readonly #authManager: AuthManager;
+
+  readonly #config: WalletConfiguration;
+
+  /**
+   * intended to emit EIP-1193 events
+   */
+  readonly #providerEventEmitter: TypedEventEmitter<ProviderEventMap>;
+
+  /**
+   * intended to emit internal Passport events
+   */
+  readonly #passportEventEmitter: TypedEventEmitter<ProviderEventMap>;
+
+  readonly #guardianClient: GuardianClient;
+
+  readonly #rpcProvider: JsonRpcProvider; // Used for read
+
+  readonly #multiRollupApiClients: MultiRollupApiClients;
+
+  readonly #relayerClient: RelayerClient;
+
+  readonly #ethSigner: Signer;
+
+  public readonly isPassport: boolean = true;
+
+  constructor({
+    authManager,
+    config,
+    multiRollupApiClients,
+    passportEventEmitter,
+    guardianClient,
+    ethSigner,
+    user,
+  }: ZkEvmProviderInput) {
+    this.#authManager = authManager;
+    this.#config = config;
+    this.#guardianClient = guardianClient;
+    this.#passportEventEmitter = passportEventEmitter;
+    this.#ethSigner = ethSigner;
+
+    this.#rpcProvider = new JsonRpcProvider(this.#config.zkEvmRpcUrl, undefined, {
+      staticNetwork: true,
+    });
+
+    this.#relayerClient = new RelayerClient({
+      config: this.#config,
+      rpcProvider: this.#rpcProvider,
+      authManager: this.#authManager,
+    });
+
+    this.#multiRollupApiClients = multiRollupApiClients;
+    this.#providerEventEmitter = new TypedEventEmitter<ProviderEventMap>();
+
+    if (user && isZkEvmUser(user)) {
+      this.#callSessionActivity(user.zkEvm.ethAddress);
+    }
+
+    passportEventEmitter.on(PassportEvents.LOGGED_IN, (loggedInUser: User) => {
+      if (isZkEvmUser(loggedInUser)) {
+        this.#callSessionActivity(loggedInUser.zkEvm.ethAddress);
+      }
+    });
+    passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.#handleLogout);
+    passportEventEmitter.on(
+      PassportEvents.ACCOUNTS_REQUESTED,
+      trackSessionActivity,
+    );
+  }
+
+  #handleLogout = () => {
+    this.#providerEventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+  };
+
+  async #callSessionActivity(zkEvmAddress: string, clientId?: string) {
+    // SessionActivity requests are processed in nonce space 1, where as all
+    // other sendTransaction requests are processed in nonce space 0. This means
+    // we can submit a session activity request per SCW in parallel without a SCW
+    // INVALID_NONCE error.
+    const nonceSpace: bigint = BigInt(1);
+    const sendTransactionClosure = async (params: Array<any>, flow: Flow) => await sendTransaction({
+      params,
+      ethSigner: this.#ethSigner,
+      guardianClient: this.#guardianClient,
+      rpcProvider: this.#rpcProvider,
+      relayerClient: this.#relayerClient,
+      zkEvmAddress,
+      flow,
+      nonceSpace,
+      isBackgroundTransaction: true,
+    });
+    this.#passportEventEmitter.emit(PassportEvents.ACCOUNTS_REQUESTED, {
+      environment: this.#config.environment,
+      sendTransaction: sendTransactionClosure,
+      walletAddress: zkEvmAddress,
+      passportClient: clientId || 'wallet',
+    });
+  }
+
+  // Used to get the registered zkEvm address from the User session
+  async #getZkEvmAddress() {
+    try {
+      const user = await this.#authManager.getUser();
+      if (user && isZkEvmUser(user)) {
+        return user.zkEvm.ethAddress;
+      }
+      return undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  async #performRequest(request: RequestArguments): Promise<any> {
+    // This is required for sending session activity events
+
+    switch (request.method) {
+      case 'eth_requestAccounts': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (zkEvmAddress) return [zkEvmAddress];
+
+        const flow = trackFlow('passport', 'ethRequestAccounts');
+
+        try {
+          const user = await this.#authManager.getUserOrLogin();
+          flow.addEvent('endGetUserOrLogin');
+
+          let userZkEvmEthAddress: string | undefined;
+
+          if (!isZkEvmUser(user)) {
+            flow.addEvent('startUserRegistration');
+
+            userZkEvmEthAddress = await registerZkEvmUser({
+              ethSigner: this.#ethSigner,
+              authManager: this.#authManager,
+              multiRollupApiClients: this.#multiRollupApiClients,
+              accessToken: user.accessToken,
+              rpcProvider: this.#rpcProvider,
+              flow,
+            });
+            flow.addEvent('endUserRegistration');
+          } else {
+            userZkEvmEthAddress = user.zkEvm.ethAddress;
+          }
+
+          this.#providerEventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [
+            userZkEvmEthAddress,
+          ]);
+          identify({
+            passportId: user.profile.sub,
+          });
+          this.#callSessionActivity(userZkEvmEthAddress);
+          return [userZkEvmEthAddress];
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'ethRequestAccounts', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+      case 'eth_sendTransaction': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (!zkEvmAddress) {
+          throw new JsonRpcError(
+            ProviderErrorCode.UNAUTHORIZED,
+            'Unauthorised - call eth_requestAccounts first',
+          );
+        }
+
+        const flow = trackFlow('passport', 'ethSendTransaction');
+
+        try {
+          return await this.#guardianClient.withConfirmationScreen({
+            width: 480,
+            height: 720,
+          })(async () => await sendTransaction({
+            params: request.params || [],
+            ethSigner: this.#ethSigner,
+            guardianClient: this.#guardianClient,
+            rpcProvider: this.#rpcProvider,
+            relayerClient: this.#relayerClient,
+            zkEvmAddress,
+            flow,
+          }));
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'eth_sendTransaction', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+      case 'eth_accounts': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        return zkEvmAddress ? [zkEvmAddress] : [];
+      }
+      case 'personal_sign': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (!zkEvmAddress) {
+          throw new JsonRpcError(
+            ProviderErrorCode.UNAUTHORIZED,
+            'Unauthorised - call eth_requestAccounts first',
+          );
+        }
+
+        const flow = trackFlow('passport', 'personalSign');
+
+        try {
+          return await this.#guardianClient.withConfirmationScreen({
+            width: 480,
+            height: 720,
+          })(async () => {
+            if (this.#config.forceScwDeployBeforeMessageSignature) {
+              // Check if the smart contract wallet has been deployed
+              const nonce = await getNonce(this.#rpcProvider, zkEvmAddress);
+              if (!(nonce > BigInt(0))) {
+                // If the smart contract wallet has not been deployed,
+                // submit a transaction before signing the message
+                return await sendDeployTransactionAndPersonalSign({
+                  params: request.params || [],
+                  zkEvmAddress,
+                  ethSigner: this.#ethSigner,
+                  rpcProvider: this.#rpcProvider,
+                  guardianClient: this.#guardianClient,
+                  relayerClient: this.#relayerClient,
+                  flow,
+                });
+              }
+            }
+
+            return await personalSign({
+              params: request.params || [],
+              zkEvmAddress,
+              ethSigner: this.#ethSigner,
+              rpcProvider: this.#rpcProvider,
+              guardianClient: this.#guardianClient,
+              relayerClient: this.#relayerClient,
+              flow,
+            });
+          });
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'personal_sign', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v4': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (!zkEvmAddress) {
+          throw new JsonRpcError(
+            ProviderErrorCode.UNAUTHORIZED,
+            'Unauthorised - call eth_requestAccounts first',
+          );
+        }
+
+        const flow = trackFlow('passport', 'ethSignTypedDataV4');
+
+        try {
+          return await this.#guardianClient.withConfirmationScreen({
+            width: 480,
+            height: 720,
+          })(async () => await signTypedDataV4({
+            method: request.method,
+            params: request.params || [],
+            ethSigner: this.#ethSigner,
+            rpcProvider: this.#rpcProvider,
+            relayerClient: this.#relayerClient,
+            guardianClient: this.#guardianClient,
+            flow,
+          }));
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'eth_signTypedData', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+      case 'eth_chainId': {
+        // Call detect network to fetch the chainId so to take advantage of
+        // the caching layer provided by StaticJsonRpcProvider.
+        // In case Passport is changed from StaticJsonRpcProvider to a
+        // JsonRpcProvider, this function will still work as expected given
+        // that detectNetwork call _uncachedDetectNetwork which will force
+        // the provider to re-fetch the chainId from remote.
+        const { chainId } = await this.#rpcProvider.getNetwork();
+        return toBeHex(chainId);
+      }
+      // Pass through methods
+      case 'eth_getBalance':
+      case 'eth_getCode':
+      case 'eth_getTransactionCount': {
+        const [address, blockNumber] = request.params || [];
+        return this.#rpcProvider.send(request.method, [
+          address,
+          blockNumber || 'latest',
+        ]);
+      }
+      case 'eth_getStorageAt': {
+        const [address, storageSlot, blockNumber] = request.params || [];
+        return this.#rpcProvider.send(request.method, [
+          address,
+          storageSlot,
+          blockNumber || 'latest',
+        ]);
+      }
+      case 'eth_call':
+      case 'eth_estimateGas': {
+        const [transaction, blockNumber] = request.params || [];
+        return this.#rpcProvider.send(request.method, [
+          transaction,
+          blockNumber || 'latest',
+        ]);
+      }
+      case 'eth_gasPrice':
+      case 'eth_blockNumber':
+      case 'eth_getBlockByHash':
+      case 'eth_getBlockByNumber':
+      case 'eth_getTransactionByHash':
+      case 'eth_getTransactionReceipt': {
+        return this.#rpcProvider.send(request.method, request.params || []);
+      }
+      case 'im_signEjectionTransaction': {
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (!zkEvmAddress) {
+          throw new JsonRpcError(
+            ProviderErrorCode.UNAUTHORIZED,
+            'Unauthorised - call eth_requestAccounts first',
+          );
+        }
+
+        const flow = trackFlow('passport', 'imSignEjectionTransaction');
+
+        try {
+          return await signEjectionTransaction({
+            params: request.params || [],
+            ethSigner: this.#ethSigner,
+            zkEvmAddress,
+            flow,
+          });
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'imSignEjectionTransaction', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+      case 'im_addSessionActivity': {
+        const [clientId] = request.params || [];
+        const zkEvmAddress = await this.#getZkEvmAddress();
+        if (zkEvmAddress) {
+          this.#callSessionActivity(zkEvmAddress, clientId);
+        }
+        return null;
+      }
+      default: {
+        throw new JsonRpcError(
+          ProviderErrorCode.UNSUPPORTED_METHOD,
+          'Method not supported',
+        );
+      }
+    }
+  }
+
+  public async request(request: RequestArguments): Promise<any> {
+    try {
+      return this.#performRequest(request);
+    } catch (error: unknown) {
+      if (error instanceof JsonRpcError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+      }
+
+      throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+    }
+  }
+
+  public on(event: string, listener: (...args: any[]) => void): void {
+    this.#providerEventEmitter.on(event, listener);
+  }
+
+  public removeListener(
+    event: string,
+    listener: (...args: any[]) => void,
+  ): void {
+    this.#providerEventEmitter.removeListener(event, listener);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDirs": ["src"],
+    "customConditions": ["development"],
+    "types": ["node"]
+  },
+  "include": ["src", "src/types.ts"],
+  "exclude": [
+    "node_modules",
+    "dist",
+  ]
+}
+