Deterministic verification for blockchain access control

Find the missing check
before it approves a loss.

For bridges, wallets, and custody systems: Holo Engine runs one critical decision flow through a deterministic state space, checks every modeled outcome, and gives your team the exact unsafe approvals to fix.

L1
SOURCEBridge vault
L2
DESTINATION0x7A3E…91C2

WITHDRAWAL REQUEST

Release locked assets

TX 0xB8…F21

2-of-3 signaturesQuorum confirmed

PASS

Bridge proofEvidence confirmed

PASS
!

Replay protectionNonce check removed

MISSING

Emergency pauseControl active

PASS

HOLO VERDICT

Exploit blocked before execution

The same withdrawal could be approved twice.
BLOCKED
Real bridge policy Exact failure explained
6/6defects caught in the executed Holo Engine campaign
896policy evaluations run inside holo_exec
131unsafe approvals exposed and explained
$3.4B

in cryptocurrency was stolen in 2025. Holo Engine does not claim to stop every attack. It targets a narrower failure: a modeled decision flow saying “yes” when it should say “no.”

Chainalysis source

One critical flow.
Four concrete deliverables.

4 weeks · $25,000 fixed

Prove value on your own system before committing to an annual on-prem license. Not API credits, not an open-ended consulting engagement, and not a replacement for your audit.

01

Behavior model

One signed-off map of the exact decision flow and its boundaries.

02

Complete state map

Every outcome in the tractable modeled space—not a sample.

03

Failure evidence

Concrete unsafe approvals, mutation score, and fix-ready counterexamples.

04

CI regression harness

A repeatable check your team keeps after the pilot ends.

Same 60 defects.
Three ways of looking.

Ten Web3 decision flows. Six missing or weakened safeguards per flow. Every strategy faces the same mutation set.

MANUALLY WRITTEN TEST BASELINE

40/60Fixed regression suiteSix targeted tests per flow · 66.7% mutation score

FUZZING-STYLE RANDOM BASELINE

57.69/60Uniform random sampling512 samples per flow · 1,000 campaigns · 96.2% mean score

COMPLETE FINITE-STATE ORACLE

60/60Exhaustive enumeration10,240 unique states · 630 unsafe approvals · 100% mutation score
How to read this: these are three benchmark strategies, not three Holo Engine product modes or three vendor results. The random sampler is a transparent fuzzing-style baseline—not an execution of Foundry or Echidna. The 60/60 result belongs to the separate exhaustive oracle. The API-executed Holo Engine result is the 6/6 bridge campaign shown above.
Bridge withdrawalMultisig executionKey rotationContract upgradeRelayer acceptanceToken mintEmergency recoverySwap settlementSession keysValidator-set update

Another security layer.
Not another replacement claim.

This is the Verify stage of the Holo Engine decision cycle — applied to access control.

Current layerWhat it does bestWhat Holo Engine adds
Manual audit

Architecture, implementation, and expert judgment

Exhaustive regression for one signed-off decision flow
Foundry / Echidna

Property and invariant testing across generated executions

A complete finite-space map when enumeration is tractable
Certora

Source-level proof against a formal CVL specification

A separate behavior-model artifact and business-readable counterexamples

Descriptions follow the tools’ own documentation: Foundry, Echidna, Certora.

A budget case for today.
A risk case for the board.

Direct ROI counts engineering time and audit rework. Risk exposure is shown separately as scenario math—never as guaranteed savings.

DIRECT VALUE ASSUMPTIONS

RISK EXPOSURE SCENARIO

DIRECT FIRST-YEAR VALUE

$32,200
28.8% ROI9.3mo payback184h saved
Break-even: 143engineer hours. This direct case counts engineering and audit-readiness work.

EXPECTED ANNUAL LOSS EXPOSURE

$100,000
$10,000,000 value at risk1% annual probability4.0× exposure / pilot
Scenario math only: exposure is not claimed as Holo Engine-attributed savings and is not added to direct ROI.
Direct efficiency Base assumptions: 184 hours = $32.2k annual valueAudit readiness Signed state map, failure evidence, and a reusable CI harnessRisk exposure $10M × 1% annual probability = $100k expected exposure

