@cowprotocol/permit-utils 0.7.0-RC.1 → 2.2.0

package/src/lib/getTokenPermitInfo.ts

@@ -0,0 +1,281 @@
+import { getTokenId } from '@cowprotocol/cow-sdk'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+import { getPermitUtilsInstance } from './getPermitUtilsInstance'
+
+import { oneInchPermitUtilsConsts } from '..'
+import { DEFAULT_MIN_GAS_LIMIT, DEFAULT_PERMIT_VALUE, PERMIT_SIGNER } from '../const'
+import { GetTokenPermitInfoParams, GetTokenPermitIntoResult, PermitInfo, PermitType } from '../types'
+import { buildDaiLikePermitCallData, buildEip2612PermitCallData } from '../utils/buildPermitCallData'
+import { Eip712Domain, getEip712Domain } from '../utils/getEip712Domain'
+import { getPermitDeadline } from '../utils/getPermitDeadline'
+import { getTokenName } from '../utils/getTokenName'
+import { getTokenPermitVersion } from '../utils/getTokenPermitVersion'
+
+import type { Eip2612PermitUtils } from '@1inch/permit-signed-approvals-utils'
+
+const EIP_2612_PERMIT_PARAMS = {
+  nonce: 0,
+  deadline: getPermitDeadline(),
+}
+
+const DAI_LIKE_PERMIT_PARAMS = {
+  allowed: true,
+  nonce: 0,
+  expiry: getPermitDeadline(),
+}
+
+const REQUESTS_CACHE: Record<string, Promise<GetTokenPermitIntoResult>> = {}
+
+const UNSUPPORTED: PermitInfo = { type: 'unsupported' }
+
+export async function getTokenPermitInfo(params: GetTokenPermitInfoParams): Promise<GetTokenPermitIntoResult> {
+  const { tokenAddress, chainId } = params
+  const key = getTokenId({ address: tokenAddress, chainId })
+
+  const cached = REQUESTS_CACHE[key]
+
+  if (cached) {
+    return cached
+  }
+
+  const request = actuallyCheckTokenIsPermittable(params)
+
+  REQUESTS_CACHE[key] = request
+
+  return request
+}
+
+// TODO: Break down this large function into smaller functions
+// TODO: Reduce function complexity by extracting logic
+// eslint-disable-next-line max-lines-per-function, complexity
+async function actuallyCheckTokenIsPermittable(params: GetTokenPermitInfoParams): Promise<GetTokenPermitIntoResult> {
+  const { spender, tokenAddress, chainId, provider, minGasLimit, amount } = params
+
+  const eip2612PermitUtils = await getPermitUtilsInstance(chainId, provider)
+
+  const owner = PERMIT_SIGNER.address
+
+  let domain: Eip712Domain | undefined = undefined
+  // Try to get eip712domain, which contains most of the info we'll need here
+  try {
+    domain = await getEip712Domain(tokenAddress, chainId, provider)
+  } catch {
+    console.debug(`[checkTokenIsPermittable] Couldn't fetch eip712domain for token ${tokenAddress}`)
+  }
+
+  let tokenName = domain?.name
+
+  try {
+    if (!tokenName) {
+      tokenName = await getTokenName(tokenAddress, chainId, provider)
+    }
+  } catch (e) {
+    if (/ETIMEDOUT/.test(e) && !tokenName) {
+      // Network issue or another temporary failure, return error
+      return { error: `Failed to fetch token name from contract. RPC connection error` }
+    }
+    console.debug(
+      `[checkTokenIsPermittable] Couldn't fetch token name from the contract for token ${tokenAddress}, using provided '${tokenName}'`,
+      e,
+    )
+  }
+
+  if (!tokenName) {
+    const error = `Token name could not be determined for ${tokenAddress}`
+    return { error }
+  }
+
+  let nonce: number
+
+  try {
+    nonce = await eip2612PermitUtils.getTokenNonce(tokenAddress, owner)
+  } catch (e) {
+    if (e === 'nonce not supported' || e.message === 'nonce is NaN') {
+      console.debug(`[checkTokenIsPermittable] Not a permittable token ${tokenAddress} - ${tokenName}`, e?.message || e)
+      // Here we know it's not supported, return unsupported
+      // See https://github.com/1inch/permit-signed-approvals-utils/blob/b190197a45c3289867ee4e6da93f10dea51ef276/src/eip-2612-permit.utils.ts#L309
+      // and https://github.com/1inch/permit-signed-approvals-utils/blob/b190197a45c3289867ee4e6da93f10dea51ef276/src/eip-2612-permit.utils.ts#L325
+      return { ...UNSUPPORTED, name: tokenName }
+    }
+    console.debug(`[checkTokenIsPermittable] Failed to get nonce for ${tokenAddress} - ${tokenName}`, e)
+
+    // Otherwise, it might have been a network issue or another temporary failure, return error
+    return { error: e.message || e.toString() }
+  }
+
+  let version: string | undefined = domain?.version
+
+  if (version === undefined) {
+    // If the token does not outright fails when calling with the `version` value
+    // returned by the contract, fetch it.
+
+    try {
+      // Required by USDC-mainnet as its version is `2`.
+      // There might be other tokens that need this as well.
+      version = await getTokenPermitVersion(tokenAddress, provider)
+    } catch (e) {
+      // Not a problem, we can (try to) continue without it, and will default to `1` (part of the 1inch lib)
+      console.debug(`[checkTokenIsPermittable] Failed to get version for ${tokenAddress} - ${tokenName}`, e)
+    }
+  }
+
+  const baseParams: BaseParams = {
+    chainId,
+    eip2612PermitUtils,
+    nonce,
+    spender,
+    tokenAddress,
+    tokenName,
+    walletAddress: owner,
+    version,
+    minGasLimit,
+    amount,
+  }
+
+  try {
+    // Try to estimate with eip-2612 first
+    return await estimateTokenPermit({ ...baseParams, type: 'eip-2612', provider })
+  } catch (e) {
+    // Not eip-2612, try dai-like
+    try {
+      const isDaiLike = await isDaiLikeTypeHash(tokenAddress, eip2612PermitUtils)
+
+      if (!isDaiLike) {
+        // These might be supported, as they have nonces, but we don't know why the permit call fails
+        // TODO: further investigate this kind of token
+        // For now mark them as unsupported and don't check it again
+        if (/invalid signature/.test(e) || e?.code === 'UNPREDICTABLE_GAS_LIMIT') {
+          console.debug(
+            `[checkTokenIsPermittable] Token ${tokenAddress} - ${tokenName} might be permittable, but it's not supported for now. Reason:`,
+            e?.reason,
+          )
+          return { ...UNSUPPORTED, name: tokenName }
+        }
+
+        // Maybe a temporary failure
+        console.debug(
+          `[checkTokenIsPermittable] Failed to estimate eip-2612 permit for ${tokenAddress} - ${tokenName}`,
+          e,
+        )
+        return { error: e.message || e.toString() }
+      }
+
+      return await estimateTokenPermit({ ...baseParams, type: 'dai-like', provider })
+    } catch (e) {
+      // Not dai-like either, return error
+      console.debug(
+        `[checkTokenIsPermittable] Failed to estimate dai-like permit for ${tokenAddress} - ${tokenName}`,
+        e,
+      )
+      return { error: e.message || e.toString() }
+    }
+  }
+}
+
+type BaseParams = {
+  tokenAddress: string
+  tokenName: string
+  chainId: number
+  walletAddress: string
+  spender: string
+  eip2612PermitUtils: Eip2612PermitUtils
+  nonce: number
+  version: string | undefined
+  minGasLimit?: number | undefined
+  amount?: bigint
+}
+
+type EstimateParams = BaseParams & {
+  type: PermitType
+  provider: JsonRpcProvider
+}
+
+async function estimateTokenPermit(params: EstimateParams): Promise<GetTokenPermitIntoResult> {
+  const {
+    provider,
+    walletAddress,
+    tokenAddress,
+    tokenName,
+    type,
+    version,
+    minGasLimit = DEFAULT_MIN_GAS_LIMIT,
+  } = params
+
+  const getCallDataFn = type === 'eip-2612' ? getEip2612CallData : getDaiLikeCallData
+
+  const data = await getCallDataFn(params)
+
+  if (!data) {
+    return { ...UNSUPPORTED, name: tokenName }
+  }
+
+  const estimatedGas = await provider.estimateGas({
+    data,
+    from: walletAddress,
+    to: tokenAddress,
+  })
+
+  const gasLimit = estimatedGas.toNumber()
+
+  return gasLimit > minGasLimit
+    ? {
+        type,
+        version,
+        name: tokenName,
+      }
+    : { ...UNSUPPORTED, name: tokenName }
+}
+
+async function getEip2612CallData(params: BaseParams): Promise<string> {
+  const { eip2612PermitUtils, walletAddress, spender, nonce, chainId, tokenName, tokenAddress, version, amount } =
+    params
+  return buildEip2612PermitCallData({
+    eip2612Utils: eip2612PermitUtils,
+    callDataParams: [
+      {
+        ...EIP_2612_PERMIT_PARAMS,
+        owner: walletAddress,
+        spender,
+        nonce,
+        value: amount ? amount.toString() : DEFAULT_PERMIT_VALUE.toString(),
+      },
+      +chainId,
+      tokenName,
+      tokenAddress,
+      version,
+    ],
+  })
+}
+
+async function isDaiLikeTypeHash(tokenAddress: string, eip2612PermitUtils: Eip2612PermitUtils): Promise<boolean> {
+  const permitTypeHash = await eip2612PermitUtils.getPermitTypeHash(tokenAddress)
+
+  return permitTypeHash === oneInchPermitUtilsConsts.DAI_LIKE_PERMIT_TYPEHASH
+}
+
+async function getDaiLikeCallData(params: BaseParams): Promise<string | false> {
+  const { eip2612PermitUtils, tokenAddress, walletAddress, spender, nonce, chainId, tokenName, version } = params
+
+  const permitTypeHash = await eip2612PermitUtils.getPermitTypeHash(tokenAddress)
+
+  if (permitTypeHash === oneInchPermitUtilsConsts.DAI_LIKE_PERMIT_TYPEHASH) {
+    return buildDaiLikePermitCallData({
+      eip2612Utils: eip2612PermitUtils,
+      callDataParams: [
+        {
+          ...DAI_LIKE_PERMIT_PARAMS,
+          holder: walletAddress,
+          spender,
+          nonce,
+        },
+        chainId as number,
+        tokenName,
+        tokenAddress,
+        version,
+      ],
+    })
+  }
+
+  return false
+}

