Bridge & Swap with Li.Fi

tradeAsset(
  params: LifiTradeAssetParams,
  options?: LifiTradeAssetOptions,
): Promise<LifiTradeAssetResult>

import Portal from '@portal-hq/web'
import type { LifiTradeAssetParams, LifiTradeAssetOptions } from '@portal-hq/web'

const portal = new Portal({
  apiKey: 'YOUR_PORTAL_CLIENT_API_KEY',
  rpcConfig: {
    'eip155:8453': 'https://YOUR_RPC_URL',
    'eip155:42161': 'https://YOUR_RPC_URL',
  },
})

async function runTrade() {
  const fromAddress = await portal.getEip155Address()
  if (!fromAddress) throw new Error('No EVM address')

  const params: LifiTradeAssetParams = {
    fromChain: 'eip155:8453',
    toChain: 'eip155:42161',
    fromToken: 'ETH',
    toToken: 'USDC',
    amount: '1000000000000',
    fromAddress,
    statusPoll: {
      everyMs: 10_000,
      initialDelayMs: 10_000,
      timeoutMs: 600_000,
    },
    onProgress: (status, data) => {
      console.log('[Li.Fi]', status, data?.txHash ?? '')
    },
  }

  const options: LifiTradeAssetOptions = {
    waitForConfirmation: async (txHash, network) => {
      return portal.waitForConfirmation(txHash, network)
    },
    evmPollerOptions: { pollIntervalMs: 4_000, timeoutMs: 600_000 },
  }

  try {
    const result = await portal.trading.lifi.tradeAsset(params, options)
    console.log('Hashes:', result.hashes)
    console.log('Executed steps:', result.steps.length)
    console.log('Route id:', result.route.id)
    return result
  } catch (e) {
    console.error('tradeAsset failed', e)
    throw e
  }
}

const result = await portal.trading.lifi.tradeAsset({
  fromChain: 'eip155:8453',
  toChain: 'eip155:42161',
  fromToken: 'ETH',
  toToken: 'USDC',
  amount: '1000000000000',
  fromAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
})

import Portal from '@portal-hq/web'

async function pollTransferStatus(portal: Portal, txHash: string) {
  const terminal = await portal.trading.lifi.pollStatus(
    {
      txHash,
      fromChain: 'eip155:8453',
      toChain: 'eip155:42161',
    },
    {
      onUpdate: (statusUpdate) => {
        console.log('Status:', statusUpdate.status)
        return true
      },
      everyMs: 10_000,
      timeoutMs: 600_000,
    },
  )

  console.log('Final status:', terminal.status)
}

const address = await portal.getEip155Address();
if (!address) return;

const request = {
  fromChain: 'eip155:8453', // Base Mainnet
  toChain: 'eip155:42161', // Arbitrum
  fromToken: 'ETH',
  toToken: 'USDC',
  fromAddress: address,
  fromAmount: '100000000000000', // 0.0001 ETH (in wei)
};

const response = await portal.trading.lifi.getQuote(request);
const rawResponse = response.data?.rawResponse;

if (rawResponse) {
  // Process quote response
  // You can sign and submit the transaction if transactionRequest is available
  if (rawResponse.transactionRequest) {
    await executeTransaction(rawResponse.transactionRequest, request.fromChain);
  }
}

const address = await portal.getEip155Address();
if (!address) return;

const request = {
  fromChainId: 'eip155:8453', // Base Mainnet
  fromAmount: '100000000000000', // 0.0001 ETH (in wei)
  fromTokenAddress: 'ETH',
  toChainId: 'eip155:42161', // Arbitrum
  toTokenAddress: 'USDC',
  fromAddress: address,
};

const response = await portal.trading.lifi.getRoutes(request);
const rawResponse = response.data?.rawResponse;

if (rawResponse) {
  const routes = rawResponse.routes;

  // Find recommended route
  const recommendedRoute = routes.find(route => route.tags?.includes('RECOMMENDED')) || routes[0];

  if (recommendedRoute) {
    console.log('Selected route:', recommendedRoute.id);
    console.log('Steps:', recommendedRoute.steps.length);
    console.log('From:', recommendedRoute.fromAmountUSD, 'USD');
    console.log('To:', recommendedRoute.toAmountUSD, 'USD');

    // Process route steps
    await processRouteSteps(recommendedRoute.steps, request.fromChainId);
  }
}

async function getStepTransactionDetails(step: LifiStep): Promise<LifiStep | null> {
  try {
    const response = await portal.trading.lifi.getRouteStep(step);
    return response.data?.rawResponse || null;
  } catch (error) {
    console.error('Error getting step details:', error.message);
    return null;
  }
}

