@eth-optimism/actions-sdk 0.0.0-main-20251009211102

package/src/lend/providers/morpho/__tests__/MorphoLendProvider.test.ts

@@ -0,0 +1,356 @@
+import { fetchAccrualVault } from '@morpho-org/blue-sdk-viem'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
+import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import {
+  MockGauntletUSDCMarket,
+  MockReceiverAddress,
+  MockWETHMarket,
+} from '@/test/MockMarkets.js'
+import type { MorphoLendConfig } from '@/types/lend/index.js'
+
+// Mock the Morpho SDK modules
+vi.mock('@morpho-org/blue-sdk-viem', () => ({
+  fetchMarket: vi.fn(),
+  fetchAccrualVault: vi.fn(),
+  MetaMorphoAction: {
+    deposit: vi.fn(() => '0x1234567890abcdef'),
+    withdraw: vi.fn(() => '0xabcdef1234567890'),
+  },
+}))
+
+vi.mock('@morpho-org/morpho-ts', () => ({
+  Time: {
+    timestamp: vi.fn(() => BigInt(Math.floor(Date.now() / 1000))),
+  },
+}))
+
+vi.mock('@morpho-org/bundler-sdk-viem', () => ({
+  populateBundle: vi.fn(),
+  finalizeBundle: vi.fn(),
+  encodeBundle: vi.fn(),
+}))
+
+describe('MorphoLendProvider', () => {
+  let provider: MorphoLendProvider
+  let mockConfig: MorphoLendConfig
+  let mockChainManager: ChainManager
+
+  beforeEach(() => {
+    mockConfig = {
+      provider: 'morpho',
+      defaultSlippage: 50,
+      marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
+    }
+
+    mockChainManager = new MockChainManager() as unknown as ChainManager
+
+    provider = new MorphoLendProvider(mockConfig, mockChainManager)
+  })
+
+  describe('constructor', () => {
+    it('should initialize with provided config', () => {
+      expect(provider).toBeInstanceOf(MorphoLendProvider)
+    })
+
+    it('should use default slippage when not provided', () => {
+      const configWithoutSlippage = {
+        ...mockConfig,
+        defaultSlippage: undefined,
+      }
+      const providerWithDefaults = new MorphoLendProvider(
+        configWithoutSlippage,
+        mockChainManager,
+      )
+      expect(providerWithDefaults).toBeInstanceOf(MorphoLendProvider)
+    })
+  })
+
+  describe('closePosition', () => {
+    beforeEach(() => {
+      const mockVault = createMockMorphoVault()
+
+      vi.mocked(fetchAccrualVault).mockResolvedValue(mockVault as any)
+
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({
+            data: {
+              vaultByAddress: {
+                state: {
+                  rewards: [],
+                  allocation: [],
+                },
+              },
+            },
+          }),
+        } as any),
+      )
+    })
+
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('should successfully create a withdrawal transaction', async () => {
+      const amount = 500
+      const asset = MockGauntletUSDCMarket.asset
+      const marketId = {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      }
+      const walletAddress = MockReceiverAddress
+
+      const withdrawTransaction = await provider.closePosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress,
+      })
+
+      expect(withdrawTransaction).toHaveProperty('amount', BigInt('500000000'))
+      expect(withdrawTransaction).toHaveProperty(
+        'asset',
+        asset.address[marketId.chainId],
+      )
+      expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
+      expect(withdrawTransaction).toHaveProperty('apy')
+      expect(withdrawTransaction).toHaveProperty('transactionData')
+      expect(withdrawTransaction.transactionData).toHaveProperty(
+        'closePosition',
+      )
+      expect(withdrawTransaction.transactionData).not.toHaveProperty('approval')
+      expect(typeof withdrawTransaction.apy).toBe('number')
+      expect(withdrawTransaction.apy).toBeGreaterThan(0)
+    })
+
+    it('should handle withdrawal errors', async () => {
+      vi.spyOn(provider as any, '_getMarket').mockRejectedValueOnce(
+        new Error('Market fetch failed'),
+      )
+
+      const amount = 500
+      const asset = MockGauntletUSDCMarket.asset
+      const marketId = {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      }
+      const walletAddress = MockReceiverAddress
+
+      await expect(
+        provider.closePosition({
+          amount,
+          asset,
+          marketId,
+          walletAddress,
+        }),
+      ).rejects.toThrow('Market fetch failed')
+    })
+  })
+
+  describe('supportedChainIds', () => {
+    it('should return array of supported chain IDs', () => {
+      const chainIds = provider.supportedChainIds()
+
+      expect(Array.isArray(chainIds)).toBe(true)
+      expect(chainIds).toContain(130) // Unichain
+      expect(chainIds.length).toBeGreaterThan(0)
+    })
+
+    it('should return unique chain IDs', () => {
+      const chainIds = provider.supportedChainIds()
+      const uniqueIds = [...new Set(chainIds)]
+
+      expect(chainIds.length).toBe(uniqueIds.length)
+    })
+  })
+
+  describe('openPosition', () => {
+    beforeEach(() => {
+      const mockVault = createMockMorphoVault()
+
+      vi.mocked(fetchAccrualVault).mockResolvedValue(mockVault as any)
+
+      // Mock the fetch API for rewards
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({
+            data: {
+              vaultByAddress: {
+                state: {
+                  rewards: [],
+                  allocation: [],
+                },
+              },
+            },
+          }),
+        } as any),
+      )
+    })
+
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('should successfully create a lending transaction', async () => {
+      const amount = 1000
+      const asset = MockGauntletUSDCMarket.asset
+      const marketId = {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      }
+
+      const lendTransaction = await provider.openPosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress: MockReceiverAddress,
+      })
+
+      expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
+      expect(lendTransaction).toHaveProperty(
+        'asset',
+        asset.address[marketId.chainId],
+      )
+      expect(lendTransaction).toHaveProperty('marketId', marketId.address)
+      expect(lendTransaction).toHaveProperty('apy')
+      expect(lendTransaction).toHaveProperty('transactionData')
+      expect(lendTransaction.transactionData).toHaveProperty('approval')
+      expect(lendTransaction.transactionData).toHaveProperty('openPosition')
+      expect(typeof lendTransaction.apy).toBe('number')
+      expect(lendTransaction.apy).toBeGreaterThan(0)
+    })
+
+    it('should handle lending errors', async () => {
+      vi.spyOn(provider as any, '_getMarket').mockRejectedValueOnce(
+        new Error('Market fetch failed'),
+      )
+
+      const asset = MockGauntletUSDCMarket.asset
+      const amount = 1000
+      const marketId = {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      }
+
+      await expect(
+        provider.openPosition({
+          amount,
+          asset,
+          marketId,
+          walletAddress: MockReceiverAddress,
+        }),
+      ).rejects.toThrow('Market fetch failed')
+    })
+
+    it('should use custom slippage when provided', async () => {
+      const amount = 1000
+      const asset = MockGauntletUSDCMarket.asset
+      const marketId = {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      }
+      const customSlippage = 100 // 1%
+
+      const lendTransaction = await provider.openPosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress: MockReceiverAddress,
+        options: {
+          slippage: customSlippage,
+        },
+      })
+
+      expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
+    })
+  })
+
+  describe('market allowlist configuration', () => {
+    it('should work without market allowlist', () => {
+      const configWithoutAllowlist: MorphoLendConfig = {
+        provider: 'morpho',
+        defaultSlippage: 50,
+      }
+
+      const providerWithoutAllowlist = new MorphoLendProvider(
+        configWithoutAllowlist,
+        mockChainManager,
+      )
+
+      expect(providerWithoutAllowlist.config.marketAllowlist).toBeUndefined()
+    })
+
+    it('should store market allowlist when provided', () => {
+      const configWithAllowlist: MorphoLendConfig = {
+        provider: 'morpho',
+        defaultSlippage: 50,
+        marketAllowlist: [MockGauntletUSDCMarket],
+      }
+
+      const providerWithAllowlist = new MorphoLendProvider(
+        configWithAllowlist,
+        mockChainManager,
+      )
+
+      const allowlist = providerWithAllowlist.config.marketAllowlist
+      expect(allowlist).toBeDefined()
+      expect(allowlist).toHaveLength(1)
+      expect(allowlist![0].address).toBe(MockGauntletUSDCMarket.address)
+      expect(allowlist![0].name).toBe(MockGauntletUSDCMarket.name)
+    })
+
+    it('should use default slippage from config', () => {
+      const customSlippage = 150
+      const configWithSlippage: MorphoLendConfig = {
+        provider: 'morpho',
+        defaultSlippage: customSlippage,
+      }
+
+      const providerWithSlippage = new MorphoLendProvider(
+        configWithSlippage,
+        mockChainManager,
+      )
+
+      expect(providerWithSlippage.config.defaultSlippage).toBe(customSlippage)
+    })
+
+    it('should use fallback default slippage when not provided', () => {
+      const configWithoutSlippage: MorphoLendConfig = {
+        provider: 'morpho',
+      }
+
+      const providerWithoutSlippage = new MorphoLendProvider(
+        configWithoutSlippage,
+        mockChainManager,
+      )
+
+      expect(providerWithoutSlippage.config.defaultSlippage || 50).toBe(50) // Default fallback
+    })
+
+    it('should handle multiple markets in allowlist', () => {
+      const configWithMultipleMarkets: MorphoLendConfig = {
+        provider: 'morpho',
+        marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
+      }
+
+      const provider = new MorphoLendProvider(
+        configWithMultipleMarkets,
+        mockChainManager,
+      )
+
+      const allowlist = provider.config.marketAllowlist
+      expect(allowlist).toBeDefined()
+      expect(allowlist).toHaveLength(2)
+      expect(allowlist![0].name).toBe(MockGauntletUSDCMarket.name)
+      expect(allowlist![1].name).toBe(MockWETHMarket.name)
+    })
+  })
+})

