arXiv CSopen access

SCOPE-FL: A Strategy-proof Chain-based Optimal pareto efficient Federated Learning System

1

SCOPE-FL: A Strategy-proof Chain-based Optimal pareto efficient Federated Learning System

arXiv:2606.18384v1 [cs.LG] 16 Jun 2026

Seyed Salar Ghazi, Student Member, IEEE, Kaiwen Zhang, Member, IEEE, Mehdi Feizi, and Hans-Arno Jacobsen, Fellow, IEEE

Abstract—Hierarchical Federated Learning (HFL) enables scalable collaborative model training across distributed devices while preserving data privacy. However, existing HFL client selection mechanisms suffer from a fundamental strategic inefficiency. By prioritizing stability over Pareto efficiency (PE), they produce suboptimal resource allocations, and without strategy proofness (SP), participants are incentivized to misrepresent their true preferences, both failures degrading system overall welfare in the Pareto sense in practice. To address it, we propose SCOPE-FL (Strategy-proof Chain-based Optimal pareto efficient Federated Learning), a synchronous HFL framework that formulates client selection as a two-sided school choice problem solved through the Top Trading Cycle (TTC) algorithm that simultaneously guarantees PE and SP. For reward distribution, SCOPE-FL employs a scalable Shapley value approximation based on OneRound Reconstruction (OR), ensuring compensation proportional to each client’s contribution. The entire mechanism executes via blockchain smart contracts, providing the tamper-proof environment required for the SP guarantees to hold in practice. A comprehensive evaluation on MNIST, Fashion-MNIST, and CIFAR-10 demonstrates that SCOPE-FL outperforms state-ofthe-art approaches, including DA, IAS, and other methods across model accuracy, convergence rate, and reward efficiency, while achieving communication latency comparable to DA and blockchain overhead significantly lower than DA at scale. Index Terms—Hierarchical Federated Learning, Multi-Server FL, Blockchain, Mechanism Design, Client Selection, School Choice, Top Trading Cycle

I. I NTRODUCTION OLLABORATIVE machine learning across distributed devices raises fundamental challenges in communication efficiency, data privacy, and strategic inefficiency in client selection, where participants misrepresent their true preferences and existing mechanisms fail to ensure Pareto efficiency over reported preferences, failing to optimize client’s welfare. Federated Learning (FL) addresses the first two concerns by enabling machine learning models to be trained collaboratively across many devices without requiring raw data to be shared. In each training round, selected clients receive the current global model, train it locally on their own data, and return model updates to a central server, which aggregates them into

C

Seyed Salar Ghazi and Kaiwen Zhang are with the Department of Software and IT Engineering, École de Technologie Supérieure (ÉTS), Montréal, QC H3C 1K3, Canada (e-mail: [email protected]; [email protected]). Mehdi Feizi is with the Department of Economics, Faculty of Economics and Administrative Sciences, Ferdowsi University of Mashhad, Mashhad, Iran (e-mail: [email protected]). Hans-Arno Jacobsen is with the Department of Electrical and Computer Engineering, University of Toronto, Toronto, ON M5S 3G4, Canada (e-mail: [email protected]).

an improved global model. This iterative process continues until convergence. [1], [2]. While single-server FL has proven effective for moderatescale deployments, it introduces critical bottlenecks as the number of participating devices grows. A single central server represents a point of failure, a communication bottleneck, and a centralized target for security attacks. Hierarchical Federated Learning (HFL) addresses these structural limitations by introducing a layered architecture in which edge servers aggregate local updates from nearby clients before forwarding them to a principal server for global aggregation [3], [4]. This hierarchical design significantly reduces communication overhead, improves scalability, and enhances fault tolerance, making HFL particularly well-suited for geo-distributed environments where clients are widely dispersed and network conditions are highly variable [3], [5]. Despite these structural advantages, existing HFL systems suffer from a fundamental limitation in their client selection mechanisms, called strategic inefficiency, that prevents them from realizing their full potential, and they fail to achieve PE. The dominant design philosophy prioritizes stability, ensuring no client-server pair mutually prefers to deviate from their current assignment at the direct expense of Pareto efficiency (PE) [4], [6]. A stable matching is not generally pareto efficient, meaning the system accepts an allocation where aggregate utility across all participants could be improved without disadvantaging anyone. In welfare terms, stabilityoriented mechanisms leave potential gains in model quality, resource utilization, and economic outcomes unrealized in every training round [7]–[9]. For HFL systems operating across large client populations and multiple servers, this systematic welfare sacrifice compounds across rounds, cumulatively degrading both learning performance and participant satisfaction. Pursuing PE alone, however, is insufficient to guarantee system welfare in practice. Without strategy proofness (SP), self-interested participants have incentives to misrepresent their true preferences (based on various parameters, including reward, latency, and capacity) and capabilities to obtain more favorable assignments. A client may misreport its computational costs to appear more attractive to highreward servers. When participants misreport, the preference profile fed into the matching mechanism is corrupted, and the resulting assignment is pareto efficient only with respect to false inputs, which means it is welfare-destroying in reality and strategically inefficient. Realizing pareto efficient outcomes in practice therefore requires PE and SP not as independent goals but as inseparable properties. PE defines the welfare target, and

2

SP is what ensures participants reveal the information needed to reach it [8], [9]. Existing approaches address pieces of this problem but none resolve it comprehensively. Stability-focused mechanisms such as Deferred Acceptance (DA) [4], [6], [8] guarantee stable matchings but, as noted above, sacrifice PE. pareto efficient mechanisms such as Immediate Acceptance with Skip (IAS) [8], [9] achieve efficiency but lack SP entirely, leaving the system vulnerable to manipulation. Auction-based and contracttheoretic incentive mechanisms [10], [11] optimize server-side utility but do not provide SP guarantees. Reputation-based systems [11] improve trust over time but cannot guarantee PE in any given round. Beyond matching, evaluating the contributions of heterogeneous clients to the global model remains a persistent bottleneck because the methods, including Shapley value calculation, are combinatorially intractable at scale [12], [13], while lightweight approximations either sacrifice accuracy in nonconvex settings or neglect coalition effects among clients [13]. Finally, even in seemingly decentralized HFL architectures, the matching process often remains centralized at a single principal server, creating single point of failure, manipulation, and bias [4], [6], [14]. To address these limitations, we propose SCOPEFL (Strategy-proof Chain-based Optimal Pareto-Efficient Federated Learning), a novel synchronous HFL framework that guarantees a pareto efficient allocation by formulating client selection as a two-sided school choice problem solved through the Top Trading Cycle (TTC) algorithm [8], [9]. The school choice formulation naturally captures the bilateral nature of HFL client selection, where both clients and servers hold preferences over each other based on reward, latency, and contribution quality. Although HFL servers collaborate toward a single global model, the school choice analogy does not require them to be rivals. In the canonical formulation [15], schools are not strategic agents but objects to be ”consumed” by students, holding only capacities and priorities, while students alone hold preferences and act strategically. Furthermore, each server rewards high-contribution clients; competing for desirable clients is equivalent to competing for those that most improve the shared model. This asymmetry does not mean that server interests are neglected. Server-side objectives (contribution quality, communication delay, and price) are encoded directly in the priority profile that the mechanism takes as input, so the TTC procedure structurally favors pairings that servers value highly. The theoretical guarantees of SCOPE-FL (Pareto efficiency and strategy proofness) are accordingly stated for the client side, while server-side and system-level outcomes, such as global model accuracy and convergence speed, are validated empirically in evaluation Section. TTC is the unique mechanism in this setting known to simultaneously guarantee PE and SP while provide minimum instability (minimum number of blocking pairs among all SP and PE mechanisms) [16], ensuring that the system reaches its pareto efficient allocation while incentivizing all participants to report their preferences and capabilities truthfully. To accurately measure each participant’s marginal contribution to

global model, SCOPE-FL employs a scalable heuristic-based Shapley value method based on One-Round Reconstruction (OR) [12], customized for the HFL framework to enable fair and transparent reward distribution without the combinatorial complexity of exact Shapley computation. The entire assignment mechanism executes via blockchain smart contracts, providing the tamper-proof execution environment necessary for SP guarantees to be credible in practice and eliminating single points of failure inherent in centralized designs. 1) Pareto efficient client selection. We are the first to formulate HFL client selection as a two-sided school choice problem and solve it using TTC, transforming what was previously a stability-oriented, welfare-sacrificing process into one that guarantees a pareto efficient allocation for clients. This moves beyond unilateral, server-centric selection to a bilateral model where the preferences and priorities of both clients and servers drive the matching outcome. 2) Simultaneous PE and SP. SCOPE-FL is a pioneering HFL framework that simultaneously guarantees PE and SP with minimum instability. This unique dual guarantee ensures PE while making it a dominant strategy for all participants to report truthfully, so the welfare gains are realized in practice and not just in theory. 3) Scalable contribution evaluation. To ensure equitable performance-based compensation, SCOPE-FL employs a scalable heuristic-based Shapley value method using OR, accurately measuring each client’s marginal contribution to global model improvement. This contributionproportional compensation ensures that clients who improve the global model most are rewarded most, creating a self-reinforcing alignment between individual participation incentives and system-wide welfare maximization. 4) Decentralized tamper-proof execution. The entire matching and reward mechanism is implemented via blockchain smart contracts, eliminating centralization risks and ensuring transparent, manipulation-resistant operation. We further identify storage write complexity, quantified by SSTORE operations on the EVM as the critical efficiency metric for matching algorithms on blockchain, a contribution that has been systematically overlooked in prior work [17]. 5) Comprehensive empirical validation. We conduct extensive evaluation on MNIST, Fashion-MNIST, and CIFAR-10, demonstrating that SCOPE-FL outperforms DA, IAS, and other baseline methods across model accuracy, convergence rate, reward efficiency, gas consumption, and communication latency. The paper’s following sections are structured as follows: Section II provides a deep dive into related work. Section III provides the foundational background necessary to contextualize this study, while Section IV demonstrates the adopted system model. Section V covers the experimental setup and findings. Finally, Section VI discusses the conclusion and future research directions.

3

