@portal-hq/web 3.4.1 → 3.5.0-alpha

package/src/__mocks/constants.ts

@@ -777,3 +777,322 @@ export const mockClientMetadata = {
     },
   },
 }
+
+// YieldXyz mock data
+export const mockYieldXyzGetYieldsRequest = {
+  network: 'ethereum',
+  limit: 10,
+  offset: 0,
+}
+
+export const mockYieldXyzGetYieldsResponse = {
+  data: {
+    rawResponse: {
+      items: [
+        {
+          id: 'test-yield-id',
+          network: 'ethereum',
+          inputTokens: [
+            {
+              symbol: 'ETH',
+              name: 'Ethereum',
+              decimals: 18,
+              network: 'ethereum',
+              address: '0x0000000000000000000000000000000000000000',
+              logoURI: 'https://example.com/eth.png',
+            },
+          ],
+          outputToken: {
+            symbol: 'stETH',
+            name: 'Staked Ethereum',
+            decimals: 18,
+            network: 'ethereum',
+            address: '0x0000000000000000000000000000000000000001',
+            logoURI: 'https://example.com/steth.png',
+          },
+          token: {
+            symbol: 'ETH',
+            name: 'Ethereum',
+            decimals: 18,
+            network: 'ethereum',
+            address: '0x0000000000000000000000000000000000000000',
+            logoURI: 'https://example.com/eth.png',
+          },
+          rewardRate: {
+            total: 5.5,
+            rateType: 'APR' as const,
+            components: [],
+          },
+          status: {
+            enter: true,
+            exit: true,
+          },
+          metadata: {
+            name: 'Test Yield',
+            logoURI: 'https://example.com/logo.png',
+            description: 'Test yield opportunity',
+            documentation: 'https://example.com/docs',
+            underMaintenance: false,
+            deprecated: false,
+            supportedStandards: ['ERC20'],
+          },
+          mechanics: {
+            type: 'staking' as const,
+            requiresValidatorSelection: false,
+            rewardSchedule: 'block' as const,
+            rewardClaiming: 'auto' as const,
+            gasFeeToken: {
+              symbol: 'ETH',
+              name: 'Ethereum',
+              decimals: 18,
+            },
+            entryLimits: {
+              minimum: '0.01',
+            },
+            supportsLedgerWalletApi: true,
+            arguments: {
+              enter: { fields: [] },
+              exit: { fields: [] },
+            },
+            possibleFeeTakingMechanisms: {
+              depositFee: false,
+              managementFee: false,
+              performanceFee: false,
+              validatorRebates: false,
+            },
+          },
+          providerId: 'test-provider',
+          tags: ['defi', 'staking'],
+        },
+      ],
+      limit: 10,
+      offset: 0,
+      total: 1,
+    },
+  },
+}
+
+export const mockYieldXyzEnterRequest = {
+  yieldId: 'test-yield-id',
+  address: mockAddress,
+  arguments: {
+    amount: '1.0',
+  },
+}
+
+export const mockYieldXyzEnterResponse = {
+  data: {
+    rawResponse: {
+      id: 'test-action-id',
+      intent: 'enter' as const,
+      type: 'STAKE' as const,
+      yieldId: 'test-yield-id',
+      address: mockAddress,
+      amount: '1.0',
+      amountRaw: '1000000000000000000',
+      amountUsd: '3000',
+      transactions: [
+        {
+          id: 'test-tx-id',
+          title: 'Stake ETH',
+          network: 'ethereum',
+          status: 'WAITING_FOR_SIGNATURE' as const,
+          type: 'STAKE' as const,
+          createdAt: '2024-01-01T00:00:00Z',
+          stepIndex: 0,
+        },
+      ],
+      executionPattern: 'synchronous' as const,
+      createdAt: '2024-01-01T00:00:00Z',
+      status: 'CREATED' as const,
+    },
+  },
+}
+
+export const mockYieldXyzExitRequest = {
+  yieldId: 'test-yield-id',
+  address: mockAddress,
+  arguments: {
+    amount: '1.0',
+  },
+}
+
+export const mockYieldXyzExitResponse = {
+  data: {
+    rawResponse: {
+      id: 'test-action-id',
+      intent: 'exit' as const,
+      type: 'UNSTAKE' as const,
+      yieldId: 'test-yield-id',
+      address: mockAddress,
+      amount: '1.0',
+      amountRaw: '1000000000000000000',
+      amountUsd: '3000',
+      transactions: [
+        {
+          id: 'test-tx-id',
+          title: 'Unstake ETH',
+          network: 'ethereum',
+          status: 'WAITING_FOR_SIGNATURE' as const,
+          type: 'UNSTAKE' as const,
+          createdAt: '2024-01-01T00:00:00Z',
+          stepIndex: 0,
+        },
+      ],
+      executionPattern: 'synchronous' as const,
+      createdAt: '2024-01-01T00:00:00Z',
+      status: 'CREATED' as const,
+    },
+  },
+}
+
+export const mockYieldXyzGetBalancesRequest = {
+  queries: [
+    {
+      address: mockAddress,
+      network: 'ethereum',
+      yieldId: 'test-yield-id',
+    },
+  ],
+}
+
+export const mockYieldXyzGetBalancesResponse = {
+  data: {
+    rawResponse: {
+      items: [
+        {
+          yieldId: 'test-yield-id',
+          balances: [
+            {
+              address: mockAddress,
+              amount: '1.5',
+              amountRaw: '1500000000000000000',
+              type: 'staked',
+              token: {
+                address: '0x0000000000000000000000000000000000000001',
+                symbol: 'stETH',
+                name: 'Staked Ethereum',
+                decimals: 18,
+                network: 'ethereum',
+              },
+              amountUsd: '4500',
+              isEarning: true,
+            },
+          ],
+        },
+      ],
+    },
+  },
+}
+
+export const mockYieldXyzGetHistoricalActionsRequest = {
+  address: mockAddress,
+  limit: 10,
+  offset: 0,
+}
+
+export const mockYieldXyzGetHistoricalActionsResponse = {
+  data: {
+    rawResponse: {
+      items: [
+        {
+          id: 'test-action-id-1',
+          intent: 'enter' as const,
+          type: 'STAKE' as const,
+          yieldId: 'test-yield-id',
+          address: mockAddress,
+          amount: '1.0',
+          amountRaw: '1000000000000000000',
+          amountUsd: '3000',
+          transactions: [],
+          executionPattern: 'synchronous' as const,
+          createdAt: '2024-01-01T00:00:00Z',
+          completedAt: '2024-01-01T00:05:00Z',
+          status: 'SUCCESS' as const,
+        },
+      ],
+      total: 1,
+      offset: 0,
+      limit: 10,
+    },
+  },
+}
+
+export const mockYieldXyzManageYieldRequest = {
+  yieldId: 'test-yield-id',
+  address: mockAddress,
+  action: 'CLAIM_REWARDS' as const,
+  passthrough: 'test-passthrough',
+}
+
+export const mockYieldXyzManageYieldResponse = {
+  data: {
+    rawResponse: {
+      id: 'test-action-id',
+      intent: 'manage' as const,
+      type: 'CLAIM_REWARDS' as const,
+      yieldId: 'test-yield-id',
+      address: mockAddress,
+      amount: '0.1',
+      amountRaw: '100000000000000000',
+      amountUsd: '300',
+      transactions: [
+        {
+          id: 'test-tx-id',
+          title: 'Claim Rewards',
+          network: 'ethereum',
+          status: 'WAITING_FOR_SIGNATURE' as const,
+          type: 'CLAIM_REWARDS' as const,
+          createdAt: '2024-01-01T00:00:00Z',
+          stepIndex: 0,
+        },
+      ],
+      executionPattern: 'synchronous' as const,
+      createdAt: '2024-01-01T00:00:00Z',
+      status: 'CREATED' as const,
+    },
+  },
+}
+
+export const mockYieldXyzTrackTransactionRequest = {
+  transactionId: 'test-tx-id',
+  hash: '0x1234567890abcdef',
+}
+
+export const mockYieldXyzTrackTransactionResponse = {
+  data: {
+    rawResponse: {
+      id: 'test-tx-id',
+      title: 'Stake ETH',
+      network: 'ethereum',
+      status: 'BROADCASTED' as const,
+      type: 'STAKE' as const,
+      hash: '0x1234567890abcdef',
+      createdAt: '2024-01-01T00:00:00Z',
+      broadcastedAt: '2024-01-01T00:01:00Z',
+      stepIndex: 0,
+      gasEstimate: '21000',
+    },
+  },
+}
+
+export const mockYieldXyzGetTransactionResponse = {
+  data: {
+    rawResponse: {
+      id: 'test-tx-id',
+      title: 'Stake ETH',
+      network: 'ethereum',
+      status: 'CONFIRMED' as const,
+      type: 'STAKE' as const,
+      hash: '0x1234567890abcdef',
+      createdAt: '2024-01-01T00:00:00Z',
+      broadcastedAt: '2024-01-01T00:01:00Z',
+      stepIndex: 0,
+      gasEstimate: '21000',
+    },
+  },
+  metadata: {
+    clientId: 'test-client-id',
+    transactionId: 'test-tx-id',
+  },
+}

