sushi 6.0.11 → 6.0.13

package/generic/types/mutable.ts

@@ -0,0 +1,3 @@
+export type Mutable<T> = {
+  -readonly [K in keyof T]: T[K]
+}

package/generic/types/replace.ts

@@ -0,0 +1,8 @@
+export type Replace<
+  T extends string,
+  S extends string,
+  D extends string,
+  A extends string = '',
+> = T extends `${infer L}${S}${infer R}`
+  ? Replace<R, S, D, `${A}${L}${D}`>
+  : `${A}${T}`

package/generic/types/union-to-intersection.ts

@@ -0,0 +1,7 @@
+export type UnionToIntersection<U> = (
+  U extends any
+    ? (k: U) => void
+    : never
+) extends (k: infer I) => void
+  ? I
+  : never

package/generic/utils/id.ts

@@ -0,0 +1,41 @@
+import type { ChainId } from '../chain/chains.js'
+import type { ID } from '../types/id.js'
+
+export function getChainIdAddressFromId<
+  TChainId extends ChainId,
+  TAddress extends string,
+>(
+  id: ID<TChainId, TAddress>,
+): {
+  chainId: TChainId
+  address: TAddress
+} {
+  const [chainId, address, ...rest] = id.split(':') as [TChainId, TAddress]
+
+  if (rest.length > 0) {
+    throw new Error(
+      `Invalid ID format: ${id}. Expected format is "chainId:address".`,
+    )
+  }
+
+  if (!chainId || !address) {
+    throw new Error(
+      `Invalid ID format: ${id}. Expected format is "chainId:address".`,
+    )
+  }
+
+  return { chainId, address }
+}
+
+export function getIdFromChainIdAddress<
+  TChainId extends ChainId,
+  TAddress extends string,
+>(chainId: TChainId, address: TAddress): ID<TChainId, TAddress> {
+  if (!chainId || !address) {
+    throw new Error(
+      `Invalid chainId or address: ${chainId}, ${address}. Both must be provided.`,
+    )
+  }
+
+  return `${chainId}:${address}` as ID<TChainId, TAddress>
+}

package/generic/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './id.js'
+export * from './lowercase-map.js'
+export * from './subtract-slippage.js'

package/generic/utils/lowercase-map.ts

@@ -0,0 +1,14 @@
+export class LowercaseMap<K extends string, V> extends Map<K, V> {
+  override get(key: K): V | undefined {
+    return super.get(key.toLowerCase() as K)
+  }
+  override has(key: K) {
+    return super.has(key.toLowerCase() as K)
+  }
+  override set(key: K, value: V) {
+    return super.set(key.toLowerCase() as K, value)
+  }
+  override delete(key: K) {
+    return super.delete(key.toLowerCase() as K)
+  }
+}

package/generic/utils/subtract-slippage.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import { Amount } from '../currency/amount.js'
+import { Token } from '../currency/token.js'
+import { subtractSlippage } from './subtract-slippage.js'
+
+class TestToken extends Token {
+  public override toJSON() {
+    return {
+      chainId: this.chainId,
+      address: this.address,
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+    } as any
+  }
+
+  public override wrap() {
+    return this
+  }
+}
+
+describe('subtractSlippage', () => {
+  const token = new TestToken({
+    chainId: 1,
+    address: '0x123',
+    symbol: 'TEST',
+    name: 'Test Token',
+    decimals: 18,
+  })
+
+  it('should subtract slippage correctly', () => {
+    const amount = Amount.fromHuman(token, '100')
+    const result = subtractSlippage(amount, 0.1) // 10%
+    expect(result.toString()).toBe('90')
+  })
+
+  it('should handle 0% slippage', () => {
+    const amount = Amount.fromHuman(token, '100')
+    const result = subtractSlippage(amount, 0)
+    expect(result.amount).toBe(amount.amount)
+  })
+
+  it('should handle 100% slippage', () => {
+    const amount = Amount.fromHuman(token, '100')
+    const result = subtractSlippage(amount, 1)
+    expect(result.toString()).toBe('0')
+  })
+
+  it('should throw on invalid slippage values', () => {
+    const amount = Amount.fromHuman(token, '100')
+    expect(() => subtractSlippage(amount, -0.1)).toThrow(
+      'Slippage must be between 0 and 1',
+    )
+    expect(() => subtractSlippage(amount, 1.1)).toThrow(
+      'Slippage must be between 0 and 1',
+    )
+  })
+
+  it('should handle very small amounts', () => {
+    const amount = new Amount(token, 1n) // 1 wei
+    const result = subtractSlippage(amount, 0.5)
+    expect(result.amount).toBe(0n) // rounds down
+  })
+})

