@portal-hq/web 3.6.2-alpha → 3.7.0

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.6.2-alpha",
+  "version": "3.7.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -13,6 +13,10 @@
     "src",
     "lib",
     "tsconfig.json",
+    "hypernative.d.ts",
+    "lifi-types.d.ts",
+    "yieldxyz-types.d.ts",
+    "zero-x.d.ts",
     "types.d.ts",
     "!src/iframe",
     "!dist"
@@ -49,6 +53,5 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.91.8"
-  },
-  "stableVersion": "3.5.2"
+  }
 }

package/src/__mocks/constants.ts

@@ -730,11 +730,17 @@ export const mockQuoteRes = {
 }
 
 export const mockSourcesRes = {
-  '0x': '0xE41d2489571d322189246DaFA5ebDe1F4699F498',
-  SushiSwap: '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2',
-  Uniswap: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
-  Uniswap_V2: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
-  Uniswap_V3: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+  data: {
+    rawResponse: {
+      sources: ['0x', 'SushiSwap', 'Uniswap', 'Uniswap_V2', 'Uniswap_V3'],
+      zid: 'test-zid',
+    },
+  },
+  metadata: {
+    chainId: 'eip155:1',
+    clientId: 'test',
+    clientEip155Address: '0x1234567890123456789012345678901234567890',
+  },
 }
 
 export const mockZeroXQuoteResponse = {
@@ -1312,3 +1318,414 @@ export const mockLifiGetRouteStepResponse = {
     },
   },
 }