package/src/types.ts

@@ -0,0 +1,61 @@
+import type { cowAppDataLatestScheme } from '@cowprotocol/cow-sdk'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+import type { Eip2612PermitUtils } from '@1inch/permit-signed-approvals-utils'
+
+export type PermitType = 'dai-like' | 'eip-2612' | 'unsupported'
+
+export type PermitInfo = {
+  type: PermitType
+  // TODO: make it not optional once token-lists is migrated
+  name?: string
+  version?: string | undefined // Some tokens have it different than `1`, and won't work without it
+}
+
+// Local TokenInfo definition to not depend on external libs just for this
+type TokenInfo = {
+  address: string
+  // TODO: remove from token info
+  name: string | undefined
+}
+
+export type PermitHookParams = {
+  inputToken: TokenInfo
+  spender: string
+  chainId: number
+  permitInfo: PermitInfo
+  provider: JsonRpcProvider
+  eip2612Utils: Eip2612PermitUtils
+  account?: string
+  nonce?: number
+  amount?: bigint
+}
+
+export type PermitHookData = cowAppDataLatestScheme.CoWHook
+
+type FailedToIdentify = { error: string }
+
+export type GetTokenPermitIntoResult =
+  // When it's a permittable token:
+  | PermitInfo
+  // When something failed:
+  | FailedToIdentify
+
+type BasePermitCallDataParams = {
+  eip2612Utils: Eip2612PermitUtils
+}
+export type BuildEip2612PermitCallDataParams = BasePermitCallDataParams & {
+  callDataParams: Parameters<Eip2612PermitUtils['buildPermitCallData']>
+}
+export type BuildDaiLikePermitCallDataParams = BasePermitCallDataParams & {
+  callDataParams: Parameters<Eip2612PermitUtils['buildDaiLikePermitCallData']>
+}
+
+export type GetTokenPermitInfoParams = {
+  spender: string
+  tokenAddress: string
+  chainId: number
+  provider: JsonRpcProvider
+  minGasLimit?: number | undefined
+  amount?: bigint
+}

