@portal-hq/web 3.5.2 → 3.6.0-alpha

package/src/__mocks/constants.ts

@@ -737,6 +737,21 @@ export const mockSourcesRes = {
   Uniswap_V3: '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
 }
 
+export const mockZeroXQuoteResponse = {
+  allowanceTarget: '0x1234567890123456789012345678901234567890',
+  cost: '1000000000000000',
+  transaction: {
+    from: '0x67aD8DCb5a4e8d6711C87D553C9325c3e85A1Da6',
+    to: '0x1234567890123456789012345678901234567890',
+    data: '0xabcdef',
+    gasLimit: '21000',
+    maxFeePerGas: '2000000000',
+    maxPriorityFeePerGas: '1000000000',
+    nonce: '1',
+    value: '1000000000000000000',
+  },
+}
+
 export const mockOrganizationShare = 'test-org-share'
 export const mockDecryptedData = JSON.stringify({
   [PortalCurve.SECP256K1]: {
@@ -1096,3 +1111,204 @@ export const mockYieldXyzGetTransactionResponse = {
     transactionId: 'test-tx-id',
   },
 }
+
+// LiFi mock data
+export const mockLifiToken = {
+  address: '0x0000000000000000000000000000000000000000',
+  symbol: 'ETH',
+  decimals: 18,
+  chainId: 'eip155:8453',
+  name: 'Ethereum',
+  logoURI: 'https://example.com/eth.png',
+  priceUSD: '3000',
+}
+
+export const mockLifiToToken = {
+  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+  symbol: 'USDC',
+  decimals: 6,
+  chainId: 'eip155:42161',
+  name: 'USD Coin',
+  logoURI: 'https://example.com/usdc.png',
+  priceUSD: '1',
+}
+
+export const mockLifiAction = {
+  fromChainId: 'eip155:8453',
+  fromAmount: '1000000000000',
+  fromToken: mockLifiToken,
+  toChainId: 'eip155:42161',
+  toToken: mockLifiToToken,
+  slippage: 0.005,
+  fromAddress: mockEip155Address,
+  toAddress: mockEip155Address,
+}
+
+export const mockLifiEstimate = {
+  tool: 'relay',
+  fromAmount: '1000000000000',
+  toAmount: '2990000000',
+  toAmountMin: '2975050000',
+  approvalAddress: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+  executionDuration: 120,
+  fromAmountUSD: '3000',
+  toAmountUSD: '2990',
+  feeCosts: [],
+  gasCosts: [
+    {
+      type: 'SEND' as const,
+      amount: '21000000000000',
+      token: mockLifiToken,
+      estimate: '21000',
+      limit: '25000',
+      amountUSD: '0.063',
+    },
+  ],
+}
+
+export const mockLifiStep = {
+  id: 'test-step-id',
+  type: 'cross' as const,
+  tool: 'relay',
+  action: mockLifiAction,
+  toolDetails: {
+    key: 'relay',
+    name: 'Relay',
+    logoURI: 'https://example.com/relay.png',
+  },
+  estimate: mockLifiEstimate,
+  integrator: 'portal',
+  transactionRequest: {
+    to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    from: mockEip155Address,
+    data: '0x123456',
+    value: '0x0de0b6b3a7640000',
+    gasLimit: '0x61a8',
+    chainId: 'eip155:1',
+  },
+}
+
+export const mockLifiRoute = {
+  id: 'test-route-id',
+  fromChainId: 'eip155:8453',
+  fromAmountUSD: '3000',
+  fromAmount: '1000000000000',
+  fromToken: mockLifiToken,
+  toChainId: 'eip155:42161',
+  toAmountUSD: '2990',
+  toAmount: '2990000000',
+  toAmountMin: '2975050000',
+  toToken: mockLifiToToken,
+  steps: [mockLifiStep],
+  gasCostUSD: '0.063',
+  fromAddress: mockEip155Address,
+  toAddress: mockEip155Address,
+  tags: ['RECOMMENDED', 'FASTEST'],
+}
+
+export const mockLifiGetRoutesRequest = {
+  fromChainId: 'eip155:8453',
+  fromAmount: '1000000000000',
+  fromTokenAddress: 'ETH',
+  toChainId: 'eip155:42161',
+  toTokenAddress: 'USDC',
+  fromAddress: mockEip155Address,
+  toAddress: mockEip155Address,
+  options: {
+    slippage: 0.005,
+    integrator: 'portal',
+  },
+}
+
+export const mockLifiGetRoutesResponse = {
+  data: {
+    rawResponse: {
+      routes: [mockLifiRoute],
+      unavailableRoutes: {
+        filteredOut: [],
+        failed: [],
+      },
+    },
+  },
+}
+
+export const mockLifiGetQuoteRequest = {
+  fromChain: 'eip155:8453',
+  toChain: 'eip155:42161',
+  fromToken: 'ETH',
+  toToken: 'USDC',
+  fromAddress: mockEip155Address,
+  fromAmount: '1000000000000',
+  toAddress: mockEip155Address,
+  order: 'FASTEST' as const,
+  slippage: 0.005,
+  integrator: 'portal',
+}
+
+export const mockLifiGetQuoteResponse = {
+  data: {
+    rawResponse: mockLifiStep,
+  },
+}
+
+export const mockLifiGetStatusRequest = {
+  txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+  bridge: 'relay' as const,
+  fromChain: '1',
+  toChain: '137',
+}
+
+export const mockLifiGetStatusResponse = {
+  data: {
+    rawResponse: {
+      sending: {
+        txHash:
+          '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+        txLink:
+          'https://etherscan.io/tx/0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+        amount: '1000000000000000000',
+        token: mockLifiToken,
+        chainId: '1',
+        gasAmount: '21000000000000',
+        gasAmountUSD: '0.063',
+        timestamp: 1704067200,
+      },
+      receiving: {
+        chainId: '137',
+        txHash:
+          '0x0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba',
+        txLink:
+          'https://polygonscan.com/tx/0x0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba',
+        token: mockLifiToToken,
+        amount: '2990000000',
+        timestamp: 1704067320,
+      },
+      status: 'DONE' as const,
+      substatus: 'COMPLETED' as const,
+      substatusMessage: 'Transfer completed successfully',
+      tool: 'relay',
+      transactionId: 'test-lifi-tx-id',
+      fromAddress: mockEip155Address,
+      toAddress: mockEip155Address,
+      lifiExplorerLink: 'https://explorer.li.fi/tx/test-lifi-tx-id',
+    },
+  },
+}
+
+export const mockLifiGetRouteStepRequest = mockLifiStep
+
+export const mockLifiGetRouteStepResponse = {
+  data: {
+    rawResponse: {
+      ...mockLifiStep,
+      transactionRequest: {
+        to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+        from: mockEip155Address,
+        data: '0x123456789abcdef',
+        value: '0x0de0b6b3a7640000',
+        gasLimit: '0x61a8',
+        chainId: 'eip155:1',
+      },
+    },
+  },
+}

package/src/index.ts

@@ -44,6 +44,7 @@ import {
 import Mpc from './mpc'
 import Provider, { RequestMethod } from './provider'
 import Yield from './integrations/yield'
+import Trading from './integrations/trading'
 
 class Portal {
   public address?: string
@@ -56,6 +57,7 @@ class Portal {
   public host: string
   public mpc: Mpc
   public yield: Yield
+  public trading: Trading
   public mpcHost: string
   public mpcVersion: string
   public provider: Provider
@@ -109,6 +111,8 @@ class Portal {
 
     this.yield = new Yield({ mpc: this.mpc })
 
+    this.trading = new Trading({ mpc: this.mpc })
+
     this.provider = new Provider({
       portal: this,
       chainId: chainId ? Number(chainId) : undefined,
@@ -887,6 +891,9 @@ class Portal {
    * Swaps Methods
    *******************************/
 
+  /**
+   * @deprecated This method is deprecated. Use `portal.trading.zeroX.getQuote` instead.
+   */
   public async getQuote(
     apiKey: string,
     args: QuoteArgs,
@@ -895,6 +902,9 @@ class Portal {
     return this.mpc?.getQuote(apiKey, args, chainId)
   }
 
+  /**
+   * @deprecated This method is deprecated. Use `portal.trading.zeroX.getSources` instead.
+   */
   public async getSources(
     apiKey: string,
     chainId: string,
@@ -1042,6 +1052,9 @@ export {
 } from '../yieldxyz-types'
 
 export { MpcError, MpcErrorCodes } from './mpc'
+
+export { PortalMpcError } from './mpc/errors'
+
 export {
   type Address,
   type Dapp,

package/src/integrations/trading/index.ts

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

package/src/integrations/trading/lifi/index.test.ts

@@ -0,0 +1,122 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import LiFi from '.'
+import Mpc from '../../../mpc'
+import portalMock from '../../../__mocks/portal/portal'
+import {
+  mockHost,
+  mockLifiGetRoutesRequest,
+  mockLifiGetRoutesResponse,
+  mockLifiGetQuoteRequest,
+  mockLifiGetQuoteResponse,
+  mockLifiGetStatusRequest,
+  mockLifiGetStatusResponse,
+  mockLifiGetRouteStepRequest,
+  mockLifiGetRouteStepResponse,
+} from '../../../__mocks/constants'
+
+describe('LiFi', () => {
+  let lifi: LiFi
+  let mpc: Mpc
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    portalMock.host = mockHost
+    mpc = new Mpc({
+      portal: portalMock,
+    })
+
+    lifi = new LiFi({ mpc })
+  })
+
+  describe('getRoutes', () => {
+    it('should call mpc.getLifiRoutes with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getLifiRoutes')
+        .mockResolvedValue(mockLifiGetRoutesResponse)
+
+      const result = await lifi.getRoutes(mockLifiGetRoutesRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockLifiGetRoutesRequest)
+      expect(result).toEqual(mockLifiGetRoutesResponse)
+    })
+
+    it('should propagate errors from mpc.getLifiRoutes', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getLifiRoutes').mockRejectedValue(error)
+
+      await expect(lifi.getRoutes(mockLifiGetRoutesRequest)).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+
+  describe('getQuote', () => {
+    it('should call mpc.getLifiQuote with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getLifiQuote')
+        .mockResolvedValue(mockLifiGetQuoteResponse)
+
+      const result = await lifi.getQuote(mockLifiGetQuoteRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockLifiGetQuoteRequest)
+      expect(result).toEqual(mockLifiGetQuoteResponse)
+    })
+
+    it('should propagate errors from mpc.getLifiQuote', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getLifiQuote').mockRejectedValue(error)
+
+      await expect(lifi.getQuote(mockLifiGetQuoteRequest)).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+
+  describe('getStatus', () => {
+    it('should call mpc.getLifiStatus with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getLifiStatus')
+        .mockResolvedValue(mockLifiGetStatusResponse)
+
+      const result = await lifi.getStatus(mockLifiGetStatusRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockLifiGetStatusRequest)
+      expect(result).toEqual(mockLifiGetStatusResponse)
+    })
+
+    it('should propagate errors from mpc.getLifiStatus', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getLifiStatus').mockRejectedValue(error)
+
+      await expect(lifi.getStatus(mockLifiGetStatusRequest)).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+
+  describe('getRouteStep', () => {
+    it('should call mpc.getLifiRouteStep with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getLifiRouteStep')
+        .mockResolvedValue(mockLifiGetRouteStepResponse)
+
+      const result = await lifi.getRouteStep(mockLifiGetRouteStepRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockLifiGetRouteStepRequest)
+      expect(result).toEqual(mockLifiGetRouteStepResponse)
+    })
+
+    it('should propagate errors from mpc.getLifiRouteStep', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getLifiRouteStep').mockRejectedValue(error)
+
+      await expect(
+        lifi.getRouteStep(mockLifiGetRouteStepRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+})

package/src/integrations/trading/lifi/index.ts

@@ -0,0 +1,61 @@
+import Mpc from '../../../mpc'
+import {
+  LifiQuoteRequest,
+  LifiQuoteResponse,
+  LifiRoutesRequest,
+  LifiRoutesResponse,
+  LifiStatusRequest,
+  LifiStatusResponse,
+  LifiStepTransactionRequest,
+  LifiStepTransactionResponse,
+} from '../../../../lifi-types'
+
+export default class LiFi {
+  private mpc: Mpc
+
+  constructor({ mpc }: { mpc: Mpc }) {
+    this.mpc = mpc
+  }
+
+  /**
+   * Retrieves routes from the Li.Fi integration.
+   * @param data - The parameters for the routes request.
+   * @returns A `LifiRoutesResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async getRoutes(data: LifiRoutesRequest): Promise<LifiRoutesResponse> {
+    return this.mpc?.getLifiRoutes(data)
+  }
+
+  /**
+   * Retrieves a quote from the Li.Fi integration.
+   * @param data - The parameters for the quote request.
+   * @returns A `LifiQuoteResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async getQuote(data: LifiQuoteRequest): Promise<LifiQuoteResponse> {
+    return this.mpc?.getLifiQuote(data)
+  }
+
+  /**
+   * Retrieves the status of a transaction from the Li.Fi integration.
+   * @param data - The parameters for the status request.
+   * @returns A `LifiStatusResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async getStatus(data: LifiStatusRequest): Promise<LifiStatusResponse> {
+    return this.mpc?.getLifiStatus(data)
+  }
+
+  /**
+   * Retrieves an unsigned transaction from the Li.Fi integration that has yet to be signed/submitted.
+   * @param data - The step transaction request containing the step details.
+   * @returns A `LifiStepTransactionResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async getRouteStep(
+    data: LifiStepTransactionRequest,
+  ): Promise<LifiStepTransactionResponse> {
+    return this.mpc?.getLifiRouteStep(data)
+  }
+}

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

@@ -0,0 +1,75 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import ZeroX from '.'
+import Mpc from '../../../mpc'
+import portalMock from '../../../__mocks/portal/portal'
+import {
+  mockHost,
+  mockQuoteArgs,
+  mockSourcesRes,
+  mockZeroXQuoteResponse,
+} from '../../../__mocks/constants'
+
+describe('ZeroX', () => {
+  let zeroX: ZeroX
+  let mpc: Mpc
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    portalMock.host = mockHost
+    mpc = new Mpc({
+      portal: portalMock,
+    })
+
+    zeroX = new ZeroX({ mpc })
+  })
+
+  describe('getQuote', () => {
+    it('should correctly call mpc.getQuote', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getQuote')
+        .mockResolvedValue(mockZeroXQuoteResponse)
+
+      const result = await zeroX.getQuote('test', mockQuoteArgs, 'eip155:1')
+
+      expect(spy).toHaveBeenCalledTimes(1)
+      expect(spy).toHaveBeenCalledWith('test', mockQuoteArgs, 'eip155:1')
+      expect(result).toEqual(mockZeroXQuoteResponse)
+    })
+
+    it('should propagate errors from mpc.getQuote', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getQuote').mockRejectedValue(error)
+
+      await expect(
+        zeroX.getQuote('test', mockQuoteArgs, 'eip155:1'),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('getSources', () => {
+    it('should correctly call mpc.getSources', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getSources')
+        .mockResolvedValue(mockSourcesRes)
+
+      const result = await zeroX.getSources('test', 'eip155:1')
+
+      expect(spy).toHaveBeenCalledTimes(1)
+      expect(spy).toHaveBeenCalledWith('test', 'eip155:1')
+      expect(result).toEqual(mockSourcesRes)
+    })
+
+    it('should propagate errors from mpc.getSources', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getSources').mockRejectedValue(error)
+
+      await expect(zeroX.getSources('test', 'eip155:1')).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+})

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

@@ -0,0 +1,40 @@
+import Mpc from '../../../mpc'
+import { QuoteArgs, QuoteResponse } from '../../../../types'
+
+export default class ZeroX {
+  private mpc: Mpc
+
+  constructor({ mpc }: { mpc: Mpc }) {
+    this.mpc = mpc
+  }
+
+  /**
+   * 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(
+    apiKey: string,
+    args: QuoteArgs,
+    chainId: string,
+  ): Promise<QuoteResponse> {
+    return this.mpc?.getQuote(apiKey, args, chainId)
+  }
+
+  /**
+   * 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(
+    apiKey: string,
+    chainId: string,
+  ): Promise<Record<string, string>> {
+    return this.mpc?.getSources(apiKey, chainId)
+  }
+}