sushi 6.7.1 → 7.0.1

package/generic/chain/interface.ts

@@ -23,10 +23,11 @@ export type BlockExplorers = {
   }
 }
 
-export type Chain<
+/** @internal Used while constructing the registry that defines ChainId/ChainKey. */
+export type ChainDefinition<
   TType extends ChainType = ChainType,
-  TChainId extends ChainId = ChainId,
-  TKey extends ChainKey = ChainKey,
+  TChainId extends number = number,
+  TKey extends string = string,
   TName extends string = string,
   TShortName extends string = string,
   TNetType extends Readonly<NetType> = Readonly<NetType>,
@@ -42,7 +43,29 @@ export type Chain<
   netType: TNetType
   blockExplorers: TBlockExplorerKeys
 
-  getTransactionUrl: (input: TAddress) => string
-  getAccountUrl: (input: TTransactionHash) => string
+  getTransactionUrl: (input: TTransactionHash) => string
+  getAccountUrl: (input: TAddress) => string
   getTokenUrl: (input: TAddress) => string
 }>
+
+export type Chain<
+  TType extends ChainType = ChainType,
+  TChainId extends ChainId = ChainId,
+  TKey extends ChainKey = ChainKey,
+  TName extends string = string,
+  TShortName extends string = string,
+  TNetType extends Readonly<NetType> = Readonly<NetType>,
+  TBlockExplorerKeys extends BlockExplorers = BlockExplorers,
+  TAddress extends string = string,
+  TTransactionHash extends string = string,
+> = ChainDefinition<
+  TType,
+  TChainId,
+  TKey,
+  TName,
+  TShortName,
+  TNetType,
+  TBlockExplorerKeys,
+  TAddress,
+  TTransactionHash
+>

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

@@ -1,10 +1,8 @@
 import { it } from 'node:test'
 import { describe, expect, expectTypeOf } from 'vitest'
 import * as z from 'zod'
-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 { svmAddress } from '~/svm/currency/token.js'
+import type { EvmChainId } from '../../evm/chain/chains.js'
+import type { EvmCurrency } from '../../evm/currency/currency.js'
 import { EvmNative } from '../../evm/currency/native.js'
 import {
   type EvmAddress,
@@ -12,7 +10,9 @@ import {
   type SerializedEvmToken,
   serializedEvmTokenSchema,
 } from '../../evm/currency/token.js'
+import type { EvmID } from '../../evm/types/id.js'
 import { MvmToken } from '../../mvm/currency/token.js'
+import { svmAddress } from '../../svm/currency/token.js'
 import {
   type SvmAddress,
   type SvmChainId,

package/generic/currency/deserialize-currency.ts

@@ -0,0 +1,11 @@
+export function createCurrencyDeserializer<
+  const TConstructors extends Record<string, new (data: any) => any>,
+>(constructors: TConstructors) {
+  return <TType extends keyof TConstructors & string>(data: {
+    type: TType
+  }): InstanceType<TConstructors[TType]> => {
+    const Constructor = constructors[data.type]
+    if (!Constructor) throw new Error(`Unsupported currency type: ${data.type}`)
+    return new Constructor(data)
+  }
+}

package/generic/currency/index.ts

@@ -1,8 +1,10 @@
 export * from './amount.js'
 export * from './currency.js'
+export * from './deserialize-currency.js'
 export * from './for-chain.js'
 export * from './native.js'
 export * from './price.js'
 export * from './serialized-currency.js'
+export * from './serialized-token.js'
 export * from './token.js'
 export * from './unwrap-token.js'

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/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())
+})

package/mvm/validate/zod.ts

@@ -1,12 +1,9 @@
-import * as z from 'zod'
-import { isMvmAddress, type MvmAddress } from '../currency/token.js'
+import { createAddressSchema } from '../../generic/validate/create-address-schema.js'
+import { isMvmAddress } from '../currency/token.js'
 import { normalizeMvmAddress } from '../utils/normalize-address.js'
 
 export const mvmAddress = () =>
