Skip to content

Hypernative Integration for Pause Roles, Safe Guards and Alert Routing

Your team grants Hypernative the pause role or Safe module it acts through. Your Hypernative integration also needs a Transaction Guard rollout and alert routing. Protofire builds these parts, and your Safe signs the grants. We deployed Safe on 120+ EVM networks, where it secures $2B+.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. What you get
  3. Guard limits
  4. Permission types
  5. Unpause and alerts
  6. Hypernative facts
  7. Why Protofire
  8. Project steps
  9. How work starts
  10. Not the right fit
  11. Related guides and services
  12. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

Hypernative's automated response needs a permission from your team

What your Hypernative integration does after a detection depends on a permission that your team granted earlier, or did not. Hypernative says its response engine can "pause contracts, move funds, unwind positions, and trigger custom actions" (Hypernative), and calls those actions "pre-authorized" (Hypernative).

Who authorizes Hypernative's automated actions? The authority comes from a role on your contract, a module on your Safe or a transaction that your MPC wallet signs. For example, you have chosen Hypernative, and a detection fires at 3 a.m. on a contract that holds client funds. Without a grant, that detection ends as an alert for someone to read.

A careless grant creates its own risks. If one role covers pause and unpause, the address that paused can also resume. A pause module on the same Safe acts outside Transaction Guard. If your team settles those choices on the night of the alert, it makes them under pressure.

Who holds each permission in a Hypernative setup

Hypernative acts through the roles, modules and approvals that your Safe grants. Protofire builds the permission contracts, the alert receiver and the drills around them.

Your team

Contracts with pause functions

Access control on each chain names who may pause and who may unpause.

Safe, owners and MPC signing policy

The owners and threshold grant and revoke roles, modules and keepers, and the signing policy decides what a Fordefi or Fireblocks wallet signs.

On-call and incident lead

The on-call and incident lead receive the alerts, decide whether to resume after a pause and own the runbook.
Hypernative

Watchlists and Custom Agents

Watchlists and Custom Agents run detection on contracts, transactions, governance, wallets and price feeds.

Keeper address and actions

Hypernative calls a pause module or granted role, signs for Transaction Guard and sends alerts to Slack, PagerDuty or a webhook.
Protofire builds

Permission contracts

Pause role grants, a pause module and Transaction Guard policy extensions are tested before your Safe enables them.

Alert receiver

A webhook endpoint checks its header secret and opens an incident.

Drills and runbook

The drills cover fork tests of each pause path, failed-pause handling and a written unpause procedure.

What your team holds after the Hypernative integration

A scoped pause permission that your Safe grants and revokes

When a Hypernative detection fires, its keeper calls the pause function through a role or module that your owners granted. Protofire builds either one: the role grant transactions, or a pause module on your Safe that sends the pause selector and nothing else. Your Safe revokes the role or the module.

A permission map that your security lead signs

Before a grant goes onchain, you see one table per chain. The table for a chain lists each role, its holder and the transaction that revokes the role. The unpause is kept on your multisig.

Transaction Guard on your Safe, with a removal plan

Transaction Guard checks a Safe transaction against your policies and a keeper approval before the transaction executes. Protofire reviews the Safe's owners and modules first. Then we write the install and removal plan, including the route to use if the keeper does not answer.

Alerts routed to a named person in your on-call tool

Each alert arrives in the on-call tool that your team already uses and names its chain and contract. Protofire builds the webhook receiver that maps severity to PagerDuty or OpsGenie and opens the case.

Pause drills before the first real alert

Each pause path is run on a fork or testnet. The drills include a target that refuses the pause and an unpause on a guarded Safe.

What Transaction Guard checks on a Safe and what it skips

A guarded Safe sends its owners' transactions through the guard at execution.Before the owners sign, Transaction Guard simulates the transaction and applies your policies (Hypernative). The transaction then needs a keeper signature after the owners' signatures, or a hash that the keeper approved ahead of time. A transaction with neither reverts with UnapprovedHash. Policy extensions run first. An extension can block a transaction but cannot approve one, and your Safe adds the extensions (GitHub).

Transaction Guard does not check transactions that enabled modules send through execTransactionFromModule. Hypernative's README says that through Safe version 1.4.1, "the module path has no guard mechanism of its own" (GitHub). So a pause module on the same Safe acts outside the guard by design. The README treats the module set as trusted configuration, "reviewed before the Guard is installed and monitored thereafter". Safe 1.5.0 adds a separate Module Guard that owners set on their own (Safe).

