sushi 6.0.11 → 6.0.13

package/generic/currency/serialized-currency.ts

@@ -0,0 +1,28 @@
+import * as z from 'zod'
+import { serializedEvmCurrencySchema } from '../../evm/currency/currency.js'
+import type { serializedEvmTokenSchema } from '../../evm/currency/token.js'
+import type { serializedEvmNativeSchema } from '../../evm/index.js'
+import { serializedMvmTokenSchema } from '../../mvm/currency/token.js'
+import {
+  serializedTvmCurrencySchema,
+  type serializedTvmNativeSchema,
+  type serializedTvmTokenSchema,
+} from '../../tvm/index.js'
+
+export type SerializedCurrencySchema =
+  | typeof serializedEvmTokenSchema
+  | typeof serializedEvmNativeSchema
+  | typeof serializedEvmCurrencySchema
+  | typeof serializedMvmTokenSchema
+  | typeof serializedTvmTokenSchema
+  | typeof serializedTvmNativeSchema
+  | typeof serializedTvmCurrencySchema
+  | typeof serializedCurrencySchema
+
+export const serializedCurrencySchema = z.union([
+  serializedEvmCurrencySchema,
+  serializedMvmTokenSchema,
+  serializedTvmCurrencySchema,
+])
+
+export type SerializedCurrency = z.infer<typeof serializedCurrencySchema>

package/generic/currency/token.ts

@@ -0,0 +1,42 @@
+import type { ChainId } from '../chain/chains.js'
+import type { ID } from '../types/id.js'
+import { BaseCurrency, type CurrencyMetadata } from './currency.js'
+
+export abstract class Token<
+  TChainId extends ChainId = ChainId,
+  TAddress extends string = string,
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> extends BaseCurrency<TChainId, TMetadata, 'token'> {
+  override readonly type = 'token'
+  override readonly isNative = false
+  override readonly isToken = true
+
+  public readonly address: TAddress
+
+  constructor({
+    address,
+    ...rest
+  }: {
+    address: TAddress
+  } & ConstructorParameters<typeof BaseCurrency<TChainId, TMetadata>>[0]) {
+    super(rest)
+
+    this.address = address.toLowerCase() as TAddress
+  }
+
+  override get id(): ID<TChainId, TAddress> {
+    return `${this.chainId}:${this.address}`
+  }
+
+  public override isSame(
+    other: BaseCurrency<ChainId, CurrencyMetadata, string, object>,
+  ): boolean {
+    return (
+      super.isSame(other) &&
+      other instanceof Token &&
+      this.address.toLowerCase() === other.address.toLowerCase()
+    )
+  }
+
+  public abstract override wrap(): Token<TChainId, TAddress, TMetadata>
+}

package/generic/currency/unwrap-token.ts

@@ -0,0 +1,27 @@
+import invariant from 'tiny-invariant'
+import { EvmToken } from '../../evm/currency/token.js'
+import { unwrapEvmToken } from '../../evm/currency/unwrap-token.js'
+import { MvmToken } from '../../mvm/currency/token.js'
+import { TvmToken } from '../../tvm/currency/token.js'
+import { unwrapTvmToken } from '../../tvm/currency/unwrap-token.js'
+import type { Currency } from './currency.js'
+
+export function unwrapToken<TCurrency extends Currency>(currency: TCurrency) {
+  if (currency.type === 'native') {
+    return currency
+  }
+
+  if (currency instanceof EvmToken) {
+    return unwrapEvmToken(currency)
+  }
+
+  if (currency instanceof TvmToken) {
+    return unwrapTvmToken(currency)
+  }
+
+  if (currency instanceof MvmToken) {
+    return currency
+  }
+
+  throw invariant('Unsupported currency type')
+}

package/generic/format/index.ts

@@ -0,0 +1,3 @@
+export * from './number.js'
+export * from './percent.js'
+export * from './price.js'

