kYUte

kYUte is a vault-backed funding hedge assistant for Hyperliquid perpetual traders. The core problem it addresses is that traders can be right on market direction and still lose meaningful returns to volatile funding payments. Managing that exposure manually is tedious: a trader has to monitor funding conditions, compare them to fixed-rate alternatives like Boros, decide whether the spread is attractive enough after fees, and then execute the hedge fast enough for it to matter. kYUte turns that into a structured workflow.

In kYUte, a user deposits collateral into a vault and can then manage their perp exposure with a clearer hedge layer around it. The system:

• monitors the user’s Hyperliquid position,
• reads recent funding data,
• fetches the relevant Boros implied APR, and
• determines whether opening, closing, or rebalancing a hedge is economically justified.

Instead of treating every position the same, it applies explicit thresholds, fee buffers, and safety checks so the hedge is only activated when conditions are favorable.

The project is designed as a full-stack prototype:

• Onchain: the vault tracks collateral, user mappings, market-specific hedge state, and controlled execution paths for syncing positions and applying hedge decisions.
• Offchain: a CRE-based execution layer gathers market data and runs the hedge policy before submitting updates back to the vault.
• Frontend: users can connect a wallet, fund a demo account, deposit collateral, inspect hedge status, and configure strategy preferences for different markets like ETH and BTC.

A key design choice in the current implementation is that live hedge execution remains deterministic and auditable. The system does not rely on an LLM to make live trading decisions. Instead, AI is used only as an assistant to help users patch or refine strategy configuration in the UI, while the actual hedge decision engine is rules-based. That makes the product easier to trust, test, and reason about, while still showcasing how AI can improve the operator experience without becoming an opaque execution risk.

kYUte is built as a multi-layer prototype spanning smart contracts, an offchain execution engine, and a web frontend. The onchain core is a Solidity vault contract built on ERC-4626 with OpenZeppelin primitives for access control and reentrancy protection. The vault stores user-to-wallet mappings and market-specific hedge state, and exposes restricted methods for syncing Hyperliquid position metadata and executing Boros hedge actions. Hedge execution is routed through a Boros router interface, while onchain guardrails enforce stale-data checks, confidence thresholds, fee-buffer requirements, and collateral-based sizing limits.

The execution layer is written in TypeScript and uses the Chainlink CRE SDK (Typescrpit) together with viem. This layer is responsible for:

• reading external market inputs,
• applying the hedge policy, and
• submitting state updates back to the vault.

It fetches Hyperliquid funding and position data from public endpoints, resolves Boros APR data, normalizes those signals into basis-point inputs, and then runs a deterministic hedge policy to decide whether to open, close, or rebalance a hedge. For local development and demo reliability, the repo also includes a direct execution path, sidecar components, and a Foundry/Anvil-based simulation flow.

The frontend is built with Next.js, React, Tailwind, Thirdweb, and viem. It includes:

• onboarding,
• dashboard views,
• a demo faucet,
• a vault deposit rail, and
• a strategy switchboard for configuring per-market hedge preferences.

The frontend talks to internal API routes for things like strategy generation, wallet nonce resolution, faucet funding, and vault state reads. Strategy preferences are persisted to Supabase so the executor and the UI share the same market-level configuration.

For local development, the project uses Foundry and Anvil to spin up a demo chain and deploy mock components such as the vault and Boros router. A helper script wires the environment together, synchronizes contract addresses into the frontend, and makes the full deposit-to-hedge flow reproducible. The result is a working end-to-end prototype that connects wallet UX, strategy configuration, offchain hedge logic, and onchain state transitions in one stack.