@eth-optimism/actions-sdk 0.2.0 → 0.3.0

package/src/lend/core/LendProvider.ts

@@ -21,6 +21,7 @@ import type {
   TransactionData,
 } from '@/types/lend/index.js'
 import { validateMarketAsset } from '@/utils/markets.js'
+import { validateChainSupported } from '@/utils/validation.js'
 
 /**
  * Lending provider abstract class
@@ -77,7 +78,7 @@ export abstract class LendProvider<
       throw new Error('walletAddress is required')
     }
 
-    this.validateProviderSupported(params.marketId.chainId)
+    validateChainSupported(params.marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(params.marketId)
 
     // Convert human-readable amount to wei using the asset's decimals
@@ -105,7 +106,7 @@ export abstract class LendProvider<
       chainId: params.chainId,
     }
 
-    this.validateProviderSupported(params.chainId)
+    validateChainSupported(params.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(marketId)
     return this._getMarket(marketId)
   }
@@ -117,7 +118,7 @@ export abstract class LendProvider<
    */
   async getMarkets(params: GetLendMarketsParams = {}): Promise<LendMarket[]> {
     if (params.chainId !== undefined)
-      this.validateProviderSupported(params.chainId)
+      validateChainSupported(params.chainId, this.SUPPORTED_CHAIN_IDS)
 
     const filteredMarkets = this.filterMarketConfigs(
       params.chainId,
@@ -156,7 +157,7 @@ export abstract class LendProvider<
       )
     }
 
-    this.validateProviderSupported(marketId.chainId)
+    validateChainSupported(marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(marketId)
 
     return this._getPosition({ marketId, walletAddress })
@@ -176,7 +177,7 @@ export abstract class LendProvider<
       throw new Error('walletAddress is required')
     }
 
