# Reference: Resolver Catalog

ChainRender ships a large library of resolvers — on-chain contracts that supply live data or media to your UI. All
implement `supportsKind` + `resolve`; many implement richer interfaces (`IChartData`, `ITableSource`, `IRouteSource`).

This page is a tour by family, naming the contracts. The **complete, exact list of every first-party kind** — args,
encoding, data edge, capability, and what each does not establish — is **[All Resolver Kinds](./resolver-kinds.md)**,
generated from `chainc/resolverkinds.ts` so it cannot drift. Cross-chain kinds (`xchain-balance`,
`xchain-snapshot-balance`, `xchain-adopted-balance`, `swap-lock`) are explained in
**[Proven Balances (Cross-Chain)](../concepts/cross-chain-balances.md)**.

## Data & DeFi
- **OracleFeed / Chainlink / UniswapV3Price** — live price feeds, rendered honestly (stale feeds are marked, never
  presented as current).
- **Aave reserve / ProtocolStat** — DeFi protocol state.
- **SwapFlow / ZQuoter** — swap quotes and (via `IRouteSource`/`RouteRenderer`) route diagrams of any topology.

## Identity & Privacy
- **EnsProfile** — live ENS identity as UI. **Credential / BoundCredential** — selective-disclosure + bound
  single-use credentials (ZK). **Identity** — attested claims. Unified via `IPrivacyResolver`.

## Reputation & social (session additions)
- **EfpResolver** (`efp-follows` · `efp-tag` · `efp-state` · `efp-list-size`) — reads EFP (Ethereum Follow Protocol) list
  ops on chain and replays them for a **forward** relationship to a caller-named list. Grade A (forward read, bounded
  scan). args (follows/state): `(listRecords, slot, target)`; (tag): `(listRecords, slot, target, tag)`; (size):
  `(listRecords, slot)`. Follower counts / reverse lookups are off-chain (indexer) → graded ≤ C, not offered here.
- **AddressReputationResolver** (`rep-vouch` · `rep-tally`) — renders delegated address vouches from an ownerless
  `AddressAttestationRegistry`: one attester's status, or a transparent **k-of-n** over a caller-supplied attester set.
  On-chain read; delegated meaning → grades ≤ C. Never a global score. args (vouch):
  `(registry, attester, subject, topic)`; (tally): `(registry, attesters[], subject, topic)`.
- **ReputationAggregateResolver** (`rep-aggregate`) — composes many `IReputationSource` adapters (EFP, vouches, EAS,
  ERC-725/735, future sources) into a transparent k-of-n with the grade **capped at the weakest source**. args:
  `(subject, sources[], ctxs[])`.
- **ERC-725Y / ERC-735 accounts** (the standard behind LUKSO Universal Profiles) — read an ERC-725Y data key or ERC-735
  claim today via **`staticread`** (`CallResolver`), against a **co-located** account (the chain the resolver is deployed
  on: Sepolia/Robinhood/Arc); a dedicated `Erc725ClaimResolver` is planned. Owned/mutable source → grades ≤ C. LUKSO's
  chain is **not integrated** — a `STATICCALL` is same-chain only, so live LUKSO UPs are out of reach until ChainRender
  is deployed on LUKSO.

All view-only, fail-closed ("unavailable"), ownerless, immutable, caller-supplied-address. See
[Reputation Capabilities](../concepts/reputation-capabilities.md).

## Media (all fully on-chain, grade A)
- **NftImage / Erc721Metadata** — on-chain NFT media. **GenArt / VectorArt / GradientIdenticon / Gradient** —
  deterministic generative art. **SdfScene / PointCloud** — 2D/3D scenes with a poster floor + optional GPU
  enhancement. **Geo** — fully on-chain cartography.

## Structured
- **Chart** (`IChartData`) — line/area/bar/scatter/pie. **Table** (`ITableSource`) — paginated data tables.
- **Progress / Allocation** — progress bars, allocation displays.

