How Kelpie works

What is Kelpie

Kelpie runs a concentrated liquidity position for you. You choose a pool, a range width, and how patient you want it to be. Kelpie opens the position, collects the fees it earns, and moves the range back to the market when the price walks away from it.

The problem it solves is specific. Concentrated liquidity pays far more than passive liquidity, but only while the price sits inside your range. Outside it, the position earns exactly nothing and has quietly converted entirely into one of the two tokens. Managing that by hand means watching a chart and paying gas at the worst possible moments. Kelpie does the watching.

Kelpie manages the position, not the venue. It runs on SuiDex V3 and on Cetus today, as two separate Move packages with the same behaviour, and the same vault runs on any concentrated liquidity DEX once its adapter lands. Which venue a vault sits on is chosen when it is opened and does not change afterwards — the position belongs to that pool.

What your vault owns

Your vault is a single on-chain object that holds one position: yours. Nothing is pooled, and there is no share token, no basket, and no accounting layer between you and the liquidity. When you deposit, a position is opened and placed inside a vault created for you. When you withdraw, that same position comes back out. You can also add to a live position at any time, or take a chosen share of it back — the vault keeps running on the rest.

Non-custodial. Kelpie binds your range, never your money. Authority is a capability object, a VaultOwnerCap transferred to your wallet when the vault is created. It is checked against the specific vault it was minted for, so it opens yours and nothing else. Hold it and you can withdraw — in full or in part — add more, reconfigure, harvest and claim.

Administrative powers exist and they are boxed in. An admin can pause new vaults and rebalancing, add or remove pools from the allowlist, revoke keepers, and set the fee and risk parameters. Every one of those is capped by a constant compiled into the package, and none of them touch a vault's balances or its position.

Why a range earns more

In a constant-product pool your capital is spread across every price from zero to infinity, and almost all of it is never used. Concentrating it into a band means the same money provides far more depth where trading actually happens, and it collects a proportionally larger share of the fees.

The multiplier is a function of width alone. A position spanning a band is roughly this many times more capital-efficient than the same money spread across the full curve:

That is the whole trade. Narrower earns more per dollar and leaves range sooner; wider earns less and sits still. Kelpie does not remove the trade-off. It removes the cost of being on the wrong side of it, by putting the range back rather than leaving you idle until you notice.

How re-ranging works

A keeper watches your vault and re-ranges it when the price has left your band. It holds a capability that permits exactly one thing: replacing the position's range. It cannot withdraw, cannot change your settings, cannot choose where the money goes, and cannot widen or narrow the band you configured.

A re-range is two transactions, separated on purpose. The first only records that the position is out of range and starts a timer. The second moves the range, and only runs after your configured delay. To force a re-range at a fake price, an attacker must hold the pool at that price throughout, while arbitrage traders are paid to correct it. That is expensive, not free.

Every re-range is checked on chain before it is allowed to close:

• Value bound. The position afterwards must be worth at least the position before, less a small tolerance, priced at a single snapshot so market drift is not mistaken for loss. Breach it and the transaction reverts.
• Width lock. The new range must be exactly the width you configured.
• Placement bound. The new range may not sit arbitrarily far from the one it replaced.
• Price stability. The pool price may not have moved materially within the transaction, which is what a sandwiched swap would need.
• Interval floor. A vault cannot be re-ranged again immediately, whatever the keeper thinks.
• Daily loss cap. Each vault carries a rolling limit on what re-ranging may cost it per day. Whatever else fails — a hostile keeper included — crossing it reverts.

You can also re-range yourself, with your own capability, once the position has been out of range long enough. The keeper is a convenience, not a dependency.

Where prices come from

Kelpie consults no external price feed, and that is a decision rather than an omission. Two different things need a price: the contract, when it decides whether a re-range may settle, and this site, when it puts a dollar figure on screen. They are answered differently, and both are worth setting out plainly.

In the contract

The contract reads the pool's own price, on chain, inside the transaction it is acting in. The value bound described above is relative: the position is valued before the re-range and after it against a single price snapshot taken within that one transaction. A manipulated price therefore moves both sides of the comparison and largely cancels out of it.

That is the reason no external feed is needed for safety. The bound measures the change the re-range itself causes, not the level the price happens to be at, so it does not need an independent opinion about that level. Around it sit the other checks: the pool price may not move materially within the transaction, the width is locked to the one you configured, the new range may not sit arbitrarily far from the old one, and the two-transaction delay means a false price would have to be held across both moments against arbitrage.

In this site

Dollar figures are derived from on-chain pool prices. A pool quoted in USDC carries, in its own state, the dollar price of the other token: square the pool's square-root price, adjust for the two tokens' decimals, and the number is already there. No service is involved. USDC is the only thing treated as a dollar; every other stablecoin, USDSUI included, is priced from its own pool rather than assumed to be worth one. A token that cannot be reached within two pools of the dollar gets no price at all.

Sui's own guidance notes that prices shown in a UI, a wallet or an indexer can lag the on-chain state. A figure read from the pool does not lag it, because it is read at the same moment the position is. The trade is that a single reading reflects a single instant, and a well-capitalised actor can move a pool for one block.

So the two sources are used against each other. Each chain-derived price is cross-checked against SuiDex's indexer, which is averaged over time and so does not follow a one-block spike. Where they agree to within 2%, the chain figure stands, because it is the fresher of the two. Where they disagree by more, the lower is shown and the page says so. Measured live on mainnet the two agree far more closely than that: SUI, wBTC, USDC and USDSUI all sat within 0.21% of each other. This is display only. Nothing here gates a transaction, and the contract does its own checking without consulting it.