package/generic/format/number.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest'
+import { numberToFixed } from './number.js'
+
+describe('numberToFixed', () => {
+  describe('fixed decimal places', () => {
+    it('should format numbers with fixed decimal places', () => {
+      expect(numberToFixed(1.234, { fixed: 2 })).toBe('1.23')
+      expect(numberToFixed(1.236, { fixed: 2 })).toBe('1.24')
+      expect(numberToFixed(1, { fixed: 2 })).toBe('1.00')
+      expect(numberToFixed(0, { fixed: 2 })).toBe('0.00')
+    })
+
+    it('should handle string inputs with fixed decimal places', () => {
+      expect(numberToFixed('1.234', { fixed: 2 })).toBe('1.23')
+      expect(numberToFixed('1.236', { fixed: 2 })).toBe('1.24')
+      expect(numberToFixed('1', { fixed: 2 })).toBe('1.00')
+      expect(numberToFixed('0', { fixed: 2 })).toBe('0.00')
+    })
+
+    it('should handle negative numbers with fixed decimal places', () => {
+      expect(numberToFixed(-1.234, { fixed: 2 })).toBe('-1.23')
+      expect(numberToFixed('-1.236', { fixed: 2 })).toBe('-1.24')
+    })
+
+    it('should handle zero decimal places', () => {
+      expect(numberToFixed(1.234, { fixed: 0 })).toBe('1')
+      expect(numberToFixed('1.234', { fixed: 0 })).toBe('1')
+    })
+  })
+
+  describe('significant digits', () => {
+    it('should format numbers with significant digits', () => {
+      expect(numberToFixed(1234.5678, { significant: 4 })).toBe('1235')
+      expect(numberToFixed(0.001234, { significant: 3 })).toBe('0.00123')
+      expect(numberToFixed(123.456, { significant: 2 })).toBe('120')
+      expect(numberToFixed(0, { significant: 2 })).toBe('0')
+    })
+
+    it('should handle string inputs with significant digits', () => {
+      expect(numberToFixed('1234.5678', { significant: 4 })).toBe('1235')
+      expect(numberToFixed('0.001234', { significant: 3 })).toBe('0.00123')
+      expect(numberToFixed('0.000', { significant: 2 })).toBe('0')
+    })
+  })
+
+  describe('maxFixed decimal places', () => {
+    it('should format numbers with maxFixed, removing trailing zeros', () => {
+      expect(numberToFixed(1.2, { maxFixed: 3 })).toBe('1.2')
+      expect(numberToFixed(1.0, { maxFixed: 3 })).toBe('1')
+      expect(numberToFixed(1.234, { maxFixed: 2 })).toBe('1.23')
+      expect(numberToFixed(1.23, { maxFixed: 3 })).toBe('1.23')
+    })
+
+    it('should handle string inputs with maxFixed', () => {
+      expect(numberToFixed('1.2', { maxFixed: 3 })).toBe('1.2')
+      expect(numberToFixed('1.0', { maxFixed: 3 })).toBe('1')
+      expect(numberToFixed('1.234', { maxFixed: 2 })).toBe('1.23')
+    })
+
+    it('should handle integers with maxFixed', () => {
+      expect(numberToFixed(123, { maxFixed: 2 })).toBe('123')
+      expect(numberToFixed('123', { maxFixed: 2 })).toBe('123')
+    })
+  })
+
+  describe('precision loss scenarios', () => {
+    it('should demonstrate precision loss with current implementation', () => {
+      // Very precise string that loses precision when converted to Number
+      const preciseString = '0.1234567890123456789012345678901234567890'
+      const result = numberToFixed(preciseString, { maxFixed: 20 })
+
+      // Current implementation converts to Number first, losing precision
+      expect(result).not.toBe('0.12345678901234568')
+      expect(result.length).toBeLessThan(preciseString.length)
+    })
+
+    it('should demonstrate precision preservation with very large numbers', () => {
+      const largeString = '123456789012345678901234567890.123456789'
+      const result = numberToFixed(largeString, { maxFixed: 10 })
+
+      // New implementation preserves precision for string inputs
+      expect(result).toBe('123456789012345678901234567890.123456789')
+      expect(result).toBe(largeString)
+    })
+
+    it('should demonstrate precision preservation with very small numbers', () => {
+      const smallString = '0.123456789012345678901234567890123456789'
+      const result = numberToFixed(smallString, { maxFixed: 35 })
+
+      // New implementation preserves precision for string inputs
+      expect(result).toBe('0.12345678901234567890123456789012345')
+      expect(result.length).toBeGreaterThan(20)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle empty and zero values', () => {
+      expect(numberToFixed(0, { maxFixed: 2 })).toBe('0')
+      expect(numberToFixed('0', { maxFixed: 2 })).toBe('0')
+      expect(numberToFixed('0.00', { maxFixed: 2 })).toBe('0')
+    })
+
+    it('should handle negative numbers', () => {
+      expect(numberToFixed(-1.234, { maxFixed: 2 })).toBe('-1.23')
+      expect(numberToFixed('-1.234', { maxFixed: 2 })).toBe('-1.23')
+    })
+
+    it('should handle scientific notation in strings', () => {
+      expect(numberToFixed('1.23e-4', { maxFixed: 8 })).toBe('0.000123')
+      expect(numberToFixed('1.23e+2', { maxFixed: 2 })).toBe('123')
+    })
+  })
+})

