@eth-optimism/actions-sdk 0.1.0 → 0.2.0

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

@@ -1,6 +1,6 @@
 import { ChainId } from '@morpho-org/blue-sdk'
 import { MetaMorphoAction } from '@morpho-org/blue-sdk-viem'
-import { encodeFunctionData, erc20Abi, formatUnits } from 'viem'
+import { erc20Abi, formatUnits } from 'viem'
 
 import { SUPPORTED_CHAIN_IDS as ACTIONS_SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
 import { LendProvider } from '@/lend/core/LendProvider.js'
@@ -39,16 +39,13 @@ export const SUPPORTED_CHAIN_IDS = [
 export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
   protected readonly SUPPORTED_CHAIN_IDS = SUPPORTED_CHAIN_IDS
 
-  private chainManager: ChainManager
-
   /**
    * Create a new Morpho lending provider
    * @param config - Morpho lending configuration
    * @param chainManager - Chain manager for blockchain interactions
    */
   constructor(config: LendProviderConfig, chainManager: ChainManager) {
-    super(config)
-    this.chainManager = chainManager
+    super(config, chainManager)
   }
 
   /**
@@ -61,13 +58,11 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
     params: LendOpenPositionInternalParams,
   ): Promise<LendTransaction> {
     try {
-      // Get asset address for the chain
-      const assetAddress = params.asset.address[params.marketId.chainId]
-      if (!assetAddress) {
-        throw new Error(
-          `Asset not supported on chain ${params.marketId.chainId}`,
-        )
-      }
+      // Get asset address for the chain (throws for native assets)
+      const assetAddress = getAssetAddress(
+        params.asset,
+        params.marketId.chainId,
+      )
 
       // Get vault information for APY
       const vaultInfo = await this.getMarket({
@@ -79,36 +74,27 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       const receiver = params.walletAddress
       const depositCallData = MetaMorphoAction.deposit(assets, receiver)
 
-      const approvalCallData = encodeFunctionData({
-        abi: erc20Abi,
-        functionName: 'approve',
-        args: [params.marketId.address, params.amountWei],
-      })
-
       return {
         amount: params.amountWei,
         asset: assetAddress,
         marketId: params.marketId.address,
         apy: vaultInfo.apy.total,
         transactionData: {
-          approval: {
-            to: assetAddress,
-            data: approvalCallData,
-            value: 0n,
-          },
-          openPosition: {
+          approval: this.buildApprovalTx(
+            assetAddress,
+            params.marketId.address,
+            params.amountWei,
+          ),
+          position: {
             to: params.marketId.address,
             data: depositCallData,
             value: 0n,
           },
         },
-        slippage: params.options?.slippage ?? 50,
       }
-    } catch (error) {
+    } catch {
       throw new Error(
-        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
+        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}`,
       )
     }
   }
@@ -149,20 +135,15 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
         marketId: params.marketId.address,
         apy: vaultInfo.apy.total,
         transactionData: {
-          closePosition: {
+          position: {
             to: params.marketId.address,
             data: withdrawCallData,
             value: 0n,
           },
         },
-        slippage: params.options?.slippage ?? 50,
       }
-    } catch (error) {
-      throw new Error(
-        `Failed to close position: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
-      )
+    } catch {
+      throw new Error('Failed to close position')
     }
   }
 
@@ -247,11 +228,9 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
         sharesFormatted,
         marketId: params.marketId,
       }
-    } catch (error) {
+    } catch {
       throw new Error(
-        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
+        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}`,
       )
     }
   }

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

@@ -1,15 +1,15 @@
 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'
+} from '@/lend/__mocks__/MockMarkets.js'
+import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
+import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
 
 // Mock the Morpho SDK modules
@@ -107,9 +107,7 @@ describe('MorphoLendProvider', () => {
       expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
       expect(withdrawTransaction).toHaveProperty('apy')
       expect(withdrawTransaction).toHaveProperty('transactionData')
-      expect(withdrawTransaction.transactionData).toHaveProperty(
-        'closePosition',
-      )
+      expect(withdrawTransaction.transactionData).toHaveProperty('position')
       expect(withdrawTransaction.transactionData).not.toHaveProperty('approval')
       expect(typeof withdrawTransaction.apy).toBe('number')
       expect(withdrawTransaction.apy).toBeGreaterThan(0)
@@ -209,7 +207,7 @@ describe('MorphoLendProvider', () => {
       expect(lendTransaction).toHaveProperty('apy')
       expect(lendTransaction).toHaveProperty('transactionData')
       expect(lendTransaction.transactionData).toHaveProperty('approval')
-      expect(lendTransaction.transactionData).toHaveProperty('openPosition')
+      expect(lendTransaction.transactionData).toHaveProperty('position')
       expect(typeof lendTransaction.apy).toBe('number')
       expect(lendTransaction.apy).toBeGreaterThan(0)
     })
@@ -233,29 +231,7 @@ describe('MorphoLendProvider', () => {
           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'))
+      ).rejects.toThrow('Failed to open position')
     })
   })
 

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

@@ -1,22 +1,284 @@
 import type { Address } from 'viem'
-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { fetchRewards } from '@/lend/providers/morpho/api.js'
-import { fetchAndCalculateRewards } from '@/lend/providers/morpho/sdk.js'
+import {
+  calculateRewardsBreakdown,
+  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
+ * Mock API response for a vault with rewards
  */
+const mockVaultWithRewards = {
+  address: '0x38f4f3B6533de0023b9DCd04b02F93d36ad1F9f9',
+  id: 'test-vault-id',
+  state: {
+    rewards: [
+      {
+        asset: {
+          address: '0x078d782b760474a361dda0af3839290b0ef57ad6',
+          name: 'USD Coin',
+          symbol: 'USDC',
+          chain: { id: 130 },
+        },
+        amountPerSuppliedToken: '1000000',
+        supplyApr: 0.025, // 2.5% APR
+      },
+      {
+        asset: {
+          address: '0x9994e35db50125e0df82e4c2dde62496ce330999',
+          name: 'Morpho Token',
+          symbol: 'MORPHO',
+          chain: { id: 130 },
+        },
+        amountPerSuppliedToken: '500000',
+        supplyApr: 0.01, // 1% APR
+      },
+    ],
+    allocation: [
+      {
+        market: {
+          id: 'market-1',
+          uniqueKey: '0xmarket1',
+          state: {
+            rewards: [
+              {
+                supplyApr: 0.005, // 0.5% APR
+                amountPerSuppliedToken: '100000',
+                asset: {
+                  address: '0xunknown',
+                  symbol: 'UNKNOWN',
+                  chain: { id: 130 },
+                },
+              },
+            ],
+          },
+        },
+        supplyAssetsUsd: 1000000,
+      },
+      {
+        market: {
+          id: 'market-2',
+          uniqueKey: '0xmarket2',
+          state: {
+            rewards: [],
+          },
+        },
+        supplyAssetsUsd: 500000,
+      },
+    ],
+  },
+  chain: { id: 130 },
+}
+
+/**
+ * Mock API response for a vault with no rewards
+ */
+const mockVaultNoRewards = {
+  address: '0x1234567890123456789012345678901234567890',
+  id: 'empty-vault-id',
+  state: {
+    rewards: [],
+    allocation: [],
+  },
+  chain: { id: 130 },
+}
 
 describe('Morpho API Integration', () => {
   const GAUNTLET_USDC_VAULT =
     '0x38f4f3B6533de0023b9DCd04b02F93d36ad1F9f9' as Address
 
-  it.runIf(externalTest())(
-    'should fetch raw vault data from Morpho GraphQL API',
-    async () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  describe('fetchRewards', () => {
+    it('should return vault data on successful API response', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          json: async () => ({
+            data: {
+              vaultByAddress: mockVaultWithRewards,
+            },
+          }),
+        }),
+      )
+
+      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.rewards).toHaveLength(2)
+    })
+
+    it('should return null when vault not found', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          json: async () => ({
+            data: {
+              vaultByAddress: null,
+            },
+          }),
+        }),
+      )
+
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+      expect(vaultData).toBeNull()
+    })
+
+    it('should handle API errors gracefully', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockRejectedValue(new Error('Network error')),
+      )
+
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+      expect(vaultData).toBeNull()
+    })
+
+    it('should handle malformed JSON response', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          json: async () => {
+            throw new Error('Invalid JSON')
+          },
+        }),
+      )
+
+      const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
+      expect(vaultData).toBeNull()
+    })
+  })
+
+  describe('calculateRewardsBreakdown', () => {
+    it('should calculate rewards from vault-level rewards', () => {
+      const rewards = calculateRewardsBreakdown(mockVaultWithRewards)
+
+      expect(rewards.usdc).toBe(0.025)
+      expect(rewards.morpho).toBe(0.01)
+      expect(rewards.totalRewards).toBeCloseTo(
+        0.025 + 0.01 + 0.005 * (1000000 / 1500000),
+        6,
+      )
+    })
+
+    it('should return zeros for vault with no rewards', () => {
+      const rewards = calculateRewardsBreakdown(mockVaultNoRewards)
+
+      expect(rewards.usdc).toBe(0)
+      expect(rewards.morpho).toBe(0)
+      expect(rewards.other).toBe(0)
+      expect(rewards.totalRewards).toBe(0)
+    })
+
+    it('should categorize unknown tokens as other', () => {
+      const vaultWithUnknown = {
+        ...mockVaultNoRewards,
+        state: {
+          rewards: [
+            {
+              asset: { symbol: 'RARE_TOKEN' },
+              supplyApr: 0.05,
+            },
+          ],
+          allocation: [],
+        },
+      }
+
+      const rewards = calculateRewardsBreakdown(vaultWithUnknown)
+
+      expect(rewards.other).toBe(0.05)
+    })
+
+    it('should weight market rewards by allocation', () => {
+      const vaultWithMarketRewards = {
+        ...mockVaultNoRewards,
+        state: {
+          rewards: [],
+          allocation: [
+            {
+              market: {
+                state: {
+                  rewards: [{ asset: { symbol: 'USDC' }, supplyApr: 0.1 }],
+                },
+              },
+              supplyAssetsUsd: 750000, // 75% of total
+            },
+            {
+              market: {
+                state: {
+                  rewards: [{ asset: { symbol: 'USDC' }, supplyApr: 0.02 }],
+                },
+              },
+              supplyAssetsUsd: 250000, // 25% of total
+            },
+          ],
+        },
+      }
+
+      const rewards = calculateRewardsBreakdown(vaultWithMarketRewards)
+
+      // Expected: 0.1 * 0.75 + 0.02 * 0.25 = 0.075 + 0.005 = 0.08
+      expect(rewards.usdc).toBeCloseTo(0.08, 6)
+    })
+  })
+
+  describe('fetchAndCalculateRewards', () => {
+    it('should fetch and calculate rewards breakdown', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          json: async () => ({
+            data: {
+              vaultByAddress: mockVaultWithRewards,
+            },
+          }),
+        }),
+      )
+
+      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')
+      expect(rewards.usdc).toBeGreaterThan(0)
+      expect(rewards.morpho).toBeGreaterThan(0)
+    })
+
+    it('should return empty rewards when vault not found', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          json: async () => ({
+            data: {
+              vaultByAddress: null,
+            },
+          }),
+        }),
+      )
+
+      const rewards = await fetchAndCalculateRewards(GAUNTLET_USDC_VAULT)
+
+      expect(rewards.usdc).toBe(0)
+      expect(rewards.morpho).toBe(0)
+      expect(rewards.other).toBe(0)
+      expect(rewards.totalRewards).toBe(0)
+    })
+  })
+
+  // External tests that make real network requests (only run with EXTERNAL_TEST=true)
+  describe.runIf(externalTest())('External API Tests', () => {
+    it('should fetch raw vault data from Morpho GraphQL API', async () => {
       const vaultData = await fetchRewards(GAUNTLET_USDC_VAULT)
 
       expect(vaultData).toBeDefined()
@@ -25,13 +287,9 @@ describe('Morpho API Integration', () => {
         GAUNTLET_USDC_VAULT.toLowerCase(),
       )
       expect(vaultData.state).toBeDefined()
-    },
-    30000,
-  ) // 30 second timeout for network request
+    }, 30000)
 
-  it.runIf(externalTest())(
-    'should fetch and calculate rewards breakdown',
-    async () => {
+    it('should fetch and calculate rewards breakdown', async () => {
       const rewards = await fetchAndCalculateRewards(GAUNTLET_USDC_VAULT)
 
       expect(rewards).toBeDefined()
@@ -40,57 +298,26 @@ describe('Morpho API Integration', () => {
       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)
+    }, 30000)
 
-      // 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 () => {
+    it('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()
-    }
-  })
+    }, 30000)
 
