types

package
v0.0.0-...-589da53 Latest Latest
Warning

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

 Go to latest Published: May 30, 2023 License: MIT Imports: 24 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	SignerPubKeyPrepend = 0x00
	ETHAddressPrepend   = 0x01
)
View Source 
const (
	SimpleRiskModelType rmType = iota
	LogNormalRiskModelType
)
View Source 
const (
	SnapshotFormatUnspecified     = snapshot.Format_FORMAT_UNSPECIFIED
	SnapshotFormatProto           = snapshot.Format_FORMAT_PROTO
	SnapshotFormatProtoCompressed = snapshot.Format_FORMAT_PROTO_COMPRESSED
	SnapshotFormatJSON            = snapshot.Format_FORMAT_JSON
)
View Source 
const (
	StakeLinkingTypeUnspecified StakeLinkingType = eventspb.StakeLinking_TYPE_UNSPECIFIED
	StakeLinkingTypeDeposited                    = eventspb.StakeLinking_TYPE_LINK
	StakeLinkingTypeRemoved                      = eventspb.StakeLinking_TYPE_UNLINK
)
View Source 
const (
	StakeLinkingStatusUnspecified StakeLinkingStatus = eventspb.StakeLinking_STATUS_UNSPECIFIED
	StakeLinkingStatusPending                        = eventspb.StakeLinking_STATUS_PENDING
	StakeLinkingStatusAccepted                       = eventspb.StakeLinking_STATUS_ACCEPTED
	StakeLinkingStatusRejected                       = eventspb.StakeLinking_STATUS_REJECTED
)
View Source 
const (
	NetworkParty = "network"
)

some constants we're relying on in multiple places. Declare them here to avoid things like settlement importing collateral etc...

Variables

View Source 
var (
	ErrMissingERC20ContractAddress     = errors.New("missing erc20 contract address")
	ErrMissingBuiltinAssetField        = errors.New("missing builtin asset field")
	ErrInvalidAssetNameEmpty           = errors.New("invalid asset, name must not be empty")
	ErrInvalidAssetSymbolEmpty         = errors.New("invalid asset, symbol must not be empty")
	ErrInvalidAssetDecimalPlacesZero   = errors.New("invalid asset, decimal places must not be zero")
	ErrInvalidAssetQuantumZero         = errors.New("invalid asset, quantum must not be zero")
	ErrLifetimeLimitMustBePositive     = errors.New("lifetime limit must be positive")
	ErrWithdrawThresholdMustBePositive = errors.New("withdraw threshold must be positive")
)
View Source 
var (
	ErrMissingTransferKind           = errors.New("missing transfer kind")
	ErrCannotTransferZeroFunds       = errors.New("cannot transfer zero funds")
	ErrInvalidFromAccount            = errors.New("invalid from account")
	ErrInvalidToAccount              = errors.New("invalid to account")
	ErrUnsupportedFromAccountType    = errors.New("unsupported from account type")
	ErrUnsupportedToAccountType      = errors.New("unsupported to account type")
	ErrEndEpochIsZero                = errors.New("end epoch is zero")
	ErrStartEpochIsZero              = errors.New("start epoch is zero")
	ErrInvalidFactor                 = errors.New("invalid factor")
	ErrStartEpochAfterEndEpoch       = errors.New("start epoch after end epoch")
	ErrInvalidToForRewardAccountType = errors.New("to party is invalid for reward account type")
)
View Source 
var (
	ErrCheckpointStateInvalid  = errors.New("state contained in the snapshot is invalid")
	ErrCheckpointHashIncorrect = errors.New("the hash and snapshot data do not match")
	ErrCheckpointHasNoState    = errors.New("there is no state set on the checkpoint")
)
View Source 
var (
	// ErrDataSourceSpecHasMultipleSameKeyNamesInFilterList is returned when filters with same key names exists inside a single list.
	ErrDataSourceSpecHasMultipleSameKeyNamesInFilterList = errors.New("multiple keys with same name found in filter list")
	// ErrDataSourceSpecHasInvalidTimeCondition is returned when timestamp value is used with 'LessThan'
	// or 'LessThanOrEqual' condition operator value.
	ErrDataSourceSpecHasInvalidTimeCondition = errors.New("data source spec time value is used with 'less than' or 'less than equal' condition")
)
View Source 
var (
	ErrMissingNetworkID                                   = errors.New("missing network ID in Ethereum config")
	ErrMissingChainID                                     = errors.New("missing chain ID in Ethereum config")
	ErrMissingCollateralBridgeAddress                     = errors.New("missing collateral bridge contract address in Ethereum config")
	ErrMissingMultiSigControlAddress                      = errors.New("missing multisig control contract address in Ethereum config")
	ErrUnsupportedCollateralBridgeDeploymentBlockHeight   = errors.New("setting collateral bridge contract deployment block height in Ethereum config is not supported")
	ErrAtLeastOneOfStakingOrVestingBridgeAddressMustBeSet = errors.New("at least one of the stacking bridge or token vesting contract addresses must be specified")
	ErrConfirmationsMustBeHigherThan0                     = errors.New("confirmation must be > 0 in Ethereum config")
)
View Source 
var (
	ErrInvalidCommitmentAmount = errors.New("invalid commitment amount")
	ErrMissingSlippageFactor   = errors.New("slippage factor not specified")
)
View Source 
var (
	ErrInvalidLifetimeLimit     = errors.New("invalid lifetime limit")
	ErrInvalidWithdrawThreshold = errors.New("invalid withdraw threshold")
	ErrAssetIDIsRequired        = errors.New("asset ID is required")
	ErrChangesAreRequired       = errors.New("changes are required")
	ErrSourceIsRequired         = errors.New("source is required")
)
View Source 
var (
	ErrNilTradableInstrument = errors.New("nil tradable instrument")
	ErrNilInstrument         = errors.New("nil instrument")
	ErrNilProduct            = errors.New("nil product")
	ErrUnknownAsset          = errors.New("unknown asset")
)
View Source 
var (
	ErrInvalidMarketID                             = OrderErrorInvalidMarketID
	ErrInvalidOrderID                              = OrderErrorInvalidOrderID
	ErrOrderOutOfSequence                          = OrderErrorOutOfSequence
	ErrInvalidRemainingSize                        = OrderErrorInvalidRemainingSize
	ErrOrderRemovalFailure                         = OrderErrorRemovalFailure
	ErrInvalidExpirationDatetime                   = OrderErrorInvalidExpirationDatetime
	ErrEditNotAllowed                              = OrderErrorEditNotAllowed
	ErrOrderAmendFailure                           = OrderErrorAmendFailure
	ErrOrderNotFound                               = OrderErrorNotFound
	ErrInvalidPartyID                              = OrderErrorInvalidParty
	ErrInvalidSize                                 = OrderErrorInvalidSize
	ErrInvalidPersistence                          = OrderErrorInvalidPersistance
	ErrInvalidType                                 = OrderErrorInvalidType
	ErrInvalidTimeInForce                          = OrderErrorInvalidTimeInForce
	ErrPeggedOrderMustBeLimitOrder                 = OrderErrorMustBeLimitOrder
	ErrPeggedOrderMustBeGTTOrGTC                   = OrderErrorMustBeGTTOrGTC
	ErrPeggedOrderWithoutReferencePrice            = OrderErrorWithoutReferencePrice
	ErrPeggedOrderBuyCannotReferenceBestAskPrice   = OrderErrorBuyCannotReferenceBestAskPrice
	ErrPeggedOrderOffsetMustBeGreaterOrEqualToZero = OrderErrorOffsetMustBeGreaterOrEqualToZero
	ErrPeggedOrderSellCannotReferenceBestBidPrice  = OrderErrorSellCannotReferenceBestBidPrice
	ErrPeggedOrderOffsetMustBeGreaterThanZero      = OrderErrorOffsetMustBeGreaterThanZero
	ErrTooManyPeggedOrders                         = OrderErrorTooManyPeggedOrders
	ErrPostOnlyOrderWouldTrade                     = OrderErrorPostOnlyOrderWouldTrade
	ErrReduceOnlyOrderWouldNotReducePosition       = OrderErrorReduceOnlyOrderWouldNotReducePosition
)
View Source 
var (
	ErrSnapshotHashMismatch         = errors.New("snapshot hashes do not match")
	ErrSnapshotMetaMismatch         = errors.New("snapshot metadata does not match")
	ErrUnknownSnapshotNamespace     = errors.New("unknown snapshot namespace")
	ErrNoPrefixFound                = errors.New("no prefix in chunk keys")
	ErrInconsistentNamespaceKeys    = errors.New("chunk contains several namespace keys")
	ErrChunkHashMismatch            = errors.New("loaded chunk hash does not match metadata")
	ErrChunkOutOfRange              = errors.New("chunk number out of range")
	ErrUnknownSnapshot              = errors.New("no shapshot to reject")
	ErrMissingChunks                = errors.New("missing previous chunks")
	ErrSnapshotRetryLimit           = errors.New("could not load snapshot, retry limit reached")
	ErrSnapshotKeyDoesNotExist      = errors.New("unknown key for snapshot")
	ErrInvalidSnapshotNamespace     = errors.New("invalid snapshot namespace")
	ErrUnknownSnapshotType          = errors.New("snapshot data type not known")
	ErrUnknownSnapshotChunkHeight   = errors.New("no snapshot or chunk found for given height")
	ErrInvalidSnapshotFormat        = errors.New("invalid snapshot format")
	ErrSnapshotFormatMismatch       = errors.New("snapshot formats do not match")
	ErrUnexpectedKey                = errors.New("snapshot namespace has unknown/unexpected key(s)")
	ErrNodeHashMismatch             = errors.New("hash of a node does not match the hash from the snapshot meta")
	ErrNoSnapshot                   = errors.New("no snapshot found")
	ErrMissingSnapshotVersion       = errors.New("unknown snapshot version")
	ErrInvalidSnapshotStorageMethod = errors.New("invalid snapshot storage method")
	ErrMissingAppstateNode          = errors.New("appstate missing from tree")
	ErrMissingPayload               = errors.New("payload missing from exported tree")
)
View Source 
var ErrInternalTimeDataSourceMissingConditions = errors.New("internal time based data source must have at least one condition")

Functions

func CheckEthereumConfig 

func CheckEthereumConfig(cfgProto *proto.EthereumConfig) error

CheckEthereumConfig verifies the proto.EthereumConfig is valid.

func CheckUntypedEthereumConfig 

func CheckUntypedEthereumConfig(v interface{}) error

CheckUntypedEthereumConfig verifies the `v` parameter is a proto.EthereumConfig struct and check if it's valid.

func DataSourceSpecPropertyKeyIsEmpty 

func DataSourceSpecPropertyKeyIsEmpty(key *DataSourceSpecPropertyKey) bool

func GetNodeKey 

func GetNodeKey(ns SnapshotNamespace, k string) string

GetNodeKey is a utility function, we don't want this mess scattered throughout the code.

func IsStoppingOrder 

func IsStoppingOrder(o OrderError) bool

func KeyFromPayload 

func KeyFromPayload(p isPayload) string

KeyFromPayload is useful in snapshot engine, used by the Payload type, too.

func SignersIntoProto 

func SignersIntoProto(s []*Signer) []*datapb.Signer

SignersIntoProto returns a list of signers after checking the list length.

func SignersToStringList 

func SignersToStringList(s []*Signer) []string

Types

type Account 

type Account struct {
	ID       string
	Owner    string
	Balance  *num.Uint
	Asset    string
	MarketID string
	Type     AccountType
}

func AccountFromProto 

func AccountFromProto(a *proto.Account) *Account

func (*Account) Clone 

func (a *Account) Clone() *Account

func (*Account) IntoProto 

func (a *Account) IntoProto() *proto.Account

func (Account) String 

func (a Account) String() string

func (Account) ToDetails 

func (a Account) ToDetails() *AccountDetails

type AccountDetails 

type AccountDetails struct {
	Owner    string
	AssetID  string
	MarketID string
	Type     AccountType
}

func (*AccountDetails) ID 

func (ad *AccountDetails) ID() string

func (*AccountDetails) IntoProto 

func (ad *AccountDetails) IntoProto() *proto.AccountDetails

type AccountType 

type AccountType = proto.AccountType
const (
	// Default value.
	AccountTypeUnspecified AccountType = proto.AccountType_ACCOUNT_TYPE_UNSPECIFIED
	// Insurance pool accounts contain insurance pool funds for a market.
	AccountTypeInsurance AccountType = proto.AccountType_ACCOUNT_TYPE_INSURANCE
	// Settlement accounts exist only during settlement or mark-to-market.
	AccountTypeSettlement AccountType = proto.AccountType_ACCOUNT_TYPE_SETTLEMENT
	// Margin accounts contain margin funds for a party and each party will
	// have multiple margin accounts, one for each market they have traded in
	//
	// Margin account funds will alter as margin requirements on positions change.
	AccountTypeMargin AccountType = proto.AccountType_ACCOUNT_TYPE_MARGIN
	// General accounts contains general funds for a party. A party will
	// have multiple general accounts, one for each asset they want
	// to trade with
	//
	// General accounts are where funds are initially deposited or withdrawn from,
	// it is also the account where funds are taken to fulfil fees and initial margin requirements.
	AccountTypeGeneral AccountType = proto.AccountType_ACCOUNT_TYPE_GENERAL
	// Infrastructure accounts contain fees earned by providing infrastructure on Fury.
	AccountTypeFeesInfrastructure AccountType = proto.AccountType_ACCOUNT_TYPE_FEES_INFRASTRUCTURE
	// Liquidity accounts contain fees earned by providing liquidity on Fury markets.
	AccountTypeFeesLiquidity AccountType = proto.AccountType_ACCOUNT_TYPE_FEES_LIQUIDITY
	// This account is created to hold fees earned by placing orders that sit on the book
	// and are then matched with an incoming order to create a trade - These fees reward parties
	// who provide the best priced liquidity that actually allows trading to take place.
	AccountTypeFeesMaker AccountType = proto.AccountType_ACCOUNT_TYPE_FEES_MAKER
	// This account is created to maintain liquidity providers funds commitments.
	AccountTypeBond AccountType = proto.AccountType_ACCOUNT_TYPE_BOND
	// External account represents an external source (deposit/withdrawal).
	AccountTypeExternal AccountType = proto.AccountType_ACCOUNT_TYPE_EXTERNAL
	// Global reward accounts contain rewards per asset.
	AccountTypeGlobalReward AccountType = proto.AccountType_ACCOUNT_TYPE_GLOBAL_REWARD
	// Global account to hold pending transfers.
	AccountTypePendingTransfers AccountType = proto.AccountType_ACCOUNT_TYPE_PENDING_TRANSFERS
	// Asset account for paid taker fees.
	AccountTypeMakerPaidFeeReward AccountType = proto.AccountType_ACCOUNT_TYPE_REWARD_MAKER_PAID_FEES
	// Asset account for received maker fees.
	AccountTypeMakerReceivedFeeReward AccountType = proto.AccountType_ACCOUNT_TYPE_REWARD_MAKER_RECEIVED_FEES
	// Asset account for received LP fees.
	AccountTypeLPFeeReward AccountType = proto.AccountType_ACCOUNT_TYPE_REWARD_LP_RECEIVED_FEES
	// Asset account for market proposers.
	AccountTypeMarketProposerReward AccountType = proto.AccountType_ACCOUNT_TYPE_REWARD_MARKET_PROPOSERS
	// Market account for holding in-flight spot passive orders funds.
	AccountTypeHolding AccountType = proto.AccountType_ACCOUNT_TYPE_HOLDING
)

type Accounts 

type Accounts []*Account

func (Accounts) IntoProto 

func (a Accounts) IntoProto() []*proto.Account

type ActiveAssets 

type ActiveAssets struct {
	Assets []*Asset
}

func ActiveAssetsFromProto 

func ActiveAssetsFromProto(aa *snapshot.ActiveAssets) *ActiveAssets

func (ActiveAssets) IntoProto 

func (a ActiveAssets) IntoProto() *snapshot.ActiveAssets

type AnnounceNode 

type AnnounceNode = commandspb.AnnounceNode

type AppState 

type AppState struct {
	Height  uint64
	Block   string
	Time    int64
	ChainID string
}

func AppStateFromProto 

func AppStateFromProto(as *snapshot.AppState) *AppState

func (AppState) IntoProto 

func (a AppState) IntoProto() *snapshot.AppState

type Asset 

type Asset struct {
	// Internal identifier of the asset
	ID string
	// Name of the asset (e.g: Great British Pound)
	Details *AssetDetails
	// Status of the asset
	Status AssetStatus
}

func AssetFromProto 

func AssetFromProto(p *proto.Asset) (*Asset, error)

func (Asset) DeepClone 

func (a Asset) DeepClone() *Asset

func (Asset) IntoProto 

func (a Asset) IntoProto() *proto.Asset

type AssetAction 

type AssetAction struct {
	ID                      string
	State                   uint32
	Asset                   string
	BlockNumber             uint64
	TxIndex                 uint64
	Hash                    string
	BuiltinD                *BuiltinAssetDeposit
	Erc20D                  *ERC20Deposit
	Erc20AL                 *ERC20AssetList
	ERC20AssetLimitsUpdated *ERC20AssetLimitsUpdated
	BridgeStopped           bool
	BridgeResume            bool
}

func AssetActionFromProto 

func AssetActionFromProto(a *checkpointpb.AssetAction) *AssetAction

func (*AssetAction) IntoProto 

func (aa *AssetAction) IntoProto() *checkpointpb.AssetAction

type AssetDetails 

type AssetDetails struct {
	Name     string
	Symbol   string
	Decimals uint64
	Quantum  num.Decimal
	//	*AssetDetailsBuiltinAsset
	//	*AssetDetailsErc20
	Source isAssetDetails
}

func AssetDetailsFromProto 

func AssetDetailsFromProto(p *proto.AssetDetails) (*AssetDetails, error)

func (AssetDetails) DeepClone 

func (a AssetDetails) DeepClone() *AssetDetails

func (AssetDetails) GetERC20 

func (a AssetDetails) GetERC20() *ERC20

func (AssetDetails) IntoProto 

func (a AssetDetails) IntoProto() *proto.AssetDetails

func (AssetDetails) String 

func (a AssetDetails) String() string

func (AssetDetails) Validate 

func (a AssetDetails) Validate() (ProposalError, error)

type AssetDetailsBuiltinAsset 

type AssetDetailsBuiltinAsset struct {
	BuiltinAsset *BuiltinAsset
}

func AssetDetailsBuiltinFromProto 

func AssetDetailsBuiltinFromProto(p *proto.AssetDetails_BuiltinAsset) *AssetDetailsBuiltinAsset

func (AssetDetailsBuiltinAsset) DeepClone 

func (a AssetDetailsBuiltinAsset) DeepClone() isAssetDetails

func (AssetDetailsBuiltinAsset) IntoProto 

func (a AssetDetailsBuiltinAsset) IntoProto() *proto.AssetDetails_BuiltinAsset

func (AssetDetailsBuiltinAsset) String 

func (a AssetDetailsBuiltinAsset) String() string

func (AssetDetailsBuiltinAsset) Validate 

func (a AssetDetailsBuiltinAsset) Validate() (ProposalError, error)

type AssetDetailsErc20 

type AssetDetailsErc20 struct {
	ERC20 *ERC20
}

func AssetDetailsERC20FromProto 

func AssetDetailsERC20FromProto(p *proto.AssetDetails_Erc20) (*AssetDetailsErc20, error)

func (AssetDetailsErc20) DeepClone 

func (a AssetDetailsErc20) DeepClone() isAssetDetails

func (AssetDetailsErc20) IntoProto 

func (a AssetDetailsErc20) IntoProto() *proto.AssetDetails_Erc20

func (AssetDetailsErc20) String 

func (a AssetDetailsErc20) String() string

func (AssetDetailsErc20) Validate 

func (a AssetDetailsErc20) Validate() (ProposalError, error)

type AssetDetailsUpdate 

type AssetDetailsUpdate struct {
	Quantum num.Decimal
	//	*AssetDetailsUpdateERC20
	Source isAssetDetailsUpdate
}

func AssetDetailsUpdateFromProto 

func AssetDetailsUpdateFromProto(p *furypb.AssetDetailsUpdate) (*AssetDetailsUpdate, error)

func (AssetDetailsUpdate) DeepClone 

func (a AssetDetailsUpdate) DeepClone() *AssetDetailsUpdate

func (AssetDetailsUpdate) IntoProto 

func (a AssetDetailsUpdate) IntoProto() *furypb.AssetDetailsUpdate

func (AssetDetailsUpdate) String 

func (a AssetDetailsUpdate) String() string

func (AssetDetailsUpdate) Validate 

func (a AssetDetailsUpdate) Validate() (ProposalError, error)

type AssetDetailsUpdateERC20 

type AssetDetailsUpdateERC20 struct {
	ERC20Update *ERC20Update
}

func AssetDetailsUpdateERC20FromProto 

func AssetDetailsUpdateERC20FromProto(p *furypb.AssetDetailsUpdate_Erc20) (*AssetDetailsUpdateERC20, error)

func (AssetDetailsUpdateERC20) DeepClone 

func (a AssetDetailsUpdateERC20) DeepClone() isAssetDetailsUpdate

func (AssetDetailsUpdateERC20) IntoProto 

func (a AssetDetailsUpdateERC20) IntoProto() *furypb.AssetDetailsUpdate_Erc20

func (AssetDetailsUpdateERC20) String 

func (a AssetDetailsUpdateERC20) String() string

func (AssetDetailsUpdateERC20) Validate 

func (a AssetDetailsUpdateERC20) Validate() (ProposalError, error)

type AssetStatus 

type AssetStatus = proto.Asset_Status
const (
	// Default value, always invalid.
	AssetStatusUnspecified AssetStatus = proto.Asset_STATUS_UNSPECIFIED
	// Asset is proposed and under vote.
	AssetStatusProposed AssetStatus = proto.Asset_STATUS_PROPOSED
	// Asset has been rejected from governance.
	AssetStatusRejected AssetStatus = proto.Asset_STATUS_REJECTED
	// Asset is pending listing from the bridge.
	AssetStatusPendingListing AssetStatus = proto.Asset_STATUS_PENDING_LISTING
	// Asset is fully usable in the network.
	AssetStatusEnabled AssetStatus = proto.Asset_STATUS_ENABLED
)

type AuctionDuration 

type AuctionDuration struct {
	Duration int64
	Volume   uint64
}

func AuctionDurationFromProto 

func AuctionDurationFromProto(ad *proto.AuctionDuration) *AuctionDuration

func (AuctionDuration) DeepClone 

func (a AuctionDuration) DeepClone() *AuctionDuration

func (AuctionDuration) IntoProto 

func (a AuctionDuration) IntoProto() *proto.AuctionDuration

func (AuctionDuration) String 

func (a AuctionDuration) String() string

type AuctionState 

type AuctionState struct {
	Mode               MarketTradingMode
	DefaultMode        MarketTradingMode
	Trigger            AuctionTrigger
	Begin              time.Time
	End                *AuctionDuration
	Start              bool
	Stop               bool
	Extension          AuctionTrigger
	ExtensionEventSent bool
}

func AuctionStateFromProto 

func AuctionStateFromProto(as *snapshot.AuctionState) *AuctionState

func (AuctionState) IntoProto 

func (a AuctionState) IntoProto() *snapshot.AuctionState

type AuctionTrigger 

type AuctionTrigger = proto.AuctionTrigger
const (
	// Default value for AuctionTrigger, no auction triggered.
	AuctionTriggerUnspecified AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_UNSPECIFIED
	// Batch auction.
	AuctionTriggerBatch AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_BATCH
	// Opening auction.
	AuctionTriggerOpening AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_OPENING
	// Price monitoring trigger.
	AuctionTriggerPrice AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_PRICE
	// Liquidity monitoring due to unmet target trigger.
	AuctionTriggerLiquidityTargetNotMet AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_LIQUIDITY_TARGET_NOT_MET
	// Liquidity monitoring due to being unable to deploy LP orders due to missing best bid or ask.
	AuctionTriggerUnableToDeployLPOrders AuctionTrigger = proto.AuctionTrigger_AUCTION_TRIGGER_UNABLE_TO_DEPLOY_LP_ORDERS
)

type BDeposit 

type BDeposit struct {
	ID      string
	Deposit *Deposit
}

func BDepositFromProto 

func BDepositFromProto(d *snapshot.Deposit) *BDeposit

func (BDeposit) IntoProto 

func (b BDeposit) IntoProto() *snapshot.Deposit

type BankingAssetActions 

type BankingAssetActions struct {
	AssetAction []*AssetAction
}

func BankingAssetActionsFromProto 

func BankingAssetActionsFromProto(aa *snapshot.BankingAssetActions) *BankingAssetActions

func (*BankingAssetActions) IntoProto 

func (a *BankingAssetActions) IntoProto() *snapshot.BankingAssetActions

type BankingBridgeState 

type BankingBridgeState struct {
	Active      bool
	BlockHeight uint64
	LogIndex    uint64
}

type BankingDeposits 

type BankingDeposits struct {
	Deposit []*BDeposit
}

func BankingDepositsFromProto 

func BankingDepositsFromProto(bd *snapshot.BankingDeposits) *BankingDeposits

func (BankingDeposits) IntoProto 

func (b BankingDeposits) IntoProto() *snapshot.BankingDeposits

type BankingSeen 

type BankingSeen struct {
	Refs             []string
	LastSeenEthBlock uint64
}

func BankingSeenFromProto 

func BankingSeenFromProto(bs *snapshot.BankingSeen) *BankingSeen

func (BankingSeen) IntoProto 

func (b BankingSeen) IntoProto() *snapshot.BankingSeen

type BankingWithdrawals 

type BankingWithdrawals struct {
	Withdrawals []*RWithdrawal
}

func BankingWithdrawalsFromProto 

func BankingWithdrawalsFromProto(bw *snapshot.BankingWithdrawals) *BankingWithdrawals

func (BankingWithdrawals) IntoProto 

func (b BankingWithdrawals) IntoProto() *snapshot.BankingWithdrawals

type BannedParty 

type BannedParty struct {
	Party string
	Until int64
}

func BannedPartyFromProto 

func BannedPartyFromProto(ban *snapshot.BannedParty) *BannedParty

func (*BannedParty) IntoProto 

func (b *BannedParty) IntoProto() *snapshot.BannedParty

type Block 

type Block struct {
	Height int64
}

func NewBlockFromProto 

func NewBlockFromProto(bp *checkpoint.Block) *Block

func (Block) IntoProto 

func (b Block) IntoProto() *checkpoint.Block

type BlockRejectStats 

type BlockRejectStats struct {
	Total    uint64
	Rejected uint64
}

func BlockRejectStatsFromProto 

func BlockRejectStatsFromProto(rejects *snapshot.BlockRejectStats) *BlockRejectStats

func (*BlockRejectStats) IntoProto 

func (brs *BlockRejectStats) IntoProto() *snapshot.BlockRejectStats

type BuiltinAsset 

type BuiltinAsset struct {
	MaxFaucetAmountMint *num.Uint
}

BuiltinAsset is a Fury internal asset.

func (BuiltinAsset) String 

func (a BuiltinAsset) String() string

type BuiltinAssetDeposit 

type BuiltinAssetDeposit struct {
	// A Fury network internal asset identifier
	FuryAssetID string
	// A Fury party identifier (pub-key)
	PartyID string
	// The amount to be deposited
	Amount *num.Uint
}

func NewBuiltinAssetDepositFromProto 

func NewBuiltinAssetDepositFromProto(p *furypb.BuiltinAssetDeposit) (*BuiltinAssetDeposit, error)

func (BuiltinAssetDeposit) GetFuryAssetID 

func (b BuiltinAssetDeposit) GetFuryAssetID() string

func (BuiltinAssetDeposit) IntoProto 

func (b BuiltinAssetDeposit) IntoProto() *furypb.BuiltinAssetDeposit

func (BuiltinAssetDeposit) String 

func (b BuiltinAssetDeposit) String() string

type BuiltinAssetEvent 

type BuiltinAssetEvent struct {
	// Types that are valid to be assigned to Action:
	//	*BuiltinAssetEvent_Deposit
	//	*BuiltinAssetEvent_Withdrawal
	Action builtinAssetEventAction
}

func NewBuiltinAssetEventFromProto 

func NewBuiltinAssetEventFromProto(p *furypb.BuiltinAssetEvent) (*BuiltinAssetEvent, error)

func (BuiltinAssetEvent) IntoProto 

func (c BuiltinAssetEvent) IntoProto() *furypb.BuiltinAssetEvent

func (BuiltinAssetEvent) String 

func (c BuiltinAssetEvent) String() string

type BuiltinAssetEventDeposit 

type BuiltinAssetEventDeposit struct {
	Deposit *BuiltinAssetDeposit
}

func NewBuiltinAssetEventDeposit 

func NewBuiltinAssetEventDeposit(p *furypb.BuiltinAssetEvent_Deposit) (*BuiltinAssetEventDeposit, error)

func (BuiltinAssetEventDeposit) IntoProto 

func (b BuiltinAssetEventDeposit) IntoProto() *furypb.BuiltinAssetEvent_Deposit

func (BuiltinAssetEventDeposit) String 

func (b BuiltinAssetEventDeposit) String() string

type BuiltinAssetEventWithdrawal 

type BuiltinAssetEventWithdrawal struct {
	Withdrawal *BuiltinAssetWithdrawal
}

func NewBuiltinAssetEventWithdrawal 

func NewBuiltinAssetEventWithdrawal(p *furypb.BuiltinAssetEvent_Withdrawal) (*BuiltinAssetEventWithdrawal, error)

func (BuiltinAssetEventWithdrawal) IntoProto 

func (b BuiltinAssetEventWithdrawal) IntoProto() *furypb.BuiltinAssetEvent_Withdrawal

func (BuiltinAssetEventWithdrawal) String 

func (b BuiltinAssetEventWithdrawal) String() string

type BuiltinAssetWithdrawal 

type BuiltinAssetWithdrawal struct {
	// A Fury network internal asset identifier
	FuryAssetID string
	// A Fury network party identifier (pub-key)
	PartyID string
	// The amount to be withdrawn
	Amount *num.Uint
}

func NewBuiltinAssetWithdrawalFromProto 

func NewBuiltinAssetWithdrawalFromProto(p *furypb.BuiltinAssetWithdrawal) (*BuiltinAssetWithdrawal, error)

func (BuiltinAssetWithdrawal) GetFuryAssetID 

func (b BuiltinAssetWithdrawal) GetFuryAssetID() string

func (BuiltinAssetWithdrawal) IntoProto 

func (b BuiltinAssetWithdrawal) IntoProto() *furypb.BuiltinAssetWithdrawal

func (BuiltinAssetWithdrawal) String 

func (b BuiltinAssetWithdrawal) String() string

type CPMarketState 

type CPMarketState struct {
	ID               string
	Shares           []*ELSShare
	InsuranceBalance *num.Uint
	LastTradeValue   *num.Uint
	LastTradeVolume  *num.Uint
	TTL              time.Time
	Market           *Market // the full market object - needed in case the market has settled but a successor market is enacted during the successor window.
}

func NewMarketStateFromProto 

func NewMarketStateFromProto(ms *checkpoint.MarketState) *CPMarketState

func (*CPMarketState) IntoProto 

func (m *CPMarketState) IntoProto() *checkpoint.MarketState

type CPState 

type CPState struct {
	NextCp int64
}

func CheckpointFromProto 

func CheckpointFromProto(c *snapshot.Checkpoint) *CPState

func (CPState) IntoProto 

func (c CPState) IntoProto() *snapshot.Checkpoint

type CancelTransferFunds 

type CancelTransferFunds struct {
	Party      string
	TransferID string
}

func NewCancelTransferFromProto 

func NewCancelTransferFromProto(party string, p *commandspb.CancelTransfer) *CancelTransferFunds

type Candle 

