Papers for

blockchain engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Verifying reward model scores for trustworthy large language model alignment

VRMaaS: Verifiable Reward-Model-as-a-Service for Trustworthy LLM Alignment

Abstract: Reward models (RMs) are increasingly deployed as service components in LLM alignment pipelines, where payment, audit, moderation, and governance workflows act on the scores they return. An inference proof alone does not show whether a score belongs to the intended request, model checkpoint, numerical configuration, and verifier: in a controlled comparison that isolates the accepted statement from prover scale, a generic inference proof wrapped for on-chain checking remains valid after six classes of such service-field substitution. We formulate verifiable reward-model-as-a-service (VRMaaS) as a service-output integrity problem and present a framework in which each returned reward becomes a proof-carrying artifact. Its off-chain acceptance rule binds request identity, committed weights, verifier and configuration identifiers, proof-task order, and the digest of the exported package, so auditors can check a reward without rerunning the private RM or exposing inputs, checkpoints, or hidden activations; an optional on-chain zero-knowledge wrapper gives contracts a partial attestation of selected consistency checks and supplied service fields. The framework decomposes Transformer RM serving into arithmetic and lookup-backed proof tasks, aggregates them into a composite proof, and links hidden operands to the committed weights. A GPU prototype on 1B, 3B, and 8B reward models over 128-1024 tokens preserves 93.5-99% pairwise agreement with the baseline RM and rejects every tested service-field substitution in complete artifacts. Using exact integer witnesses and request-level aggregation of weight-binding openings, it generates complete artifacts in 49.8-206.1 seconds across the evaluated settings; auditors verify retained artifacts in 1.94-5.11 seconds, and partial public attestation costs about 217K gas. These costs suit delayed audit, settlement, and governance workflows.

Wed 11 NovCryptography and Security
The gist
Large language models (LLMs) use reward models to measure how well they perform certain tasks. But verifying that these reward scores really come from the correct model and settings can be tricky. The authors propose a system that attaches a proof to each reward score, allowing auditors to check its authenticity without needing to rerun the entire model. This method works efficiently with different model sizes and can be used in audits or governance where trust in the model's output is critical.
Open → 2611.14984v1

Decentralized data control protects shared info without a central boss

GUARDTs: Decentralized Access Control for Replicated Data Types

Abstract: Replicated data types providing strong eventual consistency offer a principled foundation for developing decentralized software. Yet existing approaches to programming such data types leave access control unresolved: they either provide none at all, delegate it to a trusted coordinator, reintroducing the centralization they were designed to avoid, or tie it to specific data-type constructions, while typically assuming non-Byzantine replicas and static policies. We present GUARDTs: Guarded Unforgeable Algebraic Replicated Data Types, which embed fine-grained permissions directly into the application data model, operate without a central authority, support dynamic policy evolution, and tolerate Byzantine replicas. We formally prove that GUARDTs guarantee confidentiality, integrity, and availability and show empirically that their access control adds negligible overhead on top of the cost of Byzantine-resilient replication itself.

Thu 5 NovProgramming LanguagesDistributed, Parallel, and Cluster Computing
The gist
Managing who can see or change shared data without a central controller is a tricky problem, especially when data is copied across many places. The authors present a new way to build data structures that keep track of permissions inside the data itself. This method works even if some copies act badly or policies change over time. Their approach keeps data secure and available, and adding this security doesn’t slow things down much.
Open → 2611.08083v1

Weaver speeds up blockchain by parallelizing transactions smarter

Weaver: Unlocking Blockchain Transaction Parallelism through State-Decoupled Symbolic Execution

