sushi 6.0.12 → 6.0.13

package/generic/currency/amount.ts

@@ -0,0 +1,254 @@
+import { formatUnits, parseUnits } from 'viem/utils'
+import * as z from 'zod'
+import { numberToFixed } from '../format/number.js'
+import { Fraction } from '../math/fraction.js'
+import type { BigintIsh } from '../types/bigintish.js'
+import type { Currency } from './currency.js'
+import type {
+  SerializedCurrency,
+  SerializedCurrencySchema,
+} from './serialized-currency.js'
+
+export type SerializedAmount<TCurrency extends SerializedCurrency> = {
+  currency: TCurrency
+  amount: string
+}
+
+/**
+ * Represents an amount of a particular currency.
+ */
+export class Amount<TCurrency extends Currency = Currency> {
+  /** The currency of this amount */
+  public readonly currency: TCurrency
+
+  /** The raw integer amount */
+  public readonly amount: bigint
+
+  private static readonly SCALE_DECIMALS = 27
+  private static readonly SCALE = 10n ** BigInt(Amount.SCALE_DECIMALS)
+
+  constructor(currency: TCurrency, amount: BigintIsh) {
+    this.currency = currency
+    this.amount = BigInt(amount)
+  }
+
+  /**
+   * Creates an Amount from a human-readable value, e.g. "1.5".
+   * Just a wrapper around viem's `parseUnits` to handle the currency's decimals.
+   */
+  public static fromHuman<TCurrency extends Currency>(
+    currency: TCurrency,
+    human: bigint | number | string,
+  ): Amount<TCurrency> {
+    const amt = parseUnits(String(human), currency.decimals)
+    return new Amount(currency, amt)
+  }
+
+  /**
+   * Creates an Amount from a human-readable value, e.g. "1.5".
+   */
+  public static tryFromHuman<TCurrency extends Currency>(
+    currency: TCurrency,
+    human: bigint | number | string,
+  ): Amount<TCurrency> | undefined {
+    try {
+      return Amount.fromHuman(currency, human)
+    } catch {
+      return undefined
+    }
+  }
+
+  /**
+   * Wraps the amount's currency into a Token.
+   */
+  public wrap() {
+    return new Amount(
+      this.currency.wrap() as ReturnType<TCurrency['wrap']>,
+      this.amount,
+    )
+  }
+
+  private static getRawAmount<TCurrency extends Currency>(
+    _ref: Amount<TCurrency>,
+    other: Amount | bigint | string,
+  ): bigint {
+    if (other instanceof Amount) {
+      return other.amount
+    }
+    return BigInt(other)
+  }
+
+  /**
+   * Adds another Amount or raw value.
+   */
+  public add(other: Amount | Fraction | bigint | string): Amount<TCurrency> {
+    let add: bigint
+
+    if (other instanceof Fraction) {
+      add = (other.numerator * Amount.SCALE) / other.denominator / Amount.SCALE
+    } else {
+      add = Amount.getRawAmount(this, other)
+    }
+
+    return new Amount(this.currency, this.amount + add)
+  }
+
+  /**
+   * Adds a human-readable value, e.g. "0.5".
+   */
+  public addHuman(other: number | string): Amount<TCurrency> {
+    const addend = parseUnits(String(other), this.currency.decimals)
+    return new Amount(this.currency, this.amount + addend)
+  }
+
+  /**
+   * Subtracts another Amount or raw value.
+   */
+  public sub(other: Amount | Fraction | bigint | string): Amount<TCurrency> {
+    let sub: bigint
+
+    if (other instanceof Fraction) {
+      sub = (other.numerator * Amount.SCALE) / other.denominator / Amount.SCALE
+    } else {
+      sub = Amount.getRawAmount(this, other)
+    }
+
+    return new Amount(this.currency, this.amount - sub)
+  }
+
+  /**
+   * Subtracts a human-readable value, e.g. "0.5".
+   */
+  public subHuman(other: number | string): Amount<TCurrency> {
+    const sub = parseUnits(String(other), this.currency.decimals)
+    return new Amount(this.currency, this.amount - sub)
+  }
+
+  /**
+   * Multiplies this amount by another amount or raw value.
+   */
+  public mul(other: Amount | Fraction | bigint | string): Amount<TCurrency> {
+    if (other instanceof Fraction) {
+      return new Amount(
+        this.currency,
+        (this.amount * other.numerator) / other.denominator,
+      )
+    }
+
+    const mul = Amount.getRawAmount(this, other)
+    return new Amount(this.currency, this.amount * mul)
+  }
+
+  /**
+   * Multiplies this amount by a human-readable multiplier.
+   */
+  public mulHuman(other: bigint | number | string): Amount<TCurrency> {
+    const mul = parseUnits(String(other), Amount.SCALE_DECIMALS)
+    const result = (this.amount * mul) / Amount.SCALE
+    return new Amount(this.currency, result)
+  }
+
+  /**
+   * Divides this amount by a divisor.
+   * @throws Error if divisor is zero.
+   * @returns a new Amount with the result.
+   */
+  public div(divisor: bigint | number | string): Amount<TCurrency> {
+    const d = parseUnits(String(divisor), Amount.SCALE_DECIMALS)
+    if (d === 0n) throw new Error('Cannot divide by zero')
+    const result = (this.amount * Amount.SCALE) / d
+    return new Amount(this.currency, result)
+  }
+
+  /**
+   * Divides this amount by another Amount or raw value.
+   * @returns a {@link Fraction} for a precise fractional result.
+   */
+  public divToFraction(other: Amount | Fraction | bigint | string): Fraction {
+    if (other instanceof Fraction) {
+      return new Fraction({
+        numerator: this.amount * other.denominator,
+        denominator: other.numerator,
+      })
+    }
+
+    const div = Amount.getRawAmount(this, other)
+    return new Fraction({ numerator: this.amount, denominator: div })
+  }
+
+  /**
+   * Returns true if this amount > other.
+   */
+  public gt(other: Amount | bigint | string): boolean {
+    const cmp = Amount.getRawAmount(this, other)
+    return this.amount > cmp
+  }
+
+  /**
+   * Returns true if this amount >= other.
+   */
+  public gte(other: Amount | bigint | string): boolean {
+    const cmp = Amount.getRawAmount(this, other)
+    return this.amount >= cmp
+  }
+
+  /**
+   * Returns true if this amount < other.
+   */
+  public lt(other: Amount | bigint | string): boolean {
+    const cmp = Amount.getRawAmount(this, other)
+    return this.amount < cmp
+  }
+
+  /**
+   * Returns true if this amount <= other.
+   */
+  public lte(other: Amount | bigint | string): boolean {
+    const cmp = Amount.getRawAmount(this, other)
+    return this.amount <= cmp
+  }
+
+  /**
+   * Returns true if this amount == other.
+   */
+  public eq(other: Amount | bigint | string): boolean {
+    const cmp = Amount.getRawAmount(this, other)
+    return this.amount === cmp
+  }
+
+  public toJSON(): SerializedAmount<SerializedCurrency> {
+    return {
+      currency: this.currency.toJSON(),
+      amount: this.amount.toString(),
+    } as const
+  }
+
+  /**
+   * @param args.maxFixed - The maximum number of fixed decimal places to display, only if relevant, eg. "0" for 0, "1.23" for 1.23, etc.
+   * @param args.fixed - The number of fixed decimal places to display, always, eg. "0.00" for 0, "1.23" for 1.23, etc.
+   * @returns Formatted string representation of the amount
+   */
+  public toString(
+    args: Parameters<typeof numberToFixed>[1] = {
+      maxFixed: this.currency.decimals,
+    },
+  ): string {
+    const str = formatUnits(this.amount, this.currency.decimals)
+    return numberToFixed(str, args)
+  }
+
+  public toSignificant(significantDigits = 5): string {
+    return this.toString({
+      significant: significantDigits,
+    })
+  }
+}
+
+export function serializedAmountSchema<
+  TSchema extends SerializedCurrencySchema,
+>(currencySchema: TSchema) {
+  return z.object({
+    currency: currencySchema,
+    amount: z.string(),
+  })
+}

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

