v1 source realm

1const (
2	MaxQuotePercentage     = 100
3	MinQuotePercentage     = 0
4	PERCENTAGE_DENOMINATOR = int64(100)
5)

1const (
2	ErrUnknownSwapType        = "unknown swapType(%s)"
3	ErrInvalidPositiveAmount  = "invalid amount(%s), must be positive"
4	ErrInvalidZeroAmountLimit = "invalid amountLimit(%s), should not be zero"
5	ErrInvalidQuoteRange      = "quote(%d) must be %d~%d"
6)

1const (
2	MIN_SQRT_RATIO string = "4295128739"                                        // same as TickMathGetSqrtRatioAtTick(MIN_TICK)
3	MAX_SQRT_RATIO string = "1461446703485210103287273052203988822378723970342" // same as TickMathGetSqrtRatioAtTick(MAX_TICK)
4)

1const (
2	POOL_SEPARATOR = "*POOL*"
3)

1const (
2	SINGLE_HOP_ROUTE int = 1
3)

 1const (
 2	_ SwapDirection = iota
 3	// Forward indicates a swap processing direction from the first pool to the last pool.
 4	// Used primarily for exactIn swaps where the input amount is known.
 5	Forward
 6
 7	// Backward indicates a swap processing direction from the last pool to the first pool.
 8	// Used primarily for exactOut swaps where the output amount is known and input amounts
 9	// Need to be calculated in reverse order.
10	Backward
11)

 1const (
 2	Unknown SwapType = rawUnknown
 3	// ExactIn represents a swap type where the input amount is exact and the output amount may vary.
 4	// Used when a user wants to swap a specific amount of input tokens.
 5	ExactIn SwapType = rawExactIn
 6
 7	// ExactOut represents a swap type where the output amount is exact and the input amount may vary.
 8	// Used when a user wants to swap a specific amount of output tokens.
 9	ExactOut SwapType = rawExactOut
10)

1func BuildSingleHopRoutePath(tokenA, tokenB string, fee uint32) string

1func NewRouterV1(
2	routerStore router.IRouterStore,
3) router.IRouter

1func NewExactInParams(
2	baseParams BaseSwapParams,
3	amountIn int64,
4	amountOutMin int64,
5) ExactInParams

1func NewExactInSwapOperation(r *routerV1, pp ExactInParams) *ExactInSwapOperation

1func NewExactOutParams(
2	baseParams BaseSwapParams,
3	amountOut int64,
4	amountInMax int64,
5) ExactOutParams

1func NewExactOutSwapOperation(r *routerV1, pp ExactOutParams) *ExactOutSwapOperation

1func NewRouteParser() *RouteParser

1type BaseSwapParams struct {
2	InputToken        string
3	OutputToken       string
4	RouteArr          string
5	QuoteArr          string
6	SqrtPriceLimitX96 *u256.Uint
7	Deadline          int64
8}

1type DryMultiSwapExecutor struct {
2	router *routerV1
3}

1type DrySwapExecutor struct {
2	router *routerV1
3	// payer is the user's address resolved at the entry point (DrySwapRoute),
4	// since dry-run paths do not have a realm value to read PreviousRealm from.
5	payer address
6}

1type ExactInParams struct {
2	BaseSwapParams
3	AmountIn     int64
4	AmountOutMin int64
5}

1type ExactInSwapOperation struct {
2	baseSwapOperation
3	params ExactInParams
4	router *routerV1
5}

1type ExactOutParams struct {
2	BaseSwapParams
3	AmountOut   int64
4	AmountInMax int64
5}

1type ExactOutSwapOperation struct {
2	router *routerV1
3	baseSwapOperation
4	params ExactOutParams
5}

1type MultiSwapExecutor interface {
2	// Run performs the swap operation and returns pool received and pool output amounts.
3	Run(p SwapParams, data SwapCallbackData, recipient address) (int64, int64)
4}

1type MultiSwapProcessor struct {
2	executor   MultiSwapExecutor
3	direction  SwapDirection
4	router     *routerV1
5	isSimulate bool
6	// payer is the address used to identify the user. For real swaps it is the
7	// PreviousRealm address; for dry-run paths it is resolved at the entry point.
8	payer address
9}

1type RealMultiSwapExecutor struct {
2	rlm    realm
3	router *routerV1
4}

1type RealSwapExecutor struct {
2	rlm    realm
3	router *routerV1
4}

1type RouteParser struct{}

1type RouterOperation interface {
2	Validate() error
3	Process(_ int, rlm realm) (*SwapResult, error)
4}

 1type SingleSwapParams struct {
 2	tokenIn  string // token to spend
 3	tokenOut string // token to receive
 4	fee      uint32 // fee of the pool used to swap
 5
 6	// Amount specified for the swap:
 7	//  - Positive: exact input amount (tokenIn)
 8	//  - Negative: exact output amount (tokenOut)
 9	amountSpecified int64
10
11	sqrtPriceLimitX96 *u256.Uint // sqrtPriceLimitX96 for the swap, empty string or zero string means no limit
12}

1type SwapCallbackData struct {
2	tokenIn  string  // token to spend
3	tokenOut string  // token to receive
4	fee      uint32  // fee of the pool used to swap
5	payer    address // address to spend the token
6}

1type SwapDirection int

1type SwapExecutor interface {
2	// execute performs the swap operation.
3	execute(p *SingleSwapParams) (int64, int64)
4}

1type SwapParams struct {
2	SingleSwapParams
3	recipient address // address to receive the token
4}

1type SwapParamsI interface {
2	TokenIn() string
3	TokenOut() string
4	Fee() uint32
5}

1type SwapProcessor struct {
2	router *routerV1
3	// payer identifies the user for dry-run simulations. It is resolved once at
4	// the entry point via unsafe.PreviousRealm since dry-run paths are
5	// read-only and carry no realm value to thread.
6	payer address
7}

1type SwapResult struct {
2	Routes          []string
3	Quotes          []string
4	AmountIn        int64
5	AmountOut       int64
6	AmountSpecified int64
7}

 1type SwapRouteParams struct {
 2	inputToken        string
 3	outputToken       string
 4	routeArr          string
 5	quoteArr          string
 6	deadline          int64
 7	typ               SwapType
 8	exactAmount       int64      // amountIn for ExactIn, amountOut for ExactOut
 9	limitAmount       int64      // amountOutMin for ExactIn, amountInMax for ExactOut
10	sqrtPriceLimitX96 *u256.Uint // if sqrtPriceLimitX96 is zero string, it will be set to MIN_PRICE or MAX_PRICE
11}

1type SwapType string

1type SwapValidator struct{}