@lifi/sdk 3.5.1-beta.0 → 3.6.0-beta.0

package/src/core/EVM/permit2/signatureTransfer.ts

@@ -0,0 +1,214 @@
+import { hashTypedData } from 'viem'
+import type { Address, TypedData, TypedDataDomain } from 'viem'
+import { invariant } from '../../../utils/invariant.js'
+import {
+  MaxSigDeadline,
+  MaxSignatureTransferAmount,
+  MaxUnorderedNonce,
+} from './constants.js'
+import { permit2Domain } from './domain.js'
+
+export interface Witness {
+  witness: any
+  witnessTypeName: string
+  witnessType: { [key: string]: { name: string; type: string }[] }
+}
+
+export interface TokenPermissions {
+  token: Address
+  amount: bigint
+}
+
+export interface PermitTransferFrom {
+  permitted: TokenPermissions
+  spender: Address
+  nonce: bigint
+  deadline: bigint
+}
+
+export interface PermitBatchTransferFrom {
+  permitted: TokenPermissions[]
+  spender: Address
+  nonce: bigint
+  deadline: bigint
+}
+
+export type PermitTransferFromData = {
+  domain: TypedDataDomain
+  types: TypedData
+  values: PermitTransferFrom
+}
+
+export type PermitBatchTransferFromData = {
+  domain: TypedDataDomain
+  types: TypedData
+  values: PermitBatchTransferFrom
+}
+
+const TOKEN_PERMISSIONS = [
+  { name: 'token', type: 'address' },
+  { name: 'amount', type: 'uint256' },
+] as const
+
+const PERMIT_TRANSFER_FROM_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS,
+  PermitTransferFrom: [
+    { name: 'permitted', type: 'TokenPermissions' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+  ],
+} as const
+
+const PERMIT_BATCH_TRANSFER_FROM_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS,
+  PermitBatchTransferFrom: [
+    { name: 'permitted', type: 'TokenPermissions[]' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+  ],
+} as const
+
+function isPermitTransferFrom(
+  permit: PermitTransferFrom | PermitBatchTransferFrom
+): permit is PermitTransferFrom {
+  return !Array.isArray(permit.permitted)
+}
+
+export function getPermitTransferData(
+  permit: PermitTransferFrom,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+): PermitTransferFromData {
+  invariant(MaxSigDeadline >= permit.deadline, 'SIG_DEADLINE_OUT_OF_RANGE')
+  invariant(MaxUnorderedNonce >= permit.nonce, 'NONCE_OUT_OF_RANGE')
+
+  const domain = permit2Domain(permit2Address, chainId)
+
+  validateTokenPermissions(permit.permitted)
+
+  const types = witness
+    ? ({
+        TokenPermissions: TOKEN_PERMISSIONS,
+        ...witness.witnessType,
+        PermitWitnessTransferFrom: [
+          { name: 'permitted', type: 'TokenPermissions' },
+          { name: 'spender', type: 'address' },
+          { name: 'nonce', type: 'uint256' },
+          { name: 'deadline', type: 'uint256' },
+          { name: 'witness', type: witness.witnessTypeName },
+        ],
+      } as const)
+    : PERMIT_TRANSFER_FROM_TYPES
+
+  const values = witness
+    ? Object.assign(permit, { witness: witness.witness })
+    : permit
+
+  return {
+    domain,
+    types,
+    values,
+  }
+}
+
+export function getPermitBatchTransferData(
+  permit: PermitBatchTransferFrom,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+): PermitBatchTransferFromData {
+  invariant(MaxSigDeadline >= permit.deadline, 'SIG_DEADLINE_OUT_OF_RANGE')
+  invariant(MaxUnorderedNonce >= permit.nonce, 'NONCE_OUT_OF_RANGE')
+
+  const domain = permit2Domain(permit2Address, chainId)
+
+  permit.permitted.forEach(validateTokenPermissions)
+
+  const types = witness
+    ? {
+        ...witness.witnessType,
+        TokenPermissions: TOKEN_PERMISSIONS,
+        PermitBatchWitnessTransferFrom: [
+          { name: 'permitted', type: 'TokenPermissions[]' },
+          { name: 'spender', type: 'address' },
+          { name: 'nonce', type: 'uint256' },
+          { name: 'deadline', type: 'uint256' },
+          { name: 'witness', type: witness.witnessTypeName },
+        ],
+      }
+    : PERMIT_BATCH_TRANSFER_FROM_TYPES
+
+  const values = witness
+    ? Object.assign(permit, { witness: witness.witness })
+    : permit
+
+  return {
+    domain,
+    types,
+    values,
+  }
+}
+
+// return the data to be sent in a eth_signTypedData RPC call
+// for signing the given permit data
+export function getPermitData(
+  permit: PermitTransferFrom | PermitBatchTransferFrom,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+): PermitTransferFromData | PermitBatchTransferFromData {
+  if (isPermitTransferFrom(permit)) {
+    return getPermitTransferData(permit, permit2Address, chainId, witness)
+  }
+  return getPermitBatchTransferData(permit, permit2Address, chainId, witness)
+}
+
+export function hash(
+  permit: PermitTransferFrom | PermitBatchTransferFrom,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+) {
+  if (isPermitTransferFrom(permit)) {
+    const { domain, types, values } = getPermitTransferData(
+      permit,
+      permit2Address,
+      chainId,
+      witness
+    )
+
+    return hashTypedData({
+      domain,
+      types,
+      primaryType: witness ? 'PermitWitnessTransferFrom' : 'PermitTransferFrom',
+      message: {
+        ...values,
+      },
+    })
+  }
+  const { domain, types, values } = getPermitBatchTransferData(
+    permit,
+    permit2Address,
+    chainId,
+    witness
+  )
+
+  return hashTypedData({
+    domain,
+    types,
+    primaryType: witness
+      ? 'PermitBatchWitnessTransferFrom'
+      : 'PermitBatchTransferFrom',
+    message: { ...values },
+  })
+}
+
+function validateTokenPermissions(permissions: TokenPermissions) {
+  invariant(
+    MaxSignatureTransferAmount >= permissions.amount,
+    'AMOUNT_OUT_OF_RANGE'
+  )
+}

