sushi 6.0.11 → 6.0.13

package/generic/math/fraction.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, it } from 'vitest'
+import { Fraction } from './fraction.js'
+
+describe('Fraction', () => {
+  describe('constructor', () => {
+    it('should create fraction from positive integer', () => {
+      const fraction = new Fraction(5)
+      expect(fraction.numerator).toBe(5n)
+      expect(fraction.denominator).toBe(1n)
+    })
+
+    it('should create fraction from numerator/denominator object', () => {
+      const fraction = new Fraction({ numerator: 3, denominator: 4 })
+      expect(fraction.numerator).toBe(3n)
+      expect(fraction.denominator).toBe(4n)
+    })
+
+    it('should default denominator to 1 when not provided', () => {
+      const fraction = new Fraction({ numerator: 7 })
+      expect(fraction.numerator).toBe(7n)
+      expect(fraction.denominator).toBe(1n)
+    })
+
+    it('should throw on negative number input', () => {
+      expect(() => new Fraction(-1)).toThrow(
+        'Fraction must be a non-negative integer',
+      )
+    })
+
+    it('should throw on non-integer number input', () => {
+      expect(() => new Fraction(1.5)).toThrow(
+        'Fraction must be a non-negative integer',
+      )
+    })
+
+    it('should handle zero denominator input without throwing in constructor', () => {
+      // This reveals a potential bug - constructor doesn't validate denominator
+      const fraction = new Fraction({ numerator: 1, denominator: 0 })
+      expect(fraction.denominator).toBe(0n)
+    })
+
+    it('should handle very large numbers', () => {
+      const large = 2n ** 100n
+      const fraction = new Fraction({
+        numerator: large,
+        denominator: large + 1n,
+      })
+      expect(fraction.numerator).toBe(large)
+      expect(fraction.denominator).toBe(large + 1n)
+    })
+  })
+
+  describe('quotient and remainder', () => {
+    it('should calculate quotient correctly', () => {
+      const fraction = new Fraction({ numerator: 7, denominator: 3 })
+      expect(fraction.quotient).toBe(2n)
+    })
+
+    it('should calculate remainder correctly', () => {
+      const fraction = new Fraction({ numerator: 7, denominator: 3 })
+      expect(fraction.remainder).toBe(1n)
+    })
+
+    it('should handle zero denominator in quotient calculation', () => {
+      const fraction = new Fraction({ numerator: 1, denominator: 0 })
+      // This should throw due to division by zero, but let's see what happens
+      expect(() => fraction.quotient).toThrow()
+    })
+  })
+
+  describe('invert', () => {
+    it('should invert fraction correctly', () => {
+      const fraction = new Fraction({ numerator: 3, denominator: 4 })
+      const inverted = fraction.invert()
+      expect(inverted.numerator).toBe(4n)
+      expect(inverted.denominator).toBe(3n)
+    })
+
+    it('should throw when inverting zero numerator', () => {
+      const fraction = new Fraction({ numerator: 0, denominator: 5 })
+      expect(() => fraction.invert()).toThrow(
+        'Cannot invert a fraction with a numerator of 0',
+      )
+    })
+  })
+
+  describe('arithmetic operations', () => {
+    it('should add fractions correctly', () => {
+      const a = new Fraction({ numerator: 1, denominator: 3 })
+      const b = new Fraction({ numerator: 1, denominator: 6 })
+      const result = a.add(b)
+      // 1/3 + 1/6 = 2/6 + 1/6 = 3/6 = 1/2, but without reduction: 9/18
+      expect(result.numerator).toBe(9n)
+      expect(result.denominator).toBe(18n)
+    })
+
+    it('should add bigint correctly', () => {
+      const fraction = new Fraction({ numerator: 1, denominator: 2 })
+      const result = fraction.add(2n)
+      // 1/2 + 2 = 1/2 + 4/2 = 5/2
+      expect(result.numerator).toBe(5n)
+      expect(result.denominator).toBe(2n)
+    })
+
+    it('should subtract fractions correctly', () => {
+      const a = new Fraction({ numerator: 1, denominator: 2 })
+      const b = new Fraction({ numerator: 1, denominator: 4 })
+      const result = a.sub(b)
+      // 1/2 - 1/4 = 2/4 - 1/4 = 1/4, but without reduction: 2/8
+      expect(result.numerator).toBe(2n)
+      expect(result.denominator).toBe(8n)
+    })
+
+    it('should multiply fractions correctly', () => {
+      const a = new Fraction({ numerator: 2, denominator: 3 })
+      const b = new Fraction({ numerator: 3, denominator: 4 })
+      const result = a.mul(b)
+      expect(result.numerator).toBe(6n)
+      expect(result.denominator).toBe(12n)
+    })
+
+    it('should divide fractions correctly', () => {
+      const a = new Fraction({ numerator: 2, denominator: 3 })
+      const b = new Fraction({ numerator: 3, denominator: 4 })
+      const result = a.div(b)
+      // (2/3) / (3/4) = (2/3) * (4/3) = 8/9
+      expect(result.numerator).toBe(8n)
+      expect(result.denominator).toBe(9n)
+    })
+
+    it('should handle potential overflow in cross-multiplication', () => {
+      const large = 2n ** 100n
+      const a = new Fraction({ numerator: large, denominator: 1 })
+      const b = new Fraction({ numerator: large, denominator: 1 })
+      const result = a.add(b)
+      // This tests if cross-multiplication causes overflow
+      expect(result.numerator).toBe(large + large)
+      expect(result.denominator).toBe(1n)
+    })
+
+    it('should handle division by zero in div operation', () => {
+      const a = new Fraction({ numerator: 1, denominator: 2 })
+      const b = new Fraction({ numerator: 0, denominator: 1 })
+      const result = a.div(b)
+      // Division by zero fraction should create infinite denominator
+      expect(result.numerator).toBe(1n)
+      expect(result.denominator).toBe(0n)
+    })
+  })
+
+  describe('comparison operations', () => {
+    it('should compare fractions correctly', () => {
+      const a = new Fraction({ numerator: 1, denominator: 2 })
+      const b = new Fraction({ numerator: 1, denominator: 3 })
+
+      expect(a.gt(b)).toBe(true)
+      expect(b.lt(a)).toBe(true)
+      expect(a.eq(a)).toBe(true)
+      expect(a.neq(b)).toBe(true)
+    })
+
+    it('should compare with bigint correctly', () => {
+      const fraction = new Fraction({ numerator: 5, denominator: 2 })
+
+      expect(fraction.gt(2)).toBe(true)
+      expect(fraction.lt(3)).toBe(true)
+      expect(fraction.eq(2)).toBe(false)
+    })
+
+    it('should handle cross-multiplication overflow in comparison', () => {
+      const large = 2n ** 100n
+      const a = new Fraction({ numerator: large, denominator: 1 })
+      const b = new Fraction({ numerator: large + 1n, denominator: 1 })
+
+      expect(a.lt(b)).toBe(true)
+    })
+  })
+
+  describe('number conversion', () => {
+    it('should convert to number correctly', () => {
+      const fraction = new Fraction({ numerator: 1, denominator: 2 })
+      expect(fraction.toNumber()).toBe(0.5)
+    })
+
+    it('should handle precision loss in toNumber', () => {
+      const fraction = new Fraction({ numerator: 1, denominator: 3 })
+      expect(fraction.toNumber()).toBeCloseTo(0.3333333333333333)
+    })
+  })
+
+  describe('serialization', () => {
+    it('should serialize to JSON correctly', () => {
+      const fraction = new Fraction({ numerator: 3, denominator: 4 })
+      const json = fraction.toJSON()
+      expect(json).toEqual({ n: '3', d: '4' })
+    })
+
+    it('should handle large numbers in serialization', () => {
+      const large = 2n ** 100n
+      const fraction = new Fraction({
+        numerator: large,
+        denominator: large + 1n,
+      })
+      const json = fraction.toJSON()
+      expect(json.n).toBe(large.toString())
+      expect(json.d).toBe((large + 1n).toString())
+    })
+  })
+})

