sushi 6.0.12 → 6.0.13

package/evm/config/tokens/wrapped-native.ts

@@ -0,0 +1,250 @@
+import { zeroAddress } from 'viem'
+import type { Address } from 'viem'
+import type { EvmCurrency } from '../../../evm/currency/currency.js'
+import { EvmChainId } from '../../chain/index.js'
+import { EvmToken } from '../../currency/token.js'
+import { WETH9, WETH9_ADDRESS } from './tokens/WETH9.js'
+import { WRBTC, WRBTC_ADDRESS } from './tokens/WRBTC.js'
+
+export const WNATIVE_ADDRESS = {
+  [EvmChainId.ETHEREUM]: WETH9_ADDRESS[EvmChainId.ETHEREUM],
+  [EvmChainId.SEPOLIA]: WETH9_ADDRESS[EvmChainId.SEPOLIA],
+  [EvmChainId.OPTIMISM]: WETH9_ADDRESS[EvmChainId.OPTIMISM],
+  [EvmChainId.ARBITRUM]: WETH9_ADDRESS[EvmChainId.ARBITRUM],
+  [EvmChainId.ARBITRUM_SEPOLIA]: WETH9_ADDRESS[EvmChainId.ARBITRUM_SEPOLIA],
+  [EvmChainId.FANTOM]: '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83',
+  [EvmChainId.POLYGON]: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
+  [EvmChainId.GNOSIS]: '0xe91d153e0b41518a2ce8dd3d7944fa863463a97d',
+  [EvmChainId.BSC]: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
+  [EvmChainId.AVALANCHE]: '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7',
+  [EvmChainId.HARMONY]: '0xcf664087a5bb0237a0bad6742852ec6c8d69a27a',
+  [EvmChainId.CELO]: '0x471ece3750da237f93b8e339c536989b8978a438',
+  [EvmChainId.KAVA]: '0xc86c7c0efbd6a49b35e8714c5f59d99de09a225b',
+  [EvmChainId.METIS]: '0x75cb093e4d61d2a2e65d8e0bbb01de8d89b53481',
+  [EvmChainId.ARBITRUM_NOVA]: WETH9_ADDRESS[EvmChainId.ARBITRUM_NOVA],
+  [EvmChainId.BOBA]: WETH9_ADDRESS[EvmChainId.BOBA],
+  [EvmChainId.BOBA_BNB]: '0xc58aad327d6d58d979882601ba8dda0685b505ea',
+  [EvmChainId.BTTC]: '0x23181f21dea5936e24163ffaba4ea3b316b57f3c',
+  [EvmChainId.POLYGON_ZKEVM]: WETH9_ADDRESS[EvmChainId.POLYGON_ZKEVM],
+  [EvmChainId.THUNDERCORE]: '0x413cefea29f2d07b8f2acfa69d92466b9535f717',
+  [EvmChainId.FILECOIN]: '0x60e1773636cf5e4a227d9ac24f20feca034ee25a',
+  [EvmChainId.HAQQ]: '0xec8cc083787c6e5218d86f9ff5f28d4cc377ac54',
+  [EvmChainId.CORE]: '0x40375c92d9faf44d2f9db9bd9ba41a3317a2404f',
+  [EvmChainId.ZKSYNC_ERA]: WETH9_ADDRESS[EvmChainId.ZKSYNC_ERA],
+  [EvmChainId.LINEA]: WETH9_ADDRESS[EvmChainId.LINEA],
+  [EvmChainId.BASE]: WETH9_ADDRESS[EvmChainId.BASE],
+  [EvmChainId.SCROLL]: WETH9_ADDRESS[EvmChainId.SCROLL],
+  [EvmChainId.ZETACHAIN]: '0x5f0b1a82749cb4e2278ec87f8bf6b618dc71a8bf',
+  [EvmChainId.CRONOS]: '0x5c7f8a570d578ed84e63fdfa7b1ee72deae1ae23',
+  [EvmChainId.BLAST]: WETH9_ADDRESS[EvmChainId.BLAST],
+  [EvmChainId.SKALE_EUROPA]: zeroAddress,
+  [EvmChainId.ROOTSTOCK]: WRBTC_ADDRESS[EvmChainId.ROOTSTOCK],
+  [EvmChainId.MANTLE]: '0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8',
+  [EvmChainId.MANTA]: WETH9_ADDRESS[EvmChainId.MANTA],
+  [EvmChainId.MODE]: WETH9_ADDRESS[EvmChainId.MODE],
+  [EvmChainId.TAIKO]: WETH9_ADDRESS[EvmChainId.TAIKO],
+  [EvmChainId.ZKLINK]: WETH9_ADDRESS[EvmChainId.ZKLINK],
+  [EvmChainId.APE]: '0x48b62137edfa95a428d35c09e44256a739f6b557',
+  [EvmChainId.SONIC]: '0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38',
+  [EvmChainId.HEMI]: WETH9_ADDRESS[EvmChainId.HEMI],
+  [EvmChainId.TATARA]: WETH9_ADDRESS[EvmChainId.TATARA],
+  [EvmChainId.KATANA]: WETH9_ADDRESS[EvmChainId.KATANA],
+  [EvmChainId.HYPEREVM]: WETH9_ADDRESS[EvmChainId.HYPEREVM],
+} as const satisfies Record<EvmChainId, Address>
+
+export const WNATIVE = {
+  [EvmChainId.ETHEREUM]: WETH9[EvmChainId.ETHEREUM],
+  [EvmChainId.SEPOLIA]: WETH9[EvmChainId.SEPOLIA],
+  [EvmChainId.OPTIMISM]: WETH9[EvmChainId.OPTIMISM],
+  [EvmChainId.FANTOM]: new EvmToken({
+    chainId: EvmChainId.FANTOM,
+    address: WNATIVE_ADDRESS[EvmChainId.FANTOM],
+    decimals: 18,
+    symbol: 'WFTM',
+    name: 'Wrapped FTM',
+  }),
+  [EvmChainId.POLYGON]: new EvmToken({
+    chainId: EvmChainId.POLYGON,
+    address: WNATIVE_ADDRESS[EvmChainId.POLYGON],
+    decimals: 18,
+    symbol: 'WPOL',
+    name: 'Wrapped POL',
+  }),
+  [EvmChainId.GNOSIS]: new EvmToken({
+    chainId: EvmChainId.GNOSIS,
+    address: WNATIVE_ADDRESS[EvmChainId.GNOSIS],
+    decimals: 18,
+    symbol: 'WXDAI',
+    name: 'Wrapped xDai',
+  }),
+  [EvmChainId.BSC]: new EvmToken({
+    chainId: EvmChainId.BSC,
+    address: WNATIVE_ADDRESS[EvmChainId.BSC],
+    decimals: 18,
+    symbol: 'WBNB',
+    name: 'Wrapped BNB',
+  }),
+  [EvmChainId.ARBITRUM]: WETH9[EvmChainId.ARBITRUM],
+  [EvmChainId.ARBITRUM_SEPOLIA]: WETH9[EvmChainId.ARBITRUM_SEPOLIA],
+  [EvmChainId.ARBITRUM_NOVA]: WETH9[EvmChainId.ARBITRUM_NOVA],
+  [EvmChainId.AVALANCHE]: new EvmToken({
+    chainId: EvmChainId.AVALANCHE,
+    address: WNATIVE_ADDRESS[EvmChainId.AVALANCHE],
+    decimals: 18,
+    symbol: 'WAVAX',
+    name: 'Wrapped AVAX',
+  }),
+  [EvmChainId.HARMONY]: new EvmToken({
+    chainId: EvmChainId.HARMONY,
+    address: WNATIVE_ADDRESS[EvmChainId.HARMONY],
+    decimals: 18,
+    symbol: 'WONE',
+    name: 'Wrapped ONE',
+  }),
+  [EvmChainId.CELO]: new EvmToken({
+    chainId: EvmChainId.CELO,
+    address: WNATIVE_ADDRESS[EvmChainId.CELO],
+    decimals: 18,
+    symbol: 'CELO',
+    name: 'Celo',
+  }),
+  [EvmChainId.KAVA]: new EvmToken({
+    chainId: EvmChainId.KAVA,
+    address: WNATIVE_ADDRESS[EvmChainId.KAVA],
+    decimals: 18,
+    symbol: 'WKAVA',
+    name: 'Wrapped Kava',
+  }),
+  [EvmChainId.METIS]: new EvmToken({
+    chainId: EvmChainId.METIS,
+    address: WNATIVE_ADDRESS[EvmChainId.METIS],
+    decimals: 18,
+    symbol: 'WMETIS',
+    name: 'Wrapped Metis',
+  }),
+  [EvmChainId.BOBA]: WETH9[EvmChainId.BOBA],
+  [EvmChainId.BOBA_BNB]: new EvmToken({
+    chainId: EvmChainId.BOBA_BNB,
+    address: WNATIVE_ADDRESS[EvmChainId.BOBA_BNB],
+    decimals: 18,
+    symbol: 'WBOBA',
+    name: 'Wrapped Boba',
+  }),
+  [EvmChainId.BTTC]: new EvmToken({
+    chainId: EvmChainId.BTTC,
+    address: WNATIVE_ADDRESS[EvmChainId.BTTC],
+    decimals: 18,
+    symbol: 'WBTT',
+    name: 'Wrapped BitTorrent Token',
+  }),
+  // [EvmChainId.SEPOLIA]: WETH9[EvmChainId.SEPOLIA],
+  // [EvmChainId.CONSENSUS_ZKEVM_TESTNET]: WETH9[EvmChainId.CONSENSUS_ZKEVM_TESTNET],
+  // [EvmChainId.SCROLL_ALPHA_TESTNET]: WETH9[EvmChainId.SCROLL_ALPHA_TESTNET],
+  // [EvmChainId.BASE_TESTNET]: WETH9[EvmChainId.BASE_TESTNET],
+  [EvmChainId.THUNDERCORE]: new EvmToken({
+    chainId: EvmChainId.THUNDERCORE,
+    address: WNATIVE_ADDRESS[EvmChainId.THUNDERCORE],
+    decimals: 18,
+    symbol: 'WTT',
+    name: 'Wrapped Thunder Token',
+  }),
+  [EvmChainId.POLYGON_ZKEVM]: WETH9[EvmChainId.POLYGON_ZKEVM],
+  [EvmChainId.HAQQ]: new EvmToken({
+    chainId: EvmChainId.HAQQ,
+    address: WNATIVE_ADDRESS[EvmChainId.HAQQ],
+    decimals: 18,
+    symbol: 'WISLM',
+    name: 'Wrapped Islamic Coin',
+  }),
+  [EvmChainId.CORE]: new EvmToken({
+    chainId: EvmChainId.CORE,
+    address: WNATIVE_ADDRESS[EvmChainId.CORE],
+    decimals: 18,
+    symbol: 'WCORE',
+    name: 'Wrapped Core',
+  }),
+  [EvmChainId.ZKSYNC_ERA]: WETH9[EvmChainId.ZKSYNC_ERA],
+  [EvmChainId.LINEA]: WETH9[EvmChainId.LINEA],
+  [EvmChainId.BASE]: WETH9[EvmChainId.BASE],
+  [EvmChainId.SCROLL]: WETH9[EvmChainId.SCROLL],
+  [EvmChainId.FILECOIN]: new EvmToken({
+    chainId: EvmChainId.FILECOIN,
+    address: WNATIVE_ADDRESS[EvmChainId.FILECOIN],
+    decimals: 18,
+    symbol: 'WFIL',
+    name: 'Wrapped FIL',
+  }),
+  [EvmChainId.ZETACHAIN]: new EvmToken({
+    chainId: EvmChainId.ZETACHAIN,
+    address: WNATIVE_ADDRESS[EvmChainId.ZETACHAIN],
+    decimals: 18,
+    symbol: 'WZETA',
+    name: 'Wrapped ZETA',
+  }),
+  [EvmChainId.CRONOS]: new EvmToken({
+    chainId: EvmChainId.CRONOS,
+    address: WNATIVE_ADDRESS[EvmChainId.CRONOS],
+    decimals: 18,
+    symbol: 'WCRO',
+    name: 'Wrapped CRO',
+  }),
+  [EvmChainId.BLAST]: WETH9[EvmChainId.BLAST],
+  [EvmChainId.SKALE_EUROPA]: new EvmToken({
+    // Skale Europa does not have a wrapped native token, using zero address
+    chainId: EvmChainId.SKALE_EUROPA,
+    address: WNATIVE_ADDRESS[EvmChainId.SKALE_EUROPA],
+    decimals: 0,
+    symbol: 'WsFUEL',
+    name: 'Wrapped sFUEL',
+  }),
+  [EvmChainId.ROOTSTOCK]: WRBTC[EvmChainId.ROOTSTOCK],
+  [EvmChainId.MANTLE]: new EvmToken({
+    chainId: EvmChainId.MANTLE,
+    address: WNATIVE_ADDRESS[EvmChainId.MANTLE],
+    decimals: 18,
+    symbol: 'WMNT',
+    name: 'Wrapped MNT',
+  }),
+  [EvmChainId.MANTA]: WETH9[EvmChainId.MANTA],
+  [EvmChainId.MODE]: WETH9[EvmChainId.MODE],
+  [EvmChainId.TAIKO]: WETH9[EvmChainId.TAIKO],
+  [EvmChainId.ZKLINK]: WETH9[EvmChainId.ZKLINK],
+  [EvmChainId.APE]: new EvmToken({
+    chainId: EvmChainId.APE,
+    address: WNATIVE_ADDRESS[EvmChainId.APE],
+    decimals: 18,
+    symbol: 'WAPE',
+    name: 'Wrapped Ape',
+  }),
+  [EvmChainId.SONIC]: new EvmToken({
+    chainId: EvmChainId.SONIC,
+    address: WNATIVE_ADDRESS[EvmChainId.SONIC],
+    decimals: 18,
+    symbol: 'wS',
+    name: 'Wrapped Sonic',
+  }),
+  [EvmChainId.HEMI]: WETH9[EvmChainId.HEMI],
+  [EvmChainId.TATARA]: WETH9[EvmChainId.TATARA],
+  [EvmChainId.KATANA]: WETH9[EvmChainId.KATANA],
+  [EvmChainId.HYPEREVM]: new EvmToken({
+    chainId: EvmChainId.HYPEREVM,
+    address: WNATIVE_ADDRESS[EvmChainId.HYPEREVM],
+    decimals: 18,
+    symbol: 'WHYPE',
+    name: 'Wrapped HYPE',
+  }),
+} as const satisfies Record<EvmChainId, EvmToken>
+
+export const isWNativeSupported = (chainId: EvmChainId) =>
+  WNATIVE_ADDRESS[chainId] !== zeroAddress
+
+export function isWrapOrUnwrap({
+  from,
+  to,
+}: { from: EvmCurrency; to: EvmCurrency }): boolean {
+  if (from.type === 'native' && from.wrap().isSame(to)) {
+    return true
+  }
+
+  return to.type === 'native' && to.wrap().isSame(from)
+}

