entities

type Account struct {
	ID       AccountID
	PartyID  PartyID
	AssetID  AssetID
	MarketID MarketID
	Type     zeta.AccountType
	TxHash   TxHash
	ZetaTime time.Time
}

type AccountBalance struct {
	*Account
	Balance  decimal.Decimal
	TxHash   TxHash
	ZetaTime time.Time
}

type AccountBalanceKey struct {
	AccountID AccountID
	ZetaTime  time.Time
}

type AccountCursor struct {
	AccountID AccountID `json:"account_id"`
}

type AccountField int64

type AccountFilter struct {
	AssetID      AssetID
	PartyIDs     []PartyID
	AccountTypes []types.AccountType
	MarketIDs    []MarketID
}

type AccountID = ID[_Account]

type AccountSource interface {
	Obtain(ctx context.Context, a *Account) error
	GetByID(ctx context.Context, id AccountID) (Account, error)
}

type AggregatedBalance struct {
	ZetaTime  time.Time
	Balance   decimal.Decimal
	AccountID *AccountID
	PartyID   *PartyID
	AssetID   *AssetID
	MarketID  *MarketID
	Type      *types.AccountType
}

type AggregatedBalanceCursor struct {
	ZetaTime  time.Time `json:"zeta_time"`
	AccountID *AccountID
	PartyID   *PartyID
	AssetID   *AssetID
	MarketID  *MarketID
	Type      *types.AccountType
}

type AggregatedLedgerEntriesCursor struct {
	ZetaTime time.Time `json:"zeta_time"`
}

type AggregatedLedgerEntry struct {
	ZetaTime     time.Time
	Quantity     decimal.Decimal
	TransferType *LedgerMovementType
	AssetID      *AssetID

	FromAccountPartyID  *PartyID
	ToAccountPartyID    *PartyID
	FromAccountMarketID *MarketID
	ToAccountMarketID   *MarketID
	FromAccountType     *types.AccountType
	ToAccountType       *types.AccountType
	FromAccountBalance  decimal.Decimal
	ToAccountBalance    decimal.Decimal
}

type Asset struct {
	ID                AssetID
	Name              string
	Symbol            string
	Decimals          int
	Quantum           decimal.Decimal
	Source            string
	ERC20Contract     string
	TxHash            TxHash
	ZetaTime          time.Time
	LifetimeLimit     decimal.Decimal
	WithdrawThreshold decimal.Decimal
	Status            AssetStatus
}

type AssetCursor struct {
	ID AssetID `json:"id"`
}

type AssetID = ID[_Asset]

type AssetStatus zeta.Asset_Status

type AuctionDuration struct {
	Duration int64  `json:"duration,omitempty"`
	Volume   uint64 `json:"volume,omitempty"`
}

type Balance struct {
	AccountID AccountID
	TxHash    TxHash
	ZetaTime  time.Time
	Balance   decimal.Decimal
}

type BalanceKey struct {
	AccountID AccountID
	ZetaTime  time.Time
}

type BeginBlockEvent interface {
	events.Event
	BeginBlock() eventspb.BeginBlock
}

type Block struct {
	ZetaTime time.Time
	Height   int64
	Hash     []byte
}

type Candle struct {
	PeriodStart        time.Time
	LastUpdateInPeriod time.Time
	Open               decimal.Decimal
	Close              decimal.Decimal
	High               decimal.Decimal
	Low                decimal.Decimal
	Volume             uint64
}

type CandleCursor struct {
	PeriodStart time.Time `json:"periodStart"`
}

type Chain struct {
	ID string
}

type Checkpoint struct {
	Hash        string
	BlockHash   string
	BlockHeight int64
	TxHash      TxHash
	ZetaTime    time.Time
	SeqNum      uint64
}

type CheckpointCursor struct {
	BlockHeight int64 `json:"blockHeight"`
}

type CloseOnLimitOperation bool

type Condition struct {
	Operator v1.Condition_Operator
	Value    string
}

type CoreSnapshotData struct {
	BlockHeight     uint64
	BlockHash       string
	ZetaCoreVersion string
	TxHash          TxHash
	ZetaTime        time.Time
}

type CoreSnapshotDataCursor struct {
	ZetaTime        time.Time
	BlockHeight     uint64
	BlockHash       string
	ZetaCoreVersion string
}

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

