@cowprotocol/permit-utils 3.0.0 → 3.0.2

package/src/consts/1inchPermitUtils.ts

@@ -1,68 +0,0 @@
-/**
- * @1inch/permit-signed-approvals-utils has a lot of extra variables and increases bundle size.
- *
- * At the same time it's repo is archived.
- *
- * Therefore we just copied needed constants, and when it's not possible, we should use import(...)
- *
- * You also can use `import type ... from '@1inch/permit-signed-approvals-utils'`
- */
-
-export const DAI_EIP_2612_PERMIT_ABI = [
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: 'address',
-        name: 'holder',
-        type: 'address',
-      },
-      {
-        internalType: 'address',
-        name: 'spender',
-        type: 'address',
-      },
-      {
-        internalType: 'uint256',
-        name: 'nonce',
-        type: 'uint256',
-      },
-      {
-        internalType: 'uint256',
-        name: 'expiry',
-        type: 'uint256',
-      },
-      {
-        internalType: 'bool',
-        name: 'allowed',
-        type: 'bool',
-      },
-      {
-        internalType: 'uint8',
-        name: 'v',
-        type: 'uint8',
-      },
-      {
-        internalType: 'bytes32',
-        name: 'r',
-        type: 'bytes32',
-      },
-      {
-        internalType: 'bytes32',
-        name: 's',
-        type: 'bytes32',
-      },
-    ],
-    name: 'permit',
-    outputs: [],
-    payable: false,
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-]
-
-export const EIP_2612_PERMIT_SELECTOR = '0xd505accf'
-
-export const DAI_PERMIT_SELECTOR = '0x8fcbaf0c'
-
-export const DAI_LIKE_PERMIT_TYPEHASH = '0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb'

package/src/lib/checkIsCallDataAValidPermit.ts

@@ -1,64 +0,0 @@
-import { oneInchPermitUtilsConsts } from '..'
-import { PermitInfo } from '../types'
-
-import type { Eip2612PermitUtils } from '@1inch/permit-signed-approvals-utils'
-
-export async function checkIsCallDataAValidPermit(
-  owner: string,
-  chainId: number,
-  eip2612Utils: Eip2612PermitUtils,
-  tokenAddress: string,
-  _tokenName: string | undefined,
-  callData: string,
-  { version, type, name }: PermitInfo,
-): Promise<boolean | undefined> {
-  // TODO: take name only from PermitInfo
-  const tokenName = name || _tokenName
-
-  if (type === 'unsupported') {
-    return false
-  }
-
-  if (!tokenName) {
-    throw new Error(`No token name for ${tokenAddress}`)
-  }
-
-  const params = { chainId, tokenName, tokenAddress, callData, version }
-
-  let recoverPermitOwnerPromise: Promise<string> | undefined = undefined
-
-  // If pre-hook doesn't start with either selector, it's not a permit
-  if (callData.startsWith(oneInchPermitUtilsConsts.EIP_2612_PERMIT_SELECTOR)) {
-    recoverPermitOwnerPromise = eip2612Utils.recoverPermitOwnerFromCallData({
-      ...params,
-      // I don't know why this was removed, ok?
-      // We added it back on buildPermitCallData.ts
-      // But it looks like this is needed 🤷
-      // Check the test for this method https://github.com/1inch/permit-signed-approvals-utils/blob/master/src/eip-2612-permit.test.ts#L85-L106
-      callData: callData.replace(oneInchPermitUtilsConsts.EIP_2612_PERMIT_SELECTOR, '0x'),
-    })
-  } else if (callData.startsWith(oneInchPermitUtilsConsts.DAI_PERMIT_SELECTOR)) {
-    recoverPermitOwnerPromise = eip2612Utils.recoverDaiLikePermitOwnerFromCallData({
-      ...params,
-      callData: callData.replace(oneInchPermitUtilsConsts.DAI_PERMIT_SELECTOR, '0x'),
-    })
-  }
-
-  if (!recoverPermitOwnerPromise) {
-    // The callData doesn't match any known permit type
-    return undefined
-  }
-
-  try {
-    const recoveredOwner = await recoverPermitOwnerPromise
-
-    // Permit is valid when recovered owner matches order owner
-    return recoveredOwner.toLowerCase() === owner.toLowerCase()
-  } catch (e) {
-    console.debug(
-      `[checkHasValidPendingPermit] Failed to check permit validity for owner ${owner} with callData ${callData}`,
-      e,
-    )
-    return false
-  }
-}

