Truffle is a framework that provides compiling, testing and systematic project management for developing Ethereum decentralized applications. As of now, Truffle provides a way to easily deal with bundling node.js modules of decentralized application using the webpack tool. However, due to the Truffle project structure, server-side node.js modules such as network communication modules are not usable in a direct way. In this paper, to address this issue, we propose a method to use server-side node.js modules through Ethereum smart contracts and event processing mechanism. In the proposed method, a separate node application is associated to the server-side module to execute the module in response to the request of the decentralized application. To this end, we introduce the notion of function gateway, a smart contract for connecting two applications with Ethereum's event-watch processing technique. Also, to use the function gateway contract in a robust way, we introduce a robust function gateway that includes the process of confirming whether or not the event-watch has occurred and the node.js module function has been executed. In addition, we present a decentralized application using node.js module for sending actual e-mails based on the function gateway.
Suggested Citation: Jo, Gwangsik. (2026). DLT-DSA: Design and Verification of a Local Autonomous Integrity Verification Model Using Adaptive Verification Intensity. Zenodo. AbstractIn some distributed ledger systems, transaction verification requires consensus procedures and network synchronization, and previous studies have reported that verification overhead tends to scale with increasing request frequency. This paper proposes a lightweight architecture, DLT-DSA (Distributed Ledger Technology – Decentralized Sovereign Access), designed to reduce dependence on global consensus and to pre-determine request integrity at the node level. The model adopts a multi-stage local verification structure using a context-aware mechanism: normal requests undergo lightweight verification based on ROA (Reduced Overhead Access), while anomalous conditions trigger autonomous integrity verification based on SHV (Self-Hash Verification). Proof-of-Concept (PoC) experiments show that the execution time of the verification logic remains within a stable range independent of variations in network round-trip time (RTT) and exhibits deterministic resource utilization under varying load conditions. These observations suggest that partial relocation of verification procedures to local processing can serve as a viable design alternative in real-time response environments. For more information about the author's professional background and ongoing projects, please visit: LinkedIn: https://www.linkedin.com/in/gwangsik-jo-3295a43b5 ORCID: https://orcid.org/0009-0008-5702-8940
Multi-implementation systems are increasingly audited against natural-language specifications. Differential testing scales well when implementations disagree, but it provides little signal when all implementations converge on the same incorrect interpretation of an ambiguous requirement. We present SPECA, a Specification-to-Checklist Auditing framework that turns normative requirements into checklists, maps them to implementation locations, and supports cross-implementation reuse. We instantiate SPECA in an in-the-wild security audit contest for the Ethereum Fusaka upgrade, covering 11 production clients. Across 54 submissions, 17 were judged valid by the contest organizers. Cross-implementation checks account for 76.5 percent (13 of 17) of valid findings, suggesting that checklist-derived one-to-many reuse is a practical scaling mechanism in multi-implementation audits. To understand false positives, we manually coded the 37 invalid submissions and find that threat model misalignment explains 56.8 percent (21 of 37): reports that rely on assumptions about trust boundaries or scope that contradict the audit's rules. We detected no High or Medium findings in the V1 deployment; misses concentrated in specification details and implicit assumptions (57.1 percent), timing and concurrency issues (28.6 percent), and external library dependencies (14.3 percent). Our improved agent, evaluated against the ground truth of a competitive audit, achieved a strict recall of 27.3 percent on high-impact vulnerabilities, placing it in the top 4 percent of human auditors and outperforming 49 of 51 contestants on critical issues. These results, though from a single deployment, suggest that early, explicit threat modeling is essential for reducing false positives and focusing agentic auditing effort. The agent-driven process enables expert validation and submission in about 40 minutes on average.
Shubham Mishra, João Gonçalves, Chawinphat Tankuranand, Neil Giridharan · 7 authors
Distributed ledgers are increasingly relied upon by industry to provide trustworthy accountability, strong integrity protection, and high availability for critical data without centralizing trust. Recently, distributed append-only logs are opting for a layered approach, combining crash-fault-tolerant (CFT) consensus with hardware-based Trusted Execution Environments (TEEs) for greater resiliency. Unfortunately, hardware TEEs can be subject to (rare) attacks, undermining the very guarantees that distributed ledgers are carefully designed to achieve. In response, we present Proteus, a new distributed consensus protocol that cautiously trusts the guarantees of TEEs. Proteus carefully embeds a Byzantine fault-tolerant (BFT) protocol inside of a CFT protocol with no additional messages. This is made possible through careful refactoring of both the CFT and BFT protocols such that their structure aligns. Proteus achieves performance in line with regular TEE-enabled consensus protocols, while guaranteeing integrity in the face of TEE platform compromises.
Blockchain clients are fundamental software for running blockchain nodes. They provide users with various RPC (Remote Procedure Call) interfaces to interact with the blockchain. These RPC methods are expected to follow the same specification across different blockchain nodes, providing users with seamless interaction. However, there have been continuous reports on various RPC bugs that can cause unexpected responses or even Denial of Service weakness. Existing studies on blockchain RPC bug detection mainly focus on generating the RPC method calls for testing blockchain clients. However, a wide range of the reported RPC bugs are triggered in various blockchain contexts. To the best of our knowledge, little attention is paid to generating proper contexts that can trigger these context-dependent RPC bugs. In this work, we propose EthCRAFT, a Context-aware RPC Analysis and Fuzzing Tool for client RPC bug detection. EthCRAFT first proposes to explore the state transition program space of blockchain clients and generate various transactions to construct the context. EthCRAFT then designs a context-aware RPC method call generation method to send RPC calls to the blockchain clients. The responses of 5 different client implementations are used as cross-referring oracles to detect the RPC bugs. We evaluate EthCRAFT on real-world RPC bugs collected from the GitHub issues of Ethereum client implementations. Experiment results show that EthCRAFT outperforms existing client RPC detectors by detecting more RPC bugs. Moreover, EthCRAFT has found six new bugs in major Ethereum clients and reported them to the developers. One of the bug fixes has been written into breaking changes in the client's updates. Three of our bug reports have been offered a vulnerability bounty by the Ethereum Foundation.
Decentralized Identifiers (DIDs) are increasingly deployed on distributed ledgers, yet systematic cross-platform evidence on their operational behavior remains limited. We present an empirical benchmarking study of three prominent ledger-based DID methods - Ethereum, Hedera, and XRP Ledger - using reference Software Development Kits (SDKs) under a unified experimental setup. We measure latency, transaction cost, and on-chain metadata exposure, normalizing latency by each platform's block or consensus interval and cost by its native value transfer fee. Privacy leakage is quantified using a Metadata-Leakage Score (MLS), an entropy-based measure expressed in bits per operation. Our results reveal distinct architectural trade-offs. Ethereum enables near-instant, off-chain DID creation, but incurs the highest latency and cost for on-chain lifecycle operations. XRPL delivers deterministic and stable latency with fixed, low fees, yet exhibits higher metadata leakage due to more verbose transaction payloads. Hedera achieves the lowest on-chain latency and low fees with minimal metadata leakage, while occasional variance arises from SDK-side processing and confirmation pipelines. Overall, the findings show that ledger architecture and SDK workflows play a major role in shaping DID latency, cost, and metadata exposure, complementing the effects of the underlying consensus mechanism. These results provide evidence-based insights to support informed selection and configuration of DID systems under performance and privacy constraints.
Elvira Albert, Emanuele De Angelis, Marco Di Ianni, Fabio Fioravanti · 5 authors
Testing has become an integral part of the software development process in order to ensure the correct and safe execution of programs. A powerful approach to testing is property-based testing that aims at generating unit tests that verify that a certain property of interest holds. However, smart contracts are also characterized by important non-functional aspects, such as the gas consumption required to execute their functions. Static gas analyzers are able to obtain parametric gas bounds - that soundly over-approximate - the gas consumption of executing each of the public functions within a smart contract. This paper discusses our ideas towards combining both formal methods, property-based testing and gas analysis, in order to generate gas-aware unit tests that can ensure the gas requirements provided by the programmers.
K501 is a deterministic temporal-structural integration framework designed to provide append-only state anchoring, canonical serialization, and hash-bound integrity across heterogeneous systems. The framework does not replace existing infrastructures such as databases, version control systems, or distributed ledgers. Instead, it operates as an optional structural overlay layer that encapsulates states in a formally defined frame model with explicit time anchoring (UTC + Unix Epoch). K501 focuses on: Deterministic canonical serialization Append-only historical discipline Explicit temporal positioning Snapshot-based integrity Cross-system structural interoperability The specification defines minimal compliance requirements for structural integration without modifying internal operational semantics of integrated systems. K501 is intended as a neutral structural discipline for temporal knowledge stabilization and reproducible state documentation. Peace 🕊️ Frames stehen nicht isoliert! Das ist eine formal belastbare Beschreibung. Keine Überhöhung.Kein AGI.Keine Spekulation.Aber diese hier ist solide. 🕊️
K501 is a deterministic temporal-structural integration framework designed to provide append-only state anchoring, canonical serialization, and hash-bound integrity across heterogeneous systems. The framework does not replace existing infrastructures such as databases, version control systems, or distributed ledgers. Instead, it operates as an optional structural overlay layer that encapsulates states in a formally defined frame model with explicit time anchoring (UTC + Unix Epoch). K501 focuses on: Deterministic canonical serialization Append-only historical discipline Explicit temporal positioning Snapshot-based integrity Cross-system structural interoperability The specification defines minimal compliance requirements for structural integration without modifying internal operational semantics of integrated systems. K501 is intended as a neutral structural discipline for temporal knowledge stabilization and reproducible state documentation. Peace 🕊️ Frames stehen nicht isoliert! Das ist eine formal belastbare Beschreibung. Keine Überhöhung.Kein AGI.Keine Spekulation.Aber diese hier ist solide. 🕊️
<b><i>State and event validation</i></b> are fundamental for ensuring the correctness and integrity of system states as they transition across decentralized networks. In decentralized systems, such as blockchain or distributed ledgers, maintaining state consistency, triggering actions based on events, and validating those actions across nodes require robust consensus protocols. This paper explores the architecture of state and event validation mechanisms, addressing challenges such as node synchronization, consensus-based event ordering, and error handling in invalid state transitions. By examining the role of validation in maintaining trust and reliability, we highlight its importance in secure and scalable decentralized applications, including smart contracts, financial transactions, and IoT systems.
SARMF-Bench is a structured and reproducible benchmark dataset for smart contract vulnerability analysis. It consists of five minimal Solidity contracts representing canonical vulnerability classes: • Reentrancy • Arithmetic Overflow Behavior • Access Control Weakness • Unchecked External Call • Denial-of-Service Pattern Each contract is paired with machine-readable static analysis outputs generated using Slither v0.11.5. The dataset is designed to support controlled benchmarking experiments for: - Static analyzers - Symbolic execution engines - Fuzzers - AI-assisted smart contract security tools Related assets: GitHub repository: https://github.com/profmohit-edu/sarmf-framework Zenodo software DOI: https://doi.org/10.5281/zenodo.18754015 Reproducibility protocol: https://doi.org/10.17504/protocols.io.bp216eyxdgqe/v1 Mendeley dataset DOI (pending moderation): https://doi.org/10.17632/kd3vcpnn9v.1 HAL record: https://hal.science
This paper specifies the Inference Battery Token (IBT), an ERC-20 on Base that mints when the inference orchestrator verifies a failed AI response, compensating the subscriber and capturing a structured DPO preference pair in one operation. Minting occurs through two pathways: automatic spot-checks that re-execute sampled requests on trusted nodes, and subscriber-initiated flags confirmed through the same re-execution pipeline. Each verified failure mints tokens proportional to the compute cost wasted, ranging from 1 IBT for embeddings to 20 IBT for extended reasoning. Subscribers redeem IBT for battery credits, permanently burning tokens. A genesis allocation of 10,000,000 IBT bootstraps exchange liquidity, network operations, community grants, and early investor capital with 12-month vesting. Because minting depends on AI failure rates and redemption increases with adoption, circulating supply contracts as models improve. Contributors who serve compute earn platform credits and elect payouts in USD or IBT, with a 15% bonus for token election. Hardware contributors may also earn IBT by generating zero knowledge proofs for the verification system during idle GPU windows. Revenue from selling accumulated failure records to frontier labs through the data access tiers described in the companion paper provides fundamental backing for token value.
Microservice architecture has emerged as a dominant paradigm for building largescale software systems, promising modularity, scalability, and independent evolution of services. A central premise of this paradigm is that architectural decomposition reduces inter-service dependencies and enables teams to develop and deploy services autonomously. Despite these expectations, empirical evidence on whether microservice systems actually achieve loose coupling in practice remains limited, particularly in open-source environments where development processes are highly decentralized. This thesis investigates coupling phenomena in microservice-based open-source systems from both technical and organizational perspectives. The research follows a progressive investigative design structured around three stages: <i>measurement, observation</i>, and <i>explanation</i>. First, the thesis introduces the <i>Microservice Logical Coupling</i> (MLC) metric, a repository-based approach for identifying evolutionary dependencies between microservices. By extending traditional logical coupling analysis from file-level artifacts to service-level entities, MLC enables the detection of cross-service evolutionary dependencies using version control data without requiring runtime instrumentation. Second, the thesis conducts a large-scale empirical analysis to assess the prevalence and evolution of logical coupling across microservice-based open-source projects. The results show that logical coupling is a widespread phenomenon and tends to increase over time, suggesting that architectural boundaries alone do not guarantee independent service evolution. Third, the study examines the socio-technical factors associated with coupling by analyzing developer contribution patterns and service ownership structures. The findings reveal a consistent association between cross-service developer activity and higher levels of logical coupling, indicating that organizational structures influence the emerqence of architectural dependencies. Overall, this work contributes a replicable measurement approach, an empirically grounded empirical analysis of coupling in microservices, and a socio-technical perspective on microservice evolution. The results suggest that service independence is not solely an architectural property but a socio-technical outcome shaped by both system design and development practices.
This exploratory study investigates the security, fairness and economic implications of Decentralised Finance (DeFi) within the Ethereum ecosystem. While DeFi has experienced rapid growth, there remains several systemic risks and vulnerabilities that can affect hugely. The study focuses on three key aspects: (1) Transaction Semantics (Analysing how core actions in DeFi are executed on EVM and recorded in transaction receipts and logs), (2) Vulnerability Analysis (Identifying recurring patterns of anomalies), and (3) Detection Framework (Evaluating the effectiveness and potential scale of DeepTx, a real-time analysis tool to detect threats in transactions). By conducting the report based on leading protocols in Ethereum such as Uniswap, Aave and Compound, the study bridges the gap between transaction data and security insights. It will therefore provide a foundation for policymakers to create frameworks for how bugs and risks can affect the DeFi ecosystem, serving as a guide for a secure and scalable Web3 industry.
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.