Redeem Outcome Tokens

import "dotenv/config";

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

const DFLOW_METADATA_API_URL = process.env.DFLOW_METADATA_API_URL ?? "https://dev-prediction-markets-api.dflow.net";
const DFLOW_TRADE_API_URL = process.env.DFLOW_TRADE_API_URL ?? "https://dev-quote-api.dflow.net";
const DFLOW_API_KEY = process.env.DFLOW_API_KEY; // optional; not needed for dev endpoints
const DFLOW_SETTLEMENT_MINT = process.env.DFLOW_SETTLEMENT_MINT ?? "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"; // USDC
const SOLANA_RPC_URL = process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com";

const connection = new Connection(SOLANA_RPC_URL, "confirmed");
const keypair = Keypair.fromSecretKey(
  bs58.decode(process.env.SOLANA_PRIVATE_KEY ?? "")
);

const headers: HeadersInit = {};
if (DFLOW_API_KEY) headers["x-api-key"] = DFLOW_API_KEY;

/// Outcome token mint address (YES or NO token)
const outcomeMint = "OUTCOME_TOKEN_MINT_ADDRESS_HERE";

/// Fetch market details by mint address
const response = await fetch(
  `${DFLOW_METADATA_API_URL}/api/v1/market/by-mint/${outcomeMint}`,
  { headers }
);

if (!response.ok) {
  throw new Error("Failed to fetch market details");
}

const market = await response.json();

/// Check if market is determined (status can be "determined" or "finalized")
if (market.status !== "determined" && market.status !== "finalized") {
  throw new Error(`Market is not determined. Current status: ${market.status}`);
}

/// Check if the outcome mint matches the market result
/// The result can be "yes", "no", "" or "scalar" (the last two indicate a scalar outcome)
const result = market.result; // "yes", "no", "", or "scalar"
const isScalarResult = result === "" || result === "scalar";
let isDeterminedOutcome = false;
let settlementMint;

/// Option 1: Use a constant settlement mint (e.g., USDC)
/// If you only support one settlement mint, use this approach
if (market.accounts[DFLOW_SETTLEMENT_MINT]) {
  const usdcAccount = market.accounts[DFLOW_SETTLEMENT_MINT];

  /// Check if redemption is open
  if (usdcAccount.redemptionStatus === "open") {
    /// Case 1: Standard determined outcome (result is "yes" or "no")
    if (result === "yes" || result === "no") {
      if (
        (result === "yes" && usdcAccount.yesMint === outcomeMint) ||
        (result === "no" && usdcAccount.noMint === outcomeMint)
      ) {
        isDeterminedOutcome = true;
        settlementMint = DFLOW_SETTLEMENT_MINT;
      }
    }
    /// Case 2: Scalar outcome (result is "" or "scalar"; use scalarOutcomePct)
    /// Both YES and NO tokens are redeemable in this case
    else if (
      isScalarResult &&
      usdcAccount.scalarOutcomePct !== null &&
      usdcAccount.scalarOutcomePct !== undefined
    ) {
      /// Both YES and NO tokens are redeemable when scalarOutcomePct is defined
      if (
        usdcAccount.yesMint === outcomeMint ||
        usdcAccount.noMint === outcomeMint
      ) {
        isDeterminedOutcome = true;
        settlementMint = DFLOW_SETTLEMENT_MINT;

        /// Calculate payout percentages for display/logging
        const yesPayoutPct = usdcAccount.scalarOutcomePct / 10000;
        const noPayoutPct = (10000 - usdcAccount.scalarOutcomePct) / 10000;
        console.log(
          `Scalar outcome detected. YES payout: ${
            yesPayoutPct * 100
          }%, NO payout: ${noPayoutPct * 100}%`
        );
      }
    }
  } else {
    throw new Error(`Redemption is not open for ${outcomeMint}`);
  }
}