type CursorPagination struct {
	Pagination
	Forward     *offset
	Backward    *offset
	NewestFirst bool
}

type Data struct {
	Signers        Signers
	Data           []Property
	MatchedSpecIds [][]byte // pgx automatically handles [][]byte to Postgres ByteaArray mappings
	BroadcastAt    time.Time
	TxHash         TxHash
	ZetaTime       time.Time
	SeqNum         uint64
}

type DataSourceDefinition struct {
	Type     int
	External *DataSourceDefinitionExternal
	Internal *DataSourceDefinitionInternal
}

type DataSourceDefinitionExternal struct {
	Signers Signers
	Filters []Filter
}

type DataSourceDefinitionInternal struct {
	Time time.Time
}

type DataSourceSpec struct {
	ID        SpecID
	CreatedAt time.Time
	UpdatedAt time.Time
	Data      *DataSourceDefinition
	Status    DataSourceSpecStatus
	TxHash    TxHash
	ZetaTime  time.Time
}

type DataSourceSpecConfiguration struct {
	Signers Signers
	Filters []Filter
}

type DataSourceSpecCursor struct {
	ZetaTime time.Time `json:"zetaTime"`
	ID       SpecID    `json:"id"`
}

type DataSourceSpecRaw struct {
	ID        SpecID
	CreatedAt time.Time
	UpdatedAt time.Time
	Signers   Signers
	Filters   []Filter
	Status    DataSourceSpecStatus
	TxHash    TxHash
	ZetaTime  time.Time
}

type DataSourceSpecStatus zetapb.DataSourceSpec_Status

type DateRange struct {
	Start *time.Time
	End   *time.Time
}

type Delegation struct {
	PartyID  PartyID         `json:"party_id"`
	NodeID   NodeID          `json:"node_id"`
	EpochID  int64           `json:"epoch_id"`
	Amount   decimal.Decimal `json:"amount"`
	TxHash   TxHash
	ZetaTime time.Time
	SeqNum   uint64
}

type DelegationCursor struct {
	ZetaTime time.Time `json:"zetaTime"`
	PartyID  PartyID   `json:"partyId"`
	NodeID   NodeID    `json:"nodeId"`
	EpochID  int64     `json:"epochId"`
}

type Deposit struct {
	ID                DepositID
	Status            DepositStatus
	PartyID           PartyID
	Asset             AssetID
	Amount            decimal.Decimal
	ForeignTxHash     string
	CreditedTimestamp time.Time
	CreatedTimestamp  time.Time
	TxHash            TxHash
	ZetaTime          time.Time
}

type DepositCursor struct {
	ZetaTime time.Time `json:"zetaTime"`
	ID       DepositID `json:"id"`
}

type DepositID = ID[_Deposit]

type DepositStatus zeta.Deposit_Status

type ERC20MultiSigSignerAddedEvent struct {
	ERC20MultiSigSignerEvent
}

type ERC20MultiSigSignerEvent struct {
	ID           ERC20MultiSigSignerEventID
	ValidatorID  NodeID
	SignerChange EthereumAddress
	Submitter    EthereumAddress
	Nonce        string
	TxHash       TxHash
	ZetaTime     time.Time
	EpochID      int64
	Event        ERC20MultiSigSignerEventType
}

type ERC20MultiSigSignerEventCursor struct {
	ZetaTime time.Time                  `json:"zeta_time"`
	ID       ERC20MultiSigSignerEventID `json:"id"`
}

type ERC20MultiSigSignerEventID = ID[_ERC20MultiSigSignerEvent]

type ERC20MultiSigSignerEventType string

type ERC20MultiSigSignerRemovedEvent struct {
	ERC20MultiSigSignerEvent
}

type Entities interface {
	Market | Party | Trade | Order | MarketData | Reward | Candle | Deposit |
		Withdrawal | Asset | OracleSpec | OracleData | Position | LiquidityProvision | Vote |
		AccountBalance | Proposal | Delegation | Node | NetworkParameter | Checkpoint |
		StakeLinking | NodeSignature | KeyRotation | ERC20MultiSigSignerAddedEvent |
		ERC20MultiSigSignerRemovedEvent | EthereumKeyRotation | AggregatedBalance | AggregatedLedgerEntry |
		ProtocolUpgradeProposal | CoreSnapshotData | EpochRewardSummary
}

