Existing high performance blockchains verify one signature per transaction on the critical path, which creates O(N) verification cost, high hardware pressure, and difficult post quantum migration. This paper presents ACE Runtime, a ZKP native execution layer built on identity authorization separation. We replace per transaction signature checks with lightweight HMAC attestations in the hot path, then generate one aggregated zero knowledge finality certificate per block in an asynchronous prove stage. The system is organized as an Attest Execute Prove pipeline with two tier finality: soft finality from BFT voting and hard finality from proof verification. Under standard cryptographic assumptions, we provide formal arguments for attestation unforgeability and hard finality irreversibility. We also define a two phase timeout and backup proving path with witness availability gossip for liveness under builder failure. Quantitative results combine analytical modeling with reference implementation measurements. The prototype shows low CPU orchestration overhead, while model driven analysis projects constant per block verification cost, lower validator hardware requirements for non builders, and better bandwidth efficiency than per transaction signature designs. These results indicate that identity authorization separation is a practical architecture for sub second cryptographic finality with a clear path toward stronger post quantum components.
Post-quantum signature schemes impose kilobyte-scale on-chain artifacts. Verifying them inside ZK circuits merely relocates the cost via expensive lattice arithmetic in prover circuits. We present ZK-ACE (Zero-Knowledge Authorization for Cryptographic Entities), which replaces transaction-carried signature objects with identity-bound ZK statements. Given a deterministic identity derivation primitive (DIDP) as a black box, the prover demonstrates in zero knowledge that an identity consistent with an on-chain commitment authorized the transaction; no signature object is produced or verified on-chain. We provide game-based definitions and reduction-based proofs for authorization soundness, replay resistance, substitution resistance, and cross-domain separation, under knowledge soundness, collision resistance, and DIDP recovery hardness. Structural data accounting shows an order-of-magnitude reduction in per-transaction authorization data versus direct PQC deployment. A reference implementation offers two backends: Circle STARK (341 active rows / 361 AIR constraint expressions, 14.5 ms prove, 1.1 ms verify, approx. 107 KB proofs, transparent setup, post-quantum-oriented) and Groth16/BN254 (2,155 R1CS constraints, 37.3 ms prove, 128-byte proofs). Both are roughly 500--2,300x smaller than in-circuit PQC signature verification. Under mandatory per-block STARK aggregation, per-transaction consensus-visible data is approx. 160 bytes.
Traditional financial institutions face inefficiencies that can be addressed by distributed ledger technology. However, a primary barrier to adoption is the privacy concerns surrounding publicly available transaction data. Existing private protocols for distributed ledger that focus on the Ring-CT model are not suitable for adoption for financial institutions. We propose a post-quantum, lattice-based transaction scheme for encrypted ledgers which better aligns with institutions' requirements for confidentiality and audit-ability. The construction leverages various zero-knowledge proof techniques, and introduces a new method for equating two commitment messages, without the capability to open one of the commitment during the re-commitment. Subsequently, we build a publicly verifiable transaction scheme that is efficient for single or multi-assets, by introducing a new compact range-proof. We then provide a security analysis of it. The techniques used and the proofs constructed could be of independent interest.
The increasingly complex Web3 ecosystem and decentralized finance (DeFi) landscape demand ever higher levels of technical expertise and financial literacy from participants. The Intent-Centric paradigm in DeFi has thus emerged in response, which allows users to focus on their trading intents rather than the underlying execution details. However, existing approaches, including Typed-intent design and LLM-driven solver, trade off expressiveness, trust, privacy, and composability. We present OMNIINTENT, a language-runtime co-design that reconciles these requirements. OMNIINTENT introduces ICL, a domain-specific Intent-Centric Language for precise yet flexible specification of triggers, actions, and runtime constraints; a Trusted Execution Environment (TEE)-based compiler that compiles intents into signed, state-bound transactions inside an enclave; and an execution optimizer that constructs transaction dependency graphs for safe parallel batch submission and a mempool-aware feasibility checker that predicts execution outcomes. Our full-stack prototype processes diverse DeFi scenarios, achieving 89.6% intent coverage, up to 7.3x throughput speedup via parallel execution, and feasibility-prediction accuracy up to 99.2% with low latency.
LICITRA Technical Report Series, Report No. LICITRA-TR-2026-01, Version 0.2. This report documents LICITRA-MMR, an open-source ledger primitive that combines a Merkle Mountain Range (MMR) data structure with per-organization epoch anchoring, a versioned canonical JSON specification, and an atomic two-phase commit pipeline for cryptographic audit integrity in agentic AI systems. At a block size of 1,000 events, LICITRA-MMR produces inclusion proofs requiring 14 SHA-256 operations and verifies a full epoch chain of 1,000 epochs in under 1 ms. The system is a single-operator forensic integrity primitive providing no Byzantine fault tolerance, no distributed consensus, and no confidentiality guarantees. Part of the LICITRA Technical Report Series. Companion report: LICITRA-TR-2026-02 (LICITRA-SENTRY, DOI: 10.5281/zenodo.18843784).
Autonomous software agents on blockchains solve distributed-coordination problems by reading shared ledger state instead of exchanging direct messages. Liquidation keepers, arbitrage bots, and other autonomous on-chain agents watch balances, contract storage, and event logs; when conditions change, they act. The ledger therefore functions as a replicated shared-state medium through which decentralized agents coordinate indirectly. This form of indirect coordination mirrors what Grassé called stigmergy in 1959: organisms coordinating through traces left in a shared environment, with no central plan. Stigmergy has mature formalizations in swarm intelligence and multi-agent systems, and on-chain agents already behave stigmergically in practice, but no prior application-layer framework cleanly bridges the two. We introduce Indirect coordination grounded in ledger state (Coordinación indirecta basada en el estado del registro contable) as a ledger-specific applied definition that maps Grassé's mechanism onto distributed ledger technology. We operationalize this with a state-transition formalism, identify three recurring base on-chain coordination patterns (State-Flag, Event-Signal, Threshold- Trigger) together with a Commit-Reveal sequencing overlay, and work through a State-Flag task-board example to compare ledger-state coordination analytically with off-chain messaging and centralized orchestration. The contribution is a reusable vocabulary, a ledger-specific formal mapping, and design guidance for decentralized coordination over replicated shared state at the application layer.
For most distributed financial systems, the constraints imposed by the CAP (Consistency, Availability, Partition Tolerance) theorem must be reconciled against the ordering constraints needed to satisfy regulatory requirements and meet the performance requirements of real-time transaction processing. This paper presents the Temporal Sequence Barrier consistency model for asynchronous high-throughput ledger systems. Combining logical vector clocks with epoch-based orchestration patterns imposes a strict causal ordering of events across multiple geographic regions without sacrificing availability. Its database-centric architecture allows stateful routing and selective replication of entities in order to achieve linearizability of causally related transactions while allowing independent sets of entities to be processed in parallel. We provide a detailed evaluation that shows that we can provide causal consistency at latency bounds equal to or better than existing systems using clever buffering and adaptive timeouts, while also addressing the classic challenges in distributed transaction management and operator complexity.
Sybil resistance is a key requirement of decentralized consensus protocols. It is achieved by introducing a scarce resource (such as computational power, monetary stake, disk space, etc.), which prevents participants from costlessly creating multiple fake identities and hijacking the protocol. Quantum states are generically uncloneable, which suggests that they may serve naturally as an unconditionally scarce resource. In particular, uncloneability underlies quantum position-based cryptography, which is unachievable classically. We design a consensus protocol that combines classical hybrid consensus protocols with quantum position verification as the Sybil resistance mechanism, providing security in the standard model, and achieving improved energy efficiency compared to hybrid protocols based on Proof-of-Work. Our protocol inherits the benefits of other hybrid protocols, namely the faster confirmation times compared to pure Proof-of-Work protocols, and resilience against the compounding wealth issue that plagues protocols based on Proof-of-Stake Sybil resistance. We additionally propose a spam prevention mechanism for our protocol in the Random Oracle model.
Abstract Blockchain-based token systems face a fundamental scalability challenge known as the back-to-genesis problem : verifying a token’s provenance requires tracing its complete transaction history from issuance to the present. For fungible tokens, where transaction inputs can be combined and split, this history forms a directed acyclic graph whose size grows exponentially with the transaction chain length. We propose a lightweight token validation system that achieves efficient peer-to-peer (P2P) and offline verification by combining three design elements: (i) encoding tokens as UTXO-based non-fungible instruments with fixed denominations, which restricts each token’s history to a strictly linear chain; (ii) SPV-style Merkle proof verification against locally stored block headers; and (iii) a distributed hash table (DHT) that stores compact proofs for each token’s transaction history, shared peer-to-peer among participants. We formalise the structural difference between fungible and non-fungible token histories, show that the crossover point at which exponential fungible-token verification exceeds the linear NFT cost occurs at chain length ≈ 6 using empirically measured blockchain branching factors, and describe a periodic reminting mechanism that bounds chain lengths and enables predictable maintenance. We analyse the security properties of the system under a threat model that addresses DHT availability, proof freshness, eclipse resistance, and double-spend risks in offline operation. The system requires no trusted third party, no zero-knowledge proof infrastructure, and no modifications to the underlying blockchain consensus protocol, making it suitable for deployment on resource-constrained devices and a practical architecture for central bank digital currency (CBDC) implementations. Performance benchmarks on commodity hardware, including a Raspberry Pi 4 and an Android smartphone, confirm that verification completes in under 6 ms for typical payment scenarios, validating the system’s practicality for real-world deployment.
We study the implications of the existence of weak Zero-Knowledge (ZK) protocols for worst-case hard languages. These are protocols that have completeness, soundness, and zero-knowledge errors (denoted $ε_c$, $ε_s$, and $ε_z$, respectively) that might not be negligible. Under the assumption that there are worst-case hard languages in NP, we show the following: 1. If all languages in NP have NIZK proofs or arguments satisfying $ ε_c+ε_s+ ε_z < 1 $, then One-Way Functions (OWFs) exist. This covers all possible non-trivial values for these error rates. It additionally implies that if all languages in NP have such NIZK proofs and $ε_c$ is negligible, then they also have NIZK proofs where all errors are negligible. Previously, these results were known under the more restrictive condition $ ε_c+\sqrt{ε_s}+ε_z < 1 $ [Chakraborty et al., CRYPTO 2025]. 2. If all languages in NP have $k$-round public-coin ZK proofs or arguments satisfying $ ε_c+ε_s+(2k-1).ε_z < 1 $, then OWFs exist. 3. If, for some constant $k$, all languages in NP have $k$-round public-coin ZK proofs or arguments satisfying $ ε_c+ε_s+k.ε_z < 1 $, then infinitely-often OWFs exist.
The Bitcoin protocol [Nakamoto, 2008] represents a landmark achievement in distributed systems and cryptographic engineering. However, its fixed-supply design embeds a critical long-term vulnerability: the mathematical inevitability of permanent supply contraction driven by generational private-key inheritance failure. This paper formalises the generational loss model through discrete probability theory and recurrence relations, demonstrating that conservative estimates predict 51% of total supply becoming permanently inaccessible within 264 years, while realistic models project 64% loss. We further establish that the cessation of block rewards at approximately block height 6,930,000 ($\approx$2140 CE) eliminates the mining security budget, exposing the network to sustained 51% attack risk. We propose Bitcoin Infinity — the Perpetual Continuity Protocol — a minimal, mathematically grounded modification to Bitcoin Core's GetBlockSubsidy() function. The modification replaces a single hard-stop conditional with a modulo operation, restarting the original 50 BTC/block halving curve every 33 halvings ($\approx$132 years) in perpetuity. We prove that under this scheme, circulating supply converges to a stable equilibrium $C^* = S_0r/(1 - r)$ (approximately 49 M BTC at 30% generational loss), mining incentives are preserved indefinitely, and all previously issued bitcoins remain fully valid. The implementation is verified against 113 boundary tests with zero failures, exhibits no undefined behaviour under C++17, and maintains complete backward compatibility with the existing network until the activation block. Link: https://revistazen10.github.io/bitcoin-infinity/
Disentangle introduces Topological Mass Consensus (TMC), a permissionless consensus mechanism that derives Sybil resistance from discrete curvature on transaction DAGs rather than proof-of-work or proof-of-stake. Edges connecting attack clusters to the honest network exhibit negative Jaccard curvature due to low ancestor overlap, enabling geometric throttling without trusted seeds or economic incentives. The protocol uses exclusively post-quantum cryptography (ML-DSA, ML-KEM, SHA3-256, Plonky3 STARKs) and derives all temporal properties from topological depth. We also present the Capability-Coherence Identity Protocol (CCIP), unifying DID-based identity, object capabilities, and petname naming under the same curvature analysis. Implementation: 9 Rust crates, 349+ tests.
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
Real-time payment architectures are the latest wave, eased by the convergence of cloud-native technologies, continuous transaction processing, and demand from regulators for instant settlement. Batch architectures fall short of consumer and business expectations for immediacy‚ transparency‚ and the always-on availability needed to support the digital economy and new digital use cases. For real-time systems, advanced distributed architectures, messaging, and interoperability frameworks may allow for the execution of transactions across multiple institutions and geographies. These may be supported by cloud infrastructures (e.g., cloud platforms), providing scalability and fault tolerance via microservices, multi-region deployments, and zero-trust security principles to support the execution of transactions in real-time. Additional technical solutions such as distributed ledger technology, artificial intelligence-based fraud prevention, and API-based ecosystem architecture, as well as operational intelligence, are evolving. However, ultra-low latency, global interoperability, demand-based capacity scalability, and distributed consistency guarantees are some of the challenges for the continued evolution of a real-time financial system.
The rapid growth of decentralized systems in theWeb3 ecosystem has introduced numerous challenges, particularly in ensuring data security, privacy, and scalability [3, 8]. These systems rely heavily on distributed architectures, requiring robust mechanisms to manage data and interactions among participants securely. One critical aspect of decentralized systems is key management, which is essential for encrypting files, securing database segments, and enabling private transactions. However, securely managing cryptographic keys in a distributed environment poses significant risks, especially when nodes in the network can be compromised [9]. This research proposes a decentralized database scheme specifically designed for secure and private key management. Our approach ensures that cryptographic keys are not stored explicitly at any location, preventing their discovery even if an attacker gains control of multiple nodes. Instead of traditional storage, keys are encoded and distributed using the BFLUT (Bloom Filter for Private Look-Up Tables) algorithm [7], which enables secure retrieval without direct exposure. The system leverages OrbitDB [4], IPFS [1], and IPNS [10] for decentralized data management, providing robust support for consistency, scalability, and simultaneous updates. By combining these technologies, our scheme enhances both security and privacy while maintaining high performance and reliability. Our findings demonstrate the system's capability to securely manage keys, prevent unauthorized access, and ensure privacy, making it a foundational solution for Web3 applications requiring decentralized security.
Anderson Melo de Morais, Fernando Lins, Nelson Souto Rosa
The Internet of Things (IoT) drives technological advances across various sectors by enabling seamless communication among smart devices. However, significant challenges remain regarding the integrity and reliability of the data stored by these devices. Traditional blockchain solutions, such as those based on Proof of Work (PoW), are generally unsuitable for IoT applications due to their high computational resource demands. Although approaches combining multiple consensus algorithms have emerged as alternatives to optimise performance and security, determining the best combination for each scenario remains an open problem. This paper proposes a strategy based on Genetic Algorithms (GAs) to adaptively select and combine consensus algorithms, thus improving blockchain efficiency in IoT environments. The approach was evaluated on a test blockchain, OmniBlock, implemented using a Directed Acyclic Graph (DAG) and designed specifically for evaluation purposes in IoT applications. OmniBlock supports multiple consensus algorithms, including Proof of Authority (PoA), Proof of Stake (PoS), Proof of Work (PoW), Practical Byzantine Fault Tolerance (PBFT), Raft, and others. The consensus algorithm combination is chosen based on performance attributes. All combinations of consensus algorithms evaluated in this work were suggested by GAs; the practical feasibility of each is analyzed empirically. Experimental results indicate that the evolutionary optimization-based strategy performs better across most of the combinations suggested by the GAs.
Abstract When Nakamoto invented Bitcoin, the first generation of cryptocurrencies followed it in applying POW (Proof of Work) consensus mechanism; due to its excessive energy consumption and heavy carbon footprints, new innovations evolved like Proof of Space , POS (Proof of Stake) , and a lot more with many variants for each. Furthermore, the emergence of more blockchain applications and kinds beyond just cryptocurrencies needed more consensus mechanisms that is optimized to fit requirements of each application or blockchain kind; examples range from IoT (Internet of Things) blockchains for sustainability applications that often use variants of BFT (Byzantine Fault Tolerance) algorithm, and consensus needed to relay transactions and/or assets between different blockchains in interoperability solutions. Previous studies concentrated on surveying and/or proposing different blockchain consensus rules, on a specific consensus issue like attacks, randomization, or on deriving theoretical results. Starting from discussing most important theoretical results, this paper tries to gather and organize all significant existing material about consensus in the blockchain world explaining design challenges, tradeoffs and research areas. We realize that the topic could fit for a complete textbook, so we summarize the basic concepts and support with tables and appendices. Then we highlight some case examples from interoperability solutions to show how flexible and wide the design space is to fit both general and special purpose systems. The aim is to provide researchers with a comprehensive overview of the topic, along with the links to go deeper into every detail.
This paper proposes a unified Layer-0 infrastructure protocol for post-quantum distributed computing, based on high-dimensional coordinate representations derived from non-commensurate Mersenne primes. Unlike traditional approaches reliant on block-based ledgers or persistent state replication, the proposed Mersenne Lattice Protocol (MLP) represents data, transactions, and authority states as coordinates within a high-dimensional lattice space. By projecting computational events into a 4096-dimensional vector space, MLP enables theoretically unbounded parallel transaction processing under resonance-based validation, while simultaneously eliminating permanent state storage at the protocol level. Furthermore, the protocol integrates Heart Rate Variability (HRV) as a dynamic physiological entropy source for stateless bio-key regeneration, thereby binding cryptographic authority to real-time biological liveness and spatiotemporal context. Functional prototypes of the core MLP architecture have been implemented and verified through a live demo environment (https://www.icekey.cloud/teleport_v), demonstrating peak throughput exceeding 45,000,000 TPS in a parallel resonance cluster. This framework provides the foundation for post-quantum secure financial systems, stateless media reconstruction, critical infrastructure protection, and delay-tolerant interplanetary communication.
A big challenge posed in blockchain centric platforms is achieving scalability while also preserving user privacy. This report details the design, implementation and evaluation of a Layer-2 scaling solution for Hyperledger Fabric using Zero Knowledge Rollups (ZK Rollups). The proposed architecture introduces an off chain sequencer that accepts transactions immediately and sends them for batching into a Merkle tree based rollup, using ZK proofs to attest to the correctness and verifiability of the entire batch. The design aims to decouple transaction ingestion from actual on chain settlements to address Fabric scalability limitations and increase throughput under high load conditions. The baseline architecture in Hyperledger Fabric constrains transaction requests due to endorsement, ordering and validation phases, leading to a throughput of 5 to 7 TPS with an average latency of 4 seconds. Our Layer-2 solution achieves an ingestion throughput of 70 to 100 TPS, leading to an increase of nearly ten times due to the sequencer immediate acceptance of each transaction and reducing client perceived latency by nearly eighty percent to 700 to 1000 milliseconds. This work demonstrates that integrating ZK Rollups in Hyperledger Fabric enhances scalability while not compromising the security guarantees of a permissioned blockchain network.
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 technology is a distributed ledger system providing secure, transparent, decentralized cryptocurrency transactions. Its underlying structure includes wallets and the Unspent Transaction Output (UTXO), which facilitates transactions and maintains transaction integrity. A blockchain wallet is a software program that stores and manages cryptocurrencies, allowing users to send and receive digital currency and monitor their balance. The UTXO set tracks unspent outputs, particularly in the Bitcoin network, ensuring accurate and secure accounting of available balances. This paper examines how well a hybrid data structure performs when processing wallet values in a UTXO set. The hybrid data structure stores the wallet’s addresses in a hash table and the UTXO in a minimum heap tree rather than a list. At first, we assume that the values in the list should always be sorted and appear in ascending order. Then, we employ a list with unsorted values. The wallet addresses are invariably assigned to a hash table. The “instruction count” approach counts the number of statements that can be executed or what we refer to as a “single operation” to measure performance.
ELTA is a project funded by the Valencian Institute for Business Competitiveness (IVACE) and the European Union through the European Regional Development Fund (FEDER). DELTA project is aimed at bringing companies closer to the use of different disruptive technologies such as Blockchain / Distributed Ledger Technologies (DLT). To achieve its goal, DELTA will provide: A software tool for automating the deployment of DLT networks, regardless of the number of required nodes, or the process of joining an existing network. A modular mechanism that allows the synchronization of DLTs with databases. The goal of this mechanism is to ease and improve the way data is retrieved from a DLT ledger. An accountability tool for shared environments for the exchange of services that brings in some of the most important characteristics of blockchain/DLTs: facilitating auditing and accountability by each participant, use of tokens, etc.
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.
In primary-backup replication, consensus latency is bounded by the time for backup nodes to replay (re-execute) transactions proposed by the primary. In this work, we present Ira, a framework to accelerate backup replay by transmitting compact \emph{hints} alongside transaction batches. Our key insight is that the primary, having already executed transactions, possesses knowledge of future access patterns which is exactly the information needed for optimal replay. We use Ethereum for our case study and present a concrete protocol, Ira-L, within our framework to improve cache management of Ethereum block execution. The primaries implementing Ira-L provide hints that consist of the working set of keys used in an Ethereum block and one byte of metadata per key indicating the table to read from, and backups use these hints for efficient block replay. We evaluated Ira-L against the state-of-the-art Ethereum client reth over two weeks of Ethereum mainnet activity ($100,800$ blocks containing over $24$ million transactions). Our hints are compact, adding a median of $47$ KB compressed per block ($\sim5\%$ of block payload). We observe that the sequential hint generation and block execution imposes a $28.6\%$ wall-time overhead on the primary, though the direct cost from hints is $10.9\%$ of execution time; all of which can be pipelined and parallelized in production deployments. On the backup side, we observe that Ira-L achieves a median per-block speedup of $25\times$ over baseline reth. With $16$ prefetch threads, aggregate replay time drops from $6.5$ hours to $16$ minutes ($23.6\times$ wall-time speedup).