+
+// ZeroEx v2 mock data
+export const mockZeroExQuoteV2Request = {
+  chainId: 'eip155:1',
+  buyToken: 'UNI',
+  sellToken: 'WETH',
+  sellAmount: '1000000000000000000',
+}
+
+export const mockZeroExQuoteV2Response = {
+  data: {
+    rawResponse: {
+      blockNumber: '18500000',
+      buyAmount: '100000000000000000000',
+      buyToken: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+      fees: {
+        integratorFee: null,
+        zeroExFee: null,
+        gasFee: {
+          amount: '21000000000000',
+          token: '0x0000000000000000000000000000000000000000',
+          type: 'gas',
+        },
+      },
+      issues: {
+        allowance: {
+          actual: '0',
+          spender: '0x1234567890123456789012345678901234567890',
+        },
+        balance: {
+          token: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+          actual: '1000000000000000000',
+          expected: '1000000000000000000',
+        },
+        simulationIncomplete: false,
+        invalidSourcesPassed: [],
+      },
+      liquidityAvailable: true,
+      minBuyAmount: '99000000000000000000',
+      route: {
+        fills: [
+          {
+            from: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+            to: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+            source: 'Uniswap_V3',
+            proportionBps: '10000',
+          },
+        ],
+        tokens: [
+          {
+            address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+            symbol: 'WETH',
+          },
+          {
+            address: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+            symbol: 'UNI',
+          },
+        ],
+      },
+      sellAmount: '1000000000000000000',
+      sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+      tokenMetadata: {
+        buyToken: {
+          buyTaxBps: '0',
+          sellTaxBps: '0',
+        },
+        sellToken: {
+          buyTaxBps: '0',
+          sellTaxBps: '0',
+        },
+      },
+      totalNetworkFee: '21000000000000',
+      transaction: {
+        to: '0x1234567890123456789012345678901234567890',
+        data: '0xabcdef',
+        gas: '200000',
+        gasPrice: '30000000000',
+        value: '0',
+      },
+    },
+  },
+  metadata: {
+    buyToken: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+    sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    sellAmount: '1000000000000000000',
+    chainId: 'eip155:1',
+    clientId: 'test-client-id',
+    clientEip155Address: mockEip155Address,
+  },
+}
+
+export const mockZeroExSourcesV2Request = {
+  chainId: 'eip155:1',
+}
+
+export const mockZeroExSourcesV2Response = {
+  data: {
+    rawResponse: {
+      sources: ['Uniswap_V2', 'Uniswap_V3', 'SushiSwap', '0x'],
+      zid: 'test-zid',
+    },
+  },
+  metadata: {
+    chainId: 'eip155:1',
+    clientId: 'test-client-id',
+  },
+}
+
+export const mockZeroExPriceRequest = {
+  chainId: 'eip155:1',
+  buyToken: 'UNI',
+  sellToken: 'WETH',
+  sellAmount: '1000000000000000000',
+}
+
+export const mockZeroExPriceResponse = {
+  data: {
+    rawResponse: {
+      blockNumber: '18500000',
+      buyAmount: '100000000000000000000',
+      buyToken: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+      fees: {
+        integratorFee: null,
+        zeroExFee: null,
+        gasFee: {
+          amount: '21000000000000',
+          token: '0x0000000000000000000000000000000000000000',
+          type: 'gas',
+        },
+      },
+      gas: '200000',
+      gasPrice: '30000000000',
+      issues: {
+        allowance: {
+          actual: '0',
+          spender: '0x1234567890123456789012345678901234567890',
+        },
+        balance: {
+          token: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+          actual: '1000000000000000000',
+          expected: '1000000000000000000',
+        },
+        simulationIncomplete: false,
+        invalidSourcesPassed: [],
+      },
+      liquidityAvailable: true,
+      minBuyAmount: '99000000000000000000',
+      route: {
+        fills: [
+          {
+            from: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+            to: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+            source: 'Uniswap_V3',
+            proportionBps: '10000',
+          },
+        ],
+        tokens: [
+          {
+            address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+            symbol: 'WETH',
+          },
+          {
+            address: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+            symbol: 'UNI',
+          },
+        ],
+      },
+      sellAmount: '1000000000000000000',
+      sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+      tokenMetadata: {
+        buyToken: {
+          buyTaxBps: '0',
+          sellTaxBps: '0',
+        },
+        sellToken: {
+          buyTaxBps: '0',
+          sellTaxBps: '0',
+        },
+      },
+      totalNetworkFee: '21000000000000',
+    },
+  },
+  metadata: {
+    buyToken: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+    sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    sellAmount: '1000000000000000000',
+    chainId: 'eip155:1',
+    clientId: 'test-client-id',
+    clientEip155Address: mockEip155Address,
+  },
+}
+
+export const mockZeroExOptions = {
+  zeroXApiKey: 'test-0x-api-key',
+}
+
+// Hypernative Security mock data
+export const mockScanAddressesRequest = {
+  addresses: ['0x1234567890123456789012345678901234567890'],
+  screenerPolicyId: 'test-policy-id',
+}
+
+export const mockScanAddressesResponse = {
+  data: {
+    rawResponse: [
+      {
+        address: '0x1234567890123456789012345678901234567890',
+        recommendation: 'accept',
+        severity: 'low',
+        totalIncomingUsd: 1000,
+        policyId: 'test-policy-id',
+        timestamp: '2024-01-01T00:00:00Z',
+        flags: [],
+      },
+    ],
+  },
+}
+
+export const mockScanEVMTxRequest = {
+  transaction: {
+    chain: 'ethereum',
+    fromAddress: '0x1234567890123456789012345678901234567890',
+    toAddress: '0x0987654321098765432109876543210987654321',
+    input: '0xabcdef',
+    value: '1000000000000000000',
+  },
+  url: 'https://example.com',
+  validateNonce: true,
+  showFullFindings: true,
+}
+
+export const mockScanEVMTxResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        assessmentId: 'test-assessment-id',
+        assessmentTimestamp: '2024-01-01T00:00:00Z',
+        recommendation: 'accept' as const,
+        expectedStatus: 'success' as const,
+        findings: [],
+        involvedAssets: [],
+        balanceChanges: null,
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}
+
+export const mockScanEip712TxRequest = {
+  walletAddress: '0x1234567890123456789012345678901234567890',
+  chainId: '1',
+  eip712Message: {
+    primaryType: 'Transfer',
+    types: {
+      Transfer: [
+        { name: 'to', type: 'address' },
+        { name: 'amount', type: 'uint256' },
+      ],
+    },
+    domain: {
+      name: 'Test',
+      version: '1',
+      chainId: 1,
+    },
+    message: {
+      to: '0x0987654321098765432109876543210987654321',
+      amount: '1000000000000000000',
+    },
+  },
+  showFullFindings: true,
+}
+
+export const mockScanEip712TxResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        assessmentId: 'test-assessment-id',
+        assessmentTimestamp: '2024-01-01T00:00:00Z',
+        recommendation: 'accept' as const,
+        findings: [],
+        involvedAssets: [],
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}
+
+export const mockScanSolanaTxRequest = {
+  transaction: {
+    message: {
+      accountKeys: ['test-account-key'],
+      header: {
+        numRequiredSignatures: 1,
+        numReadonlySignedAccounts: 0,
+        numReadonlyUnsignedAccounts: 0,
+      },
+      instructions: [
+        {
+          accounts: [0],
+          data: 'test-data',
+          programIdIndex: 0,
+        },
+      ],
+      recentBlockhash: 'test-blockhash',
+    },
+    signatures: ['test-signature'],
+  },
+  url: 'https://example.com',
+  validateRecentBlockHash: true,
+  showFullFindings: true,
+}
+
+export const mockScanSolanaTxResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        recommendation: 'accept' as const,
+        expectedStatus: 'success' as const,
+        findings: [],
+        involvedAssets: [],
+        balanceChanges: null,
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}
+
+export const mockScanNftRequest = [
+  {
+    address: '0x1234567890123456789012345678901234567890',
+    chain: 'ethereum',
+    evmChainId: 1,
+  },
+]
+
+export const mockScanNftResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        nfts: [
+          {
+            address: '0x1234567890123456789012345678901234567890',
+            chain: 'ethereum',
+            evmChainId: '1',
+            accept: true,
+          },
+        ],
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}
+
+export const mockScanTokenRequest = [
+  {
+    address: '0x1234567890123456789012345678901234567890',
+    chain: 'ethereum',
+    evmChainId: 1,
+  },
+]
+
+export const mockScanTokenResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        tokens: [
+          {
+            address: '0x1234567890123456789012345678901234567890',
+            chain: 'ethereum',
+            reputation: {
+              recommendation: 'accept' as const,
+            },
+          },
+        ],
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}
+
+export const mockScanUrlRequest = 'https://example.com'
+
+export const mockScanUrlResponse = {
+  data: {
+    rawResponse: {
+      success: true,
+      data: {
+        isMalicious: false,
+        deepScanTriggered: false,
+      },
+      error: null,
+      version: '1.0.0',
+      service: 'hypernative',
+    },
+  },
+}

