Blockchain Based Federated Learning For Secure Data Sharing — Complete Documentation & Simulation

Overview & System Context

Blockchain Based Federated Learning For Secure Data Sharing: Comprehensive Web-Sourced Technical Investigation Exhaustive Research Dossier · Pure Web-Scraped Content: ~9548 Words · Real Software Screenshots: 3 1. Executive Overview & Technical Background Quick Share is a wireless peer-to-peer data transfer service for Android, ChromeOS and Windows. Originally developed by Samsung Electronics for its own devices, Google subsequently collaborated with Samsung and merged its own Nearby Share into Quick Share in 2024, distributing Quick Share to non-Galaxy Android devices through Google Play Services and releasing a Windows app for non-Galaxy PCs. Quick Share utilizes Bluetooth and Wi-Fi Direct to send files to nearby devices.

Samsung devices can send to distant recipients through the Samsung Cloud. Samsung develops a client intended for Samsung Galaxy Book PCs only, available from the Microsoft Store; Google distributes another client for any non-Samsung computer running Microsoft Windows. Private Share was a derivative data transfer service which used blockchain encryption, designed for important personal or financial information. Sharing files is possible via the phone number associated with a phone's SIM card, or a user-chosen private number. A private number is exclusive to the Private Share app, and commences with # and includes 10 digits, like #0123456789. The sender is able to set an expiry date for the files, which get automatically deleted from the recipient's devices. There is a 200 megabyte upload limit for senders. Like Quick Share, Private Share is also preloaded on Samsung Galaxy devices. Since December 2023, Private Share has been integrated with Quick Share, and is no longer a separate service.

Local differential privacy (LDP) is a model of differential privacy with the added requirement that if an adversary has access to the personal responses of an individual in the database, that adversary will still be unable to learn much of the user's personal data. This is contrasted with global differential privacy, a model of differential privacy that incorporates a central aggregator with access to the raw data. Local differential privacy (LDP) is an approach to mitigate the concern of data fusion and analysis techniques used to expose individuals to attacks and disclosures. LDP is a well-known privacy model for distributed architectures that aims to provide privacy guarantees for each user while collecting and analyzing data, protecting from privacy leaks for the client and server. LDP has been widely adopted to alleviate contemporary privacy concerns in the era of big data.

Figure 1: Medical BCFL: A blockchain-enabled federated learning architecture for ... Facial recognition has become widespread in recent years. Recent smartphones, for example, utilize facial recognition to unlock the users phone as well as authorize the payment with their credit card. Though this is convenient, it poses privacy concerns. It is a resource-intensive task that often involves third party users, often resulting in a gap where the user's privacy could be compromised. Biometric information delivered to untrusted third-party servers in an uncontrolled manner can constitute a significant privacy leak as biometrics can be correlated with sensitive data such as healthcare or financial records.

In Chamikara's academic article, he proposes a privacy-preserving technique for "controlled information release", where they disguise an original face image and prevent leakage of the biometric features while identifying a person. He introduces a new privacy-preserving face recognition protocol named PEEP (Privacy using Eigenface Perturbation) that utilizes local differential privacy. PEEP applies perturbation to Eigenfaces utilizing differential privacy and stores only the perturbed data in the third-party servers to run a standard Eigenface recognition algorithm. As a result, the trained model will not be vulnerable to privacy attacks such as membership inference and model memorization attacks. This model provided by Chami kara shows the potential solution of this issue or privacy leaks.

Federated learning has the ambition to protect data privacy through distributed learning methods that keep the data in its storage. Likewise, differential privacy (DP) attains to improve the protection of data privacy by measuring the privacy loss in the communication among the elements of federated learning. The prospective matching of federated learning and differential privacy to the challenges of data privacy protection has caused the release of several software tools that support their functionalities, but they lack a unified vision of these techniques, and a methodological workflow that supports their usage. In the study sponsored by the Andalusian Research Institute in Data Science and computational Intelligence, they developed a Sherpa.ai FL, 1,2 which is an open-research unified FL and DP framework that aims to foster the research and development of AI services at the edges and to preserve data privacy. The characteristics of FL and DP tested and summarized in the study suggests that they make them good candidates to support AI services at the edges and to preserve data privacy through their finding that by setting the value of I {\displaystyle \epsilon } for lower values would guarantee higher privacy at the cost of lower accuracy.

Since spam phone calls are a growing nuisance in the digital world, researchers have been looking at potential solutions in minimizing this issue. Federal agencies such as the US Federal Trade Commission (FTC) have been working with telephone carriers to design systems for blocking robocalls. Furthermore, a number of commercial and smartphone apps that promise to block spam phone calls have been created, but they come with a subtle cost. The user's privacy information that comes with giving the app the access to block spam calls may be leaked without the user's consent or knowledge of it even occurring. In the study, the researchers analyze the challenges and trade-offs related to using local differential privacy, evaluate the LDP-based system on real-world user-reported call records collected by the FTC, and show that it is possible to learn a phone blacklist using a reasonable overall privacy budget and at the same time preserve users' privacy while maintaining utility for the learned blacklist.

where the probability is taken over the random measure implicit in the algorithm. The main difference between this definition of local differential privacy and the definition of standard (global) differential privacy is that in standard differential privacy the probabilities are of the outputs of an algorithm that takes all users' data and here it is on an algorithm that takes a single user's data. Other formal definitions of local differential privacy concern algorithms that categorize all users' data as input and output a collection of all responses (such as the definition in Raef Bassily, Kobbi Nissim, Uri Stemmer and Abhradeep Guha Thakurta's 2017 paper).