package/generic/format/number.ts

@@ -0,0 +1,204 @@
+// import numeral from 'numbro'
+
+// export const formatNumber = (value: any, inputString = '0.[00]a') => {
+//   if (typeof value === 'string') value = Number(value)
+
+//   let negative = false
+//   if (value < 0) {
+//     negative = true
+//     value = Math.abs(value)
+//   }
+
+//   if (value === 0) return '0.00'
+//   if (value < 0.0001) return numeral(value).format('0.[000000]a')
+//   if (value < 0.001) return numeral(value).format('0.[0000]a')
+//   if (value < 0.01) return numeral(value).format('0.[000]a')
+//   return `${negative ? '-' : ''}${numeral(value).format(inputString)}`
+// }
+
+export const formatNumber = (
+  value: string | number,
+  maxDecimalPlaces = 2,
+): string => {
+  value = value ?? 0
+  if (typeof value === 'string') value = Number(value)
+
+  let negative = false
+  if (value < 0) {
+    negative = true
+    value = Math.abs(value)
+  }
+
+  if (value > 999_000_000_000_000) return '>999t'
+  if (value === 0) return '0.00'
+  if (value < 0.0001) return value.toFixed(6)
+  if (value < 0.001) return value.toFixed(4)
+  if (value < 0.01) return value.toFixed(3)
+
+  return `${negative ? '-' : ''}${formatValueWithSuffix(
+    value,
+    maxDecimalPlaces,
+  )}`
+}
+
+const formatValueWithSuffix = (
+  value: number,
+  maxDecimalPlaces: number,
+): string => {
+  const suffixes: string[] = ['', 'k', 'm', 'b', 't']
+  let suffixIndex = 0
+  while (value >= 1000 && suffixIndex < suffixes.length - 1) {
+    value /= 1000
+    suffixIndex++
+  }
+
+  const decimalCount = Math.min(
+    value.toString().split('.')[1]?.length || 0,
+    maxDecimalPlaces,
+  )
+
+  const formattedValue = value.toFixed(decimalCount)
+  return `${formattedValue}${suffixes[suffixIndex]}`
+}
+
+/**
+ * Convert scientific notation into decimal form, e.g. "-12.34e-5" => "-0.0001234",
+ * @param value Number in scientific notation
+ * @return Number in decimal form only
+ */
+export function withoutScientificNotation(value: string): string | undefined {
+  if (!value.includes('e')) return value
+
+  if (!value.match(/^-?\d*\.?\d+(e[+-]?\d+)?$/)) return undefined
+
+  const [sign, absValue] = value.startsWith('-')
+    ? ['-', value.slice(1)]
+    : ['', value]
+  const [m, n] = absValue.split('e') as [string, string]
+  const [integer, fraction] = m.split('.')
+
+  const mantissa = (integer + (fraction ?? '')).replace(/^0+/, '')
+  const exponent = Number.parseInt(n ?? 0) - (fraction ?? '').length
+
+  if (exponent >= 0) {
+    return sign + mantissa + '0'.repeat(exponent)
+  } else {
+    const i = mantissa.length + exponent
+    if (i > 0) {
+      return `${sign + mantissa.slice(0, i)}.${mantissa.slice(i) || 0}`
+    } else {
+      return `${sign}0.${'0'.repeat(-i)}${mantissa}`
+    }
+  }
+}
+
+/**
+ *
+ * @param num - The number to format, can be a string or a number.
+ * @param args.significant - The number of significant digits to display
+ * @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
+ */
+export function numberToFixed(
+  num: string | number,
+  args: { maxFixed: number } | { fixed: number } | { significant: number },
+) {
+  if (typeof num === 'string') {
+    return stringToFixed(num, args)
+  }
+
+  num = Number(num)
+
+  if ('fixed' in args) {
+    return num.toFixed(args.fixed)
+  }
+
+  if ('significant' in args) {
+    return Number.parseFloat(num.toPrecision(args.significant)).toString()
+  }
+
+  if ('maxFixed' in args) {
+    const str = num.toFixed(args.maxFixed)
+    let end = str.length
+
+    while (end && str.charCodeAt(end - 1) === 48) --end
+    if (end && str.charCodeAt(end - 1) === 46) --end
+
+    return `${str.slice(0, end)}`
+  }
+
+  throw new Error('Invalid arguments for numberToFixed')
+}
+
+function stringToFixed(
+  _str: string,
+  args: Parameters<typeof numberToFixed>[1],
+) {
+  const str = withoutScientificNotation(_str)
+
+  if (!str) {
+    throw new Error('Invalid number string')
+  }
+
+  const [integerPart = '0', decimalPart = ''] = str.split('.')
+
+  if ('fixed' in args) {
+    const fixedDecimal = decimalPart
+      .slice(0, args.fixed)
+      .padEnd(args.fixed, '0')
+
+    const res = `${integerPart}${fixedDecimal ? `.${fixedDecimal}` : ''}`
+    return roundString(str, res)
+  }
+
+  if ('significant' in args) {
+    let remainingLength = args.significant - integerPart.length
+
+    if (integerPart === '0' || integerPart.includes('-')) {
+      remainingLength += 1
+    }
+
+    // Handle leading zeros in decimal part
+    for (let i = 0; i < decimalPart.length; i++) {
+      if (decimalPart[i] === '0') {
+        remainingLength += 1
+      }
+    }
+
+    let significantDecimal = decimalPart.slice(0, remainingLength)
+    while (significantDecimal.endsWith('0')) {
+      significantDecimal = significantDecimal.slice(0, -1)
+    }
+
+    const res = `${integerPart}${significantDecimal ? `.${significantDecimal}` : ''}`
+    return roundString(str, res)
+  }
+
+  if ('maxFixed' in args) {
+    let fixedDecimal = decimalPart.slice(0, args.maxFixed)
+    while (fixedDecimal.endsWith('0')) {
+      fixedDecimal = fixedDecimal.slice(0, -1)
+    }
+
+    return `${integerPart}${fixedDecimal ? `.${fixedDecimal}` : ''}`
+  }
+
+  throw new Error('Invalid arguments for stringToFixed')
+}
+
+function roundString(original: string, formatted: string) {
+  const nextDigitIndex = formatted.length
+
+  let nextDigit = original.charCodeAt(nextDigitIndex)
+  if (nextDigit === '.'.charCodeAt(0)) {
+    nextDigit = original.charCodeAt(nextDigitIndex + 1)
+  }
+
+  if (!Number.isNaN(nextDigit) && nextDigit >= '5'.charCodeAt(0)) {
+    const lastDigit = formatted.charCodeAt(formatted.length - 1)
+    return `${formatted.substring(0, formatted.length - 1)}${String.fromCharCode(lastDigit + 1)}`
+  }
+
+  return formatted
+}