package/generic/math/fraction.ts

@@ -0,0 +1,191 @@
+import invariant from 'tiny-invariant'
+import { numberToFixed } from '../format/number.js'
+import type { BigintIsh } from '../types/bigintish.js'
+
+export class Fraction {
+  public readonly numerator: bigint
+  public readonly denominator: bigint
+
+  public constructor(
+    arg: { numerator: BigintIsh; denominator?: BigintIsh } | number,
+  ) {
+    if (typeof arg === 'number') {
+      invariant(
+        Number.isInteger(arg) && arg >= 0,
+        'Fraction must be a non-negative integer',
+      )
+      this.numerator = BigInt(arg)
+      this.denominator = 1n
+      return
+    }
+
+    this.numerator = BigInt(arg.numerator)
+    this.denominator = BigInt(arg.denominator ?? 1n)
+  }
+
+  public get quotient(): bigint {
+    return this.numerator / this.denominator
+  }
+
+  public get remainder(): bigint {
+    return this.numerator % this.denominator
+  }
+
+  public invert(): Fraction {
+    invariant(
+      this.numerator !== 0n,
+      'Cannot invert a fraction with a numerator of 0',
+    )
+
+    return new Fraction({
+      numerator: this.denominator,
+      denominator: this.numerator,
+    })
+  }
+
+  public add(other: Fraction | BigintIsh): Fraction {
+    if (other instanceof Fraction) {
+      return new Fraction({
+        numerator:
+          this.numerator * other.denominator +
+          other.numerator * this.denominator,
+        denominator: this.denominator * other.denominator,
+      })
+    }
+
+    return new Fraction({
+      numerator: this.numerator + this.denominator * BigInt(other),
+      denominator: this.denominator,
+    })
+  }
+
+  public sub(other: Fraction | BigintIsh): Fraction {
+    if (other instanceof Fraction) {
+      return new Fraction({
+        numerator:
+          this.numerator * other.denominator -
+          other.numerator * this.denominator,
+        denominator: this.denominator * other.denominator,
+      })
+    }
+
+    return new Fraction({
+      numerator: this.numerator - this.denominator * BigInt(other),
+      denominator: this.denominator,
+    })
+  }
+
+  public mul(other: Fraction | BigintIsh): Fraction {
+    if (other instanceof Fraction) {
+      return new Fraction({
+        numerator: this.numerator * other.numerator,
+        denominator: this.denominator * other.denominator,
+      })
+    }
+
+    return new Fraction({
+      numerator: this.numerator * BigInt(other),
+      denominator: this.denominator,
+    })
+  }
+
+  public div(other: Fraction | BigintIsh): Fraction {
+    if (other instanceof Fraction) {
+      return new Fraction({
+        numerator: this.numerator * other.denominator,
+        denominator: this.denominator * other.numerator,
+      })
+    }
+
+    return new Fraction({
+      numerator: this.numerator,
+      denominator: this.denominator * BigInt(other),
+    })
+  }
+
+  private compare(
+    other: Fraction | BigintIsh,
+    type: '<' | '<=' | '=' | '>=' | '>' | '!=',
+  ): boolean {
+    let a
+    let b
+
+    if (other instanceof Fraction) {
+      a = this.numerator * other.denominator
+      b = other.numerator * this.denominator
+    } else {
+      a = this.numerator
+      b = BigInt(other) * this.denominator
+    }
+
+    switch (type) {
+      case '<':
+        return a < b
+      case '<=':
+        return a <= b
+      case '=':
+        return a === b
+      case '>=':
+        return a >= b
+      case '>':
+        return a > b
+      case '!=':
+        return a !== b
+      default:
+        throw new Error(`Invalid comparison type: ${type}`)
+    }
+  }
+
+  public lt(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '<')
+  }
+
+  public lte(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '<=')
+  }
+
+  public eq(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '=')
+  }
+
+  public gte(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '>=')
+  }
+
+  public gt(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '>')
+  }
+
+  public neq(other: Fraction | BigintIsh): boolean {
+    return this.compare(other, '!=')
+  }
+
+  public toNumber(): number {
+    return Number(this.numerator) / Number(this.denominator)
+  }
+
+  public toString(args: Parameters<typeof numberToFixed>[1]): string {
+    return numberToFixed(this.toNumber(), args)
+  }
+
+  public toSignificant(significantDigits: number): string {
+    return this.toNumber().toPrecision(significantDigits)
+  }
+
+  public toJSON() {
+    return {
+      n: this.numerator.toString(),
+      d: this.denominator.toString(),
+    }
+  }
+
+  /**
+   * Helper method for converting any super class back to a fraction
+   */
+  public get asFraction(): Fraction {
+    return new Fraction({
+      numerator: this.numerator,
+      denominator: this.denominator,
+    })
+  }
+}

