Dust Limit

In Bitcoin, the dust limit is a consensus rule that prevents the creation of unspent transaction outputs (UTXOs) deemed too small to be economical to spend. It's calculated based on the cost of spending the output (input size * fee rate).

• Enforcement: Nodes will reject transactions creating dust outputs.
• Typical Threshold: Historically around 546 satoshis, but it's dynamic based on network fees.
• Purpose: Prevents UTXO set bloat and denial-of-service attacks via micro-transactions.

Ethereum does not have a formal 'dust limit' for ETH balances, but an economic one emerges from gas costs. Any operation (transfer, smart contract call) requires gas, making it economically irrational to hold or transact minuscule balances.

• Effective Limit: A balance must cover the gas cost to move it, which can be ~0.001 ETH or more during high congestion.
• ERC-20 Tokens: Token contracts may implement their own minimum transfer rules to prevent fractional dust from clogging state.

UTXO-based forks of Bitcoin inherit and often modify the dust limit concept.

• Litecoin: Uses a similar model, with a limit historically set at 546 litoshis.
• Bitcoin Cash (BCH): Implemented a strict dust limit of 546 satoshis post-fork to clearly define and enforce the rule, reducing implementation ambiguity compared to Bitcoin's fee-based calculation.

Account-model blockchains like Solana and Avalanche's C-Chain face dust in the form of minimum account balances required for rent and state storage.

• Solana: Accounts must maintain a minimum balance for rent-exemption; otherwise, they are purged. This acts as a de facto dust limit.
• Avalanche C-Chain: Similar to Ethereum, dust is economically defined by the cost of gas (~0.001 AVAX) for any state-changing operation.

A dust attack involves sending tiny, uneconomical outputs to many addresses to deanonymize or clutter wallets. Ecosystem responses include:

• Wallet Filters: Most wallets automatically hide or label dust transactions.
• Consolidation Services: Tools that batch many small UTXOs into one for a single fee.
• Protocol Upgrades: Adjusting dust limit parameters or introducing consolidation mechanisms at the protocol level.

Layer 2 networks handle dust limits differently, often optimizing for micro-transactions.

• Lightning Network: Dust limits are enforced by channel partners to prevent spam within payment channels.
• Rollups (Optimism, Arbitrum): Inherit the base layer's (Ethereum) economic dust limit for L1 settlement, but can have much lower effective limits for L2 transactions due to reduced fees.
• Sidechains: Can set their own independent dust policies, often lower to enable new micro-payment use cases.

The dust limit is not a single, fixed number across all blockchains or even within a single network. It is a protocol-level rule that can vary by:

• Blockchain Implementation: Bitcoin's limit differs from Litecoin's.
• Transaction Type: SegWit (P2WPKH) outputs have a different dust threshold than legacy (P2PKH) outputs.
• Network Policy: Individual nodes and miners can enforce their own, stricter policies.

While preventing network spam is a primary goal, the dust limit also serves critical economic and efficiency purposes:

• UTXO Bloat Mitigation: It discourages creating tiny, uneconomical outputs that permanently bloat the UTXO set, slowing down node validation.
• Fee Efficiency: It ensures the cost of spending an output in the future isn't disproportionate to its value (a principle of economic rationality).
• Storage Cost: Every dust output consumes node disk space in perpetuity.

A common conflation is between the dust limit (minimum output value) and the minimum relay fee (minimum fee rate). They are separate, complementary rules:

• Dust Limit: Governs the amount of native currency in a transaction output.
• Minimum Relay Fee: Governs the fee paid per byte of transaction data. A transaction can pay a high fee but still create a dust output, and vice-versa.

Dust outputs are not "locked" or burned; they are simply considered uneconomical to spend under normal conditions. They can be spent by:

• Consolidating them with a larger UTXO in a single transaction, making the fee proportional to the total value.
• Paying a transaction fee that exceeds the value of the dust output itself, which is typically irrational.
• During periods of extremely low network fees, previously dusty outputs may become spendable.

The dust limit calculation is often tied to the current network fee market. In Bitcoin, for example, the standard dust limit is derived from a formula: (minRelayTxFee * 182) / 1000 satoshis (for a typical P2PKH output). This means:

• If the minRelayTxFee parameter changes, the effective dust limit changes.
• It's a cost-benefit rule: the potential fee to later spend the output must not exceed 1/3 of its value.

Many wallets implement dust attack protection that is stricter than the base protocol. This creates user confusion. Key differences:

• Protocol Rule: The network's base validation rule. Transactions violating it are non-standard and may not be relayed.
• Wallet Policy: Wallets may refuse to create or receive outputs below a higher, internal threshold to protect users from privacy leaks or future spendability issues. This is a client-level safeguard.

A UTXO is the fundamental unit of a Bitcoin-like blockchain, representing a discrete chunk of cryptocurrency that can be spent as an input in a new transaction. The dust limit applies to the value of individual UTXOs, preventing the creation of outputs that are too small to be economically spent in the future.

• Each UTXO can only be spent in its entirety.
• A wallet's balance is the sum of all its UTXOs.
• Dust UTXOs are those below the network's defined dust limit.

The minimum relay fee is the lowest fee rate (e.g., satoshis per virtual byte) that a network node will accept to propagate a transaction to its peers. This is directly connected to the dust limit calculation.

• Transactions with outputs below the dust limit are considered non-standard and will not be relayed by default nodes.
• The dust limit is algorithmically derived from the minimum relay fee to ensure an output's potential future spending fee does not exceed its value.

Fee estimation is the process of predicting the appropriate transaction fee (fee rate) to ensure timely inclusion in a block. Dust management is a critical part of wallet fee logic.

• Wallets must account for the size (in bytes) of all inputs and outputs when estimating fees.
• Spending a dust UTXO as an input often costs more in fees than the UTXO is worth, making it economically irrational.
• Advanced fee estimation models may flag or consolidate dust outputs.

A coin selection algorithm is the logic a wallet uses to choose which UTXOs to spend as inputs for a new transaction. Efficient algorithms explicitly avoid creating or spending dust.

• Common strategies include Knapsack, Branch and Bound, and CoinGrinder.
• These algorithms aim to minimize transaction size (and thus fees) and reduce future dust.
• They may consolidate many small UTXOs (including dust) in a single transaction to clean up the wallet.

Transaction malleability refers to the ability to slightly alter a transaction's unique ID (txid) before it is confirmed, without invalidating its signatures. This historical Bitcoin issue influenced dust-related policies.

• Malleability attacks could theoretically be used to make dust outputs unspendable.
• The dust limit and related policies help mitigate the impact of such attacks by discouraging the creation of vulnerable, low-value outputs.
• SegWit (Segregated Witness) solved the malleability issue in Bitcoin.

Economic abstraction is a theoretical concept where block validators (miners/validators) accept fees in any currency, not just the native chain token. This challenges the premise of a native-token dust limit.

• In a system with economic abstraction, the value of a "dust" output could be denominated in a stable, high-value external asset.
• This could render static, native-token dust limits ineffective or require more complex, dynamic models based on real-world asset value.