Foresight API Documentation

import { createPublicClient, createWalletClient, http, type Hex } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const TRADE_API_URL = '<https://api.foresight.now/trade>'

// 1. Get available markets
const marketsResponse = await fetch(`${TRADE_API_URL}/markets`)
const markets = await marketsResponse.json()
console.log('Available markets:', markets)

// 2. Get a quote for a trade
const marketAddress = '0x...' // Market contract address
const amount = '100000000' // 100 USDC in base units (6 decimals)
const outcome = 1 // 1 = YES, 0 = NO
const tradeType = 'Buy'

const quoteResponse = await fetch(`${TRADE_API_URL}/quote`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    market: marketAddress,
    amount: amount,
    outcome: outcome,
    type: tradeType
  })
})
const quote = await quoteResponse.json()
console.log('Trade quote:', quote)

// 3. Check and handle token approval (required for buying)
const account = '0x...' // User wallet address
const tokenAddress = '0x...' // USDC token address
const spenderAddress = '0x...' // Market maker contract address

// Check current allowance
const allowance = await publicClient.readContract({
  address: tokenAddress,
  abi: erc20ABI,
  functionName: 'allowance',
  args: [account, spenderAddress]
})

// If allowance is insufficient, approve the spender
if (allowance < BigInt(amount)) {
  const approveHash = await walletClient.writeContract({
    address: tokenAddress,
    abi: erc20ABI,
    functionName: 'approve',
    args: [spenderAddress, BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')]
  })

  // Wait for approval confirmation
  await publicClient.waitForTransactionReceipt({ hash: approveHash })
  console.log('Token approval confirmed')
}

// 4. Execute the trade
const executeResponse = await fetch(`${TRADE_API_URL}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    market: marketAddress,
    amount: amount,
    outcome: outcome,
    type: tradeType,
    account: account
  })
})
const tradeData = await executeResponse.json()
console.log('Trade execution data:', tradeData)

// If the trade status is successful
if (tradeData.tx) {
  // Simulate the transaction first
  const callResult = await publicClient.call({
    account: tradeData.tx.account,
    data: tradeData.tx.data,
    to: tradeData.tx.to,
    value: BigInt(tradeData.tx.value),
  })
  console.log('Simulation result:', callResult)

  // Send the actual transaction
  const PRIVATE_KEY = process.env.PRIVATE_KEY as Hex
  const walletClient = createWalletClient({
    chain: mainnet,
    transport: http(),
  })
  const hash = await walletClient.sendTransaction({
    account: privateKeyToAccount(PRIVATE_KEY),
    data: tradeData.tx.data,
    to: tradeData.tx.to,
    value: BigInt(tradeData.tx.value),
  })
  console.log('Transaction hash:', hash)

// 5. Completion step (Deprecated): No longer needed — indexer auto-processes confirmed transactions
// Wait for on-chain confirmation; the indexer will pick it up automatically
await publicClient.waitForTransactionReceipt({ hash })
// No call to /trade/complete is required
}

// 6. Get user positions and redeem winning positions
async function redeemWinningPositions(userAddress: string) {
  // Get resolved positions
  const positionsResponse = await fetch(`${TRADE_API_URL}/positions?walletAddress=${userAddress}&type=resolved&pg=1&ps=20`)
  const positionsData = await positionsResponse.json()

  // Filter for claimable positions (resolved markets where user has winning shares)
  const claimablePositions = positionsData.positions.filter(position =>
    position.resolutionOutcome === position.outcome && position.totalShareAmount > 0
  )

  console.log(`Found ${claimablePositions.length} claimable positions`)

  // Redeem each claimable position
  for (const position of claimablePositions) {
    try {
      const redeemResponse = await fetch(`${TRADE_API_URL}/redeem`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          market: position.market,
          account: userAddress
        })
      })
      const redeemData = await redeemResponse.json()

      if (redeemData.tx) {
        // Simulate the transaction first
        const callResult = await publicClient.call({
          account: redeemData.tx.account,
          data: redeemData.tx.data,
          to: redeemData.tx.to,
          value: BigInt(redeemData.tx.value),
        })
        console.log('Redeem simulation successful')

        // Send the actual transaction
        const redeemHash = await walletClient.sendTransaction({
          data: redeemData.tx.data,
          to: redeemData.tx.to,
          value: BigInt(redeemData.tx.value),
        })
        console.log('Redeem transaction hash:', redeemHash)

        // Wait for confirmation and complete
        await publicClient.waitForTransactionReceipt({ hash: redeemHash })

        const completeRedeemResponse = await fetch(`${TRADE_API_URL}/complete`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ txHash: redeemHash })
        })
        const redeemCompletion = await completeRedeemResponse.json()
        console.log('Redeem completion:', redeemCompletion)
      }
    } catch (error) {
      console.error(`Error redeeming position for market ${position.market}:`, error)
    }
  }
}

// Usage example
// await redeemWinningPositions('0x...') // User wallet address

interface MarketInfo {
  address: string;
  question: string;
  outcome1Price: number;
  outcome0Price: number;
  endDate: string;
  conditionDisplayName?: string;
}

const markets = await fetch(`${TRADE_API_URL}/markets`)
const data = await markets.json()

interface TradeQuoteRequest {
  market: string;        // Market contract address
  amount: string;        // Amount in base units (6 decimals for USDC)
  outcome: 0 | 1;       // 0 = NO, 1 = YES
  type: 'Buy' | 'Sell'; // Trade type
}

interface TradeQuote {
  market: string;
  amount: string;
  outcome: 0 | 1;
  type: 'Buy' | 'Sell';
  estimatedReturn: string;
  estimatedPricePerShare: number;
}

const quote = await fetch(`${TRADE_API_URL}/quote`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    market: "0x...",
    amount: "100000000", // 100 USDC
    outcome: 1, // YES
    type: "Buy"
  })
})
const data = await quote.json()

interface TradeExecuteRequest {
  market: string;        // Market contract address
  amount: string;        // Amount in base units (6 decimals for USDC)
  outcome: 0 | 1;       // 0 = NO, 1 = YES
  type: 'Buy' | 'Sell'; // Trade type
  account: string;       // User wallet address
}

interface TradeExecuteResponse extends TradeQuote {
  tx: {
    to: string;      // Contract address to send transaction to
    data: string;    // Transaction data (encoded function call)
    account: string; // User account address
    value: string;   // ETH value to send (usually "0")
  };
}

const tradeData = await fetch(`${TRADE_API_URL}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    market: "0x...",
    amount: "100000000",
    outcome: 1,
    type: "Buy",
    account: "0x..." // user wallet address
  })
})
const data = await tradeData.json()