package/generic/math/index.ts

@@ -0,0 +1,9 @@
+export * from './constants.js'
+export * from './percent.js'
+export * from './fraction.js'
+export { abs } from './abs.js'
+export { difference } from './difference.js'
+export { maximum } from './maximum.js'
+export { minimum } from './minimum.js'
+export { sqrt } from './sqrt.js'
+export { numberToBigInt } from './number-to-bigint.js'

package/generic/math/maximum.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns the biggest member of the array
+ * @param values the values from which the biggest gets returned
+ * @returns the biggest memmber of the array
+ */
+export function maximum(...values: bigint[]): bigint {
+  let highest = values[0] as bigint
+  for (let i = 1; i < values.length; i++) {
+    const value = values[i] as bigint
+    if (value > highest) {
+      highest = value
+    }
+  }
+  return highest
+}

package/generic/math/minimum.ts

@@ -0,0 +1,20 @@
+function minimum(...values: number[]): number
+function minimum(...values: bigint[]): bigint
+
+/**
+ * Returns the smallest member of the array
+ * @param values the values from which the smallest gets returned
+ * @returns the smallest memmber of the array
+ */
+function minimum(...values: number[] | bigint[]) {
+  let lowest = values[0] as number | bigint
+  for (let i = 1; i < values.length; i++) {
+    const value = values[i] as number | bigint
+    if (value < lowest) {
+      lowest = value
+    }
+  }
+  return lowest
+}
+
+export { minimum }