II. R ELATED W ORK In the following, we survey related work on client selection and incentive mechanisms in FL systems, multi-server FL and HFL frameworks, blockchain-enabled FL systems, and clients’ contribution evaluation. A. Client Selection and Incentive Mechanisms in FL Systems Client selection has been widely recognized as a key determinant of system welfare in FL, yet existing mechanisms address welfare only partially. Optimization-based, importance-driven, clustering, and reinforcement learning approaches primarily maximize server-side utility while treating selection as a unilateral decision, ignoring client preferences and bilateral welfare [18]–[21]. Game-theoretic approaches move closer to bilateral modeling, for instance, Yellampalli et al. propose MAAIM, a DA-based incentive mechanism achieving stable client-server pairings through learning quality estimation, excelling at stability but not aiming to achieve PE. [6]. Similarly, Wehbi et al. employ matching game theory for bilateral selection based on accuracy and rewards, and later extend this to a mutual trust-based framework that significantly reduces untrusted client participation, but without PE or SP guarantees [4], [22]. Qu et al. propose COCS, a contextual combinatorial multi-armed bandit policy for HFL-specific client selection that handles uncertain network conditions and budget constraints, excelling at maximizing participating client count but not aiming to achieve bilateral preference satisfaction or pareto efficient matching [23]. For contribution evaluation and reward distribution, Zahra et al. introduce Block-RACS, a blockchain-driven mechanism using influence function-based Shapley estimation that achieves computational efficiency but does not capture coalition effects essential for accurate marginal contribution assessment [13]. Beyond selection mechanics, the role of incentives has been analyzed broadly. Nair et al. survey auction, contract, and game-theoretic incentive mechanisms, emphasizing contribution evaluation and manipulation resistance [24]. Donahue et al. study optimality and stability in FL, identifying a fundamental tension: mechanisms that achieve equilibrium stability systematically sacrifice efficiency, leaving potential welfare gains unrealized [7]. DualGFL combines hedonic coalition formation with multi-attribute auction mechanisms to achieve Pareto-optimal coalition structures, demonstrating the potential of hybrid cooperative-competitive modeling, but without addressing SP at the client-server matching level [25]. Diamanti et al. frame multi-server resource allocation as a Fisher market equilibrium problem guaranteeing proportional fairness and envy-freeness, excelling at resource pricing but not aiming to provide matching-theoretic welfare guarantees [26]. Collectively, these works demonstrate the importance of incentive design in FL but leave the core welfare problem unresolved: no existing mechanism simultaneously achieves PE, SP, and accurate coalition-aware contribution evaluation in HFL.

B. Multi-Server and Hierarchical Federated Learning The limitations of single-server FL, such as communication bottlenecks, vulnerability to failure, and unilateral client selection have motivated extensive research into multi-server and hierarchical architectures. Tang et al. propose a multi-UAVassisted HFL framework combining Lyapunov optimization with deep reinforcement learning for joint client selection and server assignment, achieving significant reductions in training latency and energy consumption but without bilateral incentive compatibility [27]. HaghighiFard et al. extend this to vehicular networks with a multi-tiered architecture demonstrating improved scalability and non-IID handling, while Zuo et al.’s Spyker eliminates synchronization bottlenecks through fully asynchronous multi-server FL, reducing convergence time by up to 61% in geo-distributed settings [3], [28]. Yang et al. propose HierMo, a three-tier momentum-accelerated HFL algorithm with a proven O(1/T) convergence rate that reduces total training time by 5–73% over two-tier baselines, excelling at convergence efficiency but not aiming to address client selection incentives or matching-theoretic welfare guarantees [29]. Hudson et al.’s Flight framework enables truly hierarchical multi-tier FL with over 60% reduction in communication overhead and support for up to 2,048 devices, demonstrating impressive structural scalability without addressing the strategic behavior of participants in client selection [5]. These frameworks collectively advance HFL’s structural capabilities, like convergence speed, communication efficiency, and fault tolerance but consistently leave the matching-level welfare problem unaddressed. Client selection remains either unilateral, stability-focused, or lacking SP, preventing the system from reaching its pareto efficient allocation. C. Blockchain-Enabled and Decentralized FL Blockchain has been extensively explored as infrastructure for trust, transparency, and decentralization in FL, motivated precisely by the welfare-destroying consequences of centralized execution identified in Section I. Cai et al. survey blockchain-empowered FL, highlighting its resistance to single points of failure and ability to secure incentive mechanisms, while noting efficiency and storage challenges that motivate further optimization [30]. Zhang et al. categorize decentralized FL frameworks by consensus model and application domain, and Orabi et al. further emphasize blockchain’s role in mitigating poisoning attacks and ensuring data integrity [31], [32]. Wu and Seneviratne propose a scalable blockchain-based FL framework with automated registration, validation, and reward distribution for large-scale tasks [33]. Kasyap et al.’s PoIS consensus mechanism uses Shapley value-based model interpretation to evaluate contributions and detect malicious participants, restricting attack success rates below 5% even under 90% adversarial participation [34]. Cam and Kiet’s FlwrBC and Wang et al.’s consortium blockchain mechanism further demonstrate blockchain’s utility for transparent incentive enforcement in general and healthcare FL settings respectively [35], [36]. Despite these advances, existing blockchain-based FL solutions focus primarily on trust and security rather than on

4

enforcing matching-theoretic welfare guarantees. So, even theoretically sound mechanisms are undermined by centralized execution that makes their guarantees unenforceable in practice. Moreover, the on-chain storage complexity of matching algorithms has not been systematically analyzed, leaving an open question about which mechanisms are most suitable for blockchain deployment (a gap that SCOPE-FL directly addresses through its SSTORE-based complexity analysis). D. Clients’ Contribution Evaluation Accurate contribution evaluation is a prerequisite for welfare-maximizing reward distribution in HFL since without it, compensation is decoupled from actual marginal impact, destroying the incentive compatibility that PE and SP are designed to preserve. Block-RACS introduces an influence function-based mechanism that is computationally efficient and integrates reputation tracking, but deviates from true contribution values in deep non-convex models and neglects coalition effects among clients [13]. MAAIM relies on learning quality estimation based on loss reduction, which is lightweight and effective for client ranking but captures only individual performance in isolation, missing the coalitionlevel interactions essential for Shapley-inspired contribution evaluation [6]. Multi-round reconstruction approximates Shapley values more accurately by considering long-term participation, but incurs prohibitive computational and memory costs that limit scalability in large client populations [12]. The OR method best balances accuracy, coalition awareness, and per-round efficiency among existing approximations, but its 2n subset evaluation complexity remains intractable at scale when applied over an entire client population [12]. Therefore, no contribution evaluation method achieves accuracy, scalability, and coalition awareness together. Together, mentioned three gaps define the precise problem space that SCOPE-FL occupies, one that no prior work has addressed in its entirety. III. BACKGROUND In the following section we discuss the school choice problem and provide details about the well-known TTC algorithm with an example. A. School Choice Problem The school choice problem represents a fundamental assignment challenge within the broader framework of assignment theory. This problem involves two distinct sets: a collection of individuals (students) and a corresponding set of objects (schools). Each individual possesses a preference ordering over the available objects, while each object has an associated capacity constraint and maintains priorities over the individuals based on specific criteria [9]. The formal structure of a school choice problem can be represented as the tuple (I, S, q, P, π), where: • I = {i1 , i2 , ..., in }: A finite set of students (individuals) • S = {s1 , s2 , ..., sm }: A finite set of schools

q = {qs1 , qs2 , ..., qsn }: A capacity vector specifying the maximum number of students each school can accommodate • P = {Pi1 , Pi2 , ..., Pin }: A preference profile representing the strict preferences of students over schools • π = {πs1 , πs2 , ..., πsm }: A priority structure indicating each school’s ordering over students For any student i, the preference relation Pi is defined as a strict ordering over the set S ∪ {i}. The inclusion of the student itself in their preference ordering allows for the possibility of self-matching, representing scenarios where a student might prefer remaining unmatched rather than being assigned to certain schools they consider undesirable [9]. An assignment is formally represented as a mapping µ : I ∪ S → 2I∪S satisfying the following conditions for each i ∈ I and s ∈ S: 1) µ(i) ∈ S ∪ {i} and µ(s) ∈ 2I 2) µ(i) = s if and only if i ∈ µ(s) 3) |µ(s)| ≤ qs Two fundamental properties characterize desirable assignment mechanisms: efficiency and stability. An assignment µ is considered efficient if no alternative assignment µ′ exists where all students weakly prefer µ′ over µ (meaning students either view both assignments as equally preferable or strictly prefer µ′ ) and at least one student strictly prefers µ′ over µ. This ensures that no Pareto-improving reassignment is possible [9]. An assignment µ is deemed stable if it simultaneously satisfies three conditions: 1) Individual Rationality: For every student i ∈ I, their assignment µ(i) is at least as preferred as remaining unmatched. 2) Non-wastefulness: If a student prefers a particular school to their current assignment, then that school must have reached its capacity. 3) Absence of Justified Envy: If student i prefers school s over her current assignment, then all students assigned to school s must have higher priority than student i according to πs . A fundamental impossibility result demonstrates that no assignment mechanism can simultaneously guarantee both efficiency and stability [8], [9], [15]. This impossibility forces practical mechanisms to favor one property over the other, so the choice depends on which better serves the application at hand. •

B. Top Trading Cycle Mechanism One prominent approach is the TTC mechanism, which is known to produce pareto efficient allocations, though it does not always satisfy stability [15]. By contrast, DA guarantees stable outcomes but, as noted earlier, may fail to achieve efficiency. For the client selection problem in federated learning, we favor efficiency over stability and therefore adopt TTC since it optimizes clients’ welfare in the Pareto sense and guarantees Pareto efficient outcome. Operationally, TTC is represented as a directed graph whose nodes are students and schools: at the start of each iteration, every student points to

5

their most preferred school among those still available, and each school points to the highest-priority student among those not yet assigned. It can be shown that at least one directed cycle must exist. We select any cycle, and for every student in that cycle, assign them to the school they point to; all students in the cycle are then removed from the graph. For each school in the cycle, its capacity is reduced by one, and if its capacity reaches zero the school node is removed. The procedure then repeats with the remaining students and schools. Students repoint to their top remaining choice, schools re-point to their highest-priority remaining student, and cycles are cleared in the same way. The mechanism terminates when every student is assigned or when no school seats remain [9]. A step-bystep illustration of TTC is provided in Appendix A with an example. IV. S YSTEM M ODEL This section begins with outlining the problem scenario. Next, we describe the models for both servers and clients, followed by the formulation of the problem. To help readers follow along, Table I lists all the symbols and notation used throughout the model. TABLE I: Summary of notations Parameters

Description

C, S si cj P r , Qr Cap si rn R Ix Ar C si G SC θ ϕ ∆ M D ncj nsi ℓ U (·) K s pcji c psji s Net delay cji s Obj cji

Sets of clients and tier-2 servers A single tier-2 FL server A single client device Preference & priority matrices in round r Capacity of tier-2 server i A federated server communication round Total number of FL rounds Assigned weight to parameter x Assignment mapping in round r Assigned client set to tier-2 server i Directed graph for TTC Smart contract Model parameters contribution index of each client Changes in model state Model state Dataset of each client data size of client j data size of server i Loss function Model utility function (e.g., validation accuracy) Shapley normalization constant Offered price by server i to clients Requested price by client j to contribute Average network delay between server i and client j Objective function of tier-2 server i with respect to client j Total normalized gain of client j with respect to server i Overall objective function of each tier-2 server i across all assigned clients System welfare function at round r