package/src/core/EVM/setAllowance.ts

@@ -1,4 +1,4 @@
-import type { Client, Hash, SendTransactionParameters } from 'viem'
+import type { Address, Client, Hash, SendTransactionParameters } from 'viem'
 import { encodeFunctionData } from 'viem'
 import { sendTransaction } from 'viem/actions'
 import { getAction } from 'viem/utils'
@@ -11,10 +11,10 @@ import { getMaxPriorityFeePerGas } from './utils.js'
 
 export const setAllowance = async (
   client: Client,
-  tokenAddress: string,
-  contractAddress: string,
+  tokenAddress: Address,
+  contractAddress: Address,
   amount: bigint,
-  settings?: ExecutionOptions,
+  executionOptions?: ExecutionOptions,
   returnPopulatedTransaction?: boolean
 ): Promise<Hash> => {
   const data = encodeFunctionData({
@@ -36,9 +36,9 @@ export const setAllowance = async (
         : undefined,
   }
 
-  if (settings?.updateTransactionRequestHook) {
+  if (executionOptions?.updateTransactionRequestHook) {
     const customizedTransactionRequest: TransactionParameters =
-      await settings.updateTransactionRequestHook({
+      await executionOptions.updateTransactionRequestHook({
         requestType: 'approve',
         ...transactionRequest,
       })
@@ -61,7 +61,6 @@ export const setAllowance = async (
     gasPrice: transactionRequest.gasPrice,
     maxFeePerGas: transactionRequest.maxFeePerGas,
     maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-    chain: null,
   } as SendTransactionParameters)
 }
 
@@ -86,16 +85,16 @@ export const setTokenAllowance = async ({
   }
   const approvedAmount = await getAllowance(
     token.chainId,
-    token.address,
+    token.address as Address,
     walletClient.account!.address,
-    spenderAddress
+    spenderAddress as Address
   )
 
   if (amount > approvedAmount) {
     const approveTx = await setAllowance(
       walletClient,
-      token.address,
-      spenderAddress,
+      token.address as Address,
+      spenderAddress as Address,
       amount
     )
 
@@ -122,15 +121,15 @@ export const revokeTokenApproval = async ({
   }
   const approvedAmount = await getAllowance(
     token.chainId,
-    token.address,
+    token.address as Address,
     walletClient.account!.address,
-    spenderAddress
+    spenderAddress as Address
   )
   if (approvedAmount > 0) {
     const approveTx = await setAllowance(
       walletClient,
-      token.address,
-      spenderAddress,
+      token.address as Address,
+      spenderAddress as Address,
       0n
     )
 

package/src/core/EVM/signPermitMessage.ts

@@ -0,0 +1,280 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { Address, Client, Hex } from 'viem'
+import { encodeFunctionData, keccak256, parseSignature } from 'viem'
+import { readContract, signTypedData } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import type { TransactionParameters } from '../types.js'
+import { eip2612Types, permit2ProxyAbi } from './abi.js'
+import { type NativePermitData, getNativePermit } from './getNativePermit.js'
+import {
+  type PermitBatchTransferFromData,
+  type PermitTransferFrom,
+  type PermitTransferFromData,
+  getPermitData,
+} from './permit2/signatureTransfer.js'
+
+export interface PermitSignature {
+  signature: Hex
+  data: Hex
+}
+
+export const signNativePermitMessage = async (
+  client: Client,
+  transactionRequest: TransactionParameters,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint,
+  nativePermit: NativePermitData
+): Promise<PermitSignature> => {
+  const deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60) // 30 minutes
+
+  const domain = {
+    name: nativePermit.name,
+    version: nativePermit.version,
+    chainId: chain.id,
+    verifyingContract: tokenAddress,
+  }
+
+  const message = {
+    owner: client.account!.address,
+    spender: chain.permit2Proxy as Address,
+    value: amount,
+    nonce: nativePermit.nonce,
+    deadline,
+  }
+
+  const signature = await getAction(
+    client,
+    signTypedData,
+    'signTypedData'
+  )({
+    account: client.account!,
+    domain,
+    types: eip2612Types,
+    primaryType: 'Permit',
+    message,
+  })
+
+  const { v, r, s } = parseSignature(signature)
+
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithEIP2612Signature',
+    args: [
+      tokenAddress,
+      amount,
+      deadline,
+      Number(v),
+      r,
+      s,
+      transactionRequest.data as Hex,
+    ],
+  })
+
+  return {
+    signature,
+    data,
+  }
+}
+
+export const signPermit2Message = async (
+  client: Client,
+  transactionRequest: TransactionParameters,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint
+) => {
+  const nonce = await readContract(client, {
+    address: chain.permit2Proxy as Address,
+    abi: permit2ProxyAbi,
+    functionName: 'nextNonce',
+    args: [client.account!.address],
+  })
+
+  const permitTransferFrom: PermitTransferFrom = {
+    permitted: {
+      token: tokenAddress,
+      amount: amount,
+    },
+    spender: chain.permit2Proxy as Address,
+    nonce: nonce,
+    deadline: BigInt(Math.floor(Date.now() / 1000) + 30 * 60), // 30 minutes
+  }
+
+  const { domain, types, values } = getPermitData(
+    permitTransferFrom,
+    chain.permit2 as Address,
+    chain.id
+  )
+
+  const signature = await getAction(
+    client,
+    signTypedData,
+    'signTypedData'
+  )({
+    account: client.account!,
+    primaryType: 'PermitTransferFrom',
+    domain,
+    types,
+    message: { ...values },
+  })
+
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithPermit2',
+    args: [
+      transactionRequest.data as Hex,
+      [
+        [tokenAddress, amount],
+        permitTransferFrom.nonce,
+        permitTransferFrom.deadline,
+      ],
+      signature as Hex,
+    ],
+  })
+
+  return {
+    signature,
+    data,
+  }
+}
+
+export const signPermit2WitnessMessage = async (
+  client: Client,
+  transactionRequest: TransactionParameters,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint,
+  permitData?: PermitTransferFromData | PermitBatchTransferFromData
+): Promise<PermitSignature> => {
+  let _permitData = permitData
+  if (!_permitData) {
+    const nonce = await readContract(client, {
+      address: chain.permit2Proxy as Address,
+      abi: permit2ProxyAbi,
+      functionName: 'nextNonce',
+      args: [client.account!.address],
+    })
+
+    const permitTransferFrom: PermitTransferFrom = {
+      permitted: {
+        token: tokenAddress,
+        amount: amount,
+      },
+      spender: chain.permit2Proxy as Address,
+      nonce: nonce,
+      deadline: BigInt(Math.floor(Date.now() / 1000) + 30 * 60), // 30 minutes
+    }
+
+    // Create witness data for the LI.FI call
+    const witness = {
+      witness: {
+        diamondAddress: chain.diamondAddress as Address,
+        diamondCalldataHash: keccak256(transactionRequest.data as Hex),
+      },
+      witnessTypeName: 'LiFiCall',
+      witnessType: {
+        LiFiCall: [
+          { name: 'diamondAddress', type: 'address' },
+          { name: 'diamondCalldataHash', type: 'bytes32' },
+        ],
+      },
+    }
+
+    _permitData = getPermitData(
+      permitTransferFrom,
+      chain.permit2 as Address,
+      chain.id,
+      witness
+    )
+  }
+
+  const signature = await getAction(
+    client,
+    signTypedData,
+    'signTypedData'
+  )({
+    account: client.account!,
+    primaryType: 'PermitWitnessTransferFrom',
+    domain: _permitData.domain,
+    types: _permitData.types,
+    message: { ..._permitData.values },
+  })
+
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithPermit2Witness',
+    args: [
+      transactionRequest.data as Hex,
+      client.account!.address,
+      [
+        [tokenAddress, amount],
+        _permitData.values.nonce,
+        _permitData.values.deadline,
+      ],
+      signature as Hex,
+    ],
+  })
+
+  return {
+    signature,
+    data,
+  }
+}
+
+export const signPermitMessage = async (
+  client: Client,
+  {
+    transactionRequest,
+    chain,
+    tokenAddress,
+    amount,
+    nativePermit,
+    permitData,
+    useWitness = false,
+  }: {
+    transactionRequest: TransactionParameters
+    chain: ExtendedChain
+    tokenAddress: Address
+    amount: bigint
+    nativePermit?: NativePermitData
+    permitData?: PermitTransferFromData | PermitBatchTransferFromData
+    useWitness?: boolean
+  }
+): Promise<PermitSignature> => {
+  let _nativePermit = nativePermit
+
+  if (!_nativePermit) {
+    _nativePermit = await getNativePermit(client, chain, tokenAddress)
+  }
+
+  if (_nativePermit.supported) {
+    return signNativePermitMessage(
+      client,
+      transactionRequest,
+      chain,
+      tokenAddress,
+      amount,
+      _nativePermit
+    )
+  }
+
+  if (useWitness) {
+    return signPermit2WitnessMessage(
+      client,
+      transactionRequest,
+      chain,
+      tokenAddress,
+      amount,
+      permitData
+    )
+  }
+
+  return signPermit2Message(
+    client,
+    transactionRequest,
+    chain,
+    tokenAddress,
+    amount
+  )
+}

package/src/core/EVM/typeguards.ts

@@ -0,0 +1,7 @@
+import type { LiFiStepExtended } from '../types.js'
+import type { EVMPermitStep } from './types.js'
+
+export function isEVMPermitStep(step: LiFiStepExtended): step is EVMPermitStep {
+  const evmStep = step as EVMPermitStep
+  return 'permit' in evmStep || 'permitData' in evmStep || 'witness' in evmStep
+}

package/src/core/EVM/types.ts

@@ -1,17 +1,20 @@
 import { type BaseToken, ChainType } from '@lifi/types'
-import type { Client, Hash } from 'viem'
-import type { SwitchChainHook } from '../types.js'
+import type { Client } from 'viem'
+import type { LiFiStepExtended, SwitchChainHook } from '../types.js'
 import type { SDKProvider } from '../types.js'
+import type { PermitData } from './permit2/domain.js'
+import type {
+  PermitTransferFrom,
+  Witness,
+} from './permit2/signatureTransfer.js'
 
 export interface EVMProviderOptions {
   getWalletClient?: () => Promise<Client>
   switchChain?: SwitchChainHook
-  multisig?: MultisigConfig
 }
 
 export interface EVMProvider extends SDKProvider {
   setOptions(options: EVMProviderOptions): void
-  multisig?: MultisigConfig
 }
 
 export function isEVM(provider: SDKProvider): provider is EVMProvider {
@@ -51,26 +54,8 @@ export interface RevokeApprovalRequest {
   spenderAddress: string
 }
 
-export interface MultisigTxDetails {
-  status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED'
-  txHash?: Hash
-}
-
-export interface MultisigTransaction {
-  to: string
-  value?: bigint
-  data: string
-}
-
-export interface MultisigConfig {
-  isMultisigWalletClient: boolean
-  getMultisigTransactionDetails: (
-    txHash: Hash,
-    fromChainId: number,
-    updateIntermediateStatus?: () => void
-  ) => Promise<MultisigTxDetails>
-  sendBatchTransaction?: (
-    batchTransactions: MultisigTransaction[]
-  ) => Promise<Hash>
-  shouldBatchTransactions?: boolean
+export interface EVMPermitStep extends LiFiStepExtended {
+  permit: PermitTransferFrom
+  permitData: PermitData
+  witness: Witness
 }

package/src/core/EVM/utils.ts

@@ -1,5 +1,5 @@
 import type { ChainId } from '@lifi/types'
-import type { Client, Transaction } from 'viem'
+import type { Address, Client, Transaction } from 'viem'
 import { getBlock } from 'viem/actions'
 import { config } from '../../config.js'
 import { median } from '../../utils/median.js'
@@ -37,9 +37,10 @@ export const getMaxPriorityFeePerGas = async (
 // Multicall
 export const getMulticallAddress = async (
   chainId: ChainId
-): Promise<string | undefined> => {
+): Promise<Address | undefined> => {
   const chains = await config.getChains()
-  return chains.find((chain) => chain.id === chainId)?.multicallAddress
+  return chains.find((chain) => chain.id === chainId)
+    ?.multicallAddress as Address
 }
 
 // Modified viem retryDelay exponential backoff function.