@eth-optimism/actions-sdk 0.2.0 → 0.4.0

package/src/swap/providers/velodrome/encoding/routers/v2.ts

@@ -0,0 +1,267 @@
+import type { Address, Hex, PublicClient } from 'viem'
+import { encodeAbiParameters, encodeFunctionData, encodePacked } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  LEAF_ROUTER_ABI,
+  POOL_ABI,
+  POOL_FACTORY_ABI,
+  UNIVERSAL_ROUTER_ABI,
+  V2_ROUTER_ABI,
+} from '@/swap/providers/velodrome/abis.js'
+import type { VelodromeRouterType } from '@/swap/providers/velodrome/config.js'
+import {
+  buildSwapPrice,
+  resolveTokens,
+  UNIVERSAL_ROUTER_MSG_SENDER,
+} from '@/swap/providers/velodrome/encoding/helpers.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
+import { isNativeAsset } from '@/utils/assets.js'
+
+/** Universal Router V2_SWAP_EXACT_IN command byte */
+const V2_SWAP_EXACT_IN = 0x08
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Quoting
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface GetQuoteParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  chainId: SupportedChainId
+  publicClient: PublicClient
+  routerAddress: Address
+  routerType: VelodromeRouterType
+  stable: boolean
+  factoryAddress: Address
+}
+
+/**
+ * Get a v2 AMM swap quote.
+ * @param params - Quote parameters including router type
+ * @returns Price quote with amounts and route
+ */
+export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
+  const { assetIn, assetOut, amountInRaw, chainId } = params
+  const { tokenIn, tokenOut } = resolveTokens(assetIn, assetOut, chainId)
+  const amountOutRaw = await fetchAmountOut(params, tokenIn, tokenOut)
+  const route: SwapRoute = {
+    path: [assetIn, assetOut],
+    pools: [{ address: tokenIn, fee: 0, version: 'v2' }],
+  }
+  return buildSwapPrice(assetIn, assetOut, amountInRaw, amountOutRaw, route)
+}
+
+/**
+ * Fetch the output amount using the appropriate quoting mechanism for the router type.
+ * @param params - Quote parameters
+ * @param tokenIn - Resolved input token address
+ * @param tokenOut - Resolved output token address
+ * @returns Output amount as raw bigint
+ * @throws If router type is unknown
+ */
+async function fetchAmountOut(
+  params: GetQuoteParams,
+  tokenIn: Address,
+  tokenOut: Address,
+): Promise<bigint> {
+  const { routerType } = params
+
+  if (routerType === 'universal') {
+    return fetchAmountOutViaPool(params, tokenIn, tokenOut)
+  }
+  if (routerType === 'v2') {
+    return fetchAmountOutViaRouter(params, V2_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+      factory: params.factoryAddress,
+    })
+  }
+  if (routerType === 'leaf') {
+    return fetchAmountOutViaRouter(params, LEAF_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+    })
+  }
+  throw new Error(`Unknown router type: ${routerType as string}`)
+}
+
+/** Quote via Pool.getAmountOut (Universal Router path — no router-level quoting available). */
+async function fetchAmountOutViaPool(
+  params: GetQuoteParams,
+  tokenIn: Address,
+  tokenOut: Address,
+): Promise<bigint> {
+  const { publicClient, factoryAddress, stable, assetIn, assetOut } = params
+
+  const poolAddress = await publicClient.readContract({
+    address: factoryAddress,
+    abi: POOL_FACTORY_ABI,
+    functionName: 'getPool',
+    args: [tokenIn, tokenOut, stable],
+  })
+
+  if (
+    !poolAddress ||
+    poolAddress === '0x0000000000000000000000000000000000000000'
+  ) {
+    throw new Error(
+      `No Velodrome pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (stable=${stable})`,
+    )
+  }
+
+  return (await publicClient.readContract({
+    address: poolAddress as Address,
+    abi: POOL_ABI,
+    functionName: 'getAmountOut',
+    args: [params.amountInRaw, tokenIn],
+  })) as bigint
+}
+
+/** Quote via Router.getAmountsOut (v2 and leaf router path). */
+async function fetchAmountOutViaRouter(
+  params: GetQuoteParams,
+  abi: typeof V2_ROUTER_ABI | typeof LEAF_ROUTER_ABI,
+  route: { from: Address; to: Address; stable: boolean; factory?: Address },
+): Promise<bigint> {
+  const amounts = await params.publicClient.readContract({
+    address: params.routerAddress,
+    abi,
+    functionName: 'getAmountsOut',
+    args: [params.amountInRaw, [route]],
+  })
+  return (amounts as bigint[])[1]
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Encoding
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface EncodeSwapParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  amountOutMin: bigint
+  routerType: VelodromeRouterType
+  stable: boolean
+  factoryAddress: Address
+  recipient: Address
+  deadline: number
+  chainId: SupportedChainId
+}
+
+/**
+ * Encode swap calldata for the appropriate router type.
+ * @param params - Swap encoding parameters
+ * @returns Encoded calldata as hex string
+ * @throws If router type is unknown
+ */
+export function encodeSwap(params: EncodeSwapParams): Hex {
+  const { routerType } = params
+  const { tokenIn, tokenOut } = resolveTokens(
+    params.assetIn,
+    params.assetOut,
+    params.chainId,
+  )
+
+  if (routerType === 'universal') {
+    return encodeUniversalV2Swap(tokenIn, tokenOut, params)
+  }
+  if (routerType === 'v2') {
+    return encodeRouterSwap(tokenIn, tokenOut, params, V2_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+      factory: params.factoryAddress,
+    })
+  }
+  if (routerType === 'leaf') {
+    return encodeRouterSwap(tokenIn, tokenOut, params, LEAF_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+    })
+  }
+  throw new Error(`Unknown router type: ${routerType as string}`)
+}
+
+/**
+ * Encode a V2_SWAP_EXACT_IN command for the Universal Router.
+ * Route: encodePacked(tokenIn, stable, tokenOut) — 41 bytes per hop.
+ * payerIsUser = false: tokens are pre-transferred to the Router by the smart wallet.
+ */
+function encodeUniversalV2Swap(
+  tokenIn: Address,
+  tokenOut: Address,
+  params: EncodeSwapParams,
+): Hex {
+  const commands = `0x${V2_SWAP_EXACT_IN.toString(16).padStart(2, '0')}` as Hex
+  const routes = encodePacked(
+    ['address', 'bool', 'address'],
+    [tokenIn, params.stable, tokenOut],
+  )
+  const input = encodeAbiParameters(
+    [
+      { type: 'address' },
+      { type: 'uint256' },
+      { type: 'uint256' },
+      { type: 'bytes' },
+      { type: 'bool' },
+      { type: 'bool' },
+    ],
+    [
+      UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
+      params.amountInRaw,
+      params.amountOutMin,
+      routes,
+      false, // payerIsUser
+      false, // isUni — false for Velodrome/Aerodrome
+    ],
+  )
+  return encodeFunctionData({
+    abi: UNIVERSAL_ROUTER_ABI,
+    functionName: 'execute',
+    args: [commands, [input], BigInt(params.deadline)],
+  })
+}
+
+/**
+ * Encode swap calldata for v2 or leaf routers.
+ * Selects the correct swap function based on whether native ETH is involved.
+ */
+function encodeRouterSwap(
+  tokenIn: Address,
+  tokenOut: Address,
+  params: EncodeSwapParams,
+  abi: typeof V2_ROUTER_ABI | typeof LEAF_ROUTER_ABI,
+  route: { from: Address; to: Address; stable: boolean; factory?: Address },
+): Hex {
+  const { assetIn, assetOut, amountInRaw, amountOutMin, recipient, deadline } =
+    params
+
+  if (isNativeAsset(assetIn)) {
+    return encodeFunctionData({
+      abi,
+      functionName: 'swapExactETHForTokens',
+      args: [amountOutMin, [route], recipient, BigInt(deadline)],
+    })
+  }
+
+  if (isNativeAsset(assetOut)) {
+    return encodeFunctionData({
+      abi,
+      functionName: 'swapExactTokensForETH',
+      args: [amountInRaw, amountOutMin, [route], recipient, BigInt(deadline)],
+    })
+  }
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'swapExactTokensForTokens',
+    args: [amountInRaw, amountOutMin, [route], recipient, BigInt(deadline)],
+  })
+}

