How a cycle actually settles.

A vault is a contract you own. It holds quote capital and nothing else can move it. A plan is an instruction inside that vault: buy this asset, this much, this often, never above this price. A keeper is an address permitted to trigger a plan when its window opens — and permitted to do nothing else.

Vaults are EIP-1167 minimal proxies deployed by the registry, so creating one costs a fraction of a full deployment. The implementation is immutable and unowned; there is no proxy admin and no upgrade path.

Every execution must clear a floor computed on chain, and the floor is the tighter of two independent constraints:

Your limit price

The highest price you are willing to pay, stored on the plan. Nobody but you can change it.

The oracle band

The registry's Chainlink feed for that asset, less your slippage tolerance. Chainlink is Robinhood Chain's official oracle; Pyth is not deployed there.

The keeper supplies its own minOut from the live route, but the contract takes whichever floor is higher. A keeper passing zero cannot execute below your guard. A plan with neither a limit price nor a feed is never executable at all — it reports Unguarded rather than trading blind.

Output is measured as the vault’s own balance delta before and after the swap, so a router that reports one number and delivers another is caught by arithmetic rather than by trust.

Protocol fee ceiling

0.50% — a compiled-in constant, not a governance parameter

Maximum slippage tolerance

10%

Interval range

1 hour to 1 year

Withdrawal

Never blocked — not by a vault pause, not by a protocol halt, not by a dead oracle

Ownership transfer

Two-step, so a mistyped address cannot orphan a vault

Chainlink’s tokenized-equity feeds run us_equities_24/5 with a 24-hour heartbeat. Outside market hours the last answer ages, and once it passes the registry’s freshness window the vault reports Awaiting market and refuses to execute.

This is deliberate rather than a limitation. On-chain liquidity for an equity is thinnest exactly when the underlying market is shut, which is when a scheduled buy would fill worst. Waiting for the open is the correct behaviour, and the cadence is preserved: the window stays open until the execution happens.

Balances, plans, readiness

Direct contract reads over JSON-RPC. No intermediary.

Execution history

Blockscout's indexed log API, with a bounded eth_getLogs fallback. The interface states which one answered.

Reference price

The same Chainlink aggregator the on-chain guard consults — so the price on screen is the price enforcing the trade.

Swap routes

0x Swap API v2 on mainnet. Testnet has no aggregator at all, so a simulated router is used and labelled.

Robinhood Chain produces a block roughly every 100ms. A naïve month-long eth_getLogs scan would be tens of millions of blocks, which is why history comes from an indexer and the RPC fallback is explicitly bounded and says so.

Neither Chainlink Automation nor Gelato supports Robinhood Chain. There is no managed keeper available for this network, so TIDE ships its own — a stateless script in /keeper that can run from GitHub Actions, a small VPS, or your own machine.

You can also execute by hand from the terminal at any time. The contract permits the vault owner to call execute directly, which matters on a chain where the only automation is one you run yourself.

No registry is configured for Robinhood Chain Testnet in this build.

Open the terminal →