package/evm/currency/currency.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod'
+import type { CurrencyMetadata } from '../../generic/currency/currency.js'
+import { type EvmNative, serializedEvmNativeSchema } from './native.js'
+import { type EvmToken, serializedEvmTokenSchema } from './token.js'
+
+export type EvmCurrency<
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> = EvmToken<TMetadata> | EvmNative
+
+export const serializedEvmCurrencySchema = z.discriminatedUnion('type', [
+  serializedEvmTokenSchema,
+  serializedEvmNativeSchema,
+])
+
+export type SerializedEvmCurrency = z.infer<typeof serializedEvmCurrencySchema>

package/evm/currency/deserialize-currency.ts

@@ -0,0 +1,17 @@
+import { EvmNative, type SerializedEvmNative } from './native.js'
+import { EvmToken, type SerializedEvmToken } from './token.js'
+
+function deserializeEvmCurrency(data: SerializedEvmToken): EvmToken
+function deserializeEvmCurrency(data: SerializedEvmNative): EvmNative
+
+function deserializeEvmCurrency(
+  data: SerializedEvmNative | SerializedEvmToken,
+) {
+  if (data.type === 'native') {
+    return new EvmNative(data)
+  } else {
+    return new EvmToken(data)
+  }
+}
+
+export { deserializeEvmCurrency }

