sushi 6.6.6 → 6.6.8

package/generic/types/for-chain.test-d.ts

@@ -1,12 +1,111 @@
 import { describe, expectTypeOf, it } from 'vitest'
+import type { EvmChainId } from '../../evm/chain/chains.js'
+import type { EvmCurrency } from '../../evm/currency/currency.js'
+import type { EvmNative } from '../../evm/currency/native.js'
+import type { EvmToken } from '../../evm/currency/token.js'
+import type { MvmChainId } from '../../mvm/chain/chains.js'
+import type { MvmToken } from '../../mvm/currency/token.js'
 import type { StellarAddress } from '../../stellar/address.js'
 import type { StellarChainId } from '../../stellar/chain/chains.js'
+import type { StellarCurrency } from '../../stellar/currency/currency.js'
+import type { StellarToken } from '../../stellar/currency/token.js'
 import type { StellarID } from '../../stellar/types/id.js'
+import type { SvmCurrency } from '../../svm/currency/currency.js'
+import type { SvmNative } from '../../svm/currency/native.js'
+import type { SvmToken } from '../../svm/currency/token.js'
 import type { SvmChainId } from '../../svm/index.js'
 import type { SvmID } from '../../svm/types/id.js'
-import type { IDFor } from './for-chain.js'
+import type {
+  CurrencyFor,
+  IDFor,
+  NativeChainId,
+  NativeFor,
+  TokenFor,
+} from './for-chain.js'
 
 describe('generic/types/for-chain.ts types', () => {
+  type Metadata = {
+    coingeckoId: string
+    verified: boolean
+  }
+
+  describe('TokenFor', () => {
+    it('should return the correct token type for each chain family', () => {
+      expectTypeOf<TokenFor<EvmChainId, Metadata>>().toEqualTypeOf<
+        EvmToken<Metadata>
+      >()
+      expectTypeOf<TokenFor<MvmChainId, Metadata>>().toEqualTypeOf<
+        MvmToken<Metadata>
+      >()
+      expectTypeOf<TokenFor<SvmChainId, Metadata>>().toEqualTypeOf<
+        SvmToken<Metadata>
+      >()
+      expectTypeOf<TokenFor<StellarChainId, Metadata>>().toEqualTypeOf<
+        StellarToken<Metadata>
+      >()
+    })
+
+    it('should distribute over chain id unions', () => {
+      expectTypeOf<TokenFor<EvmChainId | SvmChainId, Metadata>>().toEqualTypeOf<
+        EvmToken<Metadata> | SvmToken<Metadata>
+      >()
+    })
+  })
+
+  describe('CurrencyFor', () => {
+    it('should return the correct currency type for each chain family', () => {
+      expectTypeOf<CurrencyFor<EvmChainId, Metadata>>().toEqualTypeOf<
+        EvmCurrency<Metadata>
+      >()
+      expectTypeOf<CurrencyFor<MvmChainId, Metadata>>().toEqualTypeOf<
+        MvmToken<Metadata>
+      >()
+      expectTypeOf<CurrencyFor<SvmChainId, Metadata>>().toEqualTypeOf<
+        SvmCurrency<Metadata>
+      >()
+      expectTypeOf<CurrencyFor<StellarChainId, Metadata>>().toEqualTypeOf<
+        StellarCurrency<Metadata>
+      >()
+    })
+
+    it('should distribute over chain id unions', () => {
+      expectTypeOf<
+        CurrencyFor<EvmChainId | SvmChainId, Metadata>
+      >().toEqualTypeOf<EvmCurrency<Metadata> | SvmCurrency<Metadata>>()
+    })
+  })
+
+  describe('NativeFor', () => {
+    it('should only support chain families with native currency classes', () => {
+      expectTypeOf<NativeChainId>().toEqualTypeOf<EvmChainId | SvmChainId>()
+      expectTypeOf<NativeFor<EvmChainId, Metadata>>().toEqualTypeOf<
+        EvmNative<Metadata>
+      >()
+      expectTypeOf<NativeFor<SvmChainId, Metadata>>().toEqualTypeOf<
+        SvmNative<Metadata>
+      >()
+      expectTypeOf<NativeFor<NativeChainId, Metadata>>().toEqualTypeOf<
+        EvmNative<Metadata> | SvmNative<Metadata>
+      >()
+    })
+
+    it('should reject token-only chain families', () => {
+      type NativeForMvm = NativeFor<
+        // @ts-expect-error MVM is intentionally excluded from NativeChainId.
+        MvmChainId,
+        Metadata
+      >
+      type NativeForStellar = NativeFor<
+        // @ts-expect-error Stellar is intentionally excluded from NativeChainId.
+        StellarChainId,
+        Metadata
+      >
+
+      expectTypeOf<NativeForMvm>().toEqualTypeOf<never>()
+      expectTypeOf<NativeForStellar>().toEqualTypeOf<never>()
+    })
+  })
+
   describe('IDFor', () => {
     it('should return the correct id type for SVM chains', () => {
       expectTypeOf<IDFor<SvmChainId>>().toEqualTypeOf<SvmID>()

package/generic/types/for-chain.ts

@@ -1,5 +1,6 @@
 import type { EvmChainId } from '../../evm/chain/chains.js'
 import type { EvmCurrency } from '../../evm/currency/currency.js'
+import type { EvmNative } from '../../evm/currency/native.js'
 import type {
   EvmAddress,
   EvmToken,
@@ -19,6 +20,7 @@ import type { StellarToken } from '../../stellar/currency/token.js'
 import type { StellarID } from '../../stellar/types/id.js'
 import type { SvmChainId } from '../../svm/chain/chains.js'
 import type { SvmCurrency } from '../../svm/currency/currency.js'
+import type { SvmNative } from '../../svm/currency/native.js'
 import type {
   SvmAddress,
   SvmToken,
@@ -54,6 +56,17 @@ export type CurrencyFor<
         ? StellarCurrency<Metadata>
         : never
 
+export type NativeChainId = EvmChainId | SvmChainId
+
+export type NativeFor<
+  TChainId extends NativeChainId,
+  Metadata extends CurrencyMetadata = CurrencyMetadata,
+> = TChainId extends EvmChainId
+  ? EvmNative<Metadata>
+  : TChainId extends SvmChainId
+    ? SvmNative<Metadata>
+    : never
+
 export type AddressFor<TChainId extends ChainId> = TChainId extends EvmChainId
   ? EvmAddress
   : TChainId extends MvmChainId

package/generic/utils/normalize-address.test-d.ts

@@ -0,0 +1,110 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { EvmChainId } from '../../evm/chain/chains.js'
+import type { EvmAddress } from '../../evm/currency/token.js'
+import type { MvmAddress } from '../../mvm/currency/token.js'
+import type {
+  StellarAccountAddress,
+  StellarContractAddress,
+} from '../../stellar/address.js'
+import { StellarChainId } from '../../stellar/chain/chains.js'
+import { SvmChainId } from '../../svm/chain/chains.js'
+import type { SvmAddress } from '../../svm/currency/token.js'
+import { normalizeAddress } from './normalize-address.js'
+
+describe('normalizeAddress types', () => {
+  it('preserves EVM address types', () => {
+    const address = '0x0000000000000000000000000000000000000000' as EvmAddress
+
+    expectTypeOf(
+      normalizeAddress(EvmChainId.ETHEREUM, address),
+    ).toEqualTypeOf<EvmAddress>()
+  })
+
+  it('preserves SVM address types', () => {
+    const address = 'So11111111111111111111111111111111111111112' as SvmAddress
+
+    expectTypeOf(
+      normalizeAddress(SvmChainId.SOLANA, address),
+    ).toEqualTypeOf<SvmAddress>()
+  })
+
+  it('preserves Stellar account and contract address types', () => {
+    const accountAddress =
+      'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7' as StellarAccountAddress
+    const contractAddress =
+      'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF' as StellarContractAddress
+
+    expectTypeOf(
+      normalizeAddress(StellarChainId.STELLAR, accountAddress),
+    ).toEqualTypeOf<StellarAccountAddress>()
+    expectTypeOf(
+      normalizeAddress(StellarChainId.STELLAR, contractAddress),
+    ).toEqualTypeOf<StellarContractAddress>()
+  })
+
+  it('preserves same-chain address unions', () => {
+    function normalizeStellarUnion(
+      address: StellarAccountAddress | StellarContractAddress,
+    ) {
+      expectTypeOf(
+        normalizeAddress(StellarChainId.STELLAR, address),
+      ).toEqualTypeOf<StellarAccountAddress | StellarContractAddress>()
+    }
+
+    expectTypeOf(normalizeStellarUnion).returns.toEqualTypeOf<void>()
+  })
+
+  it('preserves cross-chain address unions', () => {
+    function normalizeEvmOrSvmUnion(
+      chainId: typeof EvmChainId.ETHEREUM | typeof SvmChainId.SOLANA,
+      address: EvmAddress | SvmAddress,
+    ) {
+      expectTypeOf(normalizeAddress(chainId, address)).toEqualTypeOf<
+        EvmAddress | SvmAddress
+      >()
+    }
+
+    expectTypeOf(normalizeEvmOrSvmUnion).returns.toEqualTypeOf<void>()
+  })
+
+  it('preserves address types without chain ids', () => {
+    const evmAddress =
+      '0x0000000000000000000000000000000000000000' as EvmAddress
+    const mvmAddress = '0x1::coin::T' as MvmAddress
+    const svmAddress =
+      'So11111111111111111111111111111111111111112' as SvmAddress
+    const stellarAccountAddress =
+      'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7' as StellarAccountAddress
+    const stellarContractAddress =
+      'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF' as StellarContractAddress
+
+    expectTypeOf(normalizeAddress(evmAddress)).toEqualTypeOf<EvmAddress>()
+    expectTypeOf(normalizeAddress(mvmAddress)).toEqualTypeOf<MvmAddress>()
+    expectTypeOf(normalizeAddress(svmAddress)).toEqualTypeOf<SvmAddress>()
+    expectTypeOf(
+      normalizeAddress(stellarAccountAddress),
+    ).toEqualTypeOf<StellarAccountAddress>()
+    expectTypeOf(
+      normalizeAddress(stellarContractAddress),
+    ).toEqualTypeOf<StellarContractAddress>()
+  })
+
+  it('preserves address unions without chain ids', () => {
+    function normalizeStellarUnion(
+      address: StellarAccountAddress | StellarContractAddress,
+    ) {
+      expectTypeOf(normalizeAddress(address)).toEqualTypeOf<
+        StellarAccountAddress | StellarContractAddress
+      >()
+    }
+
+    function normalizeEvmOrSvmUnion(address: EvmAddress | SvmAddress) {
+      expectTypeOf(normalizeAddress(address)).toEqualTypeOf<
+        EvmAddress | SvmAddress
+      >()
+    }
+
+    expectTypeOf(normalizeStellarUnion).returns.toEqualTypeOf<void>()
+    expectTypeOf(normalizeEvmOrSvmUnion).returns.toEqualTypeOf<void>()
+  })
+})

package/generic/utils/normalize-address.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import type { EvmAddress } from '../../evm/currency/token.js'
+import type { MvmAddress } from '../../mvm/currency/token.js'
+import type { StellarContractAddress } from '../../stellar/address.js'
+import type { SvmAddress } from '../../svm/currency/token.js'
+import { normalizeAddress } from './normalize-address.js'
+
+describe('normalizeAddress', () => {
+  it('normalizes addresses without chain ids by address format', () => {
+    expect(
+      normalizeAddress(
+        '0x000000000000000000000000000000000000dEaD' as EvmAddress,
+      ),
+    ).toBe('0x000000000000000000000000000000000000dead')
+
+    const mvmAddress = '0xABC::Coin::T' as MvmAddress
+    expect(normalizeAddress(mvmAddress)).toBe(mvmAddress)
+
+    const svmAddress =
+      'So11111111111111111111111111111111111111112' as SvmAddress
+    expect(normalizeAddress(svmAddress)).toBe(svmAddress)
+
+    expect(
+      normalizeAddress(
+        'ccrsmjdith3vk5qogycvzdakiy5gl3rcg4tcvliavb662iw2v5kjgzgf' as StellarContractAddress,
+      ),
+    ).toBe('CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF')
+  })
+})

package/generic/utils/normalize-address.ts

@@ -1,46 +1,88 @@
 import type { EvmChainId } from '../../evm/chain/chains.js'
 import { isEvmChainId } from '../../evm/chain/chains.js'
+import { type EvmAddress, isEvmAddress } from '../../evm/currency/token.js'
 import { normalizeEvmAddress } from '../../evm/utils/normalize-address.js'
 import type { MvmChainId } from '../../mvm/chain/chains.js'
 import { isMvmChainId } from '../../mvm/chain/chains.js'
+import { isMvmAddress } from '../../mvm/currency/token.js'
 import { normalizeMvmAddress } from '../../mvm/utils/normalize-address.js'
+import { isStellarAddress, type StellarAddress } from '../../stellar/address.js'
 import type { StellarChainId } from '../../stellar/chain/chains.js'
 import { isStellarChainId } from '../../stellar/chain/chains.js'
 import { normalizeStellarAddress } from '../../stellar/utils/normalize-address.js'
 import type { SvmChainId } from '../../svm/chain/chains.js'
 import { isSvmChainId } from '../../svm/chain/chains.js'
+import { isSvmAddress, type SvmAddress } from '../../svm/currency/token.js'
 import { normalizeSvmAddress } from '../../svm/utils/normalize-address.js'
 import type { ChainId } from '../chain/chains.js'
 import type { AddressFor } from '../types/for-chain.js'
 import { assertNever } from './assert-never.js'
 
-export function normalizeAddress<TChainId extends ChainId>(
-  chainId: TChainId,
-  address: AddressFor<TChainId>,
-): AddressFor<TChainId> {
+export function normalizeAddress<TAddress extends AddressFor<ChainId>>(
+  address: TAddress,
+): TAddress
+export function normalizeAddress<
+  TChainId extends ChainId,
+  TAddress extends AddressFor<TChainId>,
+>(chainId: TChainId, address: TAddress): TAddress
+export function normalizeAddress(
+  chainIdOrAddress: ChainId | AddressFor<ChainId>,
+  address?: AddressFor<ChainId>,
+): AddressFor<ChainId> {
+  if (address === undefined) {
+    if (typeof chainIdOrAddress !== 'string') {
+      throw new Error(
+        `normalizeAddress, unsupported address: ${chainIdOrAddress}`,
+      )
+    }
+
+    return normalizeAddressByFormat(chainIdOrAddress)
+  }
+
+  return normalizeAddressByChainId(chainIdOrAddress as ChainId, address)
+}
+
+function normalizeAddressByChainId(
+  chainId: ChainId,
+  address: AddressFor<ChainId>,
+) {
   if (isEvmChainId(chainId)) {
-    return normalizeEvmAddress(
-      address as AddressFor<EvmChainId>,
-    ) as AddressFor<TChainId>
+    return normalizeEvmAddress(address as AddressFor<EvmChainId>)
   }
 
   if (isMvmChainId(chainId)) {
-    return normalizeMvmAddress(
-      address as AddressFor<MvmChainId>,
-    ) as AddressFor<TChainId>
+    return normalizeMvmAddress(address as AddressFor<MvmChainId>)
   }
 
   if (isSvmChainId(chainId)) {
-    return normalizeSvmAddress(
-      address as AddressFor<SvmChainId>,
-    ) as AddressFor<TChainId>
+    return normalizeSvmAddress(address as AddressFor<SvmChainId>)
   }
 
   if (isStellarChainId(chainId)) {
-    return normalizeStellarAddress(
-      address as AddressFor<StellarChainId>,
-    ) as AddressFor<TChainId>
+    return normalizeStellarAddress(address as AddressFor<StellarChainId>)
   }
 
   assertNever(chainId, `normalizeAddress, unsupported chainId: ${chainId}`)
 }
+
+function normalizeAddressByFormat(
+  address: AddressFor<ChainId>,
+): AddressFor<ChainId> {
+  if (isMvmAddress(address)) {
+    return normalizeMvmAddress(address)
+  }
+
+  if (isEvmAddress(address)) {
+    return normalizeEvmAddress(address as EvmAddress)
+  }
+
+  if (isSvmAddress(address)) {
+    return normalizeSvmAddress(address as SvmAddress)
+  }
+
+  if (isStellarAddress(address.toUpperCase())) {
+    return normalizeStellarAddress(address as StellarAddress)
+  }
+
+  throw new Error(`normalizeAddress, unsupported address: ${address}`)
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sushi",
   "description": "Sushi",
-  "version": "6.6.6",
+  "version": "6.6.8",
   "type": "module",
   "main": "./_cjs/generic/index.js",
   "module": "./_esm/generic/index.js",

package/svm/currency/currency.ts

@@ -6,7 +6,7 @@ import { type SvmToken, serializedSvmTokenSchema } from './token.js'
 
 export type SvmCurrency<
   TMetadata extends CurrencyMetadata = Record<string, unknown>,
-> = SvmToken<TMetadata> | SvmNative
+> = SvmToken<TMetadata> | SvmNative<TMetadata>
 
 export const serializedSvmCurrencySchema = <
   TMetadata extends {} = CurrencyMetadata,