Figure 2: A Federated Learning Method Based on Blockchain and Cluster Training Rust is a general-purpose programming language that emphasizes performance, type safety, concurrency, and memory safety. Rust supports multiple programming paradigms. It was influenced by ideas from functional programming, including immutability, higher-order functions, algebraic data types, and pattern matching. It also supports object-oriented programming via structs, enums, traits, and methods. Rust enforces memory safety (i.e., that all references point to valid memory) without a conventional garbage collector; instead, memory safety errors and data races are prevented by the "borrow checker", which tracks the object lifetime of references at compile time. Software developer Graydon Hoare created Rust in 2006 while working at Mozilla, which officially sponsored the project in 2009. The first stable release, Rust 1.0, was published in May 2015. The project has been sponsored by the Rust Foundation since February 2021. It has been adopted by many software projects, especially web services and system software. It has been studied academically and has a growing community of developers.

In 2006, Rust began as a personal project by Mozilla employee Graydon Hoare. According to MIT Technology Review, he started the project due to his frustration with a broken elevator in his apartment building whose software had crashed, and named the language after the fungi of the same name that is "over-engineered for survival". Between 2006 and 2009, Rust was not publicized to others at Mozilla and was written in Hoare's free time. Hoare began speaking about the language around 2009 after a small group at Mozilla became interested. Early contributors have agreed that the language was based primarily on existing ideas. Hoare cited languages from the 1970s, 1980s, and 1990s as influences — including CLU, BETA, Mesa, NIL, Erlang, Newsqueak, Napier, Hermes, Sather, Alef, and Limbo. He described the language as "technology from the past come to save the future from itself." Early contributor Manish Goregaokar similarly described it as based on "mostly decades-old research." The first compiler was written in about 38,000 lines of OCaml. It supported a number of features no longer present today, including explicit object-oriented programming via an obj keyword and a typestate analysis system tracking variable state such as going from uninitialized to initialized.

The development of the Servo browser engine continued in parallel with Rust, funded by Mozilla and Samsung. New features in Rust were tested out by the Servo team, and new features in Servo were used to give feedback back to the Rust team. The first version of Servo was released in 2016. The Firefox web browser shipped with Rust code as of 2016 (version 45), but components of Servo did not appear in Firefox until September 2017 (version 57) as part of the Gecko and Quantum projects.

In the years following 1.0, improvements were made to the toolchain ecosystem including Rustfmt, integrated development environment (IDE) support, and a regular compiler testing and release cycle. Rust's community gained a code of conduct and an IRC chat for discussion. The earliest known adoption outside of Mozilla was by individual projects at Samsung, Facebook (now Meta Platforms), Dropbox, and Tilde, Inc., the company behind ember.js. Amazon Web Services followed in 2020.

Engineers cited performance, lack of a garbage collector, safety, and developer experience as reasons for the adoption. Amazon developers cited a 2017 research finding that Rust code was more energy efficient compared to similar Java code. Rust's syntax is similar to that of C and C++, although many of its features were influenced by functional programming languages such as OCaml. Hoare has described Rust as targeted at frustrated C++ developers.

Figure 3: Blockchain-based Federated Learning Security Project demonstration ... Variables are immutable by default, unless the mut keyword is added. The following example uses //, which denotes the start of a comment. Multiple let expressions can define multiple variables with the same name, known as variable shadowing. Variable shadowing allows transforming variables without having to name the variables differently. The example below declares a new variable with the same name that is double the original value: Variable shadowing is also possible for values of different types. For example, going from a string to its length: In the above code, 4..=10 is a value of type Range that implements the Iterator trait. The code within the curly braces is applied to each element returned by the iterator. Iterators can combine with functions over iterators like map, filter, and sum.

For example, the following adds up all numbers between 1 and 100 that are multiples of 3: The function print_string takes ownership over the String value passed in; Alternatively, & can be used to indicate a reference type (in &String) and to create a reference (in &s): Because of these ownership rules, Rust types are known as affine types, meaning each value may be used at most once.

This enforces a form of software fault isolation as the owner of a value is solely responsible for its correctness and deallocation. When a value goes out of scope, it is dropped by running its destructor. The destructor may be programmatically defined through implementing the Drop trait. This helps manage resources such as file handles, network sockets, and locks, since when objects are dropped, the resources associated with them are closed or released automatically.

The borrow checker in the Rust compiler then enforces that references are only used in the locations of the source code where the associated lifetime is valid. In the example above, storing a reference to variable x in r is valid, as variable x has a longer lifetime ('a) than variable r ('b). However, when x has a shorter lifetime, the borrow checker would reject the program: 2. System Architecture & Core Working Principles Since the lifetime of the referenced variable ('b) is shorter than the lifetime of the variable holding the reference ('a), the borrow checker errors, preventing x from being used from outside its scope. Lifetimes can be indicated using explicit lifetime parameters on function arguments. For example, the following code specifies that the reference returned by the function has the same lifetime as original (and not necessarily the same lifetime as prefix): In the compiler, ownership and lifetimes work together to prevent memory safety issues such as dangling pointers.

The Rust standard library defines and implements many widely used custom data types, including core data structures such as Vec, Option, and HashMap, as well as smart pointer types. Rust provides a way to exclude most of the standard library using the attribute #![no_std], for applications such as embedded devices. Internally, the standard library is divided into three parts, core, alloc, and std, where std and alloc are excluded by #![no_std]. Rust uses the option type Option to define optional values, which can be matched using if let or match to access the inner value: Similarly, Rust's result type Result holds either a successfully computed value (the Ok variant) or an error (the Err variant). Like Option, the use of Result means that the inner value cannot be used directly; programmers must use a match expression, syntactic sugar such as ? (the "try" operator), or an explicit unwrap assertion to access it. Both Option and Result are used throughout the standard library and are a fundamental part of Rust's explicit approach to handling errors and missing data.

The example above includes a method is_zero that provides a default implementation that may be overridden when implementing the trait. In the examples above, Num: Zero as well as where Self: PartialEq are trait bounds that constrain the type to only allow types that implement Zero or PartialEq. Within a trait or impl, Self refers to the type that the code is implementing. Generics can be used in functions to allow implementing a behavior for different types without repeating the same code (see bounded parametric polymorphism). Generic functions can be written in relation to other generics, without knowing the actual type.