package/evm/currency/index.ts

@@ -0,0 +1,5 @@
+export * from './currency.js'
+export * from './deserialize-currency.js'
+export * from './native.js'
+export * from './token.js'
+export * from './unwrap-token.js'

package/evm/currency/native.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod'
+import { Native } from '../../generic/currency/native.js'
+import {
+  type EvmChainId,
+  getEvmChainById,
+  isEvmChainId,
+} from '../chain/chains.js'
+import { WNATIVE } from '../config/tokens/wrapped-native.js'
+import type { EvmToken } from './token.js'
+
+export class EvmNative extends Native<EvmChainId> {
+  public override wrap(): EvmToken {
+    return WNATIVE[this.chainId]
+  }
+
+  public override toJSON(): SerializedEvmNative {
+    return {
+      chainId: this.chainId,
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      type: this.type,
+    } as const
+  }
+
+  public static fromJSON(data: SerializedEvmNative): EvmNative {
+    return new this(data)
+  }
+
+  static fromChainId(chainId: EvmChainId): EvmNative {
+    const chain = getEvmChainById(chainId)
+
+    return new EvmNative({
+      chainId,
+      symbol: chain.viemChain.nativeCurrency.symbol,
+      name: chain.viemChain.nativeCurrency.name,
+      decimals: chain.viemChain.nativeCurrency.decimals,
+    })
+  }
+}
+
+export const serializedEvmNativeSchema = z.object({
+  chainId: z.number().int().refine(isEvmChainId),
+  symbol: z.string(),
+  name: z.string(),
+  decimals: z.number().int().nonnegative(),
+  type: z.literal('native'),
+})
+
+export type SerializedEvmNative = z.infer<typeof serializedEvmNativeSchema>