package/src/utils/PermitProviderConnector.ts

@@ -0,0 +1,75 @@
+import { defaultAbiCoder, ParamType } from '@ethersproject/abi'
+import { TypedDataField } from '@ethersproject/abstract-signer'
+import { BigNumber } from '@ethersproject/bignumber'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+import { Wallet } from '@ethersproject/wallet'
+
+import { getContract } from './getContract'
+
+import type { AbiInput, AbiItem, EIP712TypedData, ProviderConnector } from '@1inch/permit-signed-approvals-utils'
+
+export class PermitProviderConnector implements ProviderConnector {
+  constructor(
+    private provider: JsonRpcProvider,
+    private walletSigner?: Wallet | undefined,
+  ) {}
+
+  contractEncodeABI(abi: AbiItem[], address: string | null, methodName: string, methodParams: unknown[]): string {
+    const contract = getContract(address || '', abi, this.provider)
+
+    return contract.interface.encodeFunctionData(methodName, methodParams)
+  }
+
+  signTypedData(_walletAddress: string, typedData: EIP712TypedData, _typedDataHash: string): Promise<string> {
+    // Removes `EIP712Domain` as it's already part of EIP712 (see https://ethereum.stackexchange.com/a/151930/55204)
+    // and EthersJS complains when a type is not needed (see https://github.com/ethers-io/ethers.js/discussions/4000)
+    const types = Object.keys(typedData.types).reduce<Record<string, TypedDataField[]>>((acc, type) => {
+      if (type !== 'EIP712Domain') {
+        acc[type] = typedData.types[type]
+      }
+      return acc
+    }, {})
+
+    const signer = this.walletSigner || this.provider.getSigner()
+
+    return signer._signTypedData(typedData.domain, types, typedData.message)
+  }
+
+  ethCall(contractAddress: string, callData: string): Promise<string> {
+    return this.provider.call({
+      to: contractAddress,
+      data: callData,
+    })
+  }
+
+  decodeABIParameter<T>(type: string, hex: string): T {
+    return defaultAbiCoder.decode([type], hex)[0]
+  }
+
+  decodeABIParameters<T>(types: AbiInput[], hex: string): T {
+    const decodedValues = defaultAbiCoder.decode(types as unknown as (ParamType | string)[], hex) as T
+
+    // Ethersjs decodes numbers as BigNumber instances
+    // However, 1inch utils do not deal with BigNumber instances,
+    // so we need this mess to convert them to hex strings, which 1inch understands
+    // TODO: Any way to make this typing mess any cleaner?
+    if (decodedValues && typeof decodedValues === 'object') {
+      const copy: Record<string, unknown> = {}
+
+      Object.keys(decodedValues).forEach((key) => {
+        // @ts-ignore
+        const value = decodedValues[key]
+        if (BigNumber.isBigNumber(value)) {
+          // @ts-ignore
+          copy[key] = value.toHexString()
+        } else {
+          copy[key] = value
+        }
+      })
+
+      return copy as T
+    }
+
+    return decodedValues
+  }
+}

