entities

package
v0.54.1-nocontractcheck Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 18, 2022 License: MIT Imports: 25 Imported by: 5

Documentation

Index

Constants

View Source 
const (
	AccountFieldUnspecified = iota
	AccountFieldID
	AccountFieldPartyID
	AccountFieldAssetID
	AccountFieldMarketID
	AccountFieldType
)
View Source 
const (
	OneOffStr    = "OneOff"
	RecurringStr = "Recurring"
	UnknownStr   = "Unknown"
)
View Source 
const (
	TransferStatusUnspecified = TransferStatus(eventspb.Transfer_STATUS_UNSPECIFIED)
	TransferStatusPending     = TransferStatus(eventspb.Transfer_STATUS_PENDING)
	TransferStatusDone        = TransferStatus(eventspb.Transfer_STATUS_DONE)
	TransferStatusRejected    = TransferStatus(eventspb.Transfer_STATUS_REJECTED)
	TransferStatusStopped     = TransferStatus(eventspb.Transfer_STATUS_STOPPED)
	TransferStatusCancelled   = TransferStatus(eventspb.Transfer_STATUS_CANCELLED)
)
View Source 
const (
	AssetStatusUnspecified    = AssetStatus(vega.Asset_STATUS_UNSPECIFIED)
	AssetStatusProposed       = AssetStatus(vega.Asset_STATUS_PROPOSED)
	AssetStatusRejected       = AssetStatus(vega.Asset_STATUS_REJECTED)
	AssetStatusPendingListing = AssetStatus(vega.Asset_STATUS_PENDING_LISTING)
	AssetStatusEnabled        = AssetStatus(vega.Asset_STATUS_ENABLED)
)
View Source 
const (
	MarketTradingModeUnspecified       = MarketTradingMode(vega.Market_TRADING_MODE_UNSPECIFIED)
	MarketTradingModeContinuous        = MarketTradingMode(vega.Market_TRADING_MODE_CONTINUOUS)
	MarketTradingModeBatchAuction      = MarketTradingMode(vega.Market_TRADING_MODE_BATCH_AUCTION)
	MarketTradingModeOpeningAuction    = MarketTradingMode(vega.Market_TRADING_MODE_OPENING_AUCTION)
	MarketTradingModeMonitoringAuction = MarketTradingMode(vega.Market_TRADING_MODE_MONITORING_AUCTION)
	MarketTradingModeNoTrading         = MarketTradingMode(vega.Market_TRADING_MODE_NO_TRADING)
)
View Source 
const (
	MarketStateUnspecified       = MarketState(vega.Market_STATE_UNSPECIFIED)
	MarketStateProposed          = MarketState(vega.Market_STATE_PROPOSED)
	MarketStateRejected          = MarketState(vega.Market_STATE_REJECTED)
	MarketStatePending           = MarketState(vega.Market_STATE_PENDING)
	MarketStateCancelled         = MarketState(vega.Market_STATE_CANCELLED)
	MarketStateActive            = MarketState(vega.Market_STATE_ACTIVE)
	MarketStateSuspended         = MarketState(vega.Market_STATE_SUSPENDED)
	MarketStateClosed            = MarketState(vega.Market_STATE_CLOSED)
	MarketStateTradingTerminated = MarketState(vega.Market_STATE_TRADING_TERMINATED)
	MarketStateSettled           = MarketState(vega.Market_STATE_SETTLED)
)
View Source 
const (
	DepositStatusUnspecified = DepositStatus(vega.Deposit_STATUS_UNSPECIFIED)
	DepositStatusOpen        = DepositStatus(vega.Deposit_STATUS_OPEN)
	DepositStatusCancelled   = DepositStatus(vega.Deposit_STATUS_CANCELLED)
	DepositStatusFinalized   = DepositStatus(vega.Deposit_STATUS_FINALIZED)
)
View Source 
const (
	WithdrawalStatusUnspecified = WithdrawalStatus(vega.Withdrawal_STATUS_UNSPECIFIED)
	WithdrawalStatusOpen        = WithdrawalStatus(vega.Withdrawal_STATUS_OPEN)
	WithdrawalStatusRejected    = WithdrawalStatus(vega.Withdrawal_STATUS_REJECTED)
	WithdrawalStatusFinalized   = WithdrawalStatus(vega.Withdrawal_STATUS_FINALIZED)
)
View Source 
const (
	ProposalStateUnspecified        = ProposalState(vega.Proposal_STATE_UNSPECIFIED)
	ProposalStateFailed             = ProposalState(vega.Proposal_STATE_FAILED)
	ProposalStateOpen               = ProposalState(vega.Proposal_STATE_OPEN)
	ProposalStatePassed             = ProposalState(vega.Proposal_STATE_PASSED)
	ProposalStateRejected           = ProposalState(vega.Proposal_STATE_REJECTED)
	ProposalStateDeclined           = ProposalState(vega.Proposal_STATE_DECLINED)
	ProposalStateEnacted            = ProposalState(vega.Proposal_STATE_ENACTED)
	ProposalStateWaitingForNodeVote = ProposalState(vega.Proposal_STATE_WAITING_FOR_NODE_VOTE)
)
View Source 
const (
	ProposalErrorUnspecified                      = ProposalError(vega.ProposalError_PROPOSAL_ERROR_UNSPECIFIED)
	ProposalErrorCloseTimeTooSoon                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_CLOSE_TIME_TOO_SOON)
	ProposalErrorCloseTimeTooLate                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_CLOSE_TIME_TOO_LATE)
	ProposalErrorEnactTimeTooSoon                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_ENACT_TIME_TOO_SOON)
	ProposalErrorEnactTimeTooLate                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_ENACT_TIME_TOO_LATE)
	ProposalErrorInsufficientTokens               = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INSUFFICIENT_TOKENS)
	ProposalErrorInvalidInstrumentSecurity        = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_INSTRUMENT_SECURITY)
	ProposalErrorNoProduct                        = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NO_PRODUCT)
	ProposalErrorUnsupportedProduct               = ProposalError(vega.ProposalError_PROPOSAL_ERROR_UNSUPPORTED_PRODUCT)
	ProposalErrorNoTradingMode                    = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NO_TRADING_MODE)
	ProposalErrorUnsupportedTradingMode           = ProposalError(vega.ProposalError_PROPOSAL_ERROR_UNSUPPORTED_TRADING_MODE)
	ProposalErrorNodeValidationFailed             = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NODE_VALIDATION_FAILED)
	ProposalErrorMissingBuiltinAssetField         = ProposalError(vega.ProposalError_PROPOSAL_ERROR_MISSING_BUILTIN_ASSET_FIELD)
	ProposalErrorMissingErc20ContractAddress      = ProposalError(vega.ProposalError_PROPOSAL_ERROR_MISSING_ERC20_CONTRACT_ADDRESS)
	ProposalErrorInvalidAsset                     = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_ASSET)
	ProposalErrorIncompatibleTimestamps           = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INCOMPATIBLE_TIMESTAMPS)
	ProposalErrorNoRiskParameters                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NO_RISK_PARAMETERS)
	ProposalErrorNetworkParameterInvalidKey       = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_INVALID_KEY)
	ProposalErrorNetworkParameterInvalidValue     = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_INVALID_VALUE)
	ProposalErrorNetworkParameterValidationFailed = ProposalError(vega.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_VALIDATION_FAILED)
	ProposalErrorOpeningAuctionDurationTooSmall   = ProposalError(vega.ProposalError_PROPOSAL_ERROR_OPENING_AUCTION_DURATION_TOO_SMALL)
	ProposalErrorOpeningAuctionDurationTooLarge   = ProposalError(vega.ProposalError_PROPOSAL_ERROR_OPENING_AUCTION_DURATION_TOO_LARGE)
	ProposalErrorMarketMissingLiquidityCommitment = ProposalError(vega.ProposalError_PROPOSAL_ERROR_MARKET_MISSING_LIQUIDITY_COMMITMENT)
	ProposalErrorCouldNotInstantiateMarket        = ProposalError(vega.ProposalError_PROPOSAL_ERROR_COULD_NOT_INSTANTIATE_MARKET)
	ProposalErrorInvalidFutureProduct             = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_FUTURE_PRODUCT)
	ProposalErrorMissingCommitmentAmount          = ProposalError(vega.ProposalError_PROPOSAL_ERROR_MISSING_COMMITMENT_AMOUNT)
	ProposalErrorInvalidFeeAmount                 = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_FEE_AMOUNT)
	ProposalErrorInvalidShape                     = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_SHAPE)
	ProposalErrorInvalidRiskParameter             = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_RISK_PARAMETER)
	ProposalErrorMajorityThresholdNotReached      = ProposalError(vega.ProposalError_PROPOSAL_ERROR_MAJORITY_THRESHOLD_NOT_REACHED)
	ProposalErrorParticipationThresholdNotReached = ProposalError(vega.ProposalError_PROPOSAL_ERROR_PARTICIPATION_THRESHOLD_NOT_REACHED)
	ProposalErrorInvalidAssetDetails              = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_ASSET_DETAILS)
	ProposalErrorUnknownType                      = ProposalError(vega.ProposalError_PROPOSAL_ERROR_UNKNOWN_TYPE)
	ProposalErrorUnknownRiskParameterType         = ProposalError(vega.ProposalError_PROPOSAL_ERROR_UNKNOWN_RISK_PARAMETER_TYPE)
	ProposalErrorInvalidFreeform                  = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_FREEFORM)
	ProposalErrorInsufficientEquityLikeShare      = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INSUFFICIENT_EQUITY_LIKE_SHARE)
	ProposalErrorInvalidMarket                    = ProposalError(vega.ProposalError_PROPOSAL_ERROR_INVALID_MARKET)
	ProposalErrorTooManyMarketDecimalPlaces       = ProposalError(vega.ProposalError_PROPOSAL_ERROR_TOO_MANY_MARKET_DECIMAL_PLACES)
	ProposalErrorTooManyPriceMonitoringTriggers   = ProposalError(vega.ProposalError_PROPOSAL_ERROR_TOO_MANY_PRICE_MONITORING_TRIGGERS)
)
View Source 
const (
	VoteValueUnspecified = VoteValue(vega.Vote_VALUE_UNSPECIFIED)
	VoteValueNo          = VoteValue(vega.Vote_VALUE_NO)
	VoteValueYes         = VoteValue(vega.Vote_VALUE_YES)
)
View Source 
const (
	NodeSignatureKindUnspecified          = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_UNSPECIFIED)
	NodeSignatureKindAsset                = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_NEW)
	NodeSignatureKindAssetUpdate          = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_UPDATE)
	NodeSignatureKindAssetWithdrawal      = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_WITHDRAWAL)
	NodeSignatureKindMultisigSignerAdded  = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ERC20_MULTISIG_SIGNER_ADDED)
	NodeSignatureKindMultisigSignerRemove = NodeSignatureKind(commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ERC20_MULTISIG_SIGNER_REMOVED)
)
View Source 
const (
	OracleSpecUnspecified = OracleSpecStatus(v1.OracleSpec_STATUS_UNSPECIFIED)
	OracleSpecActive      = OracleSpecStatus(v1.OracleSpec_STATUS_ACTIVE)
	OracleSpecDeactivated = OracleSpecStatus(v1.OracleSpec_STATUS_DEACTIVATED)
)
View Source 
const (
	LiquidityProvisionStatusUnspecified = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_UNSPECIFIED)
	LiquidityProvisionStatusActive      = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_ACTIVE)
	LiquidityProvisionStatusStopped     = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_STOPPED)
	LiquidityProvisionStatusCancelled   = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_CANCELLED)
	LiquidityProvisionStatusRejected    = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_REJECTED)
	LiquidityProvisionStatusUndeployed  = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_UNDEPLOYED)
	LiquidityProvisionStatusPending     = LiquidityProvisionStatus(vega.LiquidityProvision_STATUS_PENDING)
)
View Source 
const (
	StakeLinkingStatusUnspecified = StakeLinkingStatus(eventspb.StakeLinking_STATUS_UNSPECIFIED)
	StakeLinkingStatusPending     = StakeLinkingStatus(eventspb.StakeLinking_STATUS_PENDING)
	StakeLinkingStatusAccepted    = StakeLinkingStatus(eventspb.StakeLinking_STATUS_ACCEPTED)
	StakeLinkingStatusRejected    = StakeLinkingStatus(eventspb.StakeLinking_STATUS_REJECTED)
)
View Source 
const (
	StakeLinkingTypeUnspecified = StakeLinkingType(eventspb.StakeLinking_TYPE_UNSPECIFIED)
	StakeLinkingTypeLink        = StakeLinkingType(eventspb.StakeLinking_TYPE_LINK)
	StakeLinkingTypeUnlink      = StakeLinkingType(eventspb.StakeLinking_TYPE_UNLINK)
)
View Source 
const (
	NodeStatusUnspecified  = NodeStatus(vega.NodeStatus_NODE_STATUS_UNSPECIFIED)
	NodeStatusValidator    = NodeStatus(vega.NodeStatus_NODE_STATUS_VALIDATOR)
	NodeStatusNonValidator = NodeStatus(vega.NodeStatus_NODE_STATUS_NON_VALIDATOR)
)
View Source 
const (
	ValidatorNodeStatusUnspecified = ValidatorNodeStatus(vega.ValidatorNodeStatus_VALIDATOR_NODE_STATUS_UNSPECIFIED)
	ValidatorNodeStatusTendermint  = ValidatorNodeStatus(vega.ValidatorNodeStatus_VALIDATOR_NODE_STATUS_TENDERMINT)
	ValidatorNodeStatusErsatz      = ValidatorNodeStatus(vega.ValidatorNodeStatus_VALIDATOR_NODE_STATUS_ERSATZ)
	ValidatorNodeStatusPending     = ValidatorNodeStatus(vega.ValidatorNodeStatus_VALIDATOR_NODE_STATUS_PENDING)
)