const NATIVE_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000';

async function approveErc20IfNeeded(
  quote: LifiQuoteResponse,
  fromAmount: string,
  fromChainId: string,
): Promise<void> {
  const action = quote.data?.rawResponse?.action;
  const estimate = quote.data?.rawResponse?.estimate;
  if (!action || !estimate) return;

  const fromToken = action.fromToken;
  if (!fromToken || fromToken.address === NATIVE_TOKEN_ADDRESS) {
    // Native asset — no approval needed.
    return;
  }

  // Convert the raw fromAmount into the token's primary denomination
  // (e.g. raw "10000" with 6 decimals → "0.01"). Use a string-aware
  // conversion to preserve precision for large values.
  const amount = formatUnits(fromAmount, fromToken.decimals); // e.g. ethers.formatUnits or viem.formatUnits

  const { transactions } = await portal.delegations.approve({
    chain: fromChainId,
    token: fromToken.address,
    delegateAddress: estimate.approvalAddress,
    amount,
  });

  for (const tx of transactions) {
    const sendResponse = await portal.request({
      chainId: fromChainId,
      method: 'eth_sendTransaction',
      params: [tx],
    });
    const txHash = sendResponse.result as string;
    if (txHash) {
      await waitForConfirmation(txHash, fromChainId);
    }
  }
}

async function executeTransaction(transactionRequest: LifiTransactionRequest, chainId: string) {
  try {
    const from = transactionRequest.from;
    const to = transactionRequest.to;

    if (!from || !to) {
      console.error("Missing required 'from' or 'to' field");
      return;
    }

    // Extract value. Default: 0x0
    const value = transactionRequest.value || '0x0';

    // Extract data
    const data = transactionRequest.data || '';

    // Create transaction
    const ethTransaction = {
      from,
      to,
      value,
      data,
      // Let Portal handle gas estimation
    };

    // Sign and send
    const txHash = await portal.request({
      chainId,
      method: 'eth_sendTransaction',
      params: [ethTransaction],
    })
    if (txHash) {
      console.log('Transaction submitted:', txHash);

      // Wait for on-chain confirmation (throws on failure)
      await waitForConfirmation(txHash, chainId);
      console.log('Transaction confirmed');
    }
  } catch (error) {
    console.error('Error executing transaction:', error.message);
  }
}

async function processRouteSteps(steps: LifiStep[], fromChainId: string): Promise<boolean> {
  for (let index = 0; index < steps.length; index++) {
    const step = steps[index];
    console.log(`Processing step ${index + 1}/${steps.length}: ${step.tool}`);

    // 1. Get transaction details for this step
    const stepWithTx = await getStepTransactionDetails(step);
    const transactionRequest = stepWithTx?.transactionRequest;

    if (!transactionRequest) {
      console.error(`Failed to get transaction details for step ${index + 1}`);
      return false;
    }

    // 2. Sign and submit the transaction
    await executeTransaction(transactionRequest, fromChainId);

    console.log(`Step ${index + 1} completed`);
  }

  return true;
}

async function waitForConfirmation(
  txHash: string,
  chainId: string,
  desiredConfirmations: number = 2,
  pollIntervalMs: number = 2000,
  timeoutSeconds: number = 600
): Promise<boolean> {
  const startTime = Date.now();
  let minedBlock = null; // will be set once mined
  let confirmations = 0;

  while (true) {
    if (timeoutSeconds && (Date.now() - startTime) / 1000 > timeoutSeconds) {
      throw new Error(`Timeout waiting for ${desiredConfirmations} confirmations`);
    }

    try {
      if (!minedBlock) {
        const receiptRes = await axios.post(
          getRpcUrl(chainId), // Create a method to obtain the RPC URL for the network of the Li.Fi transaction step
          {
            jsonrpc: '2.0',
            id: 1,
            method: getRpcReceiptMethod(chainId), // i.e. 'eth_getTransactionReceipt' for non-abstracted eth accounts
            params: [txHash],
          }
        );

        const receipt = receiptRes.data.result; // If the account is abstracted, it should be receiptRes?.data?.result?.receipt.

        if (!receipt) {
          await new Promise(r => setTimeout(r, pollIntervalMs));
          continue;
        }

        // For Ethereum-based chains, check if the transaction failed by checking: receipt.status === '0x0'
        if (checkIfStatusFailed(receipt, chainId)) {
          throw new Error(`Transaction ${txHash} reverted`);
        }

        minedBlock = parseInt(receipt.blockNumber, 16);
        // fall through to Phase 2 on the same loop iteration if possible
      }

      // Phase 2: already mined → now we only need latest block number
      const latestBlockRes = await axios.post(
        getRpcUrl(chainId), // Create a method to obtain the RPC URL for the network of the Li.Fi step transaction
        {
          jsonrpc: '2.0',
          id: 2,
          method: getRpcLatestBlockMethod(chainId),
          params: [],
        }
      );

      /*
       * If on eth, then the getConfirmations function would do this:
       *   const latestBlock = parseInt(latestBlockRes.data.result, 16)
       *   return latestBlock - minedBlock + 1
       */
      confirmations = getConfirmations(latestBlockRes, minedBlock);

      if (confirmations >= desiredConfirmations) {
        return true;
      }
    } catch (err) {
      console.error('Polling error:', err.message);
    }

    await new Promise(r => setTimeout(r, pollIntervalMs));
  }
}

