In federated learning, many devices train a shared model and send updates to an aggregator. Homomorphic encryption lets that aggregator add the encrypted updates without ever seeing them: it computes on ciphertexts, which are encrypted data. The fastest encrypted-aggregation systems are all synchronous, which means every round waits for the slowest device, the straggler. The best way to handle stragglers without biasing the model toward always-online devices is to remember each device's most recent update and keep reusing it while the device is away. That memory is expensive and fragile once updates are encrypted. This proposal makes it cheap. Each client uploads only the encrypted difference between its new update and what it has already contributed. The aggregator then keeps a single encrypted running sum instead of one ciphertext per client. An append-only public log records every difference by its content hash, so anyone can check that none was dropped or applied twice.
The central observation is that this design fixes one problem and exposes another. Adding encrypted differences is trivially cheap and needs no costly noise-refresh operations. But a persistent encrypted sum corrupts permanently if a single difference is lost, replayed, or rounded badly, and nobody can inspect it to notice. Asynchronous decryption also leaks: if only one client arrived between two released snapshots, subtracting them reveals that client's update exactly. The research is about making the encrypted running sum correct, auditable, and leak-bounded. The blockchain here is not the storage layer. It is the exactly-once ledger and the rule that decides when a snapshot may be released.
Core Claim
Memory-augmented asynchronous aggregation can run under additive homomorphic encryption with three properties. The aggregator keeps constant-size encrypted state. Quantization error stays bounded by one step per client rather than growing over time. A privacy guarantee holds that each decrypted change reveals only a sum over at least $k$ distinct clients. On non-IID data with correlated device unavailability, this should match the accuracy of plaintext memory-augmented averaging and reach target accuracy faster in wall-clock time than synchronous encrypted aggregation. It should also beat the obvious encrypted asynchronous design, a buffer of fresh updates with no memory, which inherits the bias toward frequently available devices.
Background and the Gap
Three pieces of prior work supply the ingredients.
MIFA supplies the optimization rule we reuse. Its "impatient" server averages whatever arrives within a time window and keeps an array of every client's latest update. It proves minimax-optimal convergence without knowing availability patterns. It does all of this in plaintext with a central memory.
BatchCrypt supplies the encryption machinery. It quantizes gradients to low-bit signed integers, packs many into one plaintext, and encrypts them additively. It reports 23x–93x training speedups over stock FATE with under 1% accuracy loss. It is strictly synchronous.
ESAFL offers a lattice-based additive scheme with one-step multi-key decryption. It reports only 1.25x–2x training-time overhead over plaintext, and is also synchronous. FLASHE constrains the design: its masks cancel only when paired clients report together. A client that drops out or arrives late therefore breaks the cancellation. This is exactly the regime we target, which is why we build on additive encryption rather than pairwise masking.
Several systems combine two of the three directions, and each leaves out the piece we need. HieAvg estimates missing straggler updates from decayed history over a Raft consortium chain. It reports 0.74 MNIST accuracy with 40% stragglers, entirely in plaintext. FedAC/FedBlock damps stale updates by a staleness coefficient and runs aggregation through consensus nodes, again in cleartext. FLSSM shards CKKS aggregation across edge nodes and uses timestamps for rewards. It stays synchronous and never uses time to weight updates. FL-Incentivizer puts model weights on IPFS with content identifiers in Ethereum tokens, reporting "around 0.00025 ETH" per global update. It works only for synchronous, unencrypted rounds.
None of these keeps straggler memory under encryption. None of them treats the ledger as a correctness mechanism for persistent encrypted state.
The research file's Gap 1 claims that staleness weighting forces expensive encrypted multiplication and bootstrapping, the costly operation that refreshes accumulated noise in lattice ciphertexts. We think this is overstated. Staleness weights are public, and multiplying a ciphertext by a public scalar needs no bootstrapping. The real difficulty lies elsewhere: persistence, error accumulation in packed integers, and leakage from asynchronous release. That is where this proposal focuses.
Research Program
Difference uploads. Let $c_i$ be client $i$'s contributed vector: the dequantized sum of everything it has ever uploaded. Let $u_i$ be its freshly computed update and $Q$ a BatchCrypt-style quantizer. The client uploads $\mathrm{Enc}(Q(u_i - c_i))$ and sets $c_i \leftarrow c_i + Q(u_i - c_i)$. The aggregator folds each arrival into one ciphertext:
$$ \mathrm{Enc}(S) \leftarrow \mathrm{Enc}(S) \oplus \mathrm{Enc}(Q(u_i - c_i)), \qquad S = \sum_{i=1}^{N} c_i, $$
where $\oplus$ is homomorphic addition and $N$ is the number of clients. Because $c_i$ is carried forward, this is error feedback. The gap $\|u_i - c_i\|$ after an upload is at most one quantization step, so $S$ tracks MIFA's sum of latest updates to within $N$ steps however long training runs. We will prove this bound.
Integer headroom. $S$ is always a sum of $N$ current contributions, never a sum over time. The packed slot width therefore needs about $\log_2 N$ extra bits beyond the quantization width, a constant. We will check this against BatchCrypt's overflow-prevention scaling.
Model distribution. The model itself lives with key-holding clients, as in BatchCrypt. Periodically a key holder publishes an encrypted model checkpoint. A returning straggler fetches the latest checkpoint rather than replaying history.
The ledger. Each difference ciphertext goes to content-addressed storage (IPFS). The chain records a tuple: the content identifier, the client ID, the client's per-client sequence number, and the model version the update was computed from. A consortium chain with Raft consensus, as in HieAvg, replaces mainnet gas with bounded latency; a Merkle root per batch amortizes cost further. A smart contract enforces two rules. The first is exactly-once application: sequence numbers must be contiguous per client. The second is the release rule: a new aggregate snapshot may be decrypted only after at least $k$ distinct clients have logged differences since the last release.
Any verifier can recompute the fold from the last anchored snapshot and the logged ciphertexts, then compare hashes. After each checkpoint, older differences can be garbage-collected.
Privacy analysis. We will formalize the difference attack on asynchronous encrypted aggregation. We will show that the release rule bounds what any sequence of releases reveals to sums over at least $k$ clients. We will also quantify the trade-off: larger $k$ means more staleness and longer wall-clock time.
Threat model. The threat model is BatchCrypt's: an honest-but-curious aggregator that does not collude with clients. We will also evaluate a threshold-key variant in the spirit of ESAFL. Collusion between the aggregator and a key holder is outside scope for the shared-key variant, and we will say so.
Baselines
Naive reference points. The first is synchronous BatchCrypt with a round deadline that drops late clients, the "do nothing" design. The second is synchronous BatchCrypt that waits for every client. Both run on identical hardware, client-speed traces, and quantization width. The learning rate for each gets the same tuning budget of a small grid on a held-out split.
Plaintext upper references. One is plaintext MIFA, which shows how much encryption costs. The other is FADAS, the strongest asynchronous optimizer in the file. On CIFAR-10 with ResNet-18 under large delays it reports about 79.7% accuracy, against FedAsync's about 75.3%, and 8x faster time-to-target than FedAvg. We rerun FADAS in our unavailability traces rather than quoting it across settings. The goal is to land within one point of plaintext MIFA's accuracy, not to beat plaintext.
Strongest encrypted competitor. This is a buffered asynchronous design under BatchCrypt encryption, which we build ourselves. It encrypts fresh full updates, flushes after $k$ arrivals, and has no per-client memory. It uses the same $k$, the same release rule, and optional public staleness scaling. Beating it means higher final accuracy and faster time-to-target on non-IID data with availability correlated to data, at equal bytes uploaded.
Ablations isolating the key ingredients. The first stores all $N$ per-client ciphertexts server-side and subtracts and adds them. The math is identical, which isolates the benefit of constant-size state; we measure storage and per-arrival latency. The second removes error feedback, to measure drift. The third removes the release rule, to demonstrate the leak. The fourth removes the ledger, to measure silent corruption under injected faults.
For HieAvg's 0.74 on MNIST with 40% stragglers, we cite it only as context because its setting differs. For MIFA, the file contains no numerical accuracy result on Lacuna.
Why not just…?
Why not just use buffered asynchronous encrypted aggregation without memory? This is the real threat, and it is cheap. MIFA's analysis shows that averaging only whoever shows up biases the model when availability correlates with local data. That bias should survive encryption unchanged. We will test this directly on CIFAR-10 with Dirichlet splits. Availability will be tied to label clusters, so that some classes live mostly on rarely available devices. If the buffered baseline matches us there, the memory mechanism is not worth its complexity and we will report that.
Why not just drop stragglers at a deadline, or wait for them with fast encryption? Dropping discards rarely available clients, and HieAvg reports that dropping delayed updates degrades accuracy relative to retaining them. Waiting leaves fast devices idle, and FADAS attributes its 8x speedup to removing exactly that. Faster encryption such as ESAFL shrinks the cryptographic cost but not device heterogeneity. Our wall-clock experiments with heavy-tailed client-speed traces measure both effects.
Why not just use pairwise masking or differential privacy? FLASHE's mask cancellation requires paired clients to report together, which asynchronous arrivals violate. Local differential privacy adds noise that the OARF suite notes costs accuracy. We include a masked variant with dropout recovery disabled only to show where it breaks. We do not claim differential privacy is unusable, and we will not tune it.
Why not just use a signed append-only log on a cloud bucket instead of a chain? If a single trusted party runs the log, that suffices, and it is faster. The ledger matters only because the party that could drop or replay differences, the aggregator, must not control the log. A multi-operator Raft log is the minimal version of that property. We will benchmark the aggregator-signed log against the consortium chain on latency and fault detection, and recommend the cheaper one where the trust model allows.
Proposed Experiments
The benchmarks are CIFAR-10 with ResNet-18 under Dirichlet non-IID splits, following FADAS and FLSSM; Fashion-MNIST with the fully connected network used by BatchCrypt and ESAFL; and Shakespeare with an LSTM, following BatchCrypt. We use 100 to 1,000 simulated clients with availability patterns in the style of MIFA: periodic, bursty, and correlated with labels.
The metrics are final accuracy, wall-clock time to target, bytes uploaded per client, aggregator state size, per-arrival aggregation latency, ledger transactions and latency, and, for the Ethereum variant, gas per anchored batch. The gas figure is compared against FL-Incentivizer's reported 0.00025 ETH per update.
There are three decisive checks.
- Accuracy gap. Our method must stay within one point of plaintext MIFA and beat the buffered encrypted baseline under label-correlated unavailability. If it does not beat the buffered baseline, the idea fails.
- Leak and its closure. With the release rule off, a key holder should reconstruct a single client's quantized update exactly from consecutive snapshots. With the rule on at size $k$, reconstruction error should match that of recovering one term from a $k$-term sum.
- Fault detection. Under injected drops and replays of difference ciphertexts, the ledger-verified fold should detect every fault. The unverified variant should show permanent accuracy damage that never self-corrects, the failure mode that motivates the ledger.
We will also report headroom overflow rates across $N$, to confirm the constant-bit claim empirically.
References
- Fast Federated Learning in the Presence of Arbitrary Device Unavailability
- BatchCrypt: Efficient Homomorphic Encryption for Cross-Silo Federated Learning
- ESAFL: Efficient Secure Additively Homomorphic Encryption for Cross-Silo Federated Learning
- FLASHE: Additively Symmetric Homomorphic Encryption for Cross-Silo Federated Learning
- Straggler Mitigation and Latency Optimization in Blockchain-based Hierarchical Federated Learning
- Blockchain-Enabled Asynchronous Federated Learning in Edge Computing
- FLSSM: A Federated Learning Storage Security Model with Homomorphic Encryption
- FL-Incentivizer: FL-NFT and FL-Tokens for Federated Learning Model Trading and Training
- FADAS: Towards Federated Adaptive Asynchronous Optimization