type Epoch struct {
	ID         int64
	StartTime  time.Time
	ExpireTime time.Time
	EndTime    *time.Time
	TxHash     TxHash
	ZetaTime   time.Time
	FirstBlock *int64
	LastBlock  *int64
}

type EpochData struct {
	*zeta.EpochData
}

type EpochRewardSummary struct {
	AssetID    AssetID
	MarketID   MarketID
	RewardType string
	EpochID    uint64
	Amount     num.Decimal
}

type EpochRewardSummaryCursor struct {
	EpochID    uint64 `json:"epoch_id"`
	AssetID    string `json:"asset_id"`
	MarketID   string `json:"market_id"`
	RewardType string `json:"reward_type"`
	Amount     string `json:"amount"`
}

type EthereumAddress string

type EthereumKeyRotation struct {
	NodeID      NodeID
	OldAddress  EthereumAddress
	NewAddress  EthereumAddress
	BlockHeight uint64
	TxHash      TxHash
	ZetaTime    time.Time
	SeqNum      uint64
}

type EthereumKeyRotationCursor struct {
	ZetaTime   time.Time       `json:"zetaTime"`
	NodeID     NodeID          `json:"nodeID"`
	OldAddress EthereumAddress `json:"oldAddress"`
	NewAddress EthereumAddress `json:"newAddress"`
}

type ExternalData struct {
	Data *Data
}

type ExternalDataCursor struct {
	ZetaTime time.Time `json:"zetaTime"`
	Signers  Signers   `json:"signers"`
}

type ExternalDataSourceSpec struct {
	Spec *DataSourceSpec
}

type FeeFactors struct {
	MakerFee          string `json:"makerFee,omitempty"`
	InfrastructureFee string `json:"infrastructureFee,omitempty"`
	LiquidityFee      string `json:"liquidityFee,omitempty"`
}

type Fees struct {
	Factors *FeeFactors `json:"factors,omitempty"`
}

type Filter struct {
	Key        PropertyKey `json:"key"`
	Conditions []Condition `json:"conditions"`
}

type ID[T any] string

type KeyRotation struct {
	NodeID      NodeID
	OldPubKey   ZetaPublicKey
	NewPubKey   ZetaPublicKey
	BlockHeight uint64
	TxHash      TxHash
	ZetaTime    time.Time
}

type KeyRotationCursor struct {
	ZetaTime  time.Time     `json:"zeta_time"`
	NodeID    NodeID        `json:"node_id"`
	OldPubKey ZetaPublicKey `json:"old_pub_key"`
	NewPubKey ZetaPublicKey `json:"new_pub_key"`
}

type LedgerEntry struct {
	LedgerEntryTime    time.Time
	FromAccountID      AccountID `db:"account_from_id"`
	ToAccountID        AccountID `db:"account_to_id"`
	Quantity           decimal.Decimal
	TxHash             TxHash
	ZetaTime           time.Time
	TransferTime       time.Time
	Type               LedgerMovementType
	FromAccountBalance decimal.Decimal `db:"account_from_balance"`
	ToAccountBalance   decimal.Decimal `db:"account_to_balance"`
}

type LedgerEntryField int64

type LedgerEntryFilter struct {
	// CloseOnAccountFilters is used to open/close the output set of entries under the FromAccount/ToAccount values.
	// If true -> the output set will contain entries which sending and receiving accounts
	// all match the criteria given in the `AccountFilter` type.
	// Otherwise will contain entries that have a match the settings in both accounts (sending or receiving) or in one of them.
	CloseOnAccountFilters CloseOnLimitOperation
	// FromAccountFilter is a filter which is used to request properties for FromAccount field.
	FromAccountFilter AccountFilter
	// ToAccountFilter is a filter which is used to request properties for ToAccount field.
	ToAccountFilter AccountFilter

	// Filter on LedgerMovementType
	TransferTypes []LedgerMovementType
}

type LedgerMovementType zeta.TransferType

type LiquidityMonitoringParameters struct {
	TargetStakeParameters *TargetStakeParameters `json:"targetStakeParameters,omitempty"`
	TriggeringRatio       string                 `json:"triggeringRatio,omitempty"`
	AuctionExtension      int64                  `json:"auctionExtension,omitempty"`
}