Abstract: Transaction execution remains a major performance bottleneck in blockchains. Existing parallel execution engines are still blocked by slow state accesses on each transaction's critical path, creating a hidden loss of parallelism. This paper presents Weaver, a state-decoupled transaction processing paradigm that enables execution flow to proceed in the absence of concrete state values. Weaver represents states as lightweight symbolic references and records subsequent computation as symbolic expressions while concrete values are fetched on the fly. To handle state-dependent control flow, Weaver predicts the most likely branch direction through hierarchical symbolic pattern matching. Weaver further introduces expression-granular scheduling that evaluates each symbolic expression as soon as its state dependencies are resolved, rather than waiting for the transaction's entire read set, fully exploiting fine-grained intra-transaction parallelism. Evaluation on real Ethereum blocks and synthetic workloads spanning four representative dApps shows that Weaver delivers 41%-63% higher throughput than state-of-the-art parallel execution engines and up to 7.5 times the throughput of serial execution.

Wed 4 NovDistributed, Parallel, and Cluster Computing
The gist
Blockchain transaction processing is often slow because transactions need to wait for data from the blockchain's state. The authors present Weaver, a system that lets transactions run using symbolic placeholders instead of waiting for actual data, making execution faster. Weaver predicts which parts of a transaction will happen next and runs computations as soon as their data is ready, allowing many parts of transactions to run at the same time. This approach improves transaction throughput significantly compared to existing methods and serial processing.
Open → 2611.06462v1

Evm and cosmos blockchains exchange environmental tokens securely and atomically

An EVM-Cosmos Bridge for Atomic, Semantic-Preserving Transfer of Environmental Tokens

Abstract: Transferring semantically typed tokens between heterogeneous blockchains (e.g. EVM and Cosmos ecosystems) raises two problems: semantic mixing, the loss of a token's domainspecific meaning in transit (e.g., CO2 removals issued under different methodologies), and atomicity despite divergent consensus and timing assumptions. We propose a bridge that addresses both. A deterministic indicator identity derived from cryptographic commitments, mirrored in class registries on both chains and checked at mint time, preventing semantic mixing by construction. For atomicity, we extend hash time-locked contracts (HTLCs) from two-party exchange to single-owner transfer with an automatic callback that burns the source escrow after a destination claim, and a protocol-minimum bounty that makes the fallback burn incentive-compatible even against adversarial senders. We machine-check the protocol's invariants with TLC (supply conservation fails without the rational-monitor assumption and holds with it) and validate a bidirectional prototype on Polygon and Neutron mainnets over Axelar GMP: fully automatic transfers with a median end-to-end latency of 97 s over 50 Polygon to Neutron transfers across 7 days (all completed by the on-chain automatic callback) and 93 s in the reverse direction, and semantic-validation overhead below 0.4% of messaging cost. We also document the integration failure modes of Cosmos originated messaging, whose dominant operational risk proves to be relay eligibility rather than latency.

Tue 27 OctSoftware Engineering
The gist
When moving environmental tokens like CO2 removals between different blockchain systems, meaning can be lost or tokens can be copied incorrectly. The authors designed a bridge that ensures tokens keep their specific meaning and are transferred all at once or not at all. They use cryptographic methods to check tokens’ identity and special contracts to handle timing differences between blockchains. Their tests on real blockchains show the system works reliably and quickly.
Open → 2610.37663v1

Blockchain clients become active to ensure transaction inclusion safety

How Not to Be Censored: Inclusion Safety in Client-Led Consensus

Abstract: Blockchain consensus protocols implicitly follow a client-server architecture: validators are the only active participants, while clients (i.e., users) merely submit transactions and rely on validators to include them. This abstraction obscures a fundamental question: what should a client do to guarantee the timely inclusion of its own transaction? We study this question by introducing a leaderless consensus protocol in which clients are active. We define inclusion safety: the guarantee that a client's transaction enters some of the blocks produced for an epoch, and that every block omitting it belongs to a fork that is eventually abandoned. Because every transaction carries a reference to a block of the previous epoch, clients help select the surviving fork. This yields two paths to inclusion: reaching sufficiently many honest replicas within an epoch, or relaying a block containing the transaction across epochs until the corresponding fork becomes canonical. In a generalized model spanning synchrony and asynchrony, the client's and the replicas' connectivity are substitutes for inclusion safety: it is achieved either if the client is well connected, or if the client is poorly connected but honest replicas communicate reliably, provided the client reaches at least one of them. However, the substitution is imperfect: when inclusion safety rests on the replicas' connectivity, it requires a longer epoch compared to when the client is well connected.