package/src/__mocks/portal/mpc.ts

@@ -27,5 +27,6 @@ mpcMock.ejectPrivateKeys = jest
   .fn()
   .mockResolvedValue(mockEjectPrivateKeysResult)
 mpcMock.checkSharesOnDevice = jest.fn().mockResolvedValue(mockSharesOnDevice)
+mpcMock.setBackupStatus = jest.fn().mockResolvedValue(true)
 
 export default mpcMock as jest.Mocked<Mpc>

package/src/index.test.ts

@@ -173,6 +173,182 @@ describe('Portal', () => {
     })
   })
 
+  describe('generateBackupShare', () => {
+    it('should request a custom backup and return cipherText and encryptionKey', async () => {
+      const storageCallback = jest.fn().mockResolvedValue(undefined)
+      ;(portal.mpc.backup as jest.Mock).mockResolvedValueOnce({
+        cipherText: mockCipherText,
+        encryptionKey: 'manual-key',
+        storageCallback,
+      })
+
+      const result = await portal.generateBackupShare()
+
+      expect(result).toEqual({
+        cipherText: mockCipherText,
+        encryptionKey: 'manual-key',
+      })
+
+      expect(portal.mpc.backup).toHaveBeenCalledWith(
+        {
+          backupMethod: BackupMethods.custom,
+          backupConfigs: {},
+          host: 'web.portalhq.io',
+          mpcVersion: 'v6',
+          featureFlags: {},
+        },
+        expect.any(Function),
+      )
+    })
+
+    it('should throw if the iframe response does not contain an encryption key', async () => {
+      ;(portal.mpc.backup as jest.Mock).mockResolvedValueOnce({
+        cipherText: mockCipherText,
+        storageCallback: jest.fn(),
+      })
+
+      await expect(portal.generateBackupShare()).rejects.toThrow(
+        'Custom backup did not return an encryption key',
+      )
+    })
+  })
+
+  describe('registerPasskeyAndStoreEncryptionKey', () => {
+    it('should delegate to the passkey service with computed relying party data', async () => {
+      const passkeyServiceMock = {
+        registerPasskeyAndStoreKey: jest.fn().mockResolvedValue(undefined),
+      }
+      ;(portal as any).passkeyService = passkeyServiceMock
+      ;(portal as any).passkeyServiceDefaultDomain = 'backup.web.portalhq.io'
+      ;(portal as any).passkeyServiceApiKey = portal.apiKey
+
+      await portal.registerPasskeyAndStoreEncryptionKey(
+        mockCipherText,
+        'manual-key',
+      )
+
+      expect(
+        passkeyServiceMock.registerPasskeyAndStoreKey,
+      ).toHaveBeenCalledTimes(1)
+      expect(
+        passkeyServiceMock.registerPasskeyAndStoreKey,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          customDomain: undefined,
+          encryptionKey: 'manual-key',
+          relyingPartyId: 'backup.web.portalhq.io',
+          relyingPartyName: 'Portal',
+          cipherText: mockCipherText,
+        }),
+      )
+    })
+
+    it('should throw when usePopup is requested', async () => {
+      await expect(
+        portal.registerPasskeyAndStoreEncryptionKey(
+          mockCipherText,
+          'manual-key',
+          { usePopup: true },
+        ),
+      ).rejects.toThrow('does not support the popup flow')
+    })
+  })
+
+  describe('authenticatePasskeyAndRetrieveKey', () => {
+    it('should invoke the passkey service for direct authentication', async () => {
+      const passkeyServiceMock = {
+        authenticatePasskeyAndRetrieveKey: jest
+          .fn()
+          .mockResolvedValue('retrieved-key'),
+      }
+      ;(portal as any).passkeyService = passkeyServiceMock
+      ;(portal as any).passkeyServiceDefaultDomain = 'backup.web.portalhq.io'
+      ;(portal as any).passkeyServiceApiKey = portal.apiKey
+
+      const key = await portal.authenticatePasskeyAndRetrieveKey()
+
+      expect(key).toEqual('retrieved-key')
+      expect(
+        passkeyServiceMock.authenticatePasskeyAndRetrieveKey,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          customDomain: undefined,
+          relyingPartyId: 'backup.web.portalhq.io',
+          relyingPartyName: 'Portal',
+        }),
+      )
+    })
+
+    it('should throw when usePopup is true', async () => {
+      await expect(
+        portal.authenticatePasskeyAndRetrieveKey({ usePopup: true }),
+      ).rejects.toThrow('does not support the popup flow')
+    })
+  })
+
+  describe('backupWithPasskey', () => {
+    it('should orchestrate the direct passkey flow when usePopup is false', async () => {
+      const directShare = {
+        cipherText: mockCipherText,
+        encryptionKey: 'manual-key',
+      }
+      const generateSpy = jest
+        .spyOn(portal, 'generateBackupShare')
+        .mockResolvedValue(directShare)
+      const registerSpy = jest
+        .spyOn(portal, 'registerPasskeyAndStoreEncryptionKey')
+        .mockResolvedValue(undefined)
+      const storedClientBackupShareSpy = jest
+        .spyOn(portal, 'storedClientBackupShare')
+        .mockResolvedValue(undefined)
+
+      await portal.backupWithPasskey(
+        {
+          usePopup: false,
+          customDomain: 'passkeys.wigwam.app',
+          relyingPartyName: 'Wigwam',
+        },
+        undefined,
+      )
+
+      expect(generateSpy).toHaveBeenCalledTimes(1)
+      expect(registerSpy).toHaveBeenCalledWith(
+        directShare.cipherText,
+        directShare.encryptionKey,
+        expect.objectContaining({
+          customDomain: 'passkeys.wigwam.app',
+          relyingPartyName: 'Wigwam',
+          usePopup: false,
+        }),
+      )
+      expect(storedClientBackupShareSpy).toHaveBeenCalledWith(
+        true,
+        BackupMethods.passkey,
+      )
+
+      generateSpy.mockRestore()
+      registerSpy.mockRestore()
+      storedClientBackupShareSpy.mockRestore()
+    })
+
+    it('should fall back to the legacy popup flow when usePopup is true', async () => {
+      const progress = jest.fn()
+
+      await portal.backupWithPasskey({}, progress)
+
+      expect(portal.mpc.backup).toHaveBeenCalledWith(
+        {
+          backupMethod: BackupMethods.passkey,
+          backupConfigs: {},
+          host: 'web.portalhq.io',
+          mpcVersion: 'v6',
+          featureFlags: {},
+        },
+        progress,
+      )
+    })
+  })
+
   describe('recoverWallet', () => {
     it('should successfully recover a wallet and call mpc.recover correctly', async () => {
       const mockProgressFn = jest.fn()
@@ -883,9 +1059,9 @@ describe('Portal', () => {
 
       expect(portal.mpc.getQuote).toHaveBeenCalledTimes(1)
       expect(portal.mpc.getQuote).toHaveBeenCalledWith(
-        'test',
-        mockQuoteArgs,
         'eip155:1',
+        mockQuoteArgs,
+        'test',
       )
     })
   })
@@ -895,7 +1071,7 @@ describe('Portal', () => {
       await portal.getSources('test', 'eip155:1')
 
       expect(portal.mpc.getSources).toHaveBeenCalledTimes(1)
-      expect(portal.mpc.getSources).toHaveBeenCalledWith('test', 'eip155:1')
+      expect(portal.mpc.getSources).toHaveBeenCalledWith('eip155:1', 'test')
     })
   })