type LiquidityOrderReference struct {
	*zeta.LiquidityOrderReference
}

type LiquidityProvision struct {
	ID               LiquidityProvisionID
	PartyID          PartyID
	CreatedAt        time.Time
	UpdatedAt        time.Time
	MarketID         MarketID
	CommitmentAmount decimal.Decimal
	Fee              decimal.Decimal
	Sells            []LiquidityOrderReference
	Buys             []LiquidityOrderReference
	Version          int64
	Status           LiquidityProvisionStatus
	Reference        string
	TxHash           TxHash
	ZetaTime         time.Time
}

type LiquidityProvisionCursor struct {
	ZetaTime time.Time            `json:"zetaTime"`
	ID       LiquidityProvisionID `json:"id"`
}

type LiquidityProvisionID = ID[_LiquidityProvision]

type LiquidityProvisionKey struct {
	ID       LiquidityProvisionID
	ZetaTime time.Time
}

type LiquidityProvisionStatus zeta.LiquidityProvision_Status

type MarginCursor struct {
	ZetaTime  time.Time
	AccountID AccountID
}

type MarginLevels struct {
	AccountID              AccountID
	MaintenanceMargin      decimal.Decimal
	SearchLevel            decimal.Decimal
	InitialMargin          decimal.Decimal
	CollateralReleaseLevel decimal.Decimal
	Timestamp              time.Time
	TxHash                 TxHash
	ZetaTime               time.Time
}

type MarginLevelsKey struct {
	AccountID AccountID
	ZetaTime  time.Time
}

type Market struct {
	ID                            MarketID
	TxHash                        TxHash
	ZetaTime                      time.Time
	InstrumentID                  string
	TradableInstrument            TradableInstrument
	DecimalPlaces                 int
	Fees                          Fees
	OpeningAuction                AuctionDuration
	PriceMonitoringSettings       PriceMonitoringSettings
	LiquidityMonitoringParameters LiquidityMonitoringParameters
	TradingMode                   MarketTradingMode
	State                         MarketState
	MarketTimestamps              MarketTimestamps
	PositionDecimalPlaces         int
	LpPriceRange                  string
	LinearSlippageFactor          *decimal.Decimal
	QuadraticSlippageFactor       *decimal.Decimal
}

type MarketCursor struct {
	ZetaTime time.Time `json:"zetaTime"`
	ID       MarketID  `json:"id"`
}

type MarketData struct {
	// Mark price, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	MarkPrice decimal.Decimal
	// Highest price level on an order book for buy orders, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	BestBidPrice decimal.Decimal
	// Aggregated volume being bid at the best bid price
	BestBidVolume uint64
	// Aggregated volume being bid at the best bid price
	BestOfferPrice decimal.Decimal
	// Aggregated volume being offered at the best offer price, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	BestOfferVolume uint64
	// Highest price on the order book for buy orders not including pegged orders
	BestStaticBidPrice decimal.Decimal
	// Total volume at the best static bid price excluding pegged orders
	BestStaticBidVolume uint64
	// Lowest price on the order book for sell orders not including pegged orders
	BestStaticOfferPrice decimal.Decimal
	// Total volume at the best static offer price excluding pegged orders
	BestStaticOfferVolume uint64
	// Arithmetic average of the best bid price and best offer price, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	MidPrice decimal.Decimal
	// Arithmetic average of the best static bid price and best static offer price
	StaticMidPrice decimal.Decimal
	// Market identifier for the data
	Market MarketID
	// The sum of the size of all positions greater than 0 on the market
	OpenInterest uint64
	// Time in seconds until the end of the auction (0 if currently not in auction period)
	AuctionEnd int64
	// Time until next auction (used in FBA's) - currently always 0
	AuctionStart int64
	// Indicative price (zero if not in auction)
	IndicativePrice decimal.Decimal
	// Indicative volume (zero if not in auction)
	IndicativeVolume uint64
	// The current trading mode for the market
	MarketTradingMode string
	// The current trading mode for the market
	MarketState string
	// When a market is in an auction trading mode, this field indicates what triggered the auction
	AuctionTrigger string
	// When a market auction is extended, this field indicates what caused the extension
	ExtensionTrigger string
	// Targeted stake for the given market
	TargetStake decimal.Decimal
	// Available stake for the given market
	SuppliedStake decimal.Decimal
	// One or more price monitoring bounds for the current timestamp
	PriceMonitoringBounds []*types.PriceMonitoringBounds
	// the market value proxy
	MarketValueProxy string
	// the equity like share of liquidity fee for each liquidity provider
	LiquidityProviderFeeShares []*types.LiquidityProviderFeeShare
	// A synthetic time created which is the sum of zeta_time + (seq num * Microsecond)
	SyntheticTime time.Time
	// Transaction which caused this update
	TxHash TxHash
	// Zeta Block time at which the data was received from Zeta Node
	ZetaTime time.Time
	// SeqNum is the order in which the market data was received in the block
	SeqNum uint64
	// NextMarkToMarket is the next timestamp when the market wil be marked to market
	NextMarkToMarket time.Time
}

type MarketDataCursor struct {
	SyntheticTime time.Time `json:"synthetic_time"`
}

type MarketDepth struct {
	// Which market is this for
	MarketID string
	// All of the orders in the order book
	LiveOrders map[string]*types.Order
	// Just the buy side of the book
	BuySide []*PriceLevel
	// Just the sell side of the book
	SellSide []*PriceLevel
	// All price levels that have changed in the last update
	Changes []*PriceLevel
	// Sequence number is an increment-only value to identify a state
	// of the market depth in time. Used when trying to match updates
	// to a snapshot dump
	SequenceNumber uint64
	// PreviousSequenceNumber is the sequence number of the last published update. 'Changes' include
	// updates from all events with a sequence number > PreviousSequenceNumber and <= SequenceNumber
	PreviousSequenceNumber uint64
}

type MarketID = ID[_Market]

type MarketState zeta.Market_State

type MarketTimestamps struct {
	Proposed int64 `json:"proposed,omitempty"`
	Pending  int64 `json:"pending,omitempty"`
	Open     int64 `json:"open,omitempty"`
	Close    int64 `json:"close,omitempty"`
}

type MarketTradingMode zeta.Market_TradingMode

type NetworkLimits struct {
	TxHash                   TxHash
	ZetaTime                 time.Time
	CanProposeMarket         bool
	CanProposeAsset          bool
	ProposeMarketEnabled     bool
	ProposeAssetEnabled      bool
	GenesisLoaded            bool
	ProposeMarketEnabledFrom time.Time
	ProposeAssetEnabledFrom  time.Time
}

type NetworkParameter struct {
	Key      string
	Value    string
	TxHash   TxHash
	ZetaTime time.Time
}

type NetworkParameterCursor struct {
	Key string
}

type Node struct {
	ID                NodeID
	PubKey            ZetaPublicKey       `db:"zeta_pub_key"`
	TmPubKey          TendermintPublicKey `db:"tendermint_pub_key"`
	EthereumAddress   EthereumAddress
	InfoURL           string
	Location          string
	Status            NodeStatus
	Name              string
	AvatarURL         string
	TxHash            TxHash
	ZetaTime          time.Time
	StakedByOperator  decimal.Decimal
	StakedByDelegates decimal.Decimal
	StakedTotal       decimal.Decimal
	MaxIntendedStake  decimal.Decimal
	PendingStake      decimal.Decimal
	EpochData         EpochData
	Delegations       []Delegation  `json:""`
	RewardScore       *RewardScore  `json:""`
	RankingScore      *RankingScore `json:""`
}

type NodeBasic struct {
	ID              NodeID
	PubKey          ZetaPublicKey       `db:"zeta_pub_key"`
	TmPubKey        TendermintPublicKey `db:"tendermint_pub_key"`
	EthereumAddress EthereumAddress
	InfoURL         string
	Location        string
	Status          NodeStatus
	Name            string
	AvatarURL       string
	TxHash          TxHash
	ZetaTime        time.Time
}

type NodeCursor struct {
	ID NodeID `json:"id"`
}

type NodeData struct {
	StakedTotal     decimal.Decimal
	TotalNodes      uint32
	InactiveNodes   uint32
	TendermintNodes NodeSet
	ErsatzNodes     NodeSet
	PendingNodes    NodeSet
	Uptime          float64
	ZetaTime        time.Time
}

type NodeID = ID[_Node]