package/src/index.ts

@@ -6,7 +6,7 @@ import {
 } from '@solana/web3.js'
 
 import {
-  Asset,
+  GetAssetsResponse,
   BuiltTransaction,
   EjectPrivateKeysResult,
   EvaluateTransactionOperationType,
@@ -43,6 +43,7 @@ import {
 } from '../types'
 import Mpc from './mpc'
 import Provider, { RequestMethod } from './provider'
+import Yield from './integrations/yield'
 
 class Portal {
   public address?: string
@@ -54,6 +55,7 @@ class Portal {
   public passkeyConfig?: PasskeyConfig
   public host: string
   public mpc: Mpc
+  public yield: Yield
   public mpcHost: string
   public mpcVersion: string
   public provider: Provider
@@ -105,6 +107,8 @@ class Portal {
       portal: this,
     })
 
+    this.yield = new Yield({ mpc: this.mpc })
+
     this.provider = new Provider({
       portal: this,
       chainId: chainId ? Number(chainId) : undefined,
@@ -862,7 +866,7 @@ class Portal {
   public async getAssets(
     chainId: string,
     includeNfts = false,
-  ): Promise<Asset[]> {
+  ): Promise<GetAssetsResponse> {
     return this.mpc?.getAssets(chainId, includeNfts)
   }
 
@@ -1018,6 +1022,25 @@ class Portal {
   }
 }
 
+export {
+  YieldXyzEnterRequest,
+  YieldXyzEnterYieldResponse,
+  YieldXyzExitRequest,
+  YieldXyzExitResponse,
+  YieldXyzGetBalancesRequest,
+  YieldXyzGetBalancesResponse,
+  YieldXyzGetHistoricalActionsRequest,
+  YieldXyzGetHistoricalActionsResponse,
+  YieldXyzGetTransactionRequest,
+  YieldXyzGetTransactionResponse,
+  YieldXyzGetYieldsRequest,
+  YieldXyzGetYieldsResponse,
+  YieldXyzManageYieldRequest,
+  YieldXyzManageYieldResponse,
+  YieldXyzTrackTransactionRequest,
+  YieldXyzTrackTransactionResponse,
+} from 'yieldxyz-types'
+
 export { MpcError, MpcErrorCodes } from './mpc'
 export {
   type Address,

package/src/integrations/yield/index.ts

@@ -0,0 +1,14 @@
+import Mpc from '../../mpc'
+import YieldXyz from './yieldxyz'
+
+/**
+ * This class is a container for the YieldXyz class.
+ * In the future, Yield domain logic should be here.
+ */
+export default class Yield {
+  public yieldXyz: YieldXyz
+
+  constructor({ mpc }: { mpc: Mpc }) {
+    this.yieldXyz = new YieldXyz({ mpc })
+  }
+}

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

@@ -0,0 +1,220 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import YieldXyz from './yieldxyz'
+import Mpc from '../../mpc'
+import portalMock from '../../__mocks/portal/portal'
+import {
+  mockHost,
+  mockYieldXyzGetYieldsRequest,
+  mockYieldXyzGetYieldsResponse,
+  mockYieldXyzEnterRequest,
+  mockYieldXyzEnterResponse,
+  mockYieldXyzExitRequest,
+  mockYieldXyzExitResponse,
+  mockYieldXyzGetBalancesRequest,
+  mockYieldXyzGetBalancesResponse,
+  mockYieldXyzGetHistoricalActionsRequest,
+  mockYieldXyzGetHistoricalActionsResponse,
+  mockYieldXyzManageYieldRequest,
+  mockYieldXyzManageYieldResponse,
+  mockYieldXyzTrackTransactionRequest,
+  mockYieldXyzTrackTransactionResponse,
+  mockYieldXyzGetTransactionResponse,
+} from '../../__mocks/constants'
+
+describe('YieldXyz', () => {
+  let yieldXyz: YieldXyz
+  let mpc: Mpc
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    portalMock.host = mockHost
+    mpc = new Mpc({
+      portal: portalMock,
+    })
+
+    yieldXyz = new YieldXyz({ mpc })
+  })
+
+  describe('discover', () => {
+    it('should call mpc.getYieldXyzYields with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getYieldXyzYields')
+        .mockResolvedValue(mockYieldXyzGetYieldsResponse)
+
+      const result = await yieldXyz.discover(mockYieldXyzGetYieldsRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetYieldsRequest)
+      expect(result).toEqual(mockYieldXyzGetYieldsResponse)
+    })
+
+    it('should propagate errors from mpc.getYieldXyzYields', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getYieldXyzYields').mockRejectedValue(error)
+
+      await expect(
+        yieldXyz.discover(mockYieldXyzGetYieldsRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('enter', () => {
+    it('should call mpc.enterYieldXyzYield with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'enterYieldXyzYield')
+        .mockResolvedValue(mockYieldXyzEnterResponse)
+
+      const result = await yieldXyz.enter(mockYieldXyzEnterRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzEnterRequest)
+      expect(result).toEqual(mockYieldXyzEnterResponse)
+    })
+
+    it('should propagate errors from mpc.enterYieldXyzYield', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'enterYieldXyzYield').mockRejectedValue(error)
+
+      await expect(yieldXyz.enter(mockYieldXyzEnterRequest)).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+
+  describe('exit', () => {
+    it('should call mpc.exitYieldXyzYield with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'exitYieldXyzYield')
+        .mockResolvedValue(mockYieldXyzExitResponse)
+
+      const result = await yieldXyz.exit(mockYieldXyzExitRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzExitRequest)
+      expect(result).toEqual(mockYieldXyzExitResponse)
+    })
+
+    it('should propagate errors from mpc.exitYieldXyzYield', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'exitYieldXyzYield').mockRejectedValue(error)
+
+      await expect(yieldXyz.exit(mockYieldXyzExitRequest)).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+
+  describe('getBalances', () => {
+    it('should call mpc.getYieldXyzBalances with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getYieldXyzBalances')
+        .mockResolvedValue(mockYieldXyzGetBalancesResponse)
+
+      const result = await yieldXyz.getBalances(mockYieldXyzGetBalancesRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetBalancesRequest)
+      expect(result).toEqual(mockYieldXyzGetBalancesResponse)
+    })
+
+    it('should propagate errors from mpc.getYieldXyzBalances', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getYieldXyzBalances').mockRejectedValue(error)
+
+      await expect(
+        yieldXyz.getBalances(mockYieldXyzGetBalancesRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('getHistoricalActions', () => {
+    it('should call mpc.getYieldXyzHistoricalActions with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'getYieldXyzHistoricalActions')
+        .mockResolvedValue(mockYieldXyzGetHistoricalActionsResponse)
+
+      const result = await yieldXyz.getHistoricalActions(
+        mockYieldXyzGetHistoricalActionsRequest,
+      )
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetHistoricalActionsRequest)
+      expect(result).toEqual(mockYieldXyzGetHistoricalActionsResponse)
+    })
+
+    it('should propagate errors from mpc.getYieldXyzHistoricalActions', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getYieldXyzHistoricalActions').mockRejectedValue(error)
+
+      await expect(
+        yieldXyz.getHistoricalActions(mockYieldXyzGetHistoricalActionsRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('manage', () => {
+    it('should call mpc.manageYieldXyzYield with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'manageYieldXyzYield')
+        .mockResolvedValue(mockYieldXyzManageYieldResponse)
+
+      const result = await yieldXyz.manage(mockYieldXyzManageYieldRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzManageYieldRequest)
+      expect(result).toEqual(mockYieldXyzManageYieldResponse)
+    })
+
+    it('should propagate errors from mpc.manageYieldXyzYield', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'manageYieldXyzYield').mockRejectedValue(error)
+
+      await expect(
+        yieldXyz.manage(mockYieldXyzManageYieldRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('track', () => {
+    it('should call mpc.trackYieldXyzTransaction with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'trackYieldXyzTransaction')
+        .mockResolvedValue(mockYieldXyzTrackTransactionResponse)
+
+      const result = await yieldXyz.track(mockYieldXyzTrackTransactionRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockYieldXyzTrackTransactionRequest)
+      expect(result).toEqual(mockYieldXyzTrackTransactionResponse)
+    })
+
+    it('should propagate errors from mpc.trackYieldXyzTransaction', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'trackYieldXyzTransaction').mockRejectedValue(error)
+
+      await expect(
+        yieldXyz.track(mockYieldXyzTrackTransactionRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('getTransaction', () => {
+    it('should call mpc.getYieldXyzTransaction with the correct arguments', async () => {
+      const transactionId = 'test-tx-id'
+      const spy = jest
+        .spyOn(mpc, 'getYieldXyzTransaction')
+        .mockResolvedValue(mockYieldXyzGetTransactionResponse)
+
+      const result = await yieldXyz.getTransaction(transactionId)
+
+      expect(spy).toHaveBeenCalledWith(transactionId)
+      expect(result).toEqual(mockYieldXyzGetTransactionResponse)
+    })
+
+    it('should propagate errors from mpc.getYieldXyzTransaction', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'getYieldXyzTransaction').mockRejectedValue(error)
+
+      await expect(yieldXyz.getTransaction('test-tx-id')).rejects.toThrow(
+        'Test error',
+      )
+    })
+  })
+})