Ondo Swap

"use client";

import {
  useOndoSellCheckoutViewModel,
  type CheckoutWalletSelection,
} from "@passage-cl/react";
import type {
  OfferOptionId,
  OndoOfferDetail,
} from "@passage-cl/react/universal";

export function OndoSellCheckout({
  offer,
  optionId,
  wallets,
}: {
  offer: OndoOfferDetail;
  optionId: OfferOptionId;
  wallets: CheckoutWalletSelection;
}) {
  const { state, onEvent } = useOndoSellCheckoutViewModel({
    offer,
    chain: "ethereum_mainnet",
    optionId,
    wallets,
  });

  switch (state.type) {
    case "error":
      // state.reason: "unsupported-chain" | "unknown-option" | "not-tradable"
      return <MyCheckoutUnavailable reason={state.reason} />;
    case "content":
      // state.wallet is null when `preselected` skipped the wallet step.
      // state.amount, state.review, state.sidebar, state.orderConfirmed
      return <MySellFlow state={state} onEvent={onEvent} />;
    default: {
      const exhaustive: never = state;
      return exhaustive;
    }
  }
}

// Selling. The quote is the only source of the asset's address and decimals,
// so price one whole share first, then parse what the user typed.
const quote = await passage.ondo.getQuote({
  symbol: AssetSymbol("AAPLon"),
  side: "sell",
  tokenAmount: BlockchainAmount({ raw: 1n, decimals: AssetDecimals(0) }),
});

const parsed = parseBlockchainAmount(amountInput, quote.asset.decimals);
if (!parsed.valid) return;
const amount = parsed.amount;

// The option whose requirements the user was shown. This offer has one;
// on an offer with several, use the one your page displayed.
const option = offer.options.length === 1 ? offer.options[0] : undefined;
if (option === undefined) return;

const prepared = await passage.ondo.prepareSell({
  wallet,                                   // your EvmWallet
  symbol: AssetSymbol("AAPLon"),            // Ondo's API symbol
  chain: "ethereum_mainnet",
  swapContracts: offer.swapContracts,       // the spender, resolved per chain
  offerOptionId: option.id,                 // frontline runs this option's requirements
  tokenAddress: quote.assetAddress,         // the ASSET, not a stablecoin
  amount,                                   // BlockchainAmount, asset base units
  onProgress: (phase) => setBusy(phase),
});

if (prepared.type === "error") {
  // prepared.error.step: "unsupported-chain" | "allowance-check"
  //   | "approval" | "approval-reverted" | "insufficient-allowance"
  //   | "build-transaction" | "build-refused"
  // On "build-refused", prepared.error.reason says why: "requirements-not-met"
  return;
}

// prepared.transaction.expected  - what the sale should return
// prepared.transaction.minimum   - the floor the calldata enforces

const filled = await passage.ondo.executeSwap({
  wallet,
  transaction: prepared.transaction,
  chain: "ethereum_mainnet",
  onProgress: (phase) => setBusy(phase),
});

if (filled.type === "success") {
  // filled.txHash, filled.transaction
} else {
  // filled.error.step: "quote-expired" | "swap" | "swap-unconfirmed"
  //   | "swap-reverted"
}

const chain = "ethereum_mainnet";
const listed = offer.tokens.find(
  (token) => token.role === "funding" && token.chain === chain,
);
const fundingSymbol =
  (listed && TOKEN_REGISTRY.stablecoinAt(chain, listed.address)) ?? USDC_SYMBOL;
// prepareBuy's tokenAddress
const fundingAddress = TOKEN_REGISTRY.address(fundingSymbol, chain);
if (fundingAddress === null) throw new Error(`${fundingSymbol} is not on ${chain}`);
// Parse what the user typed at the funding token's decimals.
const { decimals } = TOKEN_REGISTRY.erc20(fundingSymbol);