@portal-hq/web 3.13.2 → 3.14.0-alpha.0

package/src/integrations/delegations/index.test.ts

@@ -119,4 +119,255 @@ describe('Delegations', () => {
       ).rejects.toThrow('Test error')
     })
   })
+
+  describe('approveAndSubmit, revokeAndSubmit, transferAndSubmit', () => {
+    const mockSignAndSend = jest.fn()
+
+    beforeEach(() => {
+      mockSignAndSend.mockResolvedValue('0xtxhash')
+    })
+
+    it('throws when signAndSendTransaction is not configured', async () => {
+      const d = new Delegations({ mpc })
+
+      await expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow(
+        '[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.',
+      )
+      await expect(d.revokeAndSubmit(mockEVMRevokeRequest)).rejects.toThrow(
+        '[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.',
+      )
+      await expect(d.transferAndSubmit(mockTransferFromRequest)).rejects.toThrow(
+        '[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.',
+      )
+    })
+
+    it('approveAndSubmit calls MPC then signAndSend per transaction', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse)
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      const result = await d.approveAndSubmit(mockEVMApproveRequest)
+
+      expect(mpc.delegationsApprove).toHaveBeenCalledWith(mockEVMApproveRequest)
+      expect(mockSignAndSend).toHaveBeenCalledTimes(1)
+      expect(mockSignAndSend).toHaveBeenCalledWith(
+        mockEVMApproveResponse.transactions![0],
+        mockEVMApproveRequest.chain,
+      )
+      expect(result).toEqual({ hashes: ['0xtxhash'] })
+    })
+
+    it('revokeAndSubmit calls delegationsRevoke then signAndSend per transaction', async () => {
+      jest.spyOn(mpc, 'delegationsRevoke').mockResolvedValue(mockEVMRevokeResponse)
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      const result = await d.revokeAndSubmit(mockEVMRevokeRequest)
+
+      expect(mpc.delegationsRevoke).toHaveBeenCalledWith(mockEVMRevokeRequest)
+      expect(mockSignAndSend).toHaveBeenCalledTimes(1)
+      expect(mockSignAndSend).toHaveBeenCalledWith(
+        mockEVMRevokeResponse.transactions![0],
+        mockEVMRevokeRequest.chain,
+      )
+      expect(result).toEqual({ hashes: ['0xtxhash'] })
+    })
+
+    it('transferAndSubmit calls delegationsTransferFrom then signAndSend per transaction', async () => {
+      jest
+        .spyOn(mpc, 'delegationsTransferFrom')
+        .mockResolvedValue(mockTransferFromResponse)
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      const result = await d.transferAndSubmit(mockTransferFromRequest)
+
+      expect(mpc.delegationsTransferFrom).toHaveBeenCalledWith(
+        mockTransferFromRequest,
+      )
+      expect(mockSignAndSend).toHaveBeenCalledTimes(1)
+      expect(mockSignAndSend).toHaveBeenCalledWith(
+        mockTransferFromResponse.transactions![0],
+        mockTransferFromRequest.chain,
+      )
+      expect(result).toEqual({ hashes: ['0xtxhash'] })
+    })
+
+    it('uses encodedTransactions when transactions is empty', async () => {
+      const response = {
+        transactions: [],
+        encodedTransactions: ['solTxPayload'],
+        metadata: mockEVMApproveResponse.metadata,
+      }
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(response)
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      await d.approveAndSubmit(mockEVMApproveRequest)
+
+      expect(mockSignAndSend).toHaveBeenCalledWith(
+        'solTxPayload',
+        mockEVMApproveRequest.chain,
+      )
+    })
+
+    it('invokes onProgress for each transaction', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse)
+      const onProgress = jest.fn()
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      await d.approveAndSubmit(mockEVMApproveRequest, { onProgress })
+
+      expect(onProgress).toHaveBeenCalledTimes(2)
+      expect(onProgress).toHaveBeenNthCalledWith(1, {
+        step: 'signing',
+        index: 0,
+        total: 1,
+      })
+      expect(onProgress).toHaveBeenNthCalledWith(2, {
+        step: 'submitted',
+        index: 0,
+        total: 1,
+        hash: '0xtxhash',
+      })
+    })
+
+    it('throws when response has no transactions', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+        metadata: mockEVMApproveResponse.metadata,
+      })
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      await expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow(
+        'No transactions in delegation response.',
+      )
+      expect(mockSignAndSend).not.toHaveBeenCalled()
+    })
+
+    it('submits multiple EVM transactions in order', async () => {
+      const txA = { ...(
+        mockEVMApproveResponse.transactions as NonNullable<
+          typeof mockEVMApproveResponse.transactions
+        >
+      )[0]! }
+      const txB = { ...txA, data: '0xbbbb' }
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+        ...mockEVMApproveResponse,
+        transactions: [txA, txB],
+      })
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+      mockSignAndSend.mockResolvedValueOnce('0xh1').mockResolvedValueOnce('0xh2')
+
+      const result = await d.approveAndSubmit(mockEVMApproveRequest)
+
+      expect(mockSignAndSend).toHaveBeenCalledTimes(2)
+      expect(mockSignAndSend).toHaveBeenNthCalledWith(1, txA, mockEVMApproveRequest.chain)
+      expect(mockSignAndSend).toHaveBeenNthCalledWith(2, txB, mockEVMApproveRequest.chain)
+      expect(result.hashes).toEqual(['0xh1', '0xh2'])
+    })
+
+    it('propagates error after first tx succeeds (partial submit)', async () => {
+      const txA = { ...(
+        mockEVMApproveResponse.transactions as NonNullable<
+          typeof mockEVMApproveResponse.transactions
+        >
+      )[0]! }
+      const txB = { ...txA, data: '0xbbbb' }
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+        ...mockEVMApproveResponse,
+        transactions: [txA, txB],
+      })
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+      mockSignAndSend
+        .mockResolvedValueOnce('0xh1')
+        .mockRejectedValueOnce(new Error('second tx failed'))
+
+      await expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow(
+        'second tx failed',
+      )
+      expect(mockSignAndSend).toHaveBeenCalledTimes(2)
+    })
+
+    it('per-call signAndSendTransaction overrides constructor signer', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse)
+      const instanceSigner = jest.fn().mockResolvedValue('0xinstance')
+      const perCallSigner = jest.fn().mockResolvedValue('0xpercall')
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: instanceSigner,
+      })
+
+      await d.approveAndSubmit(mockEVMApproveRequest, {
+        signAndSendTransaction: perCallSigner,
+      })
+
+      expect(instanceSigner).not.toHaveBeenCalled()
+      expect(perCallSigner).toHaveBeenCalledTimes(1)
+    })
+
+    it('throws on whitespace-only hash from signer', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse)
+      mockSignAndSend.mockResolvedValue('   ')
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      await expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow(
+        'Invalid transaction hash',
+      )
+    })
+
+    it('prefers transactions over encodedTransactions when both non-empty', async () => {
+      const evmTx = mockEVMApproveResponse.transactions![0]!
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+        transactions: [evmTx],
+        encodedTransactions: ['should-not-use'],
+        metadata: mockEVMApproveResponse.metadata,
+      })
+      const d = new Delegations({
+        mpc,
+        signAndSendTransaction: mockSignAndSend,
+      })
+
+      await d.approveAndSubmit(mockEVMApproveRequest)
+
+      expect(mockSignAndSend).toHaveBeenCalledWith(
+        evmTx,
+        mockEVMApproveRequest.chain,
+      )
+    })
+
+    it('setSignAndSendTransaction enables submit after construction', async () => {
+      jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse)
+      const d = new Delegations({ mpc })
+      const late = jest.fn().mockResolvedValue('0xlate')
+      d.setSignAndSendTransaction(late)
+
+      const result = await d.approveAndSubmit(mockEVMApproveRequest)
+
+      expect(late).toHaveBeenCalledTimes(1)
+      expect(result).toEqual({ hashes: ['0xlate'] })
+    })
+  })
 })