@@ -0,0 +1,275 @@
+import { it } from 'node:test'
+import { describe, expectTypeOf } from 'vitest'
+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 { EvmNative } from '../../evm/currency/native.js'
+import { type EvmAddress, EvmToken } from '../../evm/currency/token.js'
+import { MvmToken } from '../../mvm/currency/token.js'
+import { TvmNative } from '../../tvm/currency/native.js'
+import type { TvmToken } from '../../tvm/currency/token.js'
+import { getChainIdAddressFromId } from '../utils/id.js'
+import {
+  BaseCurrency,
+  type Currency,
+  type CurrencyMetadata,
+} from './currency.js'
+import type { Native } from './native.js'
+import type { Token } from './token.js'
+
+describe('generic/currency/currency.ts types', () => {
+  describe('id', () => {
+    it('should return the correct id for EvmNative', () => {
+      const evmMockNative = new EvmNative({
+        chainId: 1,
+        symbol: 'ETH',
+        name: 'Ethereum',
+        decimals: 18,
+      })
+
+      expectTypeOf(evmMockNative.id).toEqualTypeOf<`${EvmChainId}:NATIVE`>()
+    })
+
+    it('should return the correct id for EvmToken', () => {
+      const evmMockToken = new EvmToken({
+        chainId: 1,
+        address: '0x1234567890abcdef1234567890abcdef12345678',
+        symbol: 'USDT',
+        name: 'Tether USD',
+        decimals: 6,
+      })
+
+      expectTypeOf(
+        evmMockToken.id,
+      ).toEqualTypeOf<`${EvmChainId}:${EvmAddress}`>()
+    })
+  })
+
+  describe('wrapCurrency', () => {
+    it('should return the same chaintype - EVM', () => {
+      const evmMockNative = new EvmNative({
+        chainId: 1,
+        symbol: 'ETH',
+        name: 'Ethereum',
+        decimals: 18,
+      })
+
+      expectTypeOf(evmMockNative.wrap()).toEqualTypeOf<EvmToken>()
+    })
+
+    it('should return the same chaintype - Mvm', () => {
+      const mvmMockToken = new MvmToken({
+        chainId: -1,
+        address: '0x1234567890abcdef1234567890abcdef12345678::mvm::token',
+        symbol: 'MVM',
+        name: 'MVM Token',
+        decimals: 18,
+      })
+
+      expectTypeOf(mvmMockToken.wrap()).toEqualTypeOf<MvmToken>()
+    })
+
+    it('should return the same chaintype - Tvm', () => {
+      const tvmMockToken = new TvmNative({
+        chainId: -2,
+        symbol: 'TVM',
+        name: 'Tvm Native',
+        decimals: 18,
+      })
+
+      expectTypeOf(tvmMockToken.wrap()).toEqualTypeOf<TvmToken>()
+    })
+  })
+
+  describe('isNative/isToken', () => {
+    it('should correctly narrow the type based on isNative', () => {
+      const mockCurrency = {} as Currency
+
+      expectTypeOf(mockCurrency)
+        .extract<{ isNative: true }>()
+        .toEqualTypeOf<Native>()
+      expectTypeOf(mockCurrency)
+        .extract<{ isNative: false }>()
+        .toEqualTypeOf<Token>()
+
+      const mockEvmCurrency = {} as EvmCurrency
+
+      expectTypeOf(mockEvmCurrency)
+        .extract<{ isNative: true }>()
+        .toEqualTypeOf<EvmNative>()
+      expectTypeOf(mockEvmCurrency)
+        .extract<{ isNative: false }>()
+        .toEqualTypeOf<EvmToken>()
+    })
+
+    it('should correctly narrow the type based on isToken', () => {
+      const evmMockCurrency = {} as EvmCurrency
+
+      expectTypeOf(evmMockCurrency)
+        .extract<{ isToken: true }>()
+        .toEqualTypeOf<EvmToken>()
+      expectTypeOf(evmMockCurrency)
+        .extract<{ isToken: false }>()
+        .toEqualTypeOf<EvmNative>()
+
+      const mockEvmCurrency = {} as EvmCurrency
+
+      expectTypeOf(mockEvmCurrency)
+        .extract<{ isToken: true }>()
+        .toEqualTypeOf<EvmToken>()
+      expectTypeOf(mockEvmCurrency)
+        .extract<{ isToken: false }>()
+        .toEqualTypeOf<EvmNative>()
+    })
+  })
+
+  describe('currency type extension', () => {
+    type CustomAddress = `${EvmAddress}-${EvmAddress}`
+    type SerializedCustomToken = {
+      chainId: EvmChainId
+      vaultAddress: EvmAddress
+      tokenAddress: EvmAddress
+      symbol: string
+      name: string
+      decimals: number
+      type: 'vault-token'
+    }
+
+    class CustomToken<
+        TMetadata extends CurrencyMetadata = Record<string, unknown>,
+      >
+      extends BaseCurrency<
+        EvmChainId,
+        TMetadata,
+        'vault-token',
+        SerializedCustomToken
+      >
+      implements
+        Omit<
+          Token<EvmChainId, CustomAddress>,
+          'type' | 'isToken' | 'wrap' | 'toJSON'
+        >
+    {
+      override readonly type = 'vault-token'
+      override readonly isNative = false
+      override readonly isToken = false
+
+      public readonly tokenAddress
+      public readonly vaultAddress
+
+      public readonly address
+
+      constructor({
+        tokenAddress,
+        vaultAddress,
+        ...rest
+      }: { tokenAddress: EvmAddress; vaultAddress: EvmAddress } & Omit<
+        ConstructorParameters<
+          typeof Token<EvmChainId, CustomAddress, TMetadata>
+        >[0],
+        'address'
+      >) {
+        super({ ...rest })
+
+        this.tokenAddress = tokenAddress.toLowerCase() as EvmAddress
+        this.vaultAddress = vaultAddress.toLowerCase() as EvmAddress
+
+        this.address = `${this.vaultAddress}-${this.tokenAddress}` as const
+      }
+
+      get id() {
+        return `${this.chainId}:${this.vaultAddress}-${this.tokenAddress}` as const
+      }
+
+      wrap(): CustomToken<TMetadata> {
+        return this
+      }
+
+      toJSON(): SerializedCustomToken {
+        return {
+          chainId: this.chainId,
+          vaultAddress: this.vaultAddress,
+          tokenAddress: this.tokenAddress,
+          symbol: this.symbol,
+          name: this.name,
+          decimals: this.decimals,
+          type: this.type,
+        }
+      }
+    }
+
+    type ExtendedCurrency = CustomToken | EvmNative | EvmToken
+
+    it('should narrow to the correct type', () => {
+      const customToken = new CustomToken({
+        chainId: 1,
+        vaultAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        tokenAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        symbol: 'CTK',
+        name: 'Custom Token',
+        decimals: 18,
+      }) as ExtendedCurrency
+
+      expectTypeOf(customToken)
+        .extract<{ type: 'vault-token' }>()
+        .toEqualTypeOf<CustomToken>()
+    })
+
+    it('should wrap to itself', () => {
+      const customToken = new CustomToken({
+        chainId: 1,
+        vaultAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        tokenAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        symbol: 'CTK',
+        name: 'Custom Token',
+        decimals: 18,
+      })
+
+      expectTypeOf(customToken.wrap()).toEqualTypeOf<CustomToken>()
+    })
+
+    it('should wrap to a union if a part of a union', () => {
+      const customToken = new CustomToken({
+        chainId: 1,
+        vaultAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        tokenAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        symbol: 'CTK',
+        name: 'Custom Token',
+        decimals: 18,
+      }) as ExtendedCurrency
+
+      expectTypeOf(customToken.wrap()).toEqualTypeOf<CustomToken | EvmToken>()
+    })
+
+    it('should have the correct id', () => {
+      const customToken = new CustomToken({
+        chainId: 1,
+        vaultAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        tokenAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        symbol: 'CTK',
+        name: 'Custom Token',
+        decimals: 18,
+      })
+
+      expectTypeOf(
+        customToken.id,
+      ).toEqualTypeOf<`${EvmChainId}:${EvmAddress}-${EvmAddress}`>()
+
+      expectTypeOf(getChainIdAddressFromId(customToken.id)).toEqualTypeOf<{
+        chainId: EvmChainId
+        address: `${EvmAddress}-${EvmAddress}`
+      }>()
+
+      const extendedCurrency = customToken as ExtendedCurrency
+
+      expectTypeOf(extendedCurrency.id).toEqualTypeOf<
+        `${EvmChainId}:${EvmAddress}-${EvmAddress}` | EvmID<true>
+      >()
+
+      expectTypeOf(getChainIdAddressFromId(extendedCurrency.id)).toEqualTypeOf<{
+        chainId: EvmChainId
+        address: `${EvmAddress}-${EvmAddress}` | EvmAddress | 'NATIVE'
+      }>
+    })
+  })
+})

