domain

Documentation

Index

• Variables
• func GetDenomPrecisions(ctx context.Context) (map[string]int, error)
• type AssetList
• type AssetListGetter
  • func NewAssetListGetter() AssetListGetter
• type AssetListGetterImpl
  • func (*AssetListGetterImpl) GetDenomPrecisions(ctx context.Context) (map[string]int, error)
• type BankKeeper
• type BlockPoolUpdateTracker
• type BlockPools
• type ConcentratedKeeper
• type CosmWasmPoolKeeper
• type Ingester
• type NodeStatusChecker
• type PoolIngester
• type PoolKeeper
• type PoolManagerKeeper
• type ProtorevKeeper
• type SQSIngestKeepers
• type Token

Variables

var (
	// sqs_sync_check_error
	//
	// counter that is increased if node sync check fails when processing the first block
	//
	// Has the following labels:
	// * err - the error returned
	// * height - the height of the block being processed
	SQSNodeSyncCheckErrorMetricName = "sqs_sync_check_error"

	// sqs_process_block_error
	//
	// counter that is increased if ingest process block fails with error.
	//
	// Has the following labels:
	// * msg - the error returned
	// * height - the height of the block being processed
	SQSProcessBlockErrorMetricName = "sqs_process_block_error"

	// sqs_process_block_panic
	//
	// counter that is increased if ingest process block fails with panic.
	//
	// Has the following labels:
	// * msg - the error returned
	// * height - the height of the block being processed
	SQSProcessBlockPanicMetricName = "sqs_process_block_panic"
)

var (
	ErrNodeIsSyncing = errors.New("node is syncing, skipping block processing")
)

Functions

func GetDenomPrecisions

func GetDenomPrecisions(ctx context.Context) (map[string]int, error)

GetDenomPrecisions implements domain.TokensUsecase.

Types

type AssetList

type AssetList struct {
	ChainName string `json:"chain_name"`
	Assets    []struct {
		Description string `json:"description"`
		DenomUnits  []struct {
			Denom    string `json:"denom"`
			Exponent int    `json:"exponent"`
		} `json:"denom_units"`
		Base     string        `json:"base"`
		Name     string        `json:"name"`
		Display  string        `json:"display"`
		Symbol   string        `json:"symbol"`
		Traces   []interface{} `json:"traces"`
		LogoURIs struct {
			PNG string `json:"png"`
			SVG string `json:"svg"`
		} `json:"logo_URIs"`
		CoingeckoID string   `json:"coingecko_id"`
		Keywords    []string `json:"keywords"`
	} `json:"assets"`
}

Struct to represent the JSON structure

type AssetListGetter

type AssetListGetter interface {
	GetDenomPrecisions(ctx context.Context) (map[string]int, error)
}

func NewAssetListGetter

func NewAssetListGetter() AssetListGetter

type AssetListGetterImpl

type AssetListGetterImpl struct{}

func (*AssetListGetterImpl) GetDenomPrecisions

func (*AssetListGetterImpl) GetDenomPrecisions(ctx context.Context) (map[string]int, error)

GetDenomPrecisions implements AssetListGetter.

type BankKeeper

type BankKeeper interface {
	GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
}

BankKeeper is an interface for getting bank balances.

type BlockPoolUpdateTracker

type BlockPoolUpdateTracker interface {
	// TrackConcentrated tracks the concentrated pool.
	TrackConcentrated(pool poolmanagertypes.PoolI)

	// TrackConcentratedPoolIDTickChange tracks the concentrated pool ID tick change.
	// Due to internal implementation, it is non-trivial to apply tick changes.
	// As a result, we track the pool ID tick change and read the pool with all of its ticks
	// if at least one tick change was applied within the block.
	TrackConcentratedPoolIDTickChange(poolID uint64)

	// TrackCFMM tracks the CFMM pool.
	TrackCFMM(pool poolmanagertypes.PoolI)

	// TrackCosmWasm tracks the CosmWasm pool.
	TrackCosmWasm(pool poolmanagertypes.PoolI)

	// GetConcentratedPools returns the tracked concentrated pools.
	GetConcentratedPools() []poolmanagertypes.PoolI

	// GetConcentratedPoolIDTickChange returns the tracked concentrated pool ID tick change.
	GetConcentratedPoolIDTickChange() map[uint64]struct{}

	// GetCFMMPools returns the tracked CFMM pools.
	GetCFMMPools() []poolmanagertypes.PoolI

	// GetCosmWasmPools returns the tracked CosmWasm pools.
	GetCosmWasmPools() []poolmanagertypes.PoolI

	// Reset clears the internal state.
	Reset()
}

BlockPoolUpdateTracker is an interface for tracking the pools that were updated in a block. It persists the pools using "Track" methods in its internal state. It tracks the latest pool update, discarding the previous updates. Only on Reset, the internal state is cleared.

type BlockPools

