perpetuals

type ADLAffectedPosition struct {
	// PositionID is the affected position
	PositionID ids.ID

	// UserID is the position owner
	UserID ids.ShortID

	// OriginalSize is the size before ADL
	OriginalSize uint64

	// ReducedSize is the amount reduced by ADL
	ReducedSize uint64

	// ReductionPercentage is the percentage of position reduced
	ReductionPercentage float64

	// ExecutionPrice is the price at which the reduction occurred
	ExecutionPrice uint64

	// CompensationPaid is the compensation paid to the user
	CompensationPaid *big.Int

	// PnLRealized is the PnL realized from the reduction
	PnLRealized *big.Int
}

type ADLCandidate struct {
	// PositionID uniquely identifies the position
	PositionID ids.ID

	// UserID is the owner of the position
	UserID ids.ShortID

	// Symbol is the trading pair
	Symbol string

	// Side is the position side (true = long, false = short)
	Side bool

	// Size is the current position size
	Size uint64

	// EntryPrice is the average entry price
	EntryPrice uint64

	// UnrealizedPnL is the current unrealized profit/loss
	UnrealizedPnL *big.Int

	// PnLRanking is the profit ranking score (higher = more profitable)
	PnLRanking float64

	// Leverage is the current leverage
	Leverage uint64

	// MarginBalance is the current margin balance
	MarginBalance *big.Int
}

type ADLConfig struct {
	// Enabled controls whether ADL is active
	Enabled bool

	// Threshold is the insurance fund depletion ratio that triggers ADL
	// When insurance fund falls below this percentage of target, ADL activates
	// Default: 0.2 (20%)
	Threshold float64

	// MaxReductionPerPosition is the maximum percentage of any single position
	// that can be reduced in a single ADL event
	// Default: 0.5 (50%)
	MaxReductionPerPosition float64

	// MinProfitForADL is the minimum unrealized profit required for a position
	// to be eligible for ADL (protects small profitable positions)
	// Default: $100
	MinProfitForADL *big.Int

	// CompensationRate is the percentage of mark price paid as compensation
	// Default: 0.001 (0.1%)
	CompensationRate float64
}

type ADLEvent struct {
	// EventID uniquely identifies this ADL event
	EventID ids.ID

	// Timestamp is when the ADL occurred
	Timestamp time.Time

	// Symbol is the affected trading pair
	Symbol string

	// LiquidatedPositionID is the position that triggered ADL
	LiquidatedPositionID ids.ID

	// TriggerReason describes why ADL was triggered
	TriggerReason string

	// AffectedPositions lists all positions affected by this ADL
	AffectedPositions []*ADLAffectedPosition

	// TotalReduced is the total position size reduced
	TotalReduced uint64

	// TotalCompensation is the total compensation paid
	TotalCompensation *big.Int

	// InsuranceFundBefore is the insurance fund balance before ADL
	InsuranceFundBefore *big.Int

	// InsuranceFundAfter is the insurance fund balance after ADL
	InsuranceFundAfter *big.Int
}

type ADLStatistics struct {
	TotalEvents       uint64   `json:"totalEvents"`
	TotalReduced      *big.Int `json:"totalReduced"`
	TotalCompensation *big.Int `json:"totalCompensation"`
	LongCandidates    int      `json:"longCandidates"`
	ShortCandidates   int      `json:"shortCandidates"`
}

type AutoDeleveragingEngine struct {
	// contains filtered or unexported fields
}

type DefaultPriceOracle struct {
	// contains filtered or unexported fields
}

type Engine struct {
	// contains filtered or unexported fields
}

type FundingPayment struct {
	ID          ids.ID   // Payment ID
	Position    ids.ID   // Position ID
	Market      string   // Market symbol
	Trader      ids.ID   // Trader ID
	Amount      *big.Int // Payment amount (negative = paid, positive = received)
	FundingRate *big.Int // Funding rate at time of payment
	Timestamp   time.Time
}

type LeverageTier struct {
	MinNotional       *big.Int // Minimum notional value (in quote asset, e.g., USDT)
	MaxNotional       *big.Int // Maximum notional value
	MaxLeverage       uint16   // Maximum leverage for this tier
	MaintenanceMargin uint16   // Maintenance margin rate in basis points
	MaintenanceAmount *big.Int // Maintenance amount deduction
}

type LiquidationEvent struct {
	ID               ids.ID    // Event ID
	Position         *Position // Liquidated position (snapshot)
	LiquidationPrice *big.Int  // Price at liquidation
	LiquidationSize  *big.Int  // Size liquidated
	InsurancePayout  *big.Int  // Amount from insurance fund
	PnL              *big.Int  // P&L of liquidated position
	Liquidator       ids.ID    // Liquidator (can be system or keeper)
	Timestamp        time.Time
}

type MarginAccount struct {
	TraderID         ids.ID               // Trader ID
	Balance          *big.Int             // Total account balance
	AvailableBalance *big.Int             // Available balance for new positions
	LockedMargin     *big.Int             // Margin locked in positions
	UnrealizedPnL    *big.Int             // Total unrealized P&L across all positions
	MarginRatio      *big.Int             // Current margin ratio (scaled by 1e18)
	Positions        map[string]*Position // Active positions by market
	Mode             MarginMode           // Default margin mode
	UpdatedAt        time.Time
}

type MarginMode uint8

type Market struct {
	Symbol            string        // Market symbol (e.g., "BTC-PERP")
	BaseAsset         ids.ID        // Base asset ID
	QuoteAsset        ids.ID        // Quote asset ID (usually USDC)
	IndexPrice        *big.Int      // Current index price from oracle
	MarkPrice         *big.Int      // Current mark price
	LastPrice         *big.Int      // Last traded price
	FundingRate       *big.Int      // Current funding rate (scaled by 1e18)
	NextFundingTime   time.Time     // Next funding payment time
	OpenInterestLong  *big.Int      // Total long open interest
	OpenInterestShort *big.Int      // Total short open interest
	Volume24h         *big.Int      // 24h trading volume
	MaxLeverage       uint16        // Maximum allowed leverage
	MinSize           *big.Int      // Minimum position size
	TickSize          *big.Int      // Minimum price tick
	MakerFee          uint16        // Maker fee in basis points
	TakerFee          uint16        // Taker fee in basis points
	MaintenanceMargin uint16        // Maintenance margin ratio in basis points
	InitialMargin     uint16        // Initial margin ratio in basis points
	MaxFundingRate    *big.Int      // Maximum funding rate per period
	FundingInterval   time.Duration // Funding interval (typically 8 hours)
	InsuranceFund     *big.Int      // Insurance fund balance for this market
	CreatedAt         time.Time
	UpdatedAt         time.Time
}

type Order struct {
	ID           ids.ID   // Order ID
	Trader       ids.ID   // Trader ID
	Market       string   // Market symbol
	Side         Side     // Long or Short
	Size         *big.Int // Order size
	Price        *big.Int // Limit price (nil for market orders)
	IsMarket     bool     // True for market orders
	ReduceOnly   bool     // Only reduce position, don't increase
	PostOnly     bool     // Only maker, reject if would take
	TimeInForce  TimeInForce
	Leverage     uint16 // Desired leverage
	MarginMode   MarginMode
	FilledSize   *big.Int // Amount filled
	AvgFillPrice *big.Int // Average fill price
	Status       OrderStatus
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type OrderStatus uint8

type Position struct {
	ID               ids.ID     // Unique position ID
	Trader           ids.ID     // Trader account ID
	Market           string     // Market symbol (e.g., "BTC-PERP")
	Side             Side       // Long or Short
	Size             *big.Int   // Position size in base units (e.g., satoshis)
	EntryPrice       *big.Int   // Average entry price (scaled by 1e18)
	Margin           *big.Int   // Margin collateral locked
	MarginMode       MarginMode // Cross or Isolated
	Leverage         uint16     // Leverage multiplier (e.g., 10 = 10x)
	LiquidationPrice *big.Int   // Price at which position is liquidated
	TakeProfit       *big.Int   // Optional take profit price
	StopLoss         *big.Int   // Optional stop loss price
	UnrealizedPnL    *big.Int   // Current unrealized P&L
	RealizedPnL      *big.Int   // Total realized P&L
	FundingPaid      *big.Int   // Total funding payments made/received
	OpenedAt         time.Time  // When position was opened
	UpdatedAt        time.Time  // Last update time
}

type PriceOracle interface {
	GetIndexPrice(market string) (*big.Int, error)
	GetMarkPrice(market string) (*big.Int, error)
}

type RebatePayment struct {
	ID           ids.ID   // Payment ID
	ReferrerID   ids.ID   // Recipient
	RefereeID    ids.ID   // Source trader
	TradeID      ids.ID   // Associated trade
	Market       string   // Market
	TradeVolume  *big.Int // Trade notional volume
	TradeFee     *big.Int // Original trade fee
	RebateAmount *big.Int // Rebate amount
	Tier         uint8    // Tier at time of payment
	Timestamp    time.Time
}

type Referee struct {
	ID            ids.ID   // Referee ID
	ReferrerID    ids.ID   // Who referred them
	ReferralCode  string   // Code used
	TotalVolume   *big.Int // Total trading volume
	TotalDiscount *big.Int // Total fee discounts received
	IsActive      bool     // Active in last 30 days
	ReferredAt    time.Time
	LastActiveAt  time.Time
}

type ReferralCode struct {
	Code         string // Unique referral code
	Owner        ids.ID // Owner of the code
	CustomRebate uint16 // Custom rebate rate (0 = use tier default)
	IsActive     bool   // Whether code is active
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type ReferralEngine struct {
	// contains filtered or unexported fields
}

type ReferralStats struct {
	TotalReferrers      uint64   // Total number of referrers
	TotalReferees       uint64   // Total referred users
	TotalRebatesPaid    *big.Int // Total rebates paid out
	TotalDiscountsGiven *big.Int // Total discounts given
	ActiveReferrers30d  uint64   // Referrers active in 30 days
	Volume30d           *big.Int // Total referred volume in 30 days
}

type ReferralTier struct {
	Tier            uint8    // Tier level (1-6)
	MinVolume       *big.Int // Minimum 30-day trading volume
	MinReferrals    uint32   // Minimum active referrals
	ReferrerRebate  uint16   // Rebate % for referrer (basis points, 10000 = 100%)
	RefereeDiscount uint16   // Fee discount % for referee (basis points)
}

type Referrer struct {
	ID              ids.ID   // Referrer ID
	Codes           []string // Active referral codes
	Tier            uint8    // Current tier
	TotalReferrals  uint32   // Total number of referrals
	ActiveReferrals uint32   // Active referrals (traded in last 30 days)
	TotalVolume     *big.Int // Total referred volume
	Volume30d       *big.Int // Last 30 day referred volume
	TotalRebates    *big.Int // Total rebates earned
	PendingRebates  *big.Int // Pending rebates to claim
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

type Side uint8

type TPSLConfig struct {
	TakeProfit *TPSLOrder
	StopLoss   *TPSLOrder
}

type TPSLManager struct {
	// contains filtered or unexported fields
}

type TPSLOrder struct {
	ID           ids.ID      // Unique order ID
	PositionID   ids.ID      // Associated position
	TraderID     ids.ID      // Trader who owns this
	Market       string      // Market symbol
	Type         TPSLType    // Take profit or Stop loss
	Side         Side        // Side to close (opposite of position side)
	TriggerPrice *big.Int    // Price at which to trigger
	TriggerType  TriggerType // What price to watch
	OrderPrice   *big.Int    // Execution price (nil = market order)
	Size         *big.Int    // Size to close (nil = full position)
	SizePercent  uint16      // Size as percentage (0-10000 basis points)

	// Trailing stop specific
	TrailingDelta   *big.Int // Distance to trail from high/low
	TrailingPercent uint16   // Trail as percentage
	ActivationPrice *big.Int // Price at which trailing starts
	HighestPrice    *big.Int // Highest price since activation (for long)
	LowestPrice     *big.Int // Lowest price since activation (for short)

	// Metadata
	Status      TPSLStatus
	TriggeredAt *time.Time
	ExecutedAt  *time.Time
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type TPSLStatus uint8

type TPSLType uint8

type TierConfig struct {
	Tiers             []*LeverageTier
	GlobalMaxLeverage uint16 // Global max leverage (can be lower than tier max)
}

type TimeInForce uint8

type Trade struct {
	ID         ids.ID    // Trade ID
	Market     string    // Market symbol
	MakerOrder ids.ID    // Maker order ID
	TakerOrder ids.ID    // Taker order ID
	Maker      ids.ID    // Maker trader ID
	Taker      ids.ID    // Taker trader ID
	Side       Side      // Taker side
	Price      *big.Int  // Execution price
	Size       *big.Int  // Trade size
	MakerFee   *big.Int  // Fee paid by maker
	TakerFee   *big.Int  // Fee paid by taker
	Timestamp  time.Time // Execution time
}

type TriggerType uint8

type VIPTier struct {
	Tier         uint8    // VIP level (0-9)
	MinVolume30d *big.Int // Minimum 30-day trading volume
	MakerFee     uint16   // Maker fee in basis points
	TakerFee     uint16   // Taker fee in basis points
}