v1 state

assertIsNotExpired

assertIsNotExpired ensures the transaction deadline has not passed.

assertIsValidSqrtPriceLimitX96

assertIsValidSingleSwapRouteArrPath

assertIsValidRoutePaths

assertIsExistsPools

assertIsRouterImplementation

SINGLE_HOP_ROUTE

POOL_SEPARATOR

swap can be done by multiple pools to separate each pool, we use POOL\_SEPARATOR

RouterOperation

executeSwapOperation

executeSwapOperation validates and processes a swap operation.

BaseSwapParams

baseSwapOperation

common swap operation

SwapRouteParams

SwapRouteParams contains all parameters needed for swap route execution

buildRouteEventAttrs

createSwapOperation

createSwapOperation creates the appropriate swap operation based on swap type.

routerImplAddr

init.16

errSlippage

errInvalidRoutesAndQuotes

errExpired

errInvalidInput

errInvalidPoolFeeTier

errInvalidSwapFee

errInvalidSwapType

errInvalidPoolPath

errUnAuthorizedCaller

errHopsOutOfRange

errSameTokenSwap

errInvalidRoutePath

errInvalidRouteFirstToken

errInvalidRouteLastToken

errInvalidSwapAmount

errRouteHopDisconnected

errInsufficientBalance

errSpoofedRealm

addDetailToError

addDetailToError adds detail to an error message.

makeErrorWithDetails

makeErrorWithDetails creates an error with additional context.

ExactInSwapOperation

NewExactInSwapOperation

ExactOutSwapOperation

ExactOutSwapOperation handles swaps where the output amount is specified.

NewExactOutSwapOperation

NewExactOutSwapOperation creates a new exact-out swap operation.

defaultSwapFeeBPS

// 0.15%

init.42

registerRouterV1

initStoreData

routerV1

NewRouterV1

calculateRouterFee

calculateExactOutWithRouterFee

calculate amount to fetch from pool including router fee poolAmount = userAmount / (1 - feeRate) = userAmount \* 10000 / (10000 - swapFeeBPS)

errExactOutAmountExceeded

ErrorMessages define all error message templates used throughout the router

errInvalidRouteLength

ErrorMessages define all error message templates used throughout the router

errRoutesQuotesMismatch

ErrorMessages define all error message templates used throughout the router

errInvalidQuote

ErrorMessages define all error message templates used throughout the router

errInvalidQuoteValue

ErrorMessages define all error message templates used throughout the router

errQuoteExceedsMax

ErrorMessages define all error message templates used throughout the router

errQuoteSumExceedsMax

ErrorMessages define all error message templates used throughout the router

errInvalidQuoteSum

ErrorMessages define all error message templates used throughout the router

errExactInTooFewReceived

ErrorMessages define all error message templates used throughout the router

errExactOutTooMuchSpent

ErrorMessages define all error message templates used throughout the router

errEmptyRoutes

ErrorMessages define all error message templates used throughout the router

SwapValidator

SwapValidator provides validation methods for swap operations

RouteParser

RouteParser handles parsing and validation of routes and quotes

NewRouteParser

NewRouteParser creates a new route parser instance.

validateRoutesAndQuotes

validateRoutesAndQuotes is a convenience function that parses and validates routes in one call.

MaxQuotePercentage

QuoteConstraints defines the valid range for swap quote percentages

MinQuotePercentage

QuoteConstraints defines the valid range for swap quote percentages

PERCENTAGE_DENOMINATOR

QuoteConstraints defines the valid range for swap quote percentages

ErrUnknownSwapType

ErrorMessages for DrySwapRoute operations

ErrInvalidPositiveAmount

ErrorMessages for DrySwapRoute operations

ErrInvalidZeroAmountLimit

ErrorMessages for DrySwapRoute operations

ErrInvalidQuoteRange

ErrorMessages for DrySwapRoute operations

SwapProcessor

SwapProcessor handles the execution of swap operations

getPathIndex

getPathIndex returns the path index based on swap type and number of hops.

MIN_SQRT_RATIO

