@eth-optimism/actions-sdk 0.4.0 → 0.6.0

package/src/{lend → actions/lend}/providers/morpho/MorphoLendProvider.ts

@@ -1,11 +1,12 @@
 import { MetaMorphoAction } from '@morpho-org/blue-sdk-viem'
-import { erc20Abi, formatUnits } from 'viem'
+import { erc20Abi, erc4626Abi, formatUnits, type PublicClient } from 'viem'
 
-import { LendProvider } from '@/lend/core/LendProvider.js'
-import { getSupportedChainIds as getMorphoSupportedChainIds } from '@/lend/providers/morpho/contracts.js'
-import { getVault, getVaults } from '@/lend/providers/morpho/sdk.js'
+import { LendProvider } from '@/actions/lend/core/LendProvider.js'
+import { getVault, getVaults } from '@/actions/lend/providers/morpho/sdk.js'
+import { findMarketInAllowlist } from '@/actions/lend/utils/markets.js'
+import { getSupportedChainIds as getMorphoSupportedChainIds } from '@/actions/shared/morpho/contracts.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { LendProviderConfig, LendSettings } from '@/types/actions.js'
 import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
@@ -13,6 +14,7 @@ import type {
   LendMarket,
   LendMarketId,
   LendMarketPosition,
+  LendOpenPosition,
   LendOpenPositionInternalParams,
   LendTransaction,
 } from '@/types/lend/index.js'
@@ -23,28 +25,28 @@ import { getAssetAddress } from '@/utils/assets.js'
  * @description Lending provider implementation using Morpho protocol
  */
 export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