package/src/utils/buildPermitCallData.ts

@@ -0,0 +1,26 @@
+import { oneInchPermitUtilsConsts } from '..'
+import { BuildDaiLikePermitCallDataParams, BuildEip2612PermitCallDataParams } from '../types'
+
+export async function buildEip2612PermitCallData({
+  eip2612Utils,
+  callDataParams,
+}: BuildEip2612PermitCallDataParams): Promise<string> {
+  const [permitParams, chainId, tokenName, ...rest] = callDataParams
+
+  const callData = await eip2612Utils.buildPermitCallData(permitParams, chainId, tokenName, ...rest)
+  // For some reason, the method above removes the permit selector prefix
+  // https://github.com/1inch/permit-signed-approvals-utils/blob/master/src/eip-2612-permit.utils.ts#L92
+  // Adding it back
+  return callData.replace('0x', oneInchPermitUtilsConsts.EIP_2612_PERMIT_SELECTOR)
+}
+
+export async function buildDaiLikePermitCallData({
+  eip2612Utils,
+  callDataParams,
+}: BuildDaiLikePermitCallDataParams): Promise<string> {
+  const callData = await eip2612Utils.buildDaiLikePermitCallData(...callDataParams)
+
+  // Same as above, but for dai like
+  // https://github.com/1inch/permit-signed-approvals-utils/blob/master/src/eip-2612-permit.utils.ts#L140
+  return callData.replace('0x', oneInchPermitUtilsConsts.DAI_PERMIT_SELECTOR)
+}