Variables

View Source 
var (
	ErrChainNotFound   = errors.New("chain not found")
	ErrChainAlreadySet = errors.New("chain already set")
)
View Source 
var (
	ProposalTypeNewMarket              = ProposalType("newMarket")
	ProposalTypeNewAsset               = ProposalType("newAsset")
	ProposalTypeUpdateAsset            = ProposalType("updateAsset")
	ProposalTypeUpdateMarket           = ProposalType("updateMarket")
	ProposalTypeUpdateNetworkParameter = ProposalType("updateNetworkParameter")
	ProposalTypeNewFreeform            = ProposalType("newFreeform")
)
View Source 
var BalanceColumns = []string{"account_id", "vega_time", "balance"}
View Source 
var ErrInvalidID = errors.New("not a valid hex ID (or well known exception)")
View Source 
var ErrMarketDataIntegerOverflow = errors.New("integer overflow encountered when converting market data for persistence")
View Source 
var LedgerEntryColumns = []string{
	"account_from_id", "account_to_id", "quantity",
	"vega_time", "transfer_time", "reference", "type",
}
View Source 
var LiquidityProvisionColumns = []string{
	"id", "party_id", "created_at", "updated_at", "market_id",
	"commitment_amount", "fee", "sells", "buys", "version",
	"status", "reference", "vega_time",
}
View Source 
var MarginLevelsColumns = []string{
	"account_id", "timestamp", "maintenance_margin",
	"search_level", "initial_margin", "collateral_release_level", "vega_time",
}
View Source 
var OrderColumns = []string{
	"id", "market_id", "party_id", "side", "price",
	"size", "remaining", "time_in_force", "type", "status",
	"reference", "reason", "version", "pegged_offset", "batch_id",
	"pegged_reference", "lp_id", "created_at", "updated_at", "expires_at",
	"vega_time", "seq_num",
}
View Source 
var PositionColumns = []string{
	"market_id", "party_id", "open_volume", "realised_pnl", "unrealised_pnl",
	"average_entry_price", "loss", "adjustment", "vega_time",
}

Functions

func NanosToPostgresTimestamp 

func NanosToPostgresTimestamp(nanos int64) time.Time

NanosToPostgresTimestamp postgres stores timestamps in microsecond resolution.

func NodeFromValidatorUpdateEvent 

func NodeFromValidatorUpdateEvent(evt eventspb.ValidatorUpdate, vegaTime time.Time) (Node, ValidatorUpdateAux, error)

func RankingScoreFromRankingEvent 

func RankingScoreFromRankingEvent(evt eventspb.ValidatorRankingEvent, vegaTime time.Time) (RankingScore, RankingScoreAux, error)

func ReverseSlice 

func ReverseSlice[T any](input []T) (reversed []T)

func RewardScoreFromScoreEvent 

func RewardScoreFromScoreEvent(evt eventspb.ValidatorScoreEvent, vegaTime time.Time) (RewardScore, RewardScoreAux, error)

Types

type Account 

type Account struct {
	ID       int64
	PartyID  PartyID
	AssetID  AssetID
	MarketID MarketID
	Type     vega.AccountType
	VegaTime time.Time
}

func AccountFromAccountID 

func AccountFromAccountID(id string) (Account, error)

AccountFromAccountID takes an ID generated by vega core and uses the information in it to create an account struct. In vega core, account IDs are generated by concatenating (party id, market id, asset id, account type) with '!' indicating no market, and "*" indicating the system owner party. (see collateral/engine.go). It's a bit unfortunate that this internal detail leaks out of core, but it's required for now as it's the only way we can extract all the required account information out of an TransferResponse message.

func AccountFromProto 

func AccountFromProto(va *vega.Account) (Account, error)

func GetAccountFromMarginLevel 

func GetAccountFromMarginLevel(ctx context.Context, margin *vega.MarginLevels, accountSource AccountSource, vegaTime time.Time) (Account, error)

func (Account) String 

func (a Account) String() string

type AccountBalance 

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

func (AccountBalance) Cursor 

func (b AccountBalance) Cursor() *Cursor

func (AccountBalance) Equal 

func (b AccountBalance) Equal(other AccountBalance) bool

func (AccountBalance) Key 

func (b AccountBalance) Key() AccountBalanceKey

func (*AccountBalance) ToProto 

func (ab *AccountBalance) ToProto() *vega.Account

func (AccountBalance) ToProtoEdge 

func (ab AccountBalance) ToProtoEdge(_ ...any) (*v2.AccountEdge, error)

func (AccountBalance) ToRow 

func (b AccountBalance) ToRow() []interface{}

type AccountBalanceKey 

type AccountBalanceKey struct {
	AccountID int64
	VegaTime  time.Time
}

type AccountCursor 

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

func (*AccountCursor) Parse 

func (ac *AccountCursor) Parse(cursorString string) error

func (AccountCursor) String 

func (ac AccountCursor) String() string

type AccountField 

type AccountField int64

AccountField is an enumeration of the properties of an account which can be used for grouping and sorting.

func AccountFieldFromProto 

func AccountFieldFromProto(field v2.AccountField) (AccountField, error)

func (AccountField) String 

func (s AccountField) String() string

type AccountFilter 

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

func AccountFilterFromProto 

func AccountFilterFromProto(pbFilter *v2.AccountFilter) (AccountFilter, error)

type AccountSource 

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

type AggregatedBalance 

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

AggregatedBalance represents the the summed balance of a bunch of accounts at a given time. VegaTime and Balance will always be set. The others will be nil unless when querying, you requested grouping by one of the corresponding fields.

func (*AggregatedBalance) ToProto 

func (balance *AggregatedBalance) ToProto() v2.AggregatedBalance

type Asset 

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

func (Asset) Cursor 

func (a Asset) Cursor() *Cursor

func (Asset) ToProto 

func (a Asset) ToProto() *pb.Asset

func (Asset) ToProtoEdge 

func (a Asset) ToProtoEdge(_ ...any) (*v2.AssetEdge, error)

type AssetCursor 

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

func (*AssetCursor) Parse 

func (ac *AssetCursor) Parse(cursorString string) error

func (AssetCursor) String 

func (ac AssetCursor) String() string

type AssetID 

type AssetID = ID[_Asset]

type AssetStatus 

type AssetStatus vega.Asset_Status

func (*AssetStatus) DecodeText 