s

Ocji Esi W r (A)

The multi-server FL frameworks employ multiple servers that interact with disjoint client subsets, reducing computational and communication overhead. Among these, HFL systems, such as HierFAVG adopt a layered architecture in which a principal server maintains the global model [37]. In each round, tier-2 (edge) servers aggregate updates from their client

groups and forward the results to the principal server, which performs a second-level aggregation to produce the new global model. Most existing HFL frameworks operate synchronously, requiring all servers to finish aggregating before the global update is finalized, though asynchronous variants have been proposed to handle stragglers. In geo-distributed settings, this design reduces wide-area communication, improves scalability, and mitigates client heterogeneity at the regional level [3]. Within this architecture, both clients and servers hold incentive requirements. Servers prefer clients that demand lower rewards and offer higher marginal contributions to the global model, while clients prefer servers offering higher compensation and lower latency. The matching should therefore be contribution-aware, PE, and SP, and must execute in a tamperproof environment, which we realize through blockchain smart contracts. We detail the server, client, and welfare models and the resulting matching formulation in the following subsections. A. Server Model in SCOPE-FL In our HFL framework, servers are organized into two layers: tier-2 servers and a top server. Each tier-2 server is responsible for aggregating local model updates from its assigned clients, evaluating their contributions using the ORbased mechanism [12] over its local client set, and scoring them according to factors such as network delay, price, and contribution values. These aggregated updates and contribution scores are then transmitted to the top server. The top server serves as the principal coordinator and it collects the aggregated models from all tier-2 servers, performs a weighted global aggregation, and updates the global model accordingly. It also executes the smart contract–based assignment mechanism to ensure efficient client–server associations for subsequent rounds. Finally, the updated global model and assignment decisions are redistributed back to all servers and clients, enabling the next iteration of training. In SCOPE-FL, the OR method is executed independently at each tier-2 server over only its assigned client set, not over the entire client population. So, while the exact Shapley value computation requires evaluating all 2n subsets of clients, which is intractable for large n, our hierarchical architecture naturally bounds this complexity. The Algorithm 1 proceeds in three phases. In the first phase, (r) each assigned client j ∈ Csi trains a local model Mj using (r) (r) its local dataset and computes a model update ∆j = Mj − M (r) , which is sent to server si . In the second phase, server si aggregates these updates to form the new global model M (r+1) and simultaneously reconstructs approximate coalition models (r+1) MSub for every subset Sub ⊆ Csi using the stored gradients without requiring any additional training rounds. This oneround reconstruction is the key efficiency property of the OR method: coalition models are derived directly from existing updates rather than retraining from scratch. In the third phase, the server computes each client’s contribution index ϕj using the Shapley formula, measuring the marginal utility gain of adding client j to each possible coalition Sub ⊆ Csi \ {j}.

6

Algorithm 1 Scalable OR (One-Round Reconstruction) in SCOPE-FL Require: B: local minibatch size, E: number of local epochs, η: learning rate 1: Server si executes: {Runs independently at each tier-2 server} 2: Calculate the Local Model for assigned clients only 3: Csi ← assigned client set of si , |Csi | ≤ Cap si (0) 4: Initialize M (0) , {MSub | Sub ⊆ Csi } 5: for each round r ← 0, 1, 2, . . . , R − 1 do 6: Send M (r) to all clients j ∈ Csi (r) 7: Mj ← C LIENT U PDATE(j, M (r) ) for j ∈ Csi (r) (r) 8: ∆j ← Mj − M (r) for j ∈ Csi P (r) |Dj | 9: M (r+1) ← M (r) + j∈Cs P |Dk | · ∆j i

10: 11:

i

for each subset Sub ⊆ Csi do P (r) (r) |Dj | ∆Sub ← j∈Sub P |Dk | · ∆j (r+1)

(r)

ϕj = K ·

P

x′ =

x − min(x) max(x) − min(x)

(1)

k∈Sub

(r)

12: MSub ← MSub + ∆Sub 13: /* Calculate the CIs */ 14: for j ← 1, 2, . . . , |Csi | do 15:

k∈Cs

Net delay scji term explicitly present in both the server objective (2) and the client objective (8). By minimizing Net delay in the matching objective, SCOPE-FL’s TTC mechanism implicitly tries to minimize communication overhead at the assignment level, preferring client-server pairings with lower RTT-based transmission costs. Communication overhead is therefore a first-class component of both utility functions and is formally integrated into the welfare objective W r (A) defined in Section IV-C. It should be noted that since engaged parameters in formulas are measured in different units, each part is normalized between zero and one with the help of min-max normalization. The general formula for performing min-max normalization is as Equation (1):

Sub⊆Csi \{j}

(R)

(R)

U (MSub∪{j} )−U (MSub ) |Cs |−1 i |Sub|

(

)

16: Return M (r) and ϕ1 , ϕ2 , . . . , ϕ|Cs | i 17: ClientUpdate(j, M ): 18: B ← (split Dj into batches of size B) 19: for each local epoch e ← 1, 2, . . . , E do 20: for batch b ∈ B do 21: M ← M − η∇ℓ(M ; b) 22: Return M to server

The weights Ix , Ix′ , Ix′′ in Equation (2) are configurable parameters that allow each server to independently express its operational priorities. In real-world deployments, servers may assign different weights based on their specific requirements. servers may prioritize contribution quality (Ix ≫ Ix′ , Ix′′ ), cost-conscious providers may emphasize reward minimization (Ix′′ ≫ Ix , Ix′ ), and edge servers may focus on latency (Ix′ ≫ Ix , Ix′′ ). For experimental consistency, we set uniform weights (Ix = Ix′ = Ix′′ = 1/3) across all servers to provide an unbiased baseline for mechanism comparison. Objcsji∈Cs = Ix ϕj − Ix′ N et delaycsji − Ix′′ pcsji i

Since the subset enumeration in phase two is bounded by 2Cap si rather than 2|C| , the system-wide complexity reduces from O(2|C| ) globally to O(|S| · 2Cap max ), where |S| is the number of tier-2 servers and Cap max is the maximum server capacity. Since server capacity is a bounded system parameter independent of total client population size, contribution evaluation remains tractable as the number of clients grows, making SCOPE-FL significantly more scalable than flat FL systems where OR would need to operate over the entire client pool. As previously mentioned, federated tier-2 servers wish to maximize model accuracy while paying the least possible reward to client devices and minimize overall network delay, at the same time. Note that network delay between clients and servers can be calculated by sending a short message and checking the Round-Trip Time (RTT) of each packet. Therefore, the server si is interested in maximizing the following objective function Objcsji for each assigned client during each FL round rn in Equation (2). Communication overhead in FL systems is influenced by multiple factors, including model size, bandwidth availability, network topology, and convergence rate [1], [3]. Among these, transmission latency between clients and servers (captured by round-trip time RTT) is one of the most directly controllable and impactful factors, as it determines how long each round of model upload and download takes regardless of other system parameters. In SCOPE-FL, this is captured through the

(2)

Therefore, our solution should maximize Equation (3), for each tier-2 server si ∈ S across its assigned clients. As a final note, Constraint (4) limits each tier-2 server to select at most Capsi clients per round. Esi =

N sel X

Objcsji

(3)

cj ∈Csi

Csi ≤ Capsi

(4)

Additionally, to avoid further complication and overhead we use the FedAvg formula to aggregate client weights in tier-2 servers and tier-2 servers’ weights in the top server, according to Equations (5) and (6). FedAvg is the baseline federated learning algorithm where, in each round, the server sends the current global model to a subset of clients, each client trains it locally for a few epochs on their own data, then sends the updated model back. The server combines these client models by averaging them (giving more weight to clients with more data) to produce a new global model, and repeats this process until convergence [2]. Consider that tier-2 server si has client set Csi , client cP j has data size ncj , and server si total available data is nsi = cj ∈Cs ncj . The total data across all clients i P (r) (r+1) is N = − M (r) as si ∈S nsi . We define ∆cj = Mcj the difference between client cj ’s local model and the current (r) (r+1) global model after training, and ∆si = Msi − M (r) as

7

the difference between the global model and tier-2 server si ’s local model after aggregation. X ncj Ms(r+1) = M (r) + ∆(r) (5) i nsi cj cj ∈Csi

M (r+1) = M (r) +

X ns

i

si ∈S

N

∆(r) si

(6)

In comparison to FedAvg, we have FedProx and FedRelax, two algorithms that are developed for better dealing with data heterogeneity. The core update formula for FedProx is demonstrated in Equation (7). FedProx is an iterative federated learning algorithm that alternates between the separate training of local models, followed by combining the updated local model parameters. It was designed to address a central challenge in FedAvg: selecting an appropriate number of local updates. FedProx uses a proximal operator for training instead of standard Stochastic Gradient Descent (SGD), making it particularly effective for FL applications with high levels of heterogeneity among devices’ computational capabilities and statistical properties of their local datasets [2]. (r+1)

Mj

  1 = arg min ℓ(M ; Dj ) + ∥M − M r ∥22 η

(7)

In the Equation (7), η1 ∥M − M r ∥22 is the proximal regularization term and ℓ(M ; Dj ) is the loss function evaluated on client j’s local dataset Dj . On the other hand, FedRelax applies block-coordinate minimization to solve the Generalized Total Variation Minimization (GTVMin) problem. It is designed to handle both parametric and non-parametric models, making it model-agnostic. The algorithm exploits the structure of the objective function by updating local model parameters in parallel while keeping the parameters of the neighbors fixed [2]. B. Client Model in SCOPE-FL The main objective of client devices is to maximize their earned reward alongside reducing network latency. In (8), for each client cj and its matched server si , we demonstrate the objective function of each client. Note that client devices aim to maximize the objective function in Equation (8), in which the values of Ix , Ix′ will be adjusted according to each client’s preferences. For example, if client cj prefers to maximize the reward, Ix should be much greater than Ix′ (Ix ≫ Ix′ ), and vice versa. In this scenario, we assign (1/2) to each parameter. Ocsji = Ix pscji − Ix′ N et delaycsji

(8)

In such a situation, each client j can be assigned to at most one federated server, per each rn to satisfy (9). |Arn (cj )| ≤ 1

∀cj ∈ C, ∀rn

(9)

It should be noted that each client device runs a simple Convolutional Neural Network (CNN) model that will be described in detail in the evaluation, and the client model above assumes fully rational utility-maximizing agents, meaning each client is modeled as acting to maximize Ocsji without error.