// same as TickMathGetSqrtRatioAtTick(MIN\_TICK)

MAX_SQRT_RATIO

// same as TickMathGetSqrtRatioAtTick(MAX\_TICK)

sqrtPriceLimitForward

// zeroForOne=true: sqrtRatioAtTick(minTick+1) + 1

sqrtPriceLimitBackward

// zeroForOne=false: sqrtRatioAtTick(maxTick-1) - 1

init.77

RealSwapExecutor

RealSwapExecutor implements SwapExecutor for actual swaps.

DrySwapExecutor

DrySwapExecutor implements SwapExecutor for dry swaps.

calculateSqrtPriceLimitForSwap

calculateSqrtPriceLimitForSwap returns the price limit for a swap operation. If a non-zero limit is provided by the caller, it is returned as-is. Otherwise, returns the precomputed limit for the given fee tier and direction. The returned pointer is shared (read-only — callers must not mutate it).

mustGetSqrtPriceLimit

getMinTick

getMinTick returns the minimum tick value for a given fee tier. The implementation follows Uniswap V3's tick spacing rules where lower fee tiers allow for finer price granularity.

getMaxTick

getMaxTick returns the maximum tick value for a given fee tier. The max tick values are the exact negatives of min tick values.

SwapDirection

SwapDirection represents the direction of swap execution in multi-hop swaps. It determines whether swaps are processed in forward order (first to last pool) or backward order (last to first pool).

Forward

Backward

MultiSwapExecutor

MultiSwapExecutor defines the interface for multi-hop swap operation execution.

DryMultiSwapExecutor

DryMultiSwapExecutor implements MultiSwapExecutor for dry run simulations.

RealMultiSwapExecutor

RealMultiSwapExecutor implements MultiSwapExecutor for actual swap operations.

MultiSwapProcessor

MultiSwapProcessor handles the execution flow for multi-hop swaps.

newRealMultiSwapProcessor

newRealMultiSwapProcessor creates a processor that performs real swaps.

newDryMultiSwapProcessor

newDryMultiSwapProcessor creates a processor that performs dry-run simulations.

SwapExecutor

SwapExecutor defines the interface for executing swaps.

rawUnknown

rawExactIn

rawExactOut

SwapType

Unknown

ExactIn

ExactOut

trySwapTypeFromStr

trySwapTypeFromStr attempts to convert a string into a SwapType. It validates and converts string representations of swap types into their corresponding enum values.

SingleSwapParams

SingleSwapParams contains parameters for executing a single pool swap. It represents the simplest form of swap that occurs within a single liquidity pool.

SwapParams

SwapParams contains parameters for executing a multi-hop swap operation.

newSwapParams

newSwapParams creates a new SwapParams instance with the provided parameters.

SwapResult

SwapResult encapsulates the outcome of a swap operation.

SwapParamsI

SwapParamsI defines the common interface for swap parameters.

SwapCallbackData

SwapCallbackData contains the callback data required for swap execution. This type is used to pass necessary information during the swap callback process, ensuring proper token transfers and pool data updates.

newSwapCallbackData

newSwapCallbackData creates a new SwapCallbackData from a SwapParamsI.

ExactInParams

ExactInParams contains parameters for exact input swaps.

NewExactInParams

NewExactInParams creates a new ExactInParams instance.

ExactOutParams

ExactOutParams contains parameters for exact output swaps.

NewExactOutParams

NewExactOutParams creates a new ExactOutParams instance.

calculateSwapAmountByQuote

calculateSwapAmountByQuote calculates swap amount based on quote percentage.

assertHopsInRange

assertHopsInRange ensures the number of hops is within the valid range of 1-3.

getDataForSinglePath

getDataForSinglePath extracts token addresses and fee from a single pool path. IMPORTANT: This function returns tokens in the order they appear in the route string, which represents the swap direction (tokenIn:tokenOut:fee), NOT the canonical pool ordering.

getDataForSinglePathWithError

getDataForSinglePathWithError extracts token addresses and fee from a single pool path with error handling.

getDataForMultiPath