type Candle = proto.Candle

type ChainEvent 

type ChainEvent = commandspb.ChainEvent

type ChainEventBuiltin 

type ChainEventBuiltin struct {
	Builtin *BuiltinAssetEvent
}

func NewChainEventBuiltinFromProto 

func NewChainEventBuiltinFromProto(p *commandspb.ChainEvent_Builtin) (*ChainEventBuiltin, error)

func (ChainEventBuiltin) IntoProto 

func (c ChainEventBuiltin) IntoProto() *commandspb.ChainEvent_Builtin

func (ChainEventBuiltin) String 

func (c ChainEventBuiltin) String() string

type ChainEventERC20 

type ChainEventERC20 struct {
	ERC20 *ERC20Event
}

func NewChainEventERC20FromProto 

func NewChainEventERC20FromProto(p *commandspb.ChainEvent_Erc20) (*ChainEventERC20, error)

func (ChainEventERC20) IntoProto 

func (c ChainEventERC20) IntoProto() *commandspb.ChainEvent_Erc20

func (ChainEventERC20) String 

func (c ChainEventERC20) String() string

type Checkpoint 

type Checkpoint struct {
	Governance            []byte
	Assets                []byte
	Collateral            []byte
	NetworkParameters     []byte
	Delegation            []byte
	Epoch                 []byte
	Block                 []byte
	Rewards               []byte
	Validators            []byte
	Banking               []byte
	Staking               []byte
	MultisigControl       []byte
	MarketActivityTracker []byte
	Execution             []byte
}

func NewCheckpointFromProto 

func NewCheckpointFromProto(pc *checkpoint.Checkpoint) *Checkpoint

func (Checkpoint) Get 

func (c Checkpoint) Get(name CheckpointName) []byte

Get as the name suggests gets the data by checkpoint name.

func (Checkpoint) GetBlockHeight 

func (c Checkpoint) GetBlockHeight() (int64, error)

func (Checkpoint) HashBytes 

func (c Checkpoint) HashBytes() bytes.Buffer

HashBytes returns the data contained in the checkpoint as a []byte for hashing the order in which the data is added to the slice matters.

func (Checkpoint) IntoProto 

func (c Checkpoint) IntoProto() *checkpoint.Checkpoint

func (*Checkpoint) Set 

func (c *Checkpoint) Set(name CheckpointName, val []byte)

Set set a specific checkpoint value using the name the engine returns.

func (*Checkpoint) SetBlockHeight 

func (c *Checkpoint) SetBlockHeight(height int64) error

type CheckpointName 

type CheckpointName string
const (
	GovernanceCheckpoint            CheckpointName = "governance"
	AssetsCheckpoint                CheckpointName = "assets"
	CollateralCheckpoint            CheckpointName = "collateral"
	NetParamsCheckpoint             CheckpointName = "netparams"
	DelegationCheckpoint            CheckpointName = "delegation"
	EpochCheckpoint                 CheckpointName = "epoch"
	BlockCheckpoint                 CheckpointName = "block" // pseudo-checkpoint, really...
	MarketActivityTrackerCheckpoint CheckpointName = "marketActivity"
	PendingRewardsCheckpoint        CheckpointName = "rewards"
	BankingCheckpoint               CheckpointName = "banking"
	ValidatorsCheckpoint            CheckpointName = "validators"
	StakingCheckpoint               CheckpointName = "staking"
	MultisigControlCheckpoint       CheckpointName = "multisigControl"
	ExecutionCheckpoint             CheckpointName = "execution"
)

type CheckpointState 

type CheckpointState struct {
	State []byte
	Hash  []byte
}

func NewCheckpointStateFromProto 

func NewCheckpointStateFromProto(ps *checkpoint.CheckpointState) *CheckpointState

func (CheckpointState) GetBlockHeight 

func (s CheckpointState) GetBlockHeight() (int64, error)

func (CheckpointState) GetCheckpoint 

func (s CheckpointState) GetCheckpoint() (*Checkpoint, error)

func (CheckpointState) IntoProto 

func (s CheckpointState) IntoProto() *checkpoint.CheckpointState

func (*CheckpointState) SetCheckpoint 

func (s *CheckpointState) SetCheckpoint(cp *Checkpoint) error

func (*CheckpointState) SetState 

func (s *CheckpointState) SetState(state []byte) error

func (CheckpointState) Validate 

func (s CheckpointState) Validate() error

Validate checks the hash, returns nil if valid.

type Chunk 

type Chunk struct {
	Data   []*Payload
	Nr, Of int64
}

func ChunkFromProto 

func ChunkFromProto(c *snapshot.Chunk) *Chunk

func (Chunk) IntoProto 

func (c Chunk) IntoProto() *snapshot.Chunk

type CollateralAccounts 

type CollateralAccounts struct {
	Accounts []*Account
}

func CollateralAccountsFromProto 

func CollateralAccountsFromProto(ca *snapshot.CollateralAccounts) *CollateralAccounts

func (CollateralAccounts) IntoProto 

func (c CollateralAccounts) IntoProto() *snapshot.CollateralAccounts

type CollateralAssets 

type CollateralAssets struct {
	Assets []*Asset
}

func CollateralAssetsFromProto 

func CollateralAssetsFromProto(ca *snapshot.CollateralAssets) *CollateralAssets

func (CollateralAssets) IntoProto 

func (c CollateralAssets) IntoProto() *snapshot.CollateralAssets

type CurrentPrice 

type CurrentPrice struct {
	Price  *num.Uint
	Volume uint64
}

func CurrentPriceFromProto 

func CurrentPriceFromProto(scp *snapshot.CurrentPrice) *CurrentPrice

func (CurrentPrice) IntoProto 

func (cp CurrentPrice) IntoProto() *snapshot.CurrentPrice

type DataSignerType 

type DataSignerType int
const (
	DataSignerTypeUnspecified DataSignerType = iota
	DataSignerTypePubKey
	DataSignerTypeEthAddress
)

type DataSourceDefinition 

type DataSourceDefinition struct {
	SourceType dataSourceType
}

func DataSourceDefinitionFromProto 

func DataSourceDefinitionFromProto(protoConfig *furypb.DataSourceDefinition) *DataSourceDefinition

/ DataSourceDefinitionFromProto tries to build the DataSourceDfiniition object from the given proto object.

func NewDataSourceDefinition 

func NewDataSourceDefinition(tp int) *DataSourceDefinition

NewDataSourceDefinition creates a new EMPTY DataSourceDefinition object.

func (DataSourceDefinition) DeepClone 

func (s DataSourceDefinition) DeepClone() DataSourceDefinition

DeepClone returns a clone of the DataSourceDefinition object.

func (DataSourceDefinition) GetDataSourceSpecConfiguration 

func (s DataSourceDefinition) GetDataSourceSpecConfiguration() *furypb.DataSourceSpecConfiguration

GetDataSourceSpecConfiguration returns the base object - DataSourceSpecConfiguration from the DataSourceDefinition.

func (*DataSourceDefinition) GetDataSourceSpecConfigurationTime 

func (s *DataSourceDefinition) GetDataSourceSpecConfigurationTime() *furypb.DataSourceSpecConfigurationTime

func (DataSourceDefinition) GetFilters 

func (s DataSourceDefinition) GetFilters() []*DataSourceSpecFilter

/ GetFilters tries to get the filters from the DataSourceDefinition if they exist.

func (DataSourceDefinition) GetSigners 

func (s DataSourceDefinition) GetSigners() []*Signer

/ GetSigners tries to get the signers from the DataSourceDefinition if they exist.

func (DataSourceDefinition) IntoProto 

func (s DataSourceDefinition) IntoProto() *furypb.DataSourceDefinition

/ IntoProto returns the proto object from DataSourceDefinition that is - furypb.DataSourceDefinition that may have external or internal SourceType. Returns the whole proto object.

func (*DataSourceDefinition) IsExternal 

func (s *DataSourceDefinition) IsExternal() (bool, error)

func (*DataSourceDefinition) SetFilterDecimals 

func (s *DataSourceDefinition) SetFilterDecimals(d uint64) *DataSourceDefinition

func (*DataSourceDefinition) SetOracleConfig 

func (s *DataSourceDefinition) SetOracleConfig(oc *DataSourceSpecConfiguration) *DataSourceDefinition

SetOracleConfig sets a given oracle config in the receiver. If the receiver is not external oracle type data source - it is not changed. This method does not care about object previous contents.

func (*DataSourceDefinition) SetTimeTriggerConditionConfig 

func (s *DataSourceDefinition) SetTimeTriggerConditionConfig(c []*DataSourceSpecCondition) *DataSourceDefinition

SetTimeTriggerConditionConfig sets a given conditions config in the receiver. If the receiver is not a time triggered data source - it does not set anything to it. This method does not care about object previous contents.

func (DataSourceDefinition) String 

func (s DataSourceDefinition) String() string

/ String returns the data source definition content as a string.

func (DataSourceDefinition) ToDataSourceSpec 

func (s DataSourceDefinition) ToDataSourceSpec() *DataSourceSpec

func (*DataSourceDefinition) ToExternalDataSourceSpec 

func (s *DataSourceDefinition) ToExternalDataSourceSpec() *ExternalDataSourceSpec

func (*DataSourceDefinition) UpdateFilters 

func (s *DataSourceDefinition) UpdateFilters(filters []*DataSourceSpecFilter) error

/ UpdateFilters updates the DataSourceDefinition Filters.

type DataSourceDefinitionExternal 

type DataSourceDefinitionExternal struct {
	SourceType dataSourceType
}

func DataSourceDefinitionExternalFromProto 

func DataSourceDefinitionExternalFromProto(protoConfig *furypb.DataSourceDefinitionExternal) *DataSourceDefinitionExternal

/ DataSourceDefinitionExternalFromProto tries to build the DataSourceDefinitionExternal object from the given proto object..

func (*DataSourceDefinitionExternal) DeepClone 

func (e *DataSourceDefinitionExternal) DeepClone() dataSourceType

func (*DataSourceDefinitionExternal) IntoProto 

func (e *DataSourceDefinitionExternal) IntoProto() *furypb.DataSourceDefinitionExternal

/ IntoProto tries to return the base proto object from DataSourceDefinitionExternal.

func (*DataSourceDefinitionExternal) String 

func (e *DataSourceDefinitionExternal) String() string

type DataSourceDefinitionExternalOracle 

type DataSourceDefinitionExternalOracle struct {
	Oracle *DataSourceSpecConfiguration
}

This is the base data source.

func DataSourceDefinitionExternalOracleFromProto 

func DataSourceDefinitionExternalOracleFromProto(protoConfig *furypb.DataSourceDefinitionExternal_Oracle) *DataSourceDefinitionExternalOracle

DataSourceDefinitionExternalOracleFromProto tries to build the DataSourceDefinitionExternalOracle object from the given proto object.

func (*DataSourceDefinitionExternalOracle) DeepClone 

func (e *DataSourceDefinitionExternalOracle) DeepClone() dataSourceType

func (*DataSourceDefinitionExternalOracle) IntoProto 

func (e *DataSourceDefinitionExternalOracle) IntoProto() *furypb.DataSourceDefinitionExternal_Oracle

/ IntoProto tries to build the proto object from DataSourceDefinitionExternalOracle.

func (*DataSourceDefinitionExternalOracle) String 

func (e *DataSourceDefinitionExternalOracle) String() string

type DataSourceDefinitionExternalx 

type DataSourceDefinitionExternalx struct {
	External *DataSourceDefinitionExternal
}

func (*DataSourceDefinitionExternalx) DeepClone 

func (s *DataSourceDefinitionExternalx) DeepClone() dataSourceType

func (*DataSourceDefinitionExternalx) IntoProto 

func (s *DataSourceDefinitionExternalx) IntoProto() *furypb.DataSourceDefinition_External

IntoProto returns the proto object from DataSourceDefinitionInternalx This method is not called from anywhere.

func (*DataSourceDefinitionExternalx) String 

func (s *DataSourceDefinitionExternalx) String() string

String returns the DataSourceDefinitionExternalx content as a string.

type DataSourceDefinitionInternal 

type DataSourceDefinitionInternal struct {
	SourceType dataSourceType
}

func DataSourceDefinitionInternalFromProto 

func DataSourceDefinitionInternalFromProto(protoConfig *furypb.DataSourceDefinitionInternal) *DataSourceDefinitionInternal

// DataSourceDefinitionInternalFromProto tries to build the DataSourceDefinitionInternal object from the given proto configuration.

func (*DataSourceDefinitionInternal) DeepClone 

func (i *DataSourceDefinitionInternal) DeepClone() dataSourceType

func (*DataSourceDefinitionInternal) IntoProto 

func (i *DataSourceDefinitionInternal) IntoProto() interface{}

func (*DataSourceDefinitionInternal) String 

func (i *DataSourceDefinitionInternal) String() string

type DataSourceDefinitionInternalTime 

type DataSourceDefinitionInternalTime struct {
	Time *DataSourceSpecConfigurationTime
}

func DataSourceDefinitionInternalTimeFromProto 

func DataSourceDefinitionInternalTimeFromProto(protoConfig *furypb.DataSourceDefinitionInternal_Time) *DataSourceDefinitionInternalTime

func (*DataSourceDefinitionInternalTime) DeepClone 

func (i *DataSourceDefinitionInternalTime) DeepClone() dataSourceType

func (*DataSourceDefinitionInternalTime) IntoProto 

func (i *DataSourceDefinitionInternalTime) IntoProto() *furypb.DataSourceDefinitionInternal_Time

func (*DataSourceDefinitionInternalTime) String 

func (i *DataSourceDefinitionInternalTime) String() string

type DataSourceDefinitionInternalx 

type DataSourceDefinitionInternalx struct {
	Internal *DataSourceDefinitionInternal
}

func (*DataSourceDefinitionInternalx) DeepClone 

func (s *DataSourceDefinitionInternalx) DeepClone() dataSourceType

DeepClone returns a clone of the DataSourceDefinitionInternalx object.

func (*DataSourceDefinitionInternalx) IntoProto 

func (s *DataSourceDefinitionInternalx) IntoProto() *furypb.DataSourceDefinition_Internal

IntoProto returns the proto object from DataSourceDefinitionInternalx. This method is not called from anywhere.

func (*DataSourceDefinitionInternalx) String 

func (s *DataSourceDefinitionInternalx) String() string

String returns the DataSourceDefinitionInternalx content as a string.

type DataSourceSpec 

type DataSourceSpec struct {
	ID        string
	CreatedAt int64
	UpdatedAt int64
	Data      *DataSourceDefinition
	Status    DataSourceSpecStatus
}

func DataSourceSpecFromProto 

func DataSourceSpecFromProto(specProto *furypb.DataSourceSpec) *DataSourceSpec

func (*DataSourceSpec) IntoProto 

func (s *DataSourceSpec) IntoProto() *furypb.DataSourceSpec

func (*DataSourceSpec) String 

func (s *DataSourceSpec) String() string

func (*DataSourceSpec) ToExternalDataSourceSpec 

func (s *DataSourceSpec) ToExternalDataSourceSpec() *ExternalDataSourceSpec

/ ToExternalDataSourceSpec wraps the DataSourceSpec receiver into ExternalDataSourceSpec. Used for aligning with required types in the code.

type DataSourceSpecBindingForFuture 

type DataSourceSpecBindingForFuture struct {
	SettlementDataProperty     string
	TradingTerminationProperty string
}

func DataSourceSpecBindingForFutureFromProto 

func DataSourceSpecBindingForFutureFromProto(o *furypb.DataSourceSpecToFutureBinding) *DataSourceSpecBindingForFuture

func OracleSpecBindingForFutureFromProto 

func OracleSpecBindingForFutureFromProto(o *furypb.DataSourceSpecToFutureBinding) *DataSourceSpecBindingForFuture

func (DataSourceSpecBindingForFuture) DeepClone 

func (b DataSourceSpecBindingForFuture) DeepClone() *DataSourceSpecBindingForFuture

func (DataSourceSpecBindingForFuture) IntoProto 

func (b DataSourceSpecBindingForFuture) IntoProto() *furypb.DataSourceSpecToFutureBinding

func (DataSourceSpecBindingForFuture) String 

func (b DataSourceSpecBindingForFuture) String() string

type DataSourceSpecCondition 

type DataSourceSpecCondition struct {
	Operator DataSourceSpecConditionOperator
	Value    string
}

DataSourceSpecCondition mirrors datapb.Condition type.

func DataSourceSpecConditionFromProto 

func DataSourceSpecConditionFromProto(protoCondition *datapb.Condition) *DataSourceSpecCondition

func DataSourceSpecConditionsFromProto 

func DataSourceSpecConditionsFromProto(protoConditions []*datapb.Condition) []*DataSourceSpecCondition

func DeepCloneDataSourceSpecConditions 

func DeepCloneDataSourceSpecConditions(conditions []*DataSourceSpecCondition) []*DataSourceSpecCondition

func (*DataSourceSpecCondition) DeepClone 

func (c *DataSourceSpecCondition) DeepClone() dataSourceType

func (DataSourceSpecCondition) IntoProto 

func (c DataSourceSpecCondition) IntoProto() *datapb.Condition

func (DataSourceSpecCondition) String 

func (c DataSourceSpecCondition) String() string

type DataSourceSpecConditionOperator 

type DataSourceSpecConditionOperator = datapb.Condition_Operator

type DataSourceSpecConditions 

type DataSourceSpecConditions []*DataSourceSpecCondition

func (DataSourceSpecConditions) IntoProto 

func (sc DataSourceSpecConditions) IntoProto() []*datapb.Condition

func (DataSourceSpecConditions) String 

func (sc DataSourceSpecConditions) String() string

type DataSourceSpecConfiguration 

type DataSourceSpecConfiguration struct {
	Signers []*Signer
	Filters []*DataSourceSpecFilter
}

DataSourceSpecConfiguration is used only by Oracles without a type wrapper at the moment.

func DataSourceSpecConfigurationFromProto 

func DataSourceSpecConfigurationFromProto(protoConfig *furypb.DataSourceSpecConfiguration) *DataSourceSpecConfiguration

DataSourceSpecConfigurationFromProto tries to build the DataSourceSpecConfiguration object from the given proto object.

func (*DataSourceSpecConfiguration) DeepClone 

func (s *DataSourceSpecConfiguration) DeepClone() dataSourceType

func (*DataSourceSpecConfiguration) IntoProto 

func (s *DataSourceSpecConfiguration) IntoProto() *furypb.DataSourceSpecConfiguration

/ IntoProto tries to build the proto object from DataSourceSpecConfiguration.

func (*DataSourceSpecConfiguration) String 

func (s *DataSourceSpecConfiguration) String() string

/ String returns the content of DataSourceSpecConfiguration as a string.

type DataSourceSpecConfigurationTime 

type DataSourceSpecConfigurationTime struct {
	Conditions []*DataSourceSpecCondition
}

DataSourceSpecConfigurationTime is used internally.

func DataSourceSpecConfigurationTimeFromProto 

func DataSourceSpecConfigurationTimeFromProto(protoConfig *furypb.DataSourceSpecConfigurationTime) *DataSourceSpecConfigurationTime

func (*DataSourceSpecConfigurationTime) DeepClone 

func (s *DataSourceSpecConfigurationTime) DeepClone() dataSourceType

func (*DataSourceSpecConfigurationTime) IntoProto 

func (s *DataSourceSpecConfigurationTime) IntoProto() *furypb.DataSourceSpecConfigurationTime

func (*DataSourceSpecConfigurationTime) String 

func (s *DataSourceSpecConfigurationTime) String() string

/ String returns the content of DataSourceSpecConfigurationTime as a string.

type DataSourceSpecFilter 

type DataSourceSpecFilter struct {
	Key        *DataSourceSpecPropertyKey
	Conditions []*DataSourceSpecCondition
}

func DataSourceSpecFilterFromProto 

func DataSourceSpecFilterFromProto(protoFilter *datapb.Filter) *DataSourceSpecFilter

func DataSourceSpecFiltersFromProto 

func DataSourceSpecFiltersFromProto(protoFilters []*datapb.Filter) []*DataSourceSpecFilter

func DeepCloneDataSourceSpecFilters 

func DeepCloneDataSourceSpecFilters(filters []*DataSourceSpecFilter) []*DataSourceSpecFilter

func (*DataSourceSpecFilter) DeepClone 

func (f *DataSourceSpecFilter) DeepClone() *DataSourceSpecFilter

DeepClone clones the filter receiver taking into account if its fields are empty.

func (*DataSourceSpecFilter) IntoProto 

func (f *DataSourceSpecFilter) IntoProto() *datapb.Filter

IntoProto return proto version of the filter receiver taking into account if its fields are empty.

func (DataSourceSpecFilter) String 

func (f DataSourceSpecFilter) String() string

type DataSourceSpecFilters 

type DataSourceSpecFilters []*DataSourceSpecFilter

func (DataSourceSpecFilters) IntoProto 

func (df DataSourceSpecFilters) IntoProto() []*datapb.Filter

func (DataSourceSpecFilters) String 

func (df DataSourceSpecFilters) String() string

type DataSourceSpecPropertyKey 

type DataSourceSpecPropertyKey struct {
	Name                string
	Type                DataSourceSpecPropertyKeyType
	NumberDecimalPlaces *uint64
}

func DataSourceSpecPropertyKeyFromProto 

func DataSourceSpecPropertyKeyFromProto(protoKey *datapb.PropertyKey) *DataSourceSpecPropertyKey

func (*DataSourceSpecPropertyKey) DeepClone 

func (k *DataSourceSpecPropertyKey) DeepClone() *DataSourceSpecPropertyKey

func (DataSourceSpecPropertyKey) IntoProto 

func (k DataSourceSpecPropertyKey) IntoProto() *datapb.PropertyKey

func (DataSourceSpecPropertyKey) String 

func (k DataSourceSpecPropertyKey) String() string

type DataSourceSpecPropertyKeyType 

type DataSourceSpecPropertyKeyType = datapb.PropertyKey_Type

type DataSourceSpecSigners 

type DataSourceSpecSigners []*Signer

func (DataSourceSpecSigners) String 

func (s DataSourceSpecSigners) String() string

type DataSourceSpecStatus 

type DataSourceSpecStatus = furypb.DataSourceSpec_Status

type DataSourceSpecToFutureBinding 

type DataSourceSpecToFutureBinding struct{}

type Delegate 

type Delegate struct {
	NodeID string
	Amount *num.Uint
}

func (Delegate) IntoProto 

func (d Delegate) IntoProto() *commandspb.DelegateSubmission

func (Delegate) String 

func (d Delegate) String() string

type DelegateCP 

type DelegateCP struct {
	Active  []*DelegationEntry
	Pending []*DelegationEntry
	Auto    []string
}

func NewDelegationCPFromProto 

func NewDelegationCPFromProto(sd *checkpoint.Delegate) *DelegateCP

func (DelegateCP) IntoProto 

func (d DelegateCP) IntoProto() *checkpoint.Delegate

type Delegation 

type Delegation struct {
	Party    string
	NodeID   string
	Amount   *num.Uint
	EpochSeq string
}

func DelegationFromProto 

func DelegationFromProto(d *fury.Delegation) *Delegation

func (Delegation) IntoProto 

func (d Delegation) IntoProto() *fury.Delegation

type DelegationActive 

type DelegationActive struct {
	Delegations []*Delegation
}

func DelegationActiveFromProto 

func DelegationActiveFromProto(da *snapshot.DelegationActive) *DelegationActive

func (DelegationActive) IntoProto 

func (d DelegationActive) IntoProto() *snapshot.DelegationActive

type DelegationAuto 

type DelegationAuto struct {
	Parties []string
}

func DelegationAutoFromProto 

func DelegationAutoFromProto(da *snapshot.DelegationAuto) *DelegationAuto

func (DelegationAuto) IntoProto 

func (d DelegationAuto) IntoProto() *snapshot.DelegationAuto

type DelegationEntry 

type DelegationEntry struct {
	Party      string
	Node       string
	Amount     *num.Uint
	Undelegate bool
	EpochSeq   uint64
}

func NewDelegationEntryFromProto 

func NewDelegationEntryFromProto(de *checkpoint.DelegateEntry) *DelegationEntry

func (DelegationEntry) IntoProto 

func (d DelegationEntry) IntoProto() *checkpoint.DelegateEntry

type DelegationPending 

type DelegationPending struct {
	Delegations  []*Delegation
	Undelegation []*Delegation
}

func DelegationPendingFromProto 

func DelegationPendingFromProto(dp *snapshot.DelegationPending) *DelegationPending

func (DelegationPending) IntoProto 

func (d DelegationPending) IntoProto() *snapshot.DelegationPending

type Deposit 

type Deposit struct {
	// ID Unique identifier for the deposit
	ID string
	// Status of the deposit
	Status DepositStatus
	// Party identifier of the user initiating the deposit
	PartyID string
	// Asset The Fury asset targeted by this deposit
	Asset string
	// Amount The amount to be deposited
	Amount *num.Uint
	// TxHash The hash of the transaction from the foreign chain
	TxHash string
	// Timestamp for when the Fury account was updated with the deposit
	CreditDate int64
	// Timestamp for when the deposit was created on the Fury network
	CreationDate int64
}

Deposit represent a deposit on to the Fury network.

func DepositFromProto 

func DepositFromProto(d *furypb.Deposit) *Deposit

func (*Deposit) IntoProto 

func (d *Deposit) IntoProto() *furypb.Deposit

func (*Deposit) String 

func (d *Deposit) String() string

type DepositStatus 

type DepositStatus = furypb.Deposit_Status
const (
	// DepositStatusUnspecified Default value, always invalid.
	DepositStatusUnspecified DepositStatus = 0
	// DepositStatusOpen The deposit is being processed by the network.
	DepositStatusOpen DepositStatus = 1
	// DepositStatusCancelled The deposit has been cancelled by the network.
	DepositStatusCancelled DepositStatus = 2
	// DepositStatusFinalized The deposit has been finalised and accounts have been updated.
	DepositStatusFinalized DepositStatus = 3
)

type ELSShare 

type ELSShare struct {
	PartyID       string
	Share         num.Decimal
	SuppliedStake num.Decimal
	VStake        num.Decimal
	Avg           num.Decimal
}

func NewELSShareFromProto 

func NewELSShareFromProto(ELSs *checkpoint.ELSShare) *ELSShare

func (*ELSShare) IntoProto 

func (e *ELSShare) IntoProto() *checkpoint.ELSShare

type ERC20 

type ERC20 struct {
	ContractAddress   string
	LifetimeLimit     *num.Uint
	WithdrawThreshold *num.Uint
}

An ERC20 token based asset, living on the ethereum network.

func (ERC20) DeepClone 

func (e ERC20) DeepClone() *ERC20

func (ERC20) String 

func (e ERC20) String() string

type ERC20AssetDelist 

type ERC20AssetDelist struct {
	// The Fury network internal identifier of the asset
	FuryAssetID string
}

func NewERC20AssetDelistFromProto 

func NewERC20AssetDelistFromProto(p *furypb.ERC20AssetDelist) *ERC20AssetDelist

func (ERC20AssetDelist) IntoProto 

func (e ERC20AssetDelist) IntoProto() *furypb.ERC20AssetDelist

func (ERC20AssetDelist) String 

func (e ERC20AssetDelist) String() string

type ERC20AssetLimitsUpdated 

type ERC20AssetLimitsUpdated struct {
	FuryAssetID           string
	SourceEthereumAddress string
	LifetimeLimits        *num.Uint
	WithdrawThreshold     *num.Uint
}

func NewERC20AssetLimitsUpdatedFromProto 

func NewERC20AssetLimitsUpdatedFromProto(p *furypb.ERC20AssetLimitsUpdated) *ERC20AssetLimitsUpdated

func (ERC20AssetLimitsUpdated) GetFuryAssetID 

func (e ERC20AssetLimitsUpdated) GetFuryAssetID() string

func (ERC20AssetLimitsUpdated) IntoProto 

func (e ERC20AssetLimitsUpdated) IntoProto() *furypb.ERC20AssetLimitsUpdated

func (ERC20AssetLimitsUpdated) String 

func (e ERC20AssetLimitsUpdated) String() string

type ERC20AssetList 

type ERC20AssetList struct {
	// The Fury network internal identifier of the asset
	FuryAssetID string
	// ethereum address of the asset
	AssetSource string
}

func NewERC20AssetListFromProto 

func NewERC20AssetListFromProto(p *furypb.ERC20AssetList) *ERC20AssetList

func (ERC20AssetList) GetFuryAssetID 

func (e ERC20AssetList) GetFuryAssetID() string

func (ERC20AssetList) IntoProto 

func (e ERC20AssetList) IntoProto() *furypb.ERC20AssetList

func (ERC20AssetList) String 

func (e ERC20AssetList) String() string

type ERC20Deposit 

type ERC20Deposit struct {
	// The fury network internal identifier of the asset
	FuryAssetID string
	// The Ethereum wallet that initiated the deposit
	SourceEthereumAddress string
	// The Fury party identifier (pub-key) which is the target of the deposit
	TargetPartyID string
	// The amount to be deposited
	Amount *num.Uint
}

func NewERC20DepositFromProto 

func NewERC20DepositFromProto(p *furypb.ERC20Deposit) (*ERC20Deposit, error)

func (ERC20Deposit) GetFuryAssetID 

func (e ERC20Deposit) GetFuryAssetID() string

func (ERC20Deposit) IntoProto 

func (e ERC20Deposit) IntoProto() *furypb.ERC20Deposit

func (ERC20Deposit) String 

func (e ERC20Deposit) String() string

type ERC20Event 

type ERC20Event struct {
	// Index of the transaction
	Index uint64
	// The block in which the transaction was added
	Block uint64
	// The action
	//
	// Types that are valid to be assigned to Action:
	//	*ERC20EventAssetList
	//	*ERC20EventAssetDelist
	//	*ERC20EventDeposit
	//	*ERC20EventWithdrawal
	//	*ERC20EventAssetLimitsUpdated
	//	*ERC20BridgeStopped
	//	*ERC20BridgeRemoved
	Action erc20EventAction
}

func NewERC20Event 

func NewERC20Event(p *furypb.ERC20Event) (*ERC20Event, error)

func (ERC20Event) IntoProto 

func (e ERC20Event) IntoProto() *furypb.ERC20Event

func (ERC20Event) String 

func (e ERC20Event) String() string

type ERC20EventAssetDelist 

type ERC20EventAssetDelist struct {
	AssetDelist *ERC20AssetDelist
}

func NewERC20EventAssetDelist 

func NewERC20EventAssetDelist(p *furypb.ERC20Event_AssetDelist) *ERC20EventAssetDelist

func (ERC20EventAssetDelist) IntoProto 

func (e ERC20EventAssetDelist) IntoProto() *furypb.ERC20Event_AssetDelist

func (ERC20EventAssetDelist) String 

func (e ERC20EventAssetDelist) String() string

type ERC20EventAssetLimitsUpdated 

type ERC20EventAssetLimitsUpdated struct {
	AssetLimitsUpdated *ERC20AssetLimitsUpdated
}

func NewERC20EventAssetLimitsUpdated 

func NewERC20EventAssetLimitsUpdated(p *furypb.ERC20Event_AssetLimitsUpdated) *ERC20EventAssetLimitsUpdated

func (ERC20EventAssetLimitsUpdated) IntoProto 

func (e ERC20EventAssetLimitsUpdated) IntoProto() *furypb.ERC20Event_AssetLimitsUpdated

func (ERC20EventAssetLimitsUpdated) String 

func (e ERC20EventAssetLimitsUpdated) String() string

type ERC20EventAssetList 

type ERC20EventAssetList struct {
	AssetList *ERC20AssetList
}

func NewERC20EventAssetList 

func NewERC20EventAssetList(p *furypb.ERC20Event_AssetList) *ERC20EventAssetList

func (ERC20EventAssetList) IntoProto 

func (e ERC20EventAssetList) IntoProto() *furypb.ERC20Event_AssetList