-  protocolSupportedChainIds(): number[] {
-    return getMorphoSupportedChainIds()
+  constructor(
+    config: LendProviderConfig,
+    chainManager: ChainManager,
+    settings?: LendSettings,
+  ) {
+    super(config, chainManager, settings)
   }
 
-  /**
-   * 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, chainManager)
+  protocolSupportedChainIds(): number[] {
+    return getMorphoSupportedChainIds()
   }
 
   /**
-   * Open a lending position in a Morpho market
-   * @description Opens a lending position by supplying assets to a Morpho market
-   * @param params - Position opening parameters
-   * @returns Promise resolving to lending transaction details
+   * Describe a Morpho deposit. The base class wraps this into a
+   * `LendTransaction` with the appropriate ERC-20 approval based on
+   * `params.approvalMode`.
+   * @param params - Position opening parameters (amount in wei, walletAddress, approvalMode)
+   * @returns Spender + deposit calldata + APY snapshot
    */
   protected async _openPosition(
     params: LendOpenPositionInternalParams,
-  ): Promise<LendTransaction> {
+  ): Promise<LendOpenPosition> {
     try {
       // Get asset address for the chain (throws for native assets)
       const assetAddress = getAssetAddress(
@@ -58,27 +60,20 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
         chainId: params.marketId.chainId,
       })
 
-      const assets = params.amountWei
-      const receiver = params.walletAddress
-      const depositCallData = MetaMorphoAction.deposit(assets, receiver)
+      const depositCallData = MetaMorphoAction.deposit(
+        params.amountWei,
+        params.walletAddress,
+      )
 
       return {
-        amount: params.amountWei,
-        asset: assetAddress,
-        marketId: params.marketId.address,
-        apy: vaultInfo.apy.total,
-        transactionData: {
-          approval: this.buildApprovalTx(
-            assetAddress,
-            params.marketId.address,
-            params.amountWei,
-          ),
-          position: {
-            to: params.marketId.address,
-            data: depositCallData,
-            value: 0n,
-          },
+        spender: params.marketId.address,
+        assetAddress,
+        transaction: {
+          to: params.marketId.address,
+          data: depositCallData,
+          value: 0n,
         },
+        apy: vaultInfo.apy.total,
       }
     } catch {
       throw new Error(
@@ -119,7 +114,7 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
 
       return {
         amount: params.amount,
-        asset: assetAddress,
+        assetAddress,
         marketId: params.marketId.address,
         apy: vaultInfo.apy.total,
         transactionData: {
@@ -180,6 +175,10 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       const publicClient = this.chainManager.getPublicClient(
         params.marketId.chainId,
       )
+      const underlyingDecimals = await this.resolveUnderlyingDecimals(
+        publicClient,
+        params.marketId,
+      )
 
       // Get user's market token balance (shares in the vault)
       const shares = await publicClient.readContract({
@@ -192,28 +191,17 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       // Convert shares to underlying asset balance using convertToAssets
       const balance = await publicClient.readContract({
         address: params.marketId.address,
-        abi: [
-          {
-            name: 'convertToAssets',
-            type: 'function',
-            stateMutability: 'view',
-            inputs: [{ name: 'shares', type: 'uint256' }],
-            outputs: [{ name: '', type: 'uint256' }],
-          },
-        ],
+        abi: erc4626Abi,
         functionName: 'convertToAssets',
         args: [shares],
       })
 
-      // Format the balances (USDC has 6 decimals)
-      const balanceFormatted = formatUnits(balance, 6)
-      const sharesFormatted = formatUnits(shares, 18) // Vault shares typically have 18 decimals
-
       return {
         balance,
-        balanceFormatted,
+        balanceFormatted: formatUnits(balance, underlyingDecimals),
         shares,
-        sharesFormatted,
+        // MetaMorpho vault shares are 18 decimals by contract invariant
+        sharesFormatted: formatUnits(shares, 18),
         marketId: params.marketId,
       }
     } catch {
@@ -222,4 +210,30 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       )
     }
   }
+
+  /**
+   * Resolve the underlying asset decimals for a market.
+   * @description Prefers the allowlisted market config (free, no RPC).
+   * Falls back to an on-chain read of the vault's ERC-4626 `asset()` +
+   * ERC-20 `decimals()` when the allowlist is empty or doesn't contain the
+   * market (e.g. a provider configured without an allowlist).
+   */
+  private async resolveUnderlyingDecimals(
+    publicClient: PublicClient,
+    marketId: LendMarketId,
+  ): Promise<number> {
+    const match = findMarketInAllowlist(this._config.marketAllowlist, marketId)
+    if (match) return match.asset.metadata.decimals
+
+    const underlying = await publicClient.readContract({
+      address: marketId.address,
+      abi: erc4626Abi,
+      functionName: 'asset',
+    })
+    return publicClient.readContract({
+      address: underlying,
+      abi: erc20Abi,
+      functionName: 'decimals',
+    })
+  }
 }

package/src/{lend → actions/lend}/providers/morpho/__tests__/MorphoLendProvider.test.ts

@@ -5,9 +5,9 @@ import {
   MockGauntletUSDCMarket,
   MockReceiverAddress,
   MockWETHMarket,
-} from '@/lend/__mocks__/MockMarkets.js'
-import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
-import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+} from '@/actions/lend/__mocks__/MockMarkets.js'
+import { createMockMorphoVault } from '@/actions/lend/providers/morpho/__mocks__/mockVault.js'
+import { MorphoLendProvider } from '@/actions/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'
@@ -101,7 +101,7 @@ describe('MorphoLendProvider', () => {
 
       expect(withdrawTransaction).toHaveProperty('amount', BigInt('500000000'))
       expect(withdrawTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
@@ -200,7 +200,7 @@ describe('MorphoLendProvider', () => {
 
       expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
       expect(lendTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(lendTransaction).toHaveProperty('marketId', marketId.address)
@@ -235,6 +235,80 @@ describe('MorphoLendProvider', () => {
     })
   })
 
+  describe('getPosition', () => {
+    it('formats balance using the allowlist asset decimals (USDC, 6)', async () => {
+      const client = mockChainManager.getPublicClient(
+        MockGauntletUSDCMarket.chainId,
+      )
+      const shares = 10n ** 18n // 1 share
+      const underlyingBalance = 10n ** 6n // 1 USDC
+      vi.mocked(client.readContract)
+        .mockResolvedValueOnce(shares)
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await provider.getPosition(MockReceiverAddress, {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      })
+
+      expect(position.balance).toBe(underlyingBalance)
+      expect(position.balanceFormatted).toBe('1')
+      expect(position.shares).toBe(shares)
+      expect(position.sharesFormatted).toBe('1')
+    })
+
+    it('formats balance using the allowlist asset decimals (WETH, 18)', async () => {
+      const client = mockChainManager.getPublicClient(MockWETHMarket.chainId)
+      const shares = 10n ** 18n
+      const underlyingBalance = 10n ** 18n // 1 WETH
+      vi.mocked(client.readContract)
+        .mockResolvedValueOnce(shares)
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await provider.getPosition(MockReceiverAddress, {
+        address: MockWETHMarket.address,
+        chainId: MockWETHMarket.chainId,
+      })
+
+      expect(position.balance).toBe(underlyingBalance)
+      expect(position.balanceFormatted).toBe('1')
+    })
+
+    it('falls back to on-chain asset() + decimals() when no allowlist match', async () => {
+      const providerWithoutAllowlist = new MorphoLendProvider(
+        {},
+        mockChainManager,
+      )
+      const client = mockChainManager.getPublicClient(
+        MockGauntletUSDCMarket.chainId,
+      )
+      const underlyingAddr = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
+      const onchainDecimals = 8 // simulate a non-USDC underlying
+      const shares = 10n ** 18n
+      const underlyingBalance = 10n ** 8n
+      vi.mocked(client.readContract)
+        // resolveUnderlyingDecimals: asset()
+        .mockResolvedValueOnce(underlyingAddr)
+        // resolveUnderlyingDecimals: decimals()
+        .mockResolvedValueOnce(onchainDecimals)
+        // balanceOf
+        .mockResolvedValueOnce(shares)
+        // convertToAssets
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await providerWithoutAllowlist.getPosition(
+        MockReceiverAddress,
+        {
+          address: MockGauntletUSDCMarket.address,
+          chainId: MockGauntletUSDCMarket.chainId,
+        },
+      )
+
+      expect(position.balanceFormatted).toBe('1')
+      expect(position.sharesFormatted).toBe('1')
+    })
+  })
+
   describe('market allowlist configuration', () => {
     it('should work without market allowlist', () => {
       const configWithoutAllowlist: LendProviderConfig = {}

package/src/{lend → actions/lend}/providers/morpho/__tests__/api.test.ts

@@ -2,12 +2,12 @@ import type { Address } from 'viem'
 import { mainnet } from 'viem/chains'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
-import { MORPHO, USDC } from '@/constants/assets.js'
-import { fetchRewards } from '@/lend/providers/morpho/api.js'
+import { fetchRewards } from '@/actions/lend/providers/morpho/api.js'
 import {
   calculateRewardsBreakdown,
   fetchAndCalculateRewards,
-} from '@/lend/providers/morpho/sdk.js'
+} from '@/actions/lend/providers/morpho/sdk.js'
+import { MORPHO, USDC } from '@/constants/assets.js'
 import { externalTest } from '@/utils/test.js'
 
 const CHAIN_ID = mainnet.id

package/src/{lend → actions/lend}/providers/morpho/__tests__/sdk.test.ts

@@ -1,11 +1,11 @@
 import { mainnet } from 'viem/chains'
 import { describe, expect, it } from 'vitest'
 
-import { MORPHO, USDC } from '@/constants/assets.js'
 import {
   calculateBaseApy,
   calculateRewardsBreakdown,
-} from '@/lend/providers/morpho/sdk.js'
+} from '@/actions/lend/providers/morpho/sdk.js'
+import { MORPHO, USDC } from '@/constants/assets.js'
 
 const CHAIN_ID = mainnet.id
 const USDC_ADDRESS = USDC.address[CHAIN_ID]!.toLowerCase()

package/src/{lend → actions/lend}/providers/morpho/sdk.ts

@@ -7,12 +7,18 @@ import {
 } from '@morpho-org/blue-sdk-viem'
 import type { Address, PublicClient } from 'viem'
 
-import { NATIVELY_SUPPORTED_ASSETS } from '@/constants/assets.js'
 import {
   fetchRewards,
   type RewardsBreakdown,
-} from '@/lend/providers/morpho/api.js'
-import { getMorphoContracts } from '@/lend/providers/morpho/contracts.js'
+} from '@/actions/lend/providers/morpho/api.js'
+import { getMorphoContracts } from '@/actions/shared/morpho/contracts.js'
+import type { MorphoContracts } from '@/actions/shared/morpho/types.js'
+import { NATIVELY_SUPPORTED_ASSETS } from '@/constants/assets.js'
+import {
+  ChainNotSupportedError,
+  MarketNotAllowedError,
+  ProviderNotConfiguredError,
+} from '@/core/error/errors.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
@@ -21,7 +27,6 @@ import type {
   LendMarket,
   LendMarketConfig,
   LendMarketId,
-  MorphoContracts,
 } from '@/types/lend/index.js'
 import { SECONDS_PER_YEAR } from '@/utils/constants.js'
 
@@ -337,9 +342,11 @@ export async function getVault(params: GetVaultParams): Promise<LendMarket> {
     : undefined
 
   if (!marketConfig) {
-    throw new Error(
-      `Market ${params.marketId.address} on chain ${params.marketId.chainId} not found in allowlist`,
-    )
+    throw new MarketNotAllowedError({
+      address: params.marketId.address,
+      chainId: params.marketId.chainId,
+      reason: 'Market not found in allowlist',
+    })
   }
 
   const publicClient = params.chainManager.getPublicClient(
@@ -400,9 +407,7 @@ export async function getVault(params: GetVaultParams): Promise<LendMarket> {
   }
 
   // No SDK support and no contracts configured
-  throw new Error(
-    `Chain ${params.marketId.chainId} not supported by Morpho SDK and no contracts configured`,
-  )
+  throw new ChainNotSupportedError({ chainId: params.marketId.chainId })
 }
 
 interface GetVaultsParams {
@@ -447,7 +452,10 @@ export async function findBestVaultForAsset(
   marketAllowlist: LendMarketConfig[],
 ): Promise<Address> {
   if (!marketAllowlist || marketAllowlist.length === 0) {
-    throw new Error('Market allowlist is required and cannot be empty')
+    throw new ProviderNotConfiguredError({
+      provider: 'marketAllowlist',
+      details: 'Market allowlist is required and cannot be empty',
+    })
   }
 
   const assetVaults = marketAllowlist.filter((vault) => {
@@ -456,7 +464,10 @@ export async function findBestVaultForAsset(
   })
 
   if (assetVaults.length === 0) {
-    throw new Error(`No vaults available for asset ${asset}`)
+    throw new MarketNotAllowedError({
+      chainId: 0,
+      reason: `No vaults available for asset ${asset}`,
+    })
   }
 
   // For now, return the first (and only) supported vault for the asset

package/src/actions/lend/utils/markets.ts

@@ -0,0 +1,62 @@
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MarketNotAllowedError } from '@/core/error/errors.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  LendMarket,
+  LendMarketConfig,
+  LendMarketId,
+} from '@/types/lend/index.js'
+
+/**
+ * Find a market config in an allowlist by address + chainId (case-insensitive on address).
+ * @description Shared between `BaseLendNamespace.getProviderForMarket` and
+ * `MorphoLendProvider._getPosition` to avoid duplicate match logic.
+ * @param allowlist - Optional list of allowed markets (undefined or empty → always returns undefined)
+ * @param marketId - Market identifier to look up
+ * @returns The matching market config, or undefined if not present
+ */
+export function findMarketInAllowlist(
+  allowlist: readonly LendMarketConfig[] | undefined,
+  marketId: LendMarketId,
+): LendMarketConfig | undefined {
+  if (!allowlist || allowlist.length === 0) return undefined
+  return allowlist.find(
+    (m) =>
+      m.address.toLowerCase() === marketId.address.toLowerCase() &&
+      m.chainId === marketId.chainId,
+  )
+}
+
+/**
+ * Validates that an asset matches the market's asset
+ * @param market - Market information
+ * @param asset - Asset to validate
+ * @throws Error if asset doesn't match the market's asset
+ */
+export function validateMarketAsset(market: LendMarket, asset: Asset): void {
+  if (!isMarketAsset(market, asset)) {
+    const marketAssetAddress =
+      market.asset.address[market.marketId.chainId as SupportedChainId]
+    const providedAssetAddress =
+      asset.address[market.marketId.chainId as SupportedChainId]
+    throw new MarketNotAllowedError({
+      address: market.marketId.address,
+      chainId: market.marketId.chainId,
+      reason: `Asset mismatch: provided ${providedAssetAddress} but market ${market.marketId.address} uses ${marketAssetAddress}`,
+    })
+  }
+}
+
+/**
+ * Checks if an asset matches the market's asset
+ * @param market - Market information
+ * @param asset - Asset to check
+ * @returns true if asset matches market's asset, false otherwise
+ */
+export function isMarketAsset(market: LendMarket, asset: Asset): boolean {
+  const marketAssetAddress =
+    market.asset.address[market.marketId.chainId as SupportedChainId]
+  const providedAssetAddress =
+    asset.address[market.marketId.chainId as SupportedChainId]
+  return marketAssetAddress === providedAssetAddress
+}

package/src/actions/shared/BaseNamespace.ts

@@ -0,0 +1,46 @@
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+/**
+ * Minimum contract a concrete provider must expose for `BaseNamespace` to
+ * aggregate it. Domain providers (LendProvider, SwapProvider, BorrowProvider)
+ * implement this plus their domain-specific surface.
+ */
+export interface NamespaceProvider {
+  supportedChainIds(): readonly SupportedChainId[]
+}
+
+/**
+ * Shared base for per-domain namespaces (Lend, Swap, Borrow, …).
+ * @description Holds the generic `providers` registry and exposes
+ * provider-enumeration + chain-union helpers every domain's namespace needs.
+ * Domain-specific routing and read operations live on the concrete
+ * `BaseXxxNamespace` subclass.
+ */
+export abstract class BaseNamespace<
+  TProvider extends NamespaceProvider,
+  TProviders extends Record<string, TProvider | undefined>,
+> {
+  constructor(protected readonly providers: TProviders) {}
+
+  /**
+   * Union of chain IDs supported by any configured provider.
+   */
+  supportedChainIds(): readonly SupportedChainId[] {
+    const chainIds = new Set<SupportedChainId>()
+    for (const provider of this.getAllProviders()) {
+      for (const chainId of provider.supportedChainIds()) {
+        chainIds.add(chainId)
+      }
+    }
+    return [...chainIds]
+  }
+
+  /**
+   * Enumerate every configured (non-undefined) provider.
+   */
+  protected getAllProviders(): TProvider[] {
+    return Object.values(this.providers).filter(
+      (p): p is TProvider => p !== undefined,
+    )
+  }
+}

package/src/actions/shared/__tests__/BaseNamespace.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  BaseNamespace,
+  type NamespaceProvider,
+} from '@/actions/shared/BaseNamespace.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+class FakeProvider implements NamespaceProvider {
+  constructor(private readonly chains: readonly SupportedChainId[]) {}
+  supportedChainIds(): readonly SupportedChainId[] {
+    return this.chains
+  }
+}
+
+type FakeProviders = {
+  morpho?: FakeProvider
+  aave?: FakeProvider
+}
+
+class TestNamespace extends BaseNamespace<FakeProvider, FakeProviders> {
+  providersSnapshot(): FakeProvider[] {
+    return this.getAllProviders()
+  }
+}
+
+describe('BaseNamespace', () => {
+  it('returns only configured providers (skips undefined)', () => {
+    const morpho = new FakeProvider([1, 10])
+    const ns = new TestNamespace({ morpho, aave: undefined })
+
+    expect(ns.providersSnapshot()).toEqual([morpho])
+  })
+
+  it('returns all providers when multiple are configured', () => {
+    const morpho = new FakeProvider([1])
+    const aave = new FakeProvider([10])
+    const ns = new TestNamespace({ morpho, aave })
+
+    expect(ns.providersSnapshot()).toEqual([morpho, aave])
+  })
+
+  it('returns empty array when no providers are configured', () => {
+    const ns = new TestNamespace({})
+    expect(ns.providersSnapshot()).toEqual([])
+    expect(ns.supportedChainIds()).toEqual([])
+  })
+
+  it('unions supported chain ids across providers, deduplicated', () => {
+    const morpho = new FakeProvider([1, 10, 8453])
+    const aave = new FakeProvider([10, 8453, 42220])
+    const ns = new TestNamespace({ morpho, aave })
+
+    expect([...ns.supportedChainIds()].sort((a, b) => a - b)).toEqual([
+      1, 10, 8453, 42220,
+    ])
+  })
+})

package/src/{lend/providers → actions/shared}/morpho/contracts.ts

@@ -10,11 +10,11 @@ import {
   worldchain,
 } from 'viem/chains'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type {
   MorphoContracts,
   MorphoContractsRegistry,
-} from '@/types/lend/contracts.js'
+} from '@/actions/shared/morpho/types.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
 
 /**
  * Morpho Blue core contract - same address on all chains via CREATE2

package/src/{swap → actions/swap}/__mocks__/MockSwapProvider.ts

@@ -1,10 +1,10 @@
 import type { Address } from 'viem'
 import { type MockedFunction, vi } from 'vitest'
 
+import { SwapProvider } from '@/actions/swap/core/SwapProvider.js'
 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 { SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
@@ -110,6 +110,10 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
     return this.validateMarketAllowed(assetIn, assetOut, chainId)
   }
 
+  public testBuildSwapTransactions(quote: SwapQuote): Promise<SwapTransaction> {
+    return this.buildSwapTransactions(quote)
+  }
+
   protected async _execute(
     params: ResolvedSwapParams,
   ): Promise<SwapTransaction> {
@@ -202,7 +206,7 @@ export class MockSwapProvider extends SwapProvider<SwapProviderConfig> {
       quotedAt: now,
       expiresAt: deadline,
       gasEstimate: 150000n,
-      quotedRecipient: (params.recipient ??
+      recipient: (params.recipient ??
         '0x0000000000000000000000000000000000000001') as Address,
     }
   }