Skip to content
Crypto.world

Research

AuditFL: A Contract-Backed Clearing Layer for Open Federated Learning

On-chain update tickets, checkpoints and deterministic settlement make a federated-learning aggregator's round decisions replayable and economically accountable without moving training on chain.

AuditFL: A Contract-Backed Clearing Layer for Open Federated Learning
arXiv
2610.41278
Published
2026-10-30
Authors
Alexandros Balla, Spyros Lalis

AI summary

Overview

Research area: Blockchain-assisted federated learning (FL), specifically the coordination and settlement ("clearing") layer that sits above off-chain model training.

Technical level: Intermediate. The paper assumes familiarity with FL round structure and basic smart-contract/EVM concepts, but its central argument (separate ordering and accounting from tensor handling) is explained without heavy mathematics.

Scope: AuditFL is a Solidity smart-contract clearing layer that records FL round coordination, ticket deposits, refunds, rewards, and claims on chain while keeping model artifacts, training, and aggregation off chain, evaluated on full MNIST with a local Anvil Ethereum-compatible chain.

What This Paper Is About

Standard federated learning keeps raw data on client devices but still relies on a trusted coordinator to admit clients, distribute checkpoints, collect and aggregate updates, and pay rewards. If that coordinator is compromised or biased, it can censor participants, hide updates, manipulate aggregation, or publish round outcomes whose inputs and accounting cannot be independently reconstructed. AuditFL does not remove the aggregator; it makes the aggregator's round-level decisions attributable, replayable, auditable, and economically constrained by moving ordering, deposits, refunds, rewards, and claims into a public contract-backed state machine.

Key Contributions

  1. A clearing-layer architecture for open FL. The paper defines AuditFL as a contract-backed clearing layer that separates on-chain coordination and settlement from off-chain training, aggregation, and artifact storage, with tensor bytes referenced only by content identifiers.

  2. A fully specified round-clearing state machine. The protocol defines six transaction objects — ListingTx, FundingTx, UpdateIntentTx, UpdatePublishTx, GlobalUpdateTx, and ClaimTx — covering task listing, funding, ticket reservation with deposits, update publication, global finalization, refunds, reward entitlements, and claims, plus a deterministic round finalization rule.

  3. A layered safety and liveness argument under partial synchrony. The paper shows how ledger ordering, confirmation depth, ticket expiry, deposits, refunds, and scoring make coordinator and client actions replayable and economically accountable, using a stake-weighted PoS longest-chain deployment model and a latency approximation based on slots, confirmation depth, and proposer eligibility.

  4. A working prototype with measured overhead. The authors implement both a deterministic in-memory state-machine backend and a Solidity BCFLCoordinator contract on a local Anvil chain, then measure transaction counts, EVM gas, artifact volume, and learning-trajectory preservation on full MNIST, including controlled dropout, invalid-update, and artifact-unavailability stress tests.

Main Findings

  • Measured transaction counts match a closed-form model exactly. With R = 12 rounds, receipt counts rise from 51 transactions at N = 1 to 5,026 at N = 200 clients, matching the expression 2 + R × (2N + 2) + N. The clean-round application model is T_round = 1 fund + N reserve + N publish + 1 finalize = 2N + 2.

  • Artifact counts also match the analytical model exactly. Stored artifacts rise from 25 at N = 1 to 2,413 at N = 200, matching P_put = 1 + R × (N + 1).

  • Per-client calls dominate gas cost. At N = 200 the contract run consumes 829.7M gas, of which publishUpdate accounts for 408.7M and reserveTicket for 314.3M — approximately 87.1% combined — because each client reserves one ticket and publishes one identifier per round while finalizeRound runs once per round.

  • On-chain commitments are tiny relative to off-chain artifacts. At N = 200, artifact bytes occupy 144.9 MiB while committed SHA-256 identifier strings occupy only 0.163 MiB, a ratio of approximately 887×.

  • Learning behavior is preserved. AuditFL matches exactly the corresponding accuracy of Plain FL across all runs, with final test accuracy ranging from 89.65% at N = 1 to 89.21% at N = 200 clients. The paper attributes variation across client counts to differences in non-IID data partitioning.

  • Failures reduce inclusion but do not halt rounds. In stress tests at N = 50, R = 12, three seeds, and injected failure rates from 0% to 50%, client dropout, invalid updates, and artifact unavailability each reduce inclusion approximately linearly while rounds still finalize; even at 50% injected failures about 25 updates per round remain included.

  • Accuracy degradation under stress stays small. Final test-accuracy differences relative to Plain FL remain within a few tenths of an accuracy percentage point, with small positive values occasionally appearing because non-IID data means excluding some updates can remove noisy contributions. With only three seeds, the authors treat these differences as variation across failure realizations rather than evidence that one fault type is systematically worse.

  • Settlement invariant checked in practice. The implementation explicitly verifies that the settlement invariant from the paper's payout section holds in every run.