package/generic/math/number-to-bigint.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest'
+import { numberToBigInt } from './number-to-bigint.js'
+
+describe('numberToBigInt', () => {
+  describe('safe integer range', () => {
+    it('should convert small positive integers correctly', () => {
+      expect(numberToBigInt(0)).toBe(0n)
+      expect(numberToBigInt(1)).toBe(1n)
+      expect(numberToBigInt(42)).toBe(42n)
+      expect(numberToBigInt(1000)).toBe(1000n)
+    })
+
+    it('should convert small negative integers correctly', () => {
+      expect(numberToBigInt(-1)).toBe(-1n)
+      expect(numberToBigInt(-42)).toBe(-42n)
+      expect(numberToBigInt(-1000)).toBe(-1000n)
+    })
+
+    it('should round decimal numbers', () => {
+      expect(numberToBigInt(1.4)).toBe(1n)
+      expect(numberToBigInt(1.5)).toBe(2n)
+      expect(numberToBigInt(1.6)).toBe(2n)
+    })
+
+    it('should handle MAX_SAFE_INTEGER boundary', () => {
+      expect(numberToBigInt(Number.MAX_SAFE_INTEGER)).toBe(
+        BigInt(Number.MAX_SAFE_INTEGER),
+      )
+      expect(numberToBigInt(-Number.MAX_SAFE_INTEGER)).toBe(
+        BigInt(-Number.MAX_SAFE_INTEGER),
+      )
+    })
+  })
+
+  describe('large number handling', () => {
+    it('should handle numbers just above MAX_SAFE_INTEGER', () => {
+      const justAbove = Number.MAX_SAFE_INTEGER + 1
+      const result = numberToBigInt(justAbove)
+      expect(typeof result).toBe('bigint')
+      expect(result).toBeGreaterThan(BigInt(Number.MAX_SAFE_INTEGER))
+    })
+
+    it('should handle very large positive numbers', () => {
+      const veryLarge = Number.MAX_SAFE_INTEGER * 2
+      const result = numberToBigInt(veryLarge)
+      expect(typeof result).toBe('bigint')
+      expect(result).toBeGreaterThan(0n)
+    })
+
+    it('should handle very large negative numbers', () => {
+      const veryLarge = -Number.MAX_SAFE_INTEGER * 2
+      const result = numberToBigInt(veryLarge)
+      expect(typeof result).toBe('bigint')
+      expect(result).toBeLessThan(0n)
+    })
+
+    it('should preserve sign for large numbers', () => {
+      const large = Number.MAX_SAFE_INTEGER * 10
+      expect(numberToBigInt(large)).toBeGreaterThan(0n)
+      expect(numberToBigInt(-large)).toBeLessThan(0n)
+    })
+  })
+
+  describe('precision and rounding edge cases', () => {
+    it('should handle numbers that lose precision in JavaScript', () => {
+      // Numbers that can't be exactly represented as doubles
+      const imprecise = 0.1 + 0.2 // 0.30000000000000004
+      const result = numberToBigInt(imprecise)
+      expect(result).toBe(0n) // Should round to 0
+    })
+
+    it('should round large decimals correctly', () => {
+      const largeDecimal = Number.MAX_SAFE_INTEGER + 0.7
+      const result = numberToBigInt(largeDecimal)
+      expect(typeof result).toBe('bigint')
+    })
+
+    it('should handle scientific notation', () => {
+      expect(numberToBigInt(1e6)).toBe(1000000n)
+      expect(numberToBigInt(1.5e6)).toBe(1500000n)
+      expect(numberToBigInt(-1e6)).toBe(-1000000n)
+    })
+  })
+
+  describe('special values', () => {
+    it('should handle zero', () => {
+      expect(numberToBigInt(0)).toBe(0n)
+      expect(numberToBigInt(-0)).toBe(0n)
+    })
+
+    it('should handle Infinity', () => {
+      // Function should handle gracefully or throw
+      expect(() => numberToBigInt(Number.POSITIVE_INFINITY)).toThrow()
+      expect(() => numberToBigInt(Number.NEGATIVE_INFINITY)).toThrow()
+    })
+
+    it('should handle NaN', () => {
+      // Function should handle gracefully or throw
+      expect(() => numberToBigInt(Number.NaN)).toThrow()
+    })
+
+    it('should handle very small numbers', () => {
+      expect(numberToBigInt(Number.MIN_VALUE)).toBe(0n) // Should round to 0
+      expect(numberToBigInt(1e-10)).toBe(0n) // Should round to 0
+    })
+  })
+
+  describe('mathematical properties', () => {
+    it('should maintain relative magnitude for large numbers', () => {
+      const a = Number.MAX_SAFE_INTEGER * 2
+      const b = Number.MAX_SAFE_INTEGER * 3
+      const resultA = numberToBigInt(a)
+      const resultB = numberToBigInt(b)
+      expect(resultB).toBeGreaterThan(resultA)
+    })
+
+    it('should handle powers of 2 correctly', () => {
+      // Powers of 2 are important for binary representations
+      const powers = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+      for (const power of powers) {
+        expect(numberToBigInt(power)).toBe(BigInt(power))
+      }
+    })
+
+    it('should be approximately linear for large inputs', () => {
+      // Test that doubling input approximately doubles output for large numbers
+      const base = Number.MAX_SAFE_INTEGER * 2
+      const double = base * 2
+      const resultBase = numberToBigInt(base)
+      const resultDouble = numberToBigInt(double)
+
+      // Should be roughly 2x (allowing for some precision loss)
+      const ratio = Number(resultDouble) / Number(resultBase)
+      expect(ratio).toBeGreaterThan(1.5)
+      expect(ratio).toBeLessThan(2.5)
+    })
+  })
+
+  describe('implementation details', () => {
+    it('should trigger the large number path for numbers >= MAX_SAFE_INTEGER', () => {
+      // This tests the exp >= 51 condition in the code
+      const atThreshold = Number.MAX_SAFE_INTEGER + 1
+      const result = numberToBigInt(atThreshold)
+      expect(typeof result).toBe('bigint')
+    })
+
+    it('should handle mantissa calculations correctly', () => {
+      // Test the internal mantissa and shift calculations
+      const largeNumbers = [
+        Number.MAX_SAFE_INTEGER * 2,
+        Number.MAX_SAFE_INTEGER * 4,
+        Number.MAX_SAFE_INTEGER * 8,
+      ]
+
+      for (const num of largeNumbers) {
+        const result = numberToBigInt(num)
+        expect(typeof result).toBe('bigint')
+        expect(result).toBeGreaterThan(0n)
+      }
+    })
+  })
+})