type BlockPools struct {
	// ConcentratedPools are the concentrated pools to be ingested.
	ConcentratedPools []poolmanagertypes.PoolI
	// ConcentratedPoolIDTickChange is the map of pool ID to tick change for concentrated pools.
	// We use these pool IDs to append concentrated pools with all ticks at the end of the block.
	ConcentratedPoolIDTickChange map[uint64]struct{}
	// CosmWasmPools are the CosmWasm pools to be ingested.
	CosmWasmPools []poolmanagertypes.PoolI
	// CFMMPools are the CFMM pools to be ingested.
	CFMMPools []poolmanagertypes.PoolI
}

BlockPools contains the pools to be ingested in a block.

type ConcentratedKeeper

type ConcentratedKeeper interface {
	PoolKeeper
	GetTickLiquidityForFullRange(ctx sdk.Context, poolId uint64) ([]queryproto.LiquidityDepthWithRange, int64, error)
	GetConcentratedPoolById(ctx sdk.Context, poolId uint64) (concentratedtypes.ConcentratedPoolExtension, error)
}

ConcentratedKeeper is an interface for the concentrated keeper.

type CosmWasmPoolKeeper

type CosmWasmPoolKeeper interface {
	GetPoolsWithWasmKeeper(ctx sdk.Context) ([]poolmanagertypes.PoolI, error)
}

CosmWasmPoolKeeper is an interface for getting CosmWasm pools from a keeper.

type Ingester

type Ingester interface {
	// ProcessAllBlockData processes the block and ingests data into a sink.
	// Returns error if the ingester fails to ingest data.
	ProcessAllBlockData(ctx sdk.Context) error

	// ProcessChangedBlockData processes only the pools that were changed in the block.
	ProcessChangedBlockData(ctx sdk.Context, changedPools BlockPools) error
}

Ingester is an interface that defines the methods for the ingester. Ingester ingests data into a sink.

type NodeStatusChecker

type NodeStatusChecker interface {
	// IsNodeSyncing checks if the node is syncing.
	// Returns true if the node is syncing, false otherwise.
	// Returns error if the node syncing status cannot be determined.
	IsNodeSyncing(ctx sdk.Context) (bool, error)
}

NodeStatusChecker is an interface for checking the node status.

type PoolIngester

type PoolIngester interface {
	// ProcessPoolState processes the pool state and ingests data into a sink.
	// It appends all updates into a transaction for atomic commit at the end of the block.
	// Returns error if the ingester fails to process pool data.
	ProcessPoolState(ctx sdk.Context, tx repository.Tx, blockPools BlockPools) error
}

PoolIngester is an interface that defines the methods for the pool ingester.

type PoolKeeper

type PoolKeeper interface {
	GetPools(ctx sdk.Context) ([]poolmanagertypes.PoolI, error)
}

PoolKeeper is an interface for getting pools from a keeper.

type PoolManagerKeeper

type PoolManagerKeeper interface {
	RouteCalculateSpotPrice(
		ctx sdk.Context,
		poolId uint64,
		quoteAssetDenom string,
		baseAssetDenom string,
	) (price osmomath.BigDec, err error)

	SwapExactAmountIn(
		ctx sdk.Context,
		sender sdk.AccAddress,
		poolId uint64,
		tokenIn sdk.Coin,
		tokenOutDenom string,
		tokenOutMinAmount osmomath.Int,
	) (tokenOutAmount osmomath.Int, err error)

	RouteGetPoolDenoms(
		ctx sdk.Context,
		poolId uint64,
	) (denoms []string, err error)

	GetTradingPairTakerFee(ctx sdk.Context, denom0, denom1 string) (osmomath.Dec, error)

	MultihopEstimateInGivenExactAmountOut(
		ctx sdk.Context,
		route []poolmanagertypes.SwapAmountOutRoute,
		tokenOut sdk.Coin,
	) (tokenInAmount osmomath.Int, err error)
}

PoolManagerKeeper is an interface for the pool manager keeper.

type ProtorevKeeper

type ProtorevKeeper interface {
	GetPoolForDenomPair(ctx sdk.Context, baseDenom, denomToMatch string) (uint64, error)
}

ProtorevKeeper is an interface for getting the pool for a denom pair.

type SQSIngestKeepers

type SQSIngestKeepers struct {
	GammKeeper         PoolKeeper
	CosmWasmPoolKeeper CosmWasmPoolKeeper
	BankKeeper         BankKeeper
	ProtorevKeeper     ProtorevKeeper
	PoolManagerKeeper  PoolManagerKeeper
	ConcentratedKeeper ConcentratedKeeper
}

Chain keepers required for sqs ingest.

type Token

type Token struct {
	// ChainDenom is the denom used in the chain state.
	ChainDenom string `json:"chain_denom"`
	// HumanDenom is the human readable denom.
	HumanDenom string `json:"human_denom"`
	// Precision is the precision of the token.
	Precision int `json:"precision"`
}

Token represents the token's domain model