Research
Who Audits the Auditor? Tamper-Proof Fraud Detection with Blockchain-Anchored Explainable ML
Enterprise fraud detection systems are typically judged by model accuracy, but the audit trail they produce usually lives in a database that a privileged administrator can edit or delete.

- arXiv
- 2604.22096
- Published
- 2026-04-23
- Authors
- Zhaohui Wang
AI summary
Overview
Research area: Systems security for financial fraud detection — combining machine learning, explainable AI (SHAP), and blockchain smart contracts into a single audit architecture. Category cs.CR.
Technical level: Intermediate. The machine learning component is deliberately conventional (gradient-boosted trees); the novelty lives in the systems and security architecture, so readers need comfort with smart contracts, consensus, and audit-trail concepts rather than deep learning theory.
Scope (one sentence): The paper argues that fraud detection fails in adversarial settings not because the models are wrong but because insiders can tamper with the logs and bypass the workflow, and it proposes anchoring every prediction, explanation, and approval step to a blockchain ledger with the approval logic itself enforced by smart contracts.
What This Paper Is About
Enterprise fraud detection systems are typically judged by model accuracy, but the audit trail they produce usually lives in a database that a privileged administrator can edit or delete. The paper opens with a scenario in which a company with a 94% accuracy detector lost $2.3 million over 18 months because a finance director with admin access deleted the alerts before anyone saw them. The goal is to build a pipeline — from payment submission through machine-learning scoring to multi-party approval — that remains trustworthy even when the people operating it are not, by making log tampering mathematically infeasible rather than administratively forbidden.
Key Contributions
-
A tamper-evident system architecture that anchors both ML predictions and their SHAP-based explanations to an immutable ledger, producing verifiable decision trails that support regulatory auditability requirements such as GDPR Article 22.
-
An empirical comparison against four baselines (Rule-Based, Random Forest, XGBoost with SMOTE, and LSTM-Attention) showing the LightGBM detector reaches F1 = 0.895 and PR-AUC = 0.974 — competitive accuracy — while being the only system in the comparison that provides cryptographically verifiable audit trails.
-
A deployment and cost analysis grounded in real blockchain data (PolygonScan, April 2026, POL = $0.085), showing Layer-2 costs of $0.002–$0.008 for a typical 751K-gas payment workflow at 30–130 gwei, with confirmation times of 3–5 seconds and 92% of Polygon transactions costing under $0.01.
-
A seven-state smart contract workflow (Created, ManagerApproved, FinanceApproved, BudgetChecked, Executed, Rejected, Cancelled) in which every state transition is a separate blockchain transaction and no approval path exists that bypasses ML evaluation.
Main Findings
-
Detection accuracy is competitive, not novel. The LightGBM detector achieves precision 0.848, recall 0.948, F1 0.895, and PR-AUC 0.974 under 5-fold stratified cross-validation, beating XGBoost (F1 0.841, PR-AUC 0.968), Random Forest (0.821 / 0.952), LSTM-Attention (0.818 / 0.885), and Rule-Based (0.089 / 0.156). The authors explicitly frame this as a systems contribution rather than an algorithmic one.
-
Literature comparison holds up. Against published numbers — Random Forest 0.86 F1 / 0.87 PR-AUC, LSTM-Attention 0.89 / 0.91, PC-GNN 0.87 / 0.90, GAN-RNN Hybrid 0.87 / 0.90 — the paper's 0.895 / 0.974 is in the same band, but none of those systems address auditability.
-
Inference cost is dominated by explanation, not prediction. ML prediction takes 1.2 ms, SHAP explanation of the top-5 features adds 18.5 ms, and the API round-trip is 23.4 ms. ML-only batch throughput reaches 45,000 per second.
-
Blockchain confirmation is the real bottleneck. Layer-2 confirmation of 3–5 seconds on Polygon PoS (post-Giugliano hardfork, which cut finality by roughly 2 seconds) caps end-to-end throughput at about 200 transactions per minute. The paper notes a company processing 10,000 monthly payment requests needs only 0.2 transactions per minute on average.
-
Costs are far below mainnet. For a 751K-gas workflow, Ethereum L1 costs $56.33 per transaction ($56,330 at 1,000 tx/month), Arbitrum $0.56 ($560), Optimism $0.48 ($480), and Polygon $0.002 at 30 gwei or $0.008 at 130 gwei ($2–$8 at 1,000 tx/month). Even at the January 2026 spike of 1,519 gwei, cost stays under $0.10.
-
The insider-attack case study is the clearest demonstration. In a simulation where a finance manager submits five payments totalling $50,000 to a vendor they control, all flagged with fraud probability above 0.85, and approves all five within 10 minutes, a traditional system shows only the approvals after the alerts are deleted. The blockchain-anchored system preserves the exact scores, the SHAP reasons, the identity of the approver, and cryptographically linked timestamps.
-
Detection degrades gracefully across fraud rates. At a 0.1% fraud rate precision drops to 0.71 while recall stays above 0.92; at 5% fraud rate precision improves to 0.91. Blockchain overhead is constant because every transaction is logged whether flagged or not.
-
Throughput has a defined ceiling. At 200 tx/min the system supports up to 8,640 daily transactions, or under 260,000 monthly transactions; beyond that, batch processing or parallel chains are required.
-
A prototype worked end to end. A 3-node Quorum consortium chain replayed 30 days of simulated enterprise workload (approximately 8,000 transactions) with injected anomalies, and external auditor nodes could independently verify the full history without access to internal systems.
Methodology in Plain English
The authors start from a diagnosis rather than an algorithm. They map a standard enterprise payment workflow — submit, ML check, approve, log, execute — and identify two attack points: an insider can approve a payment without ML review, and an insider can edit the log afterward. Storing logs on a blockchain fixes only the second, because an attacker can still lie before the record reaches the chain.
Their fix is to move the workflow logic itself into smart contracts. When an employee submits a payment, an off-chain REST API scores it with LightGBM and computes SHAP contributions, then writes the request details, fraud score, and top-5 SHAP features into a blockchain transaction in a single atomic step. The contract checks budget constraints and records the assessment, requires separate manager and finance approvals as additional on-chain transactions, and only then releases funds. Because the contract code is the workflow, there is no separate logging step to skip.
To evaluate, they use the Kaggle Credit Card Fraud dataset (284,807 transactions, 0.17% fraud rate) for comparability with published work, plus a 10,000-transaction synthetic enterprise dataset whose fraud mix is drawn from ACFE industry reports (vendor fraud 27%, billing schemes 22%, expense reimbursement 14%). They measure latency for each pipeline stage, price out transactions across four network types using live gas data, and stress-test the design through sensitivity analysis on fraud rate, volume, gas volatility, and confirmation time.
The authors are candid about where trust still leaks. ML runs off-chain because blockchain virtual machines cannot handle inference, so the inference server remains a residual trust point. They propose three mitigations: committing the model hash on-chain with signed inference responses, running inference inside Intel SGX or AMD SEV enclaves (at a stated 10–30% overhead for tree-based models), or committee-based scoring where a quorum such as 2-of-3 independent servers must agree.
Why This Matters
Impact on research. The paper reframes fraud detection as a security problem rather than a classification problem. It argues that benchmarking culture — which ranks methods purely on F1 and PR-AUC — systematically ignores the failure mode that actually causes losses. It also draws a sharp architectural distinction with prior blockchain-auditing work: earlier systems use the chain as a storage layer for decisions made elsewhere, whereas this work uses it as the execution layer.
Real-world applications:
- Banking and payments — multi-party approval chains where an external regulator or auditor sits as a consortium validator and can verify history independently.
- Government contracting and public procurement — high-value disbursements where the cost of a single fraudulent payment dwarfs the system's operating cost.
- Healthcare claims processing — regulated environments where automated decisions must be explainable and contestable on the record.
- Any distributed organization — settings where no single entity should hold unilateral control over the audit log, such as joint ventures or multi-tenant ERP deployments.
Industry relevance. The economics are the argument. At $2–$8 per 1,000 monthly transactions on Polygon, the cost objection largely dissolves for any organization where a single fraud incident runs into six figures — and the paper cites ACFE figures that occupational fraud costs an estimated 5% of annual revenues with median losses of $145,000 per case. The paper also gives a clear recommendation matrix rather than a blanket sales pitch: consortium chains with external auditors as validators for most enterprises, public L2 with attention to sequencer centralization and censorship risk, and an explicit statement that private chains should not be used for fraud prevention since a single administrator controls all validators — the same vulnerability as a traditional database.
Future Directions
-
Closing the off-chain inference gap. The paper's own threat model concedes that a compromised ML server can submit false predictions; it only guarantees the false prediction cannot be hidden. TEE-based attestation or committee quorum scoring are proposed but not empirically evaluated here — a natural next study.
-
Adversarial robustness and concept drift. The authors state plainly that their evaluation assumes a stationary data distribution and does not test adversarial examples. Since fraud patterns evolve in response to detection, retraining with drift detection and input validation at the API boundary remain open operational problems.
-
Scaling past the confirmation bottleneck. At 200 tx/min the architecture supports under 260,000 monthly transactions. Batch processing, parallel chains, or optimistic execution with post-hoc verification are named as paths forward but not developed.
-
Sequencer decentralization and governance risk. The analysis flags that most rollups rely on a centralized sequencer that could censor or delay transactions, and that protocol upgrades controlled by a small multisig introduce governance risk. Monitoring shared-sequencing roadmaps and building L1 forced-inclusion fallbacks are identified as open engineering questions.
Target Audience
Enterprise security architects and audit/compliance engineers will get the most direct value, since the paper reads as a deployment blueprint with cost tables and network-selection guidance. Researchers in applied cryptography, blockchain systems, and trustworthy ML will find the framing useful — particularly the argument that "auditability" should be treated as a first-class evaluation axis alongside accuracy. Fraud detection practitioners who work on the modeling side should read it mainly for the threat model, since the paper deliberately contributes no new detection algorithm. Regulators, internal auditors, and CISOs evaluating whether blockchain anchoring satisfies auditability expectations will find the section on what anchoring does and does not establish legally to be the most relevant part. The system implementation is linked in the paper at the author's GitHub repository.
Authors’ abstract
In enterprise fraud detection, model accuracy alone is insufficient when insiders can tamper with audit logs or bypass approval workflows. Real-world incidents show that fraud often persists not because detection algorithms fail, but because the audit trail itself is controllable by privileged operators. This exposes a fundamental trust gap: *who audits the auditor?* We present a tamper-evident fraud detection system that anchors both ML predictions and workflow execution to…
The full abstract on arXiv