func (ERC20EventAssetList) String 

func (e ERC20EventAssetList) String() string

type ERC20EventBridgeResumed 

type ERC20EventBridgeResumed struct {
	BridgeResumed bool
}

func NewERC20EventBridgeResumed 

func NewERC20EventBridgeResumed(p *furypb.ERC20Event_BridgeResumed) *ERC20EventBridgeResumed

func (ERC20EventBridgeResumed) IntoProto 

func (e ERC20EventBridgeResumed) IntoProto() *furypb.ERC20Event_BridgeResumed

func (ERC20EventBridgeResumed) String 

func (e ERC20EventBridgeResumed) String() string

type ERC20EventBridgeStopped 

type ERC20EventBridgeStopped struct {
	BridgeStopped bool
}

func NewERC20EventBridgeStopped 

func NewERC20EventBridgeStopped(p *furypb.ERC20Event_BridgeStopped) *ERC20EventBridgeStopped

func (ERC20EventBridgeStopped) IntoProto 

func (e ERC20EventBridgeStopped) IntoProto() *furypb.ERC20Event_BridgeStopped

func (ERC20EventBridgeStopped) String 

func (e ERC20EventBridgeStopped) String() string

type ERC20EventDeposit 

type ERC20EventDeposit struct {
	Deposit *ERC20Deposit
}

func NewERC20EventDeposit 

func NewERC20EventDeposit(p *furypb.ERC20Event_Deposit) (*ERC20EventDeposit, error)

func (ERC20EventDeposit) IntoProto 

func (e ERC20EventDeposit) IntoProto() *furypb.ERC20Event_Deposit

func (ERC20EventDeposit) String 

func (e ERC20EventDeposit) String() string

type ERC20EventWithdrawal 

type ERC20EventWithdrawal struct {
	Withdrawal *ERC20Withdrawal
}

func NewERC20EventWithdrawal 

func NewERC20EventWithdrawal(p *furypb.ERC20Event_Withdrawal) *ERC20EventWithdrawal

func (ERC20EventWithdrawal) IntoProto 

func (e ERC20EventWithdrawal) IntoProto() *furypb.ERC20Event_Withdrawal

func (ERC20EventWithdrawal) String 

func (e ERC20EventWithdrawal) String() string

type ERC20Update 

type ERC20Update struct {
	LifetimeLimit     *num.Uint
	WithdrawThreshold *num.Uint
}

func (ERC20Update) DeepClone 

func (e ERC20Update) DeepClone() *ERC20Update

func (ERC20Update) String 

func (e ERC20Update) String() string

type ERC20Withdrawal 

type ERC20Withdrawal struct {
	// The Fury network internal identifier of the asset
	FuryAssetID string
	// The target Ethereum wallet address
	TargetEthereumAddress string
	// The reference nonce used for the transaction
	ReferenceNonce string
}

func NewERC20WithdrawalFromProto 

func NewERC20WithdrawalFromProto(p *furypb.ERC20Withdrawal) *ERC20Withdrawal

func (ERC20Withdrawal) GetFuryAssetID 

func (e ERC20Withdrawal) GetFuryAssetID() string

func (ERC20Withdrawal) IntoProto 

func (e ERC20Withdrawal) IntoProto() *furypb.ERC20Withdrawal

func (ERC20Withdrawal) String 

func (e ERC20Withdrawal) String() string

type ETHAddress 

type ETHAddress struct {
	Address string
}

ETHAddress.

func (ETHAddress) DeepClone 

func (e ETHAddress) DeepClone() *ETHAddress

func (ETHAddress) IntoProto 

func (e ETHAddress) IntoProto() *datapb.ETHAddress

func (ETHAddress) String 

func (e ETHAddress) String() string

type Epoch 

type Epoch struct {
	// Unique identifier that increases by one each epoch
	Seq uint64
	// What time did this epoch start
	StartTime time.Time
	// What time should this epoch end
	ExpireTime time.Time
	// What time did it actually end
	EndTime time.Time
	// What action took place
	Action proto.EpochAction
}

func NewEpochFromProto 

func NewEpochFromProto(p *eventspb.EpochEvent) *Epoch

func (Epoch) IntoProto 

func (e Epoch) IntoProto() *eventspb.EpochEvent

func (Epoch) String 

func (e Epoch) String() string

type EpochState 

type EpochState struct {
	Seq                  uint64
	StartTime            time.Time
	ExpireTime           time.Time
	ReadyToStartNewEpoch bool
	ReadyToEndEpoch      bool
}

func EpochFromProto 

func EpochFromProto(e *snapshot.EpochState) *EpochState

func (*EpochState) IntoProto 

func (e *EpochState) IntoProto() *snapshot.EpochState

type EquityShare 

type EquityShare struct {
	Mvp                 num.Decimal
	PMvp                num.Decimal
	R                   num.Decimal
	OpeningAuctionEnded bool
	Lps                 []*EquityShareLP
}

func EquityShareFromProto 

func EquityShareFromProto(es *snapshot.EquityShare) *EquityShare

func (EquityShare) IntoProto 

func (e EquityShare) IntoProto() *snapshot.EquityShare

type EquityShareLP 

type EquityShareLP struct {
	ID     string
	Stake  num.Decimal
	Share  num.Decimal
	Avg    num.Decimal
	VStake num.Decimal
}

func EquityShareLPFromProto 

func EquityShareLPFromProto(esl *snapshot.EquityShareLP) *EquityShareLP

func (EquityShareLP) IntoProto 

func (e EquityShareLP) IntoProto() *snapshot.EquityShareLP

type Erc20WithdrawExt 

type Erc20WithdrawExt struct {
	ReceiverAddress string
}

func Erc20WithdrawExtFromProto 

func Erc20WithdrawExtFromProto(erc20 *furypb.Erc20WithdrawExt) *Erc20WithdrawExt

func (*Erc20WithdrawExt) IntoProto 

func (x *Erc20WithdrawExt) IntoProto() *furypb.Erc20WithdrawExt

func (*Erc20WithdrawExt) String 

func (x *Erc20WithdrawExt) String() string

type EthereumConfig 

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

func EthereumConfigFromProto 

func EthereumConfigFromProto(cfgProto *proto.EthereumConfig) (*EthereumConfig, error)

func EthereumConfigFromUntypedProto 

func EthereumConfigFromUntypedProto(v interface{}) (*EthereumConfig, error)

func (*EthereumConfig) ChainID 

func (c *EthereumConfig) ChainID() string

func (*EthereumConfig) CollateralBridge 

func (c *EthereumConfig) CollateralBridge() EthereumContract

func (*EthereumConfig) Confirmations 

func (c *EthereumConfig) Confirmations() uint64

func (*EthereumConfig) MultiSigControl 

func (c *EthereumConfig) MultiSigControl() EthereumContract

func (*EthereumConfig) NetworkID 

func (c *EthereumConfig) NetworkID() string

func (*EthereumConfig) StakingBridge 

func (c *EthereumConfig) StakingBridge() EthereumContract

func (*EthereumConfig) StakingBridgeAddresses 

func (c *EthereumConfig) StakingBridgeAddresses() []ethcmn.Address

StakingBridgeAddresses returns the registered staking bridge addresses. It might return the staking bridge, or the token vesting, or both contract address. The vesting contract can also be used to get information needed by the staking engine.

func (*EthereumConfig) VestingBridge 

func (c *EthereumConfig) VestingBridge() EthereumContract

type EthereumContract 

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

func (EthereumContract) Address 

func (c EthereumContract) Address() ethcmn.Address

func (EthereumContract) DeploymentBlockHeight 

func (c EthereumContract) DeploymentBlockHeight() uint64

func (EthereumContract) HasAddress 

func (c EthereumContract) HasAddress() bool

func (EthereumContract) HexAddress 

func (c EthereumContract) HexAddress() string

type ExecMarket 

type ExecMarket struct {
	Market                     *Market
	PriceMonitor               *PriceMonitor
	AuctionState               *AuctionState
	PeggedOrders               *PeggedOrdersState
	ExpiringOrders             []*Order
	LastBestBid                *num.Uint
	LastBestAsk                *num.Uint
	LastMidBid                 *num.Uint
	LastMidAsk                 *num.Uint
	LastMarketValueProxy       num.Decimal
	LastEquityShareDistributed int64
	EquityShare                *EquityShare
	CurrentMarkPrice           *num.Uint
	LastTradedPrice            *num.Uint
	ShortRiskFactor            num.Decimal
	LongRiskFactor             num.Decimal
	RiskFactorConsensusReached bool
	FeeSplitter                *FeeSplitter
	SettlementData             *num.Numeric
	NextMTM                    int64
	Parties                    []string
	Closed                     bool
}

func ExecMarketFromProto 

func ExecMarketFromProto(em *snapshot.Market) *ExecMarket

func (ExecMarket) IntoProto 

func (e ExecMarket) IntoProto() *snapshot.Market

type ExecSpotMarket 

type ExecSpotMarket struct {
	Market                     *Market
	PriceMonitor               *PriceMonitor
	AuctionState               *AuctionState
	PeggedOrders               *PeggedOrdersState
	ExpiringOrders             []*Order
	LastBestBid                *num.Uint
	LastBestAsk                *num.Uint
	LastMidBid                 *num.Uint
	LastMidAsk                 *num.Uint
	LastMarketValueProxy       num.Decimal
	LastEquityShareDistributed int64
	EquityShare                *EquityShare
	CurrentMarkPrice           *num.Uint
	LastTradedPrice            *num.Uint
	FeeSplitter                *FeeSplitter
	NextMTM                    int64
	Parties                    []string
	Closed                     bool
}

func ExecSpotMarketFromProto 

func ExecSpotMarketFromProto(em *snapshot.SpotMarket) *ExecSpotMarket

func (ExecSpotMarket) IntoProto 

func (e ExecSpotMarket) IntoProto() *snapshot.SpotMarket

type ExecutionMarkets 

type ExecutionMarkets struct {
	Markets     []*ExecMarket
	SpotMarkets []*ExecSpotMarket
}

func ExecutionMarketsFromProto 

func ExecutionMarketsFromProto(em *snapshot.ExecutionMarkets) *ExecutionMarkets

func (ExecutionMarkets) IntoProto 

func (e ExecutionMarkets) IntoProto() *snapshot.ExecutionMarkets

type ExecutionState 

type ExecutionState struct {
	Data []*CPMarketState
}

func NewExecutionStateFromProto 

func NewExecutionStateFromProto(es *checkpoint.ExecutionState) *ExecutionState

func (*ExecutionState) IntoProto 

func (e *ExecutionState) IntoProto() *checkpoint.ExecutionState

type ExternalDataSourceSpec 

type ExternalDataSourceSpec struct {
	Spec *DataSourceSpec
}

func ExternalDataSourceSpecFromProto 

func ExternalDataSourceSpecFromProto(specProto *furypb.ExternalDataSourceSpec) *ExternalDataSourceSpec

func (*ExternalDataSourceSpec) IntoProto 

func (s *ExternalDataSourceSpec) IntoProto() *furypb.ExternalDataSourceSpec

func (*ExternalDataSourceSpec) String 

func (s *ExternalDataSourceSpec) String() string

type ExternalDataSourceSpecConfiguration 

type ExternalDataSourceSpecConfiguration struct {
	DataSourceSpec *DataSourceSpecConfiguration
}

type Fee 

type Fee struct {
	MakerFee          *num.Uint
	InfrastructureFee *num.Uint
	LiquidityFee      *num.Uint
}

func NewFee 

func NewFee() *Fee

NewFee returns a new fee object, with all fields initialised.

func (Fee) Clone 

func (f Fee) Clone() *Fee

func (Fee) IntoProto 

func (f Fee) IntoProto() *proto.Fee

func (*Fee) String 

func (f *Fee) String() string

type FeeFactors 

type FeeFactors struct {
	MakerFee          num.Decimal
	InfrastructureFee num.Decimal
	LiquidityFee      num.Decimal
}

func FeeFactorsFromProto 

func FeeFactorsFromProto(f *proto.FeeFactors) *FeeFactors

func (FeeFactors) DeepClone 

func (f FeeFactors) DeepClone() *FeeFactors

func (FeeFactors) IntoProto 

func (f FeeFactors) IntoProto() *proto.FeeFactors

func (FeeFactors) String 

func (f FeeFactors) String() string

type FeeSplitter 

type FeeSplitter struct {
	TimeWindowStart time.Time
	TradeValue      *num.Uint
	Avg             num.Decimal
	Window          uint64
}

func FeeSplitterFromProto 

func FeeSplitterFromProto(fs *snapshot.FeeSplitter) *FeeSplitter

func (FeeSplitter) IntoProto 

func (f FeeSplitter) IntoProto() *snapshot.FeeSplitter

type Fees 

type Fees struct {
	Factors *FeeFactors
}

func FeesFromProto 

func FeesFromProto(f *proto.Fees) *Fees

func (Fees) DeepClone 

func (f Fees) DeepClone() *Fees

func (Fees) IntoProto 

func (f Fees) IntoProto() *proto.Fees

func (Fees) String 

func (f Fees) String() string

type FinancialAmount 

type FinancialAmount struct {
	Asset  string
	Amount *num.Uint
}

func FinancialAmountFromProto 

func FinancialAmountFromProto(p *proto.FinancialAmount) (*FinancialAmount, error)

func (*FinancialAmount) Clone 

func (f *FinancialAmount) Clone() *FinancialAmount

func (*FinancialAmount) IntoProto 

func (f *FinancialAmount) IntoProto() *proto.FinancialAmount

func (FinancialAmount) String 

func (f FinancialAmount) String() string

type Future 

type Future struct {
	SettlementAsset                     string
	QuoteName                           string
	DataSourceSpecForSettlementData     *DataSourceSpec
	DataSourceSpecForTradingTermination *DataSourceSpec
	DataSourceSpecBinding               *DataSourceSpecBindingForFuture
}

func FutureFromProto 

func FutureFromProto(f *proto.Future) *Future

func (Future) IntoProto 

func (f Future) IntoProto() *proto.Future

func (Future) String 

func (f Future) String() string

type FutureProduct 

type FutureProduct struct {
	SettlementAsset                     string
	QuoteName                           string
	DataSourceSpecForSettlementData     DataSourceDefinition
	DataSourceSpecForTradingTermination DataSourceDefinition
	DataSourceSpecBinding               *DataSourceSpecBindingForFuture
}

func (FutureProduct) Assets 

func (f FutureProduct) Assets() []string

func (FutureProduct) DeepClone 

func (f FutureProduct) DeepClone() *FutureProduct

func (FutureProduct) IntoProto 

func (f FutureProduct) IntoProto() *furypb.FutureProduct

func (FutureProduct) String 

func (f FutureProduct) String() string

type GovernanceActive 

type GovernanceActive struct {
	Proposals []*ProposalData
}

func GovernanceActiveFromProto 

func GovernanceActiveFromProto(ga *snapshot.GovernanceActive) *GovernanceActive

func (GovernanceActive) IntoProto 

func (g GovernanceActive) IntoProto() *snapshot.GovernanceActive

type GovernanceData 

type GovernanceData = furypb.GovernanceData

type GovernanceEnacted 

type GovernanceEnacted struct {
	Proposals []*ProposalData
}

func GovernanceEnactedFromProto 

func GovernanceEnactedFromProto(ge *snapshot.GovernanceEnacted) *GovernanceEnacted

func (GovernanceEnacted) IntoProto 

func (g GovernanceEnacted) IntoProto() *snapshot.GovernanceEnacted

type GovernanceNode 

type GovernanceNode struct {
	Proposals []*Proposal
}

func GovernanceNodeFromProto 

func GovernanceNodeFromProto(ge *snapshot.GovernanceNode) *GovernanceNode

func (GovernanceNode) IntoProto 

func (g GovernanceNode) IntoProto() *snapshot.GovernanceNode

type IcebergOrder 

type IcebergOrder struct {
	ReservedRemaining uint64
	InitialPeakSize   uint64
	MinimumPeakSize   uint64
}

func NewIcebergOrderFromProto 

func NewIcebergOrderFromProto(i *proto.IcebergOrder) (*IcebergOrder, error)

func (IcebergOrder) Clone 

func (i IcebergOrder) Clone() *IcebergOrder

func (IcebergOrder) IntoProto 

func (i IcebergOrder) IntoProto() *proto.IcebergOrder

func (IcebergOrder) String 

func (i IcebergOrder) String() string

type Instrument 

type Instrument struct {
	ID       string
	Code     string
	Name     string
	Metadata *InstrumentMetadata
	// Types that are valid to be assigned to Product:
	//	*InstrumentFuture
	//	*InstrumentSpot
	Product iProto
}

func InstrumentFromProto 

func InstrumentFromProto(i *proto.Instrument) *Instrument

func (Instrument) DeepClone 

func (i Instrument) DeepClone() *Instrument

func (Instrument) GetFuture 

func (i Instrument) GetFuture() *Future

func (Instrument) GetSpot 

func (i Instrument) GetSpot() *Spot

func (Instrument) IntoProto 

func (i Instrument) IntoProto() *proto.Instrument

func (Instrument) String 

func (i Instrument) String() string

type InstrumentConfiguration 

type InstrumentConfiguration struct {
	Name string
	Code string
	// *InstrumentConfigurationFuture
	// *InstrumentConfigurationSpot
	Product instrumentConfigurationProduct
}

func InstrumentConfigurationFromProto 

func InstrumentConfigurationFromProto(
	p *furypb.InstrumentConfiguration,
) *InstrumentConfiguration

func (InstrumentConfiguration) DeepClone 

func (i InstrumentConfiguration) DeepClone() *InstrumentConfiguration

func (InstrumentConfiguration) IntoProto 

func (i InstrumentConfiguration) IntoProto() *furypb.InstrumentConfiguration

func (InstrumentConfiguration) String 

func (i InstrumentConfiguration) String() string

type InstrumentConfigurationFuture 

type InstrumentConfigurationFuture struct {
	Future *FutureProduct
}

func (InstrumentConfigurationFuture) Assets 

func (i InstrumentConfigurationFuture) Assets() []string

func (InstrumentConfigurationFuture) DeepClone 

func (i InstrumentConfigurationFuture) DeepClone() instrumentConfigurationProduct

func (InstrumentConfigurationFuture) IntoProto 

func (i InstrumentConfigurationFuture) IntoProto() *furypb.InstrumentConfiguration_Future

func (InstrumentConfigurationFuture) String 

func (i InstrumentConfigurationFuture) String() string

func (InstrumentConfigurationFuture) Type 

func (InstrumentConfigurationFuture) Type() ProductType

type InstrumentConfigurationSpot 

type InstrumentConfigurationSpot struct {
	Spot *SpotProduct
}

func (InstrumentConfigurationSpot) Assets 

func (i InstrumentConfigurationSpot) Assets() []string

func (InstrumentConfigurationSpot) DeepClone 

func (i InstrumentConfigurationSpot) DeepClone() instrumentConfigurationProduct

func (InstrumentConfigurationSpot) IntoProto 

func (i InstrumentConfigurationSpot) IntoProto() *furypb.InstrumentConfiguration_Spot

func (InstrumentConfigurationSpot) String 

func (i InstrumentConfigurationSpot) String() string

func (InstrumentConfigurationSpot) Type 

func (InstrumentConfigurationSpot) Type() ProductType

type InstrumentFuture 

type InstrumentFuture struct {
	Future *Future
}

func InstrumentFutureFromProto 

func InstrumentFutureFromProto(f *proto.Instrument_Future) *InstrumentFuture

func (InstrumentFuture) IntoProto 

func (i InstrumentFuture) IntoProto() *proto.Instrument_Future

func (InstrumentFuture) String 

func (i InstrumentFuture) String() string

func (InstrumentFuture) Type 

func (InstrumentFuture) Type() ProductType

type InstrumentMetadata 

type InstrumentMetadata struct {
	Tags []string
}

func InstrumentMetadataFromProto 

func InstrumentMetadataFromProto(m *proto.InstrumentMetadata) *InstrumentMetadata

func (InstrumentMetadata) DeepClone 

func (i InstrumentMetadata) DeepClone() *InstrumentMetadata

func (InstrumentMetadata) IntoProto 

func (i InstrumentMetadata) IntoProto() *proto.InstrumentMetadata

func (InstrumentMetadata) String 

func (i InstrumentMetadata) String() string

type InstrumentSpot 

type InstrumentSpot struct {
	Spot *Spot
}

func InstrumentSpotFromProto 

func InstrumentSpotFromProto(f *proto.Instrument_Spot) *InstrumentSpot

func (InstrumentSpot) IntoProto 

func (i InstrumentSpot) IntoProto() *proto.Instrument_Spot

func (InstrumentSpot) String 

func (i InstrumentSpot) String() string

func (InstrumentSpot) Type 

func (InstrumentSpot) Type() ProductType

type Interval 

type Interval = proto.Interval

type KeyDecimalPair 

type KeyDecimalPair struct {
	Key int64
	Val num.Decimal
}

func KeyDecimalPairFromProto 

func KeyDecimalPairFromProto(dm *snapshot.DecimalMap) *KeyDecimalPair

func (KeyDecimalPair) IntoProto 

func (d KeyDecimalPair) IntoProto() *snapshot.DecimalMap

type LedgerEntries 

type LedgerEntries []*LedgerEntry

func (LedgerEntries) IntoProto 

func (a LedgerEntries) IntoProto() []*proto.LedgerEntry

type LedgerEntry 

type LedgerEntry struct {
	FromAccount        *AccountDetails
	ToAccount          *AccountDetails
	Amount             *num.Uint
	Type               TransferType
	Timestamp          int64
	FromAccountBalance *num.Uint
	ToAccountBalance   *num.Uint
}

func (*LedgerEntry) IntoProto 

func (l *LedgerEntry) IntoProto() *proto.LedgerEntry

type LedgerMovement 

type LedgerMovement struct {
	Entries  []*LedgerEntry
	Balances []*PostTransferBalance
}

func (*LedgerMovement) IntoProto 

func (t *LedgerMovement) IntoProto() *proto.LedgerMovement

type LedgerMovements 

type LedgerMovements []*LedgerMovement

func (LedgerMovements) IntoProto 

func (a LedgerMovements) IntoProto() []*proto.LedgerMovement

type LimitState 

type LimitState struct {
	BlockCount               uint32
	CanProposeMarket         bool
	CanProposeAsset          bool
	GenesisLoaded            bool
	ProposeMarketEnabled     bool
	ProposeAssetEnabled      bool
	ProposeMarketEnabledFrom time.Time
	ProposeAssetEnabledFrom  time.Time
}

func LimitFromProto 

func LimitFromProto(l *snapshot.LimitState) *LimitState

func (*LimitState) IntoProto 

func (l *LimitState) IntoProto() *snapshot.LimitState

type LiquidityMonitoringParameters 

type LiquidityMonitoringParameters struct {
	// Specifies parameters related to target stake calculation
	TargetStakeParameters *TargetStakeParameters
	// Specifies the triggering ratio for entering liquidity auction
	TriggeringRatio num.Decimal
	// Specifies by how many seconds an auction should be extended if leaving the auction were to trigger a liquidity auction
	AuctionExtension int64
}

func LiquidityMonitoringParametersFromProto 

func LiquidityMonitoringParametersFromProto(p *proto.LiquidityMonitoringParameters) (*LiquidityMonitoringParameters, error)

func (LiquidityMonitoringParameters) DeepClone 

func (l LiquidityMonitoringParameters) DeepClone() *LiquidityMonitoringParameters

func (LiquidityMonitoringParameters) IntoProto 

func (l LiquidityMonitoringParameters) IntoProto() *proto.LiquidityMonitoringParameters

func (LiquidityMonitoringParameters) String 

func (l LiquidityMonitoringParameters) String() string

type LiquidityOrder 

type LiquidityOrder struct {
	// The pegged reference point for the order
	Reference PeggedReference
	// The relative proportion of the commitment to be allocated at a price level
	Proportion uint32
	// The offset/amount of units away for the order
	Offset *num.Uint
}

func LiquidityOrderFromProto 

func LiquidityOrderFromProto(p *proto.LiquidityOrder) (*LiquidityOrder, error)

func (LiquidityOrder) DeepClone 

func (l LiquidityOrder) DeepClone() *LiquidityOrder

func (LiquidityOrder) IntoProto 

func (l LiquidityOrder) IntoProto() *proto.LiquidityOrder

func (LiquidityOrder) String 

func (l LiquidityOrder) String() string

type LiquidityOrderReference 

type LiquidityOrderReference struct {
	// Unique identifier of the pegged order generated by the core to fulfil this liquidity order
	OrderID string
	// The liquidity order from the original submission
	LiquidityOrder *LiquidityOrder
}

func LiquidityOrderReferenceFromProto 

func LiquidityOrderReferenceFromProto(p *proto.LiquidityOrderReference) (*LiquidityOrderReference, error)

func (LiquidityOrderReference) IntoProto 

func (l LiquidityOrderReference) IntoProto() *proto.LiquidityOrderReference

func (LiquidityOrderReference) String 

func (l LiquidityOrderReference) String() string

type LiquidityOrderReferences 

type LiquidityOrderReferences []*LiquidityOrderReference

func (LiquidityOrderReferences) String 

func (ls LiquidityOrderReferences) String() string

type LiquidityOrders 

type LiquidityOrders []*LiquidityOrder

func (LiquidityOrders) String 

func (ls LiquidityOrders) String() string

type LiquidityProviderFeeShare 

type LiquidityProviderFeeShare = proto.LiquidityProviderFeeShare

type LiquidityProviderFeeShares 

type LiquidityProviderFeeShares []*LiquidityProviderFeeShare

func (LiquidityProviderFeeShares) String 

func (ls LiquidityProviderFeeShares) String() string

type LiquidityProvision 

type LiquidityProvision struct {
	// Unique identifier
	ID string
	// Unique party identifier for the creator of the provision
	Party string
	// Timestamp for when the order was created at, in nanoseconds since the epoch
	// - See [`FuryTimeResponse`](#api.FuryTimeResponse).`timestamp`
	CreatedAt int64
	// Timestamp for when the order was updated at, in nanoseconds since the epoch
	// - See [`FuryTimeResponse`](#api.FuryTimeResponse).`timestamp`
	UpdatedAt int64
	// Market identifier for the order, required field
	MarketID string
	// Specified as a unitless number that represents the amount of settlement asset of the market
	CommitmentAmount *num.Uint
	// Nominated liquidity fee factor, which is an input to the calculation of taker fees on the market, as per seeting fees and rewarding liquidity providers
	Fee num.Decimal
	// A set of liquidity sell orders to meet the liquidity provision obligation
	Sells []*LiquidityOrderReference
	// A set of liquidity buy orders to meet the liquidity provision obligation
	Buys []*LiquidityOrderReference
	// Version of this liquidity provision order
	Version uint64
	// Status of this liquidity provision order
	Status LiquidityProvisionStatus
	// A reference shared between this liquidity provision and all it's orders
	Reference string
}

func LiquidityProvisionFromProto 

func LiquidityProvisionFromProto(p *proto.LiquidityProvision) (*LiquidityProvision, error)

func (LiquidityProvision) IntoProto 

func (l LiquidityProvision) IntoProto() *proto.LiquidityProvision

func (LiquidityProvision) String 

func (l LiquidityProvision) String() string

type LiquidityProvisionAmendment 

type LiquidityProvisionAmendment struct {
	// Market identifier for the order, required field
	MarketID string
	// Specified as a unitless number that represents the amount of settlement asset of the market
	CommitmentAmount *num.Uint
	// Nominated liquidity fee factor, which is an input to the calculation of taker fees on the market, as per setting fees and rewarding liquidity providers
	Fee num.Decimal
	// A set of liquidity sell orders to meet the liquidity provision obligation
	Sells []*LiquidityOrder
	// A set of liquidity buy orders to meet the liquidity provision obligation
	Buys []*LiquidityOrder
	// A reference to be added to every order created out of this liquidityProvisionAmendment
	Reference string
}

func LiquidityProvisionAmendmentFromProto 

func LiquidityProvisionAmendmentFromProto(p *commandspb.LiquidityProvisionAmendment) (*LiquidityProvisionAmendment, error)

func (LiquidityProvisionAmendment) ContainsOrders 

func (a LiquidityProvisionAmendment) ContainsOrders() bool

func (LiquidityProvisionAmendment) GetMarketID 

func (a LiquidityProvisionAmendment) GetMarketID() string

func (LiquidityProvisionAmendment) IntoProto 

func (a LiquidityProvisionAmendment) IntoProto() *commandspb.LiquidityProvisionAmendment

func (LiquidityProvisionAmendment) String 

func (a LiquidityProvisionAmendment) String() string

type LiquidityProvisionCancellation 

type LiquidityProvisionCancellation struct {
	// Market identifier for the order, required field
	MarketID string
}

func LiquidityProvisionCancellationFromProto 

func LiquidityProvisionCancellationFromProto(p *commandspb.LiquidityProvisionCancellation) (*LiquidityProvisionCancellation, error)

func (LiquidityProvisionCancellation) GetMarketID 

func (l LiquidityProvisionCancellation) GetMarketID() string

func (LiquidityProvisionCancellation) IntoProto 

func (l LiquidityProvisionCancellation) IntoProto() *commandspb.LiquidityProvisionCancellation

func (LiquidityProvisionCancellation) String 

func (l LiquidityProvisionCancellation) String() string

type LiquidityProvisionStatus 

type LiquidityProvisionStatus = proto.LiquidityProvision_Status
const (
	// LiquidityProvisionUnspecified The default value.
	LiquidityProvisionUnspecified LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_UNSPECIFIED
	// LiquidityProvisionStatusActive The liquidity provision is active.
	LiquidityProvisionStatusActive LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_ACTIVE
	// LiquidityProvisionStatusStopped The liquidity provision was stopped by the network.
	LiquidityProvisionStatusStopped LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_STOPPED
	// LiquidityProvisionStatusCancelled The liquidity provision was cancelled by the liquidity provider.
	LiquidityProvisionStatusCancelled LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_CANCELLED
	// LiquidityProvisionStatusRejected The liquidity provision was invalid and got rejected.
	LiquidityProvisionStatusRejected LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_REJECTED
	// LiquidityProvisionStatusUndeployed The liquidity provision is valid and accepted by network, but orders aren't deployed.
	LiquidityProvisionStatusUndeployed LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_UNDEPLOYED
	// LiquidityProvisionStatusPending The liquidity provision is valid and accepted by network
	// but have never been deployed. I when it's possible to deploy them for the first time
	// margin check fails, then they will be cancelled without any penalties.
	LiquidityProvisionStatusPending LiquidityProvisionStatus = proto.LiquidityProvision_STATUS_PENDING
)

type LiquidityProvisionSubmission 

type LiquidityProvisionSubmission struct {
	// Market identifier for the order, required field
	MarketID string
	// Specified as a unitless number that represents the amount of settlement asset of the market
	CommitmentAmount *num.Uint
	// Nominated liquidity fee factor, which is an input to the calculation of taker fees on the market, as per setting fees and rewarding liquidity providers
	Fee num.Decimal
	// A set of liquidity sell orders to meet the liquidity provision obligation
	Sells []*LiquidityOrder
	// A set of liquidity buy orders to meet the liquidity provision obligation
	Buys []*LiquidityOrder
	// A reference to be added to every order created out of this liquidityProvisionSubmission
	Reference string
}

func LiquidityProvisionSubmissionFromProto 

func LiquidityProvisionSubmissionFromProto(p *commandspb.LiquidityProvisionSubmission) (*LiquidityProvisionSubmission, error)

func (LiquidityProvisionSubmission) IntoProto 

func (l LiquidityProvisionSubmission) IntoProto() *commandspb.LiquidityProvisionSubmission

func (LiquidityProvisionSubmission) String 

func (l LiquidityProvisionSubmission) String() string

type LogNormalModelParams 