package/generic/format/percent.ts

@@ -0,0 +1,27 @@
+export const formatPercent = (value: any) => {
+  value = value ?? 0
+  let negative = false
+
+  if (value < 0) {
+    negative = true
+    value = Math.abs(value)
+  }
+
+  if (value === 0) {
+    return '0.00%'
+  }
+
+  if (value < 0.0001) {
+    return '<0.01%'
+  }
+
+  if (value > 1000) {
+    return '>100000%'
+  }
+
+  value = value * 100
+
+  const decimalCount = Math.min(value.toString().split('.')[1]?.length || 0, 2)
+
+  return `${negative ? '-' : ''}${value.toFixed(decimalCount)}%`
+}

package/generic/format/price.ts

@@ -0,0 +1,57 @@
+// import numeral from 'numbro'
+
+// export const formatUSD = (
+//   value: string | number,
+//   inputString = '$0.00a',
+// ): string => {
+//   if (typeof value === 'string') value = Number(value)
+
+//   let negative = false
+//   if (value < 0) {
+//     negative = true
+//     value = Math.abs(value)
+//   }
+
+//   if (value === 0) return '$0.00'
+//   if (value < 0.000001) return '<$0.01'
+//   if (value < 0.0001) return numeral(value).format('$0.000000a')
+//   if (value < 0.001) return numeral(value).format('$0.0000a')
+//   if (value < 0.01) return numeral(value).format('$0.000a')
+//   return `${negative ? '-' : ''}${numeral(value).format(inputString)}`
+// }
+
+export const formatUSD = (value: string | number, inputString = '$0.00a') => {
+  value = value ?? 0
+  if (typeof value === 'string') value = Number(value)
+
+  let negative = false
+  if (value < 0) {
+    negative = true
+    value = Math.abs(value)
+  }
+
+  if (value === 0) return '$0.00'
+  if (value < 0.000001) return '<$0.01'
+  if (value < 0.0001) return formatValue(value, 6)
+  if (value < 0.001) return formatValue(value, 4)
+  if (value < 0.01) return formatValue(value, 3)
+
+  return `${negative ? '-' : ''}${formatValueWithSuffix(value, inputString)}`
+}
+
+const formatValue = (value: number, decimalPlaces: number) => {
+  return `$${value.toFixed(decimalPlaces)}`
+}
+
+const formatValueWithSuffix = (value: number, inputString: string) => {
+  const suffixes = ['', 'k', 'm', 'b', 't']
+  let suffixIndex = 0
+  while (value >= 1000 && suffixIndex < suffixes.length - 1) {
+    value /= 1000
+    suffixIndex++
+  }
+
+  const format = inputString.replace(/[^0.]/g, '')
+  const decimalPlaces = format.split('.')[1]?.length || 0
+  return `$${value.toFixed(decimalPlaces)}${suffixes[suffixIndex]}`
+}

