sushi 6.7.1 → 7.0.0

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.0",
   "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())
+})

package/stellar/validate/zod.ts

@@ -1,35 +1,19 @@
-import * as z from 'zod'
+import { createAddressSchema } from '../../generic/validate/create-address-schema.js'
 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' })
+  createAddressSchema(isStellarAddress, normalizeStellarAddress, true)
 
 export const stellarAccountAddress = () =>
-  z
-    .string()
-    .transform((value) =>
-      normalizeStellarAddress(value as StellarAccountAddress),
-    )
-    .refine(isStellarAccountAddress, { message: 'Invalid address' })
+  createAddressSchema(isStellarAccountAddress, normalizeStellarAddress, true)
 
 export const stellarContractAddress = () =>
-  z
-    .string()
-    .transform((value) =>
-      normalizeStellarAddress(value as StellarContractAddress),
-    )
-    .refine(isStellarContractAddress, { message: 'Invalid address' })
+  createAddressSchema(isStellarContractAddress, normalizeStellarAddress, true)
 
 export const szstellar = {
   accountAddress: stellarAccountAddress,

package/svm/chain/chains.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { svmAddress } from '../currency/token.js'
+import { getSvmChainById, isSvmChainId, SvmChainId } from './chains.js'
+
+describe('SVM chains', () => {
+  it('returns Solana with working explorer URLs', () => {
+    const chain = getSvmChainById(SvmChainId.SOLANA)
+    const address = svmAddress('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
+
+    expect(chain.getTransactionUrl('signature')).toBe(
+      'https://solscan.io/tx/signature',
+    )
+    expect(chain.getAccountUrl(address)).toBe(
+      `https://solscan.io/account/${address}`,
+    )
+    expect(chain.getTokenUrl(address)).toBe(
+      `https://solscan.io/token/${address}`,
+    )
+    expect(isSvmChainId(SvmChainId.SOLANA)).toBe(true)
+    expect(isSvmChainId(1)).toBe(false)
+  })
+})

package/svm/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 type { SvmAddress } from '../currency/token.js'
@@ -14,9 +15,11 @@ type SvmChainNativeCurrency = {
   decimals: number
 }
 
-type SvmChainBase<TChainId extends number, TChainKey extends string> = Chain<
+type SvmChainBase<
+  TChainId extends number,
+  TChainKey extends string,
+> = ChainDefinition<
   SvmChainType,
-  // @ts-expect-error infinite loop
   TChainId,
   TChainKey,
   Readonly<string>,
@@ -37,14 +40,9 @@ type SvmChainInput = Omit<
 >
 
 export function defineSvmChain<const T extends SvmChainInput>(chain: T) {
-  return {
-    ...chain,
-    type: 'svm' as const,
-    getTransactionUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/tx/${input}`,
-    getAccountUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/account/${input}`,
-    getTokenUrl: (input: string) =>
-      `${chain.blockExplorers.default.url}/token/${input}`,
-  } as const satisfies SvmChainBase<number, string>
+  return defineChain('svm', chain, {
+    transaction: (url, input) => `${url}/tx/${input}`,
+    account: (url, input) => `${url}/account/${input}`,
+    token: (url, input) => `${url}/token/${input}`,
+  })
 }

package/svm/currency/deserialize-currency.ts

@@ -1,3 +1,4 @@
+import { createCurrencyDeserializer } from '../../generic/currency/deserialize-currency.js'
 import { type SerializedSvmNative, SvmNative } from './native.js'
 import { type SerializedSvmToken, SvmToken } from './token.js'
 
@@ -7,11 +8,12 @@ function deserializeSvmCurrency(data: SerializedSvmNative): SvmNative
 function deserializeSvmCurrency(
   data: SerializedSvmNative | SerializedSvmToken,
 ) {
-  if (data.type === 'native') {
-    return new SvmNative(data)
-  } else {
-    return new SvmToken(data)
-  }
+  return deserialize({ ...data, type: data.type })
 }
 
+const deserialize = createCurrencyDeserializer({
+  native: SvmNative,
+  token: SvmToken,
+})
+
 export { deserializeSvmCurrency }

package/svm/currency/token.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { SvmChainId } from '../chain/chains.js'
+import { SVM_WNATIVE_ADDRESS } from '../config/tokens/wrapped-native.js'
+import { deserializeSvmCurrency } from './deserialize-currency.js'
+import { SvmNative } from './native.js'
+import { SvmToken, serializedSvmTokenSchema, svmAddress } from './token.js'
+import { unwrapSvmToken } from './unwrap-token.js'
+
+const usdcAddress = svmAddress('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
+
+describe('SVM currencies', () => {
+  const token = new SvmToken({
+    chainId: SvmChainId.SOLANA,
+    address: usdcAddress,
+    symbol: 'USDC',
+    name: 'USD Coin',
+    decimals: 6,
+    metadata: { verified: true },
+  })
+
+  it('preserves case-sensitive addresses and wraps to itself', () => {
+    expect(token.address).toBe(usdcAddress)
+    expect(token.wrap()).toBe(token)
+  })
+
+  it('round-trips tokens through JSON, schema, and deserialization', () => {
+    const serialized = serializedSvmTokenSchema().parse(token.toJSON())
+    const restored = deserializeSvmCurrency(serialized)
+
+    expect(restored).toBeInstanceOf(SvmToken)
+    expect(restored).toEqual(token)
+  })
+
+  it('wraps native SOL to WSOL and unwraps WSOL', () => {
+    const native = SvmNative.fromChainId(SvmChainId.SOLANA)
+    const wrapped = native.wrap()
+
+    expect(wrapped.address).toBe(SVM_WNATIVE_ADDRESS[SvmChainId.SOLANA])
+    expect(unwrapSvmToken(wrapped)).toEqual(native)
+    expect(unwrapSvmToken(token)).toBe(token)
+  })
+
+  it('rejects invalid serialized tokens', () => {
+    const serialized = token.toJSON()
+    expect(() =>
+      serializedSvmTokenSchema().parse({ ...serialized, chainId: -1 }),
+    ).toThrow()
+    expect(() =>
+      serializedSvmTokenSchema().parse({ ...serialized, address: 'invalid' }),
+    ).toThrow()
+    expect(() =>
+      serializedSvmTokenSchema().parse({ ...serialized, decimals: 1.5 }),
+    ).toThrow()
+  })
+})

package/svm/currency/token.ts

@@ -3,8 +3,9 @@ import {
   type Address as SvmAddress,
   address as svmAddress,
 } from '@solana/addresses'
-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 { isSvmChainId, type SvmChainId } from '../chain/chains.js'
 import { normalizeSvmAddress } from '../utils/normalize-address.js'
@@ -46,7 +47,7 @@ export class SvmToken<
       type: this.type,
 
       metadata: this.metadata,
-    } as const
+    }
   }
 
   static fromJSON<TMetadata extends CurrencyMetadata>(
@@ -65,26 +66,10 @@ export const serializedSvmTokenSchema = <
 }: {
   metadata?: z.ZodType<TMetadata>
 } = {}) =>
-  z.object({
-    chainId: z
-      .number()
-      .int()
-      .refine(isSvmChainId)
-      .transform((chainId) => chainId as SvmChainId),
-    address: z
-      .string()
-      .refine(isSvmAddress)
-      .transform((address) => address as SvmAddress),
-    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: isSvmChainId,
+    isAddress: isSvmAddress,
+    metadata,
   })
 
 export type SerializedSvmToken<

package/svm/validate/zod.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { svmAddress } from '../currency/token.js'
+import { svmAddressSchema } from './zod.js'
+
+describe('svmAddressSchema', () => {
+  const address = svmAddress('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
+
+  it('accepts valid Solana addresses', () => {
+    expect(svmAddressSchema().parse(address)).toBe(address)
+  })
+
+  it.each([
+    '',
+    '0x1234',
+    'not-base58',
+    `${address}0`,
+    ` ${address}`,
+  ])('rejects %j', (value) =>
+    expect(() => svmAddressSchema().parse(value)).toThrow())
+})