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

package/src/integrations/trading/zero-x/index.test.ts

@@ -5,7 +5,9 @@
 import ZeroX from '.'
 import Mpc from '../../../mpc'
 import portalMock from '../../../__mocks/portal/portal'
+import * as waitEvm from '../../../internal/waitForEvmTxConfirmation'
 import {
+  mockEip155Address,
   mockHost,
   mockSourcesRes,
   mockZeroExQuoteV2Request,
@@ -82,7 +84,6 @@ describe('ZeroX', () => {
         zeroXApiKey: 'test-api-key',
       })
 
-      console.log(`Result:`, result)
       expect(spy).toHaveBeenCalledTimes(1)
       expect(spy).toHaveBeenCalledWith(
         { chainId: 'eip155:1' },
@@ -151,4 +152,299 @@ describe('ZeroX', () => {
       )
     })
   })
+
+  describe('tradeAsset', () => {
+    it('throws when waitForConfirmation returns false and emits failed, not confirmed', async () => {
+      const onProgress = jest.fn()
+      jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+            onProgress,
+          },
+          {
+            signAndSendTransaction: async () => '0xabc',
+            waitForConfirmation: async () => false,
+          },
+        ),
+      ).rejects.toThrow(/on-chain confirmation/)
+
+      const statuses = onProgress.mock.calls.map((c) => c[0])
+      expect(statuses).toContain('failed')
+      expect(statuses).not.toContain('confirmed')
+    })
+
+    it('emits confirmed after waitForConfirmation succeeds', async () => {
+      const onProgress = jest.fn()
+      jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await zeroX.tradeAsset(
+        {
+          ...mockZeroExQuoteV2Request,
+          fromAddress: mockEip155Address,
+          onProgress,
+        },
+        {
+          signAndSendTransaction: async () => '0xabc',
+          waitForConfirmation: async () => true,
+        },
+      )
+
+      expect(onProgress).toHaveBeenCalledWith('confirmed', { txHash: '0xabc' })
+    })
+
+    it('throws before signing when quote has error string', async () => {
+      jest.spyOn(mpc, 'getSwapsQuoteV2').mockResolvedValue({
+        error: 'insufficient liquidity',
+      } as never)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+          },
+          {
+            signAndSendTransaction: async () => '0x',
+            waitForConfirmation: async () => true,
+          },
+        ),
+      ).rejects.toThrow(/Quote error: insufficient liquidity/)
+    })
+
+    it('throws before signing when neither waitForConfirmation nor evmRequestFn', async () => {
+      const quoteSpy = jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+          },
+          {
+            signAndSendTransaction: async () => '0xshouldnotrun',
+          },
+        ),
+      ).rejects.toThrow(/requires waitForConfirmation.*or evmRequestFn/)
+
+      expect(quoteSpy).not.toHaveBeenCalled()
+    })
+
+    it('throws before signing when rawResponse is missing', async () => {
+      jest.spyOn(mpc, 'getSwapsQuoteV2').mockResolvedValue({
+        data: {},
+      } as never)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+          },
+          {
+            signAndSendTransaction: async () => '0x',
+            waitForConfirmation: async () => true,
+          },
+        ),
+      ).rejects.toThrow(/missing data.rawResponse/)
+    })
+
+    it('throws before signing when transaction.to is invalid', async () => {
+      jest.spyOn(mpc, 'getSwapsQuoteV2').mockResolvedValue({
+        data: {
+          rawResponse: {
+            ...mockZeroExQuoteV2Response.data!.rawResponse,
+            transaction: { to: '' },
+          },
+        },
+      } as never)
+
+      const onProgress = jest.fn()
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+            onProgress,
+          },
+          {
+            signAndSendTransaction: async () => '0x',
+            waitForConfirmation: async () => true,
+          },
+        ),
+      ).rejects.toThrow(/missing valid transaction/)
+
+      expect(onProgress).toHaveBeenCalledWith(
+        'failed',
+        expect.objectContaining({
+          errorMessage: expect.stringContaining('valid transaction'),
+        }),
+      )
+    })
+
+    it('signer throws: rethrows and emits failed', async () => {
+      const onProgress = jest.fn()
+      jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+            onProgress,
+          },
+          {
+            signAndSendTransaction: async () => {
+              throw new Error('user rejected')
+            },
+            waitForConfirmation: async () => true,
+          },
+        ),
+      ).rejects.toThrow('user rejected')
+
+      expect(onProgress).toHaveBeenCalledWith(
+        'failed',
+        expect.objectContaining({ errorMessage: 'user rejected' }),
+      )
+    })
+
+    it('empty hash after sign: throws and emits failed', async () => {
+      const onProgress = jest.fn()
+      jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await expect(
+        zeroX.tradeAsset(
+          {
+            ...mockZeroExQuoteV2Request,
+            fromAddress: mockEip155Address,
+            onProgress,
+          },
+          {
+            signAndSendTransaction: async () => '  ',
+            waitForConfirmation: async () => true,
+          },
+        ),
+      ).rejects.toThrow(/empty or invalid transaction hash/)
+
+      expect(onProgress).toHaveBeenCalledWith(
+        'failed',
+        expect.objectContaining({ errorMessage: expect.any(String) }),
+      )
+    })
+
+    it('evmRequestFn path: waits for receipt with onTimeout throw', async () => {
+      const waitSpy = jest
+        .spyOn(waitEvm, 'waitForEvmTxConfirmation')
+        .mockResolvedValue(true)
+      jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await zeroX.tradeAsset(
+        {
+          ...mockZeroExQuoteV2Request,
+          fromAddress: mockEip155Address,
+        },
+        {
+          signAndSendTransaction: async () => '0xhash',
+          evmRequestFn: async () => ({}),
+        },
+      )
+
+      expect(waitSpy).toHaveBeenCalledWith(
+        '0xhash',
+        'eip155:1',
+        expect.any(Function),
+        expect.objectContaining({ onTimeout: 'throw' }),
+      )
+      waitSpy.mockRestore()
+    })
+
+    it('instance zeroXApiKey wins over params.zeroXApiKey when both set', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+      const z = new ZeroX({
+        mpc,
+        zeroXApiKey: 'from-instance',
+      })
+
+      await z.tradeAsset(
+        {
+          ...mockZeroExQuoteV2Request,
+          fromAddress: mockEip155Address,
+          zeroXApiKey: 'from-params',
+        },
+        {
+          signAndSendTransaction: async () => '0xh',
+          waitForConfirmation: async () => true,
+        },
+      )
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({ zeroXApiKey: 'from-instance' }),
+      )
+    })
+
+    it('uses params.zeroXApiKey when instance has no key', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getSwapsQuoteV2')
+        .mockResolvedValue(mockZeroExQuoteV2Response)
+
+      await zeroX.tradeAsset(
+        {
+          ...mockZeroExQuoteV2Request,
+          fromAddress: mockEip155Address,
+          zeroXApiKey: 'params-only',
+        },
+        {
+          signAndSendTransaction: async () => '0xh',
+          waitForConfirmation: async () => true,
+        },
+      )
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({ zeroXApiKey: 'params-only' }),
+      )
+    })
+
+    it('normalizes numeric chainId to eip155 for signer', async () => {
+      const sign = jest.fn().mockResolvedValue('0xh')
+      jest.spyOn(mpc, 'getSwapsQuoteV2').mockResolvedValue({
+        ...mockZeroExQuoteV2Response,
+      })
+
+      await zeroX.tradeAsset(
+        {
+          ...mockZeroExQuoteV2Request,
+          chainId: '1',
+          fromAddress: mockEip155Address,
+        },
+        {
+          signAndSendTransaction: sign,
+          waitForConfirmation: async () => true,
+        },
+      )
+
+      expect(sign).toHaveBeenCalledWith(
+        expect.anything(),
+        'eip155:1',
+      )
+    })
+  })
 })

