Types

TypeScript type definitions used throughout the SDK.

Initialization types

InitializeSDKParams

interface InitializeSDKParams {
  connection: Connection;
  wallet?: IWallet;
  skipPreflight?: boolean;
  commitment?: Commitment;
  maxRetries?: number;
}

IWallet

type IWallet = {
  publicKey: PublicKey;
  signTransaction<T extends Transaction | VersionedTransaction>(
    transaction: T
  ): Promise<T>;
  signAllTransactions<T extends Transaction | VersionedTransaction>(
    transactions: T[]
  ): Promise<T[]>;
};

Transaction types

BaseTransactionParams

interface BaseTransactionParams {
  payerOverride?: PublicKey;
  signers?: Keypair[];
  confirmOptions?: ConfirmOptions;
  preinstructions?: TransactionInstruction[];
  feePayerOverride?: PublicKey;
}

ConfirmOptions

interface ConfirmOptions {
  skipPreflight?: boolean;
  commitment?: Commitment;
  preflightCommitment?: Commitment;
  maxRetries?: number;
  minContextSlot?: number;
}

Bet types

InitializeBetParams

interface InitializeBetParams extends BaseTransactionParams {
  question: string;
  expectedUserCount: number;
  minimumVoteCount: number;
  isCreatorResolver: boolean;
}

PlaceWagerParams

interface PlaceWagerParams extends BaseTransactionParams {
  bet: PublicKey;
  amount?: number;     // Human-readable (e.g., 10 for 10 USDC)
  rawAmount?: number;  // Raw lamports (e.g., 10_000_000)
  side: Outcome;
}

InitiateVoteParams

interface InitiateVoteParams extends BaseTransactionParams {
  bet: PublicKey;
}

PlaceVoteParams

interface PlaceVoteParams extends BaseTransactionParams {
  bet: PublicKey;
  outcome: Outcome;
}

SettleBetBatchParams

interface SettleBetBatchParams extends BaseTransactionParams {
  bet: PublicKey;
  batchNumber: number;
  usersPerBatch: number;
}

V4 bet types

Multi-outcome bets use a numeric outcomeIndex instead of the binary Outcome enum, and amounts are raw base units (micro-USDC) typed as number | string | BN. SettleBetBatchParams is shared with V2.

InitializeBetV4Params

interface InitializeBetV4Params extends BaseTransactionParams {
  question: string;
  expectedUserCount: number;
  minimumVoteCount: number;
  isCreatorResolver: boolean;
  initialOutcomes: string[];   // 2–64 outcome labels
  votingDisabled?: boolean;    // admin-resolve-only when true
  wagerId?: number | BN;
}

AddOutcomeV4Params

interface AddOutcomeV4Params extends BaseTransactionParams {
  bet: PublicKey;
  label: string;
}

PlaceWagerV4Params

interface PlaceWagerV4Params extends BaseTransactionParams {
  bet: PublicKey;
  amount: number | string | BN;  // Raw micro-USDC (6 decimals)
  outcomeIndex: number;          // 0-based outcome index
}

PlaceVoteV4Params

interface PlaceVoteV4Params extends BaseTransactionParams {
  bet: PublicKey;
  outcomeIndex: number;
}

AdminResolveBetV4Params

interface AdminResolveBetV4Params extends BaseTransactionParams {
  bet: PublicKey;
  outcomeIndex: number;  // Winning outcome index
}

Mapped types

Returned by mapper functions — use plain numbers and strings instead of BN and Rust enums.

MappedBet

interface MappedBet {
  creator: string;
  createdAt: number;
  updatedAt: number;
  resolvedAt: number;
  distributedAt: number;
  voteInitiatedAt: number;
  status: string;           // "Draft" | "Pending" | "Resolving" | etc.
  resolvedOutcome: string;  // "For" | "Against" | "Tied"
  question: string;
  expectedUserCount: number;
  minimumVoteCount: number;
  totalOiFor: number;
  totalOiAgainst: number;
  poolAddress: string;
  wagers: MappedWager[];
  votes: MappedVote[];
  wagerId: number;
  isCreatorResolver: boolean;
  settledUserCount: number;
  totalBatchesRequired: number;
}

MappedWager

interface MappedWager {
  user: string;
  amount: number;
  outcome: string;   // "For" | "Against"
  updatedAt: number;
  status: string;    // "Open" | "SettledWin" | "SettledLoss"
  isVoteInitiator: boolean;
}

MappedBetV4

interface MappedBetV4 {
  creator: string;
  createdAt: number;
  updatedAt: number;
  resolvedAt: number;
  distributedAt: number;
  voteInitiatedAt: number;
  status: string;                      // "Draft" | "Pending" | "Resolving" | etc.
  resolvedOutcomeIndex: number | null; // null = refund-all
  isRefundAll: boolean;
  question: string;
  expectedUserCount: number;
  minimumVoteCount: number;
  feeBps: number;
  outcomes: { label: string; totalOi: string }[];
  poolAddress: string;
  poolBump: number;
  wagerId: number;
  isCreatorResolver: boolean;
  votingDisabled: boolean;
  outcomesLocked: boolean;
  wagers: {
    user: string;
    amount: string;
    outcomeIndex: number;
    updatedAt: number;
    status: string;
    isVoteInitiator: boolean;
  }[];
  votes: { user: string; outcomeIndex: number; createdAt: number }[];
  settledUserCount: number;
  totalBatchesRequired: number;
}

MappedUser

interface MappedUser {
  totalWagersCount: number;
  totalWageredAmount: number;
  inWagerAmount: number;
  nextWagerId: number;
  nextGameId: number;
}