package/src/lib/generatePermitHook.ts

@@ -1,133 +0,0 @@
-import { PERMIT_HOOK_DAPP_ID } from '@cowprotocol/hook-dapp-lib'
-import { JsonRpcProvider } from '@ethersproject/providers'
-
-import { DEFAULT_PERMIT_GAS_LIMIT, DEFAULT_PERMIT_VALUE, PERMIT_SIGNER } from '../const'
-import { PermitHookData, PermitHookParams } from '../types'
-import { buildDaiLikePermitCallData, buildEip2612PermitCallData } from '../utils/buildPermitCallData'
-import { getPermitDeadline } from '../utils/getPermitDeadline'
-import { isSupportedPermitInfo } from '../utils/isSupportedPermitInfo'
-
-const REQUESTS_CACHE: { [permitKey: string]: Promise<PermitHookData | undefined> } = {}
-
-export async function generatePermitHook(params: PermitHookParams): Promise<PermitHookData | undefined> {
-  const permitKey = getCacheKey(params)
-
-  const cachedRequest = REQUESTS_CACHE[permitKey]
-
-  if (cachedRequest) {
-    return await cachedRequest
-  }
-
-  const request = generatePermitHookRaw(params)
-    .catch((e) => {
-      console.debug(`[generatePermitHook] cached request failed`, e)
-      return undefined
-    })
-    .finally(() => {
-      // Remove consumed request to avoid stale data
-      delete REQUESTS_CACHE[permitKey]
-    })
-
-  REQUESTS_CACHE[permitKey] = request
-
-  return request
-}
-
-async function generatePermitHookRaw(params: PermitHookParams): Promise<PermitHookData> {
-  const { inputToken, spender, chainId, permitInfo, provider, account, eip2612Utils, nonce: preFetchedNonce } = params
-
-  const tokenAddress = inputToken.address
-  // TODO: remove the need for `name` from input token. Should come from permitInfo instead
-  const tokenName = permitInfo.name || inputToken.name
-
-  if (!isSupportedPermitInfo(permitInfo)) {
-    throw new Error(`Trying to generate permit hook for unsupported token: ${tokenAddress}`)
-  }
-
-  if (!tokenName) {
-    throw new Error(`No token name for token: ${tokenAddress}`)
-  }
-
-  const owner = account || PERMIT_SIGNER.address
-
-  // Only fetch the nonce in case it wasn't pre-fetched before
-  // That's the case for static account
-  const nonce = preFetchedNonce === undefined ? await eip2612Utils.getTokenNonce(tokenAddress, owner) : preFetchedNonce
-
-  const deadline = getPermitDeadline()
-  const value = params.amount || DEFAULT_PERMIT_VALUE
-
-  const callData =
-    permitInfo.type === 'eip-2612'
-      ? await buildEip2612PermitCallData({
-          eip2612Utils,
-          callDataParams: [
-            {
-              owner,
-              spender,
-              value: value.toString(),
-              nonce,
-              deadline,
-            },
-            chainId as number,
-            tokenName,
-            tokenAddress,
-            permitInfo.version,
-          ],
-        })
-      : await buildDaiLikePermitCallData({
-          eip2612Utils,
-          callDataParams: [
-            {
-              holder: owner,
-              spender,
-              allowed: true,
-              value: value.toString(),
-              nonce,
-              expiry: deadline,
-            },
-            chainId as number,
-            tokenName,
-            tokenAddress,
-            permitInfo.version,
-          ],
-        })
-
-  const gasLimit = await calculateGasLimit(callData, owner, tokenAddress, provider, !!account)
-
-  return {
-    target: tokenAddress,
-    callData,
-    gasLimit,
-    dappId: PERMIT_HOOK_DAPP_ID,
-  }
-}
-
-async function calculateGasLimit(
-  data: string,
-  from: string,
-  to: string,
-  provider: JsonRpcProvider,
-  isUserAccount: boolean,
-): Promise<string> {
-  try {
-    // Query the actual gas estimate
-    const actual = await provider.estimateGas({ data, from, to })
-
-    // Add 10% to actual value to account for minor differences with real account
-    // Do not add it if this is the real user's account
-    const gasLimit = !isUserAccount ? actual.add(actual.div(10)) : actual
-
-    // Pick the biggest between estimated and default
-    return gasLimit.gt(DEFAULT_PERMIT_GAS_LIMIT) ? gasLimit.toString() : DEFAULT_PERMIT_GAS_LIMIT
-  } catch (e) {
-    console.debug(`[calculatePermitGasLimit] Failed to estimateGas, using default`, e)
-
-    return DEFAULT_PERMIT_GAS_LIMIT
-  }
-}
-
-function getCacheKey(params: PermitHookParams): string {
-  const { inputToken, chainId, account, amount } = params
-  return `${inputToken.address.toLowerCase()}-${chainId}${account ? `-${account.toLowerCase()}` : ''}${amount ? `-${amount.toString()}` : ''}`
-}

