Resilience is the ability of a (distributed) system to withstand any stressful situation without imposing massive restrictions and, above all, without long-term consequences. Permissioned distributed ledgers based on state machine replication (SMR) offer a promising approach to achieving high resilience and fairness in federated systems. SMR provides a fault-tolerant service for clients by relying on all replicas being in a consistent state. The consistent state is achieved through a consensus algorithm, typically an atomic broadcast, that decides on a total order of client requests. In the Byzantine fault model, replicas are assumed to be potentially malicious; a Byzantine fault-tolerant (BFT) protocol withstands a fixed share of malicious actors. Classic BFT SMR protocols require $n>3t$ replicas and multiple rounds of communication to withstand $t$ faulty replicas, making the implementation complex and limiting achievable throughput and increasing latency. Trusted Execution Environments (TEEs) allow to implement SMR in the so-called hybrid fault model in which replicas are assumed to be potentially Byzantine but the TEE is restricted to only fail by crashing. In the hybrid fault model, SMR requires less communication and can be implemented with a fault tolerance of $n>2t$ replicas. While many proposals aim to optimize BFT SMR by using TEEs, they still rely on a so-called leader that coordinates the agreement process among the replicas. The leader is known to be a bottleneck and, if it fails, the system has to recover from the failure and elect a new leader. The additional coordination required to elect a new leader can cause significant performance degradation, limiting the achieved resilience. Asynchronous protocols based on directed acyclic graphs (DAGs) eliminate the reliance on distinguished replicas by allowing all replicas to participate equally in the agreement process. While asynchronous approaches and the hybrid fault model independently contribute to increasing the resilience of BFT SMR systems, their combination has largely been unexplored. This dissertation aims to fill this gap by answering the following research question: What is the achievable performance and resilience of DAG-based, hybrid fault-tolerant state machine replication and under which preconditions can the leaderless nature be safely exploited to maximize throughput? We proceed in three steps to enhance the resilience and performance of BFT SMR systems and to identify potential trade-offs that arise from the assumption of TEEs and asynchrony in BFT SMR. First, we investigate the fit of TEE-based SMR for consortium-operated applications using the example of Mobility-as-a-Service ticketing systems. We propose an SMR application that uses TEEs to protect sensitive customer and mobility provider data while limiting possibilities for fraud by both customers and mobility providers, and ensuring correct billing. We find that as long as secure multiparty computation is not competitive in terms of performance, TEE-based SMR can provide significant advantages in terms of efficiency and resilience while providing reasonable confidentiality guarantees. We describe the characteristics of the Mobility-as-a-Service use case and identify similar use cases from other domains, e.g., central bank digital currencies, allowing us to conclude that our findings generalize. In the second step, we establish the foundation for a comprehensive analysis by proposing and proving TEE-Rider, the first hybrid fault-tolerant, asynchronous, and DAG-based atomic broadcast protocol. TEE-Rider builds upon the DAG-Rider protocol family and an optimized, DAG-aware, and TEE-based causal order broadcast we propose and prove. We then identify fundamental issues that arise from the combination of TEEs and asynchrony in BFT SMR. These are the impossibility of a fault-tolerant setup and the impossibility of garbage collection. Furthermore, we prove that for partially synchronous, TEE-based reliable broadcast it is impossible to reinitialize a TEE after a crash without relying on the participation of all $n$ replicas. We conclude the theoretical contributions with the proposal of the NxBFT SMR framework. Following an assumption-algorithm co-design, NxBFT is built upon TEE-Rider for the "Not eXactly Byzantine" (NxB) operating model to maximize throughput without sacrificing resilience. Moreover, NxBFT leverages SMR state transfer to circumvent the limitations imposed by TEEs and asynchrony and provides, under the assumption of partial synchrony, garbage collection, recovery, and reconfiguration. Finally, we contribute an extensive empirical evaluation. To this end, we develop the ABCperf evaluation framework focusing on the fair and straightforward comparison of fault-tolerant SMR and agreement protocols. We investigate the performance characteristics of NxBFT and find that cryptographic operations for signature creation and verification are the main bottleneck. We compare the performance of NxBFT with the state-of-the-art leader-based, hybrid fault-tolerant protocols MinBFT and Chained-Damysus and investigate the impact of the SMR client model (BFT vs. NxB), payload sizes, network sizes, network latencies, and crash faults. While all algorithms can benefit from the NxB client model, NxBFT achieves the highest throughput in all scenarios with up to $\sim500\,000$ requests per second. All algorithms show an improvement of the end-to-end latency when using the BFT instead of the NxB client model. When small latencies are required, MinBFT and Damysus are at an advantage with Damysus showing competitive throughput and impressively low latencies for small deployments. In contrast to leader-based approaches, NxBFT's performance is almost not impacted when actual crash faults occur.
Proof-of-stake networks implement incentive-compatible transaction verification by requiring validators to post collateral, or stake, that can be forfeited upon failure. While the resilience of these networks rests on decentralization, validation activity is increasingly delegated to few professional operators. Motivated by the September 2025 Kiln security incident, where professional-but not solo-validators experienced a sharp decline in effectiveness, we develop a model of delegated validation. Delegation expands access by pooling collateral and lowering the operational burden borne by individual validators, and can improve efficiency through professional expertise and scale. At the same time, delegated validation concentrates operational infrastructure, increasing exposure to common shocks. The protocol therefore faces a tradeoff: tighter collateral requirements strengthen discipline, but can shift activity toward intermediated providers, raising concentration and correlated losses in stress states. Liquid staking tokens amplify this tradeoff by adding private liquidity and collateral-use benefits to delegation, and can move the system from a low-delegation equilibrium to a self-sustaining high-delegation equilibrium. Anti-correlation penalties mitigate this force by pricing correlated failures more directly and can reduce reliance on high collateral requirements.
This article examines the limitations of existing hybrid rollup solutions and presents an adaptive L2 architecture model that leverages artificial intelligence mechanisms. It is shown that current approaches to combining optimistic and ZK verification are largely based on static rules or manual mode selection, which prevents them from effectively accounting for load dynamics, risk profiles, and domain-specific properties of applications. Based on an analysis of optimistic, ZK, and hybrid rollups, an adaptive hybrid rollup model with AI-based transaction routing is proposed. This model combines transaction classification, GNN-based decision making, LSTM-based network condition forecasting, a dual-path execution system, and a continuous learning module. The article describes a Predictive Routing Algorithm that performs proactive selection between ZK and optimistic paths, taking into account cost, latency, security, and risk profile, as well as a Dynamic Resources Allocation mechanism that dynamically redistributes resources between the paths. The proposed multi-criteria optimization framework demonstrates the ability to tune objective weights to the specifics of different classes of DeFi and Web3 protocols. It is shown that the implementation of such a model is promising for systems with high transactional intensity, as it enables a shift from manual configurations to automated, data-driven policies for resource and risk management in hybrid rollup architectures.
Current commercial Large Language Model (LLM) architectures enforce a "server-side memory" paradigm, where user cognitive state is stored, managed, and monetized by the provider. This centralization creates two critical vulnerabilities: the economic inefficiency of "token inflation" (re-processing redundant context) and the epistemological risk of "rented cognition" (lack of user sovereignty over identity). This paper proposes a disruptive architectural shift: Remember Me AI, formally defined as the Client-Side Narrative Protocol (CSNP). By integrating Cross-Session Narrative Memory (CSNM) with a novel Semantic Compression Layer and Distributed Local Storage, we demonstrate a mechanism to reduce context token costs by approximately 40x while maintaining longitudinal coherence. We argue that this architecture commoditizes the inference layer, forcing a market transition from "Memory-as-a-Service" to "Compute-as-a-Commodity." This restores epistemological sovereignty to the user and neutralizes the lock-in mechanisms of hyperscale providers. The protocol includes Merkle-CRDT synchronization for multi-device consistency, Zero-Knowledge Safety Proofs for regulatory compliance, and a Polyglot Transpiler to ensure interoperability across proprietary model endpoints.
Dec 23, 2025·Proceedings of the ... Annual Hawaii International Conference on System Sciences/Proceedings of the Annual Hawaii International Conference on System Sciences
Oliver Alexy, Oliver Baumann, Ying-Ying Hsieh, Giorgia Sampó
Decentralized Autonomous Organizations (DAOs) represent a radical form of socio-technical systems, where rules are enforced by code and governance is conducted by a distributed network of stakeholders. A critical challenge in designing these systems is achieving consensus without centralized authority, yet how consensus ensures effective governance remains underexplored. This study investigates the design of DAO governance systems, utilizing data from 70 DAOs and applying Fuzzy Set Qualitative Comparative Analysis (fsQCA) to explore which consensus configurations lead to positive organizational outcomes. Our analysis challenges the notion of a single consensus model. Instead, we uncover 13 distinct configurations that characterize successful DAOs. Our key finding reveals a fundamental “ideation-legitimation trade-off”: successful DAOs optimize for broad participation in either the proposal (ideation) stage or the voting (legitimation) stage, but rarely both. These insights provide a nuanced framework for understanding and designing effective governance systems for DAOs.
Smart contracts are high-stakes software: their immutable, publicly accessible code may govern assets worth millions. This means that even minor defects can have severe consequences. Unit tests often miss edge cases. Although formal verification is the only route to full correctness, it demands substantial time and expertise. Property-based testing bridges this gap by exploring large input spaces and shrinking failures to minimal counterexamples. Used early, it filters defects and prioritises verification effort on code already validated by tests. Although Solidity benefits from a mature testing ecosystem, comparable support for other languages such as Daml remains limited. This dissertation addresses this gap by introducing Hypothesis2Daml, an open-source library that brings property-based testing to Damlby connecting Hypothesis withthe Daml JSON API. Hypothesis2Daml enables developers to specify invariants, pre/postconditions, and stateful workflows over realistic ledger interactions. It provides automatic input generation, shrinking to minimal counterexamples, party isolation per example, and request helpers that keep tests focused on properties rather than HTTP/JSON wiring. The approach is validated on a benchmark of eight contracts and twenty-seven properties that range from simple invariants to multi-step, role-sensitive workflows. All properties held under testing, with runs completing within practical time bounds, demonstrating that property-based testing is feasible and effective for Daml applications. A comparative evaluation situates Hypothesis2Daml among established tools and methods, highlighting strengths in usability and expressiveness, and acknowledging a throughput trade-off due to JSON-API transport overhead. Contributions include the Hypothesis2Daml library and a reusable benchmark with representative properties. Limitations concern transport overhead, ecosystem specificity, and dependence on developer-authored properties and generators. Future work targets automation, performance, andscope expansion. Together, these results establish a practical path for making property-based testing a routine part of building Daml applications.
Vikash Singh, Little, Barrett, Phil Hayes, Fang, Max · 7 authors
Verifying the private liquidity state of Lightning Network (LN) channels is desirable for auditors, service providers, and network participants who need assurance of financial capacity. Current methods often lack robustness against a malicious or compromised node operator. This paper introduces a methodology for the verification of LN channel balances. The core contribution is a framework that combines Trusted Execution Environments (TEEs) with Zero-Knowledge Transport Layer Security (zkTLS) to provide strong, hardware-backed guarantees. In our proposed method, the node's balance-reporting software runs within a TEE, which generates a remote attestation quote proving the software's integrity. This attestation is then served via an Application Programming Interface (API), and zkTLS is used to prove the authenticity of its delivery. We also analyze an alternative variant where the TEE signs the report directly without zkTLS, discussing the trade-offs between transport-layer verification and direct enclave signing. We further refine this by distinguishing between "Hot Proofs" (verifiable claims via TEEs) and "Cold Proofs" (on-chain settlement), and discuss critical security considerations including hardware vulnerabilities, privacy leakage to third-party APIs, and the performance overhead of enclaved operations.
Traditional zero trust architectures (ZTA) rely on centralized policy engines and mutable audit logs, creating single points of failure and limiting forensic integrity. We present a novel blockchain-secured zero trust network architecture that integrates distributed ledger technology, machine learning-based threat detection, and zero-knowledge proof authentication to eliminate the se limitations. Our five-layer framework comprises a user access layer, a zero-trust core (policy engine, administrator, and enforcement points), a blockchain security layer (smart con- tracts, consensus engine, and audit trail), a decentralized identity layer (W3CDIDs and zero-knowledge proof authentication), and protected network resources. Access requests are validated via zero-knowledge proofs; trust scores are computed dynamically using Random Forest classifiers achieving 96.3% accuracy; policy decisions are executed through Practical Byzantine Fault Tolerance (PBFT) consensus; and all security events are recorded immutably on Hyperledger Fabric. Smart contracts create automated incident response, which isolates malicious parties in less than 500 ms without human interference. Experiments on a 50-node testbed during simulated attacks show an authentication latency of < 100 ms, a throughput of > 1,000transactions per second (TPS), a threat-detection accuracy of > 95%, and a false-positive rate of < 5%. Our solution reduces the latency by 30% and the operating overhead by 60% and offers 100% integrity of the audit trail compared to traditional zero-trust implementations. This publication represents the first end-to-end integration of blockchain and zero-trust systems, providing a privacy-preserving, scalable, and resilient security architecture for enterprise environments and next-generation networks.
Keybyte Systems, Intentix Lab , Melbourne, Australiapronab@keybytesystems.com.au Supported by AusIndustry Grant IR2405165 __________________________________AbstractModern cloud-native applications distribute business logic across multiple layers: application code, orchestration frameworks, service meshes, and infrastructure configurations. This distribution creates ”hidden logic”—execution rules embedded in infrastructure that are invisible during design and difficult to trace at runtime. We present Intention Space , a computing model built on the CPUX (Common Path of Understanding and Execution) paradigm that consolidates all business logic into explicit, design-time declarations using plain-language state pulses. In our model, Design Nodes (DNs) contain computation while Gatekeepers declare execution conditions as named pulses (e.g., ”payment validated”: Y). The infrastructure provides only mechanical enforcement through an Intention Loop that matches runtime state to Gatekeepers without adding decision logic. We demonstrate that complex workflows—traditionally requiring nested if-then branching and explicit loops—can be expressed as linear CPUX sequences where execution paths emerge from data state rather than code branching. Our Golang implementation shows complete elimination of orchestration code while maintaining full cognitive traceability. Beyond technical innovation, CPUX addresses a critical social computing crisis: the lack of accountability in distributed social platforms. By creating unique, device-level CPUX footprints for every interaction, our model enables verifiable traceability from device identity through user intention to executed action—restoring accountability to social computing while preserving privacy. We argue this separation of intent (CPUX) from enforcement (infrastructure) is essential for building LLM-integrated, auditable, and socially responsible distributed systems.Keywords: CPUX, Intention Space, Design Nodes, Cognitive Computing, Data-Driven Execution, Microservices Architecture, Cloud Computing, LLM Integration, Social Computing Accountability__________________________________1. Introduction1.1 The Hidden Logic ProblemConsider a typical e-commerce order processing system deployed on Kubernetes with Istio service mesh:// order-service/main.go (Business Logic Layer) func ProcessOrder(order Order) error { if order.Amount > 1000 { if err := premiumValidator.Validate(order); err != nil { return retry(premiumValidator.Validate, 3, order) } } else { standardValidator.Validate(order) } // … more branching logic }# k8s/hpa.yaml (Infrastructure Layer) spec: metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 80 # Hidden rule: Scale when CPU > 80%# istio/retry-policy.yaml (Service Mesh Layer) spec: http: - retries: attempts: 3 perTryTimeout: 2s # Hidden rule: Retry 3 times on failureQuestion: What is the complete execution flow for a $1500 order that fails validation on first attempt?Answer: One must read and correlate:Application code (branching logic)Kubernetes manifests (scaling rules)Istio configurations (retry policies)Service mesh observability logs (runtime behavior)This hidden logic distribution creates fundamental problems:Traceability : No single artifact shows complete flowTestability : Must test infrastructure + code interactionsAuditability : Business stakeholders cannot validate logicMaintainability : Changes require coordinating multiple layersLLM Integration : No structured representation for AI reasoningSocial Accountability : Cannot trace interactions to source devices/users1.2 The Core InsightWe observe that traditional computing conflates two distinct concerns:What should happen(business intent)How to make it happen(mechanical execution)Current architectures intertwine these concerns across code, configuration, and infrastructure, making systems cognitively opaque.Our Contribution: We introduce CPUX (Common Path of Understanding and Execution) , a paradigm that separates business intent from infrastructure enforcement:CPUX Structure : Declares all possible execution paths as sequences of Design Nodes (DNs) with plain-language Gatekeeper conditionsInfrastructure : Provides mechanical execution (Intention Loop) that enforces CPUX declarations without adding decision logicDevice-Level Identity : Each CPUX execution tied to unique device fingerprint + user intention, enabling social computing accountabilityResult : Complete business logic is visible in CPUX; infrastructure remains purely mechanical; every social interaction is traceable1.3 Key ContributionsFormal Model : CPUX as cognitive execution contract with Design Nodes, Intentions, Objects, and Pulses as primitive componentsElimination of Hidden Logic : All business decisions visible in design-time CPUX declarations; infrastructure adds zero decision logicPlain-Language State Declarations : Execution conditions expressed as named pulses (e.g., ”inventory confirmed”: Y) enabling business stakeholder review and LLM integrationData-Driven Execution : Runtime branching eliminated from code; execution paths emerge from pulse state matching via SyncTestSocial Computing Accountability : Device-level CPUX fingerprints create unique, traceable identity for every social interaction, addressing the accountability crisis in platforms like Facebook, Twitter, TikTokImplementation & Evaluation : Golang framework code sample with concrete use case demonstrating zero orchestration code while maintaining full traceability1.4 Paper OrganizationSection 2 examines related work. Section 3 presents the PnR computing model and CPUX formalism. Section 4 details the architecture and implementation. Section 5 evaluates our approach through metrics and case studies. Section 6 discusses LLM integration. Section 7 introduces CPUX for social computing accountability—the urgent global need. Section 8 concludes with future directions.__________________________________2. Related Work2.1 Workflow Orchestration SystemsAWS Step Functions [1] and Azure Logic Apps [2] provide visual workflow definition with explicit state machines. However, they:Use proprietary JSON/XML DSLs (not plain language)Embed conditional logic in workflow definitions (still branching)Remain platform-specific (vendor lock-in)Require reading workflow definitions to understand flowCannot trace to device/user identityApache Airflow [3] and Temporal [4] define workflows as code with DAG structures. They improve on step functions ,recoverability but:Business logic still in code (if-then branches)Workflow orchestration separate from executionNo plain-language condition declarationsNo device-level traceabilityCPUX Advantage : All logic in plain-language pulses, platform-agnostic, no explicit branching in declarations, device-level identity for every execution, recoverability built into platform. 2.2 Service Mesh & OrchestrationIstio [5] and Linkerd [6] provide traffic management, retries, circuit breaking. Kubernetes Operators [7] encode reconciliation logic. These systems:Hide business rules in YAML configurationsDistribute logic across mesh config + operator codeFocus on infrastructure concerns (not business flow)Lack unified view of complete execution pathNo user/device attributionCPUX Advantage : Consolidates all execution logic in CPUX; infrastructure config aligned with business intent; device identity integral.2.3 Event-Driven ArchitecturesApache Kafka [8], AWS EventBridge [9] enable event-driven systems with loose coupling. Reactive systems [10] promote message-passing. However:Event flows implicit (must trace message paths)Conditional logic in event handlers (code-level branching)No design-time declaration of all possible flowsNo provenance tracking to source deviceCPUX Advantage : Explicit declaration of all event-driven paths as DN sequences with visible Gatekeepers; device identity in event provenance.2.4 Intent-Based SystemsIntent-Based Networking [11] translates high-level intents to network configurations. Policy-based management [12] separates policy from mechanism. Closest to our work, but:Focus on infrastructure (not application logic)Policies often domain-specific (not general computing)Limited plain-language expressivenessNo user accountabilityCPUX Advantage : General-purpose computing model with full plain-language pulse declarations applicable to any domain; device-level user accountability.2.5 Formal Methods & Model CheckingTLA+ [13], Alloy [14], and Petri Nets [15] enable formal specification and verification. These are powerful but:Require specialized formal notation (high learning curve)Specification separate from implementation (sync problems)Not designed for runtime executionNo social computing traceabilityCPUX Advantage : Declarations are executable; CPUX structure IS the implementation contract; device identity embedded.2.6 Social Computing & AccountabilityBlockchain-based identity [16] and zero-knowledge proofs [17] address digital identity but:Focus on cryptographic primitives (not execution tracing)Don’t integrate with application logicNo cognitive representation of intentFederated social networks [18] (Mastodon, ActivityPub) improve decentralization but:Still lack device-level traceabilityNo structured intent representationCannot prove user intended specific actionCPUX Advantage : First system to integrate device identity, user intention, and execution trace in single cognitive framework.2.7 PositioningCPUX is the first system to combine:Plain-language execution conditions (like Intent-Based Networking)Executable specifications (unlike formal methods)Complete flow visibility (unlike distributed orchestration)Zero hidden infrastructure logic (unique contribution)Device-level social accountability (unique contribution)__________________________________3. The PnR Computing Model3.1 Core Abstractions3.1.1 Pulse: Atomic State UnitA Pulse is the fundamental data unit representing a named state with optional response and trivalence:Pulse = (Name: String, Response: Value, Trivalence: {Y, N, U})Name : Plain-language identifier (e.g., ”payment validated”)Response : Optional value (e.g., transaction ID)Trivalence : Y (yes/true), N (no/false), U (undecided)
N. A. Natraj, J. Midhunchakkaravarthy, Brojo Kishore Mishra
INTRODUCTION: The application of blockchain technology to Internet of Things (IoT) systems offers substantial potential for enhancing security, but traditional consensus mechanisms are ill-suited for resource-constrained environments. While hybrid consensus solutions have emerged as a promising alternative, a systematic framework for their classification and evaluation is notably absent. OBJECTIVES: This study addresses this critical gap by introducing a novel, application-driven framework for analyzing hybrid consensus mechanisms, underpinned by a quantitative synthesis of performance benchmarks. METHODS: We analyze diverse architectures—including combinations of Proof of Work (PoW) and Proof of Stake (PoS), PBFT-enhanced systems, and hierarchical models—through the lens of specific IoT application priorities, such as latency, energy efficiency, and scalability. Case studies of IOTA's Tangle, IoTeX's Roll-DPoS, and Hyperledger Fabric illustrate these practical trade-offs. RESULTS: Our framework reveals not only primary performance trade-offs but also critical "second-order" complexities, such as emergent vulnerabilities at the intersection of different consensus layers. CONCLUSION: Our findings demonstrate that this structured, quantitatively-grounded approach provides an effective methodology for designing and selecting regulatory-compliant hybrid consensus solutions for specific IoT applications.
Rene Casanova (22631729), Fernan A. Villa-Garzon (22631732), John W. Branch-Bedoya (13936272)
Background Health information systems (HIS) are critical for digital health transformation, yet fragmentation and poor interoperability adoption remains a major challenge. Objectives This study systematically reviews architectural patterns used in HIS and evaluates their alignment with ecosystem-level requirements. Methods Following PRISMA 2020 guidelines, a systematic literature review was conducted across Scopus, IEEE Xplore, PubMed, and Web of Science (2020–2025). Eligible studies described, evaluated, or proposed HIS solutions. Results From an initial set of 304 records, 89 met the inclusion criteria. Service-based and decentralized/distributed ledger architectures were predominant, with emerging models integrating edge computing and modular design. FHIR-based contracts are found as stabilizers of interfaces, enabling validation and reducing integration costs. However, gaps persist in cross-border care, sustainability, and artificial intelligence integration. Conclusion While microservices dominate current HIS architectures, achieving resilient, interoperable ecosystems requires greater architectural diversity and intersectoral collaboration.
Verifiable network telemetry is crucial for ensuring transparency and trust in network measurements. However, telemetry logs (e.g., NetFlow records) often contain sensitive data, making public verification challenging. Recent work has attempted to address this problem using Trusted Execution Environments (TEEs), such as Intel SGX, to provide confidentiality and integrity guarantees. However, TEEs are known to suffer from complex deployment requirements and limited scalability. In this paper, we introduce a software-based approach utilizing the latest advances in Zero-knowledge Proofs (ZKPs) to enable verifiable network telemetry without revealing the underlying sensitive logs or relying on special-purpose hardware. Our system employs a general-purpose ZKP virtual machine (RISC Zero) to generate cryptographic proofs over NetFlow data, enabling operators to securely attest to network flow metrics. Our preliminary results indicate that our ZKP-based design offers a viable path toward overcoming deployment and scalability limitations inherent in the solutions that require special-purpose hardware.
Rene Casanova, Fernán A Villa-Garzón, John W. Branch
Background: Health information systems (HIS) are critical for digital health transformation, yet fragmentation and poor interoperability adoption remains a major challenge. Objectives: This study systematically reviews architectural patterns used in HIS and evaluates their alignment with ecosystem-level requirements. Methods: Following PRISMA 2020 guidelines, a systematic literature review was conducted across Scopus, IEEE Xplore, PubMed, and Web of Science (2020-2025). Eligible studies described, evaluated, or proposed HIS solutions. Results: From an initial set of 304 records, 89 met the inclusion criteria. Service-based and decentralized/distributed ledger architectures were predominant, with emerging models integrating edge computing and modular design. FHIR-based contracts are found as stabilizers of interfaces, enabling validation and reducing integration costs. However, gaps persist in cross-border care, sustainability, and artificial intelligence integration. Conclusion: While microservices dominate current HIS architectures, achieving resilient, interoperable ecosystems requires greater architectural diversity and intersectoral collaboration.
Abstract Distributed Software Define Network (DSDN) offers to eliminate the single point of failure present in the centralized SDN controller. The main concept is to have numerous controllers that can share the burden on the network, and one controller can take over another controller when it breaks. In this study, we work on an Opendaylight-based completely distributed system to deal with issues of the controller's central processing unit (CPU) consumption being uneven. Every controller administers its own domain therefore sharing the burden across the network's controllers. To update the flow rules and broadcast new rules to all the controllers at once, maintaining the consistency of the controller's rule set, we create an application ledger that maintains a distributed ledger. Results demonstrate that, in addition to ensuring the uniformity of inventory shards across all controllers in the system, our work presented an increase with throughput reaching 40% and the bandwidth of controller's communication is less with almost 31%.
The paradigm of enterprise analytics is undergoing a fundamental shift from centralized, reactive reporting to distributed, proactive intelligence. This review article evaluates the integration of machine learning models within SAP business intelligence frameworks operating across multi-cloud and hybrid environments. We analyze how the transition toward a federated data architecture, facilitated by SAP Datasphere, enables the deployment of high-performance neural networks without the traditional constraints of data replication. The study specifically examines the efficacy of Long Short-Term Memory units for temporal forecasting in SAP Integrated Business Planning and the role of unsupervised learning models in real-time financial anomaly detection. Furthermore, we explore the rise of augmented analytics and natural language processing in democratizing data access, alongside the operational necessity of MLOps to mitigate model drift in volatile global markets. The review also addresses critical technical and strategic barriers, including data latency across distributed cloud nodes, the harmonization of structured and unstructured data, and the evolving landscape of global data sovereignty. By synthesizing current performance benchmarks with future directions such as agentic intelligence and the integration of carbon accounting through the green ledger, this research provides a roadmap for architecting autonomous analytical ecosystems. We conclude that the convergence of machine learning and distributed cloud infrastructure is the primary catalyst for transforming raw enterprise data into a strategic, self-optimizing asset.
Software services are crucial for reliable communication and networking; therefore, Site Reliability Engineering (SRE) is important to ensure these systems stay reliable and perform well in cloud-native environments. SRE leverages tools like Prometheus and Grafana to monitor system metrics, defining critical Service Level Indicators (SLIs) and Service Level Objectives (SLOs) for maintaining high service standards. However, a significant challenge arises as many developers often lack in-depth understanding of these tools and the intricacies involved in defining appropriate SLIs and SLOs. To bridge this gap, we propose a novel SRE platform, called SRE-Llama, enhanced by Generative-AI, Federated Learning, Blockchain, and Non-Fungible Tokens (NFTs). This platform aims to automate and simplify the process of monitoring, SLI/SLO generation, and alert management, offering ease in accessibility and efficy for developers. The system operates by capturing metrics from cloud-native services and storing them in a time-series database, like Prometheus and Mimir. Utilizing this stored data, our platform employs Federated Learning models to identify the most relevant and impactful SLI metrics for different services and SLOs, addressing concerns around data privacy. Subsequently, fine-tuned Meta's Llama-3 LLM is adopted to intelligently generate SLIs, SLOs, error budgets, and associated alerting mechanisms based on these identified SLI metrics. A unique aspect of our platform is the encoding of generated SLIs and SLOs as NFT objects, which are then stored on a Blockchain. This feature provides immutable record-keeping and facilitates easy verification and auditing of the SRE metrics and objectives. The automation of the proposed platform is governed by the blockchain smart contracts. The proposed SRE-Llama platform prototype has been implemented with a use case featuring a customized Open5GS 5G Core.
This study presents a blockchain-backed Role-Based Access Control (RBAC) service for distributed clouds, addressing auditable authorization under multi-region latency and consistency constraints. Although end-to-end costs and tail impacts of permissioned ledgers in RBAC are under-quantified, the present study implements a multi-region deployment with Istanbul Byzantine Fault Tolerance (IBFT), batched commits, and an off-chain cache, with evaluation against centralized and event-sourced baselines, throughput reported in requests per second (RPS), and calibration via Expected Calibration Error (ECE) and Brier Score using multi-seed runs and moving-block bootstrap. At the target load, the candidate achieved 145.0 +/- 4.6 ms 95th percentile (p95) latency and 1008 +/- 13 RPS while meeting the 150.0 ms Service Level Objective at 1000 rps; the 99th percentile (p99) policy-update consistency lag measured 1750.0 +/- 150.0 ms. Connectivity remains the bottleneck. The parts are familiar; the sequencing is not, combining ledger finality with cache-assisted reads and bounded block intervals to narrow the gap to centralized designs under controlled failures. These findings indicate that tamper-evident auditing can be added with modest overhead for enterprise security operators planning multi-region cloud authorization.
Today's distributed payment systems must function correctly despite the inherent presence of asynchrony, partial failures, and third-party integrations. Unlike typical RPC-based workflows used in software development, payment flows are heavily influenced by external delays, retries, timeouts, and nondeterministic state changes across multiple systems of record. A fault-tolerant ledger abstraction that decouples payment intent from execution enables safe retries and supports service events that may arrive out of order. Correctness and safety depend on distributed transaction constructs such as outbox/inbox patterns, compensation workflows, and time-bounded state machines to contain the effects of race conditions, double submissions, and ambiguous or indeterminate outcomes. A declarative reconciliation framework continuously verifies consistency between internal and external systems, enabling real-time anomaly detection and facilitating orchestration and recovery. These pragmatic engineering approaches, validated through simulations and production-level benchmarks, offer guidance for building resilient payment infrastructures in naturally asynchronous and failure-prone environments.
Liang, Hanzhong, Yue Duan, Xing Su, Xiao Li · 8 authors
As the Web3 ecosystem evolves toward a multi-chain architecture, cross-chain bridges have become critical infrastructure for enabling interoperability between diverse blockchain networks. However, while connecting isolated blockchains, the lack of cross-chain transaction pairing records introduces significant challenges for security analysis like cross-chain fund tracing, advanced vulnerability detection, and transaction graph-based analysis. To address this gap, we introduce ConneX, an automated and general-purpose system designed to accurately identify corresponding transaction pairs across both ends of cross-chain bridges. Our system leverages Large Language Models (LLMs) to efficiently prune the semantic search space by identifying semantically plausible key information candidates within complex transaction records. Further, it deploys a novel examiner module that refines these candidates by validating them against transaction values, effectively addressing semantic ambiguities and identifying the correct semantics. Extensive evaluations on a dataset of about 500,000 transactions from five major bridge platforms demonstrate that ConneX achieves an average F1 score of 0.9746, surpassing baselines by at least 20.05\%, with good efficiency that reduces the semantic search space by several orders of magnitude (1e10 to less than 100). Moreover, its successful application in tracing illicit funds (including a cross-chain transfer worth $1 million) in real-world hacking incidents underscores its practical utility for enhancing cross-chain security and transparency.
In the evolving landscape of cybercrime and digital investigations, the integrity and traceability of digital evidence are paramount.Traditional chain-of-custody (CoC) mechanisms in digital forensics rely heavily on centralized systems, manual logging, and institutional trust, all of which are prone to human error, tampering, and data loss.This study introduces a blockchain-based chain-of-custody model aimed at ensuring immutable, transparent, and verifiable tracking of digital evidence across its entire lifecycle-from acquisition and analysis to presentation in court.Leveraging blockchain's decentralized architecture and cryptographic immutability, the proposed framework records every interaction with digital evidence, including transfers, access logs, and analysis events, in a tamper-proof ledger distributed across trusted nodes in a forensic network.Smart contracts automate procedural compliance, access permissions, and time-stamping, thereby reducing reliance on third-party oversight and enhancing procedural integrity.The system was designed and simulated using Hyperledger Fabric, integrating role-based access control and hash-based evidence fingerprinting.Benchmark testing demonstrated the model's robustness in preserving forensic timelines under various adversarial scenarios, including internal breaches and unauthorized access attempts.In addition to enhancing evidentiary credibility, this blockchain-enhanced CoC model offers interoperability with existing digital forensic tools and forensic readiness systems.By aligning with legal admissibility standards and ensuring end-to-end accountability, the framework strengthens the evidentiary chain, particularly in multi-jurisdictional and cloudbased investigations.As digital forensics faces increasing scrutiny regarding evidentiary handling, this research presents a scalable and future-proof alternative to conventional CoC practices-crucial for maintaining the rule of law in cybercrime prosecutions.
Carlos Cardoso, Caio Silva, Alan Veloso, Jeffson Sousa · 5 authors
As Distributed Ledger Technologies (DLTs) mature into production-grade systems, a critical gap emerges between protocol-level benchmarking and application-centric performance testing. While specialized tools like Hyperledger Caliper excel at measuring core on-chain metrics, they are less suited for evaluating the end-to-end performance of applications that interact with the DLT through an intermediary API layer. This paper addresses this gap by proposing a three-tier, API-driven framework that enables mature, general-purpose load testing tools, such as Apache JMeter, to realistically assess a Hyperledger Besu network’s performance from an application’s perspective. The core of our solution is a custom API server that provides essential services like atomic nonce management and dynamic load balancing. Our comparative analysis demonstrates that while Caliper may report higher end-to-end throughput under specific conditions, our framework induces a significantly more substantial and evenly distributed load, revealing a more accurate picture of the network’s true processing capacity. Furthermore, our approach captures API-layer latency—a crucial metric for client-perceived responsiveness—which proved to be an order of magnitude lower than the on-chain finality measured by Caliper. This work validates a reusable architectural pattern for testing DLTs within a realistic application stack, bridging the gap between protocol benchmarking and real-world performance engineering.
The growth of freelancing exposed several drawbacks in the platforms that are now in use, including high service costs, fraud risks, and late payments [1]. A well-designed system architecture is necessary to develop a freelance platform to guarantee scalability, security, and effectiveness. A modular architecture was chosen to give the required flexibility, scalability, and ease of maintenance to overcome these issues. This paper presents the design of a microservices-based architecture for a crypto freelance exchange platform, which uses Domain-Driven Design principles [2]. The architecture is built to support decentralized transactions, smart contract integration, and secure user authentication. It also ensures high availability and fault tolerance. The system uses a multi-layered architecture incorporating PostgreSQL, MongoDB, Redis, and Web3.js. The main components are a web application, KrakenD API Gateway, auth microservice, files microservice, and main microservice for managing transactions, orders, and payments. They are designed to meet critical non-functional requirements such as scalability, security, and maintainability. Each service can be independently deployed, updated, and scaled according to transaction volumes. With an emphasis on security, the platform uses JWT token techniques and multi-factor authentication to authenticate users. Also, the integration of blockchain technology enhances transparency, enabling freelancers and clients to have a trusted record of all transactions and reducing the risk of fraud. The architecture is visualized through UML and C4 model diagrams showing component interactions and service orchestration. This paper also discusses the rationale behind the chosen technologies, security mechanisms, and the benefits of using a modular microservices approach for building a crypto freelance platform.
Sharding has emerged as a critical solution to address the scalability challenges faced by blockchain networks, enabling them to achieve higher transaction throughput, reduced latency, and optimized resource usage. This paper investigates the advancements, methodologies, and adoption potential of sharding in the context of Hedera, a distributed ledger technology known for its unique Gossip about Gossip protocol and asynchronous Byzantine Fault Tolerance (ABFT). We explore various academic and industrial sharding techniques, emphasizing their benefits and trade-offs. Building on these insights, we propose a hybrid sharding solution for Hedera that partitions the network into local and global committees, facilitating efficient cross-shard transactions and ensuring robust security through dynamic reconfiguration. Our analysis highlights significant reductions in storage and communication overhead, improved scalability, and enhanced fault tolerance, demonstrating the feasibility and advantages of integrating sharding into Hedera's architecture.
Real-World Assets (RWAs) serve as a bridge between traditional financial instruments and decentralized infrastructures. By representing assets such as bonds, commodities, and real estate on blockchains, RWAs can extend the scope of decentralized finance. Industry forecasts further indicate rapid growth in tokenized RWAs after 2025, underscoring their potential role in the evolution of digital financial markets. However, in the current multi-chain environment, RWAs face challenges such as repeated authentication across multiple chains and inefficiencies arising from multi-step settlement protocols. To address these issues, we present a cross-chain framework for RWAs that emphasizes identity management, authentication, and cross-chain interaction. The framework integrates Decentralized Identifiers and Verifiable Credentials with customized attributes to support decentralized identification, and incorporates an authentication protocol based on Simplified Payment Verification to avoid redundant verification across chains. Furthermore, this paper adopts a cross-chain channel that supports efficient RWA settlements, and we refine its design so that the channel does not need to be closed immediately after each settlement, thereby reducing on-chain cost. We implement the framework and evaluate its performance via simulations, which confirm its feasibility and demonstrate improvements in efficiency for RWAs in cross-chain settings.