Statistics that genuinely need history stay on the indexer, since a single chain read cannot produce them: fee APR, fees over the last 24 hours, pool TVL and pool liquidity. When the indexer cannot be reached those columns show a dash. Position values, uncollected fees and PnL are priced from chain and keep working.

The adapter that is not switched on

The vault package ships price_guard.move, a provider-neutral oracle adapter. It defines one normalised Price type carrying magnitude, exponent, confidence and timestamp, so a Pyth reader and a Switchboard reader would return the same type and reuse the same guards without a single consumer changing. The guards are the ones Sui documents: assert_fresh for staleness, assert_confidence for a blown-out confidence interval, assert_within_deviation for a depeg or a single-feed spike, and assert_pool_matches_reference composing all three into one call. It carries 11 tests.

It is deliberately not wired into any active path. Switching on a live feed would introduce staleness and feed downtime as new ways for a re-range to fail, in order to defend against an attack the layered design above already makes expensive to attempt. The module is written and tested, not deployed in an active path, and it is ready if that trade ever changes.

What this follows

This is Sui Foundation best practice, named rather than gestured at, so each part can be checked:

• A provider-neutral adapter exposing one normalised price type, so consumers never see a provider-specific struct. That is the Move adapter pattern, and it is what price_guard.move is.
• Staleness, confidence and deviation guards on any consumed price, per Sui's oracle safety guidance. All three are implemented and tested in that module.
• Defined behaviour when data is missing rather than a guess. A token neither source can price shows a dash, and a statistic the indexer cannot supply shows a dash, all the way to the screen.
• A deviation cross-check between an instantaneous reading and a time-averaged one, which is how DeepBook Margin validates a spot price. The 2% bound above is that pattern, applied to what is displayed.

Compounding

Trading fees accumulate outside the position as claimable balances; they do not earn anything until they are put back to work. With compounding on, Kelpie folds them into the position rather than paying them out, so the next fee is earned on a slightly larger base.

With compounding off, fees are paid to your wallet instead, and the Harvest action becomes available for collecting them between re-ranges. A position that never leaves its range never re-ranges, which is exactly when harvesting matters.

Incentive rewards

Some pools pay a bonus token on top of trading fees. These are a large part of the return. On a stable pool they can be most of it, because the trading fees on a stable pair are thin by design.

Rewards in a token the pool does not itself hold are always paid to you rather than reinvested, because they cannot be added to the position without first being traded, and Kelpie does not trade your assets on your behalf. Rewards that are one of the pool's two tokens follow your compounding setting.

You can claim at any time, in range or out, without re-ranging and without withdrawing.

Choosing a configuration

Three settings matter, and they interact. There is no correct answer, only a position on the trade-off.

Width sets how hard your capital works and how often it stops. On a stable pair the price barely travels, so a very tight band stays in range and earns many multiples of a wide one. A band wide enough to never re-range on a stable pair is a band earning almost nothing. On a volatile pair the reverse applies: too tight and you spend the day chasing price and crossing the spread.

Delay is how long the position must sit out of range before it is moved. A short delay follows the market closely and re-ranges often. A long delay waits to see whether the move was real, which avoids re-ranging into a spike that immediately reverses. Every re-range costs the spread, so patience is not free but neither is haste.

Auto-rebalance can be turned off entirely, leaving the position where it is. That turns your vault into a deliberate one-sided position, useful if you actually want to be converted into the other token at a price you chose.

Fees

Kelpie takes 15% of the yield it produces, and nothing else. There is no management fee, no deposit fee and no withdrawal fee.

The 15% is charged on trading fees and rewards only, so it never touches your deposit. Earn nothing and you pay nothing. Of that 15%, 3 points go to referrals; the rest pays the gas Kelpie burns re-ranging your position and the cost of running the platform. You pay Sui gas for your own transactions, and Kelpie pays for every re-range it makes.

The live rate can be read on chain at any time, and the two arms keep it in different places: the SuiDex vault charges from its own registry, and the Cetus vault charges from the shared controller. Both are listed below and both currently read 15%, with 3 points of it going to referrals. Each package caps the rate at 20%, so neither can ever go higher than that.

Referrals

Send someone to Kelpie and you earn 3% of the yield their vault produces, for as long as it runs.

It costs them nothing. The referral share is carved out of Kelpie's 15%, not added on top of it, so a referred vault pays exactly what an unreferred one pays. Your 3 points come out of Kelpie's 15, not out of your referral's return.

Payment is automatic and immediate. The referrer is recorded on the vault when it is opened, and every time that vault skims yield or claims a reward the split happens inside the same transaction: your share lands in your wallet, in the token that was earned. Nothing to claim, no balance to track, no schedule to wait for.

A vault's referrer is fixed at the moment it is created and cannot be changed afterwards. Referring yourself pays nothing, and the contract drops a referrer address that matches the sender.

Things to weigh up

Concentrated liquidity pays because it takes real market exposure. Three things are worth understanding before you size a position.

• Divergence loss is real and re-ranging can realise it. When the price moves through your band you end up holding more of the token that fell. Moving the range to follow the price converts at that moment rather than waiting for a recovery. In a sustained trend, an actively managed range can finish behind simply holding the two tokens. Fees and rewards are what you are paid to take that risk; they do not always cover it.
• A thin pool costs more to enter and to move. Every re-range crosses the spread. On an illiquid pool that cost can outrun the fees earned.
• Out of range means zero. Between leaving your band and being moved, the position earns nothing at all. A long delay is a deliberate choice to accept more of this.

Contract reference

Live on Sui mainnet, and every object below is readable on chain. Each venue is its own package with its own registry and its own allowlist of pools; they share one controller, which is where the fee and the risk bounds live.