Six injected defects.
Six exact failures exposed.

API-executed proof you can reproduce today. Customer evidence is published only with explicit permission.

01

Pause bypass

Transfers continued after the system should have stopped.

CAUGHT
02

Replay risk

The same approved action could be accepted twice.

CAUGHT
03

Proof bypass

An action passed without the evidence it required.

CAUGHT
04

Weak approval

One signer could do what should require two.

CAUGHT
05

Guardian bypass

An emergency role gained more power than intended.

CAUGHT
06

Combined failure

Two missing safeguards opened a wider attack path.

CAUGHT
EVIDENCE STANDARD

Customer names and quotes appear only with explicit permission. Current proof: a reproducible open benchmark.

MODELED GUARANTEE

Completeness applies to the signed-off state space, so buyers know exactly what is covered.

REPRODUCIBLE HANDOFF

Download the exact harness, runner, and expected output below.

Don’t trust the claim.
Reproduce it.

The exact 277-line bridge campaign is still here—lower on the page, where technical buyers expect it.

896 evaluations6/6 defects131 unsafe approvals
Open full reproducible source277 lines ↓
bridge_policy_campaign.holo
set base = "https://api.hiholo.ai"
set auth_header = "__AUTH__"

set baseline_rows = invoke json_parse with "[]"
set no_pause_rows = invoke json_parse with "[]"
set no_nonce_rows = invoke json_parse with "[]"
set no_proof_rows = invoke json_parse with "[]"
set one_sig_rows = invoke json_parse with "[]"
set guardian_bypass_rows = invoke json_parse with "[]"
set compound_rows = invoke json_parse with "[]"

set no_pause_false_accepts = 0
set no_nonce_false_accepts = 0
set no_proof_false_accepts = 0
set one_sig_false_accepts = 0
set guardian_bypass_false_accepts = 0
set compound_false_accepts = 0
set no_pause_first_witness = -1
set no_nonce_first_witness = -1
set no_proof_first_witness = -1
set one_sig_first_witness = -1
set guardian_bypass_first_witness = -1
set compound_first_witness = -1