package/src/integrations/trading/zero-x/index.ts

@@ -1,4 +1,6 @@
 import Mpc from '../../../mpc'
+import { waitForEvmTxConfirmation } from '../../../internal/waitForEvmTxConfirmation'
+import { normalizeChainToNetwork } from '../lifi'
 import {
   ZeroExOptions,
   ZeroExPriceRequest,
@@ -6,55 +8,207 @@ import {
   ZeroExQuoteRequest,
   ZeroExQuoteResponse,
   ZeroExSourcesResponse,
+  ZeroXTradeAssetOptions,
+  ZeroXTradeAssetParams,
+  ZeroXTradeAssetResult,
 } from '../../../shared/types/zero-x'
 
-export default class ZeroX {
+const LOG_PREFIX = '[ZeroX]'
+
+export interface ZeroXOptions extends ZeroXTradeAssetOptions {
+  zeroXApiKey?: string
+}
+
+export interface IZeroX {
+  getQuote(
+    args: ZeroExQuoteRequest,
+    options?: ZeroExOptions,
+  ): Promise<ZeroExQuoteResponse>
+  getSources(
+    chainId: string,
+    options?: ZeroExOptions,
+  ): Promise<ZeroExSourcesResponse>
+  getPrice(
+    args: ZeroExPriceRequest,
+    options?: ZeroExOptions,
+  ): Promise<ZeroExPriceResponse>
+  tradeAsset(
+    params: ZeroXTradeAssetParams,
+    options?: ZeroXTradeAssetOptions & ZeroExOptions,
+  ): Promise<ZeroXTradeAssetResult>
+}
+
+function mergeZeroXOptions(
+  instance: (ZeroXTradeAssetOptions & ZeroExOptions) | undefined,
+  perCall: (ZeroXTradeAssetOptions & ZeroExOptions) | undefined,
+): ZeroXTradeAssetOptions & ZeroExOptions {
+  return { ...instance, ...perCall }
+}
+
+export default class ZeroX implements IZeroX {
   private mpc: Mpc
+  private readonly defaults: ZeroXTradeAssetOptions & ZeroExOptions
 
-  constructor({ mpc }: { mpc: Mpc }) {
+  constructor({ mpc, ...defaults }: { mpc: Mpc } & ZeroXOptions) {
     this.mpc = mpc
+    this.defaults = defaults
   }
 
-  /**
-   * Get a quote from the Swaps API.
-   *
-   * @param apiKey - The API key for the Swaps API.
-   * @param args - The arguments for the quote.
-   * @param chainId - The chain ID for the quote.
-   * @returns The quote response.
-   */
   public async getQuote(
     args: ZeroExQuoteRequest,
     options?: ZeroExOptions,
   ): Promise<ZeroExQuoteResponse> {
-    return this.mpc?.getSwapsQuoteV2(args, options)
+    const merged = { ...this.defaults, ...options }
+    const key = merged.zeroXApiKey
+    return this.mpc?.getSwapsQuoteV2(
+      args,
+      key != null && key !== '' ? { zeroXApiKey: key } : undefined,
+    )
   }
 
-  /**
-   * Get the valid, swappable token sources that can be used with your Portal MPC Wallet.
-   *
-   * @param apiKey - The API key for the Swaps API.
-   * @param chainId - The chain ID for the sources.
-   * @returns The sources response.
-   */
   public async getSources(
     chainId: string,
     options?: ZeroExOptions,
   ): Promise<ZeroExSourcesResponse> {
-    return this.mpc?.getSwapsSourcesV2({ chainId }, options)
+    const merged = { ...this.defaults, ...options }
+    const key = merged.zeroXApiKey
+    return this.mpc?.getSwapsSourcesV2(
+      { chainId },
+      key != null && key !== '' ? { zeroXApiKey: key } : undefined,
+    )
   }
 
-  /**
-   * Get the price of a token from the Swaps API.
-   *
-   * @param args - The arguments for the price.
-   * @param options - The options for the price.
-   * @returns The price response.
-   */
   public async getPrice(
     args: ZeroExPriceRequest,
     options?: ZeroExOptions,
   ): Promise<ZeroExPriceResponse> {
-    return this.mpc?.getSwapsPrice(args, options)
+    const merged = { ...this.defaults, ...options }
+    const key = merged.zeroXApiKey
+    return this.mpc?.getSwapsPrice(
+      args,
+      key != null && key !== '' ? { zeroXApiKey: key } : undefined,
+    )
+  }
+
+  public async tradeAsset(
+    params: ZeroXTradeAssetParams,
+    options?: ZeroXTradeAssetOptions & ZeroExOptions,
+  ): Promise<ZeroXTradeAssetResult> {
+    const o = mergeZeroXOptions(this.defaults, options)
+    const signAndSend = o.signAndSendTransaction
+    if (!signAndSend) {
+      throw new Error(`${LOG_PREFIX} tradeAsset requires signAndSendTransaction`)
+    }
+
+    if (!o.waitForConfirmation && !o.evmRequestFn) {
+      throw new Error(
+        `${LOG_PREFIX} tradeAsset requires waitForConfirmation (instance default or per-call option), or evmRequestFn fallback.`,
+      )
+    }
+
+    const apiOpts = { zeroXApiKey: o.zeroXApiKey ?? params.zeroXApiKey }
+
+    params.onProgress?.('fetching_quote')
+
+    const quoteReq: ZeroExQuoteRequest = {
+      chainId: params.chainId,
+      buyToken: params.buyToken,
+      sellToken: params.sellToken,
+      sellAmount: params.sellAmount,
+      txOrigin: params.fromAddress,
+      swapFeeRecipient: params.swapFeeRecipient,
+      swapFeeBps: params.swapFeeBps,
+      swapFeeToken: params.swapFeeToken,
+      tradeSurplusRecipient: params.tradeSurplusRecipient,
+      gasPrice: params.gasPrice,
+      slippageBps: params.slippageBps,
+      excludedSources: params.excludedSources,
+      sellEntireBalance: params.sellEntireBalance,
+    }
+
+    const quote = await this.mpc.getSwapsQuoteV2(quoteReq, apiOpts)
+
+    const err = quote.error?.trim()
+    if (err) {
+      throw new Error(`${LOG_PREFIX} Quote error: ${err}`)
+    }
+
+    const raw = quote.data?.rawResponse
+    if (!raw) {
+      const msg = 'Quote response missing data.rawResponse'
+      params.onProgress?.('failed', { errorMessage: msg })
+      throw new Error(`${LOG_PREFIX} ${msg}`)
+    }
+
+    const transaction = raw.transaction
+    const to =
+      transaction !== null &&
+      transaction !== undefined &&
+      typeof transaction === 'object' &&
+      'to' in transaction
+        ? (transaction as { to?: unknown }).to
+        : undefined
+
+    if (
+      typeof to !== 'string' ||
+      to.trim() === '' ||
+      transaction === null ||
+      transaction === undefined ||
+      typeof transaction !== 'object'
+    ) {
+      const msg =
+        'Quote response missing valid transaction (expected object with non-empty string "to")'
+      params.onProgress?.('failed', { errorMessage: msg })
+      throw new Error(`${LOG_PREFIX} ${msg}`)
+    }
+
+    const tx = transaction
+
+    const network = normalizeChainToNetwork(params.chainId)
+
+    params.onProgress?.('signing', {
+      buyAmount: quote.data?.rawResponse?.buyAmount,
+      sellAmount: quote.data?.rawResponse?.sellAmount,
+      transaction: tx,
+    })
+
+    let txHash: string
+    try {
+      txHash = await signAndSend(tx, network)
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      params.onProgress?.('failed', { errorMessage: msg })
+      throw e
+    }
+
+    if (typeof txHash !== 'string' || txHash.trim() === '') {
+      const msg = 'signAndSendTransaction returned empty or invalid transaction hash'
+      params.onProgress?.('failed', { errorMessage: msg })
+      throw new Error(`${LOG_PREFIX} ${msg}`)
+    }
+
+    params.onProgress?.('submitted', { txHash })
+
+    if (o.waitForConfirmation) {
+      params.onProgress?.('confirming', { txHash })
+      const waiterResult = await o.waitForConfirmation(txHash, network)
+      const ok = waiterResult === true
+      if (!ok) {
+        const msg = `${LOG_PREFIX} on-chain confirmation did not complete (waitForConfirmation did not return true) for ${txHash} on ${network}`
+        params.onProgress?.('failed', { errorMessage: msg, txHash })
+        throw new Error(msg)
+      }
+      params.onProgress?.('confirmed', { txHash })
+    } else if (o.evmRequestFn) {
+      params.onProgress?.('confirming', { txHash })
+      await waitForEvmTxConfirmation(txHash, network, o.evmRequestFn, {
+        pollIntervalMs: o.evmPollerOptions?.pollIntervalMs,
+        timeoutMs: o.evmPollerOptions?.timeoutMs,
+        onTimeout: 'throw',
+      })
+      params.onProgress?.('confirmed', { txHash })
+    }
+
+    return { hashes: [txHash] }
   }
 }

package/src/integrations/yield/index.ts

@@ -1,14 +1,34 @@
 import Mpc from '../../mpc'
+import type { YieldXyzValidator } from '../../shared/types'
 import YieldXyz from './yieldxyz'
 
+export interface YieldOptions {
+  waitForConfirmation?: (
+    txHash: string,
+    network: string,
+  ) => Promise<void | boolean>
+  evmRequestFn?: (
+    method: string,
+    params: unknown[],
+    network: string,
+  ) => Promise<unknown>
+  evmPollerOptions?: {
+    pollIntervalMs?: number
+    timeoutMs?: number
+  }
+}
+
 /**
- * This class is a container for the YieldXyz class.
- * In the future, Yield domain logic should be here.
+ * Yield integrations (Yield.xyz, etc.).
  */
 export default class Yield {
   public yieldXyz: YieldXyz
 
-  constructor({ mpc }: { mpc: Mpc }) {
-    this.yieldXyz = new YieldXyz({ mpc })
+  constructor({ mpc, ...rest }: { mpc: Mpc } & YieldOptions) {
+    this.yieldXyz = new YieldXyz({ mpc, ...rest })
+  }
+
+  public getValidators(yieldId: string): Promise<YieldXyzValidator[]> {
+    return this.yieldXyz.getValidators(yieldId)
   }
 }

package/src/integrations/yield/yieldxyz.getValidators.test.ts

@@ -0,0 +1,70 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import YieldXyz from './yieldxyz'
+import Mpc from '../../mpc'
+import portalMock from '../../__mocks/portal/portal'
+import { mockHost } from '../../__mocks/constants'
+
+describe('YieldXyz getValidators', () => {
+  let mpc: Mpc
+  let yieldXyz: YieldXyz
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    portalMock.host = mockHost
+    mpc = new Mpc({ portal: portalMock })
+    yieldXyz = new YieldXyz({ mpc })
+  })
+
+  it('returns validators from data.validators', async () => {
+    const v = [{ address: '0x1', name: 'v1' }]
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      data: { validators: v },
+    })
+    await expect(yieldXyz.getValidators('y1')).resolves.toEqual(v)
+  })
+
+  it('falls back to data.rawResponse.validators', async () => {
+    const v = [{ address: '0x2' }]
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      data: { rawResponse: { validators: v } },
+    })
+    await expect(yieldXyz.getValidators('y1')).resolves.toEqual(v)
+  })
+
+  it('falls back to data.rawResponse.items', async () => {
+    const v = [{ address: '0x3' }]
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      data: { rawResponse: { items: v, total: 1 } },
+    })
+    await expect(yieldXyz.getValidators('y1')).resolves.toEqual(v)
+  })
+
+  it('returns empty array when validators is empty (valid)', async () => {
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      data: { validators: [] },
+    })
+    await expect(yieldXyz.getValidators('y1')).resolves.toEqual([])
+  })
+
+  it('throws on res.error', async () => {
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      error: 'not found',
+      data: { validators: [{ address: 'x' }] },
+    })
+    await expect(yieldXyz.getValidators('y1')).rejects.toThrow(
+      '[YieldXyz] getValidators failed: not found',
+    )
+  })
+
+  it('throws when no validators array in response', async () => {
+    jest.spyOn(mpc, 'getYieldXyzValidators').mockResolvedValue({
+      data: { rawResponse: {} },
+    })
+    await expect(yieldXyz.getValidators('y1')).rejects.toThrow(
+      'No validators in response',
+    )
+  })
+})