type LogNormalModelParams struct {
	Mu    num.Decimal
	R     num.Decimal
	Sigma num.Decimal
}

func LogNormalParamsFromProto 

func LogNormalParamsFromProto(p *proto.LogNormalModelParams) *LogNormalModelParams

func (LogNormalModelParams) DeepClone 

func (l LogNormalModelParams) DeepClone() *LogNormalModelParams

func (LogNormalModelParams) IntoProto 

func (l LogNormalModelParams) IntoProto() *proto.LogNormalModelParams

func (LogNormalModelParams) String 

func (l LogNormalModelParams) String() string

type LogNormalRiskModel 

type LogNormalRiskModel struct {
	RiskAversionParameter num.Decimal
	Tau                   num.Decimal
	Params                *LogNormalModelParams
}

func (LogNormalRiskModel) DeepClone 

func (l LogNormalRiskModel) DeepClone() *LogNormalRiskModel

func (LogNormalRiskModel) IntoProto 

func (l LogNormalRiskModel) IntoProto() *proto.LogNormalRiskModel

func (LogNormalRiskModel) String 

func (l LogNormalRiskModel) String() string

type MarginCalculator 

type MarginCalculator struct {
	ScalingFactors *ScalingFactors
}

func MarginCalculatorFromProto 

func MarginCalculatorFromProto(p *proto.MarginCalculator) *MarginCalculator

func (MarginCalculator) DeepClone 

func (m MarginCalculator) DeepClone() *MarginCalculator

func (MarginCalculator) IntoProto 

func (m MarginCalculator) IntoProto() *proto.MarginCalculator

func (MarginCalculator) String 

func (m MarginCalculator) String() string

type MarginLevels 

type MarginLevels struct {
	MaintenanceMargin      *num.Uint
	SearchLevel            *num.Uint
	InitialMargin          *num.Uint
	CollateralReleaseLevel *num.Uint
	Party                  string
	MarketID               string
	Asset                  string
	Timestamp              int64
}

func (MarginLevels) IntoProto 

func (m MarginLevels) IntoProto() *proto.MarginLevels

func (MarginLevels) String 

func (m MarginLevels) String() string

type Market 

type Market struct {
	ID                            string
	TradableInstrument            *TradableInstrument
	DecimalPlaces                 uint64
	PositionDecimalPlaces         int64
	Fees                          *Fees
	OpeningAuction                *AuctionDuration
	PriceMonitoringSettings       *PriceMonitoringSettings
	LiquidityMonitoringParameters *LiquidityMonitoringParameters
	LPPriceRange                  num.Decimal
	LinearSlippageFactor          num.Decimal
	QuadraticSlippageFactor       num.Decimal

	TradingMode           MarketTradingMode
	State                 MarketState
	MarketTimestamps      *MarketTimestamps
	ParentMarketID        string
	InsurancePoolFraction num.Decimal
}

func MarketFromProto 

func MarketFromProto(mkt *proto.Market) (*Market, error)

func (Market) DeepClone 

func (m Market) DeepClone() *Market

func (*Market) GetAssets 

func (m *Market) GetAssets() ([]string, error)

func (*Market) GetFuture 

func (m *Market) GetFuture() *InstrumentFuture

func (Market) GetID 

func (m Market) GetID() string

func (*Market) GetSpot 

func (m *Market) GetSpot() *InstrumentSpot

func (Market) IntoProto 

func (m Market) IntoProto() *proto.Market

func (*Market) ProductType 

func (m *Market) ProductType() ProductType

func (Market) String 

func (m Market) String() string

type MarketContributionScore 

type MarketContributionScore struct {
	Asset  string
	Market string
	Metric proto.DispatchMetric
	Score  num.Decimal
}

type MarketCounters 

type MarketCounters struct {
	PeggedOrderCounter  uint64
	LPShapeCount        uint64
	PositionCount       uint64
	OrderbookLevelCount uint64
}

type MarketData 

type MarketData struct {
	MarkPrice                 *num.Uint
	LastTradedPrice           *num.Uint
	BestBidPrice              *num.Uint
	BestBidVolume             uint64
	BestOfferPrice            *num.Uint
	BestOfferVolume           uint64
	BestStaticBidPrice        *num.Uint
	BestStaticBidVolume       uint64
	BestStaticOfferPrice      *num.Uint
	BestStaticOfferVolume     uint64
	MidPrice                  *num.Uint
	StaticMidPrice            *num.Uint
	Market                    string
	Timestamp                 int64
	OpenInterest              uint64
	AuctionEnd                int64
	AuctionStart              int64
	IndicativePrice           *num.Uint
	IndicativeVolume          uint64
	MarketTradingMode         MarketTradingMode
	MarketState               MarketState
	Trigger                   AuctionTrigger
	ExtensionTrigger          AuctionTrigger
	TargetStake               string
	SuppliedStake             string
	PriceMonitoringBounds     []*PriceMonitoringBounds
	MarketValueProxy          string
	LiquidityProviderFeeShare []*LiquidityProviderFeeShare
	NextMTM                   int64
}

func (MarketData) DeepClone 

func (m MarketData) DeepClone() *MarketData

func (MarketData) IntoProto 

func (m MarketData) IntoProto() *proto.MarketData

func (MarketData) String 

func (m MarketData) String() string

type MarketDepth 

type MarketDepth = proto.MarketDepth

type MarketDepthUpdate 

type MarketDepthUpdate = proto.MarketDepthUpdate

type MarketPosition 

type MarketPosition struct {
	PartyID                       string
	Size, Buy, Sell               int64
	Price                         *num.Uint
	BuySumProduct, SellSumProduct *num.Uint
	Distressed                    bool
}

func MarketPositionFromProto 

func MarketPositionFromProto(p *snapshot.Position) *MarketPosition

func (MarketPosition) IntoProto 

func (p MarketPosition) IntoProto() *snapshot.Position

type MarketPositions 

type MarketPositions struct {
	MarketID  string
	Positions []*MarketPosition
}

func MarketPositionsFromProto 

func MarketPositionsFromProto(mp *snapshot.MarketPositions) *MarketPositions

func (MarketPositions) IntoProto 

func (m MarketPositions) IntoProto() *snapshot.MarketPositions

type MarketState 

type MarketState = proto.Market_State
const (
	// Default value, invalid.
	MarketStateUnspecified MarketState = proto.Market_STATE_UNSPECIFIED
	// The Governance proposal valid and accepted.
	MarketStateProposed MarketState = proto.Market_STATE_PROPOSED
	// Outcome of governance votes is to reject the market.
	MarketStateRejected MarketState = proto.Market_STATE_REJECTED
	// Governance vote passes/wins.
	MarketStatePending MarketState = proto.Market_STATE_PENDING
	// Market triggers cancellation condition or governance
	// votes to close before market becomes Active.
	MarketStateCancelled MarketState = proto.Market_STATE_CANCELLED
	// Enactment date reached and usual auction exit checks pass.
	MarketStateActive MarketState = proto.Market_STATE_ACTIVE
	// Price monitoring or liquidity monitoring trigger.
	MarketStateSuspended MarketState = proto.Market_STATE_SUSPENDED
	// Governance vote (to close).
	MarketStateClosed MarketState = proto.Market_STATE_CLOSED
	// Defined by the product (i.e. from a product parameter,
	// specified in market definition, giving close date/time).
	MarketStateTradingTerminated MarketState = proto.Market_STATE_TRADING_TERMINATED
	// Settlement triggered and completed as defined by product.
	MarketStateSettled MarketState = proto.Market_STATE_SETTLED
)

type MarketTimestamps 

type MarketTimestamps struct {
	Proposed int64
	Pending  int64
	Open     int64
	Close    int64
}

func MarketTimestampsFromProto 

func MarketTimestampsFromProto(p *proto.MarketTimestamps) *MarketTimestamps

func (MarketTimestamps) DeepClone 

func (m MarketTimestamps) DeepClone() *MarketTimestamps

func (MarketTimestamps) IntoProto 

func (m MarketTimestamps) IntoProto() *proto.MarketTimestamps

func (MarketTimestamps) String 

func (m MarketTimestamps) String() string

type MarketTradingMode 

type MarketTradingMode = proto.Market_TradingMode
const (
	// Default value, this is invalid.
	MarketTradingModeUnspecified MarketTradingMode = proto.Market_TRADING_MODE_UNSPECIFIED
	// Normal trading.
	MarketTradingModeContinuous MarketTradingMode = proto.Market_TRADING_MODE_CONTINUOUS
	// Auction trading (FBA).
	MarketTradingModeBatchAuction MarketTradingMode = proto.Market_TRADING_MODE_BATCH_AUCTION
	// Opening auction.
	MarketTradingModeOpeningAuction MarketTradingMode = proto.Market_TRADING_MODE_OPENING_AUCTION
	// Auction triggered by monitoring.
	MarketTradingModeMonitoringAuction MarketTradingMode = proto.Market_TRADING_MODE_MONITORING_AUCTION
	// No trading allowed.
	MarketTradingModeNoTrading MarketTradingMode = proto.Market_TRADING_MODE_NO_TRADING
)

type MatchingBook 

type MatchingBook struct {
	MarketID        string
	Buy             []*Order
	Sell            []*Order
	LastTradedPrice *num.Uint
	Auction         bool
	BatchID         uint64
}

func MatchingBookFromProto 

func MatchingBookFromProto(mb *snapshot.MatchingBook) *MatchingBook

func (MatchingBook) IntoProto 

func (m MatchingBook) IntoProto() *snapshot.MatchingBook

type Metadata 

type Metadata struct {
	Version     int64       // the version of the AVL tree
	NodeHashes  []*NodeHash // he nodes of the AVL tree ordered such that it can be imported with identical shape
	ChunkHashes []string
}

func MetadataFromProto 

func MetadataFromProto(m *snapshot.Metadata) (*Metadata, error)

func (Metadata) IntoProto 

func (m Metadata) IntoProto() *snapshot.Metadata

type MetadataList 

type MetadataList []string

func (MetadataList) String 

func (m MetadataList) String() string

type NetParams 

type NetParams struct {
	Params []*NetworkParameter
}

func NetParamsFromProto 

func NetParamsFromProto(np *snapshot.NetParams) *NetParams

func (NetParams) IntoProto 

func (n NetParams) IntoProto() *snapshot.NetParams

type NetworkParameter 

type NetworkParameter struct {
	Key, Value string
}

func NetworkParameterFromProto 

func NetworkParameterFromProto(p *proto.NetworkParameter) *NetworkParameter

func (NetworkParameter) DeepClone 

func (n NetworkParameter) DeepClone() *NetworkParameter

func (NetworkParameter) IntoProto 

func (n NetworkParameter) IntoProto() *proto.NetworkParameter

func (NetworkParameter) String 

func (n NetworkParameter) String() string

type NewAsset 

type NewAsset struct {
	Changes *AssetDetails
}

func (NewAsset) DeepClone 

func (n NewAsset) DeepClone() *NewAsset

func (*NewAsset) GetChanges 

func (n *NewAsset) GetChanges() *AssetDetails

func (NewAsset) IntoProto 

func (n NewAsset) IntoProto() *furypb.NewAsset

func (NewAsset) String 

func (n NewAsset) String() string

func (*NewAsset) Validate 

func (n *NewAsset) Validate() (ProposalError, error)

type NewFreeform 

type NewFreeform struct{}

func (NewFreeform) DeepClone 

func (n NewFreeform) DeepClone() *NewFreeform

func (NewFreeform) IntoProto 

func (n NewFreeform) IntoProto() *furypb.NewFreeform

func (NewFreeform) String 

func (n NewFreeform) String() string

type NewMarket 

type NewMarket struct {
	Changes *NewMarketConfiguration
}

func (NewMarket) DeepClone 

func (n NewMarket) DeepClone() *NewMarket

func (NewMarket) IntoProto 

func (n NewMarket) IntoProto() *furypb.NewMarket

func (NewMarket) ParentMarketID 

func (n NewMarket) ParentMarketID() (string, bool)

func (NewMarket) String 

func (n NewMarket) String() string

func (NewMarket) Successor 

func (n NewMarket) Successor() *SuccessorConfig

type NewMarketConfiguration 

type NewMarketConfiguration struct {
	Instrument                    *InstrumentConfiguration
	DecimalPlaces                 uint64
	PositionDecimalPlaces         int64
	Metadata                      []string
	PriceMonitoringParameters     *PriceMonitoringParameters
	LiquidityMonitoringParameters *LiquidityMonitoringParameters
	RiskParameters                newRiskParams
	LpPriceRange                  num.Decimal
	LinearSlippageFactor          num.Decimal
	QuadraticSlippageFactor       num.Decimal
	Successor                     *SuccessorConfig
}

func NewMarketConfigurationFromProto 

func NewMarketConfigurationFromProto(p *furypb.NewMarketConfiguration) (*NewMarketConfiguration, error)

func (NewMarketConfiguration) DeepClone 

func (n NewMarketConfiguration) DeepClone() *NewMarketConfiguration

func (NewMarketConfiguration) GetFuture 

func (n NewMarketConfiguration) GetFuture() *InstrumentConfigurationFuture

func (NewMarketConfiguration) GetSpot 

func (n NewMarketConfiguration) GetSpot() *InstrumentConfigurationSpot

func (NewMarketConfiguration) IntoProto 

func (n NewMarketConfiguration) IntoProto() *furypb.NewMarketConfiguration

func (NewMarketConfiguration) ProductType 

func (n NewMarketConfiguration) ProductType() ProductType

func (NewMarketConfiguration) String 

func (n NewMarketConfiguration) String() string

type NewMarketConfigurationLogNormal 

type NewMarketConfigurationLogNormal struct {
	LogNormal *LogNormalRiskModel
}

func NewMarketConfigurationLogNormalFromProto 

func NewMarketConfigurationLogNormalFromProto(p *furypb.NewMarketConfiguration_LogNormal) *NewMarketConfigurationLogNormal

func (NewMarketConfigurationLogNormal) DeepClone 

func (n NewMarketConfigurationLogNormal) DeepClone() newRiskParams

func (NewMarketConfigurationLogNormal) IntoProto 

func (n NewMarketConfigurationLogNormal) IntoProto() *furypb.NewMarketConfiguration_LogNormal

func (NewMarketConfigurationLogNormal) String 

func (n NewMarketConfigurationLogNormal) String() string

type NewMarketConfigurationSimple 

type NewMarketConfigurationSimple struct {
	Simple *SimpleModelParams
}

func NewMarketConfigurationSimpleFromProto 

func NewMarketConfigurationSimpleFromProto(p *furypb.NewMarketConfiguration_Simple) *NewMarketConfigurationSimple

func (NewMarketConfigurationSimple) DeepClone 

func (n NewMarketConfigurationSimple) DeepClone() newRiskParams

func (NewMarketConfigurationSimple) IntoProto 

func (n NewMarketConfigurationSimple) IntoProto() *furypb.NewMarketConfiguration_Simple

func (NewMarketConfigurationSimple) String 

func (n NewMarketConfigurationSimple) String() string

type NewSpotMarket 

type NewSpotMarket struct {
	Changes *NewSpotMarketConfiguration
}

func (NewSpotMarket) DeepClone 

func (n NewSpotMarket) DeepClone() *NewSpotMarket

func (NewSpotMarket) IntoProto 

func (n NewSpotMarket) IntoProto() *furypb.NewSpotMarket

func (NewSpotMarket) String 

func (n NewSpotMarket) String() string

type NewSpotMarketConfiguration 

type NewSpotMarketConfiguration struct {
	Instrument                *InstrumentConfiguration
	DecimalPlaces             uint64
	PositionDecimalPlaces     int64
	Metadata                  []string
	PriceMonitoringParameters *PriceMonitoringParameters
	TargetStakeParameters     *TargetStakeParameters
	RiskParameters            newRiskParams
}

func NewSpotMarketConfigurationFromProto 

func NewSpotMarketConfigurationFromProto(p *furypb.NewSpotMarketConfiguration) (*NewSpotMarketConfiguration, error)

func (NewSpotMarketConfiguration) DeepClone 

func (n NewSpotMarketConfiguration) DeepClone() *NewSpotMarketConfiguration

func (NewSpotMarketConfiguration) IntoProto 

func (n NewSpotMarketConfiguration) IntoProto() *furypb.NewSpotMarketConfiguration

func (NewSpotMarketConfiguration) String 

func (n NewSpotMarketConfiguration) String() string

type NewSpotMarketConfigurationLogNormal 

type NewSpotMarketConfigurationLogNormal struct {
	LogNormal *LogNormalRiskModel
}

func NewSpotMarketConfigurationLogNormalFromProto 

func NewSpotMarketConfigurationLogNormalFromProto(p *furypb.NewSpotMarketConfiguration_LogNormal) *NewSpotMarketConfigurationLogNormal

func (NewSpotMarketConfigurationLogNormal) DeepClone 

func (n NewSpotMarketConfigurationLogNormal) DeepClone() newRiskParams

func (NewSpotMarketConfigurationLogNormal) IntoProto 

func (n NewSpotMarketConfigurationLogNormal) IntoProto() *furypb.NewSpotMarketConfiguration_LogNormal

func (NewSpotMarketConfigurationLogNormal) String 

func (n NewSpotMarketConfigurationLogNormal) String() string

type NewSpotMarketConfigurationSimple 

type NewSpotMarketConfigurationSimple struct {
	Simple *SimpleModelParams
}

func NewSpotMarketConfigurationSimpleFromProto 

func NewSpotMarketConfigurationSimpleFromProto(p *furypb.NewSpotMarketConfiguration_Simple) *NewSpotMarketConfigurationSimple

func (NewSpotMarketConfigurationSimple) DeepClone 

func (n NewSpotMarketConfigurationSimple) DeepClone() newRiskParams

func (NewSpotMarketConfigurationSimple) IntoProto 

func (n NewSpotMarketConfigurationSimple) IntoProto() *furypb.NewSpotMarketConfiguration_Simple

func (NewSpotMarketConfigurationSimple) String 

func (n NewSpotMarketConfigurationSimple) String() string

type NodeHash 

type NodeHash struct {
	Key     string // the node's key eg. epoch.all
	Hash    string // the hash of the noes value
	IsLeaf  bool   // whether or not the node contains a payload
	Height  int32  // the height of the node in the tree
	Version int64  // the version of that node i.e how many times its value has changed
}

NodeHash contains the data for a node in the IAVL, without its value, but the values hash instead.

func NodeHashFromProto 

func NodeHashFromProto(nh *snapshot.NodeHash) (*NodeHash, error)

func (NodeHash) IntoProto 

func (n NodeHash) IntoProto() *snapshot.NodeHash

type NodeSignature 

type NodeSignature = commandspb.NodeSignature

type NodeSignatureKind 

type NodeSignatureKind = commandspb.NodeSignatureKind
const (
	// NodeSignatureKindUnspecified represents an unspecified or missing value from the input.
	NodeSignatureKindUnspecified NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_UNSPECIFIED
	// NodeSignatureKindAssetNew represents a signature for a new asset allow-listing.
	NodeSignatureKindAssetNew NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_NEW
	// NodeSignatureKindAssetUpdate represents a signature for an asset update allow-listing.
	NodeSignatureKindAssetUpdate NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_UPDATE
	// Represents a signature for an asset withdrawal.
	NodeSignatureKindAssetWithdrawal            NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ASSET_WITHDRAWAL
	NodeSignatureKindERC20MultiSigSignerAdded   NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ERC20_MULTISIG_SIGNER_ADDED
	NodeSignatureKindERC20MultiSigSignerRemoved NodeSignatureKind = commandspb.NodeSignatureKind_NODE_SIGNATURE_KIND_ERC20_MULTISIG_SIGNER_REMOVED
)

type NodeVote 

type NodeVote = commandspb.NodeVote

type NodeVoteType 

type NodeVoteType = proto.NodeVote_Type
const (
	NodeVoteTypeUnspecified             NodeVoteType = proto.NodeVote_TYPE_UNSPECIFIED
	NodeVoteTypeStakeDeposited          NodeVoteType = proto.NodeVote_TYPE_STAKE_DEPOSITED
	NodeVoteTypeStakeRemoved            NodeVoteType = proto.NodeVote_TYPE_STAKE_REMOVED
	NodeVoteTypeFundsDeposited          NodeVoteType = proto.NodeVote_TYPE_FUNDS_DEPOSITED
	NodeVoteTypeSignerAdded             NodeVoteType = proto.NodeVote_TYPE_SIGNER_ADDED
	NodeVoteTypeSignerRemoved           NodeVoteType = proto.NodeVote_TYPE_SIGNER_REMOVED
	NodeVoteTypeBridgeStopped           NodeVoteType = proto.NodeVote_TYPE_BRIDGE_STOPPED
	NodeVoteTypeBridgeResumed           NodeVoteType = proto.NodeVote_TYPE_BRIDGE_RESUMED
	NodeVoteTypeAssetListed             NodeVoteType = proto.NodeVote_TYPE_ASSET_LISTED
	NodeVoteTypeAssetLimitsUpdated      NodeVoteType = proto.NodeVote_TYPE_LIMITS_UPDATED
	NodeVoteTypeStakeTotalSupply        NodeVoteType = proto.NodeVote_TYPE_STAKE_TOTAL_SUPPLY
	NodeVoteTypeSignerThresholdSet      NodeVoteType = proto.NodeVote_TYPE_SIGNER_THRESHOLD_SET
	NodeVoteTypeGovernanceValidateAsset NodeVoteType = proto.NodeVote_TYPE_GOVERNANCE_VALIDATE_ASSET
)

type Notary 

type Notary struct {
	Sigs []*NotarySigs
}

func NotaryFromProto 

func NotaryFromProto(n *snapshot.Notary) *Notary

func (Notary) IntoProto 

func (n Notary) IntoProto() *snapshot.Notary

type NotarySigs 

type NotarySigs struct {
	ID      string
	Kind    int32
	Node    string
	Sig     string
	Pending bool
}

func NotarySigFromProto 

func NotarySigFromProto(sk *snapshot.NotarySigs) *NotarySigs

func (NotarySigs) IntoProto 

func (sk NotarySigs) IntoProto() *snapshot.NotarySigs

type OneOffTransfer 

type OneOffTransfer struct {
	*TransferBase
	DeliverOn *time.Time
}

func OneOffTransferFromEvent 

func OneOffTransferFromEvent(p *eventspb.Transfer) *OneOffTransfer

func (*OneOffTransfer) IntoEvent 

func (o *OneOffTransfer) IntoEvent(reason *string) *eventspb.Transfer

func (*OneOffTransfer) IsValid 

func (o *OneOffTransfer) IsValid() error

type OracleDataSubmission 

type OracleDataSubmission = commandspb.OracleDataSubmission

type OracleSpec 

type OracleSpec struct {
	ExternalDataSourceSpec *ExternalDataSourceSpec
}

func OracleSpecFromProto 

func OracleSpecFromProto(specProto *furypb.OracleSpec) *OracleSpec

type OracleSpecBindingForFuture 

type OracleSpecBindingForFuture = DataSourceSpecBindingForFuture

type OracleSpecCondition 

type OracleSpecCondition = DataSourceSpecCondition

func OracleSpecConditionsFromProto 

func OracleSpecConditionsFromProto(protoCondition []*datapb.Condition) []*OracleSpecCondition

type OracleSpecConditionOperator 

type OracleSpecConditionOperator = DataSourceSpecConditionOperator

type OracleSpecConditions 

type OracleSpecConditions DataSourceSpecConditions

type OracleSpecConfiguration 

type OracleSpecConfiguration struct {
	ExternalDataSourceSpec *ExternalDataSourceSpecConfiguration
}

func OracleSpecConfigurationFromProto 

func OracleSpecConfigurationFromProto(protoConfig *furypb.DataSourceSpecConfiguration) *OracleSpecConfiguration

type OracleSpecFilter 

type OracleSpecFilter struct {
	DataSourceSpec *DataSourceSpecFilter
}

func DeepCloneOracleSpecFilters 

func DeepCloneOracleSpecFilters(filters []*OracleSpecFilter) []*OracleSpecFilter

func OracleSpecFilterFromProto 

func OracleSpecFilterFromProto(protoFilter *datapb.Filter) *OracleSpecFilter

func OracleSpecFiltersFromProto 

func OracleSpecFiltersFromProto(protoFilters []*datapb.Filter) []*OracleSpecFilter

type OracleSpecFilters 

type OracleSpecFilters []*OracleSpecFilter

type OracleSpecPropertyKey 

type OracleSpecPropertyKey = DataSourceSpecPropertyKey

func OracleSpecPropertyKeyFromProto 

func OracleSpecPropertyKeyFromProto(protoKey *datapb.PropertyKey) *OracleSpecPropertyKey

type OracleSpecSigners 

type OracleSpecSigners = DataSourceSpecSigners

type OracleSpecStatus 

type OracleSpecStatus = DataSourceSpecStatus

type OracleSpecToFutureBinding 

type OracleSpecToFutureBinding = DataSourceSpecToFutureBinding

type Order 

type Order struct {
	ID                   string
	MarketID             string
	Party                string
	Side                 Side
	Price                *num.Uint
	OriginalPrice        *num.Uint
	Size                 uint64
	Remaining            uint64
	TimeInForce          OrderTimeInForce
	Type                 OrderType
	CreatedAt            int64
	Status               OrderStatus
	ExpiresAt            int64
	Reference            string
	Reason               OrderError
	UpdatedAt            int64
	Version              uint64
	BatchID              uint64
	PeggedOrder          *PeggedOrder
	LiquidityProvisionID string
	PostOnly             bool
	ReduceOnly           bool

	IcebergOrder *IcebergOrder
	// contains filtered or unexported fields
}

func OrderFromProto 

func OrderFromProto(o *proto.Order) (*Order, error)

func (*Order) ClearUpExtraRemaining 

func (o *Order) ClearUpExtraRemaining()

func (Order) Clone 

func (o Order) Clone() *Order

func (*Order) Create 

func (o *Order) Create(t int64) *Order

Create sets the creation time (CreatedAt) to t and returns the updated order.

func (*Order) HasTraded 

func (o *Order) HasTraded() bool

func (*Order) IntoProto 

func (o *Order) IntoProto() *proto.Order

func (Order) IntoSubmission 

func (o Order) IntoSubmission() *OrderSubmission

func (*Order) IsExpireable 

func (o *Order) IsExpireable() bool

func (*Order) IsFinished 

func (o *Order) IsFinished() bool

IsFinished returns true if an order is in any state different to ACTIVE and PARKED Basically any order which is never gonna trade anymore.

func (*Order) IsLiquidityOrder 

func (o *Order) IsLiquidityOrder() bool

func (*Order) IsPersistent 

func (o *Order) IsPersistent() bool

IsPersistent returns true if the order is persistent. A persistent order is a Limit type order that might be matched in the future.

func (*Order) ReduceOnlyAdjustRemaining 

func (o *Order) ReduceOnlyAdjustRemaining(extraSize uint64)

func (Order) String 

func (o Order) String() string

func (*Order) Update 

func (o *Order) Update(t time.Time) *Order

Update sets the modification time (UpdatedAt) to t and returns the updated order.

type OrderAmendment 

type OrderAmendment struct {
	OrderID         string
	MarketID        string
	Price           *num.Uint
	SizeDelta       int64
	ExpiresAt       *int64 // timestamp
	TimeInForce     OrderTimeInForce
	PeggedOffset    *num.Uint
	PeggedReference PeggedReference
}

func NewOrderAmendmentFromProto 

func NewOrderAmendmentFromProto(p *commandspb.OrderAmendment) (*OrderAmendment, error)

func (OrderAmendment) GetMarketID 

func (o OrderAmendment) GetMarketID() string

func (OrderAmendment) GetOrderID 

func (o OrderAmendment) GetOrderID() string

func (OrderAmendment) IntoProto 

func (o OrderAmendment) IntoProto() *commandspb.OrderAmendment

func (OrderAmendment) String 

func (o OrderAmendment) String() string

func (OrderAmendment) Validate 

func (o OrderAmendment) Validate() error

Validate santiy-checks the order amendment as-is, the market will further validate the amendment based on the order it's actually trying to amend.

type OrderCancellation 

type OrderCancellation struct {
	OrderID  string
	MarketID string
}

func OrderCancellationFromProto 

func OrderCancellationFromProto(p *commandspb.OrderCancellation) *OrderCancellation

func (OrderCancellation) IntoProto 

func (o OrderCancellation) IntoProto() *commandspb.OrderCancellation

func (OrderCancellation) String 

func (o OrderCancellation) String() string

type OrderCancellationConfirmation 

type OrderCancellationConfirmation struct {
	Order *Order
}

func (*OrderCancellationConfirmation) IntoProto 

func (o *OrderCancellationConfirmation) IntoProto() *proto.OrderCancellationConfirmation

type OrderConfirmation 

type OrderConfirmation struct {
	Order                 *Order
	Trades                []*Trade
	PassiveOrdersAffected []*Order
}

func (*OrderConfirmation) IntoProto 

func (o *OrderConfirmation) IntoProto() *proto.OrderConfirmation

func (OrderConfirmation) TradedValue 

func (o OrderConfirmation) TradedValue() *num.Uint

type OrderError 