C. Welfare Formulation in SCOPE-FL Beyond individual utility maximization, The system-level goal of SCOPE-FL is to reach allocations from which no Pareto improvement is possible during each federated learning round. We define the global welfare function as the sum of realized utilities of all matched participants, subject to capacity and assignment feasibility constraints. The system welfare at round r is defined as: X X W r (A) = (10) (Objcsji + Ocsji ) si ∈S cj ∈Csi

Objcsji is the server objective function defined in (2), and Ocsji is the client objective function defined in (8), subject to: (capacity feasibility) 1) |Csi | ≤ Cap si for all si ∈ S 2) Each client is assigned to at most one server (unique assignment) The welfare function W r (A) captures the bilateral nature of SCOPE-FL’s matching problem: server utilities reflect model quality, communication cost, and reward efficiency, while client utilities reflect compensation and latency preferences. An assignment that maximizes W r (A) in the Pareto sense ensures that no reallocation can improve any participant’s utility without reducing another’s. As formalized in Section IV-D and proven in Theorem 1, in section IV-E, SCOPE-FL, solves this problem by formulating client selection as a school choice problem and through the TTC mechanism. It is important to clarify the precise relationship between the TTC mechanism and the welfare function Wr (A). SCOPEFL does not optimize Wr (A) directly; rather, it guarantees Pareto efficiency with respect to the client preference profile P r , which is constructed as a monotone transformation of the client utilities Ocsji . By Theorem 1, the resulting assignment Ar+1 admits no reallocation that makes any client better off without making another client worse off under the submitted profiles. Accordingly, we employ Wr (A) not as the objective the mechanism provably optimizes, but as an empirical aggregate that quantifies the realized utility of assignments, and we report its constituent components (reward and latency) as indicators of realized welfare in our evaluation section. This welfare guarantee is only meaningful under truthful preference revelation. As established in Theorem 2, SP ensures that participants have no incentive to misrepresent P r or Qr , which is the necessary condition for the pareto efficient properties of TTC to hold in practice. Without SP, participants could corrupt the preference profile fed to TTC, producing an assignment that is pareto efficient only with respect to false inputs and therefore welfare-destroying in reality. A natural question is what protects server interests, given that the formal guarantees of Theorems 1 and 2 concern only the client side. In SCOPE-FL, servers are not strategic agents but objects endowed with capacities and priorities [15]; their interests therefore enter the mechanism through the priority profile Qr rather than through the efficiency guarantee itself. Since Qr ranks clients by the very quantities servers care about (contribution scores, network delay, and requested price)

8

servers’ priorities Workers’ preferences TTC Smart Contract

New Assignment (𝑨𝒓+𝟏 )

Top server

Block Chain

Model updates (Θ)

Global Model

Tier-2 server (1) New Assignment

Workers’ neighbors weights

......

Price Negotiation Phase

Price Negotiation Phase

Worker Worker

Tier-2 server (n)

Tier-2 server (n-1)

Worker Worker

Worker

Worker

Fig. 1: SCOPE-FL Architecture

and since a TTC cycle forms only when a server’s highestpriority remaining client points back to it, the mechanism structurally channels high-contribution, low-cost clients toward the servers that value them most. Whether this translates into strong system-level outcomes is an empirical question, which evaluation section answers affirmatively; client-side Pareto efficiency coincides with the fastest convergence and highest final accuracy among all evaluated mechanisms. D. Problem Formulation as a School Choice In this section, we formally map the client-server assignment challenge in hierarchical multi-server federated learning to the school choice framework, enabling us to leverage the TTC mechanism for pareto efficient and strategy-proof assignments. The overall architecture of SCOPE-FL has been illustrated in Figure 1. This figure illustrates a HFL system where clients are matched to servers through a blockchainbased TTC mechanism. The architecture consists of three tiers: clients at the bottom level who participate in local training and price negotiations, multiple Tier-2 servers in the middle that aggregate client contributions and they are distributed in various geographical locations, and a top server that coordinates the global model. Clients under the coverage of each Tier-2 server send their model updates to their assigned Tier-2 servers, which then forward aggregated models, contribution scores, and clients’ scores to the top server. The top server maintains the global model and communicates with a blockchain network running a TTC smart contract that processes clients’ preferences for

servers and servers’ priorities over clients to compute fair assignments for the next round. 1) Mapping FL Components to School Choice Elements: We establish the following correspondence between federated learning entities and school choice problem components. Algorithm 2 illustrates the whole procedure of SCOPE-FL. 1) Students ↔ Client Devices (Workers): The set of client devices C = {c1 , c2 , . . . , cn } corresponds to the set of students seeking assignment. Each client cj possesses computational resources, local data Dj , and preferences over available servers. 2) Schools ↔ Tier-2 Servers: The set of tier-2 federated learning servers S = {s1 , s2 , . . . , sm } corresponds to the set of schools. Each server si has a limited capacity Capsi representing the maximum number of clients it can accommodate in a given training round, analogous to school enrollment quotas. 3) Student Preferences ↔ client Preferences: Each client ci maintains a strict preference ordering Pcj over the available servers. As described in Algorithm 2, these preferences are constructed by ranking servers according to a utility function that combines normalized network delay and normalized price where higher values indicate more preferred servers. This preference reflects client’s dual objectives: minimizing communication latency and maximizing monetary rewards. 4) School Priorities ↔ Server Priorities: Each server si maintains a priority ordering Qsi over clients, constructed by ranking clients according to three normalized criteria (Algorithm 2). Here, ϕr−1 represents the OR-based contribution j score from the previous round (or initialized uniformly in round 1). Unlike classical school choice where priorities are

9

administrative rankings, our server priorities capture valuation based on efficiency, cost, and contribution quality. 5) Capacity Constraints: Each server si has a maximum capacity Capsi , enforced by the smart contract (Algorithm 3). When a server reaches capacity through TTC assignments, it is removed from the graph, preventing over-subscription. 6) Assignment Outcome: The TTC mechanism produces an assignment mapping Ar+1 where Ar+1 [cj ] = si indicates that client cj is assigned to server si for round r+1. This assignment respects capacity constraints and satisfies PE and SP properties. 2) Dynamic Preference Updates: One of the most important aspects of our approach is the dynamic evolution of preferences and priorities across training rounds. As shown in Algorithm 2: a) Contribution-Based Evolution: client contribution scores ϕrj are recalculated each round using the OR method, influencing server priorities in subsequent rounds. Highcontributing clients become more attractive to servers over time. b) Price Negotiation Integration: The agreed price between client cj and server si is contribution-weighted, creating a dynamic pricing mechanism where the base negotiated price (average of client’s request and server’s proposal) is scaled by a contribution-aware multiplier centered at 1. Specifically, a client whose contribution score ϕr−1 equals the round mean j ϕ̄ receives exactly the midpoint price, while above-average contributors receive a premium and below-average contributors receive proportionally less. This ensures higher-contributing clients receive better compensation, naturally incentivizing quality participation while maintaining fairness in the reward distribution. c) Adaptive System: Our formulation represents a repeated game where assignments, contributions, and preferences coevolve. The TTC mechanism is re-executed each round with updated profiles, ensuring continuous adaptation to network conditions and contribution dynamics. 3) TTC Smart Contract: The school choice problem formulated above is solved by Algorithm 3, which implements the TTC mechanism on blockchain via smart contracts. The algorithm receives Pr , Qr , and C as inputs, constructs a directed graph G where clients point to their most preferred available servers and servers point to their highest-priority available clients, and iteratively identifies and clears cycles until convergence. The resulting assignment Ar+1 guarantees PE, SP, and the minimum instability as demonstrated in the next section. All matching mechanisms were implemented using smart contracts written in Solidity which are EVM-compatible. This blockchain-agnostic design enables deployment flexibility, allowing the most suitable network to be selected based on transaction costs, throughput, security, and application-specific requirements. Three deployment scenarios are considered. First, Polygon that is a layer-2 scaling solution for Ethereum that processes transactions on a separate blockchain before settling them on the Ethereum mainnet. It offers faster transaction speeds (up to 65,000 transactions per second) and significantly lower

fees compared to Ethereum’s main network. [38]. Second, Improved TrustChain that is considered for resource-constrained environments. Its DAG-based structure and local-chain-only design significantly reduce computational overhead and energy consumption, while the integrated NetFlow accounting mechanism provides resilience against both Sybil and whitewashing attacks without relying on traditional consensus protocols [39], [40]. Algorithm 2 SCOPE-FL with OR Method 1: Deploy T T C SmartContract(Cap) → SC 2: Initialize: T opServer, S, C 3: Initialize: ϕ0j ← 1 for all cj ∈ C & rn ← 1 4: while not converged do 5: PHASE A: Distributed Training & OR Assessment 6: 7: 8: 9: 10: 11: 12:

for all client cj ∈ C in parallel do θjrn ← T rainLocalM odel(θglobal , Dj ) Price Negotiation: c Client cj requests price psji Server si proposes price pscji if cj assigned to si AND |Csi | ≤ Cap  si then agreed price ←

1+

ϕrj n −1 −ϕ̄ ϕ̄

c

·

s

psji +pcji 2

Accept negotiation else Reject negotiation Send M odelU pdate(θjrn , ℓj , accj ) to assigned server si 17: for all server si ∈ S in parallel do 18: {θjrn } ← Collect client updates from Csi 19: θsrin ← Aggregate CN N ({θjrn }) 20: ϕrj n ← Calculate OR Contribution({θjrn }, θglobal ) ∀ cj ∈ Csi 21: PHASE B: Global Coordination & Assignment 22: Collect all (θsrin , ϕrj n , scoresi ) at T opServer 23: θglobal ← W eightedGlobalAggregate({θsrin }, {ϕrj n }) 24: Build Client Preferences: 25: for all client cj ∈ C do 26: Pcrjn ← Rank servers by: (1 − normalized N et delaycsji ) + (1 − normalized pscji ) 27: Build Server Priorities: 28: for all server si ∈ S do 29: Qrsni ← Rank clients by: (1 − normalized N et delaycsji ) + (normalized ϕrj n ) c + (1 − normalized psji ) rn +1 30: SC : A ← ExecuteT T C(P rn , Qrn , Cap) 31: PHASE C: System Update & Next Round Preparation 32: Distribute new assignments Arn +1 to all nodes 33: Distribute θglobal and neighbor weights to all cj ∈ C 34: for all client cj ∈ C in parallel do 35: Update model with neighbors; update ϕrj n & compute OR-based earnings 36: rn ← rn + 1 37: Return θglobal , A, ϕ 13: 14: 15: 16:

10