package/generic/utils/subtract-slippage.ts

@@ -0,0 +1,20 @@
+import type { Amount } from '../currency/amount.js'
+import type { Currency } from '../currency/currency.js'
+
+/**
+ *
+ * @param amount The amount to subtract slippage from.
+ * @param slippage The slippage percentage to subtract, represented as a decimal between 0 and 1 (e.g., 0.01 for 1%).
+ *
+ * @returns The amount after subtracting the slippage, eg. amount * 0.9 if slippage is 10% (0.1).
+ */
+export function subtractSlippage<TCurrency extends Currency>(
+  amount: Amount<TCurrency>,
+  slippage: number,
+) {
+  if (slippage < 0 || slippage > 1) {
+    throw new Error('Slippage must be between 0 and 1')
+  }
+
+  return amount.mulHuman(1 - slippage)
+}

package/generic/validate/index.ts

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

package/generic/validate/isPromiseFulfilled.ts

@@ -0,0 +1,3 @@
+export const isPromiseFulfilled = <T>(
+  input: PromiseSettledResult<T>,
+): input is PromiseFulfilledResult<T> => input.status === 'fulfilled'

package/generic/validate/isPromiseRejected.ts

@@ -0,0 +1,3 @@
+export const isPromiseRejected = (
+  input: PromiseSettledResult<unknown>,
+): input is PromiseRejectedResult => input.status === 'rejected'

package/generic/validate/zod.ts

@@ -0,0 +1,16 @@
+import type { Hex } from 'viem'
+import * as z from 'zod'
+import { szevm } from '../../evm/validate/zod.js'
+
+export const hex = () =>
+  z
+    .string()
+    .refine((value) => /^0x[0-9a-fA-F]*$/.test(value), {
+      message: 'Invalid hex',
+    })
+    .transform((value) => value.toLowerCase() as Hex)
+
+export const sz = {
+  evm: szevm,
+  hex,
+}

package/mvm/chain/chains.ts

