Docs

Ilyra is a token launch protocol where yield is conditional. A creator launches a token and defines a proof — something measurable that has to happen. Until the proof is verified onchain, the token's yield mechanism stays off.

It sits somewhere between an option, a yield market, an onchain hook and a token launchpad — but the mechanic is only three parts.

A proof is a condition with a verifiable data source. Ilyra supports these proof kinds:

Every proof is stored onchain as a ProofSpec:

struct ProofSpec {
  ProofKind kind;     // see table
  address  adapter;   // data adapter (e.g. ChainlinkPriceAdapter)
  bytes32  subject;   // keccak256(symbol) for feeds, or feed address
  int256   target;    // 8-decimal USD, bps for % moves, unix ts for time
  uint64   window;    // seconds the condition must hold (0 = single round)
  uint64   deadline;  // 0 = none; after it the hook is disarmed
}

Proofs read as plain language everywhere in the interface: NVDA closes above $220, BTC drops 10%, Token reaches $10M volume.

A hook is what happens once the proof is verified. It is a list of legs, each routing a share of trading fees somewhere, plus an active window.

struct HookLeg  { HookKind kind; uint16 bps; address target; }
struct HookSpec { HookLeg[] legs; uint64 duration; }

Legs may split fees between several destinations; total bps cannot exceed 10,000. Unallocated fees stay in the vault as reserves.

A token moves through three states. Nothing flows until the last one.

Off: trading fees accrue in the token's fee vault. Verified: the ProofRegistry records the proof. On: the HookExecutor fires and fees route according to the hook for its active window. When the window ends, yield stops and the vault returns to accruing.

A launch is a single transaction to IlyraFactory.launch(params, proof, hook). The factory deploys the token, registers the proof and arms the hook atomically.

struct TokenParams {
  string  name;
  string  symbol;
  string  metadataURI;          // data: URI or https URL
  uint256 totalSupply;          // 18 decimals
  uint16  creatorAllocationBps; // ≤ 2000
  uint16  tradingFeeBps;        // 10–500
}

The launch flow in the app builds exactly this calldata. You can inspect it on the review step before signing. Drafts are saved on your device.

Verification is permissionless. Anyone can call ProofRegistry.verify(token). The registry asks the proof's adapter for the current value, checks it against the spec, and if satisfied records verifiedAt and calls HookExecutor.fire(token) in the same transaction.

For feed-based proofs the adapter reads latestRoundData() and rejects stale rounds (older than the feed heartbeat). For windowed proofs, the condition must hold across consecutive rounds spanning the window.

The interface shows two distinct states: condition met (the latest oracle value satisfies the proof, nothing recorded yet) and verified (the registry recorded it). Only the second one activates yield.

Today Ilyra reads 21 onchain Chainlink feeds — tokenized US equities and ETFs updated 24/5, and major crypto pairs. Values shown in the app are live latestRoundData reads.

Feed addresses are taken from the Chainlink registry and re-verified before any change. Registry ↗

Events that are not carried by a price feed — earnings results, listings — need an attestation adapter. Until one is live, such proofs cannot be verified, and the app says so rather than pretending.

• Creators receive at most 20% of supply, subject to the same yield rules as everyone else.
• Trading fee is 0.1–5% of each swap, collected into the token's fee vault.
• The proof and hook are immutable after launch. There is no admin switch to turn yield on.
• A deadline is optional. If set and missed, the hook is disarmed and accrued fees are distributed to holders.
• A launch fee (in ETH) is read from the factory at launch time.

• Holding the token before the proof is verified is a position on the proof: if it verifies, the hook routes fees to you.
• Fees stream pro-rata to balances at each distribution; no staking or claiming is required for ROUTE_FEES_TO_HOLDERS.
• Anyone can trigger verification; there is no privileged keeper.
• The app shows how close a proof is to its target using the same oracle the registry uses.

IlyraFactory ──launch()──▶ IlyraToken (ERC-20 + FeeVault)
      │                          │
      ├── registers ──▶ ProofRegistry ──reads──▶ IProofAdapter
      │                          │                 └─ ChainlinkPriceAdapter
      └── arms ───────▶ HookExecutor ◀──fire()──────┘

Reference Solidity lives in /contracts of the repository. The app reads deployment addresses from environment variables; until they are set it runs in a "not deployed" mode where writes are blocked and nothing is simulated.

Ilyra runs on a single EVM network — an Arbitrum-technology L2 that settles to Ethereum, with ETH for gas and native Chainlink feeds for tokenized equities. Chain ID 4663. No other networks are supported in the product.

Browser reads go through a same-origin RPC proxy so that a private RPC key never ships to clients. Wallets sign and broadcast through their own provider. Block explorer ↗

• Oracle risk. Proofs are only as good as their feed. Equity feeds update 24/5 with a 24h heartbeat and 0.5% deviation threshold; a stale or halted feed cannot verify a proof.
• Proofs can fail. A token whose proof never verifies never earns yield. Deadlines make that outcome explicit.
• No attestation source yet. Event-based proofs are defined in the spec but cannot be verified until an adapter exists.
• Contracts are unaudited and not yet deployed. Nothing in the app fabricates onchain state while that is true.
• Fee-based yield is variable. Yield depends entirely on trading activity during the active window. There is no fixed APY, by design.
• Public RPC limits. The default RPC is rate-limited; production deployments should configure a dedicated endpoint.