Algorithm 3 TTC Optimal Assignment Smart Contract Require: client preferences P , Server preferences Q, Capacities Cap Ensure: Assignment mapping A 1: Initialize directed graph G with nodes C ∪ S 2: Initialize assignment map A ← ∅ 3: Initialize preference queues: queueC , queueS ← 0 4: for all client cj ∈ C do 5: top server ← P [cj ][queueC [cj ]] 6: G.AddEdge(cj , top server) 7: for all server si ∈ S do 8: top client ← Q[si ][queueS [si ]] 9: G.AddEdge(si , top client) 10: iteration ← 0 11: while G.HasN odes() and iteration < M AX IT ERAT ION S do 12: cycle ← F indCycle(G) 13: if cycle = ∅ then 14: break 15: for all node v ∈ cycle do 16: if v ∈ C then 17: assigned server ← G.GetN extN ode(v) 18: A[v] ← assigned server 19: current capacity ← |GetAssignedClients(assigned server)| 20: if current capacity = Cap[assigned server] then 21: G.RemoveN ode(assigned server) 22: G.RemoveN ode(v) 23: U pdateP ref erenceQueues(G, P, Q, queueC , queueS ) 24: iteration ← iteration + 1 25: end while 26: return A Third, a private Ethereum network, deployed via Kurtosis, addresses the high gas fees and latency associated with public Ethereum by allowing direct configuration of chain parameters, including the ability to set gas prices to zero, thereby removing cost barriers for frequent smart contract interactions [41]. In this work, we used the Polygon testnet, though any Ethereum-compatible testnet could be used interchangeably. E. Properties of SCOPE-FL The TTC mechanism has been known for its efficiency. In the original TTC, the preferences of students over schools and vice versa are fixed. However, in SCOPE-FL, these preferences can change during each FL round. In the subsequent theorem, we establish that SCOPE-FL maintains its efficiency even when preferences are variable. Theorem 1. SCOPE-FL produces an efficient assignment. Proof. In each FL round r, SCOPE-FL updates: r • The clients’ preference profile P over servers, and r • The servers’ priority profile Q over clients (with capacities Cap), then it runs the TTC mechanism on the resulting schoolchoice instance SCr = (C, S, Cap, Pr , Qr ). By the classic result

of Abdulkadiroğlu–Sönmez, TTC returns a pareto efficient assignment for any fixed preferences/priorities with quotas [15]. Therefore, the assignment Ar generated by SCOPE-FL in round r is pareto efficient in terms of (Cap, Pr , Qr ). Dynamic evolution of preferences across rounds does not affect per-round efficiency: efficiency is evaluated relative to the preferences/priorities used in that round. Hence, SCOPEFL maintains efficiency at every round by re-running TTC on the (new) fixed profiles. Theorem 2. In SCOPE-FL, truthful preference revelation is a dominant strategy for all workers. No worker can benefit by misrepresenting their preferences over servers. (strategy proofness). Proof. According to [15], understanding why TTC is strategyproof is intuitive. Consider a student matched at step k under truthful reporting. At each preceding step, she pointed to her most preferred available school, meaning all schools she values more highly were already removed before reaching step k. Crucially, lying about her preferences cannot influence which cycles form in steps 1 through k−1, so those preferred schools remain unattainable regardless. Consequently, misrepresentation offers no benefit and may only worsen her assignment. To see that dynamic preference updates across rounds do not undermine strategy proofness, observe the following. In SCOPE-FL, preferences P r and priorities Qr are updated at the beginning of each round r based on observed contribution scores ϕr−1 , negotiated prices, and network delays (all of j which are computed prior to and independently of the TTC execution in that round). Consequently, within round r, the profiles (P r , Qr ) are fixed at the moment TTC is invoked, reducing the setting to a standard static school choice instance SCr = (C, S, Cap, P r , Qr ). The classical strategy proofness result of Abdulkadiroğlu–Sönmez [15] applies directly to this fixed instance: no worker can benefit by misreporting P r given (Qr , Cap). V. E VALUATION To comprehensively evaluate SCOPE-FL’s performance, we conducted simulation-based experiments assessing operational metrics including accuracy, reward distribution, latency, and convergence rate. Our evaluation framework compares it against baseline methods across all these parameters. The following sections detail our experimental methodology and present the simulation results. A. Experimental Setup Our simulation environment consisted of 10 servers, each with a capacity of 4 clients, and 50 participating clients. We set a uniform capacity of 4 clients per server as a practical experimental constraint to enable manageable computational overhead while ensuring sufficient diversity in matching outcomes. With 10 servers and 50 clients, this configuration allows for meaningful competition among clients for servers while maintaining tractable computation for the OR contribution evaluation method. It is important to distinguish between two dimensions of scalability in SCOPE-FL: mechanism scalability and FL

11

accuracy evaluation. The scalability of TTC, DA, and IAS is evaluated extensively in Sections V-C5 and V-C6, where gas consumption and execution time are measured across configurations at 60×60×60 and 5000×5000×5000 respectively, demonstrating TTC’s favorable scaling behavior. The FL accuracy experiments use a fixed configuration of 10 servers and 50 clients, intentionally designed to isolate matching quality rather than system throughput that is consistent with methodology in related works, such as HierMo, MAAIM, Spyker, and Block-RACS, which employ similarly sized client populations for mechanism comparison [3], [6], [13], [29]. We evaluated the model’s accuracy performance on three widely-used federated learning benchmark datasets: 1) CIFAR-10, a collection of 60,000 32×32 color images across 10 object classes [42]. 2) Fashion-MNIST (F-MNIST), comprising 70,000 grayscale images of fashion items in 10 categories [43]. 3) MNIST, containing 70,000 handwritten digit images (09) [43]. These datasets vary in complexity and are standard benchmarks for assessing federated learning systems. To evaluate SCOPE-FL under realistic federated learning conditions, we distributed data across clients using a heterogeneous (nonIID) partitioning strategy based on the Dirichlet distribution Dir(α), following widely adopted methodology in federated learning literature. The concentration parameter α controls the degree of heterogeneity: smaller α produces more skewed label distributions, while α → ∞ recovers the IID setting. In our primary experiments, we set α = 1.0, which introduces mild label heterogeneity across clients, reflecting practical scenarios where client data distributions vary but are not drastically skewed. Dataset-specific CNN architectures were employed to balance performance and computational efficiency. For MNIST and Fashion-MNIST, we used a lightweight CNN with two convolutional layers (32, 64 filters), max-pooling, and two fully connected layers (128, 10 neurons) with 0.5 dropout, optimized via Adam. For CIFAR-10, we implemented a deeper architecture with four convolutional blocks (64, 128, 256, 512 filters) incorporating batch normalization, ReLU activations, max-pooling (first three blocks), and adaptive average pooling (final block). The classifier comprises three fully connected layers (512, 256, 10 neurons) with 0.3 dropout, trained using SGD with momentum (0.9) and adaptive learning rate scheduling. The simulation framework was implemented in Python 3.x using PyTorch (deep learning framework), NumPy (numerical computations), and Python’s built-in socket library for clientserver communication. Model training leveraged PyTorch’s neural network modules (torch.nn) and optimization algorithms (torch.optim), while data handling utilized torchvision for dataset loading and preprocessing. Inter-process communication between clients and servers was implemented using TCP/IP sockets with custom serialization protocols based on Python’s pickle module. Furthermore, the matching and assignment algorithms, namely TTC, DA, and IAS were implemented as the smart contract on the Ethereum blockchain using Solidity version

0.8.19. The development, deployment, and testing were conducted using Hardhat, a comprehensive Ethereum development environment. Interaction between the federated learning system and the blockchain was facilitated through Web3.py, a Python library that provides seamless integration with Ethereum nodes and enables programmatic interaction with smart contracts. Moreover, we tried to use gas-optimized operations in our smart contracts, such as the use of storage versus memory variables to minimize transaction costs. Finally, we implemented SCOPE-FL on a 2016 MacBook Pro with a 2.2 GHz Quad-Core Intel Core i7, and 32 GB Memory and MacOS Monterey, version 12.7.6. Since all clients and servers were simulated on a single machine, the network delay term N et delaycsji does not correspond to physically measured round-trip times. Instead, we generated a synthetic latency profile at the start of each experiment, and an RTT value was drawn independently for every client-server pair for emulating the heterogeneous wide-area conditions of a geo-distributed HFL deployment. These values were used identically by all matching mechanisms (TTC, DA, IAS, MAAIM, and random selection). B. Baseline Methods To evaluate the effectiveness of SCOPE-FL, we conducted a comparison with two other algorithms, called DA and IAS; a modified version of a framework called MAAIM; and finally, a random selection mechanism. The DA algorithm, proposed by Gale and Shapley (1962), is a centralized matching mechanism that operates through iterative proposal and acceptance rounds. In each round, unmatched students propose to their most preferred school among those they have not yet applied to. Schools tentatively accept their most preferred applicants up to their capacity, rejecting others. Rejected students proceed to propose to their next preferred schools in subsequent rounds. The algorithm terminates when no student wishes to make further proposals. The resulting matching is stable. DA is strategy-proof only for the proposing side, and it doesn’t lead to a pareto efficient outcome. We applied the One-Round Reconstruction contribution evaluation method similar to SCOPE-FL and implement it on a smart contract like TTC [44]. The IAS mechanism operates through sequential application rounds where decisions are made immediately and irrevocably. In each round, unmatched students apply to their most preferred school that has not previously rejected them. Upon receiving applications, schools immediately accept their most preferred applicants up to available capacity and permanently reject others. Rejected students skip the rejecting school in subsequent rounds, removing it from consideration, and proceed to apply to their next preferred available school. The process continues until either all students are matched or no further applications are possible. Unlike DA, IAS makes binding decisions immediately rather than holding tentative acceptances, which can lead to unstable outcomes where blocking pairs exist. However, IAS offers computational simplicity and PE while the mechanism is not strategy-proof, as agents can benefit from misreporting preferences [45].

12

