Use Turnkey wallets with Li.Fi

npm install @turnkey/react-wallet-kit @turnkey/viem @turnkey/solana viem wagmi @solana/web3.js

"use client";

import { useTurnkey, WalletAccount } from "@turnkey/react-wallet-kit";
import { TurnkeySigner } from "@turnkey/solana";
import { createAccount } from "@turnkey/viem";
import { createWalletClient } from "viem";

// public providers, you might want to use a dedicated provider like alchemy or infura in production
const ETH_MAINNET_RPC_PROVIDER = "https://ethereum-rpc.publicnode.com";
const SOL_MAINNET_RPC_PROVIDER = "https://solana-rpc.publicnode.com";

export default function SwapPage() {
  const { httpClient, session, fetchWalletAccounts, wallets } = useTurnkey();
  const [viemWalletClient, setViemWalletClient] = useState<WalletClient | undefined>(undefined);

  // obtain a users turnkey wallets
  const walletAccountResponse = await fetchWalletAccounts({
    wallet: wallets[0],
  });

  // create a viem account with the turnkey wallet
  const turnkeyViemAccount = await createAccount({
    client: httpClient!,
    organizationId: walletAccountResponse[0].organizationId,
    signWith: walletAccountResponse[0].address,
    ethereumAddress: walletAccountResponse[0].address,
  });

  // create a viem wallet client to sign EVM transactions
  const viemWalletClient = createWalletClient({
    account: turnkeyAccount as Account,
    chain: mainnet,
    transport: http(MAINNET_RPC_PROVIDER),
  })

  // create a solana signer to sign SOL transactions
  const turnkeySolSigner = new TurnkeySigner({
    organizationId: walletAccountResponse[0].organizationId,
    client: httpClient!,
  });

  // Render your login/logout and account selector UI here
}

"use server";

export interface QuoteParams {
  fromChain: string;
  toChain: string;
  fromToken: string;
  toToken: string;
  fromAmount: string;
  fromAddress: string;
  toAddress: string;
}

export interface StatusParams {
  txHash: string;
}

export async function getQuote(quoteParams: QuoteParams) {
  const params = new URLSearchParams({
    fromChain: quoteParams.fromChain,
    toChain: quoteParams.toChain,
    fromToken: quoteParams.fromToken,
    toToken: quoteParams.toToken,
    fromAmount: quoteParams.fromAmount,
    fromAddress: quoteParams.fromAddress,
    toAddress: quoteParams.toAddress,
  });

  const quoteResponse = await fetch(
    "https://li.quest/v1/quote?" + params.toString(),
    process.env.LIFI_API_KEY
      ? { headers: { "x-lifi-api-key": process.env.LIFI_API_KEY } }
      : {}, // Get your live API key from the Li.Fi Partner Portal https://portal.li.fi/login
  );

  const response = await quoteResponse.json();

  return response;
}

export async function getStatus(statusParams: StatusParams) {
  const params = new URLSearchParams({
    txHash: statusParams.txHash,
  });

  const statusResponse = await fetch(
    "https://li.quest/v1/status?" + params.toString(),
    process.env.LIFI_API_KEY
      ? { headers: { "x-lifi-api-key": process.env.LIFI_API_KEY } }
      : {}, // Get your live API key from the Li.Fi Partner Portal https://portal.li.fi/login
  );

  const response = await statusResponse.json();

  return response;
}

import { parseEther } from "viem";
import { mainnet } from "viem/chains";

async function handleEVMSwap() {
  const quoteParams: QuoteParams = {
        fromChain: "ETH", // view the full list of chains here: https://docs.li.fi/introduction/chains
        toChain: "SOL",
        fromToken: "ETH", // view all available tokens for a chain here: https://docs.li.fi/api-reference/fetch-all-known-tokens
        toToken: "SOL",
        fromAmount: parseEther(value).toString(), // where value is a human-readable amount of ETH 1.0 == 1 ETH
        fromAddress: ethAddress, // the sending ETH address
        toAddress: solAddress, // the SOL address where the bridged SOL should be sent to
      };

      const getPriceResponse = await getQuote(quoteParams);

      // build, sign, and broadcast the transaction
      const sendTransactionResponse = await viemWalletClient?.sendTransaction({
        to: getPriceResponse.transactionRequest.to,
        value: getPriceResponse.transactionRequest.value,
        data: getPriceResponse.transactionRequest.data,
        chain: mainnet,
        account: turnkeyViemAccount!,
      });
}

"use client";

import { Connection, LAMPORTS_PER_SOL, VersionedTransaction } from "@solana/web3.js";

function solToLamports(sol: string | number): number {
  return Math.floor(Number(sol) * LAMPORTS_PER_SOL);
}

async function handleSVMSwap() {
  // get an initial price to display to the user
  const quoteParams: QuoteParams = {
    fromChain: "SOL", // view the full list of chains here: https://docs.li.fi/introduction/chains
    toChain: "ETH",
    fromToken: "SOL", // view all available tokens for a chain here: https://docs.li.fi/api-reference/fetch-all-known-tokens
    toToken: "ETH",
    fromAmount: solToLamports(value).toString(), // where value is a human-readable amount of SOL 1.0 == 1 SOL
    fromAddress: solAddress, // the sending SOL address
    toAddress: ethAddress, // the ETH address where the bridged ETH should be sent to
  };

  const getPriceResponse = await getQuote(quoteParams);

  // construct the SOL transaction to send for the bridge
  const txBuffer = Buffer.from(getPriceResponse.transactionRequest.data, "base64");
  const hexTransaction = VersionedTransaction.deserialize(
    new Uint8Array(txBuffer),
  );

  await turnkeySolanaSigner?.addSignature(hexTransaction, solAddress!);

  // sign and broadcast the transaction
  const connection = new Connection(SOL_MAINNET_RPC_PROVIDER);
  const signature = await connection.sendTransaction(hexTransaction, {
    skipPreflight: true,
  });
}

"use client";

import { Connection, LAMPORTS_PER_SOL, VersionedTransaction } from "@solana/web3.js";

async function getStatus() {
  let statusParams: StatusParams = {
    txHash, // this should be the txHash of the sending transaction "sendTransactionResponse" in the EVM -> SVM bridge example or "signature" in the SVM -> EVM bridge example
  };

  // poll the status of the transaction
  while (true) {
    const getStatusResponse = await getStatus(statusParams);

    // check if the status us "DONE"
    if (getStatusResponse.status == "DONE") {
      if (fromToken === "ETH") {
        console.log("SOL Receiving Transaction:" + getStatusResponse.receiving.txHash);
      } else if (fromToken === "SOL") {
         console.log("ETH Receiving Transaction:" + getStatusResponse.receiving.txHash);
      }
      break;
    }

    // sleep for 2 seconds before re-checking the status of the bridge
    await new Promise((resolve) => setTimeout(resolve, 2000));
  }
}