-  z
-    .string()
-    .refine(isMvmAddress, { message: 'Invalid address' })
-    .transform((value) => normalizeMvmAddress(value as MvmAddress))
+  createAddressSchema(isMvmAddress, normalizeMvmAddress)
 
 export const szmvm = {
   address: mvmAddress,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sushi",
   "description": "Sushi",
-  "version": "6.7.1",
+  "version": "7.0.1",
   "main": "./_cjs/generic/index.js",
   "module": "./_esm/generic/index.js",
   "types": "./_types/generic/index.d.ts",
@@ -15,6 +15,7 @@
     "mvm",
     "stellar",
     "svm",
+    "LICENSE",
     "package.json"
   ],
   "exports": {
@@ -67,20 +68,19 @@
     }
   },
   "dependencies": {
-    "@solana/addresses": "6.9.0",
-    "@uniswap/token-lists": "1.0.0-beta.33",
+    "@solana/addresses": "7.0.0",
     "tiny-invariant": "1.3.3"
   },
+  "devDependencies": {
+    "viem": "2.55.0",
+    "zod": "4.4.3"
+  },
   "peerDependencies": {
-    "@solana/addresses": ">=5",
-    "typescript": ">= 5.8.3 < 7",
+    "typescript": ">= 5.8.3 < 8",
     "viem": "*",
     "zod": ">=4"
   },
   "peerDependenciesMeta": {
-    "@solana/addresses": {
-      "optional": true
-    },
     "typescript": {
       "optional": true
     },

package/stellar/chain/chains.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import type {
+  StellarAccountAddress,
+  StellarContractAddress,
+} from '../address.js'
+import {
+  getStellarChainById,
+  isStellarChainId,
+  StellarChainId,
+} from './chains.js'
+
+describe('Stellar chains', () => {
+  const account =
+    'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7' as StellarAccountAddress
+  const contract =
+    'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF' as StellarContractAddress
+
+  it('builds transaction, account, contract, and asset URLs', () => {
+    const chain = getStellarChainById(StellarChainId.STELLAR)
+    const base = 'https://stellar.expert/explorer/public'
+
+    expect(chain.getTransactionUrl('hash')).toBe(`${base}/tx/hash`)
+    expect(chain.getAccountUrl(account)).toBe(`${base}/account/${account}`)
+    expect(chain.getAccountUrl(contract)).toBe(`${base}/contract/${contract}`)
+    expect(chain.getTokenUrl(contract)).toBe(`${base}/asset/${contract}`)
+    expect(isStellarChainId(StellarChainId.STELLAR)).toBe(true)
+    expect(isStellarChainId(1)).toBe(false)
+  })
+})

package/stellar/chain/define-chain.ts

@@ -1,6 +1,7 @@
+import { defineChain } from '../../generic/chain/define-chain.js'
 import type {
   BlockExplorers,
-  Chain,
+  ChainDefinition,
   NetType,
 } from '../../generic/chain/interface.js'
 import { isStellarContractAddress } from '../address.js'
@@ -11,9 +12,8 @@ export type StellarChainType = 'stellar'
 type StellarChainBase<
   TChainId extends number,
   TChainKey extends string,
-> = Chain<
+> = ChainDefinition<
   StellarChainType,
-  // @ts-expect-error prevent infinite loop
   TChainId,
   TChainKey,
   Readonly<string>,
@@ -34,19 +34,14 @@ type StellarChainInput = Omit<
 export function defineStellarChain<const T extends StellarChainInput>(
   chain: T,
 ) {
-  return {
-    ...chain,
-    type: 'stellar' as const,
-
-    getTransactionUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/tx/${input}`,
-    getAccountUrl: (input: string) => {
+  return defineChain('stellar', chain, {
+    transaction: (url, input) => `${url}/tx/${input}`,
+    account: (url, input) => {
       if (isStellarContractAddress(input)) {
-        return `${chain.blockExplorers.default.url}/contract/${input}`
+        return `${url}/contract/${input}`
       }
-      return `${chain.blockExplorers.default.url}/account/${input}`
+      return `${url}/account/${input}`
     },
-    getTokenUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/asset/${input}`,
-  } as const satisfies StellarChainBase<number, string>
+    token: (url, input) => `${url}/asset/${input}`,
+  })
 }

package/stellar/currency/deserialize-currency.ts

@@ -1,7 +1,10 @@
+import { createCurrencyDeserializer } from '../../generic/currency/deserialize-currency.js'
 import { type SerializedStellarToken, StellarToken } from './token.js'
 
 function deserializeStellarCurrency(data: SerializedStellarToken) {
-  return new StellarToken(data)
+  return deserialize(data)
 }
 
