Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

entities

package

Go to main page

Versions in this module

v0

v0.5.0

Mar 17, 2023

v0.4.1

Jan 14, 2023

v0.4.0

Dec 26, 2022

v0.1.9

Dec 23, 2022

v0.1.8

Dec 22, 2022

v0.1.7

Sep 5, 2022

Changes in this version

+ const ZeroValueTickIndex

+ const ZeroValueTickInitialized

+ var EmptyTick = Tick

+ var ErrAtOrAboveLargest = errors.New("at or above largest")

+ var ErrBelowSmallest = errors.New("below smallest")

+ var ErrEmptyTickList = errors.New("empty tick list")

+ var ErrInvalidTickIndex = errors.New("invalid tick index")

v0.1.6

Aug 23, 2022

v0.1.5

Jun 6, 2022

v0.1.4

Jun 3, 2022

v0.1.3

Apr 22, 2022

v0.1.2

Apr 13, 2022

v0.1.1

Apr 8, 2022

v0.1.0

Apr 6, 2022

Changes in this version

+ var ErrAllOnSameChain = errors.New("all pools must be on the same chain")

+ var ErrDuplicatePools = errors.New("duplicate pools")

+ var ErrFeeTooHigh = errors.New("Fee too high")

+ var ErrInputCurrencyMismatch = errors.New("input currency mismatch")

+ var ErrInputNotInvolved = errors.New("input token not involved in route")

+ var ErrInvalidAmountForRoute = errors.New("invalid amount for route")

+ var ErrInvalidMaxHops = errors.New("invalid max hops")

+ var ErrInvalidMaxSize = errors.New("invalid max size")

+ var ErrInvalidRecursion = errors.New("invalid recursion")

+ var ErrInvalidSlippageTolerance = errors.New("invalid slippage tolerance")

+ var ErrInvalidSqrtRatioX96 = errors.New("Invalid sqrtRatioX96")

+ var ErrInvalidTickSpacing = errors.New("invalid tick spacing")

+ var ErrMaxSizeExceeded = errors.New("max size exceeded")

+ var ErrNoPools = errors.New("no pools")

+ var ErrOutputCurrencyMismatch = errors.New("output currency mismatch")

+ var ErrOutputNotInvolved = errors.New("output token not involved in route")

+ var ErrPathNotContinuous = errors.New("path not continuous")

+ var ErrRouteNoPools = errors.New("route must have at least one pool")

+ var ErrSorted = errors.New("ticks must be sorted")

+ var ErrSqrtPriceLimitX96TooHigh = errors.New("SqrtPriceLimitX96 too high")

+ var ErrSqrtPriceLimitX96TooLow = errors.New("SqrtPriceLimitX96 too low")

+ var ErrTickLower = errors.New("tick lower error")

+ var ErrTickOrder = errors.New("tick order error")

+ var ErrTickUpper = errors.New("tick upper error")

+ var ErrTokenNotInvolved = errors.New("Token not involved in pool")

+ var ErrTradeHasMultipleRoutes = errors.New("trade has multiple routes")

+ var ErrZeroNet = errors.New("tick net delta must be zero")

+ var ErrZeroTickSpacing = errors.New("tick spacing must be greater than 0")

+ func GetAddress(tokenA, tokenB *entities.Token, fee constants.FeeAmount, ...) (common.Address, error)

+ func IsAtOrAboveLargest(ticks []Tick, tick int) bool

+ func IsBelowSmallest(ticks []Tick, tick int) bool

+ func NearestUsableTick(tick int, tickSpacing int) int

+ func NextInitializedTickWithinFixedDistance(ticks []Tick, tick int, lte bool, distance int) (int, bool)

+ func NextInitializedTickWithinOneWord(ticks []Tick, tick int, lte bool, tickSpacing int) (int, bool)

+ func Round(x float64) float64

+ func ValidateList(ticks []Tick, tickSpacing int) error

+ type BestTradeOptions struct

+ MaxHops int

+ MaxNumResults int

+ type Pool struct

+ Fee constants.FeeAmount

+ Liquidity *big.Int

+ ReinvestLiquidity *big.Int

+ SqrtRatioX96 *big.Int

+ TickCurrent int

+ TickDataProvider TickDataProvider

+ Token0 *entities.Token

+ Token1 *entities.Token

+ func NewPool(tokenA, tokenB *entities.Token, fee constants.FeeAmount, sqrtRatioX96 *big.Int, ...) (*Pool, error)

+ func (p *Pool) ChainID() uint

+ func (p *Pool) GetInputAmount(outputAmount *entities.CurrencyAmount, sqrtPriceLimitX96 *big.Int) (*entities.CurrencyAmount, *Pool, error)

+ func (p *Pool) GetOutputAmount(inputAmount *entities.CurrencyAmount, sqrtPriceLimitX96 *big.Int) (*entities.CurrencyAmount, *Pool, error)

+ func (p *Pool) InvolvesToken(token *entities.Token) bool

