When a team asks me about DeFi monitoring, the conversation often starts with a list of alerts. Big transfers. Admin changes. Oracle prices. Maybe a message in Slack when something looks unusual.
What happens after the message arrives?
An upgrade might be scheduled at 2 a.m. An oracle might stop updating. Someone needs to see those alerts and know what they can do. The team also needs a way to find out when an alert fails to arrive.
When I work with trading firms, hedge funds and institutions, these questions matter because a security review doesn’t end when the initial decision is made. Contracts change, permissions change, and the conditions that made a position acceptable can change with them.
I’ll use Cedar, the example vault from the due-diligence article, to follow four signals: a scheduled upgrade, a privileged role change, a stale oracle and an unexpected movement of funds.
Before monitoring a deployment, I would first establish which code and configuration are in use. I walk through that process in the audit-to-deployment article.
Start with the decision
Suppose the treasury has completed the reviews required for Cedar and opened the 25,000 USDC pilot position. The vault sends assets to a strategy, uses a price feed for its accounting, and can be changed by administrators through a timelock. A timelock is a delay between scheduling a change and executing it.
Before setting up an alert, I’d sit down with the people responsible for the position. We would decide which changes should stop new deposits or prompt an exit, who can make that call and what the team can do in time.
An upgrade alert may give us time to withdraw. A transfer alert may arrive after the money has moved, when the priority is stopping further exposure.
Then I’d map what needs watching: the chain, vault and strategy contracts, the timelock and admin accounts, the actual oracle feed and the wallets and assets involved in the position. I’d verify addresses against the deployment and the team’s own records, including proxies and their implementations. I’d also map integrations and any chains the funds can reach.
I would keep this inventory as a watchlist: a maintained list of addresses, contracts, assets and dependencies the team cares about. Each entry needs a network, purpose, owner and source of truth. A list copied from an old document can give us confidence in the wrong addresses.
For each signal, I’d connect the detector to a notification route, a responsible person and an action they are authorized to take. The test ends when we verify the result of that action.
An upgrade is scheduled. Do we have time to act?
Cedar Vault’s timelock schedules an upgrade to the strategy. The change might be legitimate. It still matters because new code can change how the treasury’s money is managed or withdrawn.
I’d configure a monitor for the relevant timelock’s scheduling, cancellation and execution events, and check the actual contracts’ implementation and events rather than assuming they all work the same way. The alert should include the chain, target, proposed action, transaction, scheduled execution time and a link to the decoded details. I’d also watch the proxy’s implementation for changes as a backstop: an upgrade might use another path or bypass the delay we expected.
The notification goes to the security channel in Slack and pages the on-call security lead if the execution window is short. The security lead owns the review. The treasury lead decides whether to stop new deposits or initiate a withdrawal under the team’s existing approval process. If we are depositors, we cannot assume we can cancel the protocol’s upgrade or pause its contracts. Those are protocol-side powers and need to be confirmed separately.
After the review, I’d verify the queued operation and implementation on-chain, compare them with the reviewed proposal, and record the decision and any actual withdrawal. I’d also check whether the operation was cancelled or executed. A 48-hour delay only helps if the alert arrives, someone is available and the vault has enough withdrawal capacity in that window.
Someone gains a privileged role
Next, an address is granted a role that can change the vault’s strategy. It may be a planned rotation. It may also give a new address control over a path we depend on.
I’d monitor grants, revocations and ownership transfers on the relevant contracts, including changes to the people or accounts that can grant those roles. I’d reconcile events against current on-chain role and ownership state, because event coverage alone may miss a custom permission mechanism or an unexpected code change. For a multisig, I’d watch signer and threshold changes where those controls matter.
The alert goes to security on-call with the role, address, transaction and affected contract. The security lead checks it against an independently approved change record. If it isn’t expected, the treasury lead can hold new deposits and decide whether to withdraw. The protocol’s authorized operators can investigate, revoke or pause only if their permissions and procedures allow it.
For an approved rotation, I’d confirm the resulting role and admin state matches the change record. If the team revokes unexpected access, I’d verify that removal onchain and check whether the address retains another route to the same permission.
The price hasn’t changed. Is that good news?
Now the vault’s oracle feed hasn’t updated. A stable price might be normal. It might also mean the vault is using an old price while the market has moved.
I’d first identify the exact feed the vault actually reads, its network, expected update behavior and what the protocol does when data is late. For a Chainlink feed, for example, I would read updatedAt from latestRoundData() and compare its age with a threshold chosen for that feed and the application’s risk. Chainlink feeds update according to deviation and heartbeat parameters. Applications need to account for the time between updates. The Chainlink documentation explains why applications should check freshness. A missed heartbeat and a bad price are different conditions, so I’d also consider validity and deviation from an independent reference.
The risk lead investigates the feed and the vault’s exposure, and can hold new deposits or request an exit under the team’s policy. Only an authorized protocol operator can pause or change the protocol’s oracle behavior. A contract-level freshness check or circuit breaker can reject a stale value. The external alert needs someone or an authorized automation to take the next action.
I’d verify the feed’s timestamp and value from an independent source, check whether the vault is still consuming that feed, and record any transaction or decision taken. A recovered timestamp closes the stale-feed condition, but it doesn’t automatically prove that every value used during the incident was safe.
Money moves somewhere we didn’t expect
Finally, 80,000 USDC leaves the strategy for an address outside the team’s expected destinations. That’s a large movement for our example, but the number alone doesn’t tell us whether it is theft, a routine reallocation or a withdrawal.
I’d monitor the vault, strategy and relevant token transfers, and where supported inspect transaction calls and balance changes as well as emitted events. I’d use a baseline of expected destinations, transaction types, amounts and timing, then alert on an unknown destination or an unusually large net outflow. A transfer between known contracts can still be dangerous, so I’d use the destination list to guide the investigation while continuing to monitor known addresses.
The alert should show the asset, amount, source, destination, transaction and links to related activity. Security on-call owns the first investigation and pages the treasury lead immediately. The treasury lead can stop new deposits and, if the team’s custody policy permits and liquidity is available, request a withdrawal of the remaining position. The protocol team may have other emergency controls, but we should know those permissions before an incident, not discover them in the alert thread.
I’d verify the transfer and resulting balances on-chain, follow the relevant transaction path, compare the movement with the approved operating plan and record what remains exposed. The original transfer may already be final. The response can limit further exposure, while the completed transfer remains part of the loss investigation.
Where Hypernative fits
A platform such as Hypernative can help bring these pieces together. Hypernative describes prebuilt and custom monitoring agents, a visual agent builder, a Python SDK, and alerts through channels including Slack, PagerDuty and webhooks. It also describes automated responses. I’d confirm network coverage and enabled features in the team’s account.
I’d use separate agents or monitors for the different questions: one for the timelock, another for privileged access, one for oracle freshness and another for asset flows. Each monitor would use the verified addresses in our inventory.
Then I’d connect the alerts to the places people already work. Slack is useful for context and coordination, but a busy channel isn’t a reliable on-call system by itself. For urgent signals, I’d route to a paging tool with an acknowledgement deadline, a backup and escalation if nobody responds. Use a separate delivery-health check so a broken integration isn’t mistaken for a quiet vault.
Before enabling Hypernative’s automated response, I’d establish what action is authorized, who controls the signing credentials, what happens if the signal is wrong, and whether the action can complete before the risk materializes. Test the action with restricted permissions and define how to recover if it triggers incorrectly. Some onchain actions cannot be reversed.
Which monitoring platform would I choose?
I’d ask each provider to demonstrate the same four Cedar scenarios. The shortlist below follows their published capabilities. I haven’t benchmarked their detectors, so I’d make the decision after a pilot using our contracts and response team.
| Tool or system | Where it helps | What I would verify |
|---|---|---|
| Prebuilt detection and custom monitoring agents | Build the oracle and timelock conditions, deliver a Slack alert and page the backup. Confirm which networks and response integrations the account includes. | |
| Contract, wallet and transaction-flow threat monitoring | Ask for a replay of the role change and outflow. Confirm the notification route and distinguish monitoring from its separate pre-transaction and co-signing offerings. | |
| Engineer-defined onchain alerts | Configure the relevant events or supported conditions and test delivery. Its documentation places Alerts on a paid plan. Budget for engineers to maintain custom logic. |
Hypernative would be on my shortlist when the team wants security detections alongside its own agents. I’d evaluate Cyvers against the same incidents and escalation requirements. For explicit contract conditions maintained by engineers, I’d also trial Tenderly. That is a fit assessment, with detection quality still to establish.
Whichever we choose, the monitoring owner needs to review missed and noisy signals, keep the watchlist current and retest response permissions. A delivered alert can arrive too late to prevent a transfer. Automated action needs its own restricted authority and rehearsal.
What does tested coverage mean?
I’d record coverage in three states:
- Planned: we have identified the risk, detection condition, owner and intended response. The monitor may not exist yet.
- Configured: the monitor and notification route are set up for the specified addresses, network and condition. We have inspected the configuration, but haven’t established that the whole path works.
- Tested: a defined test has confirmed detection, delivery, acknowledgement and the permitted response or a safe rehearsal of it.
For each of our four signals, I’d record the network and addresses, condition, threshold, notification route, primary and backup owner, response authority, test results and last test date. If the role-change monitor is active but no one has tested the page, I would record it as configured. A sample alert can show that delivery works. The detector still needs a test using the role-change condition.
Test the path before relying on it
I’d test the four scenarios in a sandbox, test network or supported replay workflow. Any condition we couldn’t test would stay open in the coverage record.
For the upgrade, schedule a harmless test operation and confirm the decoded target, execution time, alert and acknowledgement. For the role change, grant and revoke a test role and compare the alert with the resulting state. For the oracle, use a controlled stale feed or clock in a test environment, check the threshold boundary and confirm a healthy feed stays quiet. For movement, simulate both an expected transfer and an unknown-destination outflow, including a case just below and above the threshold.
I would also test the unglamorous failures: a muted Slack channel, a failed webhook, an unavailable primary responder, a monitor that stops receiving data and a changed address that hasn’t made it into the watchlist. The backup should receive an escalation when the primary doesn’t acknowledge. Monitor health should have its own alert through an independent route where practical.
Keep the input, configuration version, expected and actual result, delivery and acknowledgement times, response rehearsal and follow-up records.
Fewer noisy alerts, without creating a blind spot
I’d start by reviewing recent activity and the legitimate events the team expects: scheduled rebalances, approved role rotations and normal oracle behavior. Test proposed thresholds against historical activity and known incident scenarios where data is available. Separate informational messages from urgent pages, group duplicate alerts from the same incident, and give each alert enough context to make a decision. After independently verifying an approved change, I’d annotate it or route it at lower urgency. A familiar sender alone wouldn’t justify suppressing the alert.
Then review both sides: alerts that were noisy and events that should have alerted but didn’t. Track detection and delivery delays, acknowledgement and escalation times, alert volume, the share that needed action, failed checks and overdue tests. Use synthetic checks and independent reconciliation of critical changes and balances to find gaps in the monitoring pipeline itself.
Unsupported chains, provider outages and reorganizations can leave gaps. I’d record those dependencies and decide where independent checks or onchain restrictions are needed.
Keep the coverage alive
A new strategy, feed migration or signer can leave monitoring pointed at the wrong addresses.
I’d make monitoring a required part of the change process: update the dependency inventory, review affected agents and thresholds, confirm the owners and test the alert path before or as the change goes live. Reconcile the inventory with actual deployed addresses and permissions regularly, review noisy and missed signals with the people on call, and run an incident drill on a schedule the team can sustain. After an incident or meaningful change, retest the affected path and keep the test results with the revised configuration.
If you’d like help building or reviewing monitoring around your DeFi exposure, let’s discuss it through my security advisory service.