@lifi/sdk 3.4.2 → 3.5.0-beta.0

package/src/constants.ts

@@ -1,5 +1,10 @@
 export const AddressZero = '0x0000000000000000000000000000000000000000'
 export const AlternativeAddressZero =
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
-export const wrappedSolAddress = 'So11111111111111111111111111111111111111112'
+
 export const SolSystemProgram = '11111111111111111111111111111111'
+
+export const MaxUint48 = BigInt('0xffffffffffff')
+export const MaxUint160 = BigInt('0xffffffffffffffffffffffffffffffffffffffff')
+export const MaxUint256 =
+  BigInt(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn)

package/src/core/EVM/EVM.ts

@@ -12,9 +12,6 @@ export function EVM(options?: EVMProviderOptions): EVMProvider {
     get type() {
       return ChainType.EVM
     },
-    get multisig() {
-      return _options.multisig
-    },
     isAddress,
     resolveAddress: getENSAddress,
     getBalance: getEVMBalance,
@@ -29,7 +26,6 @@ export function EVM(options?: EVMProviderOptions): EVMProvider {
 
       const executor = new EVMStepExecutor({
         client: walletClient,
-        multisig: _options.multisig,
         routeId: options.routeId,
         executionOptions: {
           ...options.executionOptions,

package/src/core/EVM/EVMStepExecutor.ts

@@ -3,11 +3,19 @@ import type {
   FullStatusData,
   Process,
 } from '@lifi/types'
-import type { Client, Hash, SendTransactionParameters } from 'viem'
-import { getAddresses, sendTransaction } from 'viem/actions'
+import type {
+  Address,
+  Client,
+  Hash,
+  Hex,
+  SendTransactionParameters,
+  TransactionReceipt,
+} from 'viem'
+import { estimateGas, getAddresses, sendTransaction } from 'viem/actions'
+import { getCapabilities, sendCalls } from 'viem/experimental'
 import { config } from '../../config.js'
 import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError, ValidationError } from '../../errors/errors.js'
+import { TransactionError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
 import { getTransactionFailedMessage } from '../../utils/getTransactionMessage.js'
 import { isZeroAddress } from '../../utils/isZeroAddress.js'
@@ -22,33 +30,38 @@ import type {
 } from '../types.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { checkAllowance } from './checkAllowance.js'
-import { updateMultisigRouteProcess } from './multisig.js'
+import { getNativePermit } from './getNativePermit.js'
 import { parseEVMErrors } from './parseEVMErrors.js'
+import { signPermitMessage } from './signPermitMessage.js'
 import { switchChain } from './switchChain.js'
-import type { MultisigConfig, MultisigTransaction } from './types.js'
 import { getMaxPriorityFeePerGas } from './utils.js'
+import {
+  type WalletCallReceipt,
+  waitForBatchTransactionReceipt,
+} from './waitForBatchTransactionReceipt.js'
 import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
+export type Call = {
+  data?: Hex
+  to?: Address
+  value?: bigint
+  chainId?: number
+}
+
 export interface EVMStepExecutorOptions extends StepExecutorOptions {
   client: Client
-  multisig?: MultisigConfig
 }
 
 export class EVMStepExecutor extends BaseStepExecutor {
   private client: Client
-  private multisig?: MultisigConfig
 
   constructor(options: EVMStepExecutorOptions) {
     super(options)
     this.client = options.client
-    this.multisig = options.multisig
   }
 
   // Ensure that we are using the right chain and wallet when executing transactions.
-  checkClient = async (
-    step: LiFiStepExtended,
-    process?: Process
-  ): Promise<Client | undefined> => {
+  checkClient = async (step: LiFiStepExtended, process?: Process) => {
     const updatedClient = await switchChain(
       this.client,
       this.statusManager,
@@ -115,49 +128,81 @@ export class EVMStepExecutor extends BaseStepExecutor {
       }
     }
 
-    const isMultisigClient = !!this.multisig?.isMultisigWalletClient
-    const multisigBatchTransactions: MultisigTransaction[] = []
-
-    const shouldBatchTransactions =
-      this.multisig?.shouldBatchTransactions &&
-      !!this.multisig.sendBatchTransaction
-
     const fromChain = await config.getChainById(step.action.fromChainId)
     const toChain = await config.getChainById(step.action.toChainId)
 
+    let atomicBatchSupported = false
+    try {
+      const capabilities = await getCapabilities(this.client)
+      atomicBatchSupported = capabilities[fromChain.id]?.atomicBatch?.supported
+    } catch {
+      // If the wallet does not support getCapabilities, we assume that atomic batch is not supported
+    }
+
+    const calls: Call[] = []
+
     const isBridgeExecution = fromChain.id !== toChain.id
     const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
 
     // STEP 1: Check allowance
+    // Find existing swap/bridge process
     const existingProcess = step.execution.process.find(
       (p) => p.type === currentProcessType
     )
 
-    // Check token approval only if fromToken is not the native token => no approval needed in that case
+    // Check if token requires approval
+    // Native tokens (like ETH) don't need approval since they're not ERC20 tokens
+    // We should support different permit types:
+    // 1. Native permits (EIP-2612)
+    // 2. Permit2 - Universal permit implementation by Uniswap (limited to certain chains)
+    // 3. Standard ERC20 approval
+    const nativePermit = await getNativePermit(
+      this.client,
+      fromChain,
+      step.action.fromToken.address as Address
+    )
+    // Check if proxy contract is available and token supports native permits, not available for atomic batch
+    const nativePermitSupported =
+      !!fromChain.permit2Proxy &&
+      nativePermit.supported &&
+      !atomicBatchSupported
+    // Check if chain has Permit2 contract deployed. Permit2 should not be available for atomic batch.
+    const permit2Supported =
+      !!fromChain.permit2 && !!fromChain.permit2Proxy && !atomicBatchSupported
+    // Token supports either native permits or Permit2
+    const permitSupported = permit2Supported || nativePermitSupported
+
     const checkForAllowance =
+      // No existing swap/bridgetransaction is pending
       !existingProcess?.txHash &&
+      // Token is not native (address is not zero)
       !isZeroAddress(step.action.fromToken.address) &&
-      (shouldBatchTransactions || !isMultisigClient)
+      // Token doesn't support native permits
+      !nativePermitSupported
 
     if (checkForAllowance) {
-      const data = await checkAllowance(
-        this.client,
-        fromChain,
+      // Check if token needs approval and get approval transaction or message data when available
+      const data = await checkAllowance({
+        client: this.client,
+        chain: fromChain,
         step,
-        this.statusManager,
-        this.executionOptions,
-        this.allowUserInteraction,
-        shouldBatchTransactions
-      )
+        statusManager: this.statusManager,
+        executionOptions: this.executionOptions,
+        allowUserInteraction: this.allowUserInteraction,
+        atomicBatchSupported,
+        permit2Supported,
+      })
 
       if (data) {
-        // allowance doesn't need value
-        const baseTransaction: MultisigTransaction = {
-          to: step.action.fromToken.address,
-          data,
+        // Create approval transaction call
+        // No value needed since we're only approving ERC20 tokens
+        if (atomicBatchSupported) {
+          calls.push({
+            chainId: step.action.fromToken.chainId,
+            to: step.action.fromToken.address as Address,
+            data,
+          })
         }
-
-        multisigBatchTransactions.push(baseTransaction)
       }
     }
 
@@ -169,28 +214,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
     })
 
     if (process.status !== 'DONE') {
-      const multisigProcess = step.execution.process.find(
-        (p) => !!p.multisigTxHash
-      )
-
       try {
-        if (isMultisigClient && multisigProcess) {
-          const multisigTxHash = multisigProcess.multisigTxHash as Hash
-          if (!multisigTxHash) {
-            throw new ValidationError(
-              'Multisig internal transaction hash is undefined.'
-            )
-          }
-          await updateMultisigRouteProcess(
-            multisigTxHash,
-            step,
-            process.type,
-            fromChain,
-            this.statusManager,
-            this.multisig
-          )
-        }
-
         let txHash: Hash
         if (process.txHash) {
           // Make sure that the chain is still correct
@@ -211,7 +235,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
           // Check balance
           await checkBalance(this.client.account!.address, step)
 
-          // Create new transaction
+          // Create new transaction request
           if (!step.transactionRequest) {
             const { execution, ...stepBase } = step
             const updatedStep = await getStepTransaction(stepBase)
@@ -235,23 +259,6 @@ export class EVMStepExecutor extends BaseStepExecutor {
             )
           }
 
-          // STEP 3: Send the transaction
-          // Make sure that the chain is still correct
-          const updatedClient = await this.checkClient(step, process)
-          if (!updatedClient) {
-            return step
-          }
-
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            'ACTION_REQUIRED'
-          )
-
-          if (!this.allowUserInteraction) {
-            return step
-          }
-
           let transactionRequest: TransactionParameters = {
             to: step.transactionRequest.to,
             from: step.transactionRequest.from,
@@ -289,25 +296,71 @@ export class EVMStepExecutor extends BaseStepExecutor {
             }
           }
 
-          if (shouldBatchTransactions && this.multisig?.sendBatchTransaction) {
-            if (transactionRequest.to && transactionRequest.data) {
-              const populatedTransaction: MultisigTransaction = {
-                value: transactionRequest.value,
-                to: transactionRequest.to,
-                data: transactionRequest.data,
-              }
-              multisigBatchTransactions.push(populatedTransaction)
+          // STEP 3: Send the transaction
+          // Make sure that the chain is still correct
+          const updatedClient = await this.checkClient(step, process)
+          if (!updatedClient) {
+            return step
+          }
+
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            permitSupported ? 'PERMIT_REQUIRED' : 'ACTION_REQUIRED'
+          )
+
+          if (!this.allowUserInteraction) {
+            return step
+          }
+
+          if (atomicBatchSupported) {
+            const transferCall: Call = {
+              chainId: fromChain.id,
+              data: transactionRequest.data as Hex,
+              to: transactionRequest.to as Address,
+              value: transactionRequest.value,
+            }
+
+            calls.push(transferCall)
 
-              txHash = await this.multisig?.sendBatchTransaction(
-                multisigBatchTransactions
+            txHash = (await sendCalls(this.client, {
+              account: this.client.account!,
+              calls,
+            })) as Address
+          } else {
+            if (permitSupported) {
+              const { data } = await signPermitMessage(
+                this.client,
+                transactionRequest,
+                fromChain,
+                step.action.fromToken.address as Address,
+                BigInt(step.action.fromAmount),
+                nativePermit
               )
-            } else {
-              throw new TransactionError(
-                LiFiErrorCode.TransactionUnprepared,
-                'Unable to prepare transaction.'
+
+              transactionRequest.to = fromChain.permit2Proxy
+              transactionRequest.data = data
+
+              try {
+                // Try to re-estimate the gas due to additional Permit data
+                transactionRequest.gas = await estimateGas(this.client, {
+                  account: this.client.account!,
+                  to: transactionRequest.to as Address,
+                  data: transactionRequest.data as Hex,
+                  value: transactionRequest.value,
+                })
+              } catch {
+                // Let the wallet estimate the gas in case of failure
+                transactionRequest.gas = undefined
+              }
+
+              process = this.statusManager.updateProcess(
+                step,
+                process.type,
+                'ACTION_REQUIRED'
               )
             }
-          } else {
+
             txHash = await sendTransaction(this.client, {
               to: transactionRequest.to,
               account: this.client.account!,
@@ -317,62 +370,53 @@ export class EVMStepExecutor extends BaseStepExecutor {
               gasPrice: transactionRequest.gasPrice,
               maxFeePerGas: transactionRequest.maxFeePerGas,
               maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-              chain: null,
             } as SendTransactionParameters)
           }
 
           // STEP 4: Wait for the transaction
-          if (isMultisigClient) {
-            process = this.statusManager.updateProcess(
-              step,
-              process.type,
-              'ACTION_REQUIRED',
-              {
-                multisigTxHash: txHash,
-              }
-            )
-          } else {
-            process = this.statusManager.updateProcess(
-              step,
-              process.type,
-              'PENDING',
-              {
-                txHash: txHash,
-                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-              }
-            )
-          }
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'PENDING',
+            // When atomic batch is supported, txHash represents the batch hash rather than an individual transaction hash at this point
+            atomicBatchSupported
+              ? {
+                  atomicBatchSupported,
+                }
+              : {
+                  txHash: txHash,
+                  txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+                }
+          )
         }
 
-        const transactionReceipt = await waitForTransactionReceipt({
-          client: this.client,
-          chainId: fromChain.id,
-          txHash,
-          onReplaced: (response) => {
-            this.statusManager.updateProcess(step, process.type, 'PENDING', {
-              txHash: response.transaction.hash,
-              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
-            })
-          },
-        })
+        let transactionReceipt:
+          | TransactionReceipt
+          | WalletCallReceipt
+          | undefined
 
-        // if it's multisig wallet client and the process is in ACTION_REQUIRED
-        // then signatures are still needed
-        if (isMultisigClient && process.status === 'ACTION_REQUIRED') {
-          await updateMultisigRouteProcess(
-            transactionReceipt?.transactionHash || txHash,
-            step,
-            process.type,
-            fromChain,
-            this.statusManager,
-            this.multisig
+        if (atomicBatchSupported) {
+          transactionReceipt = await waitForBatchTransactionReceipt(
+            this.client,
+            txHash
           )
+        } else {
+          transactionReceipt = await waitForTransactionReceipt({
+            client: this.client,
+            chainId: fromChain.id,
+            txHash,
+            onReplaced: (response) => {
+              this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                txHash: response.transaction.hash,
+                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+              })
+            },
+          })
         }
 
         // Update pending process if the transaction hash from the receipt is different.
         // This might happen if the transaction was replaced.
         if (
-          !isMultisigClient &&
           transactionReceipt?.transactionHash &&
           transactionReceipt.transactionHash !== txHash
         ) {
@@ -419,13 +463,12 @@ export class EVMStepExecutor extends BaseStepExecutor {
         chainId: toChain.id,
       })
     }
-    let statusResponse: FullStatusData
 
     try {
       if (!processTxHash) {
         throw new Error('Transaction hash is undefined.')
       }
-      statusResponse = (await waitForReceivingTransaction(
+      const statusResponse = (await waitForReceivingTransaction(
         processTxHash,
         this.statusManager,
         process.type,

package/src/core/EVM/abi.ts

@@ -1,47 +1,44 @@
-import type { Abi } from 'viem'
+import { parseAbi } from 'viem'
 
-export const approveAbi: Abi = [
-  {
-    name: 'approve',
-    inputs: [
-      { internalType: 'address', name: 'spender', type: 'address' },
-      { internalType: 'uint256', name: 'amount', type: 'uint256' },
-    ],
-    outputs: [{ internalType: 'bool', name: 'approved', type: 'bool' }],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-]
+export const permit2ProxyAbi = parseAbi([
+  'function callDiamondWithPermit2(bytes, ((address, uint256), uint256, uint256), bytes) external',
+  'function callDiamondWithEIP2612Signature(address, uint256, uint256, uint8, bytes32, bytes32, bytes) external payable',
+  'function nextNonce(address) external view returns (uint256)',
+  'function callDiamondWithPermit2Witness(bytes, address, ((address, uint256), uint256, uint256), bytes) external payable',
+])
 
-export const allowanceAbi: Abi = [
-  {
-    name: 'allowance',
-    inputs: [
-      { internalType: 'address', name: 'owner', type: 'address' },
-      { internalType: 'address', name: 'spender', type: 'address' },
-    ],
-    outputs: [{ internalType: 'uint256', name: 'allowance', type: 'uint256' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-]
+export const eip2612Abi = parseAbi([
+  'function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) external',
+  'function DOMAIN_SEPARATOR() external view returns (bytes32)',
+  'function nonces(address) external view returns (uint256)',
+  'function name() external view returns (string)',
+  'function version() external view returns (string)',
+])
 
-export const getEthBalanceAbi: Abi = [
-  {
-    inputs: [{ name: '_owner', type: 'address' }],
-    name: 'getEthBalance',
-    outputs: [{ name: 'balance', type: 'uint256' }],
-    type: 'function',
-    stateMutability: 'view',
-  },
-]
+export const approveAbi = parseAbi([
+  'function approve(address, uint256) external returns (bool)',
+])
 
-export const balanceOfAbi: Abi = [
-  {
-    inputs: [{ name: '_owner', type: 'address' }],
-    name: 'balanceOf',
-    outputs: [{ name: 'balance', type: 'uint256' }],
-    type: 'function',
-    stateMutability: 'view',
-  },
-]
+export const allowanceAbi = parseAbi([
+  'function allowance(address, address) external view returns (uint256)',
+])
+
+export const getEthBalanceAbi = parseAbi([
+  'function getEthBalance(address) external view returns (uint256)',
+])
+
+export const balanceOfAbi = parseAbi([
+  'function balanceOf(address) external view returns (uint256)',
+])
+
+// EIP-2612 types
+// https://eips.ethereum.org/EIPS/eip-2612
+export const eip2612Types = {
+  Permit: [
+    { name: 'owner', type: 'address' },
+    { name: 'spender', type: 'address' },
+    { name: 'value', type: 'uint256' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+  ],
+} as const