@portal-hq/web 3.3.4-beta.1 → 3.3.5-alpha

package/lib/esm/index.js

@@ -166,7 +166,7 @@ class Portal {
                     throw new Error('orgBackupShare cannot be empty string.');
                 }
             }
-            const { SECP256K1, ED25519 } = yield this.mpc.eject({
+            const { SECP256K1 } = yield this.mpc.eject({
                 cipherText: clientBackupCipherText,
                 backupMethod,
                 backupConfigs,
@@ -175,6 +175,34 @@ class Portal {
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
             });
+            return {
+                SECP256K1,
+            };
+        });
+    }
+    ejectPrivateKeys(backupMethod, backupConfigs = {}, orgBackupShares, clientBackupCipherText = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.mpc.getClient();
+            if (!client) {
+                throw new Error('Client not found.');
+            }
+            if (!client.environment.backupWithPortalEnabled) {
+                if (clientBackupCipherText === '') {
+                    throw new Error('clientBackupCipherText cannot be empty string.');
+                }
+                if (orgBackupShares.SECP256K1 === '') {
+                    throw new Error('SECP256K1 orgBackupShare cannot be empty string.');
+                }
+            }
+            const { SECP256K1, ED25519 } = yield this.mpc.ejectPrivateKeys({
+                cipherText: clientBackupCipherText,
+                backupMethod,
+                backupConfigs,
+                organizationBackupShares: orgBackupShares,
+                host: this.host,
+                mpcVersion: this.mpcVersion,
+                featureFlags: this.featureFlags,
+            });
             return {
                 SECP256K1,
                 ED25519,

package/lib/esm/index.test.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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 { mockAddress, mockBackupConfig, mockBlockHashResponse, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEjectPrivateKeysResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockOrgBackupShares, mockQuoteArgs, mockRpcConfig, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, } from './__mocks/constants';
 import mpcMock from './__mocks/portal/mpc';
 import providerMock from './__mocks/portal/provider';
 /**
@@ -233,6 +233,58 @@ describe('Portal', () => {
             yield expect(portal.eject(BackupMethods.password, mockBackupConfig, '', mockCipherText)).rejects.toThrowError(new Error('orgBackupShare cannot be empty string.'));
         }));
     });
+    describe('ejectPrivateKeys', () => {
+        it('should successfully eject a wallet when backup with portal is enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.ejectPrivateKeys(BackupMethods.password, mockBackupConfig, {
+                SECP256K1: '',
+                ED25519: '',
+            });
+            expect(res).toEqual(mockEjectPrivateKeysResult);
+            expect(portal.mpc.ejectPrivateKeys).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.ejectPrivateKeys).toHaveBeenCalledWith({
+                cipherText: '',
+                backupMethod: BackupMethods.password,
+                backupConfigs: mockBackupConfig,
+                organizationBackupShares: {
+                    SECP256K1: '',
+                    ED25519: '',
+                },
+                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.ejectPrivateKeys(BackupMethods.password, mockBackupConfig, mockOrgBackupShares, mockCipherText);
+            expect(res).toEqual(mockEjectPrivateKeysResult);
+            expect(portal.mpc.ejectPrivateKeys).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.ejectPrivateKeys).toHaveBeenCalledWith({
+                cipherText: mockCipherText,
+                organizationBackupShares: mockOrgBackupShares,
+                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.ejectPrivateKeys(BackupMethods.password, mockBackupConfig, mockOrgBackupShares, 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.ejectPrivateKeys(BackupMethods.password, mockBackupConfig, mockOrgBackupShares)).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.ejectPrivateKeys(BackupMethods.password, mockBackupConfig, {
+                SECP256K1: '',
+                ED25519: '',
+            }, mockCipherText)).rejects.toThrowError(new Error('SECP256K1 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();

package/lib/esm/mpc/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PortalMpcError } from './errors';
 import { BackupMethods, } from '../index';
-const WEB_SDK_VERSION = '3.3.4-beta.1';
+const WEB_SDK_VERSION = '3.3.5-alpha';
 class Mpc {
     get ready() {
         return this._ready;
@@ -288,6 +288,35 @@ class Mpc {
             });
         });
     }
+    ejectPrivateKeys(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleEject = (message) => {
+                    const { type, data: result } = message.data;
+                    const { origin } = message;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:wasm:ejectPrivateKeysError') {
+                        // Remove the event listeners
+                        window.removeEventListener('message', handleEject);
+                        reject(new PortalMpcError(result));
+                    }
+                    else if (type === 'portal:wasm:ejectPrivateKeysResult') {
+                        // Remove the event listeners
+                        window.removeEventListener('message', handleEject);
+                        resolve(result);
+                    }
+                };
+                window.addEventListener('message', handleEject);
+                this.postMessage({
+                    type: 'portal:wasm:ejectPrivateKeys',
+                    data,
+                });
+            });
+        });
+    }
     rawSign(curve, param) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {