Admin and Relayer Action Types: Full Field Reference

export interface OracleUpdate {
  market: number;
  price: bigint;
  signer: Address;
  publishTimeMs: bigint;
}

await client.submitTx({
  type: "OracleUpdate",
  data: {
    market: 1,
    price: 6675234n,           // $66,752.34
    signer: oracleSignerAddress,
    publishTimeMs: BigInt(Date.now()),
  },
});

export interface CreateMarket {
  market: number;
  imBps: number;
  mmBps: number;
  takerFeeBps: number;
  makerFeeBps: number;
  signer: Address;
  fundingIntervalMs: bigint;
  maxFundingRateBps: number;
  poolId?: number;
  szDecimals: number;
  ticker: string;
}

await client.submitTx({
  type: "CreateMarket",
  data: {
    market: 3,
    imBps: 1000,          // 10% initial margin (10x max leverage)
    mmBps: 500,           // 5% maintenance margin
    takerFeeBps: 5,       // 0.05% taker fee
    makerFeeBps: 2,       // 0.02% maker fee
    signer: adminAddress,
    fundingIntervalMs: 3_600_000n, // 1 hour
    maxFundingRateBps: 100,
    szDecimals: 0,        // integer-unit sizing (MANDATORY)
    ticker: "SOL",        // (MANDATORY)
  },
});

export interface UpdateMarketFees {
  market: number;
  signer: Address;
  takerFeeBps?: number | null;
  makerFeeBps?: number | null;
  maxFundingRateBps?: number | null;
  fundingIntervalMs?: bigint | null;
  maxPositionSize?: bigint | null;
  defaultTtlMs?: bigint | null;
  netDeltaMargin?: boolean | null;
  tickSize?: bigint | null;
  lotSize?: bigint | null;
  primaryOracleSigner?: Address | null;
  oracleStalenessMs?: bigint | null;
  markSourceMode?: 0 | 1 | null;
  maxMarkSpreadBps?: number | null;
  cexCompositeStalenessMs?: bigint | null;
  partialLiquidationEnabled?: boolean | null;
  feeTiers?: FeeTier[] | null;
}

// Tighten the funding rate cap on market 1 (live — no chain rebase)
await client.submitTx({
  type: "UpdateMarketFees",
  data: {
    market: 1,
    signer: relayerAddress,
    maxFundingRateBps: 500,     // tighten from 3000 to 500 bps
    defaultTtlMs: 60_000n,      // auto-cancel stale quotes after 60 seconds
  },
});

export interface CreateImpactMarket {
  impactMarketId: number;
  underlyingMarket: number;
  childMarketBase: number;
  question: string;
  deadlineMs: bigint;
  resolutionWindowMs: bigint;
  imBps: number;
  mmBps: number;
  takerFeeBps: number;
  makerFeeBps: number;
  fundingIntervalMs: bigint;
  maxFundingRateBps: number;
  signer: Address;
  oracleSource?: EventOracleSource;
  description?: string;
  rules?: string;
}

export enum Branch {
  Yes = 1,
  No  = 2,
}

export type EventOracleSource =
  | {
      kind: "UnderlyingPriceVsStrike";
      strikePrice: bigint;
      comparison: PriceComparison;
    }
  | {
      kind: "MarketOracle";
      market: number;
      strikePrice: bigint;
      comparison: PriceComparison;
    }
  | { kind: "RelayerAttested" };

export type PriceComparison =
  | "GreaterThan"
  | "LessThan"
  | "GreaterThanOrEqual"
  | "LessThanOrEqual";

// Create an impact market that auto-resolves based on BTC oracle price
await client.submitTx({
  type: "CreateImpactMarket",
  data: {
    impactMarketId: 100,
    underlyingMarket: 1,       // BTC-PERP
    childMarketBase: 1000,
    question: "Will BTC close above $70,000 on 2025-06-30?",
    deadlineMs: 1751241600000n,
    resolutionWindowMs: 86_400_000n, // 24 hours
    imBps: 2000,
    mmBps: 1000,
    takerFeeBps: 10,
    makerFeeBps: 5,
    fundingIntervalMs: 3_600_000n,
    maxFundingRateBps: 100,
    signer: adminAddress,
    oracleSource: {
      kind: "UnderlyingPriceVsStrike",
      strikePrice: 7_000_000n,   // $70,000.00 in integer cents
      comparison: "GreaterThan",
    },
    description: "Resolves YES if BTC oracle closes strictly above $70,000.",
    rules: "Uses the BTC-PERP primary oracle price at the deadline block.",
  },
});

export interface ResolveEvent {
  impactMarketId: number;
  outcome: Outcome;
  signer: Address;
}

import { Outcome } from "@proof/trading-sdk";

await client.submitTx({
  type: "ResolveEvent",
  data: {
    impactMarketId: 100,
    outcome: Outcome.Yes,
    signer: relayerAddress,
  },
});

export enum Outcome {
  Yes  = 1,
  No   = 2,
  Void = 3,
}

export interface FeeTier {
  min30dVolumeMicroUsdc: bigint;
  makerFeeTenthBps: number;
  takerFeeTenthBps: number;
}

// Set a three-tier fee schedule on market 1
await client.submitTx({
  type: "UpdateMarketFees",
  data: {
    market: 1,
    signer: relayerAddress,
    feeTiers: [
      {
        min30dVolumeMicroUsdc: 0n,                    // base tier
        makerFeeTenthBps: 20,                         // 0.02% maker
        takerFeeTenthBps: 50,                         // 0.05% taker
      },
      {
        min30dVolumeMicroUsdc: 1_000_000_000_000n,    // $1M 30d volume
        makerFeeTenthBps: 10,                         // 0.01% maker
        takerFeeTenthBps: 40,                         // 0.04% taker
      },
      {
        min30dVolumeMicroUsdc: 10_000_000_000_000n,   // $10M 30d volume
        makerFeeTenthBps: -5,                         // −0.005% maker rebate
        takerFeeTenthBps: 30,                         // 0.03% taker
      },
    ],
  },
});

export type MarketKind =
  | "Perp"
  | { ConditionalPerp:    [number, "Yes" | "No"] }
  | { PredictionBinary:   [number, "Yes" | "No"] };

export interface MarketConfig {
  market: number;           // [0]
  imBps: number;            // [1]
  mmBps: number;            // [2]
  takerFeeBps: number;      // [3]
  makerFeeBps: number;      // [4]
  fundingIntervalMs: bigint; // [5]
  maxFundingRateBps: number; // [6]
  kind?: MarketKind;         // [7]  defaults to "Perp"
  maxPositionSize?: bigint;  // [8]  0 = no limit
  defaultTtlMs?: bigint;     // [9]  0 = no TTL
  netDeltaMargin?: boolean;  // [10]
  poolId?: number;           // [11] 0 = shared default pool
  markPriceMaxOracleAgeMs?: bigint; // [12] 0 = no check
  feeTiers?: FeeTier[];      // [13] empty = flat fees
  tickSize?: bigint;         // [14] 0 = no tick gate
  lotSize?: bigint;          // [15] 0 = no lot gate
  primaryOracleSigner?: Address; // [16]
  oracleStalenessMs?: bigint;    // [17] 0 = disabled
  markSourceMode?: MarkSourceMode; // [18]
  maxMarkSpreadBps?: number;     // [19]
  cexCompositeStalenessMs?: bigint; // [20]
  partialLiquidationEnabled?: boolean; // [21]
  szDecimals?: number;       // [22] quantity scale
  ticker?: string;           // [23] human-readable symbol
}

export type MarkSourceMode = "OracleOnly" | "Median";