Every media resolver has an on-chain **poster floor** — even GPU-enhanced scenes degrade to a verifiable on-chain
image, so the app never depends on the client's GPU to stay grade A.


## DeFi & contract-read resolvers

- **UniswapV3PriceResolver** (`uniV3Price`) -- live V3 pool spot price from `slot0().sqrtPriceX96`. args: `(pool, dec0, dec1, invert)`.
- **UniswapV4PriceResolver** (`uniV4Price`) -- live V4 pool spot price via the `StateView` lens `getSlot0(poolId)` (same Q64.96 math as V3; kept alongside V3, not a replacement). args: `(stateView, poolId, dec0, dec1, invert)`.
- **CallResolver** (`staticread`) -- the generic view reader: staticcalls any contract's view function and formats the result via `ReadFormat` (uint/int/address/bool/bytes32/string). This is how you render **any Uniswap V4 hook's state** (swap counters, dynamic fees, order books) -- no special hook resolver needed. args: `(target, callData, retType, fmt, dec, frac)`.
- **MultiCallResolver** (`multiread`) -- batch several `staticread`-shaped reads into one rendered result (e.g. a hook dashboard).

All are immutable, ownerless, view-only, and **fail closed** to a fallback string on any revert or missing contract.
See [Rendering Uniswap Hooks](../concepts/rendering-uniswap-hooks.md) for the hook-rendering pattern.


## DeFi position, quote & flow resolvers (session additions)

