Documentation

Introduction #

Most portfolios do nothing while you sleep. Cash sits idle, risk assets ride out every drawdown, and the disciplined moves (trimming into danger, re-entering when it clears) are exactly the ones humans are worst at making unemotionally.

NYXAR turns a portfolio into a rules-based, always-on index. You define a policy once: a target mix, a safety floor, how aggressively to shelter and how gradually to re-enter. An agent then watches the market 24/7 and rebalances your vault inside those limits, on decentralized markets that never close. It never takes custody: your assets live in a vault only your wallet can withdraw from.

How NYXAR works #

NYXAR is built in three layers that sit on top of each other inside your vault:

1 · Yield-bearing base

Every dollar you deposit is put to work immediately. Base capital is supplied to USDC lending on Kamino, targeting roughly 7% APY on dollar-backed assets. The interest-bearing receipt tokens become the collateral foundation the growth sleeves are built on, so nothing sits idle.

2 · Growth sleeves

On top of the base, the agent holds a target mix across three sleeves: equities (tokenized stocks & ETFs, such as xStocks), crypto (SOL, BTC, ETH) and USDC (the dollar base supplied to Kamino). The split is set by your chosen strategy and is what the agent steers back toward as prices drift.

3 · Flight to safety

Continuously, the agent computes the NYXAR Score, a composite read on market regime. When the score crosses your shelter threshold, the agent rotates risk assets into USDC on Kamino (safe yield), in stages. When the regime clears, it rebuilds risk gradually. Exiting is only 20% of the job; the disciplined re-entry is where long-term returns are actually made.

// the agent runs this continuously, per vault
const score  = nyxarScore()            // regime read, 0 to 100
const target = policy.targetFor(score) // your mix, adjusted for regime
const drift  = current.vs(target)

if (Math.abs(drift) > policy.band && cooldownElapsed())
  vault.rebalance(...)                 // one Jupiter route, inside your caps

Quickstart #

Creating your first vault takes about two minutes. You’ll need a Solana wallet (Phantom, Solflare, Backpack or any wallet-standard wallet) and a little SOL for fees.

1. Connect your wallet. Open the app and connect on Solana. No wallet handy? Use “Explore in demo mode” to look around first.
2. Pick an amount and a strategy. Choose how much to fund and one of the presets: Preserver, Balanced or Growth (see Strategies).
3. Set your autonomy level. Advisor, Copilot or Autopilot: how much the agent may do on its own (see Autonomy levels).
4. Sign & create. One signature writes your policy; one transaction creates your vault and funds it. Creating the vault costs a fraction of a cent in SOL fees, separate from your deposit.
5. You’re live. If you chose Autopilot, the agent is appointed at creation and starts managing immediately. Watch it from your dashboard; withdraw or revoke anytime.

The NYXAR Score #

The NYXAR Score is a single number from 0 to 100 that estimates how dangerous the current market regime is. Low is calm; high is stormy. It’s a composite, deliberately not a single price trigger, so it’s slow to panic and hard to whipsaw.

What it measures

Regime bands

Flight to safety #

“Flight to safety” is NYXAR’s core behavior, and it’s what separates it from a stop-loss. A stop-loss is a single price trigger that fires once, blind to context, usually into the worst liquidity of the day. NYXAR’s flight-to-safety:

• De-risks in stages as the regime deteriorates, rather than dumping everything at one price.
• Earns yield on what it shelters. Value rotates into USDC supplied to Kamino lending, not idle cash.
• Avoids whipsaw with hysteresis. Separate shelter and re-entry thresholds mean it doesn’t churn on noise.
• Re-enters gradually when the regime clears, on the schedule your policy sets.

Vaults #

A vault is your own on-chain account: a program-derived account (PDA) created for your wallet, holding your funds under a policy the agent must obey. Most people run more than one: a cautious core, a braver satellite.

Creating a vault

From the app, choose an amount and a strategy, set your autonomy level, then sign and create. Under the hood, the factory instruction derives a fresh vault PDA owned by your wallet, with the token whitelist and the routing venue preconfigured. If you fund with SOL, it is wrapped to wSOL inside the vault in the same transaction.

Funding & withdrawing

Add funds anytime by sending USDC, wSOL or SOL to your vault’s address, or via the Deposit action. Only you can withdraw: withdraw_token and withdraw_sol are owner-only and send straight back to your wallet. There are no lockups and no exit fees.

Closing a vault

The app’s Close vault action withdraws every asset back to your wallet, revokes the agent, and closes the vault’s accounts, and the rent deposit returns to you. A closed vault stops appearing on your dashboard.