If an element in the list does not implement the Display trait, it will cause a compile-time error. In this example, the macro named sum is defined using the form macro_rules! sum { (...) => { ... } }. The first part inside the parentheses of the definition, the macro pattern ( $initial:expr $(, $expr:expr )* $(,)? ) specifies the structure of input it can take. Here, $initial:expr represents the first expression, while $(, $expr:expr )* means there can be zero or more additional comma-separated expressions after it. The trailing $(,)? allows the caller to optionally include a final comma without causing an error. The second part, after the arrow =>, describes what code will be generated when the macro is invoked. In this case, $initial $(+ $expr)* means that the generated code will start with the first expression, followed by a + and each of the additional expressions in sequence. The * again means "repeat this pattern zero or more times". This means, when the macro is later called in line 8, as sum!(1, 2, 3), the macro will resolve to 1 + 2 + 3 representing the addition of all of the passed expressions.

Function-like macros custom!(...) Derive macros #[derive(CustomDerive)] Attribute macros #[custom_attribute] The #[repr(C)] attribute enables deterministic memory layouts for structs and enums for use across FFI boundaries. External libraries such as bindgen and cxx can generate Rust bindings for C/C++. The Rust ecosystem includes its compiler, standard library, and other software development toolchain components.

Component installation is typically managed by rustup, a Rust toolchain installer. Cargo is Rust's build system and package manager. It downloads, compiles, distributes, and uploads packages—called crates—that are maintained in an official registry. It also acts as a front-end for Clippy and other Rust components. By default, Cargo sources its dependencies from the user-contributed registry crates.io. Git repositories, folders on the local filesystem, and other external sources can also be specified as dependencies. Cargo supports reproducible builds through two metadata files: Cargo.toml and Cargo.lock. Cargo.toml declares each package used and its version requirements. Cargo.lock is generated automatically during dependency resolution and records exact versions of all dependencies, including transitive dependencies.

Clippy is Rust's built-in linting tool to improve the correctness, performance, and readability of Rust code. As of 2026, it has over 800 rules. In web services, OpenDNS, a DNS resolution service owned by Cisco, uses Rust internally. Amazon Web Services uses Rust in "performance-sensitive components" of services. In 2019, AWS converted Firecracker, a virtualization solution primarily written in Rust, to open source. Microsoft Azure IoT Edge, a platform used to run Azure services on IoT devices, has components implemented in Rust. Microsoft also uses Rust to run containerized modules with WebAssembly and Kubernetes.

Cloudflare, a company providing content delivery network services, used Rust to build a new web proxy named Pingora for increased performance and efficiency. The npm package manager used Rust for its production authentication service in 2019. In operating systems, the Linux kernel began introducing experimental support for Rust code in Version 6.1 in late 2022, as part of the Rust for Linux project. The first drivers written in Rust were included in version 6.8. In 2025, kernel developers at the Linux Kernel Developers Summit determined that the project was a success, and Rust for kernel code will no longer be considered experimental. The Android developers used Rust in 2021 to rewrite existing components. Microsoft has rewritten parts of Windows in Rust. The r9 project aims to re-implement Plan 9 from Bell Labs in Rust. Rust has also been used in the development of new operating systems such as Redox, a "Unix-like" operating system and microkernel, Theseus, an experimental operating system with modular state management, and most of Fuchsia. Rust is used for command-line tools and operating system components such as stratisd, a file system manager and COSMIC, a desktop environment by System76. In web development, Deno, a secure runtime for JavaScript and TypeScript, is built on top of V8 using Rust and Tokio. Other notable adoptions in this space include Ruffle, an open-source SWF emulator, and Polkadot, an open source blockchain and cryptocurrency platform. Components from the Servo browser engine (funded by Mozilla and Samsung) were incorporated in the Gecko browser engine underlying Firefox. In January 2023, Google (Alphabet) announced support for using third party Rust libraries in Chromium. In other uses, Discord, an instant messaging software company, rewrote parts of its system in Rust for increased performance in 2020. In the same year, Dropbox announced that its file synchronization had been rewritten in Rust. Facebook (Meta) used Rust to redesign its system that manages source code for internal projects. In the 2025 Stack Overflow Developer Survey, 14.8% of respondents had recently done extensive development in Rust. The survey named Rust the "most admired programming language" annually from 2016 to 2025 (inclusive), as measured by the number of existing developers interested in continuing to work in the language. In 2025, 29.2% of developers not currently working in Rust expressed an interest in doing so. In the TIOBE programming community index, which measures search-engine-derived interest in programming languages, Rust ranked in the top 10 for the first time in July 2026, with a rating of 1.34%.

According to the MIT Technology Review, the Rust community has been seen as "unusually friendly" to newcomers and particularly attracted people from the queer community, partly due to its code of conduct. Inclusiveness has been cited as an important factor for some developers. The official blog collects and publishes demographic data each year. The Rust Foundation is a non-profit membership organization incorporated in United States as a 501(c)(6) organization; it manages the Rust trademark, infrastructure, and assets. It was established on February 8, 2021. The foundation's board was chaired by Shane Miller, with Ashley Williams as interim executive director. In late 2021, Rebecca Rumbul became executive director and CEO. The foundation's website lists ARM, Amazon, Google, Huawei, Meta, Microsoft, and OpenAI as platinum members. OpenAI is the latest platinum member, having joined in June 2026.

Federated learning (FL) is a distributed machine learning approach that protects user data privacy by training models locally on clients and aggregating them on a parameter server. While effective at preserving privacy, FL systems face limitations such as single points of failure, lack of incentives, and inadequate security. To address these challenges, blockchain technology is integrated into FL systems to provide stronger security, fairness, and scalability. However, blockchain-empowered FL (BC-FL) systems introduce additional demands on network, computing, and storage resources.

This survey provides a comprehensive review of recent research on BC-FL systems, analyzing the benefits and challenges associated with blockchain integration. We explore why blockchain is applicable to FL, how it can be implemented, and the challenges and existing solutions for its integration. Additionally, we offer insights on future research directions for the BC-FL system.