The guard setup adds three gaps. First, a keeper that is also a Safe owner adds nothing beyond the threshold. Hypernative's README says a keeper must not be an owner. Second, pass-through mode skips the checks once its 1-day timelock has run. Third, a faulty guard can block a Safe (Safe), and removing the guard also waits out a 1-day timelock.

How a pause role, a Safe module and an MPC exit differ

A role on your contract and a module on your Safe both let an address that Hypernative controls trigger a pause.The two are scoped, revoked and undone differently.

A pause role granted directly to Hypernative's address

Your contract's admin grants the pause or emergency role to an address that Hypernative controls. Hypernative lists pauser roles and Safe multisigs among the permissions it integrates with (Hypernative). A role granted this way skips your multisig's signing round at the moment of the pause. So the role should be scoped to the pause function. To revoke the role, the same admin, usually your Safe, sends a call on each chain where the role was granted.

A pause module on your own Safe

Your Safe keeps the pause role on the target contracts and enables a module that a Hypernative keeper calls. The module should send the pause selector through execTransactionFromModule and record each target that refuses. The module should also leave the target list and keeper replacement to your Safe. Your Safe revokes this permission by disabling the module. Safe's documentation warns that a malicious module can take over a Safe (Safe).

An exit signed in your MPC wallet

Hypernative and Fordefi announced in September 2024 that clients record exits such as unstaking in Fordefi. The announcement says those clients are "notified for signing through Fordefi" when a Hypernative trigger fires (Hypernative). Your Fordefi policy still decides what is signed. For Fireblocks, Hypernative lists an integration "via API" (Hypernative). Fireblocks' Callback Handler is "hosted and managed by your organization", and it "can approve a request, but it cannot create a signature" (Fireblocks). Protofire's Fireblocks integration page covers the Callback Handler.

Pause runbooks trade review time for speed: constrain what emergency paths can do and use pre-tested backup UIs when minutes matter.
Security Alliance (SEAL), Security Frameworks runbook, Publisher of the open Security Frameworks for onchain teams · Emergency Pause Runbook, Security Frameworks v0.0.3, read November 2026

Who resumes after a pause, and who answers the alert

The address that your access control names for unpause can resume.In the module form, your Safe holds the pause and unpause roles, and Hypernative's keeper holds neither. SEAL's emergency pause runbook lists the unpause as a planned step "with full verification (not emergency process)" (SEAL).

A pause across several chains needs a resume on each chain, sent from that chain's admin Safe. If the admin Safe runs Transaction Guard, the unpause needs the keeper's signature or a hash approved ahead of time. When the alert threshold is kept apart from the pause threshold, a mild deviation pages a person while a severe one triggers a pause. Your risk team sets both numbers.

After launch, your Safe holds the grants and revocations, and Hypernative's keeper holds its approvals. Your on-call team answers the alerts and decides whether to resume. Protofire holds no keeper, pauser or Safe signer role and no admin seat in your Hypernative account.

Hypernative chains, detection, alerts and API access

Chains
75+ blockchains are covered, per Hypernative's About page as read on 13 November 2026. The story text on the same page says "70+ chains".
Detection
Custom Agents are built with the no-code Agent Builder or the Python SDK, and their alerts are scored by severity (Hypernative).
Alert delivery
Dashboard Actions deliver alerts, including through a webhook with a custom request header, per Cantina Clarion's guide.
API and docs
API access uses a client ID and secret from the dashboard, per Portal's docs. The API reference requires a Hypernative account.

Checked November 2026 against Hypernative's product pages and public GitHub code.

Our record: Safe deployments and contributions to Safe

Protofire's Safe work covers the contracts, owner threshold and signing flow that a Transaction Guard and a pause module attach to.Both are Safe code that your owners enable.

Safe deployed on 120+ EVM networks

Protofire deployed Safe on 120+ EVM networks, where it secures $2B+. Our Safe multisig deployment page lists those networks, each with a public source of its own.

Contributions to Safe since 2018

The Safe Ecosystem Foundation wrote in May 2026 that Protofire "has been contributing to Safe since 2018". Our Gnosis Safe case describes Protofire's work on Safe.

