@portal-hq/web 3.2.3 → 3.3.1

package/lib/commonjs/index.test.js

@@ -0,0 +1,548 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 _1 = __importStar(require("."));
+const constants_1 = require("./__mocks/constants");
+const mpc_1 = __importDefault(require("./__mocks/portal/mpc"));
+const provider_1 = __importDefault(require("./__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 _1.default({
+            rpcConfig: Object.assign(Object.assign({}, constants_1.mockRpcConfig), { 
+                // for testing -
+                // @ts-ignore-next-line
+                'incorrect-config': { test: 'test' } }),
+        });
+        portal.mpc = mpc_1.default;
+        portal.provider = provider_1.default;
+    });
+    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(constants_1.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 _1.default({
+                rpcConfig: constants_1.mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.createWallet(mockProgressFn);
+            expect(res).toBe(constants_1.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(_1.BackupMethods.gdrive, mockProgressFn, constants_1.mockBackupConfig);
+            expect(res).toBe(constants_1.mockMpcBackupResponse);
+            expect(portal.mpc.backup).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: _1.BackupMethods.gdrive,
+                backupConfigs: constants_1.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 _1.default({
+                rpcConfig: constants_1.mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.backupWallet(_1.BackupMethods.passkey, mockProgressFn, constants_1.mockBackupConfig);
+            expect(res).toBe(constants_1.mockMpcBackupResponse);
+            expect(portal.mpc.backup).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: _1.BackupMethods.passkey,
+                backupConfigs: constants_1.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(constants_1.mockCipherText, _1.BackupMethods.password, constants_1.mockBackupConfig, mockProgressFn);
+            expect(res).toBe(constants_1.mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: constants_1.mockCipherText,
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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 _1.default({
+                rpcConfig: constants_1.mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.recoverWallet(constants_1.mockCipherText, _1.BackupMethods.password, constants_1.mockBackupConfig, mockProgressFn);
+            expect(res).toBe(constants_1.mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: constants_1.mockCipherText,
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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(constants_1.mockCipherText, _1.BackupMethods.password, constants_1.mockBackupConfig, mockProgressFn);
+            expect(res).toBe(constants_1.mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: constants_1.mockCipherText,
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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 _1.default({
+                rpcConfig: constants_1.mockRpcConfig,
+                featureFlags: { isMultiBackupEnabled: true },
+                host: 'test-host',
+            });
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+            const mockProgressFn = jest.fn();
+            const res = yield portal.provisionWallet(constants_1.mockCipherText, _1.BackupMethods.password, constants_1.mockBackupConfig, mockProgressFn);
+            expect(res).toBe(constants_1.mockAddress);
+            expect(portal.mpc.recover).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.recover).toHaveBeenCalledWith({
+                cipherText: constants_1.mockCipherText,
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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(_1.BackupMethods.password, constants_1.mockBackupConfig);
+            expect(res).toEqual(constants_1.mockEjectResult);
+            expect(portal.mpc.eject).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.eject).toHaveBeenCalledWith({
+                cipherText: '',
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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({}, constants_1.mockClientResponse), { environment: Object.assign(Object.assign({}, constants_1.mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            const res = yield portal.eject(_1.BackupMethods.password, constants_1.mockBackupConfig, constants_1.mockOrgBackupShare, constants_1.mockCipherText);
+            expect(res).toEqual(constants_1.mockEjectResult);
+            expect(portal.mpc.eject).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.eject).toHaveBeenCalledWith({
+                cipherText: constants_1.mockCipherText,
+                organizationBackupShare: constants_1.mockOrgBackupShare,
+                backupMethod: _1.BackupMethods.password,
+                backupConfigs: constants_1.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(_1.BackupMethods.password, constants_1.mockBackupConfig, constants_1.mockOrgBackupShare, constants_1.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({}, constants_1.mockClientResponse), { environment: Object.assign(Object.assign({}, constants_1.mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            yield expect(portal.eject(_1.BackupMethods.password, constants_1.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({}, constants_1.mockClientResponse), { environment: Object.assign(Object.assign({}, constants_1.mockClientResponse.environment), { backupWithPortalEnabled: false }) }));
+            yield expect(portal.eject(_1.BackupMethods.password, constants_1.mockBackupConfig, '', constants_1.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(constants_1.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(constants_1.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(constants_1.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(!!constants_1.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(constants_1.mockSharesOnDevice.ED25519 && constants_1.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(constants_1.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 = constants_1.mockSolanaAddress;
+        });
+        it('should successfully send sol', () => __awaiter(void 0, void 0, void 0, function* () {
+            portal.provider.request = portal.provider.request
+                .mockResolvedValueOnce(constants_1.mockBlockHashResponse)
+                .mockResolvedValueOnce(constants_1.mockSignedHash);
+            const result = yield portal.sendSol({
+                chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                to: '9G2CRh8pzicbRkiNLh8Xsp2DEP28UhwtHSyqetGYTCWD',
+                lamports: 10000,
+            });
+            expect(result).toBe(constants_1.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: [
+                                    constants_1.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: constants_1.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 _1.default({
+                rpcConfig: {
+                    'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1': '',
+                },
+            });
+            portal.address = constants_1.mockSolanaAddress;
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+            portal.provider.request = portal.provider.request.mockResolvedValueOnce(constants_1.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(constants_1.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(constants_1.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 = constants_1.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: constants_1.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, _1.GetTransactionsOrder.DESC);
+            expect(portal.mpc.getTransactions).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getTransactions).toHaveBeenCalledWith('eip155:1', 1, 10, _1.GetTransactionsOrder.DESC);
+        }));
+    });
+    describe('simulateTransaction', () => {
+        it('should correctly call mpc.simulateTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.simulateTransaction('eip155:1', constants_1.mockEthTransaction);
+            expect(portal.mpc.simulateTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.simulateTransaction).toHaveBeenCalledWith(constants_1.mockEthTransaction, 'eip155:1');
+        }));
+    });
+    describe('evaluateTransaction', () => {
+        it('should correctly call mpc.evaluateTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.evaluateTransaction('eip155:1', constants_1.mockEthTransaction, 'validation');
+            expect(portal.mpc.evaluateTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.evaluateTransaction).toHaveBeenCalledWith('eip155:1', constants_1.mockEthTransaction, 'validation');
+        }));
+    });
+    describe('buildTransaction', () => {
+        it('should correctly call mpc.buildTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.buildTransaction('eip155:1', constants_1.mockAddress, 'USDC', '1');
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith('eip155:1', constants_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', constants_1.mockQuoteArgs, 'eip155:1');
+            expect(portal.mpc.getQuote).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.getQuote).toHaveBeenCalledWith('test', constants_1.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, _1.BackupMethods.password);
+            expect(portal.mpc.storedClientBackupShare).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.storedClientBackupShare).toHaveBeenCalledWith(true, _1.BackupMethods.password);
+        }));
+    });
+    describe('getRpcUrl', () => {
+        it('should return the correct rpc url for the given chainId', () => {
+            expect(portal.getRpcUrl('eip155:1')).toEqual(constants_1.mockEthRpcUrl);
+            expect(portal.getRpcUrl('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')).toEqual(constants_1.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/commonjs/mpc/errors/index.js

@@ -62,7 +62,7 @@ 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;
         }