@@ -0,0 +1,103 @@
+import type { Replace } from '../../generic/types/replace.js'
+import type { UnionToIntersection } from '../../generic/types/union-to-intersection.js'
+import { defineMvmChain } from './define-chain.js'
+
+const aptos = defineMvmChain({
+  chainId: -1,
+  key: 'aptos',
+  shortName: 'apt',
+  name: 'Aptos',
+  blockExplorers: {
+    default: { name: 'Aptos Explorer', url: 'https://explorer.aptoslabs.com' },
+  },
+  netType: 'mainnet',
+})
+
+export const mvmChains = [aptos] as const
+
+// MvmChainId
+
+export const mvmChainIds = /* @__PURE__ */ mvmChains.map(
+  (chain) => chain.chainId,
+)
+
+export type MvmChainId = (typeof mvmChainIds)[number]
+
+type MvmChainIdMap = UnionToIntersection<
+  (typeof mvmChains)[number] extends infer I
+    ? I extends { key: infer K; chainId: infer C }
+      ? K extends string
+        ? { [key in K as Uppercase<Replace<key, '-', '_'>>]: C }
+        : never
+      : never
+    : never
+>
+
+export const MvmChainId = /* @__PURE__ */ new Proxy<MvmChainIdMap>(
+  {} as MvmChainIdMap,
+  {
+    get: (_: unknown, key: keyof MvmChainIdMap) => {
+      const _key = key.toLowerCase().replace(/_/g, '-') as MvmChainKey
+      const chain = mvmChains.find((chain) => chain.key === _key)
+
+      if (!chain) return undefined
+
+      return chain.chainId
+    },
+  },
+)
+
+export function isMvmChainId(chainId: number): chainId is MvmChainId {
+  return mvmChains.some((chain) => chain.chainId === chainId)
+}
+
+export function getMvmChainById<C extends MvmChainId>(chainId: C) {
+  return mvmChains.find((chain) => chain.chainId === chainId)! as Extract<
+    (typeof mvmChains)[number],
+    { chainId: C }
+  >
+}
+
+// MvmMainnetChainId
+export type MvmMainnetChainId = Extract<
+  (typeof mvmChains)[number],
+  { netType: 'mainnet' }
+>['chainId']
+
+export function isMvmMainnetChainId(
+  chainId: number,
+): chainId is MvmMainnetChainId {
+  return mvmChains.some(
+    (chain) => chain.chainId === chainId && chain.netType === 'mainnet',
+  )
+}
+
+// // MvmTestnetChainId
+
+// export type MvmTestnetChainId = Extract<
+//   (typeof mvmChains)[number],
+//   { netType: 'testnet' }
+// >['chainId']
+
+// export function isMvmTestnetChainId(
+//   chainId: number,
+// ): chainId is MvmTestnetChainId {
+//   return mvmChains.some(
+//     (chain) => chain.chainId === chainId && chain.netType === 'testnet',
+//   )
+// }
+
+// MvmChainKey
+
+export type MvmChainKey = (typeof mvmChains)[number]['key']
+
+export function isMvmChainKey(key: string): key is MvmChainKey {
+  return mvmChains.some((chain) => chain.key === key)
+}
+
+export function getMvmChainByKey<C extends MvmChainKey>(key: C) {
+  return mvmChains.find((chain) => chain.key === key)! as Extract<
+    (typeof mvmChains)[number],
+    { key: C }
+  >
+}

package/mvm/chain/define-chain.ts

@@ -0,0 +1,42 @@
+import type {
+  BlockExplorers,
+  Chain,
+  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<
+  MvmChainType,
+  // @ts-expect-error prevent infinite loop
+  TChainId,
+  TChainKey,
+  Readonly<string>,
+  Readonly<string>,
+  NetType,
+  BlockExplorers,
+  string,
+  string
+>
+
+export type MvmChain = MvmChainBase<MvmChainId, MvmChainKey>
+
+type MvmChainInput = Omit<
+  MvmChainBase<number, string>,
+  'type' | 'getTransactionUrl' | 'getAccountUrl' | 'getTokenUrl'
+>
+
+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>
+}

package/mvm/chain/index.ts

@@ -0,0 +1,2 @@
+export * from './chains.js'
+export * from './define-chain.js'

package/mvm/currency/index.ts

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

package/mvm/currency/token.ts

@@ -0,0 +1,45 @@
+import * as z from 'zod'
+import type { CurrencyMetadata } from '../../generic/currency/currency.js'
+import { Token } from '../../generic/currency/token.js'
+import { type MvmChainId, isMvmChainId } from '../chain/chains.js'
+
+export type MvmAddress = `0x${string}::${string}::${string}`
+
+export function isMvmAddress(address: string): address is MvmAddress {
+  // 0x${string}::${string}::${string}
+  return !!address.match(/^0x([^:]+)::([^:]+)::([^:]+)$/)
+}
+
+export class MvmToken<
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> extends Token<MvmChainId, MvmAddress, TMetadata> {
+  public override wrap(): MvmToken<TMetadata> {
+    return this
+  }
+
+  public override toJSON(): SerializedMvmToken {
+    return {
+      chainId: this.chainId,
+      address: this.address,
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      type: this.type,
+    } as const
+  }
+
+  static fromJSON(data: SerializedMvmToken): MvmToken {
+    return new this(data)
+  }
+}
+
+export const serializedMvmTokenSchema = z.object({
+  chainId: z.number().int().refine(isMvmChainId),
+  address: z.string().refine(isMvmAddress),
+  symbol: z.string(),
+  name: z.string(),
+  decimals: z.number().int().nonnegative(),
+  type: z.literal('token'),
+})
+
+export type SerializedMvmToken = z.infer<typeof serializedMvmTokenSchema>