type OrderError = proto.OrderError
const (
	// Default value, no error reported.
	OrderErrorUnspecified OrderError = proto.OrderError_ORDER_ERROR_UNSPECIFIED
	// Order was submitted for a market that does not exist.
	OrderErrorInvalidMarketID OrderError = proto.OrderError_ORDER_ERROR_INVALID_MARKET_ID
	// Order was submitted with an invalid identifier.
	OrderErrorInvalidOrderID OrderError = proto.OrderError_ORDER_ERROR_INVALID_ORDER_ID
	// Order was amended with a sequence number that was not previous version + 1.
	OrderErrorOutOfSequence OrderError = proto.OrderError_ORDER_ERROR_OUT_OF_SEQUENCE
	// Order was amended with an invalid remaining size (e.g. remaining greater than total size).
	OrderErrorInvalidRemainingSize OrderError = proto.OrderError_ORDER_ERROR_INVALID_REMAINING_SIZE
	// Node was unable to get Fury (blockchain) time.
	OrderErrorTimeFailure OrderError = proto.OrderError_ORDER_ERROR_TIME_FAILURE
	// Failed to remove an order from the book.
	OrderErrorRemovalFailure OrderError = proto.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 = proto.OrderError_ORDER_ERROR_INVALID_EXPIRATION_DATETIME
	// Order was submitted or amended with an invalid reference field.
	OrderErrorInvalidOrderReference OrderError = proto.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 = proto.OrderError_ORDER_ERROR_EDIT_NOT_ALLOWED
	// Amend failure because amend details do not match original order.
	OrderErrorAmendFailure OrderError = proto.OrderError_ORDER_ERROR_AMEND_FAILURE
	// Order not found in an order book or store.
	OrderErrorNotFound OrderError = proto.OrderError_ORDER_ERROR_NOT_FOUND
	// Order was submitted with an invalid or missing party identifier.
	OrderErrorInvalidParty OrderError = proto.OrderError_ORDER_ERROR_INVALID_PARTY_ID
	// Order was submitted for a market that has closed.
	OrderErrorMarketClosed OrderError = proto.OrderError_ORDER_ERROR_MARKET_CLOSED
	// Order was submitted, but the party did not have enough collateral to cover the order.
	OrderErrorMarginCheckFailed OrderError = proto.OrderError_ORDER_ERROR_MARGIN_CHECK_FAILED
	// Order was submitted, but the party did not have an account for this asset.
	OrderErrorMissingGeneralAccount OrderError = proto.OrderError_ORDER_ERROR_MISSING_GENERAL_ACCOUNT
	// Unspecified internal error.
	OrderErrorInternalError OrderError = proto.OrderError_ORDER_ERROR_INTERNAL_ERROR
	// Order was submitted with an invalid or missing size (e.g. 0).
	OrderErrorInvalidSize OrderError = proto.OrderError_ORDER_ERROR_INVALID_SIZE
	// Order was submitted with an invalid persistence for its type.
	OrderErrorInvalidPersistance OrderError = proto.OrderError_ORDER_ERROR_INVALID_PERSISTENCE
	// Order was submitted with an invalid type field.
	OrderErrorInvalidType OrderError = proto.OrderError_ORDER_ERROR_INVALID_TYPE
	// Order was stopped as it would have traded with another order submitted from the same party.
	OrderErrorSelfTrading OrderError = proto.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 = proto.OrderError_ORDER_ERROR_INSUFFICIENT_FUNDS_TO_PAY_FEES
	// Order was submitted with an incorrect or invalid market type.
	OrderErrorIncorrectMarketType OrderError = proto.OrderError_ORDER_ERROR_INCORRECT_MARKET_TYPE
	// Order was submitted with invalid time in force.
	OrderErrorInvalidTimeInForce OrderError = proto.OrderError_ORDER_ERROR_INVALID_TIME_IN_FORCE
	// A GFN order has got to the market when it is in auction mode.
	OrderErrorCannotSendGFNOrderDuringAnAuction OrderError = proto.OrderError_ORDER_ERROR_CANNOT_SEND_GFN_ORDER_DURING_AN_AUCTION
	// A GFA order has got to the market when it is in continuous trading mode.
	OrderErrorGFAOrderDuringContinuousTrading OrderError = proto.OrderError_ORDER_ERROR_CANNOT_SEND_GFA_ORDER_DURING_CONTINUOUS_TRADING
	// Attempt to amend order to GTT without ExpiryAt.
	OrderErrorCannotAmendToGTTWithoutExpiryAt OrderError = proto.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GTT_WITHOUT_EXPIRYAT
	// Attempt to amend ExpiryAt to a value before CreatedAt.
	OrderErrorExpiryAtBeforeCreatedAt OrderError = proto.OrderError_ORDER_ERROR_EXPIRYAT_BEFORE_CREATEDAT
	// Attempt to amend to GTC without an ExpiryAt value.
	OrderErrorCannotHaveGTCAndExpiryAt OrderError = proto.OrderError_ORDER_ERROR_CANNOT_HAVE_GTC_AND_EXPIRYAT
	// Amending to FOK or IOC is invalid.
	OrderErrorCannotAmendToFOKOrIOC OrderError = proto.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_FOK_OR_IOC
	// Amending to GFA or GFN is invalid.
	OrderErrorCannotAmendToGFAOrGFN OrderError = proto.OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GFA_OR_GFN
	// Amending from GFA or GFN is invalid.
	OrderErrorCannotAmendFromGFAOrGFN OrderError = proto.OrderError_ORDER_ERROR_CANNOT_AMEND_FROM_GFA_OR_GFN
	// IOC orders are not allowed during auction.
	OrderErrorCannotSendIOCOrderDuringAuction OrderError = proto.OrderError_ORDER_ERROR_CANNOT_SEND_IOC_ORDER_DURING_AUCTION
	// FOK orders are not allowed during auction.
	OrderErrorCannotSendFOKOrderDurinAuction OrderError = proto.OrderError_ORDER_ERROR_CANNOT_SEND_FOK_ORDER_DURING_AUCTION
	// Pegged orders must be LIMIT orders.
	OrderErrorMustBeLimitOrder OrderError = proto.OrderError_ORDER_ERROR_MUST_BE_LIMIT_ORDER
	// Pegged orders can only have TIF GTC or GTT.
	OrderErrorMustBeGTTOrGTC OrderError = proto.OrderError_ORDER_ERROR_MUST_BE_GTT_OR_GTC
	// Pegged order must have a reference price.
	OrderErrorWithoutReferencePrice OrderError = proto.OrderError_ORDER_ERROR_WITHOUT_REFERENCE_PRICE
	// Buy pegged order cannot reference best ask price.
	OrderErrorBuyCannotReferenceBestAskPrice OrderError = proto.OrderError_ORDER_ERROR_BUY_CANNOT_REFERENCE_BEST_ASK_PRICE
	// Pegged order offset must be >= 0.
	OrderErrorOffsetMustBeGreaterOrEqualToZero OrderError = proto.OrderError_ORDER_ERROR_OFFSET_MUST_BE_GREATER_OR_EQUAL_TO_ZERO
	// Sell pegged order cannot reference best bid price.
	OrderErrorSellCannotReferenceBestBidPrice OrderError = proto.OrderError_ORDER_ERROR_SELL_CANNOT_REFERENCE_BEST_BID_PRICE
	// Pegged order offset must be > zero.
	OrderErrorOffsetMustBeGreaterThanZero OrderError = proto.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 = proto.OrderError_ORDER_ERROR_INSUFFICIENT_ASSET_BALANCE
	// Cannot amend a non pegged orders details.
	OrderErrorCannotAmendPeggedOrderDetailsOnNonPeggedOrder OrderError = proto.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 = proto.OrderError_ORDER_ERROR_UNABLE_TO_REPRICE_PEGGED_ORDER
	// It is not possible to amend the price of an existing pegged order.
	OrderErrorUnableToAmendPriceOnPeggedOrder OrderError = proto.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 = proto.OrderError_ORDER_ERROR_NON_PERSISTENT_ORDER_OUT_OF_PRICE_BOUNDS
	// Unable to submit pegged order, temporarily too many pegged orders across all markets.
	OrderErrorTooManyPeggedOrders                   OrderError = proto.OrderError_ORDER_ERROR_TOO_MANY_PEGGED_ORDERS
	OrderErrorPostOnlyOrderWouldTrade               OrderError = proto.OrderError_ORDER_ERROR_POST_ONLY_ORDER_WOULD_TRADE
	OrderErrorReduceOnlyOrderWouldNotReducePosition OrderError = proto.OrderError_ORDER_ERROR_REDUCE_ONLY_ORDER_WOULD_NOT_REDUCE_POSITION
)

func IsOrderError 

func IsOrderError(err error) (OrderError, bool)

type OrderStatus 

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

type OrderSubmission 

type OrderSubmission struct {
	// Market identifier for the order, required field
	MarketID string
	// Price for the order, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places,
	// required field for limit orders, however it is not required for market orders
	Price *num.Uint
	// Size for the order, for example, in a futures market the size equals the number of contracts, cannot be negative
	Size uint64
	// Side for the order, e.g. SIDE_BUY or SIDE_SELL, required field
	Side proto.Side
	// Time in force indicates how long an order will remain active before it is executed or expires, required field
	TimeInForce proto.Order_TimeInForce
	// Timestamp for when the order will expire, in nanoseconds since the epoch,
	ExpiresAt int64
	// Type for the order, required field
	Type proto.Order_Type
	// Reference given for the order, this is typically used to retrieve an order submitted through consensus, currently
	// set internally by the node to return a unique reference identifier for the order submission
	Reference string
	// Used to specify the details for a pegged order
	PeggedOrder  *PeggedOrder
	PostOnly     bool
	ReduceOnly   bool
	IcebergOrder *IcebergOrder
}

func NewOrderSubmissionFromProto 

func NewOrderSubmissionFromProto(p *commandspb.OrderSubmission) (*OrderSubmission, error)

func (OrderSubmission) IntoOrder 

func (o OrderSubmission) IntoOrder(party string) *Order

func (OrderSubmission) IntoProto 

func (o OrderSubmission) IntoProto() *commandspb.OrderSubmission

func (OrderSubmission) String 

func (o OrderSubmission) String() string

type OrderTimeInForce 

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

type OrderType 

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

type Orders 

type Orders []*Order

func (Orders) IntoProto 

func (o Orders) IntoProto() []*proto.Order

type Party 

type Party = proto.Party

type PartyContibutionScore 

type PartyContibutionScore struct {
	Party string
	Score num.Decimal
}

FeePartyScore represents the fraction the party has in the total fee.

type PartyCount 

type PartyCount struct {
	Party string
	Count uint64
}

func PartyCountFromProto 

func PartyCountFromProto(pc *snapshot.SpamPartyTransactionCount) *PartyCount

type PartyProposalVoteCount 

type PartyProposalVoteCount struct {
	Party    string
	Proposal string
	Count    uint64
}

func PartyProposalVoteCountFromProto 

func PartyProposalVoteCountFromProto(ppvc *snapshot.PartyProposalVoteCount) *PartyProposalVoteCount

func (*PartyProposalVoteCount) IntoProto 

func (p *PartyProposalVoteCount) IntoProto() *snapshot.PartyProposalVoteCount

type PartySettledPosition 

type PartySettledPosition struct {
	Party           string
	SettledPosition int64
}

type PartyTokenBalance 

type PartyTokenBalance struct {
	Party   string
	Balance *num.Uint
}

func PartyTokenBalanceFromProto 

func PartyTokenBalanceFromProto(balance *snapshot.PartyTokenBalance) *PartyTokenBalance

func (*PartyTokenBalance) IntoProto 

func (ptc *PartyTokenBalance) IntoProto() *snapshot.PartyTokenBalance

type PastPrice 

type PastPrice struct {
	Time                time.Time
	VolumeWeightedPrice num.Decimal
}

func PastPriceFromProto 

func PastPriceFromProto(spp *snapshot.PastPrice) *PastPrice

func (PastPrice) IntoProto 

func (pp PastPrice) IntoProto() *snapshot.PastPrice

type Payload 

type Payload struct {
	Data isPayload
	// contains filtered or unexported fields
}

func PayloadFromProto 

func PayloadFromProto(p *snapshot.Payload) *Payload

func (Payload) GetAppState 

func (p Payload) GetAppState() *PayloadAppState

func (*Payload) GetTreeKey 

func (p *Payload) GetTreeKey() string

func (Payload) IntoProto 

func (p Payload) IntoProto() *snapshot.Payload

func (Payload) Key 

func (p Payload) Key() string

func (Payload) Namespace 

func (p Payload) Namespace() SnapshotNamespace

type PayloadActiveAssets 

type PayloadActiveAssets struct {
	ActiveAssets *ActiveAssets
}

func PayloadActiveAssetsFromProto 

func PayloadActiveAssetsFromProto(paa *snapshot.Payload_ActiveAssets) *PayloadActiveAssets

func (PayloadActiveAssets) IntoProto 

func (p PayloadActiveAssets) IntoProto() *snapshot.Payload_ActiveAssets

func (*PayloadActiveAssets) Key 

func (*PayloadActiveAssets) Key() string

func (*PayloadActiveAssets) Namespace 

func (*PayloadActiveAssets) Namespace() SnapshotNamespace

type PayloadAppState 

type PayloadAppState struct {
	AppState *AppState
}

func AppStateFromTree 

func AppStateFromTree(tree *iavl.ImmutableTree) (*PayloadAppState, error)

func PayloadAppStateFromProto 

func PayloadAppStateFromProto(pas *snapshot.Payload_AppState) *PayloadAppState

func (PayloadAppState) IntoProto 

func (p PayloadAppState) IntoProto() *snapshot.Payload_AppState

func (*PayloadAppState) Key 

func (*PayloadAppState) Key() string

func (*PayloadAppState) Namespace 

func (*PayloadAppState) Namespace() SnapshotNamespace

type PayloadBankingAssetActions 

type PayloadBankingAssetActions struct {
	BankingAssetActions *BankingAssetActions
}

func PayloadBankingAssetActionsFromProto 

func PayloadBankingAssetActionsFromProto(pbs *snapshot.Payload_BankingAssetActions) *PayloadBankingAssetActions

func (PayloadBankingAssetActions) IntoProto 

func (p PayloadBankingAssetActions) IntoProto() *snapshot.Payload_BankingAssetActions

func (*PayloadBankingAssetActions) Key 

func (*PayloadBankingAssetActions) Key() string

func (*PayloadBankingAssetActions) Namespace 

func (*PayloadBankingAssetActions) Namespace() SnapshotNamespace

type PayloadBankingBridgeState 

type PayloadBankingBridgeState struct {
	BankingBridgeState *BankingBridgeState
}

func PayloadBankingBridgeStateFromProto 

func PayloadBankingBridgeStateFromProto(pbbs *snapshot.Payload_BankingBridgeState) *PayloadBankingBridgeState

func (PayloadBankingBridgeState) IntoProto 

func (p PayloadBankingBridgeState) IntoProto() *snapshot.Payload_BankingBridgeState

func (*PayloadBankingBridgeState) Key 

func (*PayloadBankingBridgeState) Key() string

func (*PayloadBankingBridgeState) Namespace 

func (*PayloadBankingBridgeState) Namespace() SnapshotNamespace

type PayloadBankingDeposits 

type PayloadBankingDeposits struct {
	BankingDeposits *BankingDeposits
}

func PayloadBankingDepositsFromProto 

func PayloadBankingDepositsFromProto(pbd *snapshot.Payload_BankingDeposits) *PayloadBankingDeposits

func (PayloadBankingDeposits) IntoProto 

func (p PayloadBankingDeposits) IntoProto() *snapshot.Payload_BankingDeposits

func (*PayloadBankingDeposits) Key 

func (*PayloadBankingDeposits) Key() string

func (*PayloadBankingDeposits) Namespace 

func (*PayloadBankingDeposits) Namespace() SnapshotNamespace

type PayloadBankingRecurringTransfers 

type PayloadBankingRecurringTransfers struct {
	BankingRecurringTransfers *checkpointpb.RecurringTransfers
}

func PayloadBankingRecurringTransfersFromProto 

func PayloadBankingRecurringTransfersFromProto(pbd *snapshot.Payload_BankingRecurringTransfers) *PayloadBankingRecurringTransfers

func (PayloadBankingRecurringTransfers) IntoProto 

func (p PayloadBankingRecurringTransfers) IntoProto() *snapshot.Payload_BankingRecurringTransfers

func (*PayloadBankingRecurringTransfers) Key 

func (*PayloadBankingRecurringTransfers) Key() string

func (*PayloadBankingRecurringTransfers) Namespace 

func (*PayloadBankingRecurringTransfers) Namespace() SnapshotNamespace

type PayloadBankingScheduledTransfers 

type PayloadBankingScheduledTransfers struct {
	BankingScheduledTransfers []*checkpointpb.ScheduledTransferAtTime
}

func PayloadBankingScheduledTransfersFromProto 

func PayloadBankingScheduledTransfersFromProto(pbd *snapshot.Payload_BankingScheduledTransfers) *PayloadBankingScheduledTransfers

func (PayloadBankingScheduledTransfers) IntoProto 

func (p PayloadBankingScheduledTransfers) IntoProto() *snapshot.Payload_BankingScheduledTransfers

func (*PayloadBankingScheduledTransfers) Key 

func (*PayloadBankingScheduledTransfers) Key() string

func (*PayloadBankingScheduledTransfers) Namespace 

func (*PayloadBankingScheduledTransfers) Namespace() SnapshotNamespace

type PayloadBankingSeen 

type PayloadBankingSeen struct {
	BankingSeen *BankingSeen
}

func PayloadBankingSeenFromProto 

func PayloadBankingSeenFromProto(pbs *snapshot.Payload_BankingSeen) *PayloadBankingSeen

func (PayloadBankingSeen) IntoProto 

func (p PayloadBankingSeen) IntoProto() *snapshot.Payload_BankingSeen

func (*PayloadBankingSeen) Key 

func (*PayloadBankingSeen) Key() string

func (*PayloadBankingSeen) Namespace 

func (*PayloadBankingSeen) Namespace() SnapshotNamespace

type PayloadBankingWithdrawals 

type PayloadBankingWithdrawals struct {
	BankingWithdrawals *BankingWithdrawals
}

func PayloadBankingWithdrawalsFromProto 

func PayloadBankingWithdrawalsFromProto(pbw *snapshot.Payload_BankingWithdrawals) *PayloadBankingWithdrawals

func (PayloadBankingWithdrawals) IntoProto 

func (p PayloadBankingWithdrawals) IntoProto() *snapshot.Payload_BankingWithdrawals

func (*PayloadBankingWithdrawals) Key 

func (*PayloadBankingWithdrawals) Key() string

func (*PayloadBankingWithdrawals) Namespace 

func (*PayloadBankingWithdrawals) Namespace() SnapshotNamespace

type PayloadCheckpoint 

type PayloadCheckpoint struct {
	Checkpoint *CPState
}

func PayloadCheckpointFromProto 

func PayloadCheckpointFromProto(pc *snapshot.Payload_Checkpoint) *PayloadCheckpoint

func (PayloadCheckpoint) IntoProto 

func (p PayloadCheckpoint) IntoProto() *snapshot.Payload_Checkpoint

func (*PayloadCheckpoint) Key 

func (*PayloadCheckpoint) Key() string

func (*PayloadCheckpoint) Namespace 

func (*PayloadCheckpoint) Namespace() SnapshotNamespace

type PayloadCollateralAccounts 

type PayloadCollateralAccounts struct {
	CollateralAccounts *CollateralAccounts
}

func PayloadCollateralAccountsFromProto 

func PayloadCollateralAccountsFromProto(pca *snapshot.Payload_CollateralAccounts) *PayloadCollateralAccounts

func (PayloadCollateralAccounts) IntoProto 

func (p PayloadCollateralAccounts) IntoProto() *snapshot.Payload_CollateralAccounts

func (*PayloadCollateralAccounts) Key 

func (*PayloadCollateralAccounts) Key() string

func (*PayloadCollateralAccounts) Namespace 

func (*PayloadCollateralAccounts) Namespace() SnapshotNamespace

type PayloadCollateralAssets 

type PayloadCollateralAssets struct {
	CollateralAssets *CollateralAssets
}

func PayloadCollateralAssetsFromProto 

func PayloadCollateralAssetsFromProto(pca *snapshot.Payload_CollateralAssets) *PayloadCollateralAssets

func (PayloadCollateralAssets) IntoProto 

func (p PayloadCollateralAssets) IntoProto() *snapshot.Payload_CollateralAssets

func (*PayloadCollateralAssets) Key 

func (*PayloadCollateralAssets) Key() string

func (*PayloadCollateralAssets) Namespace 

func (*PayloadCollateralAssets) Namespace() SnapshotNamespace

type PayloadDelegationActive 

type PayloadDelegationActive struct {
	DelegationActive *DelegationActive
}

func PayloadDelegationActiveFromProto 

func PayloadDelegationActiveFromProto(da *snapshot.Payload_DelegationActive) *PayloadDelegationActive

func (PayloadDelegationActive) IntoProto 

func (p PayloadDelegationActive) IntoProto() *snapshot.Payload_DelegationActive

func (*PayloadDelegationActive) Key 

func (*PayloadDelegationActive) Key() string

func (*PayloadDelegationActive) Namespace 

func (*PayloadDelegationActive) Namespace() SnapshotNamespace

type PayloadDelegationAuto 

type PayloadDelegationAuto struct {
	DelegationAuto *DelegationAuto
}

func PayloadDelegationAutoFromProto 

func PayloadDelegationAutoFromProto(da *snapshot.Payload_DelegationAuto) *PayloadDelegationAuto

func (PayloadDelegationAuto) IntoProto 

func (p PayloadDelegationAuto) IntoProto() *snapshot.Payload_DelegationAuto

func (*PayloadDelegationAuto) Key 

func (*PayloadDelegationAuto) Key() string

func (*PayloadDelegationAuto) Namespace 

func (*PayloadDelegationAuto) Namespace() SnapshotNamespace

type PayloadDelegationLastReconTime 

type PayloadDelegationLastReconTime struct {
	LastReconcilicationTime time.Time
}

func PayloadDelegationLastReconTimeFromProto 

func PayloadDelegationLastReconTimeFromProto(dl *snapshot.Payload_DelegationLastReconciliationTime) *PayloadDelegationLastReconTime

func (PayloadDelegationLastReconTime) IntoProto 

func (p PayloadDelegationLastReconTime) IntoProto() *snapshot.Payload_DelegationLastReconciliationTime

func (*PayloadDelegationLastReconTime) Key 

func (*PayloadDelegationLastReconTime) Key() string

func (*PayloadDelegationLastReconTime) Namespace 

func (*PayloadDelegationLastReconTime) Namespace() SnapshotNamespace

type PayloadDelegationPending 

type PayloadDelegationPending struct {
	DelegationPending *DelegationPending
}

func PayloadDelegationPendingFromProto 

func PayloadDelegationPendingFromProto(da *snapshot.Payload_DelegationPending) *PayloadDelegationPending

func (PayloadDelegationPending) IntoProto 

func (p PayloadDelegationPending) IntoProto() *snapshot.Payload_DelegationPending

func (*PayloadDelegationPending) Key 

func (*PayloadDelegationPending) Key() string

func (*PayloadDelegationPending) Namespace 

func (*PayloadDelegationPending) Namespace() SnapshotNamespace

type PayloadERC20MultiSigTopologyPending 

type PayloadERC20MultiSigTopologyPending struct {
	Pending *snapshot.ERC20MultiSigTopologyPending
}

func PayloadERC20MultiSigTopologyPendingFromProto 

func PayloadERC20MultiSigTopologyPendingFromProto(
	s *snapshot.Payload_Erc20MultisigTopologyPending,
) *PayloadERC20MultiSigTopologyPending

func (*PayloadERC20MultiSigTopologyPending) Key 

func (p *PayloadERC20MultiSigTopologyPending) Key() string

func (*PayloadERC20MultiSigTopologyPending) Namespace 

func (*PayloadERC20MultiSigTopologyPending) Namespace() SnapshotNamespace

type PayloadERC20MultiSigTopologyVerified 

type PayloadERC20MultiSigTopologyVerified struct {
	Verified *snapshot.ERC20MultiSigTopologyVerified
}

func PayloadERC20MultiSigTopologyVerifiedFromProto 

func PayloadERC20MultiSigTopologyVerifiedFromProto(
	s *snapshot.Payload_Erc20MultisigTopologyVerified,
) *PayloadERC20MultiSigTopologyVerified

func (*PayloadERC20MultiSigTopologyVerified) Key 

func (p *PayloadERC20MultiSigTopologyVerified) Key() string

func (*PayloadERC20MultiSigTopologyVerified) Namespace 

func (*PayloadERC20MultiSigTopologyVerified) Namespace() SnapshotNamespace

type PayloadEpoch 

type PayloadEpoch struct {
	EpochState *EpochState
}

func PayloadEpochFromProto 

func PayloadEpochFromProto(e *snapshot.Payload_Epoch) *PayloadEpoch

func (PayloadEpoch) IntoProto 

func (p PayloadEpoch) IntoProto() *snapshot.Payload_Epoch

func (*PayloadEpoch) Key 

func (*PayloadEpoch) Key() string

func (*PayloadEpoch) Namespace 

func (*PayloadEpoch) Namespace() SnapshotNamespace

type PayloadEventForwarder 

type PayloadEventForwarder struct {
	Keys []string
}

func PayloadEventForwarderFromProto 

func PayloadEventForwarderFromProto(ef *snapshot.Payload_EventForwarder) *PayloadEventForwarder

func (*PayloadEventForwarder) IntoProto 

func (p *PayloadEventForwarder) IntoProto() *snapshot.Payload_EventForwarder

func (*PayloadEventForwarder) Key 

func (*PayloadEventForwarder) Key() string

func (*PayloadEventForwarder) Namespace 

func (*PayloadEventForwarder) Namespace() SnapshotNamespace

type PayloadExecutionMarkets 

type PayloadExecutionMarkets struct {
	ExecutionMarkets *ExecutionMarkets
}

func PayloadExecutionMarketsFromProto 

func PayloadExecutionMarketsFromProto(pem *snapshot.Payload_ExecutionMarkets) *PayloadExecutionMarkets

func (PayloadExecutionMarkets) IntoProto 

func (p PayloadExecutionMarkets) IntoProto() *snapshot.Payload_ExecutionMarkets

func (*PayloadExecutionMarkets) Key 

func (*PayloadExecutionMarkets) Key() string

func (*PayloadExecutionMarkets) Namespace 

func (*PayloadExecutionMarkets) Namespace() SnapshotNamespace

type PayloadFloatingPointConsensus 

type PayloadFloatingPointConsensus struct {
	ConsensusData               []*snapshot.NextTimeTrigger
	StateVariablesInternalState []*snapshot.StateVarInternalState
}

func PayloadFloatingPointConsensusFromProto 

func PayloadFloatingPointConsensusFromProto(t *snapshot.Payload_FloatingPointConsensus) *PayloadFloatingPointConsensus

func (*PayloadFloatingPointConsensus) IntoProto 

func (p *PayloadFloatingPointConsensus) IntoProto() *snapshot.Payload_FloatingPointConsensus

func (*PayloadFloatingPointConsensus) Key 

func (*PayloadFloatingPointConsensus) Key() string

func (*PayloadFloatingPointConsensus) Namespace 

func (*PayloadFloatingPointConsensus) Namespace() SnapshotNamespace

type PayloadGovernanceActive 

type PayloadGovernanceActive struct {
	GovernanceActive *GovernanceActive
}

func PayloadGovernanceActiveFromProto 

func PayloadGovernanceActiveFromProto(ga *snapshot.Payload_GovernanceActive) *PayloadGovernanceActive

func (PayloadGovernanceActive) IntoProto 

func (p PayloadGovernanceActive) IntoProto() *snapshot.Payload_GovernanceActive

func (*PayloadGovernanceActive) Key 

func (*PayloadGovernanceActive) Key() string

func (*PayloadGovernanceActive) Namespace 

func (*PayloadGovernanceActive) Namespace() SnapshotNamespace

type PayloadGovernanceEnacted 

type PayloadGovernanceEnacted struct {
	GovernanceEnacted *GovernanceEnacted
}

func PayloadGovernanceEnactedFromProto 

func PayloadGovernanceEnactedFromProto(ga *snapshot.Payload_GovernanceEnacted) *PayloadGovernanceEnacted

func (PayloadGovernanceEnacted) IntoProto 

func (p PayloadGovernanceEnacted) IntoProto() *snapshot.Payload_GovernanceEnacted

func (*PayloadGovernanceEnacted) Key 

func (*PayloadGovernanceEnacted) Key() string

func (*PayloadGovernanceEnacted) Namespace 

func (*PayloadGovernanceEnacted) Namespace() SnapshotNamespace

type PayloadGovernanceNode 

type PayloadGovernanceNode struct {
	GovernanceNode *GovernanceNode
}

func PayloadGovernanceNodeFromProto 

func PayloadGovernanceNodeFromProto(gn *snapshot.Payload_GovernanceNode) *PayloadGovernanceNode

func (PayloadGovernanceNode) IntoProto 

func (p PayloadGovernanceNode) IntoProto() *snapshot.Payload_GovernanceNode

func (*PayloadGovernanceNode) Key 

func (*PayloadGovernanceNode) Key() string

func (*PayloadGovernanceNode) Namespace 

func (*PayloadGovernanceNode) Namespace() SnapshotNamespace

type PayloadLimitState 

type PayloadLimitState struct {
	LimitState *LimitState
}

func PayloadLimitStateFromProto 

func PayloadLimitStateFromProto(l *snapshot.Payload_LimitState) *PayloadLimitState

func (PayloadLimitState) IntoProto 

func (p PayloadLimitState) IntoProto() *snapshot.Payload_LimitState

func (*PayloadLimitState) Key 

func (*PayloadLimitState) Key() string

func (*PayloadLimitState) Namespace 

func (*PayloadLimitState) Namespace() SnapshotNamespace

type PayloadLiquidityParameters 

type PayloadLiquidityParameters struct {
	Parameters *snapshot.LiquidityParameters
}

func PayloadLiquidityParametersFromProto 

func PayloadLiquidityParametersFromProto(s *snapshot.Payload_LiquidityParameters) *PayloadLiquidityParameters

func (*PayloadLiquidityParameters) Key 

func (p *PayloadLiquidityParameters) Key() string

func (*PayloadLiquidityParameters) Namespace 

func (*PayloadLiquidityParameters) Namespace() SnapshotNamespace

type PayloadLiquidityPendingProvisions 

type PayloadLiquidityPendingProvisions struct {
	PendingProvisions *snapshot.LiquidityPendingProvisions
}

func PayloadLiquidityPendingProvisionsFromProto 

func PayloadLiquidityPendingProvisionsFromProto(s *snapshot.Payload_LiquidityPendingProvisions) *PayloadLiquidityPendingProvisions

func (*PayloadLiquidityPendingProvisions) Key 

func (p *PayloadLiquidityPendingProvisions) Key() string

func (*PayloadLiquidityPendingProvisions) Namespace 

func (*PayloadLiquidityPendingProvisions) Namespace() SnapshotNamespace

type PayloadLiquidityProvisions 

type PayloadLiquidityProvisions struct {
	Provisions *snapshot.LiquidityProvisions
}

func PayloadLiquidityProvisionsFromProto 

func PayloadLiquidityProvisionsFromProto(s *snapshot.Payload_LiquidityProvisions) *PayloadLiquidityProvisions

func (*PayloadLiquidityProvisions) Key 

func (p *PayloadLiquidityProvisions) Key() string

func (*PayloadLiquidityProvisions) Namespace 

func (*PayloadLiquidityProvisions) Namespace() SnapshotNamespace

type PayloadLiquidityScores 

type PayloadLiquidityScores struct {
	LiquidityScores *snapshot.LiquidityScores
}

func PayloadLiquidityScoresFromProto 

func PayloadLiquidityScoresFromProto(ls *snapshot.Payload_LiquidityScores) *PayloadLiquidityScores

func (*PayloadLiquidityScores) IntoProto 

func (p *PayloadLiquidityScores) IntoProto() *snapshot.Payload_LiquidityScores

func (*PayloadLiquidityScores) Key 

func (p *PayloadLiquidityScores) Key() string

func (*PayloadLiquidityScores) Namespace 

func (*PayloadLiquidityScores) Namespace() SnapshotNamespace

type PayloadLiquiditySupplied 

type PayloadLiquiditySupplied struct {
	LiquiditySupplied *snapshot.LiquiditySupplied
}

func PayloadLiquiditySuppliedFromProto 

func PayloadLiquiditySuppliedFromProto(ls *snapshot.Payload_LiquiditySupplied) *PayloadLiquiditySupplied

func (*PayloadLiquiditySupplied) IntoProto 

func (p *PayloadLiquiditySupplied) IntoProto() *snapshot.Payload_LiquiditySupplied

func (*PayloadLiquiditySupplied) Key 

func (p *PayloadLiquiditySupplied) Key() string

func (*PayloadLiquiditySupplied) Namespace 

func (*PayloadLiquiditySupplied) Namespace() SnapshotNamespace

type PayloadLiquidityTarget 

type PayloadLiquidityTarget struct {
	Target *snapshot.LiquidityTarget
}

func PayloadLiquidityTargetFromProto 

func PayloadLiquidityTargetFromProto(s *snapshot.Payload_LiquidityTarget) *PayloadLiquidityTarget

func (*PayloadLiquidityTarget) Key 

func (p *PayloadLiquidityTarget) Key() string

func (*PayloadLiquidityTarget) Namespace 

func (*PayloadLiquidityTarget) Namespace() SnapshotNamespace

type PayloadMarketActivityTracker 

type PayloadMarketActivityTracker struct {
	MarketActivityData *snapshot.MarketTracker
}

func PayloadMarketActivityTrackerFromProto 

func PayloadMarketActivityTrackerFromProto(t *snapshot.Payload_MarketTracker) *PayloadMarketActivityTracker

func (*PayloadMarketActivityTracker) IntoProto 

func (p *PayloadMarketActivityTracker) IntoProto() *snapshot.Payload_MarketTracker

func (*PayloadMarketActivityTracker) Key 

func (*PayloadMarketActivityTracker) Key() string

func (*PayloadMarketActivityTracker) Namespace 

func (*PayloadMarketActivityTracker) Namespace() SnapshotNamespace

type PayloadMarketPositions 

type PayloadMarketPositions struct {
	MarketPositions *MarketPositions
}

func PayloadMarketPositionsFromProto 

func PayloadMarketPositionsFromProto(mp *snapshot.Payload_MarketPositions) *PayloadMarketPositions

