A Blockchain-based Traceability System for AI-Driven Engine Blade Inspection
Authors: Mahmoud Hafez, Eman Ouda, Mohammed A. Mohammed Eltoum, Khaled Salah, Yusra Abdulrahman
Organizations: Aerospace Engineering Department, Khalifa University of Science & Technology · Computer and Information Engineering Department, Khalifa University of Science & Technology · Advanced Research and Innovation Center (ARIC), Khalifa University of Science & Technology
Aircraft engine blade maintenance relies on inspection records shared across manufacturers, airlines, maintenance organizations, and regulators. Yet current systems are fragmented, difficult to audit, and vulnerable to tampering. This paper presents BladeChain, a blockchain-based system providing immutable traceability for blade inspections throughout the component life cycle. BladeChain is the first system to integrate multi-stakeholder endorsement, automated inspection scheduling, AI model provenance, and cryptographic evidence binding, delivering auditable maintenance traceability for aerospace deployments. Built on a four-stakeholder Hyperledger Fabric network (OEM, Airline, MRO, Regulator), BladeChain captures every life-cycle event in a tamper-evident ledger. A chaincode-enforced state machine governs blade status transitions and automatically triggers inspections when configurable flight hour, cycle, or calendar thresholds are exceeded, eliminating manual scheduling errors. Inspection artifacts are stored off-chain in IPFS and linked to on-chain records via SHA-256 hashes, with each inspection record capturing the AI model name and version used for defect detection. This enables regulators to audit both what defects were found and how they were found. The detection module is pluggable, allowing organizations to adopt or upgrade inspection models without modifying the ledger or workflows. We built a prototype and evaluated it on workloads of up to 100 blades, demonstrating 100% life cycle completion with consistent throughput of 26 operations per minute. A centralized SQL baseline quantifies the consensus overhead and highlights the security trade-off. Security validation confirms tamper detection within 17~ms through hash verification.
Figures & tables
System
Year
Multi-Org
Multi-Org
Maintenance
Parts Life
AI
Off-Chain
Off-Chain
Actors
Endorsement
Record Keeping
Cycle Mgmt
Integration
Record Storage
Integrity Proofs
Aleshi et al. [ 12 ]
2019
✓
✗
✓
✗
✗
✗
✗
Schyga et al. [ 25 ]
2019
✓
✓
✓
✓
✗
✗
✗
Ho et al. [ 4 ]
2021
✓
✓
✓
✓
✗
✗
✗
AirChain [ 11 ]
2022
✓
✗
✓
✗
✗
✗
✗
Hawashin et al. [ 26 ]
2024
✓
✗
✓
✓
✗
✓
✗
TABLE I : Comparison of blockchain systems for aviation maintenance and traceability.
Fig. 1 : BladeChain architecture. Client applications communicate with the API gateway via REST/SSE. The gateway orchestrates interactions with the Hyperledger Fabric network, IPFS storage, and the pluggable AI inspection engine.
Fig. 2 : Sequence diagram for blade inspection operations. The API gateway orchestrates AI inference, IPFS storage, hash computation, and chaincode invocation before returning results to the client.
Fig. 3 : BladeChain network topology. Peers execute the chaincode and sign. Orderers sequence endorsed transactions into blocks. Peers validate and commit to state database.
Fig. 4 : Blade life cycle stages and permitted transitions. Transitions are enforced by chaincode; the transition to Inspection_Due occurs automatically when usage thresholds are exceeded.
Field
Description
serialNumber
Unique blade identifier (PK)
currentState
Current life cycle state
currentOwner
Operating airline (MSP ID)
manufactureDate
ISO 8601 manufacture timestamp
totalFlightHours
Cumulative flight hours
totalFlightCycles
Cumulative flight cycles
TABLE II : Blade record fields stored on-chain.
Field
Description
eventID
Deterministic identifier
serialNumber
Associated blade serial number
inspectionDate
ISO 8601 inspection timestamp
inspectionType
Type
aiModelName
AI model name
aiModelVersion
AI model version
TABLE III : Inspection event fields recorded on-chain.
Mechanism
Protection
Block hashing
Each block contains the hash of the previous block; tampering invalidates subsequent chain
Endorsement signatures
Committed transactions carry signatures from the majority of organizations
IPFS CID
Content-addressed storage; CID derived from content hash
Encrypted peer-to-peer and client-to-peer communication
TABLE IV : Data integrity mechanisms.
Threat
Mitigation
Invalid transaction
Rejected by majority endorsement policy
Single compromised peer
Cannot forge transactions without majority endorsement
Forged inspector identity
Inspector/org derived from MSP certificate, not client input
Network eavesdropper
TLS encryption on all channels
IPFS substitution
CID and SHA-256 verification detects modification
Raft node failure
Tolerates <N/2 crash faults (1 of 3 orderers)
TABLE V : Threat model: adversary capabilities and mitigations.
Component
Technology
Version
Blockchain framework
Hyperledger Fabric
2.5.14
Consensus
Raft (etcdraft)
3 orderers
Smart contract
Go
1.21.13
State database
Apache CouchDB
3.3.2
API gateway
Node.js + Express
20.19.5
Fabric SDK
fabric-network
2.2.20
TABLE VI : Implementation technology stack.
Fig. 5 : Blade images at different processing stages: (a) healthy blade generated using BladeSynth; (b) defective blade generated using BladeSynth; (c) AI inference result for the defective image in (b), showing detected defects annotated with bounding boxes.
Fig. 6 : AI inspection history view (cropped from blade dossier), showing IPFS-stored images and SHA-256 hashes. The full dossier view also includes blade metrics such as operating hours, cycles, ownership, and current state.
(a) Dashboard overview
Workload
Completed
Operations
10 blades × 2 cycles
10/10 (100%)
429
50 blades × 2 cycles
50/50 (100%)
2,157
100 blades × 2 cycles
100/100 (100%)
4,075
TABLE VII : Functional validation results.
Workload
Duration
Throughput
Ops/Blade
10 blades
979 sec
26.28 ops/min
42.9
50 blades
4,933 sec
26.24 ops/min
43.1
100 blades
9,476 sec
25.80 ops/min
40.8
TABLE VIII : Scalability evaluation results.
Operation
Count
P50 (ms)
P95 (ms)
Max (ms)
Manufacture
100
2,092
2,102
2,123
Flight log
1,800+
2,085
2,105
2,107
Inspection
200+
2,079
2,095
2,098
Repair
100+
2,080
2,087
2,100
Approval
100+
2,074
2,076
2,076
TABLE IX : Transaction latency by operation type.
Metric
PostgreSQL
BladeChain
Ratio
Duration (100 blades)
92 sec
9,476 sec
103 ×
Throughput
3,617 ops/min
25.8 ops/min
140 ×
Write latency (avg)
0.72 ms
2,087 ms
2,899 ×
Read latency (avg)
0.88 ms
20.9 ms
24 ×
TABLE X : Performance comparison: BladeChain vs. PostgreSQL baseline.
Fig. 8 : Tamper detection verification. The recomputed hash from the retrieved artifact differs from the on-chain hash, producing a detectable mismatch.
Fig. 9 : Console output excerpt from the tamper-evidence test, confirming the hash mismatch and verification timing.
AI systems are increasingly used to assist consequential decisions in regulated domains such as auditing, finance, and healthcare. This creates a recurring obligation: an organization must be able to reconstruct, after the fact, which evidence informed a given conclusion, and to show that the record of that reasoning was not altered. Existing tools address related but distinct problems - model observability, drift monitoring, governance reporting - and are built for the machine-learning engineer operating a system, not the reviewer who must trace one specific conclusion back to its supporting evidence. We present AuditWeave, a lightweight Python library, with no runtime dependencies, that records the steps of AI-assisted and data-transformation workflows into a single append-only, hash-chained ledger. A small, system-agnostic event vocabulary spans both retrieval-augmented generation (RAG) pipelines and tabular/lakehouse transformations, so a conclusion that draws on both can be traced end-to-end through one record. Within a sealed ledger, any modification, reordering, insertion, or deletion of events is detectable through chain verification. We describe the design and evaluate recording overhead, scalability, and tamper-detection correctness on the reference implementation. The integrity guarantees cost tens of microseconds per event, and, as the hash-chain construction implies, verification flagged every injected mutation across four mutation classes over 2,000 randomized trials.
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 an immutable blockchain ledger. Rather than using blockchain as passive storage, we enforce the entire approval process through smart contracts, ensuring that every transaction, prediction, and explanation is atomically recorded and cannot be retroactively modified. Our detection module achieves competitive accuracy (F1 = 0.895, PR-AUC = 0.974) while providing cryptographically verifiable decision trails that support regulatory auditability requirements (e.g., GDPR Article 22). System evaluation shows sub-25 ms inference latency and economically viable deployment on Layer-2 networks at under $0.01 per transaction (validated against PolygonScan data), supporting enterprise-scale workloads of 10,000+ monthly payments.
Zhaohui Wang
Viterbi School of Engineering University of Southern California Los Angeles, CA, USA
Long-horizon agents execute thousands of actions, resulting in sequential failures rather than isolated errors. When a coding agent deletes a production database or a prompt injection spreads across agents, the incident raises questions of causality, authority, and non-repudiable third-party verification. The Agent Flight Recorder captures each agent action as a structured, canonically serialized event binding eight semantic fields from intent through execution to provenance. Hash chaining and Merkle batching provide tamper evidence and compact inclusion proofs. For cross-organizational disputes where no party's infrastructure qualifies as neutral ground, periodic on-chain anchoring of epoch roots lets any verifier with the disclosed payload and Merkle proof check the record independently, without pre-agreeing on a trusted intermediary. The on-chain footprint is minimal: each anchor stores a 32-byte epoch root and a back-pointer, and no event content touches the chain. We evaluate the system across five cumulative ablation configurations on synthetic agent workloads. The full system adds ~48 microseconds median per-event latency and 512 bytes per event. L2 anchoring costs $2.30 per 100K events at 100-event epochs. The full integrity stack detects edit, delete, reorder, and fork tampering at 100% with zero false positives. Structured forensic queries achieve 1.0 precision on guardrail and delegation lookups where unstructured text search yields 0.013 and 0.077 respectively.
Laurent Bindschaedler, Quentin Botha, Christoph Siebenbrunner
Max Planck Institute for Software Systems · Research Institute for Cryptoeconomics, Vienna University of Economics and Business