In this method, we used influence function introduced in Block-RACS [13]. The influence function serves as an alternative method to evaluate client contributions in federated learning by measuring the impact of individual clients on the global model’s predictions. To calculate a client’s influence, the global model is retrained by excluding that specific client, and the resulting change in model predictions is quantified. Formally, the influence of client i is computed as the average absolute difference between predictions made by the complete global model (trained on all client data) and the retrained modelP(trained without client i), expressed as: n cn − W cn−i , where n is the dataset Influencei = (1/n) j=1 W c size, Wn represents the global model trained on all data, cn−i denotes the model trained excluding the i-th client and W [13]. Since both IAS and influence function-based contribution assessment are computationally lightweight relative to other methods, we proposed a hybrid approach that combines these two mechanisms to investigate whether their integration can achieve competitive model performance while maintaining minimal computational overhead. Note that, like DA, we implemented IAS on a smart contract. The MAAIM framework that employs a learning quality estimation approach based on loss reduction to guide server preferences in federated learning client selection. Specifically, they quantify each client’s learning quality as the difference between the server’s average global model loss in round t and the client’s local model loss in round t + 1, expressed as: qit = lossj (t) − lossji (t + 1). This metric reflects the marginal improvement a client can provide to the global model, with higher values indicating greater learning utility. The authors then utilize a many-to-one DA algorithm where servers rank clients based on descending learning quality values, while clients rank servers based on net monetary gain (server bid price minus energy consumption costs) [6]. It should be noted that our implementation of MAAIM deviates from the original in one respect: we exclude the energy consumption parameter from the client objective function, as it falls outside the scope of our experimental setup. Instead, we substitute latency as the communication cost proxy, consistent with the criteria used across all other baselines in this work. This adaptation ensures a fair and consistent comparison across all mechanisms. Therefore, whenever we use MAAIM, it refers to the modified version of this work. Finally, random selection serves as a lower-bound baseline, where in each federated learning round, each tier-2 server randomly selects clients from the available pool up to its capacity Capsi , without considering any preference, priority, contribution score, or incentive criterion. No matching mechanism or contribution evaluation method is employed. This baseline provides a reference point to quantify the minimum benefit that any structured client selection mechanism should surpass, and to contextualize the gains achieved by SCOPEFL’s pareto efficient matching approach. Table II summarizes how SCOPE-FL compares to existing approaches across the key mechanism design properties.

C. Evaluation Results This section evaluated SCOPE-FL (TTC) through comprehensive experiments across multiple performance dimensions. We organized our evaluation as follows: First, we assessed global model accuracy improvements on three standard FL datasets (MNIST, Fashion-MNIST, and CIFAR-10) compared to baseline methods. Second, we evaluated convergence efficiency of SCOPE-FL and TTC. Third, we analyzed average reward distribution in SCOPE-FL versus alternative baselines. Fourth, we examined the gas consumption overhead of implementing the TTC matching algorithm on EVM-based blockchains comparing with DA and IAS. Fifth, we measured the computational efficiency through algorithm running time analysis. Finally sixth, we evaluated average communication latency between matched client-server pairs in all methods. 1) Accuracy: We evaluated the global model accuracy achieved by SCOPE-FL (TTC) against four baseline client selection mechanisms that are explained in the Baseline Methods section across three benchmark federated learning datasets. Figure 2 illustrates the results on the CIFAR-10 dataset, being the most complex among the three benchmarks with 32×32 color images across 10 classes. As it is demonstrated in Figure 2, after almost 40 FL rounds, SCOPE-FL with TTC achieves approximately 76% global accuracy and significantly outperforms all baseline methods. DA reaches approximately 73% accuracy, demonstrating reasonable but inferior convergence compared to SCOPE-FL. The gap is particularly notable in the early training rounds. IAS with influence function and MAAIM ranked third and fourth with 63% and 48%, respectively. random selection ranks last with approximately 37% accuracy, confirming that unstructured client selection without any preference or contribution-aware mechanism fails to achieve competitive model quality on complex datasets such as CIFAR-10. The accuracy convergence results over 30 training rounds on the Fashion-MNIST dataset are shown in Figure 3. Even though DA performs better than SCOPE-FL (TTC) in the early rounds, SCOPE-FL (TTC) shows better long-term convergence, ranking first out of all methods and reaching an accuracy of about 85% after 30 rounds. With an accuracy of about 80% and just 5% less than SCOPE-FL (TTC), DA comes in second place. IAS comes in third place with about 78% accuracy after 30 rounds, while MAAIM performs poorly, reaching only 72% accuracy at the end of training. Random selection ranks last with approximately 66% accuracy, further demonstrating that random client assignment provides insufficient model quality even on relatively simpler datasets. Finally, Figure 4 illustrates the accuracy results on the MNIST dataset over 18 FL rounds. SCOPE-FL (TTC) demonstrates superior performance, achieving approximately 95% accuracy by round 18, while maintaining stable convergence throughout the training process. DA reaches approximately 92% accuracy by the same round, showing slightly slower convergence in the initial rounds. IAS baseline ranks third with 90% and more volatile behavior during the rounds, and MAAIM ranks fourth with almost 86% accuracy and some fluctuations. Random selection ranks last with approximately

13

TABLE II: Comparison of Mechanism Design Properties Across Client Selection Frameworks Property Pareto-Efficiency Stability strategy proofness Contribution Evaluation Decentralized Execution

SCOPE-FL

DA

IAS

MAAIM

Random

✓ Minimally unstable ✓ Shapley-based (OR) ✓

× ✓ ✓ Shapley-based (OR) ✓

✓ × × Influence Function ✓

× ✓ ✓ Learning Quality ×

× × × × ×

100

Algorithm TTC DA IAS MAAIM Random Selection

80

70

90 80 70

Accuracy

Accuracy

60

50

40

60 50

30

30

20

20 0

5

10

15

20

Rounds

25

30

35

Fig. 2: Accuracy Results of SCOPE-FL Compared to The Baseline Methods on CIFAR-10 90

Algorithm

TTC DA IAS MAAIM Random Selection

80 70

Accuracy

Algorithm

40

60 50 40 30 20 0

5

10

15

Rounds

20

25

30

Fig. 3: Accuracy Results of SCOPE-FL Compared to The Baseline Methods on F-MNIST

80% accuracy, exhibiting the most unstable convergence behavior across all rounds, which is expected given the absence of any structured selection criterion. The accuracy results across three federated learning datasets demonstrate that combining pareto efficient and minimally unstable mechanisms, such as TTC with the OR method for evaluating client contributions yields superior performance in the student-proposing school choice configuration for hierarchical and synchronous FL systems. Crucially, this approach also guarantees SP, which is essential in collaborative environments. Notably, the performance gap between DA with OR and SCOPE-FL (TTC) with the same method is marginal across all three datasets. This narrow difference highlights DA’s effectiveness in the mentioned setting. Nevertheless, achieving optimal accuracy requires mechanisms that balance both PE and minimal instability, such as TTC, paired with robust

TTC DA IAS MAAIM Random Selection

0

2

4

6

8

Rounds

10

12

14

16

18

Fig. 4: Accuracy Results of SCOPE-FL Compared to The Baseline Methods on MNIST

contribution evaluation methods like OR. This balance is further evidenced by IAS, another pareto efficient mechanism combined with the influence function method, which consistently ranks third across all three datasets. These results emphasize that maximizing accuracy in federated learning requires the convergence of three key elements: PE, minimum instability, and accurate contribution evaluation. Finally, across all three datasets, random selection consistently ranks last, establishing a clear lower bound and confirming that even simple structured mechanisms, such as MAAIM, substantially outperform unguided client selection. 2) Convergence Efficiency: To further quantify SCOPEFL’s advantage, Figure 5 illustrates the number of communication rounds saved by it relative to each baseline at six target accuracy levels per dataset. Across all three benchmarks, SCOPE-FL (TTC) consistently converges at least as fast as every competing mechanism, and its lead widens sharply as the target accuracy increases. On MNIST, SCOPE-FL saves up to 5 rounds over DA, 9 rounds over IAS, and 13 rounds over MAAIM, while random selection saves as many as 15 rounds and either fails to reach the two highest targets (85% and 90%) or requires a prohibitively large number of additional rounds to do so. On Fashion-MNIST, the advantage becomes more pronounced at higher targets: relative to DA, IAS, and MAAIM the savings grow to 8, 13, and 17 rounds respectively, while MAAIM and random selection either fail to reach the most demanding accuracy thresholds or converge to them only after a long training horizon. On the more challenging CIFAR10 dataset, SCOPE-FL saves up to 2 rounds over DA and 15 rounds over IAS, while MAAIM either fails to attain the three highest targets or reaches them prohibitively slowly, and random selection reaches only the lowest target accuracy of 40%,

14

CIFAR-10

30

50

25

40

15 20

8

15

12

6

5

0

8 1

40%

2 50%

9 1

55%

9

14

13

2

2

2

60%

65%

70%

Target Accuracy (%)

0

15

20

10

60%

8 10

9

65%

70%

13

7

4

3

75%

80%

Target Accuracy (%)

10 5

8 85%

0

2 1

65%

11

12

11

10

11

13

10

17

10

7

Saved vs DA Saved vs IAS Saved vs MAAIM Saved vs Random Selection

30

16

15 9

40

19

30

20

10

MNIST

Saved vs DA Saved vs IAS Saved vs MAAIM Saved vs Random Selection

Rounds Saved by TTC

60

Rounds Saved by TTC

Rounds Saved by TTC

35

Fashion-MNIST

Saved vs DA Saved vs IAS Saved vs MAAIM Saved vs Random Selection

2 1

70%

13 9

3

4

5 75%

9

3

4

3

80%

85%

90%

Target Accuracy (%)

Fig. 5: Cumulative Rounds Saved by TTC vs Baselines

80

Mean

70

Reward Value

requiring 15 additional rounds compared to it. Notably, the gap against MAAIM grows so steeply with target difficulty that on CIFAR-10 and Fashion-MNIST it either does not converge to the harder targets at all or does so only after an excessive number of rounds, reflecting MAAIM’s slow convergence due to its learning-quality estimation method. The marginal advantage over DA remains comparatively small but consistent, reinforcing the earlier observation that DA is a competitive baseline when paired with OR-based contribution evaluation. These results collectively demonstrate that SCOPE-FL’s pareto efficient matching not only achieves higher final accuracy but also reaches target performance thresholds significantly faster, reducing the overall energy consumption and communication overhead of the federated learning process. 3) Reward: Figure 6 presents the average obtained reward by clients across rounds for different methods. From the clients’ perspective, TTC delivers the highest average reward received at approximately 69.40, with a relatively wide distribution ranging from 60 to 79. This result demonstrates TTC yields the most favorable client-side outcomes through substantial compensation. DA ranks second in terms of rewards received at 64.05, showing favorable outcomes for clients with a median of 65 and a distribution ranging from 52 to 73. This aligns with theoretical expectations, as DA is optimal for clients (students) among stable matchings in the client-proposing variant. IAS with influence function follows at 59.35, displaying a consistent distribution with moderate client rewards. MAAIM with learning quality estimation demonstrates the least favorable outcome for clients with the lowest average reward received of 49.60. Random selection, as an unstructured baseline, exhibits the highest variance across all methods, with rewards ranging from 29 to 79 and a mean of approximately 46.80. Despite occasionally producing high rewards, its wide and unpredictable distribution reflects the absence of any strategic matching logic, making it unreliable from the clients’ perspective.

60

50

40

30

MAAIM

IAS

TTC

Methods

DA