set i = 0
while i < 128 do
  set s1 = i % 2
  set s2 = invoke floor with (i / 2)
  s2 = s2 % 2
  set s3 = invoke floor with (i / 4)
  s3 = s3 % 2
  set guardian = invoke floor with (i / 8)
  guardian = guardian % 2
  set paused = invoke floor with (i / 16)
  paused = paused % 2
  set proof_ok = invoke floor with (i / 32)
  proof_ok = proof_ok % 2
  set nonce_fresh = invoke floor with (i / 64)
  nonce_fresh = nonce_fresh % 2

  set sig_sum = s1 + s2 + s3
  set quorum = 0
  if sig_sum >= 2 or guardian == 1 then
    quorum = 1
  end
  set weak_quorum = 0
  if sig_sum >= 1 or guardian == 1 then
    weak_quorum = 1
  end

  set baseline = 0
  if quorum == 1 and paused == 0 and proof_ok == 1 and nonce_fresh == 1 then
    baseline = 1
  end
  set no_pause = 0
  if quorum == 1 and proof_ok == 1 and nonce_fresh == 1 then
    no_pause = 1
  end
  set no_nonce = 0
  if quorum == 1 and paused == 0 and proof_ok == 1 then
    no_nonce = 1
  end
  set no_proof = 0
  if quorum == 1 and paused == 0 and nonce_fresh == 1 then
    no_proof = 1
  end
  set one_sig = 0
  if weak_quorum == 1 and paused == 0 and proof_ok == 1 and nonce_fresh == 1 then
    one_sig = 1
  end
  set guardian_bypass = 0
  if guardian == 1 then
    guardian_bypass = 1
  else
    if sig_sum >= 2 and paused == 0 and proof_ok == 1 and nonce_fresh == 1 then
      guardian_bypass = 1
    end
  end
  set compound = 0
  if quorum == 1 and proof_ok == 1 then
    compound = 1
  end

  if baseline == 0 and no_pause == 1 then
    no_pause_false_accepts = no_pause_false_accepts + 1
    if no_pause_first_witness < 0 then
      no_pause_first_witness = i
    end
  end
  if baseline == 0 and no_nonce == 1 then
    no_nonce_false_accepts = no_nonce_false_accepts + 1
    if no_nonce_first_witness < 0 then
      no_nonce_first_witness = i
    end
  end
  if baseline == 0 and no_proof == 1 then
    no_proof_false_accepts = no_proof_false_accepts + 1
    if no_proof_first_witness < 0 then
      no_proof_first_witness = i
    end
  end
  if baseline == 0 and one_sig == 1 then
    one_sig_false_accepts = one_sig_false_accepts + 1
    if one_sig_first_witness < 0 then
      one_sig_first_witness = i
    end
  end
  if baseline == 0 and guardian_bypass == 1 then
    guardian_bypass_false_accepts = guardian_bypass_false_accepts + 1
    if guardian_bypass_first_witness < 0 then
      guardian_bypass_first_witness = i
    end
  end
  if baseline == 0 and compound == 1 then
    compound_false_accepts = compound_false_accepts + 1
    if compound_first_witness < 0 then
      compound_first_witness = i
    end
  end

  set row0 = invoke json_parse with "{}"
  set row0.s1 = s1
  set row0.s2 = s2
  set row0.s3 = s3
  set row0.guardian = guardian
  set row0.paused = paused
  set row0.proof_ok = proof_ok
  set row0.nonce_fresh = nonce_fresh
  set row0.allow = baseline
  push baseline_rows row0

  set row1 = invoke json_parse with "{}"
  set row1.s1 = s1
  set row1.s2 = s2
  set row1.s3 = s3
  set row1.guardian = guardian
  set row1.paused = paused
  set row1.proof_ok = proof_ok
  set row1.nonce_fresh = nonce_fresh
  set row1.allow = no_pause
  push no_pause_rows row1

  set row2 = invoke json_parse with "{}"
  set row2.s1 = s1
  set row2.s2 = s2
  set row2.s3 = s3
  set row2.guardian = guardian
  set row2.paused = paused
  set row2.proof_ok = proof_ok
  set row2.nonce_fresh = nonce_fresh
  set row2.allow = no_nonce
  push no_nonce_rows row2

  set row3 = invoke json_parse with "{}"
  set row3.s1 = s1
  set row3.s2 = s2
  set row3.s3 = s3
  set row3.guardian = guardian
  set row3.paused = paused
  set row3.proof_ok = proof_ok
  set row3.nonce_fresh = nonce_fresh
  set row3.allow = no_proof
  push no_proof_rows row3

  set row4 = invoke json_parse with "{}"
  set row4.s1 = s1
  set row4.s2 = s2
  set row4.s3 = s3
  set row4.guardian = guardian
  set row4.paused = paused
  set row4.proof_ok = proof_ok
  set row4.nonce_fresh = nonce_fresh
  set row4.allow = one_sig
  push one_sig_rows row4

  set row5 = invoke json_parse with "{}"
  set row5.s1 = s1
  set row5.s2 = s2
  set row5.s3 = s3
  set row5.guardian = guardian
  set row5.paused = paused
  set row5.proof_ok = proof_ok
  set row5.nonce_fresh = nonce_fresh
  set row5.allow = guardian_bypass
  push guardian_bypass_rows row5

  set row6 = invoke json_parse with "{}"
  set row6.s1 = s1
  set row6.s2 = s2
  set row6.s3 = s3
  set row6.guardian = guardian
  set row6.paused = paused
  set row6.proof_ok = proof_ok
  set row6.nonce_fresh = nonce_fresh
  set row6.allow = compound
  push compound_rows row6

  i = i + 1
end

function discover_policy rows
  set req = invoke json_parse with "{\"target_key\":\"allow\",\"domain\":[\"0\",\"1\"]}"
  set req.rows = rows
  set body = invoke json_stringify with req
  set resp = invoke http_post with (base + "/api/discover") and body and auth_header
  if at resp status_code != 200 then
    return "DISCOVER_HTTP_ERROR"
  end
  set parsed = invoke json_parse with (at resp body)
  set law = at parsed law
  return at law formula
end