Project steps from permission map to handover

  1. Step 1

    Permission map before the first grant

    Protofire reads your contracts, roles and Safes on each chain and drafts the target state. Your security lead signs this permission map before a grant goes onchain.
  2. Step 2

    Contracts and guard tested in staging

    Role grants or the pause module are written and tested on a fork. A smart contract audit can review the module before your Safe enables it. The guard is deployed in pass-through mode. The rollout switches pass-through mode off from your Safe and confirms onchain that a transaction with no keeper approval reverts.
  3. Step 3

    Alert receiver tests and pause drills

    Hypernative sends no test alerts to webhook actions, per Cantina Clarion's guide. So the alert receiver is tested by replaying a real alert in Alert Replay, under Risk Insights > Alerts. Then each pause path and the unpause on a guarded Safe are rehearsed.
  4. Step 4

    What your team holds at handover

    Contracts are deployed from your keys, and Safe transactions are prepared for your owners to sign. You also hold the install and removal plan, the runbook and the hashes that your team asks Hypernative's keeper to pre-approve.

How a Hypernative project with Protofire starts

You send the contracts, chains, admin Safe and runbook in scope.Protofire's first proposal then names each permission that we would set up and who grants it. Hypernative API calls use credentials that your staff generate and keep in your vault. A Fireblocks Callback Handler that Protofire builds runs on your servers and follows rules that your staff signed. Each service that Protofire operates under a written scope, such as the alert receiver, only reads data. The terms that follow apply to each phase, as set out on how we work.

Proposal
In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
Price
Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
Ownership
Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
After launch
Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
Access
Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
Licenses
Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.

How we work shows a worked proposal.

Cases where Hypernative's services or one install are enough

In four cases, Hypernative's own services or a single install cover what you need.

  • You need custom monitors inside Hypernative. Hypernative's Custom Configurations service offers to help "build custom monitors using the Hypernative SDK" (Hypernative).
  • An exploit is under way, and a Hypernative integration is preparation. Hypernative sells Expert Incident Response, and Protofire's incident engineering service is Protocol Rescue.
  • Your Safe holds treasury funds and no contract roles. Installing Transaction Guard takes one Safe transaction plus policies in Hypernative (GitHub).
  • You want engineers to answer the alerts for months. Protofire's managed onchain operations service covers that kind of standing watch.

FAQ

What is a Hypernative integration?
A Hypernative integration connects Hypernative's monitoring, automated pauses and Transaction Guard to a team's own contracts, Safe and on-call tools. Protofire builds the pause role or Safe module that Hypernative acts through, and the guard setup. Protofire also builds the alert routing and the drills. The team's Safe signs each grant and each revocation.
Who can build a Hypernative integration for a protocol or a Safe treasury?
Hypernative sells custom monitors and incident response, and Protofire builds the team's side of the integration. Protofire's part covers pause roles and modules and the Transaction Guard rollout on the Safe. It also covers an alert receiver and drills. Protofire's record includes Safe deployments and contributions to Safe.
Who holds the keeper role on a Safe with Transaction Guard?
Hypernative's keeper address holds the keeper role. The Safe itself grants or revokes the guard's keeper role, and at least one keeper must remain. Hypernative's README says a keeper must not also be a Safe owner (GitHub).
What happens to a guarded Safe when Hypernative's keeper does not respond?
When Hypernative's keeper does not respond, new transactions on a guarded Safe revert with UnapprovedHash unless the keeper approved their hash ahead of time. The way out is to remove the guard. At deployment, the guard pre-approves the Safe transaction that starts its 1-day revocation timelock. So the owners can start that timelock without the keeper and call setGuard once the day has passed (GitHub). Starting pass-through mode is not pre-approved, so pass-through mode needs the keeper. A policy extension that reverts blocks both routes.
Can Transaction Guard check transactions signed in Fordefi, Fireblocks or another MPC wallet?
Yes for Fordefi, where Hypernative says Transaction Guard is "natively integrated within Safe and Fordefi". For Fireblocks, Utila, Copper and other MPC wallets, Hypernative lists integrations "via API" (Hypernative). Fireblocks fails a request when its Callback Handler does not answer in time (Fireblocks).

Get a proposal

Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.

Luis MedeirosField CTO, reads every request · LinkedIn

A demo or repository link also works.