package/src/lib/getPermitUtilsInstance.ts

@@ -1,51 +0,0 @@
-import type { JsonRpcProvider } from '@ethersproject/providers'
-
-import { PERMIT_SIGNER } from '../const'
-import { PermitProviderConnector } from '../utils/PermitProviderConnector'
-
-import type { Eip2612PermitUtils } from '@1inch/permit-signed-approvals-utils'
-
-/**
- * Cache by network. Here we don't care about the provider as a static account will be used for the signature
- */
-const CHAIN_UTILS_CACHE = new Map<number, Eip2612PermitUtils>()
-/**
- * Cache by provider. Here we cache per provider as each account should have its own instance
- */
-const PROVIDER_UTILS_CACHE = new Map<string, Eip2612PermitUtils>()
-
-export async function getPermitUtilsInstance(
-  chainId: number,
-  provider: JsonRpcProvider,
-  account?: string | undefined,
-): Promise<Eip2612PermitUtils> {
-  const chainCache = CHAIN_UTILS_CACHE.get(chainId)
-
-  if (!account && chainCache) {
-    return chainCache
-  }
-  const providerCacheKey = `${chainId}-${account}`
-  const providerCache = PROVIDER_UTILS_CACHE.get(providerCacheKey)
-
-  if (providerCache) {
-    return providerCache
-  }
-
-  // TODO: allow to receive the signer as a parameter
-  const web3ProviderConnector = new PermitProviderConnector(provider, account ? undefined : PERMIT_SIGNER)
-  const Eip2612PermitUtilsClass = await import('../imports/1inchPermitUtils').then((r) => r.Eip2612PermitUtils)
-  const eip2612PermitUtils = new Eip2612PermitUtilsClass(web3ProviderConnector, { enabledCheckSalt: true })
-
-  if (!account) {
-    console.log(`[getPermitUtilsInstance] Set cached chain utils for chain ${chainId}`, eip2612PermitUtils)
-    CHAIN_UTILS_CACHE.set(chainId, eip2612PermitUtils)
-  } else {
-    console.log(
-      `[getPermitUtilsInstance] Set cached provider utils for chain ${chainId}-${account}`,
-      eip2612PermitUtils,
-    )
-    PROVIDER_UTILS_CACHE.set(providerCacheKey, eip2612PermitUtils)
-  }
-
-  return eip2612PermitUtils
-}

package/src/lib/getTokenPermitInfo.ts

@@ -1,281 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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
-}