/// Option 2: Find settlement mint dynamically (if you support multiple)
/// Uncomment this if you need to support multiple settlement mints
/*
if (!settlementMint) {
  for (const [mint, account] of Object.entries(market.accounts)) {
    if (account.redemptionStatus === "open") {
      /// Case 1: Standard determined outcome
      if (result === "yes" || result === "no") {
        if (result === "yes" && account.yesMint === outcomeMint) {
          isDeterminedOutcome = true;
          settlementMint = mint;
          break;
        } else if (result === "no" && account.noMint === outcomeMint) {
          isDeterminedOutcome = true;
          settlementMint = mint;
          break;
        }
      }
      /// Case 2: Scalar outcome (both YES and NO are redeemable)
      else if (isScalarResult && account.scalarOutcomePct !== null && account.scalarOutcomePct !== undefined) {
        if (account.yesMint === outcomeMint || account.noMint === outcomeMint) {
          isDeterminedOutcome = true;
          settlementMint = mint;
          break;
        }
      }
    } else {
      throw new Error(`Redemption is not open for ${outcomeMint}`);
    }
  }
}
*/

if (!isDeterminedOutcome) {
  if (isScalarResult) {
    throw new Error(
      `Outcome token does not match any outcome mint for this market. Token: ${outcomeMint}`
    );
  } else {
    throw new Error(
      `Outcome token does not match market result. Market result: ${result}, Token: ${outcomeMint}`
    );
  }
}

if (!settlementMint) {
  throw new Error("No settlement mint with open redemption status found");
}

const settlementAccount = market.accounts[settlementMint];

console.log("Token is redeemable!", {
  outcomeMint,
  settlementMint,
  redemptionStatus: settlementAccount.redemptionStatus,
  marketTitle: market.title,
});

// Preview a redemption order before the outcome is determined.
// Uses DFLOW_TRADE_API_URL, settlementMint (from Step 1), outcomeMint, keypair, headers from the setup above.
async function previewRedemption() {
  const previewAmount = 1_000_000; // Example: 1 outcome token (6 decimals)
  const previewParams = new URLSearchParams();
  previewParams.append("userPublicKey", keypair.publicKey.toBase58());
  previewParams.append("inputMint", outcomeMint);
  previewParams.append("outputMint", settlementMint!);
  previewParams.append("amount", previewAmount.toString());

  const preview = await fetch(
    `${DFLOW_TRADE_API_URL}/order?${previewParams.toString()}`,
    { headers }
  ).then((x) => x.json());

  console.log(
    `Redemption preview: ${preview.inAmount} of ${preview.inputMint} is redeemable for ${preview.outAmount} of ${preview.outputMint}`
  );
}

// Polling pattern: call this on an interval until the outcome is determined.
// Uses DFLOW_METADATA_API_URL, outcomeMint, headers from the setup above.
async function checkOutcomeStatus() {
  const latest = await fetch(
    `${DFLOW_METADATA_API_URL}/api/v1/market/by-mint/${outcomeMint}`,
    { headers }
  ).then((x) => x.json());

  if (latest.status === "determined" || latest.status === "finalized") {
    console.log("Outcome determined");
    return latest;
  }
  console.log("Outcome not determined yet");
  return null;
}

// Check redemption funding for a given market. settlementMint comes from Step 1.
function checkRedemptionFunding(latestMarket: any) {
  const account = latestMarket.accounts?.[settlementMint!];
  if (account?.redemptionStatus === "open") {
    console.log("Redemption funded");
    return true;
  }
  console.log("Redemption not funded yet");
  return false;
}

// Reuses DFLOW_TRADE_API_URL, settlementMint (from Step 1), outcomeMint, keypair, headers from the setup above.
const redeemAmount = 1_000_000; // 1 outcome token (6 decimals)

const queryParams = new URLSearchParams();
queryParams.append("inputMint", outcomeMint);
queryParams.append("outputMint", settlementMint!);
queryParams.append("amount", redeemAmount.toString());
queryParams.append("userPublicKey", keypair.publicKey.toBase58());

const orderResponse = await fetch(
  `${DFLOW_TRADE_API_URL}/order?${queryParams.toString()}`,
  { headers }
).then((x) => x.json());

const transactionBuffer = Buffer.from(orderResponse.transaction, "base64");
const transaction = VersionedTransaction.deserialize(transactionBuffer);

transaction.sign([keypair]);
const signature = await connection.sendTransaction(transaction);
console.log(`  Tx: https://orbmarkets.io/tx/${signature}`);

const statusResponse = await fetch(
  `${DFLOW_TRADE_API_URL}/order-status?signature=${signature}`,
  { headers }
).then((x) => x.json());

console.log(statusResponse.status, statusResponse.fills);