package/src/utils/getContract.ts

@@ -0,0 +1,6 @@
+import { Contract, ContractInterface } from '@ethersproject/contracts'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+export function getContract(address: string, abi: ContractInterface, provider: JsonRpcProvider): Contract {
+  return new Contract(address, abi, provider)
+}

package/src/utils/getEip712Domain.ts

@@ -0,0 +1,70 @@
+import { getAddress } from '@ethersproject/address'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+import { getContract } from './getContract'
+
+import Erc20Abi from '../abi/erc20.json'
+
+// See https://eips.ethereum.org/EIPS/eip-5267
+
+export async function getEip712Domain(
+  tokenAddress: string,
+  chainId: number,
+  provider: JsonRpcProvider,
+): Promise<Eip712Domain> {
+  const formattedAddress = getAddress(tokenAddress)
+  const erc20Contract = getContract(formattedAddress, Erc20Abi, provider)
+
+  const eip5267Domain: Required<Eip5267Return> = await erc20Contract.callStatic['eip712Domain']()
+
+  return processDomain(eip5267Domain, chainId, tokenAddress)
+}
+
+type Eip5267Return = {
+  fields: string
+  name?: string
+  version?: string
+  chainId?: string
+  verifyingContract?: string
+  salt?: string
+  extensions?: string[]
+}
+
+export type Eip712Domain = Omit<Eip5267Return, 'fields' | 'extensions'>
+
+/** Retrieves the EIP-712 domain of a contract using EIP-5267 without extensions.
+ *
+ * Derived from https://eips.ethereum.org/EIPS/eip-5267 reference Javascript implementation
+ **/
+async function processDomain(domain: Required<Eip5267Return>, chainId: number, address: string): Promise<Eip712Domain> {
+  const { extensions, ...rest } = domain
+
+  if (extensions.length > 0) {
+    throw Error('Extensions not implemented')
+  }
+
+  if (rest.chainId && chainId !== parseInt(rest.chainId, 16)) {
+    throw Error(`ChainId mismatch. Received: '${rest.chainId}', expected: '${chainId}'`)
+  }
+
+  if (rest.verifyingContract && address.toLowerCase() !== rest.verifyingContract.toLowerCase()) {
+    throw Error(`Address mismatch. Received: '${rest.verifyingContract}', expected: '${address}'`)
+  }
+
+  return buildBasicDomain(rest)
+}
+
+const FIELD_NAMES = ['name', 'version', 'chainId', 'verifyingContract', 'salt']
+
+/** Builds a domain object without extensions based on the return values of `eip712Domain()`. */
+function buildBasicDomain(domain: Required<Omit<Eip5267Return, 'extensions'>>): Eip712Domain {
+  // Will be a 5bit number as a hex string
+  const fields = parseInt(domain.fields, 16)
+
+  return FIELD_NAMES.reduce<Eip712Domain>((acc, field, i) => {
+    if (fields & (1 << i)) {
+      acc[field as keyof Eip712Domain] = domain[field as keyof Omit<Eip5267Return, 'extensions'>]
+    }
+    return acc
+  }, {})
+}