package/src/swap/providers/velodrome/markets.ts

@@ -0,0 +1,100 @@
+import type { Address } from 'viem'
+import { concat, keccak256 } from 'viem'
+
+import { VELODROME } from '@/constants/providers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { assetPairs } from '@/swap/core/markets.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapMarket } from '@/types/swap/index.js'
+
+import type { ResolvedPoolConfig, VelodromeMarketConfig } from './types.js'
+
+/**
+ * Resolve a VelodromeMarketConfig to a discriminated ResolvedPoolConfig.
+ * Exactly one of stable or tickSpacing must be set.
+ * @param config - Raw market config
+ * @returns Resolved pool config with discriminated type
+ * @throws If both or neither of stable/tickSpacing are set
+ */
+export function resolvePoolConfig(
+  config: VelodromeMarketConfig,
+): ResolvedPoolConfig {
+  const hasStable = config.stable !== undefined
+  const hasTick = config.tickSpacing !== undefined
+  if (hasStable && hasTick) {
+    throw new Error(
+      'stable and tickSpacing are mutually exclusive — set one, not both',
+    )
+  }
+  if (!hasStable && !hasTick) {
+    throw new Error(
+      'Either stable (v2 AMM) or tickSpacing (CL) must be configured',
+    )
+  }
+  if (hasTick) {
+    return { type: 'cl', tickSpacing: config.tickSpacing! }
+  }
+  return { type: 'v2', stable: config.stable! }
+}
+
+/**
+ * Expand a single VelodromeMarketConfig into SwapMarket objects for a given chain.
+ * Used as the `toMarkets` callback for shared findMarket/expandMarkets.
+ * @param config - Market config with pool parameters
+ * @param chainId - Target chain
+ * @param asset - If provided, only return markets containing this asset
+ */
+export function configToMarkets(
+  config: VelodromeMarketConfig,
+  chainId: SupportedChainId,
+  asset?: Asset,
+): SwapMarket[] {
+  const poolConfig = resolvePoolConfig(config)
+  return assetPairs(config.assets, asset)
+    .map(([a, b]) => pairToMarket(a, b, chainId, poolConfig))
+    .filter((m): m is SwapMarket => m !== null)
+}
+
+/**
+ * Build a SwapMarket from two assets and Velodrome pool parameters.
+ * For v2: poolId = keccak256(sortedA, sortedB, stable)
+ * For CL: poolId = keccak256(sortedA, sortedB, tickSpacing as int24)
+ * @returns SwapMarket, or null if either asset lacks an address on this chain
+ */
+function pairToMarket(
+  assetA: Asset,
+  assetB: Asset,
+  chainId: SupportedChainId,
+  poolConfig: ResolvedPoolConfig,
+): SwapMarket | null {
+  const addrA = assetA.address[chainId]
+  const addrB = assetB.address[chainId]
+  if (!addrA || addrA === 'native' || !addrB || addrB === 'native') return null
+
+  const [sortedA, sortedB] =
+    addrA.toLowerCase() < addrB.toLowerCase() ? [addrA, addrB] : [addrB, addrA]
+
+  let poolId: string
+  if (poolConfig.type === 'cl') {
+    const tickBytes =
+      `0x${(poolConfig.tickSpacing & 0xffffff).toString(16).padStart(6, '0')}` as `0x${string}`
+    poolId = keccak256(
+      concat([sortedA as Address, sortedB as Address, tickBytes]),
+    )
+  } else {
+    poolId = keccak256(
+      concat([
+        sortedA as Address,
+        sortedB as Address,
+        poolConfig.stable ? '0x01' : '0x00',
+      ]),
+    )
+  }
+
+  return {
+    marketId: { poolId, chainId },
+    assets: [assetA, assetB],
+    fee: 0,
+    provider: VELODROME,
+  }
+}

