@lifi/sdk 3.6.0-beta.5 → 3.6.0-beta.6

package/src/core/EVM/parseEVMErrors.ts

@@ -41,6 +41,15 @@ const handleSpecificErrors = async (
   if (e.cause?.code === -32000) {
     return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
   }
+  // Some wallets reject transactions sometimes with this code because of internal and JSON-RPC errors, e.g.:
+  // {
+  //     "code": -32603,
+  //     "message": "Pop up window failed to open",
+  //     "docUrl": "https://docs.cloud.coinbase.com/wallet-sdk/docs/errors"
+  // }
+  if (e.cause?.code === -32603) {
+    return new TransactionError(LiFiErrorCode.TransactionRejected, e.message, e)
+  }
 
   if (
     step &&

package/src/core/EVM/{permit2 → permits}/domain.ts

@@ -1,4 +1,4 @@
-import type { Address, TypedData, TypedDataDomain } from 'viem'
+import type { Address, TypedDataDomain } from 'viem'
 
 const PERMIT2_DOMAIN_NAME = 'Permit2'
 
@@ -12,9 +12,3 @@ export function permit2Domain(
     verifyingContract: permit2Address,
   }
 }
-
-export type PermitData = {
-  domain: TypedDataDomain
-  types: TypedData
-  values: any
-}

package/src/core/EVM/permits/encodeNativePermitData.ts

@@ -0,0 +1,19 @@
+import type { Address, Hash, Hex } from 'viem'
+import { encodeFunctionData, parseSignature } from 'viem'
+import { permit2ProxyAbi } from '../abi.js'
+
+export const encodeNativePermitData = (
+  tokenAddress: Address,
+  amount: bigint,
+  deadline: bigint,
+  signature: Hash,
+  transactionData: Hex
+): Hex => {
+  const { v, r, s } = parseSignature(signature)
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithEIP2612Signature',
+    args: [tokenAddress, amount, deadline, Number(v), r, s, transactionData],
+  })
+  return data
+}

package/src/core/EVM/permits/encodePermit2Data.ts

@@ -0,0 +1,41 @@
+import type { Address, Hex } from 'viem'
+import { type Hash, encodeFunctionData } from 'viem'
+import { permit2ProxyAbi } from '../abi.js'
+
+export const encodePermit2Data = (
+  tokenAddress: Address,
+  amount: bigint,
+  nonce: bigint,
+  deadline: bigint,
+  transactionData: Hex,
+  signature: Hash,
+  accountAddress?: Address,
+  witness?: boolean
+): Hex => {
+  if (witness && accountAddress) {
+    const data = encodeFunctionData({
+      abi: permit2ProxyAbi,
+      functionName: 'callDiamondWithPermit2Witness',
+      args: [
+        transactionData,
+        accountAddress,
+        [[tokenAddress, amount], nonce, deadline],
+        signature as Hex,
+      ],
+    })
+
+    return data
+  }
+
+  const data = encodeFunctionData({
+    abi: permit2ProxyAbi,
+    functionName: 'callDiamondWithPermit2',
+    args: [
+      transactionData,
+      [[tokenAddress, amount], nonce, deadline],
+      signature as Hex,
+    ],
+  })
+
+  return data
+}

package/src/core/EVM/{getNativePermit.ts → permits/getNativePermit.ts}