K eywords Blockchain-empowered federated learning ⋅ \cdot distributed artificial intelligence ⋅ \cdot security and privacy 3. Software Implementation, Frameworks & Protocols Artificial Intelligence (AI) technologies drive the Fourth Industrial Revolution, with user data being essential for training diverse Machine Learning (ML) models [ 1 ] . Training high-quality ML models often involves a centralized approach, necessitating internal storage of user data. This raises privacy concerns [ 2 , 3 , 4 ] and highlights the need for stringent privacy protections [ 5 ] . In recent years, regions such as the European Union [ 6 , 7 ] , the United States [ 8 ] , and Singapore [ 5 ] have enacted relevant laws and regulations to govern the use of personal data, enhancing privacy protection but potentially hindering the utilization of high-quality data.

Federated Learning (FL) is a privacy-preserving distributed machine learning paradigm that balances user data protection and effective utilization [ 9 , 10 , 11 ] . FL involves training local models on user devices and aggregating these local models into a global model on a server without requiring users to upload their data, addressing the aforementioned privacy concerns. Initially applied to training Gboard [ 12 ] , FL has proven successful. Its potential extends beyond this, as it can also address the issue of data silos. Data silos refer to the isolated or dispersed nature of data, making access to this data extremely challenging [ 13 ] . One cause of data silos is the reluctance of organizations to share data due to privacy or competitive concerns. For instance, due to privacy protection, hospitals may be unwilling to share patient data [ 14 ] . In summary, the judicious use of FL can break down data barriers, leading to its widespread application in healthcare [ 15 , 16 ] , finance [ 17 , 18 ] , industry [ 19 , 20 ] and so on.

While privacy protection and data utilization benefits have popularized FL across industry and academia, they also introduce specific challenges. First, there is a lack of trust among nodes within the FL system [ 21 , 22 ] . Nodes may worry that their training contributions will be intentionally tampered with or miscalculated, damaging their reputation and deserved rewards. Second, FL systems are vulnerable to attacks from malicious nodes [ 23 , 24 ] . Malicious users may intentionally provide incorrect information to prevent model convergence and disrupt model training, while malicious servers can recover users’ training data from the uploaded models. Third, FL is prone to single point of failure issues [ 25 ] . In traditional FL architectures, the central server is responsible for aggregating and updating global model parameters. If the central server is attacked or fails, the entire system’s operation is severely affected, leading to interruptions in the training process, data loss, and irrecoverable model states.

Blockchain is essentially a distributed ledger, and its successful application in cryptocurrencies demonstrates its potential to build trust, security, and transparency [ 26 , 27 , 28 ] . Consequently, numerous studies have integrated blockchain with FL systems to enhance functionality, creating blockchain-empowered FL (BC-FL) systems. Analyzing existing BC-FL literature, we find that blockchain’s enhancement of different aspects of FL originates from its distinct properties. First, blockchain’s transparency and immutability can alleviate the lack of trust among nodes within the FL system. By recording data requiring consensus in the FL system on the blockchain, these data cannot be tampered with by malicious nodes, enhancing trust relationships. Second, through cross-validation of blockchain nodes and other mechanisms, the resistance of the FL system to malicious nodes is improved. Finally, blockchain can replace the centralized server to avoid single point of failure issues. By designing a reasonable consensus mechanism, suitable clients can be selected to undertake model aggregation tasks in each communication round. With the advent of blockchain 2.0, users can develop smart contracts running on the blockchain, endowing BC-FL with greater scalability for automatically running various algorithms [ 29 ] .

The introduction of blockchain has further driven the development of FL, but blockchain is not a panacea for FL. Our research indicates that blockchain integration poses challenges related to runtime efficiency and storage capacity. First, the consensus mechanism of blockchain adds communication and computation overhead to the BC-FL system. Second, due to the distributed storage nature of blockchain, full nodes need to back up the entire blockchain data. Additionally, the introduction of blockchain can also bring additional security issues, such as Sybil attacks [ 30 ] .

Currently, several surveys on BC-FL systems have been published. Some focus on the integration of BC-FL with other fields, such as the Internet of Things, drones, and healthcare. These studies emphasize the specific applications of BC-FL systems rather than their commonalities. Other surveys investigate BC-FL systems in general. Qu et al. conducted a detailed study on the performance of decentralization, attack resistance, and incentive mechanisms in BC-FL systems, and surveyed the system architecture forms of BC-FL. However, they did not investigate transparent reputation mechanisms in BC-FL and thoroughly analyze why blockchain can enhance FL systems, merely classifying the functions of BC-FL. Zhu et al. divided BC-FL system models into three categories and surveyed real-world applications of BC-FL. However, they lacked a comprehensive investigation of single point of failure, reputation mechanisms, security, and privacy issues. Additionally, the aforementioned surveys neglected to conduct a detailed investigation into the negative effects blockchain can bring to BC-FL systems. Sameera et al. summarized the general architecture of BC-FL and detailed how BC-FL addresses security and privacy threats. However, they lacked in-depth research on BC-FL’s reputation mechanisms, incentive mechanisms, and system efficiency and storage issues. We believe that the various enhancements and potential challenges blockchain brings to FL systems stem from certain properties or functionalities of blockchain. Meanwhile, some properties of blockchain can play different roles in FL systems depending on their application. The contributions of this work are as follows: Starting from the characteristics and functionalities of blockchain, we introduce how blockchain enhances FL systems in terms of decentralization, reputation mechanisms, incentive mechanisms, and security.

We comprehensively investigate the additional challenges that arise from using blockchain in FL systems, the reasons behind these challenges, and existing solutions. We summarize future research directions for blockchain-based FL systems based on existing research. Investigating how blockchain enhances FL systems from the perspective of blockchain’s characteristics is an unaddressed area in existing surveys. This survey can complement similar recent surveys, filling a gap in the research on BC-FL. This survey.’s main scope is illustrated in Fig. 1 . Section 2 provides relevant background knowledge on FL, blockchain. Section 3 details general BC-FL architecture and how blockchain enhances FL systems. Section 4 elaborates on the challenges of using blockchain in FL systems and existing solutions. Section 5 we point out future research directions for BC-FL systems.