getDataForMultiPath extracts token addresses and fee from a multi-hop path at specified index.

i256MinMax

i256MinMax returns the absolute values of x and y in min-max order.

validateRoutePaths

validateRoutePaths validates multiple route paths to ensure they all start with inputToken and end with outputToken. This function processes comma-separated route paths and validates each path individually. Validates: - Each route path starts with the specified inputToken - Each route path ends with the specified outputToken - Route path format consistency (prevents swap-direction vs alphabetical pool ordering confusion) Parameters: - routePathArrString: comma-separated route paths (e.g., "gno.land/r/demo/wugnot:gno.land/r/demo/usdc:500,gno.land/r/demo/wugnot:gno.land/r/demo/gns:3000\*POOL\*gno.land/r/demo/gns:gno.land/r/demo/usdc:500") - inputToken: expected first token in all route paths - outputToken: expected last token in all route paths Examples: - Single route: "tokenA:tokenB:500" with inputToken="tokenA", outputToken="tokenB" - Multi-route: "tokenA:tokenB:500,tokenA:tokenC:3000\*POOL\*tokenC:tokenB:500" with inputToken="tokenA", outputToken="tokenB" Returns error if any route path validation fails.

validateRoutePath

validateRoutePath validates a single route path to ensure it starts with inputToken and ends with outputToken. This function handles both single-hop and multi-hop route paths. Validates: - Route path starts with the specified inputToken - Route path ends with the specified outputToken - Proper token ordering in swap direction (not alphabetical pool ordering) Route Path Formats: - single-hop: "tokenA:tokenB:fee" (direct swap between two tokens) - multi-hop: "tokenA:tokenB:fee1\*POOL\*tokenB:tokenC:fee2" (swap through intermediate tokens) Parameters: - routePath: single route path string (e.g., "gno.land/r/demo/wugnot:gno.land/r/demo/usdc:500") - inputToken: expected first token in the route path - outputToken: expected last token in the route path Examples: - single-hop: "tokenA:tokenB:500" with inputToken="tokenA", outputToken="tokenB" - multi-hop: "tokenA:tokenB:3000\*POOL\*tokenB:tokenC:500" with inputToken="tokenA", outputToken="tokenC" Returns error with specific details if validation fails.

validatePoolPathHopContinuity

splitSingleChar

splitSingleChar splits a string by a single character separator. This function is optimized for splitting strings with a single-byte separator and is more memory efficient than strings.Split for this use case.

parsePoolPathsByRoutePathArr

parsePoolPathsByRoutePathArr parses route path array string and returns a slice of pool paths. This function converts route paths (which maintain swap direction) into canonical pool paths (which use alphabetical token ordering). The function processes comma-separated route paths and extracts individual pool information from each route, ensuring tokens are ordered alphabetically for consistent pool identification. Parameters: - routePathArr: comma-separated route paths string containing single or multi-hop routes Format examples: - Single route: "tokenA:tokenB:500" - Multiple routes: "tokenA:tokenB:500,tokenC:tokenD:3000" - Multi-hop routes: "tokenA:tokenB:500\*POOL\*tokenB:tokenC:3000" Returns: - \[]string: slice of canonical pool paths with alphabetically ordered tokens - error: parsing error if any route path is invalid Example: input: "gno.land/r/demo/wugnot:gno.land/r/demo/usdc:500,gno.land/r/demo/usdc:gno.land/r/demo/gns:3000" output: ["gno.land/r/demo/usdc:gno.land/r/demo/wugnot:500", "gno.land/r/demo/gns:gno.land/r/demo/usdc:3000"]

BuildSingleHopRoutePath

BuildSingleHopPath creates a single-hop route path string. Format: "tokenA:tokenB:fee" Parameters: - tokenA: input token address - tokenB: output token address - fee: pool fee (e.g., 500, 3000, 10000) Returns: - string: formatted single-hop route path Example: - BuildSingleHopPath("gno.land/r/demo/wugnot", "gno.land/r/demo/usdc", 500) returns "gno.land/r/demo/wugnot:gno.land/r/demo/usdc:500"