package/src/swap/providers/velodrome/types.ts

@@ -0,0 +1,30 @@
+import type {
+  SwapMarketConfig,
+  SwapProviderConfig,
+} from '@/types/swap/index.js'
+
+/**
+ * Velodrome/Aerodrome market config.
+ * Exactly one of `stable` (v2 AMM) or `tickSpacing` (CL/Slipstream) must be set.
+ */
+export interface VelodromeMarketConfig extends SwapMarketConfig {
+  /** true = stable pool (correlated assets), false = volatile pool. For v2 AMM pools. */
+  stable?: boolean
+  /** Tick spacing for CL/Slipstream pools. Mutually exclusive with stable. */
+  tickSpacing?: number
+}
+
+/** Resolved v2 AMM pool config */
+export type ResolvedV2Config = { type: 'v2'; stable: boolean }
+/** Resolved CL/Slipstream pool config */
+export type ResolvedCLConfig = { type: 'cl'; tickSpacing: number }
+/** Discriminated union of resolved pool configs */
+export type ResolvedPoolConfig = ResolvedV2Config | ResolvedCLConfig
+
+/**
+ * Velodrome/Aerodrome swap provider configuration
+ */
+export interface VelodromeSwapProviderConfig extends SwapProviderConfig {
+  marketAllowlist?: VelodromeMarketConfig[]
+  marketBlocklist?: VelodromeMarketConfig[]
+}

