v1 state

assertIsNotUserCall

assertIsNotEqualsTokens

assertIsNotEqualsTokens asserts that the token0Path and token1Path are not equal.

assertIsSupportedFeeTier

assertIsSupportedFeeTier asserts that the fee is a supported fee tier.

assertIsNotExistsPoolPath

assertIsNotExistsPoolPath asserts that the pool path does not exist.

assertIsValidTokenOrder

errUnsupportedFeeTier

Error definitions for pool operations

errPoolAlreadyExists

Error definitions for pool operations

errOutOfRange

Error definitions for pool operations

errInvalidInput

Error definitions for pool operations

errDataNotFound

Error definitions for pool operations

errLiquidityCalculation

Error definitions for pool operations

errZeroLiquidity

Error definitions for pool operations

errDuplicateTokenInPool

Error definitions for pool operations

errTickLowerInvalid

Error definitions for pool operations

errTickUpperInvalid

Error definitions for pool operations

errInvalidSwapAmount

Error definitions for pool operations

errInvalidProtocolFeePct

Error definitions for pool operations

errInvalidWithdrawalFeePct

Error definitions for pool operations

errLockedPool

Error definitions for pool operations

errPriceOutOfRange

Error definitions for pool operations

errTransferFailed

Error definitions for pool operations

errInvalidTickAndTickSpacing

Error definitions for pool operations

errInvalidTickRange

Error definitions for pool operations

errUnderflow

Error definitions for pool operations

errOverflow

Error definitions for pool operations

errBalanceUpdateFailed

Error definitions for pool operations

errInvalidPayer

Error definitions for pool operations

errNotAccessEOA

Error definitions for pool operations

errInsufficientPayment

Error definitions for pool operations

errNotInitializedObservation

Error definitions for pool operations

errObservationTooOld

Error definitions for pool operations

errSpoofedRealm

Error definitions for pool operations

newErrorWithDetail

newErrorWithDetail adds detail to an error message.

makeErrorWithDetails

makeErrorWithDetails creates an error with additional context.

tickEventInfo

NewTickEventInfo

FeeTier100

FeeTier500

FeeTier3000

FeeTier10000

MIN_SQRT_RATIO

MAX_SQRT_RATIO

poolCreateConfig

poolCreateConfig holds the essential parameters for creating a new pool.

newPoolParams

newPoolParams defines the essential parameters for creating a new pool.

validateSqrtPriceX96

validateSqrtPriceX96 validates that the given sqrtPriceX96 is within valid range

isValidFeeTier

GetPoolPath

GetPoolPath generates a unique pool path string based on the token paths and fee tier.

defaultSlot0FeeProtocol

defaultPoolCreationFee

// 100\_GNS

defaultWithdrawalFeeBPS

defaultUnlocked

init.51

registerPoolV1

initStoreData

poolV1

NewPoolV1

GNS_TOKEN_KEY

validateFeeProtocol