Methodology in Plain English

The authors split the FL pipeline into three pieces: the ledger, the artifact store, and the learning computation. Everything the ledger touches is small — task listings, ticket reservations, update identifiers, score vectors, refund and reward arrays. Everything large — model checkpoints and client updates — goes into a content-addressed off-chain store (the prototype uses a local SHA-256 store), and only the identifier goes on chain.

A client reserves a publication slot with a deposit, trains locally, uploads its update bytes, and then binds its ticket to the update's identifier on chain. At the deadline the coordinator fetches whatever updates it can retrieve, filters out malformed ones, scores the rest, aggregates with a FedAvg-style rule identical to the Plain FL baseline, uploads the new global model, and finalizes the round on chain. Unavailable or invalid updates are skipped and settled by policy instead of blocking the round.

To test it, the authors run two backends: a Solidity BCFLCoordinator contract on a local Ethereum-compatible Anvil chain for transaction and gas measurement, and a deterministic state-machine backend for controlled failure injection. Both share the same Python client and coordinator logic. Experiments use the full 70,000-example MNIST dataset loaded through OpenML, split into 42,000 training, 10,500 validation, and 17,500 held-out test examples, with client counts N ∈ {1, 2, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200}, 12 rounds, and Dirichlet non-IID partitioning with α = 0.4 for N > 1. Plain FL and AuditFL use identical splits, models, and aggregation so any difference is attributable to coordination and settlement.

Why This Matters

Impact on research. The paper reframes the blockchain-for-FL question away from "can we put training on chain" toward "what is the minimum on-chain state needed to make a round auditable." Its positioning table contrasts AuditFL with BlockFL, Biscotti, FedCoin, ChainFL, BlockFLA, BlockFLow, Auditable BR-FL, and VerifBFL, claiming explicit support across open admission, commitments, participation bonds, economic settlement, contract execution cost, and fault/attack focus. The closed-form overhead models give other researchers a baseline for predicting transaction counts, artifact counts, and gas from N and R alone.

Real-world applications:

  • Cross-organization model training in finance or healthcare consortia, where no single party is trusted to be the sole record-keeper of who contributed and who was paid.
  • Open participation marketplaces where any client may join without pre-approval, and deposits price reservation spam and unusable updates.
  • Auditable reward distribution for data-contribution programs, since refunds, forfeitures, and payouts can be recomputed from on-chain rules and submitted scores.
  • Compliance and dispute resolution, where an auditor can replay a round's control flow — listings, revealed tickets, included updates, scores — and confirm that accounting balances.

Industry relevance. The paper reports gas as a proxy for execution cost and explicitly declines to report monetary deployment cost, since that depends on network gas price. Still, the finding that publishUpdate and reserveTicket consume roughly 87.1% of gas at N = 200 identifies precisely where a production deployment would need batching, rollups, or cheaper encodings.

Future Directions

  • Public-network measurement. The evaluation runs on a local Anvil chain and a local content-addressed store, so public-network delay, reorganization behavior, and real gas prices are not measured.
  • Cryptographic enforcement rather than detectability. AuditFL deliberately claims detectability and accountability, not proof of correct aggregation; verifiable aggregation mechanisms are listed as future work.
  • Larger FL workloads and replicated artifact storage. The current study uses MNIST-scale artifacts (144.9 MiB at N = 200) and a single assumed-reliable artifact store.
  • Open questions on scoring and Sybil resistance. The ledger enforces settlement arithmetic but not the correctness of a task-specific scoring policy, and the authors state that fees, deposits, and intent caps do not by themselves guarantee Sybil-proof reward fairness or truthful contribution scoring. Robust aggregation rules (Krum, coordinate-wise median, trimmed mean) and privacy mechanisms (secure aggregation, differential privacy) are noted as compatible insertions that leave the state machine unchanged but are not evaluated here.

Target Audience

Researchers and engineers working at the intersection of federated learning and distributed ledgers — particularly those designing coordination, incentive, or settlement layers rather than model architectures. It also suits blockchain protocol engineers evaluating on-chain overhead for coordination-heavy applications, and practitioners in regulated or multi-party settings who need an auditable record of who participated in a training round and how they were compensated. Readers need only moderate background: the FL side is standard FedAvg, and the contract side is six function calls, though the security argument assumes comfort with partial synchrony and proof-of-stake finality concepts.

Authors’ abstract

Federated learning (FL) keeps raw data local, but most deployments still rely on a trusted coordinator for client admission, checkpoint distribution, update collection, aggregation, and rewards. This paper presents AuditFL, a contract-backed clearing layer for auditable FL in open settings. AuditFL keeps training and aggregation off chain, stores model artifacts in an assumed reliable off-chain artifact store, and records only content identifiers and economic state on chain.…

The full abstract on arXiv
Read the original paper