type NodeSet struct {
	Total    uint32
	Inactive uint32
	Promoted []string
	Demoted  []string
	Maximum  uint32
}

type NodeSignature struct {
	ResourceID NodeSignatureID
	Sig        []byte
	Kind       NodeSignatureKind
	TxHash     TxHash
	ZetaTime   time.Time
}

type NodeSignatureCursor struct {
	ResourceID NodeSignatureID `json:"resource_id"`
	Sig        []byte          `json:"sig"`
}

type NodeSignatureID = ID[_NodeSignature]

type NodeSignatureKind commandspb.NodeSignatureKind

type NodeStatus zeta.NodeStatus

type NotaryService interface {
	GetByResourceID(ctx context.Context, id string, pagination CursorPagination) ([]NodeSignature, PageInfo, error)
}

type OracleData struct {
	ExternalData *ExternalData
}

type OracleDataCursor = ExternalDataCursor

type OracleSpec struct {
	ExternalDataSourceSpec *ExternalDataSourceSpec
}

type OracleSpecStatus = DataSourceSpecStatus

type Order struct {
	ID              OrderID
	MarketID        MarketID
	PartyID         PartyID
	Side            Side
	Price           decimal.Decimal
	Size            int64
	Remaining       int64
	TimeInForce     OrderTimeInForce
	Type            OrderType
	Status          OrderStatus
	Reference       string
	Reason          OrderError
	Version         int32
	PeggedOffset    decimal.Decimal
	BatchID         int32
	PeggedReference PeggedReference
	LpID            []byte
	CreatedAt       time.Time
	UpdatedAt       time.Time
	ExpiresAt       time.Time
	TxHash          TxHash
	ZetaTime        time.Time
	SeqNum          uint64
	PostOnly        bool
	ReduceOnly      bool
}

type OrderCursor struct {
	CreatedAt time.Time `json:"createdAt"`
	ID        OrderID   `json:"id"`
	ZetaTime  time.Time `json:"zetaTime"`
}

type OrderError = zeta.OrderError

type OrderFilter struct {
	Statuses         []zeta.Order_Status
	Types            []zeta.Order_Type
	TimeInForces     []zeta.Order_TimeInForce
	Reference        *string
	DateRange        *DateRange
	ExcludeLiquidity bool
	LiveOnly         bool
	PartyIDs         []string
	MarketIDs        []string
}

type OrderID = ID[_Order]

type OrderKey struct {
	ID       OrderID
	Version  int32
	ZetaTime time.Time
}

type OrderStatus = zeta.Order_Status

type OrderTimeInForce = zeta.Order_TimeInForce

type OrderType = zeta.Order_Type

type PageInfo struct {
	HasNextPage     bool
	HasPreviousPage bool
	StartCursor     string
	EndCursor       string
}

type PagedEntity[T proto.Message] interface {
	Entities | Transfer | MarginLevels

	// ToProtoEdge may need some optional arguments in order to generate the proto, for example margin levels
	// requires an account source. This is not ideal, but we can come back to this later if a better solution can be found.
	ToProtoEdge(...any) (T, error)
	Cursor() *Cursor
}

type Pagination interface{}

type Party struct {
	ID       PartyID
	TxHash   TxHash
	ZetaTime *time.Time // Can be NULL for built-in party 'network'
}

type PartyID = ID[_Party]

type PeggedReference = zeta.PeggedReference

type Position struct {
	MarketID                MarketID
	PartyID                 PartyID
	OpenVolume              int64
	RealisedPnl             decimal.Decimal
	UnrealisedPnl           decimal.Decimal
	AverageEntryPrice       decimal.Decimal
	AverageEntryMarketPrice decimal.Decimal
	Loss                    decimal.Decimal // what the party lost because of loss socialization
	Adjustment              decimal.Decimal // what a party was missing which triggered loss socialization
	TxHash                  TxHash
	ZetaTime                time.Time
	// keep track of trades that haven't been settled as separate fields
	// these will be zeroed out once we process settlement events
	PendingOpenVolume              int64
	PendingRealisedPnl             decimal.Decimal
	PendingUnrealisedPnl           decimal.Decimal
	PendingAverageEntryPrice       decimal.Decimal
	PendingAverageEntryMarketPrice decimal.Decimal
	LossSocialisationAmount        decimal.Decimal
	DistressedStatus               PositionStatus
}