package/generic/math/number-to-bigint.ts

@@ -0,0 +1,11 @@
+export function numberToBigInt(value: number): bigint {
+  const v = Math.abs(value)
+  if (v <= Number.MAX_SAFE_INTEGER) return BigInt(Math.round(value))
+
+  const exp = Math.floor(Math.log(v) / Math.LN2)
+  console.assert(exp >= 51, 'Internal Error 314')
+  const shift = exp - 51
+  const mant = Math.round(v / 2 ** shift)
+  const res = BigInt(mant) * 2n ** BigInt(shift)
+  return value > 0 ? res : res * -1n
+}

package/generic/math/percent.ts

@@ -0,0 +1,25 @@
+import { numberToFixed } from '../format/number.js'
+import { Fraction } from './fraction.js'
+
+export class Percent extends Fraction {
+  /**
+   *
+   * @param args.maxFixed - The maximum number of fixed decimal places to display, only if relevant, eg. "0" for 0, "1.23" for 0.0123, etc.
+   * @param args.fixed - The number of fixed decimal places to display, always, eg. "0.00" for 0, "1.23" for 0.0123, etc.
+   * @returns A string representation of the percent value, eg. "1.53"
+   */
+  public override toString(
+    args: Parameters<typeof numberToFixed>[1] = { fixed: 2 },
+  ): string {
+    const num = this.toNumber() * 100
+    const str = numberToFixed(num, args)
+
+    return str
+  }
+
+  public toPercentString(
+    args: Parameters<typeof numberToFixed>[1] = { fixed: 2 },
+  ): string {
+    return `${this.toString(args)}%`
+  }
+}

