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

package/README.md

@@ -5,7 +5,7 @@ Collection of utils for handling token permits.
 ## Installation
 
 ```bash
-yarn add @cowprotocol/permit-utils
+npm install @cowprotocol/permit-utils
 ```
 
 ## Usage
@@ -26,10 +26,10 @@ const permitInfo = await getTokenPermitInfo({
 import { getPermitUtilsInstance } from "@cowprotocol/permit-utils"
 
 // Using a static account defined in the library
-const staticEip2612PermitUtils = getPermitUtilsInstance(chainId, provider)
+const staticEip2612PermitUtils = await getPermitUtilsInstance(chainId, provider)
 
 // Using a provided account address
-const accountEip2612PermitUtils = getPermitUtilsInstance(chainId, provider, account)
+const accountEip2612PermitUtils = await getPermitUtilsInstance(chainId, provider, account)
 ```
 
 ### `generatePermitHook`
@@ -76,8 +76,7 @@ To illustrate, we'll show the flow of placing an order with a permit hook using
 
 ```typescript
 import { checkIsCallDataAValidPermit, generatePermitHook, getPermitUtilsInstance, getTokenPermitInfo } from '@cowprotocol/permit-utils'
-import { stringifyDeterministic } from '@cowprotocol/app-data'
-import { OrderBookApi } from '@cowprotocol/cow-sdk'
+import { stringifyDeterministic, OrderBookApi } from '@cowprotocol/cow-sdk'
 
 
 // Check whether token is permittable.
@@ -94,7 +93,7 @@ if (!permitInfo) {
 }
 
 // Pass in an account address as we'll need the user to sign the actual permit
-const eip2612Utils = getPermitUtilsInstance(chainId, provider, account)
+const eip2612Utils = await getPermitUtilsInstance(chainId, provider, account)
 
 // Need to know what the current permit nonce is
 const nonce = await eip2612Utils.getTokenNonce(inputToken.address, account)
@@ -112,7 +111,7 @@ const hookData = await generatePermitHook({
 })
 
 // Add the hookData to the order's appData
-// See the full reference on https://github.com/cowprotocol/app-data/
+// See the full reference on https://www.npmjs.com/package/@cowprotocol/sdk-app-data?activeTab=code
 const appData = { version: '0.10.0', metadata: { hooks: { pre: [hookData] } } }
 
 // The order expects the stringified JSON doc

package/jest.config.ts

@@ -0,0 +1,11 @@
+export default {
+  displayName: 'permit-utils',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  setupFilesAfterEnv: ['../../jest.setup.ts'],
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/libs/permit-utils',
+}

package/package.json

@@ -1,19 +1,30 @@
 {
   "name": "@cowprotocol/permit-utils",
-  "version": "0.7.0-RC.1",
-  "type": "module",
+  "version": "2.1.0",
+  "type": "commonjs",
+  "main": "./src/index.ts",
+  "types": "./src/index.d.ts",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "ethers": "^5.7.2",
-    "@1inch/permit-signed-approvals-utils": "^1.4.10",
-    "@cowprotocol/app-data": "^1.1.0",
-    "tslib": "^2.6.1"
+    "@cowprotocol/cow-sdk": "7.3.4",
+    "@1inch/permit-signed-approvals-utils": "^1.5.1",
+    "@ethersproject/abi": "5.7.0",
+    "@ethersproject/abstract-signer": "5.7.0",
+    "@ethersproject/address": "5.7.0",
+    "@ethersproject/bignumber": "5.7.0",
+    "@ethersproject/constants": "5.7.0",
+    "@ethersproject/contracts": "5.7.0",
+    "@ethersproject/providers": "5.7.0",
+    "@ethersproject/wallet": "5.7.0",
+    "ethers": "5.7.2",
+    "ms.macro": "^2.0.0",
+    "viem": "^2.42.1",
+    "@cowprotocol/hook-dapp-lib": "2.0.2"
   },
-  "module": "./index.js",
-  "main": "./index.cjs",
-  "exports": {
-    ".": {
-      "import": "./index.js",
-      "require": "./index.cjs"
-    }
+  "devDependencies": {
+    "@types/ms.macro": "^2.0.0"
   }
-}
+}

package/project.json

@@ -0,0 +1,42 @@
+{
+  "name": "permit-utils",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/permit-utils/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/permit-utils",
+        "main": "libs/permit-utils/src/index.ts",
+        "tsConfig": "libs/permit-utils/tsconfig.lib.json",
+        "assets": ["libs/permit-utils/*.md"],
+        "updateBuildableProjectDepsInPackageJson": true,
+        "buildableProjectDepsInPackageJsonType": "dependencies"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/permit-utils/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/permit-utils/jest.config.ts",
+        "passWithNoTests": true
+      },
+      "configurations": {
+        "ci": {
+          "ci": true,
+          "codeCoverage": true
+        }
+      }
+    }
+  },
+  "tags": []
+}