package/generic/currency/currency.ts

@@ -0,0 +1,72 @@
+import type { ChainId } from '../chain/chains.js'
+import type { ID } from '../types/id.js'
+import type { Native } from './native.js'
+import type { SerializedCurrency } from './serialized-currency.js'
+import type { Token } from './token.js'
+
+export type CurrencyMetadata = Record<string, unknown>
+
+export abstract class BaseCurrency<
+  TChainId extends ChainId = ChainId,
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+  TCurrencyType extends string = string,
+  TSerializedCurrency extends object = SerializedCurrency,
+> {
+  public readonly chainId: TChainId
+  public readonly symbol: string
+  public readonly name: string
+  public readonly decimals: number
+
+  public readonly metadata: TMetadata
+
+  public abstract readonly type: TCurrencyType
+  public abstract readonly isNative: boolean
+  public abstract readonly isToken: boolean
+
+  constructor({
+    chainId,
+    decimals,
+    name,
+    symbol,
+    metadata,
+  }: {
+    chainId: TChainId
+    symbol: string
+    name: string
+    decimals: number
+    metadata?: TMetadata
+  }) {
+    this.chainId = chainId
+    this.symbol = symbol
+    this.name = name
+    this.decimals = decimals
+
+    this.metadata = metadata || ({} as TMetadata)
+  }
+
+  abstract get id(): ID<TChainId, string, true>
+
+  public isSame(
+    other: BaseCurrency<ChainId, CurrencyMetadata, string, object>,
+  ): boolean {
+    return (
+      this.chainId === other.chainId &&
+      this.decimals === other.decimals &&
+      this.type === other.type
+    )
+  }
+
+  public abstract wrap(): BaseCurrency<
+    TChainId,
+    TMetadata,
+    TCurrencyType,
+    TSerializedCurrency
+  >
+
+  public abstract toJSON(): TSerializedCurrency
+}
+
+export type Currency<
+  TChainId extends ChainId = ChainId,
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> = Native<TChainId> | Token<TChainId, string, TMetadata>