package/generic/math/sqrt.ts

@@ -0,0 +1,25 @@
+import invariant from 'tiny-invariant'
+import { MAX_SAFE_INTEGER, ONE, TWO, ZERO } from './constants.js'
+
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+export function sqrt(value: bigint): bigint {
+  invariant(value >= ZERO, 'NEGATIVE')
+
+  // rely on built in sqrt if possible
+  if (value < MAX_SAFE_INTEGER) {
+    return BigInt(Math.floor(Math.sqrt(Number(value))))
+  }
+
+  let z: bigint
+  let x: bigint
+  z = value
+  x = value / TWO + ONE
+  while (x < z) {
+    z = x
+    x = (value / x + x) / TWO
+  }
+  return z
+}

package/generic/types/bigintish.ts

@@ -0,0 +1 @@
+export type BigintIsh = number | string | bigint

package/generic/types/id.ts

@@ -0,0 +1,9 @@
+import type { ChainId } from '../chain/chains.js'
+
+export type ID<
+  TChainId extends ChainId = ChainId,
+  TAddress extends string = string,
+  TIncludeNative extends boolean = false,
+> =
+  | `${TChainId}:${TAddress}`
+  | (TIncludeNative extends true ? `${TChainId}:NATIVE` : never)

package/generic/types/index.ts

@@ -0,0 +1,5 @@
+export type * from './bigintish.js'
+export type * from './id.js'
+export type * from './mutable.js'
+export type * from './replace.js'
+export type * from './union-to-intersection.js'