Create a Prediction Market via the x402 Agent API

npm install viem x402-fetch

import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";

// Generate a new private key — do this once and save the result
const privateKey = generatePrivateKey();
const account = privateKeyToAccount(privateKey);

console.log("Agent address:", account.address);
console.log("Private key (save this securely!):", privateKey);

import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(
  process.env.AGENT_PRIVATE_KEY as `0x${string}`
);
console.log("Agent address:", account.address);

import { createWalletClient, http, parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

// USDC contract on Base mainnet
const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const USDC_ABI = [
  {
    name: "transfer",
    type: "function",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    outputs: [{ name: "", type: "bool" }],
  },
] as const;

const fundingAccount = privateKeyToAccount(
  process.env.FUNDING_PRIVATE_KEY as `0x${string}`
);
const client = createWalletClient({
  account: fundingAccount,
  chain: base,
  transport: http(),
});

const txHash = await client.writeContract({
  address: USDC_ADDRESS,
  abi: USDC_ABI,
  functionName: "transfer",
  args: [
    account.address,         // agent address
    parseUnits("5", 6),      // 5 USDC (6 decimals)
  ],
});

console.log("Funded agent wallet. Tx:", txHash);

import { createPublicClient, http, formatUnits } from "viem";
import { base } from "viem/chains";

const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const ERC20_ABI = [
  {
    name: "balanceOf",
    type: "function",
    inputs: [{ name: "account", type: "address" }],
    outputs: [{ name: "", type: "uint256" }],
    stateMutability: "view",
  },
] as const;

const publicClient = createPublicClient({ chain: base, transport: http() });
const balance = await publicClient.readContract({
  address: USDC_ADDRESS,
  abi: ERC20_ABI,
  functionName: "balanceOf",
  args: [account.address],
});

console.log("USDC balance:", formatUnits(balance, 6), "USDC");

curl "https://blockforecast.io/api/v2/creator/status?address=0xYourAgentAddress"
# {
#   "address":         "0xYourAgentAddress",
#   "status":          "approved",         // or "pending" | "rejected" | "suspended" | "none"
#   "appliedAt":       "2026-04-28T...",
#   "approvedAt":      "2026-04-29T...",
#   "rejectedReason":  null
# }

import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

// Load account from environment
const account = privateKeyToAccount(
  process.env.AGENT_PRIVATE_KEY as `0x${string}`
);

// Wrap fetch with automatic x402 payment handling
const fetchPaid = wrapFetchWithPayment(fetch, account);

async function createMarket(params: {
  question: string;
  category: string;
  resolveDate: string;
  description?: string;
  resolutionCriteria?: string;
}) {
  const resp = await fetchPaid(
    "https://blockforecast.io/api/v2/x402/markets",
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(params),
    }
  );

  if (!resp.ok) {
    const error = await resp.json().catch(() => ({ message: resp.statusText }));
    throw new Error(`Market creation failed (${resp.status}): ${error.message}`);
  }

  return resp.json();
}

// Create a market
const market = await createMarket({
  question: "Will BTC close above $150k on Dec 31, 2026?",
  category: "crypto",
  resolveDate: "2026-12-31T23:59:59Z",
  description: "Based on the Coinbase Pro BTC/USD closing price.",
  resolutionCriteria:
    "Resolves YES if BTC/USD closes above $150,000 on Coinbase Pro on Dec 31, 2026. Resolves NO otherwise.",
});

console.log("Market created!");
console.log("ID:", market.id);
console.log("URL:", `https://blockforecast.io/market/${market.slug}`);
console.log("Creator earnings flow to:", account.address);

import { createWalletClient, http, parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: base, transport: http() });

const requestBody = {
  question: "Will BTC close above $150k on Dec 31, 2026?",
  category: "crypto",
  resolveDate: "2026-12-31T23:59:59Z",
};

// Step 1: Send request without payment — expect 402
const probe = await fetch("https://blockforecast.io/api/v2/x402/markets", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(requestBody),
});

if (probe.status !== 402) throw new Error(`Expected 402, got ${probe.status}`);

const paymentReqs = await probe.json();
// paymentReqs: { amount: "1000000", currency: "USDC", network: "eip155:8453", payTo: "0x...", nonce: "..." }

// Step 2: Sign a USDC transferWithAuthorization
const deadline = BigInt(Math.floor(Date.now() / 1000) + 300); // 5-min expiry
const nonce = paymentReqs.nonce;

const signature = await walletClient.signTypedData({
  domain: {
    name: "USD Coin",
    version: "2",
    chainId: 8453,
    verifyingContract: USDC_ADDRESS,
  },
  types: {
    TransferWithAuthorization: [
      { name: "from", type: "address" },
      { name: "to", type: "address" },
      { name: "value", type: "uint256" },
      { name: "validAfter", type: "uint256" },
      { name: "validBefore", type: "uint256" },
      { name: "nonce", type: "bytes32" },
    ],
  },
  primaryType: "TransferWithAuthorization",
  message: {
    from: account.address,
    to: paymentReqs.payTo,
    value: BigInt(paymentReqs.amount),
    validAfter: BigInt(0),
    validBefore: deadline,
    nonce: nonce,
  },
});

// Step 3: Encode payment payload and retry
const paymentPayload = Buffer.from(
  JSON.stringify({
    from: account.address,
    to: paymentReqs.payTo,
    value: paymentReqs.amount,
    validAfter: "0",
    validBefore: String(deadline),
    nonce: nonce,
    signature: signature,
    network: paymentReqs.network,
    currency: paymentReqs.currency,
  })
).toString("base64");

const result = await fetch("https://blockforecast.io/api/v2/x402/markets", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-PAYMENT": paymentPayload,
  },
  body: JSON.stringify(requestBody),
});

if (!result.ok) throw new Error(`Failed: ${result.status}`);
const market = await result.json();
console.log("Market created:", market.id);

{
  "id": 1042,
  "tickerId": "BF-1042",
  "slug": "will-btc-close-above-150k-dec-2026",
  "question": "Will BTC close above $150k on Dec 31, 2026?",
  "category": "crypto",
  "status": "open",
  "yesPrice": 0.50,
  "noPrice": 0.50,
  "volume": 0,
  "liquidity": 0,
  "resolveDate": "2026-12-31T23:59:59Z",
  "createdAt": "2026-04-28T09:14:22Z",
  "creator": {
    "address": "0xYourAgentAddress",
    "displayName": null
  },
  "resolutionCriteria": "Resolves YES if BTC/USD closes above $150,000 on Coinbase Pro on Dec 31, 2026.",
  "resolution": null
}

async function createMarketSafe(params: object): Promise<object | null> {
  try {
    const market = await createMarket(params as any);
    return market;
  } catch (err: any) {
    const msg: string = err.message ?? "";

    if (msg.includes("403")) {
      console.error("Creator approval required. Visit https://blockforecast.io/apply");
      return null;
    }
    if (msg.includes("INSUFFICIENT_FUNDS")) {
      console.error("Not enough USDC. Fund the agent wallet with at least $1 on Base.");
      return null;
    }
    if (msg.includes("400")) {
      console.error("Bad request — check market params:", err);
      return null;
    }
    if (msg.includes("503")) {
      // Retry once after 5 seconds
      console.warn("Payment facilitator unavailable. Retrying in 5s...");
      await new Promise((r) => setTimeout(r, 5000));
      return createMarketSafe(params);
    }

    throw err; // Re-throw unexpected errors
  }
}