sushi 6.7.0 → 7.0.0

package/evm/api/swap.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import { EvmChainId } from '../chain/index.js'
 import { WNATIVE_ADDRESS } from '../config/tokens/index.js'
 import { getSwap, type SwapRequest } from './swap.js'
@@ -13,6 +13,8 @@ const baseSwapRequest = {
 } as const satisfies SwapRequest
 
 describe('getSwap', () => {
+  afterEach(() => vi.unstubAllGlobals())
+
   it('should return a swap when recipient is included', async () => {
     const result = await getSwap({
       ...baseSwapRequest,
@@ -45,4 +47,55 @@ describe('getSwap', () => {
 
     expect(result).include({ status: 'Success' })
   })
+
+  it('rejects parameters outside the aggregator bounds', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(
+      getSwap({ ...baseSwapRequest, maxSlippage: 1 }),
+    ).rejects.toThrow()
+    await expect(
+      getSwap({ ...baseSwapRequest, maxPriceImpact: 0 }),
+    ).rejects.toThrow()
+    await expect(getSwap({ ...baseSwapRequest, fee: 0.51 })).rejects.toThrow()
+
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('requires fee and feeReceiver together', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(getSwap({ ...baseSwapRequest, fee: 0.003 })).rejects.toThrow(
+      'Fee receiver is required',
+    )
+    await expect(
+      getSwap({
+        ...baseSwapRequest,
+        feeReceiver: WNATIVE_ADDRESS[EvmChainId.ETHEREUM],
+      }),
+    ).rejects.toThrow('Fee is required')
+
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('sends a valid fractional fee and receiver', async () => {
+    const fetchMock = vi.fn(async (_input: string | URL | Request) =>
+      Response.json({ status: 'NoWay' }),
+    )
+    vi.stubGlobal('fetch', fetchMock)
+
+    await getSwap({
+      ...baseSwapRequest,
+      fee: 0.003,
+      feeReceiver: WNATIVE_ADDRESS[EvmChainId.ETHEREUM],
+    })
+
+    const url = new URL(fetchMock.mock.calls[0]![0] as string)
+    expect(url.searchParams.get('fee')).toBe('0.003')
+    expect(url.searchParams.get('feeReceiver')).toBe(
+      WNATIVE_ADDRESS[EvmChainId.ETHEREUM],
+    )
+  })
 })

package/evm/api/swap.ts

@@ -2,13 +2,12 @@ import type { Address } from 'viem'
 import * as z from 'zod'
 import { sz } from '../../generic/validate/zod.js'
 import { version } from '../../version.js'
-import type { SwapApiSupportedChainId } from '../config/index.js'
-import { szevm } from '../validate/zod.js'
 import {
-  type RouterLiquiditySource,
-  RouteStatus,
-  type TransferValue,
-} from './types.js'
+  isSwapApiSupportedChainId,
+  type SwapApiSupportedChainId,
+} from '../config/index.js'
+import { szevm } from '../validate/zod.js'
+import { RouterLiquiditySource, RouteStatus, TransferValue } from './types.js'
 
 export type SwapRequest<Simulate extends boolean = true> = {
   chainId: SwapApiSupportedChainId
@@ -19,7 +18,7 @@ export type SwapRequest<Simulate extends boolean = true> = {
   maxSlippage: number
   maxPriceImpact?: number
   source?: RouterLiquiditySource
-  fee?: bigint
+  fee?: number
   feeReceiver?: Address
   feeBy?: TransferValue
   referrer?: string
@@ -30,6 +29,43 @@ export type SwapRequest<Simulate extends boolean = true> = {
   apiKey?: string
 }
 
+const swapRequestSchema = z
+  .object({
+    chainId: z.number().int().refine(isSwapApiSupportedChainId),
+    tokenIn: szevm.address(),
+    tokenOut: szevm.address(),
+    amount: z.bigint().positive(),
+    sender: szevm.address(),
+    maxSlippage: z.number().gte(0).lt(1),
+    maxPriceImpact: z.number().positive().lte(1).optional(),
+    source: z.enum(RouterLiquiditySource).optional(),
+    fee: z.number().gte(0).lte(0.5).optional(),
+    feeReceiver: szevm.address().optional(),
+    feeBy: z.enum(TransferValue).optional(),
+    referrer: z.string().min(1).optional(),
+    baseUrl: z.url().optional(),
+    recipient: szevm.address().optional(),
+    simulate: z.boolean().optional(),
+    validate: z.boolean().optional(),
+    apiKey: z.string().min(1).optional(),
+  })
+  .superRefine((params, ctx) => {
+    if (params.fee && !params.feeReceiver) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Fee receiver is required when fee is set',
+        path: ['feeReceiver'],
+      })
+    }
+    if (params.feeReceiver && !params.fee) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Fee is required when fee receiver is set',
+        path: ['fee'],
+      })
+    }
+  })
+
 function swapResponseSchema<Simulate extends boolean>(simulate?: Simulate) {
   const tokenSchema = z.object({
     address: szevm.address(),
@@ -93,7 +129,7 @@ export async function getSwap<Simulate extends boolean = true>(
   params: SwapRequest<Simulate>,
   options?: RequestInit,
 ): Promise<SwapResponse<Simulate>> {
-  // TODO: VALIDATE PARAMS
+  params = swapRequestSchema.parse(params) as SwapRequest<Simulate>
   const url = new URL(
     `swap/v7/${params.chainId}`,
     params.baseUrl ?? 'https://api.sushi.com',
@@ -118,8 +154,8 @@ export async function getSwap<Simulate extends boolean = true>(
   }
 
   if (
-    typeof params.fee === 'bigint' &&
-    params.fee > 0n &&
+    typeof params.fee === 'number' &&
+    params.fee > 0 &&
     params.feeReceiver !== undefined
   ) {
     url.searchParams.append('fee', params.fee.toString())

package/evm/chain/define-chain.ts

@@ -1,7 +1,7 @@
 import type { Address, Hex, Chain as ViemChain } from 'viem'
 import type {
   BlockExplorers,
-  Chain,
+  ChainDefinition,
   NetType,
 } from '../../generic/chain/interface.js'
 import type { EvmChainId, EvmChainKey } from '../chain/chains.js'
@@ -9,9 +9,11 @@ import type { EvmAddress } from '../currency/token.js'
 
 export type EvmChainType = 'evm'
 
-type EvmChainBase<TChainId extends number, TChainKey extends string> = Chain<
+type EvmChainBase<
+  TChainId extends number,
+  TChainKey extends string,
+> = ChainDefinition<
   EvmChainType,
-  // @ts-expect-error infinite loop
   TChainId,
   TChainKey,
   Readonly<string>,

package/evm/config/features/init-code-hash.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import * as features from './index.js'
+
+describe('DEX init code hashes', () => {
+  it('are 32-byte hex values', () => {
+    for (const [name, value] of Object.entries(features)) {
+      if (!name.endsWith('_INIT_CODE_HASH')) continue
+
+      const hashes = typeof value === 'string' ? [value] : Object.values(value)
+      for (const hash of hashes) {
+        expect(hash, name).toMatch(/^0x[0-9a-f]{64}$/i)
+      }
+    }
+  })
+})

package/evm/config/features/master-chef.ts

@@ -2,10 +2,6 @@ import { EvmChainId } from '../../chain/index.js'
 
 export const MASTERCHEF_ADDRESS = {
   [EvmChainId.ETHEREUM]: '0xc2edad668740f1aa35e4d8f227fb8e17dca888cd',
-  // [EvmChainId.ROPSTEN]: '0x80c7dd17b01855a6d2347444a0fcc36136a314de',
-  // [EvmChainId.RINKEBY]: '0x80c7dd17b01855a6d2347444a0fcc36136a314de',
-  // [EvmChainId.GÖRLI]: '0x80c7dd17b01855a6d2347444a0fcc36136a314de',
-  // [EvmChainId.KOVAN]: '0x80c7dd17b01855a6d2347444a0fcc36136a314de',
 } as const
 
 export const MASTERCHEF_V2_ADDRESS = {

package/evm/config/features/pancakeswap-v2.ts

@@ -33,7 +33,6 @@ export const PANCAKESWAP_V2_FACTORY_ADDRESS: Record<
   [EvmChainId.LINEA]: '0x02a84c1b3bbd7401a5f7fa98a384ebc70bb5749e',
   [EvmChainId.BASE]: '0x02a84c1b3bbd7401a5f7fa98a384ebc70bb5749e',
   [EvmChainId.MONAD]: '0x02a84c1b3bbd7401a5f7fa98a384ebc70bb5749e',
-  // [EvmChainId.OP_BNB]: '0x02a84c1b3bbd7401a5f7fa98a384ebc70bb5749e',
 } as const
 
 export const PANCAKESWAP_V2_INIT_CODE_HASH: Record<
@@ -53,9 +52,7 @@ export const PANCAKESWAP_V2_INIT_CODE_HASH: Record<
   [EvmChainId.LINEA]:
     '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d',
   [EvmChainId.BASE]:
-    '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d ',
+    '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d',
   [EvmChainId.MONAD]:
-    '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d ',
-  // [EvmChainId.OP_BNB]:
-  //   '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d ',
+    '0x57224589c67f3f30a6b0d7a1b54cf3153ab84563bc609ef41dfb34f8b2974d2d',
 } as const

package/evm/config/features/uniswap-v2.ts

@@ -41,3 +41,8 @@ export const UNISWAP_V2_SUPPORTED_CHAIN_IDS = [
 export const UniswapV2ChainIds = UNISWAP_V2_SUPPORTED_CHAIN_IDS
 
 export type UniswapV2ChainId = (typeof UNISWAP_V2_SUPPORTED_CHAIN_IDS)[number]
+
+export const isUniswapV2ChainId = (
+  chainId: number,
+): chainId is UniswapV2ChainId =>
+  UNISWAP_V2_SUPPORTED_CHAIN_IDS.includes(chainId as UniswapV2ChainId)

package/evm/currency/deserialize-currency.ts

@@ -1,3 +1,4 @@
+import { createCurrencyDeserializer } from '../../generic/currency/deserialize-currency.js'
 import { EvmNative, type SerializedEvmNative } from './native.js'
 import { EvmToken, type SerializedEvmToken } from './token.js'
 
@@ -7,11 +8,12 @@ function deserializeEvmCurrency(data: SerializedEvmNative): EvmNative
 function deserializeEvmCurrency(
   data: SerializedEvmNative | SerializedEvmToken,
 ) {
-  if (data.type === 'native') {
-    return new EvmNative(data)
-  } else {
-    return new EvmToken(data)
-  }
+  return deserialize({ ...data, type: data.type })
 }
 
+const deserialize = createCurrencyDeserializer({
+  native: EvmNative,
+  token: EvmToken,
+})
+
 export { deserializeEvmCurrency }

package/evm/currency/token.ts

@@ -1,7 +1,8 @@
 import invariant from 'tiny-invariant'
 import { type Address, type Hex, isAddress } from 'viem'
-import * as z from 'zod'
+import type * as z from 'zod'
 import type { CurrencyMetadata } from '../../generic/currency/currency.js'
+import { createSerializedTokenSchema } from '../../generic/currency/serialized-token.js'
 import { Token } from '../../generic/currency/token.js'
 import { type EvmChainId, isEvmChainId } from '../chain/chains.js'
 import { normalizeEvmAddress } from '../utils/normalize-address.js'
@@ -64,7 +65,7 @@ export class EvmToken<
       type: this.type,
 
       metadata: this.metadata,
-    } as const
+    }
   }
 
   static fromJSON<TMetadata extends CurrencyMetadata>(
@@ -83,26 +84,10 @@ export const serializedEvmTokenSchema = <
 }: {
   metadata?: z.ZodType<TMetadata>
 } = {}) =>
-  z.object({
-    chainId: z
-      .number()
-      .int()
-      .refine(isEvmChainId)
-      .transform((chainId) => chainId as EvmChainId),
-    address: z
-      .string()
-      .refine(isEvmAddress)
-      .transform((address) => address as EvmAddress),
-    symbol: z.string(),
-    name: z.string(),
-    decimals: z.number().int().nonnegative(),
-    type: z.literal('token'),
-
-    metadata: (metadata ||
-      z
-        .record(z.string(), z.unknown())
-        .optional()
-        .default({})) as z.ZodType<TMetadata>,
+  createSerializedTokenSchema({
+    isChainId: isEvmChainId,
+    isAddress: isEvmAddress,
+    metadata,
   })
 
 export type SerializedEvmToken<

package/evm/pool/sushiswap-v3/utils/tickList.ts

@@ -67,7 +67,6 @@ export abstract class TickList {
     let l = 0
     let r = ticks.length - 1
     let i
-    // eslint-disable-next-line no-constant-condition
     while (true) {
       i = Math.floor((l + r) / 2)
 

package/evm/token-list/index.ts

@@ -1,2 +1 @@
-export * from '@uniswap/token-lists'
 export * from './constants.js'

package/evm/types/sushi-pool/steer-vault-id.ts

@@ -1,5 +1,5 @@
-import type { SushiSwapV3ChainId } from '~/evm/config/features/sushiswap-v3.js'
-import type { EvmAddress } from '~/evm/currency/token.js'
+import type { SushiSwapV3ChainId } from '../../config/features/sushiswap-v3.js'
+import type { EvmAddress } from '../../currency/token.js'
 import type { EvmID } from '../id.js'
 
 export type SteerVaultId = {

package/evm/validate/zod.ts

@@ -1,14 +1,9 @@
-import * as z from 'zod'
-import { type EvmAddress, isEvmAddress } from '../currency/token.js'
+import { createAddressSchema } from '../../generic/validate/create-address-schema.js'
+import { isEvmAddress } from '../currency/token.js'
 import { normalizeEvmAddress } from '../utils/normalize-address.js'
 
 export const evmAddress = () =>
-  z
-    .string()
-    .refine((value) => isEvmAddress(value), {
-      message: 'Invalid address',
-    })
-    .transform((value) => normalizeEvmAddress(value as EvmAddress))
+  createAddressSchema(isEvmAddress, normalizeEvmAddress)
 
 export const szevm = {
   address: evmAddress,

package/generic/chain/chains.test-d.ts

@@ -0,0 +1,35 @@
+import { expectTypeOf, test } from 'vitest'
+import type { EvmChainId } from '../../evm/chain/chains.js'
+import type { SvmChainId } from '../../svm/chain/chains.js'
+import type { AddressFor, TxHashFor } from '../types/for-chain.js'
+import { type ChainId, getChainById } from './chains.js'
+import type { Chain, ChainDefinition } from './interface.js'
+
+test('public Chain only accepts registered chain IDs and keys', () => {
+  // @ts-expect-error 999999 and unknown are not registered
+  expectTypeOf<Chain<'evm', 999999, 'unknown'>>()
+
+  expectTypeOf<ChainDefinition<'evm', 999999, 'unknown'>>().not.toBeNever()
+})
+
+test('getChainById URL methods remain callable for generic chain IDs', () => {
+  function getExplorerUrls<TChainId extends ChainId>(
+    chainId: TChainId,
+    address: AddressFor<TChainId>,
+    txHash: TxHashFor<TChainId>,
+  ) {
+    const chain = getChainById(chainId)
+
+    return {
+      account: chain.getAccountUrl(address),
+      token: chain.getTokenUrl(address),
+      transaction: chain.getTransactionUrl(txHash),
+    }
+  }
+
+  expectTypeOf(getExplorerUrls).toBeCallableWith(
+    1 as EvmChainId | SvmChainId,
+    'address' as AddressFor<EvmChainId | SvmChainId>,
+    'hash' as TxHashFor<EvmChainId | SvmChainId>,
+  )
+})

package/generic/chain/chains.ts

@@ -48,9 +48,11 @@ export function isChainId(chainId: number): chainId is ChainId {
   return chains.some((chain) => chain.chainId === chainId)
 }
 
-type ChainById<C extends ChainId> = Extract<
-  (typeof chains)[number],
-  { chainId: C }
+type ChainUrlMethod = 'getTransactionUrl' | 'getAccountUrl' | 'getTokenUrl'
+
+type ChainById<C extends ChainId> = Omit<
+  Extract<(typeof chains)[number], { chainId: C }>,
+  ChainUrlMethod
 > & {
   getTransactionUrl: (input: TxHashFor<C>) => string
   getAccountUrl: (input: AddressFor<C>) => string
@@ -58,7 +60,9 @@ type ChainById<C extends ChainId> = Extract<
 }
 
 export function getChainById<C extends ChainId>(chainId: C) {
-  return chains.find((chain) => chain.chainId === chainId)! as ChainById<C>
+  return chains.find(
+    (chain) => chain.chainId === chainId,
+  )! as unknown as ChainById<C>
 }
 
 // MainnetChainId

package/generic/chain/define-chain.ts

@@ -0,0 +1,45 @@
+import type {
+  BlockExplorers,
+  ChainDefinition,
+  ChainType,
+  NetType,
+} from './interface.js'
+
+type ChainBase<
+  TType extends ChainType,
+  TAddress extends string,
+> = ChainDefinition<
+  TType,
+  number,
+  string,
+  string,
+  string,
+  NetType,
+  BlockExplorers,
+  TAddress,
+  string
+>
+
+export type ChainUrlBuilders<TAddress extends string> = {
+  transaction: (baseUrl: string, input: string) => string
+  account: (baseUrl: string, input: string) => string
+  token: (baseUrl: string, input: TAddress) => string
+}
+
+export function defineChain<
+  const TType extends ChainType,
+  TAddress extends string,
+  const T extends Omit<
+    ChainBase<TType, TAddress>,
+    'type' | 'getTransactionUrl' | 'getAccountUrl' | 'getTokenUrl'
+  >,
+>(type: TType, chain: T, urls: ChainUrlBuilders<TAddress>) {
+  const baseUrl = chain.blockExplorers.default.url
+  return {
+    ...chain,
+    type,
+    getTransactionUrl: (input: string) => urls.transaction(baseUrl, input),
+    getAccountUrl: (input: string) => urls.account(baseUrl, input),
+    getTokenUrl: (input: TAddress) => urls.token(baseUrl, input),
+  } as const satisfies ChainBase<TType, TAddress>
+}

package/generic/chain/index.ts

@@ -1,2 +1,3 @@
 export * from './chains.js'
+export * from './define-chain.js'
 export type * from './interface.js'

package/generic/chain/interface.ts

@@ -23,10 +23,11 @@ export type BlockExplorers = {
   }
 }
 
-export type Chain<
+/** @internal Used while constructing the registry that defines ChainId/ChainKey. */
+export type ChainDefinition<
   TType extends ChainType = ChainType,
-  TChainId extends ChainId = ChainId,
-  TKey extends ChainKey = ChainKey,
+  TChainId extends number = number,
+  TKey extends string = string,
   TName extends string = string,
   TShortName extends string = string,
   TNetType extends Readonly<NetType> = Readonly<NetType>,
@@ -42,7 +43,29 @@ export type Chain<
   netType: TNetType
   blockExplorers: TBlockExplorerKeys
 
-  getTransactionUrl: (input: TAddress) => string
-  getAccountUrl: (input: TTransactionHash) => string
+  getTransactionUrl: (input: TTransactionHash) => string
+  getAccountUrl: (input: TAddress) => string
   getTokenUrl: (input: TAddress) => string
 }>
+
+export type Chain<
+  TType extends ChainType = ChainType,
+  TChainId extends ChainId = ChainId,
+  TKey extends ChainKey = ChainKey,
+  TName extends string = string,
+  TShortName extends string = string,
+  TNetType extends Readonly<NetType> = Readonly<NetType>,
+  TBlockExplorerKeys extends BlockExplorers = BlockExplorers,
+  TAddress extends string = string,
+  TTransactionHash extends string = string,
+> = ChainDefinition<
+  TType,
+  TChainId,
+  TKey,
+  TName,
+  TShortName,
+  TNetType,
+  TBlockExplorerKeys,
+  TAddress,
+  TTransactionHash
+>

package/generic/currency/currency.test-d.ts

@@ -1,10 +1,8 @@
 import { it } from 'node:test'
 import { describe, expect, expectTypeOf } from 'vitest'
 import * as z from 'zod'
-import type { EvmChainId } from '~/evm/chain/chains.js'
-import type { EvmCurrency } from '~/evm/currency/currency.js'
-import type { EvmID } from '~/evm/types/id.js'
-import { svmAddress } from '~/svm/currency/token.js'
+import type { EvmChainId } from '../../evm/chain/chains.js'
+import type { EvmCurrency } from '../../evm/currency/currency.js'
 import { EvmNative } from '../../evm/currency/native.js'
 import {
   type EvmAddress,
@@ -12,7 +10,9 @@ import {
   type SerializedEvmToken,
   serializedEvmTokenSchema,
 } from '../../evm/currency/token.js'
+import type { EvmID } from '../../evm/types/id.js'
 import { MvmToken } from '../../mvm/currency/token.js'
+import { svmAddress } from '../../svm/currency/token.js'
 import {
   type SvmAddress,
   type SvmChainId,

package/generic/currency/deserialize-currency.ts

@@ -0,0 +1,11 @@
+export function createCurrencyDeserializer<
+  const TConstructors extends Record<string, new (data: any) => any>,
+>(constructors: TConstructors) {
+  return <TType extends keyof TConstructors & string>(data: {
+    type: TType
+  }): InstanceType<TConstructors[TType]> => {
+    const Constructor = constructors[data.type]
+    if (!Constructor) throw new Error(`Unsupported currency type: ${data.type}`)
+    return new Constructor(data)
+  }
+}

package/generic/currency/index.ts

@@ -1,8 +1,10 @@
 export * from './amount.js'
 export * from './currency.js'
+export * from './deserialize-currency.js'
 export * from './for-chain.js'
 export * from './native.js'
 export * from './price.js'
 export * from './serialized-currency.js'
+export * from './serialized-token.js'
 export * from './token.js'
 export * from './unwrap-token.js'

package/generic/currency/price.test-d.ts

@@ -0,0 +1,59 @@
+import { it } from 'node:test'
+import { describe, expectTypeOf } from 'vitest'
+import { Price } from './price.js'
+import { Token } from './token.js'
+
+class BaseToken extends Token {
+  public override toJSON() {
+    return {} as any
+  }
+
+  public override wrap() {
+    return this
+  }
+}
+
+class QuoteToken extends Token {
+  public override toJSON() {
+    return {} as any
+  }
+
+  public override wrap() {
+    return this
+  }
+}
+
+const base = new BaseToken({
+  chainId: 1,
+  address: '0x1234567890abcdef1234567890abcdef12345678',
+  symbol: 'BASE',
+  name: 'Base',
+  decimals: 18,
+})
+
+const quote = new QuoteToken({
+  chainId: 1,
+  address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+  symbol: 'QUOTE',
+  name: 'Quote',
+  decimals: 6,
+})
+
+describe('generic/currency/price.ts types', () => {
+  it('preserves concrete base and quote currency types', () => {
+    const price = Price.fromHuman(base, quote, '1.25')
+
+    expectTypeOf(price).toEqualTypeOf<Price<BaseToken, QuoteToken>>()
+    expectTypeOf(price.base).toEqualTypeOf<BaseToken>()
+    expectTypeOf(price.quote).toEqualTypeOf<QuoteToken>()
+    expectTypeOf(price.invert()).toEqualTypeOf<Price<QuoteToken, BaseToken>>()
+  })
+
+  it('preserves types when trying to create a price', () => {
+    const price = Price.tryFromHuman(base, quote, '1.25')
+
+    expectTypeOf(price).toEqualTypeOf<
+      Price<BaseToken, QuoteToken> | undefined
+    >()
+  })
+})