Random Selection

Fig. 6: Average Obtained Reward by Clients Across Rounds for Different Mechanisms

The results highlight a fundamental trade-off in federated learning matching systems: while TTC with OR method delivers the highest client reward, MAAIM with learning quality estimation minimizes rewards received by clients, making it the least economically advantageous structured mechanism. Random selection, though occasionally competitive, fails to provide consistent compensation, confirming that unstructured assignment is unsuitable for client-welfare-oriented deployment. DA with OR method and IAS with influence function represent intermediate positions, with DA providing nearoptimal client rewards while IAS offers moderate compensation. This demonstrates TTC’s clear advantage in providing superior economic outcomes for clients, ensuring they receive maximum compensation for their contributions to the federated learning system. 4) Latency: Figure 7 presents the average latency across rounds for different mechanisms. As mentioned earlier, clients assign a weight of 0.5 to latency, while servers assign 0.3 to this parameter. The results show that DA achieves the lowest

15

Mean 900

Average Latency (ms)

average latency at approximately 588 ms, ranking first. The SCOPE-FL with TTC following closely at 609 ms (a marginal difference of only 21 ms). The boxplot further demonstrates that both DA and SCOPE-FL (TTC) maintain highly consistent performance, with DA exhibiting the tightest distribution and minimal variability. In contrast, IAS and MAAIM show substantially higher latencies with greater variability; MAAIM in particular displays the widest latency range, while IAS presents several outliers indicating inconsistent performance across rounds. Thus, while DA leads in latency optimization, SCOPE-FL (TTC) also demonstrates competitive and stable performance in this metric. Finally, random selection exhibits the highest average latency among all methods, with substantially greater variability across rounds, reflecting the absence of any latency-aware assignment criterion. Since clients and servers are paired arbitrarily, there is no mechanism to favor low-RTT pairs, resulting in consistently poor communication efficiency. Note that DA’s small latency advantage is expected, and its lower reward has the same cause. As the client-optimal stable mechanism, DA fully captures the low-RTT pairings that clients prefer, but it cannot do the same for reward. Latency is an aligned attribute, since both clients and servers seek to minimize N et delay, so a stable matching secures lowRTT pairs without conflict. Reward, however, is contested, because clients want a high price while servers want a low one. Stability therefore prevents DA from raising rewards in clients’ favor without creating blocking pairs. As a result, DA optimizes the uncontested dimension (latency) fully but settles for a constrained outcome on the contested one (reward). TTC, which is not bound by stability, trades the marginal 21 ms (about 3.5%) latency gap for the higher reward shown in Fig. 6. Beyond per-round latency, SCOPE-FL’s faster convergence directly reduces total communication overhead over the training lifetime since the rounds saved by SCOPE-FL (TTC) over each baseline translate directly into fewer rounds of model upload and download across all matched client-server pairs, representing a proportional reduction in aggregate bandwidth consumption. 5) Gas Consumption: Figure 8 shows the gas consumption comparison across three matching mechanisms, including DA, TTC, and IAS as the system scales from 5×5×5 to 60×60×60 configurations (Number of clients, number of servers, and number of preferences). The results reveal clear differences in efficiency among the mechanisms. At the smallest scale (5×5×5), all three mechanisms have similar and low gas consumption, below 10,000,000 units. However, as the system grows larger, the differences become more apparent. TTC consistently shows the lowest gas consumption across all test cases. At the largest scale (60×60×60), TTC uses approximately 98,000,000 gas units. IAS performs similarly with about 104,000,000 gas units, showing only a small difference from TTC. DA, however, consumes significantly more gas, especially at larger scales. At the 30×30×30 configuration, DA uses about 76,000,000 gas units while TTC uses only 20,000,000 units. This difference grows much larger at the 60×60×60 scale, where DA reaches approximately 260,000,000 gas units (More than 2.5 times higher than TTC

800

700

600

500

TTC

DA

IAS

Methods

MAAIM

Random Selection

Fig. 7: Average Latency Across Rounds for Different Mechanisms and IAS). The steep increase in DA’s gas consumption shows it does not scale well for larger systems. In contrast, TTC and IAS show more gradual increases. These results demonstrate that TTC is not only effective in terms of matching quality and monetization, but also the most cost-efficient option for blockchain-based federated learning systems, particularly in large-scale deployments. The gas efficiency advantage of TTC over DA stems from fundamental differences in storage write complexity on the EVM. On EVM-compatible blockchains, the SSTORE opcode (which writes a value to contract storage) costs 20,000 gas for writing a new value and 5,000 gas for updating an existing one, making it the single most expensive operation in smart contract execution [46]. DA’s tentative acceptance mechanism requires iterative proposal-rejection cycles where students may be accepted, displaced, and reassigned multiple times, resulting in O(n²) cumulative SSTORE operations in the worst case. Each time a school displaces a tentatively accepted student in favor of a higher-priority proposer, two storage writes occur: one to record the new acceptance and one to invalidate the previous one. IAS, while avoiding DA’s tentative acceptance cycles, still incurs multiple SSTORE operations per worker in the worst case. Since IAS makes immediate and irrevocable decisions, each worker may be permanently rejected by every server except their final match, requiring a storage write for each rejection and preference pointer advancement. In the worst case, where every worker is rejected by all but their last preferred server, this results in O(n2 ) cumulative SSTORE operations, similar in complexity to DA but arising from a fundamentally different mechanism: rejection cascades rather than displacement cycles. In contrast, TTC’s cycle-clearing mechanism produces permanent, write-once assignments, meaning once a client-server pair is matched through a cycle, that assignment is final and never mutated, incurring exactly one 20,000-gas SSTORE write per matched pair. This yields O(n) storage writes in

16

DA TTC IAS Execution Time (milliseconds)

Fig. 8: Gas Consumption Comparison Between Three Mechanisms

total. Since SSTORE operations dominate gas consumption on EVM-compatible blockchains, this difference in storage write complexity directly explains the empirical gas consumption gap observed in Figure 8, where DA’s consumption grows superlinearly compared to TTC’s near-linear scaling. Finally, random selection is excluded from this comparison as it involves no matching mechanism and incurs negligible on-chain overhead, including no graph construction, cycle detection, or iterative storage writes, making its gas cost effectively trivial regardless of scale. 6) Execution Time: Figure 9 presents the execution time comparison of DA, TTC, and IAS across test case sizes from 5×5×5 to 5000×5000×5000 (Number of clients, number of servers, and number of preferences). At small scales (up to 500×500×500), all three algorithms show negligible execution times below 100 milliseconds. However, as the system scales, performance differences emerge. At the largest scale (5000×5000×5000), IAS demonstrates the best performance at approximately 5300 milliseconds, followed by TTC at 6300 milliseconds, and DA at 6500 milliseconds. These differences stem from algorithmic complexity. DA’s iterative proposal-rejection mechanism requires multiple processing rounds. TTC’s cycle-finding approach is more efficient but requires complete graph traversal. IAS achieves the best execution time through its incremental adjustment strategy, which avoids redundant computations. The results show that while all mechanisms are practical for moderate-scale deployments, IAS offers the best scalability for large systems, followed by TTC, with DA being the most computationally intensive. Note that random selection is similarly omitted, as its O(1) per-server selection logic incurs near-zero computational cost regardless of scale, offering no meaningful basis for algorithmic comparison. VI. C ONCLUSION Client selection in hierarchical federated learning has long suffered from a fundamental strategic inefficiency: existing mechanisms either sacrifice PE for stability, or achieve efficiency without eliminating incentives for preference manipulation. Either failure degrades system welfare in practice.

00

00 500

0-5

000

-50

00

-10

500

0-5

000

00

-30

300

0-3

000

00

-20

-10

000

000

0-2

0-1 100

Test Cases

200

00

500 000-5

100

00

0-3 -50 500

00

0-1 -50 500

00

0-2 -20 200

0

0-1 -10 100

50

0 0-1

60x60x60

-10

50x50x50

100

40x40x40

20

30x30x30

Test Case Size

50-

20x20x20

20-

15x15x15

50-

10x10x10

20-

0

2000

-5

50,000,000

4000

10

100,000,000

6000

10-

150,000,000

5-5

Gas Consumption

200,000,000

5x5x5

Deferred Acceptance Top Trading Cycle Immediate Acceptance with Skip

8000

10-

250,000,000

Fig. 9: Execution Time of Three Mechanisms SCOPE-FL addresses this directly by formulating client selection as a two-sided school choice problem solved through the Top Trading Cycle algorithm, simultaneously achieving PE and SP, a combination no prior HFL framework has provided. Contribution evaluation via a customized One-Round Reconstruction Shapley approximation for HFL systems ensures reward distribution accurately reflects each client’s true marginal impact, while blockchain smart contract execution makes these guarantees tamper-proof in adversarial conditions. Evaluation on MNIST, Fashion-MNIST, and CIFAR-10 demonstrates consistent outperformance over DA, IAS, and other baselines across accuracy, convergence rate, reward efficiency, and blockchain overhead with communication latency and mechanism execution time comparable to DA and IAS, respectively. Future work includes exploration of flat multi-server architectures to eliminate hierarchical dependencies and improve scalability by allowing a larger and more diverse client population to participate without the overhead of tiered aggregation, and replacing FedAvg with FedProx as the local aggregation algorithm to better handle more intense non-IID data distributions across clients, where the proximal regularization term can stabilize local training under high statistical heterogeneity. R EFERENCES [1] J. Ayeelyan, S. Utomo, A. Rouniyar, H.-C. Hsu, and P.-A. Hsiung, “Federated learning design and functional models: Survey,” Artificial Intelligence Review, vol. 58, no. 1, p. 21, 2024. [2] A. Jung, “Federated learning: From theory to practice,” arXiv preprint arXiv:2505.19183, 2025. [3] Y. Zuo, B. Cox, L. Y. Chen, and J. Decouchant, “Spyker: Asynchronous multi-server federated learning for geo-distributed clients,” in Proceedings of the 25th International Middleware Conference, 2024, pp. 367– 378. [4] O. Wehbi, S. Arisdakessian, O. A. Wahab, H. Otrok, S. Otoum, and A. Mourad, “Towards bilateral client selection in federated learning using matching game theory,” in GLOBECOM 2022-2022 IEEE Global Communications Conference. IEEE, 2022, pp. 01–06. [5] N. Hudson, V. Hayot-Sasson, Y. Babuji, M. Baughman, J. G. Pauloski, R. Chard, I. Foster, and K. Chard, “Flight: A faas-based framework for complex and hierarchical federated learning,” Future Generation Computer Systems, p. 107998, 2025. [6] S. S. Yellampalli, M. Chalupa, J. Wang, H. J. Song, X. Zhang, H. Yue, and M. Pan, “Client selection in federated learning: A dynamic matching-based incentive mechanism,” in 2024 International Conference on Computing, Networking and Communications (ICNC). IEEE Computer Society, 2024, pp. 989–993.

