This paper presents a unified back‑end settlement architecture designed to support multi‑rail, ledger‑agnostic financial transactions across modern digital asset systems. It defines a deterministic settlement model capable of coordinating fiat rails, tokenized assets, distributed ledgers, and messaging networks under a single canonical framework. The architecture introduces a universal settlement core that abstracts rail‑specific behaviors into standardized primitives, enabling consistent execution, reconciliation, and finality across heterogeneous systems. It incorporates a canonical identity layer, semantic tokenization model, and compliance‑aware routing logic to ensure interoperability between traditional financial infrastructure and emerging tokenized environments. Key contributions include: A multi‑rail settlement engine supporting synchronous and asynchronous flows Deterministic finality logic for cross‑rail and cross‑ledger operations A universal bridge framework for rail‑agnostic asset movement Canonical identity mapping for participants, assets, and transaction states Semantic tokenization rules enabling unified representation of digital and traditional instruments Compliance and audit primitives embedded directly into the settlement workflow This work provides a complete architectural foundation for institutions seeking to modernize settlement operations, integrate tokenized assets, and achieve interoperability across fragmented financial rails. It serves as a reference model for next‑generation clearing and settlement systems.
Zhongjing Wei, Osaid Muhammad Ameer, Nikita Borisov, Yupeng Zhang
Modernizing the security of operational technology systems that control critical infrastructure has become a pressing challenge. Because edge devices have limited capabilities, modernization has relied on application gateways that interface with identity management systems and enforce access policies. These gateways are powerful enough to perform complex authorization decisions and support zero-trust architectures, but they create major deployment and management burdens: they must be collocated with remote, distributed edge devices, kept up to date with security patches, and managed with minimal downtime. We propose Provable Remote Execution of Zero-Trust Authorization (Prezta), an architecture that eliminates these gateways by evaluating policies within a zero-knowledge virtual machine (zkVM) running on the client. The zkVM produces a succinct proof of authorization that edge devices can verify efficiently, extending the zero-trust security envelope to the edge. Policies and identity management schemes can evolve without updating edge devices. To demonstrate the feasibility of Prezta, we implement a prototype built using the RISC Zero zkVM that supports XACML 3.0 policies and JWT identity claims. While zkVMs introduce substantial proof overhead, we mitigate this overhead by compiling policies to Rust code and precompiling regular expressions. Combined with optimized signature verification and JWT parsing, these measures reduce prover time by more than an order of magnitude. Our compiler correctly implements 83\% of the XACML 3.0 conformance suite, with proof generation completing in tens of seconds on a desktop. Verification, by contrast, takes only tens of milliseconds, which is fast enough for resource-constrained edge devices.
Abstract Stateless Ethereum is one of the most promising directions for improving blockchain scalability, but witness size remains a major deployment challenge. Existing witness generation techniques often treat all transaction workloads uniformly, resulting in unnecessary communication overhead and reduced verification efficiency. This paper presents AWCV (Adaptive Witness Compression for Stateless Ethereum Using Verkle Trees), an adaptive compression framework that reduces witness size while preserving efficient verification. AWCV combines locality-aware transaction clustering, subtree deduplication, adaptive witness construction, and delta encoding to eliminate redundant proof data without modifying Ethereum's verification semantics. The proposed framework is evaluated across representative blockchain workloads and demonstrates significant reductions in witness size, bandwidth requirements, and verification latency compared with conventional witness generation approaches. AWCV remains fully compatible with Ethereum's Verkle Tree roadmap while improving the practicality of stateless client synchronization and scalable decentralized applications. The results suggest that adaptive witness compression provides an effective and practical path toward efficient Stateless Ethereum deployments without sacrificing security or correctness.
Consensus algorithms form the core of distributed systems, enabling multiple nodes to agree on a single, consistent state even in the presence of failures, delays, or malicious actors. This chapter provides an in-depth examination of the principles, mechanisms, and practical applications of consensus in decentralized networks. Foundational models such as crash-fault tolerance (CFT) and Byzantine-fault tolerance (BFT) are introduced to explain system reliability under different failure assumptions. Major consensus algorithms, including Proof of Work (PoW), Proof of Stake (PoS), Practical Byzantine Fault Tolerance (PBFT), Raft, and Paxos, are analyzed with respect to their design logic, operational characteristics, security assumptions, and performance trade-offs. The chapter also explores emerging consensus innovations aimed at improving scalability, energy efficiency, and decentralization. By connecting theoretical foundations with real-world implementations, this work provides readers with a comprehensive understanding of how consensus algorithms maintain trust, integrity, and robustness within blockchain platforms, distributed databases, and large-scale multi-agent systems.
Consensus algorithms are the foundational mechanisms that enable blockchain networks to operate securely, transparently, and without centralized control. This chapter explores the deep interconnection between consensus mechanisms and blockchain architecture, highlighting how decentralized agreement is achieved across distributed nodes. Core concepts such as trustless coordination, ledger immutability, and fault tolerance are introduced to illustrate why consensus is critical for blockchain reliability. Major consensus models, including Proof of Work (PoW), Proof of Stake (PoS), Delegated Proof of Stake (DPoS), and Byzantine Fault Tolerant (BFT) protocols, are analyzed in terms of performance, security assumptions, energy consumption, and scalability. Real-world applications and blockchain platforms are examined to demonstrate how different consensus choices influence system behavior and design trade-offs. The chapter also discusses emerging innovations in hybrid, energy-efficient, and scalable consensus systems. By linking theory with practical implementation, this chapter provides a clear understanding of how consensus algorithms ensure integrity and trust within blockchain ecosystems.
Distributed systems can verify whether a transaction or state transition is valid, yet they often cannot establish whether the underlying action was authorized under a meaningful, current, and context-specific expression of consent. This limitation becomes increasingly significant as autonomous software agents, artificial intelligence systems, decentralized applications, and connected devices act across organizational and technical boundaries. This article presents a nonproprietary framework for verifiable consent in distributed systems through AI-assisted identity governance and recursive zero-knowledge proofs. The framework represents consent as a structured, machine-verifiable authorization object containing the consenting subject, requesting actor, permitted action, contextual constraints, validity period, policy version, and revocation state. A bounded AI-governance layer evaluates requests against explicit policies and contextual evidence while remaining subordinate to deterministic rules, human-defined constraints, and auditable decision procedures. Approved authorization statements are transformed into privacy-preserving cryptographic proofs, allowing a verifier to confirm that relevant consent and policy conditions were satisfied without requiring disclosure of the underlying identity attributes, private data, or complete policy record. To support high-volume environments, individual proofs may be recursively composed into succinct aggregate proofs. This construction separates expensive proof generation from efficient downstream verification and provides a basis for scalable authorization auditing across distributed infrastructure. The article defines the system model, consent lifecycle, trust assumptions, proof relationships, revocation requirements, and principal security properties, including authorization soundness, privacy preservation, replay resistance, policy-version integrity, and revocation safety. It also analyzes the architectural tradeoffs associated with AI reasoning, cryptographic proving costs, governance design, key management, and interoperability. The proposed framework does not disclose implementation-specific circuits, source code, model configurations, deployment topology, or proprietary protocol parameters. Instead, it establishes a general research foundation for treating consent as a verifiable computational primitive. Potential applications include decentralized identity, autonomous agents, regulated data exchange, financial services, healthcare information systems, Internet of Things networks, and cross-platform digital authorization.
This research introduces a radical paradigm shift in decentralized economic consensus and distributed ledger technology, moving beyond the thermodynamic inefficiencies of Proof-of-Work (PoW) and the quantum vulnerabilities of conventional Elliptic Curve Cryptography (ECDSA). By integrating Hyperdimensional Computing (HDC) within a 10,000-dimensional bipolar vector space and Module Learning with Errors (MLWE) via the ML-DSA (FIPS 204) post-quantum signature standard, this paper proposes the Asymptotic Stigmergic Lattice Consensus (ASLC) architecture. Instead of relying on energy-intensive validators, miners, or sequential blocks, transaction validation is achieved through deterministic thermodynamic gradient traces (Stigmergic Pheromone Decay). Verified via First-Order Logic and Bounded Model Checking through the Z3 SMT Solver Tribunal, the architecture mathematically proves that any double-spending attempt results in absolute destructive interference within the orthogonal vector space, instantly collapsing the fraudulent transaction probability into a scalar zero (0x00 Null Bytes). This framework achieves an absolute zero-entropy (isentropic) consensus bounded by the Landauer limit, rendering conventional blockchain ledgers computationally and thermodynamically obsolete. Keywords: Distributed Ledger Technology, Post-Quantum Cryptography, ML-DSA, Hyperdimensional Computing, Isentropic Consensus, Pheromone Decay, Double-Spending, Z3 SMT Solver, Bounded Model Checking, Zero-Miner Consensus
Zero-knowledge proof systems rely on a trusted setup phase to generate a Common Reference String (CRS), yet existing approaches are typically static, one-time ceremonies that are inflexible and vulnerable to long-term compromise. Offloading continuous, recurring trusted setups to a decentralized Layer 2 (L2) network introduces a fundamental coordination challenge arising from the mismatch between high-throughput transaction processing and the multi-round requirements of trusted setup ceremonies. This paper presents an L2-coordinated framework that safely decouples transaction pipelines from ceremony execution to achieve automated, continuous CRS generation without centralized coordination. We design and implement two protocol variants over a decentralized, PBFT-coordinated ZK-rollup architecture: an on-chain smart contract approach and an asynchronous peer-to-peer consensus variant. Both designs utilize non-interactive zero-knowledge proofs of knowledge alongside commit-reveal structures to eliminate adaptive manipulation vectors and isolate ceremony latency. Experimental evaluations under simulated wide-area network constraints and adversarial conditions demonstrate that our architecture successfully isolates ceremony liveness. Continuous setups complete reliably within practical time bounds despite node dropouts or malicious contributions, while preserving stable L2 transaction throughput.
Zhengqing Liu, Alberto Sonnino, Igor Zablotchi, Eleftherios Kokoris-Kogias · 5 authors
Modern blockchains rely on a modular architecture that decouples consensus from execution. Recent advances in consensus algorithms have shifted the bottleneck to the execution layer, which must deterministically follow the consensus order and handle increasingly complex, compute-intensive smart contracts. We identify that single-node validators cannot keep up, motivating the need for a scale-out design. We design Remora, a scale-out smart contract execution engine. Remora adopts an efficient asymmetric architecture with centralized transaction dispatching and distributed execution, and depends on an object versioning scheme with a strict ownership model to guarantee deterministic scale-out execution. Remora achieves up to 3x throughput improvement compared to state-of-the-art deterministic execution schemes, scales up to 250k TPS, matching modern consensus performance, and reduces latency by up to 5ms. We also show that Remora elastically adapts to bursty workloads and dynamic access patterns using real-world traces. Remora's main performance benefits come from a novel stateless-stateful separation during smart contract execution, which overlaps the execution of state-independent tasks with consensus, and a new locality-aware and load-balanced scheduling scheme.
Harlequin is a blockchain protocol in which the right to take part in consensus,governance and adjudication comes solely from reputation earned by verifiable acts— never from capital (proof of stake) or expended computation (proof of work).Reputation is a four-dimensional quantity ("the four suits"), computeddeterministically from a public evidence record by a damped trust-propagationfunction, aggregated conservatively (a strong dimension cannot buy authority in aweak one), and subject to time decay so that standing must be continuallyre-earned. Block authorship and committee/jury membership are assigned byreputation-weighted cryptographic sortition; finality is provided by aByzantine-safe gadget over signed votes; disputes are judged by sortitioned jurieswith interest-exclusion, and the only enforced consequence is reputational — theprotocol applies no coercive force. We give the system model, the consensus and justice mechanisms, and a securityanalysis against a state-level adversary whose goal is capture, censorship orde-anonymization rather than direct theft. Two results are emphasized for theirhonesty. First, steady-state Sybil resistance is strong: a Sybil farm withoutearned evidence obtains about 0% of consensus power (17/17 adversarial tests).Second, the cold-start window is not unconditionally safe: a competent adversarypresent at genesis can capture the bootstrap; we show the security of that windowis a race between honest onboarding and adversary mass — bounded, not eliminated,by non-operator personhood verification, an automatic ceiling-halt and theonboarding rate, with the residual risk declared. We report an implementation inRust (dependency-free cores cross-validated against FRAME pallets) and areproducible validation record spanning unit tests and multi-node hardware runs.
Understanding Proof-of-Work in Blockchain: Foundations, Security, and Limitations Keywords: Blockchain, Consensus, Proof-of-Work, Cryptographic Hash, Cryptography, 51% Attack. 1. Introduction In traditional distributed systems, such as banking databases, a central authority determines transaction validity. In contrast, decentralized networks like Bitcoin lack a central server, allowing unrestricted participation. This structure introduces two significant challenges:This results in two critical challenges: 1. The Byzantine Generals Problem: How do independent nodes agree on a single history of data if some nodes are malicious or untruthful? 2. Sybil Attacks: What stops an attacker from creating 10 million fake virtual nodes to vote and overpower honest nodes? Proof-of-Work (PoW) addresses both challenges. Instead of assigning one vote per identity, which is susceptible to falsification, PoW allocates voting power according to computational resources, which require significant hardware and energy investment. 2. The Core Mechanics: How Mining Actually Works Mining functions as a network-wide lottery, where the probability of success is proportional to computational speed. The process begins with solving a cryptographic puzzle. 2.1 The Cryptographic Puzzle A block consists of a batch of transactions, the hash of the previous block, and a field called a nonce (number used once). Miners repeatedly modify the nonce until the hash of the entire block matches a specific pattern.Specifically, the resulting hash must be less than or equal to a predetermined target value. +---------------------------------------------------------+ | BLOCK HEADER | | [Prev Hash] + [Merkle Root (TXs)] + [Timestamp] + [Nonce] | +---------------------------------------------------------+ | v SHA-256 Hashing | v Is the Hash < Target Threshold? / \ YES NO / \ [Success! Broadcast Block] [Increment Nonce & Try Again] Because SHA-256 is a cryptographic hash function, it has two key properties: Pre-image Resistance (One-Way): You cannot reverse-engineer a hash. If I give you a hash output, you cannot calculate the input. Avalanche Effect: Changing just one bit in the nonce completely alters the final hash output unpredictably. As a result, no mathematical shortcut exists for determining the correct nonce. Miners must use brute-force computation, generating billions of hashes per second (hash rate) until a valid solution is identified (Hash Rate — Measuring Bitcoin's Mining Power, 2026). Once a solution is found, the miner broadcasts the block, and other nodes verify it instantly with a single hash calculation, illustrating computational asymmetry. This mechanism maintains the network's equilibrium. 2.2 Difficulty Adjustment When additional miners join the network, the aggregate hash rate increases, resulting in faster block discovery. To maintain consistent block times, the protocol automatically adjusts the target threshold.If blocks are being found faster than the target time (e.g., 10 minutes in Bitcoin), the target number decreases. A smaller target means the hash must start with more leading zeros, making it statistically harder to guess. 3. Security Framework: The Rules of Engagement PoW operates on the economic principle that securing the network should be more profitable than attacking it. The following rule defines the network's dispute resolution mechanism. 3.1 The Longest Chain Rule If two miners simultaneously discover valid blocks, the network temporarily splits into two branches, known as a fork. Nodes resolve this by following the longest chain, which is defined as the branch with the greatest accumulated proof-of-work, thus maintaining a unified transaction history. [Block 101] ---> (Orphaned / Dropped) / ---- [Block 100] --+ \ [Block 101] ---> [Block 102] <--- Longest Chain (Accepted) 3.2 The 51% Attack If an attacker manages to control more than 50% of the network’s total computing power, they can out-mine the honest portion of the network.An attacker may mine a private chain in secret, spend coins on the public chain, and later broadcast the longer private chain. According to the longest chain rule, the network accepts the attacker's version of history, thereby invalidating transactions on the honest chain. This scenario, known as a Double-Spend Attack, highlights a significant vulnerability and contributes to ongoing criticism of PoW despite its security advantages. 4. Why the Industry is Moving Away from PoW While PoW is incredibly secure, it has two major flaws that make it difficult to scale for modern applications. 4.1 The Scalability Problem In PoW systems, each full node must process and store every transaction for verification. Due to limited block sizes and intentionally high block times to prevent network desynchronization, transaction throughput remains low. For example, Bitcoin processes approximately 7 transactions per second (TPS), whereas Visa handles thousands of TPS. 4.2 Energy Consumption Miners compete to achieve the highest hash rate by continuously operating large-scale data centers equipped with specialized hardware (ASICs). This process consumes substantial amounts of electricity, comparable to the consumption of a medium-sized country, and results in significant environmental impact. 5. Conclusion Proof-of-Work constituted a significant advancement in computer science by linking digital consensus to physical resource constraints, particularly energy. This innovation demonstrated the feasibility of decentralized trust. However, due to limited throughput and substantial energy requirements, newer blockchain networks increasingly adopt alternative consensus mechanisms, such as Proof-of-Stake (PoS), where voting power is determined by cryptocurrency holdings rather than energy expenditure. References Nakamoto, S. (2008). Bitcoin: A Peer-to-Peer Electronic Cash System. (The original whitepaper). Eyal, I., & Sirer, E. G. (2014). Majority is not enough: Bitcoin mining is vulnerable. (Introduced the concept of Selfish Mining). Narayanan, A., et al. (2016). Bitcoin and Cryptocurrency Technologies. Princeton University Press. (An excellent foundational textbook for CS students). (2026). Hash Rate — Measuring Bitcoin's Mining Power. Bitcoin Notes Online. https://www.bitcoinnotesonline.com/learn/hash-rate
The increasing demand for verifiable computation in privacy-sensitive distributed systems has driven the widespread adoption of Zero-Knowledge Proofs (ZKPs). However, the various kinds of current ZKP frameworks—which include zk-SNARKs, zk-STARKs, Bulletproofs, and folding-based systems—introduce complex trade-offs across proof size, prover cost, and trust assumptions, making system selection challenging in actual practice. This paper presents a systematic, application-oriented survey that connects ZKP design choices with real-world deployment constraints. It provides a comparative analysis of major constructions to evaluate their performance and security properties. Furthermore, these trade-offs are mapped to representative application scenarios, including Layer 1/Layer 2 blockchain scaling, Decentralized Identity (DID), and Verifiable Machine Learning (zkML), explaining how different systems are selected based on application-specific requirements. In addition, the paper discusses emerging paradigms such as hardware acceleration, binary field optimizations, and lookup-based zkVMs, which aim to address the prover bottleneck. Overall, this survey provides a structured understanding of the strengths and limitations of existing ZKP systems and offers insights for the design of scalable and privacy-preserving infrastructures.
The Adaptive Neural Gossip Protocol (ANGP) is a fully decentralized, asynchronous consensus mechanism designed for Directed Acyclic Graph (DAG) based distributed ledgers. Unlike classical Byzantine Fault Tolerant (BFT) systems that rely on leader election or quorums, ANGP uses:• Amedian-based consensus computed from predictions exchanged via gossip.• A continuous reputation engine that distinguishes honest nodes from Byzantine attackers, including coordinated collusion, rare attacks, sensor faults, and network impairments.• Alightweight Proof-of-Work (PoW) layer (SHA-512/256) to prevent Sybil identity floods, while keeping the core protocol free of staking or token-based governance.ANGP tolerates up to 44% coordinated attackers and 66% uncoordinated attackers with no degradation in honest node safety. It operates asynchronously, requires no global time synchronization, and self-heals under packet loss and network delays. This document provides the complete architectural blueprint, component specifications, security analysis, and integration guidelines for building a production-grade DAG based cryptocurrency or distributed application on top of ANGP.
Hüseyin Ahmet Cemil Özaslan, Şafak Durukan-Odabaşı
Smart contracts have become a fundamental component of blockchain ecosystems, and their reliability is strongly shaped by the programming languages in which they are written. While prior studies have classified vulnerabilities, fewer have quantitatively examined how language design and secure coding practices affect performance and resilience. To address this gap, this study empirically compares Solidity and Vyper under controlled conditions and complements these experiments with a literature-based evaluation of Rust and Move. Test scenarios included deployment, deposits, withdrawals, arithmetic overflow, reentrancy, and transaction origin misuse. For both vulnerable and secure variants in Solidity and Vyper, metrics such as gas consumption, deployment size, and runtime execution time were collected. The results indicate that deployment costs differ substantially between the two languages (Solidity ≈ 177 k gas vs Vyper ≈ 135 k gas, ~24% lower), whereas runtime performance is mixed: deposit calls are nearly identical (Δ ≈ 0.02 ms), whereas withdraw shows a noticeable gap (Δ ≈ 4.97 ms) favoring Vyper; nevertheless, these call-level differences remain small relative to the larger deployment-time gap. Importantly, secure coding practices such as explicit arithmetic checks and the Checks–Effects–Interactions pattern eliminate critical vulnerabilities while adding less than 1% to the overall execution cost. Although Rust and Move are considered through a literature-based review, they illustrate alternative approaches that embed security guarantees directly into the language. Based on these observations, this study proposes a measurable framework to understand how different smart contract programming languages vary in terms of security and efficiency, emphasizing the role of language design and secure coding practices in shaping contract development.
Decentralized Finance (DeFi) applications rely heavily on the order in which transactions are executed, making them susceptible to reordering attacks that enable adversaries to extract Blockchain Extractable Value (BEV). While linear blockchain systems such as Ethereum have inspired extensive research into fair ordering mechanisms, DAG-based consensus protocols have remained largely unprotected despite their growing adoption for scalability and performance. In this paper, we introduce Tilikum, a DAG-based ledger protocol that ensures fair transaction ordering without relying on weak edges. Tilikum achieves ordering linearizability by leveraging median-based timestamp aggregation, or batch order fairness, while maintaining low data redundancy and robust garbage collection. We implemented Tilikum in Rust and evaluated it against representative baselines, namely Narwhal/Tusk, Pompē, Themis and FairDAG. Our results show that Tilikum achieves up to $39\times$ higher throughput than other fair-ordering baselines, while fully blocking state-of-the-art DAG-specific reordering attacks.
Christoph Lenzen, Julian Loss, Kecheng Shi, Benedikt Wagner
Byzantine Agreement and Broadcast are traditionally studied in one of two extremes: the authenticated setting, where a public key infrastructure (PKI) enables universally verifiable signatures and yields higher fault tolerance, and the unauthenticated setting, where no PKI is available and resilience necessarily drops. Motivated by Proof-of-Stake blockchains, where only a stable subset of participants (e.g., validators) have registered long-term keys while others do not, we initiate a systematic study of consensus in the \emph{partially authenticated} setting, where a subset of parties are \emph{registered} in a PKI and the remaining parties are \emph{unregistered}. We provide a nearly complete feasibility characterization of the resilience as a function of the number $s$ of registered parties among $n$ total parties. First, we show that Byzantine Agreement or Byzantine Broadcast with an \emph{unregistered} sender is possible if and only if $t \le \max\{\lceil s/2\rceil,\lceil n/3\rceil\}-1$, matching a simple protocol and an impossibility bound. Second, for Byzantine Broadcast with a \emph{registered} sender, we give a deterministic synchronous broadcast protocol tolerating up to $t \le s + \lceil (n-s)/3\rceil - 1$ Byzantine faults (equivalently, $3t
Blockchains are distributed ledgers that let mutually distrustful parties agree on an append-only transaction history without relying on a central authority. By combining cryptographic hashing, digital signatures, and consensus mechanisms, blockchains provide tamper evidence, auditability, and agreement among nodes. Modern blockchain systems significantly vary in consensus design (e.g., Proof of Work, Proof of Stake, Proof of Author- ity, and Byzantine Fault Tolerance mechanisms), access model (open vs. permissioned), and execution layers (from simple asset transfers to expressive smart-contract virtual machines). The related architectural choices shape decentralization, fault tolerance, and the attainable latency-throughput envelope. As blockchain deployments expand to payments, tokenization, decentralized finance, supply chain traceability, and digital identities, comparing these systems has become an urgent necessity. Unfortunately, rigorous blockchain evaluation remains difficult. On the one hand, measurements are confounded by fluctuating network conditions, heterogeneous infrastructures, and rapidly evolving software. On the other hand, results are too often collapsed to a single number (such as transactions per second) without dispersion or methodological details; economic assessments of crypto-assets lack a unified and interpretable index that captures the balance of core economic parameters and their trade-offs (usage, liquidity, stability, and security) rather than market price sentiment; and experimental studies rarely address the dimensions of experimental repeatability (same setup, same results) and performance predictability (stable expectation). The consequence is an evidence gap: how to assess and compare the efficiency of blockchains – spanning performance, energy, economics, and result stability – in different scenarios? This dissertation aims at reducing this gap with a coherent yet modular approach that combines topology-controlled benchmarking with an orthogonal, entropy-based economic analysis, delivering four contributions. First, it introduces Lilith, a system-agnostic benchmarking framework that couples workload generation with network emulation to run controlled, repeatable experiments under explicit overlay topologies (i.e., the logical peer- to-peer connectivity graphs) and link properties such as latency, bandwidth, and packet loss. Lilith orchestrates deterministic deployments (pinned artifacts, controlled boot order, and CPU core pinning and memory binding), integrates power probes, and provides a uniform client interface; this underpins a comparison based on typical performance metrics. Second, Lilith is employed to quantify blockchain energy consumption under realistic conditions. Third, Lilith is adopted for a network-controlled, multi-run measurement campaign to produce a public dataset. By combining dispersion metrics (e.g., worst-case deviation) with analysis of variance and intraclass correlation, we quantify run-to-run variability and performance predictability across blockchains, topologies, workloads, and node-set sizes. Fourth, in addition to Lilith, the dissertation introduces the Entropy Balance index (EB-index), which aggregates heterogeneous on-chain indicators into a single, interpretable score of economic efficiency. ii As for the first three contributions, we set up the experimental baseline by considering five network topologies (fat-tree, full mesh, hypercube, scale-free, torus) and five industry- grade blockchains (Algorand, Diem, Ethereum Clique, Quorum IBFT, Solana), exercised with transfer transactions and smart-contract workloads (DDoS, FIFA, GAFAM, gaming, PayPal, VISA) across two node-set sizes (10 and 40). In the performance study, the network topology emerges as the primary factor de- termining throughput and latency. Full mesh, hypercube, and torus deliver higher performance under heavy load. The performance of Algorand and Diem is stable with respect to topology changes, while Ethereum is less sensitive but remains slower. In the energy study, fat-tree and full mesh turn out to be the most energy-efficient topologies, especially at high load. Algorand and Diem exhibit the lowest energy per transaction, Ethereum Clique the highest across topologies; Quorum IBFT and Solana become costlier as workload intensity and network size increase. The experimental repeatability and performance predictability study shows low per- formance variance (transactions per second, block latency, energy consumption) for Algorand and Diem and pronounced sensitivity for Solana and Quorum IBFT, especially as workloads, node-set size, and geo-latency conditions vary. The released dataset and the accompanying analysis templates, which are based on clusters instead of public-cloud testing, enable thorough checks that go beyond point estimates by quantifying dispersion and confidence in comparative results. Finally, in the economic study, the EB-index aggregates heterogeneous on-chain indicators – such as user activity (transactions, active addresses), token distribution (balance concentration), and supply turnover/velocity – by using the normalized Shannon entropy and its weighted Beliş-Guiaşu variant. When applied to the capitalization-based leading crypto-assets Bitcoin, Ethereum, Ripple, USD Coin, Dogecoin, and Cardano, the EB-index separates volume-driven bursts from structurally balanced ecosystems and reveals differences that price, total value locked, or raw activity may blur. Overall, this dissertation delivers a topology-aware blockchain benchmarking frame- work, empirical evidence that network structure materially affects performance and energy, a public multi-run dataset together with analysis templates that promote experimental repeatability and performance predictability, and an entropy-based index for assessing economic efficiency.
Ethereum Layer 2 (L2) rollups improve scalability but expose a trade-off between fast sequencer soft finality and slow Layer 1 (L1) settlement finality, limiting latency-sensitive applications that require timely and durable guarantees on transaction ordering. We introduce a Byzantine Fault Tolerant (BFT) finality layer that extends existing rollup architectures without requiring L1 or rollup protocol changes. This layer provides deterministic transaction-level finality ahead of L1 settlement by committing to the sequencer's transaction order, bridging the gap between soft and hard finality. At its core, the layer uses a 1-chain variant of the Jolteon consensus protocol, adapted to the rollup setting where a single sequencer determines transaction ordering. Experiments show sub-second committee finalization latency and stable performance under Byzantine faults.
Zero-knowledge proof (ZKP) is a promising cryptographic protocol, but its practical deployment is hindered by the time-consuming proof generation. The proof generation inherently exhibits high-degree parallelism, yet challenges persist in exploiting fine-grained parallelism due to the dataflow complexity, impeding previous work to achieve optimal acceleration. In this work, we propose FZKP, a ZKP accelerator that utilizes two novel fine-grained dataflows coupled with two forward-flow microarchitectures to alleviate dataflow complexity, efficiently exploiting fine-grained parallelism. The proposed dataflows simplify the dataflow pattern for parallel execution, disclosing fine-grained parallelism at a low cost. The microarchitectures employ a base design to handle large bit-width intermediate results for timely consumption. They then replicate and combine the base design following the proposed dataflow to facilitate parallel execution. When evaluated in 12 nm, FZKP achieves an average speedup of 10.3× and 2.2× over the state-of-the-art GPU-based solution and ZKP accelerator on real-world workloads, respectively.
This manuscript develops Dormant Continuity Theory (DCT), a protocol-relative mathematical framework for reasoning about systems that remain inactive at their protected core while retaining auditable continuity, recovery, diagnostic, and handoff capabilities. The theory formalizes dormant processes using finite transition systems, typed certificates, observable histories, evidence algebra, guarded authorization, replayable resolution, extraction adequacy, and fail-closed classification.DCT addresses practical challenges in long-lived distributed systems, including forked ledger histories, bounded model checking, data availability, zero-knowledge proof soundness boundaries, watcher incentives, MEV-resistant reward mechanisms, resource conservation, guardian corruption, maintenance transitions, and certificate-level HTLC handoff to extinction-style OSCT semantics. The framework distinguishes safety, bounded-griefing, diagnostic routing, and liveness assumptions, avoiding unconditional trustless claims while providing a rigorous finite core for verification and implementation-oriented extensions.
PYCO is the native token of the Lindblad Protocol, emerging as a direct consequence of a network that measures and rewards physical coherence. This paper describes the mechanism by which PYCO is generated, distributed, and consumed within the Spectral Ledger, and establishes the economic properties that result from anchoring token issuance in physical hardware validation. Every PYCO in existence was produced by a physical node running the Lindblad Cryptography Protocol (LCP) stack on real hardware. As of June 2026, over 1,512,000 PYCO have been mined across 35,842+ epochs by physical hardware nodes deployed on mainnet on Arbitrum One.
Proof-of-Stake DAG-BFT consensus faces a trilemma between sybil resistance, reward fairness, and plutocracy. Existing protocols prioritize liveness over fair stake-based selection, driving longitudinal centralization. FairWave is a dual-channel DAG-BFT protocol that separates anchor selection from reward distribution. The selection channel is super-linear in stake, guaranteeing Sybil gain < 1 for K > 1; the reward channel is sub-linear via square-root stake normalization. DAG-derived uptime and latency metrics eliminate external oracles,and lagged reputation breaks circular dependency between selection outcomes and weights. Evaluated through approximately 550,000 Monte Carlo rounds against eight baselines, FairWave shows Gini 0.140 (vs. Pure-PoS 0.490, monotone HHI reduction from 0.039 to 0.020 over 50,000 epochs, and optimal Sybil split K * = 1. Safety follows unconditionally from the 2f + 1 commit rule; the liveness model predicts monotone degradation from 94.0% at b = 0.20 to 74.0% at b = 1/3, consistent with the architectural expectation of no discontinuous cliff.
Abstract : Global payment platforms have grown into extraordinarily complex financial ecosystems, ones that touch dozens of legal entities, hundreds of currency pairs, and numerous regulatory perimeters, often within the lifecycle of a single transaction. This technical review examines how multi-entity ledger architectures can be designed to meet that complexity, with particular focus on customer liability management, payables and receivables tracking, revenue recognition, transaction cost monitoring, loss accounting, and cash management reconciliation. Beyond structural design, the review explores how embedded control frameworks, self-healing exception pipelines, and trend-based anomaly detection can meaningfully reduce operational overhead while improving financial accuracy. Practical diagnostic examples are included, including how a rising transaction cost ratio can signal that an external processor has silently risk-flagged a merchant's traffic due to missing critical data fields. Visual dashboards and architecture diagrams support these concepts throughout. The article uses peer-reviewed and practitioner literature from the fields of fintech, distributed systems, and financial governance
Alireza Kavousi, István András Seres, Zhipeng Wang
Regulatory compliance is increasingly mandatory for decentralized finance and privacy-enhancing technologies. Current approaches rely on binary inclusion/exclusion lists or retroactive graph analysis by centralized blockchain intelligence firms. This approach strips honest users of their financial privacy, leads to false positives and negatives, and forces decentralized platforms to bear the burden of on-chain transaction monitoring. In this work, we propose a paradigm shift: moving from platform-side surveillance to user-side provenance. We introduce Proof of Source of Funds (PoSoF), a novel cryptographic framework that shifts the burden to the user. Rather than the platform tracing funds, the user locally generates a zero-knowledge proof demonstrating that their deposit originates exclusively from a set of compliant sources. The platform is thus relieved of chain-analysis duties, requiring a constant-time, O(1) verification to enforce admission control. We formulate a unified temporal Directed Acyclic Graph (DAG) abstraction that formalizes both UTXO and account-based ledger histories within a generalized value-flow model. Users extract a compliant sub-DAG of their transaction history and utilize Incrementally Verifiable Computation (IVC) to prove rigorous state-transition predicates that protect against various attack vectors. Crucially, PoSoF provides verifiable cryptographic provenance; it guarantees the legitimacy of the funds without leaking the intermediate transaction topology, intermediary addresses, or the specific origins utilized. We formally define the security properties of PoSoF and evaluate an Ethereum-compatible prototype. Our benchmarks demonstrate that fully private, proactive compliance is highly practical, requiring only ~1.8 s to incrementally update a user's PoSoF per new transaction, and a constant-time ~1.5 ms (~800k gas) for final on-chain EVM verification.