@portal-hq/web 3.2.3 → 3.3.0

package/lib/commonjs/provider/index.test.js

@@ -0,0 +1,1222 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const portal_1 = __importDefault(require("../__mocks/portal/portal"));
+const _1 = __importDefault(require("."));
+const constants_1 = require("../__mocks/constants");
+const errors_1 = require("./errors");
+const __1 = require("../");
+const mpc_1 = __importDefault(require("../__mocks/portal/mpc"));
+describe('Provider', () => {
+    beforeEach(() => {
+        portal_1.default.autoApprove = true;
+        portal_1.default.mpc = mpc_1.default;
+        jest.clearAllMocks();
+        global.fetch = jest.fn().mockResolvedValue({
+            json: jest.fn().mockResolvedValue({ result: 'test', error: null }),
+        });
+    });
+    describe('request', () => {
+        let provider = new _1.default({ portal: portal_1.default });
+        describe('Signer methods with auto-approval', () => {
+            beforeAll(() => {
+                portal_1.default.autoApprove = true;
+                provider.emit = jest.fn();
+            });
+            describe('eth_chainId', () => {
+                it('should throw an error if no chainId is provided alongside eth_chainId', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_chainId,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual('0x1');
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_chainId,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_accounts', () => {
+                it('should throw an error if no chainId is provided alongside eth_accounts', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    portal_1.default.address = 'test';
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_accounts,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual([constants_1.mockSignedHash]);
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_accounts,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_requestAccounts', () => {
+                it('should throw an error if no chainId is provided alongside eth_requestAccounts', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    portal_1.default.address = 'test';
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_requestAccounts,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual([constants_1.mockSignedHash]);
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_requestAccounts,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_sendTransaction', () => {
+                it('should throw an error if no chainId is provided alongside eth_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_signTransaction', () => {
+                it('should throw an error if no chainId is provided alongside eth_signTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_sign', () => {
+                it('should throw an error if no chainId is provided alongside eth_sign', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('personal_sign', () => {
+                it('should throw an error if no chainId is provided alongside personal_sign', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('sol_signAndConfirmTransaction', () => {
+                it('should throw an error if no chainId is provided alongside sol_signAndConfirmTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('sol_signAndSendTransaction', () => {
+                it('should throw an error if no chainId is provided alongside sol_signAndSendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('sol_signMessage', () => {
+                it('should throw an error if no chainId is provided alongside sol_signMessage', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('sol_signTransaction', () => {
+                it('should throw an error if no chainId is provided alongside sol_signTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.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 _1.default({ portal: portal_1.default });
+                portal_1.default.autoApprove = false;
+                provider.on('portal_signingRequested', mockSigningRequestedHandler);
+                provider.on('portal_signatureReceived', mockSignatureReceivedHandler);
+            });
+            describe('eth_chainId', () => {
+                it('should successfully handle an eth_chainId request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_chainId,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0);
+                    expect(result).toEqual('0x1');
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_chainId,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_accounts', () => {
+                it('should successfully handle an eth_accounts request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    portal_1.default.address = 'test';
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_accounts,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0);
+                    expect(result).toEqual([constants_1.mockSignedHash]);
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_accounts,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_requestAccounts', () => {
+                it('should successfully handle an approved eth_requestAccounts request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    portal_1.default.address = 'test';
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_requestAccounts,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledTimes(0);
+                    expect(result).toEqual([constants_1.mockSignedHash]);
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_requestAccounts,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
+            describe('eth_sendTransaction', () => {
+                it('should successfully handle an approved eth_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_signTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_signTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_signTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_sign,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_sign request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_sign,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_sign,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_signTypedData_v3,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_signTypedData_v3 request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_signTypedData_v3,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v3,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_signTypedData_v4,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_signTypedData_v4 request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_signTypedData_v4,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signTypedData_v4,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.personal_sign,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected personal_sign request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.personal_sign,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.personal_sign,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected sol_signAndConfirmTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndConfirmTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.sol_signAndSendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected sol_signAndSendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.sol_signAndSendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signAndSendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.sol_signMessage,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected sol_signMessage request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.sol_signMessage,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signMessage,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.sol_signTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                        rpcUrl: constants_1.mockRpcUrl,
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected sol_signTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.sol_signTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                        method: __1.RequestMethod.sol_signTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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_1.default.autoApprove = true;
+                provider.emit = jest.fn();
+            });
+            it('should successfully handle non-signer method requests', () => __awaiter(void 0, void 0, void 0, function* () {
+                const result = yield provider.request({
+                    chainId: 'eip155:1',
+                    method: __1.RequestMethod.eth_sendRawTransaction,
+                    params: ['test'],
+                });
+                expect(result).toEqual('test');
+                expect(global.fetch).toHaveBeenCalledWith(constants_1.mockRpcUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: '0',
+                        method: __1.RequestMethod.eth_sendRawTransaction,
+                        params: ['test'],
+                    }),
+                });
+                expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                    chainId: 'eip155:1',
+                    method: __1.RequestMethod.eth_sendRawTransaction,
+                    params: ['test'],
+                    signature: { result: 'test', error: null },
+                });
+            }));
+            it('should throw an error if gateway request results in an error', () => __awaiter(void 0, void 0, void 0, function* () {
+                const errRes = {
+                    result: null,
+                    error: { code: 4901, data: { key: 'value' } },
+                };
+                global.fetch = jest.fn().mockResolvedValue({
+                    json: jest.fn().mockResolvedValue(errRes),
+                });
+                yield expect(provider.request({
+                    chainId: 'eip155:1',
+                    method: __1.RequestMethod.eth_sendRawTransaction,
+                    params: ['test'],
+                })).rejects.toThrow(new errors_1.ProviderRpcError(errRes.error));
+                expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                    chainId: 'eip155:1',
+                    method: __1.RequestMethod.eth_sendRawTransaction,
+                    params: ['test'],
+                    signature: errRes,
+                });
+            }));
+            it('should throw an error for an unsupported method', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield expect(provider.request({
+                    chainId: 'eip155:1',
+                    method: 'wallet_switchEthereumChain',
+                    params: ['test'],
+                })).rejects.toThrow(new errors_1.ProviderRpcError({
+                    code: errors_1.RpcErrorCodes.UnsupportedMethod,
+                    data: {
+                        method: 'wallet_switchEthereumChain',
+                        params: ['test'],
+                    },
+                }));
+                expect(provider.emit).toHaveBeenCalledTimes(0);
+            }));
+        });
+    });
+    describe('emit', () => {
+        const provider = new _1.default({ portal: portal_1.default });
+        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 _1.default({ portal: portal_1.default });
+        const mockHandler1 = jest.fn();
+        const mockHandler2 = jest.fn();
+        beforeEach(() => {
+            provider = new _1.default({ portal: portal_1.default });
+        });
+        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);
+            const eventHandlers = provider.events['test'];
+            expect(eventHandlers.length).toEqual(0);
+        });
+    });
+    describe('removeEventListener', () => {
+        let provider = new _1.default({ portal: portal_1.default });
+        const mockHandler1 = jest.fn();
+        const mockHandler2 = jest.fn();
+        beforeEach(() => {
+            provider = new _1.default({ portal: portal_1.default });
+        });
+        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 },
+            ]);
+        });
+    });
+});