-    this.validateProviderSupported(params.marketId.chainId)
+    validateChainSupported(params.marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(params.marketId)
 
     const market = await this.getMarket({
@@ -217,19 +218,6 @@ export abstract class LendProvider<
     return this.SUPPORTED_CHAIN_IDS.includes(chainId)
   }
 
-  /**
-   * Validate that a chainId is supported for lending operations
-   * @param chainId - Chain ID to validate
-   * @throws Error if chain is not supported
-   */
-  protected validateProviderSupported(chainId: number): void {
-    if (!this.isChainSupported(chainId)) {
-      throw new Error(
-        `Chain ${chainId} is not supported. Supported chains: ${this.SUPPORTED_CHAIN_IDS.join(', ')}`,
-      )
-    }
-  }
-
   /**
    * Validate that a market is in the config's market allowlist
    * @param marketId - Market identifier containing address and chainId

package/src/lend/core/__tests__/LendProvider.test.ts

@@ -4,13 +4,10 @@ import { describe, expect, it } from 'vitest'
 import { MockUSDCAsset } from '@/__mocks__/MockAssets.js'
 import { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 import type { LendMarketConfig, LendMarketId } from '@/types/lend/index.js'
+import { validateChainSupported } from '@/utils/validation.js'
 
 // Test helper class that exposes protected validation methods as public
 class TestLendProvider extends MockLendProvider {
-  public validateProviderSupported(chainId: number): void {
-    return super.validateProviderSupported(chainId)
-  }
-
   public validateConfigSupported(marketId: LendMarketId): void {
     return super.validateConfigSupported(marketId)
   }
@@ -186,7 +183,7 @@ describe('LendProvider', () => {
       const provider = new TestLendProvider()
 
       expect(() => {
-        provider.validateProviderSupported(999)
+        validateChainSupported(999, provider.supportedChainIds())
       }).toThrow('Chain 999 is not supported')
     })
 

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

@@ -160,11 +160,12 @@ describe('Vault Utilities', () => {
       const result = calculateRewardsBreakdown(apiVault)
 
       expect(result).toEqual({
+        eth: 0,
+        weth: 0,
         usdc: 0,
         usdc_demo: 0,
+        op_demo: 0,
         morpho: 0,
-        eth: 0,
-        weth: 0,
         other: 0,
         totalRewards: 0,
       })

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

@@ -3,7 +3,11 @@ import type { Address } from 'viem'
 const MORPHO_API_ENDPOINT = 'https://api.morpho.org/graphql'
 
 export interface RewardsBreakdown {
+  eth: number
+  weth: number
   usdc: number
+  usdc_demo: number
+  op_demo: number
   morpho: number
   other: number
   totalRewards: number

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

@@ -345,7 +345,16 @@ export async function getVault(params: GetVaultParams): Promise<LendMarket> {
         params.marketId.address,
       ).catch((error) => {
         console.error('Failed to fetch rewards data:', error)
-        return { usdc: 0, morpho: 0, other: 0, totalRewards: 0 }
+        return {
+          eth: 0,
+          weth: 0,
+          usdc: 0,
+          usdc_demo: 0,
+          op_demo: 0,
+          morpho: 0,
+          other: 0,
+          totalRewards: 0,
+        }
       })
 
       const apyBreakdown = calculateApyBreakdown(vault, rewardsBreakdown)

package/src/supported/tokens.ts

@@ -1,10 +1,24 @@
 import type { Address } from 'viem'
 
-import { ETH, MORPHO, USDC, USDC_DEMO, WETH } from '@/constants/assets.js'
+import {
+  ETH,
+  MORPHO,
+  OP_DEMO,
+  USDC,
+  USDC_DEMO,
+  WETH,
+} from '@/constants/assets.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
 
-export const SUPPORTED_TOKENS: Asset[] = [ETH, WETH, USDC, USDC_DEMO, MORPHO]
+export const SUPPORTED_TOKENS: Asset[] = [
+  ETH,
+  WETH,
+  USDC,
+  USDC_DEMO,
+  OP_DEMO,
+  MORPHO,
+]
 
 /**
  * Get token by address and chain ID

package/src/swap/__mocks__/MockSwapProvider.ts

@@ -0,0 +1,216 @@
+import type { Address } from 'viem'
+import { type MockedFunction, vi } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapMarket,
+  SwapPrice,
+  SwapPriceParams,
+  SwapProviderConfig,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+
+export interface MockSwapProviderConfig {
+  supportedChains: SupportedChainId[]
+  defaultPrice: string
+  defaultPriceImpact: number
+}
+
+/**
+ * Mock Swap Provider for testing
+ */
+export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
+  public mockExecute: MockedFunction<
+    (params: ResolvedSwapParams) => Promise<SwapTransaction>
+  >
+  public mockGetPrice: MockedFunction<
+    (params: SwapPriceParams) => Promise<SwapPrice>
+  >
+  public mockGetMarket: MockedFunction<
+    (params: GetSwapMarketParams) => Promise<SwapMarket>
+  >
+  public mockGetMarkets: MockedFunction<
+    (params: GetSwapMarketsParams) => Promise<SwapMarket[]>
+  >
+
+  private _supportedChains: SupportedChainId[]
+  private mockProviderConfig: MockSwapProviderConfig
+
+  constructor(
+    config?: SwapProviderConfig,
+    mockConfig?: Partial<MockSwapProviderConfig>,
+    chainManager?: ChainManager,
+  ) {
+    super(
+      config || {},
+      chainManager || (new MockChainManager() as unknown as ChainManager),
+    )
+
+    this._supportedChains = mockConfig?.supportedChains ?? [
+      84532 as SupportedChainId,
+    ]
+    this.mockProviderConfig = {
+      supportedChains: this._supportedChains,
+      defaultPrice: mockConfig?.defaultPrice ?? '1.5',
+      defaultPriceImpact: mockConfig?.defaultPriceImpact ?? 0.001,
+    }
+
+    // Create mocked functions
+    this.mockExecute = vi
+      .fn()
+      .mockImplementation(this.createMockSwapTransaction.bind(this))
+    this.mockGetPrice = vi
+      .fn()
+      .mockImplementation(this.createMockPrice.bind(this))
+    this.mockGetMarket = vi
+      .fn()
+      .mockImplementation(this.createMockMarket.bind(this))
+    this.mockGetMarkets = vi
+      .fn()
+      .mockImplementation(this.createMockMarkets.bind(this))
+  }
+
+  supportedChainIds(): SupportedChainId[] {
+    return this._supportedChains
+  }
+
+  reset(): void {
+    vi.clearAllMocks()
+  }
+
+  // Expose protected methods for testing
+  public testValidateMarketAllowed(
+    assetIn: any,
+    assetOut: any,
+    chainId: SupportedChainId,
+  ): void {
+    return this.validateMarketAllowed(assetIn, assetOut, chainId)
+  }
+
+  protected async _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction> {
+    return this.mockExecute(params)
+  }
+
+  protected async _getPrice(params: SwapPriceParams): Promise<SwapPrice> {
+    return this.mockGetPrice(params)
+  }
+
+  protected async _getMarket(params: GetSwapMarketParams): Promise<SwapMarket> {
+    return this.mockGetMarket(params)
+  }
+
+  protected async _getMarkets(
+    params: GetSwapMarketsParams,
+  ): Promise<SwapMarket[]> {
+    return this.mockGetMarkets(params)
+  }
+
+  private createMockSwapTransaction(
+    params: ResolvedSwapParams,
+  ): SwapTransaction {
+    const amountIn = params.amountInWei ?? 1000000n
+    const amountOut = 1500000000000000000n
+
+    return {
+      amountIn: 1.0,
+      amountOut: 1.5,
+      amountInWei: amountIn,
+      amountOutWei: amountOut,
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      price: this.mockProviderConfig.defaultPrice,
+      priceImpact: this.mockProviderConfig.defaultPriceImpact,
+      transactionData: {
+        swap: {
+          to: '0x492e6456d9528771018deb9e87ef7750ef184104' as Address,
+          data: '0x1234' as `0x${string}`,
+          value: 0n,
+        },
+      },
+    }
+  }
+
+  private createMockPrice(params: SwapPriceParams): SwapPrice {
+    const amountIn =
+      params.amountIn !== undefined
+        ? BigInt(
+            Math.floor(
+              params.amountIn * 10 ** params.assetIn.metadata.decimals,
+            ),
+          )
+        : BigInt(10 ** params.assetIn.metadata.decimals)
+
+    const amountOut = (amountIn * 15n) / 10n
+
+    return {
+      price: this.mockProviderConfig.defaultPrice,
+      priceInverse: '0.666666',
+      amountIn: 1.0,
+      amountOut: 1.5,
+      amountInWei: amountIn,
+      amountOutWei: amountOut,
+      priceImpact: this.mockProviderConfig.defaultPriceImpact,
+      route: {
+        path: [params.assetIn, params.assetOut!],
+        pools: [
+          {
+            address: '0x1234' as Address,
+            fee: 500,
+            version: 'v4',
+          },
+        ],
+      },
+      gasEstimate: 150000n,
+    }
+  }
+
+  private createMockMarket(params: GetSwapMarketParams): SwapMarket {
+    return {
+      marketId: {
+        poolId: params.poolId,
+        chainId: params.chainId,
+      },
+      assets: [
+        {
+          type: 'erc20',
+          address: { [params.chainId]: '0x1111' as Address },
+          metadata: { name: 'USDC', symbol: 'USDC', decimals: 6 },
+        },
+        {
+          type: 'erc20',
+          address: { [params.chainId]: '0x2222' as Address },
+          metadata: { name: 'WETH', symbol: 'WETH', decimals: 18 },
+        },
+      ],
+      fee: 500,
+      provider: 'uniswap',
+    }
+  }
+
+  private createMockMarkets(_params: GetSwapMarketsParams): SwapMarket[] {
+    return [
+      this.createMockMarket({
+        poolId: '0xpool1',
+        chainId: 84532 as SupportedChainId,
+      }),
+    ]
+  }
+}
+
+/**
+ * Create a mock swap provider
+ */
+export function createMockSwapProvider(
+  config?: SwapProviderConfig,
+  mockConfig?: Partial<MockSwapProviderConfig>,
+): MockSwapProvider {
+  return new MockSwapProvider(config, mockConfig)
+}

package/src/swap/core/SwapProvider.ts

@@ -0,0 +1,319 @@
+import type { Address } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapExecuteParams,
+  SwapMarket,
+  SwapMarketConfig,
+  SwapPrice,
+  SwapPriceParams,
+  SwapProviderConfig,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+import type { TransactionData } from '@/types/transaction.js'
+import {
+  getAssetAddress,
+  isNativeAsset,
+  parseAssetAmount,
+} from '@/utils/assets.js'
+import {
+  buildPermit2ApprovalTx,
+  buildTokenApprovalTx,
+  checkPermit2Allowance,
+  checkTokenAllowance,
+} from '@/utils/permit2.js'
+import {
+  validateAmountPositiveIfExists,
+  validateAmountProvided,
+  validateAssetOnChain,
+  validateChainSupported,
+  validateNotBothAmounts,
+  validateNotSameAsset,
+  validateNotZeroAddress,
+  validateSlippage,
+} from '@/utils/validation.js'
+
+const DEFAULT_SLIPPAGE = 0.005
+const DEFAULT_DEADLINE_OFFSET = 60
+const DEFAULT_MAX_SLIPPAGE = 0.5
+
+/**
+ * Abstract base class for swap providers.
+ * Public methods handle validation and conversion,
+ * protected abstract methods implement provider-specific logic.
+ */
+export abstract class SwapProvider<
+  TConfig extends SwapProviderConfig = SwapProviderConfig,
+> {
+  protected readonly _config: TConfig
+  protected readonly chainManager: ChainManager
+
+  constructor(config: TConfig, chainManager: ChainManager) {
+    this._config = config
+    this.chainManager = chainManager
+  }
+
+  get config(): TConfig {
+    return this._config
+  }
+
+  get defaultSlippage(): number {
+    return this._config.defaultSlippage ?? DEFAULT_SLIPPAGE
+  }
+
+  /**
+   * Execute a token swap
+   * @param params - Swap parameters including assets, amounts, and chain
+   * @returns Swap transaction data ready for execution
+   */
+  async execute(params: SwapExecuteParams): Promise<SwapTransaction> {
+    this.executeValidations(params)
+    const resolvedParams = this.resolveParams(params)
+    validateSlippage(
+      resolvedParams.slippage,
+      this._config.maxSlippage ?? DEFAULT_MAX_SLIPPAGE,
+    )
+    return this._execute(resolvedParams)
+  }
+
+  /** Get price quote for a swap */
+  async getPrice(params: SwapPriceParams): Promise<SwapPrice> {
+    validateChainSupported(params.chainId, this.supportedChainIds())
+    return this._getPrice(params)
+  }
+
+  /** Get a specific swap market by ID */
+  async getMarket(params: GetSwapMarketParams): Promise<SwapMarket> {
+    validateChainSupported(params.chainId, this.supportedChainIds())
+    return this._getMarket(params)
+  }
+
+  /** Get available swap markets, optionally filtered by chainId or asset */
+  async getMarkets(params: GetSwapMarketsParams = {}): Promise<SwapMarket[]> {
+    if (params.chainId) {
+      validateChainSupported(params.chainId, this.supportedChainIds())
+    }
+    return this._getMarkets(params)
+  }
+
+  isChainSupported(chainId: SupportedChainId): boolean {
+    return this.supportedChainIds().includes(chainId)
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Protected helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  protected validateMarketAllowed(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+  ): void {
+    const { marketBlocklist, marketAllowlist } = this._config
+
+    if (marketBlocklist?.length) {
+      const isBlocked = this.findMatchingConfig(
+        assetIn,
+        assetOut,
+        chainId,
+        marketBlocklist,
+      )
+      if (isBlocked) {
+        throw new Error(
+          `Pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} is blocked on chain ${chainId}`,
+        )
+      }
+    }
+
+    if (marketAllowlist?.length) {
+      const isAllowed = this.findMatchingConfig(
+        assetIn,
+        assetOut,
+        chainId,
+        marketAllowlist,
+      )
+      if (!isAllowed) {
+        throw new Error(
+          `Pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} is not in the allowlist for chain ${chainId}`,
+        )
+      }
+    }
+  }
+
+  protected resolveMarketConfig(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+  ): SwapMarketConfig | undefined {
+    const { marketAllowlist } = this._config
+    if (!marketAllowlist?.length) {
+      throw new Error(
+        'No markets configured. Provide a marketAllowlist in swap provider config.',
+      )
+    }
+    return this.findMatchingConfig(assetIn, assetOut, chainId, marketAllowlist)
+  }
+
+  /**
+   * Build Permit2 approval transactions for an ERC20 swap input.
+   * Skipped for native assets. Checks both ERC20→Permit2 and Permit2→spender allowances in parallel.
+   * @param params - Resolved swap params (wallet address, asset info, chain)
+   * @param requiredAmount - Amount in wei that must be approved
+   * @param permit2Address - Permit2 contract address
+   * @param permit2Spender - The router/contract that Permit2 should approve (e.g. Universal Router)
+   * @param permit2ExpirySeconds - Optional custom expiry for the Permit2 approval
+   */
+  protected async buildPermit2Approvals(
+    params: ResolvedSwapParams,
+    requiredAmount: bigint,
+    permit2Address: Address,
+    permit2Spender: Address,
+    permit2ExpirySeconds?: number,
+  ): Promise<{
+    tokenApproval: TransactionData | undefined
+    permit2Approval: TransactionData | undefined
+  }> {
+    if (isNativeAsset(params.assetIn)) {
+      return { tokenApproval: undefined, permit2Approval: undefined }
+    }
+
+    const publicClient = this.chainManager.getPublicClient(params.chainId)
+    const token = getAssetAddress(params.assetIn, params.chainId)
+
+    const [tokenAllowance, permit2Allowance] = await Promise.all([
+      checkTokenAllowance({
+        publicClient,
+        token,
+        owner: params.walletAddress,
+        spender: permit2Address,
+      }),
+      checkPermit2Allowance({
+        publicClient,
+        permit2Address,
+        owner: params.walletAddress,
+        token,
+        spender: permit2Spender,
+      }),
+    ])
+
+    const tokenApproval =
+      tokenAllowance < requiredAmount
+        ? buildTokenApprovalTx(token, permit2Address)
+        : undefined
+
+    // Permit2 expiration is in Unix seconds (matching EVM block.timestamp)
+    const permit2Expired =
+      permit2Allowance.expiration < Math.floor(Date.now() / 1000)
+    const permit2Approval =
+      permit2Allowance.amount < requiredAmount || permit2Expired
+        ? buildPermit2ApprovalTx({
+            permit2Address,
+            token,
+            spender: permit2Spender,
+            amount: requiredAmount,
+            expirySeconds: permit2ExpirySeconds,
+          })
+        : undefined
+
+    return { tokenApproval, permit2Approval }
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  private executeValidations(params: SwapExecuteParams): void {
+    validateAmountProvided(params.amountIn, params.amountOut)
+    validateAmountPositiveIfExists(params.amountIn)
+    validateAmountPositiveIfExists(params.amountOut)
+    validateNotBothAmounts(params.amountIn, params.amountOut)
+    validateNotSameAsset(params.assetIn, params.assetOut)
+    validateNotZeroAddress(params.walletAddress, 'walletAddress')
+    if (params.recipient) {
+      validateNotZeroAddress(params.recipient, 'recipient')
+    }
+    validateChainSupported(params.chainId, this.supportedChainIds())
+    this.validateMarketAllowed(params.assetIn, params.assetOut, params.chainId)
+    validateAssetOnChain(params.assetIn, params.chainId)
+    validateAssetOnChain(params.assetOut, params.chainId)
+  }
+
+  private resolveParams(params: SwapExecuteParams): ResolvedSwapParams {
+    return {
+      amountInWei: parseAssetAmount(params.assetIn, params.amountIn),
+      amountOutWei: parseAssetAmount(params.assetOut, params.amountOut),
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      slippage: params.slippage ?? this.defaultSlippage,
+      deadline:
+        params.deadline ??
+        Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE_OFFSET,
+      // Send output tokens to specified recipient, or back to the initiating wallet
+      recipient: params.recipient ?? params.walletAddress,
+      walletAddress: params.walletAddress,
+      chainId: params.chainId,
+    }
+  }
+
+  private findMatchingConfig(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+    list: SwapMarketConfig[],
+  ): SwapMarketConfig | undefined {
+    const addressIn = assetIn.address[chainId]
+    const addressOut = assetOut.address[chainId]
+    if (!addressIn || !addressOut) return undefined
+
+    return list.find((config) => {
+      if (config.chainId !== undefined && config.chainId !== chainId)
+        return false
+      return this.containsPairByAddress(
+        addressIn,
+        addressOut,
+        chainId,
+        config.assets,
+      )
+    })
+  }
+
+  private containsPairByAddress(
+    addressIn: string,
+    addressOut: string,
+    chainId: SupportedChainId,
+    assets: Asset[],
+  ): boolean {
+    const addresses = assets
+      .map((a) => a.address[chainId]?.toLowerCase())
+      .filter(Boolean)
+    return (
+      addresses.includes(addressIn.toLowerCase()) &&
+      addresses.includes(addressOut.toLowerCase())
+    )
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Abstract methods (implement in provider)
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  abstract supportedChainIds(): SupportedChainId[]
+
+  protected abstract _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction>
+
+  protected abstract _getPrice(params: SwapPriceParams): Promise<SwapPrice>
+
+  protected abstract _getMarket(
+    params: GetSwapMarketParams,
+  ): Promise<SwapMarket>
+
+  protected abstract _getMarkets(
+    params: GetSwapMarketsParams,
+  ): Promise<SwapMarket[]>
+}