package/generic/index.ts

@@ -0,0 +1,7 @@
+export * from './chain/index.js'
+export * from './currency/index.js'
+export * from './format/index.js'
+export * from './math/index.js'
+export * from './types/index.js'
+export * from './utils/index.js'
+export * from './validate/index.js'

package/generic/math/abs.ts

@@ -0,0 +1,3 @@
+export function abs(x: bigint) {
+  return x < 0n ? -x : x
+}

package/generic/math/constants.ts

@@ -0,0 +1,26 @@
+export const ZERO = 0n
+export const ONE = 1n
+export const TWO = 2n
+export const THREE = 3n
+export const FIVE = 5n
+export const TEN = 10n
+
+export const _100 = 100n
+export const _997 = 997n
+export const _1000 = 1000n
+export const _9994 = 9994n
+export const _9995 = 9995n
+export const _10000 = 10000n
+
+export const _1e18 = 10n ** 18n
+export const _1e12 = 10n ** 12n
+export const _1e9 = 10n ** 9n
+export const _1e6 = 10n ** 6n
+
+export const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER)
+export const MAX_UINT256 = BigInt(
+  '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+)
+
+// 2^128 - 1
+export const MAX_UINT128 = 2n ** 128n - 1n

package/generic/math/difference.ts

@@ -0,0 +1,6 @@
+export function difference(a: bigint, b: bigint): bigint {
+  if (a > b) {
+    return a - b
+  }
+  return b - a
+}