Permit & Permit2 Approval Flow

const quote = await fetch('https://li.quest/v1/quote?' + new URLSearchParams({
  fromChain: '42161',
  toChain: '10',
  fromToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC on Arbitrum
  toToken: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', // USDC on Optimism
  fromAmount: '10000000', // 10 USDC
  fromAddress: '0xYourWalletAddress',
})).then(r => r.json());

import { createPublicClient, createWalletClient, http, maxUint256, parseAbi } from 'viem';
import { arbitrum } from 'viem/chains';

const publicClient = createPublicClient({ chain: arbitrum, transport: http() });
const walletClient = createWalletClient({ chain: arbitrum, transport: http(), account });

const chainsResponse = await fetch('https://li.quest/v1/chains').then(r => r.json());
const fromChain = chainsResponse.chains.find((c) => c.id === quote.action.fromChainId);
const permit2Address = fromChain.permit2;
const permit2ProxyAddress = fromChain.permit2Proxy;

const erc20Abi = parseAbi([
  'function allowance(address owner, address spender) view returns (uint256)',
  'function approve(address spender, uint256 amount) returns (bool)',
]);

const tokenAddress = quote.action.fromToken.address;

const allowance = await publicClient.readContract({
  address: tokenAddress,
  abi: erc20Abi,
  functionName: 'allowance',
  args: [account.address, permit2Address],
});

if (allowance < BigInt(quote.action.fromAmount)) {
  const hash = await walletClient.writeContract({
    address: tokenAddress,
    abi: erc20Abi,
    functionName: 'approve',
    args: [permit2Address, maxUint256],
  });
  await publicClient.waitForTransactionReceipt({ hash });
}

const permit2ProxyAbi = parseAbi([
  'function nextNonce(address owner) view returns (uint256)',
  'function callDiamondWithPermit2(bytes diamondCalldata, ((address token, uint256 amount) permitted, uint256 nonce, uint256 deadline) permit, bytes signature) external',
]);

const nonce = await publicClient.readContract({
  address: permit2ProxyAddress,
  abi: permit2ProxyAbi,
  functionName: 'nextNonce',
  args: [account.address],
});

const deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60); // 30 minutes

const permitTransferFrom = {
  permitted: {
    token: tokenAddress,
    amount: BigInt(quote.action.fromAmount),
  },
  spender: permit2ProxyAddress,
  nonce,
  deadline,
};

const signature = await walletClient.signTypedData({
  account,
  primaryType: 'PermitTransferFrom',
  domain: {
    name: 'Permit2',
    chainId: arbitrum.id,
    verifyingContract: permit2Address,
  },
  types: {
    TokenPermissions: [
      { name: 'token', type: 'address' },
      { name: 'amount', type: 'uint256' },
    ],
    PermitTransferFrom: [
      { name: 'permitted', type: 'TokenPermissions' },
      { name: 'spender', type: 'address' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
    ],
  },
  message: permitTransferFrom,
});

import { encodeFunctionData } from 'viem';

const diamondCalldata = quote.transactionRequest.data;

const txData = encodeFunctionData({
  abi: permit2ProxyAbi,
  functionName: 'callDiamondWithPermit2',
  args: [
    diamondCalldata,
    [
      [permitTransferFrom.permitted.token, permitTransferFrom.permitted.amount],
      permitTransferFrom.nonce,
      permitTransferFrom.deadline,
    ],
    signature,
  ],
});

const txHash = await walletClient.sendTransaction({
  to: permit2ProxyAddress,
  data: txData,
  value: BigInt(quote.transactionRequest.value ?? 0),
  gasLimit: BigInt(quote.transactionRequest.gasLimit ?? 0),
});

const getStatus = async (txHash) => {
  const result = await fetch(`https://li.quest/v1/status?txHash=${txHash}`);
  return result.json();
};

let status;
do {
  status = await getStatus(txHash);
  if (status.status === 'PENDING') await new Promise(r => setTimeout(r, 5000));
} while (status.status !== 'DONE' && status.status !== 'FAILED');

const eip2612Abi = parseAbi([
  'function nonces(address owner) view returns (uint256)',
  'function name() view returns (string)',
  'function version() view returns (string)',
  'function DOMAIN_SEPARATOR() view returns (bytes32)',
]);

const [nonce, name, version] = await Promise.all([
  publicClient.readContract({
    address: tokenAddress, abi: eip2612Abi,
    functionName: 'nonces', args: [account.address],
  }),
  publicClient.readContract({
    address: tokenAddress, abi: eip2612Abi, functionName: 'name',
  }),
  publicClient.readContract({
    address: tokenAddress, abi: eip2612Abi, functionName: 'version',
  }),
]);

const deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60);

const permitSignature = await walletClient.signTypedData({
  account,
  primaryType: 'Permit',
  domain: {
    name,
    version,
    chainId: arbitrum.id,
    verifyingContract: tokenAddress,
  },
  types: {
    Permit: [
      { name: 'owner', type: 'address' },
      { name: 'spender', type: 'address' },
      { name: 'value', type: 'uint256' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
    ],
  },
  message: {
    owner: account.address,
    spender: permit2ProxyAddress,
    value: BigInt(quote.action.fromAmount),
    nonce,
    deadline,
  },
});

import { parseSignature, encodeFunctionData } from 'viem';

const { v, r, s } = parseSignature(permitSignature);

const permit2ProxyEip2612Abi = parseAbi([
  'function callDiamondWithEIP2612Signature(address tokenAddress, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s, bytes diamondCalldata) external payable',
]);

const txData = encodeFunctionData({
  abi: permit2ProxyEip2612Abi,
  functionName: 'callDiamondWithEIP2612Signature',
  args: [
    tokenAddress,
    BigInt(quote.action.fromAmount),
    deadline,
    Number(v),
    r,
    s,
    quote.transactionRequest.data,
  ],
});

const txHash = await walletClient.sendTransaction({
  to: permit2ProxyAddress,
  data: txData,
  value: BigInt(quote.transactionRequest.value ?? 0),
});