The app shows what the notes are worth. The explorer shows what the pool account holds. The account always holds more, and every drop of the difference is accounted for below — live, from the ledger.
reading the ledger…
| Flow on the ledger | XRP |
|---|---|
| Operator funding at genesisthe Payment that created the account (no memo): covers the XRPL reserve and the account's transaction fees; never note value | — |
Shield depositsPayments to the pool carrying the confidant/shield memo — each bound to one bundle | — |
| Payouts to unshield destinationsk-of-N Payments, each bound to an accepted unshield, net of the unshield fee | — |
| Fee sweeps to the treasuryk-of-N Payments of accrued protocol fees; verified by every node | — |
| Anchors1-drop Payments whose memo carries the state after each accepted operation | — |
| XRPL transaction fees paid by the accountburned by the ledger, go to no one | — |
| = balance on the ledger | — |
check against account_info | — |
| Inside the pool | XRP |
|---|---|
| Shield deposits | — |
| − shield fees0.25 % of each deposit, floored to the drop; the note is credited net | — |
| = notes created | — |
| − notes burned by unshieldsgross note value; the destination receives it net of the 0.25 % unshield fee | — |
| = total shielded (backing) | — |
pool account − backing = operator float and unswept fees (poolExcess, the node's own read) | — |
| protocol fees: accrued · swept · available to sweep | — |
Because they count different things. Total shielded is the value of the notes the pool backs: every shield deposit net of its fee, minus every note burned by an unshield. The account balance adds the operator's funding at genesis, the protocol fees that have accrued but not yet been swept to the treasury, and any deposit the screening gate refused and that awaits a refund. None of that is note value, and none of it can be spent by a holder. The two tables above reconcile them to the drop.
A shield is an ordinary XRPL Payment to the pool account that carries a memo: MemoType = confidant/shield,
MemoData = the hash of the bundle you built and proved before paying. The bundle commits to
the amount; the memo binds the deposit to that one bundle. Every verifier node reads the Payment from the
ledger itself (validated, to the pool, in XRP, memo present) and accepts the bundle only if the delivered amount
matches the note net of the fee. Nothing else creates a note.
Nothing good: it is not a shield, so no note is created and it does not raise the shielded total. The XRP lands in the account and shows up in the "operator float and unswept fees" line. It cannot be claimed later — a later memo would have to name a bundle that commits to that deposit, and the bundle must be built first. It cannot be swept as fees either: a sweep is capped by the fee ledger, which grows only with real shields and unshields. The signers refuse everything except anchors, payouts bound to accepted unshields, and sweeps within that cap, so the XRP stays in the account until a refund path exists (a roadmap item). Don't do it.
The pool charges a protocol fee on the way in and on the way out — 0.25 % of a shield and 0.25 % of an unshield, floored to the drop. Transfers inside the pool are free. The note is credited net of the shield fee; a payout is net of the unshield fee. The rates are a public policy fixed at the pool's genesis: a pool whose deposits were bound under one policy cannot be replayed under another, so new rates mean a new pool.
They accrue inside the pool account and leave it only through a sweep: a k-of-N multisigned Payment to the configured treasury account. Each node keeps its own fee ledger, replayable from the ledger, and will only record a sweep it has read from the ledger itself: validated, from the pool, to the canonical treasury, no larger than what is available. "Available" is the fee ledger's balance capped by the account's excess over the notes it backs, so a sweep can never dip into note value. XRPL's own transaction fees are different: the pool account pays them from its float and the ledger burns them.
The XRP the operator put into the pool account when it was created — on testnet, a faucet Payment. It covers the account's reserve (the base reserve plus the owner reserve for its SignerList) and pays the account's transaction fees for anchors, payouts and sweeps. It is never note value, and the node's conservation check — the account must always hold at least what its notes are worth — treats it as the cushion it is.
Anchors. Every accepted operation — shield, transfer, unshield — ends with the quorum signing a 1-drop Payment from the pool account whose memo carries the new state. That is how the pool's state lives on the ledger: anyone can read the memos in order and rebuild the verifiers' state without trusting them. Transfers inside the pool leave exactly one such anchor and nothing else — no sender, no receiver, no amount.
The screening standby. Each node accepts a deposit only once it is a few validated ledgers deep (two on the demo pool), which gives the boundary screening a stable view of the Payment. The app retries by itself and the shield completes after about eight seconds. It is the policy working, not an error.
A Payment the screening gate refused — for instance from a sender on a public sanctions list. The XRP is in the pool account but no note was created, so it counts in the excess, not in the shielded total. Returning it needs a quorum-signed refund path, which is on the roadmap; until then such a deposit stays where it is. The screening itself is a check against public lists at the public boundary, not a proof of innocence per note.
Public: every shield and unshield — amount, XRPL address, time — and therefore the total shielded and the account's balance. Private: who holds what inside the pool and who paid whom; a transfer leaves one anchor and nothing else. A holder can reveal their own history to an auditor with their viewing key; nobody else can. An empty or thinly used pool gives little privacy, and endpoint timing and amounts can still correlate a deposit with a withdrawal — the pool hides the graph, not the boundary.
No. Notes are non-custodial: the spending key never leaves the holder's browser, and a note moves only by a proof built with it. What the operators can do, if k of the N signers collude, is move the pool account's own XRP — that is the federated custody caveat, stated plainly everywhere. Today's XRPL has no on-ledger verifier for these proofs, which is why a quorum re-verifies every operation and signs only roots it computed itself.
The coordinator's node could not be reached, or it could not read the ledger at that moment (then it also reports no excess and nothing is sweepable). The figure returns with the next refresh.
Honest limits, as everywhere in Confidant: the pool account and proof verification are federated (k-of-N); collusion of k signers can drain the pool account but cannot spend anyone's notes; state is reconstructible from the ledger; shield and unshield amounts and addresses are public; an empty pool has no privacy. Testnet only.