sushi 6.7.0 → 7.0.0

package/generic/currency/price.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest'
+import { Price } from './price.js'
+import { Token } from './token.js'
+
+class TestToken extends Token {
+  public override toJSON() {
+    return {} as any
+  }
+
+  public override wrap() {
+    return this
+  }
+}
+
+const wbtc = new TestToken({
+  decimals: 8,
+  symbol: 'WBTC',
+  name: 'Wrapped Bitcoin',
+  chainId: 1,
+  address: '0x1234567890abcdef1234567890abcdef12345678',
+})
+
+const usdc = new TestToken({
+  decimals: 6,
+  symbol: 'USDC',
+  name: 'USD Coin',
+  chainId: 1,
+  address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+})
+
+describe('Price', () => {
+  describe('fromHuman', () => {
+    it('creates a price for currencies with different decimals', () => {
+      const price = Price.fromHuman(wbtc, usdc, '1.25')
+
+      expect(price.base).toBe(wbtc)
+      expect(price.quote).toBe(usdc)
+      expect(price.toNumber()).toBe(1.25)
+      expect(price.numerator).toBe(125000000n)
+      expect(price.denominator).toBe(10000000000n)
+      expect(price.invert().toNumber()).toBe(0.8)
+      expect(price.invert().toString({ maxFixed: 18 })).toBe('0.8')
+    })
+
+    it('accepts a decimal without a leading zero', () => {
+      expect(Price.fromHuman(wbtc, usdc, '.5').toNumber()).toBe(0.5)
+    })
+
+    it('accepts zero', () => {
+      const price = Price.fromHuman(wbtc, usdc, '0')
+
+      expect(price.toNumber()).toBe(0)
+      expect(price.numerator).toBe(0n)
+    })
+
+    it('preserves more than 18 fractional digits', () => {
+      const price = Price.fromHuman(wbtc, usdc, '0.0000000000000000001')
+
+      expect(price.numerator).toBe(1000000n)
+      expect(price.denominator).toBe(1000000000000000000000000000n)
+    })
+
+    it.each([
+      '',
+      '-1',
+      '1e6',
+      'Infinity',
+    ])('rejects invalid input %j', (value) => {
+      expect(() => Price.fromHuman(wbtc, usdc, value)).toThrow(
+        `Invalid price: ${value}`,
+      )
+    })
+  })
+
+  describe('tryFromHuman', () => {
+    it('returns a price for valid input', () => {
+      expect(Price.tryFromHuman(wbtc, usdc, '1.25')?.toNumber()).toBe(1.25)
+    })
+
+    it.each([
+      '',
+      '-1',
+      '1e6',
+      'Infinity',
+    ])('returns undefined for invalid input %j', (value) => {
+      expect(Price.tryFromHuman(wbtc, usdc, value)).toBeUndefined()
+    })
+  })
+
+  describe('string formatting', () => {
+    it('formats very small prices without scientific notation', () => {
+      const price = Price.fromHuman(wbtc, usdc, '0.000000000001')
+
+      expect(price.toString({ maxFixed: 18 })).toBe('0.000000000001')
+      expect(price.toString({ significant: 6 })).toBe('0.000000000001')
+    })
+
+    it('truncates repeating prices to maxFixed decimal places', () => {
+      const price = new Price({
+        base: wbtc,
+        quote: wbtc,
+        numerator: 1n,
+        denominator: 3n,
+      })
+
+      expect(price.toString({ maxFixed: 18 })).toBe('0.333333333333333333')
+    })
+
+    it('preserves prices beyond Number.MAX_SAFE_INTEGER', () => {
+      const price = new Price({
+        base: wbtc,
+        quote: wbtc,
+        numerator: 9007199254740993n,
+      })
+
+      expect(price.toString({ maxFixed: 18 })).toBe('9007199254740993')
+    })
+
+    it('supports fixed, maxFixed, and significant formatting', () => {
+      const price = new Price({
+        base: wbtc,
+        quote: wbtc,
+        numerator: 1n,
+        denominator: 8n,
+      })
+
+      expect(price.toString({ fixed: 3 })).toBe('0.125')
+      expect(price.toString({ maxFixed: 2 })).toBe('0.12')
+      expect(price.toString({ significant: 2 })).toBe('0.13')
+    })
+  })
+})

package/generic/currency/price.ts

@@ -1,4 +1,3 @@
-import { numberToFixed } from '../format/number.js'
 import { Fraction } from '../math/fraction.js'
 import type { BigintIsh } from '../types/bigintish.js'
 import { Amount } from './amount.js'
@@ -11,6 +10,45 @@ export class Price<
   public readonly base: TBase
   public readonly quote: TQuote
 