func (PayloadMarketPositions) IntoProto 

func (p PayloadMarketPositions) IntoProto() *snapshot.Payload_MarketPositions

func (*PayloadMarketPositions) Key 

func (p *PayloadMarketPositions) Key() string

func (*PayloadMarketPositions) Namespace 

func (*PayloadMarketPositions) Namespace() SnapshotNamespace

type PayloadMatchingBook 

type PayloadMatchingBook struct {
	MatchingBook *MatchingBook
}

func PayloadMatchingBookFromProto 

func PayloadMatchingBookFromProto(pmb *snapshot.Payload_MatchingBook) *PayloadMatchingBook

func (PayloadMatchingBook) IntoProto 

func (p PayloadMatchingBook) IntoProto() *snapshot.Payload_MatchingBook

func (*PayloadMatchingBook) Key 

func (p *PayloadMatchingBook) Key() string

func (*PayloadMatchingBook) Namespace 

func (*PayloadMatchingBook) Namespace() SnapshotNamespace

type PayloadNetParams 

type PayloadNetParams struct {
	NetParams *NetParams
}

func PayloadNetParamsFromProto 

func PayloadNetParamsFromProto(pnp *snapshot.Payload_NetworkParameters) *PayloadNetParams

func (PayloadNetParams) IntoProto 

func (p PayloadNetParams) IntoProto() *snapshot.Payload_NetworkParameters

func (*PayloadNetParams) Key 

func (*PayloadNetParams) Key() string

func (*PayloadNetParams) Namespace 

func (*PayloadNetParams) Namespace() SnapshotNamespace

type PayloadNotary 

type PayloadNotary struct {
	Notary *Notary
}

func PayloadNotaryFromProto 

func PayloadNotaryFromProto(n *snapshot.Payload_Notary) *PayloadNotary

func (PayloadNotary) IntoProto 

func (p PayloadNotary) IntoProto() *snapshot.Payload_Notary

func (*PayloadNotary) Key 

func (*PayloadNotary) Key() string

func (*PayloadNotary) Namespace 

func (*PayloadNotary) Namespace() SnapshotNamespace

type PayloadPendingAssetUpdates 

type PayloadPendingAssetUpdates struct {
	PendingAssetUpdates *PendingAssetUpdates
}

func PayloadPendingAssetUpdatesFromProto 

func PayloadPendingAssetUpdatesFromProto(ppa *snapshot.Payload_PendingAssetUpdates) *PayloadPendingAssetUpdates

func (PayloadPendingAssetUpdates) IntoProto 

func (p PayloadPendingAssetUpdates) IntoProto() *snapshot.Payload_PendingAssetUpdates

func (*PayloadPendingAssetUpdates) Key 

func (*PayloadPendingAssetUpdates) Key() string

func (*PayloadPendingAssetUpdates) Namespace 

func (*PayloadPendingAssetUpdates) Namespace() SnapshotNamespace

type PayloadPendingAssets 

type PayloadPendingAssets struct {
	PendingAssets *PendingAssets
}

func PayloadPendingAssetsFromProto 

func PayloadPendingAssetsFromProto(ppa *snapshot.Payload_PendingAssets) *PayloadPendingAssets

func (PayloadPendingAssets) IntoProto 

func (p PayloadPendingAssets) IntoProto() *snapshot.Payload_PendingAssets

func (*PayloadPendingAssets) Key 

func (*PayloadPendingAssets) Key() string

func (*PayloadPendingAssets) Namespace 

func (*PayloadPendingAssets) Namespace() SnapshotNamespace

type PayloadProofOfWork 

type PayloadProofOfWork struct {
	BlockHeight   []uint64
	BlockHash     []string
	HeightToTx    map[uint64][]string
	HeightToTid   map[uint64][]string
	BannedParties map[string]int64
	ActiveParams  []*snapshot.ProofOfWorkParams
	ActiveStates  []*snapshot.ProofOfWorkState
}

func PayloadProofOfWorkFromProto 

func PayloadProofOfWorkFromProto(s *snapshot.Payload_ProofOfWork) *PayloadProofOfWork

func (*PayloadProofOfWork) IntoProto 

func (p *PayloadProofOfWork) IntoProto() *snapshot.Payload_ProofOfWork

func (*PayloadProofOfWork) Key 

func (p *PayloadProofOfWork) Key() string

func (*PayloadProofOfWork) Namespace 

func (*PayloadProofOfWork) Namespace() SnapshotNamespace

type PayloadProtocolUpgradeProposals 

type PayloadProtocolUpgradeProposals struct {
	Proposals *snapshot.ProtocolUpgradeProposals
}

func PayloadProtocolUpgradeProposalFromProto 

func PayloadProtocolUpgradeProposalFromProto(pup *snapshot.Payload_ProtocolUpgradeProposals) *PayloadProtocolUpgradeProposals

func (*PayloadProtocolUpgradeProposals) IntoProto 

func (p *PayloadProtocolUpgradeProposals) IntoProto() *snapshot.Payload_ProtocolUpgradeProposals

func (*PayloadProtocolUpgradeProposals) Key 

func (p *PayloadProtocolUpgradeProposals) Key() string

func (*PayloadProtocolUpgradeProposals) Namespace 

func (*PayloadProtocolUpgradeProposals) Namespace() SnapshotNamespace

type PayloadRewardsPayout 

type PayloadRewardsPayout struct {
	RewardsPendingPayouts *RewardsPendingPayouts
}

func PayloadRewardPayoutFromProto 

func PayloadRewardPayoutFromProto(rpp *snapshot.Payload_RewardsPendingPayouts) *PayloadRewardsPayout

func (PayloadRewardsPayout) IntoProto 

func (p PayloadRewardsPayout) IntoProto() *snapshot.Payload_RewardsPendingPayouts

func (*PayloadRewardsPayout) Key 

func (*PayloadRewardsPayout) Key() string

func (*PayloadRewardsPayout) Namespace 

func (*PayloadRewardsPayout) Namespace() SnapshotNamespace

type PayloadSettlement 

type PayloadSettlement struct {
	SettlementState *SettlementState
}

func PayloadSettlementFromProto 

func PayloadSettlementFromProto(st *snapshot.Payload_SettlementState) *PayloadSettlement

func (PayloadSettlement) IntoProto 

func (p PayloadSettlement) IntoProto() *snapshot.Payload_SettlementState

func (PayloadSettlement) Key 

func (p PayloadSettlement) Key() string

func (*PayloadSettlement) Namespace 

func (*PayloadSettlement) Namespace() SnapshotNamespace

type PayloadSimpleSpamPolicy 

type PayloadSimpleSpamPolicy struct {
	SimpleSpamPolicy *SimpleSpamPolicy
}

func PayloadSimpleSpamPolicyFromProto 

func PayloadSimpleSpamPolicyFromProto(ssp *snapshot.Payload_SimpleSpamPolicy) *PayloadSimpleSpamPolicy

func (*PayloadSimpleSpamPolicy) IntoProto 

func (p *PayloadSimpleSpamPolicy) IntoProto() *snapshot.Payload_SimpleSpamPolicy

func (*PayloadSimpleSpamPolicy) Key 

func (p *PayloadSimpleSpamPolicy) Key() string

func (*PayloadSimpleSpamPolicy) Namespace 

func (*PayloadSimpleSpamPolicy) Namespace() SnapshotNamespace

type PayloadSpotLiquidityTarget 

type PayloadSpotLiquidityTarget struct {
	Target *snapshot.SpotLiquidityTarget
}

func PayloadSpotLiquidityTargetFromProto 

func PayloadSpotLiquidityTargetFromProto(s *snapshot.Payload_SpotLiquidityTarget) *PayloadSpotLiquidityTarget

func (*PayloadSpotLiquidityTarget) Key 

func (p *PayloadSpotLiquidityTarget) Key() string

func (*PayloadSpotLiquidityTarget) Namespace 

func (*PayloadSpotLiquidityTarget) Namespace() SnapshotNamespace

type PayloadStakeVerifierDeposited 

type PayloadStakeVerifierDeposited struct {
	StakeVerifierDeposited []*StakeDeposited
}

func PayloadStakeVerifierDepositedFromProto 

func PayloadStakeVerifierDepositedFromProto(svd *snapshot.Payload_StakeVerifierDeposited) *PayloadStakeVerifierDeposited

func (*PayloadStakeVerifierDeposited) IntoProto 

func (p *PayloadStakeVerifierDeposited) IntoProto() *snapshot.Payload_StakeVerifierDeposited

func (*PayloadStakeVerifierDeposited) Key 

func (*PayloadStakeVerifierDeposited) Key() string

func (*PayloadStakeVerifierDeposited) Namespace 

func (*PayloadStakeVerifierDeposited) Namespace() SnapshotNamespace

type PayloadStakeVerifierRemoved 

type PayloadStakeVerifierRemoved struct {
	StakeVerifierRemoved []*StakeRemoved
}

func PayloadStakeVerifierRemovedFromProto 

func PayloadStakeVerifierRemovedFromProto(svd *snapshot.Payload_StakeVerifierRemoved) *PayloadStakeVerifierRemoved

func (*PayloadStakeVerifierRemoved) IntoProto 

func (p *PayloadStakeVerifierRemoved) IntoProto() *snapshot.Payload_StakeVerifierRemoved

func (*PayloadStakeVerifierRemoved) Key 

func (*PayloadStakeVerifierRemoved) Key() string

func (*PayloadStakeVerifierRemoved) Namespace 

func (*PayloadStakeVerifierRemoved) Namespace() SnapshotNamespace

type PayloadStakingAccounts 

type PayloadStakingAccounts struct {
	StakingAccounts         *StakingAccounts
	PendingStakeTotalSupply *StakeTotalSupply
}

func PayloadStakingAccountsFromProto 

func PayloadStakingAccountsFromProto(sa *snapshot.Payload_StakingAccounts) *PayloadStakingAccounts

func (PayloadStakingAccounts) IntoProto 

func (p PayloadStakingAccounts) IntoProto() *snapshot.Payload_StakingAccounts

func (*PayloadStakingAccounts) Key 

func (*PayloadStakingAccounts) Key() string

func (*PayloadStakingAccounts) Namespace 

func (*PayloadStakingAccounts) Namespace() SnapshotNamespace

type PayloadTopology 

type PayloadTopology struct {
	Topology *Topology
}

func PayloadTopologyFromProto 

func PayloadTopologyFromProto(t *snapshot.Payload_Topology) *PayloadTopology

func (*PayloadTopology) IntoProto 

func (p *PayloadTopology) IntoProto() *snapshot.Payload_Topology

func (*PayloadTopology) Key 

func (*PayloadTopology) Key() string

func (*PayloadTopology) Namespace 

func (*PayloadTopology) Namespace() SnapshotNamespace

type PayloadVoteSpamPolicy 

type PayloadVoteSpamPolicy struct {
	VoteSpamPolicy *VoteSpamPolicy
}

func PayloadVoteSpamPolicyFromProto 

func PayloadVoteSpamPolicyFromProto(vsp *snapshot.Payload_VoteSpamPolicy) *PayloadVoteSpamPolicy

func (*PayloadVoteSpamPolicy) IntoProto 

func (p *PayloadVoteSpamPolicy) IntoProto() *snapshot.Payload_VoteSpamPolicy

func (*PayloadVoteSpamPolicy) Key 

func (*PayloadVoteSpamPolicy) Key() string

func (*PayloadVoteSpamPolicy) Namespace 

func (*PayloadVoteSpamPolicy) Namespace() SnapshotNamespace

type PayloadWitness 

type PayloadWitness struct {
	Witness *Witness
}

func PayloadWitnessFromProto 

func PayloadWitnessFromProto(w *snapshot.Payload_Witness) *PayloadWitness

func (*PayloadWitness) IntoProto 

func (p *PayloadWitness) IntoProto() *snapshot.Payload_Witness

func (*PayloadWitness) Key 

func (*PayloadWitness) Key() string

func (*PayloadWitness) Namespace 

func (*PayloadWitness) Namespace() SnapshotNamespace

type PeggedOrder 

type PeggedOrder struct {
	Reference PeggedReference
	Offset    *num.Uint
}

func NewPeggedOrderFromProto 

func NewPeggedOrderFromProto(p *proto.PeggedOrder) (*PeggedOrder, error)

func (PeggedOrder) Clone 

func (p PeggedOrder) Clone() *PeggedOrder

func (PeggedOrder) IntoProto 

func (p PeggedOrder) IntoProto() *proto.PeggedOrder

func (PeggedOrder) String 

func (p PeggedOrder) String() string

type PeggedOrdersState 

type PeggedOrdersState struct {
	Parked []*Order
}

func PeggedOrdersStateFromProto 

func PeggedOrdersStateFromProto(s *snapshot.PeggedOrders) *PeggedOrdersState

func (PeggedOrdersState) IntoProto 

func (s PeggedOrdersState) IntoProto() *snapshot.PeggedOrders

type PeggedReference 

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

type PendingAssetUpdates 

type PendingAssetUpdates struct {
	Assets []*Asset
}

func PendingAssetUpdatesFromProto 

func PendingAssetUpdatesFromProto(aa *snapshot.PendingAssetUpdates) *PendingAssetUpdates

func (PendingAssetUpdates) IntoProto 

func (a PendingAssetUpdates) IntoProto() *snapshot.PendingAssetUpdates

type PendingAssets 

type PendingAssets struct {
	Assets []*Asset
}

func PendingAssetsFromProto 

func PendingAssetsFromProto(aa *snapshot.PendingAssets) *PendingAssets

func (PendingAssets) IntoProto 

func (a PendingAssets) IntoProto() *snapshot.PendingAssets

type Position 

type Position struct {
	// Market identifier
	MarketID string
	// Party identifier
	PartyID string
	// Open volume for the position, value is signed +ve for long and -ve for short
	OpenVolume int64
	// Realised profit and loss for the position, value is signed +ve for long and -ve for short
	RealisedPnl num.Decimal
	// Unrealised profit and loss for the position, value is signed +ve for long and -ve for short
	UnrealisedPnl num.Decimal
	// Average entry price for the position, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	AverageEntryPrice *num.Uint
	// Timestamp for the latest time the position was updated
	UpdatedAt int64
}

func (*Position) IntoProto 

func (p *Position) IntoProto() *proto.Position

type Positions 

type Positions []*Position

func (Positions) IntoProto 

func (p Positions) IntoProto() []*proto.Position

type PostRestore 

type PostRestore interface {
	StateProvider
	OnStateLoaded(ctx context.Context) error
}

PostRestore is basically a StateProvider which, after the full core state is restored, expects a callback to finalise the state restore Note that the order in which the calls to this OnStateLoaded functions are called is not pre-defined. As such, this method should only be used for engine internals (upkeep, essentially)

type PostTransferBalance 

type PostTransferBalance struct {
	Account *Account
	Balance *num.Uint
}

func (*PostTransferBalance) IntoProto 

func (t *PostTransferBalance) IntoProto() *proto.PostTransferBalance

type PostTransferBalances 

type PostTransferBalances []*PostTransferBalance

func (PostTransferBalances) IntoProto 

func (a PostTransferBalances) IntoProto() []*proto.PostTransferBalance

type PreRestore 

type PreRestore interface {
	StateProvider
	OnStateLoadStarts(ctx context.Context) error
}

type PriceBound 

type PriceBound struct {
	Active     bool
	UpFactor   num.Decimal
	DownFactor num.Decimal
	Trigger    *PriceMonitoringTrigger
}

func PriceBoundFromProto 

func PriceBoundFromProto(pb *snapshot.PriceBound) *PriceBound

func (PriceBound) IntoProto 

func (p PriceBound) IntoProto() *snapshot.PriceBound

type PriceLevel 

type PriceLevel struct {
	Price          *num.Uint
	NumberOfOrders uint64
	Volume         uint64
}

func (PriceLevel) IntoProto 

func (p PriceLevel) IntoProto() *proto.PriceLevel

type PriceLevels 

type PriceLevels []*PriceLevel

func (PriceLevels) IntoProto 

func (p PriceLevels) IntoProto() []*proto.PriceLevel

type PriceMonitor 

type PriceMonitor struct {
	Initialised                 bool
	FPHorizons                  []*KeyDecimalPair
	Now                         time.Time
	Update                      time.Time
	Bounds                      []*PriceBound
	PriceRangeCache             []*PriceRangeCache
	PriceRangeCacheTime         time.Time
	PricesNow                   []*CurrentPrice
	PricesPast                  []*PastPrice
	RefPriceCache               []*KeyDecimalPair
	RefPriceCacheTime           time.Time
	PriceBoundsConsensusReached bool
}

func PriceMonitorFromProto 

func PriceMonitorFromProto(pm *snapshot.PriceMonitor) *PriceMonitor

func (PriceMonitor) IntoProto 

func (p PriceMonitor) IntoProto() *snapshot.PriceMonitor

type PriceMonitoringBounds 

type PriceMonitoringBounds struct {
	MinValidPrice  *num.Uint
	MaxValidPrice  *num.Uint
	Trigger        *PriceMonitoringTrigger
	ReferencePrice num.Decimal
}

func PriceMonitoringBoundsFromProto 

func PriceMonitoringBoundsFromProto(pr *proto.PriceMonitoringBounds) (*PriceMonitoringBounds, error)

func (PriceMonitoringBounds) DeepClone 

func (p PriceMonitoringBounds) DeepClone() *PriceMonitoringBounds

func (PriceMonitoringBounds) IntoProto 

func (p PriceMonitoringBounds) IntoProto() *proto.PriceMonitoringBounds

func (PriceMonitoringBounds) String 

func (p PriceMonitoringBounds) String() string

type PriceMonitoringBoundsList 

type PriceMonitoringBoundsList []*PriceMonitoringBounds

func (PriceMonitoringBoundsList) String 

func (ls PriceMonitoringBoundsList) String() string

type PriceMonitoringParameters 

type PriceMonitoringParameters struct {
	Triggers []*PriceMonitoringTrigger
}

func PriceMonitoringParametersFromProto 

func PriceMonitoringParametersFromProto(p *proto.PriceMonitoringParameters) *PriceMonitoringParameters

func (PriceMonitoringParameters) DeepClone 

func (p PriceMonitoringParameters) DeepClone() *PriceMonitoringParameters

func (PriceMonitoringParameters) IntoProto 

func (p PriceMonitoringParameters) IntoProto() *proto.PriceMonitoringParameters

func (*PriceMonitoringParameters) Reset 

func (p *PriceMonitoringParameters) Reset()

func (PriceMonitoringParameters) String 

func (p PriceMonitoringParameters) String() string

type PriceMonitoringSettings 

type PriceMonitoringSettings struct {
	Parameters *PriceMonitoringParameters
}

func PriceMonitoringSettingsFromProto 

func PriceMonitoringSettingsFromProto(pr *proto.PriceMonitoringSettings) *PriceMonitoringSettings

func (PriceMonitoringSettings) DeepClone 

func (p PriceMonitoringSettings) DeepClone() *PriceMonitoringSettings

func (PriceMonitoringSettings) IntoProto 

func (p PriceMonitoringSettings) IntoProto() *proto.PriceMonitoringSettings

func (PriceMonitoringSettings) String 

func (p PriceMonitoringSettings) String() string

type PriceMonitoringTrigger 

type PriceMonitoringTrigger struct {
	Horizon          int64
	HorizonDec       num.Decimal
	Probability      num.Decimal
	AuctionExtension int64
}

func PriceMonitoringTriggerFromProto 

func PriceMonitoringTriggerFromProto(p *proto.PriceMonitoringTrigger) *PriceMonitoringTrigger

func (PriceMonitoringTrigger) DeepClone 

func (p PriceMonitoringTrigger) DeepClone() *PriceMonitoringTrigger

func (PriceMonitoringTrigger) IntoProto 

func (p PriceMonitoringTrigger) IntoProto() *proto.PriceMonitoringTrigger

IntoProto return proto version of the PriceMonitoringTrigger.

func (PriceMonitoringTrigger) String 

func (p PriceMonitoringTrigger) String() string

type PriceMonitoringTriggers 

type PriceMonitoringTriggers []*PriceMonitoringTrigger

func (PriceMonitoringTriggers) String 

func (ts PriceMonitoringTriggers) String() string

type PriceRange 

type PriceRange struct {
	Min num.Decimal
	Max num.Decimal
	Ref num.Decimal
}

func PriceRangeFromProto 

func PriceRangeFromProto(pr *snapshot.PriceRange) *PriceRange

func (PriceRange) IntoProto 

func (p PriceRange) IntoProto() *snapshot.PriceRange

type PriceRangeCache 

type PriceRangeCache struct {
	Bound *PriceBound
	Range *PriceRange
}

func PriceRangeCacheFromProto 

func PriceRangeCacheFromProto(prc *snapshot.PriceRangeCache) *PriceRangeCache

func (PriceRangeCache) IntoProto 

func (p PriceRangeCache) IntoProto() *snapshot.PriceRangeCache

type ProductType 

type ProductType int32
const (
	ProductTypeFuture ProductType = iota
	ProductTypeSpot
)

type Proposal 

type Proposal struct {
	ID                      string
	Reference               string
	Party                   string
	State                   ProposalState
	Timestamp               int64
	Terms                   *ProposalTerms
	Rationale               *ProposalRationale
	Reason                  ProposalError
	ErrorDetails            string
	RequiredMajority        num.Decimal
	RequiredParticipation   num.Decimal
	RequiredLPMajority      num.Decimal
	RequiredLPParticipation num.Decimal
}

func ProposalFromProto 

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

func (Proposal) DeepClone 

func (p Proposal) DeepClone() *Proposal

func (*Proposal) FailUnexpectedly 

func (p *Proposal) FailUnexpectedly(details error)

FailUnexpectedly marks the proposal as failed. Calling this method should be reserved to cases where errors are the result of an internal issue, such as bad workflow, or conditions.

func (*Proposal) FailWithErr 

func (p *Proposal) FailWithErr(reason ProposalError, details error)

func (Proposal) IntoProto 

func (p Proposal) IntoProto() *furypb.Proposal

func (*Proposal) IsMarketUpdate 

func (p *Proposal) IsMarketUpdate() bool

func (*Proposal) IsNewMarket 

func (p *Proposal) IsNewMarket() bool

func (*Proposal) IsSpotMarketUpdate 

func (p *Proposal) IsSpotMarketUpdate() bool

func (*Proposal) IsSuccessorMarket 

func (p *Proposal) IsSuccessorMarket() bool

func (*Proposal) MarketUpdate 

func (p *Proposal) MarketUpdate() *UpdateMarket

func (*Proposal) NewMarket 

func (p *Proposal) NewMarket() *NewMarket

func (*Proposal) Reject 

func (p *Proposal) Reject(reason ProposalError)

func (*Proposal) RejectWithErr 

func (p *Proposal) RejectWithErr(reason ProposalError, details error)

func (*Proposal) SpotMarketUpdate 

func (p *Proposal) SpotMarketUpdate() *UpdateSpotMarket

func (Proposal) String 

func (p Proposal) String() string

func (*Proposal) WaitForNodeVote 

func (p *Proposal) WaitForNodeVote()

type ProposalData 

type ProposalData struct {
	Proposal *Proposal
	Yes      []*Vote
	No       []*Vote
	Invalid  []*Vote
}

func ProposalDataFromProto 

func ProposalDataFromProto(pp *snapshot.ProposalData) *ProposalData

func (ProposalData) IntoProto 

func (p ProposalData) IntoProto() *snapshot.ProposalData

type ProposalError 

type ProposalError = furypb.ProposalError
const (
	// ProposalErrorUnspecified Default value, always invalid.
	ProposalErrorUnspecified ProposalError = furypb.ProposalError_PROPOSAL_ERROR_UNSPECIFIED
	// ProposalErrorCloseTimeTooSoon The specified close time is too early base on network parameters.
	ProposalErrorCloseTimeTooSoon ProposalError = furypb.ProposalError_PROPOSAL_ERROR_CLOSE_TIME_TOO_SOON
	// ProposalErrorCloseTimeTooLate The specified close time is too late based on network parameters.
	ProposalErrorCloseTimeTooLate ProposalError = furypb.ProposalError_PROPOSAL_ERROR_CLOSE_TIME_TOO_LATE
	// ProposalErrorEnactTimeTooSoon The specified enact time is too early based on network parameters.
	ProposalErrorEnactTimeTooSoon ProposalError = furypb.ProposalError_PROPOSAL_ERROR_ENACT_TIME_TOO_SOON
	// ProposalErrorEnactTimeTooLate The specified enact time is too late based on network parameters.
	ProposalErrorEnactTimeTooLate ProposalError = furypb.ProposalError_PROPOSAL_ERROR_ENACT_TIME_TOO_LATE
	// ProposalErrorInsufficientTokens The proposer for this proposal as insufficient tokens.
	ProposalErrorInsufficientTokens ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INSUFFICIENT_TOKENS
	// ProposalErrorNoProduct The proposal has no product.
	ProposalErrorNoProduct ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NO_PRODUCT
	// ProposalErrorUnsupportedProduct The specified product is not supported.
	ProposalErrorUnsupportedProduct ProposalError = furypb.ProposalError_PROPOSAL_ERROR_UNSUPPORTED_PRODUCT
	// ProposalErrorNodeValidationFailed The proposal failed node validation.
	ProposalErrorNodeValidationFailed ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NODE_VALIDATION_FAILED
	// ProposalErrorMissingBuiltinAssetField A field is missing in a builtin asset source.
	ProposalErrorMissingBuiltinAssetField ProposalError = furypb.ProposalError_PROPOSAL_ERROR_MISSING_BUILTIN_ASSET_FIELD
	// ProposalErrorMissingErc20ContractAddress The contract address is missing in the ERC20 asset source.
	ProposalErrorMissingErc20ContractAddress ProposalError = furypb.ProposalError_PROPOSAL_ERROR_MISSING_ERC20_CONTRACT_ADDRESS
	// ProposalErrorInvalidAsset The asset identifier is invalid or does not exist on the Fury network.
	ProposalErrorInvalidAsset ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_ASSET
	// ProposalErrorIncompatibleTimestamps Proposal terms timestamps are not compatible (Validation < Closing < Enactment).
	ProposalErrorIncompatibleTimestamps ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INCOMPATIBLE_TIMESTAMPS
	// ProposalErrorNoRiskParameters No risk parameters were specified.
	ProposalErrorNoRiskParameters ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NO_RISK_PARAMETERS
	// ProposalErrorNetworkParameterInvalidKey Invalid key in update network parameter proposal.
	ProposalErrorNetworkParameterInvalidKey ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_INVALID_KEY
	// ProposalErrorNetworkParameterInvalidValue Invalid valid in update network parameter proposal.
	ProposalErrorNetworkParameterInvalidValue ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_INVALID_VALUE
	// ProposalErrorNetworkParameterValidationFailed Validation failed for network parameter proposal.
	ProposalErrorNetworkParameterValidationFailed ProposalError = furypb.ProposalError_PROPOSAL_ERROR_NETWORK_PARAMETER_VALIDATION_FAILED
	// ProposalErrorOpeningAuctionDurationTooSmall Opening auction duration is less than the network minimum opening auction time.
	ProposalErrorOpeningAuctionDurationTooSmall ProposalError = furypb.ProposalError_PROPOSAL_ERROR_OPENING_AUCTION_DURATION_TOO_SMALL
	// ProposalErrorOpeningAuctionDurationTooLarge Opening auction duration is more than the network minimum opening auction time.
	ProposalErrorOpeningAuctionDurationTooLarge ProposalError = furypb.ProposalError_PROPOSAL_ERROR_OPENING_AUCTION_DURATION_TOO_LARGE
	// ProposalErrorCouldNotInstantiateMarket Market proposal market could not be instantiated during execution.
	ProposalErrorCouldNotInstantiateMarket ProposalError = furypb.ProposalError_PROPOSAL_ERROR_COULD_NOT_INSTANTIATE_MARKET
	// ProposalErrorInvalidFutureProduct Market proposal market contained invalid product definition.
	ProposalErrorInvalidFutureProduct ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_FUTURE_PRODUCT
	// ProposalErrorInvalidRiskParameter Market proposal invalid risk parameter.
	ProposalErrorInvalidRiskParameter ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_RISK_PARAMETER
	// ProposalErrorMajorityThresholdNotReached Proposal was declined because vote didn't reach the majority threshold required.
	ProposalErrorMajorityThresholdNotReached ProposalError = furypb.ProposalError_PROPOSAL_ERROR_MAJORITY_THRESHOLD_NOT_REACHED
	// ProposalErrorParticipationThresholdNotReached Proposal declined because the participation threshold was not reached.
	ProposalErrorParticipationThresholdNotReached ProposalError = furypb.ProposalError_PROPOSAL_ERROR_PARTICIPATION_THRESHOLD_NOT_REACHED
	// ProposalErrorInvalidAssetDetails Asset proposal invalid asset details.
	ProposalErrorInvalidAssetDetails ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_ASSET_DETAILS
	// ProposalErrorUnknownType Proposal is an unknown type.
	ProposalErrorUnknownType ProposalError = furypb.ProposalError_PROPOSAL_ERROR_UNKNOWN_TYPE
	// ProposalErrorUnknownRiskParameterType Proposal has an unknown risk parameter type.
	ProposalErrorUnknownRiskParameterType ProposalError = furypb.ProposalError_PROPOSAL_ERROR_UNKNOWN_RISK_PARAMETER_TYPE
	// ProposalErrorInvalidFreeform Validation failed for freeform proposal.
	ProposalErrorInvalidFreeform ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_FREEFORM
	// ProposalErrorInsufficientEquityLikeShare The party doesn't have enough equity-like share to propose an update on the market
	// targeted by the proposal.
	ProposalErrorInsufficientEquityLikeShare ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INSUFFICIENT_EQUITY_LIKE_SHARE
	// ProposalErrorInvalidMarket The market targeted by the proposal does not exist or is not eligible to modification.
	ProposalErrorInvalidMarket ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_MARKET
	// ProposalErrorTooManyMarketDecimalPlaces the market uses more decimal places than the settlement asset.
	ProposalErrorTooManyMarketDecimalPlaces ProposalError = furypb.ProposalError_PROPOSAL_ERROR_TOO_MANY_MARKET_DECIMAL_PLACES
	// ProposalErrorTooManyPriceMonitoringTriggers the market price monitoring setting uses too many triggers.
	ProposalErrorTooManyPriceMonitoringTriggers ProposalError = furypb.ProposalError_PROPOSAL_ERROR_TOO_MANY_PRICE_MONITORING_TRIGGERS
	// ProposalErrorERC20AddressAlreadyInUse the proposal uses a erc20 address already used by another asset.
	ProposalErrorERC20AddressAlreadyInUse ProposalError = furypb.ProposalError_PROPOSAL_ERROR_ERC20_ADDRESS_ALREADY_IN_USE
	// ProposalErrorLpPriceRangeNonpositive LP price range is zero or less.
	ProposalErrorLpPriceRangeNonpositive ProposalError = furypb.ProposalError_PROPOSAL_ERROR_LP_PRICE_RANGE_NONPOSITIVE
	// ProposalErrorLpPriceRangeTooLarge LP price range above 100.
	ProposalErrorLpPriceRangeTooLarge ProposalError = furypb.ProposalError_PROPOSAL_ERROR_LP_PRICE_RANGE_TOO_LARGE
	// ProposalErrorLinearSlippageOutOfRange linear slippage factor is negative or too large.
	ProposalErrorLinearSlippageOutOfRange ProposalError = furypb.ProposalError_PROPOSAL_ERROR_LINEAR_SLIPPAGE_FACTOR_OUT_OF_RANGE
	// ProposalErrorSquaredSlippageOutOfRange squared slippage factor is negative or too large.
	ProposalErrorQuadraticSlippageOutOfRange ProposalError = furypb.ProposalError_PROPOSAL_ERROR_QUADRATIC_SLIPPAGE_FACTOR_OUT_OF_RANGE
	// ProposalErrorInvalidFreeform Validation failed for spot proposal.
	ProposalErrorInvalidSpot ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_SPOT
	// ProposalErrorSpotNotEnabled is returned when spots are not enabled.
	ProposalErrorSpotNotEnabled ProposalError = furypb.ProposalError_PROPOSAL_ERROR_SPOT_PRODUCT_DISABLED
	// ProposalErrorInvalidSuccessorMarket indicates the successor market parameters were invalid.
	ProposalErrorInvalidSuccessorMarket ProposalError = furypb.ProposalError_PROPOSAL_ERROR_INVALID_SUCCESSOR_MARKET
)