async function trackLiFiStatus(txHash: string, fromChain: string) {
  const request = {
    txHash,
    fromChain,
  };

  try {
    const response = await portal.trading.lifi.getStatus(request);
    const rawResponse = response.data?.rawResponse;

    if (rawResponse) {
      console.log('Status:', rawResponse.status);

      if (rawResponse.transactionId) {
        console.log('Transaction ID:', rawResponse.transactionId);
      }

      if (rawResponse.lifiExplorerLink) {
        console.log('Explorer:', rawResponse.lifiExplorerLink);
      }

      // Check if complete
      switch (rawResponse.status) {
        case 'DONE':
          console.log('Transfer completed successfully!');
          break;
        case 'FAILED':
          console.error('Transfer failed');
          break;
        default:
          console.log('Transfer in progress...');
      }
    }
  } catch (error) {
    console.error('Error getting status:', error.message);
  }
}

async function pollForCompletion(
  txHash: string,
  fromChain: string,
  maxAttempts: number = 300,
  pollIntervalMs: number = 2000
): Promise<boolean> {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      const request = {
        txHash,
        fromChain,
      };

      const response = await portal.trading.lifi.getStatus(request);
      const rawResponse = response.data?.rawResponse;

      if (rawResponse) {
        console.log(`Polling (${attempt + 1}/${maxAttempts}): ${rawResponse.status}`);

        switch (rawResponse.status) {
          case 'DONE':
            return true;
          case 'FAILED':
            return false;
          default:
            // Continue polling
            break;
        }
      }
    } catch (error) {
      // Continue polling on error
      console.error('There was an error in a polling intent:', error);
    }

    await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
  }

  return false; // Timeout
}

// 1. Get user address
const userAddress = await portal.getEip155Address();
if (!userAddress) return;

// 2. Get a quote
const quoteRequest = {
  fromChain: 'eip155:8453', // Base Mainnet
  toChain: 'eip155:42161', // Arbitrum
  fromToken: 'ETH',
  toToken: 'USDC',
  fromAddress: userAddress,
  fromAmount: '100000000000000', // 0.0001 ETH (in wei)
};

const quoteResponse = await portal.trading.lifi.getQuote(quoteRequest);

let txHash: string | null = null;

const quote = quoteResponse.data?.rawResponse;
const transactionRequest = quote?.transactionRequest;

if (!transactionRequest) {
  console.error('No quote available');
  return;
}

// 3. Approve the fromToken if it's an ERC-20 (no-op for native assets)
await approveErc20IfNeeded(quoteResponse, quoteRequest.fromAmount, quoteRequest.fromChain);

// 4. Extract transaction parameters
const from = transactionRequest.from;
const to = transactionRequest.to;

if (!from || !to) {
  console.error('Missing required fields');
  return;
}

const value = transactionRequest.value || '0x0';
const data = transactionRequest.data || '';

// 5. Sign and submit the transaction
const ethTransaction = {
  from,
  to,
  value,
  data,
};

txHash = await portal.request({
  chainId: quoteRequest.fromChain,
  method: 'eth_sendTransaction',
  params: [ethTransaction],
})

if (!txHash) {
  console.error('Failed to submit transaction');
  return;
}

console.log('Transaction submitted:', txHash);

// 6. Track status for cross-chain completion
if (txHash) {
  const completed = await pollForCompletion(txHash, quoteRequest.fromChain);

  if (completed) {
    console.log('Bridge completed successfully!');
  } else {
    console.error('Bridge failed or timed out');
  }
}