package/evm/currency/token.ts

@@ -0,0 +1,81 @@
+import invariant from 'tiny-invariant'
+import { type Address, isAddress } from 'viem'
+import * as z from 'zod'
+import type { CurrencyMetadata } from '../../generic/currency/currency.js'
+import { Token } from '../../generic/currency/token.js'
+import { type EvmChainId, isEvmChainId } from '../chain/chains.js'
+
+export type EvmAddress = Address
+
+export function isEvmAddress(address: string): address is EvmAddress {
+  return isAddress(address, { strict: false })
+}
+
+export type EvmTokenOrigin =
+  | 'native'
+  | 'stargate'
+  | 'celer'
+  | 'wormhole'
+  | 'native-bridge'
+
+export class EvmToken<
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> extends Token<EvmChainId, EvmAddress, TMetadata> {
+  public readonly origin: EvmTokenOrigin | undefined
+
+  constructor({
+    origin,
+    ...rest
+  }: {
+    origin?: EvmTokenOrigin | undefined
+  } & ConstructorParameters<
+    typeof Token<EvmChainId, EvmAddress, TMetadata>
+  >[0]) {
+    super(rest)
+    this.origin = origin
+  }
+
+  public sortsBefore(other: EvmToken): boolean {
+    invariant(
+      this.chainId === other.chainId,
+      'Tokens must be on the same chain',
+    )
+    invariant(
+      this.address.toLowerCase() !== other.address.toLowerCase(),
+      'Tokens must have different addresses',
+    )
+    return this.address.toLowerCase() < other.address.toLowerCase()
+  }
+
+  public override wrap(): EvmToken<TMetadata> {
+    return this
+  }
+
+  public override toJSON(): SerializedEvmToken {
+    return {
+      chainId: this.chainId,
+      address: this.address,
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      type: this.type,
+    } as const
+  }
+
+  static fromJSON(data: SerializedEvmToken): EvmToken {
+    return new this(data)
+  }
+}
+
+export const serializedEvmTokenSchema = z.object({
+  chainId: z.number().int().refine(isEvmChainId),
+  address: z
+    .string()
+    .refine((address) => isAddress(address, { strict: false })),
+  symbol: z.string(),
+  name: z.string(),
+  decimals: z.number().int().nonnegative(),
+  type: z.literal('token'),
+})
+
+export type SerializedEvmToken = z.infer<typeof serializedEvmTokenSchema>