Section 6 concludes the paper. FL is a privacy-preserving distributed machine learning paradigm proposed by Google [ 9 ] . This paradigm involves a network of multiple participants (clients) alongside a central server. The clients are tasked with developing local models, which are then consolidated by the server into a unified, global model [ 31 , 32 , 33 ] . This structure allows participants considerable autonomy, enabling them to contribute to the FL framework without disclosing their data to any FL node. Participation in FL training remains at the discretion of the users. Fig. 3 visually represents the standard FL training methodology. The task initiator selects an FL server to publish the training task. Subsequently, clients related to the training task join the FL training, and the server initializes the global model. In each communication round, the server selects clients to participate in that round of training and distributes the global model to these clients. The clients then use their local datasets to train the global model, resulting in local models, which they send back to the server. The server aggregates these local models into a new global model according to certain rules. The FL process stops when the training termination condition is met; otherwise, training continues.

FL generally has two classification methods, as depicted in Fig. 2 . Based on the sample ID and feature distribution of local datasets, FL systems can be divided into Horizontal FL (HFL), Vertical FL (VFL), and Federated Transfer Learning (FTL). In HFL, users have different sample IDs but identical data features. In VFL, users have identical sample IDs but different data features. In FTL, both the sample IDs and data features differ. Generally, current research on BC-FL is predominantly based on HFL, with only a few studies on VFL [ 34 , 35 ] and FTL [ 36 ] . Despite the datasets’ different characteristics, blockchain’s role does not fundamentally differ.

Moreover, based on the different types of user devices involved in training, FL can be divided into cross-device FL and cross-silo FL. Cross-device FL involves an extensive array of mobile and IoT devices, potentially numbering up to 10 10 10^{10} , often with poor device performance and network conditions [ 37 , 38 ] . In cross-silo FL systems, the participating clients are typically professional computing nodes maintained by specialized institutions, and the number of clients is generally fewer than 100 [ 39 , 40 ] .

Blockchain is a distributed ledger system designed to securely, transparently, and immutably record data in a decentralized manner [ 41 , 42 ] . It is resilient to the presence of some malicious nodes and is resistant to control by any single entity [ 43 , 44 ] . A blockchain is essentially composed of interconnected blocks arranged sequentially in a chronological chain. This structure is illustrated in the Fig. 4 . Each block includes a header and a body. The block header typically contains metadata such as the block number, timestamp, and the hash of the previous blocks. The specific parameters stored in the header can vary depending on the blockchain system. The block body stores specific information, like transactions.

Blockchain can be classified into two main types based on node participation restrictions: permissionless blockchain and permissioned blockchain. The permissionless blockchain allows unrestricted node participation in the system’s operations, exemplified by Bitcoin and Ethereum. These blockchains operate without the need for approvals or authorizations from central authorities. In contrast, the permissioned blockchain is managed by a specific organization, and only authorized nodes can access the system. It is suitable for data privacy and security applications, such as financial and government information management.

The autonomous operation of blockchains in the absence of central oversight relies on consensus mechanisms. These algorithms define the state of the blockchain and are vital for its functionality. Broadly, consensus mechanisms are categorized into proof-based and committee-based systems [ 26 ] . Proof-based systems prioritize nodes based on specific resource possession; for instance, Proof of Work (PoW) and Proof of Stake (PoS) are notable examples [ 45 ] . In PoW, nodes compete to solve complex puzzles, with computational prowess conferring a higher accounting priority. PoS, on the other hand, employs an encrypted random selection algorithm to appoint a leader for block creation, with a node’s selection likelihood tied to its token holdings. Proof-based consensus mechanisms are predominantly utilized in permissionless blockchains due to their robust defence against malicious nodes. Conversely, committee-based mechanisms utilize a voting process where consensus on a new block’s addition is reached through a predetermined number of affirmative votes.

Protocols such as Raft [ 46 ] and PBFT [ 47 ] exemplify committee-based mechanisms. Committee-based mechanisms generally offer higher throughput than proof-based mechanisms and are often used in permissioned blockchains. However, they can be communication-intensive, posing challenges in large-scale networks. This section introduces how blockchain technology enhances the FL system. These enhancements can be categorized into four aspects: decentralization, reputation evaluation mechanism, incentive evaluation mechanism, and security. Each of these four aspects will be discussed separately.

FL traditionally relies on a central parameter server, where clients must continuously communicate with a single FL server. This centralized structure poses significant risks, such as single points of failure and potential malicious server behaviour. Furthermore, node reputation information is solely managed by the server, which is not ideal for developing an open FL ecosystem. Blockchain’s decentralization is a core feature that fundamentally addresses these issues and provides a new architectural approach to FL systems. Decentralization can enhance the security, transparency, and reliability of FL systems, with these benefits manifesting in various facets of blockchain’s advantages for FL.

Our review of existing literature identifies several factors influencing the decentralization of BC-FL, including system architecture, consensus mechanisms, and smart contracts. The system architecture determines which nodes maintain the blockchain, while the consensus mechanism dictates which nodes have the right to manage the system. Smart contracts can automate various algorithms within the BC-FL system, offering greater scalability. Table 1 compiles representative BC-FL systems, detailing their use of smart contracts, architecture, consensus mechanisms, and experimental platforms.

4. Practical Deployment, Analysis & Case Studies Architecture. BC-FL systems can be categorized by their degree of decentralization: complete and partial. In the completely decentralized BC-FL, all nodes are eligible to participate in the consensus process of the blockchain. Fig. 5(a) shows its general system architecture. This approach demands high computational and storage capacities from all nodes. Conversely, partially decentralized BC-FL involves only a subset of nodes running the blockchain, while others focus solely on FL training.

