Auto routing onchain

/**
 * Get a quote with ERC20 onchain request information
 */
async function getQuoteWithUseInbox() {
  // Set up the parameters for the quote request
  const quoteParams = {
    userAddress: "0xYourUsersAddress",
    originChainId: "1", // Ethereum
    destinationChainId: "10", // Optimism
    inputToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
    outputToken: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607", // USDC on Optimism
    inputAmount: "1000000", // 1 USDC (6 decimals)
    receiverAddress: "0xYourUsersAddress",
    useInbox: true, // Enables autoRoute.txData for ERC20 tokens and disables autoRoute.signTypedData
  };

  // Build the URL with query parameters
  const url = `${BUNGEE_API_BASE_URL}/api/v1/bungee/quote`;
  const queryParams = new URLSearchParams(quoteParams);
  const fullUrl = `${url}?${queryParams}`;

  // Make the request
  const response = await fetch(fullUrl, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
    },
  });

  const data = await response.json();
  const serverReqId = response.headers.get("server-req-id");

  if (!data.success) {
    throw new Error(
      `Quote error: ${data.statusCode}: ${data.message}. server-req-id: ${serverReqId}`
    );
  }

  return data.result;
}

import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { optimism } from "viem/chains";

// Check if PRIVATE_KEY is set, set in console, i.e.: export PRIVATE_KEY=<YOUR_PRIVATE_KEY>
if (!process.env.PRIVATE_KEY) {
  console.error("Error: PRIVATE_KEY environment variable is not set");
  console.error("Example: export PRIVATE_KEY=<YOUR_PRIVATE_KEY>");
  process.exit(1);
}

// Create account from private key
// Normalize private key to ensure it has exactly one "0x" prefix (required by viem)
const normalizedPrivateKey = `0x${process.env.PRIVATE_KEY.replace(/^0x/i, '')}`;
const account = privateKeyToAccount(normalizedPrivateKey);

const publicClient = createPublicClient({
  chain: optimism,
  transport: http(),
});

const walletClient = createWalletClient({
  account,
  chain: optimism,
  transport: http(),
});

// API and token parameters
const BUNGEE_API_BASE_URL = "https://public-backend.bungee.exchange";

// Quote parameters for native token test (ETH from Optimism to Arbitrum)
const quoteParamsNative = {
  userAddress: account.address,
  receiverAddress: account.address,
  originChainId: 10, // Optimism
  destinationChainId: 42161, // Arbitrum
  inputToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH on Optimism
  outputToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH on Arbitrum
  inputAmount: "100000000000000", // 0.0001 ETH in wei
};

async function getQuote(params) {
  const url = `${BUNGEE_API_BASE_URL}/api/v1/bungee/quote`;
  const queryParams = new URLSearchParams(params);
  const fullUrl = `${url}?${queryParams}`;

  const response = await fetch(fullUrl);
  const data = await response.json();

  if (!data.success) {
    throw new Error(`Quote error: ${data.error?.message || "Unknown error"}`);
  }

  if (!data.result.autoRoute) {
    throw new Error("No autoRoute available for native token transfer");
  }

  return {
    txData: data.result.autoRoute.txData,
    requestHash: data.result.autoRoute.requestHash,
  };
}

async function submitNativeTransaction(txData) {
  const hash = await walletClient.sendTransaction({
    to: txData.to,
    value: BigInt(txData.value),
    data: txData.data,
  });

  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  return { hash, receipt };
}

async function checkStatus(requestHash) {
  const response = await fetch(
    `${BUNGEE_API_BASE_URL}/api/v1/bungee/status?requestHash=${requestHash}`
  );
  const data = await response.json();

  if (!data.success) {
    throw new Error(`Status error: ${data.error?.message || "Unknown error"}`);
  }

  return data.result[0];
}

async function main() {
  console.log("Starting Bungee Native Token Test (Auto Route)...");

  // Get the quote
  console.log("\n1. Getting quote...");
  const { txData, requestHash } = await getQuote(quoteParamsNative);

  if (txData) {
    // Submit the transaction
    console.log("\n2. Submitting transaction...");
    const { hash, receipt } = await submitNativeTransaction(txData);
    console.log("Transaction sent:", hash);

    // Poll for completion
    console.log("\n3. Checking status...");
    let status;
    let attempts = 0;
    const maxAttempts = 60;
    const interval = 5000;

    while (attempts < maxAttempts) {
      await new Promise((resolve) => setTimeout(resolve, interval));
      status = await checkStatus(requestHash);
      const code = status?.bungeeStatusCode;
      console.log("Status:", code);

      if (code === 3 || code === 4) {
        // FULFILLED or SETTLED
        console.log("Transaction complete:", status.destinationData?.txHash);
        break;
      }

      if (code === 5) {
        throw new Error(`Request expired. Status: ${JSON.stringify(status)}`);
      }
      if (code === 6) {
        throw new Error(`Request cancelled. Status: ${JSON.stringify(status)}`);
      }
      if (code === 7) {
        throw new Error(`Request refunded. Status: ${JSON.stringify(status)}`);
      }

      attempts++;
    }

    if (attempts >= maxAttempts) {
      throw new Error(
        `Polling timed out after ${maxAttempts} attempts. Last status: ${JSON.stringify(status)}`
      );
    }
  }
}

main();