package/src/abi/erc20.json

@@ -0,0 +1,59 @@
+[
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "eip712Domain",
+    "outputs": [
+      {
+        "internalType": "bytes1",
+        "name": "fields",
+        "type": "bytes1"
+      },
+      {
+        "internalType": "string",
+        "name": "name",
+        "type": "string"
+      },
+      {
+        "internalType": "string",
+        "name": "version",
+        "type": "string"
+      },
+      {
+        "internalType": "uint256",
+        "name": "chainId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "verifyingContract",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "salt",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "extensions",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/abi/versionAbis.ts

@@ -0,0 +1,37 @@
+/**
+ * ABIs for fetching the version of different permit flavours
+ */
+export const VERSION_ABIS = [
+  [
+    {
+      constant: true,
+      inputs: [],
+      name: 'version',
+      outputs: [
+        {
+          name: '',
+          type: 'string',
+        },
+      ],
+      payable: false,
+      stateMutability: 'view',
+      type: 'function',
+    },
+  ],
+  [
+    {
+      constant: true,
+      inputs: [],
+      name: 'ERC712_VERSION',
+      outputs: [
+        {
+          name: '',
+          type: 'string',
+        },
+      ],
+      payable: false,
+      stateMutability: 'view',
+      type: 'function',
+    },
+  ],
+]

package/src/const.ts

@@ -0,0 +1,20 @@
+import { MaxUint256 } from '@ethersproject/constants'
+import { Wallet } from '@ethersproject/wallet'
+
+import ms from 'ms.macro'
+import { privateKeyToAccount } from 'viem/accounts'
+
+// PK used only for signing permit requests for quoting and identifying token 'permittability'
+// Do not use or try to send funds to it. Or do. It'll be your funds 🤷
+const PERMIT_PK = '0xa50dc0f7fc051309434deb3b1c71e927dbb711759231d8ecbf630c85d94a42fe' // address: 0xDa5F16F4ab0410096a4403e7223988649fac38cF
+
+export const PERMIT_ACCOUNT = privateKeyToAccount(PERMIT_PK)
+export const PERMIT_SIGNER = new Wallet(PERMIT_PK)
+
+export const DEFAULT_MIN_GAS_LIMIT = 55_000
+
+export const DEFAULT_PERMIT_GAS_LIMIT = '80000'
+
+export const DEFAULT_PERMIT_VALUE = MaxUint256.toBigInt()
+
+export const DEFAULT_PERMIT_DURATION = ms`5 years`

package/src/consts/1inchPermitUtils.ts

@@ -0,0 +1,68 @@
+/**
+ * @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/imports/1inchPermitUtils.ts

@@ -0,0 +1,10 @@
+/**
+ * @1inch/permit-signed-approvals-utils has a lot of extra variables and increases bundle size, we should import in dynamically.
+ *
+ * It uses esm, but dymaic import breaks tree shaking, so we re-export here only used variables (642kb -> 256kb).
+ *
+ * You also can use `import type ... from '@1inch/permit-signed-approvals-utils'`
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+export { Eip2612PermitUtils } from '@1inch/permit-signed-approvals-utils'

package/src/index.ts

@@ -0,0 +1,11 @@
+export { DEFAULT_MIN_GAS_LIMIT, PERMIT_ACCOUNT, PERMIT_SIGNER } from './const'
+
+export { checkIsCallDataAValidPermit } from './lib/checkIsCallDataAValidPermit'
+export { generatePermitHook } from './lib/generatePermitHook'
+export { getPermitUtilsInstance } from './lib/getPermitUtilsInstance'
+export { getTokenPermitInfo } from './lib/getTokenPermitInfo'
+export { isSupportedPermitInfo } from './utils/isSupportedPermitInfo'
+
+export * as oneInchPermitUtilsConsts from './consts/1inchPermitUtils'
+
+export type { GetTokenPermitIntoResult, PermitHookData, PermitHookParams, PermitInfo, PermitType } from './types'

package/src/lib/checkIsCallDataAValidPermit.ts

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

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

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