Trust model and security

A useful way to evaluate any financial protocol is to list, precisely, what you have to trust to use it safely — and then check whether that list is short and verifiable, or long and hand-wavy. Here's Plume's list, kept as short as it actually is.

What you don't have to trust

The Plume Foundation — with a narrow, fully-bounded exception. The market contracts hold no pause switch, no upgrade path, and no function that lets anyone override a price, freeze a position, or redirect collateral. What's deployed is permanent. The powers the Foundation does hold are few and bounded by code: fee rates can be adjusted but never above hard ceilings, and treasury operations can be timed but their destinations are fixed. Even a fully compromised Foundation key could only set fees badly within the caps or run the treasury clumsily; it could not raise fees past the ceilings, redirect a single token to an arbitrary address, or touch any user's position.

The settlement bot. Its entire job is mechanical: notice an expired series, submit the correct oracle round. That submission is independently verified by the contract and can't be substituted for a more favorable one — and if the bot stopped running, any holder could settle their own position without it.

The frontend. The application is a convenience layer. Every action it initiates is a normal transaction you approve in your own wallet, and every position and contract state it displays can be independently confirmed on a block explorer, without the app in the loop.

The pricing model. A wrong suggestion misprices one listing, bounded by one person's collateral. It never becomes a claim on anyone else's funds, and the contracts have no awareness the pricing engine exists at all.

What you do have to trust

The oracle. Every settlement and exercise reads its price from an independent, established price-feed provider, not from Plume — the same standard trusted throughout DeFi. But it is a dependency, and an honest one: if that feed were compromised or malfunctioned in a sustained way, Plume's settlements would inherit that problem. The safeguards on the resolution page — round-binding, staleness limits, rejecting non-positive prices — exist to shrink how much damage a bad feed moment could do, not to claim the dependency doesn't exist.

The chain. Plume runs on Robinhood Chain. Its correctness depends on that chain behaving as a blockchain should — settling transactions as submitted, without a third party able to reorder or censor them arbitrarily.

The contract code itself. Every claim here about what the contracts do is a claim about code, not policy. It's true because the code enforces it, which means it's exactly as trustworthy as the code is correct. The code is open source specifically so this isn't a request for faith.

The one that's easy to overlook: the assets have issuers

Plume's contracts have no admin powers over anything. But the assets those contracts hold — the tokenized stocks, and the stablecoin used for premiums and put collateral — are issued by regulated companies, and those companies retain real powers over their own tokens: the ability to pause transfers, and to freeze specific addresses, including, in principle, the address of a Plume contract holding locked collateral.

Say this plainly: "fully collateralized, the vault can always pay" describes Plume's own math, not a promise that the issuer of the underlying assets will never intervene on its own token. It's a real, if unlikely, dependency, and it's disclosed here rather than left for you to discover on your own.

Where deposits stand today

Plume is unaudited. Total collateral each market can hold is capped, specifically to bound what any undiscovered bug could put at risk while that's true. The factory that deploys new markets is permissionless — technically anyone can deploy a market pointing at any asset and any price feed. Only markets published through Plume's official channels are ones Plume has actually reviewed and stands behind; anything else wearing a similar name is not.

How to check any of this yourself

• Read the contracts: the source is public in the project repository, and every function is named in the contract reference.
• Read the deployed bytecode: every official contract address is verified on the block explorer, confirming source and deployed code match.
• Read the test suite: the conservation invariant and every payoff formula has a corresponding fuzz test, run on every change.
• Read the oracle directly: every price feed address is public, and its full history is queryable independent of Plume's app.

None of this asks you to take Plume's word for anything. That's the point.