-  it.runIf(externalTest())(
-    'should validate GraphQL response structure',
-    async () => {
+    it('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({
@@ -98,7 +325,6 @@ describe('Morpho API Integration', () => {
           allocation: expect.any(Array),
         }),
       })
-    },
-    30000,
-  ) // 30 second timeout for network request
+    }, 30000)
+  })
 })

package/src/lend/providers/morpho/contracts.ts

@@ -0,0 +1,37 @@
+import { baseSepolia } from 'viem/chains'
+
+import type { MorphoContractsRegistry } from '@/types/lend/contracts.js'
+
+/**
+ * Morpho Blue core contract - same address on all chains via CREATE2
+ */
+const MORPHO_BLUE = '0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb' as const
+
+/**
+ * Contract addresses for chains NOT supported by Morpho SDK (testnets).
+ * Mainnet/Base use the SDK which provides richer data including rewards.
+ */
+export const MORPHO_CONTRACTS: MorphoContractsRegistry = {
+  [baseSepolia.id]: {
+    morphoBlue: MORPHO_BLUE,
+    irm: '0x46415998764C29aB2a25CbeA6254146D50D22687',
+  },
+}
+
+/**
+ * Get Morpho contracts for a chain
+ * @param chainId - Chain ID
+ * @returns Morpho contracts if supported, undefined otherwise
+ */
+export function getMorphoContracts(chainId: number) {
+  return MORPHO_CONTRACTS[chainId]
+}
+
+/**
+ * Check if Morpho is supported on a chain
+ * @param chainId - Chain ID
+ * @returns true if Morpho is deployed on this chain
+ */
+export function isMorphoChainSupported(chainId: number): boolean {
+  return chainId in MORPHO_CONTRACTS
+}