Fig. 5(b) shows its general system architecture. The selected nodes that operate the blockchain system are known as super nodes and typically have stronger computing power and better communication conditions. This approach sacrifices some transparency for increased efficiency. Consensus Mechanism. A considerable portion of the work adopts common blockchain consensus mechanisms such as PoW and PBFT. PoW involves blockchain nodes competing to solve a mathematical problem, with the first solver aggregating models and training information into a new block. Other nodes then verify the block’s correctness, and upon majority approval, it is added to the blockchain. In PBFT, a set of consensus nodes is chosen within the BC-FL system, from which a leader node aggregates the model and generates a new block. Other nodes in the set verify the leader’s block. Some work has specifically developed consensus mechanisms for BC-FL, such as Proof of Reputation [ 55 ] . These custom consensus mechanisms are usually designed to enhance FL functionality or mitigate the disadvantages of blockchain, which will be elaborated on in the subsequent sections.

Smart Contracts. Smart contracts significantly enhance the scalability of BC-FL systems. For instance, model aggregation can be executed via smart contracts, increasing transparency. Additionally, smart contracts can deploy algorithms for detecting and handling malicious nodes, thereby improving system efficiency. They can also manage node reputation evaluations and incentive algorithms, further enhancing system transparency.

Next, we will examine some representative architectures of completely decentralized BC-FL systems. In [ 63 ] , Xu et al. proposed a BC-FL framework named Blockchain Empowered Secure and Incentive Federated Learning (BESIFL). BESIFL enables any node in the network to initiate FL training requirements. Upon receipt of a requirement, BESIFL selects computing nodes with high computation reputation scores to form a computing pool and assigns them the task of model training. Meanwhile, BESIFL chooses verification nodes with high verification reputation scores to form a verification pool and assigns them the task of model aggregation and verification using pre-defined procedures specified by the smart contract. Li et al. also proposed a completely decentralized BF-FL system, where each client acts as both a FL trainer and a blockchain miner [ 72 ] . After training their local models, clients initiate blockchain transaction requests and broadcast their models by attaching them to the transaction information. Each client aggregates the global model locally after receiving local models from all other clients and starts mining. The winning miner broadcasts a block containing global model information, which is verified by other clients and then written into the blockchain. However, this system assumes that all clients possess equal computational power, which may not be realistic in practice. In addition to the two aforementioned decentralized methods, Qu et al. designed a novel approach that utilizes a rotation mechanism with randomness to select committee members for participating in blockchain consensus [ 73 ] . This proposed blockchain consensus mechanism greatly reduces additional consumption generated by the blockchain consensus process compared to the PoW mechanism. Committee members are only responsible for aggregating and validating the global model and do not participate in training. The global model is generated by committee members and stored in the blockchain after verification. While the rotation mechanism ensures the mobility of committee members, it can ensure some level of system security. However, this consensus mechanism is only applicable in situations where the number of malicious nodes is small.

The BC-FL systems described below follow the partial decentralization architecture. Feng et al. proposed a BC-FL system for UAVs that maintains the blockchain system only in entities with high computing and storage capabilities, such as base stations and roadside nodes [ 50 ] . This approach enables transparent and automated model aggregation operations through the use of smart contracts, which replace the traditional parameter server. To address the challenge of online and offline state changes among BC-FL participants, the authors set the maximum waiting time and the required number of local models for each learning round. If any of these conditions are met, the model update contract is triggered, ensuring timely updates while accommodating BC-FL participant availability. In [ 53 ] , Liu et al. proposed a framework for training vehicle intrusion model.

The blockchain is maintained by roadside units and stores and shares the global models for the BC-FL system. After receiving the global model, the vehicle uses the data collected by itself to train the model and upload it to the connected roadside unit nodes. The consensus mechanism in place combines PoW and PoA, with the roadside node that has achieved the highest accuracy being written into the block to encourage the training of high-precision models.

Workflow of BC-FL Systems. The overall workflow of the BC-FL system is illustrated in Fig. 6 . Different BC-FL systems may be adjusted according to specific circumstances. The steps are explained as follows: Step 1. Initialization: Each client initializes the environment based on prior negotiation, including model parameter, and training parameter. The blockchain can assist clients in negotiation by storing initialization parameters on the chain and using smart contracts.

Step 2: Local model training. Each client trains the global model using their local dataset. Step 3: Local model upload. Clients upload training-related data and local models to the blockchain system. To alleviate storage pressure on the blockchain, clients may upload only model-related information rather than the entire model, as detailed in Section 4.3 .

Step 4: Transaction broadcast. Upon receiving the transaction, blockchain nodes broadcast it within the system for cross-validation. The nodes inspect the transaction content (e.g., model) based on pre-defined rules. If no issues are found, the transaction is added to the local transaction pool. Step 5: Block generation. Blockchain nodes select the node with the right to generate blocks for the current round based on the consensus protocol. This node aggregates the local models to generate the global model, compiles relevant model and training information, and creates a block.

Step 6: Block Broadcast. The blockchain system broadcasts the newly generated block. Upon receiving it, validation nodes verify the block according to specific rules. If the majority of nodes validate the block, it is added to their locally maintained blockchain, achieving consensus across the network. Step 7: Global Model Download. Clients download the latest global model from the blockchain system.

Step 8: End condition judgment. Based on pre-negotiated rules, the FL process evaluates whether it has reached the end condition. If not, the process returns to Step 2 to continue training. FL is a collaborative approach to training a shared model that requires the participation of multiple clients with local data. However, clients may have varying motivations and behaviors, such as seeking rewards for their assistance, hoping to obtain a trained model, or attempting to benefit from the global model without contributing to the training process. In some cases, clients may even have malicious intentions, seeking to undermine the effectiveness of FL due to conflicts of interest in reality or other factors. Compared to traditional distributed learning methods, FL prioritizes user data privacy, which means that the parameter server has limited access to information about the local environment of each client. Therefore, it is essential for the FL task publisher to implement a reputation management mechanism that can assist in managing, rewarding, or punishing FL clients based on their contributions and behavior.