@@ -10,16 +10,9 @@ import {
 import type { Address, Client, Hex } from 'viem'
 import type { TypedDataDomain } from 'viem'
 import { multicall, readContract } from 'viem/actions'
-import { eip2612Abi } from './abi.js'
-import { getMulticallAddress } from './utils.js'
-
-export type NativePermitData = {
-  name: string
-  version: string
-  nonce: bigint
-  supported: boolean
-  domain: TypedDataDomain
-}
+import { eip2612Abi, eip2612Types } from '../abi.js'
+import { getMulticallAddress } from '../utils.js'
+import type { NativePermitData } from './types.js'
 
 /**
  * EIP-712 domain typehash with chainId
@@ -142,14 +135,6 @@ function validateDomainSeparator({
   }
 }
 
-const defaultPermit: NativePermitData = {
-  name: '',
-  version: '1',
-  nonce: 0n,
-  supported: false,
-  domain: {},
-}
-
 /**
  * Retrieves native permit data (EIP-2612) for a token on a specific chain
  * @link https://eips.ethereum.org/EIPS/eip-2612
@@ -161,8 +146,9 @@ const defaultPermit: NativePermitData = {
 export const getNativePermit = async (
   client: Client,
   chain: ExtendedChain,
-  tokenAddress: Address
-): Promise<NativePermitData> => {
+  tokenAddress: Address,
+  amount: bigint
+): Promise<NativePermitData | undefined> => {
   try {
     const multicallAddress = await getMulticallAddress(chain.id)
 
@@ -205,7 +191,7 @@ export const getNativePermit = async (
         !domainSeparatorResult.result ||
         noncesResult.result === undefined
       ) {
-        return defaultPermit
+        return undefined
       }
 
       const { isValid, domain } = validateDomainSeparator({
@@ -216,12 +202,22 @@ export const getNativePermit = async (
         domainSeparator: domainSeparatorResult.result,
       })
 
-      return {
-        name: nameResult.result,
-        version: versionResult.result ?? '1',
+      if (!isValid) {
+        return undefined
+      }
+
+      const values = {
+        owner: client.account!.address,
+        spender: chain.permit2Proxy as Address,
+        value: amount,
         nonce: noncesResult.result,
-        supported: isValid,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 30 * 60), // 30 minutes
+      }
+
+      return {
         domain,
+        types: eip2612Types,
+        values,
       }
     }
 
@@ -240,7 +236,7 @@ export const getNativePermit = async (
       domainSeparatorResult.status !== 'fulfilled' ||
       noncesResult.status !== 'fulfilled'
     ) {
-      return defaultPermit
+      return undefined
     }
 
     const name = nameResult.value
@@ -254,14 +250,24 @@ export const getNativePermit = async (
       domainSeparator: domainSeparatorResult.value,
     })
 
-    return {
-      name,
-      version,
+    if (!isValid) {
+      return undefined
+    }
+
+    const values = {
+      owner: client.account!.address,
+      spender: chain.permit2Proxy as Address,
+      value: amount,
       nonce: noncesResult.value,
-      supported: isValid,
+      deadline: BigInt(Math.floor(Date.now() / 1000) + 30 * 60), // 30 minutes
+    }
+
+    return {
       domain,
+      types: eip2612Types,
+      values,
     }
   } catch {
-    return defaultPermit
+    return undefined
   }
 }

package/src/core/EVM/permits/getPermitTransferFromValues.ts

@@ -0,0 +1,29 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { Address, Client } from 'viem'
+import { readContract } from 'viem/actions'
+import { permit2ProxyAbi } from '../abi.js'
+import type { PermitTransferFrom } from './signatureTransfer.js'
+
+export const getPermitTransferFromValues = async (
+  client: Client,
+  chain: ExtendedChain,
+  tokenAddress: Address,
+  amount: bigint
+): Promise<PermitTransferFrom> => {
+  const nonce = await readContract(client, {
+    address: chain.permit2Proxy as Address,
+    abi: permit2ProxyAbi,
+    functionName: 'nextNonce',
+    args: [client.account!.address],
+  })
+
+  return {
+    permitted: {
+      token: tokenAddress,
+      amount: amount,
+    },
+    spender: chain.permit2Proxy as Address,
+    nonce: nonce,
+    deadline: BigInt(Math.floor(Date.now() / 1000) + 30 * 60), // 30 minutes
+  }
+}

package/src/core/EVM/permits/signNativePermitMessage.ts

@@ -0,0 +1,27 @@
+import type {} from '@lifi/types'
+import type { Client } from 'viem'
+import { signTypedData } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import type { NativePermitData, NativePermitSignature } from './types.js'
+
+export const signNativePermitMessage = async (
+  client: Client,
+  permitData: NativePermitData
+): Promise<NativePermitSignature> => {
+  const signature = await getAction(
+    client,
+    signTypedData,
+    'signTypedData'
+  )({
+    account: client.account!,
+    domain: permitData.domain,
+    types: permitData.types,
+    primaryType: 'Permit',
+    message: permitData.values,
+  })
+
+  return {
+    signature,
+    values: permitData.values,
+  }
+}

package/src/core/EVM/permits/signPermit2Message.ts

@@ -0,0 +1,95 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { Address, Client, Hex } from 'viem'
+import { keccak256 } from 'viem'
+import { signTypedData } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import { getPermitTransferFromValues } from './getPermitTransferFromValues.js'
+import {
+  type PermitBatchTransferFrom,
+  type PermitBatchTransferFromData,
+  type PermitTransferFrom,
+  type PermitTransferFromData,
+  getPermitData,
+} from './signatureTransfer.js'
+import type { Permit2Signature } from './types.js'
+
+export interface SignPermit2MessageParams {
+  client: Client
+  chain: ExtendedChain
+  tokenAddress: Address
+  amount: bigint
+  data: Hex
+  witness?: boolean
+}
+
+export interface SignPermit2SingleParams extends SignPermit2MessageParams {
+  permitData?: PermitTransferFromData
+}
+
+export interface SignPermit2BatchParams extends SignPermit2MessageParams {
+  permitData?: PermitBatchTransferFromData
+}
+
+export function signPermit2Message(
+  params: SignPermit2SingleParams
+): Promise<Permit2Signature<PermitTransferFrom>>
+export function signPermit2Message(
+  params: SignPermit2BatchParams
+): Promise<Permit2Signature<PermitBatchTransferFrom>>
+export async function signPermit2Message(
+  params: SignPermit2SingleParams | SignPermit2BatchParams
+): Promise<Permit2Signature<PermitTransferFrom | PermitBatchTransferFrom>> {
+  const { client, chain, tokenAddress, amount, data, permitData, witness } =
+    params
+
+  let _permitData = permitData
+  if (!_permitData) {
+    const permitTransferFrom = await getPermitTransferFromValues(
+      client,
+      chain,
+      tokenAddress,
+      amount
+    )
+
+    // Create witness data for the LI.FI call
+    const _witness = witness
+      ? {
+          witness: {
+            diamondAddress: chain.diamondAddress as Address,
+            diamondCalldataHash: keccak256(data),
+          },
+          witnessTypeName: 'LiFiCall',
+          witnessType: {
+            LiFiCall: [
+              { name: 'diamondAddress', type: 'address' },
+              { name: 'diamondCalldataHash', type: 'bytes32' },
+            ],
+          },
+        }
+      : undefined
+
+    _permitData = getPermitData(
+      permitTransferFrom,
+      chain.permit2 as Address,
+      chain.id,
+      _witness
+    )
+  }
+
+  const signature = await getAction(
+    client,
+    signTypedData,
+    'signTypedData'
+  )({
+    account: client.account!,
+    primaryType: witness ? 'PermitWitnessTransferFrom' : 'PermitTransferFrom',
+    domain: _permitData.domain,
+    types: _permitData.types,
+    message: _permitData.values,
+  })
+
+  return {
+    signature,
+    values: _permitData.values,
+  }
+}

package/src/core/EVM/{permit2 → permits}/signatureTransfer.ts

@@ -8,25 +8,25 @@ import {
 } from './constants.js'
 import { permit2Domain } from './domain.js'
 
-export interface Witness {
+export type Witness = {
   witness: any
   witnessTypeName: string
-  witnessType: { [key: string]: { name: string; type: string }[] }
+  witnessType: Record<string, { name: string; type: string }[]>
 }
 
-export interface TokenPermissions {
+export type TokenPermissions = {
   token: Address
   amount: bigint
 }
 
-export interface PermitTransferFrom {
+export type PermitTransferFrom = {
   permitted: TokenPermissions
   spender: Address
   nonce: bigint
   deadline: bigint
 }
 
-export interface PermitBatchTransferFrom {
+export type PermitBatchTransferFrom = {
   permitted: TokenPermissions[]
   spender: Address
   nonce: bigint
@@ -154,6 +154,18 @@ export function getPermitBatchTransferData(
 
 // return the data to be sent in a eth_signTypedData RPC call
 // for signing the given permit data
+export function getPermitData<T extends PermitTransferFrom>(
+  permit: T,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+): PermitTransferFromData
+export function getPermitData<T extends PermitBatchTransferFrom>(
+  permit: T,
+  permit2Address: Address,
+  chainId: number,
+  witness?: Witness
+): PermitBatchTransferFromData
 export function getPermitData(
   permit: PermitTransferFrom | PermitBatchTransferFrom,
   permit2Address: Address,
@@ -166,8 +178,8 @@ export function getPermitData(
   return getPermitBatchTransferData(permit, permit2Address, chainId, witness)
 }
 
-export function hash(
-  permit: PermitTransferFrom | PermitBatchTransferFrom,
+export function hash<T extends PermitTransferFrom | PermitBatchTransferFrom>(
+  permit: T,
   permit2Address: Address,
   chainId: number,
   witness?: Witness

package/src/core/EVM/permits/types.ts

@@ -0,0 +1,33 @@
+import type { Address, Hash, TypedData, TypedDataDomain } from 'viem'
+import type {
+  PermitBatchTransferFrom,
+  PermitTransferFrom,
+} from './signatureTransfer.js'
+
+export type PermitSignature = {
+  signature: Hash
+}
+
+export type NativePermitValues = {
+  owner: Address
+  spender: Address
+  nonce: bigint
+  value: bigint
+  deadline: bigint
+}
+
+export type NativePermitData = {
+  domain: TypedDataDomain
+  types: TypedData
+  values: NativePermitValues
+}
+
+export type NativePermitSignature = PermitSignature & {
+  values: NativePermitValues
+}
+
+export type Permit2Signature<
+  T extends PermitTransferFrom | PermitBatchTransferFrom,
+> = PermitSignature & {
+  values: T
+}

package/src/core/EVM/permits/utils.ts

@@ -0,0 +1,40 @@
+import type { PermitTransferFromData } from './signatureTransfer.js'
+
+import type {
+  PermitData,
+  PermitValues,
+  PermitWitnessTransferFromValues,
+} from '@lifi/types'
+import type {} from './signatureTransfer.js'
+import type { NativePermitData } from './types.js'
+
+export const prettifyPermit2Data = (
+  permitData: PermitData<PermitWitnessTransferFromValues<string>>
+): PermitTransferFromData => {
+  return {
+    ...permitData,
+    values: {
+      ...permitData.values,
+      permitted: {
+        ...permitData.values.permitted,
+        amount: BigInt(permitData.values.permitted.amount),
+      },
+      nonce: BigInt(permitData.values.nonce),
+      deadline: BigInt(permitData.values.deadline),
+    },
+  }
+}
+
+export const prettifyNativePermitData = (
+  permitData: PermitData<PermitValues<string>>
+): NativePermitData => {
+  return {
+    ...permitData,
+    values: {
+      ...permitData.values,
+      value: BigInt(permitData.values.value),
+      nonce: BigInt(permitData.values.nonce),
+      deadline: BigInt(permitData.values.deadline),
+    },
+  }
+}

package/src/core/EVM/publicClient.ts

@@ -1,9 +1,10 @@
-import { ChainId } from '@lifi/types'
+import { ChainId, ChainType } from '@lifi/types'
 import type { Client } from 'viem'
 import { http, createClient, fallback, webSocket } from 'viem'
 import { type Chain, mainnet } from 'viem/chains'
 import { config } from '../../config.js'
 import { getRpcUrls } from '../rpc.js'
+import type { EVMProvider } from './types.js'
 
 // cached providers
 const publicClients: Record<number, Client> = {}
@@ -14,46 +15,48 @@ const publicClients: Record<number, Client> = {}
  * @returns The public client for the given chain
  */
 export const getPublicClient = async (chainId: number): Promise<Client> => {
-  if (!publicClients[chainId]) {
-    const urls = await getRpcUrls(chainId)
-    const fallbackTransports = urls.map((url) =>
-      url.startsWith('wss')
-        ? webSocket(url)
-        : http(url, {
-            batch: {
-              batchSize: 64,
-            },
-          })
-    )
-    const _chain = await config.getChainById(chainId)
-    const chain: Chain = {
-      ..._chain,
-      ..._chain.metamask,
-      name: _chain.metamask.chainName,
-      rpcUrls: {
-        default: { http: _chain.metamask.rpcUrls },
-        public: { http: _chain.metamask.rpcUrls },
-      },
-    }
-    // Add ENS contracts
-    if (chain.id === ChainId.ETH) {
-      chain.contracts = {
-        ...mainnet.contracts,
-        ...chain.contracts,
-      }
-    }
-    publicClients[chainId] = createClient({
-      chain: chain,
-      transport: fallback(fallbackTransports),
-      batch: {
-        multicall: true,
-      },
-    })
+  if (publicClients[chainId]) {
+    return publicClients[chainId]
   }
 
-  if (!publicClients[chainId]) {
-    throw new Error(`Unable to configure provider for chain ${chainId}`)
+  const urls = await getRpcUrls(chainId)
+  const fallbackTransports = urls.map((url) =>
+    url.startsWith('wss')
+      ? webSocket(url)
+      : http(url, {
+          batch: {
+            batchSize: 64,
+          },
+        })
+  )
+  const _chain = await config.getChainById(chainId)
+  const chain: Chain = {
+    ..._chain,
+    ..._chain.metamask,
+    name: _chain.metamask.chainName,
+    rpcUrls: {
+      default: { http: _chain.metamask.rpcUrls },
+      public: { http: _chain.metamask.rpcUrls },
+    },
+  }
+  // Add ENS contracts
+  if (chain.id === ChainId.ETH) {
+    chain.contracts = {
+      ...mainnet.contracts,
+      ...chain.contracts,
+    }
   }
+  const provider = config.getProvider(ChainType.EVM) as EVMProvider | undefined
+  publicClients[chainId] = createClient({
+    chain: chain,
+    transport: fallback(
+      fallbackTransports,
+      provider?.options?.fallbackTransportConfig
+    ),
+    batch: {
+      multicall: true,
+    },
+  })
 
   return publicClients[chainId]
 }

package/src/core/EVM/typeguards.ts

@@ -1,7 +1,10 @@
+import type { LiFiStep } from '@lifi/types'
 import type { LiFiStepExtended } from '../types.js'
 import type { EVMPermitStep } from './types.js'
 
-export function isRelayerStep(step: LiFiStepExtended): step is EVMPermitStep {
+export function isRelayerStep(
+  step: LiFiStepExtended | LiFiStep
+): step is EVMPermitStep {
   const evmStep = step as EVMPermitStep
-  return 'permit' in evmStep && 'permitData' in evmStep && 'witness' in evmStep
+  return 'permits' in evmStep && evmStep.permits?.length > 0
 }

package/src/core/EVM/types.ts

@@ -1,20 +1,18 @@
-import { type BaseToken, ChainType } from '@lifi/types'
-import type { Client } from 'viem'
+import { type BaseToken, ChainType, type Permit } from '@lifi/types'
+import type { Address, Client, FallbackTransportConfig, Hex } 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
+  fallbackTransportConfig?: FallbackTransportConfig
 }
 
 export interface EVMProvider extends SDKProvider {
+  options: EVMProviderOptions
   setOptions(options: EVMProviderOptions): void
+  getWalletClient?(): Promise<Client>
 }
 
 export function isEVM(provider: SDKProvider): provider is EVMProvider {
@@ -55,7 +53,14 @@ export interface RevokeApprovalRequest {
 }
 
 export interface EVMPermitStep extends LiFiStepExtended {
-  permit: PermitTransferFrom
-  permitData: PermitData
-  witness: Witness
+  permits: Permit[]
 }
+
+export type Call = {
+  to: Address
+  data?: Hex
+  value?: bigint
+  chainId?: number
+}
+
+export type TransactionMethodType = 'standard' | 'relayed' | 'batched'

package/src/core/EVM/waitForBatchTransactionReceipt.ts

@@ -28,11 +28,16 @@ export const waitForBatchTransactionReceipt = async (
         id: batchHash,
       })
 
-      if (callsDetails.status === 'PENDING') {
+      // EIP-5792 specs was updated to return 100 for pending transactions https://eips.ethereum.org/EIPS/eip-5792
+      if (
+        callsDetails.status === 'PENDING' ||
+        callsDetails.status === (100 as any)
+      ) {
         return undefined
       }
 
-      if (callsDetails.status === 'CONFIRMED') {
+      // EIP-5792 specs was updated to return 200 for confirmed transactions https://eips.ethereum.org/EIPS/eip-5792
+      if (callsDetails.status === 'CONFIRMED' || callsDetails.status === 200) {
         if (
           !callsDetails.receipts?.length ||
           !callsDetails.receipts.every((receipt) => receipt.transactionHash) ||