package/src/types/actions.ts

@@ -1,20 +1,73 @@
+import type { UniswapSwapProviderConfig } from '@/swap/providers/uniswap/types.js'
+import type { VelodromeSwapProviderConfig } from '@/swap/providers/velodrome/types.js'
 import type { Asset } from '@/types/asset.js'
 import type { ChainConfig } from '@/types/chain.js'
 import type { LendProviderConfig } from '@/types/lend/index.js'
+import type { LendProviders, SwapProviders } from '@/types/providers.js'
+import type { SwapProviderConfig } from '@/types/swap/index.js'
 import type { ProviderSpec } from '@/wallet/core/providers/hosted/types/index.js'
 
-// Re-export LendProviderConfig for convenience
-export type { LendProviderConfig }
+// Re-export provider configs for convenience
+export type { LendProviderConfig, SwapProviderConfig }
+// Re-export centralized provider maps
+export type { LendProviders, SwapProviders } from '@/types/providers.js'
+
+/** Require at least one property to be defined */
+type RequireAtLeastOne<T> = {
+  [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>
+}[keyof T]
+
+/**
+ * Lending configuration — at least one provider must be configured
+ */
+export type LendConfig = RequireAtLeastOne<{
+  [K in keyof LendProviders]: LendProviderConfig
+}>
+
+/** Names of available swap providers — derived from SwapProviders registry */
+export type SwapProviderName = keyof SwapProviders
+
+/** Names of available lend providers — derived from LendProviders registry */
+export type LendProviderName = keyof LendProviders
+
+/** Routing strategy for selecting a provider when multiple are configured. */
+export type SwapRoutingStrategy = 'price'
+
+/**
+ * Shared swap settings applied across all providers.
+ * Provider-level values override these when set.
+ */
+export interface SwapSettings {
+  /** Default slippage tolerance (e.g., 0.005 for 0.5%). Defaults to 0.005. */
+  defaultSlippage?: number
+  /** Maximum allowed slippage (e.g., 0.5 for 50%). Defaults to 0.5. */
+  maxSlippage?: number
+  /** Quote expiration in seconds from now. Defaults to 60. */
+  quoteExpirationSeconds?: number
+  /** Permit2 sub-approval expiration in seconds from now. Defaults to 2592000 (30 days). */
+  permit2ExpirationSeconds?: number
+  /**
+   * Routing strategy for multi-provider selection.
+   * 'price' fetches quotes from all eligible providers and returns the best price.
+   * Omit to fall back to market-matching heuristics.
+   */
+  routing?: SwapRoutingStrategy
+  /** Provider to prefer when routing produces a tie, or to always use when no routing strategy is set. */
+  defaultProvider?: SwapProviderName
+}
 
 /**
- * Lending configuration
- * @description Configuration for all lending providers
+ * Swap configuration — at least one provider must be configured.
+ * Shared settings go in `config`; per-provider settings go under the provider key.
  */
-export interface LendConfig {
-  /** Morpho lending provider configuration */
-  morpho?: LendProviderConfig
-  /** Aave lending provider configuration */
-  aave?: LendProviderConfig
+export type SwapConfig = RequireAtLeastOne<{
+  /** Uniswap swap provider configuration */
+  uniswap?: UniswapSwapProviderConfig
+  /** Velodrome/Aerodrome swap provider configuration */
+  velodrome?: VelodromeSwapProviderConfig
+}> & {
+  /** Shared settings applied across all providers */
+  settings?: SwapSettings
 }
 
 /**
@@ -28,12 +81,13 @@ export interface LendNetworkConfig {
 
 /**
  * Assets configuration
- * @description Configuration for supported assets
+ * @description Configuration for supported assets. Import token constants from the SDK
+ * or define your own Asset objects.
  */
 export interface AssetsConfig {
-  /** Allowlist of assets to support (optional - defaults to all SUPPORTED_TOKENS) */
+  /** Allowlist of assets to support. No default — developers must explicitly configure. */
   allow?: Asset[]
-  /** Blocklist of assets to exclude (optional) */
+  /** Blocklist of assets to exclude from the allow list. Only effective when allow is also set. For future use with runtime asset fetching. */
   block?: Asset[]
 }
 
@@ -49,6 +103,8 @@ export interface ActionsConfig<
   wallet: WalletConfig<THostedWalletProviderType, TConfigMap>
   /** Lending providers configuration (optional) */
   lend?: LendConfig
+  /** Swap providers configuration (optional) */
+  swap?: SwapConfig
   /** Assets configuration (optional) */
   assets?: AssetsConfig
   /** Chains to use for the SDK */

package/src/types/asset.ts

@@ -22,13 +22,16 @@ export interface Asset {
  * Detailed token balance information
  */
 export interface TokenBalance {
-  symbol: string
-  totalBalance: bigint
-  totalFormattedBalance: string
-  chainBalances: Array<{
-    chainId: SupportedChainId
-    balance: bigint
-    tokenAddress: Address | 'native'
-    formattedBalance: string
-  }>
+  asset: Asset
+  totalBalance: number
+  totalBalanceRaw: bigint
+  chains: Partial<
+    Record<
+      SupportedChainId,
+      {
+        balance: number
+        balanceRaw: bigint
+      }
+    >
+  >
 }

package/src/types/chain.ts

@@ -1,4 +1,4 @@
-import type { SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
 
 /**
  * Chain configuration
@@ -6,7 +6,7 @@ import type { SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
  */
 export interface ChainConfig {
   /** Chain ID */
-  chainId: (typeof SUPPORTED_CHAIN_IDS)[number]
+  chainId: SupportedChainId
   /** RPC URL for the chain */
   rpcUrls?: string[]
   /** Bundler configuration */

package/src/types/index.ts

@@ -2,4 +2,6 @@ export * from '@/types/actions.js'
 export * from '@/types/asset.js'
 export * from '@/types/chain.js'
 export * from '@/types/lend/index.js'
+export * from '@/types/swap/index.js'
+export * from '@/types/transaction.js'
 export * from '@/types/wallet.js'

package/src/types/lend/base.ts

@@ -1,7 +1,10 @@
-import type { Address, Hex } from 'viem'
+import type { Address } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { LendProviderName } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
+// Import and re-export shared transaction type for backwards compatibility
+import type { TransactionData } from '@/types/transaction.js'
 import type {
   BatchTransactionReturnType,
   TransactionReturnType,
@@ -10,6 +13,7 @@ import type {
 export { LendProvider } from '@/lend/core/LendProvider.js'
 export { ActionsLendNamespace } from '@/lend/namespaces/ActionsLendNamespace.js'
 export { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
+export type { TransactionData }
 
 /**
  * Lending market identifier
@@ -30,7 +34,7 @@ export type LendMarketConfigMetadata = {
   /** Asset information for this market */
   asset: Asset
   /** Lending provider type */
-  lendProvider: 'morpho' | 'aave'
+  lendProvider: LendProviderName
 }
 
 /**
@@ -45,19 +49,6 @@ export type LendMarketConfig = LendMarketId & LendMarketConfigMetadata
  */
 export type GetLendMarketParams = LendMarketId
 
-/**
- * Transaction data for execution
- * @description Raw transaction data for wallet execution
- */
-export interface TransactionData {
-  /** Target contract address */
-  to: Address
-  /** Encoded function call data */
-  data: Hex
-  /** ETH value to send */
-  value: bigint
-}
-
 /**
  * Supply metrics for a lending market
  * @description Total assets and shares in the vault
@@ -145,7 +136,8 @@ export interface LendMarketInfo extends LendMarketBase {
 
 /**
  * APY breakdown for detailed display
- * @description Breakdown of APY components following Morpho's official methodology
+ * @description Breakdown of APY components following Morpho's official methodology.
+ * Individual token reward APRs are keyed by lowercase token address.
  */
 export interface ApyBreakdown {
   /** Total net APY after all components and fees */
@@ -154,12 +146,10 @@ export interface ApyBreakdown {
   native: number
   /** Total rewards APR from all sources */
   totalRewards: number
-  /** Individual token rewards APRs (dynamically populated) */
-  usdc?: number
-  morpho?: number
-  other?: number
   /** Performance/management fee rate */
   performanceFee: number
+  /** Individual token reward APRs keyed by address, plus 'other' for unrecognized */
+  [key: string]: number | undefined
 }
 
 /**

package/src/types/lend/contracts.ts

@@ -1,5 +1,7 @@
 import type { Address } from 'viem'
 
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
 /**
  * Morpho contract addresses needed per chain
  */
@@ -15,4 +17,6 @@ export interface MorphoContracts {
 /**
  * Registry mapping chainId to Morpho contracts
  */
-export type MorphoContractsRegistry = Record<number, MorphoContracts>
+export type MorphoContractsRegistry = Partial<
+  Record<SupportedChainId, MorphoContracts>
+>

package/src/types/providers.ts

@@ -0,0 +1,22 @@
+import type { LendProvider } from '@/lend/core/LendProvider.js'
+import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import type { LendProviderConfig } from '@/types/lend/index.js'
+import type { SwapProviderConfig } from '@/types/swap/index.js'
+
+/**
+ * Map of available lend providers keyed by provider name.
+ * Add new lend providers here — this is the single source of truth.
+ */
+export type LendProviders = {
+  morpho?: LendProvider<LendProviderConfig>
+  aave?: LendProvider<LendProviderConfig>
+}
+
+/**
+ * Map of available swap providers keyed by provider name.
+ * Add new swap providers here — this is the single source of truth.
+ */
+export type SwapProviders = {
+  uniswap?: SwapProvider<SwapProviderConfig>
+  velodrome?: SwapProvider<SwapProviderConfig>
+}