Stablecoin Swaps via Paxos Labs Transit

npm install @getpara/viem-v2-integration @getpara/react-sdk viem

import {
  createParaViemAccount,
  createParaViemClient,
} from "@getpara/viem-v2-integration";
import { ParaWeb } from "@getpara/react-sdk";
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

// Initialize Para (complete authentication before signing)
const para = new ParaWeb("YOUR_PARA_API_KEY");

const account = createParaViemAccount({ para });

const walletClient = createParaViemClient({
  para,
  walletClientConfig: {
    account,
    chain: mainnet,
    transport: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"),
  },
});

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"),
});

const res = await fetch(
  "https://api.paxoslabs.com/v1/transit/routes?filter=" +
    encodeURIComponent("sourceChainId=1"),
);
const { routes } = await res.json();

const route = routes[0];
// route.offerAsset       token address on the source chain
// route.wantAsset        token address on the destination chain
// route.minOrderSize     minimum order size in offer-asset base units
//                         (for example, 35000000 = $35 for a 6-decimal token like USDC)
// route.tokenMetadataMap token details indexed by lowercase address

const offerAmount = "100000000"; // 100 USDC (6-decimal base units)

const authRes = await fetch(
  "https://api.paxoslabs.com/v3/core/authorization?" +
    new URLSearchParams({
      spenderAddress: TRANSIT_STATION_ADDRESS, // transaction.to from a prior quote
      tokenAddress: route.offerAsset,
      amount: offerAmount,
      userAddress: account.address,
      chainId: "1",
    }),
);
const auth = await authRes.json();

let permitSignature: `0x${string}` | undefined;
let permitDeadline: string | undefined;

if (auth.method === "permit") {
  // Token supports EIP-2612. Para signs the permit off-chain (gasless).
  permitSignature = await walletClient.signTypedData({
    account,
    domain: auth.permitData.domain,
    types: auth.permitData.types,
    primaryType: "Permit",
    message: auth.permitData.value,
  });
  permitDeadline = auth.permitData.deadline;
} else if (auth.method === "approval") {
  // Standard ERC-20 approve transaction (raw calldata sent to the token contract)
  const approvalHash = await walletClient.sendTransaction({
    account,
    to: route.offerAsset,
    data: auth.approvalTransaction.encoded,
  });
  await publicClient.waitForTransactionReceipt({ hash: approvalHash });
}
// "already_approved" means sufficient allowance exists, so proceed to the quote.

const quoteParams = new URLSearchParams({
  userAddress: account.address, // wallet receiving destination funds
  offerAmount, // base units, minimum $35 USD equivalent
  offerAsset: route.offerAsset,
  wantAsset: route.wantAsset,
  sourceChainId: "1",
  destinationChainId: String(route.destinationChainId),
});
if (permitSignature && permitDeadline) {
  quoteParams.set("permitSignature", permitSignature);
  quoteParams.set("permitDeadline", permitDeadline);
}

const quoteRes = await fetch(
  `https://api.paxoslabs.com/v1/transit/orders/quote?${quoteParams}`,
);
const quote = await quoteRes.json();
// quote.amountOut          net amount after fees (want-asset base units)
// quote.totalFees          sum of protocol and integrator fees
// quote.estimatedLatencyMs expected delivery time

const hash = await walletClient.sendTransaction({
  account,
  to: quote.transaction.to, // TransitStation contract
  data: quote.transaction.data, // ABI-encoded submitOrder calldata
  value: BigInt(quote.transaction.value), // native token messaging fee
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });
// The receipt contains an OrderSubmitted event with the order ID,
// a 32-byte hex hash used to track the order in step 6.
const orderId = "0x..."; // from the OrderSubmitted event in receipt.logs

const TERMINAL = ["PROCESSED", "REMOVED"];

async function waitForOrder(orderId: string) {
  while (true) {
    const res = await fetch(
      `https://api.paxoslabs.com/v1/transit/orders/${orderId}`,
    );
    const { order } = await res.json();

    if (TERMINAL.includes(order.status)) return order;
    await new Promise((resolve) => setTimeout(resolve, 10_000));
  }
}

const order = await waitForOrder(orderId);
// PENDING_BRIDGE order submitted, awaiting processing
// PROCESSING     order is being fulfilled
// PROCESSED      order complete, funds delivered
// REMOVED        order removed from the queue