17

[7] K. Donahue and J. Kleinberg, “Optimality and stability in federated learning: A game-theoretic approach,” Advances in Neural Information Processing Systems, vol. 34, pp. 1287–1298, 2021. [8] M. Bichler, Market design: a linear programming approach to auctions and matching. Cambridge University Press, 2017. [9] G. Haeringer, Market design: auctions and matching. MIT Press, 2018. [10] R. Gupta and J. Gupta, “Federated learning using game strategies: Stateof-the-art and future trends,” Computer Networks, vol. 225, p. 109650, 2023. [11] A. Ali, I. Ilahi, A. Qayyum, I. Mohammed, A. Al-Fuqaha, and J. Qadir, “A systematic review of federated learning incentive mechanisms and associated security challenges,” Computer Science Review, vol. 50, p. 100593, 2023. [12] T. Song, Y. Tong, and S. Wei, “Profit allocation for federated learning,” in 2019 IEEE International Conference on Big Data (Big Data). IEEE, 2019, pp. 2577–2586. [13] Z. Batool, K. Zhang, and M. Toews, “Block-racs: Towards reputationaware client selection and monetization mechanism for federated learning,” ACM SIGAPP Applied Computing Review, vol. 23, no. 3, pp. 49– 65, 2023. [14] X. Wei, J. Liu, X. Shi, and Y. Wang, “Participant selection for hierarchical federated learning in edge clouds,” in 2022 IEEE International Conference on Networking, Architecture and Storage (NAS). IEEE, 2022, pp. 1–8. [15] A. Abdulkadiroğlu and T. Sönmez, “School choice: A mechanism design approach,” American economic review, vol. 93, no. 3, pp. 729–747, 2003. [16] B. Doğan and L. Ehlers, “Robust minimal instability of the top trading cycles mechanism,” American Economic Journal: Microeconomics, vol. 14, no. 4, pp. 556–582, 2022. [17] R. W. Irving, P. Leather, and D. Gusfield, “An efficient algorithm for the “optimal” stable marriage,” Journal of the ACM (JACM), vol. 34, no. 3, pp. 532–543, 1987. [18] J. Li, T. Chen, and S. Teng, “A comprehensive survey on client selection strategies in federated learning,” Computer Networks, vol. 251, p. 110663, 2024. [19] Y. Shi, Z. Liu, Z. Shi, and H. Yu, “Fairness-aware client selection for federated learning,” in 2023 IEEE international conference on multimedia and expo (ICME). IEEE, 2023, pp. 324–329. [20] O. Marnissi, H. E. Hammouti, and E. H. Bergou, “Client selection in federated learning based on gradients importance,” in AIP Conference Proceedings, vol. 3034, no. 1. AIP Publishing LLC, 2024, p. 100005. [21] R. Albelaihi, A. Alasandagutti, L. Yu, J. Yao, and X. Sun, “Deep-reinforcement-learning-assisted client selection in nonorthogonalmultiple-access-based federated learning,” IEEE Internet of Things Journal, vol. 10, no. 17, pp. 15 515–15 525, 2023. [22] O. Wehbi, O. A. Wahab, A. Mourad, H. Otrok, H. Alkhzaimi, and M. Guizani, “Towards mutual trust-based matching for federated learning client selection,” in 2023 International Wireless Communications and Mobile Computing (IWCMC). IEEE, 2023, pp. 1112–1117. [23] Z. Qu, R. Duan, L. Chen, J. Xu, Z. Lu, and Y. Liu, “Context-aware online client selection for hierarchical federated learning,” IEEE Transactions on Parallel and Distributed Systems, vol. 33, no. 12, pp. 4353–4367, 2022. [24] A. K. Nair, S. Coleri, J. Sahoo, L. R. Cenkeramaddi, and E. D. Raj, “Incentivized federated learning: A survey,” IEEE Transactions on Emerging Topics in Computational Intelligence, 2025. [25] X. Chen, X. Zhou, S. Zhang, and M. Sun, “Dualgfl: Federated learning with a dual-level coalition-auction game,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 39, no. 15, 2025, pp. 15 904– 15 912. [26] M. Diamanti, A. B. Rahman, P. Charatsaris, E. E. Tsiropoulou, and S. Papavassiliou, “Resource allocation and pricing for multi-server multi-model federated learning based on market equilibrium,” Future Generation Computer Systems, p. 108055, 2025. [27] J. Tang, J. Nie, Y. Zhang, Z. Xiong, W. Jiang, and M. Guizani, “Multi-uav-assisted federated learning for energy-aware distributed edge training,” IEEE Transactions on Network and Service Management, vol. 21, no. 1, pp. 280–294, 2023. [28] M. S. HaghighiFard and S. Coleri, “Hierarchical federated learning in multi-hop cluster-based vanets,” IEEE Transactions on Vehicular Technology, 2025. [29] Z. Yang, S. Fu, W. Bao, D. Yuan, and A. Y. Zomaya, “Hierarchical federated learning with momentum acceleration in multi-tier networks,” IEEE Transactions on Parallel and Distributed Systems, vol. 34, no. 10, pp. 2629–2641, 2023.

[30] Z. Cai, J. Chen, Y. Fan, Z. Zheng, and K. Li, “Blockchain-empowered federated learning: Benefits, challenges, and solutions,” IEEE Transactions on Big Data, 2025. [31] H. Zhang, S. Jiang, and S. Xuan, “Decentralized federated learning based on blockchain: concepts, framework, and challenges,” Computer Communications, vol. 216, pp. 140–150, 2024. [32] M. M. Orabi, O. Emam, and H. Fahmy, “Adapting security and decentralized knowledge enhancement in federated learning using blockchain technology: literature review,” Journal of Big Data, vol. 12, no. 1, p. 55, 2025. [33] B. Wu and O. Seneviratne, “Blockchain-based framework for scalable and incentivized federated learning,” in Companion Proceedings of the ACM on Web Conference 2025, 2025, pp. 1761–1767. [34] H. Kasyap, A. Manna, and S. Tripathy, “An efficient blockchain assisted reputation aware decentralized federated learning framework,” IEEE Transactions on Network and Service Management, vol. 20, no. 3, pp. 2771–2782, 2022. [35] N. T. Cam and V. T. Kiet, “Flwrbc: Incentive mechanism design for federated learning by using blockchain,” IEEE Access, vol. 11, pp. 107 855–107 866, 2023. [36] B. Wang, Z. Tian, X. Liu, Y. Xia, W. She, and W. Liu, “A multi-center federated learning mechanism based on consortium blockchain for data secure sharing,” Knowledge-Based Systems, vol. 310, p. 112962, 2025. [37] L. Liu, J. Zhang, S. Song, and K. B. Letaief, “Client-edge-cloud hierarchical federated learning,” in ICC 2020-2020 IEEE international conference on communications (ICC). IEEE, 2020, pp. 1–6. [38] J. Werth, M. H. Berenjestanaki, H. R. Barzegar, N. El Ioini, and C. Pahl, “A review of blockchain platforms based on the scalability, security and decentralization trilemma.” ICEIS (1), pp. 146–155, 2023. [39] S. S. Ghazi and H. Amintoosi, “Improved trustchain for lightweight devices,” in 2022 12th International Conference on Computer and Knowledge Engineering (ICCKE). IEEE, 2022, pp. 085–091. [40] S. S. Ghazi, H. Amintoosi, and S. P. Moakhar, “On the suitability of improved trustchain for smartphones.” ISeCure, vol. 14, no. 3, 2022. [41] ethpandaops contributors, “Kurtosis github page,” https://github.com/eth pandaops/ethereum-package, 2026, accessed: 2026-02-03. [42] Alex Krizhevsky, “Cifar-10 dataset,” https://www.cs.toronto.edu/∼kriz/ cifar.html, 2026, accessed: 2026-02-15. [43] H. Xiao, K. Rasul, and R. Vollgraf, “Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms,” arXiv preprint arXiv:1708.07747, 2017. [44] A. E. Roth, “Deferred acceptance algorithms: History, theory, practice, and open questions,” international Journal of game Theory, vol. 36, no. 3-4, pp. 537–569, 2008. [45] P. Harless, “A school choice compromise: between immediate and deferred acceptance,” 2014. [46] GAVIN WOOD, “Ethereum: A secure decentralised generalised transaction ledger shanghai version,” https://ethereum.github.io/yellowpaper /paper.pdf, 2025, accessed: 2026-02-15.

18

A PPENDIX TTC S TEP - BY-S TEP E XAMPLE To demonstrate the algorithm’s steps, we will outline its procedure using an example. Consider five individuals, Alice, Bob, John, Lisa, and Suzanne, and five objects, A, B, C, D and E. Table III gives the preferences of the individuals over those objects and vice versa. Table III Objects’ and agents’ preferences and priorities [9] PAlice B E D C A PA Alice John Bob Suzanne Lisa

PBob C A D E B PB Bob Lisa Suzanne Alice John

PJohn A E D B C PC John Suzanne Bob Lisa Alice

PLisa C A E B D

PSuzanne A C B D E

PD Lisa Suzanne Alice John Bob

Bob

Lisa

B

C

Alice

John

A

D

Suzanne

Figure 10: First step of TTC

Lisa

E

D

Suzanne

PE Bob Suzanne Alice John Lisa

Step 1: For each individual, we create an arrow pointing to their most preferred object (for instance, Alice points to B, Bob to C, and John to A). Likewise, for every object we draw an arrow toward the individual with the highest priority for that object (e.g., object D points to Lisa, who holds the highest priority). From this, we can identify a cycle consisting of the solid arrows: (Alice, B; Bob, C; John, A). Arrows not included in any cycle are shown as dashed lines. All individuals and objects that are part of the cycle are immediately matched and removed from the system. Hence, the assignments at this stage are: µ(Alice) = B, µ(Bob) = C, µ(John) = A. The resulting graph is shown in Figure 10. E

Step 2: At this point, two individuals (Lisa and Suzanne) and two objects (D and E) remain. We now draw an arrow from each individual to her most preferred object among the remaining ones. Similarly, each object points to the individual with the highest priority between Lisa and Suzanne. Thus, object D points to Lisa, and object E points to Suzanne. There is a new cycle, so Lisa and Suzanne are assigned to the object they are pointing to, and since there is no individual who is left in the problem, the algorithm stops. The final assignment is: µ(Alice) = B, µ(Bob) = C, µ(John) = A, µ(Lisa) = E, µ(Suzanne) = D. The corresponding graph is given in Figure 11.

Figure 11: Second step of TTC