Public Chain. Private Hooks.

privatehooks is a privacy layer for programmable onchain hooks. Route fees, run a treasury and ship distributions without publishing every parameter, recipient and position — execution stays on public rails and stays verifiable.

Enter App

Hooks it wraps

Private by default. Verifiable on demand.

Enter App

Hooks it wraps

Fee routing

Splits every fee it collects between recipients nobody outside can see.

Prove the rule held, not who it paid

Rule hash
The routing logic is committed onchain and checkable by anyone.
Sealed split
Recipients and their shares never leave your side of the wall.
Exact totals
Prove 100% of collected fees followed the rule, down to the wei.

Treasury

Runs a balance sheet without publishing the portfolio behind it.

Prove solvency without opening the book

Hidden venues
Where the assets actually sit stays off the public record.
Threshold proof
Prove reserves exceed a number without naming a single position.
Auditor view
Grant one auditor the full detail, scoped to fields and to a window.

Distributions

Pays out to a list of holders without ever publishing the list.

Everyone eligible. Nobody exposed.

Sealed set
The eligibility snapshot stays private after the payout clears.
Correct by proof
Prove every eligible holder got the right amount — and no one else did.
No profiling
Indexers see the execution, never the people behind it.

Built to be Provable, Not Visible

Proofs

Commitments published per hookPublic rails, private internals

Verify proof

Disclosure keys the protocol can readPublic rails, private internals

Verify proof

Assets held in custody

Executions anyone can verify

One disclosure layer, every kind of hook

Bring the hook. Mark the fields that stay private, name who may see them, and ship on the same public rails as everything else.

All hooks

Private recipients and splits

Public rule hash, private inputs

Per-field disclosure grants

Private by default. Verifiable on demand.

Non-custodial, keyless, composable and portable — a layer over your hook, never a landlord on top of it.

Nothing is broadcast unless you say soRecipients, splits, balances, thresholds and strategy parameters stay off the public record. Everything you do not mark stays plainly public.
Disclosure is an action, not a settingGrant a viewer one field, for one window, and revoke it. Auditors, LPs, partners and DAOs each see exactly what you named and nothing beside it.
No keys ever reach the protocolDisclosure keys are derived clientside and never transmitted. Assets never leave your hook, so privatehooks never becomes a party to it.

Still just a contract

A private hook composes like any other: contracts call it, indexers verify it, and the schema is open enough to take with you whenever you want.

Enter App

Connect

Write a new hook or point privatehooks at one you already run. The existing logic keeps working — the privacy layer wraps it.

Mark & scope

Mark the fields that stay private, then grant disclosure per address, per field, per window — with an expiry and a revoke.

Deploy & prove

One commitment goes onchain. From there, prove a rule held or open a single field to a single viewer. Nothing else moves with it.

Route fees. Run a treasury. Keep the internals yours.

Wrap a hook you already run, write a new one, or define your own disclosure schema. Same protocol underneath, whichever surface you are on.

Wrap a hook you already run

Schema SDK

Write a new private hook

privatehooks Layer

Define your own disclosure schema

Hook Studio

Private execution on public rails

Execution stays provable to anyone. What becomes optional is the part that was never meant to be a broadcast: the internals.

Enter App