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.
WITHDRAWAL REQUEST
Release locked assets
2-of-3 signaturesQuorum confirmed
PASSBridge proofEvidence confirmed
PASSReplay protectionNonce check removed
MISSINGEmergency pauseControl active
PASSHOLO VERDICT
Exploit blocked before execution
The same withdrawal could be approved twice.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 sourceVALIDATION PILOT · WHAT YOU BUY
One critical flow.
Four concrete deliverables.
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.
Behavior model
One signed-off map of the exact decision flow and its boundaries.
Complete state map
Every outcome in the tractable modeled space—not a sample.
Failure evidence
Concrete unsafe approvals, mutation score, and fix-ready counterexamples.
CI regression harness
A repeatable check your team keeps after the pilot ends.
WHAT THE BENCHMARK COMPARES
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 scoreFUZZING-STYLE RANDOM BASELINE
57.69/60Uniform random sampling512 samples per flow · 1,000 campaigns · 96.2% mean scoreCOMPLETE FINITE-STATE ORACLE
60/60Exhaustive enumeration10,240 unique states · 630 unsafe approvals · 100% mutation scoreWHERE HOLO FITS
Another security layer.
Not another replacement claim.
This is the Verify stage of the Holo Engine decision cycle — applied to access control.
Architecture, implementation, and expert judgment
Exhaustive regression for one signed-off decision flowProperty and invariant testing across generated executions
A complete finite-space map when enumeration is tractableSource-level proof against a formal CVL specification
A separate behavior-model artifact and business-readable counterexamplesDescriptions follow the tools’ own documentation: Foundry, Echidna, Certora.
ROI & RISK CASE
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,200EXPECTED ANNUAL LOSS EXPOSURE
$100,000EXECUTED HOLO EVIDENCE
Six injected defects.
Six exact failures exposed.
API-executed proof you can reproduce today. Customer evidence is published only with explicit permission.
Pause bypass
Transfers continued after the system should have stopped.
Replay risk
The same approved action could be accepted twice.
Proof bypass
An action passed without the evidence it required.
Weak approval
One signer could do what should require two.
Guardian bypass
An emergency role gained more power than intended.
Combined failure
Two missing safeguards opened a wider attack path.
Customer names and quotes appear only with explicit permission. Current proof: a reproducible open benchmark.
Completeness applies to the signed-off state space, so buyers know exactly what is covered.
Download the exact harness, runner, and expected output below.
FOR ENGINEERS
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.
Open full reproducible source277 lines ↓
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])
PRICING THAT STARTS WITH PROOF
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.
Validation Pilot
One critical flow, fixed boundaries, and reproducible evidence your team keeps.
- Signed-off decision model
- Complete tractable state map
- Counterexamples + mutation campaign
- CI-ready regression harness
Protocol On-Prem
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
Enterprise
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
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.