func (m *AssetStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (AssetStatus) EncodeText 

func (m AssetStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type AuctionDuration 

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

type Balance 

type Balance struct {
	AccountID int64
	VegaTime  time.Time
	Balance   decimal.Decimal
}

func (Balance) Key 

func (b Balance) Key() BalanceKey

func (Balance) ToRow 

func (b Balance) ToRow() []interface{}

type BalanceKey 

type BalanceKey struct {
	AccountID int64
	VegaTime  time.Time
}

type Block 

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

func BlockFromTimeUpdate 

func BlockFromTimeUpdate(te TimeUpdateEvent) (*Block, error)

type Candle 

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

func (Candle) Cursor 

func (c Candle) Cursor() *Cursor

func (Candle) ToProtoEdge 

func (c Candle) ToProtoEdge(_ ...any) (*v2.CandleEdge, error)

func (*Candle) ToV1CandleProto 

func (c *Candle) ToV1CandleProto(interval vega.Interval) (*vega.Candle, error)

func (*Candle) ToV2CandleProto 

func (c *Candle) ToV2CandleProto() *v2.Candle

type CandleCursor 

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

func (*CandleCursor) Parse 

func (c *CandleCursor) Parse(cursorString string) error

func (CandleCursor) String 

func (c CandleCursor) String() string

type Chain 

type Chain struct {
	ID string
}

type Checkpoint 

type Checkpoint struct {
	Hash        string
	BlockHash   string
	BlockHeight int64
	VegaTime    time.Time
}

func CheckpointFromProto 

func CheckpointFromProto(cpe *eventspb.CheckpointEvent) (Checkpoint, error)

func (Checkpoint) Cursor 

func (cp Checkpoint) Cursor() *Cursor

func (*Checkpoint) ToProto 

func (cp *Checkpoint) ToProto() *v2.Checkpoint

func (Checkpoint) ToProtoEdge 

func (cp Checkpoint) ToProtoEdge(_ ...any) (*v2.CheckpointEdge, error)

func (*Checkpoint) ToV1Proto 

func (cp *Checkpoint) ToV1Proto() *protoapi.Checkpoint

type CheckpointCursor 

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

func (*CheckpointCursor) Parse 

func (cp *CheckpointCursor) Parse(cursorString string) error

func (CheckpointCursor) String 

func (cp CheckpointCursor) String() string

type Condition 

type Condition struct {
	Operator v1.Condition_Operator
	Value    string
}

type Cursor 

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

func NewCursor 

func NewCursor(cursor string) *Cursor

func (*Cursor) Decode 

func (c *Cursor) Decode(value string) error

func (*Cursor) Encode 

func (c *Cursor) Encode() string

func (*Cursor) IsSet 

func (c *Cursor) IsSet() bool

func (*Cursor) Value 

func (c *Cursor) Value() string

type CursorPagination 

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

func CursorPaginationFromProto 

func CursorPaginationFromProto(cp *v2.Pagination) (CursorPagination, error)

func DefaultCursorPagination 

func DefaultCursorPagination(newestFirst bool) CursorPagination

func NewCursorPagination 

func NewCursorPagination(first *int32, after *string, last *int32, before *string, newestFirst bool) (CursorPagination, error)

func (CursorPagination) HasBackward 

func (p CursorPagination) HasBackward() bool

func (CursorPagination) HasForward 

func (p CursorPagination) HasForward() bool

type Delegation 

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

func DelegationFromEventProto 

func DelegationFromEventProto(pd *eventspb.DelegationBalanceEvent) (Delegation, error)

func DelegationFromProto 

func DelegationFromProto(pd *vega.Delegation) (Delegation, error)

func (Delegation) Cursor 

func (d Delegation) Cursor() *Cursor

func (Delegation) String 

func (d Delegation) String() string

func (*Delegation) ToProto 

func (d *Delegation) ToProto() *vega.Delegation

func (Delegation) ToProtoEdge 

func (d Delegation) ToProtoEdge(_ ...any) (*v2.DelegationEdge, error)

type DelegationCursor 

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

func (*DelegationCursor) Parse 

func (c *DelegationCursor) Parse(cursorString string) error

func (DelegationCursor) String 

func (c DelegationCursor) String() string

type Deposit 

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

func DepositFromProto 

func DepositFromProto(deposit *vega.Deposit, vegaTime time.Time) (*Deposit, error)

func (Deposit) Cursor 

func (d Deposit) Cursor() *Cursor

func (Deposit) ToProto 

func (d Deposit) ToProto() *vega.Deposit

func (Deposit) ToProtoEdge 

func (d Deposit) ToProtoEdge(_ ...any) (*v2.DepositEdge, error)

type DepositCursor 

type DepositCursor struct {
	VegaTime time.Time `json:"vegaTime"`
	ID       DepositID `json:"id"`
}

func (*DepositCursor) Parse 

func (dc *DepositCursor) Parse(cursorString string) error

func (DepositCursor) String 

func (dc DepositCursor) String() string

type DepositID 

type DepositID = ID[_Deposit]

type DepositStatus 

type DepositStatus vega.Deposit_Status

func (*DepositStatus) DecodeText 

func (s *DepositStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (DepositStatus) EncodeText 

func (s DepositStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type ERC20MultiSigSignerAddedEvent 

type ERC20MultiSigSignerAddedEvent struct {
	ERC20MultiSigSignerEvent
}

func (ERC20MultiSigSignerAddedEvent) Cursor 

func (e ERC20MultiSigSignerAddedEvent) Cursor() *Cursor

func (ERC20MultiSigSignerAddedEvent) ToProto 

func (e ERC20MultiSigSignerAddedEvent) ToProto() *eventspb.ERC20MultiSigSignerAdded

func (ERC20MultiSigSignerAddedEvent) ToProtoEdge 

func (e ERC20MultiSigSignerAddedEvent) ToProtoEdge(_ ...any) (*v2.ERC20MultiSigSignerAddedEdge, error)

type ERC20MultiSigSignerEvent 

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

func ERC20MultiSigSignerEventFromAddedProto 

func ERC20MultiSigSignerEventFromAddedProto(e *eventspb.ERC20MultiSigSignerAdded) (*ERC20MultiSigSignerEvent, error)

func ERC20MultiSigSignerEventFromRemovedProto 

func ERC20MultiSigSignerEventFromRemovedProto(e *eventspb.ERC20MultiSigSignerRemoved) ([]*ERC20MultiSigSignerEvent, error)

func (ERC20MultiSigSignerEvent) Cursor 

func (e ERC20MultiSigSignerEvent) Cursor() *Cursor

type ERC20MultiSigSignerEventCursor 

type ERC20MultiSigSignerEventCursor struct {
	VegaTime time.Time                  `json:"vega_time"`
	ID       ERC20MultiSigSignerEventID `json:"id"`
}

func (*ERC20MultiSigSignerEventCursor) Parse 

func (c *ERC20MultiSigSignerEventCursor) Parse(cursorString string) error

func (ERC20MultiSigSignerEventCursor) String 

func (c ERC20MultiSigSignerEventCursor) String() string

type ERC20MultiSigSignerEventID 

type ERC20MultiSigSignerEventID = ID[_ERC20MultiSigSignerEvent]

type ERC20MultiSigSignerEventType 

type ERC20MultiSigSignerEventType string
const (
	ERC20MultiSigSignerEventTypeAdded   ERC20MultiSigSignerEventType = "SIGNER_ADDED"
	ERC20MultiSigSignerEventTypeRemoved ERC20MultiSigSignerEventType = "SIGNER_REMOVED"
)

type ERC20MultiSigSignerRemovedEvent 

type ERC20MultiSigSignerRemovedEvent struct {
	ERC20MultiSigSignerEvent
}

func (ERC20MultiSigSignerRemovedEvent) Cursor 

func (e ERC20MultiSigSignerRemovedEvent) Cursor() *Cursor

func (ERC20MultiSigSignerRemovedEvent) ToProto 

func (e ERC20MultiSigSignerRemovedEvent) ToProto() *eventspb.ERC20MultiSigSignerRemoved

func (ERC20MultiSigSignerRemovedEvent) ToProtoEdge 

func (e ERC20MultiSigSignerRemovedEvent) ToProtoEdge(_ ...any) (*v2.ERC20MultiSigSignerRemovedEdge, error)

type Epoch 

type Epoch struct {
	ID         int64
	StartTime  time.Time
	ExpireTime time.Time
	EndTime    *time.Time
	VegaTime   time.Time
}

func EpochFromProto 

func EpochFromProto(ee eventspb.EpochEvent) Epoch

func (*Epoch) ToProto 

func (e *Epoch) ToProto() *vega.Epoch

type EpochData 

type EpochData struct {
	*vega.EpochData
}

func (EpochData) MarshalJSON 

func (ed EpochData) MarshalJSON() ([]byte, error)

func (*EpochData) UnmarshalJSON 

func (ed *EpochData) UnmarshalJSON(b []byte) error

type EthereumAddress 

type EthereumAddress string

func (*EthereumAddress) Bytes 

func (addr *EthereumAddress) Bytes() ([]byte, error)

func (*EthereumAddress) DecodeBinary 

func (addr *EthereumAddress) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error

func (EthereumAddress) EncodeBinary 

func (addr EthereumAddress) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error)

func (*EthereumAddress) Error 

func (addr *EthereumAddress) Error() error

func (*EthereumAddress) String 

func (addr *EthereumAddress) String() string

type EthereumKeyRotation 

type EthereumKeyRotation struct {
	NodeID      NodeID
	OldAddress  EthereumAddress
	NewAddress  EthereumAddress
	BlockHeight uint64
	VegaTime    time.Time
}

func EthereumKeyRotationFromProto 

func EthereumKeyRotationFromProto(kr *eventspb.EthereumKeyRotation, vegaTime time.Time) (EthereumKeyRotation, error)

func (EthereumKeyRotation) Cursor 

func (kr EthereumKeyRotation) Cursor() *Cursor

func (EthereumKeyRotation) ToProto 

func (kr EthereumKeyRotation) ToProto() *eventspb.EthereumKeyRotation

func (EthereumKeyRotation) ToProtoEdge 

func (kr EthereumKeyRotation) ToProtoEdge(_ ...any) (*v2.EthereumKeyRotationEdge, error)

type EthereumKeyRotationCursor 

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

func (*EthereumKeyRotationCursor) Parse 

func (ec *EthereumKeyRotationCursor) Parse(cursorString string) error

func (EthereumKeyRotationCursor) String 

func (ec EthereumKeyRotationCursor) String() string

type FeeFactors 

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

type Fees 

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

func (Fees) ToProto 

func (f Fees) ToProto() *vega.Fees

type Filter 

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

type ID 

type ID[T any] string

func (*ID[T]) Bytes 

func (id *ID[T]) Bytes() ([]byte, error)

func (*ID[T]) DecodeBinary 

func (id *ID[T]) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error

func (ID[T]) EncodeBinary 

func (id ID[T]) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error)

func (*ID[T]) Error 

func (id *ID[T]) Error() error

func (*ID[T]) String 

func (id *ID[T]) String() string

type KeyRotation 

type KeyRotation struct {
	NodeID      NodeID
	OldPubKey   VegaPublicKey
	NewPubKey   VegaPublicKey
	BlockHeight uint64
	VegaTime    time.Time
}

func KeyRotationFromProto 

func KeyRotationFromProto(kr *eventspb.KeyRotation, vegaTime time.Time) (*KeyRotation, error)

func (KeyRotation) Cursor 

func (kr KeyRotation) Cursor() *Cursor

func (*KeyRotation) ToProto 

func (kr *KeyRotation) ToProto() *eventspb.KeyRotation

func (KeyRotation) ToProtoEdge 

func (kr KeyRotation) ToProtoEdge(_ ...any) (*v2.KeyRotationEdge, error)

func (*KeyRotation) ToProtoV1 

func (kr *KeyRotation) ToProtoV1() *protoapi.KeyRotation

type KeyRotationCursor 

type KeyRotationCursor struct {
	VegaTime  time.Time     `json:"vega_time"`
	NodeID    NodeID        `json:"node_id"`
	OldPubKey VegaPublicKey `json:"old_pub_key"`
	NewPubKey VegaPublicKey `json:"new_pub_key"`
}

func (*KeyRotationCursor) Parse 

func (kr *KeyRotationCursor) Parse(cursorString string) error

func (KeyRotationCursor) String 

func (c KeyRotationCursor) String() string

type LedgerEntry 

type LedgerEntry struct {
	ID            int64
	AccountFromID int64
	AccountToID   int64
	Quantity      decimal.Decimal
	VegaTime      time.Time
	TransferTime  time.Time
	Reference     string
	Type          string
}

func (LedgerEntry) ToRow 

func (le LedgerEntry) ToRow() []any

type LiquidityMonitoringParameters 

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

func (LiquidityMonitoringParameters) ToProto 

func (lmp LiquidityMonitoringParameters) ToProto() *vega.LiquidityMonitoringParameters

type LiquidityOrderReference 

type LiquidityOrderReference struct {
	*vega.LiquidityOrderReference
}

func (*LiquidityOrderReference) DecodeBinary 

func (l *LiquidityOrderReference) DecodeBinary(_ *pgtype.ConnInfo, src []byte) error

func (LiquidityOrderReference) EncodeBinary 

func (l LiquidityOrderReference) EncodeBinary(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type LiquidityProviderFeeShare 

type LiquidityProviderFeeShare struct {
	Party                 string          `json:"party"`
	EquityLikeShare       decimal.Decimal `json:"equityLikeShare"`
	AverageEntryValuation decimal.Decimal `json:"averageEntryValuation"`
}

func (LiquidityProviderFeeShare) Equals 

func (fee LiquidityProviderFeeShare) Equals(other LiquidityProviderFeeShare) bool

type LiquidityProvision 

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
	VegaTime         time.Time
}

func LiquidityProvisionFromProto 

func LiquidityProvisionFromProto(lpProto *vega.LiquidityProvision, vegaTime time.Time) (LiquidityProvision, error)

func (LiquidityProvision) Cursor 

func (lp LiquidityProvision) Cursor() *Cursor

func (LiquidityProvision) Key 

func (lp LiquidityProvision) Key() LiquidityProvisionKey

func (*LiquidityProvision) ToProto 

func (lp *LiquidityProvision) ToProto() *vega.LiquidityProvision

func (LiquidityProvision) ToProtoEdge 

func (lp LiquidityProvision) ToProtoEdge(_ ...any) (*v2.LiquidityProvisionsEdge, error)

func (LiquidityProvision) ToRow 

func (lp LiquidityProvision) ToRow() []interface{}

type LiquidityProvisionCursor 

type LiquidityProvisionCursor struct {
	VegaTime time.Time            `json:"vegaTime"`
	ID       LiquidityProvisionID `json:"id"`
}

func (*LiquidityProvisionCursor) Parse 

func (lc *LiquidityProvisionCursor) Parse(cursorString string) error

func (LiquidityProvisionCursor) String 

func (lc LiquidityProvisionCursor) String() string

type LiquidityProvisionID 

type LiquidityProvisionID = ID[_LiquidityProvision]

type LiquidityProvisionKey 

type LiquidityProvisionKey struct {
	ID       LiquidityProvisionID
	VegaTime time.Time
}

type LiquidityProvisionStatus 

type LiquidityProvisionStatus vega.LiquidityProvision_Status

func (*LiquidityProvisionStatus) DecodeText 

func (s *LiquidityProvisionStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (LiquidityProvisionStatus) EncodeText 

func (s LiquidityProvisionStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type MarginCursor 

type MarginCursor struct {
	VegaTime  time.Time
	AccountID int64
}

func (*MarginCursor) Parse 

func (mc *MarginCursor) Parse(cursorString string) error

func (MarginCursor) String 

func (mc MarginCursor) String() string

type MarginLevels 

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

func MarginLevelsFromProto 

func MarginLevelsFromProto(ctx context.Context, margin *vega.MarginLevels, accountSource AccountSource, vegaTime time.Time) (MarginLevels, error)

func (MarginLevels) Cursor 

func (ml MarginLevels) Cursor() *Cursor

func (MarginLevels) Key 

func (o MarginLevels) Key() MarginLevelsKey

func (*MarginLevels) ToProto 

func (ml *MarginLevels) ToProto(accountSource AccountSource) (*vega.MarginLevels, error)

func (MarginLevels) ToProtoEdge 

func (ml MarginLevels) ToProtoEdge(input ...any) (*v2.MarginEdge, error)

func (MarginLevels) ToRow 

func (ml MarginLevels) ToRow() []interface{}

type MarginLevelsKey 

type MarginLevelsKey struct {
	AccountID int64
	VegaTime  time.Time
}

type Market 

type Market struct {
	ID                            MarketID
	VegaTime                      time.Time
	InstrumentID                  string
	TradableInstrument            TradableInstrument
	DecimalPlaces                 int
	Fees                          Fees
	OpeningAuction                AuctionDuration
	PriceMonitoringSettings       PriceMonitoringSettings
	LiquidityMonitoringParameters LiquidityMonitoringParameters
	TradingMode                   MarketTradingMode
	State                         MarketState
	MarketTimestamps              MarketTimestamps
	PositionDecimalPlaces         int
}

func NewMarketFromProto 

func NewMarketFromProto(market *vega.Market, vegaTime time.Time) (*Market, error)

func (Market) Cursor 

func (m Market) Cursor() *Cursor

func (Market) ToProto 

func (m Market) ToProto() *vega.Market

func (Market) ToProtoEdge 

func (m Market) ToProtoEdge(_ ...any) (*v2.MarketEdge, error)

type MarketCursor 

type MarketCursor struct {
	VegaTime time.Time `json:"vegaTime"`
	ID       MarketID  `json:"id"`
}

func (*MarketCursor) Parse 

func (mc *MarketCursor) Parse(cursorString string) error

func (MarketCursor) String 

func (mc MarketCursor) String() string

type MarketData 

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
	// 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 []*PriceMonitoringBound
	// the market value proxy
	MarketValueProxy string
	// the equity like share of liquidity fee for each liquidity provider
	LiquidityProviderFeeShares []*LiquidityProviderFeeShare
	// A synthetic time created which is the sum of vega_time + (seq num * Microsecond)
	SyntheticTime time.Time
	// Vega Block time at which the data was received from Vega Node
	VegaTime time.Time
	// SeqNum is the order in which the market data was received in the block
	SeqNum uint64
}

MarketData represents a market data record that is stored in the SQL database.

func MarketDataFromProto 

func MarketDataFromProto(data *types.MarketData) (*MarketData, error)

func (MarketData) Cursor 

func (md MarketData) Cursor() *Cursor

func (MarketData) Equal 

func (md MarketData) Equal(other MarketData) bool

func (MarketData) ToProto 

func (md MarketData) ToProto() *types.MarketData

func (MarketData) ToProtoEdge 

func (md MarketData) ToProtoEdge(_ ...any) (*v2.MarketDataEdge, error)

type MarketDataCursor 

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

func (*MarketDataCursor) Parse 

func (c *MarketDataCursor) Parse(cursorString string) error

func (MarketDataCursor) String 

func (c MarketDataCursor) String() string

type MarketDepth 

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
}

func (*MarketDepth) AddOrderUpdate 

func (md *MarketDepth) AddOrderUpdate(order *types.Order)

func (*MarketDepth) GetPriceLevel 

func (md *MarketDepth) GetPriceLevel(side types.Side, price *num.Uint) *PriceLevel

func (*MarketDepth) ToProto 

func (md *MarketDepth) ToProto(limit uint64) *vega.MarketDepth

type MarketID 

type MarketID = ID[_Market]

type MarketState 

type MarketState vega.Market_State

func (*MarketState) DecodeText 

func (s *MarketState) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (MarketState) EncodeText 

func (s MarketState) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type MarketTimestamps 

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

func (MarketTimestamps) ToProto 

func (mt MarketTimestamps) ToProto() *vega.MarketTimestamps

type MarketTradingMode 

type MarketTradingMode vega.Market_TradingMode

func (*MarketTradingMode) DecodeText 

func (m *MarketTradingMode) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (MarketTradingMode) EncodeText 

func (m MarketTradingMode) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type NetworkLimits 

type NetworkLimits struct {
	VegaTime                 time.Time
	CanProposeMarket         bool
	CanProposeAsset          bool
	BootstrapFinished        bool
	ProposeMarketEnabled     bool
	ProposeAssetEnabled      bool
	BootstrapBlockCount      int32
	GenesisLoaded            bool
	ProposeMarketEnabledFrom time.Time
	ProposeAssetEnabledFrom  time.Time
}

func NetworkLimitsFromProto 

func NetworkLimitsFromProto(vn *vega.NetworkLimits) NetworkLimits

func (*NetworkLimits) ToProto 

func (nl *NetworkLimits) ToProto() *vega.NetworkLimits

type NetworkParameter 

type NetworkParameter struct {
	Key      string
	Value    string
	VegaTime time.Time
}

func NetworkParameterFromProto 

func NetworkParameterFromProto(pnp *vega.NetworkParameter) (NetworkParameter, error)

func (NetworkParameter) Cursor 

func (np NetworkParameter) Cursor() *Cursor

func (*NetworkParameter) ToProto 

func (np *NetworkParameter) ToProto() *vega.NetworkParameter

func (NetworkParameter) ToProtoEdge 

func (np NetworkParameter) ToProtoEdge(_ ...any) (*v2.NetworkParameterEdge, error)

type NetworkParameterCursor 

type NetworkParameterCursor struct {
	Key string
}

func (*NetworkParameterCursor) Parse 

func (c *NetworkParameterCursor) Parse(cursorString string) error

type Node 

type Node struct {
	ID                NodeID
	PubKey            VegaPublicKey       `db:"vega_pub_key"`
	TmPubKey          TendermintPublicKey `db:"tendermint_pub_key"`
	EthereumAddress   EthereumAddress
	InfoUrl           string
	Location          string
	StakedByOperator  decimal.Decimal
	StakedByDelegates decimal.Decimal
	StakedTotal       decimal.Decimal
	MaxIntendedStake  decimal.Decimal
	PendingStake      decimal.Decimal
	EpochData         EpochData
	Status            NodeStatus
	Delegations       []Delegation  `json:""`
	RewardScore       *RewardScore  `json:""`
	RankingScore      *RankingScore `json:""`
	Name              string
	AvatarUrl         string
	VegaTime          time.Time
}

func NodeFromProto 

func NodeFromProto(node *vega.Node, vegaTime time.Time) (Node, error)

func (Node) Cursor 

func (node Node) Cursor() *Cursor

func (*Node) ToProto 

func (node *Node) ToProto() *vega.Node

func (Node) ToProtoEdge 

func (node Node) ToProtoEdge(_ ...any) (*v2.NodeEdge, error)

type NodeCursor 

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

func (*NodeCursor) Parse 

func (nc *NodeCursor) Parse(cursorString string) error

func (NodeCursor) String 

func (nc NodeCursor) String() string

type NodeData 

type NodeData struct {
	StakedTotal     decimal.Decimal
	TotalNodes      uint32
	InactiveNodes   uint32
	ValidatingNodes uint32
	Uptime          float64
	VegaTime        time.Time
}

func (*NodeData) ToProto 

func (n *NodeData) ToProto() *vega.NodeData

type NodeID 

type NodeID = ID[_Node]

type NodeSignature 

type NodeSignature struct {
	ResourceID NodeSignatureID
	Sig        []byte
	Kind       NodeSignatureKind
}

func NodeSignatureFromProto 

func NodeSignatureFromProto(ns *commandspb.NodeSignature) (*NodeSignature, error)

func (NodeSignature) Cursor 

func (w NodeSignature) Cursor() *Cursor

func (NodeSignature) ToProto 

func (w NodeSignature) ToProto() *commandspb.NodeSignature

func (NodeSignature) ToProtoEdge 

func (w NodeSignature) ToProtoEdge(_ ...any) (*v2.NodeSignatureEdge, error)

type NodeSignatureCursor 

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

func (*NodeSignatureCursor) Parse 

func (c *NodeSignatureCursor) Parse(cursorString string) error

func (NodeSignatureCursor) String 

func (c NodeSignatureCursor) String() string

type NodeSignatureID 

type NodeSignatureID = ID[_NodeSignature]

type NodeSignatureKind 

type NodeSignatureKind commandspb.NodeSignatureKind

func (*NodeSignatureKind) DecodeText 

func (s *NodeSignatureKind) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (NodeSignatureKind) EncodeText 

func (s NodeSignatureKind) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type NodeStatus 

type NodeStatus vega.NodeStatus

func (*NodeStatus) DecodeText 

func (ns *NodeStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (NodeStatus) EncodeText 

func (ns NodeStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type OffsetPagination 

type OffsetPagination struct {
	Pagination
	Skip       uint64
	Limit      uint64
	Descending bool
}

func OffsetPaginationFromProto 

func OffsetPaginationFromProto(pp *v2.OffsetPagination) OffsetPagination

type OracleData 

type OracleData struct {
	PublicKeys     PublicKeys
	Data           []Property
	MatchedSpecIds [][]byte // pgx automatically handles [][]byte to Postgres ByteaArray mappings
	BroadcastAt    time.Time
	VegaTime       time.Time
}

func OracleDataFromProto 

func OracleDataFromProto(data *oraclespb.OracleData, vegaTime time.Time) (*OracleData, error)

func (OracleData) Cursor 

func (od OracleData) Cursor() *Cursor

func (*OracleData) ToProto 

func (od *OracleData) ToProto() *oraclespb.OracleData

func (OracleData) ToProtoEdge 

func (od OracleData) ToProtoEdge(_ ...any) (*v2.OracleDataEdge, error)

type OracleDataCursor 

type OracleDataCursor struct {
	VegaTime   time.Time  `json:"vegaTime"`
	PublicKeys PublicKeys `json:"publicKeys"`
}

func (*OracleDataCursor) Parse 

func (c *OracleDataCursor) Parse(cursorString string) error

func (OracleDataCursor) String 

func (c OracleDataCursor) String() string

type OracleSpec 

type OracleSpec struct {
	ID         SpecID
	CreatedAt  time.Time
	UpdatedAt  time.Time
	PublicKeys PublicKeys
	Filters    []Filter
	Status     OracleSpecStatus
	VegaTime   time.Time
}

func OracleSpecFromProto 

func OracleSpecFromProto(spec *oraclespb.OracleSpec, vegaTime time.Time) (*OracleSpec, error)

func (OracleSpec) Cursor 

func (os OracleSpec) Cursor() *Cursor

func (*OracleSpec) ToProto 

func (os *OracleSpec) ToProto() *oraclespb.OracleSpec

func (OracleSpec) ToProtoEdge 

func (os OracleSpec) ToProtoEdge(_ ...any) (*v2.OracleSpecEdge, error)

type OracleSpecCursor 

type OracleSpecCursor struct {
	VegaTime time.Time `json:"vegaTime"`
	ID       SpecID    `json:"id"`
}

func (*OracleSpecCursor) Parse 

func (os *OracleSpecCursor) Parse(cursorString string) error

func (OracleSpecCursor) String 

func (os OracleSpecCursor) String() string

type OracleSpecStatus 

type OracleSpecStatus v1.OracleSpec_Status

func (*OracleSpecStatus) DecodeText 

func (s *OracleSpecStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (OracleSpecStatus) EncodeText 

func (s OracleSpecStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type Order 

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

func OrderFromProto 

func OrderFromProto(po *vega.Order, seqNum uint64) (Order, error)

func (Order) Cursor 

func (o Order) Cursor() *Cursor

func (Order) Key 

func (o Order) Key() OrderKey

func (Order) ToProto 

func (o Order) ToProto() *vega.Order

func (Order) ToProtoEdge 

func (o Order) ToProtoEdge(_ ...any) (*v2.OrderEdge, error)

func (Order) ToRow 

func (o Order) ToRow() []interface{}

type OrderCursor 

type OrderCursor struct {
	VegaTime time.Time `json:"vegaTime"`
	SeqNum   uint64    `json:"seqNum"`
}

func (*OrderCursor) Parse 

func (oc *OrderCursor) Parse(cursorString string) error

func (OrderCursor) String 

func (oc OrderCursor) String() string

type OrderError 

type OrderError = vega.OrderError
const (
	// Default value, no error reported.
	OrderErrorUnspecified OrderError = vega.OrderError_ORDER_ERROR_UNSPECIFIED
	// Order was submitted for a market that does not exist.
	OrderErrorInvalidMarketID OrderError = vega.OrderError_ORDER_ERROR_INVALID_MARKET_ID
	// Order was submitted with an invalid identifier.
	OrderErrorInvalidOrderID OrderError = vega.OrderError_ORDER_ERROR_INVALID_ORDER_ID
	// Order was amended with a sequence number that was not previous version + 1.
	OrderErrorOutOfSequence OrderError = vega.OrderError_ORDER_ERROR_OUT_OF_SEQUENCE
	// Order was amended with an invalid remaining size (e.g. remaining greater than total size).
	OrderErrorInvalidRemainingSize OrderError = vega.OrderError_ORDER_ERROR_INVALID_REMAINING_SIZE
	// Node was unable to get Vega (blockchain) time.
	OrderErrorTimeFailure OrderError = vega.OrderError_ORDER_ERROR_TIME_FAILURE
	// Failed to remove an order from the book.
	OrderErrorRemovalFailure OrderError = vega.OrderError_ORDER_ERROR_REMOVAL_FAILURE
	// An order with `TimeInForce.TIME_IN_FORCE_GTT` was submitted or amended
	// with an expiration that was badly formatted or otherwise invalid.
	OrderErrorInvalidExpirationDatetime OrderError = vega.OrderError_ORDER_ERROR_INVALID_EXPIRATION_DATETIME
	// Order was submitted or amended with an invalid reference field.
	OrderErrorInvalidOrderReference OrderError = vega.OrderError_ORDER_ERROR_INVALID_ORDER_REFERENCE
	// Order amend was submitted for an order field that cannot not be amended (e.g. order identifier).
	OrderErrorEditNotAllowed OrderError = vega.OrderError_ORDER_ERROR_EDIT_NOT_ALLOWED
	// Amend failure because amend details do not match original order.
	OrderErrorAmendFailure OrderError = vega.OrderError_ORDER_ERROR_AMEND_FAILURE
	// Order not found in an order book or store.
	OrderErrorNotFound OrderError = vega.OrderError_ORDER_ERROR_NOT_FOUND
	// Order was submitted with an invalid or missing party identifier.
	OrderErrorInvalidParty OrderError = vega.OrderError_ORDER_ERROR_INVALID_PARTY_ID
	// Order was submitted for a market that has closed.
	OrderErrorMarketClosed OrderError = vega.OrderError_ORDER_ERROR_MARKET_CLOSED
	// Order was submitted, but the party did not have enough collateral to cover the order.
	OrderErrorMarginCheckFailed OrderError = vega.OrderError_ORDER_ERROR_MARGIN_CHECK_FAILED
	// Order was submitted, but the party did not have an account for this asset.
	OrderErrorMissingGeneralAccount OrderError = vega.OrderError_ORDER_ERROR_MISSING_GENERAL_ACCOUNT
	// Unspecified internal error.
	OrderErrorInternalError OrderError = vega.OrderError_ORDER_ERROR_INTERNAL_ERROR
	// Order was submitted with an invalid or missing size (e.g. 0).
	OrderErrorInvalidSize OrderError = vega.OrderError_ORDER_ERROR_INVALID_SIZE
	// Order was submitted with an invalid persistence for its type.
	OrderErrorInvalidPersistance OrderError = vega.OrderError_ORDER_ERROR_INVALID_PERSISTENCE
	// Order was submitted with an invalid type field.
	OrderErrorInvalidType OrderError = vega.OrderError_ORDER_ERROR_INVALID_TYPE
	// Order was stopped as it would have traded with another order submitted from the same party.
	OrderErrorSelfTrading OrderError = vega.OrderError_ORDER_ERROR_SELF_TRADING
	// Order was submitted, but the party did not have enough collateral to cover the fees for the order.
	OrderErrorInsufficientFundsToPayFees OrderError = vega.OrderError_ORDER_ERROR_INSUFFICIENT_FUNDS_TO_PAY_FEES
	// Order was submitted with an incorrect or invalid market type.
	OrderErrorIncorrectMarketType OrderError = vega.OrderError_ORDER_ERROR_INCORRECT_MARKET_TYPE
	// Order was submitted with invalid time in force.
	OrderErrorInvalidTimeInForce OrderError = vega.OrderError_ORDER_ERROR_INVALID_TIME_IN_FORCE
	// A GFN order has got to the market when it is in auction mode.
	OrderErrorGFNOrderDuringAnAuction OrderError = vega.OrderError_ORDER_ERROR_GFN_ORDER_DURING_AN_AUCTION
	// A GFA order has got to the market when it is in continuous trading mode.
	OrderErrorGFAOrderDuringContinuousTrading OrderError = vega.OrderError_ORDER_ERROR_GFA_ORDER_DURING_CONTINUOUS_TRADING
	// Attempt to amend order to GTT without ExpiryAt.
	OrderErrorCannotAmendToGTTWithoutExpiryAt OrderError = vega.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GTT_WITHOUT_EXPIRYAT
	// Attempt to amend ExpiryAt to a value before CreatedAt.
	OrderErrorExpiryAtBeforeCreatedAt OrderError = vega.OrderError_ORDER_ERROR_EXPIRYAT_BEFORE_CREATEDAT
	// Attempt to amend to GTC without an ExpiryAt value.
	OrderErrorCannotHaveGTCAndExpiryAt OrderError = vega.OrderError_ORDER_ERROR_CANNOT_HAVE_GTC_AND_EXPIRYAT
	// Amending to FOK or IOC is invalid.
	OrderErrorCannotAmendToFOKOrIOC OrderError = vega.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_FOK_OR_IOC
	// Amending to GFA or GFN is invalid.
	OrderErrorCannotAmendToGFAOrGFN OrderError = vega.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GFA_OR_GFN
	// Amending from GFA or GFN is invalid.
	OrderErrorCannotAmendFromGFAOrGFN OrderError = vega.OrderError_ORDER_ERROR_CANNOT_AMEND_FROM_GFA_OR_GFN
	// IOC orders are not allowed during auction.
	OrderErrorCannotSendIOCOrderDuringAuction OrderError = vega.OrderError_ORDER_ERROR_CANNOT_SEND_IOC_ORDER_DURING_AUCTION
	// FOK orders are not allowed during auction.
	OrderErrorCannotSendFOKOrderDurinAuction OrderError = vega.OrderError_ORDER_ERROR_CANNOT_SEND_FOK_ORDER_DURING_AUCTION
	// Pegged orders must be LIMIT orders.
	OrderErrorMustBeLimitOrder OrderError = vega.OrderError_ORDER_ERROR_MUST_BE_LIMIT_ORDER
	// Pegged orders can only have TIF GTC or GTT.
	OrderErrorMustBeGTTOrGTC OrderError = vega.OrderError_ORDER_ERROR_MUST_BE_GTT_OR_GTC
	// Pegged order must have a reference price.
	OrderErrorWithoutReferencePrice OrderError = vega.OrderError_ORDER_ERROR_WITHOUT_REFERENCE_PRICE
	// Buy pegged order cannot reference best ask price.
	OrderErrorBuyCannotReferenceBestAskPrice OrderError = vega.OrderError_ORDER_ERROR_BUY_CANNOT_REFERENCE_BEST_ASK_PRICE
	// Pegged order offset must be >= 0.
	OrderErrorOffsetMustBeGreaterOrEqualToZero OrderError = vega.OrderError_ORDER_ERROR_OFFSET_MUST_BE_GREATER_OR_EQUAL_TO_ZERO
	// Sell pegged order cannot reference best bid price.
	OrderErrorSellCannotReferenceBestBidPrice OrderError = vega.OrderError_ORDER_ERROR_SELL_CANNOT_REFERENCE_BEST_BID_PRICE
	// Pegged order offset must be > zero.
	OrderErrorOffsetMustBeGreaterThanZero OrderError = vega.OrderError_ORDER_ERROR_OFFSET_MUST_BE_GREATER_THAN_ZERO
	// The party has an insufficient balance, or does not have
	// a general account to submit the order (no deposits made
	// for the required asset).
	OrderErrorInsufficientAssetBalance OrderError = vega.OrderError_ORDER_ERROR_INSUFFICIENT_ASSET_BALANCE
	// Cannot amend a non pegged orders details.
	OrderErrorCannotAmendPeggedOrderDetailsOnNonPeggedOrder OrderError = vega.OrderError_ORDER_ERROR_CANNOT_AMEND_PEGGED_ORDER_DETAILS_ON_NON_PEGGED_ORDER
	// We are unable to re-price a pegged order because a market price is unavailable.
	OrderErrorUnableToRepricePeggedOrder OrderError = vega.OrderError_ORDER_ERROR_UNABLE_TO_REPRICE_PEGGED_ORDER
	// It is not possible to amend the price of an existing pegged order.
	OrderErrorUnableToAmendPriceOnPeggedOrder OrderError = vega.OrderError_ORDER_ERROR_UNABLE_TO_AMEND_PRICE_ON_PEGGED_ORDER
	// An FOK, IOC, or GFN order was rejected because it resulted in trades outside the price bounds.
	OrderErrorNonPersistentOrderOutOfPriceBounds OrderError = vega.OrderError_ORDER_ERROR_NON_PERSISTENT_ORDER_OUT_OF_PRICE_BOUNDS
)

type OrderID 

type OrderID = ID[_Order]

type OrderKey 

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

type OrderStatus 

type OrderStatus = vega.Order_Status
const (
	// Default value, always invalid.
	OrderStatusUnspecified OrderStatus = vega.Order_STATUS_UNSPECIFIED
	// Used for active unfilled or partially filled orders.
	OrderStatusActive OrderStatus = vega.Order_STATUS_ACTIVE
	// Used for expired GTT orders.
	OrderStatusExpired OrderStatus = vega.Order_STATUS_EXPIRED
	// Used for orders cancelled by the party that created the order.
	OrderStatusCancelled OrderStatus = vega.Order_STATUS_CANCELLED
	// Used for unfilled FOK or IOC orders, and for orders that were stopped by the network.
	OrderStatusStopped OrderStatus = vega.Order_STATUS_STOPPED
	// Used for closed fully filled orders.
	OrderStatusFilled OrderStatus = vega.Order_STATUS_FILLED
	// Used for orders when not enough collateral was available to fill the margin requirements.
	OrderStatusRejected OrderStatus = vega.Order_STATUS_REJECTED
	// Used for closed partially filled IOC orders.
	OrderStatusPartiallyFilled OrderStatus = vega.Order_STATUS_PARTIALLY_FILLED
	// Order has been removed from the order book and has been parked, this applies to pegged orders only.
	OrderStatusParked OrderStatus = vega.Order_STATUS_PARKED
)

type OrderTimeInForce 

type OrderTimeInForce = vega.Order_TimeInForce
const (
	// Default value for TimeInForce, can be valid for an amend.
	OrderTimeInForceUnspecified OrderTimeInForce = vega.Order_TIME_IN_FORCE_UNSPECIFIED
	// Good until cancelled.
	OrderTimeInForceGTC OrderTimeInForce = vega.Order_TIME_IN_FORCE_GTC
	// Good until specified time.
	OrderTimeInForceGTT OrderTimeInForce = vega.Order_TIME_IN_FORCE_GTT
	// Immediate or cancel.
	OrderTimeInForceIOC OrderTimeInForce = vega.Order_TIME_IN_FORCE_IOC
	// Fill or kill.
	OrderTimeInForceFOK OrderTimeInForce = vega.Order_TIME_IN_FORCE_FOK
	// Good for auction.
	OrderTimeInForceGFA OrderTimeInForce = vega.Order_TIME_IN_FORCE_GFA
	// Good for normal.
	OrderTimeInForceGFN OrderTimeInForce = vega.Order_TIME_IN_FORCE_GFN
)

type OrderType 

type OrderType = vega.Order_Type
const (
	// Default value, always invalid.
	OrderTypeUnspecified OrderType = vega.Order_TYPE_UNSPECIFIED
	// Used for Limit orders.
	OrderTypeLimit OrderType = vega.Order_TYPE_LIMIT
	// Used for Market orders.
	OrderTypeMarket OrderType = vega.Order_TYPE_MARKET
	// Used for orders where the initiating party is the network (with distressed traders).
	OrderTypeNetwork OrderType = vega.Order_TYPE_NETWORK
)

type PageInfo 

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

func PageEntities 

func PageEntities[T proto.Message, U PagedEntity[T]](items []U, pagination CursorPagination) ([]U, PageInfo)

func (PageInfo) ToProto 

func (p PageInfo) ToProto() *v2.PageInfo

type PagedEntity 

type PagedEntity[T proto.Message] interface {
	Market | Party | Trade | Order | MarginLevels | MarketData | Reward | Candle | Deposit |
		Withdrawal | Asset | OracleSpec | OracleData | Position | LiquidityProvision | Vote |
		Transfer | AccountBalance | Proposal | Delegation | Node | NetworkParameter | Checkpoint |
		StakeLinking | NodeSignature | KeyRotation | ERC20MultiSigSignerAddedEvent |
		ERC20MultiSigSignerRemovedEvent | EthereumKeyRotation
	// 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 

type Pagination interface{}

type Party 

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

func PartyFromProto 

func PartyFromProto(pp *types.Party) Party

func (Party) Cursor 

func (p Party) Cursor() *Cursor

func (*Party) Parse 

func (p *Party) Parse(cursorString string) error

func (Party) String 

func (p Party) String() string

func (*Party) ToProto 

func (p *Party) ToProto() *types.Party

func (Party) ToProtoEdge 

func (p Party) ToProtoEdge(_ ...any) (*v2.PartyEdge, error)

type PartyID 

type PartyID = ID[_Party]

type PeggedReference 

type PeggedReference = vega.PeggedReference
const (
	// Default value for PeggedReference, no reference given.
	PeggedReferenceUnspecified PeggedReference = vega.PeggedReference_PEGGED_REFERENCE_UNSPECIFIED
	// Mid price reference.
	PeggedReferenceMid PeggedReference = vega.PeggedReference_PEGGED_REFERENCE_MID
	// Best bid price reference.
	PeggedReferenceBestBid PeggedReference = vega.PeggedReference_PEGGED_REFERENCE_BEST_BID
	// Best ask price reference.
	PeggedReferenceBestAsk PeggedReference = vega.PeggedReference_PEGGED_REFERENCE_BEST_ASK
)

type Position 

type Position struct {
	MarketID          MarketID
	PartyID           PartyID
	OpenVolume        int64
	RealisedPnl       decimal.Decimal
	UnrealisedPnl     decimal.Decimal
	AverageEntryPrice 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
	VegaTime          time.Time
}

func NewEmptyPosition 

func NewEmptyPosition(marketID MarketID, partyID PartyID) Position

func (*Position) AverageEntryPriceUint 

func (p *Position) AverageEntryPriceUint() *num.Uint

func (Position) Cursor 

func (p Position) Cursor() *Cursor

func (Position) Equal 

func (p Position) Equal(q Position) bool

func (Position) Key 

func (p Position) Key() PositionKey

func (*Position) ToProto 

func (p *Position) ToProto() *vega.Position

func (Position) ToProtoEdge 

func (p Position) ToProtoEdge(_ ...any) (*v2.PositionEdge, error)

func (Position) ToRow 

func (p Position) ToRow() []interface{}

func (*Position) UpdateWithLossSocialization 

func (p *Position) UpdateWithLossSocialization(e lossSocialization)

func (*Position) UpdateWithPositionSettlement 

func (p *Position) UpdateWithPositionSettlement(e positionSettlement)

func (*Position) UpdateWithSettleDestressed 

func (p *Position) UpdateWithSettleDestressed(e settleDestressed)

type PositionCursor 

type PositionCursor struct {
	VegaTime time.Time `json:"vega_time"`
	PartyID  PartyID   `json:"party_id"`
	MarketID MarketID  `json:"market_id"`
}

func (*PositionCursor) Parse 

func (rc *PositionCursor) Parse(cursorString string) error

func (PositionCursor) String 

func (rc PositionCursor) String() string

type PositionKey 

type PositionKey struct {
	MarketID MarketID
	PartyID  PartyID
	VegaTime time.Time
}

type PriceLevel 

type PriceLevel struct {
	// Price of the price level
	Price *num.Uint
	// How many orders are at this level
	TotalOrders uint64
	// How much volume is at this level
	TotalVolume uint64
	// What side of the book is this level
	Side types.Side
}

type PriceMonitoringBound 

type PriceMonitoringBound struct {
	MinValidPrice  *num.Uint              `json:"minValidPrice"`
	MaxValidPrice  *num.Uint              `json:"maxValidPrice"`
	Trigger        PriceMonitoringTrigger `json:"trigger"`
	ReferencePrice *num.Uint              `json:"referencePrice"`
}

func (PriceMonitoringBound) Equals 

func (bound PriceMonitoringBound) Equals(other PriceMonitoringBound) bool

type PriceMonitoringParameters 

type PriceMonitoringParameters struct {
	Triggers []*PriceMonitoringTrigger `json:"triggers,omitempty"`
}

type PriceMonitoringSettings 

type PriceMonitoringSettings struct {
	Parameters *PriceMonitoringParameters `json:"priceMonitoringParameters,omitempty"`
}

func (PriceMonitoringSettings) ToProto 

func (s PriceMonitoringSettings) ToProto() *vega.PriceMonitoringSettings

type PriceMonitoringTrigger 

type PriceMonitoringTrigger struct {
	Horizon          uint64          `json:"horizon"`
	Probability      decimal.Decimal `json:"probability"`
	AuctionExtension uint64          `json:"auctionExtension"`
}

func (PriceMonitoringTrigger) Equals 

func (trigger PriceMonitoringTrigger) Equals(other PriceMonitoringTrigger) bool

func (PriceMonitoringTrigger) ToProto 

func (trigger PriceMonitoringTrigger) ToProto() *types.PriceMonitoringTrigger

type Property 

type Property struct {
	Name  string
	Value string
}

type PropertyKey 

type PropertyKey struct {
	Name string `json:"name"`
	Type v1.PropertyKey_Type
}

type Proposal 

type Proposal struct {
	ID           ProposalID
	Reference    string
	PartyID      PartyID
	State        ProposalState
	Rationale    ProposalRationale
	Terms        ProposalTerms
	Reason       ProposalError
	ErrorDetails string
	ProposalTime time.Time
	VegaTime     time.Time
}

func ProposalFromProto 

func ProposalFromProto(pp *vega.Proposal) (Proposal, error)

func (Proposal) Cursor 

func (p Proposal) Cursor() *Cursor

func (*Proposal) ToProto 

func (p *Proposal) ToProto() *vega.Proposal

func (Proposal) ToProtoEdge 

func (p Proposal) ToProtoEdge(_ ...any) (*v2.GovernanceDataEdge, error)

type ProposalCursor 

type ProposalCursor struct {
	State    ProposalState `json:"state"`
	VegaTime time.Time     `json:"vega_time"`
	ID       ProposalID    `json:"id"`
}

func (*ProposalCursor) Parse 

func (pc *ProposalCursor) Parse(cursorString string) error

func (ProposalCursor) String 

func (pc ProposalCursor) String() string

type ProposalError 

type ProposalError vega.ProposalError

func (*ProposalError) DecodeText 

func (s *ProposalError) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (ProposalError) EncodeText 

func (s ProposalError) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type ProposalID 

type ProposalID = ID[_Proposal]

type ProposalRationale 

type ProposalRationale struct {
	*vega.ProposalRationale
}

func (ProposalRationale) MarshalJSON 

func (pt ProposalRationale) MarshalJSON() ([]byte, error)

func (*ProposalRationale) UnmarshalJSON 

func (pt *ProposalRationale) UnmarshalJSON(b []byte) error

type ProposalState 

type ProposalState vega.Proposal_State

func (*ProposalState) DecodeText 

func (s *ProposalState) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (ProposalState) EncodeText 

func (s ProposalState) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type ProposalTerms 

type ProposalTerms struct {
	*vega.ProposalTerms
}

func (ProposalTerms) MarshalJSON 

func (pt ProposalTerms) MarshalJSON() ([]byte, error)

func (*ProposalTerms) UnmarshalJSON 

func (pt *ProposalTerms) UnmarshalJSON(b []byte) error

type ProposalType 

type ProposalType string

type PublicKey 

type PublicKey = []byte

type PublicKeys 

type PublicKeys = []PublicKey

type RankingScore 

type RankingScore struct {
	StakeScore       decimal.Decimal     `json:"stake_score"`
	PerformanceScore decimal.Decimal     `json:"performance_score"`
	PreviousStatus   ValidatorNodeStatus `json:"previous_status,string"`
	Status           ValidatorNodeStatus `json:",string"`
	VotingPower      uint32              `json:"voting_power"`
	RankingScore     decimal.Decimal     `json:"ranking_score"`
	VegaTime         time.Time           `json:"vega_time"`
	EpochSeq         uint64
}

func (*RankingScore) ToProto 

func (rs *RankingScore) ToProto() *vega.RankingScore

type RankingScoreAux 

type RankingScoreAux struct {
	NodeId   NodeID
	EpochSeq uint64
}

type Reward 

type Reward struct {
	PartyID        PartyID
	AssetID        AssetID
	MarketID       MarketID
	EpochID        int64
	Amount         decimal.Decimal
	PercentOfTotal float64
	RewardType     string
	Timestamp      time.Time
	VegaTime       time.Time
}

func RewardFromProto 

func RewardFromProto(pr eventspb.RewardPayoutEvent, vegaTime time.Time) (Reward, error)

func (Reward) Cursor 

func (r Reward) Cursor() *Cursor

func (Reward) String 

func (r Reward) String() string

func (*Reward) ToProto 

func (r *Reward) ToProto() *vega.Reward

func (Reward) ToProtoEdge 

func (r Reward) ToProtoEdge(_ ...any) (*v2.RewardEdge, error)

type RewardCursor 

type RewardCursor struct {
	PartyID string `json:"party_id"`
	AssetID string `json:"asset_id"`
	EpochID int64  `json:"epoch_id"`
}

func (*RewardCursor) Parse 

func (rc *RewardCursor) Parse(cursorString string) error

func (RewardCursor) String 

func (rc RewardCursor) String() string

type RewardScore 

type RewardScore struct {
	RawValidatorScore   decimal.Decimal     `json:"raw_validator_score"`
	PerformanceScore    decimal.Decimal     `json:"performance_score"`
	MultisigScore       decimal.Decimal     `json:"multisig_score"`
	ValidatorScore      decimal.Decimal     `json:"validator_score"`
	NormalisedScore     decimal.Decimal     `json:"normalised_score"`
	ValidatorNodeStatus ValidatorNodeStatus `json:"validator_node_status,string"`
	VegaTime            time.Time           `json:"vega_time"`
	EpochSeq            uint64
}

func (*RewardScore) ToProto 

func (rs *RewardScore) ToProto() *vega.RewardScore

type RewardScoreAux 

type RewardScoreAux struct {
	NodeId   NodeID
	EpochSeq uint64
}

type RewardSummary 

type RewardSummary struct {
	PartyID PartyID
	AssetID AssetID
	Amount  decimal.Decimal
}

func (*RewardSummary) ToProto 

func (r *RewardSummary) ToProto() *vega.RewardSummary

type RiskFactor 

type RiskFactor struct {
	MarketID MarketID
	Short    decimal.Decimal
	Long     decimal.Decimal
	VegaTime time.Time
}

func RiskFactorFromProto 

func RiskFactorFromProto(factor *vega.RiskFactor, vegaTime time.Time) (*RiskFactor, error)

func (*RiskFactor) ToProto 

func (rf *RiskFactor) ToProto() *vega.RiskFactor

type Side 

type Side = vega.Side
const (
	// Default value, always invalid.
	SideUnspecified Side = vega.Side_SIDE_UNSPECIFIED
	// Buy order.
	SideBuy Side = vega.Side_SIDE_BUY
	// Sell order.
	SideSell Side = vega.Side_SIDE_SELL
)

type SpecID 

type SpecID = ID[_Spec]

type StakeLinking 

type StakeLinking struct {
	ID                 StakeLinkingID
	StakeLinkingType   StakeLinkingType
	EthereumTimestamp  time.Time
	PartyID            PartyID
	Amount             decimal.Decimal
	StakeLinkingStatus StakeLinkingStatus
	FinalizedAt        time.Time
	TxHash             string
	LogIndex           int64
	EthereumAddress    string
	VegaTime           time.Time
}

func StakeLinkingFromProto 

func StakeLinkingFromProto(stake *eventspb.StakeLinking, vegaTime time.Time) (*StakeLinking, error)

func (StakeLinking) Cursor 

func (s StakeLinking) Cursor() *Cursor

func (*StakeLinking) ToProto 

func (s *StakeLinking) ToProto() *eventspb.StakeLinking

func (StakeLinking) ToProtoEdge 

func (s StakeLinking) ToProtoEdge(_ ...any) (*v2.StakeLinkingEdge, error)

type StakeLinkingCursor 

type StakeLinkingCursor struct {
	VegaTime time.Time      `json:"vegaTime"`
	ID       StakeLinkingID `json:"id"`
}

func (*StakeLinkingCursor) Parse 

func (s *StakeLinkingCursor) Parse(cursorString string) error

func (StakeLinkingCursor) String 

func (s StakeLinkingCursor) String() string

type StakeLinkingID 

type StakeLinkingID = ID[_StakeLinking]

type StakeLinkingStatus 

type StakeLinkingStatus eventspb.StakeLinking_Status

func (*StakeLinkingStatus) DecodeText 

func (s *StakeLinkingStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (StakeLinkingStatus) EncodeText 

func (s StakeLinkingStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type StakeLinkingType 

type StakeLinkingType eventspb.StakeLinking_Type

func (*StakeLinkingType) DecodeText 

func (s *StakeLinkingType) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (StakeLinkingType) EncodeText 

func (s StakeLinkingType) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type TargetStakeParameters 

type TargetStakeParameters struct {
	TimeWindow     int64   `json:"timeWindow,omitempty"`
	ScalingFactors float64 `json:"scalingFactor,omitempty"`
}

func (TargetStakeParameters) ToProto 

func (tsp TargetStakeParameters) ToProto() *vega.TargetStakeParameters

type TendermintPublicKey 

type TendermintPublicKey string

func (*TendermintPublicKey) Bytes 

func (pk *TendermintPublicKey) Bytes() ([]byte, error)

func (*TendermintPublicKey) DecodeBinary 

func (pk *TendermintPublicKey) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error

func (TendermintPublicKey) EncodeBinary 

func (pk TendermintPublicKey) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error)

func (*TendermintPublicKey) Error 

func (pk *TendermintPublicKey) Error() error

func (*TendermintPublicKey) String 

func (pk *TendermintPublicKey) String() string

type TimeUpdateEvent 

type TimeUpdateEvent interface {
	events.Event
	Time() time.Time
}

type TradableInstrument 

type TradableInstrument struct {
	*vega.TradableInstrument
}

func (TradableInstrument) MarshalJSON 

func (ti TradableInstrument) MarshalJSON() ([]byte, error)

func (TradableInstrument) ToProto 

func (ti TradableInstrument) ToProto() *vega.TradableInstrument

func (*TradableInstrument) UnmarshalJSON 

func (ti *TradableInstrument) UnmarshalJSON(data []byte) error

type Trade 

type Trade struct {
	SyntheticTime           time.Time
	VegaTime                time.Time
	SeqNum                  uint64
	ID                      TradeID
	MarketID                MarketID
	Price                   decimal.Decimal
	Size                    uint64
	Buyer                   PartyID
	Seller                  PartyID
	Aggressor               Side
	BuyOrder                OrderID
	SellOrder               OrderID
	Type                    TradeType
	BuyerMakerFee           decimal.Decimal
	BuyerInfrastructureFee  decimal.Decimal
	BuyerLiquidityFee       decimal.Decimal
	SellerMakerFee          decimal.Decimal
	SellerInfrastructureFee decimal.Decimal
	SellerLiquidityFee      decimal.Decimal
	BuyerAuctionBatch       uint64
	SellerAuctionBatch      uint64
}

func TradeFromProto 

func TradeFromProto(t *vega.Trade, vegaTime time.Time, sequenceNumber uint64) (*Trade, error)

func (Trade) Cursor 

func (t Trade) Cursor() *Cursor

func (*Trade) ToProto 

func (t *Trade) ToProto() *vega.Trade

func (Trade) ToProtoEdge 

func (t Trade) ToProtoEdge(_ ...any) (*v2.TradeEdge, error)

type TradeCursor 

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

func (*TradeCursor) Parse 

func (c *TradeCursor) Parse(cursorString string) error

func (TradeCursor) String 

func (c TradeCursor) String() string

type TradeID 

type TradeID = ID[_Trade]

type TradeType 

type TradeType = vega.Trade_Type
const (
	// Default value, always invalid.
	TradeTypeUnspecified TradeType = vega.Trade_TYPE_UNSPECIFIED
	// Normal trading between two parties.
	TradeTypeDefault TradeType = vega.Trade_TYPE_DEFAULT
	// Trading initiated by the network with another party on the book,
	// which helps to zero-out the positions of one or more distressed parties.
	TradeTypeNetworkCloseOutGood TradeType = vega.Trade_TYPE_NETWORK_CLOSE_OUT_GOOD
	// Trading initiated by the network with another party off the book,
	// with a distressed party in order to zero-out the position of the party.
	TradeTypeNetworkCloseOutBad TradeType = vega.Trade_TYPE_NETWORK_CLOSE_OUT_BAD
)

type Transfer 

type Transfer struct {
	ID                  TransferID
	VegaTime            time.Time
	FromAccountId       int64
	ToAccountId         int64
	AssetId             AssetID
	Amount              decimal.Decimal
	Reference           string
	Status              TransferStatus
	TransferType        TransferType
	DeliverOn           *time.Time
	StartEpoch          *uint64
	EndEpoch            *uint64
	Factor              *decimal.Decimal
	DispatchMetric      *vega.DispatchMetric
	DispatchMetricAsset *string
	DispatchMarkets     []string
}

func TransferFromProto 

func TransferFromProto(ctx context.Context, t *eventspb.Transfer, vegaTime time.Time, accountSource AccountSource) (*Transfer, error)

func (Transfer) Cursor 

func (t Transfer) Cursor() *Cursor

func (*Transfer) ToProto 

func (t *Transfer) ToProto(accountSource AccountSource) (*eventspb.Transfer, error)

func (Transfer) ToProtoEdge 

func (t Transfer) ToProtoEdge(input ...any) (*v2.TransferEdge, error)

type TransferCursor 

type TransferCursor struct {
	VegaTime time.Time  `json:"vegaTime"`
	ID       TransferID `json:"id"`
}

func (*TransferCursor) Parse 

func (tc *TransferCursor) Parse(cursorString string) error

func (TransferCursor) String 

func (tc TransferCursor) String() string

type TransferID 

type TransferID = ID[_Transfer]

type TransferStatus 

type TransferStatus eventspb.Transfer_Status

func (*TransferStatus) DecodeText 

func (m *TransferStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (TransferStatus) EncodeText 

func (m TransferStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type TransferType 

type TransferType int
const (
	Unknown TransferType = iota
	OneOff
	Recurring
)

func (*TransferType) DecodeText 

func (m *TransferType) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (TransferType) EncodeText 

func (m TransferType) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type ValidatorNodeStatus 

type ValidatorNodeStatus vega.ValidatorNodeStatus

func ValidatorNodeStatusFromString 

func ValidatorNodeStatusFromString(status string) ValidatorNodeStatus

func (*ValidatorNodeStatus) DecodeText 

func (ns *ValidatorNodeStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (ValidatorNodeStatus) EncodeText 

func (ns ValidatorNodeStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

func (*ValidatorNodeStatus) UnmarshalJSON 

func (ns *ValidatorNodeStatus) UnmarshalJSON(src []byte) error

type ValidatorUpdateAux 

type ValidatorUpdateAux struct {
	Added           bool
	FromEpoch       uint64
	VegaPubKeyIndex uint32
}

type VegaPublicKey 

type VegaPublicKey string

func (*VegaPublicKey) Bytes 

func (pk *VegaPublicKey) Bytes() ([]byte, error)

func (*VegaPublicKey) DecodeBinary 

func (pk *VegaPublicKey) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error

func (VegaPublicKey) EncodeBinary 

func (pk VegaPublicKey) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error)

func (*VegaPublicKey) Error 

func (pk *VegaPublicKey) Error() error

func (*VegaPublicKey) String 

func (pk *VegaPublicKey) String() string

type Vote 

type Vote struct {
	PartyID                     PartyID
	ProposalID                  ProposalID
	Value                       VoteValue
	TotalGovernanceTokenBalance decimal.Decimal
	TotalGovernanceTokenWeight  decimal.Decimal
	TotalEquityLikeShareWeight  decimal.Decimal
	InitialTime                 time.Time // First vote for this party/proposal
	VegaTime                    time.Time // Time of last vote update
}

func VoteFromProto 

func VoteFromProto(pv *vega.Vote) (Vote, error)

func (Vote) Cursor 

func (p Vote) Cursor() *Cursor

func (*Vote) ToProto 

func (v *Vote) ToProto() *vega.Vote

func (Vote) ToProtoEdge 

func (p Vote) ToProtoEdge(_ ...any) (*v2.VoteEdge, error)

type VoteCursor 

type VoteCursor struct {
	PartyID  PartyID   `json:"party_id"`
	VegaTime time.Time `json:"vega_time"`
}

func (*VoteCursor) Parse 

func (rc *VoteCursor) Parse(cursorString string) error

func (VoteCursor) String 

func (rc VoteCursor) String() string

type VoteValue 

type VoteValue vega.Vote_Value

func (*VoteValue) DecodeText 

func (s *VoteValue) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (VoteValue) EncodeText 

func (s VoteValue) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

type WithdrawExt 

type WithdrawExt struct {
	*vega.WithdrawExt
}

func (WithdrawExt) MarshalJSON 

func (we WithdrawExt) MarshalJSON() ([]byte, error)

func (*WithdrawExt) UnmarshalJSON 

func (we *WithdrawExt) UnmarshalJSON(b []byte) error

type Withdrawal 

type Withdrawal struct {
	ID                 WithdrawalID
	PartyID            PartyID
	Amount             decimal.Decimal
	Asset              AssetID
	Status             WithdrawalStatus
	Ref                string
	Expiry             time.Time
	TxHash             string
	CreatedTimestamp   time.Time
	WithdrawnTimestamp time.Time
	Ext                WithdrawExt
	VegaTime           time.Time
}

func WithdrawalFromProto 

func WithdrawalFromProto(withdrawal *vega.Withdrawal, vegaTime time.Time) (*Withdrawal, error)

func (Withdrawal) Cursor 

func (w Withdrawal) Cursor() *Cursor

func (Withdrawal) ToProto 

func (w Withdrawal) ToProto() *vega.Withdrawal

func (Withdrawal) ToProtoEdge 

func (w Withdrawal) ToProtoEdge(_ ...any) (*v2.WithdrawalEdge, error)

type WithdrawalCursor 

type WithdrawalCursor struct {
	VegaTime time.Time    `json:"vegaTime"`
	ID       WithdrawalID `json:"id"`
}

func (*WithdrawalCursor) Parse 

func (wc *WithdrawalCursor) Parse(cursorString string) error

func (WithdrawalCursor) String 

func (wc WithdrawalCursor) String() string

type WithdrawalID 

type WithdrawalID = ID[_Withdrawal]

type WithdrawalStatus 

type WithdrawalStatus vega.Withdrawal_Status

func (*WithdrawalStatus) DecodeText 

func (s *WithdrawalStatus) DecodeText(_ *pgtype.ConnInfo, src []byte) error

func (WithdrawalStatus) EncodeText 

func (s WithdrawalStatus) EncodeText(_ *pgtype.ConnInfo, buf []byte) ([]byte, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.