package/src/integrations/delegations/index.ts

@@ -8,6 +8,7 @@ import type {
   DelegationStatusResponse,
   TransferFromRequest,
   TransferFromResponse,
+  DelegationSubmitProgress,
 } from '../../shared/types'
 
 export interface IPortalDelegationsApi {
@@ -19,13 +20,68 @@ export interface IPortalDelegationsApi {
   transferFrom(params: TransferFromRequest): Promise<TransferFromResponse>
 }
 
-export type IDelegations = IPortalDelegationsApi
+const DELEGATIONS_SUBMIT_CONFIG_ERROR =
+  '[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.'
+
+/** Optional callback for sign-and-submit flows. Invoked once per transaction. */
+export interface DelegationSubmitOptions {
+  signAndSendTransaction?: (
+    transaction: unknown,
+    chainId: string,
+  ) => Promise<string>
+  onProgress?: (event: DelegationSubmitProgress) => void
+}
+
+/**
+ * Full delegations surface exposed on {@link Portal.delegations}, including sign-and-submit helpers.
+ */
+export interface IDelegations extends IPortalDelegationsApi {
+  /** Sets the default signer used by approveAndSubmit, revokeAndSubmit, and transferAndSubmit when options omit signAndSendTransaction. */
+  setSignAndSendTransaction(
+    fn: (transaction: unknown, chainId: string) => Promise<string>,
+  ): void
+  approveAndSubmit(
+    params: ApproveDelegationRequest,
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }>
+  revokeAndSubmit(
+    params: RevokeDelegationRequest,
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }>
+  transferAndSubmit(
+    params: TransferFromRequest,
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }>
+}
+
+export interface DelegationsOptions {
+  mpc: Mpc
+  /**
+   * When set, enables {@link Delegations.approveAndSubmit}, {@link Delegations.revokeAndSubmit},
+   * and {@link Delegations.transferAndSubmit}. `Portal` passes this by default using the iframe provider.
+   */
+  signAndSendTransaction?: (
+    transaction: unknown,
+    chainId: string,
+  ) => Promise<string>
+}
 
 export default class Delegations implements IDelegations {
-  private mpc: Mpc
+  private readonly mpc: Mpc
+  private signAndSendTransaction?: (
+    transaction: unknown,
+    chainId: string,
+  ) => Promise<string>
 
-  constructor({ mpc }: { mpc: Mpc }) {
-    this.mpc = mpc
+  constructor(options: DelegationsOptions) {
+    this.mpc = options.mpc
+    this.signAndSendTransaction = options.signAndSendTransaction
+  }
+
+  public setSignAndSendTransaction(
+    fn: (transaction: unknown, chainId: string) => Promise<string>,
+  ): void {
+    this.signAndSendTransaction = fn
   }
 
   /**
@@ -75,4 +131,146 @@ export default class Delegations implements IDelegations {
   ): Promise<TransferFromResponse> {
     return this.mpc?.delegationsTransferFrom(params)
   }
+
+  /**
+   * Approves a delegation, then signs and broadcasts each returned transaction via
+   * {@link DelegationsOptions.signAndSendTransaction}.
+   *
+   * Requires `signAndSendTransaction` (provided by default on `Portal.delegations`).
+   * Confirming transactions on-chain remains the application's responsibility.
+   *
+   * @param params - Same as {@link Delegations.approve}
+   * @param options - Optional progress callbacks
+   * @returns Transaction hashes in submission order
+   */
+  public async approveAndSubmit(
+    params: Parameters<IPortalDelegationsApi['approve']>[0],
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }> {
+    const signAndSend =
+      options?.signAndSendTransaction ?? this.signAndSendTransaction
+    if (!signAndSend) {
+      throw new Error(DELEGATIONS_SUBMIT_CONFIG_ERROR)
+    }
+    const response = await this.approve(params)
+    return this.executeAndTrack(
+      response,
+      params.chain,
+      signAndSend,
+      options?.onProgress,
+    )
+  }
+
+  /**
+   * Revokes a delegation, then signs and broadcasts each returned transaction.
+   *
+   * Requires `signAndSendTransaction` (provided by default on `Portal.delegations`).
+   *
+   * @param params - Same as {@link Delegations.revoke}
+   * @param options - Optional progress callbacks
+   * @returns Transaction hashes in submission order
+   */
+  public async revokeAndSubmit(
+    params: Parameters<IPortalDelegationsApi['revoke']>[0],
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }> {
+    const signAndSend =
+      options?.signAndSendTransaction ?? this.signAndSendTransaction
+    if (!signAndSend) {
+      throw new Error(DELEGATIONS_SUBMIT_CONFIG_ERROR)
+    }
+    const response = await this.revoke(params)
+    return this.executeAndTrack(
+      response,
+      params.chain,
+      signAndSend,
+      options?.onProgress,
+    )
+  }
+
+  /**
+   * Executes a delegated transfer, then signs and broadcasts each returned transaction.
+   *
+   * Requires `signAndSendTransaction` (provided by default on `Portal.delegations`).
+   *
+   * @param params - Same as {@link Delegations.transferFrom}
+   * @param options - Optional progress callbacks
+   * @returns Transaction hashes in submission order
+   */
+  public async transferAndSubmit(
+    params: Parameters<IPortalDelegationsApi['transferFrom']>[0],
+    options?: DelegationSubmitOptions,
+  ): Promise<{ hashes: string[] }> {
+    const signAndSend =
+      options?.signAndSendTransaction ?? this.signAndSendTransaction
+    if (!signAndSend) {
+      throw new Error(DELEGATIONS_SUBMIT_CONFIG_ERROR)
+    }
+    const response = await this.transferFrom(params)
+    return this.executeAndTrack(
+      response,
+      params.chain,
+      signAndSend,
+      options?.onProgress,
+    )
+  }
+
+  private normalizeToTransactionList(
+    response:
+      | ApproveDelegationResponse
+      | RevokeDelegationResponse
+      | TransferFromResponse,
+  ): unknown[] {
+    const transactions = Array.isArray(response.transactions)
+      ? response.transactions
+      : []
+    const encodedTransactions = Array.isArray(response.encodedTransactions)
+      ? response.encodedTransactions
+      : []
+    if (transactions.length > 0) {
+      return transactions
+    }
+    if (encodedTransactions.length > 0) {
+      return encodedTransactions
+    }
+    return []
+  }
+
+  private async executeAndTrack(
+    response:
+      | ApproveDelegationResponse
+      | RevokeDelegationResponse
+      | TransferFromResponse,
+    chainId: string,
+    signAndSend: (transaction: unknown, chainId: string) => Promise<string>,
+    onProgress?: (event: DelegationSubmitProgress) => void,
+  ): Promise<{ hashes: string[] }> {
+    const transactions = this.normalizeToTransactionList(response)
+    if (transactions.length === 0) {
+      throw new Error('No transactions in delegation response.')
+    }
+    const total = transactions.length
+    const hashes: string[] = []
+    for (let index = 0; index < transactions.length; index++) {
+      const tx = transactions[index]
+      
+      // Validate transaction exists (defensive check for sparse arrays)
+      if (!tx) {
+        throw new Error(
+          `Transaction at index ${index} is undefined or null. This indicates a malformed API response.`,
+        )
+      }
+      
+      onProgress?.({ step: 'signing', index, total })
+      const hash = await signAndSend(tx, chainId)
+      if (typeof hash !== 'string' || hash.trim().length === 0) {
+        throw new Error(
+          `Invalid transaction hash returned from signAndSendTransaction at index ${index} for chain ${chainId}.`,
+        )
+      }
+      hashes.push(hash)
+      onProgress?.({ step: 'submitted', index, total, hash })
+    }
+    return { hashes }
+  }
 }

package/src/integrations/ramps/noah/index.test.ts

@@ -63,7 +63,15 @@ describe('Noah', () => {
       destinationAddress: 'SoLAddr1111111111111111111111111111111111111',
     }
     const spy = jest.spyOn(mpc, 'initiatePayin').mockResolvedValue({
-      data: { payinId: 'p1', bankDetails: {} },
+      data: {
+        payinId: 'p1',
+        bankDetails: {
+          paymentMethodId: 'pm-123',
+          paymentMethodType: 'bank_account',
+          accountNumber: '1234567890',
+          network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+        },
+      },
     })
     await noah.initiatePayin(req)
     expect(spy).toHaveBeenCalledWith(req)
@@ -76,7 +84,7 @@ describe('Noah', () => {
       fiatCurrency: 'USD',
     }
     const spy = jest.spyOn(mpc, 'simulatePayin').mockResolvedValue({
-      data: {},
+      data: { fiatDepositId: 'deposit-123' },
     })
     await noah.simulatePayin(sim)
     expect(spy).toHaveBeenCalledWith(sim)
@@ -84,7 +92,7 @@ describe('Noah', () => {
 
   it('should call mpc.getPayoutCountries', async () => {
     const spy = jest.spyOn(mpc, 'getPayoutCountries').mockResolvedValue({
-      data: { countries: [] },
+      data: { countries: { US: ['USD'], MX: ['MXN', 'USD'] } },
     })
     await noah.getPayoutCountries()
     expect(spy).toHaveBeenCalled()
@@ -98,7 +106,7 @@ describe('Noah', () => {
       fiatAmount: '10',
     }
     const spy = jest.spyOn(mpc, 'getPayoutChannels').mockResolvedValue({
-      data: [],
+      data: { items: [] },
     } as never)
     await noah.getPayoutChannels(req)
     expect(spy).toHaveBeenCalledWith(req)
@@ -107,7 +115,12 @@ describe('Noah', () => {
   it('should call mpc.getPayoutChannelForm', async () => {
     const spy = jest
       .spyOn(mpc, 'getPayoutChannelForm')
-      .mockResolvedValue({ data: {} } as never)
+      .mockResolvedValue({
+        data: {
+          formSchema: { type: 'object', properties: {} },
+          formMetadata: { contentHash: 'abc123' },
+        },
+      } as never)
     await noah.getPayoutChannelForm('ch-1')
     expect(spy).toHaveBeenCalledWith('ch-1')
   })

package/src/integrations/trading/index.ts

@@ -1,17 +1,20 @@
 import Mpc from '../../mpc'
-import ZeroX from './zero-x'
-import LiFi from './lifi'
+import ZeroX, { type IZeroX, type ZeroXOptions } from './zero-x'
+import LiFi, { type ILiFi, type LifiOptions } from './lifi'
+
+export type TradingOptions = LifiOptions & ZeroXOptions
+
+export type { LifiOptions, ILiFi, ZeroXOptions, IZeroX }
 
 /**
- * This class is a container for the LiFi class.
- * In the future, Trading domain logic should be here.
+ * Trading integrations (LiFi, 0x).
  */
 export default class Trading {
   public lifi: LiFi
   public zeroX: ZeroX
 
-  constructor({ mpc }: { mpc: Mpc }) {
-    this.lifi = new LiFi({ mpc })
-    this.zeroX = new ZeroX({ mpc })
+  constructor({ mpc, ...defaults }: { mpc: Mpc } & TradingOptions) {
+    this.lifi = new LiFi({ mpc, ...defaults })
+    this.zeroX = new ZeroX({ mpc, ...defaults })
   }
 }