// Send transaction using wallet client
const hash = await walletClient.sendTransaction({
  data: data.tx.data,
  to: data.tx.to,
  value: BigInt(data.tx.value),
  account: data.tx.account,
})

// 4. POST `/trade/complete` - Complete Trade
// After the transaction is confirmed on-chain, notify the backend to process and persist it
await publicClient.waitForTransactionReceipt({ hash })

const completeRes = await fetch(`${TRADE_API_URL}/complete`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ txHash: hash })
})
const completion = await completeRes.json()
// completion: { success: boolean; message: string; data?: { ... } }

interface RedeemExecuteRequest {
  market: string;  // Market contract address
  account: string; // User wallet address
}

interface RedeemExecuteResponse {
  tx: {
    to: string;      // Contract address to send transaction to
    data: string;    // Transaction data (encoded function call)
    account: string; // User account address
    value: string;   // ETH value to send (usually "0")
  };
  expectedReturn: string; // Expected return amount in base units
  market: string;         // Market address
}

const redeemData = await fetch(`${TRADE_API_URL}/redeem`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    market: "0x...", // Market contract address
    account: "0x..." // User wallet address
  })
})
const data = await redeemData.json()

// Send transaction using wallet client
const hash = await walletClient.sendTransaction({
  data: data.tx.data,
  to: data.tx.to,
  value: BigInt(data.tx.value),
  account: data.tx.account,
})

// Completion step (Deprecated): No longer needed — indexer auto-processes confirmed transactions
await publicClient.waitForTransactionReceipt({ hash })
// No call to /trade/complete is required

interface PositionsQuery {
  walletAddress: string;           // User wallet address (required)
  type: 'active' | 'resolved';    // Filter by market status (required)
  pg?: number;                    // Page number (default: 1)
  ps?: number;                    // Page size (default: 20, max: 100)
}

interface UserPositionsResponse {
  positions: Array<{
    market: string;              // Market address
    tokenAddress: string;        // Token address for the market shares
    amountInvested: number;      // Amount invested in collateral token (in base units)
    outcome: 0 | 1;             // Outcome index bought (0 for NO, 1 for YES)
    totalShareAmount: number;    // Total share amount held (in base units)
    question: string;          // Market question
    resolutionOutcome: number | null; // Resolution outcome (null if market not resolved)
    marketEndDate: string | null;    // Market end date
  }>;
  page: number;                  // Current page number
  pageSize: number;              // Number of items per page
  hasPrevious: boolean;          // Whether there is a previous page
  hasNext: boolean;              // Whether there is a next page
  totalCount: number;            // Total number of positions for a given user
}

const positions = await fetch(`${TRADE_API_URL}/positions?walletAddress=0x...&type=resolved&pg=1&ps=20`)
const data = await positions.json()

// Filter for claimable positions (resolved markets where user has winning shares)
const claimablePositions = data.positions.filter(position =>
  position.resolutionOutcome === position.outcome && position.totalShareAmount > 0
)

// Redeem each claimable position
for (const position of claimablePositions) {
  const redeemData = await fetch(`${TRADE_API_URL}/redeem`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      market: position.market,
      account: "0x..." // User wallet address
    })
  })
  // ... execute redeem transaction
}

interface TradeCompleteRequest {
  txHash: string; // 0x-prefixed 32-byte hash
}

interface TradeCompleteResponse {
  success: boolean;
  message: string;
  data?: {
    txHash: string;
    type: 'BUY' | 'SELL';
    tokenAmount: string;
    usdtAmount: string;
    price: string;
    positionId: string;
    userAddress: string;
    createdAt: string; // ISO date-time
  };
}

// Check current allowance
const allowance = await publicClient.readContract({
  address: tokenAddress, // USDC token address
  abi: erc20ABI,
  functionName: 'allowance',
  args: [userAddress, marketMakerAddress]
})

// Approve if needed (using max uint256 for unlimited approval)
if (allowance < BigInt(tradeAmount)) {
  const approveHash = await walletClient.writeContract({
    address: tokenAddress,
    abi: erc20ABI,
    functionName: 'approve',
    args: [marketMakerAddress, BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')]
  })

  await publicClient.waitForTransactionReceipt({ hash: approveHash })
}