+const deserialize = createCurrencyDeserializer({ token: StellarToken })
+
 export { deserializeStellarCurrency }

package/stellar/currency/token.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import type {
+  StellarAccountAddress,
+  StellarContractAddress,
+} from '../address.js'
+import { StellarChainId } from '../chain/chains.js'
+import { deserializeStellarCurrency } from './deserialize-currency.js'
+import { StellarToken, serializedStellarTokenSchema } from './token.js'
+
+const accountAddress =
+  'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7' as StellarAccountAddress
+const contractAddress =
+  'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF' as StellarContractAddress
+
+describe('StellarToken', () => {
+  const token = new StellarToken({
+    chainId: StellarChainId.STELLAR,
+    address: contractAddress.toLowerCase() as StellarContractAddress,
+    issuer: accountAddress.toLowerCase() as StellarAccountAddress,
+    symbol: 'TOKEN',
+    name: 'Stellar Token',
+    decimals: 7,
+    origin: 'stellar',
+    metadata: { verified: true },
+  })
+
+  it('normalizes contract and issuer addresses and wraps to itself', () => {
+    expect(token.address).toBe(contractAddress)
+    expect(token.issuer).toBe(accountAddress)
+    expect(token.wrap()).toBe(token)
+  })
+
+  it('round-trips issuer and metadata through serialization', () => {
+    const serialized = serializedStellarTokenSchema().parse(token.toJSON())
+    const restored = deserializeStellarCurrency(serialized)
+
+    expect(restored).toBeInstanceOf(StellarToken)
+    expect(restored.toJSON()).toEqual(serialized)
+  })
+
+  it('rejects the wrong address kind and invalid decimals', () => {
+    const serialized = token.toJSON()
+    expect(() =>
+      serializedStellarTokenSchema().parse({
+        ...serialized,
+        address: accountAddress,
+      }),
+    ).toThrow()
+    expect(() =>
+      serializedStellarTokenSchema().parse({ ...serialized, decimals: -1 }),
+    ).toThrow()
+  })
+})

package/stellar/currency/token.ts

@@ -1,5 +1,6 @@
 import * 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 {
   isStellarAccountAddress,
@@ -66,31 +67,17 @@ export const serializedStellarTokenSchema = <
 }: {
   metadata?: z.ZodType<TMetadata>
 } = {}) =>
-  z.object({
-    chainId: z
-      .number()
-      .int()
-      .refine(isStellarChainId)
-      .transform((chainId) => chainId as StellarChainId),
-    address: z
-      .string()
-      .refine(isStellarContractAddress)
-      .transform((address) => address as StellarContractAddress),
-    issuer: z
-      .string()
-      .refine(isStellarAccountAddress)
-      .transform((address) => address as StellarAccountAddress)
-      .optional(),
-    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: isStellarChainId,
+    isAddress: isStellarContractAddress,
+    metadata,
+    extra: {
+      issuer: z
+        .string()
+        .refine(isStellarAccountAddress)
+        .transform((value) => value as StellarAccountAddress)
+        .optional(),
+    },
   })
 
 export type SerializedStellarToken<

package/stellar/validate/zod.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import {
+  stellarAccountAddress,
+  stellarAddress,
+  stellarContractAddress,
+} from './zod.js'
+
+const accountAddress =
+  'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7'
+const contractAddress =
+  'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF'
+
+describe('Stellar address schemas', () => {
+  it('normalizes before validating', () => {
+    expect(stellarAccountAddress().parse(accountAddress.toLowerCase())).toBe(
+      accountAddress,
+    )
+    expect(stellarContractAddress().parse(contractAddress.toLowerCase())).toBe(
+      contractAddress,
+    )
+  })
+
+  it('distinguishes account and contract addresses', () => {
+    expect(() => stellarAccountAddress().parse(contractAddress)).toThrow()
+    expect(() => stellarContractAddress().parse(accountAddress)).toThrow()
+    expect(stellarAddress().parse(accountAddress)).toBe(accountAddress)
+    expect(stellarAddress().parse(contractAddress)).toBe(contractAddress)
+  })
+
+  it.each([
+    '',
+    '0x1234',
+    `M${'A'.repeat(55)}`,
+    `G${'0'.repeat(55)}`,
+  ])('rejects %j', (value) =>
+    expect(() => stellarAddress().parse(value)).toThrow())
+})