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

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

@@ -1,168 +0,0 @@
-import {
-  type Address,
-  type TypedData,
-  type TypedDataDomain,
-  hashTypedData,
-} from 'viem'
-import { MaxUint48, MaxUint160 } from '../../../constants.js'
-import { invariant } from '../../../utils/invariant.js'
-import { MaxSigDeadline } from './constants.js'
-import { permit2Domain } from './domain.js'
-
-export const MaxAllowanceTransferAmount = MaxUint160
-export const MaxAllowanceExpiration = MaxUint48
-export const MaxOrderedNonce = MaxUint48
-
-export interface PermitDetails {
-  token: Address
-  amount: bigint
-  expiration: number
-  nonce: number
-}
-
-export interface PermitSingle {
-  details: PermitDetails
-  spender: Address
-  sigDeadline: bigint
-}
-
-export interface PermitBatch {
-  details: PermitDetails[]
-  spender: Address
-  sigDeadline: bigint
-}
-
-export type PermitSingleData = {
-  domain: TypedDataDomain
-  types: TypedData
-  values: PermitSingle
-}
-
-export type PermitBatchData = {
-  domain: TypedDataDomain
-  types: TypedData
-  values: PermitBatch
-}
-
-const PERMIT_DETAILS = [
-  { name: 'token', type: 'address' },
-  { name: 'amount', type: 'uint160' },
-  { name: 'expiration', type: 'uint48' },
-  { name: 'nonce', type: 'uint48' },
-] as const
-
-const PERMIT_TYPES = {
-  PermitDetails: PERMIT_DETAILS,
-  PermitSingle: [
-    { name: 'details', type: 'PermitDetails' },
-    { name: 'spender', type: 'address' },
-    { name: 'sigDeadline', type: 'uint256' },
-  ],
-} as const
-
-const PERMIT_BATCH_TYPES = {
-  PermitDetails: PERMIT_DETAILS,
-  PermitBatch: [
-    { name: 'details', type: 'PermitDetails[]' },
-    { name: 'spender', type: 'address' },
-    { name: 'sigDeadline', type: 'uint256' },
-  ],
-} as const
-
-function isPermit(permit: PermitSingle | PermitBatch): permit is PermitSingle {
-  return !Array.isArray(permit.details)
-}
-
-export function getPermitSingleData(
-  permit: PermitSingle,
-  permit2Address: Address,
-  chainId: number
-) {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  validatePermitDetails(permit.details)
-
-  return {
-    domain,
-    values: permit,
-  }
-}
-
-export function getPermitBatchData(
-  permit: PermitBatch,
-  permit2Address: Address,
-  chainId: number
-) {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  permit.details.forEach(validatePermitDetails)
-
-  return {
-    domain,
-    values: permit,
-  }
-}
-
-export function getPermitData(
-  permit: PermitSingle | PermitBatch,
-  permit2Address: Address,
-  chainId: number
-): PermitSingleData | PermitBatchData {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  if (isPermit(permit)) {
-    validatePermitDetails(permit.details)
-    return {
-      domain,
-      types: PERMIT_TYPES,
-      values: permit,
-    }
-  }
-  permit.details.forEach(validatePermitDetails)
-  return {
-    domain,
-    types: PERMIT_BATCH_TYPES,
-    values: permit,
-  }
-}
-
-export function hash(
-  permit: PermitSingle | PermitBatch,
-  permit2Address: Address,
-  chainId: number
-): string {
-  if (isPermit(permit)) {
-    const { domain, values } = getPermitSingleData(
-      permit,
-      permit2Address,
-      chainId
-    )
-
-    return hashTypedData({
-      domain,
-      types: PERMIT_TYPES,
-      primaryType: 'PermitSingle',
-      message: values,
-    })
-  }
-  const { domain, values } = getPermitBatchData(permit, permit2Address, chainId)
-
-  return hashTypedData({
-    domain,
-    types: PERMIT_BATCH_TYPES,
-    primaryType: 'PermitBatch',
-    message: values,
-  })
-}
-
-function validatePermitDetails(details: PermitDetails) {
-  invariant(MaxOrderedNonce >= details.nonce, 'NONCE_OUT_OF_RANGE')
-  invariant(MaxAllowanceTransferAmount >= details.amount, 'AMOUNT_OUT_OF_RANGE')
-  invariant(
-    MaxAllowanceExpiration >= details.expiration,
-    'EXPIRATION_OUT_OF_RANGE'
-  )
-}

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

@@ -1,11 +0,0 @@
-import { MaxUint48, MaxUint160, MaxUint256 } from '../../../constants.js'
-
-export const MaxAllowanceTransferAmount = MaxUint160
-export const MaxAllowanceExpiration = MaxUint48
-export const MaxOrderedNonce = MaxUint48
-
-export const MaxSignatureTransferAmount = MaxUint256
-export const MaxUnorderedNonce = MaxUint256
-export const MaxSigDeadline = MaxUint256
-
-export const InstantExpiration = 0n

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

@@ -1,20 +0,0 @@
-import type { Address, TypedData, TypedDataDomain } from 'viem'
-
-const PERMIT2_DOMAIN_NAME = 'Permit2'
-
-export function permit2Domain(
-  permit2Address: Address,
-  chainId: number
-): TypedDataDomain {
-  return {
-    name: PERMIT2_DOMAIN_NAME,
-    chainId,
-    verifyingContract: permit2Address,
-  }
-}
-
-export type PermitData = {
-  domain: TypedDataDomain
-  types: TypedData
-  values: any
-}

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

@@ -1,214 +0,0 @@
-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/signPermitMessage.ts

@@ -1,248 +0,0 @@
-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/waitForBatchTransactionReceipt.ts

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