peard
The registry side

Pairables and grades

A thing with a number, and the grade that fixes what it may promise.


A Pairable is a thing with a number: an id, a unit label, a resolver, a grade, an EMA-smoothed price_twap in USD e6 per one unit, a breaker and staleness config, a risk badge, and an optional asset_mint.

The id is the PDA seed, which makes the name canonical. There is exactly one PEAR-EA and it cannot be shadowed.

seeds = [b"pairable", id]        // id is ASCII, right-padded to 32 bytes

A pairable is not per token. Pairable.market_count counts how many launched tokens point at each one, and many markets can share a pairable. That is the whole reason the registry is a separate account from the market: the pairable outlives every market on it, the market outlives every position in it, and the pool is a different program that can be replaced without either of the others noticing. Fusing any two of them would make the shorter-lived thing's lifecycle the longer-lived thing's problem.

pairables/seed.json carries 111 entries as of 2026-08-25.

The three grades

Grade fixes what a pairable is allowed to promise.

HARD

A real, liquid token exists on chain, so the vault can hold it. 44 entries on 2026-08-25.

INDEX

Just a number. The vault holds dollars and coverage floats. 67 entries on 2026-08-25.

SOFT

No token, but a real price and genuine short interest. Rejected at registration today.

HARD is not simply better than INDEX

It trades coverage risk for issuer risk.

Every xStock and PAXG is a Token-2022 mint whose issuer kept a permanentDelegate (a clawback) and usually a pausableConfig (a freeze switch) over the very tokens that would sit in the vault. Read off the mainnet mint accounts on 2026-08-25, across the 44 hard entries: permanentDelegate on 32, an empty transferHook slot on 32, pausableConfig on 31, defaultAccountState on 31, scaledUiAmountConfig on 31, and interestBearingConfig on 3. Nine of the 44 are classic SPL mints carrying no extensions at all.

Different risk, not less of it. npm run verify-mints reads those powers off chain so the UI can say which. See How assets are verified.

HARD is not a separate product either: it is INDEX with a hedged vault, the same ledger and the same claim path. An INDEX pairable that later gets tokenised upgrades in place without redeploying a market, though "upgrade" is the wrong word for a move that swaps drift you can measure for an issuer you have to trust.

SOFT is refused rather than faked

require!(grade != Grade::Soft, Err::GradeUnsupported);

register_pairable rejects Soft today rather than minting a badge nothing can honour. Supporting it means lifting floorlaunch's CDP and funding engine wholesale, and it is last on the list because it carries all the risk and serves the fewest markets.

The invariant that makes the grade check mean anything

require!((grade == Grade::Hard) == (asset_mint != Pubkey::default()),
         Err::GradeAssetMismatch);

Hard grade and a real mint imply each other. A grade badge promising redemption is only issuable against something redeemable, and a registered asset mint nobody can quote against is dead weight.

Vetting is by address, and the address is curated

Three rules, in the order they were learned.

1
Symbol: never

There are a dozen mints called SPYx and eleven of them are pump launches with $2k behind them.

2
Liquidity alone: necessary, not sufficient

The deepest thing matching the query "USDC" on Jupiter is jlUSDC, a yield-bearing wrapper. Picking by depth would have quoted every denominated market against the wrong mint.

3
So the mint address is the identity

It is pinned by hand in pairables/seed.json, and liquidity is used to verify a pin still has depth rather than to discover which address to use. relayer/src/verify-mints.ts runs that check and reports rather than edits, because demoting a pairable out of hard grade affects live markets.

The deepest hard entries are staked dollars (syrupUSDC at $11.7m, eUSX at $8.2m, USDY at $2.9m), tokenised reinsurance (OnRe ONYC at $5.5m), private credit (Hastra PRIME, Huma PST), thirty tokenised equities, three Etherfuse sovereign bonds, gold via PAXG at $518k, and EURC as the only non-USD currency with a real market behind it.

A depth claim is only as good as its date

KO used to be the standing example of what cannot be hard-quoted, on the grounds that the deepest mint trading as KOx was a pump launch. That stopped being true. A genuine Backed KOx exists at XsaBXg8dU5cPM6ehmVctMkVqoiRG2ZjMo1cyBJ3AykQ carrying $21,609, which clears the $20,000 floor, so KO was promoted to hard grade on 2026-08-25 and the market can hold the real thing instead of only tracking it.

The example was worth keeping even though it inverted, because the lesson survives its own reversal. The old sentence was true when it was written and wrong eight months later, and nothing in the registry would have noticed. Hard entries therefore carry an assetLiquidityUsdAsOf with a date on it for exactly this reason: 25 entries dated 2026-08-24, 13 dated 2026-08-25, and 5 dated 2026-08-17. SOL is the one hard entry with no dated figure at all.

The lesson cuts the other way too. On the same day, TESOURO and SLV were demoted out of hard grade when a live quote found no route at $25,000, which is why the tier is 44 rather than 46.

The pairing with COKE-20OZ is still deliberate and still the joke: the stock and the bottle are different pairables, and only one of them can be shipped.

A pairable must fix every dimension that materially moves its number

This is the general rule, and it came out of two specific failures.

The unit is somebody else's definition, not an invented conversion

USDA quotes pears by carton and by size count, so "D'Anjou 80s at $48.00" means 80 pears in a 4/5 bushel carton and $0.60 a pear falls straight out of the published row. One pear is a legitimate unit because someone else already defined it.

Not every pairable is a price

valuation says how to read the index. 97 entries are price: one unit is a real purchasable quantity and the index is its dollar price. 12 are scalar: the thing has no price at all, one unit is the whole measurement, and its current level is used directly as a dollar-equivalent index. Two are rate.

Scalar pairables never render with a $. Drake's monthly listeners and the Phoenix daily high are measurements used as a dollar-equivalent index. Printing $78M in front of one asserts a price for a Spotify listener, which is exactly the claim the registry refuses to make. A scalar pairing is a ratio, never a price, and the app enforces this.

valuation lives only in the registry file and never on chain, which is why scripts/launch.ts checks it in preflight: it is the one check the programs cannot make.