type ProposalRationale 

type ProposalRationale struct {
	Description string
	Title       string
}

func ProposalRationaleFromProto 

func ProposalRationaleFromProto(p *furypb.ProposalRationale) *ProposalRationale

type ProposalState 

type ProposalState = furypb.Proposal_State
const (
	// ProposalStateUnspecified Default value, always invalid.
	ProposalStateUnspecified ProposalState = furypb.Proposal_STATE_UNSPECIFIED
	// ProposalStateFailed Proposal enactment has failed - even though proposal has passed, its execution could not be performed.
	ProposalStateFailed ProposalState = furypb.Proposal_STATE_FAILED
	// ProposalStateOpen Proposal is open for voting.
	ProposalStateOpen ProposalState = furypb.Proposal_STATE_OPEN
	// ProposalStatePassed Proposal has gained enough support to be executed.
	ProposalStatePassed ProposalState = furypb.Proposal_STATE_PASSED
	// ProposalStateRejected Proposal wasn't accepted (proposal terms failed validation due to wrong configuration or failing to meet network requirements).
	ProposalStateRejected ProposalState = furypb.Proposal_STATE_REJECTED
	// ProposalStateDeclined Proposal didn't get enough votes (either failing to gain required participation or majority level).
	ProposalStateDeclined ProposalState = furypb.Proposal_STATE_DECLINED
	// ProposalStateEnacted Proposal enacted.
	ProposalStateEnacted ProposalState = furypb.Proposal_STATE_ENACTED
	// ProposalStateWaitingForNodeVote Waiting for node validation of the proposal.
	ProposalStateWaitingForNodeVote ProposalState = furypb.Proposal_STATE_WAITING_FOR_NODE_VOTE
)

type ProposalSubmission 

type ProposalSubmission struct {
	// Proposal reference
	Reference string
	// Proposal configuration and the actual change that is meant to be executed when proposal is enacted
	Terms *ProposalTerms
	// Rationale behind the proposal change.
	Rationale *ProposalRationale
}

func NewProposalSubmissionFromProto 

func NewProposalSubmissionFromProto(p *commandspb.ProposalSubmission) (*ProposalSubmission, error)

func ProposalSubmissionFromProposal 

func ProposalSubmissionFromProposal(p *Proposal) *ProposalSubmission

func (ProposalSubmission) IntoProto 

func (p ProposalSubmission) IntoProto() *commandspb.ProposalSubmission

type ProposalTerms 

type ProposalTerms struct {
	ClosingTimestamp    int64
	EnactmentTimestamp  int64
	ValidationTimestamp int64
	// *ProposalTermsUpdateMarket
	// *ProposalTermsNewMarket
	// *ProposalTermsUpdateNetworkParameter
	// *ProposalTermsNewAsset
	Change proposalTerm
}

func ProposalTermsFromProto 

func ProposalTermsFromProto(p *furypb.ProposalTerms) (*ProposalTerms, error)

func (ProposalTerms) DeepClone 

func (p ProposalTerms) DeepClone() *ProposalTerms

func (*ProposalTerms) GetNewAsset 

func (p *ProposalTerms) GetNewAsset() *NewAsset

func (*ProposalTerms) GetNewFreeform 

func (p *ProposalTerms) GetNewFreeform() *NewFreeform

func (*ProposalTerms) GetNewMarket 

func (p *ProposalTerms) GetNewMarket() *NewMarket

func (*ProposalTerms) GetNewSpotMarket 

func (p *ProposalTerms) GetNewSpotMarket() *NewSpotMarket

func (*ProposalTerms) GetUpdateAsset 

func (p *ProposalTerms) GetUpdateAsset() *UpdateAsset

func (*ProposalTerms) GetUpdateMarket 

func (p *ProposalTerms) GetUpdateMarket() *UpdateMarket

func (*ProposalTerms) GetUpdateNetworkParameter 

func (p *ProposalTerms) GetUpdateNetworkParameter() *UpdateNetworkParameter

func (*ProposalTerms) GetUpdateSpotMarket 

func (p *ProposalTerms) GetUpdateSpotMarket() *UpdateSpotMarket

func (ProposalTerms) IntoProto 

func (p ProposalTerms) IntoProto() *furypb.ProposalTerms

func (ProposalTerms) String 

func (p ProposalTerms) String() string

type ProposalTermsNewAsset 

type ProposalTermsNewAsset struct {
	NewAsset *NewAsset
}

func NewNewAssetFromProto 

func NewNewAssetFromProto(p *furypb.ProposalTerms_NewAsset) (*ProposalTermsNewAsset, error)

func (ProposalTermsNewAsset) DeepClone 

func (a ProposalTermsNewAsset) DeepClone() proposalTerm

func (ProposalTermsNewAsset) GetTermType 

func (a ProposalTermsNewAsset) GetTermType() ProposalTermsType

func (ProposalTermsNewAsset) IntoProto 

func (a ProposalTermsNewAsset) IntoProto() *furypb.ProposalTerms_NewAsset

func (ProposalTermsNewAsset) String 

func (a ProposalTermsNewAsset) String() string

type ProposalTermsNewFreeform 

type ProposalTermsNewFreeform struct {
	NewFreeform *NewFreeform
}

func NewNewFreeformFromProto 

func NewNewFreeformFromProto(_ *furypb.ProposalTerms_NewFreeform) *ProposalTermsNewFreeform

func (ProposalTermsNewFreeform) DeepClone 

func (f ProposalTermsNewFreeform) DeepClone() proposalTerm

func (ProposalTermsNewFreeform) GetTermType 

func (f ProposalTermsNewFreeform) GetTermType() ProposalTermsType

func (ProposalTermsNewFreeform) IntoProto 

func (f ProposalTermsNewFreeform) IntoProto() *furypb.ProposalTerms_NewFreeform

func (ProposalTermsNewFreeform) String 

func (f ProposalTermsNewFreeform) String() string

type ProposalTermsNewMarket 

type ProposalTermsNewMarket struct {
	NewMarket *NewMarket
}

func NewNewMarketFromProto 

func NewNewMarketFromProto(p *furypb.ProposalTerms_NewMarket) (*ProposalTermsNewMarket, error)

func (ProposalTermsNewMarket) DeepClone 

func (a ProposalTermsNewMarket) DeepClone() proposalTerm

func (ProposalTermsNewMarket) GetTermType 

func (a ProposalTermsNewMarket) GetTermType() ProposalTermsType

func (ProposalTermsNewMarket) IntoProto 

func (a ProposalTermsNewMarket) IntoProto() *furypb.ProposalTerms_NewMarket

func (ProposalTermsNewMarket) String 

func (a ProposalTermsNewMarket) String() string

type ProposalTermsNewSpotMarket 

type ProposalTermsNewSpotMarket struct {
	NewSpotMarket *NewSpotMarket
}

func NewNewSpotMarketFromProto 

func NewNewSpotMarketFromProto(p *furypb.ProposalTerms_NewSpotMarket) (*ProposalTermsNewSpotMarket, error)

func (ProposalTermsNewSpotMarket) DeepClone 

func (a ProposalTermsNewSpotMarket) DeepClone() proposalTerm

func (ProposalTermsNewSpotMarket) GetTermType 

func (a ProposalTermsNewSpotMarket) GetTermType() ProposalTermsType

func (ProposalTermsNewSpotMarket) IntoProto 

func (a ProposalTermsNewSpotMarket) IntoProto() *furypb.ProposalTerms_NewSpotMarket

func (ProposalTermsNewSpotMarket) String 

func (a ProposalTermsNewSpotMarket) String() string

type ProposalTermsType 

type ProposalTermsType int
const (
	ProposalTermsTypeUpdateMarket ProposalTermsType = iota
	ProposalTermsTypeNewMarket
	ProposalTermsTypeUpdateNetworkParameter
	ProposalTermsTypeNewAsset
	ProposalTermsTypeNewFreeform
	ProposalTermsTypeUpdateAsset
	ProposalTermsTypeNewSpotMarket
	ProposalTermsTypeUpdateSpotMarket
)

type ProposalTermsUpdateAsset 

type ProposalTermsUpdateAsset struct {
	UpdateAsset *UpdateAsset
}

func NewUpdateAssetFromProto 

func NewUpdateAssetFromProto(p *furypb.ProposalTerms_UpdateAsset) (*ProposalTermsUpdateAsset, error)

func (ProposalTermsUpdateAsset) DeepClone 

func (a ProposalTermsUpdateAsset) DeepClone() proposalTerm

func (ProposalTermsUpdateAsset) GetTermType 

func (a ProposalTermsUpdateAsset) GetTermType() ProposalTermsType

func (ProposalTermsUpdateAsset) IntoProto 

func (a ProposalTermsUpdateAsset) IntoProto() *furypb.ProposalTerms_UpdateAsset

func (ProposalTermsUpdateAsset) String 

func (a ProposalTermsUpdateAsset) String() string

type ProposalTermsUpdateMarket 

type ProposalTermsUpdateMarket struct {
	UpdateMarket *UpdateMarket
}

func UpdateMarketFromProto 

func UpdateMarketFromProto(p *furypb.ProposalTerms_UpdateMarket) (*ProposalTermsUpdateMarket, error)

func (ProposalTermsUpdateMarket) DeepClone 

func (a ProposalTermsUpdateMarket) DeepClone() proposalTerm

func (ProposalTermsUpdateMarket) GetTermType 

func (a ProposalTermsUpdateMarket) GetTermType() ProposalTermsType

func (ProposalTermsUpdateMarket) IntoProto 

func (a ProposalTermsUpdateMarket) IntoProto() *furypb.ProposalTerms_UpdateMarket

func (ProposalTermsUpdateMarket) String 

func (a ProposalTermsUpdateMarket) String() string

type ProposalTermsUpdateNetworkParameter 

type ProposalTermsUpdateNetworkParameter struct {
	UpdateNetworkParameter *UpdateNetworkParameter
}

func NewUpdateNetworkParameterFromProto 

func NewUpdateNetworkParameterFromProto(
	p *furypb.ProposalTerms_UpdateNetworkParameter,
) *ProposalTermsUpdateNetworkParameter

func (ProposalTermsUpdateNetworkParameter) DeepClone 

func (a ProposalTermsUpdateNetworkParameter) DeepClone() proposalTerm

func (ProposalTermsUpdateNetworkParameter) GetTermType 

func (a ProposalTermsUpdateNetworkParameter) GetTermType() ProposalTermsType

func (ProposalTermsUpdateNetworkParameter) IntoProto 

func (a ProposalTermsUpdateNetworkParameter) IntoProto() *furypb.ProposalTerms_UpdateNetworkParameter

func (ProposalTermsUpdateNetworkParameter) String 

func (a ProposalTermsUpdateNetworkParameter) String() string

type ProposalTermsUpdateSpotMarket 

type ProposalTermsUpdateSpotMarket struct {
	UpdateSpotMarket *UpdateSpotMarket
}

func UpdateSpotMarketFromProto 

func UpdateSpotMarketFromProto(p *furypb.ProposalTerms_UpdateSpotMarket) (*ProposalTermsUpdateSpotMarket, error)

func (ProposalTermsUpdateSpotMarket) DeepClone 

func (a ProposalTermsUpdateSpotMarket) DeepClone() proposalTerm

func (ProposalTermsUpdateSpotMarket) GetTermType 

func (a ProposalTermsUpdateSpotMarket) GetTermType() ProposalTermsType

func (ProposalTermsUpdateSpotMarket) IntoProto 

func (a ProposalTermsUpdateSpotMarket) IntoProto() *furypb.ProposalTerms_UpdateSpotMarket

func (ProposalTermsUpdateSpotMarket) String 

func (a ProposalTermsUpdateSpotMarket) String() string

type PubKey 

type PubKey struct {
	Key string
}

PubKey.

func (PubKey) DeepClone 

func (p PubKey) DeepClone() *PubKey

func (PubKey) IntoProto 

func (p PubKey) IntoProto() *datapb.PubKey

func (PubKey) String 

func (p PubKey) String() string

type RWithdrawal 

type RWithdrawal struct {
	Ref        string
	Withdrawal *Withdrawal
}

func RWithdrawalFromProto 

func RWithdrawalFromProto(rw *snapshot.Withdrawal) *RWithdrawal

func (RWithdrawal) IntoProto 

func (r RWithdrawal) IntoProto() *snapshot.Withdrawal

type RawChunk 

type RawChunk struct {
	Nr     uint32
	Data   []byte
	Height uint64
	Format SnapshotFormat
}

type RecurringTransfer 

type RecurringTransfer struct {
	*TransferBase
	StartEpoch       uint64
	EndEpoch         *uint64
	Factor           num.Decimal
	DispatchStrategy *furypb.DispatchStrategy
}

func RecurringTransferFromEvent 

func RecurringTransferFromEvent(p *eventspb.Transfer) *RecurringTransfer

func (*RecurringTransfer) IntoEvent 

func (r *RecurringTransfer) IntoEvent(reason *string) *eventspb.Transfer

func (*RecurringTransfer) IsValid 

func (r *RecurringTransfer) IsValid() error

type ReleaseInfo 

type ReleaseInfo struct {
	FuryReleaseTag     string
	UpgradeBlockHeight uint64
}

type Resource 

type Resource struct {
	ID         string
	CheckUntil time.Time
	Votes      []string
}

func ResourceFromProto 

func ResourceFromProto(r *snapshot.Resource) *Resource

func (*Resource) IntoProto 

func (r *Resource) IntoProto() *snapshot.Resource

type RewardsPartyAmount 

type RewardsPartyAmount struct {
	Party  string
	Amount *num.Uint
}

type RewardsPayout 

type RewardsPayout struct {
	FromAccount  string
	Asset        string
	PartyAmounts []*RewardsPartyAmount
	TotalReward  *num.Uint
	EpochSeq     string
	Timestamp    int64
}

func RewardsPayoutFromProto 

func RewardsPayoutFromProto(p *snapshot.RewardsPayout) *RewardsPayout

func (*RewardsPayout) IntoProto 

func (rp *RewardsPayout) IntoProto() *snapshot.RewardsPayout

type RewardsPendingPayouts 

type RewardsPendingPayouts struct {
	ScheduledRewardsPayout []*ScheduledRewardsPayout
}

func RewardPendingPayoutsFromProto 

func RewardPendingPayoutsFromProto(rpps *snapshot.RewardsPendingPayouts) *RewardsPendingPayouts

func (RewardsPendingPayouts) IntoProto 

func (rpp RewardsPendingPayouts) IntoProto() *snapshot.RewardsPendingPayouts

type RiskFactor 

type RiskFactor struct {
	Market string
	Short  num.Decimal
	Long   num.Decimal
}

func (RiskFactor) IntoProto 

func (r RiskFactor) IntoProto() *proto.RiskFactor

func (RiskFactor) String 

func (r RiskFactor) String() string

type ScalingFactors 

type ScalingFactors struct {
	SearchLevel       num.Decimal
	InitialMargin     num.Decimal
	CollateralRelease num.Decimal
}

func ScalingFactorsFromProto 

func ScalingFactorsFromProto(p *proto.ScalingFactors) *ScalingFactors

func (ScalingFactors) DeepClone 

func (s ScalingFactors) DeepClone() *ScalingFactors

func (ScalingFactors) IntoProto 

func (s ScalingFactors) IntoProto() *proto.ScalingFactors

func (*ScalingFactors) Reset 

func (s *ScalingFactors) Reset()

func (ScalingFactors) String 

func (s ScalingFactors) String() string

type ScheduledRewardsPayout 

type ScheduledRewardsPayout struct {
	PayoutTime    int64
	RewardsPayout []*RewardsPayout
}

func ScheduledRewardsPayoutFromProto 

func ScheduledRewardsPayoutFromProto(srp *snapshot.ScheduledRewardsPayout) *ScheduledRewardsPayout

func (ScheduledRewardsPayout) IntoProto 

func (srp ScheduledRewardsPayout) IntoProto() *snapshot.ScheduledRewardsPayout

type ScoreData 

type ScoreData struct {
	RawValScores      map[string]num.Decimal
	PerformanceScores map[string]num.Decimal
	MultisigScores    map[string]num.Decimal
	ValScores         map[string]num.Decimal
	NormalisedScores  map[string]num.Decimal
	NodeIDSlice       []string
}

type SettlementState 

type SettlementState struct {
	MarketID                 string
	LastMarkPrice            *num.Uint
	PartyLastSettledPosition []*PartySettledPosition
	Trades                   []*SettlementTrade
}

func SettlementStateFromProto 

func SettlementStateFromProto(ss *snapshot.SettlementState) *SettlementState

func (SettlementState) IntoProto 

func (s SettlementState) IntoProto() *snapshot.SettlementState

type SettlementTrade 

type SettlementTrade struct {
	Price, MarketPrice *num.Uint
	Size, NewSize      int64
	Party              string
}

func SettlementTradeFromProto 

func SettlementTradeFromProto(t *snapshot.SettlementTrade) *SettlementTrade

func (SettlementTrade) IntoProto 

func (s SettlementTrade) IntoProto() *snapshot.SettlementTrade

type Side 

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

type Signer 

type Signer struct {
	Signer dataSourceSpec
}

func CreateSignerFromString 

func CreateSignerFromString(s string, t DataSignerType) *Signer

func DeserializeSigner 

func DeserializeSigner(content []byte) *Signer

func NewSigner 

func NewSigner() *Signer

func SignerAsHex 

func SignerAsHex(signer *Signer) *Signer

SignerAsHex represents the signer as a hex encoded string. We export this function as a standalone option because there are cases when we are not sure what is the signer type we deal with.

func SignerAsString 

func SignerAsString(signer *Signer) (*Signer, error)

SignerAsString represents the Signer content as a string.

func SignerFromProto 

func SignerFromProto(s *datapb.Signer) *Signer

func SignersFromProto 

func SignersFromProto(s []*datapb.Signer) []*Signer

SignersFromProto returns a list of signers after checking the list length.

func (Signer) DeepClone 

func (s Signer) DeepClone() *Signer

func (Signer) GetSignerETHAddress 

func (s Signer) GetSignerETHAddress() *ETHAddress

func (Signer) GetSignerPubKey 

func (s Signer) GetSignerPubKey() *PubKey

func (Signer) GetSignerType 

func (s Signer) GetSignerType() DataSignerType

func (Signer) IntoProto 

func (s Signer) IntoProto() *datapb.Signer

func (Signer) IsEmpty 

func (s Signer) IsEmpty() bool

func (*Signer) Serialize 

func (s *Signer) Serialize() ([]byte, error)

SerializeSigner deserializes the signer to a byte slice - we use that type top insert it into the database. The deserialization prepends the slice with two bytes as signer type indicator - that is used when the Signer is serialized back.

func (Signer) String 

func (s Signer) String() string

type SignerETHAddress 

type SignerETHAddress struct {
	ETHAddress *ETHAddress
}

func DeserializeETHAddress 

func DeserializeETHAddress(data []byte) SignerETHAddress

func ETHAddressFromProto 

func ETHAddressFromProto(s *datapb.Signer_EthAddress) *SignerETHAddress

func (SignerETHAddress) AsHex 

func (s SignerETHAddress) AsHex(prepend bool) dataSourceSpec

func (SignerETHAddress) AsString 

func (s SignerETHAddress) AsString() (dataSourceSpec, error)

func (SignerETHAddress) DeepClone 

func (s SignerETHAddress) DeepClone() dataSourceSpec

func (SignerETHAddress) GetSignerType 

func (s SignerETHAddress) GetSignerType() DataSignerType

func (SignerETHAddress) IntoProto 

func (s SignerETHAddress) IntoProto() *datapb.Signer_EthAddress

func (SignerETHAddress) IsEmpty 

func (s SignerETHAddress) IsEmpty() bool

func (SignerETHAddress) Serialize 

func (s SignerETHAddress) Serialize() []byte

func (SignerETHAddress) String 

func (s SignerETHAddress) String() string

type SignerEvent 

type SignerEvent struct {
	BlockNumber, LogIndex uint64
	TxHash                string

	ID        string
	Address   string
	Nonce     string
	BlockTime int64

	Kind SignerEventKind
}

func SignerEventFromEventProto 

func SignerEventFromEventProto(
	event *eventspb.ERC20MultiSigSignerEvent,
) *SignerEvent

func SignerEventFromSignerAddedProto 

func SignerEventFromSignerAddedProto(
	s *vgproto.ERC20SignerAdded,
	blockNumber, logIndex uint64,
	txhash, id string,
) (*SignerEvent, error)

func SignerEventFromSignerRemovedProto 

func SignerEventFromSignerRemovedProto(
	s *vgproto.ERC20SignerRemoved,
	blockNumber, logIndex uint64,
	txhash, id string,
) (*SignerEvent, error)

func (SignerEvent) Hash 

func (s SignerEvent) Hash() string

func (*SignerEvent) IntoProto 

func (s *SignerEvent) IntoProto() *eventspb.ERC20MultiSigSignerEvent

func (*SignerEvent) String 

func (s *SignerEvent) String() string

type SignerEventKind 

type SignerEventKind = eventspb.ERC20MultiSigSignerEvent_Type
const (
	SignerEventKindAdded   SignerEventKind = eventspb.ERC20MultiSigSignerEvent_TYPE_ADDED
	SignerEventKindRemoved                 = eventspb.ERC20MultiSigSignerEvent_TYPE_REMOVED
)

type SignerPubKey 

type SignerPubKey struct {
	PubKey *PubKey
}

func DeserializePubKey 

func DeserializePubKey(data []byte) SignerPubKey

func PubKeyFromProto 

func PubKeyFromProto(s *datapb.Signer_PubKey) *SignerPubKey

func (SignerPubKey) AsHex 

func (s SignerPubKey) AsHex(prepend bool) dataSourceSpec

func (SignerPubKey) AsString 

func (s SignerPubKey) AsString() (dataSourceSpec, error)

func (SignerPubKey) DeepClone 

func (s SignerPubKey) DeepClone() dataSourceSpec

func (SignerPubKey) GetSignerType 

func (s SignerPubKey) GetSignerType() DataSignerType

func (SignerPubKey) IntoProto 

func (s SignerPubKey) IntoProto() *datapb.Signer_PubKey

func (SignerPubKey) IsEmpty 

func (s SignerPubKey) IsEmpty() bool

func (SignerPubKey) Serialize 

func (s SignerPubKey) Serialize() []byte

func (SignerPubKey) String 

func (s SignerPubKey) String() string

type SignerThresholdSetEvent 

type SignerThresholdSetEvent struct {
	BlockNumber, LogIndex uint64
	TxHash                string

	ID        string
	Threshold uint32
	Nonce     string
	BlockTime int64
}

func SignerThresholdSetEventFromEventProto 

func SignerThresholdSetEventFromEventProto(
	event *eventspb.ERC20MultiSigThresholdSetEvent,
) *SignerThresholdSetEvent

func SignerThresholdSetEventFromProto 

func SignerThresholdSetEventFromProto(
	s *vgproto.ERC20ThresholdSet,
	blockNumber, logIndex uint64,
	txhash, id string,
) (*SignerThresholdSetEvent, error)

func (SignerThresholdSetEvent) Hash 

func (s SignerThresholdSetEvent) Hash() string

func (*SignerThresholdSetEvent) IntoProto 

func (s *SignerThresholdSetEvent) IntoProto() *eventspb.ERC20MultiSigThresholdSetEvent

func (*SignerThresholdSetEvent) String 

func (s *SignerThresholdSetEvent) String() string

type SimpleModelParams 

type SimpleModelParams struct {
	FactorLong           num.Decimal
	FactorShort          num.Decimal
	MaxMoveUp            num.Decimal
	MinMoveDown          num.Decimal
	ProbabilityOfTrading num.Decimal
}

func SimpleModelParamsFromProto 

func SimpleModelParamsFromProto(p *proto.SimpleModelParams) *SimpleModelParams

func (SimpleModelParams) DeepClone 

func (s SimpleModelParams) DeepClone() *SimpleModelParams

func (SimpleModelParams) IntoProto 

func (s SimpleModelParams) IntoProto() *proto.SimpleModelParams

func (SimpleModelParams) String 

func (s SimpleModelParams) String() string

type SimpleRiskModel 

type SimpleRiskModel struct {
	Params *SimpleModelParams
}

func (SimpleRiskModel) IntoProto 

func (s SimpleRiskModel) IntoProto() *proto.SimpleRiskModel

func (SimpleRiskModel) String 

func (s SimpleRiskModel) String() string

type SimpleSpamPolicy 

type SimpleSpamPolicy struct {
	PolicyName      string
	PartyToCount    []*PartyCount
	BannedParty     []*BannedParty
	CurrentEpochSeq uint64
}

func SimpleSpamPolicyFromProto 

func SimpleSpamPolicyFromProto(ssp *snapshot.SimpleSpamPolicy) *SimpleSpamPolicy

func (*SimpleSpamPolicy) IntoProto 

func (ssp *SimpleSpamPolicy) IntoProto() *snapshot.SimpleSpamPolicy

type Snapshot 

type Snapshot struct {
	Format SnapshotFormat
	Height uint64    // the block-height of the snapshot
	Hash   []byte    // the hash of the snapshot (the root hash of the AVL tree)
	Meta   *Metadata // the AVL tree metadata
	// Metadata []byte     // the above metadata serialised
	Nodes []*Payload // the snapshot payloads in the tree (always leaf nodes)

	// Chunk stuff
	Chunks     uint32
	DataChunks []*Chunk
	ByteChunks [][]byte
	ChunksSeen uint32
	// contains filtered or unexported fields
}

func SnapshotFromTM 

func SnapshotFromTM(tms *tmtypes.Snapshot) (*Snapshot, error)

func SnapshotFromTree 

func SnapshotFromTree(tree *iavl.ImmutableTree) (*Snapshot, error)

SnapshotFromTree traverses the given avl tree and represents it as a Snapshot.

func (Snapshot) GetMissing 

func (s Snapshot) GetMissing() []uint32

func (Snapshot) GetRawChunk 

func (s Snapshot) GetRawChunk(idx uint32) (*RawChunk, error)

func (*Snapshot) LoadChunk 

func (s *Snapshot) LoadChunk(chunk *RawChunk) error

func (Snapshot) Ready 

func (s Snapshot) Ready() bool

func (Snapshot) ToTM 

func (s Snapshot) ToTM() (*tmtypes.Snapshot, error)

func (*Snapshot) TreeFromSnapshot 

func (s *Snapshot) TreeFromSnapshot(tree *iavl.MutableTree) error

TreeFromSnapshot takes the given snapshot data and creates a avl tree from it.

func (*Snapshot) ValidateMeta 

func (s *Snapshot) ValidateMeta(other *Snapshot) error

type SnapshotFormat 

type SnapshotFormat = snapshot.Format

func SnapshotFormatFromU32 

func SnapshotFormatFromU32(f uint32) (SnapshotFormat, error)

type SnapshotNamespace 

type SnapshotNamespace string
const (
	AppSnapshot                    SnapshotNamespace = "app"
	AssetsSnapshot                 SnapshotNamespace = "assets"
	WitnessSnapshot                SnapshotNamespace = "witness" // Must be done before any engine that call RestoreResource
	BankingSnapshot                SnapshotNamespace = "banking"
	CheckpointSnapshot             SnapshotNamespace = "checkpoint"
	CollateralSnapshot             SnapshotNamespace = "collateral"
	NetParamsSnapshot              SnapshotNamespace = "netparams"
	DelegationSnapshot             SnapshotNamespace = "delegation"
	GovernanceSnapshot             SnapshotNamespace = "governance"
	PositionsSnapshot              SnapshotNamespace = "positions"
	MatchingSnapshot               SnapshotNamespace = "matching"
	ExecutionSnapshot              SnapshotNamespace = "execution"
	EpochSnapshot                  SnapshotNamespace = "epoch"
	StakingSnapshot                SnapshotNamespace = "staking"
	IDGenSnapshot                  SnapshotNamespace = "idgenerator"
	RewardSnapshot                 SnapshotNamespace = "rewards"
	SpamSnapshot                   SnapshotNamespace = "spam"
	LimitSnapshot                  SnapshotNamespace = "limits"
	NotarySnapshot                 SnapshotNamespace = "notary"
	StakeVerifierSnapshot          SnapshotNamespace = "stakeverifier"
	EventForwarderSnapshot         SnapshotNamespace = "eventforwarder"
	TopologySnapshot               SnapshotNamespace = "topology"
	LiquiditySnapshot              SnapshotNamespace = "liquidity"
	LiquidityTargetSnapshot        SnapshotNamespace = "liquiditytarget"
	FloatingPointConsensusSnapshot SnapshotNamespace = "floatingpoint"
	MarketActivityTrackerSnapshot  SnapshotNamespace = "marketActivityTracker"
	ERC20MultiSigTopologySnapshot  SnapshotNamespace = "erc20multisigtopology"
	PoWSnapshot                    SnapshotNamespace = "pow"
	ProtocolUpgradeSnapshot        SnapshotNamespace = "protocolUpgradeProposals"
	SettlementSnapshot             SnapshotNamespace = "settlement"

	MaxChunkSize   = 16 * 1000 * 1000 // technically 16 * 1024 * 1024, but you know
	IdealChunkSize = 10 * 1000 * 1000 // aim for 10MB
)

func (SnapshotNamespace) String 

func (n SnapshotNamespace) String() string

type Spot 

type Spot struct {
	Name       string
	BaseAsset  string
	QuoteAsset string
}

func SpotFromProto 

func SpotFromProto(s *proto.Spot) *Spot

func (Spot) IntoProto 

func (s Spot) IntoProto() *proto.Spot

func (Spot) String 

func (s Spot) String() string

type SpotProduct 

type SpotProduct struct {
	Name       string
	BaseAsset  string
	QuoteAsset string
}

func (SpotProduct) Assets 

func (f SpotProduct) Assets() []string

func (SpotProduct) DeepClone 

func (f SpotProduct) DeepClone() *SpotProduct

func (SpotProduct) IntoProto 

func (f SpotProduct) IntoProto() *furypb.SpotProduct

func (SpotProduct) String 

func (f SpotProduct) String() string

type StakeDeposited 

type StakeDeposited struct {
	BlockNumber, LogIndex uint64
	TxID                  string // hash

	ID              string
	FuryPubKey      string
	EthereumAddress string
	Amount          *num.Uint
	BlockTime       int64
}

func StakeDepositedFromProto 

func StakeDepositedFromProto(
	s *vgproto.StakeDeposited,
	blockNumber, logIndex uint64,
	txID, id string,
) (*StakeDeposited, error)

func (*StakeDeposited) IntoStakeLinking 

func (s *StakeDeposited) IntoStakeLinking() *StakeLinking

func (StakeDeposited) String 

func (s StakeDeposited) String() string

type StakeLinking 

type StakeLinking struct {
	ID              string
	Type            StakeLinkingType
	TS              int64
	Party           string
	Amount          *num.Uint
	Status          StakeLinkingStatus
	FinalizedAt     int64
	TxHash          string
	BlockHeight     uint64
	BlockTime       int64
	LogIndex        uint64
	EthereumAddress string
}

func StakeLinkingFromProto 

func StakeLinkingFromProto(sl *eventspb.StakeLinking) *StakeLinking

func (StakeLinking) Hash 

func (s StakeLinking) Hash() string