package/src/utils/getPermitDeadline.ts

@@ -0,0 +1,7 @@
+import { DEFAULT_PERMIT_DURATION } from '../const'
+
+// TODO: Add proper return type annotation
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function getPermitDeadline() {
+  return Math.ceil((Date.now() + DEFAULT_PERMIT_DURATION) / 1000)
+}

package/src/utils/getTokenName.ts

@@ -0,0 +1,13 @@
+import { getAddress } from '@ethersproject/address'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+import { getContract } from './getContract'
+
+import Erc20Abi from '../abi/erc20.json'
+
+export async function getTokenName(tokenAddress: string, chainId: number, provider: JsonRpcProvider): Promise<string> {
+  const formattedAddress = getAddress(tokenAddress)
+  const erc20Contract = getContract(formattedAddress, Erc20Abi, provider)
+
+  return erc20Contract.callStatic['name']()
+}

package/src/utils/getTokenPermitVersion.ts

@@ -0,0 +1,35 @@
+import { defaultAbiCoder } from '@ethersproject/abi'
+import type { JsonRpcProvider } from '@ethersproject/providers'
+
+import { getContract } from './getContract'
+
+import { VERSION_ABIS } from '../abi/versionAbis'
+
+export async function getTokenPermitVersion(
+  tokenAddress: string,
+  provider: JsonRpcProvider,
+  index = 0,
+): Promise<string> {
+  const abi = VERSION_ABIS[index]
+
+  if (!abi) {
+    return '1'
+  }
+
+  try {
+    const contract = getContract(tokenAddress, abi, provider)
+    const data = contract.interface.encodeFunctionData(abi[0].name)
+    const response = await provider.call({ to: tokenAddress, data })
+
+    if (response === '0x' || Number.isNaN(Number(response))) {
+      return '1'
+    }
+    if (!response.startsWith('0x')) {
+      return response
+    }
+
+    return defaultAbiCoder.decode(['string'], response).toString()
+  } catch {
+    return getTokenPermitVersion(tokenAddress, provider, index + 1)
+  }
+}

package/src/utils/isSupportedPermitInfo.ts

@@ -0,0 +1,5 @@
+import { PermitInfo } from '../types'
+
+export function isSupportedPermitInfo(p: PermitInfo | undefined): p is PermitInfo {
+  return !!p && p.type !== 'unsupported'
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/vite.config.mts

@@ -0,0 +1,51 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vite'
+import macrosPlugin from 'vite-plugin-babel-macros'
+import dts from 'vite-plugin-dts'
+import viteTsConfigPaths from 'vite-tsconfig-paths'
+
+import * as path from 'path'
+
+export default defineConfig({
+  root: path.resolve(__dirname, './'),
+  cacheDir: '../../../node_modules/.vite/permit-utils',
+
+  plugins: [
+    dts({
+      entryRoot: 'src',
+      tsconfigPath: path.join(__dirname, 'tsconfig.lib.json'),
+    }),
+
+    macrosPlugin(),
+
+    viteTsConfigPaths({
+      root: '../../../',
+    }),
+  ],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [
+  //    viteTsConfigPaths({
+  //      root: '../../',
+  //    }),
+  //  ],
+  // },
+
+  // Configuration for building your library.
+  // See: https://vitejs.dev/guide/build.html#library-mode
+  build: {
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: 'src/index.ts',
+      name: 'permit-utils',
+      fileName: 'index',
+      // Change this to the formats you want to support.
+      // Don't forget to update your package.json as well.
+      formats: ['es', 'cjs'],
+    },
+    rollupOptions: {
+      // External packages that should not be bundled into your library.
+      external: [/@1inch/, /@cowprotocol/, /@ethersproject/],
+    },
+  },
+})