Strategies #

Strategies are presets for your target mix and how aggressively you shelter and re-enter. Pick one as a starting point, then fine-tune the policy.

Custom policy

Beyond the presets you control: the target mix, a safety floor (minimum % always in USDC), the shelter threshold (the NYXAR Score at which de-risking begins), re-entry speed, and the asset whitelist. The agent can trade nothing outside it.

Autonomy levels #

You choose how much the agent may do on its own. All three stay inside your policy and caps. The difference is who presses “go”.

The agent #

The agent is NYXAR’s off-chain brain. It’s an always-on service that, each tick (about every 10 minutes):

• computes the live NYXAR Score from market data and Pyth price feeds;
• discovers the vaults that have appointed its key;
• reads each vault’s real on-chain balances;
• computes the target allocation from the vault’s policy and the score;
• if the vault has drifted past its band and the on-chain cooldown has elapsed, submits one rebalance: a real Jupiter route the vault executes on itself.

The agent key is powerful only in a narrow way: it can call rebalance within the vault’s hard caps, and nothing else. It cannot withdraw a cent. Losing the agent key is not the same as losing funds. The worst case is that the vault stops rebalancing until you appoint a new agent or manage it manually.

Non-custody model #

NYXAR is non-custodial by construction. Your assets are held in a vault account derived for your wallet. The agent receives delegated trading rights only. They are scoped to a whitelist of assets and a single routing venue, capped by your policy, and revocable in one transaction.

Control boundary #

Three parties, three roles, and the program is the police.

The on-chain caps that back this up:

Yield & risk #

The base lending layer is USDC supplied to Kamino lending on Solana. That is the yield foundation of the portfolio. It is variable, set by market conditions, and not a guaranteed or insured rate.

The growth sleeves, tokenized stocks and crypto, carry normal market risk. That’s precisely the part NYXAR’s flight-to-safety logic actively manages, but it does not remove it. Nothing here is FDIC or SIPC coverage, and no strategy removes market risk entirely.

Network & addresses #

NYXAR runs on Solana mainnet-beta.

Vault program #

Each vault is an account owned by the NYXAR vault program and controlled by the wallet that created it. Owner-only instructions manage funds and policy; the appointed agent may only call rebalance.

Owner instructions

Agent instruction

// callable only by the appointed agent, only within the caps below
pub fn rebalance(
    ctx: Context<Rebalance>,
    mint_in:   Pubkey,
    mint_out:  Pubkey,
    amount_in: u64,
    min_out:   u64,
    route:     RouteData,   // Jupiter route, executed via CPI
) -> Result<u64>

View helpers

The vault account exposes owner, agent, paused, max_trade_bps, cooldown, last_trade_at and the whitelist, all readable from any RPC without a transaction.

Vault factory #

Vault creation is permissionless: the program has no admin and takes no fees. Anyone can create a vault they own.

const program = new anchor.Program(IDL, PROGRAM_ID, provider)
const sig = await program.methods
  .createVaultWithSol(policyHash, NYXAR_AGENT, new BN(0.5 * LAMPORTS_PER_SOL))
  .accounts({ owner: wallet.publicKey })
  .rpc()                       // VaultCreated → your new vault PDA

Policy & signing #

Your policy (target mix, thresholds, re-entry, autonomy) is expressed as structured data and signed by your wallet as an off-chain message (Ed25519, sign-in-with-Solana style). The signature is free and moves nothing; it proves you authored the policy. The vault stores only the hash of the policy on-chain, so anyone can verify a policy against its hash and recover your address from the signature.

Rebalance mechanics #

When the agent rebalances, the vault performs the swap on itself through the routing venue. Every call is bounded:

• Direction & size come from the drift between current and target allocation. The agent moves a fraction of the gap, never the whole balance.
• Per-trade cap (max_trade_bps) hard-limits amount_in to a share of the input balance.
• Cooldown (cooldown vs last_trade_at) blocks trades that are too frequent.
• Slippage floor (min_out) is derived from the live quote; the transaction fails if it can’t be met.
• Whitelist: both mint_in and mint_out must be allowed, or the instruction fails.

Proceeds always stay inside the vault. There is no path for a rebalance to send value anywhere but back into your vault’s own balance.

Glossary #

Links #

• NYXAR app: create and manage vaults.
• Main site: what NYXAR does, and the live demo.
• @NyxarProtocol on X: announcements, and the only place the contract address is posted.
• Solscan: verify programs and transactions at launch.