func (*StakeLinking) IntoProto 

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

func (*StakeLinking) String 

func (s *StakeLinking) String() string

type StakeLinkingStatus 

type StakeLinkingStatus = eventspb.StakeLinking_Status

type StakeLinkingType 

type StakeLinkingType = eventspb.StakeLinking_Type

type StakeRemoved 

type StakeRemoved struct {
	BlockNumber, LogIndex uint64
	TxID                  string // hash

	ID              string
	FuryPubKey      string
	EthereumAddress string
	Amount          *num.Uint
	BlockTime       int64
}

func StakeRemovedFromProto 

func StakeRemovedFromProto(
	s *vgproto.StakeRemoved,
	blockNumber, logIndex uint64,
	txID, id string,
) (*StakeRemoved, error)

func (*StakeRemoved) IntoStakeLinking 

func (s *StakeRemoved) IntoStakeLinking() *StakeLinking

func (StakeRemoved) String 

func (s StakeRemoved) String() string

type StakeScoreParams 

type StakeScoreParams struct {
	MinVal                 num.Decimal
	CompLevel              num.Decimal
	OptimalStakeMultiplier num.Decimal
}

type StakeTotalSupply 

type StakeTotalSupply struct {
	TokenAddress string
	TotalSupply  *num.Uint
}

func StakeTotalSupplyFromProto 

func StakeTotalSupplyFromProto(s *vgproto.StakeTotalSupply) (*StakeTotalSupply, error)

func (*StakeTotalSupply) IntoProto 

func (s *StakeTotalSupply) IntoProto() *vgproto.StakeTotalSupply

func (*StakeTotalSupply) String 

func (s *StakeTotalSupply) String() string

type StakingAccount 

type StakingAccount struct {
	Party   string
	Balance *num.Uint
	Events  []*StakeLinking
}

func StakingAccountFromProto 

func StakingAccountFromProto(sa *snapshot.StakingAccount) *StakingAccount

func (StakingAccount) IntoProto 

func (s StakingAccount) IntoProto() *snapshot.StakingAccount

type StakingAccounts 

type StakingAccounts struct {
	Accounts                []*StakingAccount
	StakingAssetTotalSupply *num.Uint
}

func StakingAccountsFromProto 

func StakingAccountsFromProto(sa *snapshot.StakingAccounts) *StakingAccounts

func (StakingAccounts) IntoProto 

func (s StakingAccounts) IntoProto() *snapshot.StakingAccounts

type StateProvider 

type StateProvider interface {
	Namespace() SnapshotNamespace
	Keys() []string
	// NB: GetState must be threadsafe as it may be called from multiple goroutines concurrently!
	GetState(key string) ([]byte, []StateProvider, error)
	LoadState(ctx context.Context, pl *Payload) ([]StateProvider, error)
	Stopped() bool
}

StateProvider - not a huge fan of this interface being here, but it ensures that the state providers don't have to import the snapshot package

type Stringer 

type Stringer interface {
	String() string
}

type SuccessorConfig 

type SuccessorConfig struct {
	ParentID              string
	InsurancePoolFraction num.Decimal
}

func SuccessorConfigFromProto 

func SuccessorConfigFromProto(p *furypb.SuccessorConfiguration) *SuccessorConfig

func (*SuccessorConfig) IntoProto 

func (s *SuccessorConfig) IntoProto() *furypb.SuccessorConfiguration

type Tags 

type Tags []string

func (Tags) String 

func (t Tags) String() string

type TargetStakeParameters 

type TargetStakeParameters struct {
	TimeWindow    int64
	ScalingFactor num.Decimal
}

func TargetStakeParametersFromProto 

func TargetStakeParametersFromProto(p *proto.TargetStakeParameters) *TargetStakeParameters

func (TargetStakeParameters) DeepClone 

func (t TargetStakeParameters) DeepClone() *TargetStakeParameters

func (TargetStakeParameters) IntoProto 

func (t TargetStakeParameters) IntoProto() *proto.TargetStakeParameters

func (TargetStakeParameters) String 

func (t TargetStakeParameters) String() string

type Topology 

type Topology struct {
	ValidatorData                  []*snapshot.ValidatorState
	ChainValidators                []string
	PendingPubKeyRotations         []*snapshot.PendingKeyRotation
	PendingEthereumKeyRotations    []*snapshot.PendingEthereumKeyRotation
	UnresolvedEthereumKeyRotations []*snapshot.PendingEthereumKeyRotation
	Signatures                     *snapshot.ToplogySignatures
	ValidatorPerformance           *snapshot.ValidatorPerformance
}

type TradableInstrument 

type TradableInstrument struct {
	Instrument       *Instrument
	MarginCalculator *MarginCalculator
	RiskModel        isTRM
	// contains filtered or unexported fields
}

func TradableInstrumentFromProto 

func TradableInstrumentFromProto(ti *proto.TradableInstrument) *TradableInstrument

func (TradableInstrument) DeepClone 

func (t TradableInstrument) DeepClone() *TradableInstrument

func (TradableInstrument) GetLogNormalRiskModel 

func (t TradableInstrument) GetLogNormalRiskModel() *LogNormalRiskModel

func (TradableInstrument) GetSimpleRiskModel 

func (t TradableInstrument) GetSimpleRiskModel() *SimpleRiskModel

func (TradableInstrument) IntoProto 

func (t TradableInstrument) IntoProto() *proto.TradableInstrument

func (TradableInstrument) String 

func (t TradableInstrument) String() string

type TradableInstrumentLogNormalRiskModel 

type TradableInstrumentLogNormalRiskModel struct {
	LogNormalRiskModel *LogNormalRiskModel
}

func TradableInstrumentLogNormalFromProto 

func TradableInstrumentLogNormalFromProto(p *proto.TradableInstrument_LogNormalRiskModel) *TradableInstrumentLogNormalRiskModel

func (TradableInstrumentLogNormalRiskModel) Equal 

func (t TradableInstrumentLogNormalRiskModel) Equal(trm isTRM) bool

func (TradableInstrumentLogNormalRiskModel) IntoProto 

func (t TradableInstrumentLogNormalRiskModel) IntoProto() *proto.TradableInstrument_LogNormalRiskModel

func (TradableInstrumentLogNormalRiskModel) String 

func (t TradableInstrumentLogNormalRiskModel) String() string

type TradableInstrumentSimpleRiskModel 

type TradableInstrumentSimpleRiskModel struct {
	SimpleRiskModel *SimpleRiskModel
}

func TradableInstrumentSimpleFromProto 

func TradableInstrumentSimpleFromProto(p *proto.TradableInstrument_SimpleRiskModel) *TradableInstrumentSimpleRiskModel

func (TradableInstrumentSimpleRiskModel) Equal 

func (t TradableInstrumentSimpleRiskModel) Equal(trm isTRM) bool

Equal returns true if the risk models match.

func (TradableInstrumentSimpleRiskModel) IntoProto 

func (t TradableInstrumentSimpleRiskModel) IntoProto() *proto.TradableInstrument_SimpleRiskModel

func (TradableInstrumentSimpleRiskModel) String 

func (t TradableInstrumentSimpleRiskModel) String() string

type Trade 

type Trade struct {
	ID                 string
	MarketID           string
	Price              *num.Uint
	MarketPrice        *num.Uint
	Size               uint64
	Buyer              string
	Seller             string
	Aggressor          Side
	BuyOrder           string
	SellOrder          string
	Timestamp          int64
	Type               TradeType
	BuyerFee           *Fee
	SellerFee          *Fee
	BuyerAuctionBatch  uint64
	SellerAuctionBatch uint64
}

func (*Trade) IntoProto 

func (t *Trade) IntoProto() *proto.Trade

func (*Trade) SetIDs 

func (t *Trade) SetIDs(tradeID string, aggressive, passive *Order)

func (Trade) String 

func (t Trade) String() string

type TradeType 

type TradeType = proto.Trade_Type
const (
	// Default value, always invalid.
	TradeTypeUnspecified TradeType = proto.Trade_TYPE_UNSPECIFIED
	// Normal trading between two parties.
	TradeTypeDefault TradeType = proto.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 = proto.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 = proto.Trade_TYPE_NETWORK_CLOSE_OUT_BAD
)

type Trades 

type Trades []*Trade

func (Trades) IntoProto 

func (t Trades) IntoProto() []*proto.Trade

type Transfer 

type Transfer struct {
	Owner     string
	Amount    *FinancialAmount
	Type      TransferType
	MinAmount *num.Uint
	Market    string
}

func TransferFromProto 

func TransferFromProto(p *proto.Transfer) (*Transfer, error)

func (*Transfer) Clone 

func (t *Transfer) Clone() *Transfer

func (*Transfer) IntoProto 

func (t *Transfer) IntoProto() *proto.Transfer

func (*Transfer) Merge 

func (t *Transfer) Merge(oth *Transfer) *Transfer

Merge creates a new Transfer.

func (*Transfer) String 

func (t *Transfer) String() string

type TransferBase 

type TransferBase struct {
	ID              string
	From            string
	FromAccountType AccountType
	To              string
	ToAccountType   AccountType
	Asset           string
	Amount          *num.Uint
	Reference       string
	Status          TransferStatus
	Timestamp       time.Time
}

func (*TransferBase) IsValid 

func (t *TransferBase) IsValid() error

type TransferCommandKind 

type TransferCommandKind int
const (
	TransferCommandKindOneOff TransferCommandKind = iota
	TransferCommandKindRecurring
)

type TransferFunds 

type TransferFunds struct {
	Kind      TransferCommandKind
	OneOff    *OneOffTransfer
	Recurring *RecurringTransfer
}

Just a wrapper, use the Kind on a switch to access the proper value.

func NewTransferFromProto 

func NewTransferFromProto(id, from string, tf *commandspb.Transfer) (*TransferFunds, error)

func (*TransferFunds) IntoEvent 

func (t *TransferFunds) IntoEvent(reason *string) *eventspb.Transfer

type TransferRequest 

type TransferRequest struct {
	FromAccount []*Account
	ToAccount   []*Account
	Amount      *num.Uint
	MinAmount   *num.Uint
	Asset       string
	// Reference   string
	Type TransferType
}

func (*TransferRequest) IntoProto 

func (t *TransferRequest) IntoProto() *proto.TransferRequest

type TransferStatus 

type TransferStatus = eventspb.Transfer_Status
const (
	// Default value.
	TransferStatsUnspecified TransferStatus = eventspb.Transfer_STATUS_UNSPECIFIED
	// A pending transfer.
	TransferStatusPending TransferStatus = eventspb.Transfer_STATUS_PENDING
	// A finished transfer.
	TransferStatusDone TransferStatus = eventspb.Transfer_STATUS_DONE
	// A rejected transfer.
	TransferStatusRejected TransferStatus = eventspb.Transfer_STATUS_REJECTED
	// A stopped transfer.
	TransferStatusStopped TransferStatus = eventspb.Transfer_STATUS_STOPPED
	// A cancelled transfer.
	TransferStatusCancelled TransferStatus = eventspb.Transfer_STATUS_CANCELLED
)

type TransferType 

type TransferType = proto.TransferType
const (
	// Default value, always invalid.
	TransferTypeUnspecified TransferType = proto.TransferType_TRANSFER_TYPE_UNSPECIFIED
	// Loss.
	TransferTypeLoss TransferType = proto.TransferType_TRANSFER_TYPE_LOSS
	// Win.
	TransferTypeWin TransferType = proto.TransferType_TRANSFER_TYPE_WIN
	// Mark to market loss.
	TransferTypeMTMLoss TransferType = proto.TransferType_TRANSFER_TYPE_MTM_LOSS
	// Mark to market win.
	TransferTypeMTMWin TransferType = proto.TransferType_TRANSFER_TYPE_MTM_WIN
	// Margin too low.
	TransferTypeMarginLow TransferType = proto.TransferType_TRANSFER_TYPE_MARGIN_LOW
	// Margin too high.
	TransferTypeMarginHigh TransferType = proto.TransferType_TRANSFER_TYPE_MARGIN_HIGH
	// Margin was confiscated.
	TransferTypeMarginConfiscated TransferType = proto.TransferType_TRANSFER_TYPE_MARGIN_CONFISCATED
	// Pay maker fee.
	TransferTypeMakerFeePay TransferType = proto.TransferType_TRANSFER_TYPE_MAKER_FEE_PAY
	// Receive maker fee.
	TransferTypeMakerFeeReceive TransferType = proto.TransferType_TRANSFER_TYPE_MAKER_FEE_RECEIVE
	// Pay infrastructure fee.
	TransferTypeInfrastructureFeePay TransferType = proto.TransferType_TRANSFER_TYPE_INFRASTRUCTURE_FEE_PAY
	// Receive infrastructure fee.
	TransferTypeInfrastructureFeeDistribute TransferType = proto.TransferType_TRANSFER_TYPE_INFRASTRUCTURE_FEE_DISTRIBUTE
	// Pay liquidity fee.
	TransferTypeLiquidityFeePay TransferType = proto.TransferType_TRANSFER_TYPE_LIQUIDITY_FEE_PAY
	// Receive liquidity fee.
	TransferTypeLiquidityFeeDistribute TransferType = proto.TransferType_TRANSFER_TYPE_LIQUIDITY_FEE_DISTRIBUTE
	// Bond too low.
	TransferTypeBondLow TransferType = proto.TransferType_TRANSFER_TYPE_BOND_LOW
	// Bond too high.
	TransferTypeBondHigh TransferType = proto.TransferType_TRANSFER_TYPE_BOND_HIGH
	// Actual withdraw from system.
	TransferTypeWithdraw TransferType = proto.TransferType_TRANSFER_TYPE_WITHDRAW
	// Deposit funds.
	TransferTypeDeposit TransferType = proto.TransferType_TRANSFER_TYPE_DEPOSIT
	// Bond slashing.
	TransferTypeBondSlashing TransferType = proto.TransferType_TRANSFER_TYPE_BOND_SLASHING
	// Reward payout.
	TransferTypeRewardPayout               TransferType = proto.TransferType_TRANSFER_TYPE_REWARD_PAYOUT
	TransferTypeTransferFundsSend          TransferType = proto.TransferType_TRANSFER_TYPE_TRANSFER_FUNDS_SEND
	TransferTypeTransferFundsDistribute    TransferType = proto.TransferType_TRANSFER_TYPE_TRANSFER_FUNDS_DISTRIBUTE
	TransferTypeClearAccount               TransferType = proto.TransferType_TRANSFER_TYPE_CLEAR_ACCOUNT
	TransferTypeCheckpointBalanceRestore   TransferType = proto.TransferType_TRANSFER_TYPE_CHECKPOINT_BALANCE_RESTORE
	TransferTypeSuccessorInsuranceFraction TransferType = proto.TransferType_TRANSFER_TYPE_SUCCESSOR_INSURANCE_FRACTION
	TransferTypeSpot                       TransferType = proto.TransferType_TRANSFER_TYPE_SPOT
	TransferTypeHoldingAccount             TransferType = proto.TransferType_TRANSFER_TYPE_HOLDING_LOCK
	TransferTypeReleaseHoldingAccount      TransferType = proto.TransferType_TRANSFER_TYPE_HOLDING_RELEASE
)

type Undelegate 

type Undelegate struct {
	NodeID string
	Amount *num.Uint
	Method string
}

func (Undelegate) IntoProto 

func (u Undelegate) IntoProto() *commandspb.UndelegateSubmission

func (Undelegate) String 

func (u Undelegate) String() string

type UpdateAsset 

type UpdateAsset struct {
	AssetID string
	Changes *AssetDetailsUpdate
}

func (UpdateAsset) DeepClone 

func (a UpdateAsset) DeepClone() *UpdateAsset

func (*UpdateAsset) GetChanges 

func (a *UpdateAsset) GetChanges() *AssetDetailsUpdate

func (UpdateAsset) IntoProto 

func (a UpdateAsset) IntoProto() *furypb.UpdateAsset

func (UpdateAsset) String 

func (a UpdateAsset) String() string

func (UpdateAsset) Validate 

func (a UpdateAsset) Validate() (ProposalError, error)

type UpdateFutureProduct 

type UpdateFutureProduct struct {
	QuoteName                           string
	DataSourceSpecForSettlementData     DataSourceDefinition
	DataSourceSpecForTradingTermination DataSourceDefinition
	DataSourceSpecBinding               *DataSourceSpecBindingForFuture
}

func (UpdateFutureProduct) DeepClone 

func (f UpdateFutureProduct) DeepClone() *UpdateFutureProduct

func (UpdateFutureProduct) IntoProto 

func (f UpdateFutureProduct) IntoProto() *furypb.UpdateFutureProduct

func (UpdateFutureProduct) String 

func (f UpdateFutureProduct) String() string

type UpdateInstrumentConfiguration 

type UpdateInstrumentConfiguration struct {
	Code string
	// *UpdateInstrumentConfigurationFuture
	Product updateInstrumentConfigurationProduct
}

func UpdateInstrumentConfigurationFromProto 

func UpdateInstrumentConfigurationFromProto(p *furypb.UpdateInstrumentConfiguration) *UpdateInstrumentConfiguration

func (UpdateInstrumentConfiguration) DeepClone 

func (i UpdateInstrumentConfiguration) DeepClone() *UpdateInstrumentConfiguration

func (UpdateInstrumentConfiguration) IntoProto 

func (i UpdateInstrumentConfiguration) IntoProto() *furypb.UpdateInstrumentConfiguration

func (UpdateInstrumentConfiguration) String 

func (i UpdateInstrumentConfiguration) String() string

type UpdateInstrumentConfigurationFuture 

type UpdateInstrumentConfigurationFuture struct {
	Future *UpdateFutureProduct
}

func (UpdateInstrumentConfigurationFuture) DeepClone 

func (i UpdateInstrumentConfigurationFuture) DeepClone() updateInstrumentConfigurationProduct

func (UpdateInstrumentConfigurationFuture) IntoProto 

func (i UpdateInstrumentConfigurationFuture) IntoProto() *furypb.UpdateInstrumentConfiguration_Future

func (UpdateInstrumentConfigurationFuture) String 

func (i UpdateInstrumentConfigurationFuture) String() string

type UpdateMarket 

type UpdateMarket struct {
	MarketID string
	Changes  *UpdateMarketConfiguration
}

func (UpdateMarket) DeepClone 

func (n UpdateMarket) DeepClone() *UpdateMarket

func (UpdateMarket) IntoProto 

func (n UpdateMarket) IntoProto() *furypb.UpdateMarket

func (UpdateMarket) String 

func (n UpdateMarket) String() string

type UpdateMarketConfiguration 

type UpdateMarketConfiguration struct {
	Instrument                    *UpdateInstrumentConfiguration
	Metadata                      []string
	PriceMonitoringParameters     *PriceMonitoringParameters
	LiquidityMonitoringParameters *LiquidityMonitoringParameters
	RiskParameters                updateRiskParams
	LpPriceRange                  num.Decimal
	LinearSlippageFactor          num.Decimal
	QuadraticSlippageFactor       num.Decimal
}

func UpdateMarketConfigurationFromProto 

func UpdateMarketConfigurationFromProto(p *furypb.UpdateMarketConfiguration) (*UpdateMarketConfiguration, error)

func (UpdateMarketConfiguration) DeepClone 

func (n UpdateMarketConfiguration) DeepClone() *UpdateMarketConfiguration

func (UpdateMarketConfiguration) IntoProto 

func (n UpdateMarketConfiguration) IntoProto() *furypb.UpdateMarketConfiguration

func (UpdateMarketConfiguration) String 

func (n UpdateMarketConfiguration) String() string

type UpdateMarketConfigurationLogNormal 

type UpdateMarketConfigurationLogNormal struct {
	LogNormal *LogNormalRiskModel
}

func UpdateMarketConfigurationLogNormalFromProto 

func UpdateMarketConfigurationLogNormalFromProto(p *furypb.UpdateMarketConfiguration_LogNormal) *UpdateMarketConfigurationLogNormal

func (UpdateMarketConfigurationLogNormal) DeepClone 

func (n UpdateMarketConfigurationLogNormal) DeepClone() updateRiskParams

func (UpdateMarketConfigurationLogNormal) IntoProto 

func (n UpdateMarketConfigurationLogNormal) IntoProto() *furypb.UpdateMarketConfiguration_LogNormal

func (UpdateMarketConfigurationLogNormal) String 

func (n UpdateMarketConfigurationLogNormal) String() string

type UpdateMarketConfigurationSimple 

type UpdateMarketConfigurationSimple struct {
	Simple *SimpleModelParams
}

func UpdateMarketConfigurationSimpleFromProto 

func UpdateMarketConfigurationSimpleFromProto(p *furypb.UpdateMarketConfiguration_Simple) *UpdateMarketConfigurationSimple

func (UpdateMarketConfigurationSimple) DeepClone 

func (n UpdateMarketConfigurationSimple) DeepClone() updateRiskParams

func (UpdateMarketConfigurationSimple) IntoProto 

func (n UpdateMarketConfigurationSimple) IntoProto() *furypb.UpdateMarketConfiguration_Simple

func (UpdateMarketConfigurationSimple) String 

func (n UpdateMarketConfigurationSimple) String() string

type UpdateNetworkParameter 

type UpdateNetworkParameter struct {
	Changes *NetworkParameter
}

func (UpdateNetworkParameter) DeepClone 

func (n UpdateNetworkParameter) DeepClone() *UpdateNetworkParameter

func (UpdateNetworkParameter) IntoProto 

func (n UpdateNetworkParameter) IntoProto() *furypb.UpdateNetworkParameter

func (UpdateNetworkParameter) String 

func (n UpdateNetworkParameter) String() string

type UpdateSpotMarket 

type UpdateSpotMarket struct {
	MarketID string
	Changes  *UpdateSpotMarketConfiguration
}

func (UpdateSpotMarket) DeepClone 

func (n UpdateSpotMarket) DeepClone() *UpdateSpotMarket

func (UpdateSpotMarket) IntoProto 

func (n UpdateSpotMarket) IntoProto() *furypb.UpdateSpotMarket

func (UpdateSpotMarket) String 

func (n UpdateSpotMarket) String() string

type UpdateSpotMarketConfiguration 

type UpdateSpotMarketConfiguration struct {
	Instrument                *UpdateInstrumentConfiguration
	Metadata                  []string
	PriceMonitoringParameters *PriceMonitoringParameters
	TargetStakeParameters     *TargetStakeParameters
	RiskParameters            updateRiskParams
}

func UpdateSpotMarketConfigurationFromProto 

func UpdateSpotMarketConfigurationFromProto(p *furypb.UpdateSpotMarketConfiguration) (*UpdateSpotMarketConfiguration, error)

func (UpdateSpotMarketConfiguration) DeepClone 

func (n UpdateSpotMarketConfiguration) DeepClone() *UpdateSpotMarketConfiguration

func (UpdateSpotMarketConfiguration) IntoProto 

func (n UpdateSpotMarketConfiguration) IntoProto() *furypb.UpdateSpotMarketConfiguration

func (UpdateSpotMarketConfiguration) String 

func (n UpdateSpotMarketConfiguration) String() string

type UpdateSpotMarketConfigurationLogNormal 

type UpdateSpotMarketConfigurationLogNormal struct {
	LogNormal *LogNormalRiskModel
}

func UpdateSpotMarketConfigurationLogNormalFromProto 

func UpdateSpotMarketConfigurationLogNormalFromProto(p *furypb.UpdateSpotMarketConfiguration_LogNormal) *UpdateSpotMarketConfigurationLogNormal

func (UpdateSpotMarketConfigurationLogNormal) DeepClone 

func (n UpdateSpotMarketConfigurationLogNormal) DeepClone() updateRiskParams

func (UpdateSpotMarketConfigurationLogNormal) IntoProto 

func (n UpdateSpotMarketConfigurationLogNormal) IntoProto() *furypb.UpdateSpotMarketConfiguration_LogNormal

func (UpdateSpotMarketConfigurationLogNormal) String 

func (n UpdateSpotMarketConfigurationLogNormal) String() string

type UpdateSpotMarketConfigurationSimple 

type UpdateSpotMarketConfigurationSimple struct {
	Simple *SimpleModelParams
}

func UpdateSpotMarketConfigurationSimpleFromProto 

func UpdateSpotMarketConfigurationSimpleFromProto(p *furypb.UpdateSpotMarketConfiguration_Simple) *UpdateSpotMarketConfigurationSimple

func (UpdateSpotMarketConfigurationSimple) DeepClone 

func (n UpdateSpotMarketConfigurationSimple) DeepClone() updateRiskParams

func (UpdateSpotMarketConfigurationSimple) IntoProto 

func (n UpdateSpotMarketConfigurationSimple) IntoProto() *furypb.UpdateSpotMarketConfiguration_Simple

func (UpdateSpotMarketConfigurationSimple) String 

func (n UpdateSpotMarketConfigurationSimple) String() string

type UpgradeStatus 

type UpgradeStatus struct {
	AcceptedReleaseInfo *ReleaseInfo
	ReadyToUpgrade      bool
}

type ValidatorData 

type ValidatorData struct {
	NodeID            string
	PubKey            string
	StakeByDelegators *num.Uint
	SelfStake         *num.Uint
	Delegators        map[string]*num.Uint
	TmPubKey          string
}

ValidatorData is delegation data for validator.

type ValidatorVotingPower 

type ValidatorVotingPower struct {
	TmPubKey    string
	VotingPower int64
}

ValidatorVotingPower is the scaled voting power for the given tm key.

type Vote 

type Vote struct {
	// PartyID is the party that casted the vote.
	PartyID string
	// ProposalID is the proposal identifier concerned by the vote.
	ProposalID string
	// Value is the actual position of the vote: yes or no.
	Value VoteValue
	// Timestamp is the date and time (in nanoseconds) at which the vote has
	// been casted.
	Timestamp int64
	// TotalGovernanceTokenBalance is the total number of tokens hold by the
	// party that casted the vote.
	TotalGovernanceTokenBalance *num.Uint
	// TotalGovernanceTokenWeight is the weight of the vote compared to the
	// total number of governance token.
	TotalGovernanceTokenWeight num.Decimal
	// TotalEquityLikeShareWeight is the weight of the vote compared to the
	// total number of equity-like share on the market.
	TotalEquityLikeShareWeight num.Decimal
}

Vote represents a governance vote casted by a party for a given proposal.

func VoteFromProto 

func VoteFromProto(v *furypb.Vote) (*Vote, error)

func (Vote) IntoProto 

func (v Vote) IntoProto() *furypb.Vote

type VoteSpamPolicy 

type VoteSpamPolicy struct {
	PartyProposalVoteCount  []*PartyProposalVoteCount
	BannedParty             []*BannedParty
	RecentBlocksRejectStats []*BlockRejectStats
	CurrentBlockIndex       uint64
	LastIncreaseBlock       uint64
	CurrentEpochSeq         uint64
	MinVotingTokensFactor   *num.Uint
}

func VoteSpamPolicyFromProto 

func VoteSpamPolicyFromProto(vsp *snapshot.VoteSpamPolicy) *VoteSpamPolicy

func (*VoteSpamPolicy) IntoProto 

func (vsp *VoteSpamPolicy) IntoProto() *snapshot.VoteSpamPolicy

type VoteSubmission 

type VoteSubmission struct {
	// The ID of the proposal to vote for.
	ProposalID string
	// The actual value of the vote
	Value VoteValue
}

func NewVoteSubmissionFromProto 

func NewVoteSubmissionFromProto(p *commandspb.VoteSubmission) *VoteSubmission

func (VoteSubmission) IntoProto 

func (v VoteSubmission) IntoProto() *commandspb.VoteSubmission

func (VoteSubmission) String 

func (v VoteSubmission) String() string

type VoteValue 

type VoteValue = furypb.Vote_Value
const (
	// VoteValueUnspecified Default value, always invalid.
	VoteValueUnspecified VoteValue = furypb.Vote_VALUE_UNSPECIFIED
	// VoteValueNo represents a vote against the proposal.
	VoteValueNo VoteValue = furypb.Vote_VALUE_NO
	// VoteValueYes represents a vote in favour of the proposal.
	VoteValueYes VoteValue = furypb.Vote_VALUE_YES
)

type WithdrawExt 

type WithdrawExt struct {
	Ext isWithdrawExtExt
}

func WithdrawExtFromProto 

func WithdrawExtFromProto(extProto *furypb.WithdrawExt) *WithdrawExt

func (*WithdrawExt) GetErc20 

func (x *WithdrawExt) GetErc20() *WithdrawExtErc20

func (*WithdrawExt) IntoProto 

func (x *WithdrawExt) IntoProto() *furypb.WithdrawExt

func (*WithdrawExt) String 

func (x *WithdrawExt) String() string

type WithdrawExtErc20 

type WithdrawExtErc20 struct {
	Erc20 *Erc20WithdrawExt
}

func WithdrawExtErc20FromProto 

func WithdrawExtErc20FromProto(erc20 *furypb.WithdrawExt_Erc20) *WithdrawExtErc20

func (*WithdrawExtErc20) GetReceiverAddress 

func (x *WithdrawExtErc20) GetReceiverAddress() string

func (*WithdrawExtErc20) IntoProto 

func (x *WithdrawExtErc20) IntoProto() *furypb.WithdrawExt_Erc20

func (*WithdrawExtErc20) String 

func (x *WithdrawExtErc20) String() string

type WithdrawSubmission 

type WithdrawSubmission struct {
	// The amount to be withdrawn
	Amount *num.Uint
	// The asset we want to withdraw
	Asset string
	// Foreign chain specifics
	Ext *WithdrawExt
}

func NewWithdrawSubmissionFromProto 

func NewWithdrawSubmissionFromProto(p *commandspb.WithdrawSubmission) (*WithdrawSubmission, error)

func (WithdrawSubmission) IntoProto 

func (w WithdrawSubmission) IntoProto() *commandspb.WithdrawSubmission

func (WithdrawSubmission) String 

func (w WithdrawSubmission) String() string

type Withdrawal 

type Withdrawal struct {
	// ID Unique identifier for the withdrawal
	ID string
	// PartyID Unique party identifier of the user initiating the withdrawal
	PartyID string
	// Amount The amount to be withdrawn
	Amount *num.Uint
	// Asset The asset we want to withdraw funds from
	Asset string
	// Status The status of the withdrawal
	Status WithdrawalStatus
	// Ref The reference which is used by the foreign chain
	// to refer to this withdrawal
	Ref string
	// TxHash The hash of the foreign chain for this transaction
	TxHash string
	// CreationDate Timestamp for when the network started to process this withdrawal
	CreationDate int64
	// WithdrawalDate Timestamp for when the withdrawal was finalised by the network
	WithdrawalDate int64
	// Ext Foreign chain specifics
	Ext *WithdrawExt
}

func WithdrawalFromProto 

func WithdrawalFromProto(w *furypb.Withdrawal) *Withdrawal

func (*Withdrawal) IntoProto 

func (w *Withdrawal) IntoProto() *furypb.Withdrawal

type WithdrawalStatus 

type WithdrawalStatus = furypb.Withdrawal_Status
const (
	// WithdrawalStatusUnspecified Default value, always invalid.
	WithdrawalStatusUnspecified WithdrawalStatus = 0
	// WithdrawalStatusOpen The withdrawal is open and being processed by the network.
	WithdrawalStatusOpen WithdrawalStatus = 1
	// WithdrawalStatusRejected The withdrawal have been rejected.
	WithdrawalStatusRejected WithdrawalStatus = 2
	// WithdrawalStatusFinalized The withdrawal went through and is fully finalised, the funds are removed from the
	// Fury network and are unlocked on the foreign chain bridge, for example, on the Ethereum network.
	WithdrawalStatusFinalized WithdrawalStatus = 3
)

type Witness 

type Witness struct {
	Resources []*Resource
}

Source Files

View all Source files

Directories

Path Synopsis
Package mocks is a generated GoMock package.
 Package mocks is a generated GoMock package.

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.