Several studies have proposed the use of some reputation management mechanisms in a centralized way on the parameter server [ 74 , 51 ] . While this approach can serve as a foundation for client management, reward and punishment schemes, its lack of transparency remains a concern. Data owners who contribute to the training process may worry about potential inaccuracies in the parameter server’s reputation calculations, while those seeking to obtain a trained model may be concerned that the parameter server could intentionally manipulate reputations to undermine FL models. Given the importance of attracting high-quality data owners to ensure optimal FL model performance, the transparent reputation management mechanism is particularly well-suited for FL systems. Additionally, a trustworthy parameter server aims to calculate reputation in a transparent manner to discourage malicious nodes. To address these concerns, the BC-FL system leverages blockchain technology to ensure the transparency and credibility of the reputation management mechanism.

After conducting our analysis, we have identified two crucial functions that blockchain can perform within the reputation management mechanism. The blockchain acts as a reliable third-party ledger in the BC-FL system to document crucial information regarding each node’s reputation, including but not limited to its reputation value [ 51 , 75 , 76 ] and various calculation bases [ 77 , 53 , 57 ] .

5. Performance Evaluation & Extended Technical Observations In the BC-FL system, the reputation computation process can be deployed on the blockchain through a specialized reputation calculation smart contract [ 77 , 78 , 57 ] . This approach serves to ensure both transparency and automation throughout the entire computation process, thereby guaranteeing dependable and consistent outcomes.

The reputation management mechanism based on blockchain in BC-FL is illustrated in Fig. 7 . Our study of recent research papers on client reputation calculation methods has revealed that the multiweight subjective logic calculation method is a popular choice for enhancing the trustworthiness and reliability of BC-FL systems. To elucidate the operation of the reputation management mechanism in BC-FL systems, we will present a concise overview of the multi-weight subjective logic calculation method.

This method aims to assess the reputation value of a client by considering three crucial attributes: positive evaluation, negative evaluation, and uncertain evaluation. For example, in [ 75 , 79 , 77 ] , Kang et al. demonstrated how multi-weight subjective logic can be used to accurately calculate reputation values. In their proposed BC-FL systems, the task publisher, denoted as T I P i TP_{i} , calculates the reputation of each client through two main components. The first part involves direct reputation calculation, where T I P i TP_{i} evaluates BC-FL clients based on three attributes: belief, disbelief, and uncertainty, corresponding to positive evaluation, negative evaluation, and uncertain evaluation, respectively. To facilitate comprehension, we simplify the formula as follows: where b i → j d I i I r b^{dir}_{i\rightarrow j} , d i → j d I i I r d^{dir}_{i\rightarrow j} , and u i → j d I i I r u^{dir}_{i\rightarrow j} need to satisfy the restrictions: The variables a i a_{i} and b i b_{i} represent the positive and negative evaluations of client C j C_{j} by T I P i TP_{i} respectively. Variables b i → j d I i I r b^{dir}_{i\rightarrow j} , d i → j d I i I r d^{dir}_{i\rightarrow j} , and u i → j d I i I r u^{dir}_{i\rightarrow j} correspond to the previously mentioned belief, disbelief, and uncertainty. Variable q i → j q_{i\rightarrow j} denotes the probability of successful delivery of data packets sent by C j C_{j} to T I P i TP_{i} . The direct reputation D I I I R i → j DIR_{i\rightarrow j} is then expressed as: The second part involves the evaluation of the client’s reputations by other task publishers T I P k TP_{k} . First, T I P k TP_{k} sends its reputation opinion vector to T I P x TP_{x} , which then calculates the credibility of T I P k TP_{k} ’s reputation opinion through an amendatory cosine function. Then, form the weight of publisher k k by calculated credibility. All task publishers’ reputation opinions are combined in a weighted manner to form an indirect reputation.

Combining direct and indirect reputations results in the final value of belief b i → j f I i I n I a I l b^{final}_{i\rightarrow j} , disbelief d i → j f I i I n I a I l d^{final}_{i\rightarrow j} and uncertainty u i → j f I i I n I a I l u^{final}_{i\rightarrow j} of the C j C_{j} , as defined as: where b r I e I c b^{rec} , d r I e I c d^{rec} , and u r I e I c u^{rec} are the belief, disbelief and uncertainty of the indirect reputation mentioned above. Then, we compute the final reputation R I E I P i → j REP_{i\rightarrow j} of C j C_{j} in: Various papers adopt distinct approaches in calculating the reputation of BC-FL clients. Some calculate reputation values solely on the basis of local model test accuracy, while others take into account evaluations from other clients or factor in the interaction effect between clients and the blockchain system. Moreover, researchers have leveraged clients’ reputations in various ways. For instance, some deploy reputation as a criterion for selecting participating clients, whereas others utilize it to ascertain the weight assigned to global model aggregation. Additionally, there are those who offer incentives and penalties to clients based on their respective reputations.

We present a comprehensive analysis of BC-FL systems that utilize blockchain technology to establish transparent reputation management mechanisms. Table 2 summarizes the key attributes of these systems. The attributes “Aggregation”, “Other Workers”, and “Blockchain” represent the basis for evaluating the reputation of clients. A checkmark in the corresponding box signifies that the BC-FL system takes the attribute into consideration when calculating the client’s reputation. “aggregation” represents the contribution of a client’s local model towards the global model during aggregation, including evaluating the accuracy of the local model. “other workers” relates to the interaction between clients, specifically through peer evaluation among training clients. “Blockchain” encompasses the effect of a client’s participation in blockchain maintenance activities, such as successful block generation. The attributes “Usage 1” and “Usage 2” illustrate two potential roles that blockchain may play in the node reputation mechanism, as previously mentioned. “Usage 1” describes blockchain’s involvement in the BC-FL system’s reputation management mechanism as a transparent and open ledger.

