Helico VaultA walkthrough, not a live account. The numbers are ones the project recorded.
Built with
A Program That Cannot Break Your Rules
You set the rules. The program decides. The contract checks. Nothing moves otherwise.
- Which marketETH and ARB nowhere elseline 489 ↗
- How widenarrow, 20 steps never wider or narrowerline 733 ↗
- Worth the moveat least 0.5% closer or it stays putline 747 ↗
- How oftenonce an hour at most no churningline 473 ↗
- How much at oncea fixed cap per moveline 486 ↗
- Until when30 days then nothing movesline 468 ↗
- How much to keepat least 90% checked after the moveline 718 ↗
- Where the price isinside the band or it earns nothingline 739 ↗
Break any of these and the contract rejects the move. There is no other way in.
- Market
- ETH and ARB, on the Uniswap exchange, on the Arbitrum network
- Band
- a narrow band of prices, 20 steps wide
- Price now
- inside the band, so your funds are earning
- Last move
- kept 94.3% of the funds working, as in the rehearsal
- Cooldown
- until 15:32; no move can happen before then
- Owner
- you; the funds stay in your wallet and the contract may only move them
- Reads
- the market's price and your funds, from inside a sealed environment
- Checks
- that the rules it was given are the rules the contract holds; if not, it stops
- Decides
- to wait while the price is inside the band or the cooldown runs; otherwise, a new band of your chosen width around the price
- Sizes
- the exchange that covers both sides of the new band, and what goes back in
- Leaves
- only the decision, signed with a key that never leaves the sealed environment
- Holds
- a fingerprint of your rules, never the rules themselves
- Checks
- that the decision matches your rules, then every rule again: market, width, worth it, how often, cap, expiry, share kept, price inside
- Moves
- takes the funds out, exchanges only what the new band needs, puts them back in, all in one step
- Ends
- holding nothing; whatever the move did not use goes back to you
- Refuses
- anything else; there is no other way in
- Rehearsal
- on a snapshot of the real market, an automated decision moved real funds that had drifted out of their band
- Kept
- 94.3% of the funds working; the rules demanded at least 50%
- Second run
- correctly did nothing, because the cooldown was running
- Tests
- 240+ automated tests, 11 of them on a snapshot of the real market
- Caveats
- a snapshot, not the live network; the sealed environment was simulated; nothing is deployed yet
An example, not a live account. Nothing is deployed yet; the seven rules are the ones the contract stores.
Rules for every style.
Move often or rarely. Keep more or less. You pick once, and the contract stops everything else.
Active
Stays close to the price and moves often.
Relaxed
Moves only when the price has clearly drifted away.
Cautious
Moves only when it clearly pays, and keeps almost everything.
Built in the Open
Every line is public: the contract, the program that decides, and the tests for both.
_checkRange · open on GitHub ↗function _checkRange(Mandate memory m, PoolKey memory key, uint256 info, int24 tickLower, int24 tickUpper)
internal
view
{
if (tickLower >= tickUpper) revert TicksNotOrdered();
if (tickLower % key.tickSpacing != 0 || tickUpper % key.tickSpacing != 0) revert TicksNotSpaced();
// Exactly the committed width. `setMandate` already refused a width that is not a whole
// number of spacings, so there is nothing left to snap - and snapping here is how a
// user ends up in a range they did not agree to.
if (tickUpper - tickLower != int24(uint24(m.rangeWidthTicks))) revert RangeWidthMismatch();
(, int24 current,,) = stateView.getSlot0(m.poolId);
// Liquidity outside the range earns nothing. Constraining width without constraining
// location leaves the whole product open to a band parked where no trade will reach it.
if (current < tickLower || current >= tickUpper) revert RangeOffMarket();
// And it has to be worth doing. Without this, an agent can move the range sideways
// every cooldown for as long as the mandate lasts, paying gas and fees out of the
// user's position each time.
uint256 gapNow = _gapToCentre(current, _tickLower(info), _tickUpper(info));
uint256 gapNext = _gapToCentre(current, tickLower, tickUpper);
if (gapNext >= gapNow) revert NotEnoughImprovement();
if (gapNext * BPS > gapNow * (BPS - uint256(m.minImprovementBps))) revert NotEnoughImprovement();
}Open by default.
The code above is the actual check the contract runs, read from the source when this page is built. Every count below points at the code that proves it.
Reads pools and positions from the SDK's own address maps, on any chain in config.
Read the source ↗Decides, sizes, and signs inside the enclave. The key never leaves it.
Read the source ↗Enforces the mandate on chain, with the swap inside its own lock. 11 of them run on a fork of Arbitrum One.
Read the source ↗Your Money Stays Yours
It can move your funds. It can never keep them.
Your funds stay in your wallet.
The contract moves them for one step, and proves it kept none before that step ends.
Break a rule and the move is refused.
The contract checks every rule itself. 240+ automated checks run on every change.
All of the code is public.
Twelve automated reviewers went over it. That is not a professional audit, and nothing is live yet.
94% kept working.
In a rehearsal on a copy of the real market, funds that had drifted out of their band were moved back with 94% still working. The rules asked for at least 50%. A rehearsal, not the live network.
FAQs
What is Helico, in plain words?
When you put money into a trading pool, it only earns while the price stays inside a band you chose. Prices drift, and then the money sits idle. Helico watches for that and moves your funds back into their band, under rules you write down once: which market, how wide, how often, how much must be kept. A contract checks every rule before anything moves, and blocks anything else.
What do I need to start?
A wallet, and funds already sitting in a supported market on the Arbitrum network. Helico does not create or hold them; it only moves what you already have, and only under your rules. One market at a time per wallet: to switch, you end the first yourself, so nothing is ever quietly dropped. Nothing is live yet, so today the honest answer is the code and a rehearsal on a snapshot of the market.
Who holds my money?
You do. Your funds stay in your wallet as a token that proves you own them. You give the contract permission to move them, not to keep them. A move takes your funds out, exchanges what is needed, and puts them straight back in your name. The contract holds the funds for one step and proves, before that step ends, that it kept none.
What can the automation do to it?
One thing: propose a move inside your rules. It cannot pay itself, it cannot spend more than your funds released, and it cannot send anything anywhere but back to you or into the pool. A misbehaving automation could move you within your own rules, and nothing else.
When does it do nothing?
Most of the time. It waits while your cooldown runs, and whenever a move would not bring your funds meaningfully closer to the price, because every move costs a little. And the contract refuses any instruction that does not match the rules it holds for you.
What stays private?
How the decision is made. The program that decides runs inside a sealed environment: whose funds it watches, when it looks, and how it sizes a move never leave it. The rules themselves are public on the chain, so anyone can check that a move followed them.
Is it live? Is it audited?
Neither, yet. It is built for Arbitrum One. The contract has a rehearsed deployment, and the whole flow has been run end to end on a snapshot of the real market: an automated decision moved a real position on a copy of the market and kept 94% of it working, and a second run correctly did nothing. That was a snapshot, not the live network, and the sealed environment was simulated. Twelve AI reviewers and then six more went over the contract; that is not a professional audit, and this page does not call it one.