[Paper Review] Txilm: Lossy Block Compression with Salted Short Hashing

Donghui Ding, Xin Jiang+4 more|arXiv (Cornell University)|Jun 15, 2019

Blockchain Technology Applications and Security6 references10 citations

TL;DR

Txilm proposes a lossy block compression protocol that replaces full transactions in blockchain blocks with 32-bit salted short hashes of transaction IDs (TXIDs), enabling 80× reduction in data size. By sorting transactions by TXID and using Merkle roots to resolve collisions, it achieves high compression without additional data structures, significantly improving blockchain throughput while defending against hash collision attacks via per-block salting.

ABSTRACT

Current blockchains are restricted by the low throughput. Aimed at this problem, we propose Txilm, a protocol that compresses the size of transaction presentation in each block to save the bandwidth of the network. In this protocol, a block carries short hashes of TXIDs instead of complete transactions. Combined with the sorted transactions based on TXIDs, Txilm realizes 80 times of data size reduction compared with the original blockchains. We also evaluate the probability of hash collisions, and provide methods of resolving such collisions. Finally, we design strategies to protect against potential attacks on Txilm.

Motivation & Objective

• To address the low throughput limitation in current blockchains like Bitcoin, which handle only ~7 TPS.
• To reduce the bandwidth overhead of transmitting full transactions per block, which limits scalability.
• To design a lossy compression scheme that maintains security and efficiency without requiring consistent memory pools across nodes.
• To minimize hash collision probability and provide practical detection and fallback mechanisms for collision attacks.
• To achieve higher compression than prior schemes like compact blocks and Xthin without using complex data structures such as bloom filters or IBLTs.

Proposed method

• Replace full transactions in blocks with 32-bit short hashes (TX-HASHes) of TXIDs, reducing block size from ~300–400 bytes to ~40 bits per transaction.
• Sort transactions by TXID to minimize the collision space, reducing the probability of hash collisions and enabling shorter hash lengths.
• Use the Merkle root of the memory pool to resolve hash collisions by verifying transaction inclusion through cryptographic proofs.
• Introduce a per-block salt in TX-HASH computation (TXID-HASH = hash(salt + TXID)) to prevent preimage attacks and collision flooding.
• Detect potential collision attacks by monitoring the number of ambiguous TX-HASHes per block; fall back to full TXID lists if anomaly is detected.
• Simulate collision probability under varying parameters (k-bit hash length, block size n, memory pool size m) to validate security and compression efficiency.

Experimental results

Research questions

• RQ1 Can a lossy compression scheme using short, salted TXID hashes achieve significantly higher data reduction than existing compact block protocols without relying on complex data structures?
• RQ2 What is the probability of hash collisions in a blockchain environment with sorted TXIDs and a dynamic memory pool, and how can it be minimized?
• RQ3 How effective is per-block salting in preventing adversarial collision attacks that aim to overwhelm the network with conflicting TX-HASHes?
• RQ4 Can transaction recovery be reliably achieved using Merkle roots when hash collisions occur, and what is the computational cost of such resolution?
• RQ5 What is the optimal short hash length (k) that balances high compression (80×) with acceptably low collision probability under realistic network conditions?

Key findings

• Txilm achieves an 80× reduction in data size compared to original blockchains by using 32-bit TX-HASHes, enabling significantly higher blockchain throughput.
• With a 32-bit hash length (k=32), the probability of a single collision between a new block and the memory pool is reduced to 7.2×10⁻⁷ when m=3000 and n=200.
• Sorting transactions by TXID reduces the effective collision space from m to m/n, which dramatically lowers collision probability and allows shorter hash lengths.
• The simulation results show that collision probability converges to zero when k > 25 after optimization, validating the effectiveness of the sorting-based collision space reduction.
• Per-block salting effectively prevents adversarial collision attacks by making preimage attacks infeasible until a new block is generated, with fallback to full TXID lists if attack is detected.
• The protocol is secure against known collision flooding attacks and does not require consistent memory pools across nodes, enhancing practical deployment feasibility.