import { BlankClient } from "@blankdotbuild/sdk";

const blank = new BlankClient({ apiKey: process.env.BLANK_API_KEY });

const rounds = await blank.predictions.rounds(mint, { limit: 10 });

const open = rounds.data.data.find((round) => round.status === "open");
if (!open) {
  throw new Error("No open round for this token right now");
}

const round = await blank.predictions.round(mint, roundId);

if (round.data.status === "settled") {
  console.log("Settlement price", round.data.settlementPriceInSol);
}

const entries = await blank.predictions.entries(mint, roundId);

if (entries.data.visibility === "aggregate") {
  // Round has not durably locked. Only the count is public.
  console.log(`${entries.data.participantCount} predictions so far`);
} else {
  // visibility === "exact": the round has locked.
  for (const entry of entries.data.data) {
    console.log(entry.username, entry.predictedPriceInSol, entry.rank);
  }
}

{ "visibility": "aggregate", "participantCount": 187 }

{
  "visibility": "exact",
  "participantCount": 187,
  "data": [
    {
      "id": "b1c5a9f2-2d43-4c8e-9f11-0a7c3d61be40",
      "walletAddress": "So11111111111111111111111111111111111111112",
      "username": "alice",
      "predictedPriceInSol": "0.00001234",
      "rank": 1,
      "distancePpm": "412",
      "submittedAt": "2026-08-10T09:12:03Z"
    }
  ]
}

import { BlankApiError } from "@blankdotbuild/sdk";

try {
  const standings = await blank.predictions.standings(mint, roundId);
  for (const standing of standings.data.data) {
    console.log(standing.rank, standing.username, standing.payoutLamports);
  }
} catch (error) {
  if (
    error instanceof BlankApiError &&
    error.code === "prediction_exact_values_locked"
  ) {
    // Round is still open. Poll again after it locks.
  } else {
    throw error;
  }
}

const eligibility = await blank.predictions.eligibility(mint, roundId);

if (!eligibility.data.eligible) {
  console.log("Not eligible:", eligibility.data.reasons.join(", "));
}

const submission = await blank.predictions.create(
  {
    roundId: open.id,
    walletAddress: process.env.BLANK_WALLET_ADDRESS!,
    predictedPriceInSol: "0.00001234",
  },
  { idempotencyKey: "prediction-round-42-attempt-1" }
);

console.log(submission.data.id, submission.data.status);

curl -sX POST "https://api.blank.build/api/v2/predictions" \
  -H "Authorization: Bearer $BLANK_API_KEY" \
  -H "Idempotency-Key: prediction-round-42-attempt-1" \
  -H "Content-Type: application/json" \
  -d '{
    "roundId": "7d2c1a4e-8b93-4a17-9c05-2f6e8d1b3a90",
    "walletAddress": "So11111111111111111111111111111111111111112",
    "predictedPriceInSol": "0.00001234"
  }'

const intent = await blank.predictions.createDelegatedIntent(
  {
    roundId,
    walletAddress: endUserWallet,
    predictedPriceInSol: "0.00001234",
  },
  { idempotencyKey: `prediction-intent:${checkoutId}` }
);

// Return only these public values to your browser.
return {
  intentId: intent.data.id,
  message: intent.data.message,
  expiresAt: intent.data.expiresAt,
};

import bs58 from "bs58";

const signatureBytes = await wallet.signMessage(
  new TextEncoder().encode(message)
);
const signature = bs58.encode(signatureBytes);

await fetch("/api/predictions/submit", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ intentId, signature }),
});

const prediction = await blank.predictions.createDelegated(
  { intentId, signature },
  { idempotencyKey: `delegated-prediction:${intentId}` }
);

console.log(prediction.data.id, prediction.data.walletAddress);

import { randomUUID } from "node:crypto";
import { mkdir, readFile, writeFile } from "node:fs/promises";
import path from "node:path";
import { BlankApiError, BlankClient } from "@blankdotbuild/sdk";

const blank = new BlankClient({ apiKey: process.env.BLANK_API_KEY });

const mint = process.env.BLANK_MINT!;
const wallet = process.env.BLANK_WALLET_ADDRESS!;

async function submitPrediction(predictedPriceInSol: string) {
  // 1. Find the open round.
  const rounds = await blank.predictions.rounds(mint, { limit: 10 });
  const round = rounds.data.data.find(
    (candidate) => candidate.status === "open"
  );
  if (!round) {
    return { submitted: false as const, reason: "no_open_round" };
  }

  // 2. Check eligibility so you can report a clear reason before spending a submit.
  const eligibility = await blank.predictions.eligibility(mint, round.id);
  if (!eligibility.data.eligible) {
    return {
      submitted: false as const,
      reason: eligibility.data.reasons.join(","),
    };
  }

  // 3. Persist a durable idempotency key BEFORE the request, then submit.
  const idempotencyKey = await loadOrCreateKey(round.id);

  let predictionId: string;
  try {
    const created = await blank.predictions.create(
      { roundId: round.id, walletAddress: wallet, predictedPriceInSol },
      { idempotencyKey }
    );
    predictionId = created.data.id;

    if (created.metadata.idempotentReplayed) {
      console.log("Replayed an earlier attempt, no new prediction was created");
    }
  } catch (error) {
    if (error instanceof BlankApiError) {
      if (error.code === "idempotency_request_in_progress") {
        // First attempt is still running. Retry after Retry-After with the same key.
        return { submitted: false as const, reason: "in_progress" };
      }
      if (error.code === "prediction_already_submitted") {
        return { submitted: false as const, reason: "already_submitted" };
      }
    }
    throw error;
  }

  // 4. Read the immutable record back.
  const prediction = await blank.predictions.get(predictionId);
  return { submitted: true as const, prediction: prediction.data };
}

// One durable key per round, written before the request is issued. Swap the
// filesystem for whatever store you already run — the property that matters is
// that the key survives a crash so a retry replays instead of double-submitting.
const keyDir = process.env.BLANK_IDEMPOTENCY_DIR ?? "./.blank-idempotency";

async function loadOrCreateKey(roundId: string) {
  await mkdir(keyDir, { recursive: true });
  const file = path.join(keyDir, `${roundId}.key`);
  const key = `prediction-${roundId}-${randomUUID()}`;

  try {
    // "wx" fails if the file exists, so the first writer wins the race.
    await writeFile(file, key, { flag: "wx" });
    return key;
  } catch {
    return (await readFile(file, "utf8")).trim();
  }
}