sushi 6.6.10 → 6.7.0

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.12";
+export declare const version = "6.7.0";
 //# sourceMappingURL=version.d.ts.map

package/_types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,WAAW,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAA"}

package/evm/abi/selfPermitAbi/index.ts

@@ -1,4 +1,2 @@
 export * from './selfPermitAbi_selfPermit.js'
 export * from './selfPermitAbi_selfPermitAllowed.js'
-export * from './selfPermitAbi_selfPermitAllowedIfNecessary.js'
-export * from './selfPermitAbi_selfPermitIfNecessary.js'

package/evm/pool/sushiswap-v3/entities/TickDataProvider.test.ts

@@ -4,13 +4,13 @@ import { NoTickDataProvider } from './TickDataProvider.js'
 describe('TickDataProvider', () => {
   describe('NoTickDataProvider', () => {
     const provider = new NoTickDataProvider()
-    it('throws on getTick', () => {
-      expect(provider.getTick(0)).rejects.toThrow(
+    it('throws on getTick', async () => {
+      await expect(provider.getTick(0)).rejects.toThrow(
         'No tick data provider was given',
       )
     })
-    it('throws on nextInitializedTickWithinOneWord', () => {
-      expect(
+    it('throws on nextInitializedTickWithinOneWord', async () => {
+      await expect(
         provider.nextInitializedTickWithinOneWord(0, false, 1),
       ).rejects.toThrow('No tick data provider was given')
     })

package/evm/validate/zod.ts

@@ -1,13 +1,14 @@
-import { type Address, isAddress } from 'viem'
 import * as z from 'zod'
+import { type EvmAddress, isEvmAddress } from '../currency/token.js'
+import { normalizeEvmAddress } from '../utils/normalize-address.js'
 
 export const evmAddress = () =>
   z
     .string()
-    .refine((value) => isAddress(value, { strict: false }), {
+    .refine((value) => isEvmAddress(value), {
       message: 'Invalid address',
     })
-    .transform((value) => value as Address)
+    .transform((value) => normalizeEvmAddress(value as EvmAddress))
 
 export const szevm = {
   address: evmAddress,

package/generic/format/number.test.ts

@@ -127,7 +127,7 @@ describe('numberToFixed', () => {
   })
 
   describe('edge cases', () => {
-    it('should handle empty and z8ero values', () => {
+    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')
@@ -143,4 +143,104 @@ describe('numberToFixed', () => {
       expect(numberToFixed('1.23e+2', { maxFixed: 2 })).toBe('123')
     })
   })
+
+  describe('string rounding edge cases', () => {
+    it('should round fixed-decimal string inputs that overflow into a new integer digit', () => {
+      expect(numberToFixed('9.995', { fixed: 2 })).toBe('10')
+      expect(numberToFixed('-9.995', { fixed: 2 })).toBe('-10')
+    })
+
+    it('should round long leading-zero decimals when using significant digits', () => {
+      expect(numberToFixed('0.00009999', { significant: 2 })).toBe('0.0001')
+      expect(numberToFixed('-0.00009999', { significant: 2 })).toBe('-0.0001')
+    })
+
+    it('should round large negative strings when all significant digits are 9s', () => {
+      expect(numberToFixed('-9999.9', { significant: 1 })).toBe('-10000')
+    })
+  })
+
+  describe('fixed rounding cascades', () => {
+    it('should cascade rounding across multiple integer digits for strings', () => {
+      expect(numberToFixed('199.995', { fixed: 2 })).toBe('200')
+      expect(numberToFixed('-199.995', { fixed: 2 })).toBe('-200')
+    })
+
+    it('should keep trailing zeros for numeric inputs when the same rounding occurs', () => {
+      expect(numberToFixed(199.995, { fixed: 2 })).toBe('200.00')
+      expect(numberToFixed(-199.995, { fixed: 2 })).toBe('-200.00')
+    })
+
+    it('should handle +/-0.005 thresholds symmetrically', () => {
+      expect(numberToFixed('0.005', { fixed: 2 })).toBe('0.01')
+      expect(numberToFixed('-0.005', { fixed: 2 })).toBe('-0.01')
+      expect(numberToFixed(0.005, { fixed: 2 })).toBe('0.01')
+      expect(numberToFixed(-0.005, { fixed: 2 })).toBe('-0.01')
+    })
+
+    it('should preserve decimal accuracy for strings at IEEE rounding pain points', () => {
+      expect(numberToFixed('2.675', { fixed: 2 })).toBe('2.68')
+      expect(numberToFixed(2.675, { fixed: 2 })).toBe('2.67')
+    })
+  })
+
+  describe('maxFixed nuances', () => {
+    it('should truncate (not round) string inputs for maxFixed', () => {
+      expect(numberToFixed('2.999', { maxFixed: 2 })).toBe('2.99')
+      expect(numberToFixed('-2.999', { maxFixed: 2 })).toBe('-2.99')
+    })
+
+    it('should round numeric inputs for maxFixed after trimming trailing zeros', () => {
+      expect(numberToFixed(2.999, { maxFixed: 2 })).toBe('3')
+      expect(numberToFixed(-2.999, { maxFixed: 2 })).toBe('-3')
+    })
+
+    it('should drop redundant zeros for very small fractions supplied as strings', () => {
+      expect(numberToFixed('0.0001000', { maxFixed: 6 })).toBe('0.0001')
+      expect(numberToFixed('-0.0001000', { maxFixed: 6 })).toBe('-0.0001')
+    })
+
+    it('should distinguish between truncation and rounding when maxFixed is zero', () => {
+      expect(numberToFixed('12.9', { maxFixed: 0 })).toBe('12')
+      expect(numberToFixed('-12.9', { maxFixed: 0 })).toBe('-12')
+      expect(numberToFixed(12.9, { maxFixed: 0 })).toBe('13')
+      expect(numberToFixed(-12.9, { maxFixed: 0 })).toBe('-13')
+    })
+
+    it('should trim or round repeating decimals based on input type', () => {
+      expect(numberToFixed('0.10999', { maxFixed: 3 })).toBe('0.109')
+      expect(numberToFixed('-0.10999', { maxFixed: 3 })).toBe('-0.109')
+      expect(numberToFixed(0.10999, { maxFixed: 3 })).toBe('0.11')
+      expect(numberToFixed(-0.10999, { maxFixed: 3 })).toBe('-0.11')
+    })
+  })
+
+  describe('significant digits with decimals', () => {
+    it('should keep track of leading zeros for negative decimals', () => {
+      expect(numberToFixed('-0.00056789', { significant: 2 })).toBe('-0.0006')
+    })
+
+    it('should round decimals just below one down to -1 with a single significant digit', () => {
+      expect(numberToFixed('-0.9994', { significant: 1 })).toBe('-1')
+    })
+  })
+
+  describe('input validation', () => {
+    it('should accept trailing decimal strings', () => {
+      expect(numberToFixed('1.', { fixed: 2 })).toBe('1.00')
+      expect(numberToFixed('1.', { significant: 2 })).toBe('1')
+    })
+
+    it('should reject invalid numeric strings', () => {
+      expect(() => numberToFixed('invalid', { fixed: 2 })).toThrow(
+        'Invalid number string',
+      )
+    })
+
+    it('should reject empty option objects', () => {
+      expect(() => numberToFixed(1, {} as any)).toThrow(
+        'Invalid arguments for numberToFixed',
+      )
+    })
+  })
 })

package/generic/format/number.ts

@@ -175,7 +175,9 @@ function stringToFixed(
       significantDecimal = significantDecimal.slice(0, -1)
     }
 
-    const res = `${integerPart}${significantDecimal ? `.${significantDecimal}` : ''}`
+    const res = `${integerPart}${
+      significantDecimal ? `.${significantDecimal}` : ''
+    }`
     return roundString(str, res)
   }
 
@@ -192,6 +194,10 @@ function stringToFixed(
 }
 
 function roundString(original: string, formatted: string) {
+  if (!original.match(/^-?(?:\d+\.?|\d*\.\d+)$/)) {
+    throw new Error('Invalid number string')
+  }
+
   const decimalIndex = original.indexOf('.')
 
   const nextDigitIndex = formatted.length
@@ -216,15 +222,16 @@ function roundString(original: string, formatted: string) {
       // handle full carry (e.g., "9.9" -> "10")
       if (formatted.length === 0 || formatted === '-') {
         const negative = original.startsWith('-')
-        const zeros = Math.max(decimalIndex, 0)
+        const digitsLeftOfDecimal = decimalIndex - (negative ? 1 : 0)
+        const zeros = Math.max(digitsLeftOfDecimal, 0)
         return `${negative ? '-' : ''}1${'0'.repeat(zeros)}`
       }
     }
 
-    return `${formatted.substring(0, formatted.length - 1)}${String.fromCharCode(lastDigit() + 1)}`.padEnd(
-      decimalIndex,
-      '0',
-    )
+    return `${formatted.substring(
+      0,
+      formatted.length - 1,
+    )}${String.fromCharCode(lastDigit() + 1)}`.padEnd(decimalIndex, '0')
   }
 
   return formatted

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

@@ -15,6 +15,7 @@ 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 { ChainId } from '../chain/chains.js'
 import type {
   CurrencyFor,
   IDFor,
@@ -73,6 +74,20 @@ describe('generic/types/for-chain.ts types', () => {
         CurrencyFor<EvmChainId | SvmChainId, Metadata>
       >().toEqualTypeOf<EvmCurrency<Metadata> | SvmCurrency<Metadata>>()
     })
+
+    it('should accept TokenFor for a generic chain id', () => {
+      // Regression guard: holds only because TokenFor's branch order matches
+      // CurrencyFor's, letting TypeScript relate the two conditional types for
+      // an unresolved generic `T`. The constraint `A extends B` fails to
+      // compile if TokenFor<T> is not assignable to CurrencyFor<T>.
+      type AssertAssignable<_A extends B, B> = true
+      type _Guard<T extends ChainId> = AssertAssignable<
+        TokenFor<T, Metadata>,
+        CurrencyFor<T, Metadata>
+      >
+
+      expectTypeOf<_Guard<ChainId>>().toEqualTypeOf<true>()
+    })
   })
 
   describe('NativeFor', () => {

package/generic/types/for-chain.ts

@@ -13,7 +13,11 @@ import type {
   MvmToken,
   MvmTxHash,
 } from '../../mvm/currency/token.js'
-import type { StellarAddress, StellarTxHash } from '../../stellar/address.js'
+import type {
+  StellarAddress,
+  StellarContractAddress,
+  StellarTxHash,
+} 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'
@@ -30,23 +34,24 @@ import type { SvmID } from '../../svm/types/id.js'
 import type { ChainId } from '../chain/chains.js'
 import type { CurrencyMetadata } from '../currency/currency.js'
 
+// Branch order (Evm, Svm, Mvm, Stellar) is kept identical across `TokenFor`,
+// `NativeFor` and `CurrencyFor` so TypeScript can relate the conditional types
+// branch-by-branch and prove `TokenFor<T>`/`NativeFor<T>` are assignable to
+// `CurrencyFor<T>` for a generic `T`. The chain families are disjoint, so the
+// order has no effect on the resolved type — only on relatability.
 export type TokenFor<
   TChainId extends ChainId,
   Metadata extends CurrencyMetadata = CurrencyMetadata,
 > = TChainId extends EvmChainId
   ? EvmToken<Metadata>
-  : TChainId extends MvmChainId
-    ? MvmToken<Metadata>
-    : TChainId extends SvmChainId
-      ? SvmToken<Metadata>
+  : TChainId extends SvmChainId
+    ? SvmToken<Metadata>
+    : TChainId extends MvmChainId
+      ? MvmToken<Metadata>
       : TChainId extends StellarChainId
         ? StellarToken<Metadata>
         : never
 
-// Branch order matches `NativeFor` (Evm, then Svm) so TypeScript can relate the
-// two conditional types and prove `NativeFor<T>` is assignable to
-// `CurrencyFor<T>` for a generic `T`. The chain families are disjoint, so the
-// order has no effect on the resolved type.
 export type CurrencyFor<
   TChainId extends ChainId,
   Metadata extends CurrencyMetadata = CurrencyMetadata,
@@ -81,6 +86,17 @@ export type AddressFor<TChainId extends ChainId> = TChainId extends EvmChainId
         ? StellarAddress
         : never
 
+export type ContractAddressFor<TChainId extends ChainId> =
+  TChainId extends EvmChainId
+    ? EvmAddress
+    : TChainId extends MvmChainId
+      ? MvmAddress
+      : TChainId extends SvmChainId
+        ? SvmAddress
+        : TChainId extends StellarChainId
+          ? StellarContractAddress
+          : never
+
 export type TxHashFor<TChainId extends ChainId> = TChainId extends EvmChainId
   ? EvmTxHash
   : TChainId extends MvmChainId

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

@@ -0,0 +1,35 @@
+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 type { ID } from '../types/id.js'
+import { getChainIdAddressFromId, getIdFromChainIdAddress } from './id.js'
+
+describe('getChainIdAddressFromId', () => {
+  it('preserves EVM chainId and address types', () => {
+    const id = '1:0xaa' as ID<EvmChainId, EvmAddress>
+
+    expectTypeOf(getChainIdAddressFromId(id)).toEqualTypeOf<{
+      chainId: EvmChainId
+      address: EvmAddress
+    }>()
+  })
+
+  it('preserves Solana chainId and address types', () => {
+    const id = getIdFromChainIdAddress(
+      SvmChainId.SOLANA,
+      'So11111111111111111111111111111111111111112' as SvmAddress,
+    )
+
+    expectTypeOf(getChainIdAddressFromId(id)).not.toEqualTypeOf<{
+      chainId: SvmChainId
+      address: `${SvmAddress}`
+    }>()
+
+    expectTypeOf(getChainIdAddressFromId(id)).toEqualTypeOf<{
+      chainId: SvmChainId
+      address: SvmAddress
+    }>()
+  })
+})

package/generic/utils/id.ts

@@ -1,9 +1,15 @@
+import type { SvmAddress } from '../../svm/currency/token.js'
 import type { ChainId } from '../chain/chains.js'
 import type { AddressFor } from '../types/for-chain.js'
 import type { ID } from '../types/id.js'
 import { getNativeAddress } from './native-address.js'
 import { normalizeAddress } from './normalize-address.js'
 
+// Hacky fix, SvmAddress is a branded type, but when used in a template literal type, it loses its branding.
+type ReturnedAddress<TAddress extends string> = TAddress extends `${SvmAddress}`
+  ? SvmAddress
+  : TAddress
+
 export function getChainIdAddressFromId<
   TChainId extends ChainId,
   TAddress extends string,
@@ -11,7 +17,7 @@ export function getChainIdAddressFromId<
   id: ID<TChainId, TAddress>,
 ): {
   chainId: TChainId
-  address: TAddress
+  address: ReturnedAddress<TAddress>
 } {
   const separatorIndex = id.indexOf(':')
 
@@ -22,7 +28,7 @@ export function getChainIdAddressFromId<
   }
 
   const chainId = +id.slice(0, separatorIndex) as TChainId
-  const address = id.slice(separatorIndex + 1) as TAddress
+  const address = id.slice(separatorIndex + 1) as ReturnedAddress<TAddress>
 
   if (!chainId || !address) {
     throw new Error(

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

@@ -0,0 +1,25 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { EvmChainId } from '../../evm/chain/chains.js'
+import type { EvmAddress } from '../../evm/currency/token.js'
+import type {
+  StellarAccountAddress,
+  StellarContractAddress,
+} from '../../stellar/address.js'
+import { StellarChainId } from '../../stellar/chain/chains.js'
+import { getNativeAddress } from './native-address.js'
+
+describe('getNativeAddress', () => {
+  it('returns contract address types', () => {
+    expectTypeOf(
+      getNativeAddress(EvmChainId.ETHEREUM),
+    ).toEqualTypeOf<EvmAddress>()
+
+    expectTypeOf(
+      getNativeAddress(StellarChainId.STELLAR),
+    ).toEqualTypeOf<StellarContractAddress>()
+
+    expectTypeOf(
+      getNativeAddress(StellarChainId.STELLAR),
+    ).not.toEqualTypeOf<StellarAccountAddress>()
+  })
+})

package/generic/utils/native-address.ts

@@ -7,26 +7,26 @@ import { stellarNativeAddress } from '../../stellar/config/simple-constants.js'
 import { isSvmChainId } from '../../svm/chain/chains.js'
 import { svmNativeAddress } from '../../svm/config/simple-constants.js'
 import type { ChainId } from '../chain/chains.js'
-import type { AddressFor } from '../types/for-chain.js'
+import type { ContractAddressFor } from '../types/for-chain.js'
 import { assertNever } from './assert-never.js'
 
 export function getNativeAddress<TChainId extends ChainId>(
   chainId: TChainId,
-): AddressFor<TChainId> {
+): ContractAddressFor<TChainId> {
   if (isEvmChainId(chainId)) {
-    return evmNativeAddress as AddressFor<TChainId>
+    return evmNativeAddress as ContractAddressFor<TChainId>
   }
 
   if (isMvmChainId(chainId)) {
-    return mvmNativeAddress as AddressFor<TChainId>
+    return mvmNativeAddress as ContractAddressFor<TChainId>
   }
 
   if (isSvmChainId(chainId)) {
-    return svmNativeAddress as AddressFor<TChainId>
+    return svmNativeAddress as ContractAddressFor<TChainId>
   }
 
   if (isStellarChainId(chainId)) {
-    return stellarNativeAddress as AddressFor<TChainId>
+    return stellarNativeAddress as ContractAddressFor<TChainId>
   }
 
   assertNever(chainId, `getNativeAddress, unsupported chainId: ${chainId}`)

package/generic/validate/zod.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import { sz } from './zod.js'
+
+describe('sz address validators', () => {
+  it('validates, casts, and normalizes EVM addresses', () => {
+    const address = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+
+    expect(sz.evm.address().parse(address)).toBe(
+      '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    )
+    expect(sz.evm.address().safeParse('0x1234').success).toBe(false)
+  })
+
+  it('validates and casts SVM addresses', () => {
+    const address = 'So11111111111111111111111111111111111111112'
+
+    expect(sz.svm.address().parse(address)).toBe(address)
+    expect(sz.svm.address().safeParse('0x1234').success).toBe(false)
+  })
+
+  it('validates and casts MVM addresses', () => {
+    const address = '0x2::sui::SUI'
+
+    expect(sz.mvm.address().parse(address)).toBe(address)
+    expect(sz.mvm.address().safeParse('0x2::sui').success).toBe(false)
+  })
+
+  it('validates, casts, and normalizes Stellar addresses', () => {
+    const accountAddress =
+      'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7'
+    const contractAddress =
+      'CCRSMJDITH3VK5QOGYCVZDAKIY5GL3RCG4TCVLIAVB662IW2V5KJGZGF'
+
+    expect(sz.stellar.address().parse(accountAddress.toLowerCase())).toBe(
+      accountAddress,
+    )
+    expect(
+      sz.stellar.contractAddress().parse(contractAddress.toLowerCase()),
+    ).toBe(contractAddress)
+    expect(sz.stellar.accountAddress().safeParse(contractAddress).success).toBe(
+      false,
+    )
+  })
+})

package/generic/validate/zod.ts

@@ -1,6 +1,9 @@
 import type { Hex } from 'viem'
 import * as z from 'zod'
 import { szevm } from '../../evm/validate/zod.js'
+import { szmvm } from '../../mvm/validate/zod.js'
+import { szstellar } from '../../stellar/validate/zod.js'
+import { szsvm } from '../../svm/validate/zod.js'
 
 export const hex = () =>
   z
@@ -13,4 +16,7 @@ export const hex = () =>
 export const sz = {
   evm: szevm,
   hex,
+  mvm: szmvm,
+  stellar: szstellar,
+  svm: szsvm,
 }

package/mvm/index.ts

@@ -2,3 +2,4 @@ export * from './chain/index.js'
 export * from './config/index.js'
 export * from './currency/index.js'
 export * from './utils/index.js'
+export * from './validate/index.js'

package/mvm/validate/index.ts

@@ -0,0 +1 @@
+export * from './zod.js'

package/mvm/validate/zod.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod'
+import { isMvmAddress, type MvmAddress } 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))
+
+export const szmvm = {
+  address: mvmAddress,
+}

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "sushi",
   "description": "Sushi",
-  "version": "6.6.10",
-  "type": "module",
+  "version": "6.7.0",
   "main": "./_cjs/generic/index.js",
   "module": "./_esm/generic/index.js",
   "types": "./_types/generic/index.d.ts",
@@ -68,13 +67,13 @@
     }
   },
   "dependencies": {
-    "@solana/addresses": ">=5",
+    "@solana/addresses": "6.9.0",
     "@uniswap/token-lists": "1.0.0-beta.33",
     "tiny-invariant": "1.3.3"
   },
   "peerDependencies": {
     "@solana/addresses": ">=5",
-    "typescript": ">= 5.8.3 < 6",
+    "typescript": ">= 5.8.3 < 7",
     "viem": "*",
     "zod": ">=4"
   },

package/stellar/config/simple-constants.ts

@@ -1,11 +1,8 @@
-import type {
-  StellarAccountAddress,
-  StellarContractAddress,
-} from '../address.js'
+import type { StellarContractAddress } from '../address.js'
 import { StellarChainId } from '../chain/chains.js'
 
 export const stellarNativeAddress =
-  'GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' as const satisfies StellarAccountAddress
+  'CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' as const satisfies StellarContractAddress
 
 export const SUSHISWAP_V3_FACTORY_ADDRESS: Record<
   StellarChainId,

package/stellar/index.ts

@@ -4,3 +4,4 @@ export * from './config/index.js'
 export * from './currency/index.js'
 export type * from './types/index.js'
 export * from './utils/index.js'
+export * from './validate/index.js'

package/stellar/validate/index.ts

@@ -0,0 +1 @@
+export * from './zod.js'

package/stellar/validate/zod.ts

@@ -0,0 +1,38 @@
+import * as z from 'zod'
+import {
+  isStellarAccountAddress,
+  isStellarAddress,
+  isStellarContractAddress,
+  type StellarAccountAddress,
+  type StellarAddress,
+  type StellarContractAddress,
+} from '../address.js'
+import { normalizeStellarAddress } from '../utils/normalize-address.js'
+
+export const stellarAddress = () =>
+  z
+    .string()
+    .transform((value) => normalizeStellarAddress(value as StellarAddress))
+    .refine(isStellarAddress, { message: 'Invalid address' })
+
+export const stellarAccountAddress = () =>
+  z
+    .string()
+    .transform((value) =>
+      normalizeStellarAddress(value as StellarAccountAddress),
+    )
+    .refine(isStellarAccountAddress, { message: 'Invalid address' })
+
+export const stellarContractAddress = () =>
+  z
+    .string()
+    .transform((value) =>
+      normalizeStellarAddress(value as StellarContractAddress),
+    )
+    .refine(isStellarContractAddress, { message: 'Invalid address' })
+
+export const szstellar = {
+  accountAddress: stellarAccountAddress,
+  address: stellarAddress,
+  contractAddress: stellarContractAddress,
+}

package/svm/currency/token.ts

@@ -9,7 +9,7 @@ import { Token } from '../../generic/currency/token.js'
 import { isSvmChainId, type SvmChainId } from '../chain/chains.js'
 import { normalizeSvmAddress } from '../utils/normalize-address.js'
 
-export { type SvmAddress, svmAddress, isSvmAddress }
+export { isSvmAddress, type SvmAddress, svmAddress }
 export type SvmTxHash = string
 
 export type SvmTokenOrigin = 'native' | 'native-bridge'

package/svm/index.ts

@@ -2,3 +2,4 @@ export * from './chain/index.js'
 export * from './config/index.js'
 export * from './currency/index.js'
 export * from './utils/index.js'
+export * from './validate/index.js'

package/svm/validate/index.ts

@@ -0,0 +1 @@
+export * from './zod.js'

package/svm/validate/zod.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod'
+import { isSvmAddress, type SvmAddress } from '../currency/token.js'
+import { normalizeSvmAddress } from '../utils/normalize-address.js'
+
+export const svmAddressSchema = () =>
+  z
+    .string()
+    .refine(isSvmAddress, { message: 'Invalid address' })
+    .transform((value) => normalizeSvmAddress(value as SvmAddress))
+
+export const szsvm = {
+  address: svmAddressSchema,
+}