+ func (p *Pool) PriceOf(token *entities.Token) (*entities.Price, error)

+ func (p *Pool) Token0Price() *entities.Price

+ func (p *Pool) Token1Price() *entities.Price

+ type Position struct

+ Liquidity *big.Int

+ Pool *Pool

+ TickLower int

+ TickUpper int

+ func FromAmount0(pool *Pool, tickLower, tickUpper int, amount0 *big.Int, useFullPrecision bool) (*Position, error)

+ func FromAmount1(pool *Pool, tickLower, tickUpper int, amount1 *big.Int) (*Position, error)

+ func FromAmounts(pool *Pool, tickLower, tickUpper int, amount0, amount1 *big.Int, ...) (*Position, error)

+ func NewPosition(pool *Pool, liquidity *big.Int, tickLower int, tickUpper int) (*Position, error)

+ func (p *Position) Amount0() (*entities.CurrencyAmount, error)

+ func (p *Position) Amount1() (*entities.CurrencyAmount, error)

+ func (p *Position) BurnAmountsWithSlippage(slippageTolerance *entities.Percent) (amount0, amount1 *big.Int, err error)

+ func (p *Position) MintAmounts() (amount0, amount1 *big.Int, err error)

+ func (p *Position) MintAmountsWithSlippage(slippageTolerance *entities.Percent) (amount0, amount1 *big.Int, err error)

+ func (p *Position) Token0PriceLower() (*entities.Price, error)

+ func (p *Position) Token0PriceUpper() (*entities.Price, error)

+ type Route struct

+ Input *entities.Token

+ Output *entities.Token

+ Pools []*Pool

+ TokenPath []*entities.Token

+ func NewRoute(pools []*Pool, input, output *entities.Token) (*Route, error)

+ func (r *Route) ChainID() uint

+ func (r *Route) MidPrice() (*entities.Price, error)

+ type StepComputations struct

+ type Swap struct

+ InputAmount *entities.CurrencyAmount

+ OutputAmount *entities.CurrencyAmount

+ Route *Route

+ type Tick struct

+ Index int

+ LiquidityGross *big.Int

+ LiquidityNet *big.Int

+ func GetTick(ticks []Tick, index int) Tick

+ func NextInitializedTick(ticks []Tick, tick int, lte bool) Tick

+ type TickDataProvider interface

+ GetTick func(tick int) Tick

+ NextInitializedTickWithinFixedDistance func(tick int, lte bool, distance int) (int, bool)

+ NextInitializedTickWithinOneWord func(tick int, lte bool, tickSpacing int) (int, bool)

+ type TickListDataProvider struct

+ func NewTickListDataProvider(ticks []Tick, tickSpacing int) (*TickListDataProvider, error)

+ func (p *TickListDataProvider) GetTick(tick int) Tick

+ func (p *TickListDataProvider) NextInitializedTickWithinFixedDistance(tick int, lte bool, distance int) (int, bool)

+ func (p *TickListDataProvider) NextInitializedTickWithinOneWord(tick int, lte bool, tickSpacing int) (int, bool)

+ type Trade struct

+ Swaps []*Swap

+ TradeType entities.TradeType

+ func BestTradeExactIn(pools []*Pool, currencyAmountIn *entities.CurrencyAmount, ...) ([]*Trade, error)

+ func BestTradeExactOut(pools []*Pool, tokenIn *entities.Token, ...) ([]*Trade, error)

+ func CreateUncheckedTrade(route *Route, inputAmount, outputAmount *entities.CurrencyAmount, ...) (*Trade, error)

+ func CreateUncheckedTradeWithMultipleRoutes(routes []*Swap, tradeType entities.TradeType) (*Trade, error)

+ func ExactIn(route *Route, amountIn *entities.CurrencyAmount) (*Trade, error)

+ func ExactOut(route *Route, amountOut *entities.CurrencyAmount) (*Trade, error)

+ func FromRoute(route *Route, amount *entities.CurrencyAmount, tradeType entities.TradeType) (*Trade, error)

+ func FromRoutes(wrappedRoutes []*WrappedRoute, tradeType entities.TradeType) (*Trade, error)

+ func (t *Trade) ExecutionPrice() *entities.Price

+ func (t *Trade) InputAmount() *entities.CurrencyAmount

+ func (t *Trade) MaximumAmountIn(slippageTolerance *entities.Percent) (*entities.CurrencyAmount, error)

+ func (t *Trade) MinimumAmountOut(slippageTolerance *entities.Percent) (*entities.CurrencyAmount, error)

+ func (t *Trade) OutputAmount() *entities.CurrencyAmount

+ func (t *Trade) PriceImpact() (*entities.Percent, error)

+ func (t *Trade) Route() (*Route, error)

+ func (t *Trade) WorstExecutionPrice(slippageTolerance *entities.Percent) (*entities.Price, error)

+ type WrappedRoute struct

+ Amount *entities.CurrencyAmount

+ Route *Route