- **UniswapV3PositionResolver** (`uniV3Position`) — an LP NFT's pair/fee/tick-range/liquidity/fees. args: `(positionManager, tokenId, field)`.
- **AavePositionResolver** (`aavePosition`) — a lending position: collateral/debt/borrowing-power/**health factor**. args: `(pool, user, field)`. field 4 = health factor (`∞` when no debt).
- **UniswapQuoteResolver** (`uniQuote`) — expected swap output before signing (QuoterV2, staticcalled). args: `(quoter, tokenIn, tokenOut, amountIn, fee, outDecimals, field)`. ESTIMATE — swap must still carry min-out.
- **ApprovalStateResolver** (`approvalState`) — Approve-vs-Swap gating via ERC-20 allowance. args: `(token, owner, spender, needed, field)`. field 0 = Approved / Needs approval / Unlimited.
- **CurvePoolResolver** (`curvePool`) — Curve get_dy quote + balances (classic int128 stable pools). args: `(pool, i, j, dx, outDecimals, field)`.
- **PortfolioResolver** (`portfolio`) — aggregated TOTAL summing many numeric reads (complements `multiread` which joins). args: `(Read[]{target,callData,mulScale,divScale}, outDecimals, field)`. Fail-closed per read (partial total).
- **UniswapV4PriceResolver** (`uniV4Price`) — live V4 pool price (StateView.getSlot0). args: `(stateView, poolId, dec0, dec1, invert)`.

All view-only, fail-closed ("unavailable"), ownerless, immutable. See [DeFi Capabilities](../concepts/defi-capabilities.md) for the full picture + the honest swap flow, and [Sepolia DeFi Addresses](../concepts/sepolia-defi-addresses.md) for which protocols exist on Sepolia.


## CoW / intent-DeFi resolvers (session additions)

Intent-based DeFi — CoW Protocol conditional/programmatic orders — rendered + verified trustlessly. Deployed on Sepolia
(where ComposableCoW lives); portable to any chain with ComposableCoW, since its address is a caller argument. Full
treatment in [Intent DeFi & CoW Protocol](../concepts/intent-defi-cow.md).

- **CowTwapResolver** (`cowTwap`) — a TWAP order's live schedule (part X/N · next-slice countdown · per-part sell/limit)
  decoded from the `TWAP.Data` definition + `block.timestamp`. Pure arithmetic, **Grade A**. Renders the definition's
  schedule, not proof of registration. args: `(twapData, sellDecimals, buyDecimals, field)`.
- **CowConditionalOrderResolver** (`cowOrder`) — live tradeability **this block** via a STATICCALL to the real
  **ComposableCoW** `getTradeableOrderWithSignature`, rendering a field of the discrete `GPv2Order` it would emit, and
  failing closed to `"not active"` when none is valid. **Grade A.** args:
  `(composableCow, owner, receiver, salt, staticInput, offchainInput, proof[], sellDecimals, buyDecimals, field)`.
- **CowIntentVerifyResolver** (`cowIntent`) — "verify what you sign": recomputes `keccak256(fullAppData)` **on chain**
  and compares it to the order's committed `appData` → `"verified"` / `"app-data mismatch"` (field 0), or the computed
  hash as hex (field 1). Integrity, never a safety verdict; fail-closed. **Grade A.** args: `(fullAppData, expected,
  field)`. The human-readable pre/post-hook plan is a ⚙ **client** decode (`webapps/lib/cr-cow-intent.js`) over the
  hash-verified document — rendered only after `"verified"`, unknown selectors marked `OPAQUE`, never "safe to sign".


## Tokenized-vault resolver (session addition)

- **VaultResolver** (`vault4626` · `vault7540`) — tokenized-vault NAV and async queue. `vault4626` renders NAV per share
  (`convertToAssets` of one share), total assets, or share supply; `vault7540` renders the ERC-7540 pending/claimable
  redeem & deposit queue. Genuine on-chain `view`s → **Grade A** on the data edge; the trust boundary is the vault's own
  accounting (stated, never hidden). Fails closed to `"unavailable"` on a non-vault/revert/degenerate decimals. args
  (4626): `(vault, assetDecimals, shareDecimals, field)`; (7540): `(vault, controller, requestId, assetDecimals,
  shareDecimals, field)`. See [RWA Capabilities](../concepts/rwa-capabilities.md).


## RWA & compliance resolvers

Real-world-asset resolvers **display** on-chain reserve, compliance, and credential state — ChainRender never *becomes*
the reserve oracle, the compliance authority, or the issuer. Reads are on-chain; where the underlying authority is
mutable (an agent-updated identity registry), the binding grades **≤ C** via the dependency axis, not the data edge.

- **ProofOfReserveResolver** (`por-coverage` · `por-reserves` · `por-supply`) — coverage% = attested reserves ÷ token
  `totalSupply`, with provenance (feed, round) + freshness and a backed / under-collateralized badge. **Grade A** (both
  reads are on-chain). args: `(reserveFeed, token, fracDigits, maxStaleSeconds)` — `maxStaleSeconds` 0 = show age but
  never assert stale; >0 = flag `STALE` past that age. Sibling kinds return the reserve (`por-reserves`) and supply
  (`por-supply`) figures. (docs/131)
- **Erc3643Resolver** (`erc3643-status` · `erc3643-verified` · `erc3643-frozen` · `erc3643-can-transfer`) — ERC-3643
  (T-REX) compliance **display**: holder verified/frozen status via the token's identity registry + `isFrozen`, and a
  `canTransfer` preview. **DISPLAY only, never enforcement** — a real transfer re-checks on chain. The identity
  registry / compliance module are **agent-mutable**, so a binding grades **≤ C (DEP_MUTABLE)**, never A, even though
  the read itself is on-chain. args (status/verified/frozen): `(token, holder)`; (can-transfer):
  `(token, from, to, amount)`. (docs/133)
- **CredentialLifecycleResolver** (`cred-status` · `cred-valid`) — issuer-bound credential lifecycle
  `VALID / EXPIRED / REVOKED / UNKNOWN` (or "issuer mismatch") from a caller-supplied `CredentialStatusRegistry`, with
  issuer-key provenance; `cred-valid` collapses it to a one-word gate. **Grade A read** (the authority behind it is what
  you trust). args: `(registry, credentialId, expectedIssuer)` — `expectedIssuer` `address(0)` disables the issuer-key
  binding check. Composes with the ZK credential kinds (anonymous membership + revocable, issuer-bound validity).
  (docs/134)

All view-only, fail-closed ("unavailable"), ownerless, immutable, caller-supplied-address. See
[RWA Capabilities](../concepts/rwa-capabilities.md) for the full picture and the display-not-enforcement discipline.

## Settlement / escrow resolver (session addition)

The programmable-settlement framework (escrow, Kiva-class lending, crowdfunding) renders through one resolver that
reads a settlement **agreement's** own on-chain state — never off-chain — and renders the honest card with the
trust-grade split the framework is built on.

- **SettlementCardResolver** (`settle-status` · `settle-principal` · `settle-repaid`) — reads a settlement agreement
  (`AttestedLoanChannel` / `LoanChannel` / any `ISettlementView`: `principal`/`totalRepaid`/`status`/`defaulted`) and
  renders principal (in asset units), repaid % (`totalRepaid ÷ principal`), and a status word
  (`funded`/`disbursed`/`settled`/`defaulted`). **Grade A** (every figure is an on-chain read), with the card
  disclosing the split in words: **escrow + distribution are on-chain ✓ · the disburse/repay legs are attested by a
  partner (≤ C), not enforced by code** — a faithful render of state that shows where trust actually sits, never
  "trustless lending". args (all kinds): `(agreement, assetDecimals, fracDigits)` — `assetDecimals` is the escrowed
  asset's decimals (18 = native ETH, 6 = USDC). Fails closed to "unavailable". (docs/172 §8/§9, docs/173)


## Oracle, ENS & attestation resolvers

- **OracleFeedResolver** (`price`) — reads an AggregatorV3-shaped feed as on-chain state, rendered with provenance
  (feed, round) and freshness (`STALE` past a caller bound). **Grade A.** args: `(feed, fracDigits, maxStaleSeconds)`.
  ChainRender blesses no oracle — the feed is caller-supplied.
- **EnsRecordResolver** (`ensAddr` · `ensText` · `ensName`) — resolve **addr** (`bytes32 node`), read a **text**
  record (`abi.encode(bytes32 node, string key)`), or the verified primary **reverse name** (`address`, 20 bytes; the
  forward record must point back), live on-chain — **Grade A**. It reads the node's resolver directly (no ENSIP-10
  parent walk), so wildcard names are not resolved here.
- **EnsV2Resolver** (`ensV2`) — reads one record from a name's resolver that was discovered off-chain at seed time.
  args: `abi.encode(address resolver, bytes innerCalldata, bool isText)`. An on-chain value is **Grade A**; if the
  resolver reverts with `OffchainLookup` (CCIP-Read / EIP-3668), the slot renders `"off-chain (CCIP)"` — the contract
  detects the boundary but does not cross it; a client must fetch that record. See
  [ENS Names & Integration](../guides/ens-integration.md).
- **EnsMultichainResolver** (`ensApp` · `ensNameChain`) — two additive ENS reads beyond records: `ensApp` reads a name's
  conventional `chainrender.app` text key (ENS as ChainRender's own naming layer), and `ensNameChain` is the **ENSIP-19**
  multichain verified reverse — the primary name for an address *on a given chain* (per-`coinType` reverse namespace),
  requiring the forward round-trip `addr(namehash(name), coinType) == who` so an unverified reverse can never be shown.
  **Grade A** (pure on-chain reads), fail-closed to `"-"`. args (`ensApp`): `(node)`; (`ensNameChain`): `(who, coinType)`
  where an EVM coinType is `0x80000000 | chainId`. The ENS registry is supplied at construction, never hardcoded. See
  [ENS Names & Integration](../guides/ens-integration.md).
- **AttestationResolver** (EAS) — read whether an EAS attestation is valid for `(subject, schema, uid)`
  (verified / unverified — reveals the claim, not the data), or the claimed string a subject published
  `(uid, schema, subject)`. **Grade A read** (a mutable attester is the authority). See
  [Data Sources](./data-sources.md).