package/src/lend/providers/morpho/__tests__/api.test.ts

@@ -0,0 +1,104 @@
+import type { Address } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import { fetchRewards } from '@/lend/providers/morpho/api.js'
+import { fetchAndCalculateRewards } from '@/lend/providers/morpho/sdk.js'
+import { externalTest } from '@/utils/test.js'
+
+/**
+ * External tests for API functionality
+ * These tests make actual network requests and require EXTERNAL_TEST=true
+ */
+
+describe('Morpho API Integration', () => {
+  const GAUNTLET_USDC_VAULT =
+    '0x38f4f3B6533de0023b9DCd04b02F93d36ad1F9f9' as Address
+
+  it.runIf(externalTest())(
+    'should fetch raw vault data from Morpho GraphQL API',
+    async () => {
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+
+      expect(vaultData).toBeDefined()
+      expect(vaultData).not.toBeNull()
+      expect(vaultData.address.toLowerCase()).toBe(
+        GAUNTLET_USDC_VAULT.toLowerCase(),
+      )
+      expect(vaultData.state).toBeDefined()
+    },
+    30000,
+  ) // 30 second timeout for network request
+
+  it.runIf(externalTest())(
+    'should fetch and calculate rewards breakdown',
+    async () => {
+      const rewards = await fetchAndCalculateRewards(GAUNTLET_USDC_VAULT)
+
+      expect(rewards).toBeDefined()
+      expect(typeof rewards.usdc).toBe('number')
+      expect(typeof rewards.morpho).toBe('number')
+      expect(typeof rewards.other).toBe('number')
+      expect(typeof rewards.totalRewards).toBe('number')
+
+      // All reward APRs should be non-negative
+      expect(rewards.usdc).toBeGreaterThanOrEqual(0)
+      expect(rewards.morpho).toBeGreaterThanOrEqual(0)
+      expect(rewards.other).toBeGreaterThanOrEqual(0)
+      expect(rewards.totalRewards).toBeGreaterThanOrEqual(0)
+
+      // Total rewards should equal sum of individual rewards
+      const expectedTotal = rewards.usdc + rewards.morpho + rewards.other
+      expect(rewards.totalRewards).toBeCloseTo(expectedTotal, 6)
+
+      // For the Gauntlet USDC vault, we typically expect some rewards
+      // This assertion may need adjustment based on actual market conditions
+      expect(rewards.totalRewards).toBeGreaterThanOrEqual(0)
+    },
+    30000,
+  ) // 30 second timeout for network request
+
+  it.runIf(externalTest())(
+    'should handle non-existent vault gracefully',
+    async () => {
+      const nonExistentVault =
+        '0x0000000000000000000000000000000000000000' as Address
+
+      const vaultData = await fetchRewards(nonExistentVault)
+      expect(vaultData).toBeNull()
+    },
+    30000,
+  ) // 30 second timeout for network request
+
+  it('should handle API errors gracefully', async () => {
+    // Mock fetch to simulate network error
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockRejectedValue(new Error('Network error')),
+    )
+
+    try {
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+      expect(vaultData).toBeNull()
+    } finally {
+      // Restore original fetch
+      vi.unstubAllGlobals()
+    }
+  })
+
+  it.runIf(externalTest())(
+    'should validate GraphQL response structure',
+    async () => {
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+
+      // Verify that the response has the expected structure
+      expect(vaultData).toMatchObject({
+        address: expect.any(String),
+        state: expect.objectContaining({
+          rewards: expect.any(Array),
+          allocation: expect.any(Array),
+        }),
+      })
+    },
+    30000,
+  ) // 30 second timeout for network request
+})