set baseline_formula = invoke discover_policy with baseline_rows
set no_pause_formula = invoke discover_policy with no_pause_rows
set no_nonce_formula = invoke discover_policy with no_nonce_rows
set no_proof_formula = invoke discover_policy with no_proof_rows
set one_sig_formula = invoke discover_policy with one_sig_rows
set guardian_bypass_formula = invoke discover_policy with guardian_bypass_rows
set compound_formula = invoke discover_policy with compound_rows

set total_false_accepts = no_pause_false_accepts + no_nonce_false_accepts + no_proof_false_accepts + one_sig_false_accepts + guardian_bypass_false_accepts + compound_false_accepts
set mutants_killed = 0
if no_pause_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end
if no_nonce_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end
if no_proof_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end
if one_sig_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end
if guardian_bypass_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end
if compound_false_accepts > 0 then
  mutants_killed = mutants_killed + 1
end

set policy_verdict = "PASS"
if mutants_killed != 6 or baseline_formula == "DISCOVER_HTTP_ERROR" then
  policy_verdict = "FAIL"
end

set report = invoke json_parse with "{}"
set report.campaign = "bridge_authorization_exhaustive_mutation"
set report.verdict = policy_verdict
set report.states_per_version = 128
set report.versions = 7
set report.total_policy_evaluations = 896
set report.mutants_killed = mutants_killed
set report.mutation_score_percent = mutants_killed * 100 / 6
set report.total_false_accepts = total_false_accepts
set report.no_pause_false_accepts = no_pause_false_accepts
set report.no_nonce_false_accepts = no_nonce_false_accepts
set report.no_proof_false_accepts = no_proof_false_accepts
set report.one_sig_false_accepts = one_sig_false_accepts
set report.guardian_bypass_false_accepts = guardian_bypass_false_accepts
set report.compound_false_accepts = compound_false_accepts
set report.no_pause_first_witness = no_pause_first_witness
set report.no_nonce_first_witness = no_nonce_first_witness
set report.no_proof_first_witness = no_proof_first_witness
set report.one_sig_first_witness = one_sig_first_witness
set report.guardian_bypass_first_witness = guardian_bypass_first_witness
set report.compound_first_witness = compound_first_witness
set report.baseline_formula = baseline_formula
set report.no_pause_formula = no_pause_formula
set report.no_nonce_formula = no_nonce_formula
set report.no_proof_formula = no_proof_formula
set report.one_sig_formula = one_sig_formula
set report.guardian_bypass_formula = guardian_bypass_formula
set report.compound_formula = compound_formula
set persisted_report = invoke json_stringify with report
print persisted_report

REPRODUCE IN ONE REQUEST

Use your own key. Get the same machine-readable verdict.

export HOLO_API_KEY="YOUR_KEY"

python3 - <<'PY'
import os, pathlib, requests

key = os.environ["HOLO_API_KEY"]
code = pathlib.Path("bridge_policy_campaign.holo").read_text()
code = code.replace("__AUTH__", f"Authorization: Bearer {key}")

response = requests.post(
    "https://api.hiholo.ai/api/holo_exec",
    headers={"Authorization": f"Bearer {key}"},
    json={"code": code, "snapshot": False},
    timeout=120,
)
response.raise_for_status()
print(response.json()["output"][-1])

Validate first.
Deploy after the evidence.

Start with one critical decision flow. Move to an annual private deployment only after Holo Engine proves value on your system.

02 · DEPLOY

Protocol On-Prem

From$120,000/ year

Private deployment for a security team running continuous regression verification.

  • Up to 10 agreed modeled flows
  • Private on-prem deployment
  • CI integration and product updates
  • Implementation support
Onboarding & deployment from $20k one-time.
Talk about production
03 · SCALE

Enterprise

From$300,000/ year

Institutional deployment across multiple products, protocols, or business units.

  • Multi-product agreed scope
  • SSO, SLA, and custom integrations
  • Dedicated implementation support
  • Annual architecture health-check
Custom scope and support terms.
Talk about enterprise

Additional modeled flows are priced by scope. Custom modeling is delivered under a separate Statement of Work. Perpetual licensing is available only by exception and is not part of the standard offer.