Wed 21 OctDistributed, Parallel, and Cluster Computing
The gist
Most blockchain systems give validators control over which transactions get recorded, leaving users uncertain if their transactions will be included quickly. The authors study a new system where users actively help decide which transactions are accepted, improving the chances their transactions will be included in the blockchain securely. They define a guarantee called inclusion safety, meaning if a transaction is excluded from some blocks, those blocks will eventually be discarded. Their approach allows transactions to be safely included either through direct contact with honest nodes or by relaying the transaction over time across blockchain versions. This work provides a way for users to better ensure their transactions are not censored, even in complex network conditions.
Open → 2610.29497v1

Fast Tendermint agreement bug exposed and two fixes proposed

Revisiting Fast Tendermint: An Agreement Violation and Two Repairs

Abstract: Fast Tendermint reduces Tendermint's good-case latency to two communication steps for n>=5f+1. We show that its published round-change rule violates Agreement: one Byzantine process suffices for every f>=1, and for f>=2 two Byzantine processes suffice without double signing. The failure occurs when a process advances past a round without recording the value that may have been decided there. The Quint specification that accompanies the protocol does not allow this kind of round skipping and is not affected; the violation lies in the published pseudocode. We present two repairs. Walk requires a process to leave each round on a quorum of that round's precommits and to precommit before leaving. It keeps the recorded valid state and removes the wait after a precommit quorum. Justify carries the evidence needed to accept a proposal in the proposal itself, removing both the recorded valid state and the proposer's synchronization wait. Both satisfy Agreement and Validity under asynchrony and Termination under the partially synchronous gossip model of Tendermint and Fast Tendermint. Both retain proposal timeouts. The main text presents the executions that violate Agreement and explains the two repairs. The appendices provide proofs, a brief comparison with other round-change designs, and an extension to chains.

Mon 12 OctDistributed, Parallel, and Cluster ComputingCryptography and Security
The gist
Fast Tendermint is a method for agreeing on a decision quickly in a network even if some participants are dishonest. The paper shows that the current published rules can lead to disagreements if even one participant acts badly, breaking the system’s fundamental promise. This happens because a participant can skip important steps without recording key information. The authors offer two fixes that guarantee agreement and keep the system reliable, even with some network delays and dishonest actors.
Open → 2610.16442v1

Signature-free blockchain methods cut consensus delays significantly

Simple and Fast Signature-Free Blockchain Consensus

Abstract: Signature-free protocols avoid the cost of post-quantum signatures. We present two simple signature-free blockchain consensus protocols for eventual synchrony with optimal good-case commit latency (three message delays for \(f<n/3\) and two for \(f<n/5\)), optimistic responsiveness, a block time of only two message delays without speculation, and \(O(n^2)\) communication per view. They instantiate Generic Simplex, a blockchain consensus construction parameterized by a new abstraction called view agreement. The same construction also captures Simplex, Minimmit, and a new synchronous signature-free protocol with optimal good-case commit latency of two message delays for \(f<n/4\).

Sat 26 SeptDistributed, Parallel, and Cluster Computing
The gist
Blockchain systems need to agree on the order of transactions, which often requires complex digital signatures that could be vulnerable to quantum computers. The authors present new ways to reach consensus without these signatures, making the process faster while keeping security guarantees under certain network conditions. Their methods reduce the number of communication steps needed to confirm transactions and work efficiently even when some participants behave badly. These protocols use a new concept called view agreement to coordinate participants reliably.
Open → 2609.32985v1

NostrAgent combines identity trust delegation payment for autonomous AI

NostrAgent: A Decentralized Identity and Delegation Architecture for Sovereign Agentic Systems

