@lifi/sdk 3.4.2 → 3.5.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 { isNativeTokenAddress } from '../../utils/isZeroAddress.js'
@@ -10,10 +10,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({
@@ -35,9 +35,9 @@ export const setAllowance = async (
         : undefined,
   }
 
-  if (settings?.updateTransactionRequestHook) {
+  if (executionOptions?.updateTransactionRequestHook) {
     const customizedTransactionRequest: TransactionParameters =
-      await settings.updateTransactionRequestHook({
+      await executionOptions.updateTransactionRequestHook({
         requestType: 'approve',
         ...transactionRequest,
       })
@@ -56,7 +56,6 @@ export const setAllowance = async (
     gasPrice: transactionRequest.gasPrice,
     maxFeePerGas: transactionRequest.maxFeePerGas,
     maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-    chain: null,
   } as SendTransactionParameters)
 }
 
@@ -81,16 +80,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
     )
 
@@ -117,15 +116,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,248 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { Client, Hex } from 'viem'
+import { encodeFunctionData } from 'viem'
+import { parseSignature } from 'viem'
+import type { Address } from 'viem'
+import { keccak256 } from 'viem'
+import { readContract, signTypedData } from 'viem/actions'
+import type { TransactionParameters } from '../types.js'
+import { eip2612Types, permit2ProxyAbi } from './abi.js'
+import { type NativePermitData, getNativePermit } from './getNativePermit.js'
+import {
+  type PermitTransferFrom,
+  getPermitData,
+} from './permit2/signatureTransfer.js'
+
+export const signNativePermitMessage = async (
+  client: Client,
+  transactionRequest: TransactionParameters,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint,
+  nativePermit: NativePermitData
+) => {
+  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 signTypedData(client, {
+    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 signTypedData(client, {
+    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
+) => {
+  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: {
+      tokenReceiver: chain.permit2Proxy as Address,
+      diamondAddress: chain.diamondAddress as Address,
+      diamondCalldataHash: keccak256(transactionRequest.data as Hex),
+    },
+    witnessTypeName: 'LiFiCall',
+    witnessType: {
+      LiFiCall: [
+        { name: 'diamondAddress', type: 'address' },
+        { name: 'diamondCalldataHash', type: 'bytes32' },
+      ],
+    },
+  }
+
+  const { domain, types, values } = getPermitData(
+    permitTransferFrom,
+    chain.permit2 as Address,
+    chain.id,
+    witness
+  )
+
+  const signature = await signTypedData(client, {
+    account: client.account!,
+    primaryType: 'PermitWitnessTransferFrom',
+    domain,
+    types,
+    message: { ...values },
+  })
+
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithPermit2Witness',
+    args: [
+      transactionRequest.data as Hex,
+      client.account!.address,
+      [
+        [tokenAddress, amount],
+        permitTransferFrom.nonce,
+        permitTransferFrom.deadline,
+      ],
+      signature as Hex,
+    ],
+  })
+
+  return {
+    signature,
+    data,
+  }
+}
+
+export const signPermitMessage = async (
+  client: Client,
+  transactionRequest: TransactionParameters,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint,
+  nativePermit?: NativePermitData,
+  useWitness = false
+) => {
+  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
+    )
+  }
+
+  return signPermit2Message(
+    client,
+    transactionRequest,
+    chain,
+    tokenAddress,
+    amount
+  )
+}

package/src/core/EVM/types.ts

@@ -1,17 +1,15 @@
 import { type BaseToken, ChainType } from '@lifi/types'
-import type { Client, Hash } from 'viem'
+import type { Client } from 'viem'
 import type { SwitchChainHook } from '../types.js'
 import type { SDKProvider } from '../types.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 {
@@ -50,27 +48,3 @@ export interface RevokeApprovalRequest {
   token: BaseToken
   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
-}

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.

package/src/core/EVM/waitForBatchTransactionReceipt.ts

@@ -0,0 +1,49 @@
+import type {
+  Client,
+  Hash,
+  WalletCallReceipt as _WalletCallReceipt,
+} from 'viem'
+import { getCallsStatus } from 'viem/experimental'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import { waitForResult } from '../../utils/waitForResult.js'
+
+export type WalletCallReceipt = _WalletCallReceipt<
+  bigint,
+  'success' | 'reverted'
+>
+
+export const waitForBatchTransactionReceipt = async (
+  client: Client,
+  batchHash: Hash
+): Promise<WalletCallReceipt> => {
+  return waitForResult(async () => {
+    const callsDetails = await getCallsStatus(client, {
+      id: batchHash,
+    })
+
+    if (callsDetails.status === 'PENDING') {
+      return undefined
+    }
+
+    if (callsDetails.status === 'CONFIRMED') {
+      if (
+        !callsDetails.receipts?.length ||
+        !callsDetails.receipts.every((receipt) => receipt.transactionHash) ||
+        callsDetails.receipts.some((receipt) => receipt.status === 'reverted')
+      ) {
+        throw new TransactionError(
+          LiFiErrorCode.TransactionFailed,
+          'Transaction was reverted.'
+        )
+      }
+      const transactionReceipt = callsDetails.receipts.at(-1)!
+      return transactionReceipt
+    }
+
+    throw new TransactionError(
+      LiFiErrorCode.TransactionFailed,
+      'Transaction not found.'
+    )
+  }, 3000)
+}

package/src/core/checkBalance.ts

@@ -28,13 +28,16 @@ export const checkBalance = async (
       } else {
         const neeeded = formatUnits(neededBalance, token.decimals)
         const current = formatUnits(currentBalance, token.decimals)
-        let _errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${neeeded} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
+        let errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${neeeded} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
 
         if (currentBalance !== 0n) {
-          _errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
+          errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
         }
 
-        throw new BalanceError('The balance is too low.')
+        throw new BalanceError(
+          'The balance is too low.',
+          new Error(errorMessage)
+        )
       }
     }
   }

package/src/index.ts

@@ -15,9 +15,6 @@ export { isEVM } from './core/EVM/types.js'
 export type {
   EVMProvider,
   EVMProviderOptions,
-  MultisigConfig,
-  MultisigTransaction,
-  MultisigTxDetails,
 } from './core/EVM/types.js'
 export { StatusManager } from './core/StatusManager.js'
 export {