@portal-hq/web 3.2.2 → 3.3.0

package/lib/esm/index.test.js

@@ -0,0 +1,520 @@
+/**
+ * @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());
+    });
+};
+import Portal, { BackupMethods, GetTransactionsOrder } from '.';
+import { mockAddress, mockBackupConfig, mockBlockHashResponse, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockQuoteArgs, mockRpcConfig, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, } from './__mocks/constants';
+import mpcMock from './__mocks/portal/mpc';
+import providerMock from './__mocks/portal/provider';
+/**
+ * context -
+ *  https://github.com/jestjs/jest/issues/4422
+ *  https://github.com/anza-xyz/solana-pay/issues/106
+ *  */
+const originalUint8ArrayHasInstance = Uint8Array[Symbol.hasInstance];
+beforeAll(() => {
+    Object.defineProperty(Uint8Array, Symbol.hasInstance, {
+        value(potentialInstance) {
+            return (originalUint8ArrayHasInstance.call(this, potentialInstance) ||
+                Buffer.isBuffer(potentialInstance));
+        },
+    });
+});
+afterAll(() => {
+    Object.defineProperty(Uint8Array, Symbol.hasInstance, originalUint8ArrayHasInstance);
+});
+describe('Portal', () => {
+    let portal;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portal = new Portal({
+            rpcConfig: Object.assign(Object.assign({}, mockRpcConfig), { 
+                // for testing -
+                // @ts-ignore-next-line
+                'incorrect-config': { test: 'test' } }),
+        });
+        portal.mpc = mpcMock;
+        portal.provider = providerMock;
+    });
+    describe('clearLocalWallet', () => {
+        it('should call mpc.clearLocalWallet', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.clearLocalWallet();
+            expect(portal.mpc.clearLocalWallet).toHaveBeenCalledTimes(1);
+        }));
+    });
+    describe('createWallet', () => {
+        it('should successfully generate a wallet and call mpc.generate correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const res = yield portal.createWallet(mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.generate).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.generate).toHaveBeenCalledWith({
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, mockProgressFn);
+        }));
+        it('should successfully generate a wallet and call mpc.generate correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal = new Portal({
+                rpcConfig: mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.createWallet(mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.generate).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.generate).toHaveBeenCalledWith({
+                host: 'test-host',
+                mpcVersion: 'v6',
+                featureFlags: { isMultiBackupEnabled: true },
+            }, mockProgressFn);
+        }));
+    });
+    describe('backupWallet', () => {
+        it('should successfully backup a wallet and call mpc.backup correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const res = yield portal.backupWallet(BackupMethods.gdrive, mockProgressFn, mockBackupConfig);
+            expect(res).toBe(mockMpcBackupResponse);
+            expect(portal.mpc.backup).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: BackupMethods.gdrive,
+                backupConfigs: mockBackupConfig,
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, mockProgressFn);
+        }));
+        it('should successfully backup a wallet and call mpc.backup correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal = new Portal({
+                rpcConfig: mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.backupWallet(BackupMethods.passkey, mockProgressFn, mockBackupConfig);
+            expect(res).toBe(mockMpcBackupResponse);
+            expect(portal.mpc.backup).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: BackupMethods.passkey,
+                backupConfigs: mockBackupConfig,
+                host: 'test-host',
+                mpcVersion: 'v6',
+                featureFlags: { isMultiBackupEnabled: true },
+            }, mockProgressFn);
+        }));
+    });
+    describe('recoverWallet', () => {
+        it('should successfully recover a wallet and call mpc.recover correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const res = yield portal.recoverWallet(mockCipherText, BackupMethods.password, mockBackupConfig, mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, mockProgressFn);
+        }));
+        it('should successfully recover a wallet and call mpc.recover correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal = new Portal({
+                rpcConfig: mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.recoverWallet(mockCipherText, BackupMethods.password, mockBackupConfig, mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                host: 'test-host',
+                mpcVersion: 'v6',
+                featureFlags: { isMultiBackupEnabled: true },
+            }, mockProgressFn);
+        }));
+    });
+    describe('provisionWallet', () => {
+        it('should successfully generate a wallet and call mpc.recover correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const res = yield portal.provisionWallet(mockCipherText, BackupMethods.password, mockBackupConfig, mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, mockProgressFn);
+        }));
+        it('should successfully generate a wallet and call mpc.recover correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal = new Portal({
+                rpcConfig: mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.provisionWallet(mockCipherText, BackupMethods.password, mockBackupConfig, mockProgressFn);
+            expect(res).toBe(mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                host: 'test-host',
+                mpcVersion: 'v6',
+                featureFlags: { isMultiBackupEnabled: true },
+            }, mockProgressFn);
+        }));
+    });
+    describe('eject', () => {
+        it('should successfully eject a wallet when backup with portal is enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.eject(BackupMethods.password, mockBackupConfig);
+            expect(res).toEqual(mockEjectResult);
+            expect(portal.mpc.eject).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.eject).toHaveBeenCalledWith({
+                cipherText: '',
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                organizationBackupShare: '',
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            });
+        }));
+        it('should successfully eject a wallet when backup with portal is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.mpc.getClient = portal.mpc.getClient.mockResolvedValueOnce(Object.assign(Object.assign({}, mockClientResponse), { environment: Object.assign(Object.assign({}, mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            const res = yield portal.eject(BackupMethods.password, mockBackupConfig, mockOrgBackupShare, mockCipherText);
+            expect(res).toEqual(mockEjectResult);
+            expect(portal.mpc.eject).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.eject).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                organizationBackupShare: mockOrgBackupShare,
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            });
+        }));
+        it('should error out if client could not be found', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.mpc.getClient = portal.mpc.getClient.mockResolvedValueOnce(null);
+            yield expect(portal.eject(BackupMethods.password, mockBackupConfig, mockOrgBackupShare, mockCipherText)).rejects.toThrowError(new Error('Client not found.'));
+        }));
+        it('should error if clientBackupCipherText was not supplied when backup with portal is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.mpc.getClient = portal.mpc.getClient.mockResolvedValueOnce(Object.assign(Object.assign({}, mockClientResponse), { environment: Object.assign(Object.assign({}, mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            yield expect(portal.eject(BackupMethods.password, mockBackupConfig)).rejects.toThrowError(new Error('clientBackupCipherText cannot be empty string.'));
+        }));
+        it('should error if orgBackupShare was empty when backup with portal is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.mpc.getClient = portal.mpc.getClient.mockResolvedValueOnce(Object.assign(Object.assign({}, mockClientResponse), { environment: Object.assign(Object.assign({}, mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            yield expect(portal.eject(BackupMethods.password, mockBackupConfig, '', mockCipherText)).rejects.toThrowError(new Error('orgBackupShare cannot be empty string.'));
+        }));
+    });
+    describe('getEip155Address', () => {
+        it("should return the wallet's eip155 address correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.getEip155Address();
+            expect(res).toBe(mockEip155Address);
+        }));
+    });
+    describe('getSolanaAddress', () => {
+        it("should return the wallet's solana address correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.getSolanaAddress();
+            expect(res).toBe(mockSolanaAddress);
+        }));
+    });
+    describe('doesWalletExist', () => {
+        it('should successfully return if wallets exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.doesWalletExist();
+            expect(res).toBe(mockClientResponse.wallets.length > 0);
+        }));
+        it('should successfully return if wallets exist for a specific chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield portal.doesWalletExist('eip155:1')).toBe(!!mockClientResponse.metadata.namespaces['eip155']);
+            expect(yield portal.doesWalletExist('unsupported:chain')).toBe(false);
+        }));
+    });
+    describe('isWalletOnDevice', () => {
+        it('should successfully check if wallet is on device', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.isWalletOnDevice();
+            expect(res).toBe(mockSharesOnDevice.ED25519 && mockSharesOnDevice.SECP256K1);
+        }));
+        it('should successfully check if wallet is on device for a specific chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield portal.isWalletOnDevice('eip155:1')).toBe(mockSharesOnDevice.SECP256K1);
+            expect(yield portal.isWalletOnDevice('unsupported:chain')).toBe(false);
+        }));
+    });
+    describe('isWalletBackedUp', () => {
+        it('should successfully check if wallet is backed up', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.isWalletBackedUp();
+            expect(res).toBe(true);
+        }));
+        it('should successfully check if wallet is backed up for a specific chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield portal.isWalletBackedUp('eip155:1')).toBe(true);
+            expect(yield portal.isWalletBackedUp('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')).toBe(false);
+            expect(yield portal.isWalletBackedUp('unsupported:chain')).toBe(false);
+        }));
+    });
+    describe('sendSol', () => {
+        beforeEach(() => {
+            portal.address = mockSolanaAddress;
+        });
+        it('should successfully send sol', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.provider.request = portal.provider.request
+                .mockResolvedValueOnce(mockBlockHashResponse)
+                .mockResolvedValueOnce(mockSignedHash);
+            const result = yield portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            });
+            expect(result).toBe(mockSignedHash);
+            expect(portal.provider.request).toHaveBeenCalledTimes(2);
+            expect(portal.provider.request.mock.calls[0]).toEqual([
+                {
+                    chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                    method: 'getLatestBlockhash',
+                    params: [],
+                },
+            ]);
+            expect(portal.provider.request.mock.calls[1]).toEqual([
+                {
+                    chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                    method: 'sol_signAndSendTransaction',
+                    params: [
+                        {
+                            message: {
+                                accountKeys: [
+                                    mockSolanaAddress,
+                                    '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                                    '11111111111111111111111111111111',
+                                ],
+                                header: {
+                                    numReadonlySignedAccounts: 0,
+                                    numReadonlyUnsignedAccounts: 1,
+                                    numRequiredSignatures: 1,
+                                },
+                                instructions: [
+                                    {
+                                        accounts: [0, 1],
+                                        // @solana/web3.js/src/programs/system.ts > .transfer > encodeData
+                                        data: '3Bxs43ZMjSRQLs6o',
+                                        programIdIndex: 2,
+                                    },
+                                ],
+                                recentBlockhash: mockBlockHashResponse.value.blockhash,
+                            },
+                            signatures: null,
+                        },
+                    ],
+                },
+            ]);
+        }));
+        it('should throw an error if the chainId is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendSol({
+                chainId: 'eip155:1',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] Invalid chainId. Please provide a chainId that starts with "solana:"'));
+        }));
+        it('should throw an error if the to address is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: 'test',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] Invalid "to" Solana address provided, must be 44 characters'));
+        }));
+        it('should throw an error if the lamports arg is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: -32,
+            })).rejects.toThrow(new Error('[Portal] Invalid lamports amount, must be a positive number greater than 0'));
+        }));
+        it('should throw an error if the latest blockhash could not be fetched', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.provider.request = portal.provider.request.mockResolvedValueOnce({ error: 'test' });
+            yield expect(portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] Failed to get most recent blockhash'));
+        }));
+        it('should throw an error if rpc url was empty for the chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal = new Portal({
+                rpcConfig: {
+                    'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1': '',
+                },
+            });
+            portal.address = mockSolanaAddress;
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+            portal.provider.request = portal.provider.request.mockResolvedValueOnce(mockBlockHashResponse);
+            yield expect(portal.sendSol({
+                chainId: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] No RPC endpoint configured for chainId'));
+        }));
+        it("should throw an error if client's solana address could not be fetched", () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.provider.request = portal.provider.request.mockResolvedValueOnce(mockBlockHashResponse);
+            portal.mpc.getClient = portal.mpc.getClient.mockResolvedValueOnce(null);
+            yield expect(portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] Failed to get Solana address'));
+        }));
+        it("should throw an error if txn hash wasn't returned from the provider", () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.provider.request = portal.provider.request
+                .mockResolvedValueOnce(mockBlockHashResponse)
+                .mockResolvedValueOnce(null);
+            yield expect(portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            })).rejects.toThrow(new Error('[Portal] Failed to send Solana transaction'));
+        }));
+    });
+    describe('sendEth', () => {
+        it('should correctly call provider.request', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.address = mockAddress;
+            yield portal.sendEth({
+                chainId: 'eip155:1',
+                to: 'test',
+                value: '42',
+            });
+            expect(portal.provider.request).toHaveBeenCalledTimes(1);
+            expect(portal.provider.request).toHaveBeenCalledWith({
+                chainId: 'eip155:1',
+                method: 'eth_sendTransaction',
+                params: [
+                    {
+                        from: mockAddress,
+                        to: 'test',
+                        value: '42',
+                    },
+                ],
+            });
+        }));
+    });
+    describe('getBalances', () => {
+        it('should correctly call mpc.getBalances', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getBalances('eip155:1');
+            expect(portal.mpc.getBalances).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getBalances).toHaveBeenCalledWith('eip155:1');
+        }));
+    });
+    describe('getClient', () => {
+        it('should correctly call mpc.getClient', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getClient();
+            expect(portal.mpc.getClient).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getClient).toHaveBeenCalledWith();
+        }));
+    });
+    describe('getNFTs', () => {
+        it('should correctly call mpc.getNFTs', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getNFTs('eip155:1');
+            expect(portal.mpc.getNFTs).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getNFTs).toHaveBeenCalledWith('eip155:1');
+        }));
+    });
+    describe('getTransactions', () => {
+        it('should correctly call mpc.getTransactions', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getTransactions('eip155:1', 1, 10, GetTransactionsOrder.DESC);
+            expect(portal.mpc.getTransactions).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getTransactions).toHaveBeenCalledWith('eip155:1', 1, 10, GetTransactionsOrder.DESC);
+        }));
+    });
+    describe('simulateTransaction', () => {
+        it('should correctly call mpc.simulateTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.simulateTransaction('eip155:1', mockEthTransaction);
+            expect(portal.mpc.simulateTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.simulateTransaction).toHaveBeenCalledWith(mockEthTransaction, 'eip155:1');
+        }));
+    });
+    describe('evaluateTransaction', () => {
+        it('should correctly call mpc.evaluateTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.evaluateTransaction('eip155:1', mockEthTransaction, 'validation');
+            expect(portal.mpc.evaluateTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.evaluateTransaction).toHaveBeenCalledWith('eip155:1', mockEthTransaction, 'validation');
+        }));
+    });
+    describe('buildTransaction', () => {
+        it('should correctly call mpc.buildTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.buildTransaction('eip155:1', mockAddress, 'USDC', '1');
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith('eip155:1', mockAddress, 'USDC', '1');
+        }));
+    });
+    describe('getNFTAssets', () => {
+        it('should correctly call mpc.getNFTAssets', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getNFTAssets('eip155:1');
+            expect(portal.mpc.getNFTAssets).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getNFTAssets).toHaveBeenCalledWith('eip155:1');
+        }));
+    });
+    describe('getAssets', () => {
+        it('should correctly call mpc.getAssets', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getAssets('eip155:1');
+            expect(portal.mpc.getAssets).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getAssets).toHaveBeenCalledWith('eip155:1', false);
+        }));
+    });
+    describe('getQuote', () => {
+        it('should correctly call mpc.getQuote', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getQuote('test', mockQuoteArgs, 'eip155:1');
+            expect(portal.mpc.getQuote).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getQuote).toHaveBeenCalledWith('test', mockQuoteArgs, 'eip155:1');
+        }));
+    });
+    describe('getSources', () => {
+        it('should correctly call mpc.getSources', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.getSources('test', 'eip155:1');
+            expect(portal.mpc.getSources).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getSources).toHaveBeenCalledWith('test', 'eip155:1');
+        }));
+    });
+    describe('storedClientBackupShare', () => {
+        it('should correctly call mpc.storedClientBackupShare', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.storedClientBackupShare(true, BackupMethods.password);
+            expect(portal.mpc.storedClientBackupShare).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.storedClientBackupShare).toHaveBeenCalledWith(true, BackupMethods.password);
+        }));
+    });
+    describe('getRpcUrl', () => {
+        it('should return the correct rpc url for the given chainId', () => {
+            expect(portal.getRpcUrl('eip155:1')).toEqual(mockEthRpcUrl);
+            expect(portal.getRpcUrl('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')).toEqual(mockSolRpcUrl);
+        });
+        it('should throw an error if the chainId is not provided', () => {
+            expect(() => portal.getRpcUrl()).toThrow(new Error('[Portal] No chainId provided. Please provide a chainId to get the RPC endpoint'));
+        });
+        it('should throw an error if the chainId is not present in the rpc config', () => {
+            expect(() => portal.getRpcUrl('test')).toThrow(new Error('[Portal] No RPC endpoint configured for chainId: test'));
+        });
+        it('should throw an error if the chainId is not present in the rpc config', () => {
+            expect(() => portal.getRpcUrl('incorrect-config')).toThrow(new Error('[Portal] Could not find a valid rpcConfig entry for chainId: incorrect-config'));
+        });
+    });
+});

package/lib/esm/mpc/errors/index.js

@@ -59,7 +59,7 @@ export class MpcError extends Error {
         // Init the actual error
         super(error.message(context));
         // Custom error context
-        this.code = (error === null || error === void 0 ? void 0 : error.code) || 999;
+        this.code = (error === null || error === void 0 ? void 0 : error.code) || '999';
         if (context) {
             this.context = context;
         }