package/evm/currency/unwrap-token.ts

@@ -0,0 +1,18 @@
+import { WNATIVE } from '../config/tokens/wrapped-native.js'
+import type { EvmCurrency } from './currency.js'
+import { EvmNative } from './native.js'
+
+export function unwrapEvmToken(currency: EvmCurrency): EvmCurrency {
+  if (currency.type === 'native') {
+    return currency
+  }
+
+  if (
+    currency.address.toLowerCase() ===
+    WNATIVE[currency.chainId].address.toLowerCase()
+  ) {
+    return EvmNative.fromChainId(currency.chainId)
+  }
+
+  return currency
+}

package/evm/dex/errors.ts

@@ -0,0 +1,30 @@
+// see https://stackoverflow.com/a/41102306
+const CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object
+
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+export class InsufficientReservesError extends Error {
+  public readonly isInsufficientReservesError = true as const
+
+  public constructor() {
+    super()
+    this.name = this.constructor.name
+    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+export class InsufficientInputAmountError extends Error {
+  public readonly isInsufficientInputAmountError = true as const
+
+  public constructor() {
+    super()
+    this.name = this.constructor.name
+    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)
+  }
+}

package/evm/dex/fee.ts

@@ -0,0 +1,13 @@
+export enum Fee {
+  /** 0.01% */
+  LOW = 1,
+  /** 0.05% */
+  MEDIUM = 5,
+  /** 0.1% */
+  AVERAGE = 10,
+  /** 0.3% */
+  DEFAULT = 30,
+  /** 1% */
+  HIGH = 100,
+  //   MAX = 10000
+}

package/evm/dex/index.ts

@@ -0,0 +1,5 @@
+export * from './errors.js'
+export * from './fee.js'
+export * from './pool.js'
+export * from './router-liquidity-source.js'
+export * from './trade-type.js'

package/evm/dex/pool.ts

@@ -0,0 +1,50 @@
+import type { Amount } from '../../generic/index.js'
+import type { EvmToken } from '../currency/token.js'
+import type { Fee } from './fee.js'
+
+export enum PoolType {
+  Wrap = 'Wrap',
+  Bridge = 'Bridge',
+  Classic = 'Classic',
+  Concentrated = 'Concentrated',
+  Stable = 'Stable',
+  Curve = 'Curve',
+  Unknown = 'Unknown',
+}
+
+export abstract class Pool {
+  public abstract readonly liquidityToken: EvmToken
+
+  // Swap gas cost, could be different depending on source & dest,
+  // wallet->wallet, bento->wallet/wallet->bento, bento->bento
+
+  // wallet->wallet: ???
+  // bento->wallet/wallet->bento: ???
+  // bento->bento: ???
+  public abstract readonly swapGasCost: bigint
+
+  // Minimum pool liquidity, typically 1000
+  public abstract readonly minLiquidity: bigint
+
+  public abstract get chainId(): number
+
+  public abstract get fee(): Fee
+
+  public abstract get assets(): EvmToken[]
+
+  public abstract get reserves(): Amount<EvmToken>[]
+
+  public abstract getLiquidityMinted(
+    totalSupply: Amount<EvmToken>,
+    tokenAmountA: Amount<EvmToken>,
+    tokenAmountB: Amount<EvmToken>,
+  ): Amount<EvmToken>
+
+  public abstract getLiquidityValue(
+    token: EvmToken,
+    totalSupply: Amount<EvmToken>,
+    liquidity: Amount<EvmToken>,
+  ): Amount<EvmToken>
+
+  public abstract involvesToken(token: EvmToken): boolean
+}

package/evm/dex/router-liquidity-source.ts

@@ -0,0 +1,4 @@
+export enum RouterLiquiditySource {
+  Sender = 'Sender', // msg.sender
+  XSwap = 'XSwap',
+}

package/evm/dex/trade-type.ts

@@ -0,0 +1,4 @@
+export enum TradeType {
+  EXACT_INPUT = 0,
+  EXACT_OUTPUT = 1,
+}

package/evm/format/address.ts

@@ -0,0 +1,6 @@
+// shorten the checksummed version of the input address to have 0x + 4 characters at start and end
+export function shortenEvmAddress(address: string, characters = 4): string {
+  return `${address.substring(0, characters + 2)}...${address.substring(
+    address.length - characters,
+  )}`
+}

package/evm/format/hash.ts

@@ -0,0 +1,10 @@
+// shorten the checksummed version of the input hash to have 0x + 4 characters at start and end
+export function shortenHash(hash: string, characters = 4): string {
+  try {
+    return `${hash.substring(0, characters + 2)}...${hash.substring(
+      hash.length - characters,
+    )}`
+  } catch {
+    throw `Invalid 'hash' parameter '${hash}'.`
+  }
+}

package/evm/format/index.ts

@@ -0,0 +1,2 @@
+export * from './address.js'
+export * from './hash.js'

package/evm/index.ts

@@ -0,0 +1,12 @@
+export * from './abi/index.js'
+export * from './api/index.js'
+export * from './chain/index.js'
+export * from './config/index.js'
+export * from './currency/index.js'
+export * from './dex/index.js'
+export * from './format/index.js'
+export * from './pool/index.js'
+export * from './token-list/index.js'
+export * from './types/index.js'
+export * from './utils/index.js'
+export * from './validate/index.js'

package/evm/pool/index.ts

@@ -0,0 +1,2 @@
+export * from './sushiswap-v2/index.js'
+export * from './sushiswap-v3/index.js'

package/evm/pool/sushiswap-v2/compute-sushiswap-v2-pool-address.ts

@@ -0,0 +1,49 @@
+import invariant from 'tiny-invariant'
+import type { Hex } from 'viem'
+import { encodePacked, keccak256 } from 'viem/utils'
+import {
+  SUSHISWAP_V2_INIT_CODE_HASH,
+  type SushiSwapV2ChainId,
+} from '../../config/index.js'
+import type { EvmAddress, EvmToken } from '../../currency/token.js'
+import { getCreate2Address } from '../../utils/get-create-2-address.js'
+
+/**
+ * Computes a pair address
+ * @param factoryAddress The Uniswap V2 factory address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
+ * @returns The pair address
+ */
+export const computeSushiSwapV2PoolAddress = ({
+  factoryAddress,
+  tokenA,
+  tokenB,
+  initCodeHashManualOverride,
+}: {
+  factoryAddress: EvmAddress
+  tokenA: EvmToken
+  tokenB: EvmToken
+  initCodeHashManualOverride?: Hex
+}): EvmAddress => {
+  const [token0, token1] = tokenA.sortsBefore(tokenB)
+    ? [tokenA, tokenB]
+    : [tokenB, tokenA] // does safety checks
+
+  invariant(token0.chainId === token1.chainId, 'CHAIN_ID')
+
+  return getCreate2Address({
+    from: factoryAddress,
+    salt: keccak256(
+      encodePacked(
+        ['address', 'address'],
+        [token0.address, token1.address],
+      ) as Hex,
+    ),
+    bytecodeHash:
+      initCodeHashManualOverride ??
+      SUSHISWAP_V2_INIT_CODE_HASH[token0.chainId as SushiSwapV2ChainId],
+    chainId: token0.chainId,
+  }).toLowerCase() as EvmAddress
+}

package/evm/pool/sushiswap-v2/index.ts

@@ -0,0 +1,3 @@
+export * from './compute-sushiswap-v2-pool-address.js'
+export * from './sushiswap-v2-pool.js'
+export * from './zod.js'