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

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.3.4-beta.1",
+  "version": "3.3.5-alpha",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",

package/src/__mocks/constants.ts

@@ -84,10 +84,18 @@ export const mockClientResponse = {
 
 export const mockEjectResult = {
   SECP256K1: 'test',
-  ED25519: 'test',
+}
+export const mockEjectPrivateKeysResult = {
+  SECP256K1: 'test-SECP256K1',
+  ED25519: 'test-ED25519',
 }
 
 export const mockOrgBackupShare = 'test-org-share'
+export const mockOrgBackupShares = {
+  SECP256K1: 'test-SECP256K1-org-share',
+  ED25519: 'test-ED25519-org-share',
+}
+
 export const mockSharesOnDevice = {
   SECP256K1: true,
   ED25519: false,
@@ -133,7 +141,7 @@ export const mockGenerateResponse = {
   },
 }
 export const mockBackupResponse = {
-  cipherText: mockCipherText
+  cipherText: mockCipherText,
 }
 
 export const mockContent = 'test-content'

package/src/__mocks/portal/mpc.ts

@@ -2,6 +2,7 @@ import {
   mockAddress,
   mockClientResponse,
   mockEjectResult,
+  mockEjectPrivateKeysResult,
   mockMpcBackupResponse,
   mockSharesOnDevice,
   mockSignedHash,
@@ -22,6 +23,9 @@ mpcMock.backup = jest.fn().mockResolvedValue(mockMpcBackupResponse)
 mpcMock.recover = jest.fn().mockResolvedValue(mockAddress)
 mpcMock.getClient = jest.fn().mockResolvedValue(mockClientResponse)
 mpcMock.eject = jest.fn().mockResolvedValue(mockEjectResult)
+mpcMock.ejectPrivateKeys = jest
+  .fn()
+  .mockResolvedValue(mockEjectPrivateKeysResult)
 mpcMock.checkSharesOnDevice = jest.fn().mockResolvedValue(mockSharesOnDevice)
 
 export default mpcMock as jest.Mocked<Mpc>

package/src/index.test.ts

@@ -11,10 +11,12 @@ import {
   mockClientResponse,
   mockEip155Address,
   mockEjectResult,
+  mockEjectPrivateKeysResult,
   mockEthRpcUrl,
   mockEthTransaction,
   mockMpcBackupResponse,
   mockOrgBackupShare,
+  mockOrgBackupShares,
   mockQuoteArgs,
   mockRpcConfig,
   mockSharesOnDevice,
@@ -392,6 +394,128 @@ describe('Portal', () => {
     })
   })
 
+  describe('ejectPrivateKeys', () => {
+    it('should successfully eject a wallet when backup with portal is enabled', async () => {
+      const res = await 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', async () => {
+      portal.mpc.getClient = (
+        portal.mpc.getClient as jest.Mock
+      ).mockResolvedValueOnce({
+        ...mockClientResponse,
+        environment: {
+          ...mockClientResponse.environment,
+          backupWithPortalEnabled: false,
+        },
+      })
+
+      const res = await 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', async () => {
+      portal.mpc.getClient = (
+        portal.mpc.getClient as jest.Mock
+      ).mockResolvedValueOnce(null)
+
+      await 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', async () => {
+      portal.mpc.getClient = (
+        portal.mpc.getClient as jest.Mock
+      ).mockResolvedValueOnce({
+        ...mockClientResponse,
+        environment: {
+          ...mockClientResponse.environment,
+          backupWithPortalEnabled: false,
+        },
+      })
+
+      await 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', async () => {
+      portal.mpc.getClient = (
+        portal.mpc.getClient as jest.Mock
+      ).mockResolvedValueOnce({
+        ...mockClientResponse,
+        environment: {
+          ...mockClientResponse.environment,
+          backupWithPortalEnabled: false,
+        },
+      })
+
+      await 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", async () => {
       const res = await portal.getEip155Address()

package/src/index.ts

@@ -8,10 +8,12 @@ import {
 import {
   Asset,
   BuiltTransaction,
+  EjectPrivateKeysResult,
   EvaluateTransactionOperationType,
   EvaluateTransactionParam,
   EvaluatedTransaction,
   NFTAsset,
+  OrgBackupShares,
   type BackupConfigs,
   type BackupResponse,
   type Balance,
@@ -101,7 +103,7 @@ class Portal {
 
     this.provider = new Provider({
       portal: this,
-      chainId: chainId ? Number(chainId): undefined,
+      chainId: chainId ? Number(chainId) : undefined,
     })
   }
 
@@ -255,7 +257,7 @@ class Portal {
       }
     }
 
-    const { SECP256K1, ED25519 } = await this.mpc.eject({
+    const { SECP256K1 } = await this.mpc.eject({
       cipherText: clientBackupCipherText,
       backupMethod,
       backupConfigs,
@@ -265,6 +267,41 @@ class Portal {
       featureFlags: this.featureFlags,
     })
 
+    return {
+      SECP256K1,
+    }
+  }
+
+  public async ejectPrivateKeys(
+    backupMethod: BackupMethods,
+    backupConfigs: BackupConfigs = {},
+    orgBackupShares: OrgBackupShares,
+    clientBackupCipherText = '',
+  ): Promise<EjectPrivateKeysResult> {
+    const client = await 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 } = await this.mpc.ejectPrivateKeys({
+      cipherText: clientBackupCipherText,
+      backupMethod,
+      backupConfigs,
+      organizationBackupShares: orgBackupShares,
+      host: this.host,
+      mpcVersion: this.mpcVersion,
+      featureFlags: this.featureFlags,
+    })
+
     return {
       SECP256K1,
       ED25519,