Abstract: Autonomous AI agents increasingly act across organizational boundaries on behalf of human operators: they invoke third-party services, delegate subtasks to other agents, and pay for metered resources. Deploying such agents safely requires five capabilities that today live in separate systems: persistent identity, scoped delegation, peer trust, discovery, and payment. Existing approaches root these in centralized authorities or cover only subsets, so authority, trust, and payment fracture exactly where autonomy needs continuity: when a key rotates or a delegation must be revoked. We present NostrAgent, a decentralized architecture that unifies all five over Nostr relays using three custom event kinds: Kind 38100 identity declarations authenticated by BIP340 Schnorr signatures with pre-rotation commitments, Kind 38101 scoped delegation chains whose every hop verifiably narrows granted capabilities, and Kind 38102 peer attestations forming a Sybil-deterrent trust graph, with Lightning HTTP 402 (L402) binding payment to agent identity. Identity remains operator-sovereign without any registration authority; relays are substitutable transport rather than a trust root; and every authorization decision is replayable offline from signed events. We evaluate a Python prototype with a mixed-method design: ATAM quality analysis with a two-round mini-Delphi panel, STRIDE threat modeling across three trust boundaries, eleven benchmarks with non-parametric statistics, and 19 failure modes. Results show sub-millisecond offline verification, linear delegation-chain scaling, and Lightning-settled L402 at 157 ms median on regtest. 17 of 19 failure modes pass empirically, one is bounded analytically, and one is disclosed as an architectural limitation. NostrAgent demonstrates an auditable prototype substrate for trustworthy agentic systems without centralized trust roots.

Sat 19 SeptSoftware EngineeringArtificial IntelligenceMultiagent Systems
The gist
AI agents that act for people often need to prove who they are, trust other agents, and manage payments, but these tasks usually rely on different systems controlled by central authorities. The authors introduce NostrAgent, a new decentralized system that handles identity, delegation, trust, discovery, and payments all together without needing a central authority. It uses special message types and cryptographic signatures to keep things secure and lets agents work smoothly even if keys change or permissions are revoked. Their tests show it works quickly and reliably, offering a new foundation for safe distributed AI agents.
Open → 2609.22944v1

Blockchain validators enable efficient historical data proofs with write logs

You've Got a BUD in Me: Authenticated Reads from Per-Block Write Logs

Abstract: Blockchains usually pay for authenticated reads by maintaining a structure that spans the entire state. We show how validators can support historical membership and exclusion proofs by authenticating each block's writes instead. A Block Update Digest (BUD) commits a write log whose predecessor pointers link successive modifications of each key. A SuperBUD summarizes last writes over a window; an exponential hierarchy turns long unchanged intervals into short proofs. The digest count is logarithmic in the gap within the hierarchy's range, with one additional digest per top-level window beyond it. We prove soundness against adversarial provers and up to f Byzantine validators, and completeness for queries anchored by a post-deployment modification, assuming archive, attestation, and committee evidence is available. Across a 50x increase in state size, the measured base-BUD path rises by 1.24x, compared with 3.1x and 69.5x for in-memory and cache-bounded disk-backed Merkle Patricia tries. On the synthetic trace, two-digest read-layer payloads stay below 800 bytes, and warm hash-path verification takes at most 146 microseconds at p99.

Thu 10 SeptCryptography and SecurityDatabasesDistributed, Parallel, and Cluster Computing
The gist
Blockchain systems need a way to prove that data was or wasn’t part of their history, which usually costs extra computational work over all stored data. The authors propose a way for participants called validators to prove past states by only focusing on the changes each new block made, instead of tracking the whole dataset. They introduce structures called Block Update Digests (BUDs) that link successive changes to data keys, and a hierarchy that lets proofs stay small and quick even if data hasn’t changed for a long time. Their approach reduces proof sizes and verification times significantly compared to other common methods, making it more efficient for blockchains to provide historical proofs.
Open → 2609.11251v1