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
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.
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.
Salience-Queue Occupation Theory (SQOT) is a protocol-relative mathematical framework for analyzing when finite-budget operational processes lose effective control over their priority queues under persistent or adversarial salience sources. The manuscript formalizes salience occupation using observable histories, budget ledgers, diagnostic reserves, queue morphisms, finite certificate grammars, checkable ledgers, typed risk composition, self-auditing kernels, and route-sound checker semantics. The theory is designed for artificial, distributed, or post-biological operational systems, but it does not rely on subjective psychology or normative claims about what a process should attend to. Instead, it studies finite, auditable conditions under which a process can preserve diagnostic capacity, response or no-action availability, rollback or quarantine options, semantic-egress safety, mechanism-compatible incentives, and bounded verification cost. The results include finite checker semantics soundness, checked non-circular sovereignty certificates, typed risk composition, adaptive succinct-session soundness, egress abstraction refinement, and payoff-reflected mechanism robustness. SQOT explicitly limits its claims to declared validity domains and does not assert absolute physical, cryptographic, economic, or base-reality guarantees.
Trusted Execution Environments (TEEs) have emerged as a critical technology for safeguarding sensitive data and ensuring code integrity in modern computing systems. However, relying on a single TEE implementation makes systems vulnerable to a central point of attack. Building distributed-trust systems leveraging heterogeneous TEEs helps disperse trust but still faces threats from centralized management and adaptive mobile adversaries. To address these challenges, this paper introduces TeeDAO, a novel three-layer framework that automatically organizes multiple heterogeneous TEE instances and provides unified interfaces to support diverse applications, while ensuring long-term guarantees of availability, integrity, and confidentiality. TeeDAO couples BFT-ordered governance with heterogeneity-aware Distributed Proactive Secret Sharing (DPSS) and Secure Multi-Party Computation (MPC) so that attestation-driven committee changes are consistently reflected in secret recovery, resharing, and computation across a dynamic committee of heterogeneous TEEs. We implement a prototype of TeeDAO, integrating COBRA's DPSS scheme with the HotStuff BFT consensus protocol, and adapt it for Intel SGX, TDX, and Hygon CSV. Evaluations demonstrate that TeeDAO achieves up to 1.8x higher key-value store throughput in a large cluster with 61 nodes compared to state-of-the-art systems, efficient autonomous management, and minimal computation overhead (<18%) for multi-party computation tasks.
Alternative data availability (AltDA) systems provide Ethereum L2s with an external data publication layer for high throughput rollup designs. By moving bulk data publication outside of Ethereum, AltDA allows L2s to process more data than native DA. However, this replacement introduces a new consensus critical integration layer. Existing ecosystem frameworks identify high level risks, such as external DA trust assumptions and the presence or absence of a DA verifier, but do not provide a complete specification for how an L2 should integrate with AltDA. This gap can lead to L2 halts, inconsistent derivation across honest L2 nodes, invalid state assertions, or bridge attacks. This paper presents a canonical validation framework for secure AltDA integration. We model the boundary as a typed, deterministic, and total translation from L1 inbox bytes to an AltDA commitment, then to externally available data, and finally to the rollup payload consumed by the rest of core L2s logic. The central principle is that every adversarial input must lead to a defined unique outcome. We show how missing obligations lead to concrete failure modes, including underconstrained settlement, derivation halts, inconsistent honest node behavior, invalid state assertions, and bridge safety failures. We then apply the framework to representative AltDA integration architectures, including Celestia-Blobstream, EigenDA based designs, and Avail-ZKsync. Our evaluation shows that secure AltDA integration is not determined solely by the DA provider or bridge. The surrounding L2 integration must also enforce the full validation relation connecting L1 inbox inputs to accepted L2 state.
Abstract Ethereum's transaction validity model is currently anchored in ECDSA over secp256k1, whose security assumptions weaken in the presence of large-scale quantum adversaries. While NIST-standardized post-quantum signature schemes such as ML-DSA, SLH-DSA, and FALCON provide resistance against quantum attacks, integrating these schemes into Ethereum introduces significant systems-level challenges involving bounded execution, gas determinism, and adversarial verification complexity. This paper introduces PQSigAbstract, a modular post-quantum signature verification architecture for Ethereum that separates validation into a stateless pre-validation phase and a deferred cryptographic verification phase linked through commitment binding. The design defines typed Verification Modules with explicit gas estimation, a versioned Scheme Registry with quarantine-based deployment safety, and a probabilistic aggregation mechanism for non-aggregatable post-quantum schemes. The proposed architecture preserves EU-CMA security while maintaining compatibility with ERC-4337 and RIP-7560 account abstraction models. Formal gas cost models are derived for ML-DSA-44, FALCON-512, and SLH-DSA-128f, and empirical evaluation demonstrates practical deployment feasibility for high-value Ethereum accounts despite substantially higher verification costs relative to ECDSA. Status: Technical Report / Working Paper Author: Ankita Virani Affiliation: University of Colorado Boulder
While full ledger access is theoretically possible on public blockchains, in reality it is often not possible. Things that can be seen are limited by storage limitations, client design, indexing services, and off-chain execution pathways. This means that entire ledger objects are rarely used for empirical blockchain analysis; instead, observable projections are typically used. In this research, the observability of blockchain is recast as an inferential problem with incomplete observation. Studying identifiability, information loss, and irreducible uncertainty under coarsened access, the framework defines a full ledger, an observable ledger, and an observability mechanism. Three distinct visibility regimes, independent Bernoulli, clustered, and activity-dependent, are assessed in the simulation study. Reduced visibility raises uncertainty inflation, root mean squared error, variance, and mean squared error across all three regimes. The most severe deterioration happens when the condition of the underlying ledger determines visibility. This empirical study employs Google BigQuery's publicly indexed Ethereum block data spanning blocks 18,000,000 to 18,001,000. Over the chosen Ethereum period, descriptive summaries reveal a large amount of fluctuation in gas utilised, transaction count, and basic charge per gas at the block level. Experiments with controlled missingness on the observed slice reveal that RMSE and trend estimate bias grow with increasing missingness, and that the degree of distortion is significantly affected by whether the incompleteness is MCAR-like, MAR-like, or MNAR-like. This research proves that partial observability isn't just a secondary data issue; it can significantly affect inference on Ethereum block-level summaries.
THE SS138 PROTOCOL: A DETERMINISTIC INGRESS ARCHITECTURE FOR DISTRIBUTED DATA DRIFT ISOLATION Abstract — This paper introduces the SS138 protocol, an invariant edge gateway architecture designed to isolate and eliminate calculation variance, packet time-series anomalies, and systemic tracking drift before data reaches downstream processing components. The architecture provides an application-layer structural filter, mapping incoming data vectors onto a fixed coordinate system bound by a multi-phase temporal macro framework. By evaluating metrics across structured phase intervals, the protocol achieves deterministic input sanitization and real-time entropy tracking with minimum algorithmic overhead, reducing the attack surface and protecting downstream distributed ledgers from processing failures or data propagation errors. Owner and Developer SquirrelSniper138 from YouTube