@portal-hq/web 3.2.2 → 3.3.0

package/src/provider/index.test.ts

@@ -0,0 +1,1570 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import portal from '../__mocks/portal/portal'
+import Provider from '.'
+import { mockRpcUrl, mockSignedHash } from '../__mocks/constants'
+import { ProviderRpcError, RpcErrorCodes } from './errors'
+import { RequestMethod } from '../'
+import mpcMock from '../__mocks/portal/mpc'
+
+describe('Provider', () => {
+  beforeEach(() => {
+    portal.autoApprove = true
+    portal.mpc = mpcMock
+    jest.clearAllMocks()
+
+    global.fetch = jest.fn().mockResolvedValue({
+      json: jest.fn().mockResolvedValue({ result: 'test', error: null }),
+    })
+  })
+
+  describe('request', () => {
+    let provider = new Provider({ portal })
+
+    describe('Signer methods with auto-approval', () => {
+      beforeAll(() => {
+        portal.autoApprove = true
+        provider.emit = jest.fn()
+      })
+
+      describe('eth_chainId', () => {
+        it('should throw an error if no chainId is provided alongside eth_chainId', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_chainId,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_chainId', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_chainId,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_chainId request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_chainId,
+            params: ['test'],
+          })
+
+          expect(result).toEqual('0x1')
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_chainId,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_accounts', () => {
+        it('should throw an error if no chainId is provided alongside eth_accounts', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_accounts,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_accounts', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_accounts,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_accounts request', async () => {
+          portal.address = 'test'
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_accounts,
+            params: ['test'],
+          })
+
+          expect(result).toEqual([mockSignedHash])
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_accounts,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_requestAccounts', () => {
+        it('should throw an error if no chainId is provided alongside eth_requestAccounts', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_requestAccounts,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_requestAccounts', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_requestAccounts,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_requestAccounts request', async () => {
+          portal.address = 'test'
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_requestAccounts,
+            params: ['test'],
+          })
+
+          expect(result).toEqual([mockSignedHash])
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_requestAccounts,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_sendTransaction', () => {
+        it('should throw an error if no chainId is provided alongside eth_sendTransaction', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_sendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_sendTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_sendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_sendTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_sendTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_signTransaction', () => {
+        it('should throw an error if no chainId is provided alongside eth_signTransaction', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_signTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_signTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_signTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_signTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_signTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_sign', () => {
+        it('should throw an error if no chainId is provided alongside eth_sign', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_sign,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_sign', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_sign,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_sign request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_sign,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_signTypedData_v3', () => {
+        it('should throw an error if no chainId is provided alongside eth_signTypedData_v3', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_signTypedData_v3,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_signTypedData_v3', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_signTypedData_v3,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_signTypedData_v3 request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_signTypedData_v3,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('eth_signTypedData_v4', () => {
+        it('should throw an error if no chainId is provided alongside eth_signTypedData_v4', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.eth_signTypedData_v4,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside eth_signTypedData_v4', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.eth_signTypedData_v4,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle an eth_signTypedData_v4 request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_signTypedData_v4,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('personal_sign', () => {
+        it('should throw an error if no chainId is provided alongside personal_sign', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.personal_sign,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside personal_sign', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.personal_sign,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a personal_sign request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.personal_sign,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('sol_signAndConfirmTransaction', () => {
+        it('should throw an error if no chainId is provided alongside sol_signAndConfirmTransaction', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.sol_signAndConfirmTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside sol_signAndConfirmTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.sol_signAndConfirmTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a sol_signAndConfirmTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+              method: RequestMethod.sol_signAndConfirmTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('sol_signAndSendTransaction', () => {
+        it('should throw an error if no chainId is provided alongside sol_signAndSendTransaction', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.sol_signAndSendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside sol_signAndSendTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.sol_signAndSendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a sol_signAndSendTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+              method: RequestMethod.sol_signAndSendTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('sol_signMessage', () => {
+        it('should throw an error if no chainId is provided alongside sol_signMessage', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.sol_signMessage,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside sol_signMessage', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.sol_signMessage,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a sol_signMessage request', async () => {
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+              method: RequestMethod.sol_signMessage,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+
+      describe('sol_signTransaction', () => {
+        it('should throw an error if no chainId is provided alongside sol_signTransaction', async () => {
+          expect(
+            provider.request({
+              method: RequestMethod.sol_signTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside sol_signTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.sol_signTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a sol_signTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+              method: RequestMethod.sol_signTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
+    })
+
+    describe('Signer methods without auto-approval', () => {
+      const mockSigningRequestedHandler = jest.fn()
+      const mockSignatureReceivedHandler = jest.fn()
+      const mockConsoleWarn = jest.spyOn(global.console, 'warn')
+
+      beforeEach(() => {
+        provider = new Provider({ portal })
+        portal.autoApprove = false
+        provider.on('portal_signingRequested', mockSigningRequestedHandler)
+        provider.on('portal_signatureReceived', mockSignatureReceivedHandler)
+      })
+
+      describe('eth_chainId', () => {
+        it('should successfully handle an eth_chainId request', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_chainId,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0)
+          expect(result).toEqual('0x1')
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_chainId,
+            params: ['test'],
+            signature: result,
+          })
+        })
+      })
+
+      describe('eth_accounts', () => {
+        it('should successfully handle an eth_accounts request', async () => {
+          portal.address = 'test'
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_accounts,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0)
+          expect(result).toEqual([mockSignedHash])
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_accounts,
+            params: ['test'],
+            signature: result,
+          })
+        })
+      })
+
+      describe('eth_requestAccounts', () => {
+        it('should successfully handle an approved eth_requestAccounts request', async () => {
+          portal.address = 'test'
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_requestAccounts,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0)
+          expect(result).toEqual([mockSignedHash])
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_requestAccounts,
+            params: ['test'],
+            signature: result,
+          })
+        })
+      })
+
+      describe('eth_sendTransaction', () => {
+        it('should successfully handle an approved eth_sendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_sendTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_sendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_sendTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_sendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'eth_sendTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('eth_signTransaction', () => {
+        it('should successfully handle an approved eth_signTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_signTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_signTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_signTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'eth_signTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('eth_sign', () => {
+        it('should successfully handle an approved eth_sign request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_sign,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_sign request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_sign,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_sign,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'eth_sign' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('eth_signTypedData_v3', () => {
+        it('should successfully handle an approved eth_signTypedData_v3 request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_signTypedData_v3,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_signTypedData_v3 request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_signTypedData_v3,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTypedData_v3,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'eth_signTypedData_v3' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('eth_signTypedData_v4', () => {
+        it('should successfully handle an approved eth_signTypedData_v4 request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_signTypedData_v4,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_signTypedData_v4 request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_signTypedData_v4,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signTypedData_v4,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'eth_signTypedData_v4' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('personal_sign', () => {
+        it('should successfully handle an approved personal_sign request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.personal_sign,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected personal_sign request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.personal_sign,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.personal_sign,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'personal_sign' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('sol_signAndConfirmTransaction', () => {
+        it('should successfully handle an approved sol_signAndConfirmTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.sol_signAndConfirmTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected sol_signAndConfirmTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.sol_signAndConfirmTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signAndConfirmTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'sol_signAndConfirmTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('sol_signAndSendTransaction', () => {
+        it('should successfully handle an approved sol_signAndSendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.sol_signAndSendTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected sol_signAndSendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.sol_signAndSendTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signAndSendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'sol_signAndSendTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('sol_signMessage', () => {
+        it('should successfully handle an approved sol_signMessage request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.sol_signMessage,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected sol_signMessage request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.sol_signMessage,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signMessage,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'sol_signMessage' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+
+      describe('sol_signTransaction', () => {
+        it('should successfully handle an approved sol_signTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.sol_signTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+            rpcUrl: mockRpcUrl,
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected sol_signTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.sol_signTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.sol_signTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'sol_signTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
+    })
+
+    describe('Non-signer methods', () => {
+      beforeAll(() => {
+        portal.autoApprove = true
+        provider.emit = jest.fn()
+      })
+
+      it('should successfully handle non-signer method requests', async () => {
+        const result = await provider.request({
+          chainId: 'eip155:1',
+          method: RequestMethod.eth_sendRawTransaction,
+          params: ['test'],
+        })
+
+        expect(result).toEqual('test')
+        expect(global.fetch).toHaveBeenCalledWith(mockRpcUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: '0',
+            method: RequestMethod.eth_sendRawTransaction,
+            params: ['test'],
+          }),
+        })
+        expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+          chainId: 'eip155:1',
+          method: RequestMethod.eth_sendRawTransaction,
+          params: ['test'],
+          signature: { result: 'test', error: null },
+        })
+      })
+
+      it('should throw an error if gateway request results in an error', async () => {
+        const errRes = {
+          result: null,
+          error: { code: 4901, data: { key: 'value' } },
+        }
+        global.fetch = jest.fn().mockResolvedValue({
+          json: jest.fn().mockResolvedValue(errRes),
+        })
+
+        await expect(
+          provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_sendRawTransaction,
+            params: ['test'],
+          }),
+        ).rejects.toThrow(new ProviderRpcError(errRes.error))
+
+        expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+          chainId: 'eip155:1',
+          method: RequestMethod.eth_sendRawTransaction,
+          params: ['test'],
+          signature: errRes,
+        })
+      })
+
+      it('should throw an error for an unsupported method', async () => {
+        await expect(
+          provider.request({
+            chainId: 'eip155:1',
+            method: 'wallet_switchEthereumChain' as RequestMethod,
+            params: ['test'],
+          }),
+        ).rejects.toThrow(
+          new ProviderRpcError({
+            code: RpcErrorCodes.UnsupportedMethod,
+            data: {
+              method: 'wallet_switchEthereumChain' as RequestMethod,
+              params: ['test'],
+            },
+          }),
+        )
+
+        expect(provider.emit).toHaveBeenCalledTimes(0)
+      })
+    })
+  })
+
+  describe('emit', () => {
+    const provider = new Provider({ portal })
+
+    const mockHandler1 = jest.fn()
+    const mockHandler2 = jest.fn()
+
+    beforeEach(() => {
+      provider.on('test', mockHandler1)
+      provider.on('test', mockHandler2)
+    })
+
+    it('should successfully execute all handlers of an event', () => {
+      provider.emit('test', { data: 'test' })
+
+      expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' })
+      expect(mockHandler1).toHaveBeenCalledTimes(1)
+      expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' })
+      expect(mockHandler2).toHaveBeenCalledTimes(1)
+    })
+
+    it('should not execute handlers for a different event', () => {
+      provider.emit('test1', { data: 'test' })
+
+      expect(mockHandler1).toHaveBeenCalledTimes(0)
+      expect(mockHandler2).toHaveBeenCalledTimes(0)
+    })
+  })
+
+  describe('on', () => {
+    let provider = new Provider({ portal })
+
+    const mockHandler1 = jest.fn()
+    const mockHandler2 = jest.fn()
+
+    beforeEach(() => {
+      provider = new Provider({ portal })
+    })
+
+    it('should successfully register handlers for an event', () => {
+      const event = 'test'
+      provider.on(event, mockHandler1)
+      provider.on(event, mockHandler2)
+
+      const eventHandlers = provider.events[event]
+      expect(eventHandlers.length).toEqual(2)
+      expect(eventHandlers).toEqual([
+        { handler: mockHandler1, once: false },
+        { handler: mockHandler2, once: false },
+      ])
+    })
+
+    it('should not register undefined handlers', () => {
+      provider.on('test', undefined as any)
+
+      const eventHandlers = provider.events['test']
+      expect(eventHandlers.length).toEqual(0)
+    })
+  })
+
+  describe('removeEventListener', () => {
+    let provider = new Provider({ portal })
+
+    const mockHandler1 = jest.fn()
+    const mockHandler2 = jest.fn()
+
+    beforeEach(() => {
+      provider = new Provider({ portal })
+    })
+
+    it('should successfully remove specified event listener of an event', () => {
+      const event = 'test'
+      provider.on(event, mockHandler1)
+      provider.on(event, mockHandler2)
+
+      provider.removeEventListener(event, mockHandler1)
+
+      const eventHandlers = provider.events[event]
+      expect(eventHandlers.length).toEqual(1)
+      expect(eventHandlers).toEqual([{ handler: mockHandler2, once: false }])
+    })
+
+    it('should successfully remove all event listeners of an event if no specific handler is specified to be removed', () => {
+      const event = 'test'
+      provider.on(event, mockHandler1)
+      provider.on(event, mockHandler2)
+
+      provider.removeEventListener(event)
+
+      const eventHandlers = provider.events[event]
+      expect(eventHandlers.length).toEqual(0)
+      expect(eventHandlers).toEqual([])
+    })
+
+    it('should skip handler removal for events with no handlers', () => {
+      provider.removeEventListener('non-existent', mockHandler1)
+
+      const eventHandlers = provider.events['non-existent']
+      expect(eventHandlers).toEqual(undefined)
+    })
+
+    it('should skip handler removal for a handler that does not exist for an event', () => {
+      const event = 'test'
+      provider.on(event, mockHandler1)
+      provider.on(event, mockHandler2)
+
+      provider.removeEventListener(event, jest.fn())
+
+      const eventHandlers = provider.events[event]
+      expect(eventHandlers.length).toEqual(2)
+      expect(eventHandlers).toEqual([
+        { handler: mockHandler1, once: false },
+        { handler: mockHandler2, once: false },
+      ])
+    })
+  })
+})