validateFeeProtocol validates the fee protocol values for token0 and token1. This function checks whether the provided fee protocol values (\`feeProtocol0\` and \`feeProtocol1\`) are valid using the \`isValidFeeProtocolValue\` function. If either value is invalid, it returns an error indicating that the protocol fee percentage is invalid. Parameters: - feeProtocol0: uint8, the fee protocol value for token0. - feeProtocol1: uint8, the fee protocol value for token1. Returns: - error: Returns \`errInvalidProtocolFeePct\` if either \`feeProtocol0\` or \`feeProtocol1\` is invalid. Returns \`nil\` if both values are valid.

isValidFeeProtocolValue

isValidFeeProtocolValue checks if a fee protocol value is within acceptable range. Valid values are either 0 (disabled) or between 4 and 10 inclusive. The value is used as a denominator: protocolFee = swapFee / feeProtocol (e.g., feeProtocol=4 means 1/4 = 25% of swap fees go to protocol)

maxObservationCardinality

maxObservationCardinality defines the maximum number of observations to store

getTWAP

GetTWAP calculates the time-weighted average price between two points in time Returns the arithmetic mean tick and harmonic mean liquidity over the time period

writeObservationByPool

increaseObservationCardinalityNextByPool

transform

grow

lte

writeObservation

lastObservation

observationAt

observationAt returns the observation at a specific index Returns error if the observation doesn't exist

observeSingle

observeSingle returns the data for a single observation at a specific time ago

getSurroundingObservations

getSurroundingObservations finds the observations immediately before and after the target timestamp. It uses binary search over the logical time-ordered view of the circular buffer. Logical order starts at (index+1) % cardinality (oldest) and ends at index (latest).

binarySearch

observe

observe returns the cumulative tick and liquidity as of each timestamp secondsAgo from the current time.

minRequestedAmount

getPositionKey

getPositionKey generates a compact deterministic key for a liquidity position. Creates deterministic identifier for position tracking. Ensures unique positions per price range while preserving lexical ordering. Used internally for position state management. Parameters: - tickLower: Lower boundary tick of position range - tickUpper: Upper boundary tick of position range Key Format: EncodePositionKey(tickLower, tickUpper)

positionUpdate

positionUpdate updates a position's liquidity and calculates fees owed. Returns the updated position information and any error.

calculateToken0Amount

calculateToken0Amount calculates the amount of token0 based on price range and liquidity delta.

calculateToken1Amount

calculateToken1Amount calculates the amount of token1 based on price range and liquidity delta.

PositionLiquidity

PositionLiquidity returns the liquidity of a position.

PositionFeeGrowthInside0LastX128

PositionFeeGrowthInside0LastX128 returns the fee growth of token0 inside a position.

PositionFeeGrowthInside1LastX128

PositionFeeGrowthInside1LastX128 returns the fee growth of token1 inside a position.

PositionTokensOwed0

PositionTokensOwed0 returns the amount of token0 owed by a position.

PositionTokensOwed1

PositionTokensOwed1 returns the amount of token1 owed by a position.

GetPositionByPool

GetPosition returns the position info for a given key.

positionUpdateWithKey

positionUpdateWithKey updates a position in the pool and returns the updated position.

setPosition

setPosition sets the position info for a given key.

mustGetPositionByPool

mustGetPosition returns the position info for a given key.

modifyPosition

modifyPosition updates a position in the pool and calculates the amount of tokens needed (for minting) or returned (for burning). The calculation depends on the current price (tick) relative to the position's price range. The function handles three cases: 1. Current price below range (tick \< tickLower): only token0 is used/returned 2. Current price in range (tickLower \<= tick \< tickUpper): both tokens are used/returned 3. Current price above range (tick >= tickUpper): only token1 is used/returned Parameters: - params: ModifyPositionParams containing owner, tickLower, tickUpper, and liquidityDelta Returns: - PositionInfo: updated position information - \*u256.Uint: amount of token0 needed/returned - \*u256.Uint: amount of token1 needed/returned

updatePosition

updatePosition modifies the position's liquidity and updates the corresponding tick states. This function updates the position data based on the specified liquidity delta and tick range. It also manages the fee growth, tick state flipping, and cleanup of unused tick data. Parameters: - positionParams: ModifyPositionParams, the parameters for the position modification, which include: - owner: The address of the position owner. - tickLower: The lower tick boundary of the position. - tickUpper: The upper tick boundary of the position. - liquidityDelta: The change in liquidity (positive or negative). - tick: int32, the current tick position. Returns: - PositionInfo: The updated position information. Workflow: 1. Clone the global fee growth values (token 0 and token 1). 2. If the liquidity delta is non-zero: - Update the lower and upper ticks using \`tickUpdate\`, flipping their states if necessary. - If a tick's state was flipped, update the tick bitmap to reflect the new state. 3. Calculate the fee growth inside the tick range using \`getFeeGrowthInside\`. 4. Generate a unique position key and update the position data using \`positionUpdateWithKey\`. 5. If liquidity is being removed (negative delta), clean up unused tick data by deleting the tick entries. 6. Return the updated position. Notes: - The function flips the tick states and cleans up unused tick data when liquidity is removed. - It ensures fee growth and position data remain accurate after the update. Example Usage: \`\`\`gno updatedPosition := pool.updatePosition(positionParams, currentTick) println("Updated Position Info:", updatedPosition) \`\`\`

MaxBpsValue

// 10%

ZeroBps

calculateAmountWithFee

calculateAmountWithFee calculates the fee amount and the amount after the fee Inputs: - amount: the amount before the fee - fee: the fee in BPS Outputs: - the fee amount - the amount after the fee applied

zero

Hook functions allow external contracts to be notified of swap events.

zeroI256

/\* readonly \*/

fixedPointQ128

Hook functions allow external contracts to be notified of swap events.

maxInt256

Hook functions allow external contracts to be notified of swap events.

maxInt64

Hook functions allow external contracts to be notified of swap events.

minInt64

Hook functions allow external contracts to be notified of swap events.

SwapResult

SwapResult encapsulates all state changes from a swap. It ensures atomic state transitions that can be applied at once.

SwapComputation

SwapComputation encapsulates the pure computation logic for swaps.

tickCrossHookFn

tickCrossHookFn is invoked from inside the swap loop whenever an initialized tick is crossed. DrySwap passes nil to skip side effects.

applySwapResult

applySwapResult updates pool state with computed results. All state changes are applied at once to maintain consistency

validatePriceLimits

validatePriceLimits ensures the provided price limit is valid for the swap direction The function enforces that: For zeroForOne (selling token0): - Price limit must be below current price - Price limit must be above MIN\_SQRT\_RATIO For !zeroForOne (selling token1): - Price limit must be above current price - Price limit must be below MAX\_SQRT\_RATIO

getFeeProtocol

getFeeProtocol returns the appropriate fee protocol based on zero for one. When zeroForOne is true, we want the lower 4 bits (% 16). Otherwise, we want the upper 4 bits (/ 16).

getFeeGrowthGlobal

getFeeGrowthGlobal returns the appropriate fee growth global based on zero for one.

shouldContinueSwap

shouldContinueSwap checks if swap should continue based on remaining amount and price limit.

updateFeeProtocol

updateFeeProtocol calculates and updates protocol fees for the current step.

computeSwapStepInit

computeSwapStepInit initializes the computation for a single swap step.

computeTargetSqrtRatio

computeTargetSqrtRatio determines the target sqrt price for the current swap step.

shouldUsePriceLimit

shouldUsePriceLimit returns true if the price limit should be used instead of the next tick price

computeAmounts

computeAmounts calculates the input and output amounts for the current swap step.

updateAmounts

updateAmounts calculates new remaining and calculated amounts based on the swap step. For exact input swaps: - Decrements remaining input amount by (amountIn + feeAmount) - Decrements calculated amount by amountOut For exact output swaps: - Increments remaining output amount by amountOut - Increments calculated amount by (amountIn + feeAmount)

MAX_LIQUIDITY_PER_TICK_SPACING_1

MAX_LIQUIDITY_PER_TICK_SPACING_10

MAX_LIQUIDITY_PER_TICK_SPACING_60

MAX_LIQUIDITY_PER_TICK_SPACING_200

MIN_TICK

MAX_TICK

maxLiquidityPerTickSpacing1FromDec

maxLiquidityPerTickSpacing\* return the precomputed max-liquidity-per-tick for each supported tick spacing. They are constructors (not package-level vars) so each caller receives a fresh instance — calculateMaxLiquidityPerTick returns the value directly to callers, and a shared singleton could otherwise be mutated in place and corrupt every caller. Values are built from little-endian \[4]uint64 literals to avoid runtime decimal parsing.

maxLiquidityPerTickSpacing10FromDec

maxLiquidityPerTickSpacing60FromDec

maxLiquidityPerTickSpacing200FromDec

GetTickLiquidityGross

GetTickLiquidityGross returns the gross liquidity for the specified tick.

GetTickLiquidityNet

GetTickLiquidityNet returns the net liquidity for the specified tick.

GetTickFeeGrowthOutside0X128

GetTickFeeGrowthOutside0X128 returns the fee growth outside the tick for token 0.

GetTickFeeGrowthOutside1X128

GetTickFeeGrowthOutside1X128 returns the fee growth outside the tick for token 1.

GetTickCumulativeOutside

GetTickCumulativeOutside returns the cumulative liquidity outside the tick.

GetTickSecondsPerLiquidityOutsideX128

GetTickSecondsPerLiquidityOutsideX128 returns the seconds per liquidity outside the tick.

GetTickSecondsOutside

GetTickSecondsOutside returns the seconds outside the tick.

GetTickInitialized

GetTickInitialized returns whether the tick is initialized.

getFeeGrowthInside

getFeeGrowthInside calculates the fee growth within a specified tick range. This function computes the accumulated fee growth for token 0 and token 1 inside a given tick range (\`tickLower\` to \`tickUpper\`) relative to the current tick position (\`tickCurrent\`). It isolates the fee growth within the range by subtracting the fee growth below the lower tick and above the upper tick from the global fee growth. Parameters: - tickLower: int32, the lower tick boundary of the range. - tickUpper: int32, the upper tick boundary of the range. - tickCurrent: int32, the current tick index. - feeGrowthGlobal0X128: \*u256.Uint, the global fee growth for token 0 in X128 precision. - feeGrowthGlobal1X128: \*u256.Uint, the global fee growth for token 1 in X128 precision. Returns: - \*u256.Uint: Fee growth inside the tick range for token 0. - \*u256.Uint: Fee growth inside the tick range for token 1. Workflow: 1. Retrieve the tick information (\`lower\` and \`upper\`) for the lower and upper tick boundaries using \`p.getTick\`. 2. Calculate the fee growth below the lower tick using \`getFeeGrowthBelowX128\`. 3. Calculate the fee growth above the upper tick using \`getFeeGrowthAboveX128\`. 4. Subtract the fee growth below and above the range from the global fee growth values: feeGrowthInside = feeGrowthGlobal - feeGrowthBelow - feeGrowthAbove 5. Return the computed fee growth values for token 0 and token 1 within the range. Behavior: - The fee growth is isolated within the range \`\[tickLower, tickUpper]\`. - The function ensures the calculations accurately consider the tick boundaries and the current tick position. Example: \`\`\`gno feeGrowth0, feeGrowth1 := pool.getFeeGrowthInside( 100, 200, 150, globalFeeGrowth0, globalFeeGrowth1, ) println("Fee Growth Inside (Token 0):", feeGrowth0) println("Fee Growth Inside (Token 1):", feeGrowth1) \`\`\`

tickUpdate

tickUpdate updates the state of a specific tick. This function applies a given liquidity change (liquidityDelta) to the specified tick, updates the fee growth values if necessary, and adjusts the net liquidity based on whether the tick is an upper or lower boundary. It also verifies that the total liquidity does not exceed the maximum allowed value and ensures the net liquidity stays within the valid int128 range. Parameters: - tick: int32, the index of the tick to update. - tickCurrent: int32, the current active tick index. - liquidityDelta: \*i256.Int, the amount of liquidity to add or remove. - feeGrowthGlobal0X128: \*u256.Uint, the global fee growth value for token 0. - feeGrowthGlobal1X128: \*u256.Uint, the global fee growth value for token 1. - upper: bool, indicates if this is the upper boundary (true for upper, false for lower). - maxLiquidity: \*u256.Uint, the maximum allowed liquidity. Returns: - flipped: bool, indicates if the tick's initialization state has changed. (e.g., liquidity transitioning from zero to non-zero, or vice versa) Workflow: 1. Nil input values are replaced with zero. 2. The function retrieves the tick information for the specified tick index. 3. Applies the liquidityDelta to compute the new total liquidity (liquidityGross). - If the total liquidity exceeds the maximum allowed value, the function panics. 4. Checks whether the tick's initialized state has changed and sets the \`flipped\` flag. 5. If the tick was previously uninitialized and its index is less than or equal to the current tick, the fee growth values are initialized to the current global values. 6. Updates the tick's net liquidity: - For an upper boundary, it subtracts liquidityDelta. - For a lower boundary, it adds liquidityDelta. - Ensures the net liquidity remains within the int128 range using \`checkOverFlowInt128\`. 7. Updates the tick's state with the new values. 8. Returns whether the tick's initialized state has flipped. Panic Conditions: - The total liquidity (liquidityGross) exceeds the maximum allowed liquidity (maxLiquidity). - The net liquidity (liquidityNet) exceeds the int128 range. Example: \`\`\`gno flipped := pool.tickUpdate(10, 5, liquidityDelta, feeGrowth0, feeGrowth1, true, maxLiquidity) println("Tick flipped:", flipped) \`\`\`

tickCross

tickCross updates a tick's state when it is crossed and returns the liquidity net. Updates fee growth and oracle accumulator values for the tick.

setTick

setTick updates the tick data for the specified tick index in the pool.

deleteTick

deleteTick deletes the tick data for the specified tick index in the pool.

getTick

getTick retrieves the TickInfo associated with the specified tick index from the pool. If the TickInfo contains any nil fields, they are replaced with zero values using valueOrZero. Parameters: - tick: The tick index (int32) for which the TickInfo is to be retrieved. Behavior: - Retrieves the TickInfo for the given tick from the pool's tick map. - Ensures that all fields of TickInfo are non-nil by calling valueOrZero, which replaces nil values with zero. - Returns the updated TickInfo. Returns: - TickInfo: The tick data with all fields guaranteed to have valid values (nil fields are set to zero). Use Case: This function ensures the retrieved tick data is always valid and safe for further operations, such as calculations or updates, by sanitizing nil fields in the TickInfo structure.

mustGetTick

mustGetTick retrieves the TickInfo for a specific tick, panicking if the tick does not exist. This function ensures that the requested tick data exists in the pool's tick mapping. If the tick does not exist, it panics with an appropriate error message. Parameters: - tick: int32, the index of the tick to retrieve. Returns: - TickInfo: The information associated with the specified tick. Behavior: - Checks if the tick exists in the pool's tick mapping (\`p.ticks\`). - If the tick exists, it returns the corresponding \`TickInfo\`. - If the tick does not exist, the function panics with a descriptive error. Panic Conditions: - The specified tick does not exist in the pool's mapping. Example: \`\`\`gno tickInfo := pool.mustGetTick(10) ufmt.Println("Tick Info:", tickInfo) \`\`\`

calculateMaxLiquidityPerTick

calculateMaxLiquidityPerTick calculates the maximum liquidity per tick for a given tick spacing.

getFeeGrowthBelowX128

getFeeGrowthBelowX128 calculates the fee growth below a specified tick. This function computes the fee growth for token 0 and token 1 below a given tick (\`tickLower\`) relative to the current tick (\`tickCurrent\`). The fee growth values are adjusted based on whether the \`tickCurrent\` is above or below the \`tickLower\`. Parameters: - tickLower: int32, the lower tick boundary for fee calculation. - tickCurrent: int32, the current tick index. - feeGrowthGlobal0X128: \*u256.Uint, the global fee growth for token 0 in X128 precision. - feeGrowthGlobal1X128: \*u256.Uint, the global fee growth for token 1 in X128 precision. - lowerTick: TickInfo, the fee growth and liquidity details for the lower tick. Returns: - \*u256.Uint: Fee growth below \`tickLower\` for token 0. - \*u256.Uint: Fee growth below \`tickLower\` for token 1. Workflow: 1. If \`tickCurrent\` is greater than or equal to \`tickLower\`: - Return the \`feeGrowthOutside0X128\` and \`feeGrowthOutside1X128\` values of the \`lowerTick\`. 2. If \`tickCurrent\` is below \`tickLower\`: - Compute the fee growth below the lower tick by subtracting \`feeGrowthOutside\` values from the global fee growth values (\`feeGrowthGlobal0X128\` and \`feeGrowthGlobal1X128\`). 3. Return the calculated fee growth values for both tokens. Behavior: - If \`tickCurrent >= tickLower\`, the fee growth outside the lower tick is returned as-is. - If \`tickCurrent \< tickLower\`, the fee growth is calculated as: feeGrowthBelow = feeGrowthGlobal - feeGrowthOutside Example: \`\`\`gno feeGrowth0, feeGrowth1 := getFeeGrowthBelowX128( 100, 150, globalFeeGrowth0, globalFeeGrowth1, lowerTickInfo, ) println("Fee Growth Below:", feeGrowth0, feeGrowth1)

getFeeGrowthAboveX128

getFeeGrowthAboveX128 calculates the fee growth above a specified tick. This function computes the fee growth for token 0 and token 1 above a given tick (\`tickUpper\`) relative to the current tick (\`tickCurrent\`). The fee growth values are adjusted based on whether the \`tickCurrent\` is above or below the \`tickUpper\`. Parameters: - tickUpper: int32, the upper tick boundary for fee calculation. - tickCurrent: int32, the current tick index. - feeGrowthGlobal0X128: \*u256.Uint, the global fee growth for token 0 in X128 precision. - feeGrowthGlobal1X128: \*u256.Uint, the global fee growth for token 1 in X128 precision. - upperTick: TickInfo, the fee growth and liquidity details for the upper tick. Returns: - \*u256.Uint: Fee growth above \`tickUpper\` for token 0. - \*u256.Uint: Fee growth above \`tickUpper\` for token 1. Workflow: 1. If \`tickCurrent\` is less than \`tickUpper\`: - Return the \`feeGrowthOutside0X128\` and \`feeGrowthOutside1X128\` values of the \`upperTick\`. 2. If \`tickCurrent\` is greater than or equal to \`tickUpper\`: - Compute the fee growth above the upper tick by subtracting \`feeGrowthOutside\` values from the global fee growth values (\`feeGrowthGlobal0X128\` and \`feeGrowthGlobal1X128\`). 3. Return the calculated fee growth values for both tokens. Behavior: - If \`tickCurrent \< tickUpper\`, the fee growth outside the upper tick is returned as-is. - If \`tickCurrent >= tickUpper\`, the fee growth is calculated as: feeGrowthAbove = feeGrowthGlobal - feeGrowthOutside Example: feeGrowth0, feeGrowth1 := getFeeGrowthAboveX128( 200, 150, globalFeeGrowth0, globalFeeGrowth1, upperTickInfo, ) println("Fee Growth Above:", feeGrowth0, feeGrowth1) \`\`\`

validateTicks

validateTicks validates the tick range for a liquidity position. This function performs three essential checks to ensure the provided tick values are valid before creating or modifying a liquidity position.

bitMask8

// 256 - 1

tickBitmapFlipTick

tickBitmapFlipTick flips the state of a tick in the tick bitmap. This function toggles the "initialized" state of a tick in the tick bitmap. It ensures that the tick aligns with the specified tick spacing and then flips the corresponding bit in the bitmap representation. Parameters: - tick: int32, the tick index to toggle. - tickSpacing: int32, the spacing between valid ticks. The tick must align with this spacing. Workflow: 1. Validates that the \`tick\` aligns with \`tickSpacing\` using \`checkTickSpacing\`. 2. Computes the position of the bit in the tick bitmap: - \`wordPos\`: Determines which word in the bitmap contains the bit. - \`bitPos\`: Identifies the position of the bit within the word. 3. Creates a bitmask using \`Lsh\` (Left Shift) to target the bit at \`bitPos\`. 4. Toggles (flips) the bit using XOR with the current value of the tick bitmap. 5. Updates the tick bitmap with the modified word. Behavior: - If the bit is \`0\` (uninitialized), it will be flipped to \`1\` (initialized). - If the bit is \`1\` (initialized), it will be flipped to \`0\` (uninitialized). Example: pool.tickBitmapFlipTick(120, 60) // This flips the bit for tick 120 with a tick spacing of 60. Notes: - The \`tick\` must be divisible by \`tickSpacing\`. If not, the function will panic.

tickBitmapNextInitializedTickWithInOneWord

tickBitmapNextInitializedTickWithInOneWord finds the next initialized tick within one word of the bitmap.

getTickBitmap

getTickBitmap gets the tick bitmap for the given word position if the tick bitmap is not initialized, initialize it to zero

setTickBitmap

setTickBitmap sets the tick bitmap for the given word position

tickBitmapPosition

tickBitmapPosition calculates the word and bit position for a given tick

getWordAndBitPos

getWordAndBitPos gets tick's wordPos and bitPos depending on the swap direction

getMaskBit

getMaskBit generates a mask based on the provided bit position (bitPos) and a boolean flag (lte). The function constructs a bitmask with a shift depending on the bit position and the boolean value. It either returns the mask or its negation, based on the value of 'lte' (swap direction). NOTE: should always use a newly created \`u256.One()\` object.

getNextTick

getNextTick gets the next tick depending on the initialized state and the swap direction

getTickIfInitialized

getTickIfInitialized gets the next tick if the tick bitmap is initialized

getTickIfNotInitialized

getTickIfNotInitialized gets the next tick if the tick bitmap is not initialized

validatePoolBalance

validatePoolBalance checks if the pool has sufficient balance of either token0 and token1 before proceeding with a transfer. This prevents the pool won't go into a negative balance.

updatePoolBalance

updatePoolBalance calculates the new balance after a transfer and validate. It ensures the resulting balance won't be negative or overflow.

ModifyPositionParams

ModifyPositionParams repersents the parameters for modifying a liquidity position. This structure is used internally both \`Mint\` and \`Burn\` operation to manage the liquidity positions.

newModifyPositionParams

newModifyPositionParams creates a new \`ModifyPositionParams\` instance. This is used to preare parameters for the \`modifyPosition\` function, which handles both minting and burning of liquidity positions. Parameters: - owner: address that will own (or owns) the position - tickLower: lower tick bound of the position - tickUpper: upper tick bound of the position - liquidityDelta: amount of liquidity to add (positive) or remove (negative) The tick parameters represent prices as powers of 1.0001: - actual\_price = 1.0001^tick - For example, tick = 100 means price = 1.0001^100 Returns: - ModifyPositionParams: a new instance of ModifyPositionParams

SwapCache

SwapCache holds data that remains constant throughout a swap.

newSwapCache

SwapState

SwapState tracks the changing values during a swap. This type helps manage the state transitions that occur as the swap progresses across different price ranges.

newSwapState

StepComputations

StepComputations holds intermediate values used during a single step of a swap. Each step represents movement from the current tick to the next initialized tick or the target price, whichever comes first.

newPool

MAX_UINT64

MAX_INT64

MAX_INT128

MAX_UINT128

MAX_INT256

INT64_MIN

INT64_MAX

Q96_RESOLUTION

Q128_RESOLUTION

Q64

// 2 \*\* 64

Q96

// 2 \*\* 96

Q128

// 2 \*\* 128

maxInt128FromDecimal

maxUint128FromDecimal

q128FromDecimal

uint128Mask

toUint128

toUint128 ensures a \*u256.Uint value fits within the uint128 range. This function validates that the given \`value\` is properly initialized and checks whether it exceeds the maximum value of uint128. If the value exceeds the uint128 range, it applies a masking operation to truncate the value to fit within the uint128 limit. Parameters: - value: \*u256.Uint, the value to be checked and possibly truncated. Returns: - \*u256.Uint: A value guaranteed to fit within the uint128 range. Notes: - The function first checks if the value is not nil to avoid potential runtime errors. - The mask ensures that only the lower 128 bits of the value are retained. - If the input value is already within the uint128 range, it is returned unchanged. - If masking is required, a new instance is returned without modifying the input. - MAX\_UINT128 is a constant representing \`2^128 - 1\`.

u256Min

u256Min returns the smaller of two \*u256.Uint values. This function compares two unsigned 256-bit integers and returns the smaller of the two. If \`num1\` is less than \`num2\`, it returns \`num1\`; otherwise, it returns \`num2\`. Parameters: - num1 (\*u256.Uint): The first unsigned 256-bit integer. - num2 (\*u256.Uint): The second unsigned 256-bit integer. Returns: - \*u256.Uint: The smaller of \`num1\` and \`num2\`. Notes: - This function uses the \`Lt\` (less than) method of \`\*u256.Uint\` to perform the comparison. - The function assumes both input values are non-nil. If nil inputs are possible in the usage context, additional validation may be needed. Example: smaller := u256Min(u256.MustFromDecimal("10"), u256.MustFromDecimal("20")) // Returns 10 smaller := u256Min(u256.MustFromDecimal("30"), u256.MustFromDecimal("20")) // Returns 20

checkOverFlowInt128

checkOverFlowInt128 checks if the value overflows the int128 range.

checkTickSpacing

checkTickSpacing checks if the tick is divisible by the tickSpacing.