+  /**
+   * Creates a Price from a human-readable quote-per-base value, e.g. "1.5".
+   */
+  public static fromHuman<TBase extends Currency, TQuote extends Currency>(
+    base: TBase,
+    quote: TQuote,
+    value: string,
+  ): Price<TBase, TQuote> {
+    if (!value.match(/^\d*\.?\d+$/)) {
+      throw new Error(`Invalid price: ${value}`)
+    }
+
+    const [whole = '', fraction = ''] = value.split('.')
+    const decimalScale = 10n ** BigInt(fraction.length)
+    const valueWithoutDecimals = BigInt(`${whole}${fraction}`)
+
+    return new Price({
+      base,
+      quote,
+      numerator: valueWithoutDecimals * 10n ** BigInt(quote.decimals),
+      denominator: decimalScale * 10n ** BigInt(base.decimals),
+    })
+  }
+
+  /**
+   * Tries to create a Price from a human-readable quote-per-base value.
+   */
+  public static tryFromHuman<TBase extends Currency, TQuote extends Currency>(
+    base: TBase,
+    quote: TQuote,
+    value: string,
+  ): Price<TBase, TQuote> | undefined {
+    try {
+      return Price.fromHuman(base, quote, value)
+    } catch {
+      return undefined
+    }
+  }
+
   constructor(
     args:
       | {
@@ -65,8 +103,8 @@ export class Price<
     return super.mul(this.scalar).toNumber()
   }
 
-  public override toString(args: Parameters<typeof numberToFixed>[1]): string {
-    return numberToFixed(this.toNumber(), args)
+  public override toString(args: Parameters<Fraction['toString']>[0]): string {
+    return super.mul(this.scalar).toString(args)
   }
 
   public override toSignificant(significantDigits = 5): string {

package/generic/currency/serialized-token.ts

@@ -0,0 +1,41 @@
+import * as z from 'zod'
+import type { CurrencyMetadata } from './currency.js'
+
+export function createSerializedTokenSchema<
+  TChainId extends number,
+  TAddress extends string,
+  TMetadata extends {} = CurrencyMetadata,
+  TExtra extends z.ZodRawShape = Record<never, never>,
+>({
+  isChainId,
+  isAddress,
+  metadata,
+  extra = {} as TExtra,
+}: {
+  isChainId: (chainId: number) => chainId is TChainId
+  isAddress: (address: string) => address is TAddress
+  metadata?: z.ZodType<TMetadata> | undefined
+  extra?: TExtra
+}) {
+  return z.object({
+    chainId: z
+      .number()
+      .int()
+      .refine(isChainId)
+      .transform((value) => value as TChainId),
+    address: z
+      .string()
+      .refine(isAddress)
+      .transform((value) => value as TAddress),
+    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>,
+    ...extra,
+  })
+}

package/generic/math/fraction.test.ts

@@ -188,6 +188,103 @@ describe('Fraction', () => {
     })
   })
 
+  describe('string formatting', () => {
+    it('formats terminating fractions without floating-point artifacts', () => {
+      const fraction = new Fraction({ numerator: 4n, denominator: 5n })
+
+      expect(fraction.toString({ maxFixed: 18 })).toBe('0.8')
+    })
+
+    it('truncates repeating fractions to maxFixed decimal places', () => {
+      const fraction = new Fraction({ numerator: 1n, denominator: 3n })
+
+      expect(fraction.toString({ maxFixed: 18 })).toBe('0.333333333333333333')
+    })
+
+    it('preserves very small fractions in ordinary decimal notation', () => {
+      const fraction = new Fraction({
+        numerator: 1n,
+        denominator: 10n ** 12n,
+      })
+
+      expect(fraction.toString({ maxFixed: 18 })).toBe('0.000000000001')
+      expect(fraction.toSignificant(6)).toBe('0.000000000001')
+    })
+
+    it('preserves integers beyond Number.MAX_SAFE_INTEGER', () => {
+      const fraction = new Fraction({
+        numerator: 9007199254740993n,
+        denominator: 1n,
+      })
+
+      expect(fraction.toString({ maxFixed: 18 })).toBe('9007199254740993')
+    })
+
+    it('rounds and pads fixed decimal places', () => {
+      expect(
+        new Fraction({ numerator: 1n, denominator: 8n }).toString({
+          fixed: 2,
+        }),
+      ).toBe('0.13')
+      expect(
+        new Fraction({ numerator: 1n, denominator: 2n }).toString({
+          fixed: 3,
+        }),
+      ).toBe('0.500')
+      expect(
+        new Fraction({ numerator: 199995n, denominator: 1000n }).toString({
+          fixed: 2,
+        }),
+      ).toBe('200.00')
+    })
+
+    it('rounds to significant digits without scientific notation', () => {
+      expect(
+        new Fraction({ numerator: 1n, denominator: 3n }).toString({
+          significant: 6,
+        }),
+      ).toBe('0.333333')
+      expect(
+        new Fraction({
+          numerator: 123456789123n,
+          denominator: 100n,
+        }).toString({ significant: 4 }),
+      ).toBe('1235000000')
+      expect(
+        new Fraction({ numerator: 9999n, denominator: 10n }).toString({
+          significant: 3,
+        }),
+      ).toBe('1000')
+    })
+
+    it('formats negative fractions', () => {
+      const fraction = new Fraction({ numerator: -1n, denominator: 8n })
+
+      expect(fraction.toString({ fixed: 2 })).toBe('-0.13')
+      expect(fraction.toString({ maxFixed: 2 })).toBe('-0.12')
+    })
+
+    it('formats zero-denominator fractions as non-finite numbers', () => {
+      const infinity = new Fraction({ numerator: 1n, denominator: 2n }).div(
+        new Fraction({ numerator: 0n }),
+      )
+
+      expect(infinity.toString({ fixed: 2 })).toBe('Infinity')
+      expect(infinity.toString({ maxFixed: 2 })).toBe('Infinity')
+      expect(infinity.toString({ significant: 2 })).toBe('Infinity')
+      expect(
+        new Fraction({ numerator: -1n, denominator: 0n }).toString({
+          maxFixed: 2,
+        }),
+      ).toBe('-Infinity')
+      expect(
+        new Fraction({ numerator: 0n, denominator: 0n }).toString({
+          maxFixed: 2,
+        }),
+      ).toBe('NaN')
+    })
+  })
+
   describe('serialization', () => {
     it('should serialize to JSON correctly', () => {
       const fraction = new Fraction({ numerator: 3, denominator: 4 })

package/generic/math/fraction.ts

@@ -1,5 +1,5 @@
 import invariant from 'tiny-invariant'
-import { numberToFixed } from '../format/number.js'
+import type { numberToFixed } from '../format/number.js'
 import type { BigintIsh } from '../types/bigintish.js'
 
 export class Fraction {
@@ -164,12 +164,115 @@ export class Fraction {
     return Number(this.numerator) / Number(this.denominator)
   }
 
+  private formatDecimal(
+    decimalPlaces: number,
+    { round, trim }: { round: boolean; trim: boolean },
+  ): string {
+    invariant(
+      Number.isSafeInteger(decimalPlaces),
+      'Decimal places must be a safe integer',
+    )
+    invariant(this.denominator !== 0n, 'Cannot format a fraction by zero')
+
+    const negative = this.numerator < 0n !== this.denominator < 0n
+    const numerator = this.numerator < 0n ? -this.numerator : this.numerator
+    const denominator =
+      this.denominator < 0n ? -this.denominator : this.denominator
+
+    const scale = 10n ** BigInt(Math.abs(decimalPlaces))
+    const scaledDenominator =
+      decimalPlaces >= 0 ? denominator : denominator * scale
+    const scaledNumerator = decimalPlaces >= 0 ? numerator * scale : numerator
+
+    let scaledValue = scaledNumerator / scaledDenominator
+    const remainder = scaledNumerator % scaledDenominator
+    if (round && remainder * 2n >= scaledDenominator) {
+      scaledValue += 1n
+    }
+
+    let integerPart: string
+    let decimalPart = ''
+    if (decimalPlaces > 0) {
+      const value = scaledValue.toString().padStart(decimalPlaces + 1, '0')
+      integerPart = value.slice(0, -decimalPlaces)
+      decimalPart = value.slice(-decimalPlaces)
+    } else {
+      integerPart = (scaledValue * scale).toString()
+    }
+
+    if (trim) {
+      decimalPart = decimalPart.replace(/0+$/, '')
+    }
+
+    return `${negative ? '-' : ''}${integerPart}${
+      decimalPart ? `.${decimalPart}` : ''
+    }`
+  }
+
+  private getDecimalExponent(): number {
+    const numerator = this.numerator < 0n ? -this.numerator : this.numerator
+    const denominator =
+      this.denominator < 0n ? -this.denominator : this.denominator
+
+    invariant(numerator !== 0n, 'Cannot get the decimal exponent of zero')
+    invariant(denominator !== 0n, 'Cannot format a fraction by zero')
+
+    let exponent = numerator.toString().length - denominator.toString().length
+
+    if (
+      (exponent >= 0 && numerator < denominator * 10n ** BigInt(exponent)) ||
+      (exponent < 0 && numerator * 10n ** BigInt(-exponent) < denominator)
+    ) {
+      exponent -= 1
+    }
+
+    return exponent
+  }
+
   public toString(args: Parameters<typeof numberToFixed>[1]): string {
-    return numberToFixed(this.toNumber(), args)
+    if ('fixed' in args) {
+      invariant(
+        Number.isSafeInteger(args.fixed) && args.fixed >= 0,
+        'Fixed digits must be a non-negative safe integer',
+      )
+    } else if ('maxFixed' in args) {
+      invariant(
+        Number.isSafeInteger(args.maxFixed) && args.maxFixed >= 0,
+        'Maximum fixed digits must be a non-negative safe integer',
+      )
+    } else if ('significant' in args) {
+      invariant(
+        Number.isSafeInteger(args.significant) && args.significant > 0,
+        'Significant digits must be a positive safe integer',
+      )
+    } else {
+      throw new Error('Invalid arguments for Fraction.toString')
+    }
+
+    if (this.denominator === 0n) {
+      return this.toNumber().toString()
+    }
+
+    if ('fixed' in args) {
+      return this.formatDecimal(args.fixed, { round: true, trim: false })
+    }
+
+    if ('maxFixed' in args) {
+      return this.formatDecimal(args.maxFixed, { round: false, trim: true })
+    }
+
+    if ('significant' in args) {
+      if (this.numerator === 0n) return '0'
+
+      const decimalPlaces = args.significant - this.getDecimalExponent() - 1
+      return this.formatDecimal(decimalPlaces, { round: true, trim: true })
+    }
+
+    throw new Error('Invalid arguments for Fraction.toString')
   }
 
   public toSignificant(significantDigits: number): string {
-    return this.toNumber().toPrecision(significantDigits)
+    return this.toString({ significant: significantDigits })
   }
 
   public toJSON() {

package/generic/utils/id.test-d.ts

@@ -1,8 +1,8 @@
 import { describe, expectTypeOf, it } from 'vitest'
-import { SvmChainId } from '~/svm/chain/chains.js'
-import type { SvmAddress } from '~/svm/currency/token.js'
 import type { EvmChainId } from '../../evm/chain/chains.js'
 import type { EvmAddress } from '../../evm/currency/token.js'
+import { SvmChainId } from '../../svm/chain/chains.js'
+import type { SvmAddress } from '../../svm/currency/token.js'
 import type { ID } from '../types/id.js'
 import { getChainIdAddressFromId, getIdFromChainIdAddress } from './id.js'
 

package/generic/validate/create-address-schema.ts

@@ -0,0 +1,18 @@
+import * as z from 'zod'
+
+export function createAddressSchema<TAddress extends string>(
+  isAddress: (value: string) => value is TAddress,
+  normalize: (value: TAddress) => TAddress,
+  normalizeBeforeValidation = false,
+) {
+  if (normalizeBeforeValidation) {
+    return z
+      .string()
+      .transform((value) => normalize(value as TAddress))
+      .refine(isAddress, { message: 'Invalid address' })
+  }
+  return z
+    .string()
+    .refine(isAddress, { message: 'Invalid address' })
+    .transform((value) => normalize(value as TAddress))
+}

package/generic/validate/index.ts

@@ -1,3 +1,4 @@
+export * from './create-address-schema.js'
 export * from './isPromiseFulfilled.js'
 export * from './isPromiseRejected.js'
 export * from './zod.js'

package/mvm/chain/chains.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { getMvmChainById, isMvmChainId, MvmChainId } from './chains.js'
+
+describe('MVM chains', () => {
+  it('returns Aptos with working explorer URLs', () => {
+    const chain = getMvmChainById(MvmChainId.APTOS)
+
+    expect(chain.getTransactionUrl('0xabc')).toBe(
+      'https://explorer.aptoslabs.com/txn/0xabc',
+    )
+    expect(chain.getAccountUrl('0x1')).toBe(
+      'https://explorer.aptoslabs.com/account/0x1',
+    )
+    expect(chain.getTokenUrl('0x1::coin::Coin')).toBe(
+      'https://explorer.aptoslabs.com/coin/0x1::coin::Coin',
+    )
+    expect(isMvmChainId(MvmChainId.APTOS)).toBe(true)
+    expect(isMvmChainId(1)).toBe(false)
+  })
+})

package/mvm/chain/define-chain.ts

@@ -1,15 +1,18 @@
+import { defineChain } from '../../generic/chain/define-chain.js'
 import type {
   BlockExplorers,
-  Chain,
+  ChainDefinition,
   NetType,
 } from '../../generic/chain/interface.js'
 import type { MvmChainId, MvmChainKey } from './chains.js'
 
 export type MvmChainType = 'mvm'
 
-type MvmChainBase<TChainId extends number, TChainKey extends string> = Chain<
+type MvmChainBase<
+  TChainId extends number,
+  TChainKey extends string,
+> = ChainDefinition<
   MvmChainType,
-  // @ts-expect-error prevent infinite loop
   TChainId,
   TChainKey,
   Readonly<string>,
@@ -28,15 +31,9 @@ type MvmChainInput = Omit<
 >
 
 export function defineMvmChain<const T extends MvmChainInput>(chain: T) {
-  return {
-    ...chain,
-    type: 'mvm' as const,
-
-    getTransactionUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/txn/${input}`,
-    getAccountUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/account/${input}`,
-    getTokenUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/coin/${input}`,
-  } as const satisfies MvmChainBase<number, string>
+  return defineChain('mvm', chain, {
+    transaction: (url, input) => `${url}/txn/${input}`,
+    account: (url, input) => `${url}/account/${input}`,
+    token: (url, input) => `${url}/coin/${input}`,
+  })
 }

package/mvm/currency/token.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { MvmChainId } from '../chain/chains.js'
+import { MvmToken, serializedMvmTokenSchema } from './token.js'
+
+const address = '0x1::aptos_coin::AptosCoin' as const
+
+describe('MvmToken', () => {
+  const token = new MvmToken({
+    chainId: MvmChainId.APTOS,
+    address,
+    symbol: 'APT',
+    name: 'Aptos Coin',
+    decimals: 8,
+    metadata: { verified: true },
+  })
+
+  it('uses Move coin types as token IDs and wraps to itself', () => {
+    expect(token.id).toBe(`${MvmChainId.APTOS}:${address}`)
+    expect(token.wrap()).toBe(token)
+  })
+
+  it('round-trips through JSON and the serialized schema', () => {
+    const serialized = serializedMvmTokenSchema().parse(token.toJSON())
+    const restored = MvmToken.fromJSON(serialized)
+
+    expect(restored).toEqual(token)
+    expect(restored.toJSON()).toEqual(serialized)
+  })
+
+  it('defaults missing metadata and rejects invalid serialized tokens', () => {
+    const serialized = token.toJSON()
+    expect(
+      serializedMvmTokenSchema().parse({ ...serialized, metadata: undefined })
+        .metadata,
+    ).toEqual({})
+    expect(() =>
+      serializedMvmTokenSchema().parse({ ...serialized, chainId: -5 }),
+    ).toThrow()
+    expect(() =>
+      serializedMvmTokenSchema().parse({ ...serialized, decimals: -1 }),
+    ).toThrow()
+    expect(() =>
+      serializedMvmTokenSchema().parse({ ...serialized, type: 'native' }),
+    ).toThrow()
+  })
+})

package/mvm/currency/token.ts

@@ -1,5 +1,6 @@
-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 { isMvmChainId, type MvmChainId } from '../chain/chains.js'
 import { normalizeMvmAddress } from '../utils/normalize-address.js'
@@ -38,7 +39,7 @@ export class MvmToken<
       type: this.type,
 
       metadata: this.metadata,
-    } as const
+    }
   }
 
   static fromJSON<TMetadata extends CurrencyMetadata>(
@@ -57,26 +58,10 @@ export const serializedMvmTokenSchema = <
 }: {
   metadata?: z.ZodType<TMetadata>
 } = {}) =>
-  z.object({
-    chainId: z
-      .number()
-      .int()
-      .refine(isMvmChainId)
-      .transform((chainId) => chainId as MvmChainId),
-    address: z
-      .string()
-      .refine(isMvmAddress)
-      .transform((address) => address as MvmAddress),
-    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: isMvmChainId,
+    isAddress: isMvmAddress,
+    metadata,
   })
 
 export type SerializedMvmToken<

package/mvm/validate/zod.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+import { mvmAddress } from './zod.js'
+
+describe('mvmAddress', () => {
+  it('accepts Move coin-type addresses', () => {
+    expect(mvmAddress().parse('0x1::aptos_coin::AptosCoin')).toBe(
+      '0x1::aptos_coin::AptosCoin',
+    )
+  })
+
+  it.each([
+    '',
+    '0x1',
+    '0x1::coin',
+    '0x1::coin::',
+    ' 0x1::coin::Coin',
+  ])('rejects %j', (address) =>
+    expect(() => mvmAddress().parse(address)).toThrow())
+})