SDK Example Usage: Build Your Own Prediction Market Frontend

import { Connection, PublicKey } from '@solana/web3.js';
import DepredictClient, { MarketType, OracleType, TOKEN_MINTS } from '@endcorp/depredict';
 
const connection = new Connection('https://api.devnet.solana.com');
const client = new DepredictClient(connection);
 
const adminKey = new PublicKey('...'); // payer/authority for setup + txs
const feeVault = new PublicKey('...'); // protocol fee vault (ATA for the market mint)
 
// One-time setup (authority):
// await sendTx(await client.config.createConfig(50, adminKey, feeVault), [adminSigner]);
// await sendTx((await client.marketCreator.createMarketCreator({ name: 'My Platform', feeVault, creatorFeeBps: 50, signer: adminKey })).ixs, [adminSigner]);

const markets = await client.trade.getAllMarkets();
// Render these in your UI

const { tx, marketId } = await client.trade.createMarket({
  startTime: Math.floor(Date.now() / 1000),
  endTime: Math.floor((Date.now() + 86400000) / 1000),
  question: 'Will SOL be above $200 by tomorrow?',
  metadataUri: 'https://your-metadata-url',
  payer: adminKey,
  oracleType: OracleType.MANUAL, // or OracleType.SWITCHBOARD
  marketType: MarketType.LIVE, // or MarketType.FUTURE
  mintAddress: TOKEN_MINTS.USDC_DEVNET, // optional (default is USDC devnet)
  // bettingStartTime required for FUTURE markets
});
// submit `tx` with your wallet adapter

await client.trade.openPosition({
  marketId: 1, // The market you want to trade on
  amount: 100, // Amount in market token; decimals auto-handled (Token or Token-2022 mint)
  direction: { yes: {} }, // or { no: {} }
  payer: /* user's public key */,
  metadataUri: 'https://your-nft-metadata',
});

// Create a shared LUT for all markets this creator runs
const creatorLut = await client.trade.ensureMarketCreatorLookupTable({
  authority: adminKey,
  payer: adminKey,
});
if (creatorLut.createTx) await sendTx(creatorLut.createTx, [adminSigner]);
for (const extendTx of creatorLut.extendTxs) await sendTx(extendTx, [adminSigner]);
 
// After createMarket, provision a market-specific LUT that excludes creator entries
const marketLut = await client.trade.ensureMarketLookupTable({
  marketId,
  authority: adminKey,
  payer: adminKey,
  creatorLookupTableAddress: creatorLut.lookupTableAddress,
  pageIndexes: [0, 1],
});
if (marketLut.createTx) await sendTx(marketLut.createTx, [adminSigner]);
for (const extendTx of marketLut.extendTxs) await sendTx(extendTx, [adminSigner]);
 
// Before a user claims, add any new proof nodes to the market LUT
await client.trade.extendMarketLookupTable({
  marketId,
  authority: adminKey,
  lookupTableAddress: marketLut.lookupTableAddress,
  creatorLookupTableAddress: creatorLut.lookupTableAddress,
  proofNodes: proof.proof,
});
 
// Build the settle instruction and compile a versioned transaction with both LUTs
const { instruction } = await client.trade.buildSettleInstructionWithProof({
  marketId,
  claimer: userKey,
  assetId,
  pageIndex,
  slotIndex,
  proof,
});
const { message } = await buildV0Message(
  client.program,
  [instruction],
  userKey,
  [creatorLut.lookupTableAddress.toBase58(), marketLut.lookupTableAddress.toBase58()],
);
await sendVtx(message, [userSigner]);

import DepredictClient, { MarketType, OracleType } from '@endcorp/depredict';
 
async function createDailyMarkets(client: DepredictClient, payer: PublicKey, days = 7) {
  const now = Math.floor(Date.now()/1000);
  for (let i = 0; i < days; i++) {
    const startTime = now + i * 86400; // each day
    const endTime = startTime + 86400; // 24h duration
    const question = `Will SOL close above $200 on day ${i+1}?`;
 
    const { tx, marketId } = await client.trade.createMarket({
      startTime,
      endTime,
      question,
      oracleType: OracleType.MANUAL,
      marketType: MarketType.LIVE,
      metadataUri: 'https://example.com/metadata.json',
      payer,
    });
    // send tx using your wallet adapter / connection
  }
}