package/generic/currency/index.ts

@@ -0,0 +1,7 @@
+export * from './amount.js'
+export * from './currency.js'
+export * from './native.js'
+export * from './price.js'
+export * from './serialized-currency.js'
+export * from './token.js'
+export * from './unwrap-token.js'

package/generic/currency/native.ts

@@ -0,0 +1,18 @@
+import type { ChainId } from '../chain/chains.js'
+import { BaseCurrency, type CurrencyMetadata } from '../currency/currency.js'
+import type { Token } from './token.js'
+
+export abstract class Native<
+  TChainId extends ChainId = ChainId,
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> extends BaseCurrency<TChainId, TMetadata, 'token' | 'native'> {
+  override readonly type = 'native'
+  override readonly isNative = true
+  override readonly isToken = false
+
+  override get id() {
+    return `${this.chainId}:NATIVE` as const
+  }
+
+  public abstract override wrap(): Token<TChainId, string, TMetadata>
+}

package/generic/currency/price.ts

@@ -0,0 +1,77 @@
+import { numberToFixed } from '../format/number.js'
+import { Fraction } from '../math/fraction.js'
+import type { BigintIsh } from '../types/bigintish.js'
+import { Amount } from './amount.js'
+import type { Currency } from './currency.js'
+
+export class Price<
+  TBase extends Currency,
+  TQuote extends Currency,
+> extends Fraction {
+  public readonly base: TBase
+  public readonly quote: TQuote
+
+  constructor(
+    args:
+      | {
+          base: TBase
+          quote: TQuote
+          numerator: BigintIsh
+          denominator?: BigintIsh
+        }
+      | { baseAmount: Amount<TBase>; quoteAmount: Amount<TQuote> },
+  ) {
+    if ('baseAmount' in args && 'quoteAmount' in args) {
+      const { baseAmount, quoteAmount } = args
+      super({ numerator: baseAmount.amount, denominator: quoteAmount.amount })
+
+      this.base = baseAmount.currency
+      this.quote = quoteAmount.currency
+      return
+    }
+
+    super({ numerator: args.numerator, denominator: args.denominator || 1n })
+    this.base = args.base
+    this.quote = args.quote
+  }
+
+  get scalar(): Fraction {
+    return new Fraction({
+      numerator: 10n ** BigInt(this.base.decimals),
+      denominator: 10n ** BigInt(this.quote.decimals),
+    })
+  }
+
+  /**
+   *
+   * @param baseAmount The amount of the base currency to convert
+   * @returns The equivalent amount in the quote currency
+   */
+  public getQuote(baseAmount: Amount<TBase>): Amount<TQuote> {
+    const quoteAmount = super.mul(baseAmount.amount).toNumber()
+    return new Amount(this.quote, BigInt(Math.floor(quoteAmount)))
+  }
+
+  public override invert(): Price<TQuote, TBase> {
+    return new Price({
+      base: this.quote,
+      quote: this.base,
+      numerator: this.denominator,
+      denominator: this.numerator,
+    })
+  }
+
+  public override toNumber(): number {
+    return super.mul(this.scalar).toNumber()
+  }
+
+  public override toString(args: Parameters<typeof numberToFixed>[1]): string {
+    return numberToFixed(this.toNumber(), args)
+  }
+
+  public override toSignificant(significantDigits = 5): string {
+    return this.toString({
+      significant: significantDigits,
+    })
+  }
+}