“Usage 2” involves the use of smart contracts to automatically and transparently calculate a client’s reputation. In addition, we examine how reputation is utilized in BC-FL systems by exploring the attributes of “Model aggregation”, “Node Selection”, and “Reward or Punishment“. “Model aggregation” involves weighting a local model based on the client’s reputation value when aggregating the global model. “Node selection” indicates that the FL client selection process in each round will consider its reputation value. “Reward or punishment” signifies the use of reputation value as the basis for rewarding or punishing the client.

In addition to the reputation calculation methods discussed earlier, several other approaches have been proposed in the literature. In [ 57 ] , Qi et al. proposed a novel reputation evaluation mechanism for multi-model aggregators in FL. Each model aggregator has its test dataset, and the reputation of each participating client is calculated separately by each aggregator. The winning aggregator is selected based on a set of rules, and the winning aggregator updates the client’s reputation value to the blockchain. The model aggregators calculate the client’s reputation in two steps. In the first step, each model aggregator uses a fair-value game [ 86 ] to test the quality of the local model with its test dataset. When the result of a formula containing model test accuracy reaches a certain threshold, the corresponding reputation update is activated. In the second step, the model aggregator synthesizes the results given by other aggregators on the network to obtain the indirect reputation value of the node. Finally, the reputation evaluation value of the modified model aggregator for the node in this round is obtained from the results of the first and second steps. This approach ensures fairness in reputation evaluation across different aggregators and improves the accuracy of the final reputation value.

In [ 81 ] , Gao et al. designed a time-decaying subjective logic model (SLM) algorithm to measure the client’s reputation and a lightweight approach based on gradient similarity to measure client contribution. The final task publisher determines the client’s reward share by multiplying the contribution and reputation metrics. They used reputation metrics to measure client reliability and select clients with high reputations to ensure high system stability, which enables their proposed system to work stably in unreliable environments.

In FL systems, clients not only need to contribute local data but also consume significant amounts of computing resources and network bandwidth [ 87 , 88 ] . Without tangible incentives, it may be difficult to attract enough clients to participate in the FL systems. Therefore, introducing an incentive mechanism in FL systems is critical. The introduction of incentives can help incentivize clients to join the FL systems and contribute their valuable data. Adequate participation is crucial for FL to train accurate models with good generalization. Additionally, incorporating incentives can increase clients’ engagement and motivation, leading to contributing better data and participation in more training epochs [ 89 ] . Furthermore, the incentive mechanism can help achieve fairness in FL systems by rewarding clients based on their data quality and computing power.

A transparent and open incentive mechanism is crucial for attracting clients to participate in federated learning. As it involves vital interests, each client hopes to supervise the calculation of rewards. The BC-FL system utilizes the blockchain to provide a transparent and open incentive mechanism. The blockchain is a decentralized ledger that is maintained on each participating node, requiring the joint efforts of blockchain nodes instead of a centralized organization. This architecture ensures transparency and openness and facilitates tracking and auditing of data necessary for calculating incentives, thereby establishing clients’ trust in the incentive results. Furthermore, the incentive algorithm can be written as a smart contract and deployed on the blockchain for automatic incentive calculation and distribution, further strengthening clients’ trust in the incentive results. The transparent and open incentive mechanism provided by the blockchain can help to attract more clients to participate in the FL process, contributing high-quality data and computing resources. Consequently, it promotes the accuracy and generalization of the trained model and enhances the efficiency of the BC-FL system.

We focus on BC-FL systems that provide transparent and open incentive mechanisms based on the blockchain. We believe that understanding this incentive mechanism requires consideration of three aspects: incentive basis, incentives, and incentive algorithms. The settings of these aspects should be tailored to the specific FL tasks. Table 3 outlines several prominent BC-FL systems developed in recent years.

The incentive basis refers to the criteria that the system uses to reward clients, which may include factors such as node reputation, data quality and quantity, and learning behavior. For instance, Qu et al. rewarded the clients based on the amount of data they contributed [ 93 ] , but this approach may not accurately reflect the overall contribution of a client to the global model. Factors such as data quality and participation frequency can also significantly impact the effectiveness of the training process. In contrast, Li et al. focused solely on model accuracy as the basis for awarding nodes, as it is verifiable and reflects their contribution [ 91 ] . Meanwhile, Gao et al. argued that rewards should be based on both model accuracy and node reputation, as this incentivizes continued contributions to the global model [ 81 ] . In addition, to compensate the data owner, Zhang et al. considered the energy consumption of the data owner during training and incorporated this factor into the calculation of rewards [ 98 ] .

Incentives refer to the rewards that clients receive in a system, and they can take various forms such as economic items, tokens, and reputation. Economic items provide monetary benefits to data owners, such as cryptocurrencies like Bitcoin or Ethereum. Tokens, on the other hand, are generated by the BC-FL system and can be used to purchase services within the system, including trained models or tasks for model training. The circulation of tokens promotes a self-sustaining ecosystem within the system that encourages participants to contribute and collaborate. In [ 90 , 81 , 96 ] , researchers have utilized tokens within their proposed BC-FL systems as rewards Liu et al. used Ethereum as a reward for training, providing real-world economic incentives [ 11 ] . In addition to cryptocurrency rewards, Abdel et al. proposed a BC-FL system for the Industrial Internet of Things that offers clients maintenance services or discounts on products from manufacturers as incentives [ 48 ] .

The incentive algorithm determines the specific implementation method of the incentive mechanism. Generally, the algorithm involves quantifying each incentive basis and inputting it as a variable into the reward function, which yields the corresponding reward value. For instance, xu et al. devised a rewarding formula that takes model accuracy and training time into account [ 62 ] . The reward c I s i cs_{i} of the i i -th client in the proposed solution is calculated as: Harvested Online Documentation & Reference Sources • https://en.wikipedia.org/wiki/Quick%20Share • https://en.wikipedia.org/wiki/Local%20differential%20privacy • https://en.wikipedia.org/wiki/Rust%20%28programming%20language%29 • https://arxiv.org/html/2403.00873v2