package/mvm/index.ts

@@ -0,0 +1,2 @@
+export * from './chain/index.js'
+export * from './currency/index.js'

package/package.json

@@ -1,55 +1,59 @@
 {
   "name": "sushi",
   "description": "Sushi",
-  "version": "6.0.11",
+  "version": "6.0.13",
   "type": "module",
   "main": "./_cjs/generic/index.js",
   "module": "./_esm/generic/index.js",
   "types": "./_types/generic/index.d.ts",
-  "typings": "./_types/generic/index.d.ts",
   "sideEffects": false,
   "files": [
     "_cjs",
     "_esm",
     "_types",
+    "generic",
+    "evm",
+    "mvm",
+    "tvm",
     "package.json"
   ],
   "exports": {
     ".": {
       "types": "./_types/generic/index.d.ts",
       "import": "./_esm/generic/index.js",
-      "default": "./_cjs/generic/index.js"
+      "require": "./_cjs/generic/index.cjs",
+      "default": "./_esm/generic/index.js"
     },
     "./evm": {
       "types": "./_types/evm/index.d.ts",
       "import": "./_esm/evm/index.js",
-      "default": "./_cjs/evm/index.js"
+      "require": "./_cjs/evm/index.cjs",
+      "default": "./_esm/evm/index.js"
     },
     "./mvm": {
       "types": "./_types/mvm/index.d.ts",
       "import": "./_esm/mvm/index.js",
-      "default": "./_cjs/mvm/index.js"
+      "require": "./_cjs/mvm/index.cjs",
+      "default": "./_esm/mvm/index.js"
     },
     "./tvm": {
       "types": "./_types/tvm/index.d.ts",
       "import": "./_esm/tvm/index.js",
-      "default": "./_cjs/tvm/index.js"
+      "require": "./_cjs/tvm/index.cjs",
+      "default": "./_esm/tvm/index.js"
     },
     "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
-      ".": [
-        "./_types/generic/index.d.ts"
-      ],
       "evm": [
-        "./_types/evm/index.d.ts"
+        "_types/evm/index.d.ts"
       ],
       "mvm": [
-        "./_types/mvm/index.d.ts"
+        "_types/mvm/index.d.ts"
       ],
       "tvm": [
-        "./_types/tvm/index.d.ts"
+        "_types/tvm/index.d.ts"
       ]
     }
   },

package/tvm/abi/factoryAbi/factoryAbi.ts

@@ -0,0 +1,189 @@
+export const factoryAbi = [
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_feeToSetter',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'constructor',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'token0',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'token1',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'pair',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    name: 'PairCreated',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    name: 'allPairs',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'allPairsLength',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'tokenA',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'tokenB',
+        type: 'address',
+      },
+    ],
+    name: 'createPair',
+    outputs: [
+      {
+        internalType: 'address',
+        name: 'pair',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'feeTo',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'feeToSetter',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    name: 'getPair',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'getPairHash',
+    outputs: [
+      {
+        internalType: 'bytes32',
+        name: '',
+        type: 'bytes32',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_feeTo',
+        type: 'address',
+      },
+    ],
+    name: 'setFeeTo',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_feeToSetter',
+        type: 'address',
+      },
+    ],
+    name: 'setFeeToSetter',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]