sushi 6.6.11 → 6.7.1

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/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/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/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'
@@ -82,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(