@portal-hq/web 3.16.0 → 3.17.0-alpha.0

package/src/index.test.ts

@@ -2,12 +2,18 @@
  * @jest-environment jsdom
  */
 
-import Portal, { BackupMethods, GetTransactionsOrder } from '.'
+import Portal, { BackupMethods, GetTransactionsOrder, PortalCurve } from '.'
 import {
   mockAddress,
   mockBackupConfig,
   mockBlockHashResponse,
+  mockBuiltEip155Transaction,
+  mockBuiltEip155TransactionNative,
   mockBuiltTronTransaction,
+  mockBuildBatchedUserOpRequest,
+  mockBuildBatchedUserOpResponse,
+  mockBroadcastBatchedUserOpRequest,
+  mockBroadcastBatchedUserOpResponse,
   mockCipherText,
   mockClientResponse,
   mockEip155Address,
@@ -20,6 +26,7 @@ import {
   mockOrgBackupShares,
   mockQuoteArgs,
   mockRpcConfig,
+  mockSendBatchUserOpRequest,
   mockSharesOnDevice,
   mockSignedHash,
   mockSolanaAddress,
@@ -1167,6 +1174,471 @@ describe('Portal', () => {
     })
   })
 
+  describe('buildBatchedUserOp', () => {
+    it('should correctly call mpc.accountAbstractionBuildBatchedUserOp', async () => {
+      await portal.buildBatchedUserOp(mockBuildBatchedUserOpRequest)
+
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledTimes(1)
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledWith(mockBuildBatchedUserOpRequest)
+    })
+  })
+
+  describe('broadcastBatchedUserOp', () => {
+    it('should correctly call mpc.accountAbstractionBroadcastBatchedUserOp', async () => {
+      await portal.broadcastBatchedUserOp(mockBroadcastBatchedUserOpRequest)
+
+      expect(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp,
+      ).toHaveBeenCalledTimes(1)
+      expect(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp,
+      ).toHaveBeenCalledWith(mockBroadcastBatchedUserOpRequest)
+    })
+  })
+
+  describe('sendBatchUserOp', () => {
+    it('should build, sign, and broadcast a batched UserOperation', async () => {
+      const result = await portal.sendBatchUserOp(mockSendBatchUserOpRequest)
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          data: expect.objectContaining({ userOpHash: expect.any(String) }),
+          metadata: expect.objectContaining({ chainId: expect.any(String) }),
+        }),
+      )
+
+      // buildTransaction called once per transaction descriptor
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(2)
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(
+        mockSendBatchUserOpRequest.chain,
+        mockSendBatchUserOpRequest.transactions[0].to,
+        mockSendBatchUserOpRequest.transactions[0].token,
+        mockSendBatchUserOpRequest.transactions[0].value,
+        expect.any(String),
+      )
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(
+        mockSendBatchUserOpRequest.chain,
+        mockSendBatchUserOpRequest.transactions[1].to,
+        mockSendBatchUserOpRequest.transactions[1].token,
+        mockSendBatchUserOpRequest.transactions[1].value,
+        expect.any(String),
+      )
+
+      // buildBatchedUserOp called with ERC-20 call shape (no value field) and the shared traceId
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledTimes(1)
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledWith(
+        {
+          chain: mockSendBatchUserOpRequest.chain,
+          calls: [
+            {
+              to: mockBuiltEip155Transaction.transaction.to,
+              data: mockBuiltEip155Transaction.transaction.data,
+            },
+            {
+              to: mockBuiltEip155Transaction.transaction.to,
+              data: mockBuiltEip155Transaction.transaction.data,
+            },
+          ],
+        },
+        expect.any(String),
+      )
+
+      // rawSign called with SECP256K1 and the userOpHash with 0x prefix stripped
+      expect(portal.mpc.rawSign).toHaveBeenCalledTimes(1)
+      expect(portal.mpc.rawSign).toHaveBeenCalledWith(
+        PortalCurve.SECP256K1,
+        mockBuildBatchedUserOpResponse.data.userOpHash.slice(2),
+        { signatureApprovalMemo: undefined, traceId: expect.any(String) },
+      )
+
+      // broadcastBatchedUserOp called with the built userOperation and signature, and the shared traceId
+      expect(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp,
+      ).toHaveBeenCalledTimes(1)
+      expect(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp,
+      ).toHaveBeenCalledWith(
+        {
+          chain: mockSendBatchUserOpRequest.chain,
+          userOperation: mockBuildBatchedUserOpResponse.data.userOperation,
+          signature: mockSignedHash,
+        },
+        expect.any(String),
+      )
+    })
+
+    it('should propagate the same traceId to buildBatchedUserOp and broadcastBatchedUserOp', async () => {
+      await portal.sendBatchUserOp(mockSendBatchUserOpRequest)
+
+      const buildTraceId = (
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mock.calls[0][1]
+      const broadcastTraceId = (
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp as jest.Mock
+      ).mock.calls[0][1]
+
+      expect(typeof buildTraceId).toBe('string')
+      expect(buildTraceId).toEqual(broadcastTraceId)
+    })
+
+    it('should include value in the call for native ETH transfers', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock).mockResolvedValueOnce(
+        mockBuiltEip155TransactionNative,
+      )
+
+      await portal.sendBatchUserOp({
+        chain: 'eip155:1',
+        transactions: [{ token: 'ETH', value: '0.1', to: '0x1111111111111111111111111111111111111111' }],
+      })
+
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledWith(
+        {
+          chain: 'eip155:1',
+          calls: [
+            {
+              to: mockBuiltEip155TransactionNative.transaction.to,
+              data: '0x',
+              value: mockBuiltEip155TransactionNative.metadata.rawAmount,
+            },
+          ],
+        },
+        expect.any(String),
+      )
+    })
+
+    it('should not include value in the call for ERC-20 transfers', async () => {
+      await portal.sendBatchUserOp({
+        chain: 'eip155:1',
+        transactions: [{ token: 'USDC', value: '1.0', to: '0x1111111111111111111111111111111111111111' }],
+      })
+
+      const calls = (
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mock.calls[0][0].calls
+
+      expect(calls[0]).not.toHaveProperty('value')
+    })
+
+    it('should forward signatureApprovalMemo to rawSign', async () => {
+      await portal.sendBatchUserOp({
+        ...mockSendBatchUserOpRequest,
+        signatureApprovalMemo: 'approve this batch',
+      })
+
+      expect(portal.mpc.rawSign).toHaveBeenCalledWith(
+        PortalCurve.SECP256K1,
+        expect.any(String),
+        { signatureApprovalMemo: 'approve this batch', traceId: expect.any(String) },
+      )
+    })
+
+    it('should throw if chain is not eip155', async () => {
+      await expect(
+        portal.sendBatchUserOp({
+          ...mockSendBatchUserOpRequest,
+          chain: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] UserOperations are only supported on EIP-155 (EVM) chains',
+      )
+    })
+
+    it('should throw if transactions array is empty', async () => {
+      await expect(
+        portal.sendBatchUserOp({
+          ...mockSendBatchUserOpRequest,
+          transactions: [],
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] transactions must contain at least one transaction',
+      )
+    })
+
+    it('should throw with index context if buildTransaction fails for transaction 0', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock).mockRejectedValueOnce(
+        new Error('Network error'),
+      )
+
+      await expect(
+        portal.sendBatchUserOp({
+          chain: 'eip155:1',
+          transactions: [{ token: 'USDC', value: '1.0', to: '0x1111111111111111111111111111111111111111' }],
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] Failed to build call for transaction at index 0: Network error',
+      )
+    })
+
+    it('should throw with index context if buildTransaction fails for transaction 1', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock)
+        .mockResolvedValueOnce(mockBuiltEip155Transaction)
+        .mockRejectedValueOnce(new Error('Network error'))
+
+      await expect(
+        portal.sendBatchUserOp(mockSendBatchUserOpRequest),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] Failed to build call for transaction at index 1: Network error',
+      )
+    })
+
+    it('should throw if buildBatchedUserOp fails', async () => {
+      ;(
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mockRejectedValueOnce(new Error('UserOp build failed'))
+
+      await expect(
+        portal.sendBatchUserOp(mockSendBatchUserOpRequest),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] Failed to build UserOperation: UserOp build failed',
+      )
+    })
+
+    it('should throw if rawSign fails', async () => {
+      ;(portal.mpc.rawSign as jest.Mock).mockRejectedValueOnce(
+        new Error('Signing failed'),
+      )
+
+      await expect(
+        portal.sendBatchUserOp(mockSendBatchUserOpRequest),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] Failed to sign userOpHash: Signing failed',
+      )
+    })
+
+    it('should throw if broadcastBatchedUserOp fails', async () => {
+      ;(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp as jest.Mock
+      ).mockRejectedValueOnce(new Error('Broadcast failed'))
+
+      await expect(
+        portal.sendBatchUserOp(mockSendBatchUserOpRequest),
+      ).rejects.toThrow(
+        '[Portal.sendBatchUserOp] Failed to broadcast UserOperation: Broadcast failed',
+      )
+    })
+  })
+
+  describe('sendBatchedAssets', () => {
+    const feeRecipient = '0x2222222222222222222222222222222222222222'
+    const baseRequest = {
+      chain: 'eip155:1',
+      transactions: [
+        {
+          token: 'USDC',
+          value: '1.0',
+          to: '0x1111111111111111111111111111111111111111',
+        },
+      ],
+    }
+
+    it('should build twice, convert gas to a fee, sign, and broadcast', async () => {
+      const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.5')
+
+      const result = await portal.sendBatchedAssets({
+        ...baseRequest,
+        gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount },
+      })
+
+      expect(result).toEqual(mockBroadcastBatchedUserOpResponse)
+
+      // Estimation pass + final pass = 2 builds.
+      expect(
+        portal.mpc.accountAbstractionBuildBatchedUserOp,
+      ).toHaveBeenCalledTimes(2)
+
+      // buildTransaction: 1 user tx + 1 placeholder fee + 1 real fee = 3.
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(3)
+
+      // Conversion called once with gasCostWei = totalGas(100000) * maxFeePerGas(1e9).
+      expect(convertGasToFeeAmount).toHaveBeenCalledTimes(1)
+      expect(convertGasToFeeAmount).toHaveBeenCalledWith(BigInt('100000000000000'))
+
+      // Placeholder fee call built with the default '0.01'; real fee call with '0.5'.
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(
+        'eip155:1',
+        feeRecipient,
+        'USDC',
+        '0.01',
+        expect.any(String),
+      )
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(
+        'eip155:1',
+        feeRecipient,
+        'USDC',
+        '0.5',
+        expect.any(String),
+      )
+
+      expect(portal.mpc.rawSign).toHaveBeenCalledTimes(1)
+      expect(
+        portal.mpc.accountAbstractionBroadcastBatchedUserOp,
+      ).toHaveBeenCalledTimes(1)
+    })
+
+    it('should apply bufferBps to the gas cost before conversion', async () => {
+      const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.6')
+
+      await portal.sendBatchedAssets({
+        ...baseRequest,
+        gasReimbursement: {
+          feeToken: 'USDC',
+          feeRecipient,
+          convertGasToFeeAmount,
+          bufferBps: 1000, // +10%
+        },
+      })
+
+      // 1e14 * 11000 / 10000 = 1.1e14
+      expect(convertGasToFeeAmount).toHaveBeenCalledWith(BigInt('110000000000000'))
+    })
+
+    it('should throw if the build response is missing estimatedGasCostWei', async () => {
+      const noGasCost = {
+        ...mockBuildBatchedUserOpResponse,
+        metadata: { chainId: 'eip155:1' },
+      }
+      ;(
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mockResolvedValueOnce(noGasCost)
+      const convertGasToFeeAmount = jest.fn()
+
+      await expect(
+        portal.sendBatchedAssets({
+          ...baseRequest,
+          gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] build response is missing metadata.estimatedGasCostWei',
+      )
+      // Conversion should never run if we can't determine the gas cost.
+      expect(convertGasToFeeAmount).not.toHaveBeenCalled()
+    })
+
+    it('should throw if the estimated gas cost is 0 (e.g. Ultra Relay zero-fee path)', async () => {
+      const zeroCost = {
+        ...mockBuildBatchedUserOpResponse,
+        metadata: {
+          chainId: 'eip155:1',
+          totalGas: '2000000',
+          maxFeePerGas: '0',
+          estimatedGasCostWei: '0',
+        },
+      }
+      ;(
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mockResolvedValueOnce(zeroCost)
+      const convertGasToFeeAmount = jest.fn()
+
+      await expect(
+        portal.sendBatchedAssets({
+          ...baseRequest,
+          gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] Estimated gas cost is 0',
+      )
+      expect(convertGasToFeeAmount).not.toHaveBeenCalled()
+    })
+
+    it('should reuse the same traceId across both builds', async () => {
+      const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.5')
+
+      await portal.sendBatchedAssets({
+        ...baseRequest,
+        gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount },
+      })
+
+      const calls = (
+        portal.mpc.accountAbstractionBuildBatchedUserOp as jest.Mock
+      ).mock.calls
+      expect(typeof calls[0][1]).toBe('string')
+      expect(calls[0][1]).toEqual(calls[1][1])
+    })
+
+    it('should throw if chain is not eip155', async () => {
+      await expect(
+        portal.sendBatchedAssets({
+          chain: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+          transactions: baseRequest.transactions,
+          gasReimbursement: {
+            feeToken: 'USDC',
+            feeRecipient,
+            convertGasToFeeAmount: () => '1',
+          },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] UserOperations are only supported on EIP-155 (EVM) chains',
+      )
+    })
+
+    it('should throw if transactions is empty', async () => {
+      await expect(
+        portal.sendBatchedAssets({
+          chain: 'eip155:1',
+          transactions: [],
+          gasReimbursement: {
+            feeToken: 'USDC',
+            feeRecipient,
+            convertGasToFeeAmount: () => '1',
+          },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] transactions must contain at least one transaction',
+      )
+    })
+
+    it('should throw if convertGasToFeeAmount is missing', async () => {
+      await expect(
+        portal.sendBatchedAssets({
+          ...baseRequest,
+          gasReimbursement: { feeToken: 'USDC', feeRecipient } as never,
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] gasReimbursement.convertGasToFeeAmount (a function) is required',
+      )
+    })
+
+    it('should throw if feeRecipient is not a valid EVM address', async () => {
+      await expect(
+        portal.sendBatchedAssets({
+          ...baseRequest,
+          gasReimbursement: {
+            feeToken: 'USDC',
+            feeRecipient: '0xnope',
+            convertGasToFeeAmount: () => '1',
+          },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] Invalid gasReimbursement.feeRecipient',
+      )
+    })
+
+    it('should surface an error thrown by the conversion callback', async () => {
+      const convertGasToFeeAmount = jest
+        .fn()
+        .mockRejectedValue(new Error('rate unavailable'))
+
+      await expect(
+        portal.sendBatchedAssets({
+          ...baseRequest,
+          gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount },
+        }),
+      ).rejects.toThrow(
+        '[Portal.sendBatchedAssets] gasReimbursement.convertGasToFeeAmount threw: rate unavailable',
+      )
+    })
+  })
+
   describe('storedClientBackupShare', () => {
     it('should correctly call mpc.storedClientBackupShare', async () => {
       await portal.storedClientBackupShare(true, BackupMethods.password)