Bitcoin Development Mailinglist
 help / color / mirror / Atom feed
Search results ordered by [date|relevance]  view[summary|nested|Atom feed]
thread overview below | download mbox.gz: |
* [bitcoindev] Testnet 5 launch
@ 2026-11-09 18:14  1% Anthony Towns
  0 siblings, 0 replies; 200+ results
From: Anthony Towns @ 2026-11-09 18:14 UTC (permalink / raw)
  To: bitcoindev

Hello world,

I propose mining testnet 5's genesis block at the end of the week,
aligned with the next mainnet retarget at block 975,744.

If people want to point hashrate at bootstrapping testnet5, I've got
some docs on the process available at:

  https://gist.github.com/ajtowns/ebb148819c6028387271e6f0dce5e1da

and the 0%-fee solo-mining pool to point to is available at:

  https://lapis.erisian.com.au/chain.html

It will keep running tests at lower difficulty for the rest of the week
until shortly before block 975,744 is mined.



Couple of extra bits of info:

This setup involves a couple of tweaks to the genesis block structure,
documented in https://github.com/bitcoin/bips/pull/2347 . These are to
make pooled mining of the genesis block easier (providing extranonce
space and expicitly allowing nVersion rolling), and also to make it a
bit closer to previous genesis blocks (having the commitment be text in
the pszTimestamp field rather than the output, and making the output an
unspendable OP_RETURN rather than a potentially-post-quantum spendable
x-point).

When bootstrapping a new chain, the ambiguity in how BIP 34 block height's
are encoded tends to bite: bitcoin core expects blocks 1 to 16 to use
OP_1 to OP_16 in the coinbase, but a lot of mining software expects to
see a one-byte push, so 0x0101 to 0x0110, so if you see weird behaviour
at low height blocks, this might be a cause. References:

  * https://github.com/bitcoin/bips/pull/2342
  * https://github.com/bitaxeorg/ESP-Miner/pull/2089

Cheers,
aj

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/avINnoG-1r242rAw%40erisian.com.au.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Stale Tip Relay
  2026-07-29 17:21  1% [bitcoindev] [BIP Proposal] Stale Tip Relay Ram
  2026-08-11 13:51  0% ` Edil Guimarães de Medeiros
@ 2026-11-05 23:19  0% ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  1 sibling, 0 replies; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2026-11-05 23:19 UTC (permalink / raw)
  To: Ram; +Cc: Bitcoin Development Mailing List

Hi,

This is useful, good to see progress on this.

I'd like to suggest an incremental approach, and to start relaying only stale
headers at first.

This gives you most of the benefits, without having to make an argument that the
protocol change does not negatively affect mining incentives.

As you note yourself:
> An added benefit is potentially faster reorg handling: if a node already knows
> the relevant headers, and perhaps has the block data, it has less work to do if
> that branch later becomes active.

This increases the expected revenue of (temporarily) mining on top of your block
in the event you lose a race.

On the other hand, this accelerates convergence slightly as honest miners on the
losing side switch to the winning chain faster.

So clearly such a change affects the incentive structure, and would require
analyzing whether it's a greater force for convergence or divergence, or at all
meaningful.

Performing this analysis for a message which aims to make the *presence* of stale
blocks more observable seems overkill to me. Headers alone are enough for this,
and pre-relaying them does not affect the incentive structure in the same way.

Therefore i suggest to specify and implement relay of stale headers, then later
revisit whether the additional information present in the block content (pool
attribution from the coinbase, and validity, i suppose?) is worth the work on
analyzing the effect on the incentive structure.

Best,
Antoine


On Wednesday, July 29th, 2026 at 1:28 PM, Ram <pseudoramdom8@gmail.com> wrote:

> Hello list,
>
> This proposal introduces `staletip`, an opt-in P2P message for relaying recent
> stale tips between peers. Building on AJ Towns' initial work, w0xlt and I have
> developed the proposal further and built a proof-of-concept implementation.
>
> Draft BIP:
> https://github.com/pseudoramdom/bips/blob/staletip-bip-draft/bip-staletip.md
>
> Proof-of-concept:
> https://github.com/w0xlt/bitcoin/tree/staletip-v4
>
> Today, once a block loses a race and goes stale, it stops propagating – compact
> block relay and FIBRE aggressively relay the winning chain, while stale
> branches fall away. That's great for fast propagation, but it makes the stale
> rate difficult to observe. Even dedicated monitors [0] have only partial views:
> a stale block seen by one monitor may never reach another.
>
> The stale rate is a useful network-health signal because it is closely related
> to block propagation delay. The longer it takes miners to learn about a newly
> found block, the greater the chance that another valid block will be found at
> the same height, creating a race in which one of the blocks becomes stale [1].
> An elevated stale rate could also expose validation or relay bottlenecks.
> For example, the May 2023 "inv-to-send" bug degraded block propagation and
> coincided with a roughly 10x increase in the observed stale rate [2].
>
> A stale block does not by itself identify its cause, but changes in the
> rate or shape of stale branches can provide a reason to investigate:
>
> - a network partition – when a partition heals, blocks mined on the
> losing side become stale, potentially producing several related stale
> blocks at once.
> - adversarial mining strategies such as selfish mining [3] – these
> can cause honest miners' blocks to become stale.
>
> The proposal fills this observability gap with an opt-in P2P message called
> `staletip`, allowing nodes to proactively announce recent stale tips to peers.
>
> An added benefit is potentially faster reorg handling: if a node already knows
> the relevant headers, and perhaps has the block data, it has less work to do if
> that branch later becomes active.
>
> At protocol level, nodes advertise support using BIP 434 `feature` message [4],
> and `staletip` messages are only sent to peers that advertised support. Each
> announcement contains the fork point, a sequence of compressed headers, and a
> flag indicating whether the sender can serve the stale tip block.
>
> The proposed default relay policy:
> - relays only tips within 1000 blocks (about seven days) of the active tip,
> keeping announcements recent and stale-tip spam costly on mainnet.
> - limits branches to 20 compressed headers, covering short-term reorgs
> without tracking persistent chain splits and keeps each announcement under
> 1 kB.
> - keeps at most 10 recent tips in the relay cache, so announcing the full
> cache to a new peer remains under 10 kB, excluding any blocks requested.
>
> The BIP text has more background and the full message format. Comments are
> welcome.
>
> Cheers,
> Ram (pseudoramdom)&
> w0xlt
> [0] https://github.com/bitcoin-data/stale-blocks
> [1] https://delvingbitcoin.org/t/propagation-delay-and-mining-centralization-modeling-stale-rates/2110
> [2] https://b10c.me/observations/15-inv-to-send-queue/
> [3] https://arxiv.org/abs/1311.0243
> [4] https://github.com/bitcoin/bips/blob/master/bip-0434.md
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/3rRzUIQUWDcT-ASQXvovARX12jzE0UWy0RQ8fk7M_z3bW_k2LWPPEvRhoD6sEe3GW3fjCdtzLOZN34TCsB2CI6iRcdjer9Y8QiNwUh2QepI%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* [bitcoindev] Bitcoin Core v32.1 Released
@ 2026-10-28 15:45  1% fanquake
  0 siblings, 0 replies; 200+ results
From: fanquake @ 2026-10-28 15:45 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 28002 bytes --]

Due to last-minute issues, 32.0, although tagged, was never
fully announced or released.

Bitcoin Core version 32.1 is now available from:

  <https://bitcoincore.org/bin/bitcoin-core-32.1/>

This release includes new features, various bug fixes and performance
improvements, as well as updated translations.

Please report bugs using the issue tracker at GitHub:

  <https://github.com/bitcoin/bitcoin/issues>

To receive security and update notifications, please subscribe to:

  <https://bitcoincore.org/en/list/announcements/join/>

With the release of this new major version, versions 29.x and
older are at "End of Life" and will no longer receive updates.

In accordance with our [security 
policy](https://bitcoincore.org/en/security-advisories/), any **easily 
discoverable** vulnerabilities fixed in this
release will be disclosed as soon as fixed releases are available for all 
maintained major versions.

Under the regular disclosure schedule, we will disclose the following in 
two weeks:

* Medium and high severity vulnerabilities fixed in 30.0. There are 3 of 
these.

* Low severity vulnerabilities fixed in 32.1. There are 0 of these.

How to Upgrade
==============

If you are running an older version, shut it down. Wait until it has 
completely
shut down (which might take a few minutes in some cases), then run the
installer (on Windows) or just copy over `/Applications/Bitcoin-Qt` (on 
macOS)
or `bin/` and `libexec/` (on Linux).

Upgrading directly from a version of Bitcoin Core that has reached its EOL 
is
possible, but it might take some time if the data directory needs to be 
migrated. Old
wallet versions of Bitcoin Core are generally supported.

Compatibility
==============

Bitcoin Core is supported and tested on the following operating systems or 
newer:
Linux Kernel 3.17, macOS 14, and Windows 10 (version 1903). Bitcoin
Core should also work on most other Unix-like systems but is not as
frequently tested on them. It is not recommended to use Bitcoin Core on
unsupported systems.

Notable changes
===============

P2P and network changes
-----------------------

- Tor hidden services that are created automatically by Bitcoin Core will 
have
  [PoW 
defenses](https://tpo.pages.torproject.net/onion-services/ecosystem/technology/security/pow/)
  enabled if the Tor daemon supports that. (#33414)
- To reduce memory and CPU usage during periods of high transaction volume,
  rate-limiting of outgoing transaction relay has been changed to use a 
global
  backlog instead of being done on a per-peer basis. The default rate-limit
  remains as 14 tx/s (boosted by 2.5x for outbound peers), though this can 
be
  changed via the `-txsendrate` configuration option. An additional 
bandwidth
  rate-limit has also been introduced at 12MB of transactions per 10 
minutes,
  with a high burst rate. The size of the global backlog and the token 
bucket
  values for the rate limits can be queried via the `getnetworkinfo` RPC.
  (#34628)
- Fix a possible leak of the originator's IP address for transactions sent 
with
  `sendrawtransaction` RPC when `-privatebroadcast=1`. When Bitcoin Core
  connects to a peer, if that peer has been advertised to support P2P 
protocol
  v2, then Bitcoin Core tries to use the v2 protocol and if that fails it
  retries the connection using the v1 protocol. When the private broadcast 
is
  about to send a transaction to an IPv4 or IPv6 peer it overrides the 
normal
  proxy selection and forces the connection through the Tor proxy (and thus
  through the Tor network, protecting the sender's IP address). However if 
v2
  protocol is tried and it fails, then the v1 retry connection would be made
  disregarding the "override proxy" request, possibly making an IPv4 or IPv6
  direct connection. In other words, for this to happen the following must 
be
  true:
  1. An IPv4 or IPv6 address has been advertised to the sender, indicating 
v2
     support.
  2. The sender must have Tor configured.
  3. The sender's configuration must be such that connections to IPv4 or 
IPv6
     are made directly (no `-proxy=` is used for IPv4 or IPv6).
  4. The recipient does not support v2 (the flags from 1. are bogus). 
(#35410)
- The private-broadcast queue (transactions submitted via 
`sendrawtransaction`
  when `-privatebroadcast` is enabled and not yet echoed back from the 
network)
  is now capped at 10,000 entries. When full, new submissions are rejected. 
It
  is up to the caller to inspect the queue via `getprivatebroadcastinfo` and
  free up space when stuck via `abortprivatebroadcast`. (#35406)
- Each transaction sent via private broadcast (`-privatebroadcast`) is 
limited
  to 1,000 send attempts. After reaching the limit, broadcasting stops; call
  `sendrawtransaction` again to retry. Transactions that reach the limit 
remain
  available through `getprivatebroadcastinfo` and `abortprivatebroadcast`.
  (#35680)
- Support for the legacy ElGamal (type 0) encryption type when creating I2P
  sessions is being sunset by the I2P network and will be removed from 
bitcoind
  on or before v34. Nodes using I2P with versions of Bitcoin Core earlier 
than
  v26.1 (PRs #29200, #29209) will soon only be able to connect to other 
legacy
  ElGamal I2P peers and will be increasingly isolated from the rest of the
  network, with a reduced anonymity set. See #35696 for details. (#35696)
- The project is currently considering whether to drop support for CJDNS 
(see
  discussion in #36041). Since its introduction in v23.0, it has not gained
  substantial adoption amongst nodes, and there is some concern about 
supporting
  a network with such a low number of peers. (#36202)
- The CJDNS documentation was updated in #34811 to simplify the setup / peer
  discovery process. (#36202)
- The default maximum number of automatic peer connections 
(`-maxconnections`)
  has increased from 125 to 200, providing additional inbound capacity for
  block-relay-only peers. By default, transaction-relaying peers may use at 
most
  50% of inbound connection slots. This percentage can be configured with 
the
  new `-inboundrelaypercent` option, which accepts values from 0 to 100 and
  defaults to 50. The number of automatic outbound connections is unchanged.
  (#28463)
- Explicitly configured `-maxconnections` values remain unchanged, but the 
new
  inbound transaction-relay limit still applies. To retain the previous
  connection limits, use `-maxconnections=125 -inboundrelaypercent=100`.
`-maxconnections` now clamps values above 2,000 with a warning to reduce
  crash risk at very high peer counts. (#35919)

Mempool
-------

- mempoolfullrbf=1 behaviour has been the default since v28 and the 
argument has
  been removed since v29 subsequently. The `getmempoolinfo` RPC stops 
returning
  the deprecated `fullrbf` key in the response unless the user requests it 
via
  the `-deprecatedrpc=fullrbf` node argument. Also, the 
`bip125-replaceable` key
  is removed from the mempool RPCs responses (because it, too, has been
  deprecated since v29) unless the user requests it via 
`-deprecatedrpc=bip125`
  node argument. Affected mempool RPCs are `getrawmempool`,
  `getmempoolancestors`, `getmempooldescendants`, and `getmempoolentry`.
  (#34911)

Updated RPCs
------------

- `createpsbt`, `walletcreatefundedpsbt`, `converttopsbt`, and `psbtbumpfee`
  will now default to creating version 2 PSBTs. An optional `psbt_version`
  argument is added to these RPCs which allows specifying the version of 
PSBT to
  create. (#21283)
- 'taproot' has been removed from 'getdeploymentinfo' because its historical
  activation height is no longer used anywhere in the codebase. Applications
  that rely on `deployments.taproot` to detect Taproot support should either
  assume Taproot to be always active (since Bitcoin Core v24.0), or check 
for
  `TAPROOT` in the `script_flags` array returned by `getdeploymentinfo` 
(since
  Bitcoin Core v31.0). (#26201)
- Bitcoin Core now reports a debug message explaining why transaction 
inputs are
  non-standard. This information is now returned in the responses of the
  transaction-sending RPCs `submitpackage`, `sendrawtransaction`, and
  `testmempoolaccept`, and is also logged to `debug.log` (if `mempoolrej` +
  debug category is enabled) when such transactions are received over the 
P2P
  network. This does not change the existing error code
  `bad-txns-nonstandard-inputs`, but instead adds additional debug 
information
  to it. (#29060)
- The `dumptxoutset` RPC now supports writing to a named pipe on UNIX-like
  systems (see mkfifo(1) and mkfifo(3) man pages). This allows the raw UTXO 
set
  data to be consumed directly by another process (e.g., the
  `contrib/utxo-tools/utxo_to_sqlite.py` conversion script) without first
  writing it to disk. (#31560)
- Mempool RPCs (`getrawmempool`, `getmempoolentry`, `testmempoolaccept`,
  `submitpackage`) now include an additional field `vsize_adjusted` (which 
is
  the sigop-adjusted virtual size used for policy) and `vsize_bip141` (which
  represents the raw BIP141 virtual size). While `vsize` is marked as
  DEPRECATED, it was previously erroneously described as the BIP 141 vsize, 
but
  is actually sigops-adjusted vsize. Use `vsize_bip141` to actually get that
  behavior or switch to the explicit `vsize_adjusted` for retained behavior.
  (#32800)
- `getrawtransaction` RPC now includes an additional field `vsize_adjusted`,
  which is the sigop-adjusted virtual size if the transaction is in the 
mempool.
  (#32800)
- The `getblockchaininfo` RPC now exposes progress for background 
validation if
  the `assumeutxo` feature is used. Once a node has synced from snapshot to 
tip,
  `verificationprogress` returns 1.0 and `initialblockdownload` false even
  though the node may still be validating blocks in the background. A new
  object, `backgroundvalidation`, provides details about the snapshot being
  validated, including snapshot height, number of blocks processed, best 
block
  hash, chainwork, median time, and verification progress. (#33259)
- `getbalances` now includes a `nonmempool` field under `mine`, reporting 
the
  net balance of wallet transactions that are not in the mempool (e.g. due 
to
  too low a feerate, too many unconfirmed ancestors, or a too-large 
`OP_RETURN`
  output). This value is always negative, and is typically an over-estimate
  since it accounts for coins being spent but not for change outputs 
returning
  to the wallet (which are also outside the mempool). Without this field, 
funds
  involved in non-mempool transactions could appear to go missing from the
  wallet balance. (#33671)
- The `estimatesmartfee` RPC now combines two fee rate estimators: the 
existing
  block policy fee rate estimator and a new mempool fee rate estimator. 
(#34075)
- The new mempool fee rate estimator produces conservative and economical 
fee
  rate estimates from the current contents of the mempool. It only produces 
a
  fee rate estimate when recent blocks indicate a healthy mempool, and falls
  back to the higher of the minimum relay fee rate and the current mempool
  minimum fee rate when the mempool is too sparse. Its statistics are 
persisted
  to `fees/mempool_policy_estimator.dat` and reloaded on startup.
  `estimatesmartfee` returns the lower of the two fee rate estimators' 
results,
  so the mempool fee rate estimator can only lower the block policy fee rate
  estimate. (#34075)
- `estimatesmartfee` accepts an `options` object with `fee_rate_estimator`.
  Recognized values are `"auto"` (the default, combined behavior described
  above), `"block_policy"` (use only the block policy fee rate estimator), 
and
  `"mempool_policy"` (use only the mempool fee rate estimator). All unknown
  values are rejected. Users who want the previous behavior can
  select the block policy fee rate estimator explicitly. (#34075)
- The options object also accepts `verbosity`. A verbosity of `2` or higher 
also
  returns `mempool_health_statistics`. (#34075)
- When `fee_rate_estimator` is `"auto"` and the estimate succeeds, the 
response
  also includes an `estimator` field identifying which fee rate estimator
  produced the result. (#34075)
- Block policy fee estimator data is now stored in
  `fees/block_policy_estimates.dat`. If the new file does not exist, the 
legacy
  `fee_estimates.dat` file is moved to the new path during startup. If both
  files exist, the legacy file is removed. (#34075)
- Wallet fee rate estimation uses the default combined estimate. (#34075)

- The `-deprecatedrpc=startingheight` configuration option has been 
removed. The
  `getpeerinfo` RPC no longer returns the `startingheight` field, which was
  previously deprecated in v31.0. (#34796)
- The `migratewallet` RPC now gives the option to not load the descriptor 
wallet
  after migrating it from a legacy wallet. This will now allow pruned nodes 
to
  migrate a wallet out of sync below the pruning height. Note that to use 
the
  new wallet it must be loaded to a full node anyway. (#35266)
- The `getprivatebroadcastinfo` and `abortprivatebroadcast` RPCs now return 
an
  error `-32601`, "Method not found", when `-privatebroadcast` is not 
enabled at
  startup. (#35267)
- `gettransaction`, `listtransactions`, and `listsinceblock` now have an
  `alternate_wtxids` field which lists the wtxids of all transactions that 
have
  the same txid. When there is only one known witness variant the field is 
an
  empty array, analogous to `walletconflicts` and `mempoolconflicts`. 
(#35501)
- `getprivatebroadcastinfo` now reports an `attempts_remaining` field for 
each
  transaction. (#35680)
- `getnetworkinfo` now reports the `asmap_version` if `-asmap` is in use. 
The
  version is the hash of the asmap data and can be verified against the 
hash of
  the raw asmap data file that also gets attested in the
  [asmap-data](https://github.com/bitcoin-core/asmap-data) repository with
  `sha256sum`. (#36249)

Changes to wallet related RPCs can be found in the Wallet section below.

New RPCs
--------

- A new `exportasmap` RPC writes the ASMap data embedded at build time to a
  file. (#33920)
- A new `getopenrpcinfo` RPC returns a machine-readable OpenRPC 1.4.1
  description of the RPCs available on the running node, including their
  parameters and result schemas. The new `rpc.discover` method provides the 
same
  public document using OpenRPC’s standard service discovery method. To 
include
  hidden commands and arguments, call `getopenrpcinfo` with 
`show_hidden=true`.
  (#34683)

Build System
------------

- The next major release is planned to drop support for building Bitcoin 
Core on
  Windows with MSVC, once clang-cl support is ready. See
  [#36153](https://github.com/bitcoin/bitcoin/issues/36153).
- The undocumented `BITCOIN_GENBUILD_NO_GIT` environment variable is no 
longer
  required and has been removed. The build system now automatically detects 
when
  it is being built from a source archive or as a subproject of a git-aware
  parent project and skips git metadata fetching. Users who need to disable 
git
  execution explicitly can still do so by configuring with
  `-DCMAKE_DISABLE_FIND_PACKAGE_Git=ON`. (#32220)

Updated settings
----------------

- The `bip125-replaceable` key in the wallet transaction RPCs such as
  `listtransactions`, `listsinceblock`, and `gettransaction` is marked as
  deprecated. Users still have the option to retrieve this key by passing 
the
  `-deprecatedrpc=bip125` startup option. Also, the `-walletrbf` startup 
option
  has been marked as deprecated and will be fully removed in the next 
release.
  Using this option emits a warning in the logs. (#34917)
- The `libevent` logging category has been removed. Configurations like
  `-debug=libevent` or `-debugexclude=libevent` will log a deprecation 
warning
  and be ignored. These configurations will result in an error in a future
  release.
- A new configuration option `-rpcmaxconnections` (default `16`) limits the
  number of simultaneously connected HTTP clients to the server. The 
application
  will now attempt to reserve file descriptors for the HTTP server sockets. 
If
  your system has limited resources, consider using a lower setting.
- A new `mining` logging category has been added, enabled with 
`-debug=mining`.
  The `CreateNewBlock(): block weight: ...` line, previously logged on every
  block template build regardless of logging configuration, is now logged 
only
  when this category is enabled. `getblocktemplate` and Mining IPC users are
  encouraged to enable it to see this log and future mining log.

Changes to GUI or wallet related settings can be found in the GUI or Wallet 
section below.

New settings
------------

- Block validation can now prefetch input prevouts from the chainstate 
database
  in parallel while connecting blocks, speeding up validation when prevouts 
need
  to be read from disk. A new `-prevoutfetchthreads=<n>` option controls the
  number of prefetch worker threads. The default is 8 threads, up to a 
maximum
  of 16; set it to 0 to disable parallel prefetching. (#35295)

Tools and Utilities
-------------------

- CLI -addrinfo now returns the full set of known addresses. In previous
  versions (v22.0 - v30.0) the set of returned addresses was filtered for
  quality and recency. This was changed since it does not match the logic 
for
  selecting peers to connect to, which does not filter. Note: CLI -addrinfo 
now
  requires bitcoind v26.0 or later, as it uses the getaddrmaninfo RPC
  internally. Users querying older, unmaintained node versions would need 
to use
  an older bitcoin-cli version. (#26988)
- A new `bitcoin-util getchainparams` command returns hardcoded details 
about
  the selected chain. (#35610)

Wallet
------

- A new RPC `addhdkey` is added which allows a BIP 32 extended key to be 
added
  to the wallet without needing to import it as part of a separate 
descriptor.
  This key will not be used to produce any output scripts unless it is
  explicitly imported as part of a separate descriptor independent of the
  `addhdkey` RPC. (#29136)
- A new `exportwatchonlywallet` RPC creates a watchonly wallet file from an
  existing descriptor wallet. The exported file contains the wallet's public
  descriptors (with derived key caches where needed), transactions, and 
address
  book data, but no private keys. It can be imported on another node using 
the
  existing `restorewallet` RPC. (#32489)
- The [Offline Signing Tutorial](/doc/offline-signing-tutorial.md) has been
  updated to use `exportwatchonlywallet` for setting up the online 
watch-only
  wallet, replacing the previous manual descriptor import workflow. (#32489)
- A new `derivehdkey` RPC is available to obtain an xpub or xprv for a
  derivation path with at least one hardened step from an HD key known to 
the
  wallet. This can be used to coordinate a multisig setup, where each signer
  shares an xpub using a different derivation path than the default
  single-signature descriptors. The example in `doc/multisig-tutorial.md` is
  updated to use this RPC. (#32784)
- The `fee_reason` field returned by wallet transaction creation RPCs now
  reports the reason the wallet selected the fee rate ("Fee Rate Estimator",
  "Mempool Min Fee", "User Specified Fee", "Fallback fee" or
  "Minimum Required Fee") instead of the block policy fee rate estimator's
  internal threshold details. Those details remain available in the block
  policy fee rate estimator debug log. (#34075)
- Wallet names that are relative paths including `..` and `.` elements, and
  wallets named `/` are no longer allowed. Any users that depended on this
  behavior can instead use absolute paths to their wallet or move their 
wallet
  to a safer path. (#34544)
- The `send` and `sendall` RPCs are no longer marked as experimental. 
(#35601)
- The `fundrawtransaction` RPC no longer accepts a boolean as the second
  positional argument. This silent no-op fallback was removed and the 
argument
  is now fully type checked. Passing a boolean will raise an error. (#35836)
- On non-Windows systems, an authenticated RPC caller allowed to create 
wallets
  could execute arbitrary commands as the node process account when
  `-walletnotify` was configured, by crafting a wallet name with regex
  replacement characters. Wallet notification placeholder replacement now 
treats
  wallet names literally. (#36048)
- The `removeprunedfunds` RPC has been deprecated and will be removed in the
  next major release. In order to continue using it, `bitcoind` must be 
started
  with the `-deprecatedrpc=removeprunedfunds` option. (#35605)

GUI changes
-----------

- A menu action has been added to allow creating a watchonly wallet file 
from an
  existing descriptor wallet. This option mirrors the 
`exportwatchonlywallet`
  RPC - the exported file can be imported to another node using the Restore
  Wallet menu action. (gui#872)
- The "Enable Replace-By-Fee" checkbox has been removed from the Send tab, 
and
  the send confirmation dialog no longer states whether a transaction 
signals
  BIP 125 replaceability. Transactions created in the GUI now follow the 
wallet's
  `-walletrbf` setting, which defaults to signalling replaceability and is
  deprecated in this release (see Updated settings). (gui#936)
- The migrate wallet option now allows to disable wallet loading after
  migrating. It is useful in case the node is pruned and the wallet was 
created
  before the pruned height. (gui#953)
- The GUI is now built with Qt 6.8.4. (#35709)

Mining
------

- The IPC mining interface now rejects out-of-range block template options
  instead of silently clamping them, such as oversized reserved block 
weight or
  coinbase sigops limits. (#33966)
- The `-blockmaxweight` startup option is now rejected when it is lower than
  `-blockreservedweight`, instead of being silently clamped. (#33966)


IPC Interface
-------------

- `BlockTemplate.submitSolution` now returns `reason` and `debug` rejection
  details in addition to the boolean result. Clients must regenerate IPC
  bindings from the updated `mining.capnp` schema to use the new method. The
  previous `@7` method now returns an error directing clients to update.
  (#34672)
- `BlockTemplate.submitSolution` now reports duplicate blocks as failures 
with
  `reason="duplicate"`, matching `Mining.submitBlock`, instead of returning
  success for duplicate submissions. (#34672)

Logging
-------

- BIP 9 bits 5 to 28 inclusive are now ignored for soft fork signaling, as 
per
  BIP 323. We won't warn about unknown deployments when receiving blocks 
that
  set any of those bits in their version. (#34779)

REST API
--------

- REST responses now include `Cache-Control` headers to guide intermediary
  caches. Immutable responses such as block binary and hex data, block 
parts,
  block filters, spent transaction outputs, and block-specific deployment 
info
  are marked cacheable for one day. Responses that can change with active 
chain
  or node state, as well as errors, are marked `no-store`. (#34794)

Low-level changes
=================

Indexes
-------

- The transaction index (`-txindex`) now stores less data on disk; a fully
  rebuilt index takes less than half the space. The index is backwards
  compatible, so existing users will not see the space saving unless the 
index
  is recreated. To do so, stop the node, delete the 
`<datadir>/indexes/txindex`
  directory, and restart; rebuilding can take up to a few hours depending on
  hardware. Progress can be monitored using the `getindexinfo` RPC. Once
  rebuilt, the index can no longer be read by previous releases, so 
downgrading
  will rebuild it again in the old format. When downgrading permanently, 
delete
  the `<datadir>/indexes/txindex` directory first, since previous releases 
do
  not reclaim the space used by entries in the new format. (#35531)
- The transaction output spender index (`-txospenderindex`) now uses less 
disk
  space. Existing indexes remain compatible and no action is required. To
  reclaim the space for data indexed before upgrading, stop the node, 
delete the
  `<datadir>/indexes/txospenderindex/` directory, and restart with
  `-txospenderindex` enabled to rebuild it. (#35634, #35568)

RPC
---

- Libevent has been replaced with a custom HTTP server (#35182). Certain 
HTTP
  edge cases will observe different behavior to be more RFC-compliant:
  - Stricter enforcement of maximum headers size (8192 bytes)
  - Reject requests with whitespace in header field-names
  - "Line Folding" is rejected (whitespace at start of a header line)
  - Tolerate `%` at the end of requested URLs
  - Multiple "Content-Length" headers with different values are rejected
- Clients attempting to connect from addresses not allowed by the 
`-rpcallowip`
  option (or its default, `localhost`) will now be immediately disconnected
  instead of receiving a `403 Forbidden`. (#35592)

Credits
=======

Thanks to everyone who directly contributed to this release:

- 0xb10c
- Adam Andrews
- Alexander Wiederin
- Alfonso Roman Zubeldia
- ameen-alam
- amisha
- Amiti Uttarwar
- Andreas Kouloumos
- Andrew Toth
- Anthony Towns
- Anthropic Security
- Antoine Poinsot
- ArvinFarrelP
- Ava Chow
- azuchi
- benthecarman
- Ben Woosley
- Bicaru20
- b-l-u-e
- Bortlesboat
- Brandon Odiwuor
- Bruno Garcia
- CaesarCoder
- Chandra Pratap
- codeabysss
- Cory Fields
- Craig Raw
- crStiv
- csjones
- cyb3ralbert
- Daniela Brozzoni
- Daniel Pfeifer
- Danny van Heumen
- David Gumberg
- deadmanoz
- dergoegge
- ekzyis
- Enoch Azariah
- Eugene Siegel
- Evan Sultanik
- Fabian Jahr
- fanquake
- frankomosh
- Gloria Zhao
- Greg Sanders
- Guillermo Fernandes
- GuTS805
- Hao Xu
- Hennadii Stepanov
- Henry Romp
- Hodlinator
- HouseOfHufflepuff
- ImMike
- ismaelsadeeq
- janb84
- jeanpablojp
- Jean-Philippe Aumasson
- joaonevess
- Jon Atack
- jpk68
- jrakibi
- junbyjun1238
- Kanan
- kevkevinpal
- Kyle 🐆
- l0rinc
- Laxman Acharya
- littleyier
- Luke Dashjr
- maflcko
- marcofleon
- Martin Zumsande
- Matias Furszyfer
- Matthew Zipkin
- Max Edwards
- Mccalabrese
- Memetic Money
- Michael Dietz
- Muhammad
- Murch
- Musa Haruna
- naiyoma
- nebula-21
- nervana21
- Novo
- optout
- Pablo Martin
- Peter Zafonte
- Philips Ucheolisah .N
- Pieter Wuille
- Pol Espinasa
- pseudoramdom
- pythcoiner
- Renato Britto
- rkrux
- Rob Hamilton
- Robin David
- Roqqit
- Ruslan Kasheparov
- Russell Yanofsky
- rustaceanrob
- Sanjana2906
- satsfy
- sayed nabhan
- Sebastian Falbesoner
- Sebastian van Staa
- sedited
- seduless
- shaurya2k06
- Shrey
- Shuvam Pandey
- Sjors Provoost
- stickies-v
- stratospher
- stringintech
- taboger
- takeshikurosawaa
- Thomas
- Torkel Rogstad
- Vasil Dimov
- vicjuma
- ViniciusCestarii
- w0xlt
- Will Clark
- winterrdog
- xyzconstant
- Yancy
- yuvicc

As well as to everyone that helped with translations on
[Transifex](https://explore.transifex.com/bitcoin/bitcoin/).

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c47ceea6-99de-41fe-a97c-928881963eccn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 30604 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ rescue protocol
  2026-09-18 16:51  0%     ` Antoine Riard
@ 2026-10-04  0:52  1%       ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-10-04  0:52 UTC (permalink / raw)
  To: Antoine Riard; +Cc: Bitcoin Development Mailing List


[-- Attachment #1.1.1: Type: text/plain, Size: 22115 bytes --]

Hi Antoine, and thank you for spending the time to read into DropKick :)


> On the delay, it's not clear if you'reproposing the delay to be "gentleman's agreement" enforced by the
> aggregator ? If yes it doesn't sound very robust in face of an
> adversarial one, and note the "toxicity" of the information, i.e
> the commitment tx, you cannot delegate to a N number of aggregator,
> as a single enough not complying is enough.



The reveal delay (the `d` parameter) is enforced by consensus, during the reveal stage. The exact check is described in step 2 of this section:


> Authenticate the commitment opening `pi`, asserting `H(H(w, Q), Q)` was committed at least `d` blocks earlier.



The reveal delay `d` must unfortunately be fixed at deployment time, and applies globally to every dropkick spend. So that, and the closely related minimum fee rate δ are very "bikeshed-able". One welcome area for suggestions would be if anyone can find a way to allow users to pick their own block delay parameters to better suit their uses cases. Unfortunately Tadge and I have been unable to find any way to do this securely.


The aggregator doesn't need to do anything special here - their job is simply to put merkle trees of commitments on-chain, and potentially earn fees directly from the rescued users by doing so.


> Generally, I'm thinking be it Lifeboat of Dropkick, they're bothvulnerable to some class of time-dilation attack [0], where a miner
> and PQ adversary can go to forge a hashrate-good chain, sybil the
> target victim and trigger her or him to reveal her reveal tx, too
> earlier from the "real" chain time. Once the victim is sybilled,
> one has a selfish mining advantage, and this is realistic to consider
> if the rescued coins are of a significant amount.



Astute observation! My understanding is that in a time dilation attack, the victim sees blocks appear slower than usual, yes? So a time-dilation attacker would delay the victim from publishing her reveal longer than they otherwise would, because the victim won't publish the reveal until `d` blocks after their commitment is mined.

More concerning is, i don't think time dilation is necessary here - if anything it hurts the attackers because they have to wait longer before seeing the reveal transaction, and thus they must maintain their eclipse for longer. An eclipse attack by itself is sufficient, as it allows the attackers to censor the victim's reveal transaction and start working on their own commit/reveal spend without the victim realizing.

More generally, if an adversary can convince the user that her reveal transaction has been published when in fact it hasn't, then the attacker gains a significant advantage in a censorship attack. An attacker with sufficient hashrate could even convince the user her reveal has been mined when it hasn't. Though, for reasonable block delays (e.g. `d > 100`) the attacker would need to maintain this kind of sandboxing/eclipse attack for potentially several days.

Lifeboat doesn't have this problem AFAICT. With Lifeboat, once a user's commitment is made, censorship attacks of any kind (including eclipse attacks) are not possible without a deep reorg. As long as hers is the first valid commitment in the chain, no subsequent commitments can usurp the user's spending control with Lifeboat. 


> As you're observing the aggregator is very at risk to be the objectof a distrubuted denial-of-service. While micro-payment can be a
> solution, there is always the risk of proof inflation cost, where
> a third-party inflate the asked rate for micro-payment beyond what
> lowest economic users can afford for the proof, leveraging a asymmetrical
> factor in her or his benefice as it's a common ressource. A classic
> when you have to evaluate lightning dos attack.



Could you clarify, are you saying a third party could submit many commitments in an attempt to inflate the aggregator's fees and proof sizes for everyone else? This is precisely what anti-DoS measures would need to prevent.  


> This might be also delicate to have secure opening proof, as thecommitment transaction witness txid could be altered before it's
> included in the chain (e.g one can go to modify the witness stack),
> though it sounds a user could re-compute an opening proof. There is
> the risk of "binding malleability" if the opening proof can be malleated
> to point to another commitment tx at spending or be plainly invalidated
> while the carrying transaction would stay valid (some "half-state" issue).



Using the witness TXID to cover the user's commitment is probably not the best design, as proofs would be much larger (they'd have to include signatures and the coinbase transaction). Better is to put the commitment somewhere outside the witness, e.g. in an OP_RETURN, or hidden in a P2TR public key tweak (i.e. the vout script). 

Correct me if i'm misunderstanding here, but if a third party malleates an opening proof to point at a different (incorrect) commitment, this would simply render the proof invalid. Of course if the user makes multiple commitments for the same secret witness, the proof could be malleated to point between them. I'm not sure this is any more dangerous than the ability of a user to create multiple distinct signatures for the same transaction input. Like a signature, the opening proof is either valid, or it's not in which case the whole reveal transaction becomes invalid. 


---


Thanks again for your time and attention reading through the proposal. It is sincerely appreciated!


regards,
conduition
On Friday, September 18th, 2026 at 9:53 AM, Antoine Riard <antoine.riard@gmail.com> wrote:

> Hello Conduition,
> 

> Thanks for your Dropkick proposal.
> 

> Found the time to have a cursory read of your ideas, it's all
> interesting. I think the problematization of the issue in plain
> terms of knowledge asymmetry sounds an interesting analytical
> foundations to evaluate rescue protocols.
> 

> With my earlier idea of a certificate-based rescue protocol, the
> intuition is very similar with what I'm calling a "proof of
> knowledge anteriority". With the notable difference than
> rather to rely on a derivation secret like parent BIP32 xprivs
> one generate a new secret (e.g a random preimage) counter-signed
> by a ECC key. It's true the security of this scheme relies on
> a "decaying assumption" as it's invalidated by the occurence of
> the Q-day, though on the other hand it's an "open set" of secret
> asymmetry, whatever the address type evaluated.
> 

> Now, digging a bit about your proposal, and how it's sharing some
> limitation with Lifeboat. On the delay, it's not clear if you're
> proposing the delay to be "gentleman's agreement" enforced by the
> aggregator ? If yes it doesn't sound very robust in face of an
> adversarial one, and note the "toxicity" of the information, i.e
> the commitment tx, you cannot delegate to a N number of aggregator,
> as a single enough not complying is enough.
> 

> Generally, I'm thinking be it Lifeboat of Dropkick, they're both
> vulnerable to some class of time-dilation attack [0], where a miner
> and PQ adversary can go to forge a hashrate-good chain, sybil the
> target victim and trigger her or him to reveal her reveal tx, too
> earlier from the "real" chain time. Once the victim is sybilled,
> one has a selfish mining advantage, and this is realistic to consider
> if the rescued coins are of a significant amount.
> 

> As you're observing the aggregator is very at risk to be the object
> of a distrubuted denial-of-service. While micro-payment can be a
> solution, there is always the risk of proof inflation cost, where
> a third-party inflate the asked rate for micro-payment beyond what
> lowest economic users can afford for the proof, leveraging a asymmetrical
> factor in her or his benefice as it's a common ressource. A classic
> when you have to evaluate lightning dos attack.
> 

> This might be also delicate to have secure opening proof, as the
> commitment transaction witness txid could be altered before it's
> included in the chain (e.g one can go to modify the witness stack),
> though it sounds a user could re-compute an opening proof. There is
> the risk of "binding malleability" if the opening proof can be malleated
> to point to another commitment tx at spending or be plainly invalidated
> while the carrying transaction would stay valid (some "half-state" issue).
> 

> Anyway, those are the few constraints and weaknesses that I can think
> of while doing a brief read of your DropKick proposal. To be clear,
> I do think there are trade-offs affecting any rescue protocol, and there
> are not specific to DropKick or Lifeboat.
> 

> Overall, it's a very interesting formalization of the issues.
> 

> Best,
> Antoine
> OTS: cc1d5b4a3d0ed137fc3778ff2d72c35814d9aec8d2b8e74279740d6e726901e0
> 

> [0] https://arxiv.org/abs/2006.01418
> 

> Le Monday, August 24, 2026 à 12:58:01 AM UTC+1, conduition a écrit :
> 

> > Hi Alex,
> > 

> > 

> > > We need to have an already functioning PQC solution for Bitcoin itself, deployed, before any of commit/reveal can help, right?
> > 

> > 

> > Yes. Two reasons:
> > 

> > First, without on-chain PQC, making commitments would be impossible to do safely unless commitment are aggregated directly by miners into the coinbase transaction.
> > 

> > Second, without on-chain PQ-secure addresses, where would one even rescue coins to? Commit/reveal protocols are meant as a tool saving coins in an emergency, not for everyday spending.
> > 

> > 

> > PQ signature schemes are therefore needed as a prerequisite.
> > 

> > 

> > regards,
> > conduition
> > On Saturday, August 22nd, 2026 at 1:46 PM, Alex <alexh...@gmail.com> wrote:
> > 

> > > Am I correct in understanding that commit/reveal always depends on someone else already having a valid PQC UTXO to spend?
> > > So in other words, this can never be a solution for a (procrastinating Bitcoin system), only a solution for (procrastinating Bitcoin users).
> > > 

> > > We need to have an already functioning PQC solution for Bitcoin itself, deployed, before any of commit/reveal can help, right?
> > > 

> > > Den tors 20 aug. 2026 23:56'conduition' via Bitcoin Development Mailing List <bitco...@googlegroups.com> skrev:
> > > 

> > > > Dearest friends, colleagues, and lurkers,
> > > > 

> > > > I would like to present for your consideration a new commit/reveal rescue protocol to save the coins of quantum procrastinators - those who take no action to move their coins to PQC-enabled wallets by Q-Day.
> > > > 

> > > > https://conduition.io/bitcoin/dropkick/
> > > > 

> > > > The term "DropKick" is self-descriptive of its usage: Drop a hidden commitment somewhere on the blockchain, and reveal it later with an SPV-style proof to Kick (spend) your legacy coins forward to a new PQ-secure wallet.
> > > > 

> > > > Background
> > > > 

> > > > As with any post-quantum commit/reveal protocol, DropKick uses the blockchain as a trustless timestamping service to prove than an honest user had earlier chronological knowledge of some secret witness to a quantum-hard one-way function. The honest user hides a commitment in a block, waits for confirmations, and later reveals her commitment to certify she knew the secret witness long before an adversary (like a quantum computer) could have done so. Assuming this witness was indeed kept secret prior to reveal time, it is already too late for the adversary to forge an equivalent proof.
> > > > 

> > > > 

> > > > This general mechanism also allows validators to distinguish an honest bitcoin-holding procrastinator from a CRQC in many situations, and so procrastinators can still authorize spending of their legacy UTXOs even well after Q-day, provided the rescue protocol is deployed before Q-day as a new encumbrance on affected legacy coins.
> > > > DropKick In One Paragraph
> > > > 

> > > > DropKick specifically is a commit/reveal protocol where the commitment `H(H(w, Q), Q)` is hidden somewhere in a block, such as an OP_RETURN or inside a taproot tweak. `Q` is a post-quantum public key, and `w` is the witness to a one-way function `f`, such that `s = f(x)` is the script pubkey (address) encumbering a coin. We can later reveal the witness `w` and a signature from pubkey `Q` to authorize a spend, along with an opening proof showing that the commitment was included in a prior block. The verifier checks the commitment opening is valid and sufficiently old, checks `s = f(x)`, and verifies the PQ-signature from `Q`.
> > > > 

> > > > See this section for the actual proving/verifying steps of the protocol.
> > > > 

> > > > Features
> > > > 

> > > > 

> > > > Generality: DropKick generalizes to any efficient [1] one-way function based on knowledge asymmetries - things the honest user knows which the adversary doesn't. In the context of Bitcoin, the one-way function would typically be a computational pipeline that includes hashing of secret data unknown to a CRQC, such as "BIP32 hardened derivation of an address" or "hashing a public key or script to build an address" or "taproot key tweaking". DropKick can be instantiated with different one-way functions to encumber different coins.
> > > > 

> > > > 

> > > > Compatibility: DropKick can be deployed as a soft-fork, as it only tightens spending validation rules, and does so only on certain UTXOs.
> > > > 

> > > > Confiscation: DropKick can be deployed without confiscating any coins, if so desired, by deploying it as an encumbrance only on UTXOs with decidable knowledge asymmetries like hashed addresses (see this section). If one wishes to maximize the number of legacy coins rescued, DropKick can also be deployed on undecidable knowledge asymmetries like BIP32-CKD. To be clear, P2PK coins cannot be covered by DropKick or indeed by any rescue protocol, as these UTXOs have no known knowledge asymmetries when a CRQC is in play.
> > > > 

> > > > Blockspace Efficiency: DropKick has near zero on-chain impact until reveal time, at which point the commitment opening proofs are included in a reveal transaction spending the legacy coins. Opening proofs could be attached in an OP_RETURN for backwards compatibility, or for better efficiency the proofs could be attached in a new transaction witness field which would allow for the 4x segwit discount to apply. DropKick opening proofs are approximately the same size as SPV or OpenTimestamps proofs (less than a kilobyte) and those proofs can be reused to rescue multiple related UTXOs, e.g. coins on the same address, or coins on addresses derived from the same seed.
> > > > 

> > > > Performance: DropKick opening proofs cost very little to verify: a few hash invocations, about as fast to verify as an SPV proof or lamport signature of the same size, and the cost of verification scales linearly with the size of the proof. If one has `txindex=1` enabled, verification is even faster. The only prerequisite data needed to verify the opening proof is the set of all Bitcoin block headers. Verifying the revealed witness `w` is exactly as efficient as evaluating the one-way function `f(w)`.
> > > > 

> > > > 

> > > > Ergonomics: Procrastinator do not need to have their own PQ-safe UTXOs available to execute a DropKick rescue: Users can delegate their commitments to untrusted third party servers called "aggregators" who do have PQ-safe UTXOs. These servers take it upon themselves to aggregate the commitments of other users together into a merkle tree, whose root they publish on-chain. Those aggregators can charge a salvage fee for their services if desired, paid in-band from the rescued UTXOs, or up-front out-of-band. Procrastinators can shop between different aggregators, and anyone with PQ-safe UTXOs can operate one.
> > > > 

> > > > Comparison to Lifeboat
> > > > 

> > > > DropKick competes directly with Tadge Dryja's Lifeboat/Lifejacket proposal (also see this older post), but DropKick aims for a different (lower) degree of security in exchange for a simpler implementation surface, more flexibility, and better efficiency.
> > > > 

> > > > The two protocols fulfill functionally similar roles, so I will take a moment to compare and contrast DropKick and Lifeboat/Lifejacket.
> > > > 

> > > > DropKick includes some novel features which Lifeboat does not, such as key certification (allowing things like RBF, or equivocation, by the honest spender), or generalization to arbitrary one-way functions. Such developments could be easily transferred to Lifeboat as well, so I will mostly ignore these minor differences here.
> > > > 

> > > > The fundamental difference between DropKick and Lifeboat is the commitment ordering requirement.
> > > > 

> > > > 

> > > > -   Lifeboat requires procrastinators to (1) procure a PQ-secure UTXO, and (2) upload a ~96-byte commitment in-the-clear in a new transaction, such as in an OP_RETURN or inscription. Validators must index all such commitments, so that they can chronologically order the revealed commitments later. Reveals reference this index to authorize spending: Only the earliest valid commitment for a given witness is allowed to spend the legacy coin that witness unlocks.
> > > >     

> > > > -   DropKick encourages procrastinators to hide commitments in merkle trees committed into blocks, such as via a merkle root posted in an OP_RETURN, or in a taproot-style key tweak. Reveals use SPV-style proofs to convince validators that the commitment was included in a past block. Validators therefore do not (and cannot) index all commitments, and so there is no way to confirm any one commitment was earliest.
> > > > 

> > > > 

> > > > 

> > > > By dropping the commitment ordering requirement, DropKick skips the need for a new index database collecting all the commitments, and this frees us from putting commitments on chain in-the-clear. DropKick commitments can be hidden off-chain, but anchored to the chain in merkle trees of arbitrary size, which is the key feature that enables the new role of aggregators, and means procrastinators don't need PQ-UTXOs to publish a commitment and rescue their legacy coins.
> > > > 

> > > > To gain these benefits, DropKick sacrifices some security, by admitting miner censorship attacks where miners can intentionally censor a reveal transaction to gain a chance to steal the procrastinator's coins. Lifeboat entirely avoids this class of attacks, whereas DropKick requires a somewhat loose game-theoretical argument that miners will converge on choosing not to censor reveals, provided we enforce a long delay (days or weeks) between commitment and reveal steps, and provided the procrastinator pays a proportional fee to incentivize honest miners. We also have to assume no 51% reorg attacks of course, as a malicious hashrate majority could easily censor any reveal transactions and so steal coins.
> > > > 

> > > > However, if this security loss is acceptable, DropKick offers a much simpler and less complex engineering surface area, and supports rescuing users in more diverse situations than LifeBoat can (because PQ UTXOs are mandatory in Lifeboat).
> > > > 

> > > > LifeBoat's UX advantage over DropKick is that because of the ordering, there is no long delay or value-proportional fee needed: Users only need to wait a few blocks between commit and reveal stages, and they pay only regular mining fees as usual. DropKick OTOH requires a delay proportional to the fraction of the UTXO one is willing to sacrifice to miners. E.g. if we assume users are willing to sacrifice 1% of their UTXOs, then we need to enforce a reveal delay period of at least 100 blocks. See here for a derivation of these parameters.
> > > > 

> > > > Conclusion
> > > > 

> > > > So that's it.
> > > > 

> > > > I'm submitting DropKick here as a sketch for consideration, not as a concrete proposal. I am most interested to know if anyone can think of a better mechanism to avoid miner censorship attacks, or if we can at least reduce the strength of the assumptions needed for DropKick to resist them.
> > > > 

> > > > regards,
> > > > conduition
> > > > 

> > > > 

> > > > [1]: The one-way function must be efficient so that verifiers can recompute it to validate reveal transactions without DoS risks. For example, BIP32 master key derivation via BIP39 is not considered efficient because it uses PBKDF2, whereas BIP32 CKD is efficient if restricted to a maximum derivation depth.
> > > > 

> > > > --
> > > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me.
> 

> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/0521d915-8613-47ea-ad44-6eaeaa5a6ed0n%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/MCeBFwbQNl9QpVD5DW7A-tEd3qvg-vnlJ7CrBcZvrCmjtjGleFxGrcQ49oK2rG9vVqGHe4aLhcEuBGseNrj4tym_sl7jWN1JlDc7SKzciTQ%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 37416 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] No burn, Quantum Migration Proposal, Quantum Secure Asset Verification & Escrow (QSAVE)
  @ 2026-09-21 23:23  0%           ` 'James T' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'James T' via Bitcoin Development Mailing List @ 2026-09-21 23:23 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 34378 bytes --]

 

Yes, SHA256 was a concern at the time, and quantum computers were a distant 
thought, but he acknowledged that in certain circumstances we might need to 
rewrite the chain. However, you are right: this is vanishingly unlikely to 
be approved, so I have thought more about it. I am suggesting that either 
we legalize white-hat hacking and lock old coins so they can only be moved 
to a lost property office after a certain time - that would be defined as a 
white-hat act. I think a simple consensus vote could give that permission 
in the USA. That way, only someone with the right key can move coins, but 
after a certain time, that key needs a second factor. A ZK proof of 
derivation from your seed would work, or, for extremely old coins, we would 
need corroboration that can't be found uniquely on-chain and might require 
further evidence. This sort of locking soft fork would avoid a burn and buy 
time for a clean migration. I have written this up as a BIP proposal, which 
I'll post soon. 



On Monday, September 15, 2025 at 12:20:23 PM UTC-7 conduition wrote:

> Hi James,
>
> Notice how satoshi is talking about replacing the hash function SHA256 in 
> the context of blocks and proof-of-work, and that if SHA256 is broken we 
> could walk the chain back a bit and then "continue from there with a new 
> hash function". He's saying the community can come to consensus *on a new 
> hash algo* and then nodes continue operating under the same decentralized 
> PoW protocol from then onwards, just with a slightly cryptographic 
> primitive underlying it.
>
> He is most definitely *not* saying the community should vest the power to 
> mint new blocks in some trusted block-producing organization. That would be 
> more closely analogous to what QSAVE is proposing, and would likewise be a 
> total reversal of the principles that Bitcoin was founded on.
>
> Unfortunately, a consensus hash algorithm switcheroo is much easier to 
> engineer than migrating the UTXO set to a new PQ secure signing primitive, 
> because with UTXOs we're talking about an authentication (ownership) 
> problem, rather than a coordination (consensus) problem. As you know, the 
> network can't just hot-swap signing algorithms for old UTXOs the same way 
> we can hot-swap hash algorithms for new blocks.
>
> For the curious, here is the original thread where Satoshi said these 
> things. https://bitcointalk.org/index.php?topic=191.0
>
>
> regards,
> conduition
> On Friday, September 5th, 2025 at 9:45 AM, 'James T' via Bitcoin 
> Development Mailing List <bitco...@googlegroups.com> wrote:
>
> If we are going to quote Satoshi, *he imagined that some group of 
> people—the consensus—could come together and agree on what the chain should 
> say if the underlying maths failed. “If SHA-256 became completely broken, I 
> think we could come to some agreement about what the honest blockchain was 
> before the trouble started, lock that in, and continue from there with a 
> new hash function.” *
>
> *This is exactly what I am proposing; that we come to some agreement about 
> what the honest blockchain. If ECSDA is compromised, the only way to fix it 
> will be to reach a consensus, and that will require the labor of people.*
>
> So far from being a non-negotiable point, this was anticipated from the 
> beginning. I do agree with the sentiment. It would be great to have a 
> protocol that operated independently of any human involvement but, the very 
> fact that we are having this debate means we are past that point. We will 
> have to decide which path to take and I think the QSAVE proposal does the 
> least harm and the most good.
>
> Best,
>
> James
>
> On Tuesday, August 19, 2025 at 3:54:01 AM UTC-7 Javier Mateos wrote:
>
>> Hi James, thanks for opening this discussion.
>>
>> One point that is non-negotiable in Bitcoin is "embedding" in the code a 
>> group of people to arbitrate claims. That goes against de very essence of 
>> the network ("trustless") and was part of the reason Bitcoin was created.
>>
>> While not strictly canonical from Satoshi, his messages are clear: "what 
>> is needed is an electronic payment system based on cryptographic proof 
>> instead of trust..." and "lost coins only make everyone else's coins worth 
>> slightly more..." Coin loss is an inherent risk of the system, but that 
>> shouldn´t be confused with designing a protocol that automatically protects 
>> funds and transactions via human arbiters.
>>
>> That's why I consider this (and other) debates about preparing Bitcoin to 
>> survive in a potentially dangerous quantum enviroment valid, whether that 
>> happens in 5 years or 100. Sooner or later, upgrades will be needeed, but 
>> the response must be technical and opt-in (migration to post-quantum 
>> signatures, inheritable vaults, voluntary mechanisms), not a return to 
>> introducing judges into consensus.
>>
>> Best regards,
>> Javier Mateos
>>
>> El lunes, 18 de agosto de 2025 a las 14:12:36 UTC-3, James T escribió:
>>
>>> I *am* suggesting that Bitcoin elects people who can arbitrate 
>>> reasonable claims. The Bitcoin dev team proposing a burn solution is the 
>>> same problem you articulate: a small group of people (80% of miners) voting 
>>> to burn coins. I don't see a way around this fundamental problem. The keys 
>>> will fail in the future; some human intervention is going to happen. 
>>> Remember, if the burn happens, tens of thousands of people will open safety 
>>> deposit boxes full of Bitcoin addresses and find them zeroed out. Only our 
>>> solution provides a solution to this and preserves the Digital Gold promise.
>>>
>>> We like to assume there is no human intervention in Bitcoin and it's all 
>>> algorithmic, but that's not true. There is an army of people working to 
>>> secure Bitcoin behind the scenes, including upfront KYC/AML and 
>>> after-the-fact recovery by private companies and law enforcement when there 
>>> is a hack. This all works on a worldwide basis today.
>>>
>>> No lawyers have been involved in the drafting of our proposal. I would 
>>> welcome input, but it's really an engineering problem. Once Bitcoin keys 
>>> can no longer be relied on, what do we do to establish ownership? Deleting 
>>> ownership is certainly one solution, but I just don't think it is a fair 
>>> one.
>>>
>>> We are proposing our solution as either a hard fork or a no-fork. Either 
>>> way, we still have to solve the problem of a room full of elected experts 
>>> to adjudicate claims (obviously, they would be distributed worldwide, and 
>>> often it could be achieved algorithmically).
>>>
>>> In the no-fork solution, we encourage - maybe reward - white hat quantum 
>>> actors to recover vulnerable Bitcoin under lost property law. If it's 
>>> claimed, then it's returned; if not claimed, it's invested for the public 
>>> good. This is then a race between white hat and black hat actors. BUT most 
>>> laws will deter white hat actors because it might be considered computer 
>>> misuse. It would be really helpful if the Bitcoin consensus said, "We favor 
>>> white hat actors protecting Bitcoin". Although there are no Bitcoin terms 
>>> and conditions or EULA, this would massively protect white hats.
>>>
>>> In the hard fork solution, instead of burning the coins, they go into 
>>> the recovery process, and here the Bitcoin consensus has made a clear 
>>> protocol decision, and there is no white hat actor risk.
>>>
>>> I apologize for the lack of technical details at this point. We have a 
>>> lot of code written, and I did make a note to that effect in my submission, 
>>> but that bit seems to have been cut off. The recovery process has to obey 
>>> the law and be distributable worldwide, and be fair, and I think it is 
>>> possible to do all that. Not simple, of course. In the meantime, there are 
>>> plenty of best practices that can be implemented to better protect and 
>>> prepare the network, which I know are in process.
>>>
>>> Best,
>>>
>>>
>>> James T
>>>
>>>
>>> On Friday, August 8, 2025 at 7:07:25 PM UTC-7 conduition wrote:
>>>
>>>> Hi James,
>>>>
>>>> This is a curious idea, though I'm not seeing any technical details of 
>>>> how this "BIP" would maintain Bitcoin's value as a distributed system. It 
>>>> more-or-less sounds like you're suggesting to vest the power of 
>>>> quantum-recovery using legal mechanisms (e.g. KYC, real-world evidence, 
>>>> etc)... in a group of people working in an office somewhere? Surely you 
>>>> realize that's impractical and un-scaleable. Besides, even if you had all 
>>>> the manpower needed to do it, no one who owns Bitcoin would run a node 
>>>> which subscribes to such consensus rules. A huge portion of the supply on 
>>>> that (hardforked) chain would be effectively under the total control of a 
>>>> select few. Who elects these people?
>>>>
>>>> It sounds like something a corporate lawyer would cook up if asked how 
>>>> to solve the post-quantum-rescue problem. Not to say that legal opinions on 
>>>> quantum migration are unwanted. I'm sure there are interesting legal 
>>>> questions to be debated around the rights of property holders in case of a 
>>>> possible quantum-freeze. But this proposal at least is DOA because KYC 
>>>> *cannot* be the answer, for practical and ethical reasons.
>>>>
>>>> Perhaps, independent of any technical consensus upgrades, it would be 
>>>> wise to encourage quantum adversaries to become benevolent, somehow. I'm 
>>>> not sure what that looks like. If a quantum freeze doesn't happen, there 
>>>> ought to be legal guidelines for how quantum giants like Google or IBM 
>>>> should behave given their newfound quantum weaponry. It'll be impossible to 
>>>> fully enforce any such rules, but if they *want* to play nice, someone 
>>>> should tell them what "playing nice" actually looks like.
>>>>
>>>> regards,
>>>> conduition
>>>> On Thursday, August 7, 2025 at 5:26:07 PM UTC-7 James T wrote:
>>>>
>>>>> This BIP Proposal is an alternative to QRAMP or a quantum 
>>>>> winner-takes-all approach to the migration from a pre- to post quantum 
>>>>> blockchain. It could be implemented as a hard fork OR as a consensus that 
>>>>> quantum actors can legitimately move funds to safe addresses for protective 
>>>>> custody and public good. It could even go forward with no consensuses at 
>>>>> all since it is functionally equivalent to a quantum winner-takes-all at 
>>>>> the protocol level. 
>>>>>
>>>>> BIP: TBD
>>>>>
>>>>> Title: Quantum Secure Asset Verification & Escrow (QSAVE)
>>>>>
>>>>> Author: James Tagg 
>>>>>
>>>>> Status: Draft
>>>>>
>>>>> Type: Standards Track
>>>>>
>>>>> Layer: Consensus (Consensus / Soft Fork / Hard Fork)
>>>>>
>>>>> Created:
>>>>>
>>>>> License: 
>>>>>
>>>>> Abstract
>>>>>
>>>>> This BIP proposes QSAVE (Quantum Secure Asset Verification & Escrow) - 
>>>>> a non-sovereign wealth fund providing protective custody for Bitcoin 
>>>>> vulnerable to quantum attack (see Appendix for detailed vulnerability 
>>>>> assessment). QSAVE preserves 100% of the principal for rightful owners 
>>>>> while using generated returns to fund the protocol and global public good. 
>>>>> It provides an alternative to the QRAMP (Quantum Resistant Asset Migration 
>>>>> Protocol) proposal (which makes coins unspendable) or taking no action 
>>>>> (which allows quantum appropriation, which many view as theft). This 
>>>>> proposal addresses coins that are dormant but acknowledges there may be 
>>>>> coins that have quantum watermarks but have not migrated to quantum 
>>>>> addresses. A separate BIP proposal will address this case.
>>>>>
>>>>> Motivation
>>>>>
>>>>> Chain analysis reveals 3.5-5.5 million Bitcoin (~17-28% of circulating 
>>>>> supply) have exposed public keys vulnerable to quantum attack (see 
>>>>> Appendix: Quantum Vulnerability Assessment for detailed breakdown).
>>>>>
>>>>> With sufficient education and proactive migration, a significant 
>>>>> portion of the 2-4M BTC in reused addresses could be moved to quantum-safe 
>>>>> addresses before the threat materializes. Modern wallets are increasingly 
>>>>> implementing best practices such as always sending change to fresh 
>>>>> addresses. However, some portion will inevitably remain unprotected when 
>>>>> quantum computers arrive due to:
>>>>>
>>>>> - Owners who don't follow Bitcoin news
>>>>>
>>>>> - Forgotten wallets discovered years later
>>>>>
>>>>> - Cold storage assumed long term safe
>>>>>
>>>>> - Users who die and whose heirs have yet to uncover the keys
>>>>>
>>>>> - Users who procrastinate or underestimate the threat
>>>>>
>>>>> When quantum computers capable of running Shor's algorithm arrive, the 
>>>>> remaining vulnerable coins face two equally problematic outcomes:
>>>>>
>>>>> 1. Quantum appropriation: First actors with quantum computers take the 
>>>>> coins
>>>>>
>>>>> 2. Forced burning: The community burns coins preventatively (by making 
>>>>> them unspendable), breaking Bitcoin's promise as a store of value
>>>>>
>>>>> This BIP proposes a third way: QSAVE - protective custody that 
>>>>> preserves ownership rights and puts dormant capital to work for humanity.
>>>>>
>>>>> Note on "Theft": Bitcoin's protocol operates purely through 
>>>>> cryptographic proofs, without built-in concepts of ownership or theft—these 
>>>>> are legal constructs that vary by jurisdiction. The community holds 
>>>>> divergent views: some consider using advanced technology to derive private 
>>>>> keys as legitimate within Bitcoin's rules, while others view it as 
>>>>> unethical appropriation of others' funds.
>>>>>
>>>>> QSAVE addresses both perspectives: If quantum key derivation is 
>>>>> considered fair game, then racing to secure vulnerable coins before 
>>>>> malicious actors is simply good-faith participation in the system. If it's 
>>>>> deemed unethical, then the community needs a consensus solution that 
>>>>> balances property rights with Bitcoin's algorithmic nature. Either way, 
>>>>> protective custody preserves coins for their rightful owners rather than 
>>>>> allowing them to be stolen or destroyed.
>>>>>
>>>>> The Inheritance Vulnerability Window
>>>>>
>>>>> Consider the "Auntie Alice's Bitcoin" scenario: Alice stores Bitcoin 
>>>>> in cold storage as inheritance for her grandchildren, with keys secured in 
>>>>> a safe deposit box. She doesn't follow Bitcoin news and remains unaware of 
>>>>> quantum threats. She passes away and by the time her heirs discover the 
>>>>> wallet, quantum computers capable of deriving private keys have emerged.
>>>>>
>>>>> Three outcomes are possible:
>>>>>
>>>>> 1. Without protection: Quantum actors take the grandchildren's 
>>>>> inheritance
>>>>>
>>>>> 2. With burning: The network destroys legitimate inheritance funds
>>>>>
>>>>> 3. With protective custody: Heirs can claim their inheritance with 
>>>>> proper evidence (will, keys, proof of box opening)
>>>>>
>>>>> This illustrates why we cannot assume dormant equals lost and why 
>>>>> protective custody is the only approach that preserves legitimate ownership 
>>>>> rights. The inability to distinguish between lost coins and stored coins is 
>>>>> the fundamental reason protective custody is essential.
>>>>>
>>>>> Principles
>>>>>
>>>>> 1. Preserve the principal - 100% of recovered Bitcoin remains 
>>>>> available for rightful owners to reclaim at any time
>>>>>
>>>>> 2. Ensure long-term store of value by avoiding any pre-emptive burn 
>>>>> (making coins unspendable)
>>>>>
>>>>> 3. Avoid market shocks by keeping principal locked while only using 
>>>>> generated returns
>>>>>
>>>>> 4. Generate returns for the benefit of humanity through conservative 
>>>>> yield strategies
>>>>>
>>>>> 5. Protect the Chain, ensuring smooth transition to post-quantum era
>>>>>
>>>>> 6. Enable priority recovery through quantum watermark system
>>>>>
>>>>> Recovery Process
>>>>>
>>>>> Recovery Timing Matrix
>>>>>
>>>>> | Scenario | Timing | Method | Requirements |
>>>>>
>>>>>
>>>>> |---------------------------|-------------------------------|---------------------------|----------------------------|
>>>>>
>>>>> | M-Day (Migration Day) | Pre-Q-Day with Hard Fork | Consensus-based 
>>>>> migration | Hard fork implementation |
>>>>>
>>>>> | Q-Day (Quantum Day) | When quantum computers arrive | White-hat 
>>>>> recovery race | No protocol changes needed |
>>>>>
>>>>> | Emergency Cut-over | Catastrophic quantum break | Parallel chain 
>>>>> migration | Rapid consensus response |
>>>>>
>>>>> | Overlapping M/Q-Day | Both processes active | Concurrent migrations 
>>>>> | Mempool competition |
>>>>>
>>>>> Recovery Protocol
>>>>>
>>>>> All recovery transactions follow the same pattern:
>>>>>
>>>>> 1. Move vulnerable coins to protective custody addresses
>>>>>
>>>>> 2. Leave OP_RETURN notification on original address with recovery 
>>>>> information
>>>>>
>>>>> 3. Prioritize by dormant period and value at risk
>>>>>
>>>>> 4. Quantum watermarks permit immediate return of funds
>>>>>
>>>>> Consensus Layer
>>>>>
>>>>> Implementation varies based on timing and consensus level (see 
>>>>> Recovery Timing Matrix above):
>>>>>
>>>>> No Action: PQP (Post Quantum Pay) wallet technology - purely 
>>>>> commercial/user layer
>>>>>
>>>>> Consensus: Community endorsement strengthens legal position for 
>>>>> white-hat recovery
>>>>>
>>>>> Soft Fork: Taproot V2/BIP-360 enables voluntary migration (doesn't 
>>>>> protect dormant accounts)
>>>>>
>>>>> Hard Fork: Required for pre-Q-Day recovery or emergency cut-over 
>>>>> scenarios
>>>>>
>>>>> Implementation Timeline
>>>>>
>>>>> Phase 0: Launch - Live from Day One
>>>>>
>>>>> - DAO Governance: Active voting on proposals from day one
>>>>>
>>>>> - Initial Publication: Non-Sovereign Wealth Fund Proposal Discussion
>>>>>
>>>>> Phase 1: Consensus Building & Infrastructure (Months 1-6)
>>>>>
>>>>> - Community discussion and refinement (while QD3 registrations 
>>>>> continue)
>>>>>
>>>>> - Technical specification development for advanced features
>>>>>
>>>>> - Technical specification for backup chain
>>>>>
>>>>> - Legal framework establishment with states
>>>>>
>>>>> - Coordination with regulatory bodies for good-faith protections
>>>>>
>>>>> - Signing the main quantum computer makers to the recovery principles
>>>>>
>>>>> - Begin backup chain development using post-quantum signature schemes 
>>>>> (e.g., FIPS 204 ML-DSA)
>>>>>
>>>>> Phase 2: Enhanced Infrastructure (Months 7-12)
>>>>>
>>>>> - Smart contract deployment for fund management
>>>>>
>>>>> - Advanced governance system implementation
>>>>>
>>>>> - Claim verification protocol enhancements
>>>>>
>>>>> - Complete backup chain synchronization and cut over process
>>>>>
>>>>> - Multi-signature protective custody addresses pre-established
>>>>>
>>>>> Phase 3: Recovery Preparation (Months 13-18)
>>>>>
>>>>> - Public notification system deployment
>>>>>
>>>>> - Recovery transaction staging
>>>>>
>>>>> - Security audits of all systems
>>>>>
>>>>> - Publish recovery chain software
>>>>>
>>>>> - Public notice period initiation (6 months before recovery)
>>>>>
>>>>> - Broadcast intent to recover specific UTXOs
>>>>>
>>>>> - Allow time for unregistered owners to move coins or register claims
>>>>>
>>>>> - Publish recovery transactions in mempool but not mine
>>>>>
>>>>> Phase 4: Active Recovery (Month 19+)
>>>>>
>>>>> - Execute recovery per Recovery Timing Matrix
>>>>>
>>>>> - Use Recovery Protocol for all transactions
>>>>>
>>>>> - Manage protective custody with multi-signature addresses
>>>>>
>>>>> - Process ownership claims per Claim Verification Protocol
>>>>>
>>>>> - Initiate fund operations per Fund Architecture
>>>>>
>>>>> Proposed Fund Architecture
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> | Recovered Bitcoin |
>>>>>
>>>>> | (Principal - 100% Preserved) |
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> |
>>>>>
>>>>> v
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> | Conservative Strategies |
>>>>>
>>>>> | (3-5% Annual Return) |
>>>>>
>>>>> | * Lightning Network Liquidity |
>>>>>
>>>>> | * DeFi Lending Protocols |
>>>>>
>>>>> | * Bitcoin-backed Stablecoins |
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> |
>>>>>
>>>>> v
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> | Interest Distribution |
>>>>>
>>>>> | (Public Good Only) |
>>>>>
>>>>> | * Open Source Development |
>>>>>
>>>>> | * Quantum Security Research |
>>>>>
>>>>> | * Global Infrastructure |
>>>>>
>>>>> | * AI Safety & Alignment |
>>>>>
>>>>> +-----------------------------------------+
>>>>>
>>>>> Claim Verification Protocol
>>>>>
>>>>> Original owners can reclaim their coins at ANY time by providing:
>>>>>
>>>>> Prior to Break (Q-Day):
>>>>>
>>>>> 1. Cryptographic Proof: Message signed with their key
>>>>>
>>>>> 2. Optional Supporting Evidence: Transaction history, temporal 
>>>>> patterns if there is any doubt/dispute on Q-Day date
>>>>>
>>>>> Post Break:
>>>>>
>>>>> 1. Identity Verification: Since quantum computers will create publicly 
>>>>> available databases of all exposed private keys (similar to existing 
>>>>> databases of classically compromised keys), possession of the private key 
>>>>> alone is insufficient.
>>>>>
>>>>> 2. Required Evidence:
>>>>>
>>>>> - government-issued identification
>>>>>
>>>>> - Historical transaction knowledge
>>>>>
>>>>> - Temporal pattern matching
>>>>>
>>>>> - Social recovery attestations
>>>>>
>>>>> This approach recognizes that post-quantum, private key possession 
>>>>> becomes meaningless as proof of ownership since quantum-derived key 
>>>>> databases will be publicly available.
>>>>>
>>>>> Three-tier Evidence Hierarchy
>>>>>
>>>>> The claim verification process employs a three-tier evidence hierarchy 
>>>>> to evaluate ownership claims with staking and slashing to prevent fraud and 
>>>>> partial time based awards in case of partial proof. Evidence strength:
>>>>>
>>>>> - Tier 1: Cryptographic proofs with verifiable pre-break timestamps 
>>>>> (signatures in pre-quantum blocks and similar immutable records)
>>>>>
>>>>> - Tier 2: Third-party records (exchange logs, bankruptcy filings, 
>>>>> probate rulings, trustee statements)
>>>>>
>>>>> - Tier 3: Supporting materials (affidavits, chain-of-inheritance, 
>>>>> media coverage, witness declarations)
>>>>>
>>>>> Governance Structure
>>>>>
>>>>> The QSAVE fund requires robust decentralized governance to ensure 
>>>>> proper stewardship of recovered assets. The governance framework must 
>>>>> balance efficiency with decentralization while maintaining absolute 
>>>>> commitment to principal preservation.
>>>>>
>>>>> Core Governance Principles:
>>>>>
>>>>> - Quadratic Voting: Reduces influence of large stakeholders while 
>>>>> maintaining democratic participation
>>>>>
>>>>> - Multi-Council Structure: Separates technical, allocation, and audit 
>>>>> functions to prevent capture
>>>>>
>>>>> - Constraints: Only generated returns may be allocated (per principle 
>>>>> #1)
>>>>>
>>>>> - Emergency Procedures: Supermajority (75%) required for emergency 
>>>>> actions; freeze of recovery process can be executed by authorized 
>>>>> individuals until quarum can be established.
>>>>>
>>>>> Governance Bodies:
>>>>>
>>>>> - Technical Council: Oversees security, recovery operations, and 
>>>>> technical infrastructure
>>>>>
>>>>> - Allocation Council: Manages distribution of generated returns to for 
>>>>> the public good thru charitable donation, impact investing or research 
>>>>> funding.
>>>>>
>>>>> - Audit Council: Provides independent oversight and transparency 
>>>>> reporting
>>>>>
>>>>> Safeguards:
>>>>>
>>>>> - Staggered terms to ensure continuity
>>>>>
>>>>> - Public transparency of all decisions
>>>>>
>>>>> - Time-locked implementations for non-emergency changes
>>>>>
>>>>> - Immutable smart contracts for principal preservation
>>>>>
>>>>> Rationale
>>>>>
>>>>> The QSAVE protocol represents the optimal technical implementation for 
>>>>> addressing quantum vulnerability. Unlike binary approaches (burn or allow 
>>>>> appropriation), QSAVE introduces a third path that aligns with Bitcoin's 
>>>>> core principles while solving practical challenges.
>>>>>
>>>>> Technical Neutrality
>>>>>
>>>>> QSAVE maintains implementation flexibility:
>>>>>
>>>>> - Fork-neutral: Works with or without protocol changes (see Recovery 
>>>>> Timing Matrix)
>>>>>
>>>>> - Price-neutral: Markets have already priced quantum risk (per 
>>>>> BlackRock ETF disclosures)
>>>>>
>>>>> - Liquidity-neutral: Principal preservation prevents market disruption
>>>>>
>>>>> Implementation Advantages
>>>>>
>>>>> - Transparent Operations: All movements follow Recovery Protocol
>>>>>
>>>>> - Decentralized Governance: See Governance Structure section
>>>>>
>>>>> - Auditable Recovery: See Claim Verification Protocol
>>>>>
>>>>> - Progressive Deployment: Phase 0 operational from day one
>>>>>
>>>>> Risk Mitigation
>>>>>
>>>>> The protocol addresses key operational risks:
>>>>>
>>>>> - Race Condition Risk: Pre-positioned infrastructure for rapid Q-Day 
>>>>> response
>>>>>
>>>>> - Legal Clarity: Aligns with established lost & found precedents
>>>>>
>>>>> - Governance Capture: Quadratic voting and mandatory principal 
>>>>> preservation constraints
>>>>>
>>>>> - Technical Failure: Backup chain with post-quantum signatures ensures 
>>>>> continuity
>>>>>
>>>>> Legal Framework Considerations
>>>>>
>>>>> The recovery process aligns with established legal principles in many 
>>>>> jurisdictions. Under precedents like People v. Jennings (NY 1986), 
>>>>> temporary custody without intent to permanently deprive does not constitute 
>>>>> larceny. This is analogous to moving lost property to a lost & found — a 
>>>>> universally accepted practice despite technically involving "taking without 
>>>>> permission."
>>>>>
>>>>> In the United States alone, over 400 million items are moved to lost & 
>>>>> found departments annually without legal consequence. QSAVE applies this 
>>>>> same principle to digital assets vulnerable to quantum attack, providing a 
>>>>> protective custody mechanism that preserves ownership rights.
>>>>>
>>>>> Furthermore, the U.S. Department of Justice's policy on good-faith 
>>>>> security research provides additional legal clarity for recovery operators 
>>>>> acting to protect vulnerable assets from quantum threats.
>>>>>
>>>>> Legal clarification and Jurisdiction choices need to be made.
>>>>>
>>>>> The Sovereign Law Paradox
>>>>>
>>>>> Without protective frameworks, law-abiding states face a critical 
>>>>> disadvantage. Bad actors operating from jurisdictions with weak or 
>>>>> non-existent cryptocurrency regulations can exploit quantum vulnerabilities 
>>>>> with impunity, while good-faith actors in law-compliant states remain 
>>>>> paralyzed by legal uncertainty. This creates a systematic wealth transfer 
>>>>> from citizens of law-abiding nations to criminal organizations and rogue 
>>>>> states. The strongest property laws paradoxically create the weakest 
>>>>> defense against quantum theft. Jurisdictions are developing good faith 
>>>>> exemptions to their computer security laws and these will need to 
>>>>> accelerate.
>>>>>
>>>>> Economic Impact
>>>>>
>>>>> Positive Effects
>>>>>
>>>>> - Removes quantum uncertainty from Bitcoin price
>>>>>
>>>>> - Funds public good without inflation or taxation (see Fund 
>>>>> Architecture)
>>>>>
>>>>> - Preserves Bitcoin's fixed supply economics (Principle #1)
>>>>>
>>>>> - Creates new model for decentralized capital allocation
>>>>>
>>>>> Neutral Effects
>>>>>
>>>>> - No net change in circulating supply (coins preserved, not spent)
>>>>>
>>>>> - Market has already priced in quantum risk per BlackRock ETF terms
>>>>>
>>>>> - Interest generation creates minimal selling pressure
>>>>>
>>>>> Appendix: Quantum Vulnerability
>>>>>
>>>>> Vulnerable Address Categories
>>>>>
>>>>> | Category | Address Type | Key Status | Quantum Vulnerable | Est. BTC 
>>>>> (M) | Recovery Priority | Notes |
>>>>>
>>>>>
>>>>> |-----------------------|------------------|------------|--------------------|--------------|-------------------|------------------------------------|
>>>>>
>>>>> | P2PK Outputs | P2PK | Various | Yes | 1.9-2.0 | Critical | Directly 
>>>>> exposed public keys |
>>>>>
>>>>> | Taproot (All) | P2TR | Various | Yes | 0.5-1 | Critical | ALL 
>>>>> Taproot addresses exposed |
>>>>>
>>>>> | Reused P2PKH (spent) | P2PKH | Various | Yes | 2-4 | High | Spent = 
>>>>> pubkey revealed |
>>>>>
>>>>> | Reused P2WPKH (spent) | P2WPKH | Various | Yes | ~0.5-1 | High | 
>>>>> Modern but still vulnerable |
>>>>>
>>>>> | Unused P2PKH | P2PKH | Various | No | 6-8 | Protected | Hash only; 
>>>>> quantum-safe |
>>>>>
>>>>> | Unused P2WPKH | P2WPKH | Various | No | 4-6 | Protected | Modern 
>>>>> safe until spent |
>>>>>
>>>>> | Script Hash | P2SH/P2WSH | Various | Mostly No | 3-4 | Protected | 
>>>>> Generally safe (depends on script) |
>>>>>
>>>>> | Total Vulnerable | | | Yes | 3.5-5.5M | | 17-28% of supply |
>>>>>
>>>>> Quantum Risk
>>>>>
>>>>> There is a lack of consensus on the timeline for the quantum threat 
>>>>> other than it appears to be accelerating:
>>>>>
>>>>> Expert Consensus:
>>>>>
>>>>> - Conservative estimates (NIST IR 8413): 2035-2050
>>>>>
>>>>> - Aggressive projections: 2027-2035
>>>>>
>>>>> - Industry leaders (including Brock Pierce at Tokenize 2025): "Yes, 
>>>>> quantum was 20 years away until recently. It's likely this decade. Most 
>>>>> people are now pinpointing it at 2027. I think that's early, but there's 
>>>>> some bright minds working on it."
>>>>>
>>>>> Recent Technical Advances:
>>>>>
>>>>> - Google's 2025 research: Demonstrated that 2048-bit RSA encryption 
>>>>> could theoretically be broken by a quantum computer with 1 million noisy 
>>>>> qubits running for one week (20-fold decrease from previous estimate)
>>>>>
>>>>> - Jensen Huang (NVIDIA CEO): Shifted to optimistic stance, stating 
>>>>> quantum computing is "reaching an inflection point" and we're "within reach 
>>>>> of being able to apply quantum computing" to solve problems "in the coming 
>>>>> years"
>>>>>
>>>>> Regulatory Requirements:
>>>>>
>>>>> - U.S. National Security Systems must use quantum-resistant algorithms 
>>>>> for new acquisitions after January 1, 2027 (NSA CNSA 2.0)
>>>>>
>>>>> - Given 1-5 year government procurement cycles, blockchain proposals 
>>>>> today must be quantum-proof
>>>>>
>>>>> References
>>>>>
>>>>> 1. NIST IR 8413 - "Status Report on the Third Round of the NIST 
>>>>> Post-Quantum Cryptography Standardization Process", July 2022.
>>>>>
>>>>> https://doi.org/10.6028/NIST.IR.8413
>>>>>
>>>>> 2. NSA CNSA 2.0 - "Commercial National Security Algorithm Suite 2.0 
>>>>> FAQ", September 7, 2022.
>>>>>
>>>>>
>>>>> https://media.defense.gov/2022/Sep/07/2003071836/-1/-1/0/CSI_CNSA_2.0_FAQ_.PDF
>>>>>
>>>>> 3. Google Quantum AI - "Quantum Advantage in Error Correction", 
>>>>> Nature, 2025.
>>>>>
>>>>> Demonstrated 99.85% reduction in required quantum resources.
>>>>>
>>>>> 4. Jensen Huang - "Nvidia CEO says quantum computing is at an 
>>>>> inflection point", Channel News Asia, June 11, 2025.
>>>>>
>>>>>
>>>>> https://www.channelnewsasia.com/business/nvidia-ceo-says-quantum-computing-inflection-point-5174861
>>>>>
>>>>> 5. Global Risk Institute - "Quantum Threat Timeline 2025: Executive 
>>>>> Perspectives on Barriers to Action", 2025.
>>>>>
>>>>>
>>>>> https://globalriskinstitute.org/publication/quantum-threat-timeline-2025-executive-perspectives-on-barriers-to-action/
>>>>>
>>>>> 6. Brock Pierce - "Million Dollar Bitcoin CONFIRMED! Brock Pierce & 
>>>>> Michael Terpin Drop BOMBS at Tokenize! 2025." YouTube, timestamp 18:10.
>>>>>
>>>>> https://www.youtube.com/watch?v=DhYO1Jxmano
>>>>>
>>>>> 7. Satoshi Nakamoto - BitcoinTalk Forum post, 2010. "If it happens 
>>>>> gradually, we can transition to something stronger."
>>>>>
>>>>> https://bitcointalk.org/index.php?topic=3120.0
>>>>>
>>>>> 8. FIPS 204 - "Module-Lattice-Based Digital Signature Standard", 
>>>>> August 2024.
>>>>>
>>>>> Specifies CRYSTALS-Dilithium (ML-DSA).
>>>>>
>>>>> 9. BIP 341 - "Taproot: SegWit version 1 spending rules", January 2020.
>>>>>
>>>>> https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
>>>>>
>>>>> 10. BlackRock iShares Bitcoin Trust - Prospectus acknowledging quantum 
>>>>> computing risk to Bitcoin holdings, 2024.
>>>>>
>>>>> 11. Mosca, M. - "Quantum Threat Timeline," University of Waterloo, 
>>>>> 2023.
>>>>>
>>>>> Estimates 2035-2040 timeline for quantum threats to cryptography.
>>>>>
>>>> -- 
> You received this message because you are subscribed to a topic in the 
> Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit 
> https://groups.google.com/d/topic/bitcoindev/PjpaidcHX4A/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to 
> bitcoindev+...@googlegroups.com.
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/e4c8c8e8-0ffe-42a6-905a-0859b2123f73n%40googlegroups.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/48b51073-e3d5-4875-a16d-216fb12fa7fcn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 62575 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ rescue protocol
  2026-08-23 23:28  0%   ` 'conduition' via Bitcoin Development Mailing List
@ 2026-09-18 16:51  0%     ` Antoine Riard
  2026-10-04  0:52  1%       ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-09-18 16:51 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 16392 bytes --]

Hello Conduition,

Thanks for your Dropkick proposal.

Found the time to have a cursory read of your ideas, it's all
interesting. I think the problematization of the issue in plain
terms of knowledge asymmetry sounds an interesting analytical
foundations to evaluate rescue protocols.

With my earlier idea of a certificate-based rescue protocol, the
intuition is very similar with what I'm calling a "proof of
knowledge anteriority".  With the notable difference than
rather to rely on a derivation secret like parent BIP32 xprivs
one generate a new secret (e.g a random preimage) counter-signed
by a ECC key. It's true the security of this scheme relies on
a "decaying assumption" as it's invalidated by the occurence of
the Q-day, though on the other hand it's an "open set" of secret
asymmetry, whatever the address type evaluated.

Now, digging a bit about your proposal, and how it's sharing some
limitation with Lifeboat. On the delay, it's not clear if you're
proposing the delay to be "gentleman's agreement" enforced by the
aggregator ? If yes it doesn't sound very robust in face of an
adversarial one, and note the "toxicity" of the information, i.e
the commitment tx, you  cannot delegate to a N number of aggregator,
as a single enough not complying is enough.

Generally, I'm thinking be it Lifeboat of Dropkick, they're both
vulnerable to some class of time-dilation attack [0], where a miner
and PQ adversary can go to forge a hashrate-good chain,  sybil the
target victim and trigger her or him to reveal her reveal tx, too
earlier from the "real" chain time. Once the victim is sybilled,
one has a selfish mining advantage, and this is realistic to consider
if the rescued coins are of a significant amount.

As you're observing the aggregator is very at risk to be the object
of a distrubuted denial-of-service. While micro-payment can be a
solution, there is always the risk of proof inflation cost, where
a third-party inflate the asked rate for micro-payment beyond what
lowest economic users can afford for the proof, leveraging a asymmetrical
factor in her or his benefice as it's a common ressource. A classic
when you have to evaluate lightning dos attack.

This might be also delicate to have secure opening proof, as the
commitment transaction witness txid could be altered before it's
included in the chain (e.g one can go to modify the witness stack),
though it sounds a user could re-compute an opening proof. There is
the risk of "binding malleability" if the opening proof can be malleated
to point to another commitment tx at spending or be plainly invalidated
while the carrying transaction would stay valid (some "half-state" issue).

Anyway, those are the few constraints and weaknesses that I can think
of while doing a brief read of your DropKick proposal. To be clear, 
I do think there are trade-offs affecting any rescue protocol, and there
are not specific to DropKick or Lifeboat.

Overall, it's a very interesting formalization of the issues.

Best,
Antoine
OTS: cc1d5b4a3d0ed137fc3778ff2d72c35814d9aec8d2b8e74279740d6e726901e0

[0] https://arxiv.org/abs/2006.01418

Le Monday, August 24, 2026 à 12:58:01 AM UTC+1, conduition a écrit :

> Hi Alex,
>
> We need to have an already functioning PQC solution for Bitcoin itself, 
> deployed, before any of commit/reveal can help, right?
>
>
> Yes. Two reasons:
>
> First, without on-chain PQC, making commitments would be impossible to do 
> safely unless commitment are aggregated directly by miners into the 
> coinbase transaction.
>
> Second, without on-chain PQ-secure addresses, where would one even rescue 
> coins *to*? Commit/reveal protocols are meant as a tool saving coins in 
> an emergency, not for everyday spending.
>
> PQ signature schemes are therefore needed as a prerequisite.
>
> regards,
> conduition
> On Saturday, August 22nd, 2026 at 1:46 PM, Alex <alexh...@gmail.com> 
> wrote:
>
> Am I correct in understanding that commit/reveal always depends on someone 
> else already having a valid PQC UTXO to spend?
>
> So in other words, this can never be a solution for a (procrastinating 
> Bitcoin system), only a solution for (procrastinating Bitcoin users). 
>
> We need to have an already functioning PQC solution for Bitcoin itself, 
> deployed, before any of commit/reveal can help, right?
>
> Den tors 20 aug. 2026 23:56'conduition' via Bitcoin Development Mailing 
> List <bitco...@googlegroups.com> skrev:
>
>> Dearest friends, colleagues, and lurkers,
>>
>> I would like to present for your consideration a new commit/reveal rescue 
>> protocol to save the coins of quantum procrastinators - those who take no 
>> action to move their coins to PQC-enabled wallets by Q-Day.
>>
>> https://conduition.io/bitcoin/dropkick/
>>
>> The term "DropKick" is self-descriptive of its usage: *Drop* a hidden 
>> commitment somewhere on the blockchain, and reveal it later with an 
>> SPV-style proof to *Kick* (spend) your legacy coins forward to a new 
>> PQ-secure wallet.
>>
>> Background
>>
>> As with any post-quantum commit/reveal protocol, DropKick uses the 
>> blockchain as a trustless timestamping service to prove than an honest user 
>> had earlier chronological knowledge of some secret *witness* to a 
>> quantum-hard* one-way function*. The honest user hides a *commitment* in 
>> a block, waits for confirmations, and later *reveals* her commitment to 
>> certify she knew the secret witness long before an adversary (like a 
>> quantum computer) could have done so. Assuming this witness was indeed kept 
>> secret prior to reveal time, it is already too late for the adversary to 
>> forge an equivalent proof.
>>
>>
>> This general mechanism also allows validators to distinguish an honest 
>> bitcoin-holding procrastinator from a CRQC in many situations, and so 
>> procrastinators can still authorize spending of their legacy UTXOs even 
>> well after Q-day, provided the rescue protocol is deployed *before* 
>> Q-day as a new encumbrance on affected legacy coins.
>>
>> DropKick In One Paragraph
>>
>> DropKick specifically is a commit/reveal protocol where the commitment H(H(w, 
>> Q), Q)​ is hidden somewhere in a block, such as an OP_RETURN or inside a 
>> taproot tweak. Q​ is a post-quantum public key, and w​ is the witness to 
>> a one-way function f​, such that s = f(x)​ is the script pubkey 
>> (address) encumbering a coin. We can later reveal the witness w​ and a 
>> signature from pubkey Q​ to authorize a spend, along with an *opening 
>> proof* showing that the commitment was included in a prior block. The 
>> verifier checks the commitment opening is valid and sufficiently old, 
>> checks s = f(x)​, and verifies the PQ-signature from Q​.
>>
>> See this section for the actual proving/verifying steps of the protocol. 
>> <https://conduition.io/bitcoin/dropkick/#DropKick>
>>
>> Features
>>
>> *Generality:* DropKick generalizes to any *efficient *[1] one-way 
>> function based on knowledge asymmetries - things the honest user knows 
>> which the adversary doesn't. In the context of Bitcoin, the one-way 
>> function would typically be a computational pipeline that includes hashing 
>> of secret data unknown to a CRQC, such as "BIP32 hardened derivation of an 
>> address" or "hashing a public key or script to build an address" or 
>> "taproot key tweaking". DropKick can be instantiated with different one-way 
>> functions to encumber different coins.
>>
>> *Compatibility:* DropKick can be deployed as a soft-fork, as it only 
>> *tightens* spending validation rules, and does so only on certain UTXOs.
>>
>> *Confiscation:* DropKick can be deployed *without* confiscating any 
>> coins, if so desired, by deploying it as an encumbrance only on UTXOs with 
>> *decidable* knowledge asymmetries like hashed addresses (see this section 
>> <https://conduition.io/bitcoin/dropkick/#Knowledge-Asymmetries>). If one 
>> wishes to maximize the number of legacy coins rescued, DropKick can also be 
>> deployed on *undecidable* knowledge asymmetries like BIP32-CKD. To be 
>> clear, P2PK coins cannot be covered by DropKick or indeed by any rescue 
>> protocol, as these UTXOs have no known knowledge asymmetries when a CRQC is 
>> in play.
>>
>> *Blockspace Efficiency:* DropKick has near zero on-chain impact until 
>> reveal time, at which point the commitment opening proofs are included in a *reveal 
>> transaction* spending the legacy coins. Opening proofs could be attached 
>> in an OP_RETURN for backwards compatibility, or for better efficiency the 
>> proofs could be attached in a new transaction witness field which would 
>> allow for the 4x segwit discount to apply. DropKick opening proofs are 
>> approximately the same size as SPV 
>> <https://learnmeabitcoin.com/technical/networking/node/#lightweight-node> 
>> or OpenTimestamps <https://opentimestamps.org/> proofs (less than a 
>> kilobyte) and those proofs can be reused to rescue multiple related UTXOs, 
>> e.g. coins on the same address, or coins on addresses derived from the same 
>> seed.
>>
>> *Performance:* DropKick opening proofs cost very little to verify: a few 
>> hash invocations, about as fast to verify as an SPV proof or lamport 
>> signature of the same size, and the cost of verification scales linearly 
>> with the size of the proof. If one has txindex=1​ enabled, verification 
>> is even faster. The only prerequisite data needed to verify the opening 
>> proof is the set of all Bitcoin block headers. Verifying the revealed 
>> witness w​ is exactly as efficient as evaluating the one-way function 
>> f(w)​.
>>
>> *Ergonomics: *Procrastinator *do not* need to have their own PQ-safe 
>> UTXOs available to execute a DropKick rescue: Users can delegate their 
>> commitments to untrusted third party servers called "aggregators" who 
>> *do* have PQ-safe UTXOs. These servers take it upon themselves to 
>> aggregate the commitments of other users together into a merkle tree, whose 
>> root they publish on-chain. Those aggregators can charge a salvage fee for 
>> their services if desired, paid in-band from the rescued UTXOs, or up-front 
>> out-of-band. Procrastinators can shop between different aggregators, and 
>> anyone with PQ-safe UTXOs can operate one.
>>
>> Comparison to Lifeboat
>>
>> DropKick competes directly with Tadge Dryja's Lifeboat/Lifejacket 
>> proposal <https://www.youtube.com/watch?v=PmW90HX89P8> (also see this 
>> older post <https://groups.google.com/g/bitcoindev/c/LpWOcXMcvk8/>), but 
>> DropKick aims for a different (lower) degree of security in exchange for a 
>> simpler implementation surface, more flexibility, and better efficiency.
>>
>> The two protocols fulfill functionally similar roles, so I will take a 
>> moment to compare and contrast DropKick and Lifeboat/Lifejacket.
>>
>> DropKick includes some novel features which Lifeboat does not, such as *key 
>> certification *(allowing things like RBF, or equivocation, by the honest 
>> spender), or generalization to arbitrary one-way functions. Such 
>> developments could be easily transferred to Lifeboat as well, so I will 
>> mostly ignore these minor differences here. 
>>
>> The fundamental difference between DropKick and Lifeboat is the 
>> commitment ordering requirement.
>>
>>
>>    - Lifeboat requires procrastinators to (1) procure a PQ-secure UTXO, 
>>    and (2) upload a ~96-byte commitment in-the-clear in a new transaction, 
>>    such as in an OP_RETURN or inscription. Validators must index all such 
>>    commitments, so that they can *chronologically order* the revealed 
>>    commitments later. Reveals reference this index to authorize spending: Only 
>>    the earliest valid commitment for a given witness is allowed to spend 
>>    the legacy coin that witness unlocks.
>>    - DropKick encourages procrastinators to *hide* commitments in merkle 
>>    trees committed into blocks, such as via a merkle root posted in an 
>>    OP_RETURN, or in a taproot-style key tweak. Reveals use SPV-style proofs to 
>>    convince validators that the commitment was included in a past block. *Validators 
>>    therefore do not (and cannot) index all commitments, and so there is no way 
>>    to confirm any one commitment was earliest*.
>>
>>
>> By dropping the commitment ordering requirement, DropKick skips the need 
>> for a new index database collecting all the commitments, and this frees us 
>> from putting commitments on chain in-the-clear. DropKick commitments can be 
>> hidden off-chain, but anchored to the chain in merkle trees of arbitrary 
>> size, which is the key feature that enables the new role of aggregators, 
>> and means procrastinators don't need PQ-UTXOs to publish a commitment and 
>> rescue their legacy coins.
>>
>> To gain these benefits, DropKick sacrifices some security, by admitting miner 
>> censorship attacks <https://conduition.io/bitcoin/dropkick/#Censorship> 
>> where miners can intentionally censor a reveal transaction to gain a chance 
>> to steal the procrastinator's coins. Lifeboat entirely avoids this class of 
>> attacks, whereas DropKick requires a somewhat loose game-theoretical 
>> argument <https://conduition.io/bitcoin/dropkick/#Appendix-Game-Theory> 
>> that miners will converge on choosing *not* to censor reveals, provided 
>> we enforce a long delay (days or weeks) between commitment and reveal 
>> steps, and provided the procrastinator pays a proportional fee to 
>> incentivize honest miners. We also have to assume no 51% reorg attacks of 
>> course, as a malicious hashrate majority could easily censor any reveal 
>> transactions and so steal coins.
>>
>> However, if this security loss is acceptable, DropKick offers a much 
>> simpler and less complex engineering surface area, and supports rescuing 
>> users in more diverse situations than LifeBoat can (because PQ UTXOs are 
>> mandatory in Lifeboat).
>>
>> LifeBoat's UX advantage over DropKick is that because of the ordering, 
>> there is no long delay or value-proportional fee needed: Users only need to 
>> wait a few blocks between *commit* and *reveal* stages, and they pay 
>> only regular mining fees as usual. DropKick OTOH requires a delay 
>> proportional to the fraction of the UTXO one is willing to sacrifice to 
>> miners. E.g. if we assume users are willing to sacrifice 1% of their UTXOs, 
>> then we need to enforce a reveal delay period of at least 100 blocks. See 
>> here for a derivation of these parameters 
>> <https://conduition.io/bitcoin/dropkick/#Parameters>. 
>>
>> Conclusion
>>
>> So that's it.
>>
>> I'm submitting DropKick here as a sketch for consideration, not as a 
>> concrete proposal. I am most interested to know if anyone can think of a 
>> better mechanism to avoid miner censorship attacks, or if we can at least 
>> reduce the strength of the assumptions needed for DropKick to resist them.
>>
>> regards,
>> conduition
>>
>>
>> [1]: The one-way function must be *efficient* so that verifiers can 
>> recompute it to validate reveal transactions without DoS risks. For 
>> example, BIP32 master key derivation via BIP39 is not considered efficient 
>> because it uses PBKDF2, whereas BIP32 CKD is efficient if restricted to a 
>> maximum derivation depth.
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me
>> .
>>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/0521d915-8613-47ea-ad44-6eaeaa5a6ed0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 27284 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Silent payments light clients: measurements and index commitments
@ 2026-09-02  9:52  1% Rob Segers
  0 siblings, 0 replies; 200+ results
From: Rob Segers @ 2026-09-02  9:52 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3846 bytes --]

Hi list,

The delving thread on silent payments light clients
(https://delvingbitcoin.org/t/silent-payments-light-client-protocol/891)
stalled in mid-2024 waiting on numbers. I measured them, and can't post on
delving yet (new account), so here they are.

Setup: I've been running a BlindBit Oracle v2
(https://github.com/setavenger/blindbit-oracle) on mainnet since Sept 1, 
full
range from taproot activation, checked against the bips reference
implementation on sampled blocks and against oracle.setor.dev at every
height both serve.

All 255,434 blocks (709,656 to 965,089), no sampling:

- Full serving index: 109 GB (the often-quoted 1.7-2.8 GB is tweak storage
  only). 187,814,353 tweaks total, avg 735/block, ~6.2 GB raw. Index build
  took about 2h on 8 cores from local Core REST.

  mechanism                      total      avg/block    per day at tip
  BIP-158 basic filter           5.78 GB    22.6 KB      2.8 MB
  taproot-only filter (2024)     0.94 GB     3.7 KB      0.4 MB
  v2 compute-index payload      15.08 GB    59.0 KB      8.0 MB

josibake asked in that thread what a taproot-only filter saves over stock
BIP-158: about 6.1x overall, 3.2x at the inscriptions peak. I validated the
GCS size formula by actually encoding 21 real blocks; it's within 0.5%.

The other comparison matters more now: the v2 oracle that actually ships
dropped filters entirely and serves txid + tweak + output-prefixes instead.
A filter client still needs the raw tweaks (6.2 GB) plus a full block per
match, so a complete filter stack is ~7.1 GB against v2's 15.1 GB. In other
words v2 pays about 2.1x the bytes for zero false positives and no
per-match block fetches. Nobody had numbers on either side of that until
now.

Per-block CSVs and reproduction scripts:
https://github.com/bitsagarob/silentpayments-measurements

Spec drift, already filed with both spec repos
(https://github.com/setavenger/BIP0352-light-client-specification/issues/2,
https://github.com/silent-payments/BIP0352-index-server-specification/pull/1):
v2 has no filter endpoints, spent outputs are unsalted 8-byte x-only pubkey
prefixes where the spec says salted outpoint hashes, JSON is deprecated for
gRPC, and harding's full-block-on-match conclusion from the thread never
made it back into the spec text.

Last thing. The index-server spec asks how a wallet knows it received all
tweaks for a block. Today it can't, and a server that omits one silently
loses the receiver money. My oracle publishes per-block commitments
(sha256 over height, block hash, count, sorted tweak set, chained) and
checkpoints the head to nostr every 6 hours
(npub1wc5were3y63h4nwcckdrw72gceh4kgz8eg7fz0zrk2xufr4dx9xqlvmcx8).

Format spec and test vectors are in the repo above. This makes omission
attributable after the fact. It does not fix the targeted lying-server
attack harding described; clients should still fetch the full block on a
match. If a second server published the same digests, any two could be
cross-checked. Feedback on the serialization welcome before it ossifies.

Why I care about getting the canonical set right: if Core ever serves a
tweak index over P2P, a per-block digest chain is how peers get
cross-checked (the BIP-157 pattern), and a coinbase commitment would be
the version where nobody needs trusting at all. Every step of that ladder
uses the same canonical per-block set, so it seems worth agreeing on one
now while only a handful of servers exist.

Rob
silentpayments.net

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/6871d475-fbd4-4455-954d-20a369fba471n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 4511 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] post-quantum: solution ideas to "tripwire"game-theory issues + a certificate-based rescue protocol
  2026-08-20 16:33  0% ` 'conduition' via Bitcoin Development Mailing List
@ 2026-08-26 21:54  0%   ` Antoine Riard
  0 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-08-26 21:54 UTC (permalink / raw)
  To: conduition; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 19409 bytes --]

Hello Conduition,

> It's clever, but the main problem is that it's a hard fork, as you mention

Yeah, I think there could be some ways to roll it as a soft-fork, in a
transparent way for non-upgraded nodes and that way maintain a common
ordering of the blocks.

The issue is effectively that non-upgraded nodes won't apply the chain
ordering bonus to the "tripwire" proof, as they would still run the old
ordering mechanism. However, if there is a super-majority of the miners
running the new ordering mechanism (>= 95%), one can make the assumption
that non-upgraded nodes won't see that much further updates on the chain.

Due to the proof-of-work "gravity", at some temporal point, non-upgraded
nodes are going to start to select the chain including the "tripwire" block,
just because it has the most proof-of-work, even if those nodes see no pow
for the "tripwire" block itself.

Now, there is a turtle in the turtle, as the miners can jump from the
"tripwire" chain to the "no tripwire" chain, back-and-forth. One way to
alleviate this would be some form of merge-mining where the "no-tripwire"
chain's blocks could be replayed on the "tripwire" chain...though we start
to be in the (very) ugly land of consensus activation design...

Note, BIP9 in its design surface opens the door to multi-stage soft forks,
so there could be an early phase where all the miners have to commit to a
new coinbase output with an empty "tripwire" proof placehodler.

What you wish to dissociate is the survenance of a CRQC altering the
miners incentives games and therefore the inclusion odds of a "tripwire"
proof, whatever the staged spending policy that is active by this proof.

> Granted, this would be a pre-scheduled hard-fork agreed upon presumably well in-advance of the (undefined) fork date, as opposed to an emergency hard fork of the kind that split ETH and ETC back in the day, or the kind that would be needed to reverse a hypothetical mass-quantum-theft event.

I think you can do that with a soft-fork, if you go as deep of designing
merge-mining mechanisms to minimize miners equivocation, at the time of
the "tripwire" activation. The problem of a hard fork it's a pandora box
concerning the social consensus, that personally I prefer not to consider.

> Plus, as you mentioned, we would run the risk of a dishonest minority
colluding to trigger the fork early. I especially worry about corporate
actors here, who now control a significant fraction of the supply volume,
and might have incentive to jump the gun and ossify bitcoin's cryptography
early.

Yeah, I was just mentioning the proof-of-stake idea to have more tools on
the design table, if it ever can be useful or combined with other technical
mechanisms to  be made more robust. Though I'm sharing the same worry than
you, it could be leveraged by a dishonest minority, where dishonesty would
be defined by the lack of the survenance of a CRQC.

> A UASF-like approach is probably the better option here to prevent miner
collusion: Perhaps if we distinguish the set of "active" nodes, and write
rules that say "if an active node has seen a tripwire proof, they must
disregard any blockchain that doesn't include a tripwire proof". Maybe you'd
call this a "block policy".


You can have this translated in consensus rules, iirc this was the LOT idea
that was discussed for taproot activation. See my point above about BIP 9's
multi-staged soft-fork activation too.

> This obviously doesn't work for nodes doing IBD (the first block after genesis
would be considered invalid!) or nodes that come online after sleeping a while
(they'd reject the first new block after seeing the tripwire proof!) so there
would need to be some means to distinguish those cases from an active
synchronized
node. Not sure how that'd work.

AFAICT, the problem you're mentioning would only appear transitively during the
soft-fork activation of new accouting rules for a "tripwire" proof. It sounds it
can be resolved by having a good ordering of the soft-fork activation effect,
where there would take effect at a clean transition block, and the "tripwire"
proof can be just replayed after.

Note, if we reorg of this depth back to genesis I believe we'll already have
issues far earlier with any buried soft-fork activation.

> or even just having PQ-safe wallets, because if one can take the proactive measure
to pre-register, why not simply move one's coins to an address that
can be rescued
later, or better yet to a PQ-secure address?

That's an excellent question, as a pre-register protocol. While one can take
proactive measure to pre-register, it's bitcoin and social convergence
on consensus
is never guaranteed. We have no guarantee that the community *will* converge on
a PQ-safety address, even if I guess you and me are hoping so for a
PQ-safe scheme
whatever it is.

On the other hand a pre-register protocol that is a wallet-policy and
custom blocks
validation for now, opens more door to have a rescue consenensus
soft-fork happening
*at a latter time* once you have a CQRC adversary popping up in the wild.

> A rescue protocol on the other hand must assume zero action from the user prior to Q-day (i.e. tripwire activation).

A rescue protocol still have to assume that the community will
converge on a soft-fork
activation before a hypothetical Q-day.

>  What is the "opt-in tripwire lock" field here?

An opt-in field if you wish to have your EC coins to be "frozen" or
not (until you
come with a ZK PQ safe of ownership of the coin at a latter time),
once a "tripwire"
proof is included in the chain. This would still require some
secondary registered
coin cache to have the effect being applied, though I believe this could be done
leveraging the BIP141 commitment extension mechanism.

> This sounds similar to my own proposal, DropKick, which is also OTS-like in the way
> commitments are opened. I'll open a new thread soon to discuss that :)

Cool, I'll have a look, using chain time as some sort of conveying
information is an interesting idea.

Best,
Antoine
OTS hash: 959e84871689e6ee1f8e19ae50727549164d6f2e881f5cef3a9fe3700c0e6f21


Le jeu. 20 août 2026 à 17:33, conduition <conduition@proton.me> a écrit :

> Hi Antoine,
>
> One way to alleviate the problem would be to consider the
> spent of the NUMS point, that can be a hardcoded value that
> one can commit in a dedicated coinbase output as a "proof of
> work in itself" where the CheckProofOfWOrk() would return true
> for it and the nChainWork of the chain in which the NUMS spent
> is included would get a bonus (e.g *20 the last period's difficulty).
>
>
> A very interesting idea! Essentially this gives a one-time difficulty
> advantage to miners who choose to include the tripwire proof, so a "51%
> attack" to censor that proof would need a much larger share of hashrate.
> For example, if the honest miners receive a 2x advantage for mining the
> tripwire, then censoring miners would need to hold at least double the
> hashrate of the honest miners (e.g a "67% attack"). If the advantage is 4x,
> then they'd need at least 4x the hashrate (e.g. an "81% attack"), etc.
>
> It's clever, but the main problem is that it's a hard fork, as you mention:
>
> All network nodes sharing this consensus mechanism would follow
> the new and same chain ordering, overruling the most proof of
> work ordering.
>
>
> Nodes that don't upgrade would see the new "advantaged" block containing
> the tripwire proof as having an invalid PoW, and would reject it.
>
> Granted, this would be a pre-scheduled hard-fork agreed upon presumably
> well in-advance of the (undefined) fork date, as opposed to an emergency
> hard fork of the kind that split ETH and ETC back in the day, or the kind
> that would be needed to reverse a hypothetical mass-quantum-theft event. So
> maybe you could argue it'd be acceptable as long as enough nodes have
> upgraded by Q-day.
>
> This group signature constituted of a merkle tree of signatures
> would be attach a "weight" based on the amount PQ signed for the
> coins, and if the "weight" is superior to some threshold, the
> block attaching this special "one-time" group signature would
> a POW ordering bonus and the "tripwire" effect would be attached.
>
>
> I think this would also be a hard fork for similar reasons.
>
> Plus, as you mentioned, we would run the risk of a dishonest minority
> colluding to trigger the fork early. I especially worry about corporate
> actors here, who now control a significant fraction of the supply volume,
> and might have incentive to jump the gun and ossify bitcoin's cryptography
> early.
>
> -----
>
> A UASF-like approach is probably the better option here to prevent miner
> collusion: Perhaps if we distinguish the set of "active" nodes, and write
> rules that say "if an active node has seen a tripwire proof, they must
> disregard any blockchain that doesn't include a tripwire proof". Maybe
> you'd call this a "block policy".
>
> This obviously doesn't work for nodes doing IBD (the first block after
> genesis would be considered invalid!) or nodes that come online after
> sleeping a while (they'd reject the first new block after seeing the
> tripwire proof!) so there would need to be some means to distinguish those
> cases from an active synchronized node. Not sure how that'd work.
>
> By leveraging the preimage in some ZK-proof of a PQ-safe scheme
> a legitimate coin owner could be able to prove that her or him
> *knew* the discreet log at some point in time of the bitcoin
> blockchain. This knowledge could be leveraged to allow the transfer
> of the coins a posteriori of the "tripwire" lock in function of
> the post-quantum transition policy opt-ed in by the coin owner.
>
>
> Are you describing this as a rescue protocol, or a pre-registration
> protocol? Pre-registration protocols aren't that useful if we have a rescue
> protocol, or even just having PQ-safe wallets, because if one can take the
> proactive measure to pre-register, why not simply move one's coins to an
> address that can be rescued later, or better yet to a PQ-secure address?
>
> A rescue protocol on the other hand must assume zero action from the user
> prior to Q-day (i.e. tripwire activation).
>
> A simple certificate can have a very simple format, e.g:
>
> <1-byte certificate version> <opt-in tripwire lock> <sha256_hash>
> <signature>
>
>
> What is the "opt-in tripwire lock" field here?
>
> The scheme is not bulletproof, as we cannot have certainty, _if_ and
> _when_ a CQRC will appear, however in its simple logic it could be
> done today (it's like open-timestamp the marginal cost of a certificate
> is very very low, the witness cost only being encumbered at spending).
> This idea only to add more color on the painture pallet of the technical
> optional to protect EC exposed coins.
>
>
> This sounds similar to my own proposal, DropKick, which is also OTS-like
> in the way commitments are opened. I'll open a new thread soon to discuss
> that :)
>
>
> regards,
> conduition
> On Wednesday, August 19th, 2026 at 6:36 PM, Antoine Riard <
> antoine.riard@gmail.com> wrote:
>
> Hello,
>
> In this post, I'm detailing (a) what could be a solution for
> the game-theory difficulties of the "tripwire" NUMS point and
> (b) a second solution for the exact same problem, relying on
> different assumptions and (c) a variant of a commit/reveal
> rescue protocol for EC coins based on the strict ordering of
> the bitcoin blockchain.
>
> Most of the ideas are "rough" (and maybe a bit heretical...),
> the whole is for putting more tools on the design table, on
> what can be done in the face of CQRC adversarie(s) aiming to
> compromise the chain finality, among other attacks goals.
>
> ## A. NUMS Spend As a Proof of Equivalence of POW
>
> One of the difficulty previously raised with a PQ-flag
> transaction based on a solution to the "tripwire" is the risk
> of "tx-withold" being coordinated by a majority coalition of
> miners eager to exploit EC coins in coordination with a CQRC [0].
>
> There are able to dictate what is the chain state, of which
> the "tripwire" spend must included it to trigger effect, as
> according to Satoshi paper, the "majority decision is represented
> by the longest chain, which has the greatest proof-of-work
> effort invested in it".
>
> If the coalition has a 51% advantage, or an appromixative
> amount of hashrate using other techniques, they can maintain
> their advantage on what is getting in the chain. No one will
> be able to produce an equivalent amount of proof of _work_.
>
> One way to alleviate the problem would be to consider the
> spent of the NUMS point, that can be a hardcoded value that
> one can commit in a dedicated coinbase output as a "proof of
> work in itself" where the CheckProofOfWOrk() would return true
> for it and the nChainWork of the chain in which the NUMS spent
> is included would get a bonus (e.g *20 the last period's difficulty).
>
> By introducing an ordering of the chain among network nodes
> based on multiple factors, of which the NUMS spent would be
> a *one-time* accounted for factor, the bar to trigger the
> activation of the effect of the NUMS spent, whatever they are,
> is removed of the assumption of availing the majority of hashrate [1].
>
> All network nodes sharing this consensus mechanism would follow
> the new and same chain ordering, overruling the most proof of
> work ordering.
>
> This approach still raises some problem of its own, as it's one
> thing to have a "tripwire" NUMS spent that would be part of
> consensus rules, it is still assuming that an entity availing
> a CRQC would produce a proof to activate the "tripwire".
>
> It can sounds a high bar for the community to assume there will
> be a nice and kind CRQC-capable entity, just right there at the
> corner to produce such a proof, if real-world quantum computer
> ever becomes a reality.
>
> ## B. Group Signatures of PQ Upgraded Coins
>
> An alternative solution not running in the same issue of
> availing a CQRC would be to rely on a group signatures of
> some threshold of PQ upgraded coins, e.g having more their
> coins to some variant of crystal-dilithium, falcon or whatever.
>
> The idea is on the same line than the one previously introduced,
> a novel merkle tree of PQ "blessing" signatures could be added
> in the commitment extension structure of BIP141 (i.e in the
> commitment hash of the coinbase output's commitment hash).
>
> This group signature constituted of a merkle tree of signatures
> would be attach a "weight" based on the amount PQ signed for the
> coins, and if the "weight" is superior to some threshold, the
> block attaching this special "one-time" group signature would
> a POW ordering bonus and the "tripwire" effect would be attached.
>
> This scheme comes with the advantage of being CRQC-resistant, as
> a CRQC would not be able to forge a signature, without herself
> or himself already availing some significant amount of coins. It
> would be an "indirect oracle" that a CQRC might be active and is
> more robust than the community.
>
> However, this mechanism, a contrario of the NUMS-based can be
> fooled, even in the absence of a CRQC, therefore making it a
> risk of social blackmail (e.g a proof-of-stake majority meeting
> the threshold deciding to activate the "tripwire" to alter the
> conditions of spendability of numerous coins at their advantage).
>
> A two-phase commit "tripwire" protocol could be designed, where
> the "tripwire" effect is only locked-in (somehow in some analogy
> with BIP9 mechanism), if the threshold is not "challenged" by another
> economic group of coins owner during some period (e.g two to three
> months).
>
> ## C. Chain Timestamped Certificate of Discreet Log Knowledge
>
> On the more technical problem of "what can do procrastinators coin
> owners", one train of solution in the line of the commit-reveal
> protocol that has been previously discussed would be to use the
> chain itself as a publication space of discreet log ownerships.
>
> The problem with a CRQC it's enabling someone to crack the DL k
> of a point K, where K = k * G, blurring the ability of the coin
> owner to prove she or he is the legitimate owner of the coins,
> EC cryptography being based on the knowledge of a discreet log.
>
> While once a CRQC appears in the wild, it is not possible anymore
> to assume that anyone in knowledge of the discreet log is the
> legitimate owner of the coin, a proof of "knowledge anteriority"
> could be able to break the tie in multiple transactions claiming
> to be the owner of the coin.
>
> A simple certificate can have a very simple format, e.g:
>
> <1-byte certificate version> <opt-in tripwire lock> <sha256_hash>
> <signature>
>
> Where the <signature> would commit to all the fields of the
> certificates.
>
> By leveraging the preimage in some ZK-proof of a PQ-safe scheme
> a legitimate coin owner could be able to prove that her or him
> *knew* the discreet log at some point in time of the bitcoin
> blockchain. This knowledge could be leveraged to allow the transfer
> of the coins a posteriori of the "tripwire" lock in function of
> the post-quantum transition policy opt-ed in by the coin owner.
>
> One interesting aspect of this scheme is coin owners could start
> for now building merkle tree of coin certificates and commit them
> in the bip141 commitment structure, a magic number op_return or an
> annex, whatever even if the "proving" consensus logic is only added
> in an ulterior soft-fork.
>
> The scheme is not bulletproof, as we cannot have certainty, _if_ and
> _when_ a CQRC will appear, however in its simple logic it could be
> done today (it's like open-timestamp the marginal cost of a certificate
> is very very low, the witness cost only being encumbered at spending).
> This idea only to add more color on the painture pallet of the technical
> optional to protect EC exposed coins.
>
> Cheers,
> Antoine
> OTS hash: a5a11d42e13724c04d44b953ae5c5f0d152346a7e2041a0a966a62ef148f5ab7
>
> [0] https://groups.google.com/g/bitcoindev/c/DEfcMWSdQRY
> [1] To facilitate P2P communication and discovery of this
> bloc, the nVersion field of the header could commit to a bit.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BHRNFdtWUpg4v2aj9CRMamS7eG9Nem3mdxJq4sZEtOL6w%40mail.gmail.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BHKO%2B64J8EaRR-ih__aE%2Bj-uJAMq79%2BCPVKOvkw9V_Lyw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 25434 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ rescue protocol
  2026-08-22 17:46  0% ` Alex
@ 2026-08-23 23:28  0%   ` 'conduition' via Bitcoin Development Mailing List
  2026-09-18 16:51  0%     ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-23 23:28 UTC (permalink / raw)
  To: Alex; +Cc: bitcoindev


[-- Attachment #1.1.1: Type: text/plain, Size: 12131 bytes --]

Hi Alex,


> We need to have an already functioning PQC solution for Bitcoin itself, deployed, before any of commit/reveal can help, right?


Yes. Two reasons:

First, without on-chain PQC, making commitments would be impossible to do safely unless commitment are aggregated directly by miners into the coinbase transaction.

Second, without on-chain PQ-secure addresses, where would one even rescue coins to? Commit/reveal protocols are meant as a tool saving coins in an emergency, not for everyday spending.


PQ signature schemes are therefore needed as a prerequisite.


regards,
conduition
On Saturday, August 22nd, 2026 at 1:46 PM, Alex <alexhultman@gmail.com> wrote:

> Am I correct in understanding that commit/reveal always depends on someone else already having a valid PQC UTXO to spend?
> So in other words, this can never be a solution for a (procrastinating Bitcoin system), only a solution for (procrastinating Bitcoin users).
> 

> We need to have an already functioning PQC solution for Bitcoin itself, deployed, before any of commit/reveal can help, right?
> 

> Den tors 20 aug. 2026 23:56'conduition' via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> skrev:
> 

> > Dearest friends, colleagues, and lurkers,
> > 

> > I would like to present for your consideration a new commit/reveal rescue protocol to save the coins of quantum procrastinators - those who take no action to move their coins to PQC-enabled wallets by Q-Day.
> > 

> > https://conduition.io/bitcoin/dropkick/
> > 

> > The term "DropKick" is self-descriptive of its usage: Drop a hidden commitment somewhere on the blockchain, and reveal it later with an SPV-style proof to Kick (spend) your legacy coins forward to a new PQ-secure wallet.
> > 

> > Background
> > 

> > As with any post-quantum commit/reveal protocol, DropKick uses the blockchain as a trustless timestamping service to prove than an honest user had earlier chronological knowledge of some secret witness to a quantum-hard one-way function. The honest user hides a commitment in a block, waits for confirmations, and later reveals her commitment to certify she knew the secret witness long before an adversary (like a quantum computer) could have done so. Assuming this witness was indeed kept secret prior to reveal time, it is already too late for the adversary to forge an equivalent proof.
> > 

> > 

> > This general mechanism also allows validators to distinguish an honest bitcoin-holding procrastinator from a CRQC in many situations, and so procrastinators can still authorize spending of their legacy UTXOs even well after Q-day, provided the rescue protocol is deployed before Q-day as a new encumbrance on affected legacy coins.
> > DropKick In One Paragraph
> > 

> > DropKick specifically is a commit/reveal protocol where the commitment `H(H(w, Q), Q)` is hidden somewhere in a block, such as an OP_RETURN or inside a taproot tweak. `Q` is a post-quantum public key, and `w` is the witness to a one-way function `f`, such that `s = f(x)` is the script pubkey (address) encumbering a coin. We can later reveal the witness `w` and a signature from pubkey `Q` to authorize a spend, along with an opening proof showing that the commitment was included in a prior block. The verifier checks the commitment opening is valid and sufficiently old, checks `s = f(x)`, and verifies the PQ-signature from `Q`.
> > 

> > See this section for the actual proving/verifying steps of the protocol.
> > 

> > Features
> > 

> > 

> > Generality: DropKick generalizes to any efficient [1] one-way function based on knowledge asymmetries - things the honest user knows which the adversary doesn't. In the context of Bitcoin, the one-way function would typically be a computational pipeline that includes hashing of secret data unknown to a CRQC, such as "BIP32 hardened derivation of an address" or "hashing a public key or script to build an address" or "taproot key tweaking". DropKick can be instantiated with different one-way functions to encumber different coins.
> > 

> > 

> > Compatibility: DropKick can be deployed as a soft-fork, as it only tightens spending validation rules, and does so only on certain UTXOs.
> > 

> > Confiscation: DropKick can be deployed without confiscating any coins, if so desired, by deploying it as an encumbrance only on UTXOs with decidable knowledge asymmetries like hashed addresses (see this section). If one wishes to maximize the number of legacy coins rescued, DropKick can also be deployed on undecidable knowledge asymmetries like BIP32-CKD. To be clear, P2PK coins cannot be covered by DropKick or indeed by any rescue protocol, as these UTXOs have no known knowledge asymmetries when a CRQC is in play.
> > 

> > Blockspace Efficiency: DropKick has near zero on-chain impact until reveal time, at which point the commitment opening proofs are included in a reveal transaction spending the legacy coins. Opening proofs could be attached in an OP_RETURN for backwards compatibility, or for better efficiency the proofs could be attached in a new transaction witness field which would allow for the 4x segwit discount to apply. DropKick opening proofs are approximately the same size as SPV or OpenTimestamps proofs (less than a kilobyte) and those proofs can be reused to rescue multiple related UTXOs, e.g. coins on the same address, or coins on addresses derived from the same seed.
> > 

> > Performance: DropKick opening proofs cost very little to verify: a few hash invocations, about as fast to verify as an SPV proof or lamport signature of the same size, and the cost of verification scales linearly with the size of the proof. If one has `txindex=1` enabled, verification is even faster. The only prerequisite data needed to verify the opening proof is the set of all Bitcoin block headers. Verifying the revealed witness `w` is exactly as efficient as evaluating the one-way function `f(w)`.
> > 

> > 

> > Ergonomics: Procrastinator do not need to have their own PQ-safe UTXOs available to execute a DropKick rescue: Users can delegate their commitments to untrusted third party servers called "aggregators" who do have PQ-safe UTXOs. These servers take it upon themselves to aggregate the commitments of other users together into a merkle tree, whose root they publish on-chain. Those aggregators can charge a salvage fee for their services if desired, paid in-band from the rescued UTXOs, or up-front out-of-band. Procrastinators can shop between different aggregators, and anyone with PQ-safe UTXOs can operate one.
> > 

> > Comparison to Lifeboat
> > 

> > DropKick competes directly with Tadge Dryja's Lifeboat/Lifejacket proposal (also see this older post), but DropKick aims for a different (lower) degree of security in exchange for a simpler implementation surface, more flexibility, and better efficiency.
> > 

> > The two protocols fulfill functionally similar roles, so I will take a moment to compare and contrast DropKick and Lifeboat/Lifejacket.
> > 

> > DropKick includes some novel features which Lifeboat does not, such as key certification (allowing things like RBF, or equivocation, by the honest spender), or generalization to arbitrary one-way functions. Such developments could be easily transferred to Lifeboat as well, so I will mostly ignore these minor differences here.
> > 

> > The fundamental difference between DropKick and Lifeboat is the commitment ordering requirement.
> > 

> > 

> > -   Lifeboat requires procrastinators to (1) procure a PQ-secure UTXO, and (2) upload a ~96-byte commitment in-the-clear in a new transaction, such as in an OP_RETURN or inscription. Validators must index all such commitments, so that they can chronologically order the revealed commitments later. Reveals reference this index to authorize spending: Only the earliest valid commitment for a given witness is allowed to spend the legacy coin that witness unlocks.
> >     

> > -   DropKick encourages procrastinators to hide commitments in merkle trees committed into blocks, such as via a merkle root posted in an OP_RETURN, or in a taproot-style key tweak. Reveals use SPV-style proofs to convince validators that the commitment was included in a past block. Validators therefore do not (and cannot) index all commitments, and so there is no way to confirm any one commitment was earliest.
> > 

> > 

> > 

> > By dropping the commitment ordering requirement, DropKick skips the need for a new index database collecting all the commitments, and this frees us from putting commitments on chain in-the-clear. DropKick commitments can be hidden off-chain, but anchored to the chain in merkle trees of arbitrary size, which is the key feature that enables the new role of aggregators, and means procrastinators don't need PQ-UTXOs to publish a commitment and rescue their legacy coins.
> > 

> > To gain these benefits, DropKick sacrifices some security, by admitting miner censorship attacks where miners can intentionally censor a reveal transaction to gain a chance to steal the procrastinator's coins. Lifeboat entirely avoids this class of attacks, whereas DropKick requires a somewhat loose game-theoretical argument that miners will converge on choosing not to censor reveals, provided we enforce a long delay (days or weeks) between commitment and reveal steps, and provided the procrastinator pays a proportional fee to incentivize honest miners. We also have to assume no 51% reorg attacks of course, as a malicious hashrate majority could easily censor any reveal transactions and so steal coins.
> > 

> > However, if this security loss is acceptable, DropKick offers a much simpler and less complex engineering surface area, and supports rescuing users in more diverse situations than LifeBoat can (because PQ UTXOs are mandatory in Lifeboat).
> > 

> > LifeBoat's UX advantage over DropKick is that because of the ordering, there is no long delay or value-proportional fee needed: Users only need to wait a few blocks between commit and reveal stages, and they pay only regular mining fees as usual. DropKick OTOH requires a delay proportional to the fraction of the UTXO one is willing to sacrifice to miners. E.g. if we assume users are willing to sacrifice 1% of their UTXOs, then we need to enforce a reveal delay period of at least 100 blocks. See here for a derivation of these parameters.
> > 

> > Conclusion
> > 

> > So that's it.
> > 

> > I'm submitting DropKick here as a sketch for consideration, not as a concrete proposal. I am most interested to know if anyone can think of a better mechanism to avoid miner censorship attacks, or if we can at least reduce the strength of the assumptions needed for DropKick to resist them.
> > 

> > regards,
> > conduition
> > 

> > 

> > [1]: The one-way function must be efficient so that verifiers can recompute it to validate reveal transactions without DoS risks. For example, BIP32 master key derivation via BIP39 is not considered efficient because it uses PBKDF2, whereas BIP32 CKD is efficient if restricted to a maximum derivation depth.
> > 

> > --
> > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/O_i0gml6GTRro49f8c8jlCmgwOH5ZMDsJg4zxe-pX6akiGaibaFP7ilCTX90ZDfKORvmd3YlU4UUZWkwI-NPlvEtY8eVAvCFqO_ckuMG7m8%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 21428 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ rescue protocol
  2026-08-20 21:30  1% [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ " 'conduition' via Bitcoin Development Mailing List
@ 2026-08-22 17:46  0% ` Alex
  2026-08-23 23:28  0%   ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Alex @ 2026-08-22 17:46 UTC (permalink / raw)
  To: conduition; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 12271 bytes --]

Am I correct in understanding that commit/reveal always depends on someone
else already having a valid PQC UTXO to spend?

So in other words, this can never be a solution for a (procrastinating
Bitcoin system), only a solution for (procrastinating Bitcoin users).

We need to have an already functioning PQC solution for Bitcoin itself,
deployed, before any of commit/reveal can help, right?

Den tors 20 aug. 2026 23:56'conduition' via Bitcoin Development Mailing
List <bitcoindev@googlegroups.com> skrev:

> Dearest friends, colleagues, and lurkers,
>
> I would like to present for your consideration a new commit/reveal rescue
> protocol to save the coins of quantum procrastinators - those who take no
> action to move their coins to PQC-enabled wallets by Q-Day.
>
> https://conduition.io/bitcoin/dropkick/
>
> The term "DropKick" is self-descriptive of its usage: *Drop* a hidden
> commitment somewhere on the blockchain, and reveal it later with an
> SPV-style proof to *Kick* (spend) your legacy coins forward to a new
> PQ-secure wallet.
>
> Background
>
> As with any post-quantum commit/reveal protocol, DropKick uses the
> blockchain as a trustless timestamping service to prove than an honest user
> had earlier chronological knowledge of some secret *witness* to a
> quantum-hard* one-way function*. The honest user hides a *commitment* in
> a block, waits for confirmations, and later *reveals* her commitment to
> certify she knew the secret witness long before an adversary (like a
> quantum computer) could have done so. Assuming this witness was indeed kept
> secret prior to reveal time, it is already too late for the adversary to
> forge an equivalent proof.
>
>
> This general mechanism also allows validators to distinguish an honest
> bitcoin-holding procrastinator from a CRQC in many situations, and so
> procrastinators can still authorize spending of their legacy UTXOs even
> well after Q-day, provided the rescue protocol is deployed *before* Q-day
> as a new encumbrance on affected legacy coins.
>
> DropKick In One Paragraph
>
> DropKick specifically is a commit/reveal protocol where the commitment H(H(w,
> Q), Q)​ is hidden somewhere in a block, such as an OP_RETURN or inside a
> taproot tweak. Q​ is a post-quantum public key, and w​ is the witness to
> a one-way function f​, such that s = f(x)​ is the script pubkey (address)
> encumbering a coin. We can later reveal the witness w​ and a signature
> from pubkey Q​ to authorize a spend, along with an *opening proof* showing
> that the commitment was included in a prior block. The verifier checks the
> commitment opening is valid and sufficiently old, checks s = f(x)​, and
> verifies the PQ-signature from Q​.
>
> See this section for the actual proving/verifying steps of the protocol.
> <https://conduition.io/bitcoin/dropkick/#DropKick>
>
> Features
>
> *Generality:* DropKick generalizes to any *efficient *[1] one-way
> function based on knowledge asymmetries - things the honest user knows
> which the adversary doesn't. In the context of Bitcoin, the one-way
> function would typically be a computational pipeline that includes hashing
> of secret data unknown to a CRQC, such as "BIP32 hardened derivation of an
> address" or "hashing a public key or script to build an address" or
> "taproot key tweaking". DropKick can be instantiated with different one-way
> functions to encumber different coins.
>
> *Compatibility:* DropKick can be deployed as a soft-fork, as it only
> *tightens* spending validation rules, and does so only on certain UTXOs.
>
> *Confiscation:* DropKick can be deployed *without* confiscating any
> coins, if so desired, by deploying it as an encumbrance only on UTXOs with
> *decidable* knowledge asymmetries like hashed addresses (see this section
> <https://conduition.io/bitcoin/dropkick/#Knowledge-Asymmetries>). If one
> wishes to maximize the number of legacy coins rescued, DropKick can also be
> deployed on *undecidable* knowledge asymmetries like BIP32-CKD. To be
> clear, P2PK coins cannot be covered by DropKick or indeed by any rescue
> protocol, as these UTXOs have no known knowledge asymmetries when a CRQC is
> in play.
>
> *Blockspace Efficiency:* DropKick has near zero on-chain impact until
> reveal time, at which point the commitment opening proofs are included in a *reveal
> transaction* spending the legacy coins. Opening proofs could be attached
> in an OP_RETURN for backwards compatibility, or for better efficiency the
> proofs could be attached in a new transaction witness field which would
> allow for the 4x segwit discount to apply. DropKick opening proofs are
> approximately the same size as SPV
> <https://learnmeabitcoin.com/technical/networking/node/#lightweight-node>
> or OpenTimestamps <https://opentimestamps.org/> proofs (less than a
> kilobyte) and those proofs can be reused to rescue multiple related UTXOs,
> e.g. coins on the same address, or coins on addresses derived from the same
> seed.
>
> *Performance:* DropKick opening proofs cost very little to verify: a few
> hash invocations, about as fast to verify as an SPV proof or lamport
> signature of the same size, and the cost of verification scales linearly
> with the size of the proof. If one has txindex=1​ enabled, verification
> is even faster. The only prerequisite data needed to verify the opening
> proof is the set of all Bitcoin block headers. Verifying the revealed
> witness w​ is exactly as efficient as evaluating the one-way function f(w)
> ​.
>
> *Ergonomics: *Procrastinator *do not* need to have their own PQ-safe
> UTXOs available to execute a DropKick rescue: Users can delegate their
> commitments to untrusted third party servers called "aggregators" who *do* have
> PQ-safe UTXOs. These servers take it upon themselves to aggregate the
> commitments of other users together into a merkle tree, whose root they
> publish on-chain. Those aggregators can charge a salvage fee for their
> services if desired, paid in-band from the rescued UTXOs, or up-front out-of-band. Procrastinators
> can shop between different aggregators, and anyone with PQ-safe UTXOs can
> operate one.
>
> Comparison to Lifeboat
>
> DropKick competes directly with Tadge Dryja's Lifeboat/Lifejacket proposal
> <https://www.youtube.com/watch?v=PmW90HX89P8> (also see this older post
> <https://groups.google.com/g/bitcoindev/c/LpWOcXMcvk8/>), but DropKick
> aims for a different (lower) degree of security in exchange for a simpler
> implementation surface, more flexibility, and better efficiency.
>
> The two protocols fulfill functionally similar roles, so I will take a
> moment to compare and contrast DropKick and Lifeboat/Lifejacket.
>
> DropKick includes some novel features which Lifeboat does not, such as *key
> certification *(allowing things like RBF, or equivocation, by the honest
> spender), or generalization to arbitrary one-way functions. Such
> developments could be easily transferred to Lifeboat as well, so I will
> mostly ignore these minor differences here.
>
> The fundamental difference between DropKick and Lifeboat is the commitment
> ordering requirement.
>
>
>    - Lifeboat requires procrastinators to (1) procure a PQ-secure UTXO,
>    and (2) upload a ~96-byte commitment in-the-clear in a new transaction,
>    such as in an OP_RETURN or inscription. Validators must index all such
>    commitments, so that they can *chronologically order* the revealed
>    commitments later. Reveals reference this index to authorize spending: Only
>    the earliest valid commitment for a given witness is allowed to spend
>    the legacy coin that witness unlocks.
>    - DropKick encourages procrastinators to *hide* commitments in merkle
>    trees committed into blocks, such as via a merkle root posted in an
>    OP_RETURN, or in a taproot-style key tweak. Reveals use SPV-style proofs to
>    convince validators that the commitment was included in a past block. *Validators
>    therefore do not (and cannot) index all commitments, and so there is no way
>    to confirm any one commitment was earliest*.
>
>
> By dropping the commitment ordering requirement, DropKick skips the need
> for a new index database collecting all the commitments, and this frees us
> from putting commitments on chain in-the-clear. DropKick commitments can be
> hidden off-chain, but anchored to the chain in merkle trees of arbitrary
> size, which is the key feature that enables the new role of aggregators,
> and means procrastinators don't need PQ-UTXOs to publish a commitment and
> rescue their legacy coins.
>
> To gain these benefits, DropKick sacrifices some security, by admitting miner
> censorship attacks <https://conduition.io/bitcoin/dropkick/#Censorship> where
> miners can intentionally censor a reveal transaction to gain a chance to
> steal the procrastinator's coins. Lifeboat entirely avoids this class of
> attacks, whereas DropKick requires a somewhat loose game-theoretical
> argument <https://conduition.io/bitcoin/dropkick/#Appendix-Game-Theory>
> that miners will converge on choosing *not* to censor reveals, provided
> we enforce a long delay (days or weeks) between commitment and reveal
> steps, and provided the procrastinator pays a proportional fee to
> incentivize honest miners. We also have to assume no 51% reorg attacks of
> course, as a malicious hashrate majority could easily censor any reveal
> transactions and so steal coins.
>
> However, if this security loss is acceptable, DropKick offers a much
> simpler and less complex engineering surface area, and supports rescuing
> users in more diverse situations than LifeBoat can (because PQ UTXOs are
> mandatory in Lifeboat).
>
> LifeBoat's UX advantage over DropKick is that because of the ordering,
> there is no long delay or value-proportional fee needed: Users only need to
> wait a few blocks between *commit* and *reveal* stages, and they pay only
> regular mining fees as usual. DropKick OTOH requires a delay proportional
> to the fraction of the UTXO one is willing to sacrifice to miners. E.g. if
> we assume users are willing to sacrifice 1% of their UTXOs, then we need to
> enforce a reveal delay period of at least 100 blocks. See here for a
> derivation of these parameters
> <https://conduition.io/bitcoin/dropkick/#Parameters>.
>
> Conclusion
>
> So that's it.
>
> I'm submitting DropKick here as a sketch for consideration, not as a
> concrete proposal. I am most interested to know if anyone can think of a
> better mechanism to avoid miner censorship attacks, or if we can at least
> reduce the strength of the assumptions needed for DropKick to resist them.
>
> regards,
> conduition
>
>
> [1]: The one-way function must be *efficient* so that verifiers can
> recompute it to validate reveal transactions without DoS risks. For
> example, BIP32 master key derivation via BIP39 is not considered efficient
> because it uses PBKDF2, whereas BIP32 CKD is efficient if restricted to a
> maximum derivation depth.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me
> <https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAHPaHkr5r4%2BhodZv6F2S1yCq_UcHSr2iCrkYLgZ_vryNgwbRPA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 18995 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ rescue protocol
@ 2026-08-20 21:30  1% 'conduition' via Bitcoin Development Mailing List
  2026-08-22 17:46  0% ` Alex
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-20 21:30 UTC (permalink / raw)
  To: bitcoindev@googlegroups.com


[-- Attachment #1.1.1: Type: text/plain, Size: 10103 bytes --]

Dearest friends, colleagues, and lurkers,

I would like to present for your consideration a new commit/reveal rescue protocol to save the coins of quantum procrastinators - those who take no action to move their coins to PQC-enabled wallets by Q-Day.

https://conduition.io/bitcoin/dropkick/

The term "DropKick" is self-descriptive of its usage: Drop a hidden commitment somewhere on the blockchain, and reveal it later with an SPV-style proof to Kick (spend) your legacy coins forward to a new PQ-secure wallet.

Background

As with any post-quantum commit/reveal protocol, DropKick uses the blockchain as a trustless timestamping service to prove than an honest user had earlier chronological knowledge of some secret witness to a quantum-hard one-way function. The honest user hides a commitment in a block, waits for confirmations, and later reveals her commitment to certify she knew the secret witness long before an adversary (like a quantum computer) could have done so. Assuming this witness was indeed kept secret prior to reveal time, it is already too late for the adversary to forge an equivalent proof.


This general mechanism also allows validators to distinguish an honest bitcoin-holding procrastinator from a CRQC in many situations, and so procrastinators can still authorize spending of their legacy UTXOs even well after Q-day, provided the rescue protocol is deployed before Q-day as a new encumbrance on affected legacy coins.
DropKick In One Paragraph

DropKick specifically is a commit/reveal protocol where the commitment `H(H(w, Q), Q)` is hidden somewhere in a block, such as an OP_RETURN or inside a taproot tweak. `Q` is a post-quantum public key, and `w` is the witness to a one-way function `f`, such that `s = f(x)` is the script pubkey (address) encumbering a coin. We can later reveal the witness `w` and a signature from pubkey `Q` to authorize a spend, along with an opening proof showing that the commitment was included in a prior block. The verifier checks the commitment opening is valid and sufficiently old, checks `s = f(x)`, and verifies the PQ-signature from `Q`.

See this section for the actual proving/verifying steps of the protocol.

Features


Generality: DropKick generalizes to any efficient [1] one-way function based on knowledge asymmetries - things the honest user knows which the adversary doesn't. In the context of Bitcoin, the one-way function would typically be a computational pipeline that includes hashing of secret data unknown to a CRQC, such as "BIP32 hardened derivation of an address" or "hashing a public key or script to build an address" or "taproot key tweaking". DropKick can be instantiated with different one-way functions to encumber different coins.


Compatibility: DropKick can be deployed as a soft-fork, as it only tightens spending validation rules, and does so only on certain UTXOs.

Confiscation: DropKick can be deployed without confiscating any coins, if so desired, by deploying it as an encumbrance only on UTXOs with decidable knowledge asymmetries like hashed addresses (see this section). If one wishes to maximize the number of legacy coins rescued, DropKick can also be deployed on undecidable knowledge asymmetries like BIP32-CKD. To be clear, P2PK coins cannot be covered by DropKick or indeed by any rescue protocol, as these UTXOs have no known knowledge asymmetries when a CRQC is in play.

Blockspace Efficiency: DropKick has near zero on-chain impact until reveal time, at which point the commitment opening proofs are included in a reveal transaction spending the legacy coins. Opening proofs could be attached in an OP_RETURN for backwards compatibility, or for better efficiency the proofs could be attached in a new transaction witness field which would allow for the 4x segwit discount to apply. DropKick opening proofs are approximately the same size as SPV or OpenTimestamps proofs (less than a kilobyte) and those proofs can be reused to rescue multiple related UTXOs, e.g. coins on the same address, or coins on addresses derived from the same seed.

Performance: DropKick opening proofs cost very little to verify: a few hash invocations, about as fast to verify as an SPV proof or lamport signature of the same size, and the cost of verification scales linearly with the size of the proof. If one has `txindex=1` enabled, verification is even faster. The only prerequisite data needed to verify the opening proof is the set of all Bitcoin block headers. Verifying the revealed witness `w` is exactly as efficient as evaluating the one-way function `f(w)`.


Ergonomics: Procrastinator do not need to have their own PQ-safe UTXOs available to execute a DropKick rescue: Users can delegate their commitments to untrusted third party servers called "aggregators" who do have PQ-safe UTXOs. These servers take it upon themselves to aggregate the commitments of other users together into a merkle tree, whose root they publish on-chain. Those aggregators can charge a salvage fee for their services if desired, paid in-band from the rescued UTXOs, or up-front out-of-band. Procrastinators can shop between different aggregators, and anyone with PQ-safe UTXOs can operate one.

Comparison to Lifeboat

DropKick competes directly with Tadge Dryja's Lifeboat/Lifejacket proposal (also see this older post), but DropKick aims for a different (lower) degree of security in exchange for a simpler implementation surface, more flexibility, and better efficiency.

The two protocols fulfill functionally similar roles, so I will take a moment to compare and contrast DropKick and Lifeboat/Lifejacket.

DropKick includes some novel features which Lifeboat does not, such as key certification (allowing things like RBF, or equivocation, by the honest spender), or generalization to arbitrary one-way functions. Such developments could be easily transferred to Lifeboat as well, so I will mostly ignore these minor differences here.

The fundamental difference between DropKick and Lifeboat is the commitment ordering requirement.


-   Lifeboat requires procrastinators to (1) procure a PQ-secure UTXO, and (2) upload a ~96-byte commitment in-the-clear in a new transaction, such as in an OP_RETURN or inscription. Validators must index all such commitments, so that they can chronologically order the revealed commitments later. Reveals reference this index to authorize spending: Only the earliest valid commitment for a given witness is allowed to spend the legacy coin that witness unlocks.
    

-   DropKick encourages procrastinators to hide commitments in merkle trees committed into blocks, such as via a merkle root posted in an OP_RETURN, or in a taproot-style key tweak. Reveals use SPV-style proofs to convince validators that the commitment was included in a past block. Validators therefore do not (and cannot) index all commitments, and so there is no way to confirm any one commitment was earliest.



By dropping the commitment ordering requirement, DropKick skips the need for a new index database collecting all the commitments, and this frees us from putting commitments on chain in-the-clear. DropKick commitments can be hidden off-chain, but anchored to the chain in merkle trees of arbitrary size, which is the key feature that enables the new role of aggregators, and means procrastinators don't need PQ-UTXOs to publish a commitment and rescue their legacy coins.

To gain these benefits, DropKick sacrifices some security, by admitting miner censorship attacks where miners can intentionally censor a reveal transaction to gain a chance to steal the procrastinator's coins. Lifeboat entirely avoids this class of attacks, whereas DropKick requires a somewhat loose game-theoretical argument that miners will converge on choosing not to censor reveals, provided we enforce a long delay (days or weeks) between commitment and reveal steps, and provided the procrastinator pays a proportional fee to incentivize honest miners. We also have to assume no 51% reorg attacks of course, as a malicious hashrate majority could easily censor any reveal transactions and so steal coins.

However, if this security loss is acceptable, DropKick offers a much simpler and less complex engineering surface area, and supports rescuing users in more diverse situations than LifeBoat can (because PQ UTXOs are mandatory in Lifeboat).

LifeBoat's UX advantage over DropKick is that because of the ordering, there is no long delay or value-proportional fee needed: Users only need to wait a few blocks between commit and reveal stages, and they pay only regular mining fees as usual. DropKick OTOH requires a delay proportional to the fraction of the UTXO one is willing to sacrifice to miners. E.g. if we assume users are willing to sacrifice 1% of their UTXOs, then we need to enforce a reveal delay period of at least 100 blocks. See here for a derivation of these parameters. 

Conclusion

So that's it.

I'm submitting DropKick here as a sketch for consideration, not as a concrete proposal. I am most interested to know if anyone can think of a better mechanism to avoid miner censorship attacks, or if we can at least reduce the strength of the assumptions needed for DropKick to resist them.

regards,
conduition


[1]: The one-way function must be efficient so that verifiers can recompute it to validate reveal transactions without DoS risks. For example, BIP32 master key derivation via BIP39 is not considered efficient because it uses PBKDF2, whereas BIP32 CKD is efficient if restricted to a maximum derivation depth.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ruufSzDPIml1W5hF-m_IJLeBzuhqey6CGe7-zT1WwY4vlhVj_5NJTSalz43T4ZlZgXs3sDesW61FaU_asfj39Ri1QgSXtz7-OekEt6bbTvo%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 18262 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] post-quantum: solution ideas to "tripwire"game-theory issues + a certificate-based rescue protocol
  2026-08-19 22:27  1% [bitcoindev] post-quantum: solution ideas to "tripwire"game-theory issues + a certificate-based rescue protocol Antoine Riard
@ 2026-08-20 16:33  0% ` 'conduition' via Bitcoin Development Mailing List
  2026-08-26 21:54  0%   ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-20 16:33 UTC (permalink / raw)
  To: Antoine Riard; +Cc: Bitcoin Development Mailing List, btc


[-- Attachment #1.1.1: Type: text/plain, Size: 13066 bytes --]

Hi Antoine,


> One way to alleviate the problem would be to consider thespent of the NUMS point, that can be a hardcoded value that
> one can commit in a dedicated coinbase output as a "proof of
> work in itself" where the CheckProofOfWOrk() would return true
> for it and the nChainWork of the chain in which the NUMS spent
> is included would get a bonus (e.g *20 the last period's difficulty).



A very interesting idea! Essentially this gives a one-time difficulty advantage to miners who choose to include the tripwire proof, so a "51% attack" to censor that proof would need a much larger share of hashrate. For example, if the honest miners receive a 2x advantage for mining the tripwire, then censoring miners would need to hold at least double the hashrate of the honest miners (e.g a "67% attack"). If the advantage is 4x, then they'd need at least 4x the hashrate (e.g. an "81% attack"), etc.


It's clever, but the main problem is that it's a hard fork, as you mention:


> All network nodes sharing this consensus mechanism would followthe new and same chain ordering, overruling the most proof of
> work ordering.



Nodes that don't upgrade would see the new "advantaged" block containing the tripwire proof as having an invalid PoW, and would reject it.


Granted, this would be a pre-scheduled hard-fork agreed upon presumably well in-advance of the (undefined) fork date, as opposed to an emergency hard fork of the kind that split ETH and ETC back in the day, or the kind that would be needed to reverse a hypothetical mass-quantum-theft event. So maybe you could argue it'd be acceptable as long as enough nodes have upgraded by Q-day.


> This group signature constituted of a merkle tree of signatureswould be attach a "weight" based on the amount PQ signed for the
> coins, and if the "weight" is superior to some threshold, the
> block attaching this special "one-time" group signature would
> a POW ordering bonus and the "tripwire" effect would be attached.



I think this would also be a hard fork for similar reasons. 


Plus, as you mentioned, we would run the risk of a dishonest minority colluding to trigger the fork early. I especially worry about corporate actors here, who now control a significant fraction of the supply volume, and might have incentive to jump the gun and ossify bitcoin's cryptography early.


-----


A UASF-like approach is probably the better option here to prevent miner collusion: Perhaps if we distinguish the set of "active" nodes, and write rules that say "if an active node has seen a tripwire proof, they must disregard any blockchain that doesn't include a tripwire proof". Maybe you'd call this a "block policy".


This obviously doesn't work for nodes doing IBD (the first block after genesis would be considered invalid!) or nodes that come online after sleeping a while (they'd reject the first new block after seeing the tripwire proof!) so there would need to be some means to distinguish those cases from an active synchronized node. Not sure how that'd work.


> By leveraging the preimage in some ZK-proof of a PQ-safe schemea legitimate coin owner could be able to prove that her or him
> *knew* the discreet log at some point in time of the bitcoin
> blockchain. This knowledge could be leveraged to allow the transfer
> of the coins a posteriori of the "tripwire" lock in function of
> the post-quantum transition policy opt-ed in by the coin owner.



Are you describing this as a rescue protocol, or a pre-registration protocol? Pre-registration protocols aren't that useful if we have a rescue protocol, or even just having PQ-safe wallets, because if one can take the proactive measure to pre-register, why not simply move one's coins to an address that can be rescued later, or better yet to a PQ-secure address?


A rescue protocol on the other hand must assume zero action from the user prior to Q-day (i.e. tripwire activation). 


> A simple certificate can have a very simple format, e.g:
> 

> <1-byte certificate version> <opt-in tripwire lock> <sha256_hash> <signature>

What is the "opt-in tripwire lock" field here?


> The scheme is not bulletproof, as we cannot have certainty, _if_ and_when_ a CQRC will appear, however in its simple logic it could be
> done today (it's like open-timestamp the marginal cost of a certificate
> is very very low, the witness cost only being encumbered at spending).
> This idea only to add more color on the painture pallet of the technical
> optional to protect EC exposed coins.



This sounds similar to my own proposal, DropKick, which is also OTS-like in the way commitments are opened. I'll open a new thread soon to discuss that :)


regards,
conduition

On Wednesday, August 19th, 2026 at 6:36 PM, Antoine Riard <antoine.riard@gmail.com> wrote:

> Hello,
> 

> In this post, I'm detailing (a) what could be a solution for
> the game-theory difficulties of the "tripwire" NUMS point and
> (b) a second solution for the exact same problem, relying on
> different assumptions and (c) a variant of a commit/reveal
> rescue protocol for EC coins based on the strict ordering of
> the bitcoin blockchain.
> 

> Most of the ideas are "rough" (and maybe a bit heretical...),
> the whole is for putting more tools on the design table, on
> what can be done in the face of CQRC adversarie(s) aiming to
> compromise the chain finality, among other attacks goals.
> 

> ## A. NUMS Spend As a Proof of Equivalence of POW
> 

> One of the difficulty previously raised with a PQ-flag
> transaction based on a solution to the "tripwire" is the risk
> of "tx-withold" being coordinated by a majority coalition of
> miners eager to exploit EC coins in coordination with a CQRC [0].
> 

> There are able to dictate what is the chain state, of which
> the "tripwire" spend must included it to trigger effect, as
> according to Satoshi paper, the "majority decision is represented
> by the longest chain, which has the greatest proof-of-work
> effort invested in it".
> 

> If the coalition has a 51% advantage, or an appromixative
> amount of hashrate using other techniques, they can maintain
> their advantage on what is getting in the chain. No one will
> be able to produce an equivalent amount of proof of _work_.
> 

> One way to alleviate the problem would be to consider the
> spent of the NUMS point, that can be a hardcoded value that
> one can commit in a dedicated coinbase output as a "proof of
> work in itself" where the CheckProofOfWOrk() would return true
> for it and the nChainWork of the chain in which the NUMS spent
> is included would get a bonus (e.g *20 the last period's difficulty).
> 

> By introducing an ordering of the chain among network nodes
> based on multiple factors, of which the NUMS spent would be
> a *one-time* accounted for factor, the bar to trigger the
> activation of the effect of the NUMS spent, whatever they are,
> is removed of the assumption of availing the majority of hashrate [1].
> 

> All network nodes sharing this consensus mechanism would follow
> the new and same chain ordering, overruling the most proof of
> work ordering.
> 

> This approach still raises some problem of its own, as it's one
> thing to have a "tripwire" NUMS spent that would be part of
> consensus rules, it is still assuming that an entity availing
> a CRQC would produce a proof to activate the "tripwire".
> 

> It can sounds a high bar for the community to assume there will
> be a nice and kind CRQC-capable entity, just right there at the
> corner to produce such a proof, if real-world quantum computer
> ever becomes a reality.
> 

> ## B. Group Signatures of PQ Upgraded Coins
> 

> An alternative solution not running in the same issue of
> availing a CQRC would be to rely on a group signatures of
> some threshold of PQ upgraded coins, e.g having more their
> coins to some variant of crystal-dilithium, falcon or whatever.
> 

> The idea is on the same line than the one previously introduced,
> a novel merkle tree of PQ "blessing" signatures could be added
> in the commitment extension structure of BIP141 (i.e in the
> commitment hash of the coinbase output's commitment hash).
> 

> This group signature constituted of a merkle tree of signatures
> would be attach a "weight" based on the amount PQ signed for the
> coins, and if the "weight" is superior to some threshold, the
> block attaching this special "one-time" group signature would
> a POW ordering bonus and the "tripwire" effect would be attached.
> 

> This scheme comes with the advantage of being CRQC-resistant, as
> a CRQC would not be able to forge a signature, without herself
> or himself already availing some significant amount of coins. It
> would be an "indirect oracle" that a CQRC might be active and is
> more robust than the community.
> 

> However, this mechanism, a contrario of the NUMS-based can be
> fooled, even in the absence of a CRQC, therefore making it a
> risk of social blackmail (e.g a proof-of-stake majority meeting
> the threshold deciding to activate the "tripwire" to alter the
> conditions of spendability of numerous coins at their advantage).
> 

> A two-phase commit "tripwire" protocol could be designed, where
> the "tripwire" effect is only locked-in (somehow in some analogy
> with BIP9 mechanism), if the threshold is not "challenged" by another
> economic group of coins owner during some period (e.g two to three
> months).
> 

> ## C. Chain Timestamped Certificate of Discreet Log Knowledge
> 

> On the more technical problem of "what can do procrastinators coin
> owners", one train of solution in the line of the commit-reveal
> protocol that has been previously discussed would be to use the
> chain itself as a publication space of discreet log ownerships.
> 

> The problem with a CRQC it's enabling someone to crack the DL k
> of a point K, where K = k * G, blurring the ability of the coin
> owner to prove she or he is the legitimate owner of the coins,
> EC cryptography being based on the knowledge of a discreet log.
> 

> While once a CRQC appears in the wild, it is not possible anymore
> to assume that anyone in knowledge of the discreet log is the
> legitimate owner of the coin, a proof of "knowledge anteriority"
> could be able to break the tie in multiple transactions claiming
> to be the owner of the coin.
> 

> A simple certificate can have a very simple format, e.g:
> 

> <1-byte certificate version> <opt-in tripwire lock> <sha256_hash> <signature>
> 

> Where the <signature> would commit to all the fields of the
> certificates.
> 

> By leveraging the preimage in some ZK-proof of a PQ-safe scheme
> a legitimate coin owner could be able to prove that her or him
> *knew* the discreet log at some point in time of the bitcoin
> blockchain. This knowledge could be leveraged to allow the transfer
> of the coins a posteriori of the "tripwire" lock in function of
> the post-quantum transition policy opt-ed in by the coin owner.
> 

> One interesting aspect of this scheme is coin owners could start
> for now building merkle tree of coin certificates and commit them
> in the bip141 commitment structure, a magic number op_return or an
> annex, whatever even if the "proving" consensus logic is only added
> in an ulterior soft-fork.
> 

> The scheme is not bulletproof, as we cannot have certainty, _if_ and
> _when_ a CQRC will appear, however in its simple logic it could be
> done today (it's like open-timestamp the marginal cost of a certificate
> is very very low, the witness cost only being encumbered at spending).
> This idea only to add more color on the painture pallet of the technical
> optional to protect EC exposed coins.
> 

> Cheers,
> Antoine
> OTS hash: a5a11d42e13724c04d44b953ae5c5f0d152346a7e2041a0a966a62ef148f5ab7
> 

> [0] https://groups.google.com/g/bitcoindev/c/DEfcMWSdQRY
> [1] To facilitate P2P communication and discovery of this
> bloc, the nVersion field of the header could commit to a bit.
> 

> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BHRNFdtWUpg4v2aj9CRMamS7eG9Nem3mdxJq4sZEtOL6w%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/UW5dOJNFjgt67sz-2sRUPeMJi0XL6_wSm7zKCmSoj_8IzkQavc-Vo9vwiR7Tbaz7bvP2YrH8b-1JGm-9jNQXQM8dqsw1f1Sl75SHIOt9cOc%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 18365 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] post-quantum: solution ideas to "tripwire"game-theory issues + a certificate-based rescue protocol
@ 2026-08-19 22:27  1% Antoine Riard
  2026-08-20 16:33  0% ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-08-19 22:27 UTC (permalink / raw)
  To: Bitcoin Development Mailing List; +Cc: btc

[-- Attachment #1: Type: text/plain, Size: 7222 bytes --]

Hello,

In this post, I'm detailing (a) what could be a solution for
the game-theory difficulties of the "tripwire" NUMS point and
(b) a second solution for the exact same problem, relying on
different assumptions and (c) a variant of a commit/reveal
rescue protocol for EC coins based on the strict ordering of
the bitcoin blockchain.

Most of the ideas are "rough" (and maybe a bit heretical...),
the whole is for putting more tools on the design table, on
what can be done in the face of CQRC adversarie(s) aiming to
compromise the chain finality, among other attacks goals.

## A. NUMS Spend As a Proof of Equivalence of POW

One of the difficulty previously raised with a PQ-flag
transaction based on a solution to the "tripwire" is the risk
of "tx-withold" being coordinated by a majority coalition of
miners eager to exploit EC coins in coordination with a CQRC [0].

There are able to dictate what is the chain state, of which
the "tripwire" spend must included it to trigger effect, as
according to Satoshi paper, the "majority decision is represented
by the longest chain, which has the greatest proof-of-work
effort invested in it".

If the coalition has a 51% advantage, or an appromixative
amount of hashrate using other techniques, they can maintain
their advantage on what is getting in the chain. No one will
be able to produce an equivalent amount of proof of _work_.

One way to alleviate the problem would be to consider the
spent of the NUMS point, that can be a hardcoded value that
one can commit in a dedicated coinbase output as a "proof of
work in itself" where the CheckProofOfWOrk() would return true
for it and the nChainWork of the chain in which the NUMS spent
is included would get a bonus (e.g *20 the last period's difficulty).

By introducing an ordering of the chain among network nodes
based on multiple factors, of which the NUMS spent would be
a *one-time* accounted for factor, the bar to trigger the
activation of the effect of the NUMS spent, whatever they are,
is removed of the assumption of availing the majority of hashrate [1].

All network nodes sharing this consensus mechanism would follow
the new and same chain ordering, overruling the most proof of
work ordering.

This approach still raises some problem of its own, as it's one
thing to have a "tripwire" NUMS spent that would be part of
consensus rules, it is still assuming that an entity availing
a CRQC would produce a proof to activate the "tripwire".

It can sounds a high bar for the community to assume there will
be a nice and kind CRQC-capable entity, just right there at the
corner to produce such a proof, if real-world quantum computer
ever becomes a reality.

## B. Group Signatures of PQ Upgraded Coins

An alternative solution not running in the same issue of
availing a CQRC would be to rely on a group signatures of
some threshold of PQ upgraded coins, e.g having more their
coins to some variant of crystal-dilithium, falcon or whatever.

The idea is on the same line than the one previously introduced,
a novel merkle tree of PQ "blessing" signatures could be added
in the commitment extension structure of BIP141 (i.e in the
commitment hash of the coinbase output's commitment hash).

This group signature constituted of a merkle tree of signatures
would be attach a "weight" based on the amount PQ signed for the
coins, and if the "weight" is superior to some threshold, the
block attaching this special "one-time" group signature would
a POW ordering bonus and the "tripwire" effect would be attached.

This scheme comes with the advantage of being CRQC-resistant, as
a CRQC would not be able to forge a signature, without herself
or himself already availing some significant amount of coins. It
would be an "indirect oracle" that a CQRC might be active and is
more robust than the community.

However, this mechanism, a contrario of the NUMS-based can be
fooled, even in the absence of a CRQC, therefore making it a
risk of social blackmail (e.g a proof-of-stake majority meeting
the threshold deciding to activate the "tripwire" to alter the
conditions of spendability of numerous coins at their advantage).

A two-phase commit "tripwire" protocol could be designed, where
the "tripwire" effect is only locked-in (somehow in some analogy
with BIP9 mechanism), if the threshold is not "challenged" by another
economic group of coins owner during some period (e.g two to three
months).

## C. Chain Timestamped Certificate of Discreet Log Knowledge

On the more technical problem of "what can do procrastinators coin
owners", one train of solution in the line of the commit-reveal
protocol that has been previously discussed would be to use the
chain itself as a publication space of discreet log ownerships.

The problem with a CRQC it's enabling someone to crack the DL k
of a point K, where K = k * G, blurring the ability of the coin
owner to prove she or he is the legitimate owner of the coins,
EC cryptography being based on the knowledge of a discreet log.

While once a CRQC appears in the wild, it is not possible anymore
to assume that anyone in knowledge of the discreet log is the
legitimate owner of the coin, a proof of "knowledge anteriority"
could be able to break the tie in multiple transactions claiming
to be the owner of the coin.

A simple certificate can have a very simple format, e.g:

<1-byte certificate version> <opt-in tripwire lock> <sha256_hash>
<signature>

Where the <signature> would commit to all the fields of the
certificates.

By leveraging the preimage in some ZK-proof of a PQ-safe scheme
a legitimate coin owner could be able to prove that her or him
*knew* the discreet log at some point in time of the bitcoin
blockchain. This knowledge could be leveraged to allow the transfer
of the coins a posteriori of the "tripwire" lock in function of
the post-quantum transition policy opt-ed in by the coin owner.

One interesting aspect of this scheme is coin owners could start
for now building merkle tree of coin certificates and commit them
in the bip141 commitment structure, a magic number op_return or an
annex, whatever even if the "proving" consensus logic is only added
in an ulterior soft-fork.

The scheme is not bulletproof, as we cannot have certainty, _if_ and
_when_ a CQRC will appear, however in its simple logic it could be
done today (it's like open-timestamp the marginal cost of a certificate
is very very low, the witness cost only being encumbered at spending).
This idea only to add more color on the painture pallet of the technical
optional to protect EC exposed coins.

Cheers,
Antoine
OTS hash: a5a11d42e13724c04d44b953ae5c5f0d152346a7e2041a0a966a62ef148f5ab7

[0] https://groups.google.com/g/bitcoindev/c/DEfcMWSdQRY
[1] To facilitate P2P communication and discovery of this
bloc, the nVersion field of the header could commit to a bit.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BHRNFdtWUpg4v2aj9CRMamS7eG9Nem3mdxJq4sZEtOL6w%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8315 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-19  2:32  1%                             ` 'conduition' via Bitcoin Development Mailing List
  2026-08-19 15:18  1%                               ` waxwing/ AdamISZ
@ 2026-08-19 22:16  1%                               ` Pieter Wuille
  1 sibling, 0 replies; 200+ results
From: Pieter Wuille @ 2026-08-19 22:16 UTC (permalink / raw)
  To: conduition; +Cc: waxwing/ AdamISZ, Bitcoin Development Mailing List

Hi, 

On Tuesday, August 18th, 2026 at 10:32 PM, conduition <conduition@proton.me> wrote:

> Oh I misunderstood. So to be clear, a "canary" is just a social signal that should push consensus to activate a soft fork, whereas a "tripwire" is an unattended system that automatically triggers a change to consensus rules.

I like that terminology.

> > While it's certainly possible it's actually triggered by a cooperative CRQC, that's not how I expect ECC disabling to happen (instead I expect a community consensus-changing effort, effected through Miner Lockdown or otherwise). The Tripwire just sets an unambiguous expectation that disabling is intended by Q-day.
> 
> In the absence of evidence, I expect this fork to be highly contentious or delayed until hard evidence is available.

I don't disagree, but I also do expect hard evidence to become available, unless we're actually taking about scenario where a CRQC appears out of nowhere, and in that case there are really no good outcomes.

> I agree but for a different reason on top. Given the polynomial efficiency of Shor, and the massive time/money investment needed to build quantum computers, we have no reason to expect anyone will build a QC that can break 192-bit curves but not 256-bit curves. There is actually incentive not to do so, especially if breaking a 192-bit curve will cause the Bitcoin network (the most ripe target to pay off QC investors) to react by locking itself down. 
> Think of it this way: If you have the mans to build a stable 900 logical-qubit quantum-computer, why not spend the extra time and money to build a 1200 logical-qubit quantum computer? Is a 1.5x factor improvement really so hard at this point? If you do expend the effort, then at least you stand a chance to make some money (e.g. by decrypting old internet traffic on behalf of the NSA).

You seem to be talking about an adversarial CRQC here? Those won't trigger any tripwire, nor publish any canaries.

There is a pretty weird philosophical point here: as far as I'm aware, at this point, there isn't really any application for CRQC-capable hardware except breaking classical cryptography. So beyond scientific curiosity, the only incentive to build one is either adversarial, or to prove it's possible to build one before one lands in adversarial hands. And the better migrated the world is (including Bitcoin...) for PQC, the lower the incentives for both get.

> I think I'm coming to the conclusion that a 256-bit ST-ECDLP tripwire is the way to go, because at least then the canary is unambiguously dead, and it's time to stop using secp256k1, whereas 192-bit curves leave a shred of doubt.

Agreed.

> Really interesting idea there. Small correction: I believe Shor's space (qubit) requirements are dominated primarily by the group order that we are searching for the dlog within, not by the size of the field used for the the elliptic curve group operation. I'm pretty sure the field size would affect runtime complexity (gate count), but not qubit count requirements. (Happy to be corrected). If I'm correct, a group order of approx 2^187 would need approx 842 qubits (at least) to break.

My friendly neighborhood LLM believes the qubit count is primarily a function of the field size (to represent curve coordinates), while the gate count grows with larger with the group (because point multiplication needs more additions), but I am by no means an expert.

> Still, as previously discussed, I'm unsure if a canary which is only slightly harder to break would be meaningful. It'd be nice if we could find some problem which quantum computers of, say, 150 qubits could do, but which classical computers cannot (feasibly) solve. Then we might have a reasonably predictive canary which could be solved by cooperative.

Agreed.

> > From a simplicity standpoint, I think just having a "a UTXO with scriptPubKey X is spent" is ideal, because it reuses all existing block and transaction validation logic, and just adds a trivial trigger.
> 
> I would like to make a case that we should expend the extra effort and not bind the canary to a specific UTXO. I will point to Antoine's game theory arguments about reorgs and miner collusion with CRQCs. 
> 
> If we tie the canary to a specific UTXO, or even to any UTXO with a specific script, then this makes miner censorship of the canary proof very easy: Just block spends of that UTXO (or of any UTXO unlocking the chosen script).

I hadn't considered that. But if miners are actively blocking a security feature (as this effectively is), I think we're in UASF territory already.

> If, on the other hand, we had nodes check something almost as simple, like for example "check every 32-byte OP_RETURN to see if it happens to be the dlog of the NUMS point", then any user can choose to include the proof in their transactions at relatively little cost. Any miners who want to censor the canary proof will have to also censor any such transactions, and so they lose out on the potential fee revenue of the entire TX by doing so.

I think this is pretty unrealistic. Most user software won't have the ability to include a tripwire in an OP_RETURN (this includes all kinds of higher-level / layer-two constructions that need cooperation to build transactions). It further also relies on this happening at a time when fee income is substantial.

> I'm not sure if this incentive is meaningful when compared to the potential bribes that a miner could be offered by a CRQC, but still it is worth considering. It does have the down side that it will slow down block validation slightly (one EC mult per 32-byte OP_RETURN). Maybe this could be accounted for somehow in the sigops budget?

Yeah, these concerns are why I like just triggering on a scriptPubKey, because all cost accounting is dealt with already. That said, I don't think this is a particularly strong point; if there are good reasons to do the trigger through an OP_RETURN, there are probably fairly easy ways of doing that too.

On Wednesday, August 19th, 2026 at 11:36 AM, waxwing/ AdamISZ <ekaggata@gmail.com> wrote:

> Smaller group *canaries* (not tripwires) are still interesting I think. Not amazing, but maybe quite valuable.

Agreed. I think formalized or not, this will effectively be how the ecosystem decides it's time to disable ECC.

> Good point about signature, I wasn't considering that, earlier. If you publish (R, s) with truly random R=kG choice you are not leaking more than what already existed with the pubkey H; that's true if HVZK holds and assuming the ROM (except it has to be "QROM" now, right).

Right.

> However! There might be a non-technical reason to avoid H directly: it's a bit like toxic waste in powers-of-tau and similar: suppose a whitehat organization is targeting a tripwire. If that dlog knowledge is exposed (in the process of creating a valid signature) it has to be destroyed "trustfully", since it'll allow spending of all kinds of coins[1]. This comment is only relevant of course if there is a CRQC which costs 2 months and $100m to run, if it's easy to find a specific dlog whenever, then nothing to talk about.
> 
> So yeah I would go with the abundance of caution, myself; don't see how it hurts.

Yeah.

I think the important choice is whether to cater to adversarially-constructed proofs or not. I believe we should not, but:

If yes: use AJ's construction of providing BIP-340 signature on point of the form rG+H with arbitrary r, and arbitrary message. This is incompatible with using UTXO trigger, and needs H (or derivation from H).

If no: no reason to specifically use H, or even support multiple targets. Just pick an "as random as possible" fixed point, are require spending a scriptPubKey with it, or publishing its DLP, or publishing a signature for it.

Cheers,

-- 
Pieter

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/Bx0LA0afwRjPIcEol98t7ztodzX7mIBeA1kGLV-rAicu4IuGBkME3A-UzBC5KJOawIciVn1CW3bCILlyVpMJU_MAgqV5OBjSFQiZrX60fb4%3D%40wuille.net.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-19  2:32  1%                             ` 'conduition' via Bitcoin Development Mailing List
@ 2026-08-19 15:18  1%                               ` waxwing/ AdamISZ
  2026-08-19 22:16  1%                               ` Pieter Wuille
  1 sibling, 0 replies; 200+ results
From: waxwing/ AdamISZ @ 2026-08-19 15:18 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 17041 bytes --]

Hi conduition,

> Given the polynomial efficiency of Shor, and the massive time/money 
investment needed to build quantum computers, we have no reason to expect 
anyone will build a QC that can break 192-bit curves but *not* 256-bit 
curves. There is actually incentive *not* to do so, especially if breaking 
a 192-bit curve will cause the Bitcoin network (the most ripe target to pay 
off QC investors) to react by locking itself down. 

Well, but this brings me right back to my first comment here (not that it 
is *my* comment, it's been said elsewhere in thread): this tripwire concept 
is not a defence against an adversary, right; if the first QC is expensive 
and difficult (likely), and if they decide to be adversarial, they won't be 
tripping any wires. But surely it follows, that they have just as much 
incentive to not trip the 256 wire as the 192 wire.

Anyway I will try to now avoid further nerd sniping (including against 
myself) talking about smaller order curves; I do agree with the points 
raised, that it's not a sufficiently practical idea (given secp256k1's most 
excellent property, its cofactor of 1, is extremely unhelpful in this 
particular case! - therefore nice idea, Pieter, with the 'algebraically 
similar curve but with subgroups', but I'm willing to bet you're right that 
that doesn't cut it, either) on more than one axis.

Smaller group *canaries* (not tripwires) are still interesting I think. Not 
amazing, but maybe quite valuable.

> Also found this related paper which proposes an incremental ladder of 
canaries using NUMS points on a sequence of curves of increasing size: 
https://arxiv.org/pdf/2508.14011

interesting find, thanks!

> If, on the other hand, we had nodes check something almost as simple, 
like for example "check every 32-byte OP_RETURN to see if it happens to be 
the dlog of the NUMS point", then any user can choose to include the proof 
in their transactions at relatively little cost. Any miners who want to 
censor the canary proof will have to also censor any such transactions, and 
so they lose out on the potential fee revenue of the entire TX by doing so.

Yes that does seem to be better than single utxo. But perhaps the 
difference isn't that significant in practice?

> I'm not sure if this incentive is meaningful when compared to the 
potential bribes that a miner could be offered by a CRQC, but still it is 
worth considering. It does have the down side that it will slow down block 
validation slightly (one EC mult per 32-byte OP_RETURN). Maybe this could 
be accounted for somehow in the sigops budget?

I agree it doesn't seem very reasonable that there's a way to counter such 
a huge incentive in *a* miner as one related to a QC break.

It also makes me think: that's not how consensus changes usually work, eh. 
Giving miners the ability to censor an update seems antithetical. It's also 
weirdly the opposite shape to what you want: it activates with the 
permission of 1 of N miners (weighted by hashrate), which means it's kind 
of guaranteed to occur once the proof exists, but could be quite slow. The 
counterargument might be: that's not going to happen! Once the proof is 
public, a miner deliberately not mining it is very transparently a bad 
actor. Not sure. Seems a bit wobbly but not crazy.

Pieter,
> Regarding using the BIP-341 H itself as canary, I don't think that's a 
problem if the ECDLP break proof is a Schnorr signature (as opposed to 
revealing the DLP itself). But it also makes sense to be as conservative as 
possible here; it may make sense to make a selection of hash functions, 
feed them all as much input as possible (the genesis block is a good idea, 
the existing generator G, maybe a block hash from a time when the 
activation parameters are decided, or even a block hash when the block goes 
live as suggested by Tadge though that adds hash-to-curve logic to 
consensus too), and then XOR (or hash) all hash results together.

Good point about signature, I wasn't considering that, earlier. If you 
publish (R, s) with truly random R=kG choice you are not leaking more than 
what already existed with the pubkey H; that's true if HVZK holds and 
assuming the ROM (except it has to be "QROM" now, right).

However! There might be a non-technical reason to avoid H directly: it's a 
bit like toxic waste in powers-of-tau and similar: suppose a whitehat 
organization is targeting a tripwire. If that dlog knowledge is exposed (in 
the process of creating a valid signature) it has to be destroyed 
"trustfully", since it'll allow spending of all kinds of coins[1]. This 
comment is only relevant of course if there is a CRQC which costs 2 months 
and $100m to run, if it's easy to find a specific dlog whenever, then 
nothing to talk about.

So yeah I would go with the abundance of caution, myself; don't see how it 
hurts.

[1] Uh not actually sure about that. There was a +rG tweak suggested in 
BIP341 for better privacy. Don't know how widely it was used (curious, in 
codebases I looked at, it wasn't). Silent Payments BIP352 explicitly carves 
out H which, I dunno if that proves anything, but it's an example of people 
tacitly assuming no tweaking happens. If the tweaking was used it would at 
least limit how much risk exists with H, though not remove it.

On Tuesday, August 18, 2026 at 8:37:02 PM UTC-6 conduition wrote:

> Oh wait, it's much simpler (not perhaps in character, but concretely): we 
> don't need to talk about some general ZKP system here, right. If we all 
> agree on a 192 bit curve, and a NUMS point on that curve, then in the 
> OP_RETURN (say), we just need to put the point's dlog and consensus nodes 
> only have to do a single scalar multiplication on that curve to verify.
>
> Exactly. Also, the canary proof need not be the NUMS discrete log itself, 
> it could also be a signature proving knowledge of the dlog without 
> revealing it outright. Dlog exposure is simpler and faster to verify; 
> Signature allows the first QC to identify itself later. (IDK if useful)
>
>
> Right, so: the QCAP thread was about a canary rather than a full tripwire
>
> Oh I misunderstood. So to be clear, a "canary" is just a social signal 
> that should push consensus to activate a soft fork, whereas a "tripwire" is 
> an unattended system that automatically triggers a change to consensus 
> rules.
>
> While it's certainly possible it's actually triggered by a cooperative 
> CRQC, that's not how I expect ECC disabling to happen (instead I expect a 
> community consensus-changing effort, effected through Miner Lockdown or 
> otherwise). The Tripwire just sets an unambiguous expectation that 
> disabling is intended by Q-day.
>
> In the absence of evidence, I expect this fork to be highly contentious or 
> delayed until hard evidence is available. 
>
> I don't think the presence of a 192-bit canary changes this expectation 
> much. 192-bit ECDLP broken (or breakable) is certainly a legitimate reason 
> for panic, but nothing prevents that information from being used at the 
> human layer without it needing to have been part of consensus rules.
>
>
> I agree but for a different reason on top. Given the polynomial efficiency 
> of Shor, and the massive time/money investment needed to build quantum 
> computers, we have no reason to expect anyone will build a QC that can 
> break 192-bit curves but *not* 256-bit curves. There is actually 
> incentive *not* to do so, especially if breaking a 192-bit curve will 
> cause the Bitcoin network (the most ripe target to pay off QC investors) to 
> react by locking itself down. 
> Think of it this way: If you have the mans to build a stable 900 
> logical-qubit quantum-computer, why not spend the extra time and money to 
> build a 1200 logical-qubit quantum computer? Is a 1.5x factor improvement 
> really so hard at this point? If you do expend the effort, then at least 
> you stand a chance to make some money (e.g. by decrypting old internet 
> traffic on behalf of the NSA).
> From the google paper:
>
> Given broad progress across multiple hardware architectures, the safe assumption 
> is that there may be little time between the breaking of 256-bit ECDLP and 
> the breaking of 1024-bit ECDLP.
>
> I think I'm coming to the conclusion that a 256-bit ST-ECDLP tripwire is 
> the way to go, because at least then the canary is unambiguously dead, and 
> it's time to stop using secp256k1, whereas 192-bit curves leave a shred of 
> doubt.
>
> This makes me wonder about using a subgroup of a very related curve: for 
> example y^2 = x^3 + 3 (mod 2^256-2^32-977) has a subgroup of order 
> ~2^187.11, which would use all the same finite field arithmetic and almost 
> the same multiplication logic (only doubling is affected). Keeping the 
> field modulus the same does mean the q-bit count is unaffected though, only 
> the gate count decreases (proportional to logarithm of group order). Like 
> other weaker-curve constructions, I don't think this is worth it, but want 
> to throw the idea out there.
>
>
> Really interesting idea there. Small correction: I believe Shor's space 
> (qubit) requirements are dominated primarily by the group order that we are 
> searching for the dlog within, not by the size of the field used for the 
> the elliptic curve group operation. I'm pretty sure the field size would 
> affect runtime complexity (gate count), but not qubit count requirements. 
> (Happy to be corrected). If I'm correct, a group order of approx 2^187 
> would need approx 842 qubits (at least) to break.
>
> Still, as previously discussed, I'm unsure if a canary which is only 
> *slightly* harder to break would be meaningful. It'd be nice if we could 
> find some problem which quantum computers of, say, 150 qubits could do, but 
> which classical computers cannot (feasibly) solve. Then we might have a 
> reasonably predictive canary which could be solved by cooperative.
>
> Also found this related paper which proposes an incremental ladder of 
> canaries using NUMS points on a sequence of curves of increasing size: 
> https://arxiv.org/pdf/2508.14011
>
> I also don't think optimizing for multi-target ECDLP adds much.
>
>
> Strongly agree.
>
> From a simplicity standpoint, I think just having a "a UTXO with 
> scriptPubKey X is spent" is ideal, because it reuses all existing block and 
> transaction validation logic, and just adds a trivial trigger.
>
>
> I would like to make a case that we should expend the extra effort and not 
> bind the canary to a specific UTXO. I will point to Antoine's game theory 
> arguments about reorgs and miner collusion with CRQCs. 
>
> If we tie the canary to a specific UTXO, or even to any UTXO with a 
> specific script, then this makes miner censorship of the canary proof very 
> easy: Just block spends of that UTXO (or of any UTXO unlocking the chosen 
> script).
>
> If, on the other hand, we had nodes check something almost as simple, like 
> for example "check every 32-byte OP_RETURN to see if it happens to be the 
> dlog of the NUMS point", then any user can choose to include the proof in 
> their transactions at relatively little cost. Any miners who want to censor 
> the canary proof will have to also censor any such transactions, and so 
> they lose out on the potential fee revenue of the entire TX by doing so.
>
> In the extreme case, if every transaction in the mempool contained the 
> canary proof as an OP_RETURN, then censoring miners would receive no fee 
> revenue at all - they would have to mine empty blocks.
>
> I'm not sure if this incentive is meaningful when compared to the 
> potential bribes that a miner could be offered by a CRQC, but still it is 
> worth considering. It does have the down side that it will slow down block 
> validation slightly (one EC mult per 32-byte OP_RETURN). Maybe this could 
> be accounted for somehow in the sigops budget?
>
> regards,
> conduition
>
>
> On Tuesday, August 18th, 2026 at 1:30 PM, Pieter Wuille 
> bitco...@wuille.net wrote:
>
> Hi all,
>
> I'm unconvinced the complexity of a 192-bit canary is worth it. Picking a 
> curve and a NUMS point on it are not hard, but very little of 
> libsecp256k1's code can be reused (even field arithmetic is optimized 
> specifically for the secp256k1 prime). A more generic implementation is 
> possible of course, but it's still a pretty big piece of engineering for 
> what is IMO very little gain.
>
> There is a pretty fundamental difference between a secp256k1 Tripwire and 
> a canary for weaker curves, in that the former isn't intended to be 
> predictive. Its purpose is setting a codified upper bound on when ECC 
> (within PQC output types) is expected to be disabled. While it's certainly 
> possible it's actually triggered by a cooperative CRQC, that's not how I 
> expect ECC disabling to happen (instead I expect a community 
> consensus-changing effort, effected through Miner Lockdown or otherwise). 
> The Tripwire just sets an unambiguous expectation that disabling is 
> intended by Q-day.
>
> I don't think the presence of a 192-bit canary changes this expectation 
> much. 192-bit ECDLP broken (or breakable) is certainly a legitimate reason 
> for panic, but nothing prevents that information from being used at the 
> human layer without it needing to have been part of consensus rules.
>
> Relatedly, something I don't know is how "similar" a canary needs to be to 
> the real secp256k1 ECDLP for people to bother building/programming/running 
> a QC for it. This is of course a question that exists for secp256k1 itself: 
> whether a *cooperative* entity with the capability of building a 
> secp256k1-ECDLP QRQC would bother doing so. But it's even more tenuous for 
> weaker problems, if they're not so much weaker that they're trivial. This 
> makes me wonder about using a subgroup of a very related curve: for example 
> y^2 = x^3 + 3 (mod 2^256-2^32-977) has a subgroup of order ~2^187.11, which 
> would use all the same finite field arithmetic and almost the same 
> multiplication logic (only doubling is affected). Keeping the field modulus 
> the same does mean the q-bit count is unaffected though, only the gate 
> count decreases (proportional to logarithm of group order). Like other 
> weaker-curve constructions, I don't think this is worth it, but want to 
> throw the idea out there.
>
> I also don't think optimizing for multi-target ECDLP adds much. My 
> understanding is that Shor's doesn't benefit from multiple targets? I'm not 
> opposed to giving freedom of finding (m,x) such that H(m) = x*G, but I 
> don't see why that would encourage a cooperative CRQC to work on breaking 
> it.
>
> Regarding using the BIP-341 H itself as canary, I don't think that's a 
> problem if the ECDLP break proof is a Schnorr signature (as opposed to 
> revealing the DLP itself). But it also makes sense to be as conservative as 
> possible here; it may make sense to make a selection of hash functions, 
> feed them all as much input as possible (the genesis block is a good idea, 
> the existing generator G, maybe a block hash from a time when the 
> activation parameters are decided, or even a block hash when the block goes 
> live as suggested by Tadge though that adds hash-to-curve logic to 
> consensus too), and then XOR (or hash) all hash results together.
>
> From a simplicity standpoint, I think just having a "a UTXO with 
> scriptPubKey X is spent" is ideal, because it reuses all existing block and 
> transaction validation logic, and just adds a trivial trigger. It's not 
> compatible with any weaker curve construction of course, or with AJ's 
> H-dependent DLP proof which could enlist non-cooperative CRQC, but I don't 
> think that's worth complicating matters for.
>
> Cheers,
>
> --
> Pieter
>
> --
>
>
> You received this message because you are subscribed to a topic in the 
> Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit 
> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to 
> bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/td8wPWxRVg0rQIdP41uibTvWuIoCvGYpvfX022TaDurf-qu1TMm1TmWogw-JTs4C7Mt-97cvJCBW66z4g-Vc2fsSoo-Qxfm8Lcnd384Uink%3D%40wuille.net
> .
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/baff534c-a392-4af7-8264-998c3390fe84n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 26270 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  @ 2026-08-19  2:32  1%                             ` 'conduition' via Bitcoin Development Mailing List
  2026-08-19 15:18  1%                               ` waxwing/ AdamISZ
  2026-08-19 22:16  1%                               ` Pieter Wuille
  0 siblings, 2 replies; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-19  2:32 UTC (permalink / raw)
  To: Pieter Wuille; +Cc: waxwing/ AdamISZ, Bitcoin Development Mailing List


[-- Attachment #1.1.1: Type: text/plain, Size: 11134 bytes --]

> Oh wait, it's much simpler (not perhaps in character, but concretely): we don't need to talk about some general ZKP system here, right. If we all agree on a 192 bit curve, and a NUMS point on that curve, then in the OP_RETURN (say), we just need to put the point's dlog and consensus nodes only have to do a single scalar multiplication on that curve to verify.

Exactly. Also, the canary proof need not be the NUMS discrete log itself, it could also be a signature proving knowledge of the dlog without revealing it outright. Dlog exposure is simpler and faster to verify; Signature allows the first QC to identify itself later. (IDK if useful)



> Right, so: the QCAP thread was about a canary rather than a full tripwire

Oh I misunderstood. So to be clear, a "canary" is just a social signal that should push consensus to activate a soft fork, whereas a "tripwire" is an unattended system that automatically triggers a change to consensus rules.


> While it's certainly possible it's actually triggered by a cooperative CRQC, that's not how I expect ECC disabling to happen (instead I expect a community consensus-changing effort, effected through Miner Lockdown or otherwise). The Tripwire just sets an unambiguous expectation that disabling is intended by Q-day.

In the absence of evidence, I expect this fork to be highly contentious or delayed until hard evidence is available.


> I don't think the presence of a 192-bit canary changes this expectation much. 192-bit ECDLP broken (or breakable) is certainly a legitimate reason for panic, but nothing prevents that information from being used at the human layer without it needing to have been part of consensus rules.

I agree but for a different reason on top. Given the polynomial efficiency of Shor, and the massive time/money investment needed to build quantum computers, we have no reason to expect anyone will build a QC that can break 192-bit curves but not 256-bit curves. There is actually incentive not to do so, especially if breaking a 192-bit curve will cause the Bitcoin network (the most ripe target to pay off QC investors) to react by locking itself down. 
Think of it this way: If you have the mans to build a stable 900 logical-qubit quantum-computer, why not spend the extra time and money to build a 1200 logical-qubit quantum computer? Is a 1.5x factor improvement really so hard at this point? If you do expend the effort, then at least you stand a chance to make some money (e.g. by decrypting old internet traffic on behalf of the NSA).
From the google paper:

> Given broad progress across multiple hardware architectures, the safe assumption is that there may be little time between the breaking of 256-bit ECDLP and the breaking of 1024-bit ECDLP.

I think I'm coming to the conclusion that a 256-bit ST-ECDLP tripwire is the way to go, because at least then the canary is unambiguously dead, and it's time to stop using secp256k1, whereas 192-bit curves leave a shred of doubt.

> This makes me wonder about using a subgroup of a very related curve: for example y^2 = x^3 + 3 (mod 2^256-2^32-977) has a subgroup of order ~2^187.11, which would use all the same finite field arithmetic and almost the same multiplication logic (only doubling is affected). Keeping the field modulus the same does mean the q-bit count is unaffected though, only the gate count decreases (proportional to logarithm of group order). Like other weaker-curve constructions, I don't think this is worth it, but want to throw the idea out there.



Really interesting idea there. Small correction: I believe Shor's space (qubit) requirements are dominated primarily by the group order that we are searching for the dlog within, not by the size of the field used for the the elliptic curve group operation. I'm pretty sure the field size would affect runtime complexity (gate count), but not qubit count requirements. (Happy to be corrected). If I'm correct, a group order of approx 2^187 would need approx 842 qubits (at least) to break.


Still, as previously discussed, I'm unsure if a canary which is only slightly harder to break would be meaningful. It'd be nice if we could find some problem which quantum computers of, say, 150 qubits could do, but which classical computers cannot (feasibly) solve. Then we might have a reasonably predictive canary which could be solved by cooperative.


Also found this related paper which proposes an incremental ladder of canaries using NUMS points on a sequence of curves of increasing size: https://arxiv.org/pdf/2508.14011


> I also don't think optimizing for multi-target ECDLP adds much.



Strongly agree.


> From a simplicity standpoint, I think just having a "a UTXO with scriptPubKey X is spent" is ideal, because it reuses all existing block and transaction validation logic, and just adds a trivial trigger.



I would like to make a case that we should expend the extra effort and not bind the canary to a specific UTXO. I will point to Antoine's game theory arguments about reorgs and miner collusion with CRQCs. 


If we tie the canary to a specific UTXO, or even to any UTXO with a specific script, then this makes miner censorship of the canary proof very easy: Just block spends of that UTXO (or of any UTXO unlocking the chosen script).


If, on the other hand, we had nodes check something almost as simple, like for example "check every 32-byte OP_RETURN to see if it happens to be the dlog of the NUMS point", then any user can choose to include the proof in their transactions at relatively little cost. Any miners who want to censor the canary proof will have to also censor any such transactions, and so they lose out on the potential fee revenue of the entire TX by doing so.


In the extreme case, if every transaction in the mempool contained the canary proof as an OP_RETURN, then censoring miners would receive no fee revenue at all - they would have to mine empty blocks.


I'm not sure if this incentive is meaningful when compared to the potential bribes that a miner could be offered by a CRQC, but still it is worth considering. It does have the down side that it will slow down block validation slightly (one EC mult per 32-byte OP_RETURN). Maybe this could be accounted for somehow in the sigops budget?


regards,
conduition


On Tuesday, August 18th, 2026 at 1:30 PM, Pieter Wuille bitcoin-dev@wuille.net wrote:

> Hi all,
> 

> I'm unconvinced the complexity of a 192-bit canary is worth it. Picking a curve and a NUMS point on it are not hard, but very little of libsecp256k1's code can be reused (even field arithmetic is optimized specifically for the secp256k1 prime). A more generic implementation is possible of course, but it's still a pretty big piece of engineering for what is IMO very little gain.
> 

> There is a pretty fundamental difference between a secp256k1 Tripwire and a canary for weaker curves, in that the former isn't intended to be predictive. Its purpose is setting a codified upper bound on when ECC (within PQC output types) is expected to be disabled. While it's certainly possible it's actually triggered by a cooperative CRQC, that's not how I expect ECC disabling to happen (instead I expect a community consensus-changing effort, effected through Miner Lockdown or otherwise). The Tripwire just sets an unambiguous expectation that disabling is intended by Q-day.
> 

> I don't think the presence of a 192-bit canary changes this expectation much. 192-bit ECDLP broken (or breakable) is certainly a legitimate reason for panic, but nothing prevents that information from being used at the human layer without it needing to have been part of consensus rules.
> 

> Relatedly, something I don't know is how "similar" a canary needs to be to the real secp256k1 ECDLP for people to bother building/programming/running a QC for it. This is of course a question that exists for secp256k1 itself: whether a cooperative entity with the capability of building a secp256k1-ECDLP QRQC would bother doing so. But it's even more tenuous for weaker problems, if they're not so much weaker that they're trivial. This makes me wonder about using a subgroup of a very related curve: for example y^2 = x^3 + 3 (mod 2^256-2^32-977) has a subgroup of order ~2^187.11, which would use all the same finite field arithmetic and almost the same multiplication logic (only doubling is affected). Keeping the field modulus the same does mean the q-bit count is unaffected though, only the gate count decreases (proportional to logarithm of group order). Like other weaker-curve constructions, I don't think this is worth it, but want to throw the idea out there.
> 

> I also don't think optimizing for multi-target ECDLP adds much. My understanding is that Shor's doesn't benefit from multiple targets? I'm not opposed to giving freedom of finding (m,x) such that H(m) = x*G, but I don't see why that would encourage a cooperative CRQC to work on breaking it.
> 

> Regarding using the BIP-341 H itself as canary, I don't think that's a problem if the ECDLP break proof is a Schnorr signature (as opposed to revealing the DLP itself). But it also makes sense to be as conservative as possible here; it may make sense to make a selection of hash functions, feed them all as much input as possible (the genesis block is a good idea, the existing generator G, maybe a block hash from a time when the activation parameters are decided, or even a block hash when the block goes live as suggested by Tadge though that adds hash-to-curve logic to consensus too), and then XOR (or hash) all hash results together.
> 

> From a simplicity standpoint, I think just having a "a UTXO with scriptPubKey X is spent" is ideal, because it reuses all existing block and transaction validation logic, and just adds a trivial trigger. It's not compatible with any weaker curve construction of course, or with AJ's H-dependent DLP proof which could enlist non-cooperative CRQC, but I don't think that's worth complicating matters for.
> 

> Cheers,
> 

> --
> Pieter
> 

> --
> You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/td8wPWxRVg0rQIdP41uibTvWuIoCvGYpvfX022TaDurf-qu1TMm1TmWogw-JTs4C7Mt-97cvJCBW66z4g-Vc2fsSoo-Qxfm8Lcnd384Uink%3D%40wuille.net.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/FhcVTVM6flM4OpPCZpaGbC3msQG9kG48uvyz6T4qdNv8iAq-clhoMmNmRWSSWs78hug3KZSsKG3Mi2lZIzo5PFY-WvbvxdA0Ssj-G2HCz2o%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 16840 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-16 19:30  1%                       ` 'conduition' via Bitcoin Development Mailing List
@ 2026-08-18 14:36  1%                         ` waxwing/ AdamISZ
    0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2026-08-18 14:36 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5125 bytes --]

(re-sending 2 messages after sending them to the wrong location!):

Right, so: the QCAP thread was about a canary rather than a full tripwire, 
and doing DKG (optionally) plus DLEQAG, rather than NUMS. You're 
saying/thinking (are you?): do NUMS on 192 bit, then, when proof is 
published, activate the consensus change. But that would mean validating 
the ZKP in consensus right? It'd presumably be simpler than literally 
implementing the 192 bit curve in consensus (doesn't sound very simple!), 
just for this one action. And it's more realistic than the idea of having a 
trusted setup to create a small dlog in secp256k1 (because trusted setup in 
consensus is not going to fly in bitcoin). But it *would* mean having a ZKP 
verifier inside our consensus. Heck, if we can do that, we can do lots of 
other nicer things :) 

So tell me if I'm wrong, but I don't think the fact that it doesn't have to 
tie to spending of a specific utxo is the thing: I think the thing about 
'tripwire' is creating a consensus rule, which means validating nodes have 
to agree. I tended, after our earlier discussion on this, to come to the 
conclusion that a 192 bit tripwire would be 'nice' but doesn't seem to be 
practical. Could have it as a canary still, ofc. But probably only 256 bit 
is going to work as a tripwire?

2nd message:

Oh wait, it's much simpler (not perhaps in character, but concretely): we 
don't need to talk about some general ZKP system here, right. If we all 
agree on a 192 bit curve, and a NUMS point on that curve, then in the 
OP_RETURN (say), we just need to put the point's dlog and consensus nodes 
only have to do a single scalar multiplication on that curve to verify.

That's so much simpler that I almost change my mind, i.e. that really is a 
simple extra consensus rule, but I wouldn't be surprised if the engineers 
still say, no, we should definitely not do that (dependencies?). After all 
there is something very ugly about one-off consensus rules like that that 
are completely unconnected with bitcoin's central design. Has there been 
any such thing before? Maybe that one about the repeated block hash? (even 
if I'm right, a bug fix like that in the existing rule set, is very 
different).

Not commenting on the gate-scaling because I'm completely clueless about 
how the scaling works / will work (and don't know if anyone knows). 
Obviously it's *plausible* that the gap between these two cases will be 
small.

Cheers, waxwing/AdamISZ

On Tuesday, August 18, 2026 at 3:17:32 AM UTC-6 conduition wrote:

I'm hesitant to say I support a 192-bit canary outright, but I like the 
idea and I think more research is needed to confirm whether it would work, 
or if such a system would be over- or under-sensitive (i.e. triggered too 
late by the first powerful quantum computer, or triggered exceptionally 
early by a classical attack). I'm especially interested in any attempts to 
estimate a rough time delta between the "secp192r is broken" and "secp256k1 
is broken" events. I suppose that's more a question for the QC experts (not 
me). I'll have a go anyway.

Based on logical qubit count estimates in the google paper 
<https://quantumai.google/static/site-assets/downloads/cryptocurrency-whitepaper.pdf> (see 
page 7), a QC needs at least 4.5 * n qubits to crack a curve of n bits 
(with a practical Toffoli gate count). So secp192r1 might be broken by more 
than 192 * 4.5 = 900 logical qubits. Breaking secp256k1 requires at least 
1200.

So how difficult would it be for a QC to scale from 900 to 1200 qubits? If 
we assume QC scaling will follow moore's law (if it ever scales at all), 
then that's worrisome: less than half a doubling of margin. The first QC 
that breaks secp192r1 might very well also be able to break secp256k1.

Also: I read the QCAP thread 
<https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498>, 
and my initial impression is that using DLEQAG proofs to share the secret 
among a trusted group is overkill: If breaking a 192-bit curve such as 
secp192r1 suffices to prove "QCs are coming" and so activate a soft fork, 
then why go through the effort to map that statement to secp256k1? We can 
just use a secp192r1 canary proof on its own as a self-contained 
cryptographic statement published on-chain. Then the proof can use a NUMS 
point generated in some honest fashion, same as for secp256k1. Nodes could 
activate the canary as soon as they see the canary proof published anywhere 
on-chain (e.g. OP_RETURN). As discussed before in this thread, there's no 
need to tie the canary specifically to a Bitcoin UTXO being spent.

regards,
conduition

<snip> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f6565311-f62e-4210-8c15-93830c3f71cbn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 5801 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-15 18:06  0%                     ` waxwing/ AdamISZ
@ 2026-08-16 19:30  1%                       ` 'conduition' via Bitcoin Development Mailing List
  2026-08-18 14:36  1%                         ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-16 19:30 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 28952 bytes --]

I'm hesitant to say I support a 192-bit canary outright, but I like the 
idea and I think more research is needed to confirm whether it would work, 
or if such a system would be over- or under-sensitive (i.e. triggered too 
late by the first powerful quantum computer, or triggered exceptionally 
early by a classical attack). I'm especially interested in any attempts to 
estimate a rough time delta between the "secp192r is broken" and "secp256k1 
is broken" events. I suppose that's more a question for the QC experts (not 
me). I'll have a go anyway.

Based on logical qubit count estimates in the google paper 
<https://quantumai.google/static/site-assets/downloads/cryptocurrency-whitepaper.pdf> (see 
page 7), a QC needs at least 4.5 * n qubits to crack a curve of n bits 
(with a practical Toffoli gate count). So secp192r1 might be broken by more 
than 192 * 4.5 = 900 logical qubits. Breaking secp256k1 requires at least 
1200.

So how difficult would it be for a QC to scale from 900 to 1200 qubits? If 
we assume QC scaling will follow moore's law (if it ever scales at all), 
then that's worrisome: less than half a doubling of margin. The first QC 
that breaks secp192r1 might very well also be able to break secp256k1.

Also: I read the QCAP thread 
<https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498>, 
and my initial impression is that using DLEQAG proofs to share the secret 
among a trusted group is overkill: If breaking a 192-bit curve such as 
secp192r1 suffices to prove "QCs are coming" and so activate a soft fork, 
then why go through the effort to map that statement to secp256k1? We can 
just use a secp192r1 canary proof on its own as a self-contained 
cryptographic statement published on-chain. Then the proof can use a NUMS 
point generated in some honest fashion, same as for secp256k1. Nodes could 
activate the canary as soon as they see the canary proof published anywhere 
on-chain (e.g. OP_RETURN). As discussed before in this thread, there's no 
need to tie the canary specifically to a Bitcoin UTXO being spent.

regards,
conduition

On Saturday, August 15, 2026 at 1:12:44 PM UTC-5 waxwing/ AdamISZ wrote:

> As if everything wasn't confusing enough, I also made one very notable 
> error: What I was saying here:
>
> > This is relevant because the hypothetical evil curve-generator who is 
> trying to poison the future H=SHA2(G) has an easier time in doing so, than 
> a future canary-solver who obviously cannot try different values of G :)
>
> is, I'm pretty sure, not correct: the canary-solver only needs 2^128 work 
> anyway (all the normal classical collision finding); it's not like he has 
> to use pure brute force.
>
> > If we have any doubt about that, we could tweak the hash function with 
> some data that is newer than G but still unbiased, e.g. the hash of the 
> genesis block, or the hash of the first block in which the canary goes live 
> (idea credit: Tadge Dryja 
> <https://youtu.be/PmW90HX89P8?si=NhRJSaxKILVAJBkr&t=841>).
>
> Seems plausible.
>
> I guess two tracks of conversation here; I'm still genuinely curious what 
> people think about 192 bit and whether we can do it practically, because, 
> depending on how it plays out, it might buy very useful time. The delving 
> thread was focused on distributed keygen and ZKP for the canary, but this 
> is obviously way less trustless than NUMS, so perhaps that's the end of 
> that, or perhaps there's something else clever I'm not aware of.
>
> On Saturday, August 15, 2026 at 10:54:11 AM UTC-6 conduition wrote:
>
>> This is relevant because the hypothetical evil curve-generator who is 
>> trying to poison the future H=SHA2(G) has an easier time in doing so, than 
>> a future canary-solver who obviously cannot try different values of G :)
>>
>>
>> Ah sorry, I thought you were talking about canary solvers, didn't realize 
>> you were talking about curve designers. Agreed then, but still seems 
>> unlikely that G was chosen this way: 
>> https://bitcoin.stackexchange.com/questions/58784/how-were-the-secp256k1-base-point-coordinates-decided
>>
>> If we have any doubt about that, we could tweak the hash function with 
>> some data that is newer than G but still unbiased, e.g. the hash of the 
>> genesis block, or the hash of the first block in which the canary goes live 
>> (idea credit: Tadge Dryja 
>> <https://youtu.be/PmW90HX89P8?si=NhRJSaxKILVAJBkr&t=841>).
>>
>> interesting point is that Shor can target any specific dlog problem, 
>> right. So I do think the ST is the correct version of the problem?
>>
>>
>> Yes, I believe so. I don't know of any way to batch Shor's algorithm in a 
>> multi-target attack that is any more efficient than a trivial one-by-one 
>> attack, so using MT-ECDLP seems like it only serves to makes classical 
>> attacks (or Grover's search) easier.
>>
>> regards,
>> conduition
>>
>> On Saturday, August 15th, 2026 at 10:14 AM, waxwing/ AdamISZ <
>> ekag...@gmail.com> wrote:
>>
>> > A 192-bit curve i think should be reasonable as a canary, but consider 
>> this: If someone already has a QC that breaks 192-bit ECC, how long until 
>> they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
>> knowing. If the delay is too long, users may see the canary as a 
>> false-positive, and migrate back to vulnerable addresses, and they might 
>> even be right. 192-bit canaries are vulnerable to classical attack with 
>> work approximately 2^96. We should bear in mind the possibility that such a 
>> canary could be activated possibly very early, well before Q-day, possibly 
>> even in the absence of any quantum computers.
>>
>> Agreed that is unlikely a big delta, in the nature of these things (QCs), 
>> between 192 and 256. Including that it's obvious that going very much below 
>> 192 means classical attack and therefore bad idea. Which is why I said 192 
>> and not sub 160. What's not obvious is that 192 is worse than 256 here. It 
>> may only give us a small amount of extra time, but it won't give us 
>> negative extra time. So the tradeoff is, presumably, whether the additional 
>> complexity (which is a bit tricky from what I recall [1], but there will 
>> definitely be experts out there who can clean it up) is worth it.
>>
>> The idea of 'people will think it a false positive', disagree, I think 
>> the whole tripwire idea is likely a *bit* vulnerable to genpop 
>> misunderstanding as I said in my previous post, but this particular thing I 
>> don't see it: a 192 bit being broken is *very* likely to cause an 
>> appropriate level of panic.
>>
>> > Anyone can find G = a * B​. Just generate a key and invert your secret 
>> key.
>>
>> > P = a * G​
>> > G = a**-1 * P
>>
>> > The hard part is then finding some b such that b*G = SHA256(G).
>>
>> You slightly missed my point here, I think? The idea is that if you set 
>> up two sides that are both sample-able, you can birthday. Like, you keep 
>> sampling a on one side and b on the other. Build tables of both sides. Then 
>> all you have to do is check whether SHA2 of the LHS ever matches the RHS. 
>> This gives you a square root style speedup a la birthday attack. Contrast 
>> with if you just fix G, then keep searching for matches: no square root 
>> speedup. This is relevant because the hypothetical evil curve-generator who 
>> is trying to poison the future H=SHA2(G) has an easier time in doing so, 
>> than a future canary-solver who obviously cannot try different values of G 
>> :)
>>
>> About your single-target vs multi-target distinction: interesting point 
>> is that Shor can target any specific dlog problem, right. So I do think the 
>> ST is the correct version of the problem? But actually I am quite unsure 
>> and unclear about those ST, MT, LMT distinctions you're making; 
>> specifically I mean, I am very unsure about how they differ in costs.
>>
>> As for characterizing the problem, I think it's fair to say: if you 
>> assumed SHA2 was a proper random oracle then we have with SHA2(enc(G)), 
>> something that's very tightly equivalent to ECDLP, which is what we want. 
>> If we want to pay attention to the fact that SHA2 is an actual hash 
>> function and not an RO, then I think there's some statement like "assuming 
>> SHA2 has no structure "matching" secp256k1, then it's tightly equivalent to 
>> ECDLP on secp256k1" which is obviously horrendously vague, but would not be 
>> very easy to write down properly.
>>
>> Another observation, probably it already exists up-thread: we obviously 
>> don't want to *literally* use BIP341's H on a 256 bit tripwire, because 
>> then a Shor-break directly steals a bunch of coins, so what should we use? 
>> Maybe SHA2(SHA2(enc(G)) ?
>>
>>
>> [1] 
>> https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498/9
>> On Friday, August 14, 2026 at 12:34:54 PM UTC-6 conduition wrote:
>>
>>> An obvious question to raise: would we consider tripwiring a 192 bit 
>>> group break of a similar type (NUMS)? I find that ... plausible?
>>>
>>>
>>> A 192-bit curve i think should be reasonable as a canary, but consider 
>>> this: If someone already has a QC that breaks 192-bit ECC, how long until 
>>> they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
>>> knowing. If the delay is too long, users may see the canary as a 
>>> false-positive, and migrate back to vulnerable addresses, and they might 
>>> even be right. 192-bit canaries are vulnerable to classical attack with 
>>> work approximately 2^96. We should bear in mind the possibility that such a 
>>> canary could be activated possibly very early, well before Q-day, possibly 
>>> even in the absence of any quantum computers.
>>>
>>> Ideally we want a short gap between "192-bit is broken" and "256-bit is 
>>> broken", but not so short as to make the 192-bit canary effectively 
>>> fungible with a 256-bit canary (because then it's less likely to be 
>>> activated before theft occurs).
>>>
>>> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based 
>>> on SHA2 preimage resistance, but: isn't the real point that we're relying 
>>> on SHA-2 not being a naughty function so that you couldn't find G = a * B 
>>> and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC 
>>> of course, as was likely back then!). I have no idea what precise name you 
>>> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
>>> given when SHA2 and secp256k1 were standardized :) And given the encoding 
>>> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
>>> using uncompressed encoding?) were able to be counted on the fingers of the 
>>> hand which the sleeve does not cover :)
>>>
>>>
>>> Anyone can find G = a * B​. Just generate a key and invert your secret 
>>> key.
>>>
>>> P = a * G​
>>> G = a**-1 * P
>>>
>>> The hard part is then finding some b such that b*G = SHA256(G).
>>>
>>> ---------
>>>
>>> If we reflect on the requirement that G​ is fixed, we see SHA256(G)​ is 
>>> also fixed as a pseudorandom challenge point. The reason for using SHA256 
>>> instead of, say, picking an arbitary point by committee or using digits of 
>>> pi or some other trickery, is that hash outputs are supposed to be random 
>>> and so SHA256(G)​ is (assumably) a random ECDLP challenge. This matches 
>>> the classical definition of ECDLP more tightly: Given an arbitrary point 
>>> P​, find p​ such that P = p * G​. The assumption is that if an attacker 
>>> can factor an honestly-sampled challenge point, they can factor any point. 
>>> SHA256 is just a stand-in for the "honestly-sampled" part.
>>>
>>> However, the following two tasks are actually very different:
>>>
>>>
>>>    1. Given G, find scalar a​ such that a*G = lift_x(SHA256(G))​.
>>>    2. Given G, find scalar a​ and message m​ such that a*G = 
>>>    lift_x(SHA256(m))​.
>>>
>>>
>>> In the case of task 1, if we assume SHA256 output is random, then this 
>>> is more tightly equivalent to ECDLP, because the point we're trying to 
>>> factor is a fixed target, as is the one sampled honestly by the ECDLP 
>>> security game.
>>>
>>> In the case of task 2, the attacker can sample arbitrary messages to 
>>> create multiple *target points*, and the attacker wins if they succeed 
>>> in factoring any of them. The attacker can attack all those target points 
>>> concurrently if they want, and they get a speedup from doing so.
>>>
>>> So I believe it is worth disambiguating canaries between the two cases, 
>>> because they are different security notions. The first (1) I would call *single-target 
>>> ECDLP *(ST-ECDLP), and the second (2) I would call *multi-target ECDLP *
>>> (MT-ECDLP).
>>>
>>> It's pretty clear that MT-ECDLP is easier to break, because attackers 
>>> can make progress against more than one target concurrently, and breaking 
>>> any one is sufficient to win the security game.
>>>
>>> For example, say I sample 2 different messages m1​ and m2​, and compute 
>>> ECDLP target points T1 = lift_x(SHA256(m1))​ and T2 = lift_x(SHA256(m2))​. 
>>> Then if I sample a random scalar r​ and compute R = r*G​, I have two 
>>> potential chances of success: R == T1​ OR R == T2​. I can scale up this 
>>> advantage by generating more targets, T3​, T4​, ... and so on.
>>>
>>> MT-ECDLP also admits a more efficient basic unit of computation in brute 
>>> force attacks (including Grover) by using hashes instead of EC point 
>>> multiplications. If I instead start by picking scalar t​ and fix the 
>>> target point T = t*G​, then I can run a brute-force preimage search on 
>>> SHA256 until I find m​ such that SHA256(m) == x(T)​. This can also be 
>>> scaled up using a multi-target attack [1].
>>>
>>> With ST-ECDLP, we have only a single fixed message m = G​, and so the 
>>> attacker can't use those multi-target cheat codes. They can parallelize, 
>>> use pollard-rho or Shor or other algorithms, but they have only a single 
>>> target point that they must break to win the game.
>>>
>>> The method Pieter suggested using for the canary construction is 
>>> equivalent to *single-target* ECDLP.
>>>
>>> I've heard others (e.g. Tadge in this thread 
>>> <https://groups.google.com/g/bitcoindev/c/LpWOcXMcvk8/m/DjaiWnViAQAJ>) 
>>> previously suggest using a script like OP_SHA256 OP_CHECKSIG​ as a 
>>> canary, where any spend of such a script would trigger the canary. This 
>>> would be *multi-target* ECDLP.
>>>
>>> I'm not sure which is better. 
>>>
>>>
>>>    - ST-ECDLP is less likely to be triggered early or mistakenly, and 
>>>    is more tightly equivalent to ECDLP. 
>>>    
>>>
>>>    - MT-ECDLP is more reflective of how real-world attackers behave on 
>>>    Bitcoin (e.g. with thousands-to-millions of public keys available to attack 
>>>    in parallel, and breaking even one is considered unacceptable).
>>>
>>>
>>> I'm slightly leanings towards a construction like Pieter's, featuring 
>>> ST-ECDLP, just because I'm not sure what other tricks could be used to 
>>> potentially trigger MT-ECDLP classically or quantumly.
>>>
>>> We could also engineer a compromise between the two, where we limit the 
>>> number of targets. For example, define the game like this:
>>>
>>> Given G​, find scalar a​​ and 32-bit integer i​​ such that a*G = 
>>> lift_x(SHA256(G || i))​​.
>>>
>>> Then the adversary can only attack against at most 2^32 unique target 
>>> points, and those targets are fixed forever, for any adversary. This is an 
>>> easier problem than ST-ECDLP, but harder than MT-ECDLP. Maybe call it *limited 
>>> multi-target ECDLP (LMT-ECDLP)*?
>>>
>>>
>>> regards,
>>> conduition
>>>
>>>
>>> [1]: First, generate a bunch of target points. Sample scalar t​ and compute 
>>> T0 = t * G​, T1 = T0 + T0, and T2 = T1 + T1, and T3 = T2 + T2​, etc. 
>>> Why double each point? point doubling is cheaper than addition or 
>>> multiplication, and still covers the whole curve. Then we run a 
>>> multi-target SHA256 preimage search over all targets [x(T0), x(T1), x(T2), 
>>> x(T3), ...]​. If we have n​ targets and curve order N​, then each message 
>>> hash has an n/N​​ chance of success. If we find a valid message m​, 
>>> such that SHA256(m) == x(R_i)​ for some target index i​, then we have 
>>> found T_i = t * 2**i * G = lift_x(SHA256(m))​.
>>>
>>>
>>>
>>>
>>>
>>> On Thursday, August 13th, 2026 at 2:02 AM, waxwing/ AdamISZ <
>>> ekag...@gmail.com> wrote:
>>>
>>> This tripwire idea is interesting. Basically "canary in consensus".
>>>
>>> I agree it's valuable. In the scenario of adversarial actor(s) gaining 
>>> access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing 
>>> to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm 
>>> slightly worried that the general userbase will not notice that point, 
>>> instead thinking it's a solid defense when it ... depends.
>>>
>>> In the scenario of at least some whitehats, we get wires tripped, or 
>>> canaries singing. Having it in consensus is nice. The blockchain then does 
>>> its job of being an unambiguous signal and we can have all the arguments 
>>> well ahead of time. [1]
>>>
>>> On the other hand, we traditionally design such systems adversarially, 
>>> right, so you could argue that an overfocus on this might be suboptimal - 
>>> it might be better to do other things.
>>>
>>> (Similar comment applies to the 'smaller group canary' - definitely 
>>> nothing wrong with it, but it is not in itself a defence unless we strongly 
>>> believe whitehats, and *active* whitehats at that, are keeping up). An 
>>> obvious question to raise: would we consider tripwiring a 192 bit group 
>>> break of a similar type (NUMS)? I find that ... plausible?
>>>
>>> > The BIP341 NUMS point (which I suggest using in this context) is the 
>>> point whose X coordinate is the SHA256 hash of the generator point G. This 
>>> guarantees that the NUMS point cannot predate G (if it did, it would be 
>>> possible in theory that secp256k1's designers actually chose G in function 
>>> of what we call that NUMS point, giving it a DLP known to them).
>>>
>>> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based 
>>> on SHA2 preimage resistance, but: isn't the real point that we're relying 
>>> on SHA-2 not being a naughty function so that you couldn't find G = a * B 
>>> and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC 
>>> of course, as was likely back then!). I have no idea what precise name you 
>>> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
>>> given when SHA2 and secp256k1 were standardized :) And given the encoding 
>>> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
>>> using uncompressed encoding?) were able to be counted on the fingers of the 
>>> hand which the sleeve does not cover :)
>>>
>>> [1] I take Antoine's point that making it consensus means the miners are 
>>> involved and there is a non-trivial collusion risk if the stakes are high, 
>>> but I can't see how this scenario is *worse* than no tripwire?
>>>
>>> On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:
>>>
>>>> Hi Pieter,
>>>>
>>>> Thanks for the observations.
>>>>
>>>> When I was saying there is a problem with the game theory,
>>>> it's that strikingly, any activation of the tripwire logic
>>>> would rely on a "flag" transaction being mined in the chain
>>>> for the network nodes starting to enforce at the block N or
>>>> N+1 or whatever the EC disabling threshold.
>>>>
>>>> Any "flag" transaction can be itself re-orged out of the chain
>>>> to purely disable the effects of the EC disabling threshold,
>>>> therefore make it null and void as an effect. One might see
>>>> it as a competing race between a group of "sunsetting" users
>>>> and a (majority) coalition of miners in coordination with a
>>>> CRQC adversary, where the latter have an interest and the
>>>> hashrate capabilities to do a tx-withold [0].
>>>>
>>>> In pure terms of satoshi fee denominated calculus, empirically
>>>> global miners have won an average of $20 B yearly. If we only
>>>> consider that P2PK are going to be frozen by the tripwire effect,
>>>> as for most of them it might be assumed they will never move to
>>>> a safer format, we talk already about 1.7 M of coins or as of
>>>> today valuation $107 B (the information is on the chain and can
>>>> be verified).
>>>>
>>>> That's $107B can "burn" in revenue or income that a CRQC-enabled
>>>> miners coalition to constantly reorg-out the "flag" tx out of the
>>>> chain. In other terms, something like 5 years of income, and I
>>>> kindly do not count all the loss coins that are likely to amount
>>>> to a far bigger "tripwire" neutralization budget.
>>>>
>>>> In the name of what a majority of miners will gracefully let on
>>>> the table an opportunity of massive income ?
>>>>
>>>> Leveraging Shor the exploitation might be even done anonymously
>>>> as the mining process is done. Not even certainty, by who the
>>>> EC-protected coins could be covertly exfiltrated.
>>>>
>>>> That's the most striking problem when you think about the math
>>>> with any "tripwire" approach, or even an "hourglass" one relying
>>>> on a "flag" transaction [1]. I'm ruling out "checkpoints" and
>>>> any other trust-the-dev approach, as that's even worst [2].
>>>>
>>>> As you're introducing post is resounding, what the miners
>>>> are saying now, there are no guarantees on how they would use
>>>> their hashrate down the road, potentially 10 or 20 years from now.
>>>>
>>>> Beyond, and to answer back your point, I still think you can
>>>> manage an escape hatch of the "tripwire" effect, it's all depends
>>>> how the script tripwire logic is implemented, but if you have
>>>> two OP_SUCCESS of different kinds before your EC CHECKSIG, you
>>>> can always have a "soft-fork" after the "tripwire" to return 
>>>> true on the stack, with an EC or hashlock as a success (I agree
>>>> using undefined op_success in a script is not safe at all) [3].
>>>>
>>>> Best,
>>>> Antoine
>>>> OTS hash: 
>>>> 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
>>>>
>>>> [0] See naumenkog's 
>>>> https://www.bitmex.com/blog/txwithhold-smart-contracts
>>>> [1] This is sad, as the "hourglass" depending how the parameters are 
>>>> chosen
>>>> was a more acceptable trade-off than pure sunsetting.
>>>> [2] Given the amounts at stake to sunset, as a group of developers you
>>>> would just paint yourself a target, there are more even funds at stake
>>>> that Satoshi herself / himself is assumed to have.
>>>> [3] There is no security proof in BIP341 on the unforgeability of the
>>>> NUMS point, if it binds in the ROM or whatever.
>>>>
>>>> Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a 
>>>> écrit :
>>>>
>>>>>
>>>>>
>>>>> On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
>>>>>
>>>>> [...]
>>>>>
>>>>> > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a 
>>>>> > specific marker). This is smaller than a full transaction input + 
>>>>> > signature.
>>>>> >
>>>>> > * Similarly, but publishing in the coinbase, and requiring relay 
>>>>> using 
>>>>> > a separate message. Less places a node needs to check, but I'm 
>>>>> > concerned about the difficulty of testing infrastructure that relay 
>>>>> of 
>>>>> > such a message works
>>>>>
>>>>> [...]
>>>>>
>>>>> >
>>>>> > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns 
>>>>> > <a...@erisian.com.au> wrote:
>>>>> >
>>>>> >> A slight variant of this approach would be to have a 128 byte value 
>>>>> "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a 
>>>>> BIP340 signature of m by P. That would allow the victim of post-quantum 
>>>>> theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in 
>>>>> addition to someone who has direct access to a CRQC.
>>>>> >
>>>>> > Indeed, I had considered something similar, but see above for why 
>>>>> I'm 
>>>>> > not convinced supporting non-cooperative CRQCs is that useful.
>>>>> >
>>>>> > Also, in my view the tripwire isn't really a security feature on 
>>>>> itself 
>>>>> > (it's not expected to trigger...), but more something that sets 
>>>>> > expectations around the output type for prospective users.
>>>>> >
>>>>> > In that sense, the question is really whether supporting 
>>>>> > non-cooperative CRQCs helps set that expectation more than only 
>>>>> > cooperative ones, which are definitely easier to support.
>>>>> >
>>>>> >> I think it could make sense to have the tripwire be included in the 
>>>>> block via the coinbase witness commitment output, rather than having it be 
>>>>> locked to a transaction, so you only having to check the coinbase for the 
>>>>> magic rather than every transaction. That would require a separate P2P 
>>>>> message to relay the necessary ECDL-break proof to miners, and would 
>>>>> probably need stratumv2 or a getblocktemplate update in order for the node 
>>>>> to be able to tell pools to actually include that info in the coinbase.
>>>>> >
>>>>> > I worry this is untestable, really. You'd need things like 
>>>>> > fake-tripwires to be supported through the same message which don't 
>>>>> > require an ECDLP break, and still propagate. And then that needs DoS 
>>>>> > protection measures, 
>>>>>
>>>>> I whipped something up last weekend:
>>>>> https://github.com/Sjors/bitcoin/pull/121
>>>>>
>>>>> It seems straightforward, but maybe I missed something:
>>>>> - for test code we use a fake NUMS point, so we can generate "proof" 
>>>>> without a quantum computer
>>>>> - a p2p message floods the proof
>>>>> - nodes ignore the message if they already have *any* valid proof
>>>>> - verifying p2p proof candidates might need some rate limiting, but 
>>>>> it's as cheap as verifying a transaction signature
>>>>> - mining code includes the proof in a coinbase op_return, until the 
>>>>> freeze activates
>>>>> - with stratum v2 (and ipc mining clients in general this works out of 
>>>>> the box, a small change is needed for getblocktemplate clients)
>>>>> - since the proof is not in the header, we can't use the normal bip9 
>>>>> style header scan to see if the rule activated. Instead the prototype 
>>>>> stores it in a file along with a merkle inclusion proof, which is read when 
>>>>> the node restarts.
>>>>>
>>>>> With this mechanism it doesn't really need to be in the coinbase 
>>>>> transaction, but that does seem more convenient and miners can censor it 
>>>>> anyway.
>>>>>
>>>>> - Sjors
>>>>>
>>>>> -- 
>>>>> You received this message because you are subscribed to a topic in the 
>>>>> Google Groups "Bitcoin Development Mailing List" group.
>>>>> To unsubscribe from this topic, visit 
>>>>> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
>>>>> To unsubscribe from this group and all its topics, send an email to 
>>>>> bitcoindev+...@googlegroups.com.
>>>>> To view this discussion visit 
>>>>> https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com
>>>>> .
>>>>>
>>>> -- 
>>>
>>> You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com.
>>> To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com
>>> .
>>>
>>>
>>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/fd947d7c-86fd-407c-98aa-0a63b8be28fan%40googlegroups.com
>> .
>>
>>
>>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/22f8b95d-403c-4a3e-ad64-221faf2ea851n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 42284 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-15 16:52  0%                   ` 'conduition' via Bitcoin Development Mailing List
@ 2026-08-15 18:06  0%                     ` waxwing/ AdamISZ
  2026-08-16 19:30  1%                       ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2026-08-15 18:06 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 26191 bytes --]

As if everything wasn't confusing enough, I also made one very notable 
error: What I was saying here:

> This is relevant because the hypothetical evil curve-generator who is 
trying to poison the future H=SHA2(G) has an easier time in doing so, than 
a future canary-solver who obviously cannot try different values of G :)

is, I'm pretty sure, not correct: the canary-solver only needs 2^128 work 
anyway (all the normal classical collision finding); it's not like he has 
to use pure brute force.

> If we have any doubt about that, we could tweak the hash function with 
some data that is newer than G but still unbiased, e.g. the hash of the 
genesis block, or the hash of the first block in which the canary goes live 
(idea credit: Tadge Dryja 
<https://youtu.be/PmW90HX89P8?si=NhRJSaxKILVAJBkr&t=841>).

Seems plausible.

I guess two tracks of conversation here; I'm still genuinely curious what 
people think about 192 bit and whether we can do it practically, because, 
depending on how it plays out, it might buy very useful time. The delving 
thread was focused on distributed keygen and ZKP for the canary, but this 
is obviously way less trustless than NUMS, so perhaps that's the end of 
that, or perhaps there's something else clever I'm not aware of.

On Saturday, August 15, 2026 at 10:54:11 AM UTC-6 conduition wrote:

> This is relevant because the hypothetical evil curve-generator who is 
> trying to poison the future H=SHA2(G) has an easier time in doing so, than 
> a future canary-solver who obviously cannot try different values of G :)
>
>
> Ah sorry, I thought you were talking about canary solvers, didn't realize 
> you were talking about curve designers. Agreed then, but still seems 
> unlikely that G was chosen this way: 
> https://bitcoin.stackexchange.com/questions/58784/how-were-the-secp256k1-base-point-coordinates-decided
>
> If we have any doubt about that, we could tweak the hash function with 
> some data that is newer than G but still unbiased, e.g. the hash of the 
> genesis block, or the hash of the first block in which the canary goes live 
> (idea credit: Tadge Dryja 
> <https://youtu.be/PmW90HX89P8?si=NhRJSaxKILVAJBkr&t=841>).
>
> interesting point is that Shor can target any specific dlog problem, 
> right. So I do think the ST is the correct version of the problem?
>
>
> Yes, I believe so. I don't know of any way to batch Shor's algorithm in a 
> multi-target attack that is any more efficient than a trivial one-by-one 
> attack, so using MT-ECDLP seems like it only serves to makes classical 
> attacks (or Grover's search) easier.
>
> regards,
> conduition
>
> On Saturday, August 15th, 2026 at 10:14 AM, waxwing/ AdamISZ <
> ekag...@gmail.com> wrote:
>
> > A 192-bit curve i think should be reasonable as a canary, but consider 
> this: If someone already has a QC that breaks 192-bit ECC, how long until 
> they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
> knowing. If the delay is too long, users may see the canary as a 
> false-positive, and migrate back to vulnerable addresses, and they might 
> even be right. 192-bit canaries are vulnerable to classical attack with 
> work approximately 2^96. We should bear in mind the possibility that such a 
> canary could be activated possibly very early, well before Q-day, possibly 
> even in the absence of any quantum computers.
>
> Agreed that is unlikely a big delta, in the nature of these things (QCs), 
> between 192 and 256. Including that it's obvious that going very much below 
> 192 means classical attack and therefore bad idea. Which is why I said 192 
> and not sub 160. What's not obvious is that 192 is worse than 256 here. It 
> may only give us a small amount of extra time, but it won't give us 
> negative extra time. So the tradeoff is, presumably, whether the additional 
> complexity (which is a bit tricky from what I recall [1], but there will 
> definitely be experts out there who can clean it up) is worth it.
>
> The idea of 'people will think it a false positive', disagree, I think the 
> whole tripwire idea is likely a *bit* vulnerable to genpop misunderstanding 
> as I said in my previous post, but this particular thing I don't see it: a 
> 192 bit being broken is *very* likely to cause an appropriate level of 
> panic.
>
> > Anyone can find G = a * B​. Just generate a key and invert your secret 
> key.
>
> > P = a * G​
> > G = a**-1 * P
>
> > The hard part is then finding some b such that b*G = SHA256(G).
>
> You slightly missed my point here, I think? The idea is that if you set up 
> two sides that are both sample-able, you can birthday. Like, you keep 
> sampling a on one side and b on the other. Build tables of both sides. Then 
> all you have to do is check whether SHA2 of the LHS ever matches the RHS. 
> This gives you a square root style speedup a la birthday attack. Contrast 
> with if you just fix G, then keep searching for matches: no square root 
> speedup. This is relevant because the hypothetical evil curve-generator who 
> is trying to poison the future H=SHA2(G) has an easier time in doing so, 
> than a future canary-solver who obviously cannot try different values of G 
> :)
>
> About your single-target vs multi-target distinction: interesting point is 
> that Shor can target any specific dlog problem, right. So I do think the ST 
> is the correct version of the problem? But actually I am quite unsure and 
> unclear about those ST, MT, LMT distinctions you're making; specifically I 
> mean, I am very unsure about how they differ in costs.
>
> As for characterizing the problem, I think it's fair to say: if you 
> assumed SHA2 was a proper random oracle then we have with SHA2(enc(G)), 
> something that's very tightly equivalent to ECDLP, which is what we want. 
> If we want to pay attention to the fact that SHA2 is an actual hash 
> function and not an RO, then I think there's some statement like "assuming 
> SHA2 has no structure "matching" secp256k1, then it's tightly equivalent to 
> ECDLP on secp256k1" which is obviously horrendously vague, but would not be 
> very easy to write down properly.
>
> Another observation, probably it already exists up-thread: we obviously 
> don't want to *literally* use BIP341's H on a 256 bit tripwire, because 
> then a Shor-break directly steals a bunch of coins, so what should we use? 
> Maybe SHA2(SHA2(enc(G)) ?
>
>
> [1] 
> https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498/9
> On Friday, August 14, 2026 at 12:34:54 PM UTC-6 conduition wrote:
>
>> An obvious question to raise: would we consider tripwiring a 192 bit 
>> group break of a similar type (NUMS)? I find that ... plausible?
>>
>>
>> A 192-bit curve i think should be reasonable as a canary, but consider 
>> this: If someone already has a QC that breaks 192-bit ECC, how long until 
>> they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
>> knowing. If the delay is too long, users may see the canary as a 
>> false-positive, and migrate back to vulnerable addresses, and they might 
>> even be right. 192-bit canaries are vulnerable to classical attack with 
>> work approximately 2^96. We should bear in mind the possibility that such a 
>> canary could be activated possibly very early, well before Q-day, possibly 
>> even in the absence of any quantum computers.
>>
>> Ideally we want a short gap between "192-bit is broken" and "256-bit is 
>> broken", but not so short as to make the 192-bit canary effectively 
>> fungible with a 256-bit canary (because then it's less likely to be 
>> activated before theft occurs).
>>
>> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based 
>> on SHA2 preimage resistance, but: isn't the real point that we're relying 
>> on SHA-2 not being a naughty function so that you couldn't find G = a * B 
>> and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC 
>> of course, as was likely back then!). I have no idea what precise name you 
>> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
>> given when SHA2 and secp256k1 were standardized :) And given the encoding 
>> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
>> using uncompressed encoding?) were able to be counted on the fingers of the 
>> hand which the sleeve does not cover :)
>>
>>
>> Anyone can find G = a * B​. Just generate a key and invert your secret 
>> key.
>>
>> P = a * G​
>> G = a**-1 * P
>>
>> The hard part is then finding some b such that b*G = SHA256(G).
>>
>> ---------
>>
>> If we reflect on the requirement that G​ is fixed, we see SHA256(G)​ is 
>> also fixed as a pseudorandom challenge point. The reason for using SHA256 
>> instead of, say, picking an arbitary point by committee or using digits of 
>> pi or some other trickery, is that hash outputs are supposed to be random 
>> and so SHA256(G)​ is (assumably) a random ECDLP challenge. This matches 
>> the classical definition of ECDLP more tightly: Given an arbitrary point 
>> P​, find p​ such that P = p * G​. The assumption is that if an attacker 
>> can factor an honestly-sampled challenge point, they can factor any point. 
>> SHA256 is just a stand-in for the "honestly-sampled" part.
>>
>> However, the following two tasks are actually very different:
>>
>>
>>    1. Given G, find scalar a​ such that a*G = lift_x(SHA256(G))​.
>>    2. Given G, find scalar a​ and message m​ such that a*G = 
>>    lift_x(SHA256(m))​.
>>
>>
>> In the case of task 1, if we assume SHA256 output is random, then this is 
>> more tightly equivalent to ECDLP, because the point we're trying to factor 
>> is a fixed target, as is the one sampled honestly by the ECDLP security 
>> game.
>>
>> In the case of task 2, the attacker can sample arbitrary messages to 
>> create multiple *target points*, and the attacker wins if they succeed 
>> in factoring any of them. The attacker can attack all those target points 
>> concurrently if they want, and they get a speedup from doing so.
>>
>> So I believe it is worth disambiguating canaries between the two cases, 
>> because they are different security notions. The first (1) I would call *single-target 
>> ECDLP *(ST-ECDLP), and the second (2) I would call *multi-target ECDLP *
>> (MT-ECDLP).
>>
>> It's pretty clear that MT-ECDLP is easier to break, because attackers can 
>> make progress against more than one target concurrently, and breaking any 
>> one is sufficient to win the security game.
>>
>> For example, say I sample 2 different messages m1​ and m2​, and compute 
>> ECDLP target points T1 = lift_x(SHA256(m1))​ and T2 = lift_x(SHA256(m2))​. 
>> Then if I sample a random scalar r​ and compute R = r*G​, I have two 
>> potential chances of success: R == T1​ OR R == T2​. I can scale up this 
>> advantage by generating more targets, T3​, T4​, ... and so on.
>>
>> MT-ECDLP also admits a more efficient basic unit of computation in brute 
>> force attacks (including Grover) by using hashes instead of EC point 
>> multiplications. If I instead start by picking scalar t​ and fix the 
>> target point T = t*G​, then I can run a brute-force preimage search on 
>> SHA256 until I find m​ such that SHA256(m) == x(T)​. This can also be 
>> scaled up using a multi-target attack [1].
>>
>> With ST-ECDLP, we have only a single fixed message m = G​, and so the 
>> attacker can't use those multi-target cheat codes. They can parallelize, 
>> use pollard-rho or Shor or other algorithms, but they have only a single 
>> target point that they must break to win the game.
>>
>> The method Pieter suggested using for the canary construction is 
>> equivalent to *single-target* ECDLP.
>>
>> I've heard others (e.g. Tadge in this thread 
>> <https://groups.google.com/g/bitcoindev/c/LpWOcXMcvk8/m/DjaiWnViAQAJ>) 
>> previously suggest using a script like OP_SHA256 OP_CHECKSIG​ as a 
>> canary, where any spend of such a script would trigger the canary. This 
>> would be *multi-target* ECDLP.
>>
>> I'm not sure which is better. 
>>
>>
>>    - ST-ECDLP is less likely to be triggered early or mistakenly, and is 
>>    more tightly equivalent to ECDLP. 
>>    
>>
>>    - MT-ECDLP is more reflective of how real-world attackers behave on 
>>    Bitcoin (e.g. with thousands-to-millions of public keys available to attack 
>>    in parallel, and breaking even one is considered unacceptable).
>>
>>
>> I'm slightly leanings towards a construction like Pieter's, featuring 
>> ST-ECDLP, just because I'm not sure what other tricks could be used to 
>> potentially trigger MT-ECDLP classically or quantumly.
>>
>> We could also engineer a compromise between the two, where we limit the 
>> number of targets. For example, define the game like this:
>>
>> Given G​, find scalar a​​ and 32-bit integer i​​ such that a*G = 
>> lift_x(SHA256(G || i))​​.
>>
>> Then the adversary can only attack against at most 2^32 unique target 
>> points, and those targets are fixed forever, for any adversary. This is an 
>> easier problem than ST-ECDLP, but harder than MT-ECDLP. Maybe call it *limited 
>> multi-target ECDLP (LMT-ECDLP)*?
>>
>>
>> regards,
>> conduition
>>
>>
>> [1]: First, generate a bunch of target points. Sample scalar t​ and compute 
>> T0 = t * G​, T1 = T0 + T0, and T2 = T1 + T1, and T3 = T2 + T2​, etc. Why 
>> double each point? point doubling is cheaper than addition or 
>> multiplication, and still covers the whole curve. Then we run a 
>> multi-target SHA256 preimage search over all targets [x(T0), x(T1), x(T2), 
>> x(T3), ...]​. If we have n​ targets and curve order N​, then each message 
>> hash has an n/N​​ chance of success. If we find a valid message m​, such 
>> that SHA256(m) == x(R_i)​ for some target index i​, then we have found T_i 
>> = t * 2**i * G = lift_x(SHA256(m))​.
>>
>>
>>
>>
>>
>> On Thursday, August 13th, 2026 at 2:02 AM, waxwing/ AdamISZ <
>> ekag...@gmail.com> wrote:
>>
>> This tripwire idea is interesting. Basically "canary in consensus".
>>
>> I agree it's valuable. In the scenario of adversarial actor(s) gaining 
>> access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing 
>> to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm 
>> slightly worried that the general userbase will not notice that point, 
>> instead thinking it's a solid defense when it ... depends.
>>
>> In the scenario of at least some whitehats, we get wires tripped, or 
>> canaries singing. Having it in consensus is nice. The blockchain then does 
>> its job of being an unambiguous signal and we can have all the arguments 
>> well ahead of time. [1]
>>
>> On the other hand, we traditionally design such systems adversarially, 
>> right, so you could argue that an overfocus on this might be suboptimal - 
>> it might be better to do other things.
>>
>> (Similar comment applies to the 'smaller group canary' - definitely 
>> nothing wrong with it, but it is not in itself a defence unless we strongly 
>> believe whitehats, and *active* whitehats at that, are keeping up). An 
>> obvious question to raise: would we consider tripwiring a 192 bit group 
>> break of a similar type (NUMS)? I find that ... plausible?
>>
>> > The BIP341 NUMS point (which I suggest using in this context) is the 
>> point whose X coordinate is the SHA256 hash of the generator point G. This 
>> guarantees that the NUMS point cannot predate G (if it did, it would be 
>> possible in theory that secp256k1's designers actually chose G in function 
>> of what we call that NUMS point, giving it a DLP known to them).
>>
>> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based 
>> on SHA2 preimage resistance, but: isn't the real point that we're relying 
>> on SHA-2 not being a naughty function so that you couldn't find G = a * B 
>> and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC 
>> of course, as was likely back then!). I have no idea what precise name you 
>> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
>> given when SHA2 and secp256k1 were standardized :) And given the encoding 
>> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
>> using uncompressed encoding?) were able to be counted on the fingers of the 
>> hand which the sleeve does not cover :)
>>
>> [1] I take Antoine's point that making it consensus means the miners are 
>> involved and there is a non-trivial collusion risk if the stakes are high, 
>> but I can't see how this scenario is *worse* than no tripwire?
>>
>> On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:
>>
>>> Hi Pieter,
>>>
>>> Thanks for the observations.
>>>
>>> When I was saying there is a problem with the game theory,
>>> it's that strikingly, any activation of the tripwire logic
>>> would rely on a "flag" transaction being mined in the chain
>>> for the network nodes starting to enforce at the block N or
>>> N+1 or whatever the EC disabling threshold.
>>>
>>> Any "flag" transaction can be itself re-orged out of the chain
>>> to purely disable the effects of the EC disabling threshold,
>>> therefore make it null and void as an effect. One might see
>>> it as a competing race between a group of "sunsetting" users
>>> and a (majority) coalition of miners in coordination with a
>>> CRQC adversary, where the latter have an interest and the
>>> hashrate capabilities to do a tx-withold [0].
>>>
>>> In pure terms of satoshi fee denominated calculus, empirically
>>> global miners have won an average of $20 B yearly. If we only
>>> consider that P2PK are going to be frozen by the tripwire effect,
>>> as for most of them it might be assumed they will never move to
>>> a safer format, we talk already about 1.7 M of coins or as of
>>> today valuation $107 B (the information is on the chain and can
>>> be verified).
>>>
>>> That's $107B can "burn" in revenue or income that a CRQC-enabled
>>> miners coalition to constantly reorg-out the "flag" tx out of the
>>> chain. In other terms, something like 5 years of income, and I
>>> kindly do not count all the loss coins that are likely to amount
>>> to a far bigger "tripwire" neutralization budget.
>>>
>>> In the name of what a majority of miners will gracefully let on
>>> the table an opportunity of massive income ?
>>>
>>> Leveraging Shor the exploitation might be even done anonymously
>>> as the mining process is done. Not even certainty, by who the
>>> EC-protected coins could be covertly exfiltrated.
>>>
>>> That's the most striking problem when you think about the math
>>> with any "tripwire" approach, or even an "hourglass" one relying
>>> on a "flag" transaction [1]. I'm ruling out "checkpoints" and
>>> any other trust-the-dev approach, as that's even worst [2].
>>>
>>> As you're introducing post is resounding, what the miners
>>> are saying now, there are no guarantees on how they would use
>>> their hashrate down the road, potentially 10 or 20 years from now.
>>>
>>> Beyond, and to answer back your point, I still think you can
>>> manage an escape hatch of the "tripwire" effect, it's all depends
>>> how the script tripwire logic is implemented, but if you have
>>> two OP_SUCCESS of different kinds before your EC CHECKSIG, you
>>> can always have a "soft-fork" after the "tripwire" to return 
>>> true on the stack, with an EC or hashlock as a success (I agree
>>> using undefined op_success in a script is not safe at all) [3].
>>>
>>> Best,
>>> Antoine
>>> OTS hash: 
>>> 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
>>>
>>> [0] See naumenkog's 
>>> https://www.bitmex.com/blog/txwithhold-smart-contracts
>>> [1] This is sad, as the "hourglass" depending how the parameters are 
>>> chosen
>>> was a more acceptable trade-off than pure sunsetting.
>>> [2] Given the amounts at stake to sunset, as a group of developers you
>>> would just paint yourself a target, there are more even funds at stake
>>> that Satoshi herself / himself is assumed to have.
>>> [3] There is no security proof in BIP341 on the unforgeability of the
>>> NUMS point, if it binds in the ROM or whatever.
>>>
>>> Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a 
>>> écrit :
>>>
>>>>
>>>>
>>>> On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
>>>>
>>>> [...]
>>>>
>>>> > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a 
>>>> > specific marker). This is smaller than a full transaction input + 
>>>> > signature.
>>>> >
>>>> > * Similarly, but publishing in the coinbase, and requiring relay 
>>>> using 
>>>> > a separate message. Less places a node needs to check, but I'm 
>>>> > concerned about the difficulty of testing infrastructure that relay 
>>>> of 
>>>> > such a message works
>>>>
>>>> [...]
>>>>
>>>> >
>>>> > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns 
>>>> > <a...@erisian.com.au> wrote:
>>>> >
>>>> >> A slight variant of this approach would be to have a 128 byte value 
>>>> "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a 
>>>> BIP340 signature of m by P. That would allow the victim of post-quantum 
>>>> theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in 
>>>> addition to someone who has direct access to a CRQC.
>>>> >
>>>> > Indeed, I had considered something similar, but see above for why I'm 
>>>> > not convinced supporting non-cooperative CRQCs is that useful.
>>>> >
>>>> > Also, in my view the tripwire isn't really a security feature on 
>>>> itself 
>>>> > (it's not expected to trigger...), but more something that sets 
>>>> > expectations around the output type for prospective users.
>>>> >
>>>> > In that sense, the question is really whether supporting 
>>>> > non-cooperative CRQCs helps set that expectation more than only 
>>>> > cooperative ones, which are definitely easier to support.
>>>> >
>>>> >> I think it could make sense to have the tripwire be included in the 
>>>> block via the coinbase witness commitment output, rather than having it be 
>>>> locked to a transaction, so you only having to check the coinbase for the 
>>>> magic rather than every transaction. That would require a separate P2P 
>>>> message to relay the necessary ECDL-break proof to miners, and would 
>>>> probably need stratumv2 or a getblocktemplate update in order for the node 
>>>> to be able to tell pools to actually include that info in the coinbase.
>>>> >
>>>> > I worry this is untestable, really. You'd need things like 
>>>> > fake-tripwires to be supported through the same message which don't 
>>>> > require an ECDLP break, and still propagate. And then that needs DoS 
>>>> > protection measures, 
>>>>
>>>> I whipped something up last weekend:
>>>> https://github.com/Sjors/bitcoin/pull/121
>>>>
>>>> It seems straightforward, but maybe I missed something:
>>>> - for test code we use a fake NUMS point, so we can generate "proof" 
>>>> without a quantum computer
>>>> - a p2p message floods the proof
>>>> - nodes ignore the message if they already have *any* valid proof
>>>> - verifying p2p proof candidates might need some rate limiting, but 
>>>> it's as cheap as verifying a transaction signature
>>>> - mining code includes the proof in a coinbase op_return, until the 
>>>> freeze activates
>>>> - with stratum v2 (and ipc mining clients in general this works out of 
>>>> the box, a small change is needed for getblocktemplate clients)
>>>> - since the proof is not in the header, we can't use the normal bip9 
>>>> style header scan to see if the rule activated. Instead the prototype 
>>>> stores it in a file along with a merkle inclusion proof, which is read when 
>>>> the node restarts.
>>>>
>>>> With this mechanism it doesn't really need to be in the coinbase 
>>>> transaction, but that does seem more convenient and miners can censor it 
>>>> anyway.
>>>>
>>>> - Sjors
>>>>
>>>> -- 
>>>> You received this message because you are subscribed to a topic in the 
>>>> Google Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this topic, visit 
>>>> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
>>>> To unsubscribe from this group and all its topics, send an email to 
>>>> bitcoindev+...@googlegroups.com.
>>>> To view this discussion visit 
>>>> https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com
>>>> .
>>>>
>>> -- 
>>
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com
>> .
>>
>>
>> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/fd947d7c-86fd-407c-98aa-0a63b8be28fan%40googlegroups.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d84e4a53-f3b1-4cd1-9a86-9591ec8c7211n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 39667 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-15 14:49  0%                 ` waxwing/ AdamISZ
@ 2026-08-15 16:52  0%                   ` 'conduition' via Bitcoin Development Mailing List
  2026-08-15 18:06  0%                     ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-15 16:52 UTC (permalink / raw)
  To: waxwing/ AdamISZ; +Cc: Bitcoin Development Mailing List


[-- Attachment #1.1.1: Type: text/plain, Size: 24646 bytes --]

> This is relevant because the hypothetical evil curve-generator who is trying to poison the future H=SHA2(G) has an easier time in doing so, than a future canary-solver who obviously cannot try different values of G :)



Ah sorry, I thought you were talking about canary solvers, didn't realize you were talking about curve designers. Agreed then, but still seems unlikely that G was chosen this way: https://bitcoin.stackexchange.com/questions/58784/how-were-the-secp256k1-base-point-coordinates-decided


If we have any doubt about that, we could tweak the hash function with some data that is newer than G but still unbiased, e.g. the hash of the genesis block, or the hash of the first block in which the canary goes live (idea credit: Tadge Dryja).


> interesting point is that Shor can target any specific dlog problem, right. So I do think the ST is the correct version of the problem?



Yes, I believe so. I don't know of any way to batch Shor's algorithm in a multi-target attack that is any more efficient than a trivial one-by-one attack, so using MT-ECDLP seems like it only serves to makes classical attacks (or Grover's search) easier.


regards,
conduition


On Saturday, August 15th, 2026 at 10:14 AM, waxwing/ AdamISZ <ekaggata@gmail.com> wrote:

> > A 192-bit curve i think should be reasonable as a canary, but consider this: If someone already has a QC that breaks 192-bit ECC, how long until they build one which breaks 256-bit ECC? A day, a week, a year? No way of knowing. If the delay is too long, users may see the canary as a false-positive, and migrate back to vulnerable addresses, and they might even be right. 192-bit canaries are vulnerable to classical attack with work approximately 2^96. We should bear in mind the possibility that such a canary could be activated possibly very early, well before Q-day, possibly even in the absence of any quantum computers.
> 

> Agreed that is unlikely a big delta, in the nature of these things (QCs), between 192 and 256. Including that it's obvious that going very much below 192 means classical attack and therefore bad idea. Which is why I said 192 and not sub 160. What's not obvious is that 192 is worse than 256 here. It may only give us a small amount of extra time, but it won't give us negative extra time. So the tradeoff is, presumably, whether the additional complexity (which is a bit tricky from what I recall [1], but there will definitely be experts out there who can clean it up) is worth it.
> The idea of 'people will think it a false positive', disagree, I think the whole tripwire idea is likely a *bit* vulnerable to genpop misunderstanding as I said in my previous post, but this particular thing I don't see it: a 192 bit being broken is *very* likely to cause an appropriate level of panic.
> 

> > Anyone can find G = a * B. Just generate a key and invert your secret key.
> 

> > P = a * G
> > G = a**-1 * P
> 

> > The hard part is then finding some b such that b*G = SHA256(G).
> 

> You slightly missed my point here, I think? The idea is that if you set up two sides that are both sample-able, you can birthday. Like, you keep sampling a on one side and b on the other. Build tables of both sides. Then all you have to do is check whether SHA2 of the LHS ever matches the RHS. This gives you a square root style speedup a la birthday attack. Contrast with if you just fix G, then keep searching for matches: no square root speedup. This is relevant because the hypothetical evil curve-generator who is trying to poison the future H=SHA2(G) has an easier time in doing so, than a future canary-solver who obviously cannot try different values of G :)
> 

> About your single-target vs multi-target distinction: interesting point is that Shor can target any specific dlog problem, right. So I do think the ST is the correct version of the problem? But actually I am quite unsure and unclear about those ST, MT, LMT distinctions you're making; specifically I mean, I am very unsure about how they differ in costs.
> 

> As for characterizing the problem, I think it's fair to say: if you assumed SHA2 was a proper random oracle then we have with SHA2(enc(G)), something that's very tightly equivalent to ECDLP, which is what we want. If we want to pay attention to the fact that SHA2 is an actual hash function and not an RO, then I think there's some statement like "assuming SHA2 has no structure "matching" secp256k1, then it's tightly equivalent to ECDLP on secp256k1" which is obviously horrendously vague, but would not be very easy to write down properly.
> 

> Another observation, probably it already exists up-thread: we obviously don't want to *literally* use BIP341's H on a 256 bit tripwire, because then a Shor-break directly steals a bunch of coins, so what should we use? Maybe SHA2(SHA2(enc(G)) ?
> 

> 

> [1] https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498/9
> On Friday, August 14, 2026 at 12:34:54 PM UTC-6 conduition wrote:
> 

> > > An obvious question to raise: would we consider tripwiring a 192 bit group break of a similar type (NUMS)? I find that ... plausible?
> > 

> > 

> > A 192-bit curve i think should be reasonable as a canary, but consider this: If someone already has a QC that breaks 192-bit ECC, how long until they build one which breaks 256-bit ECC? A day, a week, a year? No way of knowing. If the delay is too long, users may see the canary as a false-positive, and migrate back to vulnerable addresses, and they might even be right. 192-bit canaries are vulnerable to classical attack with work approximately 2^96. We should bear in mind the possibility that such a canary could be activated possibly very early, well before Q-day, possibly even in the absence of any quantum computers.
> > 

> > Ideally we want a short gap between "192-bit is broken" and "256-bit is broken", but not so short as to make the 192-bit canary effectively fungible with a 256-bit canary (because then it's less likely to be activated before theft occurs).
> > 

> > 

> > > w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on SHA2 preimage resistance, but: isn't the real point that we're relying on SHA-2 not being a naughty function so that you couldn't find G = a * B and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of course, as was likely back then!). I have no idea what precise name you give to that property. OK, this is a ridiculous thing to discuss, perhaps, given when SHA2 and secp256k1 were standardized :) And given the encoding choices for our BIP341 NUMS (iirc the same as for Elements back in the day? using uncompressed encoding?) were able to be counted on the fingers of the hand which the sleeve does not cover :)
> > 

> > 

> > Anyone can find `G = a * B`. Just generate a key and invert your secret key.
> > 

> > `P = a * G`
> > G = a**-1 * P
> > 

> > The hard part is then finding some b such that `b*G = SHA256(G).`
> > 

> > ---------
> > 

> > If we reflect on the requirement that `G` is fixed, we see `SHA256(G)` is also fixed as a pseudorandom challenge point. The reason for using SHA256 instead of, say, picking an arbitary point by committee or using digits of pi or some other trickery, is that hash outputs are supposed to be random and so `SHA256(G)` is (assumably) a random ECDLP challenge. This matches the classical definition of ECDLP more tightly: Given an arbitrary point `P`, find `p` such that `P = p * G`. The assumption is that if an attacker can factor an honestly-sampled challenge point, they can factor any point. SHA256 is just a stand-in for the "honestly-sampled" part.
> > However, the following two tasks are actually very different:
> > 

> > 

> > 1.  Given G, find scalar `a` such that `a*G = lift_x(SHA256(G))`.
> > 2.  Given G, find scalar `a` and message `m` such that `a*G = lift_x(SHA256(m))`.
> > 

> > 

> > In the case of task 1, if we assume SHA256 output is random, then this is more tightly equivalent to ECDLP, because the point we're trying to factor is a fixed target, as is the one sampled honestly by the ECDLP security game.
> > 

> > In the case of task 2, the attacker can sample arbitrary messages to create multiple target points, and the attacker wins if they succeed in factoring any of them. The attacker can attack all those target points concurrently if they want, and they get a speedup from doing so.
> > 

> > So I believe it is worth disambiguating canaries between the two cases, because they are different security notions. The first (1) I would call single-target ECDLP (ST-ECDLP), and the second (2) I would call multi-target ECDLP (MT-ECDLP).
> > 

> > It's pretty clear that MT-ECDLP is easier to break, because attackers can make progress against more than one target concurrently, and breaking any one is sufficient to win the security game.
> > 

> > For example, say I sample 2 different messages `m1` and `m2`, and compute ECDLP target points `T1 = lift_x(SHA256(m1))` and `T2 = lift_x(SHA256(m2))`. Then if I sample a random scalar `r` and compute `R = r*G`, I have two potential chances of success: `R == T1` OR `R == T2`. I can scale up this advantage by generating more targets, `T3`, `T4`, ... and so on.
> > 

> > MT-ECDLP also admits a more efficient basic unit of computation in brute force attacks (including Grover) by using hashes instead of EC point multiplications. If I instead start by picking scalar `t` and fix the target point `T = t*G`, then I can run a brute-force preimage search on SHA256 until I find `m` such that `SHA256(m) == x(T)`. This can also be scaled up using a multi-target attack [1].
> > 

> > With ST-ECDLP, we have only a single fixed message `m = G`, and so the attacker can't use those multi-target cheat codes. They can parallelize, use pollard-rho or Shor or other algorithms, but they have only a single target point that they must break to win the game.
> > 

> > The method Pieter suggested using for the canary construction is equivalent to single-target ECDLP.
> > 

> > I've heard others (e.g. Tadge in this thread) previously suggest using a script like `OP_SHA256 OP_CHECKSIG` as a canary, where any spend of such a script would trigger the canary. This would be multi-target ECDLP.
> > 

> > I'm not sure which is better.
> > 

> > 

> > -   ST-ECDLP is less likely to be triggered early or mistakenly, and is more tightly equivalent to ECDLP.
> >     

> > 

> > -   MT-ECDLP is more reflective of how real-world attackers behave on Bitcoin (e.g. with thousands-to-millions of public keys available to attack in parallel, and breaking even one is considered unacceptable).
> > 

> > 

> > 

> > I'm slightly leanings towards a construction like Pieter's, featuring ST-ECDLP, just because I'm not sure what other tricks could be used to potentially trigger MT-ECDLP classically or quantumly.
> > 

> > We could also engineer a compromise between the two, where we limit the number of targets. For example, define the game like this:
> > 

> > 

> > Given `G`, find scalar `a` and 32-bit integer `i` such that `a*G = lift_x(SHA256(G || i))`.
> > 

> > 

> > Then the adversary can only attack against at most 2^32 unique target points, and those targets are fixed forever, for any adversary. This is an easier problem than ST-ECDLP, but harder than MT-ECDLP. Maybe call it limited multi-target ECDLP (LMT-ECDLP)?
> > 

> > 

> > regards,
> > conduition
> > 

> > 

> > [1]: First, generate a bunch of target points. Sample scalar `t` and compute `T0 = t * G`, T1 = T0 + T0, and T2 = T1 + T1, and T3 = T2 + T2, etc. Why double each point? point doubling is cheaper than addition or multiplication, and still covers the whole curve. Then we run a multi-target SHA256 preimage search over all targets [x(T0), x(T1), x(T2), x(T3), ...]. If we have n targets and curve order N, then each message hash has an `n/N` chance of success. If we find a valid message `m`, such that `SHA256(m) == x(R_i)` for some target index `i`, then we have found `T_i = t * 2**i * G = lift_x(SHA256(m))`.
> > 

> > 

> > 

> > 

> > 

> > 

> > On Thursday, August 13th, 2026 at 2:02 AM, waxwing/ AdamISZ <ekag...@gmail.com> wrote:
> > 

> > > This tripwire idea is interesting. Basically "canary in consensus".
> > > I agree it's valuable. In the scenario of adversarial actor(s) gaining access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm slightly worried that the general userbase will not notice that point, instead thinking it's a solid defense when it ... depends.
> > > 

> > > In the scenario of at least some whitehats, we get wires tripped, or canaries singing. Having it in consensus is nice. The blockchain then does its job of being an unambiguous signal and we can have all the arguments well ahead of time. [1]
> > > 

> > > On the other hand, we traditionally design such systems adversarially, right, so you could argue that an overfocus on this might be suboptimal - it might be better to do other things.
> > > 

> > > (Similar comment applies to the 'smaller group canary' - definitely nothing wrong with it, but it is not in itself a defence unless we strongly believe whitehats, and *active* whitehats at that, are keeping up). An obvious question to raise: would we consider tripwiring a 192 bit group break of a similar type (NUMS)? I find that ... plausible?
> > > > The BIP341 NUMS point (which I suggest using in this context) is the point whose X coordinate is the SHA256 hash of the generator point G. This guarantees that the NUMS point cannot predate G (if it did, it would be possible in theory that secp256k1's designers actually chose G in function of what we call that NUMS point, giving it a DLP known to them).
> > > 

> > > w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on SHA2 preimage resistance, but: isn't the real point that we're relying on SHA-2 not being a naughty function so that you couldn't find G = a * B and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of course, as was likely back then!). I have no idea what precise name you give to that property. OK, this is a ridiculous thing to discuss, perhaps, given when SHA2 and secp256k1 were standardized :) And given the encoding choices for our BIP341 NUMS (iirc the same as for Elements back in the day? using uncompressed encoding?) were able to be counted on the fingers of the hand which the sleeve does not cover :)
> > > 

> > > [1] I take Antoine's point that making it consensus means the miners are involved and there is a non-trivial collusion risk if the stakes are high, but I can't see how this scenario is *worse* than no tripwire?
> > > 

> > > On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:
> > > 

> > > > Hi Pieter,
> > > > 

> > > > Thanks for the observations.
> > > > 

> > > > When I was saying there is a problem with the game theory,
> > > > it's that strikingly, any activation of the tripwire logic
> > > > would rely on a "flag" transaction being mined in the chain
> > > > for the network nodes starting to enforce at the block N or
> > > > N+1 or whatever the EC disabling threshold.
> > > > 

> > > > Any "flag" transaction can be itself re-orged out of the chain
> > > > to purely disable the effects of the EC disabling threshold,
> > > > therefore make it null and void as an effect. One might see
> > > > it as a competing race between a group of "sunsetting" users
> > > > and a (majority) coalition of miners in coordination with a
> > > > CRQC adversary, where the latter have an interest and the
> > > > hashrate capabilities to do a tx-withold [0].
> > > > 

> > > > In pure terms of satoshi fee denominated calculus, empirically
> > > > global miners have won an average of $20 B yearly. If we only
> > > > consider that P2PK are going to be frozen by the tripwire effect,
> > > > as for most of them it might be assumed they will never move to
> > > > a safer format, we talk already about 1.7 M of coins or as of
> > > > today valuation $107 B (the information is on the chain and can
> > > > be verified).
> > > > 

> > > > That's $107B can "burn" in revenue or income that a CRQC-enabled
> > > > miners coalition to constantly reorg-out the "flag" tx out of the
> > > > chain. In other terms, something like 5 years of income, and I
> > > > kindly do not count all the loss coins that are likely to amount
> > > > to a far bigger "tripwire" neutralization budget.
> > > > 

> > > > In the name of what a majority of miners will gracefully let on
> > > > the table an opportunity of massive income ?
> > > > 

> > > > Leveraging Shor the exploitation might be even done anonymously
> > > > as the mining process is done. Not even certainty, by who the
> > > > EC-protected coins could be covertly exfiltrated.
> > > > 

> > > > That's the most striking problem when you think about the math
> > > > with any "tripwire" approach, or even an "hourglass" one relying
> > > > on a "flag" transaction [1]. I'm ruling out "checkpoints" and
> > > > any other trust-the-dev approach, as that's even worst [2].
> > > > 

> > > > As you're introducing post is resounding, what the miners
> > > > are saying now, there are no guarantees on how they would use
> > > > their hashrate down the road, potentially 10 or 20 years from now.
> > > > 

> > > > Beyond, and to answer back your point, I still think you can
> > > > manage an escape hatch of the "tripwire" effect, it's all depends
> > > > how the script tripwire logic is implemented, but if you have
> > > > two OP_SUCCESS of different kinds before your EC CHECKSIG, you
> > > > can always have a "soft-fork" after the "tripwire" to return
> > > > true on the stack, with an EC or hashlock as a success (I agree
> > > > using undefined op_success in a script is not safe at all) [3].
> > > > 

> > > > Best,
> > > > Antoine
> > > > OTS hash: 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
> > > > 

> > > > [0] See naumenkog's https://www.bitmex.com/blog/txwithhold-smart-contracts
> > > > [1] This is sad, as the "hourglass" depending how the parameters are chosen
> > > > was a more acceptable trade-off than pure sunsetting.
> > > > [2] Given the amounts at stake to sunset, as a group of developers you
> > > > would just paint yourself a target, there are more even funds at stake
> > > > that Satoshi herself / himself is assumed to have.
> > > > [3] There is no security proof in BIP341 on the unforgeability of the
> > > > NUMS point, if it binds in the ROM or whatever.
> > > > 

> > > > 

> > > > Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a écrit :
> > > > 

> > > > > 

> > > > > 

> > > > > On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
> > > > > 

> > > > > [...]
> > > > > 

> > > > > > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a
> > > > > > specific marker). This is smaller than a full transaction input +
> > > > > > signature.
> > > > > >
> > > > > > * Similarly, but publishing in the coinbase, and requiring relay using
> > > > > > a separate message. Less places a node needs to check, but I'm
> > > > > > concerned about the difficulty of testing infrastructure that relay of
> > > > > > such a message works
> > > > > 

> > > > > [...]
> > > > > 

> > > > > >
> > > > > > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns
> > > > > > <a...@erisian.com.au> wrote:
> > > > > >
> > > > > >> A slight variant of this approach would be to have a 128 byte value "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a BIP340 signature of m by P. That would allow the victim of post-quantum theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in addition to someone who has direct access to a CRQC.
> > > > > >
> > > > > > Indeed, I had considered something similar, but see above for why I'm
> > > > > > not convinced supporting non-cooperative CRQCs is that useful.
> > > > > >
> > > > > > Also, in my view the tripwire isn't really a security feature on itself
> > > > > > (it's not expected to trigger...), but more something that sets
> > > > > > expectations around the output type for prospective users.
> > > > > >
> > > > > > In that sense, the question is really whether supporting
> > > > > > non-cooperative CRQCs helps set that expectation more than only
> > > > > > cooperative ones, which are definitely easier to support.
> > > > > >
> > > > > >> I think it could make sense to have the tripwire be included in the block via the coinbase witness commitment output, rather than having it be locked to a transaction, so you only having to check the coinbase for the magic rather than every transaction. That would require a separate P2P message to relay the necessary ECDL-break proof to miners, and would probably need stratumv2 or a getblocktemplate update in order for the node to be able to tell pools to actually include that info in the coinbase.
> > > > > >
> > > > > > I worry this is untestable, really. You'd need things like
> > > > > > fake-tripwires to be supported through the same message which don't
> > > > > > require an ECDLP break, and still propagate. And then that needs DoS
> > > > > > protection measures,
> > > > > 

> > > > > I whipped something up last weekend:
> > > > > https://github.com/Sjors/bitcoin/pull/121
> > > > > 

> > > > > It seems straightforward, but maybe I missed something:
> > > > > - for test code we use a fake NUMS point, so we can generate "proof" without a quantum computer
> > > > > - a p2p message floods the proof
> > > > > - nodes ignore the message if they already have *any* valid proof
> > > > > - verifying p2p proof candidates might need some rate limiting, but it's as cheap as verifying a transaction signature
> > > > > - mining code includes the proof in a coinbase op_return, until the freeze activates
> > > > > - with stratum v2 (and ipc mining clients in general this works out of the box, a small change is needed for getblocktemplate clients)
> > > > > - since the proof is not in the header, we can't use the normal bip9 style header scan to see if the rule activated. Instead the prototype stores it in a file along with a merkle inclusion proof, which is read when the node restarts.
> > > > > 

> > > > > With this mechanism it doesn't really need to be in the coinbase transaction, but that does seem more convenient and miners can censor it anyway.
> > > > > 

> > > > > - Sjors
> > > > 

> > > > > --
> > > > > You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> > > > > To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
> > > > > To unsubscribe from this group and all its topics, send an email to bitcoindev+...@googlegroups.com.
> > > > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com.
> > > 

> > > --
> > 

> > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com.
> 

> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/fd947d7c-86fd-407c-98aa-0a63b8be28fan%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/irB0rm4rUG6GyaLnf1vUsNFW8BBJXAuh8-FIJ_s75xjgFgbOuTdaEGQ30PYzjtawVv5UVIC5xs7Uq_Cm9BPSyC73A-xGwT5J2oYsKE8QiPE%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 36014 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-14 18:33  0%               ` 'conduition' via Bitcoin Development Mailing List
@ 2026-08-15 14:49  0%                 ` waxwing/ AdamISZ
  2026-08-15 16:52  0%                   ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2026-08-15 14:49 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 22481 bytes --]

> A 192-bit curve i think should be reasonable as a canary, but consider 
this: If someone already has a QC that breaks 192-bit ECC, how long until 
they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
knowing. If the delay is too long, users may see the canary as a 
false-positive, and migrate back to vulnerable addresses, and they might 
even be right. 192-bit canaries are vulnerable to classical attack with 
work approximately 2^96. We should bear in mind the possibility that such a 
canary could be activated possibly very early, well before Q-day, possibly 
even in the absence of any quantum computers.

Agreed that is unlikely a big delta, in the nature of these things (QCs), 
between 192 and 256. Including that it's obvious that going very much below 
192 means classical attack and therefore bad idea. Which is why I said 192 
and not sub 160. What's not obvious is that 192 is worse than 256 here. It 
may only give us a small amount of extra time, but it won't give us 
negative extra time. So the tradeoff is, presumably, whether the additional 
complexity (which is a bit tricky from what I recall [1], but there will 
definitely be experts out there who can clean it up) is worth it.

The idea of 'people will think it a false positive', disagree, I think the 
whole tripwire idea is likely a *bit* vulnerable to genpop misunderstanding 
as I said in my previous post, but this particular thing I don't see it: a 
192 bit being broken is *very* likely to cause an appropriate level of 
panic.

> Anyone can find G = a * B​. Just generate a key and invert your secret 
key.

> P = a * G​
> G = a**-1 * P

> The hard part is then finding some b such that b*G = SHA256(G).

You slightly missed my point here, I think? The idea is that if you set up 
two sides that are both sample-able, you can birthday. Like, you keep 
sampling a on one side and b on the other. Build tables of both sides. Then 
all you have to do is check whether SHA2 of the LHS ever matches the RHS. 
This gives you a square root style speedup a la birthday attack. Contrast 
with if you just fix G, then keep searching for matches: no square root 
speedup. This is relevant because the hypothetical evil curve-generator who 
is trying to poison the future H=SHA2(G) has an easier time in doing so, 
than a future canary-solver who obviously cannot try different values of G 
:)

About your single-target vs multi-target distinction: interesting point is 
that Shor can target any specific dlog problem, right. So I do think the ST 
is the correct version of the problem? But actually I am quite unsure and 
unclear about those ST, MT, LMT distinctions you're making; specifically I 
mean, I am very unsure about how they differ in costs.

As for characterizing the problem, I think it's fair to say: if you assumed 
SHA2 was a proper random oracle then we have with SHA2(enc(G)), something 
that's very tightly equivalent to ECDLP, which is what we want. If we want 
to pay attention to the fact that SHA2 is an actual hash function and not 
an RO, then I think there's some statement like "assuming SHA2 has no 
structure "matching" secp256k1, then it's tightly equivalent to ECDLP on 
secp256k1" which is obviously horrendously vague, but would not be very 
easy to write down properly.

Another observation, probably it already exists up-thread: we obviously 
don't want to *literally* use BIP341's H on a 256 bit tripwire, because 
then a Shor-break directly steals a bunch of coins, so what should we use? 
Maybe SHA2(SHA2(enc(G)) ?


[1] https://delvingbitcoin.org/t/qcap-a-bitcoin-native-quantum-canary-alert/2498/9
On Friday, August 14, 2026 at 12:34:54 PM UTC-6 conduition wrote:

> An obvious question to raise: would we consider tripwiring a 192 bit group 
> break of a similar type (NUMS)? I find that ... plausible?
>
>
> A 192-bit curve i think should be reasonable as a canary, but consider 
> this: If someone already has a QC that breaks 192-bit ECC, how long until 
> they build one which breaks 256-bit ECC? A day, a week, a year? No way of 
> knowing. If the delay is too long, users may see the canary as a 
> false-positive, and migrate back to vulnerable addresses, and they might 
> even be right. 192-bit canaries are vulnerable to classical attack with 
> work approximately 2^96. We should bear in mind the possibility that such a 
> canary could be activated possibly very early, well before Q-day, possibly 
> even in the absence of any quantum computers.
>
> Ideally we want a short gap between "192-bit is broken" and "256-bit is 
> broken", but not so short as to make the 192-bit canary effectively 
> fungible with a 256-bit canary (because then it's less likely to be 
> activated before theft occurs).
>
> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on 
> SHA2 preimage resistance, but: isn't the real point that we're relying on 
> SHA-2 not being a naughty function so that you couldn't find G = a * B and 
> SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of 
> course, as was likely back then!). I have no idea what precise name you 
> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
> given when SHA2 and secp256k1 were standardized :) And given the encoding 
> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
> using uncompressed encoding?) were able to be counted on the fingers of the 
> hand which the sleeve does not cover :)
>
>
> Anyone can find G = a * B​. Just generate a key and invert your secret 
> key.
>
> P = a * G​
> G = a**-1 * P
>
> The hard part is then finding some b such that b*G = SHA256(G).
>
> ---------
>
> If we reflect on the requirement that G​ is fixed, we see SHA256(G)​ is 
> also fixed as a pseudorandom challenge point. The reason for using SHA256 
> instead of, say, picking an arbitary point by committee or using digits of 
> pi or some other trickery, is that hash outputs are supposed to be random 
> and so SHA256(G)​ is (assumably) a random ECDLP challenge. This matches 
> the classical definition of ECDLP more tightly: Given an arbitrary point P​, 
> find p​ such that P = p * G​. The assumption is that if an attacker can 
> factor an honestly-sampled challenge point, they can factor any point. 
> SHA256 is just a stand-in for the "honestly-sampled" part.
>
> However, the following two tasks are actually very different:
>
>
>    1. Given G, find scalar a​ such that a*G = lift_x(SHA256(G))​.
>    2. Given G, find scalar a​ and message m​ such that a*G = 
>    lift_x(SHA256(m))​.
>
>
> In the case of task 1, if we assume SHA256 output is random, then this is 
> more tightly equivalent to ECDLP, because the point we're trying to factor 
> is a fixed target, as is the one sampled honestly by the ECDLP security 
> game.
>
> In the case of task 2, the attacker can sample arbitrary messages to 
> create multiple *target points*, and the attacker wins if they succeed in 
> factoring any of them. The attacker can attack all those target points 
> concurrently if they want, and they get a speedup from doing so.
>
> So I believe it is worth disambiguating canaries between the two cases, 
> because they are different security notions. The first (1) I would call *single-target 
> ECDLP *(ST-ECDLP), and the second (2) I would call *multi-target ECDLP *
> (MT-ECDLP).
>
> It's pretty clear that MT-ECDLP is easier to break, because attackers can 
> make progress against more than one target concurrently, and breaking any 
> one is sufficient to win the security game.
>
> For example, say I sample 2 different messages m1​ and m2​, and compute 
> ECDLP target points T1 = lift_x(SHA256(m1))​ and T2 = lift_x(SHA256(m2))​. 
> Then if I sample a random scalar r​ and compute R = r*G​, I have two 
> potential chances of success: R == T1​ OR R == T2​. I can scale up this 
> advantage by generating more targets, T3​, T4​, ... and so on.
>
> MT-ECDLP also admits a more efficient basic unit of computation in brute 
> force attacks (including Grover) by using hashes instead of EC point 
> multiplications. If I instead start by picking scalar t​ and fix the 
> target point T = t*G​, then I can run a brute-force preimage search on 
> SHA256 until I find m​ such that SHA256(m) == x(T)​. This can also be 
> scaled up using a multi-target attack [1].
>
> With ST-ECDLP, we have only a single fixed message m = G​, and so the 
> attacker can't use those multi-target cheat codes. They can parallelize, 
> use pollard-rho or Shor or other algorithms, but they have only a single 
> target point that they must break to win the game.
>
> The method Pieter suggested using for the canary construction is 
> equivalent to *single-target* ECDLP.
>
> I've heard others (e.g. Tadge in this thread 
> <https://groups.google.com/g/bitcoindev/c/LpWOcXMcvk8/m/DjaiWnViAQAJ>) 
> previously suggest using a script like OP_SHA256 OP_CHECKSIG​ as a 
> canary, where any spend of such a script would trigger the canary. This 
> would be *multi-target* ECDLP.
>
> I'm not sure which is better. 
>
>
>    - ST-ECDLP is less likely to be triggered early or mistakenly, and is 
>    more tightly equivalent to ECDLP. 
>    
>
>    - MT-ECDLP is more reflective of how real-world attackers behave on 
>    Bitcoin (e.g. with thousands-to-millions of public keys available to attack 
>    in parallel, and breaking even one is considered unacceptable).
>
>
> I'm slightly leanings towards a construction like Pieter's, featuring 
> ST-ECDLP, just because I'm not sure what other tricks could be used to 
> potentially trigger MT-ECDLP classically or quantumly.
>
> We could also engineer a compromise between the two, where we limit the 
> number of targets. For example, define the game like this:
>
> Given G​, find scalar a​​ and 32-bit integer i​​ such that a*G = 
> lift_x(SHA256(G || i))​​.
>
> Then the adversary can only attack against at most 2^32 unique target 
> points, and those targets are fixed forever, for any adversary. This is an 
> easier problem than ST-ECDLP, but harder than MT-ECDLP. Maybe call it *limited 
> multi-target ECDLP (LMT-ECDLP)*?
>
>
> regards,
> conduition
>
>
> [1]: First, generate a bunch of target points. Sample scalar t​ and compute 
> T0 = t * G​, T1 = T0 + T0, and T2 = T1 + T1, and T3 = T2 + T2​, etc. Why 
> double each point? point doubling is cheaper than addition or 
> multiplication, and still covers the whole curve. Then we run a 
> multi-target SHA256 preimage search over all targets [x(T0), x(T1), x(T2), 
> x(T3), ...]​. If we have n​ targets and curve order N​, then each message 
> hash has an n/N​​ chance of success. If we find a valid message m​, such 
> that SHA256(m) == x(R_i)​ for some target index i​, then we have found T_i 
> = t * 2**i * G = lift_x(SHA256(m))​.
>
>
>
>
>
> On Thursday, August 13th, 2026 at 2:02 AM, waxwing/ AdamISZ <
> ekag...@gmail.com> wrote:
>
> This tripwire idea is interesting. Basically "canary in consensus".
>
> I agree it's valuable. In the scenario of adversarial actor(s) gaining 
> access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing 
> to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm 
> slightly worried that the general userbase will not notice that point, 
> instead thinking it's a solid defense when it ... depends.
>
> In the scenario of at least some whitehats, we get wires tripped, or 
> canaries singing. Having it in consensus is nice. The blockchain then does 
> its job of being an unambiguous signal and we can have all the arguments 
> well ahead of time. [1]
>
> On the other hand, we traditionally design such systems adversarially, 
> right, so you could argue that an overfocus on this might be suboptimal - 
> it might be better to do other things.
>
> (Similar comment applies to the 'smaller group canary' - definitely 
> nothing wrong with it, but it is not in itself a defence unless we strongly 
> believe whitehats, and *active* whitehats at that, are keeping up). An 
> obvious question to raise: would we consider tripwiring a 192 bit group 
> break of a similar type (NUMS)? I find that ... plausible?
>
> > The BIP341 NUMS point (which I suggest using in this context) is the 
> point whose X coordinate is the SHA256 hash of the generator point G. This 
> guarantees that the NUMS point cannot predate G (if it did, it would be 
> possible in theory that secp256k1's designers actually chose G in function 
> of what we call that NUMS point, giving it a DLP known to them).
>
> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on 
> SHA2 preimage resistance, but: isn't the real point that we're relying on 
> SHA-2 not being a naughty function so that you couldn't find G = a * B and 
> SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of 
> course, as was likely back then!). I have no idea what precise name you 
> give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
> given when SHA2 and secp256k1 were standardized :) And given the encoding 
> choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
> using uncompressed encoding?) were able to be counted on the fingers of the 
> hand which the sleeve does not cover :)
>
> [1] I take Antoine's point that making it consensus means the miners are 
> involved and there is a non-trivial collusion risk if the stakes are high, 
> but I can't see how this scenario is *worse* than no tripwire?
>
> On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:
>
>> Hi Pieter,
>>
>> Thanks for the observations.
>>
>> When I was saying there is a problem with the game theory,
>> it's that strikingly, any activation of the tripwire logic
>> would rely on a "flag" transaction being mined in the chain
>> for the network nodes starting to enforce at the block N or
>> N+1 or whatever the EC disabling threshold.
>>
>> Any "flag" transaction can be itself re-orged out of the chain
>> to purely disable the effects of the EC disabling threshold,
>> therefore make it null and void as an effect. One might see
>> it as a competing race between a group of "sunsetting" users
>> and a (majority) coalition of miners in coordination with a
>> CRQC adversary, where the latter have an interest and the
>> hashrate capabilities to do a tx-withold [0].
>>
>> In pure terms of satoshi fee denominated calculus, empirically
>> global miners have won an average of $20 B yearly. If we only
>> consider that P2PK are going to be frozen by the tripwire effect,
>> as for most of them it might be assumed they will never move to
>> a safer format, we talk already about 1.7 M of coins or as of
>> today valuation $107 B (the information is on the chain and can
>> be verified).
>>
>> That's $107B can "burn" in revenue or income that a CRQC-enabled
>> miners coalition to constantly reorg-out the "flag" tx out of the
>> chain. In other terms, something like 5 years of income, and I
>> kindly do not count all the loss coins that are likely to amount
>> to a far bigger "tripwire" neutralization budget.
>>
>> In the name of what a majority of miners will gracefully let on
>> the table an opportunity of massive income ?
>>
>> Leveraging Shor the exploitation might be even done anonymously
>> as the mining process is done. Not even certainty, by who the
>> EC-protected coins could be covertly exfiltrated.
>>
>> That's the most striking problem when you think about the math
>> with any "tripwire" approach, or even an "hourglass" one relying
>> on a "flag" transaction [1]. I'm ruling out "checkpoints" and
>> any other trust-the-dev approach, as that's even worst [2].
>>
>> As you're introducing post is resounding, what the miners
>> are saying now, there are no guarantees on how they would use
>> their hashrate down the road, potentially 10 or 20 years from now.
>>
>> Beyond, and to answer back your point, I still think you can
>> manage an escape hatch of the "tripwire" effect, it's all depends
>> how the script tripwire logic is implemented, but if you have
>> two OP_SUCCESS of different kinds before your EC CHECKSIG, you
>> can always have a "soft-fork" after the "tripwire" to return 
>> true on the stack, with an EC or hashlock as a success (I agree
>> using undefined op_success in a script is not safe at all) [3].
>>
>> Best,
>> Antoine
>> OTS hash: 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
>>
>> [0] See naumenkog's 
>> https://www.bitmex.com/blog/txwithhold-smart-contracts
>> [1] This is sad, as the "hourglass" depending how the parameters are 
>> chosen
>> was a more acceptable trade-off than pure sunsetting.
>> [2] Given the amounts at stake to sunset, as a group of developers you
>> would just paint yourself a target, there are more even funds at stake
>> that Satoshi herself / himself is assumed to have.
>> [3] There is no security proof in BIP341 on the unforgeability of the
>> NUMS point, if it binds in the ROM or whatever.
>>
>> Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a 
>> écrit :
>>
>>>
>>>
>>> On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
>>>
>>> [...]
>>>
>>> > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a 
>>> > specific marker). This is smaller than a full transaction input + 
>>> > signature.
>>> >
>>> > * Similarly, but publishing in the coinbase, and requiring relay using 
>>> > a separate message. Less places a node needs to check, but I'm 
>>> > concerned about the difficulty of testing infrastructure that relay of 
>>> > such a message works
>>>
>>> [...]
>>>
>>> >
>>> > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns 
>>> > <a...@erisian.com.au> wrote:
>>> >
>>> >> A slight variant of this approach would be to have a 128 byte value 
>>> "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a 
>>> BIP340 signature of m by P. That would allow the victim of post-quantum 
>>> theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in 
>>> addition to someone who has direct access to a CRQC.
>>> >
>>> > Indeed, I had considered something similar, but see above for why I'm 
>>> > not convinced supporting non-cooperative CRQCs is that useful.
>>> >
>>> > Also, in my view the tripwire isn't really a security feature on 
>>> itself 
>>> > (it's not expected to trigger...), but more something that sets 
>>> > expectations around the output type for prospective users.
>>> >
>>> > In that sense, the question is really whether supporting 
>>> > non-cooperative CRQCs helps set that expectation more than only 
>>> > cooperative ones, which are definitely easier to support.
>>> >
>>> >> I think it could make sense to have the tripwire be included in the 
>>> block via the coinbase witness commitment output, rather than having it be 
>>> locked to a transaction, so you only having to check the coinbase for the 
>>> magic rather than every transaction. That would require a separate P2P 
>>> message to relay the necessary ECDL-break proof to miners, and would 
>>> probably need stratumv2 or a getblocktemplate update in order for the node 
>>> to be able to tell pools to actually include that info in the coinbase.
>>> >
>>> > I worry this is untestable, really. You'd need things like 
>>> > fake-tripwires to be supported through the same message which don't 
>>> > require an ECDLP break, and still propagate. And then that needs DoS 
>>> > protection measures, 
>>>
>>> I whipped something up last weekend:
>>> https://github.com/Sjors/bitcoin/pull/121
>>>
>>> It seems straightforward, but maybe I missed something:
>>> - for test code we use a fake NUMS point, so we can generate "proof" 
>>> without a quantum computer
>>> - a p2p message floods the proof
>>> - nodes ignore the message if they already have *any* valid proof
>>> - verifying p2p proof candidates might need some rate limiting, but it's 
>>> as cheap as verifying a transaction signature
>>> - mining code includes the proof in a coinbase op_return, until the 
>>> freeze activates
>>> - with stratum v2 (and ipc mining clients in general this works out of 
>>> the box, a small change is needed for getblocktemplate clients)
>>> - since the proof is not in the header, we can't use the normal bip9 
>>> style header scan to see if the rule activated. Instead the prototype 
>>> stores it in a file along with a merkle inclusion proof, which is read when 
>>> the node restarts.
>>>
>>> With this mechanism it doesn't really need to be in the coinbase 
>>> transaction, but that does seem more convenient and miners can censor it 
>>> anyway.
>>>
>>> - Sjors
>>>
>>> -- 
>>> You received this message because you are subscribed to a topic in the 
>>> Google Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this topic, visit 
>>> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
>>> To unsubscribe from this group and all its topics, send an email to 
>>> bitcoindev+...@googlegroups.com.
>>> To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com
>>> .
>>>
>> -- 
>
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/fd947d7c-86fd-407c-98aa-0a63b8be28fan%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 31037 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-08-13  3:28  0%             ` waxwing/ AdamISZ
@ 2026-08-14 18:33  0%               ` 'conduition' via Bitcoin Development Mailing List
  2026-08-15 14:49  0%                 ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-08-14 18:33 UTC (permalink / raw)
  To: waxwing/ AdamISZ; +Cc: Bitcoin Development Mailing List


[-- Attachment #1.1.1: Type: text/plain, Size: 18178 bytes --]

> An obvious question to raise: would we consider tripwiring a 192 bit group break of a similar type (NUMS)? I find that ... plausible?


A 192-bit curve i think should be reasonable as a canary, but consider this: If someone already has a QC that breaks 192-bit ECC, how long until they build one which breaks 256-bit ECC? A day, a week, a year? No way of knowing. If the delay is too long, users may see the canary as a false-positive, and migrate back to vulnerable addresses, and they might even be right. 192-bit canaries are vulnerable to classical attack with work approximately 2^96. We should bear in mind the possibility that such a canary could be activated possibly very early, well before Q-day, possibly even in the absence of any quantum computers.

Ideally we want a short gap between "192-bit is broken" and "256-bit is broken", but not so short as to make the 192-bit canary effectively fungible with a 256-bit canary (because then it's less likely to be activated before theft occurs).


> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on SHA2 preimage resistance, but: isn't the real point that we're relying on SHA-2 not being a naughty function so that you couldn't find G = a * B and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of course, as was likely back then!). I have no idea what precise name you give to that property. OK, this is a ridiculous thing to discuss, perhaps, given when SHA2 and secp256k1 were standardized :) And given the encoding choices for our BIP341 NUMS (iirc the same as for Elements back in the day? using uncompressed encoding?) were able to be counted on the fingers of the hand which the sleeve does not cover :)


Anyone can find `G = a * B`. Just generate a key and invert your secret key.

`P = a * G`
G = a**-1 * P

The hard part is then finding some b such that `b*G = SHA256(G).`

---------

If we reflect on the requirement that `G` is fixed, we see `SHA256(G)` is also fixed as a pseudorandom challenge point. The reason for using SHA256 instead of, say, picking an arbitary point by committee or using digits of pi or some other trickery, is that hash outputs are supposed to be random and so `SHA256(G)` is (assumably) a random ECDLP challenge. This matches the classical definition of ECDLP more tightly: Given an arbitrary point `P`, find `p` such that `P = p * G`. The assumption is that if an attacker can factor an honestly-sampled challenge point, they can factor any point. SHA256 is just a stand-in for the "honestly-sampled" part.
However, the following two tasks are actually very different:


1.  Given G, find scalar `a` such that `a*G = lift_x(SHA256(G))`.
2.  Given G, find scalar `a` and message `m` such that `a*G = lift_x(SHA256(m))`.


In the case of task 1, if we assume SHA256 output is random, then this is more tightly equivalent to ECDLP, because the point we're trying to factor is a fixed target, as is the one sampled honestly by the ECDLP security game.

In the case of task 2, the attacker can sample arbitrary messages to create multiple target points, and the attacker wins if they succeed in factoring any of them. The attacker can attack all those target points concurrently if they want, and they get a speedup from doing so.

So I believe it is worth disambiguating canaries between the two cases, because they are different security notions. The first (1) I would call single-target ECDLP (ST-ECDLP), and the second (2) I would call multi-target ECDLP (MT-ECDLP).

It's pretty clear that MT-ECDLP is easier to break, because attackers can make progress against more than one target concurrently, and breaking any one is sufficient to win the security game.

For example, say I sample 2 different messages `m1` and `m2`, and compute ECDLP target points `T1 = lift_x(SHA256(m1))` and `T2 = lift_x(SHA256(m2))`. Then if I sample a random scalar `r` and compute `R = r*G`, I have two potential chances of success: `R == T1` OR `R == T2`. I can scale up this advantage by generating more targets, `T3`, `T4`, ... and so on.

MT-ECDLP also admits a more efficient basic unit of computation in brute force attacks (including Grover) by using hashes instead of EC point multiplications. If I instead start by picking scalar `t` and fix the target point `T = t*G`, then I can run a brute-force preimage search on SHA256 until I find `m` such that `SHA256(m) == x(T)`. This can also be scaled up using a multi-target attack [1].

With ST-ECDLP, we have only a single fixed message `m = G`, and so the attacker can't use those multi-target cheat codes. They can parallelize, use pollard-rho or Shor or other algorithms, but they have only a single target point that they must break to win the game.

The method Pieter suggested using for the canary construction is equivalent to single-target ECDLP.

I've heard others (e.g. Tadge in this thread) previously suggest using a script like `OP_SHA256 OP_CHECKSIG` as a canary, where any spend of such a script would trigger the canary. This would be multi-target ECDLP.

I'm not sure which is better. 


-   ST-ECDLP is less likely to be triggered early or mistakenly, and is more tightly equivalent to ECDLP. 

-   MT-ECDLP is more reflective of how real-world attackers behave on Bitcoin (e.g. with thousands-to-millions of public keys available to attack in parallel, and breaking even one is considered unacceptable).



I'm slightly leanings towards a construction like Pieter's, featuring ST-ECDLP, just because I'm not sure what other tricks could be used to potentially trigger MT-ECDLP classically or quantumly.

We could also engineer a compromise between the two, where we limit the number of targets. For example, define the game like this:


Given `G`, find scalar `a` and 32-bit integer `i` such that `a*G = lift_x(SHA256(G || i))`.


Then the adversary can only attack against at most 2^32 unique target points, and those targets are fixed forever, for any adversary. This is an easier problem than ST-ECDLP, but harder than MT-ECDLP. Maybe call it limited multi-target ECDLP (LMT-ECDLP)?


regards,
conduition


[1]: First, generate a bunch of target points. Sample scalar `t` and compute `T0 = t * G`, T1 = T0 + T0, and T2 = T1 + T1, and T3 = T2 + T2, etc. Why double each point? point doubling is cheaper than addition or multiplication, and still covers the whole curve. Then we run a multi-target SHA256 preimage search over all targets [x(T0), x(T1), x(T2), x(T3), ...]. If we have n targets and curve order N, then each message hash has an `n/N` chance of success. If we find a valid message `m`, such that `SHA256(m) == x(R_i)` for some target index `i`, then we have found `T_i = t * 2**i * G = lift_x(SHA256(m))`.





On Thursday, August 13th, 2026 at 2:02 AM, waxwing/ AdamISZ <ekaggata@gmail.com> wrote:

> This tripwire idea is interesting. Basically "canary in consensus".
> I agree it's valuable. In the scenario of adversarial actor(s) gaining access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm slightly worried that the general userbase will not notice that point, instead thinking it's a solid defense when it ... depends.
> 

> In the scenario of at least some whitehats, we get wires tripped, or canaries singing. Having it in consensus is nice. The blockchain then does its job of being an unambiguous signal and we can have all the arguments well ahead of time. [1]
> 

> On the other hand, we traditionally design such systems adversarially, right, so you could argue that an overfocus on this might be suboptimal - it might be better to do other things.
> 

> (Similar comment applies to the 'smaller group canary' - definitely nothing wrong with it, but it is not in itself a defence unless we strongly believe whitehats, and *active* whitehats at that, are keeping up). An obvious question to raise: would we consider tripwiring a 192 bit group break of a similar type (NUMS)? I find that ... plausible?
> > The BIP341 NUMS point (which I suggest using in this context) is the point whose X coordinate is the SHA256 hash of the generator point G. This guarantees that the NUMS point cannot predate G (if it did, it would be possible in theory that secp256k1's designers actually chose G in function of what we call that NUMS point, giving it a DLP known to them).
> 

> w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on SHA2 preimage resistance, but: isn't the real point that we're relying on SHA-2 not being a naughty function so that you couldn't find G = a * B and SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of course, as was likely back then!). I have no idea what precise name you give to that property. OK, this is a ridiculous thing to discuss, perhaps, given when SHA2 and secp256k1 were standardized :) And given the encoding choices for our BIP341 NUMS (iirc the same as for Elements back in the day? using uncompressed encoding?) were able to be counted on the fingers of the hand which the sleeve does not cover :)
> 

> [1] I take Antoine's point that making it consensus means the miners are involved and there is a non-trivial collusion risk if the stakes are high, but I can't see how this scenario is *worse* than no tripwire?
> 

> On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:
> 

> > Hi Pieter,
> > 

> > Thanks for the observations.
> > 

> > When I was saying there is a problem with the game theory,
> > it's that strikingly, any activation of the tripwire logic
> > would rely on a "flag" transaction being mined in the chain
> > for the network nodes starting to enforce at the block N or
> > N+1 or whatever the EC disabling threshold.
> > 

> > Any "flag" transaction can be itself re-orged out of the chain
> > to purely disable the effects of the EC disabling threshold,
> > therefore make it null and void as an effect. One might see
> > it as a competing race between a group of "sunsetting" users
> > and a (majority) coalition of miners in coordination with a
> > CRQC adversary, where the latter have an interest and the
> > hashrate capabilities to do a tx-withold [0].
> > 

> > In pure terms of satoshi fee denominated calculus, empirically
> > global miners have won an average of $20 B yearly. If we only
> > consider that P2PK are going to be frozen by the tripwire effect,
> > as for most of them it might be assumed they will never move to
> > a safer format, we talk already about 1.7 M of coins or as of
> > today valuation $107 B (the information is on the chain and can
> > be verified).
> > 

> > That's $107B can "burn" in revenue or income that a CRQC-enabled
> > miners coalition to constantly reorg-out the "flag" tx out of the
> > chain. In other terms, something like 5 years of income, and I
> > kindly do not count all the loss coins that are likely to amount
> > to a far bigger "tripwire" neutralization budget.
> > 

> > In the name of what a majority of miners will gracefully let on
> > the table an opportunity of massive income ?
> > 

> > Leveraging Shor the exploitation might be even done anonymously
> > as the mining process is done. Not even certainty, by who the
> > EC-protected coins could be covertly exfiltrated.
> > 

> > That's the most striking problem when you think about the math
> > with any "tripwire" approach, or even an "hourglass" one relying
> > on a "flag" transaction [1]. I'm ruling out "checkpoints" and
> > any other trust-the-dev approach, as that's even worst [2].
> > 

> > As you're introducing post is resounding, what the miners
> > are saying now, there are no guarantees on how they would use
> > their hashrate down the road, potentially 10 or 20 years from now.
> > 

> > Beyond, and to answer back your point, I still think you can
> > manage an escape hatch of the "tripwire" effect, it's all depends
> > how the script tripwire logic is implemented, but if you have
> > two OP_SUCCESS of different kinds before your EC CHECKSIG, you
> > can always have a "soft-fork" after the "tripwire" to return
> > true on the stack, with an EC or hashlock as a success (I agree
> > using undefined op_success in a script is not safe at all) [3].
> > 

> > Best,
> > Antoine
> > OTS hash: 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
> > 

> > [0] See naumenkog's https://www.bitmex.com/blog/txwithhold-smart-contracts
> > [1] This is sad, as the "hourglass" depending how the parameters are chosen
> > was a more acceptable trade-off than pure sunsetting.
> > [2] Given the amounts at stake to sunset, as a group of developers you
> > would just paint yourself a target, there are more even funds at stake
> > that Satoshi herself / himself is assumed to have.
> > [3] There is no security proof in BIP341 on the unforgeability of the
> > NUMS point, if it binds in the ROM or whatever.
> > 

> > 

> > Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a écrit :
> > 

> > > 

> > > 

> > > On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
> > > 

> > > [...]
> > > 

> > > > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a
> > > > specific marker). This is smaller than a full transaction input +
> > > > signature.
> > > >
> > > > * Similarly, but publishing in the coinbase, and requiring relay using
> > > > a separate message. Less places a node needs to check, but I'm
> > > > concerned about the difficulty of testing infrastructure that relay of
> > > > such a message works
> > > 

> > > [...]
> > > 

> > > >
> > > > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns
> > > > <a...@erisian.com.au> wrote:
> > > >
> > > >> A slight variant of this approach would be to have a 128 byte value "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a BIP340 signature of m by P. That would allow the victim of post-quantum theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in addition to someone who has direct access to a CRQC.
> > > >
> > > > Indeed, I had considered something similar, but see above for why I'm
> > > > not convinced supporting non-cooperative CRQCs is that useful.
> > > >
> > > > Also, in my view the tripwire isn't really a security feature on itself
> > > > (it's not expected to trigger...), but more something that sets
> > > > expectations around the output type for prospective users.
> > > >
> > > > In that sense, the question is really whether supporting
> > > > non-cooperative CRQCs helps set that expectation more than only
> > > > cooperative ones, which are definitely easier to support.
> > > >
> > > >> I think it could make sense to have the tripwire be included in the block via the coinbase witness commitment output, rather than having it be locked to a transaction, so you only having to check the coinbase for the magic rather than every transaction. That would require a separate P2P message to relay the necessary ECDL-break proof to miners, and would probably need stratumv2 or a getblocktemplate update in order for the node to be able to tell pools to actually include that info in the coinbase.
> > > >
> > > > I worry this is untestable, really. You'd need things like
> > > > fake-tripwires to be supported through the same message which don't
> > > > require an ECDLP break, and still propagate. And then that needs DoS
> > > > protection measures,
> > > 

> > > I whipped something up last weekend:
> > > https://github.com/Sjors/bitcoin/pull/121
> > > 

> > > It seems straightforward, but maybe I missed something:
> > > - for test code we use a fake NUMS point, so we can generate "proof" without a quantum computer
> > > - a p2p message floods the proof
> > > - nodes ignore the message if they already have *any* valid proof
> > > - verifying p2p proof candidates might need some rate limiting, but it's as cheap as verifying a transaction signature
> > > - mining code includes the proof in a coinbase op_return, until the freeze activates
> > > - with stratum v2 (and ipc mining clients in general this works out of the box, a small change is needed for getblocktemplate clients)
> > > - since the proof is not in the header, we can't use the normal bip9 style header scan to see if the rule activated. Instead the prototype stores it in a file along with a merkle inclusion proof, which is read when the node restarts.
> > > 

> > > With this mechanism it doesn't really need to be in the coinbase transaction, but that does seem more convenient and miners can censor it anyway.
> > > 

> > > - Sjors
> > 

> > > --
> > > You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> > > To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
> > > To unsubscribe from this group and all its topics, send an email to bitcoindev+...@googlegroups.com.
> > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com.
> 

> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/wftCzgJs2k7H-4R22EOqdOhhXYdFPFhSZhsYHvlzejpJ5emoze0ACgL3rrYiTP-X5QQMpThdRW1cO7mr9IQvs2C4MHxSD2eu_gPFGv-yZs8%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 26286 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Stale Tip Relay
  2026-08-11 13:51  0% ` Edil Guimarães de Medeiros
@ 2026-08-13 18:53  0%   ` Ram
  0 siblings, 0 replies; 200+ results
From: Ram @ 2026-08-13 18:53 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 7922 bytes --]

Hi Edil,

Appreciate taking the time to review the BIP.

> But I'm not so sure about how that improves the main purpose of the 
network. 
Quite the contrary, seems to open more DoS and fingerprinting vectors.

For DoS, the concern is whether a small message can cause disproportionate 
processing, disk usage, or outgoing traffic. Merely sending invalid data is
not a new DoS vector; peers already have many ways to do that. It's not 
possible to prevent all of them.

Currently, I don’t see any resource-exhaustion or bandwidth amplification 
vector
introduced by this proposal. Processing is bounded by the branch-length,
recency and retained-tip limits. Nodes are not required to download stale 
block
data. Nodes that choose to collect it use the normal block-download 
mechanisms
and resource limits. Implementations may also apply stricter limits, 
rate-limit
abusive peers, or disable the feature.
Also on mainnet, producing stale headers requires real proof of work 
comparable
to the active chain.
  
On fingerprinting - supporting staletip does add another observable 
characteristic.
This is a trade-off the node makes when enabling the feature and is common 
to 
optional P2P features generally. Nodes for which this trade-off is 
unacceptable
can disable staletip relay.

> About the design, it's not clear to me how that could work in face of more
than one competing chain.

Each staletip message describes one linear branch. Assuming A1-A2-A3-A4 is 
the 
active chain, the two competing branches would be announced separately:

staletip(fork_point=A2, headers=[B3, B4])
staletip(fork_point=A3, headers=[C4])

The protocol announces competing branches in separate messages. 
I’ve clarified this in the BIP draft. Thanks for pointing it out :)

Thanks again for reviewing. Hope this addresses your concerns.
Feel free to reach out or leave additional comments.

Cheers,
Ram

On Tuesday, August 11, 2026 at 7:04:41 AM UTC-7 Edil Guimarães de Medeiros 
wrote:

> There's an ongoing effort to document mainnet stale blocks: 
> https://github.com/bitcoin-data/stale-blocks
> As one can imagine, since there is currently no way to recover them from 
> the network itself, this
> requires constantly monitoring several long running nodes in the hope to 
> get them. From a monitoring
> and research perspective, this proposal could be useful.
>
> But I'm not so sure about how that improves the main purpose of the 
> network. Quite the contrary, seems
> to open more DoS and fingerprinting vectors.
>
> About the design, it's not clear to me how that could work in face of more 
> than one competing chain. For
> instance, suppose I have:
>
>             /- C4
> A1 - A2 - A3 - A4
>        \- B3 - B4
>
> It's not clear to me how the proposal deals with communicating this, which 
> is quite common in signet and 
> the testnets, since each message is designed to relay a single competing 
> branch (e.g. B3-B4 above).
>
> Left more detailed and editorial comments in the bip repository PR.
>
> Cheers.
> Edil
>
> Em qua., 29 de jul. de 2026 às 14:28, Ram <pseudo...@gmail.com> escreveu:
>
>> Hello list,
>>
>> This proposal introduces `staletip`, an opt-in P2P message for relaying 
>> recent
>> stale tips between peers. Building on AJ Towns' initial work, w0xlt and I 
>> have
>> developed the proposal further and built a proof-of-concept 
>> implementation.
>>
>> Draft BIP:
>>
>> https://github.com/pseudoramdom/bips/blob/staletip-bip-draft/bip-staletip.md
>>
>> Proof-of-concept:
>> https://github.com/w0xlt/bitcoin/tree/staletip-v4
>>
>> Today, once a block loses a race and goes stale, it stops propagating – 
>> compact
>> block relay and FIBRE aggressively relay the winning chain, while stale 
>> branches fall away. That's great for fast propagation, but it makes the 
>> stale
>> rate difficult to observe. Even dedicated monitors [0] have only partial 
>> views:
>> a stale block seen by one monitor may never reach another.
>>
>> The stale rate is a useful network-health signal because it is closely 
>> related
>> to block propagation delay. The longer it takes miners to learn about a 
>> newly
>> found block, the greater the chance that another valid block will be 
>> found at
>> the same height, creating a race in which one of the blocks becomes stale 
>> [1].
>> An elevated stale rate could also expose validation or relay bottlenecks.
>> For example, the May 2023 "inv-to-send" bug degraded block propagation and
>> coincided with a roughly 10x increase in the observed stale rate [2].
>>
>> A stale block does not by itself identify its cause, but changes in the
>> rate or shape of stale branches can provide a reason to investigate:
>>
>>   - a network partition – when a partition heals, blocks mined on the
>>     losing side become stale, potentially producing several related stale
>>     blocks at once.
>>   - adversarial mining strategies such as selfish mining [3] – these
>>     can cause honest miners' blocks to become stale.
>>
>> The proposal fills this observability gap with an opt-in P2P message 
>> called
>> `staletip`, allowing nodes to proactively announce recent stale tips to 
>> peers.
>>
>> An added benefit is potentially faster reorg handling: if a node already 
>> knows
>> the relevant headers, and perhaps has the block data, it has less work to 
>> do if
>> that branch later becomes active.
>>
>> At protocol level, nodes advertise support using BIP 434 `feature` 
>> message [4], 
>> and `staletip` messages are only sent to peers that advertised support. 
>> Each
>> announcement contains the fork point, a sequence of compressed headers, 
>> and a
>> flag indicating whether the sender can serve the stale tip block. 
>>
>> The proposed default relay policy:
>>   - relays only tips within 1000 blocks (about seven days) of the active 
>> tip, 
>>     keeping announcements recent and stale-tip spam costly on mainnet.
>>   - limits branches to 20 compressed headers, covering short-term reorgs
>>     without tracking persistent chain splits and keeps each announcement 
>> under
>>     1 kB.
>>   - keeps at most 10 recent tips in the relay cache, so announcing the 
>> full
>>     cache to a new peer remains under 10 kB, excluding any blocks 
>> requested.
>>
>> The BIP text has more background and the full message format. Comments are
>> welcome.
>>
>> Cheers,
>> Ram (pseudoramdom <https://github.com/pseudoramdom>)
>> & 
>> w0xlt <https://github.com/w0xlt>
>>
>> [0] https://github.com/bitcoin-data/stale-blocks
>> [1] 
>> https://delvingbitcoin.org/t/propagation-delay-and-mining-centralization-modeling-stale-rates/2110
>> [2] https://b10c.me/observations/15-inv-to-send-queue/
>> [3] https://arxiv.org/abs/1311.0243
>> [4] https://github.com/bitcoin/bips/blob/master/bip-0434.md
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>
>
> -- 
> Edil
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/7bbef0df-dbb5-48d1-9671-b0cec91fcbb0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 12761 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-07-05 21:55  0%           ` Antoine Riard
@ 2026-08-13  3:28  0%             ` waxwing/ AdamISZ
  2026-08-14 18:33  0%               ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2026-08-13  3:28 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10568 bytes --]

This tripwire idea is interesting. Basically "canary in consensus".

I agree it's valuable. In the scenario of adversarial actor(s) gaining 
access to CQRC first, i.e. no whitehats, only blackhats, obviously nothing 
to discuss; touching a NUMS ECDL is the last thing they'll do. So I'm 
slightly worried that the general userbase will not notice that point, 
instead thinking it's a solid defense when it ... depends.

In the scenario of at least some whitehats, we get wires tripped, or 
canaries singing. Having it in consensus is nice. The blockchain then does 
its job of being an unambiguous signal and we can have all the arguments 
well ahead of time. [1]

On the other hand, we traditionally design such systems adversarially, 
right, so you could argue that an overfocus on this might be suboptimal - 
it might be better to do other things.

(Similar comment applies to the 'smaller group canary' - definitely nothing 
wrong with it, but it is not in itself a defence unless we strongly believe 
whitehats, and *active* whitehats at that, are keeping up). An obvious 
question to raise: would we consider tripwiring a 192 bit group break of a 
similar type (NUMS)? I find that ... plausible?

> The BIP341 NUMS point (which I suggest using in this context) is the 
point whose X coordinate is the SHA256 hash of the generator point G. This 
guarantees that the NUMS point cannot predate G (if it did, it would be 
possible in theory that secp256k1's designers actually chose G in function 
of what we call that NUMS point, giving it a DLP known to them).

w.r.t. 'This guarantees that the NUMS point cannot predate G' yes based on 
SHA2 preimage resistance, but: isn't the real point that we're relying on 
SHA-2 not being a naughty function so that you couldn't find G = a * B and 
SHA2(G) = b*B for some base B in some feasible computation (sans CQRC of 
course, as was likely back then!). I have no idea what precise name you 
give to that property. OK, this is a ridiculous thing to discuss, perhaps, 
given when SHA2 and secp256k1 were standardized :) And given the encoding 
choices for our BIP341 NUMS (iirc the same as for Elements back in the day? 
using uncompressed encoding?) were able to be counted on the fingers of the 
hand which the sleeve does not cover :)

[1] I take Antoine's point that making it consensus means the miners are 
involved and there is a non-trivial collusion risk if the stakes are high, 
but I can't see how this scenario is *worse* than no tripwire?

On Sunday, July 5, 2026 at 4:07:33 PM UTC-6 Antoine Riard wrote:

> Hi Pieter,
>
> Thanks for the observations.
>
> When I was saying there is a problem with the game theory,
> it's that strikingly, any activation of the tripwire logic
> would rely on a "flag" transaction being mined in the chain
> for the network nodes starting to enforce at the block N or
> N+1 or whatever the EC disabling threshold.
>
> Any "flag" transaction can be itself re-orged out of the chain
> to purely disable the effects of the EC disabling threshold,
> therefore make it null and void as an effect. One might see
> it as a competing race between a group of "sunsetting" users
> and a (majority) coalition of miners in coordination with a
> CRQC adversary, where the latter have an interest and the
> hashrate capabilities to do a tx-withold [0].
>
> In pure terms of satoshi fee denominated calculus, empirically
> global miners have won an average of $20 B yearly. If we only
> consider that P2PK are going to be frozen by the tripwire effect,
> as for most of them it might be assumed they will never move to
> a safer format, we talk already about 1.7 M of coins or as of
> today valuation $107 B (the information is on the chain and can
> be verified).
>
> That's $107B can "burn" in revenue or income that a CRQC-enabled
> miners coalition to constantly reorg-out the "flag" tx out of the
> chain. In other terms, something like 5 years of income, and I
> kindly do not count all the loss coins that are likely to amount
> to a far bigger "tripwire" neutralization budget.
>
> In the name of what a majority of miners will gracefully let on
> the table an opportunity of massive income ?
>
> Leveraging Shor the exploitation might be even done anonymously
> as the mining process is done. Not even certainty, by who the
> EC-protected coins could be covertly exfiltrated.
>
> That's the most striking problem when you think about the math
> with any "tripwire" approach, or even an "hourglass" one relying
> on a "flag" transaction [1]. I'm ruling out "checkpoints" and
> any other trust-the-dev approach, as that's even worst [2].
>
> As you're introducing post is resounding, what the miners
> are saying now, there are no guarantees on how they would use
> their hashrate down the road, potentially 10 or 20 years from now.
>
> Beyond, and to answer back your point, I still think you can
> manage an escape hatch of the "tripwire" effect, it's all depends
> how the script tripwire logic is implemented, but if you have
> two OP_SUCCESS of different kinds before your EC CHECKSIG, you
> can always have a "soft-fork" after the "tripwire" to return 
> true on the stack, with an EC or hashlock as a success (I agree
> using undefined op_success in a script is not safe at all) [3].
>  
> Best,
> Antoine
> OTS hash: 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66
>
> [0] See naumenkog's https://www.bitmex.com/blog/txwithhold-smart-contracts
> [1] This is sad, as the "hourglass" depending how the parameters are chosen
> was a more acceptable trade-off than pure sunsetting.
> [2] Given the amounts at stake to sunset, as a group of developers you
> would just paint yourself a target, there are more even funds at stake
> that Satoshi herself / himself is assumed to have.
> [3] There is no security proof in BIP341 on the unforgeability of the
> NUMS point, if it binds in the ROM or whatever.
>
> Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sj...@sprovoost.nl> a 
> écrit :
>
>>
>>
>> On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
>>
>> [...]
>>
>> > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a 
>> > specific marker). This is smaller than a full transaction input + 
>> > signature.
>> >
>> > * Similarly, but publishing in the coinbase, and requiring relay using 
>> > a separate message. Less places a node needs to check, but I'm 
>> > concerned about the difficulty of testing infrastructure that relay of 
>> > such a message works
>>
>> [...]
>>
>> >
>> > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns 
>> > <a...@erisian.com.au> wrote:
>> >
>> >> A slight variant of this approach would be to have a 128 byte value 
>> "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a 
>> BIP340 signature of m by P. That would allow the victim of post-quantum 
>> theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in 
>> addition to someone who has direct access to a CRQC.
>> >
>> > Indeed, I had considered something similar, but see above for why I'm 
>> > not convinced supporting non-cooperative CRQCs is that useful.
>> >
>> > Also, in my view the tripwire isn't really a security feature on itself 
>> > (it's not expected to trigger...), but more something that sets 
>> > expectations around the output type for prospective users.
>> >
>> > In that sense, the question is really whether supporting 
>> > non-cooperative CRQCs helps set that expectation more than only 
>> > cooperative ones, which are definitely easier to support.
>> >
>> >> I think it could make sense to have the tripwire be included in the 
>> block via the coinbase witness commitment output, rather than having it be 
>> locked to a transaction, so you only having to check the coinbase for the 
>> magic rather than every transaction. That would require a separate P2P 
>> message to relay the necessary ECDL-break proof to miners, and would 
>> probably need stratumv2 or a getblocktemplate update in order for the node 
>> to be able to tell pools to actually include that info in the coinbase.
>> >
>> > I worry this is untestable, really. You'd need things like 
>> > fake-tripwires to be supported through the same message which don't 
>> > require an ECDLP break, and still propagate. And then that needs DoS 
>> > protection measures, 
>>
>> I whipped something up last weekend:
>> https://github.com/Sjors/bitcoin/pull/121
>>
>> It seems straightforward, but maybe I missed something:
>> - for test code we use a fake NUMS point, so we can generate "proof" 
>> without a quantum computer
>> - a p2p message floods the proof
>> - nodes ignore the message if they already have *any* valid proof
>> - verifying p2p proof candidates might need some rate limiting, but it's 
>> as cheap as verifying a transaction signature
>> - mining code includes the proof in a coinbase op_return, until the 
>> freeze activates
>>   - with stratum v2 (and ipc mining clients in general this works out of 
>> the box, a small change is needed for getblocktemplate clients)
>> - since the proof is not in the header, we can't use the normal bip9 
>> style header scan to see if the rule activated. Instead the prototype 
>> stores it in a file along with a merkle inclusion proof, which is read when 
>> the node restarts.
>>
>> With this mechanism it doesn't really need to be in the coinbase 
>> transaction, but that does seem more convenient and miners can censor it 
>> anyway.
>>
>> - Sjors
>>
>> -- 
>> You received this message because you are subscribed to a topic in the 
>> Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this topic, visit 
>> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
>> To unsubscribe from this group and all its topics, send an email to 
>> bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f6d78499-d551-45ea-89b1-2b9cbd52f5can%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 13364 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Stale Tip Relay
  2026-07-29 17:21  1% [bitcoindev] [BIP Proposal] Stale Tip Relay Ram
@ 2026-08-11 13:51  0% ` Edil Guimarães de Medeiros
  2026-08-13 18:53  0%   ` Ram
  2026-11-05 23:19  0% ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  1 sibling, 1 reply; 200+ results
From: Edil Guimarães de Medeiros @ 2026-08-11 13:51 UTC (permalink / raw)
  Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 5700 bytes --]

There's an ongoing effort to document mainnet stale blocks:
https://github.com/bitcoin-data/stale-blocks
As one can imagine, since there is currently no way to recover them from
the network itself, this
requires constantly monitoring several long running nodes in the hope to
get them. From a monitoring
and research perspective, this proposal could be useful.

But I'm not so sure about how that improves the main purpose of the
network. Quite the contrary, seems
to open more DoS and fingerprinting vectors.

About the design, it's not clear to me how that could work in face of more
than one competing chain. For
instance, suppose I have:

            /- C4
A1 - A2 - A3 - A4
       \- B3 - B4

It's not clear to me how the proposal deals with communicating this, which
is quite common in signet and
the testnets, since each message is designed to relay a single competing
branch (e.g. B3-B4 above).

Left more detailed and editorial comments in the bip repository PR.

Cheers.
Edil

Em qua., 29 de jul. de 2026 às 14:28, Ram <pseudoramdom8@gmail.com>
escreveu:

> Hello list,
>
> This proposal introduces `staletip`, an opt-in P2P message for relaying
> recent
> stale tips between peers. Building on AJ Towns' initial work, w0xlt and I
> have
> developed the proposal further and built a proof-of-concept implementation.
>
> Draft BIP:
>
> https://github.com/pseudoramdom/bips/blob/staletip-bip-draft/bip-staletip.md
>
> Proof-of-concept:
> https://github.com/w0xlt/bitcoin/tree/staletip-v4
>
> Today, once a block loses a race and goes stale, it stops propagating –
> compact
> block relay and FIBRE aggressively relay the winning chain, while stale
> branches fall away. That's great for fast propagation, but it makes the
> stale
> rate difficult to observe. Even dedicated monitors [0] have only partial
> views:
> a stale block seen by one monitor may never reach another.
>
> The stale rate is a useful network-health signal because it is closely
> related
> to block propagation delay. The longer it takes miners to learn about a
> newly
> found block, the greater the chance that another valid block will be found
> at
> the same height, creating a race in which one of the blocks becomes stale
> [1].
> An elevated stale rate could also expose validation or relay bottlenecks.
> For example, the May 2023 "inv-to-send" bug degraded block propagation and
> coincided with a roughly 10x increase in the observed stale rate [2].
>
> A stale block does not by itself identify its cause, but changes in the
> rate or shape of stale branches can provide a reason to investigate:
>
>   - a network partition – when a partition heals, blocks mined on the
>     losing side become stale, potentially producing several related stale
>     blocks at once.
>   - adversarial mining strategies such as selfish mining [3] – these
>     can cause honest miners' blocks to become stale.
>
> The proposal fills this observability gap with an opt-in P2P message called
> `staletip`, allowing nodes to proactively announce recent stale tips to
> peers.
>
> An added benefit is potentially faster reorg handling: if a node already
> knows
> the relevant headers, and perhaps has the block data, it has less work to
> do if
> that branch later becomes active.
>
> At protocol level, nodes advertise support using BIP 434 `feature` message
> [4],
> and `staletip` messages are only sent to peers that advertised support.
> Each
> announcement contains the fork point, a sequence of compressed headers,
> and a
> flag indicating whether the sender can serve the stale tip block.
>
> The proposed default relay policy:
>   - relays only tips within 1000 blocks (about seven days) of the active
> tip,
>     keeping announcements recent and stale-tip spam costly on mainnet.
>   - limits branches to 20 compressed headers, covering short-term reorgs
>     without tracking persistent chain splits and keeps each announcement
> under
>     1 kB.
>   - keeps at most 10 recent tips in the relay cache, so announcing the full
>     cache to a new peer remains under 10 kB, excluding any blocks
> requested.
>
> The BIP text has more background and the full message format. Comments are
> welcome.
>
> Cheers,
> Ram (pseudoramdom <https://github.com/pseudoramdom>)
> &
> w0xlt <https://github.com/w0xlt>
>
> [0] https://github.com/bitcoin-data/stale-blocks
> [1]
> https://delvingbitcoin.org/t/propagation-delay-and-mining-centralization-modeling-stale-rates/2110
> [2] https://b10c.me/observations/15-inv-to-send-queue/
> [3] https://arxiv.org/abs/1311.0243
> [4] https://github.com/bitcoin/bips/blob/master/bip-0434.md
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>


-- 
Edil

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CANJiN3%2BKetUeNjjeRgd7xgCSF%2BvAakDtH7ysPC%2Bh4DqtHJPsLA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 7701 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Motion to remove Luke Dashjr from BIP Editors
  @ 2026-08-10  1:40  1%     ` Antoine Riard
  0 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-08-10  1:40 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10148 bytes --]

 

Hello

I think it's the best move for Luke to remove himself from the BIP
editorship, even if it's temporary. If he's not blocked from the
github, nothing prevent him to contribute to the review work of
the BIPs in a good spirit in the future and regain his BIP editor
role.

I have very been little been involved in all this OP_RETURN mess,
whatever side one has taken in this discussion, so I hope and aim
to hold an objective tone, in what I'm saying there after.

I do have a very mixed opinion of the Luke's persona himself. On
one hand, I respect the years of hard work and dedication invested
in the bitcoin project. He has been technically contributing more
longer than I had. On the other hand, for someone who is spending
his time questioning the morality of his technical peers, I always
been a bit cold about his professional ethics, given how he did
behave repeatedly few times, especially with what did happen with
coredev atlanta '22.

As a former coreDev co-organizer, I very coldly appreciated that he
went to the FBI to accuse coredev meeting participants to have been
involved in any manner with the loss of his coins at the end of '22
and put the organizers in a situation where they legally had to
reveal the names of *all* the participants in the meeting in an
*indiscriminate* fashion.

Rat'ing out your bitcoin core devs colleagues to a domestic intel
agency to have a case build on all of them is very not okay, and I
would say this whatever the jurisdiction that would be involved.
Beyond, once the FBI subpoena was public, I reached out privately
to Luke in April '24 to have more clarifications on this affair,
as a former coredev co-organizer.

Neither Luke, neither the FBI went back to me and as far as I know
no participant was ever worried or more questioned about this Luke
claim, so it tells you a lot about the seriousness of the ungrounded
accusations that were made on the coredev participants as an indiscriminate
group. If you have ever a problem with someone in this space, keep it
contained and stay professional. There is a sense of measure and
balance to have.

On the removal of Luke, if it has been to be done by using the
github administrative permission, as far as I know there is no
mention in BIP1 or BIP2 or BIP3 about what is a formal process
to remove someone from a BIP editor role, against her or his consent.

Short of that, in my opinion if there is a wish to make the removal
happening on bright lines, I would suggest to follow the following
formalities:
- in the lack of a clear organ deciding the removal of the BIP editor,
  have all existent BIP editors giving their public says on this
  and their own motivations
- the BIP process is not a democracy, though everyone that has ever
  contributed to the repository and who is still broadly active in 
  bitcoin has a material interest in the resolution of this issue.
  if we check the gitlog there are like ~531 individual contributors
  to the git tree. if we had people who are credited or thanks in the
  BIPs documents we might have a rough 100 more people. it would be
  legitimate to have the ones who have contributed, at least significantly
  or meaningfully to have as say, without putting the process in a
  situation of functional paralysis.
- give a chance to Luke or someone taking his defense to answer point
  by point in public what are the motivations justifying his removal
  of his BIP editor role, based on evidences if needed. giving him at least 
2
  weeks or even a full month would legitimate. he can always be temporarily
  removed until there is a legit justification that has been answered from 
his side.
- Murch was mentioning Luke's conflict of interest as a motivation to
  remove him from his BIP editor. nothing says in BIP3 editor's
  responsibilities that they should stay free from "conflict of interest".
  however the very goal the BIP process is to have implementation inter-
  compatibility therefore a shared set of logical rules executed the same
  by all the implementation to have a common network. it would appear to
  me that it's in the "spirit" of the BIP process that BIP editors have
  a duty of neutrality with regards to how they fulfill their editors role

On this last point, I would strongly suggest to amend the BIP3 document
to underscore that editors have an explicit duty of neutrality, and that
under this duty they should not engage in the promotion of contentious
fork, even under one of their other hats (be it the maintainer of a 
full-node
implementation or whatever). Otherwise it's lacking the good faith they
owe to the community under their BIP editor roles.

Bitcoin is at its heart a scientific project, science and engineering
made progress by the rationalized discussion of contradictory viewpoints.
No one can claim to have papal infaillability in this space, though if
you do so you're always free to go to build your own fork and church and
not to try to coerce people under your religion. By education, I'm sensible
in matters of freedom of consciousness.

I respect Luke's historical contributions in this space, so it's better for
the community to tread him with respect and fairness on this aspect, even if
it means taking a bit more time to resolve this issue and following more
formalities. We should not race to the bottom in matters of procedural
standards, and somehow acting in such a way it's closing surface for
ulterior contestations.

Finally, I would underscore we're in the middle of the month of August,
at a period where people can be in vacations, it's okay to be more lenient
on the time granted to resolute this issue. Some people might be on the
road for vacations, or between two transport (like me) and be usually a
bit less on their keyboard.

All my take and humble opinion only.

Best,
Antoine
OTS hash: 2dd0347a79c77bd2e56fa9587d0099baa9fcebccc688732e23c38fb4d99044fe

Le Sunday, August 9, 2026 à 11:35:19 PM UTC+1, Michael Tidwell a écrit :

> Luke, 
>
> Thanks for the years of hard work. Genuinely appreciated.
>
> It's my opinion this is the right move. And, it would be better to step 
> down yourself than get forced out through this informal process (Frankly 
> it's embarrassing that this seems appropriate given your historic 
> contributions). I believe it's apparent to most, (and I hope to you), that 
> it's unlikely you would be working effectively with Core from here.
>
> There’s going to be a need for strong technical leader around 
> decentralized mining at Ocean, and for a solid BIP editor if that new PoW 
> chain happens. Whoever takes that on is going to need real conviction. Good 
> luck with whatever comes next and whatever happens. Looking forward to what 
> you building more amazing things at Ocean (again being genuine), so far 
> y'all have made a splash, looking forward to the waves! (get it? because 
> water and ocean.. anyways).
>
> Anyways for "communication", make sure you haven't accidentally blocked 
> someone who you think has stopped communicating with you.. for instance if 
> I wasn't blocked, I would have just sent this as a DM.
>
> Thanks,
> Tidwell
> On Sunday, August 9, 2026 at 3:50:52 PM UTC-4 Matt Corallo wrote:
>
>> I see no reason why he should not be removed. 
>>
>> Matt 
>>
>> On 8/9/26 2:29 PM, Murch wrote: 
>> > Hello everyone, 
>> > 
>> > I recommend that Luke Dashjr be removed from the position of BIP 
>> Editor. 
>> > 
>> > Over the past several years, Luke has been at the center of many 
>> contentious disputes within the 
>> > Bitcoin ecosystem, and this week a new forkcoin spun out of Bitcoin 
>> under his leadership. 
>> > 
>> > More specifically, Luke was heavily involved in the creation and 
>> implementation of BIP110, the 
>> > proposal that led to the fork. During that process, he also exercised 
>> his authority as a BIP Editor 
>> > inconsistently with the established editorial process unfairly favoring 
>> the proposal he was involved 
>> > in. For example, he attempted to assign a BIP number to the draft 
>> publicly on Twitter before the 
>> > proposal had been discussed on the mailing list, and he merged a PR 
>> updating the BIP within minutes 
>> > of the PR being opened. 
>> > 
>> > The latter is particularly notable given that Luke has otherwise made 
>> hardly any contributions to 
>> > the day-to-day work of the BIP Editors since the additional editors 
>> began serving in April 2024: he 
>> > left fewer than 1% of the BIP Editor comments in the repository since 
>> then, and the merge action of 
>> > this PR was his first since May 2024. 
>> > 
>> > Communication between Luke and other BIP Editors had already broken 
>> down last year, following a 
>> > discussion about his attempt to side-step the process by prematurely 
>> assigning a BIP number out of 
>> > band. 
>> > 
>> > Taken together, I believe these circumstances raise serious concerns 
>> about Luke continuing to hold 
>> > editorial authority. In particular: 
>> > 
>> > - he has exercised his editorial privileges in a manner that raises 
>> conflict-of-interest concerns; 
>> > - he has contributed little to the ongoing workload of the BIP Editors; 
>> > - his recent championing of a contentious soft fork that now appears to 
>> evolve into a hard fork 
>> > represents a complete departure from the Bitcoin development ecosystem; 
>> and 
>> > - trust, communication, and coordination with the other BIP Editors 
>> have broken down. 
>> > 
>> > For these reasons, I motion that Luke be removed as a BIP Editor. 
>> > 
>> > Murch 
>> > 
>>
>>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/43fa13f1-00bc-47e0-8a46-0668fd435e97n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 11319 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] [BIP Proposal] Stale Tip Relay
@ 2026-07-29 17:21  1% Ram
  2026-08-11 13:51  0% ` Edil Guimarães de Medeiros
  2026-11-05 23:19  0% ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 2 replies; 200+ results
From: Ram @ 2026-07-29 17:21 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3873 bytes --]

Hello list,

This proposal introduces `staletip`, an opt-in P2P message for relaying 
recent
stale tips between peers. Building on AJ Towns' initial work, w0xlt and I 
have
developed the proposal further and built a proof-of-concept implementation.

Draft BIP:
https://github.com/pseudoramdom/bips/blob/staletip-bip-draft/bip-staletip.md

Proof-of-concept:
https://github.com/w0xlt/bitcoin/tree/staletip-v4

Today, once a block loses a race and goes stale, it stops propagating – 
compact
block relay and FIBRE aggressively relay the winning chain, while stale 
branches fall away. That's great for fast propagation, but it makes the 
stale
rate difficult to observe. Even dedicated monitors [0] have only partial 
views:
a stale block seen by one monitor may never reach another.

The stale rate is a useful network-health signal because it is closely 
related
to block propagation delay. The longer it takes miners to learn about a 
newly
found block, the greater the chance that another valid block will be found 
at
the same height, creating a race in which one of the blocks becomes stale 
[1].
An elevated stale rate could also expose validation or relay bottlenecks.
For example, the May 2023 "inv-to-send" bug degraded block propagation and
coincided with a roughly 10x increase in the observed stale rate [2].

A stale block does not by itself identify its cause, but changes in the
rate or shape of stale branches can provide a reason to investigate:

  - a network partition – when a partition heals, blocks mined on the
    losing side become stale, potentially producing several related stale
    blocks at once.
  - adversarial mining strategies such as selfish mining [3] – these
    can cause honest miners' blocks to become stale.

The proposal fills this observability gap with an opt-in P2P message called
`staletip`, allowing nodes to proactively announce recent stale tips to 
peers.

An added benefit is potentially faster reorg handling: if a node already 
knows
the relevant headers, and perhaps has the block data, it has less work to 
do if
that branch later becomes active.

At protocol level, nodes advertise support using BIP 434 `feature` message 
[4], 
and `staletip` messages are only sent to peers that advertised support. Each
announcement contains the fork point, a sequence of compressed headers, and 
a
flag indicating whether the sender can serve the stale tip block. 

The proposed default relay policy:
  - relays only tips within 1000 blocks (about seven days) of the active 
tip, 
    keeping announcements recent and stale-tip spam costly on mainnet.
  - limits branches to 20 compressed headers, covering short-term reorgs
    without tracking persistent chain splits and keeps each announcement 
under
    1 kB.
  - keeps at most 10 recent tips in the relay cache, so announcing the full
    cache to a new peer remains under 10 kB, excluding any blocks requested.

The BIP text has more background and the full message format. Comments are
welcome.

Cheers,
Ram (pseudoramdom <https://github.com/pseudoramdom>)
& 
w0xlt <https://github.com/w0xlt>

[0] https://github.com/bitcoin-data/stale-blocks
[1] 
https://delvingbitcoin.org/t/propagation-delay-and-mining-centralization-modeling-stale-rates/2110
[2] https://b10c.me/observations/15-inv-to-send-queue/
[3] https://arxiv.org/abs/1311.0243
[4] https://github.com/bitcoin/bips/blob/master/bip-0434.md

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d92f1615-368b-4406-b326-a1799c72a555n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 4437 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-07-04 11:57  1%         ` Sjors Provoost
@ 2026-07-05 21:55  0%           ` Antoine Riard
  2026-08-13  3:28  0%             ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-07-05 21:55 UTC (permalink / raw)
  To: Sjors Provoost
  Cc: Pieter Wuille, conduition, Nagaev Boris,
	Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 7714 bytes --]

Hi Pieter,

Thanks for the observations.

When I was saying there is a problem with the game theory,
it's that strikingly, any activation of the tripwire logic
would rely on a "flag" transaction being mined in the chain
for the network nodes starting to enforce at the block N or
N+1 or whatever the EC disabling threshold.

Any "flag" transaction can be itself re-orged out of the chain
to purely disable the effects of the EC disabling threshold,
therefore make it null and void as an effect. One might see
it as a competing race between a group of "sunsetting" users
and a (majority) coalition of miners in coordination with a
CRQC adversary, where the latter have an interest and the
hashrate capabilities to do a tx-withold [0].

In pure terms of satoshi fee denominated calculus, empirically
global miners have won an average of $20 B yearly. If we only
consider that P2PK are going to be frozen by the tripwire effect,
as for most of them it might be assumed they will never move to
a safer format, we talk already about 1.7 M of coins or as of
today valuation $107 B (the information is on the chain and can
be verified).

That's $107B can "burn" in revenue or income that a CRQC-enabled
miners coalition to constantly reorg-out the "flag" tx out of the
chain. In other terms, something like 5 years of income, and I
kindly do not count all the loss coins that are likely to amount
to a far bigger "tripwire" neutralization budget.

In the name of what a majority of miners will gracefully let on
the table an opportunity of massive income ?

Leveraging Shor the exploitation might be even done anonymously
as the mining process is done. Not even certainty, by who the
EC-protected coins could be covertly exfiltrated.

That's the most striking problem when you think about the math
with any "tripwire" approach, or even an "hourglass" one relying
on a "flag" transaction [1]. I'm ruling out "checkpoints" and
any other trust-the-dev approach, as that's even worst [2].

As you're introducing post is resounding, what the miners
are saying now, there are no guarantees on how they would use
their hashrate down the road, potentially 10 or 20 years from now.

Beyond, and to answer back your point, I still think you can
manage an escape hatch of the "tripwire" effect, it's all depends
how the script tripwire logic is implemented, but if you have
two OP_SUCCESS of different kinds before your EC CHECKSIG, you
can always have a "soft-fork" after the "tripwire" to return
true on the stack, with an EC or hashlock as a success (I agree
using undefined op_success in a script is not safe at all) [3].

Best,
Antoine
OTS hash: 4bc91d8dee1625f6e78b27c88bced8e405f25ef6d3d8fd59be8016db5b0fbe66

[0] See naumenkog's https://www.bitmex.com/blog/txwithhold-smart-contracts
[1] This is sad, as the "hourglass" depending how the parameters are chosen
was a more acceptable trade-off than pure sunsetting.
[2] Given the amounts at stake to sunset, as a group of developers you
would just paint yourself a target, there are more even funds at stake
that Satoshi herself / himself is assumed to have.
[3] There is no security proof in BIP341 on the unforgeability of the
NUMS point, if it binds in the ROM or whatever.

Le sam. 4 juil. 2026 à 13:47, Sjors Provoost <sjors@sprovoost.nl> a écrit :

>
>
> On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:
>
> [...]
>
> > * Just publishing the DLP in a transaction (e.g. OP_RETURN with a
> > specific marker). This is smaller than a full transaction input +
> > signature.
> >
> > * Similarly, but publishing in the coinbase, and requiring relay using
> > a separate message. Less places a node needs to check, but I'm
> > concerned about the difficulty of testing infrastructure that relay of
> > such a message works
>
> [...]
>
> >
> > On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns
> > <aj@erisian.com.au> wrote:
> >
> >> A slight variant of this approach would be to have a 128 byte value
> "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a
> BIP340 signature of m by P. That would allow the victim of post-quantum
> theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in
> addition to someone who has direct access to a CRQC.
> >
> > Indeed, I had considered something similar, but see above for why I'm
> > not convinced supporting non-cooperative CRQCs is that useful.
> >
> > Also, in my view the tripwire isn't really a security feature on itself
> > (it's not expected to trigger...), but more something that sets
> > expectations around the output type for prospective users.
> >
> > In that sense, the question is really whether supporting
> > non-cooperative CRQCs helps set that expectation more than only
> > cooperative ones, which are definitely easier to support.
> >
> >> I think it could make sense to have the tripwire be included in the
> block via the coinbase witness commitment output, rather than having it be
> locked to a transaction, so you only having to check the coinbase for the
> magic rather than every transaction. That would require a separate P2P
> message to relay the necessary ECDL-break proof to miners, and would
> probably need stratumv2 or a getblocktemplate update in order for the node
> to be able to tell pools to actually include that info in the coinbase.
> >
> > I worry this is untestable, really. You'd need things like
> > fake-tripwires to be supported through the same message which don't
> > require an ECDLP break, and still propagate. And then that needs DoS
> > protection measures,
>
> I whipped something up last weekend:
> https://github.com/Sjors/bitcoin/pull/121
>
> It seems straightforward, but maybe I missed something:
> - for test code we use a fake NUMS point, so we can generate "proof"
> without a quantum computer
> - a p2p message floods the proof
> - nodes ignore the message if they already have *any* valid proof
> - verifying p2p proof candidates might need some rate limiting, but it's
> as cheap as verifying a transaction signature
> - mining code includes the proof in a coinbase op_return, until the freeze
> activates
>   - with stratum v2 (and ipc mining clients in general this works out of
> the box, a small change is needed for getblocktemplate clients)
> - since the proof is not in the header, we can't use the normal bip9 style
> header scan to see if the rule activated. Instead the prototype stores it
> in a file along with a merkle inclusion proof, which is read when the node
> restarts.
>
> With this mechanism it doesn't really need to be in the coinbase
> transaction, but that does seem more convenient and miners can censor it
> anyway.
>
> - Sjors
>
> --
> You received this message because you are subscribed to a topic in the
> Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit
> https://groups.google.com/d/topic/bitcoindev/aWYtPLVPZ3U/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to
> bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BFMHG3yoOCXPfMhS%3DKFF9bn%2BrCi9NL836GDRp1CKTBXRA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 9401 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-07-03 21:23  1%       ` Pieter Wuille
@ 2026-07-04 11:57  1%         ` Sjors Provoost
  2026-07-05 21:55  0%           ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: Sjors Provoost @ 2026-07-04 11:57 UTC (permalink / raw)
  To: Pieter Wuille, conduition
  Cc: Nagaev Boris, 'Bitcoin Development Mailing List'



On Fri, Jul 3, 2026, at 23:23, Pieter Wuille wrote:

[...]

> * Just publishing the DLP in a transaction (e.g. OP_RETURN with a 
> specific marker). This is smaller than a full transaction input + 
> signature.
>
> * Similarly, but publishing in the coinbase, and requiring relay using 
> a separate message. Less places a node needs to check, but I'm 
> concerned about the difficulty of testing infrastructure that relay of 
> such a message works

[...]

>
> On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns 
> <aj@erisian.com.au> wrote:
>
>> A slight variant of this approach would be to have a 128 byte value "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a BIP340 signature of m by P. That would allow the victim of post-quantum theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in addition to someone who has direct access to a CRQC.
>
> Indeed, I had considered something similar, but see above for why I'm 
> not convinced supporting non-cooperative CRQCs is that useful.
>
> Also, in my view the tripwire isn't really a security feature on itself 
> (it's not expected to trigger...), but more something that sets 
> expectations around the output type for prospective users.
>
> In that sense, the question is really whether supporting 
> non-cooperative CRQCs helps set that expectation more than only 
> cooperative ones, which are definitely easier to support.
>
>> I think it could make sense to have the tripwire be included in the block via the coinbase witness commitment output, rather than having it be locked to a transaction, so you only having to check the coinbase for the magic rather than every transaction. That would require a separate P2P message to relay the necessary ECDL-break proof to miners, and would probably need stratumv2 or a getblocktemplate update in order for the node to be able to tell pools to actually include that info in the coinbase.
>
> I worry this is untestable, really. You'd need things like 
> fake-tripwires to be supported through the same message which don't 
> require an ECDLP break, and still propagate. And then that needs DoS 
> protection measures, 

I whipped something up last weekend:
https://github.com/Sjors/bitcoin/pull/121

It seems straightforward, but maybe I missed something:
- for test code we use a fake NUMS point, so we can generate "proof" without a quantum computer
- a p2p message floods the proof
- nodes ignore the message if they already have *any* valid proof
- verifying p2p proof candidates might need some rate limiting, but it's as cheap as verifying a transaction signature
- mining code includes the proof in a coinbase op_return, until the freeze activates
  - with stratum v2 (and ipc mining clients in general this works out of the box, a small change is needed for getblocktemplate clients)
- since the proof is not in the header, we can't use the normal bip9 style header scan to see if the rule activated. Instead the prototype stores it in a file along with a merkle inclusion proof, which is read when the node restarts.

With this mechanism it doesn't really need to be in the coinbase transaction, but that does seem more convenient and miners can censor it anyway.

- Sjors

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/002f2395-7d5d-4cb6-852c-e991aa1f0eb3%40app.fastmail.com.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  2026-06-26 18:20  1%     ` 'conduition' via Bitcoin Development Mailing List
@ 2026-07-03 21:23  1%       ` Pieter Wuille
  2026-07-04 11:57  1%         ` Sjors Provoost
  0 siblings, 1 reply; 200+ results
From: Pieter Wuille @ 2026-07-03 21:23 UTC (permalink / raw)
  To: conduition; +Cc: Nagaev Boris, Bitcoin Development Mailing List

Hi list,

Some responses inline below.

On Friday, June 26th, 2026 at 2:20 PM, conduition <conduition@proton.me> wrote:

> Mining an on-chain spend isn't the only option. The signature by (or discrete log of) the NUMS point is itself a sufficient and succinct proof that EC spending ought to be disabled. We don't need a trustless "honeypot"/"reward"/"bounty" for the CRQC, since we're already assuming the CRQC is cooperative. We don't need the "tripwire proof" to be included on-chain except for posterity (i.e. nodes bootstrapping after Q-day, to know when to enact the new consensus rules retroactively). All a validator node today needs is to see the signature/discrete log of the NUMS point, anywhere, at any time, to know that EC spending ought to be disabled immediately.
>
> It could be in an OP_RETURN, it could be a new field in a block, it could be a simple P2P message or just seeing a TX containing the tripwire proof appear in the mempool.

There are multiple variations of what the tripwire proof could look like, and I don't think the details matter as much. However, it must be part of the chain or it's not available to consensus rules. Just seeing a ECDLP breakage proof is not enough, because enforcing nodes need to be in agreement about which blocks it applies to. And without being in the chain, there is no way to guarantee all nodes see the proof at the same time w.r.t. blocks, and discrepancies will leak to forks.

The options I know of:

* Using a spend of a known-to-be-NUMS transaction output (as my original mail proposed). I like this because it needs no infrastructure, and has no DoS concerns as it's just a normal transaction.

* Just publishing the DLP in a transaction (e.g. OP_RETURN with a specific marker). This is smaller than a full transaction input + signature.

* Similarly, but publishing in the coinbase, and requiring relay using a separate message. Less places a node needs to check, but I'm concerned about the difficulty of testing infrastructure that relay of such a message works.

* Either of the two above options, but with AJ's (sig + msg + tweak) proof form, which could be used to prove P2TR key-path spends with NUMS internal key by unknowing malicious CRQCs. It's neat, but I'm not sure catering to non-cooperative CRQCs is all that relevant, because (a) if thefts are happening, I think it's all too late anyway and (b) Malicious CRQCs aren't likely to go after P2TR outputs first, probably, including for this reason. Maybe it discourages them from stealing P2TR though, which may be a reason to consider it...

> Maybe requiring the tripwire proof to be mined is simple to implement for validators, but relying on that alone runs the risk of miners censoring or purposefully delaying the inclusion of the tripwire proof in a block. So it might be worth the extra complexity engineering of a more highly reactive solution.

That is a fair concern, but it's inevitable. Miners are by definition the decider of the ordering of events as far as the consensus rules are concerned. This includes when the trigger happens.

> > Miner Lockdown (P2XX-ML): allow a hashrate majority/threshold to trigger the disabling, allowing a faster reaction time to urgent CRQC threats.
> 
> I'll echo the others' concerns here about early activation, and add that miners may actually be incentivized to trigger this activation early if given the chance, since doing so will massively pump their fee revenue (though perhaps at a cost to the price of Bitcoin itself). This could be more of a concern as the subsidy drops lower and miners with sunk cost seek to recoup their up-front hardware investment.

That's a fair concern. A related one is that if the activation of the trigger is at a time with a juicy mempool full of ECC spends, it may encourage miners to not include the trigger, or if one does, for others to reorg it. I think this can partially mitigated by having a delay of something in the order of days between activation and actual enforcement (for both tripwire and miner lockdown).

> The more important question is, how do you propose to technically achieve this? How does "majority hashpower" enact the disabling? My fear is that the reaction time will actually be very slow, because for us to measure "majority hashpower" we typically measure this over an epoch of many blocks. Otherwise a random minority miner could luck their way into a few blocks that signal for EC disabling, and so trigger the fork early.

BIP9, with modified parameters, probably? It'd be conditional on the consensus change that introduces the P2XX-ML output type, which would be the real softfork activation. The lockdown just reuses the same signalling infrastructure, but isn't a consensus change. I haven't really thought about what the parameters need to look like.

> The activation window would need to be spread out, and the further it is spread out the less time miners have to react, if they even react at all.

I'm not sure what you mean here.

> This will confiscate coins held in hybrid scripts and in multisigs whose parties use different sig-schemes, e.g. <ec_pubkey> CHECKSIG <pq_pubkey> CHECKSIG.
> 
> I would suggest to enforce the disabling by running spend validation as normal, but failing at the end if EC-checksig operations have occurred without any PQ-checksig ops. This also implicitly disables P2TR-style key-spending and Boris' EC recovery scheme in P2TRH and P2MR, because such spends wouldn't involve a PQ signature.

I don't think self-crafted hybrid schemes should be something to cater to, but that approach works, indeed. PQC scripts could also be just a separate script leaf version, which has no ECC opcodes from the start.

> We thus concluded that deploying a hybrid scheme doesn't seem to offer much unique value, and comes at the expense of great risk and effort in adding a new checksig algorithm, which very few people will use anyway since they have much cheaper options (separate leaf scripts).

I agree that SHRINCS doesn't need hybridization.

On Saturday, June 27th, 2026 at 12:33 AM, Anthony Towns <aj@erisian.com.au> wrote:

> A slight variant of this approach would be to have a 128 byte value "aRsm", such that P = N+a*G, N is the BIP-341 NUMS point, and Rs is a BIP340 signature of m by P. That would allow the victim of post-quantum theft via a key-path spend of a BIP341 NUMS IPK to trigger the tripwire, in addition to someone who has direct access to a CRQC.

Indeed, I had considered something similar, but see above for why I'm not convinced supporting non-cooperative CRQCs is that useful.

Also, in my view the tripwire isn't really a security feature on itself (it's not expected to trigger...), but more something that sets expectations around the output type for prospective users.

In that sense, the question is really whether supporting non-cooperative CRQCs helps set that expectation more than only cooperative ones, which are definitely easier to support.

> I think it could make sense to have the tripwire be included in the block via the coinbase witness commitment output, rather than having it be locked to a transaction, so you only having to check the coinbase for the magic rather than every transaction. That would require a separate P2P message to relay the necessary ECDL-break proof to miners, and would probably need stratumv2 or a getblocktemplate update in order for the node to be able to tell pools to actually include that info in the coinbase.

I worry this is untestable, really. You'd need things like fake-tripwires to be supported through the same message which don't require an ECDLP break, and still propagate. And then that needs DoS protection measures, and ...

On Sunday, June 28th, 2026 at 10:31 PM, Antoine Riard <antoine.riard@gmail.com> wrote:

> [0] A cryptographically-leaning mind can note the first difficulty here. Quid if it's not a "real" nothing-under-my-sleeve point... Show original message

Due to EC's random self-reducibility, if an attacker has a non-negligible change of finding the DLP of a randomly chosen point, they can do that for any point. It of course needs to be a random point, but hash-to-curve achieve that.

The BIP341 NUMS point (which I suggest using in this context) is the point whose X coordinate is the SHA256 hash of the generator point G. This guarantees that the NUMS point cannot predate G (if it did, it would be possible in theory that secp256k1's designers actually chose G in function of what we call that NUMS point, giving it a DLP known to them).

> but frankly I don't see how you can prevent massive "unfreeze" at a latter chain "time" of the activation of your tripwire idea, if you can assume that a (even transient) majority of miners might act in coordination with a cartel of CQRCs.

Unfreezing requires a hardfork, and won't be accepted by any existing node that implemented the tripwire logic. After the EC opcodes within the relevant output type are disabled, those spend paths are gone from the perspective of existing nodes.

It's of course always possible to introduce a new output type with ECC opcodes, or new ECC opcodes within existing output types (e.g. using OP_SUCCESSx). This is always an option the ecosystem has (not miners!), but it won't affect coins using the older output type/opcodes, which are the ones that matter here.

-- 
Pieter

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/G6JS-1KFsfB7MzyRZH42MhcTp4rb_7M9Xg-1xznpwSg9MUjuI9B4ZSfVZ68S-FTaMjGBQhIpPb2E9U346X1xN1jzWoQeL5X_0Ju_j81MSAg%3D%40wuille.net.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML)
  @ 2026-06-26 18:20  1%     ` 'conduition' via Bitcoin Development Mailing List
  2026-07-03 21:23  1%       ` Pieter Wuille
  0 siblings, 1 reply; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-06-26 18:20 UTC (permalink / raw)
  To: Pieter Wuille; +Cc: Nagaev Boris, Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10903 bytes --]

Hi Pieter,

Thanks for voicing this, I'm generally very supporting of the tripwire idea. It's an easy win for any PQ output type.

I have a few comments on the specifics.


> Specifically, as part of the softfork definition, a NUMS point is picked. Whenever a transaction is mined whose input contains a successful "<NUMS> OP_CHECKSIG", EC opcodes/paths are disabled within the new output type, as of the next block.

Mining an on-chain spend isn't the only option. The signature by (or discrete log of) the NUMS point is itself a sufficient and succinct proof that EC spending ought to be disabled. We don't need a trustless "honeypot"/"reward"/"bounty" for the CRQC, since we're already assuming the CRQC is cooperative. We don't need the "tripwire proof" to be included on-chain except for posterity (i.e. nodes bootstrapping after Q-day, to know when to enact the new consensus rules retroactively). All a validator node today needs is to see the signature/discrete log of the NUMS point, anywhere, at any time, to know that EC spending ought to be disabled immediately.

It could be in an OP_RETURN, it could be a new field in a block, it could be a simple P2P message or just seeing a TX containing the tripwire proof appear in the mempool. Maybe requiring the tripwire proof to be mined is simple to implement for validators, but relying on that alone runs the risk of miners censoring or purposefully delaying the inclusion of the tripwire proof in a block. So it might be worth the extra complexity engineering of a more highly reactive solution.

I'm not sure what the best option here is yet, but I just wanted to point out the tripwire doesn't have to be a UTXO spend, and we should discuss more options and their trade-offs.


> Miner Lockdown (P2XX-ML): allow a hashrate majority/threshold to trigger the disabling, allowing a faster reaction time to urgent CRQC threats.

I'll echo the others' concerns here about early activation, and add that miners may actually be incentivized to trigger this activation early if given the chance, since doing so will massively pump their fee revenue (though perhaps at a cost to the price of Bitcoin itself). This could be more of a concern as the subsidy drops lower and miners with sunk cost seek to recoup their up-front hardware investment.

Generally I think this is a good idea though, and might be worth the risk especially because, as you stated, early activation will not confiscate any meaningful amount of coins. But it should also be possible for nodes to reject a bad-faith early activation.

The more important question is, how do you propose to technically achieve this? How does "majority hashpower" enact the disabling? My fear is that the reaction time will actually be very slow, because for us to measure "majority hashpower" we typically measure this over an epoch of many blocks. Otherwise a random minority miner could luck their way into a few blocks that signal for EC disabling, and so trigger the fork early.

The activation window would need to be spread out, and the further it is spread out the less time miners have to react, if they even react at all.


> I agree with Antoine that it necessarily must disable all usage of EC inside the new output type, so that includes taproot key path spending (if present), and making any execution of an OP_CHECK* opcode with a non-empty signature for an EC pubkey cause the transaction to be invalid. Anything else falls short of the goal of making it possible for users to keep sharing public keys. This should be the case for all disabling, whether through Tripwire, Miner Lockdown, or a future softfork.

This will confiscate coins held in hybrid scripts and in multisigs whose parties use different sig-schemes, e.g. <ec_pubkey> CHECKSIG <pq_pubkey> CHECKSIG.

I would suggest to enforce the disabling by running spend validation as normal, but failing at the end if EC-checksig operations have occurred without any PQ-checksig ops. This also implicitly disables P2TR-style key-spending and Boris' EC recovery scheme in P2TRH and P2MR, because such spends wouldn't involve a PQ signature.


> My thinking is that hybrid signature schemes, if desired, should be dealt with at the opcode level, and not the script level. That is, there would be (only) an OP_CHECKHYBRIDECSQISIGN opcode, not an expectation to use both OP_CHECKSIG and OP_CHECKSQISIGN.
>
> Practically, my thinking is that due to the low cryptographic assumptions needed for hash-based schemes, those wouldn't need hybridization with EC (though the statefulness of some variants is worrying).

In the SHRINCS proposal we elect not to introduce a hybrid EC+PQ signature scheme, for a few reasons:

- Complexity & fragility. A hybrid scheme necessitates a brand new Schnorr signature scheme because combiners like Bird-of-Prey don't use Schnorr as a black-box. Expands the scope of implementation a lot.
- Lack of value. Strong unforgability (one of the main selling points of hybridization) is not security-critical because witnesses don't affect TXIDs anymore. At best a hybrid scheme would provide a minor ~5%-10% improvement in witness size over a naive scripting approach, and this is still less efficient than keeping keys compartmentalized in isolated spending paths.
- Redundancy. Deploying SHRINCS as a standalone opcode is already needed for post-Q-day spending, so taking that opcode as a-given, users will already have access to hybridization techniques by using hybrid scripts.
- Security. Standalone SHRINCS uses fewer cryptographic assumptions than BIP340. Adding Schnorr hybridization thus hedges only against implementation flaws or state reuse, both of which can be effectively mitigated against.

We thus concluded that deploying a hybrid scheme doesn't seem to offer much unique value, and comes at the expense of great risk and effort in adding a new checksig algorithm, which very few people will use anyway since they have much cheaper options (separate leaf scripts).

I suspect hybrid script users will exist, but will likely be limited to major custodians, high-security vaults, and other such address-reusers. Dedicated hybrid signature algorithms may be desirable in the future with other signature schemes, but I doubt we'll be doing this with SHRINCS anytime soon.

regards,
conduition


On Friday, June 26th, 2026 at 8:14 AM, Pieter Wuille <bitcoin-dev@wuille.net> wrote:

> Hi Boris,
>
> See responses inline below.
>
> On Friday, June 26th, 2026 at 5:41 AM, Nagaev Boris wrote:
>
> > For Miner Lockdown, I see a potential false-positive activation. A large
> > classical theft may happen, be misinterpreted as a CRQC event, and miners
> > may lock the EC path with the best intentions, but it turns out to be a
> > false alarm. Shouldn't there be a mechanism for reactivation in this case?
> > We have historical examples of bugs causing large-scale or initially
> > mysterious thefts: Milk Sad, Android SecureRandom 2013, and the LuBian
> > 2020 theft. A similar event in the future could be confused with Q-day,
> > and miners could push the button.
>
> I agree that's a concern, but of course, if this happens, no coins are
> lost, just inefficient to access. As Sjors mentions, it's possible for
> users to move back to P2TR temporarily, but that of course goes counter to
> the CRQC-protection goal, and if it happens at scale, chain capacity
> problems may cause chaos.
>
> Adding the ability to revert is a possibility, but I'm not sure it's all
> that much better than realizing there is also the possibility of adding a
> new P2TRv3 / P2MRv2 / ... that is in a pre-lockdown state?
>
> > Can you elaborate on the scope of EC disabling, please? Does it disable
> > only the main EC path (e.g. key spend in the case of Taproot v2) or all EC
> > involving paths?
>
> I agree with Antoine that it necessarily must disable all usage of EC
> inside the new output type, so that includes taproot key path spending (if
> present), and making any execution of an OP_CHECK* opcode with a non-empty
> signature for an EC pubkey cause the transaction to be invalid. Anything
> else falls short of the goal of making it possible for users to keep
> sharing public keys. This should be the case for all disabling, whether
> through Tripwire, Miner Lockdown, or a future softfork.
>
> > What will happen to scripts using something else in addition to EC? Some
> > useful constructions may include an EC opcode, e.g. hybrid EC-PQ
> > signatures or HTLCs. Maybe it makes sense to disable the main spending path
> > and keep hash-protected supplementary paths available?
>
> My thinking is that hybrid signature schemes, if desired, should be dealt
> with at the opcode level, and not the script level. That is, there would be
> (only) an OP_CHECKHYBRIDECSQISIGN opcode, not an expectation to use both
> OP_CHECKSIG and OP_CHECKSQISIGN. My reason for this is that I think the
> question of what level of security is appropriate (i.e., whether schemes
> should be protected with a layer of EC hybridity) should be a consensus
> decision, not an individual one.
>
> Thinking about it, maybe that means it makes sense to completely separate
> PQC scripts and (pure-)EC scripts at the script leaf level, by having
> separate script leaf versions for them. That rules out some potentially
> useful ways of using conditionals that have PQC and pure-EC branches, but
> those do seem pretty error prone (as mixing the two within one execution
> trace would be unusable post EC-disabling).
>
> Practically, my thinking is that due to the low cryptographic assumptions
> needed for hash-based schemes, those wouldn't need hybridization with EC
> (though the statefulness of some variants is worrying). I don't think
> schemes relying on other assumptions feel ready in terms of confidence for
> adding to Bitcoin to me, but that can change.
>
> Cheers,
>
> --
> Pieter
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/A54QKCjvV0Tnk26mHFZrbAKPHdYh6Ol1XWTetB3y1skuSaoLtBZnvNlYD2hSqQtp6oYt85rqvK4w-JMsDJOm3nPrYgkN94E9jlxxCPZsKZw%3D%40wuille.net.
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/Jj-Ozzq4OMo2XaP_Drftu_n7gmEHWC_Dw2bToW9hI8vId-BN3y4hmQSaHh5JY1xTonTyBWKa17vzNH4GMYTkM-CiFw5ZNwRFATdc3OE_lLk%3D%40proton.me.

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Aligning privacy incentives in P2MR
  @ 2026-06-06 19:33  2%       ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-06-06 19:33 UTC (permalink / raw)
  To: Pieter Wuille; +Cc: Antoine Poinsot, bitcoindev@googlegroups.com


[-- Attachment #1.1.1: Type: text/plain, Size: 15296 bytes --]

Hey Pieter, nice to hear from you too on this. 


Do you have any take on the OP idea about P2MR depth restrictions?


> as far as compelling reasons go, I think the quantum resistance debate is quite different from P2TR adoption. As Q-fear grows, I suspect there will be increasingly loud and hard-to-ignore voices (and possibly regulation...) to adopt post quantum cryptography technology stacks.



I hope so too! It's totally possible that a significant majority of UTXOs migrate in time - say if you're right and there is a very public concerted push towards PQ, or if Q-day turns out to be 50+ years from now. But it's impossible to predict this. For now I hope for the best, but I also want to plan for the worst.


If PQ fear is indeed such a strong motivating factor as you hypothesize, wouldn't this be an argument against P2TRv2? P2TRv2 isn't quantum-resistant by default but P2MR is. Personally, if I thought a CRQC is imminent, I would rather sell my coins or stow them in a P2WSH address than migrate to an address format which requires a follow-up fork to be secure. 

To borrow a phrase, P2TRv2 bears a systemic risk (solving the fork timing problem), whereas P2MR has only local risk (address reuse, which btw would also be solved if we could solve fork-timing). Antoine drew this comparison on his post too but we apparently disagree on which is preferable.

Users and devs can control local risk with very simple software tweaks (to avoid address reuse) but they can't do anything about systemic risks. This is why I prefer P2MR. If the fork-timing problem can be solved conclusively then maybe P2TRv2 would be viable, but as you've alluded to, we have yet to hear any passable solution that doesn't require a cooperative CRQC.


> No offense, but this sounds like a fairly depressing scenario to me. If an ECDLP break happens before even a large majority of the "active" economy adopts Q-safe outputs, I don't think there is much of an interesting future for Bitcoin. Leaving many users' coins vulnerable to theft will undermine short-term trust in the currency, possibly fatally so. The alternative, burning significant amounts of users' coins will be seen as confiscation that undermines the long-term stability value proposition bitcoin has, as it would be indistinguishable from a PQC altcoin that imports some fairly arbitrary subset of Bitcoin's UTXO set (see also https://antoinep.com/posts/quantum_risk_mitigation/, where Antoine makes that point in more detail).


Agreed, it would suck, but would likely be viable.


I lack data, but I suspect that by Q-day most coins will have some knowledge-asymmetry with a CRQC (hash preimages, BIP32 parent keys, hidden P2TR script paths, etc) and so can be rescued with simple commit/reveal protocols - no heavy ZK machinery or hard-forks needed.

With that in mind, then it doesn't really matter how many recoverable coins migrate before Q-day, does it? If you can assume P2TRv2's PQ-security promise will be deployed on-time, then you can also assume any BIP32 wallet in-use today can be rescued. What we really must care about is migrating the unrecoverable fraction of coins (e.g. JBOK wallets with exposed pubkeys). These should already be rare and will only become rarer as more time passes.

So in order to argue your point that P2TRv2 makes confiscation/theft less likely, you'd need to show that P2TRv2 will result in a meaningfully higher number of unrecoverable coins migrating. And I don't see why that would be the case. Holders of ancient JBOK coins with exposed keys are probably either dead, or have lost their keys. If a holder does still have the keys, then why would they move to P2TRv2 but not P2MR?

On a more positive note, if we can someday say "Look, quantum computers appeared and screwed some people over, but most people can recover their coins as long as they fulfill any one of these common criteria," then that seems like Bitcoin's unique value and confiscation resistance is surprisingly intact to me. Certainly better than certain other altcoin migrations I've seen in the past, but I guess this is a subjective question, and everyone will have their own opinion.


> It's possible to allow a Merkle tree whose leaves are either EC keys or scripts, and then allow spending from the key-leaves by revealing the path and a signature, but recover the expected public key from the signature. That needs a variation of BIP340 that doesn't commit to the public keys (which may break some of the proofs of higher-level schemes, but as long as there is no ANYPREVOUT like functionality, the message implicitly commits to the output so that may be fine). But even with that, efficiency is 32 bytes worse than P2TR, because in a Q-safe setting with at least one additional PQC branch, you have at least 32 bytes of Merkle path. Is this what you have in mind?



Sorry to string you along but I'm gonna hold off here as I don't want to take credit for the idea by jumping the gun and explaining it myself. I'll leave it open for the actual author to chime in on this thread if/when he's ready :)


> A reasonable intersection of both opinions could be further witness discount of EC Schnorr of P2MR (Segwit v2).
> Further 2x witness discount (total 8x witness discount) makes P2MR EC-spend transaction cost almost at par with P2TRv2 key-spend path.



I wouldn't rule out a discount in a future upgrade but for now i'm hesitant to bundle PQ addresses/signatures with anything that might disrupt the existing fee market, especially given the frustratingly controversial topic of inscriptions/spam. I can already picture the Knotsies decrying a witness-discounted PQ soft fork as "spam-support hidden behind quantum FUD". Never mind that we're already going to have to bump the stack element size limit...


regards,
conduition

On Saturday, June 6th, 2026 at 12:30 AM, Pieter Wuille <bitcoin-dev@wuille.net> wrote:

> Hi Conduition,
> 

> Some comments inline below.
> 

> On Friday, June 5th, 2026 at 6:59 PM, 'conduition' via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> wrote:
> 

> > Hi Antoine, thanks for the feedback. Glad to hear you're receptive!
> > 

> > 

> > > It's important to consider that in any scenario where Bitcoin as we know it survives a CRQC, the vast majority of users would have had to migrate to an output type that includes an escape hatch long before we could have been reasonably certain that a CRQC would materialize. Therefore we should not assume that the vast majority of users strongly desire to migrate to an escape-hatch output type. (In fact, i think it would actually be reasonable to assume none have a strong desire to do so. This is because everyone has an incentive for everybody to migrate, but there is little incentive for each individual to migrate if nobody else does.)
> > 

> > > 

> > > 

> > > Therefore any additional barrier to encourage users to opt into an escape-hatch output type is working against CRQC risk mitigation.
> > 

> > 

> > All else being equal, whether we use P2MR or P2TRv2 I believe we will end up with roughly the same (small) fraction of the UTXO set migrated by Q-day. I believe this because address format adoption is always slow even with good incentives. Even after 7 years and plenty of incentives to migrate, P2TR still secures only a small fraction of the UTXO-set compared to P2(W)PKH, and a tiny fraction (0.75%) of the supply. See this 2025 report from mempool.space and this 2025 report from Galaxy Digital. Incentivizing adoption doesn't always lead to adoption, so why expect it to do so with P2TRv2? It doesn't offer any incentive over P2TR beyond a shallow promise of maybe-some-day-quantum-security.
> 

> 

> I don't think that's necessarily the right conclusion. P2TR adoption is low, partially because wallets and especially commercial service providers generally don't ever upgrade their technology stacks unless there is a compelling reason; the ecosystem primarily updates through companies going out of business and being replaced by new ones, which are more likely to be built using modern technology. We obviously cannot ask for faster movement through business failure here, but as far as compelling reasons go, I think the quantum resistance debate is quite different from P2TR adoption. As Q-fear grows, I suspect there will be increasingly loud and hard-to-ignore voices (and possibly regulation...) to adopt post quantum cryptography technology stacks. At that point, wallets may start to offer users an "Upgrade to quantum-resistant addresses?" migration button. In the case of P2MR that will need to come with a "Warning: transactions will cost 15% more going forward" notice. In the case of P2TRv2, depending on what what used before it may have 0 impact on costs, or even be a discount going forward. If on-chain fees remain as low as they are now, this may not matter, but otherwise, I think the number may very well discourage a substantial amount of users who aren't convinced about CRQC threats. And I think those users do matter, unfortunately.
> 

> 

> > Here's my timeline prediction, with the above precedent in mind. We deploy a PQ output type, some minority of UTXOs migrate to it. When the first confirmed ECDLP break is proven (e.g. if someone breaks a NUMS point) or suspected (someone stole Satoshi's coins), then we will deploy a rescue protocol which we hopefully prepared in advance to protect the majority procrastinator UTXOs. Maybe we disable EC spending at the same time (a valid option for either P2MR or P2TRv2). Then there will be a brief fork-war (hard or soft) revolving around the question of how to handle Satoshi's coins. After that IDK what happens, but I expect Bitcoin will survive if we prepare adequately today by deploying a quantum-safe address format and PQ signature scheme, and develop rescue protocols for later activation to move laggards over to PQ wallets.
> 

> 

> No offense, but this sounds like a fairly depressing scenario to me. If an ECDLP break happens before even a large majority of the "active" economy adopts Q-safe outputs, I don't think there is much of an interesting future for Bitcoin. Leaving many users' coins vulnerable to theft will undermine short-term trust in the currency, possibly fatally so. The alternative, burning significant amounts of users' coins will be seen as confiscation that undermines the long-term stability value proposition bitcoin has, as it would be indistinguishable from a PQC altcoin that imports some fairly arbitrary subset of Bitcoin's UTXO set (see also https://antoinep.com/posts/quantum_risk_mitigation/, where Antoine makes that point in more detail).
> 

> I cannot confidently state that your scenario is unlikely of course, but I think there is little we can do today that affects the outcome in this case. People can think about emergency recovery scenarios to scavenge what's left to save (BIP32 ZKPs and all that), and the result may well survive, but I don't think it'll be very interesting, and not something we as protocol designers should optimize for at this stage.
> 

> The interesting scenarios to me are ones where either a CRQC doesn't happen, or where we get a large majority of users to adopt Q-safe outputs before that happens. Maximizing the probability that that will happen should be our priority.
> 

> 

> > Whether we pick P2MR or P2TRv2 today, neither choice will affect the early stages of this plot-line very much, so we might as well optimize for the long-term future, and P2MR wins out there.
> 

> 

> The ideal long-term future is one where we get feature-rich cryptographic schemes that can replace most of the properties Bitcoin relies on today (homomorphic derivation, efficient multisigs, ...) with low costs (through discounts, smaller signatures/keys, efficient verification, ...). At that point, they can be introduced in PQC-only outputs even (say, P2MR without any EC opcodes ever), everyone can adopt them over time, and then when a CRQC appears or not won't really matter. That technology does not exist today, I think, so the best we can aim for today is something where most users can migrate to with minimal downsides before Q-day, even if it comes with some downsides afterwards, which will inevitably be chaotic but maybe not an existential threat. I don't think it matters much that P2TR(v2) is slightly less efficient than P2MR in this hopefully-avoidable chaos; we'll have much bigger fish to fry.
> 

> I believe P2MR is effectively optimizing for the time after/if a CRQC appears (possibly only temporarily so if another migration to a more fully-features PQC scheme is needed anyway then) while P2TRv2 is optimizing for the time before a CRQC happens and minimizing barriers for adopting Q-safe coins. All of this is under the assumption that P2MR comes with a reasonable expectation of a narrow P2MR-only EC opcode disabling softfork when CRQCs happen (like P2TRv2); without it, I believe it is much worse, as P2MR would be entirely inadvisable to adopt by anyone whose workflow relies on sharing public keys with others (hardware wallets with descriptor-based watchonly software, wallets with indexing servers, multisig, Lightning, escrows, fee bumping, ...).
> 

> So, I prefer P2TRv2 here, though under the assumption that the narrow EC opcode disabling softfork can be relied upon. I am not confident that that is possible, though I have more thoughts on the matter. That's for another post, though.
> 

> 

> > > any additional barrier to encourage users to opt into an escape-hatch output type is working against CRQC risk mitigation. And i think the additional costs of using P2MR compared to P2TRv2 is one of them.
> > 

> > 

> > I have good news for you: there is an optimization to BIP360 which would make single-signer Schnorr spending significantly (32 bytes) cheaper. It's not my idea so I don't want to jump the gun in explaining the details, but expect another mailing list post soon with more info.
> 

> 

> It's possible to allow a Merkle tree whose leaves are either EC keys or scripts, and then allow spending from the key-leaves by revealing the path and a signature, but recover the expected public key from the signature. That needs a variation of BIP340 that doesn't commit to the public keys (which may break some of the proofs of higher-level schemes, but as long as there is no ANYPREVOUT like functionality, the message implicitly commits to the output so that may be fine). But even with that, efficiency is 32 bytes worse than P2TR, because in a Q-safe setting with at least one additional PQC branch, you have at least 32 bytes of Merkle path. Is this what you have in mind?
> -- 
> Pieter
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/jVpYczjMUwILN76cjc9LSoXttkuOrkClgAX6gwtlQ4-lVEcGFKD8tEp72zhTCzCqmOdyrkyuoyGF2DA-p5WebDgmgXyAGpBnH6mYRGvl1-I%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 28011 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Draft] Testnet 5
  2026-06-02 16:22  0%   ` Garlo Nicon
@ 2026-06-02 16:48  0%     ` 'Pol Espinasa' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'Pol Espinasa' via Bitcoin Development Mailing List @ 2026-06-02 16:48 UTC (permalink / raw)
  To: Garlo Nicon; +Cc: Saint Wenhao, bitcoindev@googlegroups.com


[-- Attachment #1.1.1: Type: text/plain, Size: 6378 bytes --]

Hi Garlo,

> So, are there any use cases, where testnet5 is needed, and signet cannot be used?"


Yes, as per the BIP text: "However, signet does not allow miners to test that their software reliably follows the rules of BIP 54. Testnet 5 provides a testing environment for this."

You want to test the same software that you are aiming to run on mainnet, not a modified version that allows you to solve some PoW puzzles. Also, you want to test enforcement of consensus rules on block creation and validation, and check interaction with other nodes and miners.


Pol

On Tuesday, June 2nd, 2026 at 6:23 PM, Garlo Nicon garlonicon@gmail.com wrote:

> > coins being too difficult to mine without a lot of hash rate
> 

> It could be easily solved, if blocks with regular difficulty would replace the min-difficulty ones. Because the current rule forces all miners, with CPUs, GPUs, ASICs, or anything else, to produce a min-difficulty block after 20 minutes. However, there are many different ways to handle that. For example: after 20 minutes, block with any difficulty could be accepted, but could be reorged by stronger miners later. Then, the network would never be stuck.
> 

> Or: to discourage mining low-difficulty blocks, the amount of the coinbase could be adjusted, proportionally to the difficulty. You don't have hashpower, to mine a block with 1M difficulty, and receive 50 tBTC? No problem, mine million times easier block, get 5k tBTC for testing, and do your tests. If stronger miner will appear, they will have a chance to reorg you, but the same is true in testnet3 and testnet4.
> 

> > I wonder if the goal of having a clone of mainnet with worthless coins is even possible.
> 

> Currently, even signet coins are traded for mainnet BTCs, so probably not. By the way: I wonder, if there are any tests, where testnets like testnet3 or testnet4 are still needed. Because most things can be covered by regtest and signet. And if someone needs to test mining, then coins can be locked to a Proof of Work in many ways, and then, miners could claim them, by solving such puzzle. And it works even on mainnet, all you need is using OP_SIZE on a DER signature, to reach an arbitrary difficulty: https://github.com/adambor/btc-pow-locked-outputs/
> 

> So, are there any use cases, where testnet5 is needed, and signet cannot be used?
> 

> wt., 2 cze 2026 o 17:05 Saint Wenhao saintwenhao@gmail.com napisał(a):
> 

> > > I am sharing a BIP draft for a new Testnet5.
> > 

> > Interesting. Does it mean, that testnet4 fixes won't be done? https://batmanbytes.github.io/testnet4-softfork/
> > 

> > > For the Pubkey field, use a recent Bitcoin mainnet block hash.
> > 

> > Do you mean taking the hash of the block, and using it as x-value for a public key? Then, it could be potentially spendable, if it would be a valid secp256k1 point, and people would send more coins to it, or unspendable, if it would be outside of the curve. For example:
> > 

> > spendable: 0200000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
> > unspendable: 02000000000000000000013ac2955a2b6029bc1a86ab4b19e01e8030ceb0eeb2ae OP_CHECKSIG
> > unspendable: 00000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
> > 

> > Also, if the size of the stack push would be different than 33 or 65 bytes, then it would be unspendable (for example if it would take 32 bytes, like block hashes, and would be followed by OP_CHECKSIG, to invalidate it, or if it would start with OP_RETURN).
> > 

> > > Difficulty: 0x1d00ffff
> > 

> > I wonder, how quickly it would be listed on exchanges, and traded. Because historically, new testnets were launched, when that happened. But today, new coins are listed faster, than they are replaced. Which would give the creator with any ASIC an incentive, to mine initial 30k or so blocks, keep them for a while, and then sell for BTCs, when the coin will be listed.
> > 

> > Also, I wonder if testnet5 will have any premine. Previous attempt to create testnet5: https://bitcointalk.org/index.php?topic=5543921
> > 

> > > Testnet 5 also does not apply the difficulty exception rule from Testnet 3 or Testnet 4 requires.
> > 

> > It would be nice to simplify the code, and remove that rule completely from sources, but it would probably take a while to deprecate testnet3 and testnet4.
> > 

> > wt., 2 cze 2026 o 13:27 'Pol Espinasa' via Bitcoin Development Mailing List bitcoindev@googlegroups.com napisał(a):
> > 

> > > Dear list,
> > > I am sharing a BIP draft for a new Testnet5.
> > > People are complaining about Testnet4 being difficult to use, the new testnet also works as a miner playground for BIP54, we are killing two birds with one stone.
> > > 

> > > You can find the full text to read and comment on in the following draft PR: https://github.com/fjahr/bips/pull/2
> > > Feel free to leave inline comments there or respond here on the list.
> > > 

> > > Pol
> > > 

> > > --
> > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com.
> > 

> > --
> > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CACgYNOKGG1ht-2deT3jP81BzMrcqYd8tTL-tXeX-Z5sugUngJw%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ZjV9FwOf2ShRUaaQWs6LZoHTDjbF8WmfmDptSF3x-V6rNducvUu7IRoXKfz7ZYnkxX9b4r8rIsKXcpMTgVNA7QS8qALJqCYEVRyaXrmwaXA%3D%40protonmail.com.

[-- Attachment #1.1.2.1: Type: text/html, Size: 7920 bytes --]

[-- Attachment #1.2: publickey - polespinasa@protonmail.com - 0x44205759.asc --]
[-- Type: application/pgp-keys, Size: 856 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Testnet 5
  2026-06-02 15:02  1% ` Saint Wenhao
  2026-06-02 15:29  0%   ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  2026-06-02 16:22  0%   ` Garlo Nicon
@ 2026-06-02 16:37  0%   ` 'Pol Espinasa' via Bitcoin Development Mailing List
  2 siblings, 0 replies; 200+ results
From: 'Pol Espinasa' via Bitcoin Development Mailing List @ 2026-06-02 16:37 UTC (permalink / raw)
  To: Saint Wenhao; +Cc: bitcoindev@googlegroups.com


[-- Attachment #1.1: Type: text/plain, Size: 4480 bytes --]

Hi,


On Tuesday, June 2nd, 2026 at 5:02 PM, Saint Wenhao <saintwenhao@gmail.com> wrote:

> > I am sharing a BIP draft for a new Testnet5.
>
> Interesting. Does it mean, that testnet4 fixes won't be done? https://batmanbytes.github.io/testnet4-softfork/

They won't (or at least it is not what we are proposing here), I agree with Antoine that a fresh start is better than just pile up workarounds.
Sometimes the cure is worse than the disease.

> > For the Pubkey field, use a recent Bitcoin mainnet block hash.
>
> Do you mean taking the hash of the block, and using it as x-value for a public key? Then, it could be potentially spendable, if it would be a valid secp256k1 point, and people would send more coins to it, or unspendable, if it would be outside of the curve. For example:
>
> spendable: 0200000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
> unspendable: 02000000000000000000013ac2955a2b6029bc1a86ab4b19e01e8030ceb0eeb2ae OP_CHECKSIG
> unspendable: 00000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
>
> Also, if the size of the stack push would be different than 33 or 65 bytes, then it would be unspendable (for example if it would take 32 bytes, like block hashes, and would be followed by OP_CHECKSIG, to invalidate it, or if it would start with OP_RETURN).

yes, as per the original text in the draft: "the output is provably unspendable". The idea comes from: https://github.com/bitcoin/bitcoin/pull/29775#issuecomment-2093516015, https://github.com/bitcoin/bitcoin/pull/29775#issuecomment-2095786951, https://github.com/bitcoin/bitcoin/pull/29775#issuecomment-2099974737


> > Difficulty: 0x1d00ffff
>
> I wonder, how quickly it would be listed on exchanges, and traded. Because historically, new testnets were launched, when that happened. But today, new coins are listed faster, than they are replaced. Which would give the creator with any ASIC an incentive, to mine initial 30k or so blocks, keep them for a while, and then sell for BTCs, when the coin will be listed.

That is a risk, but I personally don't think there is any real solution for that. It is impossible to avoid people selling coins.
I hope the risk of resetting the network or starting a new one (as we did multiple times, and we are suggesting here) is enough for coins to not have "much" value.

> Also, I wonder if testnet5 will have any premine. Previous attempt to create testnet5: https://bitcointalk.org/index.php?topic=5543921

It will not, using a mainnnet block hash in the Pubkey field acts as an anti-premine-commitment.

> > Testnet 5 also does not apply the difficulty exception rule from Testnet 3 or Testnet 4 requires.
>
> It would be nice to simplify the code, and remove that rule completely from sources, but it would probably take a while to deprecate testnet3 and testnet4.

I agree that might take time, but that is a node client implementation detail :)

> wt., 2 cze 2026 o 13:27 'Pol Espinasa' via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> napisał(a):
>
> > Dear list,
> > I am sharing a BIP draft for a new Testnet5.
> > People are complaining about Testnet4 being difficult to use, the new testnet also works as a miner playground for BIP54, we are killing two birds with one stone.
> >
> > You can find the full text to read and comment on in the following draft PR: https://github.com/fjahr/bips/pull/2
> > Feel free to leave inline comments there or respond here on the list.
> >
> >
> >
> >
> > Pol
> >
> > --
> > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/FJTfAMGEfN5PH0phIMiQ--jMyFCzpSHQpZb8eg8ZMVKFqTMZtzjYrPz2qB6HIvAl81ZSuMCH88i3_B_vYcCmhmi8laRxbgOtFEBh0h24GK8%3D%40protonmail.com.

[-- Attachment #1.2: publickey - polespinasa@protonmail.com - 0x44205759.asc --]
[-- Type: application/pgp-keys, Size: 856 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Testnet 5
  2026-06-02 15:02  1% ` Saint Wenhao
  2026-06-02 15:29  0%   ` 'Antoine Poinsot' via Bitcoin Development Mailing List
@ 2026-06-02 16:22  0%   ` Garlo Nicon
  2026-06-02 16:48  0%     ` 'Pol Espinasa' via Bitcoin Development Mailing List
  2026-06-02 16:37  0%   ` 'Pol Espinasa' via Bitcoin Development Mailing List
  2 siblings, 1 reply; 200+ results
From: Garlo Nicon @ 2026-06-02 16:22 UTC (permalink / raw)
  To: Saint Wenhao; +Cc: Pol Espinasa, bitcoindev@googlegroups.com

[-- Attachment #1: Type: text/plain, Size: 5977 bytes --]

> coins being too difficult to mine without a lot of hash rate

It could be easily solved, if blocks with regular difficulty would replace
the min-difficulty ones. Because the current rule forces all miners, with
CPUs, GPUs, ASICs, or anything else, to produce a min-difficulty block
after 20 minutes. However, there are many different ways to handle that.
For example: after 20 minutes, block with any difficulty could be accepted,
but could be reorged by stronger miners later. Then, the network would
never be stuck.

Or: to discourage mining low-difficulty blocks, the amount of the coinbase
could be adjusted, proportionally to the difficulty. You don't have
hashpower, to mine a block with 1M difficulty, and receive 50 tBTC? No
problem, mine million times easier block, get 5k tBTC for testing, and do
your tests. If stronger miner will appear, they will have a chance to reorg
you, but the same is true in testnet3 and testnet4.

> I wonder if the goal of having a clone of mainnet with worthless coins is
even possible.

Currently, even signet coins are traded for mainnet BTCs, so probably not.
By the way: I wonder, if there are any tests, where testnets like testnet3
or testnet4 are still needed. Because most things can be covered by regtest
and signet. And if someone needs to test mining, then coins can be locked
to a Proof of Work in many ways, and then, miners could claim them, by
solving such puzzle. And it works even on mainnet, all you need is using
OP_SIZE on a DER signature, to reach an arbitrary difficulty:
https://github.com/adambor/btc-pow-locked-outputs/

So, are there any use cases, where testnet5 is needed, and signet cannot be
used?

wt., 2 cze 2026 o 17:05 Saint Wenhao <saintwenhao@gmail.com> napisał(a):

> > I am sharing a BIP draft for a new Testnet5.
>
> Interesting. Does it mean, that testnet4 fixes won't be done?
> https://batmanbytes.github.io/testnet4-softfork/
>
> > For the Pubkey field, use a recent Bitcoin mainnet block hash.
>
> Do you mean taking the hash of the block, and using it as x-value for a
> public key? Then, it could be potentially spendable, if it would be a valid
> secp256k1 point, and people would send more coins to it, or unspendable, if
> it would be outside of the curve. For example:
>
> spendable:
> 0200000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084
> OP_CHECKSIG
> unspendable:
> 02000000000000000000013ac2955a2b6029bc1a86ab4b19e01e8030ceb0eeb2ae
> OP_CHECKSIG
> unspendable:
> 00000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
>
> Also, if the size of the stack push would be different than 33 or 65
> bytes, then it would be unspendable (for example if it would take 32 bytes,
> like block hashes, and would be followed by OP_CHECKSIG, to invalidate it,
> or if it would start with OP_RETURN).
>
> > Difficulty: 0x1d00ffff
>
> I wonder, how quickly it would be listed on exchanges, and traded. Because
> historically, new testnets were launched, when that happened. But today,
> new coins are listed faster, than they are replaced. Which would give the
> creator with any ASIC an incentive, to mine initial 30k or so blocks, keep
> them for a while, and then sell for BTCs, when the coin will be listed.
>
> Also, I wonder if testnet5 will have any premine. Previous attempt to
> create testnet5: https://bitcointalk.org/index.php?topic=5543921
>
> > Testnet 5 also does not apply the difficulty exception rule from Testnet
> 3 or Testnet 4 requires.
>
> It would be nice to simplify the code, and remove that rule completely
> from sources, but it would probably take a while to deprecate testnet3 and
> testnet4.
>
> wt., 2 cze 2026 o 13:27 'Pol Espinasa' via Bitcoin Development Mailing
> List <bitcoindev@googlegroups.com> napisał(a):
>
>> Dear list,
>>
>> I am sharing a BIP draft for a new Testnet5.
>> People are complaining about Testnet4 being difficult to use, the new
>> testnet also works as a miner playground for BIP54, we are killing two
>> birds with one stone.
>>
>> You can find the full text to read and comment on in the following draft
>> PR: https://github.com/fjahr/bips/pull/2
>> Feel free to leave inline comments there or respond here on the list.
>>
>>
>> Pol
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CACgYNOKGG1ht-2deT3jP81BzMrcqYd8tTL-tXeX-Z5sugUngJw%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CACgYNOKGG1ht-2deT3jP81BzMrcqYd8tTL-tXeX-Z5sugUngJw%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAN7kyNiH_8hnBmxBR8rPc%2BwYwbKPRy51yif3jRXofHbFFKsSgQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8034 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Testnet 5
  2026-06-02 15:02  1% ` Saint Wenhao
@ 2026-06-02 15:29  0%   ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  2026-06-02 16:22  0%   ` Garlo Nicon
  2026-06-02 16:37  0%   ` 'Pol Espinasa' via Bitcoin Development Mailing List
  2 siblings, 0 replies; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2026-06-02 15:29 UTC (permalink / raw)
  To: Saint Wenhao; +Cc: Pol Espinasa, bitcoindev@googlegroups.com

[-- Attachment #1: Type: text/plain, Size: 3982 bytes --]

Hi,

On Tuesday, June 2nd, 2026 at 11:05 AM, Saint Wenhao <saintwenhao@gmail.com> wrote:

>> I am sharing a BIP draft for a new Testnet5.
>
> Interesting. Does it mean, that testnet4 fixes won't be done? https://batmanbytes.github.io/testnet4-softfork/

I for one believe we are better off ripping the band-aid and starting fresh than trying to pile up more workarounds.

>> For the Pubkey field, use a recent Bitcoin mainnet block hash.
>
> Do you mean taking the hash of the block, and using it as x-value for a public key? Then, it could be potentially spendable, if it would be a valid secp256k1 point, and people would send more coins to it, or unspendable, if it would be outside of the curve. For example:
>
> spendable: 0200000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
> unspendable: 02000000000000000000013ac2955a2b6029bc1a86ab4b19e01e8030ceb0eeb2ae OP_CHECKSIG
> unspendable: 00000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG
>
> Also, if the size of the stack push would be different than 33 or 65 bytes, then it would be unspendable (for example if it would take 32 bytes, like block hashes, and would be followed by OP_CHECKSIG, to invalidate it, or if it would start with OP_RETURN).
>
>> Difficulty: 0x1d00ffff
>
> I wonder, how quickly it would be listed on exchanges, and traded. Because historically, new testnets were launched, when that happened. But today, new coins are listed faster, than they are replaced. Which would give the creator with any ASIC an incentive, to mine initial 30k or so blocks, keep them for a while, and then sell for BTCs, when the coin will be listed.
>
> Also, I wonder if testnet5 will have any premine. Previous attempt to create testnet5: https://bitcointalk.org/index.php?topic=5543921
>
>> Testnet 5 also does not apply the difficulty exception rule from Testnet 3 or Testnet 4 requires.
>
> It would be nice to simplify the code, and remove that rule completely from sources, but it would probably take a while to deprecate testnet3 and testnet4.
>
> wt., 2 cze 2026 o 13:27 'Pol Espinasa' via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> napisał(a):
>
>> Dear list,
>>
>> I am sharing a BIP draft for a new Testnet5.
>> People are complaining about Testnet4 being difficult to use, the new testnet also works as a miner playground for BIP54, we are killing two birds with one stone.
>>
>> You can find the full text to read and comment on in the following draft PR: https://github.com/fjahr/bips/pull/2
>> Feel free to leave inline comments there or respond here on the list.
>>
>> Pol
>>
>> --
>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com.
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CACgYNOKGG1ht-2deT3jP81BzMrcqYd8tTL-tXeX-Z5sugUngJw%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/Note5jyeHB1BStZ3AMHw2aYjj8KmOuSO7wl8FAAEj8lzo9PFX6972iUY6iWbcG0VidvpgRbw-gh1dZTC3DTlELA3pjANhz_1WLW7P1KiXL4%3D%40protonmail.com.

[-- Attachment #2: Type: text/html, Size: 7390 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Testnet 5
  @ 2026-06-02 15:02  1% ` Saint Wenhao
  2026-06-02 15:29  0%   ` 'Antoine Poinsot' via Bitcoin Development Mailing List
                     ` (2 more replies)
  0 siblings, 3 replies; 200+ results
From: Saint Wenhao @ 2026-06-02 15:02 UTC (permalink / raw)
  To: Pol Espinasa; +Cc: bitcoindev@googlegroups.com

[-- Attachment #1: Type: text/plain, Size: 3519 bytes --]

> I am sharing a BIP draft for a new Testnet5.

Interesting. Does it mean, that testnet4 fixes won't be done?
https://batmanbytes.github.io/testnet4-softfork/

> For the Pubkey field, use a recent Bitcoin mainnet block hash.

Do you mean taking the hash of the block, and using it as x-value for a
public key? Then, it could be potentially spendable, if it would be a valid
secp256k1 point, and people would send more coins to it, or unspendable, if
it would be outside of the curve. For example:

spendable:
0200000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084
OP_CHECKSIG
unspendable:
02000000000000000000013ac2955a2b6029bc1a86ab4b19e01e8030ceb0eeb2ae
OP_CHECKSIG
unspendable:
00000000000000000001799c6f72ebe5ebc6b18fd5cdf8bd3697b8d73d01b084 OP_CHECKSIG

Also, if the size of the stack push would be different than 33 or 65 bytes,
then it would be unspendable (for example if it would take 32 bytes, like
block hashes, and would be followed by OP_CHECKSIG, to invalidate it, or if
it would start with OP_RETURN).

> Difficulty: 0x1d00ffff

I wonder, how quickly it would be listed on exchanges, and traded. Because
historically, new testnets were launched, when that happened. But today,
new coins are listed faster, than they are replaced. Which would give the
creator with any ASIC an incentive, to mine initial 30k or so blocks, keep
them for a while, and then sell for BTCs, when the coin will be listed.

Also, I wonder if testnet5 will have any premine. Previous attempt to
create testnet5: https://bitcointalk.org/index.php?topic=5543921

> Testnet 5 also does not apply the difficulty exception rule from Testnet
3 or Testnet 4 requires.

It would be nice to simplify the code, and remove that rule completely from
sources, but it would probably take a while to deprecate testnet3 and
testnet4.

wt., 2 cze 2026 o 13:27 'Pol Espinasa' via Bitcoin Development Mailing List
<bitcoindev@googlegroups.com> napisał(a):

> Dear list,
>
> I am sharing a BIP draft for a new Testnet5.
> People are complaining about Testnet4 being difficult to use, the new
> testnet also works as a miner playground for BIP54, we are killing two
> birds with one stone.
>
> You can find the full text to read and comment on in the following draft
> PR: https://github.com/fjahr/bips/pull/2
> Feel free to leave inline comments there or respond here on the list.
>
>
> Pol
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com
> <https://groups.google.com/d/msgid/bitcoindev/BrgqDZiNhpEz32-Z9ZX2rrPDE9EUIb62SKT2WsTo-yZtd3gLMLVk6TkO6kLIR96-87TumXqi92l_m1j3xlJr1tcJwG_I3UVDk2NZgXZL8fw%3D%40protonmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CACgYNOKGG1ht-2deT3jP81BzMrcqYd8tTL-tXeX-Z5sugUngJw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 5157 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Hybrid SPHINCS+ / secp256k1 Key Derivation for Quantum-Resistant Paper Wallets
  @ 2026-05-27  0:51  1% ` 'conduition' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'conduition' via Bitcoin Development Mailing List @ 2026-05-27  0:51 UTC (permalink / raw)
  To: 3D; +Cc: bitcoindev


[-- Attachment #1.1.1: Type: text/plain, Size: 3636 bytes --]

> 3’s Company HE-SD (High-Entropy Seed Distillation) algorithm



Never heard of that. Google shows no results. Doesn't seem to exist.


> (which uses SPX-QEC for cleanup)



Cleanup of what? What is SPX-QEC? Your draft doc links to this word-salad repo. I can't make sense of how this is related.


> This is intended as a practical bridge for quantum-hardened cold storage/paper wallets while post-quantum consensus migration is still in the future.


What does this even mean? There is no way to "quantum harden" a secp256k1 keypair with different entropy, despite what some snake-oil salesmen are saying. A curve point is a curve point and Shor's algorithm can factor it to find its discrete log just as well as any other point.

Mods, this appears to be an underinformed proposal at best, AI slop/spam, or even phishing at worst. 

Needless to say but I'll say it anyway: Don't use this tool to generate paper wallet keys. The keygen code is unreadable gibberish to my eye. Output entropy could be compromised in a way that only the author knows, designed to steal any money deposited into the output keys. Don't click on links to websites you don't already know & trust.

DigiMancer3D, if this is not the case, please explain your proposal better and document your code.


regards,
conduition
On Tuesday, May 26th, 2026 at 6:19 PM, '3D' via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> wrote:

> Hi all,
> I'd like to propose a new wallet-layer BIP for a practical hybrid post-quantum key derivation scheme.
> 

> **Title:** Hybrid SPHINCS+ / secp256k1 Key Derivation for Quantum-Resistant Bitcoin Wallets
> 

> **Summary:**
> This BIP defines a simple, immediately usable method that combines NIST-standardized SLH-DSA (SPHINCS+) with the 3’s Company HE-SD (High-Entropy Seed Distillation) algorithm (which uses SPX-QEC for cleanup) to derive ordinary secp256k1 private keys and standard Bitcoin addresses (legacy + BIP-341 Taproot).
> 

> The process is fully offline, runs on low-end/air-gapped hardware (Raspberry Pi class), and produces keys that work today with Electrum, bitaddress.org, and Bitcoin Core; no consensus changes required.
> 

> **Reference implementation & full code:**
> https://github.com/DigiMancer3D/bip-xxx-sphincs-hybrid
> 

> **Draft BIP text:**
> https://github.com/DigiMancer3D/bip-xxx-sphincs-hybrid/blob/main/bip-xxx.mediawiki
> 

> This is intended as a practical bridge for quantum-hardened cold storage/paper wallets while post-quantum consensus migration is still in the future.
> 

> Happy to answer questions, incorporate feedback, and make any changes needed.
> 

> Thanks,
> DigiMancer3D
> 

> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/bpSypbIuSoDinhE-Y4CrVI5LGHrJ_I79xYUzpYswA5JGkbASwibq94UozeR2jsu48vH6FZLdEBPpWHgIuVtSpUNy-tRpnGfe1hce2ti8k5w%3D%40protonmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/8xzOqkvC9ILirjnikYtVVAW60ZqDGF9RfQi4hZ-g9gM7Ex4onLrDLT132wC2ObA8F1oixXZRGT-uE8DMc7qoVYhh9pCO2ioFT76RzbLoi08%3D%40proton.me.

[-- Attachment #1.1.2.1: Type: text/html, Size: 8843 bytes --]

[-- Attachment #1.2: publickey - conduition@proton.me - 0x474891AD.asc --]
[-- Type: application/pgp-keys, Size: 649 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Draft] P2P UTXO Set Sharing
  2026-05-16  0:58  1%         ` eric
@ 2026-05-16 17:58  0%           ` Saint Wenhao
  2026-05-16 21:48  0%             ` 'Fabian' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Saint Wenhao @ 2026-05-16 17:58 UTC (permalink / raw)
  To: eric; +Cc: Bitcoin Development Mailing List, Fabian, Anthony Towns

[-- Attachment #1: Type: text/plain, Size: 7410 bytes --]

> I commonly see people expecting IBD to take a week or more

Because it is true, at least for me, and maybe also for some others. You
can read some examples on forums, where people run full nodes, and post
their progress on a regular basis:
https://bitcointalk.org/index.php?topic=5480200

Currently, I started Initial Blockchain Download on some node. It is now
around block 250,000, after few hours. It shows around 1 MB/s in the
"Network Traffic" tab from the GUI client. Even if my Internet speed may be
better than that, then still: it is limited by what my peers can provide.
And if I check 10 connected nodes, and all use NETWORK_LIMITED flag, so all
are in pruned mode, and all just act as proxies, fetching blocks from other
full, archival nodes, then guess what: it is limited to the weakest link,
the slowest node in the chain of connections.

When I did the same experiment some months ago, but this time from some
VPS, running 24/7, my results were quite similar. Waiting around a week to
be fully synced is normal for me, and I got used to that.

Also, I understand, why full, archival nodes, use rate limits: because
otherwise, they would pay more bandwidth fees, if everyone would be able to
get everything instantly, at full speed. Which is why when many people
limit their connections, to not share too much data too fast, it is what it
is. And it is normal, because nodes are not rewarded for their services, so
they have no incentive to provide more, than the bare minimum they can
handle.

sob., 16 maj 2026 o 03:01 <eric@voskuil.org> napisał(a):

> > From: Anthony Towns
>
> > On Tue, May 12, 2026 at 11:56:33AM -0400, eric@voskuil.org wrote:
> > > > AssumeUTXO  is a UX improvement for those interested in running a
> > > > fully validating node. The option to get started in a very limited
> > > > amount of time [...]
>
> > > It's not at all clear to me how this is a UX improvement. Get started
> doing
>
> > what?
> >
> > Getting started validating blocks and transactions at the current tip; ie
> > receiving payments.
>
> Receiving payments without having validated is an exceedingly unwise
> scenario, and not worthy of protocol support.
>
> If you have not fully validated every block in history, you have not
> validated at all. The validity of a block requires the validity of all
> prior blocks.
>
> There seems to be a common misapprehension that using a trusted utxo store
> is something akin to SPV. This is not the case. A node/wallet could
> certainly also implement SPV and use it while downloading/validating,
> though that eliminates the use case for trusted utxo state.
>
> Using a trusted utxo store for transacting is equivalent to a fully
> trusting wallet. The person is 100% trusting that the state of their node
> is valid - having not validated any of it until having validated all of it.
> Accepting this as a matter of protocol is irresponsible.
>
> If you want a reduced (vs. zero) level of security while downloading and
> validating the chain, I suggest implementing an SPV wallet that transitions
> to a full node wallet after downloading and validating the full chain.
>
> > Obtaining the full Bitcoin blockchain currently requires downloading
> about
> > 600GB of data. At 250Mbps with perfectly well-behaved peers, that's a bit
> > under 7 hours. At the consumer level, bandwidth seems to be the
> bottleneck,
> > with modern PCs being able to validate the blockchain in about that time.
>
> Let's look at the trend:
>
> May 2016
> ---------------------------------------------------------------------------
> Blockchain size: ~80 GB
> Median U.S. broadband speed: 39 Mbps
> Download time: 4 hours 33 minutes
>
> 80 × 8,000 = 640,000 Mb
> 640,000 ÷ 39 ≈ 16,410 seconds
> 16,410 ÷ 3,600 ≈ 4.558 hours (4 hours 33 minutes)
>
> May 2021
> ---------------------------------------------------------------------------
> Blockchain size: 343.5 GB
> Median U.S. broadband speed: 100 Mbps
> Download time: 7 hours and 38 minutes
>
> 343.5 × 8,000 = 2,748,000 Mb
> 2,748,000 ÷ 100 = 27,480 seconds
> 27,480 ÷ 3,600 ≈ 7.633 hours (7 hours and 38 minutes)
>
> May 2026
> ---------------------------------------------------------------------------
> Blockchain size: 739.2 GB
> Median U.S. broadband speed: 308 Mbps
> Download time: 5 hours and 20 minutes
>
> 739.2 × 8,000 = 5,913,600 Mb
> 5,913,600 ÷ 308 = 19,200 seconds
> 19,200 ÷ 3,600 = 5.333… hours (5 hours and 20 minutes)
>
> ---------------------------------------------------------------------------
>
> Despite a 4x max block size increase in 2016, download time is
> *decreasing*.
>
> It only increased in early years because blocks went from empty to ~full
> (median block ~1MB in 2016), coupled with segwit 4MB limit impact.
>
> > AssumeUTXO significantly reduces the download requirement, with the utxo
> > snapshot at block 935000 being under 9GB. At 100Mbps with perfectly well-
> > behaved peers, that's about 15m to download. Adding in another 8GB-34GB
> > of actual block data to download (assuming that the utxo snapshot people
> use
> > will be between 4 and 17 weeks out of date) brings that up to 30 minutes
> to
> > an hour.
>
> Downloading an additional 9GB only increases the total download
> requirement/time.
>
> What has been increasing is the perception of increased block data
> exceeding Moore's Law. This perception has fed the spam debacle. This
> perception is rooted in the reality that sequential indexation (even
> without validation) does not (cannot) fully take advantage of advancing
> hardware. This is an implementation issue.
>
> Chain growth is linearly bounded. Hardware growth at a given cost is
> exponential. Even Satoshi reasoned this out. What he didn't do in his
> prototype was provide a scalable implementation - he left that to us.
> Necessary download and validation time/cost is shrinking. Eventually
> downloading and validating the chain will be as cheap as texting a video
> clip has become. It wasn't long ago that too was unthinkable.
>
> On a fast home Internet today, on the same machine I've been developing on
> since 2017, the full chain can be downloaded and fully validated in under 5
> hours. That's less time than it took almost 10 years ago on the same
> machine - and my real Internet cost today is about half what it was at that
> time.
>
> So I reiterate my NACK. This is a very unwise idea, without justification
> for network protocol integration.
>
> Best,
> Eric
>
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/002301dce4cf%2427bc3040%24773490c0%24%40voskuil.org
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CACgYNOJVvO9BgMHspYKyKtcOZZpXqERbwgxnLi%3DecTXO8HuM4Q%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8552 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Draft] P2P UTXO Set Sharing
  2026-05-16 17:58  0%           ` Saint Wenhao
@ 2026-05-16 21:48  0%             ` 'Fabian' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'Fabian' via Bitcoin Development Mailing List @ 2026-05-16 21:48 UTC (permalink / raw)
  To: Saint Wenhao; +Cc: eric, Bitcoin Development Mailing List, Anthony Towns

[-- Attachment #1: Type: text/plain, Size: 13880 bytes --]

Hi Eric,

Sorry for the late reply. I'm responding to bits of both your last emails since
they made closely related points.

> It's not at all clear to me how this is a UX improvement. Get started doing what?

Aside from the most obvious case that was already named, receiving payments for
goods and services, I would name mining without a centralized template provider
as an equally important use case.

> Receiving payments without having validated is an exceedingly unwise scenario,
> and not worthy of protocol support.

For most merchants this scenario is much preferred to not receiving payments at
all for an extended period of time if they don't have great hardware and bandwidth
at their store or home. I also need to add that an AssumeUTXO node is not
"not validated". The header chain is fully validated before the snapshot is
loaded, and the historical blocks are validated in the background. The work is
the same, only the node becomes usable earlier.

That IBD sync time has been a real deterrent for users choosing a fully
validating node for their PoS setup is demonstrated by the fact that BTCPayServer
shipped their own AssumeUTXO equivalent before AssumeUTXO existed: https://docs.btcpayserver.org/Docker/fastsync/
They also did so with a worse trust model than what is proposed here, a tarball from
a single trusted source.

> There seems to be a common misapprehension that using a trusted utxo store is
> something akin to SPV. This is not the case. A node/wallet could certainly also
> implement SPV and use it while downloading/validating, though that eliminates
> the use case for trusted utxo state.

No such software exists, and I think the reason is that most users would not
bother validating anymore once they have turned to SPV. With AssumeUTXO the
situation is different: there is no option to skip background validation of the
chain.

There will always an alternative solution available for those who don't want to
or can't wait for IBD to finish, and it will always be a worse one than what is
being proposed here. Why should users bother with SPV then? We will continue
to lose users to custodial solutions if we are not willing to offer alternatives
with a UX that at least comes somewhat close to what today's consumers
are used to.

Being able to transact with IBD running in the background also takes away the
economic and other pressure off of those who need to get a node started quickly.

> But of course this presents another problem, that of the cost of validating
> them, requiring full validation of the chain. So this inevitably leads to miner
> commitments.

AssumeUTXO is anchored to a hash that is hardcoded in Bitcoin Core and reviewed
in the open. Anyone running a fully validating node can independently reproduce
it from their own UTXO set. That has no relationship to miner behaviour or
PoW-based commitments, and Strateman's concern with about a >50% attacker
creating new bitcoin, does not apply to it. If anything, providing a working P2P
path for snapshot distribution reduces the pressure for any future commitment
scheme rather than enabling one, because the user-facing problem that motivates
commitments is already addressed.

> Even if for some reason you cannot comment, I and others can.

I did comment, I just pointed out that I cannot disprove something that doesn't
exist. I have not been part of any such conversations and I have not heard of
anyone being part of them.

> It is not hypothetical, and it is dangerous. This understanding is at least
> 11 years old:

Old mailing list conversations are useful context but they don't prove anything.
The author of the original Bitcoin Prototype software also wrote, "I don't
believe a second, compatible implementation of Bitcoin will ever be a good idea"
(https://satoshi.nakamotoinstitute.org/posts/bitcointalk/threads/69/#2), and
that does not seem to have stopped you from working on libbitcoin. The Strateman
quote is a sound warning about a specific scheme, but it is not a scheme this
BIP proposes.

> These aren't limitations inherent in protocol. The implementation details of a given
> node aren't relevant.

The protocol's job here is to enable obtaining UTXO state from peers rather than from
a third-party website. What each implementation does with that capability is, indeed,
implementation. While AssumeUTXO is the primary motivation right now, there may
be other interesting use cases for this down the road.

> Median U.S. broadband speed

> Despite a 4x max block size increase in 2016, download time is decreasing.

Those figures use US-median broadband. Globally the picture is significantly
different, and a meaningful fraction of users rely on mobile or metered
connections where the difference between "over lunch" and "multiple days"
decides whether they run a node at all. The same applies to the 32 GB RAM
minimum noted for libbitcoin (https://nitter.net/evoskuil/status/2054456087252816267),
which already excludes a large share of consumer hardware outside high-income
regions.

I think disregarding hardware and network requirements of users in less developed
countries is causing much higher centralization pressures today than this UTXO
set sharing proposal ever could. Following the trajectory of the last few years
to its conclusion, the minimum is likely to be 64 GB next year, then 128 GB the
year after, and validating with libbitcoin will soon require the latest generation
of Nvidia chips. Validation time will keep going down on that path, but the
user base it serves will keep shrinking.

I am obviously exaggerating somewhat to make a point: it is easy to construct a
plausible-sounding slippery slope argument, including one about libbitcoin's
hardware trajectory. And I don't think you are able to prove today that libbitcoin
will not follow this path in the future. That is exactly why I don't find
your similar argument persuasive.

And in all seriousness, I think at least some Bitcoin implementations should aim to
be accessible with low bandwidth and minimum hardware requirements compatible
with widely available consumer hardware outside high-income regions. That is
what many of the developers I work with are aiming for.

Best,
Fabian
On Saturday, May 16th, 2026 at 7:58 PM, Saint Wenhao <saintwenhao@gmail.com> wrote:

>> I commonly see people expecting IBD to take a week or more
>
> Because it is true, at least for me, and maybe also for some others. You can read some examples on forums, where people run full nodes, and post their progress on a regular basis: https://bitcointalk.org/index.php?topic=5480200
>
> Currently, I started Initial Blockchain Download on some node. It is now around block 250,000, after few hours. It shows around 1 MB/s in the "Network Traffic" tab from the GUI client. Even if my Internet speed may be better than that, then still: it is limited by what my peers can provide. And if I check 10 connected nodes, and all use NETWORK_LIMITED flag, so all are in pruned mode, and all just act as proxies, fetching blocks from other full, archival nodes, then guess what: it is limited to the weakest link, the slowest node in the chain of connections.
>
> When I did the same experiment some months ago, but this time from some VPS, running 24/7, my results were quite similar. Waiting around a week to be fully synced is normal for me, and I got used to that.
>
> Also, I understand, why full, archival nodes, use rate limits: because otherwise, they would pay more bandwidth fees, if everyone would be able to get everything instantly, at full speed. Which is why when many people limit their connections, to not share too much data too fast, it is what it is. And it is normal, because nodes are not rewarded for their services, so they have no incentive to provide more, than the bare minimum they can handle.
>
> sob., 16 maj 2026 o 03:01 <eric@voskuil.org> napisał(a):
>
>>> From: Anthony Towns
>>
>>> On Tue, May 12, 2026 at 11:56:33AM -0400, eric@voskuil.org wrote:
>>> > > AssumeUTXO is a UX improvement for those interested in running a
>>> > > fully validating node. The option to get started in a very limited
>>> > > amount of time [...]
>>
>>> > It's not at all clear to me how this is a UX improvement. Get started doing
>>
>>> what?
>>>
>>> Getting started validating blocks and transactions at the current tip; ie
>>> receiving payments.
>>
>> Receiving payments without having validated is an exceedingly unwise scenario, and not worthy of protocol support.
>>
>> If you have not fully validated every block in history, you have not validated at all. The validity of a block requires the validity of all prior blocks.
>>
>> There seems to be a common misapprehension that using a trusted utxo store is something akin to SPV. This is not the case. A node/wallet could certainly also implement SPV and use it while downloading/validating, though that eliminates the use case for trusted utxo state.
>>
>> Using a trusted utxo store for transacting is equivalent to a fully trusting wallet. The person is 100% trusting that the state of their node is valid - having not validated any of it until having validated all of it. Accepting this as a matter of protocol is irresponsible.
>>
>> If you want a reduced (vs. zero) level of security while downloading and validating the chain, I suggest implementing an SPV wallet that transitions to a full node wallet after downloading and validating the full chain.
>>
>>> Obtaining the full Bitcoin blockchain currently requires downloading about
>>> 600GB of data. At 250Mbps with perfectly well-behaved peers, that's a bit
>>> under 7 hours. At the consumer level, bandwidth seems to be the bottleneck,
>>> with modern PCs being able to validate the blockchain in about that time.
>>
>> Let's look at the trend:
>>
>> May 2016
>> ---------------------------------------------------------------------------
>> Blockchain size: ~80 GB
>> Median U.S. broadband speed: 39 Mbps
>> Download time: 4 hours 33 minutes
>>
>> 80 × 8,000 = 640,000 Mb
>> 640,000 ÷ 39 ≈ 16,410 seconds
>> 16,410 ÷ 3,600 ≈ 4.558 hours (4 hours 33 minutes)
>>
>> May 2021
>> ---------------------------------------------------------------------------
>> Blockchain size: 343.5 GB
>> Median U.S. broadband speed: 100 Mbps
>> Download time: 7 hours and 38 minutes
>>
>> 343.5 × 8,000 = 2,748,000 Mb
>> 2,748,000 ÷ 100 = 27,480 seconds
>> 27,480 ÷ 3,600 ≈ 7.633 hours (7 hours and 38 minutes)
>>
>> May 2026
>> ---------------------------------------------------------------------------
>> Blockchain size: 739.2 GB
>> Median U.S. broadband speed: 308 Mbps
>> Download time: 5 hours and 20 minutes
>>
>> 739.2 × 8,000 = 5,913,600 Mb
>> 5,913,600 ÷ 308 = 19,200 seconds
>> 19,200 ÷ 3,600 = 5.333… hours (5 hours and 20 minutes)
>>
>> ---------------------------------------------------------------------------
>>
>> Despite a 4x max block size increase in 2016, download time is *decreasing*.
>>
>> It only increased in early years because blocks went from empty to ~full (median block ~1MB in 2016), coupled with segwit 4MB limit impact.
>>
>>> AssumeUTXO significantly reduces the download requirement, with the utxo
>>> snapshot at block 935000 being under 9GB. At 100Mbps with perfectly well-
>>> behaved peers, that's about 15m to download. Adding in another 8GB-34GB
>>> of actual block data to download (assuming that the utxo snapshot people use
>>> will be between 4 and 17 weeks out of date) brings that up to 30 minutes to
>>> an hour.
>>
>> Downloading an additional 9GB only increases the total download requirement/time.
>>
>> What has been increasing is the perception of increased block data exceeding Moore's Law. This perception has fed the spam debacle. This perception is rooted in the reality that sequential indexation (even without validation) does not (cannot) fully take advantage of advancing hardware. This is an implementation issue.
>>
>> Chain growth is linearly bounded. Hardware growth at a given cost is exponential. Even Satoshi reasoned this out. What he didn't do in his prototype was provide a scalable implementation - he left that to us. Necessary download and validation time/cost is shrinking. Eventually downloading and validating the chain will be as cheap as texting a video clip has become. It wasn't long ago that too was unthinkable.
>>
>> On a fast home Internet today, on the same machine I've been developing on since 2017, the full chain can be downloaded and fully validated in under 5 hours. That's less time than it took almost 10 years ago on the same machine - and my real Internet cost today is about half what it was at that time.
>>
>> So I reiterate my NACK. This is a very unwise idea, without justification for network protocol integration.
>>
>> Best,
>> Eric
>>
>> --
>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to [bitcoindev+unsubscribe@googlegroups.com](mailto:bitcoindev%2Bunsubscribe@googlegroups.com).
>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/002301dce4cf%2427bc3040%24773490c0%24%40voskuil.org.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/RiAeHX6Gt48YabQbYIIOFyMF63Pziq12Czi1gSAHlXZ3dBWHIs6l5P-egzOYpyShLUQKVcIeb1pW358WsHR5pALr6T5xAHoN6Igg9Hg0NS0%3D%40protonmail.com.

[-- Attachment #2: Type: text/html, Size: 19405 bytes --]

^ permalink raw reply	[relevance 0%]

* RE: [bitcoindev] Re: [BIP Draft] P2P UTXO Set Sharing
  @ 2026-05-16  0:58  1%         ` eric
  2026-05-16 17:58  0%           ` Saint Wenhao
  0 siblings, 1 reply; 200+ results
From: eric @ 2026-05-16  0:58 UTC (permalink / raw)
  To: 'Bitcoin Development Mailing List'
  Cc: 'Fabian', 'Anthony Towns'

> From: Anthony Towns

> On Tue, May 12, 2026 at 11:56:33AM -0400, eric@voskuil.org wrote:
> > > AssumeUTXO  is a UX improvement for those interested in running a
> > > fully validating node. The option to get started in a very limited
> > > amount of time [...]

> > It's not at all clear to me how this is a UX improvement. Get started doing

> what?
> 
> Getting started validating blocks and transactions at the current tip; ie
> receiving payments.

Receiving payments without having validated is an exceedingly unwise scenario, and not worthy of protocol support.

If you have not fully validated every block in history, you have not validated at all. The validity of a block requires the validity of all prior blocks.

There seems to be a common misapprehension that using a trusted utxo store is something akin to SPV. This is not the case. A node/wallet could certainly also implement SPV and use it while downloading/validating, though that eliminates the use case for trusted utxo state.

Using a trusted utxo store for transacting is equivalent to a fully trusting wallet. The person is 100% trusting that the state of their node is valid - having not validated any of it until having validated all of it. Accepting this as a matter of protocol is irresponsible.

If you want a reduced (vs. zero) level of security while downloading and validating the chain, I suggest implementing an SPV wallet that transitions to a full node wallet after downloading and validating the full chain.

> Obtaining the full Bitcoin blockchain currently requires downloading about
> 600GB of data. At 250Mbps with perfectly well-behaved peers, that's a bit
> under 7 hours. At the consumer level, bandwidth seems to be the bottleneck,
> with modern PCs being able to validate the blockchain in about that time.

Let's look at the trend:

May 2016
---------------------------------------------------------------------------
Blockchain size: ~80 GB
Median U.S. broadband speed: 39 Mbps
Download time: 4 hours 33 minutes

80 × 8,000 = 640,000 Mb
640,000 ÷ 39 ≈ 16,410 seconds
16,410 ÷ 3,600 ≈ 4.558 hours (4 hours 33 minutes)

May 2021
---------------------------------------------------------------------------
Blockchain size: 343.5 GB
Median U.S. broadband speed: 100 Mbps
Download time: 7 hours and 38 minutes

343.5 × 8,000 = 2,748,000 Mb
2,748,000 ÷ 100 = 27,480 seconds
27,480 ÷ 3,600 ≈ 7.633 hours (7 hours and 38 minutes)

May 2026
---------------------------------------------------------------------------
Blockchain size: 739.2 GB
Median U.S. broadband speed: 308 Mbps
Download time: 5 hours and 20 minutes

739.2 × 8,000 = 5,913,600 Mb
5,913,600 ÷ 308 = 19,200 seconds
19,200 ÷ 3,600 = 5.333… hours (5 hours and 20 minutes)

---------------------------------------------------------------------------

Despite a 4x max block size increase in 2016, download time is *decreasing*.

It only increased in early years because blocks went from empty to ~full (median block ~1MB in 2016), coupled with segwit 4MB limit impact.

> AssumeUTXO significantly reduces the download requirement, with the utxo
> snapshot at block 935000 being under 9GB. At 100Mbps with perfectly well-
> behaved peers, that's about 15m to download. Adding in another 8GB-34GB
> of actual block data to download (assuming that the utxo snapshot people use
> will be between 4 and 17 weeks out of date) brings that up to 30 minutes to
> an hour.

Downloading an additional 9GB only increases the total download requirement/time.

What has been increasing is the perception of increased block data exceeding Moore's Law. This perception has fed the spam debacle. This perception is rooted in the reality that sequential indexation (even without validation) does not (cannot) fully take advantage of advancing hardware. This is an implementation issue.

Chain growth is linearly bounded. Hardware growth at a given cost is exponential. Even Satoshi reasoned this out. What he didn't do in his prototype was provide a scalable implementation - he left that to us. Necessary download and validation time/cost is shrinking. Eventually downloading and validating the chain will be as cheap as texting a video clip has become. It wasn't long ago that too was unthinkable.

On a fast home Internet today, on the same machine I've been developing on since 2017, the full chain can be downloaded and fully validated in under 5 hours. That's less time than it took almost 10 years ago on the same machine - and my real Internet cost today is about half what it was at that time.

So I reiterate my NACK. This is a very unwise idea, without justification for network protocol integration.

Best,
Eric


-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/002301dce4cf%2427bc3040%24773490c0%24%40voskuil.org.


^ permalink raw reply	[relevance 1%]

* [bitcoindev] Re: Garbled Circuit and Channel Jamming
  2026-01-22  6:41  1% [bitcoindev] Garbled Circuit and Channel Jamming Antoine Riard
@ 2026-05-14  1:38  0% ` Antoine Riard
  0 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-05-14  1:38 UTC (permalink / raw)
  To: Bitcoin Development Mailing List; +Cc: btc

[-- Attachment #1: Type: text/plain, Size: 11311 bytes --]

Hi,

> Two, Alice and Caroll can always collude to have Bob never getting the HTLC
> secret and as such being penalized with the highest fee on the Alice - Bob
> channel. Somehow, Bob should be able to produce a proof proving that the
> heartbeat protocol has played out in integrality on the Bob-Caroll channel
> and that no HTLC secret was ever learn from Caroll.

After writing this initial post and walking back to home, I figured out it
was precisely broken on this precise step and never took time until now to
say why. There is an easy way for Caroll to escape the replay of Bob's heartbeat
transcript on Alice-Bob channel, i.e Caroll can just unilaterally force-close
the Bob-Caroll channel and provide the HTLC secret on-chain.

So to mitigate this, Bob's proof should be composed of the concatenation
of the "off-chain" ping-pong transcript _or/and_ the "on-chain" witness
or a trace of it. Intuitively, to satisfy any penaly script mechanism on
the Alice-Bob channel, the "on-chain" and "off-chain" state has to be
reconciliated, as any "on-chain" or "off-chain" outcome is indeed valid.

For the trace of the Bob-Caroll "closure" witness, it sounds it could
be achieved with some adaptor signature scheme, where Caroll is the
oracle for the Alice-Bob chan, the message signed would be the UTXO
or the script only, though this is asking more thinking (the signature
is pure noise, so it could *not* be set ahead of the reveal on the AB-link).

Anyway, I'm thinking that this class of "amnesic" knowledge transfer
to link an off-chain events between 2 contracting protocols rooted in
two distinct UTXOs where contracting parties might have competing interest
is very interesting. In my mind, a practical solution would be valuable
beyond the pure scope of channel jamming.

The operational model would still rely on the counterparties not hitting
the chain, though in practice the revocation - penalty mechanism of LN
is already working (how many justice txn have seen published on mainnet ?
probably in the order of 2-digits).

Best,
Antoine
OTS hash: 7f08ea7660c86cdbc6f8950782081a46f7daadd668a610d025bbeabb52d8828e


Le jeu. 22 janv. 2026 à 06:41, Antoine Riard <antoine.riard@gmail.com> a
écrit :

> Hi,
>
> Recently, before the EoY vacation to be more precise, I gave a talk on the
> BitVm
> flavors and their advances, which was the opportunity to browse back a bit
> the
> old cryptographic primitive underpinning the claimed advances. One of such
> primitive
> is indeed the old idea of "garbled circuits" and how to order knowledge
> transfer
> among two distrusted parties [0].
>
> What it's interesting for this class of cryptographic protocol is the wide
> class
> of secure multi-party game that can be built from it, and a bit of
> analysis lets
> you modelize quite easily channel jamming as a multi-party game (Alice,
> Bob, Caroll
> the next hop and the blockchain). Few years ago, when with Gleb Naumenko,
> we studied
> the solution design space for jamming, we briefly mentioned how "smart
> contract"
> (a.k.a something something covenant for more expressivity), could be a
> potential
> solution [1] [2].
>
> Looking more on "garbled circuits" made me realize that actually we might
> have already
> the primitives to envision "native contract-based" solutions to the
> channel jamming
> problem, and this with no consensus change. I.e beyond the known "monetary
> solutions"
> and "reputation-based" solutions [3]
>
> This is not the intent of this short post to discuss the merits of the
> current
> reputation-measured channel mitigation, which still have a lot of good
> properties
> like local vs global, monadic vs consensus, non-fungible vs fungible and
> lightning-endogenous vs exogenous on some scarce ressource. Rather than
> it's to
> bring some prolegomena of a solution to the problem of a channel jamming,
> as it has
> been said elegantly and succintly:
>
> "The holy grail? is indeed charging fees as a function of the time the
> HTLC was held.
> As for now, we are not aware of a reasonable way to do this. There is no
> universal
> clock, and there is no way for me to prove that a message was sent to you,
> and you
> decided to pretend you didn’t. It can easily happen that the fee for a
> two-week
> unresolved HTLC is higher than the fee for a quickly resolving one". [4]
>
> Solving this problem, in my view, means to reconciliate the off-chain
> notion
> of shared time among the 2 Lightning state machines with the on-chain
> imperative
> notion of time. A effective notion of time enabling one to determine
> objectively
> if an event did happen or not (e.g a message exchange) [0]. All the
> difficulty
> being that off-chain there is no such notion of shared time.
>
> Let's start with a strawman protocol, that is moving one step closer to an
> effective notion of shared time among 2 Lightnig state machines.
>
> One way to solve channel jamming would be to have a (taproot) tree of
> scripts
> covering the whole time range for which the funds are locked in the offered
> HTLC (so `<cltv_expiry>`). I.e for each block belonging to the cltv_expiry
> range,
> Bob pays Alice a penalty from his `counterparty_balance` (on Alice's
> commitment_tx)
> where "local channel time" is ticked by some monotonic counter. This tree
> of
> scripts would become valid to be spend after some timelock enforced grace
> delay.
>
> It should be noted, that if the HTLC routing is extending beyond the reach
> of
> Bob, Bob has no guarantee that he will get the HTLC secret before the upper
> bound of Alice's cover penaly script is reached on the Alice - Bob
> channel, e.g
> time T + 200
>
> As soon as the offered HTLC has been committed on both parties commitment
> transactions (Alice is the latest's one to receive the RAA), Alice and Bob
> starts to exchange ping-pong messages where each message is increasing the
> monotonic counter. Those messages might have as a data payload the preimage
> for which the Alice to Bob offered HTLC is pending.
>
> While Bob might have received the HTLC secret from Caroll at absolute
> blockchain
> time T + 100, and give it to Alice at time T + 110 i.e before the
> expiration of
> the hard `cltv_expiry`, Alice is always in a position to equivocate and
> said she
> never received the preimage from Bob ping-pong message.
>
> So this strawman protocol is obviously broken.
>
> Let's consider the same protocol, with few differences, the ping-pong
> messages
> between Alice and Bob are scheduled on some hearbeat rythm, so message
> happens
> every X, in way that Alice cannot guess if yes or no, a secret exchange
> did happen
> between Bob and Caroll about the next hop HTLC secret.
>
> The penalty scripts are also modified where Bob can now prove a ping
> message
> at time T + 110 has been viewed by Alice, with the correct HTLC secret. So
> Alice would make a claim by broadcasting a transaction to claim the output,
> and Bob would be able to dismiss the penaly with a valid proof of preimage
> transfer.
>
> Other modification, all ping-ping messages sent by Bob from Alice would be
> now an oblivious transfer, where Alice would sign all the pongs and the
> incremented counter [6], among those pongs would be a ciphered HTLC secret.
> This mechanism allows Bob to obtain an off-chain proof (e.g go to unblind
> the
> signed HTLC secret) that Alice has seen a preimage at time T + 110, and
> they
> can now update the HTLC commitment txn, back to the normal flow. If Alice
> stucks
> the channel, she "knows" that she would loss the proving game with Bob.
>
> However, this strawman protocol still present 2 bottlenecks, that are
> described
> in their main lines.
>
> One, there is no guarantee that Alice engage in the heartbeat protocol, so
> the HTLC commitment transaction should present some scripting path where
> the
> ping-pong messages are numbered, and if this has not reach some threshold
> before the `cltv_expiry`, she got punished on her local balance. One
> counterparty
> should always engaged in the "amnesic" knowledge transfer, under the risk
> of
> on-chain punishment.
>
> Two, Alice and Caroll can always collude to have Bob never getting the HTLC
> secret and as such being penalized with the highest fee on the Alice - Bob
> channel. Somehow, Bob should be able to produce a proof proving that the
> heartbeat protocol has played out in integrality on the Bob-Caroll channel
> and that no HTLC secret was ever learn from Caroll. That's where "garbled
> circuits" might be useful in minimizing the amount of knowledge leaked from
> Bob-Caroll channel to Alice, while still ensuring fairness [7].
>
> To conclude, this short post is advancing the idea that oblivious transfer
> class of protocol, might be able to solve the channel jamming issue where
> the messages are exchanged without all the parties "knowing" what has been
> exchanged, and being punished by on-chain scripts, if the equivocate from
> the knowledge transfer they engage into. I'm not making the claim that this
> strawman protocol is fully sound game-theoretic wise, though I found if a
> shared notions of time can be enforced among 2 Lightning channel
> counterparties,
> the implications are wider than just solving channel jamming.
>
> Anyway, I don't have time to flush more the ideas exposed here [8], though
> I
> was eager to mention them if some people are bored and wish to play with
> interesting cryptographic primitives actually solving real-world lightning
> problems.
>
> Cheers,
> Antoine
> OTS hash: 98c12f58d4e39e85427cca156cc548d225b2ecb45296be70a93d3534b77aa1c7
>
> [0] "How to Generate and Exchange Secrets" - Andrew Yao, 1986.
> [1] See "Chapter 4 - Solution Design Space" - "Solving channel jamming
> issue of the lightning network", Naumenko / Riard, 2022
> [2] As the joking goes "Oh a workable solution to a bitcoin problem
> involving
> a consensus change, that's a very ice theoretical paper you've here, sir!".
> [4] See for more - "Unjamming Lightning: A Systematic Approach",
> Clara Shikhelman and Sergei Tikhomirov, 2022.
> [4]
> https://delvingbitcoin.org/t/fee-based-spam-prevention-for-lightning/1524/2
> [5] "If a tree falls in the forest and no one is around to hear it, does it
> make a sound ?" "A Network of Micropayments Channels Can Solve
> Scalability" -
> Lightning Network paper.
> [6] E.g counter could fit in a nSequence field.
> [7] I'm wawing aside the biggest witness trace that Lightning nodes might
> have to pay, as one downside of this kind of solution compared to the other
> ones.
> [8] Yes, the subject would have deserved a real research paper, but
> writing your
> own bitcoin full-node it's real work, no kidding.
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BHJ-iRD9dZQMwmbVuov8sbk9nSkyzPcBS09U9qzxXpzsQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 12406 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: The Bitcoin Lost and Found
  2026-05-05 11:38  1% [bitcoindev] The Bitcoin Lost and Found Light
@ 2026-05-05 13:23  0% ` waxwing/ AdamISZ
  0 siblings, 0 replies; 200+ results
From: waxwing/ AdamISZ @ 2026-05-05 13:23 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 16012 bytes --]

Hi Light,
I like the general flavor of the Lost and Found proposal, I suspect we are 
very philosophically aligned on this. Albeit, this is *not* going to stop 
the argument, but I'm sure you're well aware of that :)

I'm probably against Recirculation as an idea. If even thinking about 
confiscation is a mistake (your "meta" comment; I agree), then maybe that's 
also true about changing system incentives with different redistributions. 
Maybe.

But on a technical question:

- **Enabling recovery of coins whose private keys were not generated using 
a BIP-32 seed or secured with 
a PACT.** This is not for a lack of interest; if anyone has any ideas for 
how to do this, the author is 
open to suggestions!

I'm thinking about taproot sans bip32. If can satisfy a script path spend 
then you could in theory prove with (merkle proof + validating spend) 
inside a QR ZKP. No?

On reflection it's little more than a small side-issue, because even where 
taproot is used, it is not generally used with script paths that much, and 
where it is used, it's usually with things like BIP86, i.e. BIP32 
derivation. But I *think* as a footnote, it's valid?

Cheers,
AdamISZ/waxwing
On Tuesday, May 5, 2026 at 9:00:25 AM UTC-3 Light wrote:

> Hello list,
>
> There have recently been multiple (uncharacteristically confiscatory!) 
> proposals put forward 
> to answer the question of "what to do with quantum-vulnerable 
> coins?"[a][b] For reasons I have 
> explained elsewhere, I reject the meta-premise of the question i.e. that 
> there is any discussion 
> to be had at all with regard to these coins, at least at the level of 
> bitcoin consensus.[c] However, 
> these proposals are not entirely without merit: they have generated both 
> discussion and code 
> that may still prove useful even if bitcoin consensus has nothing new to 
> say about the disposition 
> of these coins.[d]
>
> It is in the spirit of turning confiscatory lemons into cypherpunk 
> lemonade that I present to 
> this list the Bitcoin Lost and Found protocol. The protocol takes 
> noticeable inspiration from both 
> BIP-361 Phase B and the Hourglass proposal, but it does so without asking 
> bitcoin consensus 
> to actively intervene in anyone's spending abilities. A long-form 
> description of the protocol can be 
> found below.
>
> If there is sufficient interest, I intend to advance this proposal as an 
> application-layer 
> standard for the recovery and recirculation of coins held in addresses 
> secured by "weak" 
> private keys, such as those vulnerable to a CRQC. I welcome and look 
> forward to any feedback the 
> list may have to offer.
>
> Regards,
>
> Light
>
> [a] https://groups.google.com/g/bitcoindev/c/0E1UyyQIUA0
> [b] https://github.com/bitcoin/bips/blob/master/bip-0361.mediawiki
> [c] https://lightco.in/2026/04/14/quantum/
> [d] 
> https://gist.github.com/Roasbeef/563f173fe44e2005e003a082716e586f#zk-proofs-for-migration-and-recovery
>
> # Description
>
> The Bitcoin Lost and Found is an application-layer standard for the 
> recovery and recirculation 
> of coins that have been lost and found by way of "cracking" a "weak" 
> bitcoin private key. Research 
> indicates that thousands of BTC has already been lost and found this 
> way.[1][2][3] With the possibility 
> of breakthroughs in quantum computing, classical computing, and/or 
> cryptanalysis, that number could 
> rise to include all currently-circulating BTC depending on the weakness 
> that is exploited and the 
> capabilities of the attacker.[4]
>
> The Bitcoin Lost and Found provides security researchers, hackers, quantum 
> computer operators, and 
> anyone else who discovers weak bitcoin private key material a standard 
> protocol for disposing of any 
> coins held by the keys. There is a cryptographically-secure path to 
> recovery of coins whose keys were 
> generated using a standard seed, or which had a timestamped proof of 
> knowledge of the private key, 
> with a fallback path that eventually and gradually returns the coins back 
> into circulation using bitcoin's 
> existing mining mechanism.
>
> # Motivation
>
> If you are an ethical individual and you generate a bitcoin private key 
> that already has a balance, 
> then realize that it would be easy for someone else with some technical 
> know-how to generate that 
> private key as well, what do you do?
>
> One option, probably the safer option from your perspective, is to not 
> move the coins. You could 
> instead try to let the owner of the coins know about the weak private key 
> by posting a message to 
> some public message boards. The message could include the address that was 
> generated with some 
> kind of secure proof that you do indeed know the private key, so that the 
> message is credible, 
> along with a warning about the weakness and instructions for the owner to 
> move the coins to a 
> secure wallet. The risk is that an attacker beats the owner of the coins 
> to the punch by generating 
> the private key and taking the coins for themselves before the owner has a 
> chance to move them.
>
> The other option is to move the coins into your own secure wallet, so that 
> an attacker does not 
> get to them first, and then attempt to return the coins to their owner. 
> The fundamental problem 
> with this approach is verification: even if you put the word out and 
> receive a response from 
> someone claiming to be the owner, how do you verify that they are indeed 
> the "real" owner of the 
> coins? The private keys are known to be insecure, so you cannot rely on a 
> cryptographic signature 
> from them. And if the coins were acquired anonymously, for example by 
> mining or buying p2p, then 
> it would be difficult or maybe even impossible for the owner to produce a 
> verifiable proof of 
> purchase. Less fundamental but still very real are all the legal 
> challenges associated with this 
> approach, including liability, tax, regulatory compliance, questions of 
> jurisdiction, etc etc. Maybe 
> not insurmountable, but also maybe not worth the effort depending on the 
> value of the coins that 
> were found and any compensation that may be offered as a bounty for secure 
> recovery.
>
> The Bitcoin Lost and Found offers a third option, one that requires no 
> interaction between the 
> finder of coins and their owner: the finder can send the coins to a 
> special address where the 
> owner can recover them using a cryptographic proof, as long as the coins 
> were originally held 
> in an address that was either generated using a BIP-32 seed or had a 
> timestamped proof of knowledge 
> of the private keys. If the coins are not recovered within 100 years (well 
> beyond current average 
> life expectancy) then the coins will gradually re-enter circulation using 
> bitcoin's existing mining 
> mechanism.[5]
>
> > Note: The Bitcoin Lost and Found does not guarantee recoverability of 
> all coins sent to it. Only 
> > coins that were sent to the Bitcoin Lost and Found from an address 
> generated using a BIP-32 seed, 
> > or whose original owner timestamped a proof of knowledge of the address' 
> private key, can be recovered 
> > using this protocol. There is a non-zero chance that if coins are sent 
> to the Bitcoin Lost and Found 
> > then they will not be able to be recovered, since not all wallets use 
> BIP-32 seeds, and not all 
> > coinholders will timestamp a proof of knowledge.
> > 
> > For addresses generated after the invention of BIP-32, there is a high a 
> likelihood that they will 
> > be recoverable, since most modern wallets generate their private keys 
> using BIP-32. And for coins 
> > held in non-BIP-32 "JBOK" wallets, there is a low risk and potentially 
> high reward for the owner to 
> > timestamp a proof of knowledge, increasing the likelihood that attentive 
> coinholders will create 
> > such timestamps. Finders can now weigh these probabilities against the 
> probability that someone with 
> > less virtuous intentions generates the private keys and takes the coins 
> for their own private gain.
>
> # Specification
>
> There are two components to the Bitcoin Lost and Found:
> 1) The Recovery address, and
> 2) The Recirculation address
>
> When weak key material securing one or more bitcoin UTXOs is found by 
> someone who is not the "true 
> owner" of the UTXOs, then the finder MUST immediately transfer all UTXOs 
> secured by the weak key material 
> to the Recovery address.
>
> > Note: If the finder is aware of the existence of a 
> cryptographically-relevant quantum computer (CRQC), 
> > then the finder MUST send the UTXOs to the post-quantum secure version 
> of the Recovery address.
>
> ## The Recovery address
>
> UTXOs encumbered by the Recovery address MUST only be able to be spent 
> under one of three conditions:
>
> 1) The spender of the UTXO MUST supply a zero-knowledge proof of knowledge 
> that cryptographically 
> proves that the spender knows the BIP-32 seed used to generate the weak 
> key material that the UTXO 
> originated from (a "zkPKS"), or [6]
>
> 2) The spender of the UTXO MUST supply a zero-knowledge proof of knowledge 
> that cryptographically 
> proves that prior to the creation of the UTXO, the spender created a 
> timestamp of a proof of knowledge 
> of the weak private key that the UTXO originated from (a "PACT"), or [7]
>
> 3) Starting 5,250,000 blocks after the creation of the UTXO, anyone can 
> spend up to 1% of the UTXO 
> balance, or 100,000 sats, whichever is greater, and MUST send the change 
> to the Recirculation address.
>
> > Note: The post-quantum secure version of the recovery address has two 
> modified spending conditions:
> > 
> > - For condition (1), the spender MUST provide a PQ zkPKS e.g. a zkSTARK
> >
> > - For condition (2), the PACT MUST have been made prior to block `X`. 
> `X` MUST be standardized after 
> > a CRQC is known to exist, and MUST be set conservatively to a block 
> height that is prior to the presumed 
> > date of invention of the CRQC, to minimize the likelihood of a CRQC 
> operator abusing this protocol, but 
> > also recent enough to give time after the publication of this standard 
> for coinholders to produce their 
> > PACTs so that this protocol can be used effectively. The standard for 
> `X` can be updated for new deposits 
> > if the intial block height chosen turns out to be too late.
>
> ## The Recirculation address
>
> UTXOs encumbered by the Recirculation address MUST only be able to be 
> spent according to the following 
> condition:
>
> 1) After a relative timelock of 1 block, anyone can spend up to 1% of the 
> value of the UTXO, or 
> 100,000 sats, whichever is greater, and MUST send the change (if any) to 
> the Recirculation address.
>
> # Out of scope
>
> The following considerations are explicitly out of scope:
>
> - **Enabling recovery of coins whose private keys were not generated using 
> a BIP-32 seed or secured with 
> a PACT.** This is not for a lack of interest; if anyone has any ideas for 
> how to do this, the author is 
> open to suggestions!
>
> - **Changing consensus to disable the spending of coins that are held in 
> addresses derived from "weak" 
> private keys.** This proposal is intentionally designed as an 
> application-layer standard, because using 
> consensus to intentionally impair the ability to spend specific coins runs 
> contrary to bitcoin's utility 
> as a p2p electronic cash system and therefore risks fatally undermining 
> public confidence in bitcoin.
>
> # Alternatives considered
>
> - In the current proposal, the Recirculation address was specified to 
> provide some way for the coins 
> to re-enter circulation, akin to future generations finding buried 
> treasure, providing more certainty 
> over the eventual disposition of the coins. As an alternative, coins 
> transferred to the Recovery address 
> could instead remain there for an indefinite amount of time until they are 
> spent using a zkPKS. This would 
> not provide the same level of certainty as the current proposal, but would 
> substantially reduce the 
> proposal's argument surface. Whether or not inclusion of the Recirculation 
> address is preferable to the 
> bitcoin standards community, and therefore whether or not it makes it into 
> the finalized proposal, is open 
> to discussion. The author is also open the possibility of two standards 
> existing: a "v1" with the Recirculation 
> address, and a "v2" without the Recirculation address. Finders could then 
> choose which standard to follow 
> based on their own preference.
>
> # Dependencies
>
> The Bitcoin Lost and Found depends upon support for verifying a 
> (post-quantum) zkPKS in Script, along 
> with a recursive covenant that enforces change destinations in perpetuity, 
> ideally using standard bitcoin 
> transactions.[8] These capabilities do not yet exist in bitcoin, but could 
> be added with a soft fork that includes 
> OP_CAT and OP_MUL e.g. BIP-441 and a recursive covenant opcode such as 
> OP_TX, or opcodes with equivalent 
> capabilities.[9][10][11] Alternatively, we could use a soft fork to add a 
> new smart contract language to bitcoin that 
> has these capabilities, such as Basic Bitcoin Lisp or Simplicity.[12][13]
>
> # Prior art
>
> This idea for the Recovery address was inspired by a conversation between 
> the author, Matt Corallo, and 
> Ethan Heilman about the author's proposal that anyone who uses a 
> cryptographically-relevant quantum 
> computer to crack bitcoin private keys should burn the coins using 
> `OP_RETURN`.[14] In response to this 
> proposal, Matt suggested that rather than burn the coins, they could be 
> sent to a recovery address that 
> requires a PQ zkPKS to spend from the address. This document is an 
> elaboration of this suggestion into a 
> full protocol.
>
> Related prior art on the general topic of using zero-knowledge proofs for 
> the recovery of quantum-vulnerable 
> coins can be found here: 
> https://gist.github.com/Roasbeef/563f173fe44e2005e003a082716e586f#zk-proofs-for-migration-and-recovery
>
> The concept of the Recirculation address was inspired by Hourglass.[15]
>
> # References
>
> [1] https://cs.unm.edu/~vasek/papers/vasekfc16.pdf
> [2] https://milksad.info/disclosure.html
> [3] 
> https://bitcoinmagazine.com/technical/critical-vulnerability-found-in-android-wallets-1376273924
> [4] 
> https://github.com/presidiobtc/bitcoin-quantum/#how-quantum-affects-bitcoin
> [5] https://ourworldindata.org/grapher/life-expectancy
> [6] https://lightco.in/2026/04/14/quantum
> [7] 
> https://www.paradigm.xyz/2026/05/pacts-protecting-your-bitcoin-from-a-quantum-sunset
> [8] 
> https://developer.bitcoin.org/devguide/transactions.html#standard-transactions
> [9] https://x.com/_julian256_/status/2029931162685080039
> [10] https://github.com/bitcoin/bips/blob/master/bip-0441.mediawiki
> [11] 
> https://github.com/rustyrussell/bips/blob/68125328504930d8f5efdd594f600749ce75f130/bip-unknown-optx.mediawiki
> [12] https://bitcoinops.org/en/topics/basic-bitcoin-lisp-language/
> [13] https://bitcoinops.org/en/topics/simplicity/
> [14] https://x.com/lightcoin/status/1892987447471911005
> [15] 
> https://github.com/cryptoquick/bips/blob/hourglass-v2/bip-hourglass-v2.mediawiki
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d0fb6249-d436-48c2-9dc1-0ed6fa25c988n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 23260 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] The Bitcoin Lost and Found
@ 2026-05-05 11:38  1% Light
  2026-05-05 13:23  0% ` [bitcoindev] " waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Light @ 2026-05-05 11:38 UTC (permalink / raw)
  To: bitcoindev

Hello list,

There have recently been multiple (uncharacteristically confiscatory!) proposals put forward 
to answer the question of "what to do with quantum-vulnerable coins?"[a][b] For reasons I have 
explained elsewhere, I reject the meta-premise of the question i.e. that there is any discussion 
to be had at all with regard to these coins, at least at the level of bitcoin consensus.[c] However, 
these proposals are not entirely without merit: they have generated both discussion and code 
that may still prove useful even if bitcoin consensus has nothing new to say about the disposition 
of these coins.[d]

It is in the spirit of turning confiscatory lemons into cypherpunk lemonade that I present to 
this list the Bitcoin Lost and Found protocol. The protocol takes noticeable inspiration from both 
BIP-361 Phase B and the Hourglass proposal, but it does so without asking bitcoin consensus 
to actively intervene in anyone's spending abilities. A long-form description of the protocol can be 
found below.

If there is sufficient interest, I intend to advance this proposal as an application-layer 
standard for the recovery and recirculation of coins held in addresses secured by "weak" 
private keys, such as those vulnerable to a CRQC. I welcome and look forward to any feedback the 
list may have to offer.

Regards,

Light

[a] https://groups.google.com/g/bitcoindev/c/0E1UyyQIUA0
[b] https://github.com/bitcoin/bips/blob/master/bip-0361.mediawiki
[c] https://lightco.in/2026/04/14/quantum/
[d] https://gist.github.com/Roasbeef/563f173fe44e2005e003a082716e586f#zk-proofs-for-migration-and-recovery

# Description

The Bitcoin Lost and Found is an application-layer standard for the recovery and recirculation 
of coins that have been lost and found by way of "cracking" a "weak" bitcoin private key. Research 
indicates that thousands of BTC has already been lost and found this way.[1][2][3] With the possibility 
of breakthroughs in quantum computing, classical computing, and/or cryptanalysis, that number could 
rise to include all currently-circulating BTC depending on the weakness that is exploited and the 
capabilities of the attacker.[4]

The Bitcoin Lost and Found provides security researchers, hackers, quantum computer operators, and 
anyone else who discovers weak bitcoin private key material a standard protocol for disposing of any 
coins held by the keys. There is a cryptographically-secure path to recovery of coins whose keys were 
generated using a standard seed, or which had a timestamped proof of knowledge of the private key, 
with a fallback path that eventually and gradually returns the coins back into circulation using bitcoin's 
existing mining mechanism.

# Motivation

If you are an ethical individual and you generate a bitcoin private key that already has a balance, 
then realize that it would be easy for someone else with some technical know-how to generate that 
private key as well, what do you do?

One option, probably the safer option from your perspective, is to not move the coins. You could 
instead try to let the owner of the coins know about the weak private key by posting a message to 
some public message boards. The message could include the address that was generated with some 
kind of secure proof that you do indeed know the private key, so that the message is credible, 
along with a warning about the weakness and instructions for the owner to move the coins to a 
secure wallet. The risk is that an attacker beats the owner of the coins to the punch by generating 
the private key and taking the coins for themselves before the owner has a chance to move them.

The other option is to move the coins into your own secure wallet, so that an attacker does not 
get to them first, and then attempt to return the coins to their owner. The fundamental problem 
with this approach is verification: even if you put the word out and receive a response from 
someone claiming to be the owner, how do you verify that they are indeed the "real" owner of the 
coins? The private keys are known to be insecure, so you cannot rely on a cryptographic signature 
from them. And if the coins were acquired anonymously, for example by mining or buying p2p, then 
it would be difficult or maybe even impossible for the owner to produce a verifiable proof of 
purchase. Less fundamental but still very real are all the legal challenges associated with this 
approach, including liability, tax, regulatory compliance, questions of jurisdiction, etc etc. Maybe 
not insurmountable, but also maybe not worth the effort depending on the value of the coins that 
were found and any compensation that may be offered as a bounty for secure recovery.

The Bitcoin Lost and Found offers a third option, one that requires no interaction between the 
finder of coins and their owner: the finder can send the coins to a special address where the 
owner can recover them using a cryptographic proof, as long as the coins were originally held 
in an address that was either generated using a BIP-32 seed or had a timestamped proof of knowledge 
of the private keys. If the coins are not recovered within 100 years (well beyond current average 
life expectancy) then the coins will gradually re-enter circulation using bitcoin's existing mining 
mechanism.[5]

> Note: The Bitcoin Lost and Found does not guarantee recoverability of all coins sent to it. Only 
> coins that were sent to the Bitcoin Lost and Found from an address generated using a BIP-32 seed, 
> or whose original owner timestamped a proof of knowledge of the address' private key, can be recovered 
> using this protocol. There is a non-zero chance that if coins are sent to the Bitcoin Lost and Found 
> then they will not be able to be recovered, since not all wallets use BIP-32 seeds, and not all 
> coinholders will timestamp a proof of knowledge.
> 
> For addresses generated after the invention of BIP-32, there is a high a likelihood that they will 
> be recoverable, since most modern wallets generate their private keys using BIP-32. And for coins 
> held in non-BIP-32 "JBOK" wallets, there is a low risk and potentially high reward for the owner to 
> timestamp a proof of knowledge, increasing the likelihood that attentive coinholders will create 
> such timestamps. Finders can now weigh these probabilities against the probability that someone with 
> less virtuous intentions generates the private keys and takes the coins for their own private gain.

# Specification

There are two components to the Bitcoin Lost and Found:
1) The Recovery address, and
2) The Recirculation address

When weak key material securing one or more bitcoin UTXOs is found by someone who is not the "true 
owner" of the UTXOs, then the finder MUST immediately transfer all UTXOs secured by the weak key material 
to the Recovery address.

> Note: If the finder is aware of the existence of a cryptographically-relevant quantum computer (CRQC), 
> then the finder MUST send the UTXOs to the post-quantum secure version of the Recovery address.

## The Recovery address

UTXOs encumbered by the Recovery address MUST only be able to be spent under one of three conditions:

1) The spender of the UTXO MUST supply a zero-knowledge proof of knowledge that cryptographically 
proves that the spender knows the BIP-32 seed used to generate the weak key material that the UTXO 
originated from (a "zkPKS"), or [6]

2) The spender of the UTXO MUST supply a zero-knowledge proof of knowledge that cryptographically 
proves that prior to the creation of the UTXO, the spender created a timestamp of a proof of knowledge 
of the weak private key that the UTXO originated from (a "PACT"), or [7]

3) Starting 5,250,000 blocks after the creation of the UTXO, anyone can spend up to 1% of the UTXO 
balance, or 100,000 sats, whichever is greater, and MUST send the change to the Recirculation address.

> Note: The post-quantum secure version of the recovery address has two modified spending conditions:
> 
> - For condition (1), the spender MUST provide a PQ zkPKS e.g. a zkSTARK
>
> - For condition (2), the PACT MUST have been made prior to block `X`. `X` MUST be standardized after 
> a CRQC is known to exist, and MUST be set conservatively to a block height that is prior to the presumed 
> date of invention of the CRQC, to minimize the likelihood of a CRQC operator abusing this protocol, but 
> also recent enough to give time after the publication of this standard for coinholders to produce their 
> PACTs so that this protocol can be used effectively. The standard for `X` can be updated for new deposits 
> if the intial block height chosen turns out to be too late.

## The Recirculation address

UTXOs encumbered by the Recirculation address MUST only be able to be spent according to the following 
condition:

1) After a relative timelock of 1 block, anyone can spend up to 1% of the value of the UTXO, or 
100,000 sats, whichever is greater, and MUST send the change (if any) to the Recirculation address.

# Out of scope

The following considerations are explicitly out of scope:

- **Enabling recovery of coins whose private keys were not generated using a BIP-32 seed or secured with 
a PACT.** This is not for a lack of interest; if anyone has any ideas for how to do this, the author is 
open to suggestions!
 
- **Changing consensus to disable the spending of coins that are held in addresses derived from "weak" 
private keys.** This proposal is intentionally designed as an application-layer standard, because using 
consensus to intentionally impair the ability to spend specific coins runs contrary to bitcoin's utility 
as a p2p electronic cash system and therefore risks fatally undermining public confidence in bitcoin.

# Alternatives considered

- In the current proposal, the Recirculation address was specified to provide some way for the coins 
to re-enter circulation, akin to future generations finding buried treasure, providing more certainty 
over the eventual disposition of the coins. As an alternative, coins transferred to the Recovery address 
could instead remain there for an indefinite amount of time until they are spent using a zkPKS. This would 
not provide the same level of certainty as the current proposal, but would substantially reduce the 
proposal's argument surface. Whether or not inclusion of the Recirculation address is preferable to the 
bitcoin standards community, and therefore whether or not it makes it into the finalized proposal, is open 
to discussion. The author is also open the possibility of two standards existing: a "v1" with the Recirculation 
address, and a "v2" without the Recirculation address. Finders could then choose which standard to follow 
based on their own preference.

# Dependencies

The Bitcoin Lost and Found depends upon support for verifying a (post-quantum) zkPKS in Script, along 
with a recursive covenant that enforces change destinations in perpetuity, ideally using standard bitcoin 
transactions.[8] These capabilities do not yet exist in bitcoin, but could be added with a soft fork that includes 
OP_CAT and OP_MUL e.g. BIP-441 and a recursive covenant opcode such as OP_TX, or opcodes with equivalent 
capabilities.[9][10][11] Alternatively, we could use a soft fork to add a new smart contract language to bitcoin that 
has these capabilities, such as Basic Bitcoin Lisp or Simplicity.[12][13]

# Prior art

This idea for the Recovery address was inspired by a conversation between the author, Matt Corallo, and 
Ethan Heilman about the author's proposal that anyone who uses a cryptographically-relevant quantum 
computer to crack bitcoin private keys should burn the coins using `OP_RETURN`.[14] In response to this 
proposal, Matt suggested that rather than burn the coins, they could be sent to a recovery address that 
requires a PQ zkPKS to spend from the address. This document is an elaboration of this suggestion into a 
full protocol.

Related prior art on the general topic of using zero-knowledge proofs for the recovery of quantum-vulnerable 
coins can be found here: https://gist.github.com/Roasbeef/563f173fe44e2005e003a082716e586f#zk-proofs-for-migration-and-recovery

The concept of the Recirculation address was inspired by Hourglass.[15]

# References

[1] https://cs.unm.edu/~vasek/papers/vasekfc16.pdf
[2] https://milksad.info/disclosure.html
[3] https://bitcoinmagazine.com/technical/critical-vulnerability-found-in-android-wallets-1376273924
[4] https://github.com/presidiobtc/bitcoin-quantum/#how-quantum-affects-bitcoin
[5] https://ourworldindata.org/grapher/life-expectancy
[6] https://lightco.in/2026/04/14/quantum
[7] https://www.paradigm.xyz/2026/05/pacts-protecting-your-bitcoin-from-a-quantum-sunset
[8] https://developer.bitcoin.org/devguide/transactions.html#standard-transactions
[9] https://x.com/_julian256_/status/2029931162685080039
[10] https://github.com/bitcoin/bips/blob/master/bip-0441.mediawiki
[11] https://github.com/rustyrussell/bips/blob/68125328504930d8f5efdd594f600749ce75f130/bip-unknown-optx.mediawiki
[12] https://bitcoinops.org/en/topics/basic-bitcoin-lisp-language/
[13] https://bitcoinops.org/en/topics/simplicity/
[14] https://x.com/lightcoin/status/1892987447471911005
[15] https://github.com/cryptoquick/bips/blob/hourglass-v2/bip-hourglass-v2.mediawiki

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/db16b0f2-6b21-4eba-a562-df3659f6a8f4%40app.fastmail.com.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] BIP-322: Add type prefix, change PoF serialization, PSBT-based signing
  2026-04-21  9:16  0%   ` Oliver
@ 2026-04-21 13:13  0%     ` thomas s.
  0 siblings, 0 replies; 200+ results
From: thomas s. @ 2026-04-21 13:13 UTC (permalink / raw)
  To: Oliver; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 10368 bytes --]

Hi Oli,

Thanks for the detailedd reply and for the detection section — the five checks are solid, especially the cryptographic binding via to_spend.txid in in check 4.

On the per-input vs global question: since you're open to either, I'd argue for a global field (PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE).

The message text isn't data required to satisfy input 0's script — it's semantic context about what the whole transaction represents. That maps cleanly to the global/per-input split in BIP-174: global fields carry transaction-wide metadata, per-input fields carry what's needed to sign that specific input.

Putting it on input 0 works mechanically but sets a precedent where transaction-level metadata lives on an arbitrary input by convention. A global field avoids that and keeps the detection logic just as simple — check 1 moves from input-level to global-level, everything else stays the same.

Thomas


> On 21 Apr 2026, at 11:16, Oliver <gugger@gmail.com> wrote:
> 
> Hi Thomas
> 
> Thank you for your feedback and questions!
> 
> Whether the new PSBT field should be on the input or a global field is a good question.
> I did ask myself the same thing and then slightly leaned toward adding it to the input that directly references the TXID that contains the message hash.
> But I don't have strong opinions either way, so a global field would definitely also work.
> 
> > how does a parser that ingests PSBTs generically distinguish a BIP-322 proof-of-funds from a regular transaction PSBT?
> 
> I did add a section that covers detection to the BIP, see
> https://github.com/bitcoin/bips/blob/518dc68dcd3d8793c66128638cc61f60c6007eeb/bip-0322.mediawiki#user-content-PSBT_signer
> 
> I made it as strict as possible to minimize the chance of a false positive.
> The 0x21 field is a good indication that the PSBT contains a message to be signed but the additional checks I propose also help to make sure it's a well-formed and valid BIP-322 PSBT.
> 
> > Worth noting because it suggests "signer context" deserves to be a first-class concern in PSBT design broadly.
> 
> Yes, that's something I noticed in another project as well. A more generic approach to "signer context" would definitely be a useful endeavor.
> Thanks for the links, I'll take a look when I find some time.
> 
> Oli
> 
> On Monday, April 20, 2026 at 4:50:15 PM UTC+2 Thomas Suau wrote:
>> 
>> Hi Oli,
>> 
>> Concept ACK on the direction. Good to see this this moving forward.
>> 
>> 
>> I work on PSBT tooling (author of BTSL [1], a declarative validation layer for multi-party PSBT workflows) so the PSBT parts caught my attention.
>> 
>> On PSBT_IN_GENERIC_SIGNED_MESSAGE (0x21)
>> 
>> Why a per-input field rather than global? The signed message is a property of the whole `to_sign` transaction, not of input 0 specifically. Placing it there works but creates an implicit convention that the first input carries transaction-wide metadata. Was there a reason to avoid PSBT_GLOBAL_*?
>> 
>> On Proof of Funds as finalized PSBT
>> 
>> Clean choice. One question: how does a parser that ingests PSBTs generically distinguish a BIP-322 proof-of-funds from a regular transaction PSBT? Is 0x21 on the first input sufficient as discriminant, or does this need an explicit marker?
>> 
>> 
>> 
>> The problem you identify — signer sees a zero-value-to-OP_RETURN transaction with no idea they're signing a message — extends beyond BIP-322 to any multi-party PSBT workflow where the signer lacks semantic context. I've been working on the same gap from a different angle with BTSL [1][2]. Different mechanism, same problem. Worth noting because it suggests "signer context" deserves to be a first-class concern in PSBT design broadly.
>> 
>> Cheers,
>> 
>> Thomas
>> 
>> [1] https://github.com/tsua0002/btsl-standard 
>> 
>> [2] https://btsl-playground.vercel.app <https://btsl-playground.vercel.app/>
>> Le lundi 20 avril 2026 à 09:26:14 UTC+2, Oliver a écrit :
>>> Dear mailing list
>>> 
>>> I've started an implementation of BIP-322 in Go ([1]), and during implementation I noticed
>>> that a number of open questions remain.
>>> 
>>> I believe that these open questions and the "Draft" status are contributing reasons for the
>>> BIP not being widely implemented.
>>> I do see demand for generic message signing in discussions and pull requests, though, so I'm
>>> taking a shot at helping to move the BIP forward ([2]).
>>> 
>>> In short, I'm proposing three major changes:
>>>  - Introduce a human-readable prefix to distinguish the three signature variants.
>>>  - Change the encoding format of the "Proof of Funds" variant to include UTXO information.
>>>  - Introduce a new PSBT field for for PSBT-based message signing.
>>> 
>>> Let me explain the details and reasoning behind the changes:
>>> 
>>> 
>>> Human-readable prefix
>>> ------
>>> 
>>> As in an earlier discussion ([3]), not having a prefix and needing to attempt decoding both
>>> initially proposed formats to detect which one a signature used is cumbersome, potentially
>>> error prone and requires careful implementation.
>>> Introducing a simple fixed-length (for easy detection and parsing) human-readable prefix that
>>> is simply prepended to the base64-encoded signature should make detection quite straightforward
>>> in code and also make it easy to distinguish a BIP-322 signature from a legacy one.
>>> The proposed prefixes are: `smp`, `ful`, `pof` for the 'simple', 'full' and 'Proof of Funds'
>>> variants respectively.
>>> Because there already are implementations of BIP-322 out there, I also added a backward
>>> compatibility clause for existing implementations. Observing that many of the implementations
>>> I found and looked at only produce signatures of the 'simple' variant, an implementation may
>>> assume the 'simple' format if it doesn't detect a valid prefix.
>>> 
>>> 
>>> Encoding format of the "Proof of Funds" variant
>>> ------
>>> 
>>> The "Proof of Funds" variant allows attesting spendability of specific UTXOs. While the
>>> selection and purpose of the UTXOs (e.g., completeness or unspent status) remain out of scope
>>> of the BIP, it is my opinion that it should at least be possible to validate (offline) that
>>> the witness of a BIP-322 `to_sign` transaction is valid, should be part of the specification.
>>> However, validating the witness of an additional input requires its UTXO information.
>>> Instead of coming up with a custom encoding for the UTXO information in addition to the
>>> full `to_sign` transaction, I realized that a finalized PSBT contains exactly the information
>>> we require: The full transaction, the witness and/or signature scripts and the (Non-)Witness
>>> UTXO fields. A finalized PSBT also must not contain fields that may be detrimental to privacy,
>>> like internal keys, xPubs or script information.
>>> Therefore, I propose that the encoding format for the "Proof of Funds" variant should be the
>>> full, base64-encoded PSBT of the `to_sign` transaction, but in the "finalized" state as
>>> described in BIP-174.
>>> Because non-witness inputs require the whole previous transaction to be present, I also added
>>> a size optimization that allows this field to be reused between inputs if more than one input
>>> references the same previous transaction.
>>> 
>>> 
>>> New PSBT field for PSBT-based message signing
>>> ------
>>> 
>>> When creating a signature for a multisig address script, it makes sense to use a PSBT to get
>>> a signature for the `to_sign` transaction from each signer.
>>> However, although a signer produces a signature for a _transaction_, their intent is to sign
>>> a _message_. Signing software and devices should be able to show that fact in their user
>>> interface, as a BIP-322 transaction would look unusual to a user when presented as such
>>> (spending a zero-value output into an OP_RETURN output).
>>> I propose to add a new field (PSBT_IN_GENERIC_SIGNED_MESSAGE, 0x21) to the first input of
>>> the PSBT-wrapped `to_sign` transaction that contains the full message to be signed. A signing
>>> device or software can then detect and present such a message-signing PSBT in an appropriate
>>> way to the user.
>>> The detection and signature producing procedure is also explained in detail in my proposed
>>> BIP body.
>>> 
>>> 
>>> The above changes are the most notable changes, but my Pull Request to the BIP ([2]) also
>>> addresses additional discussion points raised in Bitcoin Core PRs and previous mailing list
>>> discussions:
>>>  - Clarify intent and terminology of the BIP, make it clear what it can't prove (the PR body
>>>    [2] contains links to the relevant discussions).
>>>  - Add extensive test vectors for all the variants.
>>>  - Propose the status to move to "Complete".
>>>  - Offer myself to be a deputy to BIP-322 as described in BIP-3.
>>> 
>>> I'm looking forward to your feedback and to further discussion here or on the BIPs PR ([2]).
>>> 
>>> Oli
>>> 
>>> 
>>> [1]: https://github.com/btcsuite/btcd/pull/2521
>>> [2]: https://github.com/bitcoin/bips/pull/2141
>>> [3]: https://groups.google.com/g/bitcoindev/c/RCi1Exs0ZvQ/m/NsFQcCcaCAAJ
> 
> 
> -- 
> You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/qd6BNz9gxCk/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to bitcoindev+unsubscribe@googlegroups.com <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/6dc35b8a-e837-4fc9-9a17-ca29204bf738n%40googlegroups.com <https://groups.google.com/d/msgid/bitcoindev/6dc35b8a-e837-4fc9-9a17-ca29204bf738n%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/E17F4A33-34AF-4E6C-AC15-69854AE8A08E%40gmail.com.

[-- Attachment #2: Type: text/html, Size: 29523 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: BIP-322: Add type prefix, change PoF serialization, PSBT-based signing
  2026-04-20 14:47  1% ` [bitcoindev] " Thomas Suau
@ 2026-04-21  9:16  0%   ` Oliver
  2026-04-21 13:13  0%     ` [bitcoindev] " thomas s.
  0 siblings, 1 reply; 200+ results
From: Oliver @ 2026-04-21  9:16 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 8751 bytes --]

Hi Thomas

Thank you for your feedback and questions!

Whether the new PSBT field should be on the input or a global field is a 
good question.
I did ask myself the same thing and then slightly leaned toward adding it 
to the input that directly references the TXID that contains the message 
hash.
But I don't have strong opinions either way, so a global field would 
definitely also work.

> how does a parser that ingests PSBTs generically distinguish a BIP-322 
proof-of-funds from a regular transaction PSBT?

I did add a section that covers detection to the BIP, see
https://github.com/bitcoin/bips/blob/518dc68dcd3d8793c66128638cc61f60c6007eeb/bip-0322.mediawiki#user-content-PSBT_signer

I made it as strict as possible to minimize the chance of a false positive.
The 0x21 field is a good indication that the PSBT contains a message to be 
signed but the additional checks I propose also help to make sure it's a 
well-formed and valid BIP-322 PSBT.

> Worth noting because it suggests "signer context" deserves to be a 
first-class concern in PSBT design broadly.

Yes, that's something I noticed in another project as well. A more generic 
approach to "signer context" would definitely be a useful endeavor.
Thanks for the links, I'll take a look when I find some time.

Oli

On Monday, April 20, 2026 at 4:50:15 PM UTC+2 Thomas Suau wrote:

> ------------------------------
>
> Hi Oli,
>
> Concept ACK on the direction. Good to see this this moving forward.
>
> I work on PSBT tooling (author of BTSL [1], a declarative validation layer 
> for multi-party PSBT workflows) so the PSBT parts caught my attention.
>
> On PSBT_IN_GENERIC_SIGNED_MESSAGE (0x21)
>
> Why a per-input field rather than global? The signed message is a property 
> of the whole `to_sign` transaction, not of input 0 specifically. Placing it 
> there works but creates an implicit convention that the first input carries 
> transaction-wide metadata. Was there a reason to avoid PSBT_GLOBAL_*?
>
> On Proof of Funds as finalized PSBT
>
> Clean choice. One question: how does a parser that ingests PSBTs 
> generically distinguish a BIP-322 proof-of-funds from a regular transaction 
> PSBT? Is 0x21 on the first input sufficient as discriminant, or does this 
> need an explicit marker?
>
>
> The problem you identify — signer sees a zero-value-to-OP_RETURN 
> transaction with no idea they're signing a message — extends beyond BIP-322 
> to any multi-party PSBT workflow where the signer lacks semantic context. 
> I've been working on the same gap from a different angle with BTSL [1][2]. 
> Different mechanism, same problem. Worth noting because it suggests "signer 
> context" deserves to be a first-class concern in PSBT design broadly.
>
> Cheers,
>
> Thomas
>
> [1] https://github.com/tsua0002/btsl-standard 
>
> [2] https://btsl-playground.vercel.app
>
> Le lundi 20 avril 2026 à 09:26:14 UTC+2, Oliver a écrit :
>
>> Dear mailing list
>>
>> I've started an implementation of BIP-322 in Go ([1]), and during 
>> implementation I noticed
>> that a number of open questions remain.
>>
>> I believe that these open questions and the "Draft" status are 
>> contributing reasons for the
>> BIP not being widely implemented.
>> I do see demand for generic message signing in discussions and pull 
>> requests, though, so I'm
>> taking a shot at helping to move the BIP forward ([2]).
>>
>> In short, I'm proposing three major changes:
>>  - Introduce a human-readable prefix to distinguish the three signature 
>> variants.
>>  - Change the encoding format of the "Proof of Funds" variant to include 
>> UTXO information.
>>  - Introduce a new PSBT field for for PSBT-based message signing.
>>
>> Let me explain the details and reasoning behind the changes:
>>
>>
>> Human-readable prefix
>> ------
>>
>> As in an earlier discussion ([3]), not having a prefix and needing to 
>> attempt decoding both
>> initially proposed formats to detect which one a signature used is 
>> cumbersome, potentially
>> error prone and requires careful implementation.
>> Introducing a simple fixed-length (for easy detection and parsing) 
>> human-readable prefix that
>> is simply prepended to the base64-encoded signature should make detection 
>> quite straightforward
>> in code and also make it easy to distinguish a BIP-322 signature from a 
>> legacy one.
>> The proposed prefixes are: `smp`, `ful`, `pof` for the 'simple', 'full' 
>> and 'Proof of Funds'
>> variants respectively.
>> Because there already are implementations of BIP-322 out there, I also 
>> added a backward
>> compatibility clause for existing implementations. Observing that many of 
>> the implementations
>> I found and looked at only produce signatures of the 'simple' variant, an 
>> implementation may
>> assume the 'simple' format if it doesn't detect a valid prefix.
>>
>>
>> Encoding format of the "Proof of Funds" variant
>> ------
>>
>> The "Proof of Funds" variant allows attesting spendability of specific 
>> UTXOs. While the
>> selection and purpose of the UTXOs (e.g., completeness or unspent status) 
>> remain out of scope
>> of the BIP, it is my opinion that it should at least be possible to 
>> validate (offline) that
>> the witness of a BIP-322 `to_sign` transaction is valid, should be part 
>> of the specification.
>> However, validating the witness of an additional input requires its UTXO 
>> information.
>> Instead of coming up with a custom encoding for the UTXO information in 
>> addition to the
>> full `to_sign` transaction, I realized that a finalized PSBT contains 
>> exactly the information
>> we require: The full transaction, the witness and/or signature scripts 
>> and the (Non-)Witness
>> UTXO fields. A finalized PSBT also must not contain fields that may be 
>> detrimental to privacy,
>> like internal keys, xPubs or script information.
>> Therefore, I propose that the encoding format for the "Proof of Funds" 
>> variant should be the
>> full, base64-encoded PSBT of the `to_sign` transaction, but in the 
>> "finalized" state as
>> described in BIP-174.
>> Because non-witness inputs require the whole previous transaction to be 
>> present, I also added
>> a size optimization that allows this field to be reused between inputs if 
>> more than one input
>> references the same previous transaction.
>>
>>
>> New PSBT field for PSBT-based message signing
>> ------
>>
>> When creating a signature for a multisig address script, it makes sense 
>> to use a PSBT to get
>> a signature for the `to_sign` transaction from each signer.
>> However, although a signer produces a signature for a _transaction_, 
>> their intent is to sign
>> a _message_. Signing software and devices should be able to show that 
>> fact in their user
>> interface, as a BIP-322 transaction would look unusual to a user when 
>> presented as such
>> (spending a zero-value output into an OP_RETURN output).
>> I propose to add a new field (PSBT_IN_GENERIC_SIGNED_MESSAGE, 0x21) to 
>> the first input of
>> the PSBT-wrapped `to_sign` transaction that contains the full message to 
>> be signed. A signing
>> device or software can then detect and present such a message-signing 
>> PSBT in an appropriate
>> way to the user.
>> The detection and signature producing procedure is also explained in 
>> detail in my proposed
>> BIP body.
>>
>>
>> The above changes are the most notable changes, but my Pull Request to 
>> the BIP ([2]) also
>> addresses additional discussion points raised in Bitcoin Core PRs and 
>> previous mailing list
>> discussions:
>>  - Clarify intent and terminology of the BIP, make it clear what it can't 
>> prove (the PR body
>>    [2] contains links to the relevant discussions).
>>  - Add extensive test vectors for all the variants.
>>  - Propose the status to move to "Complete".
>>  - Offer myself to be a deputy to BIP-322 as described in BIP-3.
>>
>> I'm looking forward to your feedback and to further discussion here or on 
>> the BIPs PR ([2]).
>>
>> Oli
>>
>>
>> [1]: https://github.com/btcsuite/btcd/pull/2521
>> [2]: https://github.com/bitcoin/bips/pull/2141
>> [3]: https://groups.google.com/g/bitcoindev/c/RCi1Exs0ZvQ/m/NsFQcCcaCAAJ
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/6dc35b8a-e837-4fc9-9a17-ca29204bf738n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 10872 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: BIP-322: Add type prefix, change PoF serialization, PSBT-based signing
  2026-04-20  7:22  1% [bitcoindev] BIP-322: Add type prefix, change PoF serialization, PSBT-based signing Oliver
@ 2026-04-20 14:47  1% ` Thomas Suau
  2026-04-21  9:16  0%   ` Oliver
  0 siblings, 1 reply; 200+ results
From: Thomas Suau @ 2026-04-20 14:47 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 7165 bytes --]


------------------------------

Hi Oli,

Concept ACK on the direction. Good to see this this moving forward.

I work on PSBT tooling (author of BTSL [1], a declarative validation layer 
for multi-party PSBT workflows) so the PSBT parts caught my attention.

On PSBT_IN_GENERIC_SIGNED_MESSAGE (0x21)

Why a per-input field rather than global? The signed message is a property 
of the whole `to_sign` transaction, not of input 0 specifically. Placing it 
there works but creates an implicit convention that the first input carries 
transaction-wide metadata. Was there a reason to avoid PSBT_GLOBAL_*?

On Proof of Funds as finalized PSBT

Clean choice. One question: how does a parser that ingests PSBTs 
generically distinguish a BIP-322 proof-of-funds from a regular transaction 
PSBT? Is 0x21 on the first input sufficient as discriminant, or does this 
need an explicit marker?


The problem you identify — signer sees a zero-value-to-OP_RETURN 
transaction with no idea they're signing a message — extends beyond BIP-322 
to any multi-party PSBT workflow where the signer lacks semantic context. 
I've been working on the same gap from a different angle with BTSL [1][2]. 
Different mechanism, same problem. Worth noting because it suggests "signer 
context" deserves to be a first-class concern in PSBT design broadly.

Cheers,

Thomas

[1] https://github.com/tsua0002/btsl-standard 

[2] https://btsl-playground.vercel.app

Le lundi 20 avril 2026 à 09:26:14 UTC+2, Oliver a écrit :

> Dear mailing list
>
> I've started an implementation of BIP-322 in Go ([1]), and during 
> implementation I noticed
> that a number of open questions remain.
>
> I believe that these open questions and the "Draft" status are 
> contributing reasons for the
> BIP not being widely implemented.
> I do see demand for generic message signing in discussions and pull 
> requests, though, so I'm
> taking a shot at helping to move the BIP forward ([2]).
>
> In short, I'm proposing three major changes:
>  - Introduce a human-readable prefix to distinguish the three signature 
> variants.
>  - Change the encoding format of the "Proof of Funds" variant to include 
> UTXO information.
>  - Introduce a new PSBT field for for PSBT-based message signing.
>
> Let me explain the details and reasoning behind the changes:
>
>
> Human-readable prefix
> ------
>
> As in an earlier discussion ([3]), not having a prefix and needing to 
> attempt decoding both
> initially proposed formats to detect which one a signature used is 
> cumbersome, potentially
> error prone and requires careful implementation.
> Introducing a simple fixed-length (for easy detection and parsing) 
> human-readable prefix that
> is simply prepended to the base64-encoded signature should make detection 
> quite straightforward
> in code and also make it easy to distinguish a BIP-322 signature from a 
> legacy one.
> The proposed prefixes are: `smp`, `ful`, `pof` for the 'simple', 'full' 
> and 'Proof of Funds'
> variants respectively.
> Because there already are implementations of BIP-322 out there, I also 
> added a backward
> compatibility clause for existing implementations. Observing that many of 
> the implementations
> I found and looked at only produce signatures of the 'simple' variant, an 
> implementation may
> assume the 'simple' format if it doesn't detect a valid prefix.
>
>
> Encoding format of the "Proof of Funds" variant
> ------
>
> The "Proof of Funds" variant allows attesting spendability of specific 
> UTXOs. While the
> selection and purpose of the UTXOs (e.g., completeness or unspent status) 
> remain out of scope
> of the BIP, it is my opinion that it should at least be possible to 
> validate (offline) that
> the witness of a BIP-322 `to_sign` transaction is valid, should be part of 
> the specification.
> However, validating the witness of an additional input requires its UTXO 
> information.
> Instead of coming up with a custom encoding for the UTXO information in 
> addition to the
> full `to_sign` transaction, I realized that a finalized PSBT contains 
> exactly the information
> we require: The full transaction, the witness and/or signature scripts and 
> the (Non-)Witness
> UTXO fields. A finalized PSBT also must not contain fields that may be 
> detrimental to privacy,
> like internal keys, xPubs or script information.
> Therefore, I propose that the encoding format for the "Proof of Funds" 
> variant should be the
> full, base64-encoded PSBT of the `to_sign` transaction, but in the 
> "finalized" state as
> described in BIP-174.
> Because non-witness inputs require the whole previous transaction to be 
> present, I also added
> a size optimization that allows this field to be reused between inputs if 
> more than one input
> references the same previous transaction.
>
>
> New PSBT field for PSBT-based message signing
> ------
>
> When creating a signature for a multisig address script, it makes sense to 
> use a PSBT to get
> a signature for the `to_sign` transaction from each signer.
> However, although a signer produces a signature for a _transaction_, their 
> intent is to sign
> a _message_. Signing software and devices should be able to show that fact 
> in their user
> interface, as a BIP-322 transaction would look unusual to a user when 
> presented as such
> (spending a zero-value output into an OP_RETURN output).
> I propose to add a new field (PSBT_IN_GENERIC_SIGNED_MESSAGE, 0x21) to the 
> first input of
> the PSBT-wrapped `to_sign` transaction that contains the full message to 
> be signed. A signing
> device or software can then detect and present such a message-signing PSBT 
> in an appropriate
> way to the user.
> The detection and signature producing procedure is also explained in 
> detail in my proposed
> BIP body.
>
>
> The above changes are the most notable changes, but my Pull Request to the 
> BIP ([2]) also
> addresses additional discussion points raised in Bitcoin Core PRs and 
> previous mailing list
> discussions:
>  - Clarify intent and terminology of the BIP, make it clear what it can't 
> prove (the PR body
>    [2] contains links to the relevant discussions).
>  - Add extensive test vectors for all the variants.
>  - Propose the status to move to "Complete".
>  - Offer myself to be a deputy to BIP-322 as described in BIP-3.
>
> I'm looking forward to your feedback and to further discussion here or on 
> the BIPs PR ([2]).
>
> Oli
>
>
> [1]: https://github.com/btcsuite/btcd/pull/2521
> [2]: https://github.com/bitcoin/bips/pull/2141
> [3]: https://groups.google.com/g/bitcoindev/c/RCi1Exs0ZvQ/m/NsFQcCcaCAAJ
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/fa1ca8ae-385a-4f16-85c2-544f8667b00en%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 8524 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] BIP-322: Add type prefix, change PoF serialization, PSBT-based signing
@ 2026-04-20  7:22  1% Oliver
  2026-04-20 14:47  1% ` [bitcoindev] " Thomas Suau
  0 siblings, 1 reply; 200+ results
From: Oliver @ 2026-04-20  7:22 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5251 bytes --]

Dear mailing list

I've started an implementation of BIP-322 in Go ([1]), and during 
implementation I noticed
that a number of open questions remain.

I believe that these open questions and the "Draft" status are contributing 
reasons for the
BIP not being widely implemented.
I do see demand for generic message signing in discussions and pull 
requests, though, so I'm
taking a shot at helping to move the BIP forward ([2]).

In short, I'm proposing three major changes:
 - Introduce a human-readable prefix to distinguish the three signature 
variants.
 - Change the encoding format of the "Proof of Funds" variant to include 
UTXO information.
 - Introduce a new PSBT field for for PSBT-based message signing.

Let me explain the details and reasoning behind the changes:


Human-readable prefix
------

As in an earlier discussion ([3]), not having a prefix and needing to 
attempt decoding both
initially proposed formats to detect which one a signature used is 
cumbersome, potentially
error prone and requires careful implementation.
Introducing a simple fixed-length (for easy detection and parsing) 
human-readable prefix that
is simply prepended to the base64-encoded signature should make detection 
quite straightforward
in code and also make it easy to distinguish a BIP-322 signature from a 
legacy one.
The proposed prefixes are: `smp`, `ful`, `pof` for the 'simple', 'full' and 
'Proof of Funds'
variants respectively.
Because there already are implementations of BIP-322 out there, I also 
added a backward
compatibility clause for existing implementations. Observing that many of 
the implementations
I found and looked at only produce signatures of the 'simple' variant, an 
implementation may
assume the 'simple' format if it doesn't detect a valid prefix.


Encoding format of the "Proof of Funds" variant
------

The "Proof of Funds" variant allows attesting spendability of specific 
UTXOs. While the
selection and purpose of the UTXOs (e.g., completeness or unspent status) 
remain out of scope
of the BIP, it is my opinion that it should at least be possible to 
validate (offline) that
the witness of a BIP-322 `to_sign` transaction is valid, should be part of 
the specification.
However, validating the witness of an additional input requires its UTXO 
information.
Instead of coming up with a custom encoding for the UTXO information in 
addition to the
full `to_sign` transaction, I realized that a finalized PSBT contains 
exactly the information
we require: The full transaction, the witness and/or signature scripts and 
the (Non-)Witness
UTXO fields. A finalized PSBT also must not contain fields that may be 
detrimental to privacy,
like internal keys, xPubs or script information.
Therefore, I propose that the encoding format for the "Proof of Funds" 
variant should be the
full, base64-encoded PSBT of the `to_sign` transaction, but in the 
"finalized" state as
described in BIP-174.
Because non-witness inputs require the whole previous transaction to be 
present, I also added
a size optimization that allows this field to be reused between inputs if 
more than one input
references the same previous transaction.


New PSBT field for PSBT-based message signing
------

When creating a signature for a multisig address script, it makes sense to 
use a PSBT to get
a signature for the `to_sign` transaction from each signer.
However, although a signer produces a signature for a _transaction_, their 
intent is to sign
a _message_. Signing software and devices should be able to show that fact 
in their user
interface, as a BIP-322 transaction would look unusual to a user when 
presented as such
(spending a zero-value output into an OP_RETURN output).
I propose to add a new field (PSBT_IN_GENERIC_SIGNED_MESSAGE, 0x21) to the 
first input of
the PSBT-wrapped `to_sign` transaction that contains the full message to be 
signed. A signing
device or software can then detect and present such a message-signing PSBT 
in an appropriate
way to the user.
The detection and signature producing procedure is also explained in detail 
in my proposed
BIP body.


The above changes are the most notable changes, but my Pull Request to the 
BIP ([2]) also
addresses additional discussion points raised in Bitcoin Core PRs and 
previous mailing list
discussions:
 - Clarify intent and terminology of the BIP, make it clear what it can't 
prove (the PR body
   [2] contains links to the relevant discussions).
 - Add extensive test vectors for all the variants.
 - Propose the status to move to "Complete".
 - Offer myself to be a deputy to BIP-322 as described in BIP-3.

I'm looking forward to your feedback and to further discussion here or on 
the BIPs PR ([2]).

Oli


[1]: https://github.com/btcsuite/btcd/pull/2521
[2]: https://github.com/bitcoin/bips/pull/2141
[3]: https://groups.google.com/g/bitcoindev/c/RCi1Exs0ZvQ/m/NsFQcCcaCAAJ

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/2d8243b4-6c89-4d9a-b7d5-86cfc9ff875an%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 5935 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-14 22:39  0%     ` Murch
@ 2026-04-16 22:02  0%       ` 'bubb1es' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'bubb1es' via Bitcoin Development Mailing List @ 2026-04-16 22:02 UTC (permalink / raw)
  To: Murch; +Cc: bitcoindev


Hi Murch, thanks for explaining the sighash issue. I understand better now that a RBF free-for-all caused by signing dust inputs with `NONE|ANYONECANPAY` is very undesirable in terms of tx relay bandwidth and mempool processing. I've changes our draft BIP spec and reference `ddust` tool back to require the `ALL|ANYONECANPAY` sighash type. (https://github.com/bubb1es71/ddust/pull/31).

Next harris is updating the batching spec to select and order dust inputs in a more deterministic way. He's also  updating the `ddust` tool batching and adding tests to follow the updated spec and make sure it follows all the RBF rules.  

Sent with Proton Mail secure email.

On Wednesday, April 15th, 2026 at 2:55 AM, Murch <murch@murch.one> wrote:

> Hi bubb1les,
> 
> Sorry, I thought Steven might be another co-author or an accidental 
> reply from a diffierent email account by you. Thanks for clarifying.
> 
> At recent feerates of 0.12–0.15 s/vB, e.g., a P2TR keypath-spend input 
> only costs 6–9 sats, but with the P2TR dust limit being defined 
> traditionally as 330 sats, a P2TR keypath-spend could pay for itself at 
> feerates of up to ~5.72 s/vB.
> 
> Using `NONE|ANYONECANPAY` sighash flags would mean that any sender that 
> sees a transaction with the inputs could try to use them to fund their 
> own transactions for free. With the new incremental relay feerate of 
> 0.1 s/vB, this could lead to quite a few replacements and conflicting 
> transactions before any one of them were to get confirmed. Using 
> `ALL|ANYONECANPAY` would only allow aggregating inputs that commit to 
> the same dust destruction output script which prevents this potential 
> bandwidth wasting competition vector.
> 
> Cheers,
> Murch
> 
> On 2026-04-09 19:14, bubb1es wrote:
> > Hi Murch, since posting we've had some constructive discussion on the Delving thread with nothingmuch (https://delvingbitcoin.org/t/disposing-of-dust-attack-utxos/2215/21). He suggested using the "NONE|ANYONECANPAY" sighash flags instead of "ALL|ANYONECANPAY" as we originally proposed.
> >
> >
> > This change would allow batched dust transactions to replace an unnecessary OP_RETURN "ash" output with an empty OP_RETURN. I don't see any downside to doing this so I've updated the proposed draft BIP.
> >
> > I've also updated the draft BIP with your corrections regarding the versions of Bitcoin Core with the new feerate policy.
> >
> > Thank you for your review and encouragement! We hope to submit it for review soon.
> >
> > PS. I do not know who "<STEVEN SLATER> thugm501@gmail.com" is and he has not made any contributions to this project.
> >
> > On Monday, April 6th, 2026 at 11:26 AM, Murch <murch@murch.one> wrote:
> >
> >> Hi bubb1es,
> >>
> >> I just skimmed your proposal and was considering the impact of the two
> >> possible output variants. As you mention in the description of the test
> >> cases, adding more inputs to a transaction would retain the output of
> >> the first transaction that appeared on the network. However, if two
> >> users independently submit transactions with incompatible outputs, third
> >> parties would not be able to aggregate those transactions into a single
> >> transaction.
> >>
> >> I was wondering whether you considered generally requiring the
> >> ash-output to ensure that transactions can always be collapsed. This may
> >> especially be attractive if feerates will be more dynamic in the future
> >> and dust disposal transactions linger in the mempool for a while.
> >>
> >> It probably comes down to how heavily this scheme will be used whether a
> >> general 3-byte overhead is justifiable to simplify aggregation. Either
> >> way, perhaps you could expound a bit on that trade-off in your rationale.
> >>
> >> Also, minor correction: the feerate policy change was backported to
> >> Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
> >> releases of those major branches would also propagate sub-sat transactions.
> >>
> >> Otherwise, this proposal looks reasonable to me. Looking forward to your
> >> submission.
> >>
> >> Cheers,
> >> Murch
> >>
> >> On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List wrote:
> >>> Hi, based on a topic I started on Delving <https://delvingbitcoin.org/t/
> >>> disposing-of-dust-attack-utxos/2215> I'd like to gather feedback from
> >>> this community for a BIP to standardize disposing of dust UTXOs by
> >>> spending their values to the fee of single OP_RETURN output transactions.
> >>>
> >>> Thanks in advance for taking your time to consider this proposal.
> >>>
> >>> ```
> >>> BIP: ?
> >>> Layer: Applications
> >>> Title: Dust UTXO Disposal Protocol
> >>> Authors: bubb1es <bubb1es71@proton.me>
> >>> harris <imtux2@proton.me>
> >>> Status: Draft
> >>> Type: Specification
> >>> Assigned: ?
> >>> License: CC0-1.0
> >>> Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-of-dust-
> >>> attack-utxos/2215
> >>> Version: 0.1.0
> >>> ```
> >>>
> >>> ## Abstract
> >>>
> >>> This BIP specifies a standardized protocol for safely disposing of dust
> >>> UTXOs by spending them to an OP_RETURN output with the entire value
> >>> going to transaction fees. The protocol enables wallet software to
> >>> remove unwanted small-value UTXOs, particularly those received in dust
> >>> attacks, without creating new address linkages or degrading user
> >>> privacy. The specification includes transaction format requirements,
> >>> signature conventions enabling third-party batching, and validation
> >>> rules for compliant implementations.
> >>>
> >>> ## Motivation
> >>>
> >>> ### The Dust Attack Problem
> >>>
> >>> Dust attacks are a well-documented privacy threat where attackers send
> >>> small amounts of bitcoin to numerous addresses. When wallet software
> >>> later consolidates these dust UTXOs with non-dust UTXOs, the attacker
> >>> can analyze the blockchain to link previously unassociated addresses,
> >>> potentially deanonymizing users.
> >>>
> >>> The common solution to this issue is to "lock" dust UTXOs and never
> >>> spend them, but this creates its own problems:
> >>>
> >>> 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the
> >>> UTXO set that all full nodes must maintain.
> >>> 2. **Wallet Clutter**: Accumulated dust degrades wallet usability and
> >>> complicates coin selection.
> >>> 3. **Accidental Consolidation**: Users may inadvertently spend dust
> >>> during legitimate transactions, achieving the attacker's goal.
> >>> 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
> >>> prevent spending provides only temporary protection; wallet migrations,
> >>> restores from seed phrases, software bugs, or inheritance scenarios can
> >>> inadvertently unlock dust, exposing users to the original attack.
> >>>
> >>> ### Why OP_RETURN Disposal
> >>>
> >>> Spending dust to an OP_RETURN output with the entire value going to fees
> >>> provides several benefits:
> >>>
> >>> 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not
> >>> stored in the UTXO set.
> >>> 2. **No Address Linking**: Without a change output, there is no new
> >>> address to link.
> >>> 3. **Permanent Removal**: The dust UTXOs are removed from the user's
> >>> wallet entirely.
> >>> 4. **Miner Compensation**: OP_RETURN outputs are small, providing higher
> >>> transaction fee rates.
> >>> 5. **No Cost to Victims**: Dust attack UTXO values are used to pay for
> >>> their own disposal.
> >>>
> >>> ### Why Standardization
> >>>
> >>> A standardized protocol enables:
> >>>
> >>> 1. **Wallet Anonymity**: Transactions with a standard format cannot be
> >>> used to fingerprint the wallet software a user is running.
> >>> 2. **Third-Party Batching**: Multiple dust disposals can be combined
> >>> into single transactions, reducing overall block space consumption.
> >>> 3. **Best Practice Codification**: Ensures implementations follow
> >>> privacy-preserving best practices.
> >>> 4. **Easy Identification**: Chain analysis tools can use disposal
> >>> transactions to help trace the sources of dust attacks.
> >>>
> >>> ## Specification
> >>>
> >>> ### Transaction Format
> >>>
> >>> A compliant dust disposal transaction MUST satisfy all the following
> >>> requirements:
> >>>
> >>> #### Overall
> >>>
> >>> 1. The transaction MUST signal RBF replaceability (nSequence < 0xFFFFFFFE).
> >>> 2. The ntimelock MUST be set to block height 0.
> >>> 3. The fee rate MUST be at least 0.1 sat/vB.
> >>>
> >>> #### Outputs
> >>>
> >>> 1. The transaction MUST have exactly one output.
> >>> 2. The single output MUST be an OP_RETURN.
> >>> 3. The OP_RETURN data MUST be either:
> >>> - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
> >>> - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
> >>> OP_PUSHBYTES_3 "ash").
> >>>
> >>> The "ash" marker MUST be used when padding is needed to meet the 65 vB
> >>> minimum standard transaction size with a single witness input.
> >>> Implementations MUST prefer empty OP_RETURN data when the transaction
> >>> already meets minimum size requirements.
> >>>
> >>> #### Inputs
> >>>
> >>> 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
> >>> SIGHASH_ANYONECANPAY` (0x81).
> >>> 2. For Taproot (P2TR) inputs using key-path spending, implementations
> >>> MUST explicitly append the signature hash type byte `SIGHASH_ALL |
> >>> SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the
> >>> default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does
> >>> not include ANYONECANPAY.
> >>> 3. All inputs must be confirmed in the blockchain at least one block deep.
> >>>
> >>> #### Fees
> >>>
> >>> 1. The entire input value MUST go to fees (output value is zero for
> >>> OP_RETURN).
> >>> 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum
> >>> relay requirements (Bitcoin Core 30.0+).
> >>> 3. The transaction fee rate MAY be higher based on the available dust
> >>> UTXO amounts and transaction size.
> >>>
> >>> ### Transaction Size
> >>>
> >>> 1. The transaction base size MUST be at least 65 bytes to meet Bitcoin
> >>> Core's minimum relay size standardness rule.
> >>> 2. If the transaction would otherwise be smaller than 65 bytes, the
> >>> OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be
> >>> used to pad the transaction's size to 65 bytes.
> >>>
> >>> ### Address Consolidation Rules
> >>>
> >>> Implementations consolidating dust UTXOs for a single user (i.e., not
> >>> third-party batching services):
> >>>
> >>> - MUST NOT spend dust UTXOs that were sent to different addresses in the
> >>> same transaction.
> >>> - MUST NOT broadcast dust disposal transactions at the same time for
> >>> dust sent to different addresses.
> >>> - SHOULD spend dust UTXOs for dust sent to the same address in one
> >>> transaction.
> >>>
> >>> ### Batching Dust Disposal Transactions via RBF
> >>>
> >>> Multiple unconfirmed dust disposal transactions created by unrelated
> >>> entities MAY be batched into a single replacement transaction using
> >>> Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY
> >>> signature type.
> >>>
> >>> In addition to standard RBF rules, batch dust disposal transactions must
> >>> follow all transaction construction requirements for non-batched dust
> >>> disposal transactions.
> >>>
> >>> #### Third-Party Batching
> >>>
> >>> A third-party batching service for dust disposal transactions could
> >>> compromise their users' privacy by collecting user-related network and
> >>> timing metadata. The best practice for these services is:
> >>>
> >>> 1. The service MUST NOT collect pre-signed inputs directly from wallet
> >>> users.
> >>> 2. The service SHOULD collect pre-signed inputs from the public bitcoin
> >>> network mempool.
> >>> 3. The service MAY add their own UTXO inputs to improve the batch
> >>> transaction's fee rate as long as all the requirements of this
> >>> specification are still followed.
> >>>
> >>> This mempool-based approach preserves user privacy while enabling
> >>> efficient batching:
> >>>
> >>> 1. Users broadcast their individual dust disposal transactions to the
> >>> network.
> >>> 2. Batching services monitor the mempool for compliant dust disposal
> >>> transactions.
> >>> 3. Services can combine unconfirmed transactions via RBF without knowing
> >>> user identities.
> >>>
> >>> ### Dust Threshold
> >>>
> >>> Implementations SHOULD allow users to configure their own dust threshold
> >>> based on:
> >>>
> >>> 1. The current and anticipated fee rates.
> >>> 2. The dust input script type, different types have different spending
> >>> costs.
> >>> 3. The varying amounts that may be used by dust attack initiators.
> >>>
> >>> A UTXO is generally considered dust if its value is less than the cost
> >>> to spend it at a reasonable fee rate, but any small UTXO value could be
> >>> used in a dust attack.
> >>>
> >>> ### Security Considerations
> >>>
> >>> #### Transaction Signing
> >>>
> >>> 1. **Key Security**: Signing dust disposal transactions requires signing
> >>> with the user's wallet private keys. This could be a risk for cold
> >>> storage wallets where the key or keys needed to sign are not easily
> >>> accessible.
> >>> 2. **Transaction Correctness**: Transaction signers must carefully
> >>> review and verify that only dust UTXOs are spent and no other inputs are
> >>> signed.
> >>>
> >>> #### Privacy Preservation
> >>>
> >>> 1. **Network surveillance**: Internet service providers and other
> >>> internet monitors may be able to determine the nodes that initially
> >>> broadcast a dust disposal transaction. If available the
> >>> `sendrawtransaction -privatebroadcast` RPC feature should be used
> >>> (available in [Bitcoin Core 31.0](https://github.com/bitcoin-core/
> >>> bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
> >>> 2. **Timing Analysis**: Users should be aware that the timing of dust
> >>> disposal transactions is publicly observable. Dust disposal transactions
> >>> should not be broadcast at the same time or on a predictable schedule.
> >>> 3. **Amount Analysis**: The specific dust amounts selected for dust
> >>> disposal if outside the norm may be used to fingerprint the wallet
> >>> creating the disposal transactions.
> >>>
> >>> ## Rationale
> >>>
> >>> ### Why Empty or "ash" OP_RETURN Data?
> >>>
> >>> 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the
> >>> transaction size.
> >>> 2. **Standardization**: Consistent transaction construction eliminates
> >>> wallet fingerprinting.
> >>> 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
> >>> OP_PUSHBYTES_3 "ash") provides a standardized way to meet the minimum
> >>> transaction size; e.g., for a single P2TR dust input.
> >>> 4. **Semantic Meaning**: The word "ash" metaphorically represents the
> >>> result of "burning" the dust.
> >>>
> >>> ### Why Per-Address Transactions?
> >>>
> >>> Consolidating dust from multiple addresses for the same wallet creates
> >>> the same privacy harm that dust attacks attempt to achieve. By requiring
> >>> wallet software to create separate transactions per address (by
> >>> default), the protocol ensures dust disposal doesn't harm privacy.
> >>>
> >>> ### Why 65 Byte Minimum?
> >>>
> >>> Bitcoin Core enforces a minimum transaction base size of 65 bytes as a
> >>> policy rule to prevent certain attack vectors. Compliant transactions
> >>> must meet this threshold to be relayed by standard nodes.
> >>>
> >>> ### Why 0.1 sat/vB Minimum Fee Rate?
> >>>
> >>> [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced
> >>> the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust
> >>> UTXOs to be disposed of economically even when their value is very
> >>> small. Implementations targeting earlier node versions may need higher
> >>> minimum fee rates.
> >>>
> >>> ### Why SIGHASH_ALL|ANYONECANPAY?
> >>>
> >>> The ANYONECANPAY flag allows additional inputs to be added to the dust
> >>> disposal transaction after signing. This provides several benefits:
> >>>
> >>> 1. **Batching**: Unrelated dust disposal transactions can be found in
> >>> the mempool and batched together via RBF.
> >>> 2. **User privacy**: Transactions shared via the public mempool do not
> >>> reveal user identity metadata.
> >>> 3. **Fee Bumping**: Additional inputs can be added by unrelated third
> >>> parties to increase the fee rate.
> >>>
> >>> ### Why nLockTime block height 0
> >>>
> >>> 1. **User privacy**: Using the same nLockTime for all dust disposal
> >>> transactions obscures when it was created.
> >>> 2. **Fee sniping**: The value of disposal transactions should be small
> >>> enough that fee sniping is not a concern.
> >>>
> >>> ## Backwards Compatibility
> >>>
> >>> This BIP introduces no changes to the Bitcoin consensus rules or peer-
> >>> to-peer protocol. All transactions conforming to this specification are
> >>> valid under existing consensus rules and can be relayed by nodes supporting:
> >>>
> >>> - OP_RETURN outputs (Bitcoin Core 0.9.0+)
> >>> - SIGHASH_ANYONECANPAY (original Bitcoin feature)
> >>> - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
> >>> - Private transaction broadcast (Bitcoin Core 31.0+)
> >>>
> >>> Nodes running Bitcoin Core versions prior to 30.0 do not relay
> >>> transactions with fee rates below 1 sat/vB which could slow the relaying
> >>> of disposal transactions with lower fee rates.
> >>>
> >>> ## Reference Implementation
> >>>
> >>> A reference implementation is available at: https://github.com/
> >>> bubb1es71/ddust
> >>>
> >>> The implementation provides:
> >>> - Command-line tool for creating dust disposal transactions
> >>> - Automatic dust detection based on configurable thresholds
> >>> - Transaction batching via RBF
> >>> - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
> >>> - Integration with Bitcoin Core (version 30.0+) via RPC for syncing and
> >>> broadcasting transactions
> >>>
> >>> ## Test Cases
> >>>
> >>> The test cases below can be used to verify a wallet disposes of dust
> >>> UTXOs according to the specification in this BIP.
> >>>
> >>> ### List dust
> >>>
> >>> 1. Create payment addresses for multiple address types, send dust and
> >>> non-dust amounts to these addresses, verify that listing dust only
> >>> returns UTXOs at or below the configured dust threshold (e.g. 1000 sats).
> >>> 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
> >>> verify listing dust only returns the confirmed dust UTXOs.
> >>>
> >>> ### Spending dust
> >>>
> >>> All valid dust disposal transactions should be verified to be accepted
> >>> into the bitcoind (Bitcoin Core 30.0+) mempool.
> >>>
> >>> 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
> >>> dust disposal transaction with a single "ash" OP_RETURN output.
> >>> 2. Spending multiple dust UTXOs always produces a single empty OP_RETURN
> >>> output regardless of script type.
> >>> 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single
> >>> empty OP_RETURN output.
> >>> 4. All dust UTXOs sent to the same address are disposed of in the same
> >>> transaction.
> >>> 5. Dust disposal transactions only include confirmed dust UTXOs.
> >>>
> >>> #### Example dust disposal transaction sizes
> >>>
> >>> | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> >>> |-------------------|-------|------------|--------|-------------|-------|
> >>> | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
> >>> | Input (b) | 148 | 295 | 41 | 41 | 41 |
> >>> | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
> >>> | Base size (b) | 169 | 316 | 65 | 65 | 65 |
> >>> | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
> >>> | Size (b) | 169 | 316 | 173 | 320 | 132 |
> >>> | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
> >>> | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
> >>>
> >>> #### Example dust disposal transaction fee rates (sats/vb)
> >>>
> >>> | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> >>> |--------------|---------|------------|--------|-------------|-------|
> >>> | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
> >>> | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
> >>> | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
> >>> | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
> >>>
> >>> ### Batching dust disposal txs via RBF
> >>>
> >>> 1. Adding a Bech32m dust input to an unconfirmed disposal transaction
> >>> with a legacy dust input keeps the original single empty OP_RETURN output.
> >>> 2. Adding a Bech32m dust input to an unconfirmed disposal transaction
> >>> with a Bech32m dust input keeps the original single "ash" OP_RETURN output.
> >>> 3. Adding a new dust input to an unconfirmed disposal transaction
> >>> results in a new batch disposal transaction with a fee rate sufficient
> >>> for RBF.
> >>> 4. A new dust input that contributes an insufficient fee rate for RBF
> >>> with an existing unconfirmed disposal transaction is not batched with it.
> >>>
> >>> ## Related work
> >>>
> >>> * "dust-b-gone": https://github.com/petertodd/dust-b-gone
> >>> * "dusts": https://github.com/bubb1es71/dusts
> >>>
> >>> ## Changelog
> >>>
> >>> * **0.1.0** (2026-03-22):
> >>> * Initial draft of the BIP.
> >>>
> >>> ## Copyright
> >>>
> >>>
> >>> This document is licensed under the Creative Commons CC0 1.0 Universal
> >>> license.
> >>>
> >>> --
> >>> You received this message because you are subscribed to the Google
> >>> Groups "Bitcoin Development Mailing List" group.
> >>> To unsubscribe from this group and stop receiving emails from it, send
> >>> an email to bitcoindev+unsubscribe@googlegroups.com
> >>> <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> >>> To view this discussion visit https://groups.google.com/d/msgid/
> >>> bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com
> >>> <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
> >>> b53a-0e9b631044ffn%40googlegroups.com?utm_medium=email&utm_source=footer>.
> >> --
> >> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> >> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> >> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one.
> >>
> 
> -- 
> You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/pr1z3_j8vTc/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/4c3bb222-c492-4eb2-af98-68bee09ec5cd%40murch.one.
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ORIGIO060hH_CrtpqpBQ_WLqZJ2xE41K17-P11n2aUsCpGDqhim0om_kz_rJ2oMjlzmPUt84YlRHsvcj1LJAtXQe_FlS0p_SW0Khm5LTN1Y%3D%40proton.me.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-10  2:14  1%   ` 'bubb1es' via Bitcoin Development Mailing List
@ 2026-04-14 22:39  0%     ` Murch
  2026-04-16 22:02  0%       ` 'bubb1es' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Murch @ 2026-04-14 22:39 UTC (permalink / raw)
  To: bubb1es; +Cc: bitcoindev


[-- Attachment #1.1.1: Type: text/plain, Size: 21602 bytes --]

Hi bubb1les,

Sorry, I thought Steven might be another co-author or an accidental 
reply from a diffierent email account by you. Thanks for clarifying.

At recent feerates of 0.12–0.15 s/vB, e.g., a P2TR keypath-spend input 
only costs 6–9 sats, but with the P2TR dust limit being defined 
traditionally as 330 sats, a P2TR keypath-spend could pay for itself at 
feerates of up to ~5.72 s/vB.

Using `NONE|ANYONECANPAY` sighash flags would mean that any sender that 
sees a transaction with the inputs could try to use them to fund their 
own transactions for free. With the new incremental relay feerate of 
0.1 s/vB, this could lead to quite a few replacements and conflicting 
transactions before any one of them were to get confirmed. Using 
`ALL|ANYONECANPAY` would only allow aggregating inputs that commit to 
the same dust destruction output script which prevents this potential 
bandwidth wasting competition vector.

Cheers,
Murch

On 2026-04-09 19:14, bubb1es wrote:
> Hi Murch, since posting we've had some constructive discussion on the Delving thread with nothingmuch (https://delvingbitcoin.org/t/disposing-of-dust-attack-utxos/2215/21). He suggested using the "NONE|ANYONECANPAY" sighash flags instead of "ALL|ANYONECANPAY" as we originally proposed.
>
>
> This change would allow batched dust transactions to replace an unnecessary OP_RETURN "ash" output with an empty OP_RETURN. I don't see any downside to doing this so I've updated the proposed draft BIP.
>
> I've also updated the draft BIP with your corrections regarding the versions of Bitcoin Core with the new feerate policy.
>
> Thank you for your review and encouragement! We hope to submit it for review soon.
>
> PS. I do not know who "<STEVEN SLATER> thugm501@gmail.com" is and he has not made any contributions to this project.
>
> On Monday, April 6th, 2026 at 11:26 AM, Murch <murch@murch.one> wrote:
>
>> Hi bubb1es,
>>
>> I just skimmed your proposal and was considering the impact of the two
>> possible output variants. As you mention in the description of the test
>> cases, adding more inputs to a transaction would retain the output of
>> the first transaction that appeared on the network. However, if two
>> users independently submit transactions with incompatible outputs, third
>> parties would not be able to aggregate those transactions into a single
>> transaction.
>>
>> I was wondering whether you considered generally requiring the
>> ash-output to ensure that transactions can always be collapsed. This may
>> especially be attractive if feerates will be more dynamic in the future
>> and dust disposal transactions linger in the mempool for a while.
>>
>> It probably comes down to how heavily this scheme will be used whether a
>> general 3-byte overhead is justifiable to simplify aggregation. Either
>> way, perhaps you could expound a bit on that trade-off in your rationale.
>>
>> Also, minor correction: the feerate policy change was backported to
>> Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
>> releases of those major branches would also propagate sub-sat transactions.
>>
>> Otherwise, this proposal looks reasonable to me. Looking forward to your
>> submission.
>>
>> Cheers,
>> Murch
>>
>> On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List wrote:
>>> Hi, based on a topic I started on Delving <https://delvingbitcoin.org/t/
>>> disposing-of-dust-attack-utxos/2215> I'd like to gather feedback from
>>> this community for a BIP to standardize disposing of dust UTXOs by
>>> spending their values to the fee of single OP_RETURN output transactions.
>>>
>>> Thanks in advance for taking your time to consider this proposal.
>>>
>>> ```
>>> BIP: ?
>>> Layer: Applications
>>> Title: Dust UTXO Disposal Protocol
>>> Authors: bubb1es <bubb1es71@proton.me>
>>> harris <imtux2@proton.me>
>>> Status: Draft
>>> Type: Specification
>>> Assigned: ?
>>> License: CC0-1.0
>>> Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-of-dust-
>>> attack-utxos/2215
>>> Version: 0.1.0
>>> ```
>>>
>>> ## Abstract
>>>
>>> This BIP specifies a standardized protocol for safely disposing of dust
>>> UTXOs by spending them to an OP_RETURN output with the entire value
>>> going to transaction fees. The protocol enables wallet software to
>>> remove unwanted small-value UTXOs, particularly those received in dust
>>> attacks, without creating new address linkages or degrading user
>>> privacy. The specification includes transaction format requirements,
>>> signature conventions enabling third-party batching, and validation
>>> rules for compliant implementations.
>>>
>>> ## Motivation
>>>
>>> ### The Dust Attack Problem
>>>
>>> Dust attacks are a well-documented privacy threat where attackers send
>>> small amounts of bitcoin to numerous addresses. When wallet software
>>> later consolidates these dust UTXOs with non-dust UTXOs, the attacker
>>> can analyze the blockchain to link previously unassociated addresses,
>>> potentially deanonymizing users.
>>>
>>> The common solution to this issue is to "lock" dust UTXOs and never
>>> spend them, but this creates its own problems:
>>>
>>> 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the
>>> UTXO set that all full nodes must maintain.
>>> 2. **Wallet Clutter**: Accumulated dust degrades wallet usability and
>>> complicates coin selection.
>>> 3. **Accidental Consolidation**: Users may inadvertently spend dust
>>> during legitimate transactions, achieving the attacker's goal.
>>> 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
>>> prevent spending provides only temporary protection; wallet migrations,
>>> restores from seed phrases, software bugs, or inheritance scenarios can
>>> inadvertently unlock dust, exposing users to the original attack.
>>>
>>> ### Why OP_RETURN Disposal
>>>
>>> Spending dust to an OP_RETURN output with the entire value going to fees
>>> provides several benefits:
>>>
>>> 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not
>>> stored in the UTXO set.
>>> 2. **No Address Linking**: Without a change output, there is no new
>>> address to link.
>>> 3. **Permanent Removal**: The dust UTXOs are removed from the user's
>>> wallet entirely.
>>> 4. **Miner Compensation**: OP_RETURN outputs are small, providing higher
>>> transaction fee rates.
>>> 5. **No Cost to Victims**: Dust attack UTXO values are used to pay for
>>> their own disposal.
>>>
>>> ### Why Standardization
>>>
>>> A standardized protocol enables:
>>>
>>> 1. **Wallet Anonymity**: Transactions with a standard format cannot be
>>> used to fingerprint the wallet software a user is running.
>>> 2. **Third-Party Batching**: Multiple dust disposals can be combined
>>> into single transactions, reducing overall block space consumption.
>>> 3. **Best Practice Codification**: Ensures implementations follow
>>> privacy-preserving best practices.
>>> 4. **Easy Identification**: Chain analysis tools can use disposal
>>> transactions to help trace the sources of dust attacks.
>>>
>>> ## Specification
>>>
>>> ### Transaction Format
>>>
>>> A compliant dust disposal transaction MUST satisfy all the following
>>> requirements:
>>>
>>> #### Overall
>>>
>>> 1. The transaction MUST signal RBF replaceability (nSequence < 0xFFFFFFFE).
>>> 2. The ntimelock MUST be set to block height 0.
>>> 3. The fee rate MUST be at least 0.1 sat/vB.
>>>
>>> #### Outputs
>>>
>>> 1. The transaction MUST have exactly one output.
>>> 2. The single output MUST be an OP_RETURN.
>>> 3. The OP_RETURN data MUST be either:
>>> - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
>>> - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
>>> OP_PUSHBYTES_3 "ash").
>>>
>>> The "ash" marker MUST be used when padding is needed to meet the 65 vB
>>> minimum standard transaction size with a single witness input.
>>> Implementations MUST prefer empty OP_RETURN data when the transaction
>>> already meets minimum size requirements.
>>>
>>> #### Inputs
>>>
>>> 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
>>> SIGHASH_ANYONECANPAY` (0x81).
>>> 2. For Taproot (P2TR) inputs using key-path spending, implementations
>>> MUST explicitly append the signature hash type byte `SIGHASH_ALL |
>>> SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the
>>> default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does
>>> not include ANYONECANPAY.
>>> 3. All inputs must be confirmed in the blockchain at least one block deep.
>>>
>>> #### Fees
>>>
>>> 1. The entire input value MUST go to fees (output value is zero for
>>> OP_RETURN).
>>> 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum
>>> relay requirements (Bitcoin Core 30.0+).
>>> 3. The transaction fee rate MAY be higher based on the available dust
>>> UTXO amounts and transaction size.
>>>
>>> ### Transaction Size
>>>
>>> 1. The transaction base size MUST be at least 65 bytes to meet Bitcoin
>>> Core's minimum relay size standardness rule.
>>> 2. If the transaction would otherwise be smaller than 65 bytes, the
>>> OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be
>>> used to pad the transaction's size to 65 bytes.
>>>
>>> ### Address Consolidation Rules
>>>
>>> Implementations consolidating dust UTXOs for a single user (i.e., not
>>> third-party batching services):
>>>
>>> - MUST NOT spend dust UTXOs that were sent to different addresses in the
>>> same transaction.
>>> - MUST NOT broadcast dust disposal transactions at the same time for
>>> dust sent to different addresses.
>>> - SHOULD spend dust UTXOs for dust sent to the same address in one
>>> transaction.
>>>
>>> ### Batching Dust Disposal Transactions via RBF
>>>
>>> Multiple unconfirmed dust disposal transactions created by unrelated
>>> entities MAY be batched into a single replacement transaction using
>>> Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY
>>> signature type.
>>>
>>> In addition to standard RBF rules, batch dust disposal transactions must
>>> follow all transaction construction requirements for non-batched dust
>>> disposal transactions.
>>>
>>> #### Third-Party Batching
>>>
>>> A third-party batching service for dust disposal transactions could
>>> compromise their users' privacy by collecting user-related network and
>>> timing metadata. The best practice for these services is:
>>>
>>> 1. The service MUST NOT collect pre-signed inputs directly from wallet
>>> users.
>>> 2. The service SHOULD collect pre-signed inputs from the public bitcoin
>>> network mempool.
>>> 3. The service MAY add their own UTXO inputs to improve the batch
>>> transaction's fee rate as long as all the requirements of this
>>> specification are still followed.
>>>
>>> This mempool-based approach preserves user privacy while enabling
>>> efficient batching:
>>>
>>> 1. Users broadcast their individual dust disposal transactions to the
>>> network.
>>> 2. Batching services monitor the mempool for compliant dust disposal
>>> transactions.
>>> 3. Services can combine unconfirmed transactions via RBF without knowing
>>> user identities.
>>>
>>> ### Dust Threshold
>>>
>>> Implementations SHOULD allow users to configure their own dust threshold
>>> based on:
>>>
>>> 1. The current and anticipated fee rates.
>>> 2. The dust input script type, different types have different spending
>>> costs.
>>> 3. The varying amounts that may be used by dust attack initiators.
>>>
>>> A UTXO is generally considered dust if its value is less than the cost
>>> to spend it at a reasonable fee rate, but any small UTXO value could be
>>> used in a dust attack.
>>>
>>> ### Security Considerations
>>>
>>> #### Transaction Signing
>>>
>>> 1. **Key Security**: Signing dust disposal transactions requires signing
>>> with the user's wallet private keys. This could be a risk for cold
>>> storage wallets where the key or keys needed to sign are not easily
>>> accessible.
>>> 2. **Transaction Correctness**: Transaction signers must carefully
>>> review and verify that only dust UTXOs are spent and no other inputs are
>>> signed.
>>>
>>> #### Privacy Preservation
>>>
>>> 1. **Network surveillance**: Internet service providers and other
>>> internet monitors may be able to determine the nodes that initially
>>> broadcast a dust disposal transaction. If available the
>>> `sendrawtransaction -privatebroadcast` RPC feature should be used
>>> (available in [Bitcoin Core 31.0](https://github.com/bitcoin-core/
>>> bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
>>> 2. **Timing Analysis**: Users should be aware that the timing of dust
>>> disposal transactions is publicly observable. Dust disposal transactions
>>> should not be broadcast at the same time or on a predictable schedule.
>>> 3. **Amount Analysis**: The specific dust amounts selected for dust
>>> disposal if outside the norm may be used to fingerprint the wallet
>>> creating the disposal transactions.
>>>
>>> ## Rationale
>>>
>>> ### Why Empty or "ash" OP_RETURN Data?
>>>
>>> 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the
>>> transaction size.
>>> 2. **Standardization**: Consistent transaction construction eliminates
>>> wallet fingerprinting.
>>> 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
>>> OP_PUSHBYTES_3 "ash") provides a standardized way to meet the minimum
>>> transaction size; e.g., for a single P2TR dust input.
>>> 4. **Semantic Meaning**: The word "ash" metaphorically represents the
>>> result of "burning" the dust.
>>>
>>> ### Why Per-Address Transactions?
>>>
>>> Consolidating dust from multiple addresses for the same wallet creates
>>> the same privacy harm that dust attacks attempt to achieve. By requiring
>>> wallet software to create separate transactions per address (by
>>> default), the protocol ensures dust disposal doesn't harm privacy.
>>>
>>> ### Why 65 Byte Minimum?
>>>
>>> Bitcoin Core enforces a minimum transaction base size of 65 bytes as a
>>> policy rule to prevent certain attack vectors. Compliant transactions
>>> must meet this threshold to be relayed by standard nodes.
>>>
>>> ### Why 0.1 sat/vB Minimum Fee Rate?
>>>
>>> [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced
>>> the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust
>>> UTXOs to be disposed of economically even when their value is very
>>> small. Implementations targeting earlier node versions may need higher
>>> minimum fee rates.
>>>
>>> ### Why SIGHASH_ALL|ANYONECANPAY?
>>>
>>> The ANYONECANPAY flag allows additional inputs to be added to the dust
>>> disposal transaction after signing. This provides several benefits:
>>>
>>> 1. **Batching**: Unrelated dust disposal transactions can be found in
>>> the mempool and batched together via RBF.
>>> 2. **User privacy**: Transactions shared via the public mempool do not
>>> reveal user identity metadata.
>>> 3. **Fee Bumping**: Additional inputs can be added by unrelated third
>>> parties to increase the fee rate.
>>>
>>> ### Why nLockTime block height 0
>>>
>>> 1. **User privacy**: Using the same nLockTime for all dust disposal
>>> transactions obscures when it was created.
>>> 2. **Fee sniping**: The value of disposal transactions should be small
>>> enough that fee sniping is not a concern.
>>>
>>> ## Backwards Compatibility
>>>
>>> This BIP introduces no changes to the Bitcoin consensus rules or peer-
>>> to-peer protocol. All transactions conforming to this specification are
>>> valid under existing consensus rules and can be relayed by nodes supporting:
>>>
>>> - OP_RETURN outputs (Bitcoin Core 0.9.0+)
>>> - SIGHASH_ANYONECANPAY (original Bitcoin feature)
>>> - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
>>> - Private transaction broadcast (Bitcoin Core 31.0+)
>>>
>>> Nodes running Bitcoin Core versions prior to 30.0 do not relay
>>> transactions with fee rates below 1 sat/vB which could slow the relaying
>>> of disposal transactions with lower fee rates.
>>>
>>> ## Reference Implementation
>>>
>>> A reference implementation is available at: https://github.com/
>>> bubb1es71/ddust
>>>
>>> The implementation provides:
>>> - Command-line tool for creating dust disposal transactions
>>> - Automatic dust detection based on configurable thresholds
>>> - Transaction batching via RBF
>>> - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
>>> - Integration with Bitcoin Core (version 30.0+) via RPC for syncing and
>>> broadcasting transactions
>>>
>>> ## Test Cases
>>>
>>> The test cases below can be used to verify a wallet disposes of dust
>>> UTXOs according to the specification in this BIP.
>>>
>>> ### List dust
>>>
>>> 1. Create payment addresses for multiple address types, send dust and
>>> non-dust amounts to these addresses, verify that listing dust only
>>> returns UTXOs at or below the configured dust threshold (e.g. 1000 sats).
>>> 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
>>> verify listing dust only returns the confirmed dust UTXOs.
>>>
>>> ### Spending dust
>>>
>>> All valid dust disposal transactions should be verified to be accepted
>>> into the bitcoind (Bitcoin Core 30.0+) mempool.
>>>
>>> 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
>>> dust disposal transaction with a single "ash" OP_RETURN output.
>>> 2. Spending multiple dust UTXOs always produces a single empty OP_RETURN
>>> output regardless of script type.
>>> 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single
>>> empty OP_RETURN output.
>>> 4. All dust UTXOs sent to the same address are disposed of in the same
>>> transaction.
>>> 5. Dust disposal transactions only include confirmed dust UTXOs.
>>>
>>> #### Example dust disposal transaction sizes
>>>
>>> | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
>>> |-------------------|-------|------------|--------|-------------|-------|
>>> | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
>>> | Input (b) | 148 | 295 | 41 | 41 | 41 |
>>> | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
>>> | Base size (b) | 169 | 316 | 65 | 65 | 65 |
>>> | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
>>> | Size (b) | 169 | 316 | 173 | 320 | 132 |
>>> | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
>>> | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
>>>
>>> #### Example dust disposal transaction fee rates (sats/vb)
>>>
>>> | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
>>> |--------------|---------|------------|--------|-------------|-------|
>>> | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
>>> | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
>>> | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
>>> | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
>>>
>>> ### Batching dust disposal txs via RBF
>>>
>>> 1. Adding a Bech32m dust input to an unconfirmed disposal transaction
>>> with a legacy dust input keeps the original single empty OP_RETURN output.
>>> 2. Adding a Bech32m dust input to an unconfirmed disposal transaction
>>> with a Bech32m dust input keeps the original single "ash" OP_RETURN output.
>>> 3. Adding a new dust input to an unconfirmed disposal transaction
>>> results in a new batch disposal transaction with a fee rate sufficient
>>> for RBF.
>>> 4. A new dust input that contributes an insufficient fee rate for RBF
>>> with an existing unconfirmed disposal transaction is not batched with it.
>>>
>>> ## Related work
>>>
>>> * "dust-b-gone": https://github.com/petertodd/dust-b-gone
>>> * "dusts": https://github.com/bubb1es71/dusts
>>>
>>> ## Changelog
>>>
>>> * **0.1.0** (2026-03-22):
>>> * Initial draft of the BIP.
>>>
>>> ## Copyright
>>>
>>>
>>> This document is licensed under the Creative Commons CC0 1.0 Universal
>>> license.
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+unsubscribe@googlegroups.com
>>> <mailto:bitcoindev+unsubscribe@googlegroups.com>.
>>> To view this discussion visit https://groups.google.com/d/msgid/
>>> bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com
>>> <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
>>> b53a-0e9b631044ffn%40googlegroups.com?utm_medium=email&utm_source=footer>.
>> --
>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one.
>>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/4c3bb222-c492-4eb2-af98-68bee09ec5cd%40murch.one.

[-- Attachment #1.1.2: OpenPGP public key --]
[-- Type: application/pgp-keys, Size: 56263 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: A slight change proposed on Committing to quantum resistance: a slow defence for Bitcoin against a fast quantum computing attack
  2026-04-06 20:30  1% [bitcoindev] A slight change proposed on Committing to quantum resistance: a slow defence for Bitcoin against a fast quantum computing attack PYM
@ 2026-04-11 17:09  0% ` Daniel Buchner
  0 siblings, 0 replies; 200+ results
From: Daniel Buchner @ 2026-04-11 17:09 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 2552 bytes --]

This is basically the same concept as this proposal that describes a 
mechanism to do so (which I started a thread about 
yesterday): https://github.com/csuwildcat/pqc-precommitment-migration. Only 
difference is that you'd just activate the precommitted PQC key/validation 
pathways instead of having to explicitly freeze ECC (though I suppose you 
could do both).

On Monday, April 6, 2026 at 3:32:30 PM UTC-5 PYM wrote:

> Hello, here's a small idea to combine merkel tree with timestamped message 
> signature to bind p2pkh adress to quantum resistant scheme so user do not 
> need to rush to move bitcoin before qday, in a space efficient form.
>
>
>    - *Universal P2PKH freeze* — At a defined block height, all P2PKH 
>    outputs become unspendable via classical ECDSA. 
>    - *Pre-freeze claim* — Before the freeze, owners sign a claim 
>    containing their Bitcoin address and a new post-quantum public key of their 
>    choice. The claim is ECDSA-signed, proving classical ownership while 
>    quantum computers don't yet exist. 
>    - *Merkle-batched publication* — Claims are batched into Merkle trees. 
>    Only the 32-byte root goes on-chain via OP_RETURN. One transaction covers 
>    large amount of claims. 
>    - *Post-freeze spending* — To spend a frozen output, provide: the 
>    original claim, a Merkle inclusion proof linking it to a pre-freeze root, 
>    and a signature from the post-quantum key committed in the claim.  
>    - *No claim, no spend* — Any P2PKH output with no registered claim 
>    before the freeze height is permanently frozen until a future recovery 
>    mechanism is defined by the community.
>
>
> I do not have enough knowledge to find the ideal scheme or implementation 
> that fulfill those requirements sadly. 
>
> 1 - Stewart I, Ilie D, Zamyatin A, Werner S, Torshizi MF, Knottenbelt WJ. 
> Committing to quantum resistance: a slow defence for Bitcoin against a fast 
> quantum computing attack. R Soc Open Sci. 2018 Jun 20;5(6):180410. doi: 
> 10.1098/rsos.180410. PMID: 30110420; PMCID: PMC6030263.
> https://pmc.ncbi.nlm.nih.gov/articles/PMC6030263/

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/adeaa540-eaf0-4a1c-ad67-57ae50a58671n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 3678 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-06 20:45  0%     ` Murch
@ 2026-04-10  2:23  0%       ` 'bubb1es' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'bubb1es' via Bitcoin Development Mailing List @ 2026-04-10  2:23 UTC (permalink / raw)
  To: Murch; +Cc: bitcoindev


Hi again Murch, to address your question about BIP 125, the reason we required the opt-in for our dust disposal spec is to prevent implementation fingerprinting. But if it's more future proof to not signal for it I'll put that in the spec. The most important thing is all implementations do the same thing.

PS. I still don't know who "<STEVEN SLATER> thugm501@gmail.com" is. I suspect a bot.

Sent with Proton Mail secure email.

On Monday, April 6th, 2026 at 4:04 PM, Murch <murch@murch.one> wrote:

> Hi Steven,
> 
> Thanks for the quick reply, looking forward to reading the updated document!
> 
> I just realized that I forgot another point in my prior email. While
> there are some other node implementations that still implement BIP 125:
> Opt-in Full Replace-by-Fee Signaling, Bitcoin Core 28.0 and later will
> accept replacements even if the original transaction did not signal
> replaceability¹, so you could consider dropping the replaceability
> signal requirement. While the dust disposal transactions will be quite
> distinguishable either way and it’s unlikely to be a big deal if they
> were to continue signaling in the future, it may be more forward-looking
> not to signal.
> 
> ¹ E.g., see the linked news items regarding `mempoolfullrbf` on
> https://bitcoinops.org/en/topics/replace-by-fee/ for details
> 
> Cheers,
> Murch
> 
> On 2026-04-06 11:11, STEVEN SLATER wrote:
> > Response to Feedback on Transaction Aggregation Proposal
> >
> > Hi Murch,
> >
> > Thank you for taking the time to review my proposal and for raising
> > these thoughtful points.
> >
> > On the question of requiring an ash-output: I did consider the idea of
> > mandating it universally. The main trade-off is between simplicity in
> > aggregation and the overhead cost. A fixed 3‑byte addition per
> > transaction is relatively small, but when scaled across high‑volume
> > usage it does introduce measurable bloat. My current rationale was to
> > avoid imposing that cost on transactions that are unlikely to benefit
> > from aggregation. That said, I agree that in scenarios where feerates
> > fluctuate significantly and dust transactions linger in the mempool, a
> > standardized ash-output could make collapsing transactions more
> > predictable and efficient. I’ll expand the rationale to weigh the
> > benefits of guaranteed collapsibility against the marginal overhead, and
> > outline conditions where the overhead is justified.
> >
> > Regarding incompatible outputs: you’re right that independent
> > submissions with conflicting outputs cannot be aggregated. My intent was
> > to highlight that aggregation works best when inputs are aligned, and
> > that ash-output could serve as a safeguard to preserve compatibility.
> > I’ll clarify this point further in the next revision.
> >
> > Thank you also for the correction on feerate policy backports to Bitcoin
> > Core 29.1 and 28.3. I’ll update the proposal to reflect that users on
> > those branches will indeed propagate sub‑sat transactions.
> >
> > I appreciate your constructive feedbackit helps sharpen the rationale
> > and ensures the proposal is practical for broader adoption. I’ll
> > incorporate these clarifications before submission.
> >
> > Best regards,
> > Steven
> >
> > On Mon, 6 Apr 2026, 5:26 pm Murch, <murch@murch.one> wrote:
> >
> >     Hi bubb1es,
> >
> >     I just skimmed your proposal and was considering the impact of the two
> >     possible output variants. As you mention in the description of the test
> >     cases, adding more inputs to a transaction would retain the output of
> >     the first transaction that appeared on the network. However, if two
> >     users independently submit transactions with incompatible outputs,
> >     third
> >     parties would not be able to aggregate those transactions into a single
> >     transaction.
> >
> >     I was wondering whether you considered generally requiring the
> >     ash-output to ensure that transactions can always be collapsed. This
> >     may
> >     especially be attractive if feerates will be more dynamic in the future
> >     and dust disposal transactions linger in the mempool for a while.
> >
> >     It probably comes down to how heavily this scheme will be used
> >     whether a
> >     general 3-byte overhead is justifiable to simplify aggregation. Either
> >     way, perhaps you could expound a bit on that trade-off in your
> >     rationale.
> >
> >     Also, minor correction: the feerate policy change was backported to
> >     Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
> >     releases of those major branches would also propagate sub-sat
> >     transactions.
> >
> >     Otherwise, this proposal looks reasonable to me. Looking forward to
> >     your
> >     submission.
> >
> >     Cheers,
> >     Murch
> >
> >     On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List
> >     wrote:
> >      >
> >      > Hi, based on a topic I started on Delving <https://
> >     delvingbitcoin.org/t/ <https://delvingbitcoin.org/t/>
> >      > disposing-of-dust-attack-utxos/2215> I'd like to gather feedback
> >     from
> >      > this community for a BIP to standardize disposing of dust UTXOs by
> >      > spending their values to the fee of single OP_RETURN output
> >     transactions.
> >      >
> >      > Thanks in advance for taking your time to consider this proposal.
> >      >
> >      > ```
> >      > BIP: ?
> >      > Layer: Applications
> >      > Title: Dust UTXO Disposal Protocol
> >      > Authors: bubb1es <bubb1es71@proton.me <mailto:bubb1es71@proton.me>>
> >      > harris <imtux2@proton.me <mailto:imtux2@proton.me>>
> >      > Status: Draft
> >      > Type: Specification
> >      > Assigned: ?
> >      > License: CC0-1.0
> >      > Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-
> >     of-dust- <https://delvingbitcoin.org/t/disposing-of-dust->
> >      > attack-utxos/2215
> >      > Version: 0.1.0
> >      > ```
> >      >
> >      > ## Abstract
> >      >
> >      > This BIP specifies a standardized protocol for safely disposing
> >     of dust
> >      > UTXOs by spending them to an OP_RETURN output with the entire value
> >      > going to transaction fees. The protocol enables wallet software to
> >      > remove unwanted small-value UTXOs, particularly those received in
> >     dust
> >      > attacks, without creating new address linkages or degrading user
> >      > privacy. The specification includes transaction format requirements,
> >      > signature conventions enabling third-party batching, and validation
> >      > rules for compliant implementations.
> >      >
> >      > ## Motivation
> >      >
> >      > ### The Dust Attack Problem
> >      >
> >      > Dust attacks are a well-documented privacy threat where attackers
> >     send
> >      > small amounts of bitcoin to numerous addresses. When wallet software
> >      > later consolidates these dust UTXOs with non-dust UTXOs, the
> >     attacker
> >      > can analyze the blockchain to link previously unassociated
> >     addresses,
> >      > potentially deanonymizing users.
> >      >
> >      > The common solution to this issue is to "lock" dust UTXOs and never
> >      > spend them, but this creates its own problems:
> >      >
> >      > 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in
> >     the
> >      > UTXO set that all full nodes must maintain.
> >      > 2. **Wallet Clutter**: Accumulated dust degrades wallet usability
> >     and
> >      > complicates coin selection.
> >      > 3. **Accidental Consolidation**: Users may inadvertently spend dust
> >      > during legitimate transactions, achieving the attacker's goal.
> >      > 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
> >      > prevent spending provides only temporary protection; wallet
> >     migrations,
> >      > restores from seed phrases, software bugs, or inheritance
> >     scenarios can
> >      > inadvertently unlock dust, exposing users to the original attack.
> >      >
> >      > ### Why OP_RETURN Disposal
> >      >
> >      > Spending dust to an OP_RETURN output with the entire value going
> >     to fees
> >      > provides several benefits:
> >      >
> >      > 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable
> >     and not
> >      > stored in the UTXO set.
> >      > 2. **No Address Linking**: Without a change output, there is no new
> >      > address to link.
> >      > 3. **Permanent Removal**: The dust UTXOs are removed from the user's
> >      > wallet entirely.
> >      > 4. **Miner Compensation**: OP_RETURN outputs are small, providing
> >     higher
> >      > transaction fee rates.
> >      > 5. **No Cost to Victims**: Dust attack UTXO values are used to
> >     pay for
> >      > their own disposal.
> >      >
> >      > ### Why Standardization
> >      >
> >      > A standardized protocol enables:
> >      >
> >      > 1. **Wallet Anonymity**: Transactions with a standard format
> >     cannot be
> >      > used to fingerprint the wallet software a user is running.
> >      > 2. **Third-Party Batching**: Multiple dust disposals can be combined
> >      > into single transactions, reducing overall block space consumption.
> >      > 3. **Best Practice Codification**: Ensures implementations follow
> >      > privacy-preserving best practices.
> >      > 4. **Easy Identification**: Chain analysis tools can use disposal
> >      > transactions to help trace the sources of dust attacks.
> >      >
> >      > ## Specification
> >      >
> >      > ### Transaction Format
> >      >
> >      > A compliant dust disposal transaction MUST satisfy all the following
> >      > requirements:
> >      >
> >      > #### Overall
> >      >
> >      > 1. The transaction MUST signal RBF replaceability (nSequence <
> >     0xFFFFFFFE).
> >      > 2. The ntimelock MUST be set to block height 0.
> >      > 3. The fee rate MUST be at least 0.1 sat/vB.
> >      >
> >      > #### Outputs
> >      >
> >      > 1. The transaction MUST have exactly one output.
> >      > 2. The single output MUST be an OP_RETURN.
> >      > 3. The OP_RETURN data MUST be either:
> >      > - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
> >      > - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
> >      > OP_PUSHBYTES_3 "ash").
> >      >
> >      > The "ash" marker MUST be used when padding is needed to meet the
> >     65 vB
> >      > minimum standard transaction size with a single witness input.
> >      > Implementations MUST prefer empty OP_RETURN data when the
> >     transaction
> >      > already meets minimum size requirements.
> >      >
> >      > #### Inputs
> >      >
> >      > 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
> >      > SIGHASH_ANYONECANPAY` (0x81).
> >      > 2. For Taproot (P2TR) inputs using key-path spending,
> >     implementations
> >      > MUST explicitly append the signature hash type byte `SIGHASH_ALL |
> >      > SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as
> >     the
> >      > default sighash for Taproot (SIGHASH_DEFAULT, which omits the
> >     byte) does
> >      > not include ANYONECANPAY.
> >      > 3. All inputs must be confirmed in the blockchain at least one
> >     block deep.
> >      >
> >      > #### Fees
> >      >
> >      > 1. The entire input value MUST go to fees (output value is zero for
> >      > OP_RETURN).
> >      > 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet
> >     minimum
> >      > relay requirements (Bitcoin Core 30.0+).
> >      > 3. The transaction fee rate MAY be higher based on the available
> >     dust
> >      > UTXO amounts and transaction size.
> >      >
> >      > ### Transaction Size
> >      >
> >      > 1. The transaction base size MUST be at least 65 bytes to meet
> >     Bitcoin
> >      > Core's minimum relay size standardness rule.
> >      > 2. If the transaction would otherwise be smaller than 65 bytes, the
> >      > OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68)
> >     MUST be
> >      > used to pad the transaction's size to 65 bytes.
> >      >
> >      > ### Address Consolidation Rules
> >      >
> >      > Implementations consolidating dust UTXOs for a single user (i.e.,
> >     not
> >      > third-party batching services):
> >      >
> >      > - MUST NOT spend dust UTXOs that were sent to different addresses
> >     in the
> >      > same transaction.
> >      > - MUST NOT broadcast dust disposal transactions at the same time for
> >      > dust sent to different addresses.
> >      > - SHOULD spend dust UTXOs for dust sent to the same address in one
> >      > transaction.
> >      >
> >      > ### Batching Dust Disposal Transactions via RBF
> >      >
> >      > Multiple unconfirmed dust disposal transactions created by unrelated
> >      > entities MAY be batched into a single replacement transaction using
> >      > Replace-By-Fee (RBF). This is enabled by the inputs
> >     SIGHASH_ANYONECANPAY
> >      > signature type.
> >      >
> >      > In addition to standard RBF rules, batch dust disposal
> >     transactions must
> >      > follow all transaction construction requirements for non-batched
> >     dust
> >      > disposal transactions.
> >      >
> >      > #### Third-Party Batching
> >      >
> >      > A third-party batching service for dust disposal transactions could
> >      > compromise their users' privacy by collecting user-related
> >     network and
> >      > timing metadata. The best practice for these services is:
> >      >
> >      > 1. The service MUST NOT collect pre-signed inputs directly from
> >     wallet
> >      > users.
> >      > 2. The service SHOULD collect pre-signed inputs from the public
> >     bitcoin
> >      > network mempool.
> >      > 3. The service MAY add their own UTXO inputs to improve the batch
> >      > transaction's fee rate as long as all the requirements of this
> >      > specification are still followed.
> >      >
> >      > This mempool-based approach preserves user privacy while enabling
> >      > efficient batching:
> >      >
> >      > 1. Users broadcast their individual dust disposal transactions to
> >     the
> >      > network.
> >      > 2. Batching services monitor the mempool for compliant dust disposal
> >      > transactions.
> >      > 3. Services can combine unconfirmed transactions via RBF without
> >     knowing
> >      > user identities.
> >      >
> >      > ### Dust Threshold
> >      >
> >      > Implementations SHOULD allow users to configure their own dust
> >     threshold
> >      > based on:
> >      >
> >      > 1. The current and anticipated fee rates.
> >      > 2. The dust input script type, different types have different
> >     spending
> >      > costs.
> >      > 3. The varying amounts that may be used by dust attack initiators.
> >      >
> >      > A UTXO is generally considered dust if its value is less than the
> >     cost
> >      > to spend it at a reasonable fee rate, but any small UTXO value
> >     could be
> >      > used in a dust attack.
> >      >
> >      > ### Security Considerations
> >      >
> >      > #### Transaction Signing
> >      >
> >      > 1. **Key Security**: Signing dust disposal transactions requires
> >     signing
> >      > with the user's wallet private keys. This could be a risk for cold
> >      > storage wallets where the key or keys needed to sign are not easily
> >      > accessible.
> >      > 2. **Transaction Correctness**: Transaction signers must carefully
> >      > review and verify that only dust UTXOs are spent and no other
> >     inputs are
> >      > signed.
> >      >
> >      > #### Privacy Preservation
> >      >
> >      > 1. **Network surveillance**: Internet service providers and other
> >      > internet monitors may be able to determine the nodes that initially
> >      > broadcast a dust disposal transaction. If available the
> >      > `sendrawtransaction -privatebroadcast` RPC feature should be used
> >      > (available in [Bitcoin Core 31.0](https://github.com/bitcoin-
> >     core/ <https://github.com/bitcoin-core/>
> >      > bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-
> >     changes)).
> >      > 2. **Timing Analysis**: Users should be aware that the timing of
> >     dust
> >      > disposal transactions is publicly observable. Dust disposal
> >     transactions
> >      > should not be broadcast at the same time or on a predictable
> >     schedule.
> >      > 3. **Amount Analysis**: The specific dust amounts selected for dust
> >      > disposal if outside the norm may be used to fingerprint the wallet
> >      > creating the disposal transactions.
> >      >
> >      > ## Rationale
> >      >
> >      > ### Why Empty or "ash" OP_RETURN Data?
> >      >
> >      > 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0)
> >     minimizes the
> >      > transaction size.
> >      > 2. **Standardization**: Consistent transaction construction
> >     eliminates
> >      > wallet fingerprinting.
> >      > 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
> >      > OP_PUSHBYTES_3 "ash") provides a standardized way to meet the
> >     minimum
> >      > transaction size; e.g., for a single P2TR dust input.
> >      > 4. **Semantic Meaning**: The word "ash" metaphorically represents
> >     the
> >      > result of "burning" the dust.
> >      >
> >      > ### Why Per-Address Transactions?
> >      >
> >      > Consolidating dust from multiple addresses for the same wallet
> >     creates
> >      > the same privacy harm that dust attacks attempt to achieve. By
> >     requiring
> >      > wallet software to create separate transactions per address (by
> >      > default), the protocol ensures dust disposal doesn't harm privacy.
> >      >
> >      > ### Why 65 Byte Minimum?
> >      >
> >      > Bitcoin Core enforces a minimum transaction base size of 65 bytes
> >     as a
> >      > policy rule to prevent certain attack vectors. Compliant
> >     transactions
> >      > must meet this threshold to be relayed by standard nodes.
> >      >
> >      > ### Why 0.1 sat/vB Minimum Fee Rate?
> >      >
> >      > [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/
> >     <https://bitcoincore.org/en/releases/30.0/>) reduced
> >      > the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows
> >     dust
> >      > UTXOs to be disposed of economically even when their value is very
> >      > small. Implementations targeting earlier node versions may need
> >     higher
> >      > minimum fee rates.
> >      >
> >      > ### Why SIGHASH_ALL|ANYONECANPAY?
> >      >
> >      > The ANYONECANPAY flag allows additional inputs to be added to the
> >     dust
> >      > disposal transaction after signing. This provides several benefits:
> >      >
> >      > 1. **Batching**: Unrelated dust disposal transactions can be
> >     found in
> >      > the mempool and batched together via RBF.
> >      > 2. **User privacy**: Transactions shared via the public mempool
> >     do not
> >      > reveal user identity metadata.
> >      > 3. **Fee Bumping**: Additional inputs can be added by unrelated
> >     third
> >      > parties to increase the fee rate.
> >      >
> >      > ### Why nLockTime block height 0
> >      >
> >      > 1. **User privacy**: Using the same nLockTime for all dust disposal
> >      > transactions obscures when it was created.
> >      > 2. **Fee sniping**: The value of disposal transactions should be
> >     small
> >      > enough that fee sniping is not a concern.
> >      >
> >      > ## Backwards Compatibility
> >      >
> >      > This BIP introduces no changes to the Bitcoin consensus rules or
> >     peer-
> >      > to-peer protocol. All transactions conforming to this
> >     specification are
> >      > valid under existing consensus rules and can be relayed by nodes
> >     supporting:
> >      >
> >      > - OP_RETURN outputs (Bitcoin Core 0.9.0+)
> >      > - SIGHASH_ANYONECANPAY (original Bitcoin feature)
> >      > - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
> >      > - Private transaction broadcast (Bitcoin Core 31.0+)
> >      >
> >      > Nodes running Bitcoin Core versions prior to 30.0 do not relay
> >      > transactions with fee rates below 1 sat/vB which could slow the
> >     relaying
> >      > of disposal transactions with lower fee rates.
> >      >
> >      > ## Reference Implementation
> >      >
> >      > A reference implementation is available at: https://github.com/
> >     <https://github.com/>
> >      > bubb1es71/ddust
> >      >
> >      > The implementation provides:
> >      > - Command-line tool for creating dust disposal transactions
> >      > - Automatic dust detection based on configurable thresholds
> >      > - Transaction batching via RBF
> >      > - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
> >      > - Integration with Bitcoin Core (version 30.0+) via RPC for
> >     syncing and
> >      > broadcasting transactions
> >      >
> >      > ## Test Cases
> >      >
> >      > The test cases below can be used to verify a wallet disposes of dust
> >      > UTXOs according to the specification in this BIP.
> >      >
> >      > ### List dust
> >      >
> >      > 1. Create payment addresses for multiple address types, send dust
> >     and
> >      > non-dust amounts to these addresses, verify that listing dust only
> >      > returns UTXOs at or below the configured dust threshold (e.g.
> >     1000 sats).
> >      > 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
> >      > verify listing dust only returns the confirmed dust UTXOs.
> >      >
> >      > ### Spending dust
> >      >
> >      > All valid dust disposal transactions should be verified to be
> >     accepted
> >      > into the bitcoind (Bitcoin Core 30.0+) mempool.
> >      >
> >      > 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
> >      > dust disposal transaction with a single "ash" OP_RETURN output.
> >      > 2. Spending multiple dust UTXOs always produces a single empty
> >     OP_RETURN
> >      > output regardless of script type.
> >      > 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a
> >     single
> >      > empty OP_RETURN output.
> >      > 4. All dust UTXOs sent to the same address are disposed of in the
> >     same
> >      > transaction.
> >      > 5. Dust disposal transactions only include confirmed dust UTXOs.
> >      >
> >      > #### Example dust disposal transaction sizes
> >      >
> >      > | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> >      >
> >     |-------------------|-------|------------|--------|-------------|-------|
> >      > | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
> >      > | Input (b) | 148 | 295 | 41 | 41 | 41 |
> >      > | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
> >      > | Base size (b) | 169 | 316 | 65 | 65 | 65 |
> >      > | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
> >      > | Size (b) | 169 | 316 | 173 | 320 | 132 |
> >      > | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
> >      > | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
> >      >
> >      > #### Example dust disposal transaction fee rates (sats/vb)
> >      >
> >      > | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> >      >
> >     |--------------|---------|------------|--------|-------------|-------|
> >      > | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
> >      > | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
> >      > | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
> >      > | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
> >      >
> >      > ### Batching dust disposal txs via RBF
> >      >
> >      > 1. Adding a Bech32m dust input to an unconfirmed disposal
> >     transaction
> >      > with a legacy dust input keeps the original single empty
> >     OP_RETURN output.
> >      > 2. Adding a Bech32m dust input to an unconfirmed disposal
> >     transaction
> >      > with a Bech32m dust input keeps the original single "ash"
> >     OP_RETURN output.
> >      > 3. Adding a new dust input to an unconfirmed disposal transaction
> >      > results in a new batch disposal transaction with a fee rate
> >     sufficient
> >      > for RBF.
> >      > 4. A new dust input that contributes an insufficient fee rate for
> >     RBF
> >      > with an existing unconfirmed disposal transaction is not batched
> >     with it.
> >      >
> >      > ## Related work
> >      >
> >      > * "dust-b-gone": https://github.com/petertodd/dust-b-gone
> >     <https://github.com/petertodd/dust-b-gone>
> >      > * "dusts": https://github.com/bubb1es71/dusts <https://
> >     github.com/bubb1es71/dusts>
> >      >
> >      > ## Changelog
> >      >
> >      > * **0.1.0** (2026-03-22):
> >      > * Initial draft of the BIP.
> >      >
> >      > ## Copyright
> >      >
> >      >
> >      > This document is licensed under the Creative Commons CC0 1.0
> >     Universal
> >      > license.
> >      >
> >      > --
> >      > You received this message because you are subscribed to the Google
> >      > Groups "Bitcoin Development Mailing List" group.
> >      > To unsubscribe from this group and stop receiving emails from it,
> >     send
> >      > an email to bitcoindev+unsubscribe@googlegroups.com
> >     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>
> >      > <mailto:bitcoindev+unsubscribe@googlegroups.com
> >     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>>.
> >      > To view this discussion visit https://groups.google.com/d/msgid/
> >     <https://groups.google.com/d/msgid/>
> >      > bitcoindev/3b3328b8-bba4-4858-
> >     b53a-0e9b631044ffn%40googlegroups.com <http://40googlegroups.com>
> >      > <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
> >     <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858->
> >      > b53a-0e9b631044ffn%40googlegroups.com?
> >     utm_medium=email&utm_source=footer <http://40googlegroups.com?
> >     utm_medium=email&utm_source=footer>>.
> >
> >     --
> >     You received this message because you are subscribed to the Google
> >     Groups "Bitcoin Development Mailing List" group.
> >     To unsubscribe from this group and stop receiving emails from it,
> >     send an email to bitcoindev+unsubscribe@googlegroups.com
> >     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>.
> >     To view this discussion visit https://groups.google.com/d/msgid/
> >     bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one
> >     <https://groups.google.com/d/msgid/
> >     bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one>.
> >
> 
> --
> You received this message because you are subscribed to a topic in the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this topic, visit https://groups.google.com/d/topic/bitcoindev/pr1z3_j8vTc/unsubscribe.
> To unsubscribe from this group and all its topics, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/283ccf28-c0ca-4ba5-9c5b-c4215a2fa0cf%40murch.one.
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/-s2dq7t8eZAKtQO-BvS0Ug3Zgo6D7evmyRgdeWBME_5wIOLasu47umjQikb2-dlWY7_ndn5mTIYZzsxDidMMbboKXF4ElpEHKxQdk60V9c0%3D%40proton.me.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-06 16:18  0% ` Murch
  2026-04-06 18:11  0%   ` STEVEN SLATER
@ 2026-04-10  2:14  1%   ` 'bubb1es' via Bitcoin Development Mailing List
  2026-04-14 22:39  0%     ` Murch
  1 sibling, 1 reply; 200+ results
From: 'bubb1es' via Bitcoin Development Mailing List @ 2026-04-10  2:14 UTC (permalink / raw)
  To: Murch; +Cc: bitcoindev

Hi Murch, since posting we've had some constructive discussion on the Delving thread with nothingmuch (https://delvingbitcoin.org/t/disposing-of-dust-attack-utxos/2215/21). He suggested using the "NONE|ANYONECANPAY" sighash flags instead of "ALL|ANYONECANPAY" as we originally proposed. 

This change would allow batched dust transactions to replace an unnecessary OP_RETURN "ash" output with an empty OP_RETURN. I don't see any downside to doing this so I've updated the proposed draft BIP.

I've also updated the draft BIP with your corrections regarding the versions of Bitcoin Core with the new feerate policy.

Thank you for your review and encouragement! We hope to submit it for review soon.

PS. I do not know who "<STEVEN SLATER> thugm501@gmail.com" is and he has not made any contributions to this project.

On Monday, April 6th, 2026 at 11:26 AM, Murch <murch@murch.one> wrote:

> Hi bubb1es,
> 
> I just skimmed your proposal and was considering the impact of the two
> possible output variants. As you mention in the description of the test
> cases, adding more inputs to a transaction would retain the output of
> the first transaction that appeared on the network. However, if two
> users independently submit transactions with incompatible outputs, third
> parties would not be able to aggregate those transactions into a single
> transaction.
> 
> I was wondering whether you considered generally requiring the
> ash-output to ensure that transactions can always be collapsed. This may
> especially be attractive if feerates will be more dynamic in the future
> and dust disposal transactions linger in the mempool for a while.
> 
> It probably comes down to how heavily this scheme will be used whether a
> general 3-byte overhead is justifiable to simplify aggregation. Either
> way, perhaps you could expound a bit on that trade-off in your rationale.
> 
> Also, minor correction: the feerate policy change was backported to
> Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
> releases of those major branches would also propagate sub-sat transactions.
> 
> Otherwise, this proposal looks reasonable to me. Looking forward to your
> submission.
> 
> Cheers,
> Murch
> 
> On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List wrote:
> >
> > Hi, based on a topic I started on Delving <https://delvingbitcoin.org/t/
> > disposing-of-dust-attack-utxos/2215> I'd like to gather feedback from
> > this community for a BIP to standardize disposing of dust UTXOs by
> > spending their values to the fee of single OP_RETURN output transactions.
> >
> > Thanks in advance for taking your time to consider this proposal.
> >
> > ```
> > BIP: ?
> > Layer: Applications
> > Title: Dust UTXO Disposal Protocol
> > Authors: bubb1es <bubb1es71@proton.me>
> > harris <imtux2@proton.me>
> > Status: Draft
> > Type: Specification
> > Assigned: ?
> > License: CC0-1.0
> > Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-of-dust-
> > attack-utxos/2215
> > Version: 0.1.0
> > ```
> >
> > ## Abstract
> >
> > This BIP specifies a standardized protocol for safely disposing of dust
> > UTXOs by spending them to an OP_RETURN output with the entire value
> > going to transaction fees. The protocol enables wallet software to
> > remove unwanted small-value UTXOs, particularly those received in dust
> > attacks, without creating new address linkages or degrading user
> > privacy. The specification includes transaction format requirements,
> > signature conventions enabling third-party batching, and validation
> > rules for compliant implementations.
> >
> > ## Motivation
> >
> > ### The Dust Attack Problem
> >
> > Dust attacks are a well-documented privacy threat where attackers send
> > small amounts of bitcoin to numerous addresses. When wallet software
> > later consolidates these dust UTXOs with non-dust UTXOs, the attacker
> > can analyze the blockchain to link previously unassociated addresses,
> > potentially deanonymizing users.
> >
> > The common solution to this issue is to "lock" dust UTXOs and never
> > spend them, but this creates its own problems:
> >
> > 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the
> > UTXO set that all full nodes must maintain.
> > 2. **Wallet Clutter**: Accumulated dust degrades wallet usability and
> > complicates coin selection.
> > 3. **Accidental Consolidation**: Users may inadvertently spend dust
> > during legitimate transactions, achieving the attacker's goal.
> > 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
> > prevent spending provides only temporary protection; wallet migrations,
> > restores from seed phrases, software bugs, or inheritance scenarios can
> > inadvertently unlock dust, exposing users to the original attack.
> >
> > ### Why OP_RETURN Disposal
> >
> > Spending dust to an OP_RETURN output with the entire value going to fees
> > provides several benefits:
> >
> > 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not
> > stored in the UTXO set.
> > 2. **No Address Linking**: Without a change output, there is no new
> > address to link.
> > 3. **Permanent Removal**: The dust UTXOs are removed from the user's
> > wallet entirely.
> > 4. **Miner Compensation**: OP_RETURN outputs are small, providing higher
> > transaction fee rates.
> > 5. **No Cost to Victims**: Dust attack UTXO values are used to pay for
> > their own disposal.
> >
> > ### Why Standardization
> >
> > A standardized protocol enables:
> >
> > 1. **Wallet Anonymity**: Transactions with a standard format cannot be
> > used to fingerprint the wallet software a user is running.
> > 2. **Third-Party Batching**: Multiple dust disposals can be combined
> > into single transactions, reducing overall block space consumption.
> > 3. **Best Practice Codification**: Ensures implementations follow
> > privacy-preserving best practices.
> > 4. **Easy Identification**: Chain analysis tools can use disposal
> > transactions to help trace the sources of dust attacks.
> >
> > ## Specification
> >
> > ### Transaction Format
> >
> > A compliant dust disposal transaction MUST satisfy all the following
> > requirements:
> >
> > #### Overall
> >
> > 1. The transaction MUST signal RBF replaceability (nSequence < 0xFFFFFFFE).
> > 2. The ntimelock MUST be set to block height 0.
> > 3. The fee rate MUST be at least 0.1 sat/vB.
> >
> > #### Outputs
> >
> > 1. The transaction MUST have exactly one output.
> > 2. The single output MUST be an OP_RETURN.
> > 3. The OP_RETURN data MUST be either:
> > - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
> > - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
> > OP_PUSHBYTES_3 "ash").
> >
> > The "ash" marker MUST be used when padding is needed to meet the 65 vB
> > minimum standard transaction size with a single witness input.
> > Implementations MUST prefer empty OP_RETURN data when the transaction
> > already meets minimum size requirements.
> >
> > #### Inputs
> >
> > 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
> > SIGHASH_ANYONECANPAY` (0x81).
> > 2. For Taproot (P2TR) inputs using key-path spending, implementations
> > MUST explicitly append the signature hash type byte `SIGHASH_ALL |
> > SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the
> > default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does
> > not include ANYONECANPAY.
> > 3. All inputs must be confirmed in the blockchain at least one block deep.
> >
> > #### Fees
> >
> > 1. The entire input value MUST go to fees (output value is zero for
> > OP_RETURN).
> > 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum
> > relay requirements (Bitcoin Core 30.0+).
> > 3. The transaction fee rate MAY be higher based on the available dust
> > UTXO amounts and transaction size.
> >
> > ### Transaction Size
> >
> > 1. The transaction base size MUST be at least 65 bytes to meet Bitcoin
> > Core's minimum relay size standardness rule.
> > 2. If the transaction would otherwise be smaller than 65 bytes, the
> > OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be
> > used to pad the transaction's size to 65 bytes.
> >
> > ### Address Consolidation Rules
> >
> > Implementations consolidating dust UTXOs for a single user (i.e., not
> > third-party batching services):
> >
> > - MUST NOT spend dust UTXOs that were sent to different addresses in the
> > same transaction.
> > - MUST NOT broadcast dust disposal transactions at the same time for
> > dust sent to different addresses.
> > - SHOULD spend dust UTXOs for dust sent to the same address in one
> > transaction.
> >
> > ### Batching Dust Disposal Transactions via RBF
> >
> > Multiple unconfirmed dust disposal transactions created by unrelated
> > entities MAY be batched into a single replacement transaction using
> > Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY
> > signature type.
> >
> > In addition to standard RBF rules, batch dust disposal transactions must
> > follow all transaction construction requirements for non-batched dust
> > disposal transactions.
> >
> > #### Third-Party Batching
> >
> > A third-party batching service for dust disposal transactions could
> > compromise their users' privacy by collecting user-related network and
> > timing metadata. The best practice for these services is:
> >
> > 1. The service MUST NOT collect pre-signed inputs directly from wallet
> > users.
> > 2. The service SHOULD collect pre-signed inputs from the public bitcoin
> > network mempool.
> > 3. The service MAY add their own UTXO inputs to improve the batch
> > transaction's fee rate as long as all the requirements of this
> > specification are still followed.
> >
> > This mempool-based approach preserves user privacy while enabling
> > efficient batching:
> >
> > 1. Users broadcast their individual dust disposal transactions to the
> > network.
> > 2. Batching services monitor the mempool for compliant dust disposal
> > transactions.
> > 3. Services can combine unconfirmed transactions via RBF without knowing
> > user identities.
> >
> > ### Dust Threshold
> >
> > Implementations SHOULD allow users to configure their own dust threshold
> > based on:
> >
> > 1. The current and anticipated fee rates.
> > 2. The dust input script type, different types have different spending
> > costs.
> > 3. The varying amounts that may be used by dust attack initiators.
> >
> > A UTXO is generally considered dust if its value is less than the cost
> > to spend it at a reasonable fee rate, but any small UTXO value could be
> > used in a dust attack.
> >
> > ### Security Considerations
> >
> > #### Transaction Signing
> >
> > 1. **Key Security**: Signing dust disposal transactions requires signing
> > with the user's wallet private keys. This could be a risk for cold
> > storage wallets where the key or keys needed to sign are not easily
> > accessible.
> > 2. **Transaction Correctness**: Transaction signers must carefully
> > review and verify that only dust UTXOs are spent and no other inputs are
> > signed.
> >
> > #### Privacy Preservation
> >
> > 1. **Network surveillance**: Internet service providers and other
> > internet monitors may be able to determine the nodes that initially
> > broadcast a dust disposal transaction. If available the
> > `sendrawtransaction -privatebroadcast` RPC feature should be used
> > (available in [Bitcoin Core 31.0](https://github.com/bitcoin-core/
> > bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
> > 2. **Timing Analysis**: Users should be aware that the timing of dust
> > disposal transactions is publicly observable. Dust disposal transactions
> > should not be broadcast at the same time or on a predictable schedule.
> > 3. **Amount Analysis**: The specific dust amounts selected for dust
> > disposal if outside the norm may be used to fingerprint the wallet
> > creating the disposal transactions.
> >
> > ## Rationale
> >
> > ### Why Empty or "ash" OP_RETURN Data?
> >
> > 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the
> > transaction size.
> > 2. **Standardization**: Consistent transaction construction eliminates
> > wallet fingerprinting.
> > 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
> > OP_PUSHBYTES_3 "ash") provides a standardized way to meet the minimum
> > transaction size; e.g., for a single P2TR dust input.
> > 4. **Semantic Meaning**: The word "ash" metaphorically represents the
> > result of "burning" the dust.
> >
> > ### Why Per-Address Transactions?
> >
> > Consolidating dust from multiple addresses for the same wallet creates
> > the same privacy harm that dust attacks attempt to achieve. By requiring
> > wallet software to create separate transactions per address (by
> > default), the protocol ensures dust disposal doesn't harm privacy.
> >
> > ### Why 65 Byte Minimum?
> >
> > Bitcoin Core enforces a minimum transaction base size of 65 bytes as a
> > policy rule to prevent certain attack vectors. Compliant transactions
> > must meet this threshold to be relayed by standard nodes.
> >
> > ### Why 0.1 sat/vB Minimum Fee Rate?
> >
> > [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced
> > the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust
> > UTXOs to be disposed of economically even when their value is very
> > small. Implementations targeting earlier node versions may need higher
> > minimum fee rates.
> >
> > ### Why SIGHASH_ALL|ANYONECANPAY?
> >
> > The ANYONECANPAY flag allows additional inputs to be added to the dust
> > disposal transaction after signing. This provides several benefits:
> >
> > 1. **Batching**: Unrelated dust disposal transactions can be found in
> > the mempool and batched together via RBF.
> > 2. **User privacy**: Transactions shared via the public mempool do not
> > reveal user identity metadata.
> > 3. **Fee Bumping**: Additional inputs can be added by unrelated third
> > parties to increase the fee rate.
> >
> > ### Why nLockTime block height 0
> >
> > 1. **User privacy**: Using the same nLockTime for all dust disposal
> > transactions obscures when it was created.
> > 2. **Fee sniping**: The value of disposal transactions should be small
> > enough that fee sniping is not a concern.
> >
> > ## Backwards Compatibility
> >
> > This BIP introduces no changes to the Bitcoin consensus rules or peer-
> > to-peer protocol. All transactions conforming to this specification are
> > valid under existing consensus rules and can be relayed by nodes supporting:
> >
> > - OP_RETURN outputs (Bitcoin Core 0.9.0+)
> > - SIGHASH_ANYONECANPAY (original Bitcoin feature)
> > - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
> > - Private transaction broadcast (Bitcoin Core 31.0+)
> >
> > Nodes running Bitcoin Core versions prior to 30.0 do not relay
> > transactions with fee rates below 1 sat/vB which could slow the relaying
> > of disposal transactions with lower fee rates.
> >
> > ## Reference Implementation
> >
> > A reference implementation is available at: https://github.com/
> > bubb1es71/ddust
> >
> > The implementation provides:
> > - Command-line tool for creating dust disposal transactions
> > - Automatic dust detection based on configurable thresholds
> > - Transaction batching via RBF
> > - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
> > - Integration with Bitcoin Core (version 30.0+) via RPC for syncing and
> > broadcasting transactions
> >
> > ## Test Cases
> >
> > The test cases below can be used to verify a wallet disposes of dust
> > UTXOs according to the specification in this BIP.
> >
> > ### List dust
> >
> > 1. Create payment addresses for multiple address types, send dust and
> > non-dust amounts to these addresses, verify that listing dust only
> > returns UTXOs at or below the configured dust threshold (e.g. 1000 sats).
> > 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
> > verify listing dust only returns the confirmed dust UTXOs.
> >
> > ### Spending dust
> >
> > All valid dust disposal transactions should be verified to be accepted
> > into the bitcoind (Bitcoin Core 30.0+) mempool.
> >
> > 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
> > dust disposal transaction with a single "ash" OP_RETURN output.
> > 2. Spending multiple dust UTXOs always produces a single empty OP_RETURN
> > output regardless of script type.
> > 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single
> > empty OP_RETURN output.
> > 4. All dust UTXOs sent to the same address are disposed of in the same
> > transaction.
> > 5. Dust disposal transactions only include confirmed dust UTXOs.
> >
> > #### Example dust disposal transaction sizes
> >
> > | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> > |-------------------|-------|------------|--------|-------------|-------|
> > | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
> > | Input (b) | 148 | 295 | 41 | 41 | 41 |
> > | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
> > | Base size (b) | 169 | 316 | 65 | 65 | 65 |
> > | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
> > | Size (b) | 169 | 316 | 173 | 320 | 132 |
> > | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
> > | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
> >
> > #### Example dust disposal transaction fee rates (sats/vb)
> >
> > | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> > |--------------|---------|------------|--------|-------------|-------|
> > | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
> > | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
> > | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
> > | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
> >
> > ### Batching dust disposal txs via RBF
> >
> > 1. Adding a Bech32m dust input to an unconfirmed disposal transaction
> > with a legacy dust input keeps the original single empty OP_RETURN output.
> > 2. Adding a Bech32m dust input to an unconfirmed disposal transaction
> > with a Bech32m dust input keeps the original single "ash" OP_RETURN output.
> > 3. Adding a new dust input to an unconfirmed disposal transaction
> > results in a new batch disposal transaction with a fee rate sufficient
> > for RBF.
> > 4. A new dust input that contributes an insufficient fee rate for RBF
> > with an existing unconfirmed disposal transaction is not batched with it.
> >
> > ## Related work
> >
> > * "dust-b-gone": https://github.com/petertodd/dust-b-gone
> > * "dusts": https://github.com/bubb1es71/dusts
> >
> > ## Changelog
> >
> > * **0.1.0** (2026-03-22):
> > * Initial draft of the BIP.
> >
> > ## Copyright
> >
> >
> > This document is licensed under the Creative Commons CC0 1.0 Universal
> > license.
> >
> > --
> > You received this message because you are subscribed to the Google
> > Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> > an email to bitcoindev+unsubscribe@googlegroups.com
> > <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> > To view this discussion visit https://groups.google.com/d/msgid/
> > bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com
> > <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
> > b53a-0e9b631044ffn%40googlegroups.com?utm_medium=email&utm_source=footer>.
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one.
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/s9lD_CC0yTtNN2igb1JAiRCacgPeBB8Za6sC7TE0wljSg2rfuWN0ByWciCdhzKxPoa0FfrYulGBkKCFlInWg8iJRED5fnItOShtOMuszSN4%3D%40proton.me.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Draft] 24 bits for nVersion nonce space instead of 16
  2026-04-08 16:16  1%   ` Sjors Provoost
@ 2026-04-08 20:11  0%     ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2026-04-08 20:11 UTC (permalink / raw)
  To: Sjors Provoost
  Cc: Bitcoin Development Mailing List, Matt Corallo, Anthony Towns

Hi Sjors,

I would rather not make activation signals dependent on block content. 5 bits is less than ideal but i also don't expect much friction. We've never had 5 deployment windows overlapping, and if anything i'd expect less frequent deployments moving forward.

Antoine


On Wednesday, April 8th, 2026 at 12:57 PM, Sjors Provoost <sjors@sprovoost.nl> wrote:

> This could lead to friction around who gets to allocate these scarce 5 bits, as well as
> potential confusion when people and client software interpret contentious bits differently.
> 
> What if we reserve bit 0 to indicate that the actual signal can be found in the coinbase
> transaction? The signal itself can be as simple as OP_RETURN BIP-XXXX.
> 
> The chosen string doesn't matter. We can keep referring to "deployment bits", where
> bits > 28 represent the new method. That gives us practically unlimited bits and no
> need to ever repurpose them.
> 
> A quick vibe coding session suggests this is straightforward to implement. [0]
> 
> The two implementation caveats:
> - BIP22 will need an extension to feed the new coinbase OP_RETURN fields to
>   mining pool software (IPC clients like Stratum v2 work out of the box)
> - headers are no longer sufficient to track signalling [1]
> 
> - Sjors
> 
> [0] https://github.com/Sjors/bitcoin/commits/2026/05/version/
> [1] v31.0 will make the coinbase is easily accessible via RPC: https://github.com/bitcoin/bitcoin/pull/34512
> 
> 
> > Op 28 mrt 2026, om 12:58 heeft Anthony Towns <aj@erisian.com.au> het volgende geschreven:
> >
> > On Thu, Feb 26, 2026 at 05:12:03PM -0500, Matt Corallo wrote:
> >> ==Specification==
> >> 24 bits from the block header nVersion field, starting from 5 and ending at
> >> 28 inclusive (0x1fffffe0), are reserved for nonce use and removed from BIP8
> >> and BIP9 specifications. A mask of 0xe000001f should be applied to nVersion
> >> bits so bits 5-28 inclusive will be ignored for soft-fork signalling and
> >> unknown soft-fork warnings.
> >
> > This conflicts with the proposed use of bit 5 for signalling CTV activation
> > over the next twelve months mentioned at:
> >
> > * https://groups.google.com/g/bitcoindev/c/HC2bn4QOR-M/m/TF8qJidzAAAJ
> > * https://delvingbitcoin.org/t/bip-119-ctv-activation-client/2242
> > * https://github.com/ctv-activation/activation-client/blob/06ddbdf01bc8ce181b01c7497010bff74c2b79c6/src/kernel/chainparams.cpp#L121-L127
> >
> > I don't think there's any meaningful support for that activation proposal,
> > but thought it was worth pointing out for completeness.
> >
> > BIP110 is currently signalling via bit 4 until block 963648; LNHANCE
> > is possibly signalling on bit 3 between May last year and Jan 2028.
> >
> > Previously, CSV signalled on bit 0, segwit on bit 1, segwit reduced
> > threshold (bip 91) on bit 4, and taproot on bit 2.
> >
> > Cheers,
> > aj
> >
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/D52CEDCC-C7EF-429E-802F-F28DC9241FF0%40sprovoost.nl.
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/D15PTH54rGnJKjSIXFHJnMHU9opDYr6bUafBENLHSDNVIj-uZwLmDY8oTSWNLp-NZSeiB9XruEs_6x1mb38TR8xyR78xvsYcnWYz1T3OrWk%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] 24 bits for nVersion nonce space instead of 16
  @ 2026-04-08 16:16  1%   ` Sjors Provoost
  2026-04-08 20:11  0%     ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Sjors Provoost @ 2026-04-08 16:16 UTC (permalink / raw)
  To: Bitcoin Development Mailing List; +Cc: Matt Corallo, Anthony Towns

This could lead to friction around who gets to allocate these scarce 5 bits, as well as
potential confusion when people and client software interpret contentious bits differently.

What if we reserve bit 0 to indicate that the actual signal can be found in the coinbase
transaction? The signal itself can be as simple as OP_RETURN BIP-XXXX.

The chosen string doesn't matter. We can keep referring to "deployment bits", where
bits > 28 represent the new method. That gives us practically unlimited bits and no
need to ever repurpose them.

A quick vibe coding session suggests this is straightforward to implement. [0]

The two implementation caveats:
- BIP22 will need an extension to feed the new coinbase OP_RETURN fields to
  mining pool software (IPC clients like Stratum v2 work out of the box)  
- headers are no longer sufficient to track signalling [1]

- Sjors

[0] https://github.com/Sjors/bitcoin/commits/2026/05/version/
[1] v31.0 will make the coinbase is easily accessible via RPC: https://github.com/bitcoin/bitcoin/pull/34512


> Op 28 mrt 2026, om 12:58 heeft Anthony Towns <aj@erisian.com.au> het volgende geschreven:
> 
> On Thu, Feb 26, 2026 at 05:12:03PM -0500, Matt Corallo wrote:
>> ==Specification==
>> 24 bits from the block header nVersion field, starting from 5 and ending at
>> 28 inclusive (0x1fffffe0), are reserved for nonce use and removed from BIP8
>> and BIP9 specifications. A mask of 0xe000001f should be applied to nVersion
>> bits so bits 5-28 inclusive will be ignored for soft-fork signalling and
>> unknown soft-fork warnings.
> 
> This conflicts with the proposed use of bit 5 for signalling CTV activation
> over the next twelve months mentioned at:
> 
> * https://groups.google.com/g/bitcoindev/c/HC2bn4QOR-M/m/TF8qJidzAAAJ
> * https://delvingbitcoin.org/t/bip-119-ctv-activation-client/2242
> * https://github.com/ctv-activation/activation-client/blob/06ddbdf01bc8ce181b01c7497010bff74c2b79c6/src/kernel/chainparams.cpp#L121-L127
> 
> I don't think there's any meaningful support for that activation proposal,
> but thought it was worth pointing out for completeness.
> 
> BIP110 is currently signalling via bit 4 until block 963648; LNHANCE
> is possibly signalling on bit 3 between May last year and Jan 2028.
> 
> Previously, CSV signalled on bit 0, segwit on bit 1, segwit reduced
> threshold (bip 91) on bit 4, and taproot on bit 2.
> 
> Cheers,
> aj
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/D52CEDCC-C7EF-429E-802F-F28DC9241FF0%40sprovoost.nl.


^ permalink raw reply	[relevance 1%]

* [bitcoindev] New bitcoin backbone code release: addr / tx relay mngt + multiproces support layout
@ 2026-04-07  3:13  1% Antoine Riard
  0 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-04-07  3:13 UTC (permalink / raw)
  To: Bitcoin Development Mailing List; +Cc: btc

[-- Attachment #1: Type: text/plain, Size: 1865 bytes --]

Hello devs,

Shared new code for bitcoin backbone, with a lot of new stuff at the tx and
addr management level. The most notable change has been to start to isolate
all the interfaces code in its own daemons, and start the groundwork to
re-implement the multiprocess interface in bitcoin backbone. That way in the
future being able to have the bitcoin-wallet calling the code, the
bitcoin-gui
or any future application that likes the interface [0]. It's not for nothing
that *NIX has the POSIX which lets you write a shell (which is a not trivial
piece of software...) and lets you run it everywhere on all *NIX.

There is also a dedicated mailing list on framagroupes.org, for the ones who
are more interested to follow updates (
https://framagroupes.org/sympa/info/bitcoin-backbone-dev).
This also avoid me to have to spam the mailing list [0] with each update of
the project, and only keep it to share back what is interesting. Next
updates
are going to be focused on pouring more love on the test framework. I know,
I know, so far testing has been only manual.

Do the work and keep building.

Cheers,
Antoine
OTS hash: 208bd991dc7a04b9ccb7023ae2a4de12c76484361c766ff3986cc107eecb5cf9

[0] See this old gist on some ways to improve perfs for wallet in
bitcoind's thanks
to bitcoind: https://gist.github.com/ariard/89f9bcc3a7ab9576fc6d15d251032cfa

[1] Better to be careful in this ecosystem with spam. No one expects the
Spanish
inquisition but you never know...

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BGMFjL5on%3D2pFfOLJ4neJHgXmHv%2Bg1iQ-SRnRNuB1y%2BKg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 2447 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-06 18:11  0%   ` STEVEN SLATER
@ 2026-04-06 20:45  0%     ` Murch
  2026-04-10  2:23  0%       ` 'bubb1es' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Murch @ 2026-04-06 20:45 UTC (permalink / raw)
  To: STEVEN SLATER; +Cc: bitcoindev

Hi Steven,

Thanks for the quick reply, looking forward to reading the updated document!

I just realized that I forgot another point in my prior email. While 
there are some other node implementations that still implement BIP 125: 
Opt-in Full Replace-by-Fee Signaling, Bitcoin Core 28.0 and later will 
accept replacements even if the original transaction did not signal 
replaceability¹, so you could consider dropping the replaceability 
signal requirement. While the dust disposal transactions will be quite 
distinguishable either way and it’s unlikely to be a big deal if they 
were to continue signaling in the future, it may be more forward-looking 
not to signal.

¹ E.g., see the linked news items regarding `mempoolfullrbf` on
https://bitcoinops.org/en/topics/replace-by-fee/ for details

Cheers,
Murch

On 2026-04-06 11:11, STEVEN SLATER wrote:
> Response to Feedback on Transaction Aggregation Proposal
> 
> Hi Murch,
> 
> Thank you for taking the time to review my proposal and for raising 
> these thoughtful points.
> 
> On the question of requiring an ash-output: I did consider the idea of 
> mandating it universally. The main trade-off is between simplicity in 
> aggregation and the overhead cost. A fixed 3‑byte addition per 
> transaction is relatively small, but when scaled across high‑volume 
> usage it does introduce measurable bloat. My current rationale was to 
> avoid imposing that cost on transactions that are unlikely to benefit 
> from aggregation. That said, I agree that in scenarios where feerates 
> fluctuate significantly and dust transactions linger in the mempool, a 
> standardized ash-output could make collapsing transactions more 
> predictable and efficient. I’ll expand the rationale to weigh the 
> benefits of guaranteed collapsibility against the marginal overhead, and 
> outline conditions where the overhead is justified.
> 
> Regarding incompatible outputs: you’re right that independent 
> submissions with conflicting outputs cannot be aggregated. My intent was 
> to highlight that aggregation works best when inputs are aligned, and 
> that ash-output could serve as a safeguard to preserve compatibility. 
> I’ll clarify this point further in the next revision.
> 
> Thank you also for the correction on feerate policy backports to Bitcoin 
> Core 29.1 and 28.3. I’ll update the proposal to reflect that users on 
> those branches will indeed propagate sub‑sat transactions.
> 
> I appreciate your constructive feedbackit helps sharpen the rationale 
> and ensures the proposal is practical for broader adoption. I’ll 
> incorporate these clarifications before submission.
> 
> Best regards,
> Steven
> 
> On Mon, 6 Apr 2026, 5:26 pm Murch, <murch@murch.one> wrote:
> 
>     Hi bubb1es,
> 
>     I just skimmed your proposal and was considering the impact of the two
>     possible output variants. As you mention in the description of the test
>     cases, adding more inputs to a transaction would retain the output of
>     the first transaction that appeared on the network. However, if two
>     users independently submit transactions with incompatible outputs,
>     third
>     parties would not be able to aggregate those transactions into a single
>     transaction.
> 
>     I was wondering whether you considered generally requiring the
>     ash-output to ensure that transactions can always be collapsed. This
>     may
>     especially be attractive if feerates will be more dynamic in the future
>     and dust disposal transactions linger in the mempool for a while.
> 
>     It probably comes down to how heavily this scheme will be used
>     whether a
>     general 3-byte overhead is justifiable to simplify aggregation. Either
>     way, perhaps you could expound a bit on that trade-off in your
>     rationale.
> 
>     Also, minor correction: the feerate policy change was backported to
>     Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
>     releases of those major branches would also propagate sub-sat
>     transactions.
> 
>     Otherwise, this proposal looks reasonable to me. Looking forward to
>     your
>     submission.
> 
>     Cheers,
>     Murch
> 
>     On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List
>     wrote:
>      >
>      > Hi, based on a topic I started on Delving <https://
>     delvingbitcoin.org/t/ <https://delvingbitcoin.org/t/>
>      > disposing-of-dust-attack-utxos/2215> I'd like to gather feedback
>     from
>      > this community for a BIP to standardize disposing of dust UTXOs by
>      > spending their values to the fee of single OP_RETURN output
>     transactions.
>      >
>      > Thanks in advance for taking your time to consider this proposal.
>      >
>      > ```
>      > BIP: ?
>      > Layer: Applications
>      > Title: Dust UTXO Disposal Protocol
>      > Authors: bubb1es <bubb1es71@proton.me <mailto:bubb1es71@proton.me>>
>      > harris <imtux2@proton.me <mailto:imtux2@proton.me>>
>      > Status: Draft
>      > Type: Specification
>      > Assigned: ?
>      > License: CC0-1.0
>      > Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-
>     of-dust- <https://delvingbitcoin.org/t/disposing-of-dust->
>      > attack-utxos/2215
>      > Version: 0.1.0
>      > ```
>      >
>      > ## Abstract
>      >
>      > This BIP specifies a standardized protocol for safely disposing
>     of dust
>      > UTXOs by spending them to an OP_RETURN output with the entire value
>      > going to transaction fees. The protocol enables wallet software to
>      > remove unwanted small-value UTXOs, particularly those received in
>     dust
>      > attacks, without creating new address linkages or degrading user
>      > privacy. The specification includes transaction format requirements,
>      > signature conventions enabling third-party batching, and validation
>      > rules for compliant implementations.
>      >
>      > ## Motivation
>      >
>      > ### The Dust Attack Problem
>      >
>      > Dust attacks are a well-documented privacy threat where attackers
>     send
>      > small amounts of bitcoin to numerous addresses. When wallet software
>      > later consolidates these dust UTXOs with non-dust UTXOs, the
>     attacker
>      > can analyze the blockchain to link previously unassociated
>     addresses,
>      > potentially deanonymizing users.
>      >
>      > The common solution to this issue is to "lock" dust UTXOs and never
>      > spend them, but this creates its own problems:
>      >
>      > 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in
>     the
>      > UTXO set that all full nodes must maintain.
>      > 2. **Wallet Clutter**: Accumulated dust degrades wallet usability
>     and
>      > complicates coin selection.
>      > 3. **Accidental Consolidation**: Users may inadvertently spend dust
>      > during legitimate transactions, achieving the attacker's goal.
>      > 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
>      > prevent spending provides only temporary protection; wallet
>     migrations,
>      > restores from seed phrases, software bugs, or inheritance
>     scenarios can
>      > inadvertently unlock dust, exposing users to the original attack.
>      >
>      > ### Why OP_RETURN Disposal
>      >
>      > Spending dust to an OP_RETURN output with the entire value going
>     to fees
>      > provides several benefits:
>      >
>      > 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable
>     and not
>      > stored in the UTXO set.
>      > 2. **No Address Linking**: Without a change output, there is no new
>      > address to link.
>      > 3. **Permanent Removal**: The dust UTXOs are removed from the user's
>      > wallet entirely.
>      > 4. **Miner Compensation**: OP_RETURN outputs are small, providing
>     higher
>      > transaction fee rates.
>      > 5. **No Cost to Victims**: Dust attack UTXO values are used to
>     pay for
>      > their own disposal.
>      >
>      > ### Why Standardization
>      >
>      > A standardized protocol enables:
>      >
>      > 1. **Wallet Anonymity**: Transactions with a standard format
>     cannot be
>      > used to fingerprint the wallet software a user is running.
>      > 2. **Third-Party Batching**: Multiple dust disposals can be combined
>      > into single transactions, reducing overall block space consumption.
>      > 3. **Best Practice Codification**: Ensures implementations follow
>      > privacy-preserving best practices.
>      > 4. **Easy Identification**: Chain analysis tools can use disposal
>      > transactions to help trace the sources of dust attacks.
>      >
>      > ## Specification
>      >
>      > ### Transaction Format
>      >
>      > A compliant dust disposal transaction MUST satisfy all the following
>      > requirements:
>      >
>      > #### Overall
>      >
>      > 1. The transaction MUST signal RBF replaceability (nSequence <
>     0xFFFFFFFE).
>      > 2. The ntimelock MUST be set to block height 0.
>      > 3. The fee rate MUST be at least 0.1 sat/vB.
>      >
>      > #### Outputs
>      >
>      > 1. The transaction MUST have exactly one output.
>      > 2. The single output MUST be an OP_RETURN.
>      > 3. The OP_RETURN data MUST be either:
>      > - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
>      > - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
>      > OP_PUSHBYTES_3 "ash").
>      >
>      > The "ash" marker MUST be used when padding is needed to meet the
>     65 vB
>      > minimum standard transaction size with a single witness input.
>      > Implementations MUST prefer empty OP_RETURN data when the
>     transaction
>      > already meets minimum size requirements.
>      >
>      > #### Inputs
>      >
>      > 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
>      > SIGHASH_ANYONECANPAY` (0x81).
>      > 2. For Taproot (P2TR) inputs using key-path spending,
>     implementations
>      > MUST explicitly append the signature hash type byte `SIGHASH_ALL |
>      > SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as
>     the
>      > default sighash for Taproot (SIGHASH_DEFAULT, which omits the
>     byte) does
>      > not include ANYONECANPAY.
>      > 3. All inputs must be confirmed in the blockchain at least one
>     block deep.
>      >
>      > #### Fees
>      >
>      > 1. The entire input value MUST go to fees (output value is zero for
>      > OP_RETURN).
>      > 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet
>     minimum
>      > relay requirements (Bitcoin Core 30.0+).
>      > 3. The transaction fee rate MAY be higher based on the available
>     dust
>      > UTXO amounts and transaction size.
>      >
>      > ### Transaction Size
>      >
>      > 1. The transaction base size MUST be at least 65 bytes to meet
>     Bitcoin
>      > Core's minimum relay size standardness rule.
>      > 2. If the transaction would otherwise be smaller than 65 bytes, the
>      > OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68)
>     MUST be
>      > used to pad the transaction's size to 65 bytes.
>      >
>      > ### Address Consolidation Rules
>      >
>      > Implementations consolidating dust UTXOs for a single user (i.e.,
>     not
>      > third-party batching services):
>      >
>      > - MUST NOT spend dust UTXOs that were sent to different addresses
>     in the
>      > same transaction.
>      > - MUST NOT broadcast dust disposal transactions at the same time for
>      > dust sent to different addresses.
>      > - SHOULD spend dust UTXOs for dust sent to the same address in one
>      > transaction.
>      >
>      > ### Batching Dust Disposal Transactions via RBF
>      >
>      > Multiple unconfirmed dust disposal transactions created by unrelated
>      > entities MAY be batched into a single replacement transaction using
>      > Replace-By-Fee (RBF). This is enabled by the inputs
>     SIGHASH_ANYONECANPAY
>      > signature type.
>      >
>      > In addition to standard RBF rules, batch dust disposal
>     transactions must
>      > follow all transaction construction requirements for non-batched
>     dust
>      > disposal transactions.
>      >
>      > #### Third-Party Batching
>      >
>      > A third-party batching service for dust disposal transactions could
>      > compromise their users' privacy by collecting user-related
>     network and
>      > timing metadata. The best practice for these services is:
>      >
>      > 1. The service MUST NOT collect pre-signed inputs directly from
>     wallet
>      > users.
>      > 2. The service SHOULD collect pre-signed inputs from the public
>     bitcoin
>      > network mempool.
>      > 3. The service MAY add their own UTXO inputs to improve the batch
>      > transaction's fee rate as long as all the requirements of this
>      > specification are still followed.
>      >
>      > This mempool-based approach preserves user privacy while enabling
>      > efficient batching:
>      >
>      > 1. Users broadcast their individual dust disposal transactions to
>     the
>      > network.
>      > 2. Batching services monitor the mempool for compliant dust disposal
>      > transactions.
>      > 3. Services can combine unconfirmed transactions via RBF without
>     knowing
>      > user identities.
>      >
>      > ### Dust Threshold
>      >
>      > Implementations SHOULD allow users to configure their own dust
>     threshold
>      > based on:
>      >
>      > 1. The current and anticipated fee rates.
>      > 2. The dust input script type, different types have different
>     spending
>      > costs.
>      > 3. The varying amounts that may be used by dust attack initiators.
>      >
>      > A UTXO is generally considered dust if its value is less than the
>     cost
>      > to spend it at a reasonable fee rate, but any small UTXO value
>     could be
>      > used in a dust attack.
>      >
>      > ### Security Considerations
>      >
>      > #### Transaction Signing
>      >
>      > 1. **Key Security**: Signing dust disposal transactions requires
>     signing
>      > with the user's wallet private keys. This could be a risk for cold
>      > storage wallets where the key or keys needed to sign are not easily
>      > accessible.
>      > 2. **Transaction Correctness**: Transaction signers must carefully
>      > review and verify that only dust UTXOs are spent and no other
>     inputs are
>      > signed.
>      >
>      > #### Privacy Preservation
>      >
>      > 1. **Network surveillance**: Internet service providers and other
>      > internet monitors may be able to determine the nodes that initially
>      > broadcast a dust disposal transaction. If available the
>      > `sendrawtransaction -privatebroadcast` RPC feature should be used
>      > (available in [Bitcoin Core 31.0](https://github.com/bitcoin-
>     core/ <https://github.com/bitcoin-core/>
>      > bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-
>     changes)).
>      > 2. **Timing Analysis**: Users should be aware that the timing of
>     dust
>      > disposal transactions is publicly observable. Dust disposal
>     transactions
>      > should not be broadcast at the same time or on a predictable
>     schedule.
>      > 3. **Amount Analysis**: The specific dust amounts selected for dust
>      > disposal if outside the norm may be used to fingerprint the wallet
>      > creating the disposal transactions.
>      >
>      > ## Rationale
>      >
>      > ### Why Empty or "ash" OP_RETURN Data?
>      >
>      > 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0)
>     minimizes the
>      > transaction size.
>      > 2. **Standardization**: Consistent transaction construction
>     eliminates
>      > wallet fingerprinting.
>      > 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
>      > OP_PUSHBYTES_3 "ash") provides a standardized way to meet the
>     minimum
>      > transaction size; e.g., for a single P2TR dust input.
>      > 4. **Semantic Meaning**: The word "ash" metaphorically represents
>     the
>      > result of "burning" the dust.
>      >
>      > ### Why Per-Address Transactions?
>      >
>      > Consolidating dust from multiple addresses for the same wallet
>     creates
>      > the same privacy harm that dust attacks attempt to achieve. By
>     requiring
>      > wallet software to create separate transactions per address (by
>      > default), the protocol ensures dust disposal doesn't harm privacy.
>      >
>      > ### Why 65 Byte Minimum?
>      >
>      > Bitcoin Core enforces a minimum transaction base size of 65 bytes
>     as a
>      > policy rule to prevent certain attack vectors. Compliant
>     transactions
>      > must meet this threshold to be relayed by standard nodes.
>      >
>      > ### Why 0.1 sat/vB Minimum Fee Rate?
>      >
>      > [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/
>     <https://bitcoincore.org/en/releases/30.0/>) reduced
>      > the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows
>     dust
>      > UTXOs to be disposed of economically even when their value is very
>      > small. Implementations targeting earlier node versions may need
>     higher
>      > minimum fee rates.
>      >
>      > ### Why SIGHASH_ALL|ANYONECANPAY?
>      >
>      > The ANYONECANPAY flag allows additional inputs to be added to the
>     dust
>      > disposal transaction after signing. This provides several benefits:
>      >
>      > 1. **Batching**: Unrelated dust disposal transactions can be
>     found in
>      > the mempool and batched together via RBF.
>      > 2. **User privacy**: Transactions shared via the public mempool
>     do not
>      > reveal user identity metadata.
>      > 3. **Fee Bumping**: Additional inputs can be added by unrelated
>     third
>      > parties to increase the fee rate.
>      >
>      > ### Why nLockTime block height 0
>      >
>      > 1. **User privacy**: Using the same nLockTime for all dust disposal
>      > transactions obscures when it was created.
>      > 2. **Fee sniping**: The value of disposal transactions should be
>     small
>      > enough that fee sniping is not a concern.
>      >
>      > ## Backwards Compatibility
>      >
>      > This BIP introduces no changes to the Bitcoin consensus rules or
>     peer-
>      > to-peer protocol. All transactions conforming to this
>     specification are
>      > valid under existing consensus rules and can be relayed by nodes
>     supporting:
>      >
>      > - OP_RETURN outputs (Bitcoin Core 0.9.0+)
>      > - SIGHASH_ANYONECANPAY (original Bitcoin feature)
>      > - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
>      > - Private transaction broadcast (Bitcoin Core 31.0+)
>      >
>      > Nodes running Bitcoin Core versions prior to 30.0 do not relay
>      > transactions with fee rates below 1 sat/vB which could slow the
>     relaying
>      > of disposal transactions with lower fee rates.
>      >
>      > ## Reference Implementation
>      >
>      > A reference implementation is available at: https://github.com/
>     <https://github.com/>
>      > bubb1es71/ddust
>      >
>      > The implementation provides:
>      > - Command-line tool for creating dust disposal transactions
>      > - Automatic dust detection based on configurable thresholds
>      > - Transaction batching via RBF
>      > - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
>      > - Integration with Bitcoin Core (version 30.0+) via RPC for
>     syncing and
>      > broadcasting transactions
>      >
>      > ## Test Cases
>      >
>      > The test cases below can be used to verify a wallet disposes of dust
>      > UTXOs according to the specification in this BIP.
>      >
>      > ### List dust
>      >
>      > 1. Create payment addresses for multiple address types, send dust
>     and
>      > non-dust amounts to these addresses, verify that listing dust only
>      > returns UTXOs at or below the configured dust threshold (e.g.
>     1000 sats).
>      > 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
>      > verify listing dust only returns the confirmed dust UTXOs.
>      >
>      > ### Spending dust
>      >
>      > All valid dust disposal transactions should be verified to be
>     accepted
>      > into the bitcoind (Bitcoin Core 30.0+) mempool.
>      >
>      > 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
>      > dust disposal transaction with a single "ash" OP_RETURN output.
>      > 2. Spending multiple dust UTXOs always produces a single empty
>     OP_RETURN
>      > output regardless of script type.
>      > 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a
>     single
>      > empty OP_RETURN output.
>      > 4. All dust UTXOs sent to the same address are disposed of in the
>     same
>      > transaction.
>      > 5. Dust disposal transactions only include confirmed dust UTXOs.
>      >
>      > #### Example dust disposal transaction sizes
>      >
>      > | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
>      >
>     |-------------------|-------|------------|--------|-------------|-------|
>      > | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
>      > | Input (b) | 148 | 295 | 41 | 41 | 41 |
>      > | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
>      > | Base size (b) | 169 | 316 | 65 | 65 | 65 |
>      > | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
>      > | Size (b) | 169 | 316 | 173 | 320 | 132 |
>      > | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
>      > | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
>      >
>      > #### Example dust disposal transaction fee rates (sats/vb)
>      >
>      > | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
>      >
>     |--------------|---------|------------|--------|-------------|-------|
>      > | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
>      > | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
>      > | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
>      > | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
>      >
>      > ### Batching dust disposal txs via RBF
>      >
>      > 1. Adding a Bech32m dust input to an unconfirmed disposal
>     transaction
>      > with a legacy dust input keeps the original single empty
>     OP_RETURN output.
>      > 2. Adding a Bech32m dust input to an unconfirmed disposal
>     transaction
>      > with a Bech32m dust input keeps the original single "ash"
>     OP_RETURN output.
>      > 3. Adding a new dust input to an unconfirmed disposal transaction
>      > results in a new batch disposal transaction with a fee rate
>     sufficient
>      > for RBF.
>      > 4. A new dust input that contributes an insufficient fee rate for
>     RBF
>      > with an existing unconfirmed disposal transaction is not batched
>     with it.
>      >
>      > ## Related work
>      >
>      > * "dust-b-gone": https://github.com/petertodd/dust-b-gone
>     <https://github.com/petertodd/dust-b-gone>
>      > * "dusts": https://github.com/bubb1es71/dusts <https://
>     github.com/bubb1es71/dusts>
>      >
>      > ## Changelog
>      >
>      > * **0.1.0** (2026-03-22):
>      > * Initial draft of the BIP.
>      >
>      > ## Copyright
>      >
>      >
>      > This document is licensed under the Creative Commons CC0 1.0
>     Universal
>      > license.
>      >
>      > --
>      > You received this message because you are subscribed to the Google
>      > Groups "Bitcoin Development Mailing List" group.
>      > To unsubscribe from this group and stop receiving emails from it,
>     send
>      > an email to bitcoindev+unsubscribe@googlegroups.com
>     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>
>      > <mailto:bitcoindev+unsubscribe@googlegroups.com
>     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>>.
>      > To view this discussion visit https://groups.google.com/d/msgid/
>     <https://groups.google.com/d/msgid/>
>      > bitcoindev/3b3328b8-bba4-4858-
>     b53a-0e9b631044ffn%40googlegroups.com <http://40googlegroups.com>
>      > <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
>     <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858->
>      > b53a-0e9b631044ffn%40googlegroups.com?
>     utm_medium=email&utm_source=footer <http://40googlegroups.com?
>     utm_medium=email&utm_source=footer>>.
> 
>     -- 
>     You received this message because you are subscribed to the Google
>     Groups "Bitcoin Development Mailing List" group.
>     To unsubscribe from this group and stop receiving emails from it,
>     send an email to bitcoindev+unsubscribe@googlegroups.com
>     <mailto:bitcoindev%2Bunsubscribe@googlegroups.com>.
>     To view this discussion visit https://groups.google.com/d/msgid/
>     bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one
>     <https://groups.google.com/d/msgid/
>     bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one>.
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/283ccf28-c0ca-4ba5-9c5b-c4215a2fa0cf%40murch.one.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-04-06 16:18  0% ` Murch
@ 2026-04-06 18:11  0%   ` STEVEN SLATER
  2026-04-06 20:45  0%     ` Murch
  2026-04-10  2:14  1%   ` 'bubb1es' via Bitcoin Development Mailing List
  1 sibling, 1 reply; 200+ results
From: STEVEN SLATER @ 2026-04-06 18:11 UTC (permalink / raw)
  To: Murch; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 21531 bytes --]

Response to Feedback on Transaction Aggregation Proposal

Hi Murch,

Thank you for taking the time to review my proposal and for raising these
thoughtful points.

On the question of requiring an ash-output: I did consider the idea of
mandating it universally. The main trade-off is between simplicity in
aggregation and the overhead cost. A fixed 3‑byte addition per transaction
is relatively small, but when scaled across high‑volume usage it does
introduce measurable bloat. My current rationale was to avoid imposing that
cost on transactions that are unlikely to benefit from aggregation. That
said, I agree that in scenarios where feerates fluctuate significantly and
dust transactions linger in the mempool, a standardized ash-output could
make collapsing transactions more predictable and efficient. I’ll expand
the rationale to weigh the benefits of guaranteed collapsibility against
the marginal overhead, and outline conditions where the overhead is
justified.

Regarding incompatible outputs: you’re right that independent submissions
with conflicting outputs cannot be aggregated. My intent was to highlight
that aggregation works best when inputs are aligned, and that ash-output
could serve as a safeguard to preserve compatibility. I’ll clarify this
point further in the next revision.

Thank you also for the correction on feerate policy backports to Bitcoin
Core 29.1 and 28.3. I’ll update the proposal to reflect that users on those
branches will indeed propagate sub‑sat transactions.

I appreciate your constructive feedbackit helps sharpen the rationale and
ensures the proposal is practical for broader adoption. I’ll incorporate
these clarifications before submission.

Best regards,
Steven

On Mon, 6 Apr 2026, 5:26 pm Murch, <murch@murch.one> wrote:

> Hi bubb1es,
>
> I just skimmed your proposal and was considering the impact of the two
> possible output variants. As you mention in the description of the test
> cases, adding more inputs to a transaction would retain the output of
> the first transaction that appeared on the network. However, if two
> users independently submit transactions with incompatible outputs, third
> parties would not be able to aggregate those transactions into a single
> transaction.
>
> I was wondering whether you considered generally requiring the
> ash-output to ensure that transactions can always be collapsed. This may
> especially be attractive if feerates will be more dynamic in the future
> and dust disposal transactions linger in the mempool for a while.
>
> It probably comes down to how heavily this scheme will be used whether a
> general 3-byte overhead is justifiable to simplify aggregation. Either
> way, perhaps you could expound a bit on that trade-off in your rationale.
>
> Also, minor correction: the feerate policy change was backported to
> Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest
> releases of those major branches would also propagate sub-sat transactions.
>
> Otherwise, this proposal looks reasonable to me. Looking forward to your
> submission.
>
> Cheers,
> Murch
>
> On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List wrote:
> >
> > Hi, based on a topic I started on Delving <https://delvingbitcoin.org/t/
> > disposing-of-dust-attack-utxos/2215> I'd like to gather feedback from
> > this community for a BIP to standardize disposing of dust UTXOs by
> > spending their values to the fee of single OP_RETURN output transactions.
> >
> > Thanks in advance for taking your time to consider this proposal.
> >
> > ```
> > BIP: ?
> > Layer: Applications
> > Title: Dust UTXO Disposal Protocol
> > Authors: bubb1es <bubb1es71@proton.me>
> > harris <imtux2@proton.me>
> > Status: Draft
> > Type: Specification
> > Assigned: ?
> > License: CC0-1.0
> > Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-of-dust-
> > attack-utxos/2215
> > Version: 0.1.0
> > ```
> >
> > ## Abstract
> >
> > This BIP specifies a standardized protocol for safely disposing of dust
> > UTXOs by spending them to an OP_RETURN output with the entire value
> > going to transaction fees. The protocol enables wallet software to
> > remove unwanted small-value UTXOs, particularly those received in dust
> > attacks, without creating new address linkages or degrading user
> > privacy. The specification includes transaction format requirements,
> > signature conventions enabling third-party batching, and validation
> > rules for compliant implementations.
> >
> > ## Motivation
> >
> > ### The Dust Attack Problem
> >
> > Dust attacks are a well-documented privacy threat where attackers send
> > small amounts of bitcoin to numerous addresses. When wallet software
> > later consolidates these dust UTXOs with non-dust UTXOs, the attacker
> > can analyze the blockchain to link previously unassociated addresses,
> > potentially deanonymizing users.
> >
> > The common solution to this issue is to "lock" dust UTXOs and never
> > spend them, but this creates its own problems:
> >
> > 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the
> > UTXO set that all full nodes must maintain.
> > 2. **Wallet Clutter**: Accumulated dust degrades wallet usability and
> > complicates coin selection.
> > 3. **Accidental Consolidation**: Users may inadvertently spend dust
> > during legitimate transactions, achieving the attacker's goal.
> > 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to
> > prevent spending provides only temporary protection; wallet migrations,
> > restores from seed phrases, software bugs, or inheritance scenarios can
> > inadvertently unlock dust, exposing users to the original attack.
> >
> > ### Why OP_RETURN Disposal
> >
> > Spending dust to an OP_RETURN output with the entire value going to fees
> > provides several benefits:
> >
> > 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not
> > stored in the UTXO set.
> > 2. **No Address Linking**: Without a change output, there is no new
> > address to link.
> > 3. **Permanent Removal**: The dust UTXOs are removed from the user's
> > wallet entirely.
> > 4. **Miner Compensation**: OP_RETURN outputs are small, providing higher
> > transaction fee rates.
> > 5. **No Cost to Victims**: Dust attack UTXO values are used to pay for
> > their own disposal.
> >
> > ### Why Standardization
> >
> > A standardized protocol enables:
> >
> > 1. **Wallet Anonymity**: Transactions with a standard format cannot be
> > used to fingerprint the wallet software a user is running.
> > 2. **Third-Party Batching**: Multiple dust disposals can be combined
> > into single transactions, reducing overall block space consumption.
> > 3. **Best Practice Codification**: Ensures implementations follow
> > privacy-preserving best practices.
> > 4. **Easy Identification**: Chain analysis tools can use disposal
> > transactions to help trace the sources of dust attacks.
> >
> > ## Specification
> >
> > ### Transaction Format
> >
> > A compliant dust disposal transaction MUST satisfy all the following
> > requirements:
> >
> > #### Overall
> >
> > 1. The transaction MUST signal RBF replaceability (nSequence <
> 0xFFFFFFFE).
> > 2. The ntimelock MUST be set to block height 0.
> > 3. The fee rate MUST be at least 0.1 sat/vB.
> >
> > #### Outputs
> >
> > 1. The transaction MUST have exactly one output.
> > 2. The single output MUST be an OP_RETURN.
> > 3. The OP_RETURN data MUST be either:
> > - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
> > - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN
> > OP_PUSHBYTES_3 "ash").
> >
> > The "ash" marker MUST be used when padding is needed to meet the 65 vB
> > minimum standard transaction size with a single witness input.
> > Implementations MUST prefer empty OP_RETURN data when the transaction
> > already meets minimum size requirements.
> >
> > #### Inputs
> >
> > 1. All inputs MUST use the signature hash type `SIGHASH_ALL |
> > SIGHASH_ANYONECANPAY` (0x81).
> > 2. For Taproot (P2TR) inputs using key-path spending, implementations
> > MUST explicitly append the signature hash type byte `SIGHASH_ALL |
> > SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the
> > default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does
> > not include ANYONECANPAY.
> > 3. All inputs must be confirmed in the blockchain at least one block
> deep.
> >
> > #### Fees
> >
> > 1. The entire input value MUST go to fees (output value is zero for
> > OP_RETURN).
> > 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum
> > relay requirements (Bitcoin Core 30.0+).
> > 3. The transaction fee rate MAY be higher based on the available dust
> > UTXO amounts and transaction size.
> >
> > ### Transaction Size
> >
> > 1. The transaction base size MUST be at least 65 bytes to meet Bitcoin
> > Core's minimum relay size standardness rule.
> > 2. If the transaction would otherwise be smaller than 65 bytes, the
> > OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be
> > used to pad the transaction's size to 65 bytes.
> >
> > ### Address Consolidation Rules
> >
> > Implementations consolidating dust UTXOs for a single user (i.e., not
> > third-party batching services):
> >
> > - MUST NOT spend dust UTXOs that were sent to different addresses in the
> > same transaction.
> > - MUST NOT broadcast dust disposal transactions at the same time for
> > dust sent to different addresses.
> > - SHOULD spend dust UTXOs for dust sent to the same address in one
> > transaction.
> >
> > ### Batching Dust Disposal Transactions via RBF
> >
> > Multiple unconfirmed dust disposal transactions created by unrelated
> > entities MAY be batched into a single replacement transaction using
> > Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY
> > signature type.
> >
> > In addition to standard RBF rules, batch dust disposal transactions must
> > follow all transaction construction requirements for non-batched dust
> > disposal transactions.
> >
> > #### Third-Party Batching
> >
> > A third-party batching service for dust disposal transactions could
> > compromise their users' privacy by collecting user-related network and
> > timing metadata. The best practice for these services is:
> >
> > 1. The service MUST NOT collect pre-signed inputs directly from wallet
> > users.
> > 2. The service SHOULD collect pre-signed inputs from the public bitcoin
> > network mempool.
> > 3. The service MAY add their own UTXO inputs to improve the batch
> > transaction's fee rate as long as all the requirements of this
> > specification are still followed.
> >
> > This mempool-based approach preserves user privacy while enabling
> > efficient batching:
> >
> > 1. Users broadcast their individual dust disposal transactions to the
> > network.
> > 2. Batching services monitor the mempool for compliant dust disposal
> > transactions.
> > 3. Services can combine unconfirmed transactions via RBF without knowing
> > user identities.
> >
> > ### Dust Threshold
> >
> > Implementations SHOULD allow users to configure their own dust threshold
> > based on:
> >
> > 1. The current and anticipated fee rates.
> > 2. The dust input script type, different types have different spending
> > costs.
> > 3. The varying amounts that may be used by dust attack initiators.
> >
> > A UTXO is generally considered dust if its value is less than the cost
> > to spend it at a reasonable fee rate, but any small UTXO value could be
> > used in a dust attack.
> >
> > ### Security Considerations
> >
> > #### Transaction Signing
> >
> > 1. **Key Security**: Signing dust disposal transactions requires signing
> > with the user's wallet private keys. This could be a risk for cold
> > storage wallets where the key or keys needed to sign are not easily
> > accessible.
> > 2. **Transaction Correctness**: Transaction signers must carefully
> > review and verify that only dust UTXOs are spent and no other inputs are
> > signed.
> >
> > #### Privacy Preservation
> >
> > 1. **Network surveillance**: Internet service providers and other
> > internet monitors may be able to determine the nodes that initially
> > broadcast a dust disposal transaction. If available the
> > `sendrawtransaction -privatebroadcast` RPC feature should be used
> > (available in [Bitcoin Core 31.0](https://github.com/bitcoin-core/
> > bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
> > 2. **Timing Analysis**: Users should be aware that the timing of dust
> > disposal transactions is publicly observable. Dust disposal transactions
> > should not be broadcast at the same time or on a predictable schedule.
> > 3. **Amount Analysis**: The specific dust amounts selected for dust
> > disposal if outside the norm may be used to fingerprint the wallet
> > creating the disposal transactions.
> >
> > ## Rationale
> >
> > ### Why Empty or "ash" OP_RETURN Data?
> >
> > 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the
> > transaction size.
> > 2. **Standardization**: Consistent transaction construction eliminates
> > wallet fingerprinting.
> > 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN
> > OP_PUSHBYTES_3 "ash") provides a standardized way to meet the minimum
> > transaction size; e.g., for a single P2TR dust input.
> > 4. **Semantic Meaning**: The word "ash" metaphorically represents the
> > result of "burning" the dust.
> >
> > ### Why Per-Address Transactions?
> >
> > Consolidating dust from multiple addresses for the same wallet creates
> > the same privacy harm that dust attacks attempt to achieve. By requiring
> > wallet software to create separate transactions per address (by
> > default), the protocol ensures dust disposal doesn't harm privacy.
> >
> > ### Why 65 Byte Minimum?
> >
> > Bitcoin Core enforces a minimum transaction base size of 65 bytes as a
> > policy rule to prevent certain attack vectors. Compliant transactions
> > must meet this threshold to be relayed by standard nodes.
> >
> > ### Why 0.1 sat/vB Minimum Fee Rate?
> >
> > [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced
> > the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust
> > UTXOs to be disposed of economically even when their value is very
> > small. Implementations targeting earlier node versions may need higher
> > minimum fee rates.
> >
> > ### Why SIGHASH_ALL|ANYONECANPAY?
> >
> > The ANYONECANPAY flag allows additional inputs to be added to the dust
> > disposal transaction after signing. This provides several benefits:
> >
> > 1. **Batching**: Unrelated dust disposal transactions can be found in
> > the mempool and batched together via RBF.
> > 2. **User privacy**: Transactions shared via the public mempool do not
> > reveal user identity metadata.
> > 3. **Fee Bumping**: Additional inputs can be added by unrelated third
> > parties to increase the fee rate.
> >
> > ### Why nLockTime block height 0
> >
> > 1. **User privacy**: Using the same nLockTime for all dust disposal
> > transactions obscures when it was created.
> > 2. **Fee sniping**: The value of disposal transactions should be small
> > enough that fee sniping is not a concern.
> >
> > ## Backwards Compatibility
> >
> > This BIP introduces no changes to the Bitcoin consensus rules or peer-
> > to-peer protocol. All transactions conforming to this specification are
> > valid under existing consensus rules and can be relayed by nodes
> supporting:
> >
> > - OP_RETURN outputs (Bitcoin Core 0.9.0+)
> > - SIGHASH_ANYONECANPAY (original Bitcoin feature)
> > - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
> > - Private transaction broadcast (Bitcoin Core 31.0+)
> >
> > Nodes running Bitcoin Core versions prior to 30.0 do not relay
> > transactions with fee rates below 1 sat/vB which could slow the relaying
> > of disposal transactions with lower fee rates.
> >
> > ## Reference Implementation
> >
> > A reference implementation is available at: https://github.com/
> > bubb1es71/ddust
> >
> > The implementation provides:
> > - Command-line tool for creating dust disposal transactions
> > - Automatic dust detection based on configurable thresholds
> > - Transaction batching via RBF
> > - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
> > - Integration with Bitcoin Core (version 30.0+) via RPC for syncing and
> > broadcasting transactions
> >
> > ## Test Cases
> >
> > The test cases below can be used to verify a wallet disposes of dust
> > UTXOs according to the specification in this BIP.
> >
> > ### List dust
> >
> > 1. Create payment addresses for multiple address types, send dust and
> > non-dust amounts to these addresses, verify that listing dust only
> > returns UTXOs at or below the configured dust threshold (e.g. 1000 sats).
> > 2. Create confirmed and unconfirmed dust UTXOs in the test wallet,
> > verify listing dust only returns the confirmed dust UTXOs.
> >
> > ### Spending dust
> >
> > All valid dust disposal transactions should be verified to be accepted
> > into the bitcoind (Bitcoin Core 30.0+) mempool.
> >
> > 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a
> > dust disposal transaction with a single "ash" OP_RETURN output.
> > 2. Spending multiple dust UTXOs always produces a single empty OP_RETURN
> > output regardless of script type.
> > 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single
> > empty OP_RETURN output.
> > 4. All dust UTXOs sent to the same address are disposed of in the same
> > transaction.
> > 5. Dust disposal transactions only include confirmed dust UTXOs.
> >
> > #### Example dust disposal transaction sizes
> >
> > | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> > |-------------------|-------|------------|--------|-------------|-------|
> > | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
> > | Input (b) | 148 | 295 | 41 | 41 | 41 |
> > | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
> > | Base size (b) | 169 | 316 | 65 | 65 | 65 |
> > | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
> > | Size (b) | 169 | 316 | 173 | 320 | 132 |
> > | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
> > | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
> >
> > #### Example dust disposal transaction fee rates (sats/vb)
> >
> > | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> > |--------------|---------|------------|--------|-------------|-------|
> > | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
> > | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
> > | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
> > | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
> >
> > ### Batching dust disposal txs via RBF
> >
> > 1. Adding a Bech32m dust input to an unconfirmed disposal transaction
> > with a legacy dust input keeps the original single empty OP_RETURN
> output.
> > 2. Adding a Bech32m dust input to an unconfirmed disposal transaction
> > with a Bech32m dust input keeps the original single "ash" OP_RETURN
> output.
> > 3. Adding a new dust input to an unconfirmed disposal transaction
> > results in a new batch disposal transaction with a fee rate sufficient
> > for RBF.
> > 4. A new dust input that contributes an insufficient fee rate for RBF
> > with an existing unconfirmed disposal transaction is not batched with it.
> >
> > ## Related work
> >
> > * "dust-b-gone": https://github.com/petertodd/dust-b-gone
> > * "dusts": https://github.com/bubb1es71/dusts
> >
> > ## Changelog
> >
> > * **0.1.0** (2026-03-22):
> > * Initial draft of the BIP.
> >
> > ## Copyright
> >
> >
> > This document is licensed under the Creative Commons CC0 1.0 Universal
> > license.
> >
> > --
> > You received this message because you are subscribed to the Google
> > Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> > an email to bitcoindev+unsubscribe@googlegroups.com
> > <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> > To view this discussion visit https://groups.google.com/d/msgid/
> > bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com
> > <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-
> > b53a-0e9b631044ffn%40googlegroups.com?utm_medium=email&utm_source=footer
> >.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAP%2B9vXOVhnCC5fPjK1q9d_gL0%2BoHs1-Gk3p04%3Dw90W6dW1PbcQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 26585 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] A slight change proposed on Committing to quantum resistance: a slow defence for Bitcoin against a fast quantum computing attack
@ 2026-04-06 20:30  1% PYM
  2026-04-11 17:09  0% ` [bitcoindev] " Daniel Buchner
  0 siblings, 1 reply; 200+ results
From: PYM @ 2026-04-06 20:30 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 2011 bytes --]

Hello, here's a small idea to combine merkel tree with timestamped message 
signature to bind p2pkh adress to quantum resistant scheme so user do not 
need to rush to move bitcoin before qday, in a space efficient form.

- *Universal P2PKH freeze* — At a defined block height, all P2PKH outputs 
become unspendable via classical ECDSA. 
- *Pre-freeze claim* — Before the freeze, owners sign a claim containing 
their Bitcoin address and a new post-quantum public key of their choice. 
The claim is ECDSA-signed, proving classical ownership while quantum 
computers don't yet exist. 
- *Merkle-batched publication* — Claims are batched into Merkle trees. Only 
the 32-byte root goes on-chain via OP_RETURN. One transaction covers large 
amount of claims. 
- *Post-freeze spending* — To spend a frozen output, provide: the original 
claim, a Merkle inclusion proof linking it to a pre-freeze root, and a 
signature from the post-quantum key committed in the claim.  
- *No claim, no spend* — Any P2PKH output with no registered claim before 
the freeze height is permanently frozen until a future recovery mechanism 
is defined by the community.
I do not have enough knowledge to find the ideal scheme or implementation 
that fulfill those requirements sadly. 

1 - Stewart I, Ilie D, Zamyatin A, Werner S, Torshizi MF, Knottenbelt WJ. 
Committing to quantum resistance: a slow defence for Bitcoin against a fast 
quantum computing attack. R Soc Open Sci. 2018 Jun 20;5(6):180410. doi: 
10.1098/rsos.180410. PMID: 30110420; PMCID: PMC6030263.
https://pmc.ncbi.nlm.nih.gov/articles/PMC6030263/

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/4303fca1-81a8-4655-ac53-33f566daebc2n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 2762 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
  2026-03-30 18:34  1% [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol 'bubb1es' via Bitcoin Development Mailing List
@ 2026-04-06 16:18  0% ` Murch
  2026-04-06 18:11  0%   ` STEVEN SLATER
  2026-04-10  2:14  1%   ` 'bubb1es' via Bitcoin Development Mailing List
  0 siblings, 2 replies; 200+ results
From: Murch @ 2026-04-06 16:18 UTC (permalink / raw)
  To: bitcoindev

Hi bubb1es,

I just skimmed your proposal and was considering the impact of the two 
possible output variants. As you mention in the description of the test 
cases, adding more inputs to a transaction would retain the output of 
the first transaction that appeared on the network. However, if two 
users independently submit transactions with incompatible outputs, third 
parties would not be able to aggregate those transactions into a single 
transaction.

I was wondering whether you considered generally requiring the 
ash-output to ensure that transactions can always be collapsed. This may 
especially be attractive if feerates will be more dynamic in the future 
and dust disposal transactions linger in the mempool for a while.

It probably comes down to how heavily this scheme will be used whether a 
general 3-byte overhead is justifiable to simplify aggregation. Either 
way, perhaps you could expound a bit on that trade-off in your rationale.

Also, minor correction: the feerate policy change was backported to 
Bitcoin Core 29.1 and Bitcoin Core 28.3, so users running the latest 
releases of those major branches would also propagate sub-sat transactions.

Otherwise, this proposal looks reasonable to me. Looking forward to your 
submission.

Cheers,
Murch

On 2026-03-30 11:34, 'bubb1es' via Bitcoin Development Mailing List wrote:
> 
> Hi, based on a topic I started on Delving <https://delvingbitcoin.org/t/ 
> disposing-of-dust-attack-utxos/2215> I'd like to gather feedback from 
> this community for a BIP to standardize disposing of dust UTXOs by 
> spending their values to the fee of single OP_RETURN output transactions.
> 
> Thanks in advance for taking your time to consider this proposal.
> 
> ```
> BIP: ?
> Layer: Applications
> Title: Dust UTXO Disposal Protocol
> Authors: bubb1es <bubb1es71@proton.me>
> harris <imtux2@proton.me>
> Status: Draft
> Type: Specification
> Assigned: ?
> License: CC0-1.0
> Discussion: 2026-01-25: https://delvingbitcoin.org/t/disposing-of-dust- 
> attack-utxos/2215
> Version: 0.1.0
> ```
> 
> ## Abstract
> 
> This BIP specifies a standardized protocol for safely disposing of dust 
> UTXOs by spending them to an OP_RETURN output with the entire value 
> going to transaction fees. The protocol enables wallet software to 
> remove unwanted small-value UTXOs, particularly those received in dust 
> attacks, without creating new address linkages or degrading user 
> privacy. The specification includes transaction format requirements, 
> signature conventions enabling third-party batching, and validation 
> rules for compliant implementations.
> 
> ## Motivation
> 
> ### The Dust Attack Problem
> 
> Dust attacks are a well-documented privacy threat where attackers send 
> small amounts of bitcoin to numerous addresses. When wallet software 
> later consolidates these dust UTXOs with non-dust UTXOs, the attacker 
> can analyze the blockchain to link previously unassociated addresses, 
> potentially deanonymizing users.
> 
> The common solution to this issue is to "lock" dust UTXOs and never 
> spend them, but this creates its own problems:
> 
> 1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the 
> UTXO set that all full nodes must maintain.
> 2. **Wallet Clutter**: Accumulated dust degrades wallet usability and 
> complicates coin selection.
> 3. **Accidental Consolidation**: Users may inadvertently spend dust 
> during legitimate transactions, achieving the attacker's goal.
> 4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to 
> prevent spending provides only temporary protection; wallet migrations, 
> restores from seed phrases, software bugs, or inheritance scenarios can 
> inadvertently unlock dust, exposing users to the original attack.
> 
> ### Why OP_RETURN Disposal
> 
> Spending dust to an OP_RETURN output with the entire value going to fees 
> provides several benefits:
> 
> 1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not 
> stored in the UTXO set.
> 2. **No Address Linking**: Without a change output, there is no new 
> address to link.
> 3. **Permanent Removal**: The dust UTXOs are removed from the user's 
> wallet entirely.
> 4. **Miner Compensation**: OP_RETURN outputs are small, providing higher 
> transaction fee rates.
> 5. **No Cost to Victims**: Dust attack UTXO values are used to pay for 
> their own disposal.
> 
> ### Why Standardization
> 
> A standardized protocol enables:
> 
> 1. **Wallet Anonymity**: Transactions with a standard format cannot be 
> used to fingerprint the wallet software a user is running.
> 2. **Third-Party Batching**: Multiple dust disposals can be combined 
> into single transactions, reducing overall block space consumption.
> 3. **Best Practice Codification**: Ensures implementations follow 
> privacy-preserving best practices.
> 4. **Easy Identification**: Chain analysis tools can use disposal 
> transactions to help trace the sources of dust attacks.
> 
> ## Specification
> 
> ### Transaction Format
> 
> A compliant dust disposal transaction MUST satisfy all the following 
> requirements:
> 
> #### Overall
> 
> 1. The transaction MUST signal RBF replaceability (nSequence < 0xFFFFFFFE).
> 2. The ntimelock MUST be set to block height 0.
> 3. The fee rate MUST be at least 0.1 sat/vB.
> 
> #### Outputs
> 
> 1. The transaction MUST have exactly one output.
> 2. The single output MUST be an OP_RETURN.
> 3. The OP_RETURN data MUST be either:
> - Empty: `0x6a 0x00` (OP_RETURN OP_0), or
> - The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN 
> OP_PUSHBYTES_3 "ash").
> 
> The "ash" marker MUST be used when padding is needed to meet the 65 vB 
> minimum standard transaction size with a single witness input. 
> Implementations MUST prefer empty OP_RETURN data when the transaction 
> already meets minimum size requirements.
> 
> #### Inputs
> 
> 1. All inputs MUST use the signature hash type `SIGHASH_ALL | 
> SIGHASH_ANYONECANPAY` (0x81).
> 2. For Taproot (P2TR) inputs using key-path spending, implementations 
> MUST explicitly append the signature hash type byte `SIGHASH_ALL | 
> SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the 
> default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does 
> not include ANYONECANPAY.
> 3. All inputs must be confirmed in the blockchain at least one block deep.
> 
> #### Fees
> 
> 1. The entire input value MUST go to fees (output value is zero for 
> OP_RETURN).
> 2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum 
> relay requirements (Bitcoin Core 30.0+).
> 3. The transaction fee rate MAY be higher based on the available dust 
> UTXO amounts and transaction size.
> 
> ### Transaction Size
> 
> 1. The transaction base size MUST be at least 65 bytes to meet Bitcoin 
> Core's minimum relay size standardness rule.
> 2. If the transaction would otherwise be smaller than 65 bytes, the 
> OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be 
> used to pad the transaction's size to 65 bytes.
> 
> ### Address Consolidation Rules
> 
> Implementations consolidating dust UTXOs for a single user (i.e., not 
> third-party batching services):
> 
> - MUST NOT spend dust UTXOs that were sent to different addresses in the 
> same transaction.
> - MUST NOT broadcast dust disposal transactions at the same time for 
> dust sent to different addresses.
> - SHOULD spend dust UTXOs for dust sent to the same address in one 
> transaction.
> 
> ### Batching Dust Disposal Transactions via RBF
> 
> Multiple unconfirmed dust disposal transactions created by unrelated 
> entities MAY be batched into a single replacement transaction using 
> Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY 
> signature type.
> 
> In addition to standard RBF rules, batch dust disposal transactions must 
> follow all transaction construction requirements for non-batched dust 
> disposal transactions.
> 
> #### Third-Party Batching
> 
> A third-party batching service for dust disposal transactions could 
> compromise their users' privacy by collecting user-related network and 
> timing metadata. The best practice for these services is:
> 
> 1. The service MUST NOT collect pre-signed inputs directly from wallet 
> users.
> 2. The service SHOULD collect pre-signed inputs from the public bitcoin 
> network mempool.
> 3. The service MAY add their own UTXO inputs to improve the batch 
> transaction's fee rate as long as all the requirements of this 
> specification are still followed.
> 
> This mempool-based approach preserves user privacy while enabling 
> efficient batching:
> 
> 1. Users broadcast their individual dust disposal transactions to the 
> network.
> 2. Batching services monitor the mempool for compliant dust disposal 
> transactions.
> 3. Services can combine unconfirmed transactions via RBF without knowing 
> user identities.
> 
> ### Dust Threshold
> 
> Implementations SHOULD allow users to configure their own dust threshold 
> based on:
> 
> 1. The current and anticipated fee rates.
> 2. The dust input script type, different types have different spending 
> costs.
> 3. The varying amounts that may be used by dust attack initiators.
> 
> A UTXO is generally considered dust if its value is less than the cost 
> to spend it at a reasonable fee rate, but any small UTXO value could be 
> used in a dust attack.
> 
> ### Security Considerations
> 
> #### Transaction Signing
> 
> 1. **Key Security**: Signing dust disposal transactions requires signing 
> with the user's wallet private keys. This could be a risk for cold 
> storage wallets where the key or keys needed to sign are not easily 
> accessible.
> 2. **Transaction Correctness**: Transaction signers must carefully 
> review and verify that only dust UTXOs are spent and no other inputs are 
> signed.
> 
> #### Privacy Preservation
> 
> 1. **Network surveillance**: Internet service providers and other 
> internet monitors may be able to determine the nodes that initially 
> broadcast a dust disposal transaction. If available the 
> `sendrawtransaction -privatebroadcast` RPC feature should be used 
> (available in [Bitcoin Core 31.0](https://github.com/bitcoin-core/ 
> bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
> 2. **Timing Analysis**: Users should be aware that the timing of dust 
> disposal transactions is publicly observable. Dust disposal transactions 
> should not be broadcast at the same time or on a predictable schedule.
> 3. **Amount Analysis**: The specific dust amounts selected for dust 
> disposal if outside the norm may be used to fingerprint the wallet 
> creating the disposal transactions.
> 
> ## Rationale
> 
> ### Why Empty or "ash" OP_RETURN Data?
> 
> 1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the 
> transaction size.
> 2. **Standardization**: Consistent transaction construction eliminates 
> wallet fingerprinting.
> 3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN 
> OP_PUSHBYTES_3 "ash") provides a standardized way to meet the minimum 
> transaction size; e.g., for a single P2TR dust input.
> 4. **Semantic Meaning**: The word "ash" metaphorically represents the 
> result of "burning" the dust.
> 
> ### Why Per-Address Transactions?
> 
> Consolidating dust from multiple addresses for the same wallet creates 
> the same privacy harm that dust attacks attempt to achieve. By requiring 
> wallet software to create separate transactions per address (by 
> default), the protocol ensures dust disposal doesn't harm privacy.
> 
> ### Why 65 Byte Minimum?
> 
> Bitcoin Core enforces a minimum transaction base size of 65 bytes as a 
> policy rule to prevent certain attack vectors. Compliant transactions 
> must meet this threshold to be relayed by standard nodes.
> 
> ### Why 0.1 sat/vB Minimum Fee Rate?
> 
> [Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced 
> the minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust 
> UTXOs to be disposed of economically even when their value is very 
> small. Implementations targeting earlier node versions may need higher 
> minimum fee rates.
> 
> ### Why SIGHASH_ALL|ANYONECANPAY?
> 
> The ANYONECANPAY flag allows additional inputs to be added to the dust 
> disposal transaction after signing. This provides several benefits:
> 
> 1. **Batching**: Unrelated dust disposal transactions can be found in 
> the mempool and batched together via RBF.
> 2. **User privacy**: Transactions shared via the public mempool do not 
> reveal user identity metadata.
> 3. **Fee Bumping**: Additional inputs can be added by unrelated third 
> parties to increase the fee rate.
> 
> ### Why nLockTime block height 0
> 
> 1. **User privacy**: Using the same nLockTime for all dust disposal 
> transactions obscures when it was created.
> 2. **Fee sniping**: The value of disposal transactions should be small 
> enough that fee sniping is not a concern.
> 
> ## Backwards Compatibility
> 
> This BIP introduces no changes to the Bitcoin consensus rules or peer- 
> to-peer protocol. All transactions conforming to this specification are 
> valid under existing consensus rules and can be relayed by nodes supporting:
> 
> - OP_RETURN outputs (Bitcoin Core 0.9.0+)
> - SIGHASH_ANYONECANPAY (original Bitcoin feature)
> - 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
> - Private transaction broadcast (Bitcoin Core 31.0+)
> 
> Nodes running Bitcoin Core versions prior to 30.0 do not relay 
> transactions with fee rates below 1 sat/vB which could slow the relaying 
> of disposal transactions with lower fee rates.
> 
> ## Reference Implementation
> 
> A reference implementation is available at: https://github.com/ 
> bubb1es71/ddust
> 
> The implementation provides:
> - Command-line tool for creating dust disposal transactions
> - Automatic dust detection based on configurable thresholds
> - Transaction batching via RBF
> - Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
> - Integration with Bitcoin Core (version 30.0+) via RPC for syncing and 
> broadcasting transactions
> 
> ## Test Cases
> 
> The test cases below can be used to verify a wallet disposes of dust 
> UTXOs according to the specification in this BIP.
> 
> ### List dust
> 
> 1. Create payment addresses for multiple address types, send dust and 
> non-dust amounts to these addresses, verify that listing dust only 
> returns UTXOs at or below the configured dust threshold (e.g. 1000 sats).
> 2. Create confirmed and unconfirmed dust UTXOs in the test wallet, 
> verify listing dust only returns the confirmed dust UTXOs.
> 
> ### Spending dust
> 
> All valid dust disposal transactions should be verified to be accepted 
> into the bitcoind (Bitcoin Core 30.0+) mempool.
> 
> 1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a 
> dust disposal transaction with a single "ash" OP_RETURN output.
> 2. Spending multiple dust UTXOs always produces a single empty OP_RETURN 
> output regardless of script type.
> 3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single 
> empty OP_RETURN output.
> 4. All dust UTXOs sent to the same address are disposed of in the same 
> transaction.
> 5. Dust disposal transactions only include confirmed dust UTXOs.
> 
> #### Example dust disposal transaction sizes
> 
> | | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> |-------------------|-------|------------|--------|-------------|-------|
> | Overhead (b) | 10 | 10 | 10 | 10 | 10 |
> | Input (b) | 148 | 295 | 41 | 41 | 41 |
> | OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
> | Base size (b) | 169 | 316 | 65 | 65 | 65 |
> | Witness data (b) | 0 | 0 | 108 | 255 | 67 |
> | Size (b) | 169 | 316 | 173 | 320 | 132 |
> | Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
> | Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 |
> 
> #### Example dust disposal transaction fee rates (sats/vb)
> 
> | Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
> |--------------|---------|------------|--------|-------------|-------|
> | 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
> | 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
> | 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
> | 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |
> 
> ### Batching dust disposal txs via RBF
> 
> 1. Adding a Bech32m dust input to an unconfirmed disposal transaction 
> with a legacy dust input keeps the original single empty OP_RETURN output.
> 2. Adding a Bech32m dust input to an unconfirmed disposal transaction 
> with a Bech32m dust input keeps the original single "ash" OP_RETURN output.
> 3. Adding a new dust input to an unconfirmed disposal transaction 
> results in a new batch disposal transaction with a fee rate sufficient 
> for RBF.
> 4. A new dust input that contributes an insufficient fee rate for RBF 
> with an existing unconfirmed disposal transaction is not batched with it.
> 
> ## Related work
> 
> * "dust-b-gone": https://github.com/petertodd/dust-b-gone
> * "dusts": https://github.com/bubb1es71/dusts
> 
> ## Changelog
> 
> * **0.1.0** (2026-03-22):
> * Initial draft of the BIP.
> 
> ## Copyright
> 
> 
> This document is licensed under the Creative Commons CC0 1.0 Universal 
> license.
> 
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com 
> <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> To view this discussion visit https://groups.google.com/d/msgid/ 
> bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858- 
> b53a-0e9b631044ffn%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5028df3d-22ec-4a3e-9b54-64a4f1f0cefc%40murch.one.


^ permalink raw reply	[relevance 0%]

* [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol
@ 2026-03-30 18:34  1% 'bubb1es' via Bitcoin Development Mailing List
  2026-04-06 16:18  0% ` Murch
  0 siblings, 1 reply; 200+ results
From: 'bubb1es' via Bitcoin Development Mailing List @ 2026-03-30 18:34 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 15485 bytes --]


Hi, based on a topic I started on Delving 
<https://delvingbitcoin.org/t/disposing-of-dust-attack-utxos/2215> I'd like 
to gather feedback from this community for a BIP to standardize disposing 
of dust UTXOs by spending their values to the fee of single OP_RETURN 
output transactions. 

Thanks in advance for taking your time to consider this proposal.

```
BIP: ?
Layer: Applications
Title: Dust UTXO Disposal Protocol
Authors: bubb1es <bubb1es71@proton.me>
harris <imtux2@proton.me>
Status: Draft
Type: Specification
Assigned: ?
License: CC0-1.0
Discussion: 2026-01-25: 
https://delvingbitcoin.org/t/disposing-of-dust-attack-utxos/2215
Version: 0.1.0
```

## Abstract

This BIP specifies a standardized protocol for safely disposing of dust 
UTXOs by spending them to an OP_RETURN output with the entire value going 
to transaction fees. The protocol enables wallet software to remove 
unwanted small-value UTXOs, particularly those received in dust attacks, 
without creating new address linkages or degrading user privacy. The 
specification includes transaction format requirements, signature 
conventions enabling third-party batching, and validation rules for 
compliant implementations.

## Motivation

### The Dust Attack Problem

Dust attacks are a well-documented privacy threat where attackers send 
small amounts of bitcoin to numerous addresses. When wallet software later 
consolidates these dust UTXOs with non-dust UTXOs, the attacker can analyze 
the blockchain to link previously unassociated addresses, potentially 
deanonymizing users.

The common solution to this issue is to "lock" dust UTXOs and never spend 
them, but this creates its own problems:

1. **UTXO Set Bloat**: Unspent dust permanently occupies space in the UTXO 
set that all full nodes must maintain.
2. **Wallet Clutter**: Accumulated dust degrades wallet usability and 
complicates coin selection.
3. **Accidental Consolidation**: Users may inadvertently spend dust during 
legitimate transactions, achieving the attacker's goal.
4. **Lock Fragility**: Wallet software that "locks" dust UTXOs to prevent 
spending provides only temporary protection; wallet migrations, restores 
from seed phrases, software bugs, or inheritance scenarios can 
inadvertently unlock dust, exposing users to the original attack.

### Why OP_RETURN Disposal

Spending dust to an OP_RETURN output with the entire value going to fees 
provides several benefits:

1. **No New UTXOs**: OP_RETURN outputs are provably unspendable and not 
stored in the UTXO set.
2. **No Address Linking**: Without a change output, there is no new address 
to link.
3. **Permanent Removal**: The dust UTXOs are removed from the user's wallet 
entirely.
4. **Miner Compensation**: OP_RETURN outputs are small, providing higher 
transaction fee rates.
5. **No Cost to Victims**: Dust attack UTXO values are used to pay for 
their own disposal.

### Why Standardization

A standardized protocol enables:

1. **Wallet Anonymity**: Transactions with a standard format cannot be used 
to fingerprint the wallet software a user is running.
2. **Third-Party Batching**: Multiple dust disposals can be combined into 
single transactions, reducing overall block space consumption.
3. **Best Practice Codification**: Ensures implementations follow 
privacy-preserving best practices.
4. **Easy Identification**: Chain analysis tools can use disposal 
transactions to help trace the sources of dust attacks.

## Specification

### Transaction Format

A compliant dust disposal transaction MUST satisfy all the following 
requirements:

#### Overall

1. The transaction MUST signal RBF replaceability (nSequence < 0xFFFFFFFE).
2. The ntimelock MUST be set to block height 0.
3. The fee rate MUST be at least 0.1 sat/vB.

#### Outputs

1. The transaction MUST have exactly one output.
2. The single output MUST be an OP_RETURN.
3. The OP_RETURN data MUST be either:
- Empty: `0x6a 0x00` (OP_RETURN OP_0), or
- The ASCII string "ash": `0x6a 0x03 0x61 0x73 0x68` (OP_RETURN 
OP_PUSHBYTES_3 "ash").

The "ash" marker MUST be used when padding is needed to meet the 65 vB 
minimum standard transaction size with a single witness input. 
Implementations MUST prefer empty OP_RETURN data when the transaction 
already meets minimum size requirements.

#### Inputs

1. All inputs MUST use the signature hash type `SIGHASH_ALL | 
SIGHASH_ANYONECANPAY` (0x81).
2. For Taproot (P2TR) inputs using key-path spending, implementations MUST 
explicitly append the signature hash type byte `SIGHASH_ALL | 
SIGHASH_ANYONECANPAY` (0x81) to enable ANYONECANPAY semantics, as the 
default sighash for Taproot (SIGHASH_DEFAULT, which omits the byte) does 
not include ANYONECANPAY.
3. All inputs must be confirmed in the blockchain at least one block deep.

#### Fees

1. The entire input value MUST go to fees (output value is zero for 
OP_RETURN).
2. The transaction fee rate MUST be at least 0.1 sat/vB to meet minimum 
relay requirements (Bitcoin Core 30.0+).
3. The transaction fee rate MAY be higher based on the available dust UTXO 
amounts and transaction size.

### Transaction Size

1. The transaction base size MUST be at least 65 bytes to meet Bitcoin 
Core's minimum relay size standardness rule.
2. If the transaction would otherwise be smaller than 65 bytes, the 
OP_RETURN value "ash" as ASCII (UTF-8) bytes (0x61, 0x73, 0x68) MUST be 
used to pad the transaction's size to 65 bytes.

### Address Consolidation Rules

Implementations consolidating dust UTXOs for a single user (i.e., not 
third-party batching services):

- MUST NOT spend dust UTXOs that were sent to different addresses in the 
same transaction.
- MUST NOT broadcast dust disposal transactions at the same time for dust 
sent to different addresses.
- SHOULD spend dust UTXOs for dust sent to the same address in one 
transaction.

### Batching Dust Disposal Transactions via RBF

Multiple unconfirmed dust disposal transactions created by unrelated 
entities MAY be batched into a single replacement transaction using 
Replace-By-Fee (RBF). This is enabled by the inputs SIGHASH_ANYONECANPAY 
signature type.

In addition to standard RBF rules, batch dust disposal transactions must 
follow all transaction construction requirements for non-batched dust 
disposal transactions.

#### Third-Party Batching

A third-party batching service for dust disposal transactions could 
compromise their users' privacy by collecting user-related network and 
timing metadata. The best practice for these services is:

1. The service MUST NOT collect pre-signed inputs directly from wallet 
users.
2. The service SHOULD collect pre-signed inputs from the public bitcoin 
network mempool.
3. The service MAY add their own UTXO inputs to improve the batch 
transaction's fee rate as long as all the requirements of this 
specification are still followed.

This mempool-based approach preserves user privacy while enabling efficient 
batching:

1. Users broadcast their individual dust disposal transactions to the 
network.
2. Batching services monitor the mempool for compliant dust disposal 
transactions.
3. Services can combine unconfirmed transactions via RBF without knowing 
user identities.

### Dust Threshold

Implementations SHOULD allow users to configure their own dust threshold 
based on:

1. The current and anticipated fee rates.
2. The dust input script type, different types have different spending 
costs.
3. The varying amounts that may be used by dust attack initiators.

A UTXO is generally considered dust if its value is less than the cost to 
spend it at a reasonable fee rate, but any small UTXO value could be used 
in a dust attack.

### Security Considerations

#### Transaction Signing

1. **Key Security**: Signing dust disposal transactions requires signing 
with the user's wallet private keys. This could be a risk for cold storage 
wallets where the key or keys needed to sign are not easily accessible.
2. **Transaction Correctness**: Transaction signers must carefully review 
and verify that only dust UTXOs are spent and no other inputs are signed.

#### Privacy Preservation

1. **Network surveillance**: Internet service providers and other internet 
monitors may be able to determine the nodes that initially broadcast a dust 
disposal transaction. If available the `sendrawtransaction 
-privatebroadcast` RPC feature should be used (available in [Bitcoin Core 
31.0](https://github.com/bitcoin-core/bitcoin-devwiki/wiki/31.0-Release-Notes-Draft#p2p-and-network-changes)).
2. **Timing Analysis**: Users should be aware that the timing of dust 
disposal transactions is publicly observable. Dust disposal transactions 
should not be broadcast at the same time or on a predictable schedule.
3. **Amount Analysis**: The specific dust amounts selected for dust 
disposal if outside the norm may be used to fingerprint the wallet creating 
the disposal transactions.

## Rationale

### Why Empty or "ash" OP_RETURN Data?

1. **Minimal Size**: Empty data (2 bytes: OP_RETURN OP_0) minimizes the 
transaction size.
2. **Standardization**: Consistent transaction construction eliminates 
wallet fingerprinting.
3. **Padding Option**: The "ash" string (5 bytes: OP_RETURN OP_PUSHBYTES_3 
"ash") provides a standardized way to meet the minimum transaction size; 
e.g., for a single P2TR dust input.
4. **Semantic Meaning**: The word "ash" metaphorically represents the 
result of "burning" the dust.

### Why Per-Address Transactions?

Consolidating dust from multiple addresses for the same wallet creates the 
same privacy harm that dust attacks attempt to achieve. By requiring wallet 
software to create separate transactions per address (by default), the 
protocol ensures dust disposal doesn't harm privacy.

### Why 65 Byte Minimum?

Bitcoin Core enforces a minimum transaction base size of 65 bytes as a 
policy rule to prevent certain attack vectors. Compliant transactions must 
meet this threshold to be relayed by standard nodes.

### Why 0.1 sat/vB Minimum Fee Rate?

[Bitcoin Core 30.0](https://bitcoincore.org/en/releases/30.0/) reduced the 
minimum relay fee rate to 0.1 sat/vB (1 sat/kvB). This allows dust UTXOs to 
be disposed of economically even when their value is very small. 
Implementations targeting earlier node versions may need higher minimum fee 
rates.

### Why SIGHASH_ALL|ANYONECANPAY?

The ANYONECANPAY flag allows additional inputs to be added to the dust 
disposal transaction after signing. This provides several benefits:

1. **Batching**: Unrelated dust disposal transactions can be found in the 
mempool and batched together via RBF.
2. **User privacy**: Transactions shared via the public mempool do not 
reveal user identity metadata.
3. **Fee Bumping**: Additional inputs can be added by unrelated third 
parties to increase the fee rate.

### Why nLockTime block height 0

1. **User privacy**: Using the same nLockTime for all dust disposal 
transactions obscures when it was created.
2. **Fee sniping**: The value of disposal transactions should be small 
enough that fee sniping is not a concern.

## Backwards Compatibility

This BIP introduces no changes to the Bitcoin consensus rules or 
peer-to-peer protocol. All transactions conforming to this specification 
are valid under existing consensus rules and can be relayed by nodes 
supporting:

- OP_RETURN outputs (Bitcoin Core 0.9.0+)
- SIGHASH_ANYONECANPAY (original Bitcoin feature)
- 0.1 sat/vB minimum relay fee (Bitcoin Core 30.0+)
- Private transaction broadcast (Bitcoin Core 31.0+)

Nodes running Bitcoin Core versions prior to 30.0 do not relay transactions 
with fee rates below 1 sat/vB which could slow the relaying of disposal 
transactions with lower fee rates.

## Reference Implementation

A reference implementation is available at: 
https://github.com/bubb1es71/ddust

The implementation provides:
- Command-line tool for creating dust disposal transactions
- Automatic dust detection based on configurable thresholds
- Transaction batching via RBF
- Support for P2PKH, P2SH, P2WPKH, P2WSH, and P2TR input descriptors
- Integration with Bitcoin Core (version 30.0+) via RPC for syncing and 
broadcasting transactions

## Test Cases

The test cases below can be used to verify a wallet disposes of dust UTXOs 
according to the specification in this BIP. 

### List dust

1. Create payment addresses for multiple address types, send dust and 
non-dust amounts to these addresses, verify that listing dust only returns 
UTXOs at or below the configured dust threshold (e.g. 1000 sats).
2. Create confirmed and unconfirmed dust UTXOs in the test wallet, verify 
listing dust only returns the confirmed dust UTXOs.

### Spending dust

All valid dust disposal transactions should be verified to be accepted into 
the bitcoind (Bitcoin Core 30.0+) mempool.

1. Spending a single witness (Bech32m/P2TR) dust UTXO must produce a dust 
disposal transaction with a single "ash" OP_RETURN output.
2. Spending multiple dust UTXOs always produces a single empty OP_RETURN 
output regardless of script type.
3. Spending a single 2-of-2 P2SH multisig dust UTXO produces a single empty 
OP_RETURN output.
4. All dust UTXOs sent to the same address are disposed of in the same 
transaction.
5. Dust disposal transactions only include confirmed dust UTXOs.

#### Example dust disposal transaction sizes

| | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
|-------------------|-------|------------|--------|-------------|-------|
| Overhead (b) | 10 | 10 | 10 | 10 | 10 | 
| Input (b) | 148 | 295 | 41 | 41 | 41 |
| OP_RETURN (b) | 11 | 11 | 14 | 14 | 14 |
| Base size (b) | 169 | 316 | 65 | 65 | 65 |
| Witness data (b) | 0 | 0 | 108 | 255 | 67 |
| Size (b) | 169 | 316 | 173 | 320 | 132 |
| Weight (wu) | 676 | 1264 | 370 | 517 | 329 |
| Virtual Size (vb) | 169 | 316 | 92.5 | 129.25 | 82.25 | 

#### Example dust disposal transaction fee rates (sats/vb)

| Input Amount | P2PKH | P2SH (2-3) | P2WPKH | P2WSH (2-3) | P2TR |
|--------------|---------|------------|--------|-------------|-------|
| 294 | 1.74 | 0.93 | 3.18 | 2.27 | 3.57 |
| 300 | 1.78 | 0.95 | 3.24 | 2.32 | 3.65 |
| 325 | 1.92 | 1.03 | 3.51 | 2.51 | 3.95 |
| 330 | 1.95 | 1.04 | 3.57 | 2.55 | 4.01 |

### Batching dust disposal txs via RBF

1. Adding a Bech32m dust input to an unconfirmed disposal transaction with 
a legacy dust input keeps the original single empty OP_RETURN output.
2. Adding a Bech32m dust input to an unconfirmed disposal transaction with 
a Bech32m dust input keeps the original single "ash" OP_RETURN output.
3. Adding a new dust input to an unconfirmed disposal transaction results 
in a new batch disposal transaction with a fee rate sufficient for RBF.
4. A new dust input that contributes an insufficient fee rate for RBF with 
an existing unconfirmed disposal transaction is not batched with it.

## Related work

* "dust-b-gone": https://github.com/petertodd/dust-b-gone
* "dusts": https://github.com/bubb1es71/dusts

## Changelog

* **0.1.0** (2026-03-22):
* Initial draft of the BIP.

## Copyright


This document is licensed under the Creative Commons CC0 1.0 Universal 
license.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/3b3328b8-bba4-4858-b53a-0e9b631044ffn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 17014 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] [Draft BIP proposal] Ladder script
@ 2026-03-16 16:10  1% defenwycke
  0 siblings, 0 replies; 200+ results
From: defenwycke @ 2026-03-16 16:10 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 8029 bytes --]

Hello list,

I'd like to introduce Ladder Script, a draft BIP proposing transaction 
version 4 with typed, structured spending conditions as an alternative to 
opcode-based Script.


*The problem it addresses*
Bitcoin Script operates on untyped stack elements. A 520-byte data push 
could be a public key, a hash preimage, a signature, or arbitrary data. 
There is no way to distinguish them structurally. This makes static 
analysis unreliable, compound conditions error-prone to construct, and 
creates a surface for data embedding through witness fields.

Adding new spending condition types requires new opcodes, each consuming 
from a finite space and requiring individual activation. There is no 
mechanism for structured extensibility.


*How it works*
The name and structure are borrowed from ladder logic, the programming 
model used in industrial PLCs (programmable logic controllers) for decades. 
In a PLC, a program is a series of rungs on a ladder. Each rung contains 
condition blocks wired in series (AND) or parallel (OR). The output 
energises when the conditions are met. It's a model designed to make 
complex conditional logic readable and composable by people who aren't 
software engineers.

Ladder Script applies the same model to Bitcoin transactions. A spending 
policy is a ladder. Each rung is a possible spending path containing one or 
more typed condition blocks (a signature check, a timelock, a hash 
verification, a covenant constraint). Blocks on the same rung are AND - all 
must be satisfied. Rungs themselves are OR - the first satisfied rung 
authorises the spend. A vault with fee-gated spending and a dead man's 
switch is three blocks on a rung.

Every byte in a Ladder Script witness belongs to a declared data type with 
enforced size constraints. You can read a transaction and see exactly what 
it requires.

The output format is MLSC (Merkelized Ladder Script Conditions): a 33-byte 
scriptPubKey (0xC2 || merkle_root) regardless of policy complexity. Only 
the exercised spending path is revealed at spend time. Unused paths stay 
hidden. The UTXO footprint is 40 bytes per entry.

The system currently defines 59 block types across 10 families: signatures, 
timelocks, hash verification, covenants, recursion, anchors, programmable 
logic controllers, compound patterns, governance constraints, and legacy 
Bitcoin transaction wrappers. New block types slot into numbered families 
without consuming opcode space.


*Notable properties*
Post-quantum signatures. FALCON-512, FALCON-1024, Dilithium3, and SPHINCS+ 
are native block types. A SCHEME field on any signature block 
routes verification to classical Schnorr or any PQ algorithm. Existing 
spending policies (multisig, vaults, covenants) use quantum-resistant keys 
with no structural changes. COSIGN allows a PQ-secured UTXO to co-sign for 
classical UTXOs, enabling incremental migration without a flag day.


*Anti-spam hardening*
Three defenses close practical data embedding surfaces: merkle_pub_key 
folds public keys into the Merkle leaf hash (no writable pubkey field in 
conditions), selective inversion prevents key-consuming blocks from being 
inverted (closes the garbage-pubkey vector), and hash lock deprecation 
removes standalone preimage blocks (closes the invertible-preimage vector).


*Wire efficiency*
Compound blocks collapse common multi-block patterns (HTLC, PTLC, 
TIMELOCKED_MULTISIG, etc.) into single blocks. Relays allow shared 
conditions across rungs without duplication. Template references let inputs 
inherit conditions from other inputs with field-level diffs, 
which significantly reduces size for batched operations.


*Programmable logic*
The PLC family brings 14 block types drawn directly from industrial 
automation: hysteresis controllers, timers, latches, counters, comparators, 
sequencers, rate limiters. State machines, approval accumulators, and 
watchdog patterns as composable blocks within the same wire format.


*Example: FALCON-512 on signet*
FALCON-512 transactions are running on the live signet today. The funding 
output is a 33-byte MLSC scriptPubKey - identical to any other Ladder 
Script output. The 897-byte public key is folded into the Merkle leaf and 
never appears in the UTXO set.

At spend time, the witness carries the full public key (897 bytes) and 
signature (~666 bytes) for a total of ~1,572 bytes, which is about 16x a 
Schnorr witness. The cost is paid at spend time only, and only for the path 
actually exercised.

The RPC interface is three calls: generatepqkeypair, createrungtx, 
signrungtx. Switching from Schnorr to any PQ scheme is a one-byte SCHEME 
field change. The same pattern works for FALCON-1024, Dilithium3, and 
SPHINCS+.


*Migration path*
Ladder Script is a soft fork. Non-upgraded nodes treat version 4 
transactions as anyone-can-spend, the same upgrade path as SegWit and 
Taproot. The proposal includes a three-phase migration model for 
coexistence with legacy transaction types:

  1. Coexistence. Both legacy Bitcoin transaction types (P2PK, P2PKH, P2SH, 
P2WPKH, P2WSH, P2TR) and Ladder Script v4 transactions are valid on-chain. 
No existing type is deprecated. Wallets choose which format to use.
  2. Legacy-in-Blocks. A Legacy block family (7 block types) wraps 
traditional Bitcoin transaction types as typed Ladder Script blocks. 
Spending semantics are identical, but all fields are typed and validated — 
no arbitrary data surfaces exist in the wrapped form. This lets wallets 
standardise on a single transaction builder while preserving full backward 
compatibility.
  3. Sunset. Raw legacy transaction formats are deprecated for new output 
creation. Only block-wrapped versions are accepted. Existing legacy UTXOs 
remain spendable under their original rules indefinitely.

Each phase is a separate activation decision. Phase 1 is the BIP itself. 
Phases 2 and 3 are future soft forks that the Legacy block family is 
designed to support, not requirements of this proposal.


*Trade-offs and open questions*
This is a large surface area change. 59 block types activate as a single 
deployment, which is a different philosophy from the incremental opcode 
approach. The argument for it is that a typed framework is extensible 
without further soft forks — the argument against is activation risk.

The PLC family pushes beyond what most people consider "transaction 
conditions." Whether timers, counters, and sequencers belong at the 
consensus layer is a legitimate question.

The three-phase migration is ambitious. Phase 1 (coexistence) is 
straightforward, but phases 2 and 3 would be among the largest consensus 
changes Bitcoin has undertaken. They're included in the design to show that 
the framework can absorb legacy semantics cleanly, not as an expectation 
that they happen soon or at all.


*Implementation*
Ladder Script is fully implemented in C++ (Bitcoin Core v30.1 fork) with 
437 unit tests and 229 functional tests, running on a dedicated signet.

BIP draft, block library, and browser-based transaction builder: 
https://bitcoinghost.org/labs/

Source: https://github.com/defenwycke/ghost-labs-ladder-script

The easiest way to understand it is to load an example in the signet 
builder and modify something.

I'm looking for feedback on the approach, the block type taxonomy, the 
activation surface, and anything I've got wrong. If you find any bugs 
please let me know. Happy to answer questions here or on X (@defenwycke).

Defenwycke

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/590f01a8-d704-4fcc-9dd2-f7c591124575n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 8522 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-02-05 22:48  0%               ` 'Antoine Poinsot' via Bitcoin Development Mailing List
@ 2026-02-12  3:57  0%                 ` Antoine Riard
  0 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-02-12  3:57 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 18942 bytes --]

Hi,

Thanks for your insightful additional comments on the BIP rational.

> Enforcing timelock validation gives us a context-independent guarantee 
when
> validating a block that no past block in the chain could possibly have 
had the
> same pair of nLockTime and nSequence.

I'm getting the general idea of the nlocktime field committing to the
current height minus one to ensure coinbase transaction uniquness and
avoids to re-activate BIP30 validation post block 1,983,702.

Where I'm diverging is on the necessity itself to have to set the
nSequence field in any fashion in my understanding due to the check
in `ContextualCheckBlock()` (L4312) and the check in `IsFinalTx()`
(L4294). The first one is ensuring that nLocktime == nHeight - 1
otherwise the coinbase transaction is rejected as invalid. The
second one is considering the transaction as final if nLocktime
to current nBlockHeight.

If a transaction is respecting the first check, i.e nLocktime ==
nHeight - 1, it is implying logicall that nLocktime < nBlockHeight
if nHeight == nBlockHeight. Unless I'm logically missing something,
post BIP54, for the case of the coinbase tx and counter-intuitively
_for the case of the coinbase only_, the inspection of its nSequence
field to determine it's final is superflous.

Said differently, with the new BIP54 check the uniqueness property
is coming from a context-dependent check ensuring that a coinbase
transaction is always set to the current heigh, and the general
validation logic (at least the one of bitcoin core) is ensuring
that this context-dependent check is done on a linearly ordered
set of block (multiple blocks can have the same ordinal index, but
it shouldn't matter for transaction uniqueness).

See more comments under.

> Technically, as per the code you point to, BIP 30 is enforced from
> genesis in Bitcoin Core with the exception of the specific blocks at
> height 91,842 and 91,880 in the historical chain."

This is correct. The pull request implementing BIP30 only applied after
March 15th 2012, and it was latter extended. Somehow, I think it was a
hardfork, as in the very hypothetical thermodynamically unlikely scenario
where you would take a genesis client and you validate a higher-PoW chain
than the historical one, you would get a fork.

Doesn't matter for the present discussion.

> He later suggested to me to also constrain the nSequence in direct 
communication,
> and i publicly shared my decision to include his suggestion in the BIP in 
the
> Consensus Cleanup thread on Delving [4], the same same thread you point 
to.
> In this post i explain the rationale for this decision, which is 
essentially
> the reasoning i presented at the beginning of this email.

Thanks for pointing me the exact location, where you mentionned it.
Initially read the AJ post of Mar. 2024, where it was first suggested
and I think this was the only rational explanation.

Quoting your own comment:

"Once (and if) the Consensus Cleanup is activated and its activation height
buried, this would give us the following property: “BIP30 validation is 
never
necessary after CC activation height”.

Rephrasing in my own words iiuc, the argument is the following by asking a
coinbase to always have its timelock and nsequence not set to final, you
ensure that the nLocktime must have been respected at the time (nLocktime
< nBlockHeight).

Post-BIP54, assuming it's activation height (I'll wawe about the 
hypothetical
situation of hard-fork as you're pointing apparently the 227,835 first 
blocks 
have been set with a nLocktime of 0), a pre-BIP54 coinbase transaction could
not create a duplicate, therefore BIP 30 validation is unecessary.

Okay, at this stage I think I agree with AJ and you on the idea of the 
rational.

However, I still hold the belief the check on the nsequence field is 
superflous,
as with BIP54 you're implementing a context-dependent check that the 
coinbase
transaction nLocktime must be exactly set to the height of the checked 
block.

If this check was assumed to have been enforced since the genesis block,
the result would be the same, you're guaranteed to have unique coinbase
(there can only be one and only one block valid for a given ordinal height
in the blockchain at any time, the blockchain is not a dag or whatever
with multiple parents) and BIP 30 should not be necessary again.

Again, the block ordering consensus rules are guaranteeing that from
the PoV of a let's say a bitcoin core client at any release, there is
only _one_ block at a given ordinal height.

> I assume you mean default Bitcoin Core mining policy here? Talking about
> network wide policy for transactions that don't get relayed is a bit 
confusing.

Yeah a mining policy of which the rational would be to preserve the sanity 
of
the nSequence field (e.g "nSequence field must be 0"). Coinbase transaction 
got
relayed by BIP152 message, but technically it's not transaction-relay.

That we keep or not the nSequence field BIP54 proposed consensus check, I 
think
it's of independent interest to keep the nSequence field clean with a 
legacy rule.

BIP141 do not require to have a witness commitment, if there are not witness
spends in the block iirc. On the other hand, it's mandatory for the coinbase
transaction to be present.

Here we would got a legacy field present in all coinbase transaction that 
could
be used to introduce a block-wide commitment structure on 31-bits.

Best,
Antoine
OTS hash: 85b441de80dc914f5b5ef15f2ea8b6f6493755b4b58840e9bf3908781ebdbca8

[0] 
https://github.com/bitcoin/bitcoin/commit/a206b0ea12eb4606b93323268fc81a4f1f952531  

Le Thursday, February 5, 2026 à 10:52:13 PM UTC, Antoine Poinsot a écrit :

> Hi,
>
> Thanks for your careful review of our BIP.
>
> There still appears to be some confusion around the rationale for also 
> constraining the nSequence,
> which suggests the explanation needs to be clearer. I’ve noted this in my 
> collected feedback for the
> BIP [0] and will restate the rationale in more detail below.
>
> The purpose of constraining the nSequence of coinbase transactions is to 
> ensure that timelock
> validation is performed. An nSequence set as final (i.e. equal to 
> 0xffffffff) allows timelock
> validation to be bypassed. Enforcing timelock validation gives us a 
> context-independent guarantee
> when validating a block that no past block in the chain could possibly 
> have had the same pair of
> nLockTime and nSequence. Therefore, assuming SHA256 isn’t broken, the txid 
> of the coinbase
> transaction in the block being validated is guaranteed to be unique.
>
> Of course, we already know that no block pre-BIP 34 activation had its 
> nLockTime set in the
> historical chain [2]. However, being able to state that post-BIP 54 
> activation no coinbase
> transaction can possibly be a duplicate is a useful reduction in 
> complexity. For instance, if BIP 54
> activation height ever gets buried in Bitcoin Core, the BIP 30 check could 
> just be disabled past
> this height instead of having to figure out if we are on a chain that 
> contains the historical BIP 34
> activation block hash [3].
>
> Hopefully this clarifies the rationale. I’ll now respond to some specific 
> points from your email.
>
> > With BIP 30, there is now a check at block validation to reject as 
> invalid any
> > block posterior to the BIP activation cutoff (March 15, 2012, 00:00 UTC) 
> [0].
>
> Technically, as per the code you point to, BIP 30 is enforced from genesis 
> in Bitcoin Core with the
> exception of the specific blocks at height 91,842 and 91,880 in the 
> historical chain.
>
> > the only implicit mentioning I'm seeing of this problem, is here [3], it 
> doesn't seem it has been
> > very peer reviewed, less even said to be documented in the BIP rational 
> or the implementation.
>
> Your point that the BIP and code documentation could expand on this aspect 
> is well taken. However it
> is incorrect to say it's only been mentioned implicitly by AJ in this 
> comment. He later suggested to
> me to also constrain the nSequence in direct communication, and i publicly 
> shared my decision to
> include his suggestion in the BIP in the Consensus Cleanup thread on 
> Delving [4], the same same
> thread you point to. In this post i explain the rationale for this 
> decision, which is essentially
> the reasoning i presented at the beginning of this email.
>
> Furthermore, the BIP also explicitly gives this rationale. It reads "There 
> are multiple ways of
> achieving this, but setting and enforcing the timelock for the coinbase 
> transaction makes it so all
> coinbase transactions past Consensus Cleanup activation could not have 
> been valid before this height
> and therefore cannot be a duplicate." And then it links to a footnote that 
> goes into greater details
> about timelock enforcement: "Technically it could be argued a duplicate 
> could in principle always be
> possible before block 31,001 when nLockTime enforcement was originally 
> soft-forked. But treating
> coinbase transactions as not having duplicate past Consensus Cleanup 
> activation would be consistent
> for any implementation which enforces nLockTime from the genesis block, 
> which is the behaviour
> notably of Bitcoin Core but also of all other implementations the authors 
> are aware of."
>
> > And therefore, the nSequence field can be preserved as future extranonce 
> (-- while it would be
> > still worthy to have a network-wide policy rule to avoid intempestive 
> usage of the field).
>
> I assume you mean default Bitcoin Core mining policy here? Talking about 
> network wide policy for
> transactions that don't get relayed is a bit confusing.
>
> Best,
> Antoine
>
> [0]: 
> https://github.com/bitcoin-inquisition/bitcoin/pull/99#discussion_r2636788599
> [1]: https://github.com/bitcoin/bips/pull/2015#issuecomment-3773345379
> [2]: In fact, the nLockTime of all coinbase transactions in the 227,835 
> first blocks in the
> historical chain are all set to 0.
> [3]: 
> https://github.com/bitcoin/bitcoin/blob/28d860788286ec31981f5509a8cbe6a9ba4cddc5/src/validation.cpp#L2391-L2461
> [4]: https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/79
>
>
> On Thursday, January 29th, 2026 at 11:13 PM, Antoine Riard <
> antoin...@gmail.com> wrote:
>
> > Hi,
> > 
> > > "that giving meaning to the coinbase transaction nLockTime is 
> undesirable"
> > 
> > On the rational of asking the block height to be in the coinbase's 
> nLocktime,
> > to enforce coinbase uniqueness in a post-BIP34-implies-BIP30-limit (i.e 
> height
> > = 1,983,702), I think there is a point that would be valuable to clarify 
> and
> > that is not documented in the BIP.
> > 
> > Let's remind the problem solved with BIP 30. Originally, since genesis, 
> coinbase
> > and spending transactions identifiers were able to be duplicated. That 
> means,
> > accidentally, an ulterior coinbase transaction was able to overwrite an 
> unspent
> > coinbase tx. E.g, if you have block N=50 with coinbase tx_id=0xbeef and 
> if this
> > transaction is unspent at block=100, a miner could generate a block with 
> coinbase
> > tx_id=0xbeef _again_ and erase the coinbase output included in an 
> anterior block.
> > 
> > With BIP 30, there is now a check at block validation to reject as 
> invalid any
> > block posterior to the BIP activation cutoff (March 15, 2012, 00:00 UTC) 
> [0].
> > This uniqueness validation has been then enhanced with BIP34, of which 
> the two
> > problems it aims to solve was to introduce a network-wide mechanism to 
> upgrade
> > blocks and transactions and enforce block and coinbase uniqueness. 
> Solving the
> > second problem is a partially overlapping set of the BIP 30 implemented 
> solution
> > [1].
> > 
> > However, and what is the motivation for including the block height in 
> the coinbase
> > transaction as part of the BIP54 consensus cleanup, there are some 
> pre-BIP34
> > activation height coinbase transactions of which the BIP34 solution, i.e 
> requiring
> > a CSscriptSig to commit to the block height, are violating historically 
> violating
> > said solution [2]. Therefore no optimized validation could be done in 
> the future for
> > those BIP-34 historical transactions and BIP54, by mandating another 
> uniqueness
> > mechanism than the BIP34 one, would allow to get rid off the BIP30 
> forever.
> > 
> > Problem, and that's where the BIP54 document and its implementation is 
> silent,
> > there is the potential issue of historical BIP34-violating coinbase 
> transactions
> > (i.e with a CScriptNum[..] = 1,983,702+) where the nLocktime field has a 
> value
> > equal or superiror to the "post-BIP54 activation height". While coinbase 
> finality
> > has always been enforced, if the coinbase's unique nSequence field is 
> set to
> > CTxIn::SequenceFinal, the nLocktime should be ignored (see `IsFinal()`'s 
> code
> > comment "in which case nLocktime is ignored").
> > 
> > While, I have no checked yet if the behavior always hold on all version 
> of the code
> > (it's all `ContextualCheckBlock()`), the only implicit mentioning I'm 
> seeing of
> > this problem, is here [3], it doesn't seem it has been very peer 
> reviewed, less
> > even said to be documented in the BIP rational or the implementation.
> > 
> > Present coinbase uniqueness implementation asks for the nSequence field 
> to be
> > also set to SequenceFinal, but given the goal is coinbase uniqueness 
> (and not
> > timelock semantics, as it would be for any other transaction), I don't 
> believe
> > it's necessary to set the sequence field to final. And therefore, the 
> nSequence
> > field can be preserved as future extranonce (-- while it would be still 
> worthy
> > to have a network-wide policy rule to avoid intempestive usage of the 
> field).
> > 
> > For where encoding the uniqueness of the coinbase and the arguments that
> > have been raised so far in the thread, I'm still favoring the coinbase 
> over
> > the additional op_return field, nLocktime is already a mandatory 
> transaction
> > field so it's more information-theoretic space efficient. As I was 
> raising in
> > a previous comment, I don't think there is an additional risk of 
> cryptoeconomic
> > kind of attack, where the coinbase time finality could be used, it's 
> already
> > implicitly possible for all post-BIP34 coinbase transactions.
> > 
> > Best,
> > Antoine
> > OTS hash: 
> f4d42a800a2b6672609b48097a25d961840d7b91cfc5e9caffff65ecd7533dd5
> > 
> > [0] bitcoin-inquistion, commit 8d513a0, validation.cpp L2591
> > [1] bitcoin-inquisition, commit 8d513a0, validation.cpp L4300
> > [2] bitcoin-inquisition, commit 8d513a0, validation.cpp L2554
> > [3] https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/6
> > Le Wednesday, January 14, 2026 à 6:59:48 PM UTC, Murch a écrit :
> > 
> > > Ah right, the Merkle root is calculated based on the stripped
> > > transaction, and therefore AJ’s idea works fine. Nevermind, carry on!
> > > 
> > > Thanks,
> > > Murch
> > > 
> > > On 2026-01-14 07:33, Antoine Poinsot wrote:
> > > > Thanks everyone for the comments.
> > > >
> > > > Sjors, transactions are serialized in modern blocks as described by 
> Murch.
> > > >
> > > > Murch, for the purpose of computing the Merkle root transactions are 
> serialized without witness data.
> > > >
> > > > Best,
> > > > Antoine
> > > >
> > > >
> > > >
> > > > On Wednesday, January 14th, 2026 at 5:23 AM, Sjors Provoost <
> sj...@sprovoost.nl> wrote:
> > > >
> > > >> Hi Murch,
> > > >>
> > > >> You're referring to the "serialization with witness data" defined 
> in BIP 141.
> > > >>
> > > >> But that's not how the transaction is serialised in a block, since 
> the witness is
> > > >> segregated.
> > > >>
> > > >>> The witness is committed in a tree that is nested into the block's 
> existing
> > > >> merkle root via the coinbase transaction for the purpose of making 
> this BIP
> > > >> soft fork compatible. A future hard fork can place this tree in its 
> own branch.
> > > >>
> > > >> As long as the miner doesn't touch the SegWit OP_RETURN , which 
> also commits
> > > >> to the coinbase witness, it can safely use the legacy transaction 
> serialisation.
> > > >>
> > > >> - Sjors
> > > >>
> > > >> [0] 
> https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id
> > > >>
> > > >>> Op 14 jan 2026, om 01:23 heeft Murch mu...@murch.one het volgende 
> geschreven:
> > > >>>
> > > >>> Hi Sjors,
> > > >>>
> > > >>> On 2026-01-08 00:30, Sjors Provoost wrote:
> > > >>>
> > > >>>> The approach suggested by Towns [4] of appending a 0-sat 
> OP_RETURN output with
> > > >>>> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk 
> is probably
> > > >>>> better, but not because like nLockTime it has a small hashing 
> midstate
> > > >>>> benefit. It's easier to implement.
> > > >>>> I can’t access Delving right now to read AJ’s comment, but a 
> small nit on the idea of using an additional output: BIP 141 requires 
> coinbase transaction inputs to have a 32-byte witness. Since the witness 
> section follows the outputs in the serialization, the bytes before the 
> `nLocktime` in a coinbase transaction are the witness of the coinbase 
> input, not the last output script.
> > > >>> -Murch
> > > >> --
> > > >> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > > >> To unsubscribe from this group and stop receiving emails from it, 
> send an email to bitcoindev+...@googlegroups.com.
> > > >> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl
> .
> > 
> > --
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/e758af9b-72fc-4fdd-8e07-e1126635780an%40googlegroups.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1922c72f-3288-42b4-b5ad-9757440348c5n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 23927 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-30  4:08  1%             ` Antoine Riard
@ 2026-02-05 22:48  0%               ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  2026-02-12  3:57  0%                 ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2026-02-05 22:48 UTC (permalink / raw)
  To: Antoine Riard; +Cc: Bitcoin Development Mailing List

Hi,

Thanks for your careful review of our BIP.

There still appears to be some confusion around the rationale for also constraining the nSequence,
which suggests the explanation needs to be clearer. I’ve noted this in my collected feedback for the
BIP [0] and will restate the rationale in more detail below.

The purpose of constraining the nSequence of coinbase transactions is to ensure that timelock
validation is performed. An nSequence set as final (i.e. equal to 0xffffffff) allows timelock
validation to be bypassed. Enforcing timelock validation gives us a context-independent guarantee
when validating a block that no past block in the chain could possibly have had the same pair of
nLockTime and nSequence. Therefore, assuming SHA256 isn’t broken, the txid of the coinbase
transaction in the block being validated is guaranteed to be unique.

Of course, we already know that no block pre-BIP 34 activation had its nLockTime set in the
historical chain [2]. However, being able to state that post-BIP 54 activation no coinbase
transaction can possibly be a duplicate is a useful reduction in complexity. For instance, if BIP 54
activation height ever gets buried in Bitcoin Core, the BIP 30 check could just be disabled past
this height instead of having to figure out if we are on a chain that contains the historical BIP 34
activation block hash [3].

Hopefully this clarifies the rationale. I’ll now respond to some specific points from your email.

> With BIP 30, there is now a check at block validation to reject as invalid any
> block posterior to the BIP activation cutoff (March 15, 2012, 00:00 UTC) [0].

Technically, as per the code you point to, BIP 30 is enforced from genesis in Bitcoin Core with the
exception of the specific blocks at height 91,842 and 91,880 in the historical chain.

> the only implicit mentioning I'm seeing of this problem, is here [3], it doesn't seem it has been
> very peer reviewed, less even said to be documented in the BIP rational or the implementation.

Your point that the BIP and code documentation could expand on this aspect is well taken. However it
is incorrect to say it's only been mentioned implicitly by AJ in this comment. He later suggested to
me to also constrain the nSequence in direct communication, and i publicly shared my decision to
include his suggestion in the BIP in the Consensus Cleanup thread on Delving [4], the same same
thread you point to. In this post i explain the rationale for this decision, which is essentially
the reasoning i presented at the beginning of this email.

Furthermore, the BIP also explicitly gives this rationale. It reads "There are multiple ways of
achieving this, but setting and enforcing the timelock for the coinbase transaction makes it so all
coinbase transactions past Consensus Cleanup activation could not have been valid before this height
and therefore cannot be a duplicate." And then it links to a footnote that goes into greater details
about timelock enforcement: "Technically it could be argued a duplicate could in principle always be
possible before block 31,001 when nLockTime enforcement was originally soft-forked. But treating
coinbase transactions as not having duplicate past Consensus Cleanup activation would be consistent
for any implementation which enforces nLockTime from the genesis block, which is the behaviour
notably of Bitcoin Core but also of all other implementations the authors are aware of."

> And therefore, the nSequence field can be preserved as future extranonce (-- while it would be
> still worthy to have a network-wide policy rule to avoid intempestive usage of the field).

I assume you mean default Bitcoin Core mining policy here? Talking about network wide policy for
transactions that don't get relayed is a bit confusing.

Best,
Antoine

[0]: https://github.com/bitcoin-inquisition/bitcoin/pull/99#discussion_r2636788599
[1]: https://github.com/bitcoin/bips/pull/2015#issuecomment-3773345379
[2]: In fact, the nLockTime of all coinbase transactions in the 227,835 first blocks in the
historical chain are all set to 0.
[3]: https://github.com/bitcoin/bitcoin/blob/28d860788286ec31981f5509a8cbe6a9ba4cddc5/src/validation.cpp#L2391-L2461
[4]: https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/79


On Thursday, January 29th, 2026 at 11:13 PM, Antoine Riard <antoine.riard@gmail.com> wrote:

> Hi,
> 
> > "that giving meaning to the coinbase transaction nLockTime is undesirable"
> 
> On the rational of asking the block height to be in the coinbase's nLocktime,
> to enforce coinbase uniqueness in a post-BIP34-implies-BIP30-limit (i.e height
> = 1,983,702), I think there is a point that would be valuable to clarify and
> that is not documented in the BIP.
> 
> Let's remind the problem solved with BIP 30. Originally, since genesis, coinbase
> and spending transactions identifiers were able to be duplicated. That means,
> accidentally, an ulterior coinbase transaction was able to overwrite an unspent
> coinbase tx. E.g, if you have block N=50 with coinbase tx_id=0xbeef and if this
> transaction is unspent at block=100, a miner could generate a block with coinbase
> tx_id=0xbeef _again_ and erase the coinbase output included in an anterior block.
> 
> With BIP 30, there is now a check at block validation to reject as invalid any
> block posterior to the BIP activation cutoff (March 15, 2012, 00:00 UTC) [0].
> This uniqueness validation has been then enhanced with BIP34, of which the two
> problems it aims to solve was to introduce a network-wide mechanism to upgrade
> blocks and transactions and enforce block and coinbase uniqueness. Solving the
> second problem is a partially overlapping set of the BIP 30 implemented solution
> [1].
> 
> However, and what is the motivation for including the block height in the coinbase
> transaction as part of the BIP54 consensus cleanup, there are some pre-BIP34
> activation height coinbase transactions of which the BIP34 solution, i.e requiring
> a CSscriptSig to commit to the block height, are violating historically violating
> said solution [2]. Therefore no optimized validation could be done in the future for
> those BIP-34 historical transactions and BIP54, by mandating another uniqueness
> mechanism than the BIP34 one, would allow to get rid off the BIP30 forever.
> 
> Problem, and that's where the BIP54 document and its implementation is silent,
> there is the potential issue of historical BIP34-violating coinbase transactions
> (i.e with a CScriptNum[..] = 1,983,702+) where the nLocktime field has a value
> equal or superiror to the "post-BIP54 activation height". While coinbase finality
> has always been enforced, if the coinbase's unique nSequence field is set to
> CTxIn::SequenceFinal, the nLocktime should be ignored (see `IsFinal()`'s code
> comment "in which case nLocktime is ignored").
> 
> While, I have no checked yet if the behavior always hold on all version of the code
> (it's all `ContextualCheckBlock()`), the only implicit mentioning I'm seeing of
> this problem, is here [3], it doesn't seem it has been very peer reviewed, less
> even said to be documented in the BIP rational or the implementation.
> 
> Present coinbase uniqueness implementation asks for the nSequence field to be
> also set to SequenceFinal, but given the goal is coinbase uniqueness (and not
> timelock semantics, as it would be for any other transaction), I don't believe
> it's necessary to set the sequence field to final. And therefore, the nSequence
> field can be preserved as future extranonce (-- while it would be still worthy
> to have a network-wide policy rule to avoid intempestive usage of the field).
> 
> For where encoding the uniqueness of the coinbase and the arguments that
> have been raised so far in the thread, I'm still favoring the coinbase over
> the additional op_return field, nLocktime is already a mandatory transaction
> field so it's more information-theoretic space efficient. As I was raising in
> a previous comment, I don't think there is an additional risk of cryptoeconomic
> kind of attack, where the coinbase time finality could be used, it's already
> implicitly possible for all post-BIP34 coinbase transactions.
> 
> Best,
> Antoine
> OTS hash: f4d42a800a2b6672609b48097a25d961840d7b91cfc5e9caffff65ecd7533dd5
> 
> [0] bitcoin-inquistion, commit 8d513a0, validation.cpp L2591
> [1] bitcoin-inquisition, commit 8d513a0, validation.cpp L4300
> [2] bitcoin-inquisition, commit 8d513a0, validation.cpp L2554
> [3] https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/6
> Le Wednesday, January 14, 2026 à 6:59:48 PM UTC, Murch a écrit :
> 
> > Ah right, the Merkle root is calculated based on the stripped
> > transaction, and therefore AJ’s idea works fine. Nevermind, carry on!
> > 
> > Thanks,
> > Murch
> > 
> > On 2026-01-14 07:33, Antoine Poinsot wrote:
> > > Thanks everyone for the comments.
> > >
> > > Sjors, transactions are serialized in modern blocks as described by Murch.
> > >
> > > Murch, for the purpose of computing the Merkle root transactions are serialized without witness data.
> > >
> > > Best,
> > > Antoine
> > >
> > >
> > >
> > > On Wednesday, January 14th, 2026 at 5:23 AM, Sjors Provoost <sj...@sprovoost.nl> wrote:
> > >
> > >> Hi Murch,
> > >>
> > >> You're referring to the "serialization with witness data" defined in BIP 141.
> > >>
> > >> But that's not how the transaction is serialised in a block, since the witness is
> > >> segregated.
> > >>
> > >>> The witness is committed in a tree that is nested into the block's existing
> > >> merkle root via the coinbase transaction for the purpose of making this BIP
> > >> soft fork compatible. A future hard fork can place this tree in its own branch.
> > >>
> > >> As long as the miner doesn't touch the SegWit OP_RETURN , which also commits
> > >> to the coinbase witness, it can safely use the legacy transaction serialisation.
> > >>
> > >> - Sjors
> > >>
> > >> [0] https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id
> > >>
> > >>> Op 14 jan 2026, om 01:23 heeft Murch mu...@murch.one het volgende geschreven:
> > >>>
> > >>> Hi Sjors,
> > >>>
> > >>> On 2026-01-08 00:30, Sjors Provoost wrote:
> > >>>
> > >>>> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
> > >>>> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
> > >>>> better, but not because like nLockTime it has a small hashing midstate
> > >>>> benefit. It's easier to implement.
> > >>>> I can’t access Delving right now to read AJ’s comment, but a small nit on the idea of using an additional output: BIP 141 requires coinbase transaction inputs to have a 32-byte witness. Since the witness section follows the outputs in the serialization, the bytes before the `nLocktime` in a coinbase transaction are the witness of the coinbase input, not the last output script.
> > >>> -Murch
> > >> --
> > >> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > >> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > >> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl.
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/e758af9b-72fc-4fdd-8e07-e1126635780an%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/0Gc3rCZzaVbzL88b9G3EDjXdayArs8JtirCO2nmmMVLDgbxovIEu7-hhQp0G4wPnEB3YABywEppEFbC-zSudJUiR7HW680kM6LWtHDmp_Hc%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-14 18:58  0%           ` Murch
@ 2026-01-30  4:08  1%             ` Antoine Riard
  2026-02-05 22:48  0%               ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-01-30  4:08 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 7382 bytes --]

Hi,

> "that giving meaning to the coinbase transaction nLockTime is undesirable"

On the rational of asking the block height to be in the coinbase's 
nLocktime,
to enforce coinbase uniqueness in a post-BIP34-implies-BIP30-limit (i.e 
height
= 1,983,702), I think there is a point that would be valuable to clarify and
that is not documented in the BIP.

Let's remind the problem solved with BIP 30. Originally, since genesis, 
coinbase
and spending transactions identifiers were able to be duplicated. That 
means,
accidentally, an ulterior coinbase transaction was able to overwrite an 
unspent
coinbase tx. E.g, if you have block N=50 with coinbase tx_id=0xbeef and if 
this
transaction is unspent at block=100, a miner could generate a block with 
coinbase
tx_id=0xbeef _again_ and erase the coinbase output included in an anterior 
block.

With BIP 30, there is now a check at block validation to reject as invalid 
any
block posterior to the BIP activation cutoff (March 15, 2012, 00:00 UTC) 
[0].
This uniqueness validation has been then enhanced with BIP34, of which the 
two
problems it aims to solve was to introduce a network-wide mechanism to 
upgrade
blocks and transactions and enforce block and coinbase uniqueness. Solving 
the
second problem is a partially overlapping set of the BIP 30 implemented 
solution
[1].

However, and what is the motivation for including the block height in the 
coinbase
transaction as part of the BIP54 consensus cleanup, there are some pre-BIP34
activation height coinbase transactions of which the BIP34 solution, i.e 
requiring
a CSscriptSig to commit to the block height, are violating historically 
violating
said solution [2]. Therefore no optimized validation could be done in the 
future for
those BIP-34 historical transactions and BIP54, by mandating another 
uniqueness
mechanism than the BIP34 one, would allow to get rid off the BIP30 forever.

Problem, and that's where the BIP54 document and its implementation is 
silent,
there is the potential issue of historical BIP34-violating coinbase 
transactions
(i.e with a CScriptNum[..] = 1,983,702+) where the nLocktime field has a 
value
equal or superiror to the "post-BIP54 activation height". While coinbase 
finality
has always been enforced, if the coinbase's unique nSequence field is set to
CTxIn::SequenceFinal, the nLocktime should be ignored (see `IsFinal()`'s 
code
comment "in which case nLocktime is ignored").

While, I have no checked yet if the behavior always hold on all version of 
the code
(it's all `ContextualCheckBlock()`), the only implicit mentioning I'm 
seeing of
this problem, is here [3], it doesn't seem it has been very peer reviewed, 
less
even said to be documented in the BIP rational or the implementation.

Present coinbase uniqueness implementation asks for the nSequence field to 
be
also set to SequenceFinal, but given the goal is coinbase uniqueness (and 
not
timelock semantics, as it would be for any other transaction), I don't 
 believe
it's necessary to set the sequence field to final. And therefore, the 
nSequence
field can be preserved as future extranonce (-- while it would be still 
worthy
to have a network-wide policy rule to avoid intempestive usage of the 
field).

For where encoding the uniqueness of the coinbase and the arguments that
have been raised so far in the thread, I'm still favoring the coinbase over
the additional op_return field, nLocktime is already a mandatory transaction
field so it's more information-theoretic space efficient. As I was raising 
in
a previous comment, I don't think there is an additional risk of 
cryptoeconomic
kind of attack, where the coinbase time finality could be used, it's already
implicitly possible for all post-BIP34 coinbase transactions.

Best,
Antoine
OTS hash: f4d42a800a2b6672609b48097a25d961840d7b91cfc5e9caffff65ecd7533dd5

[0] bitcoin-inquistion, commit 8d513a0, validation.cpp L2591
[1] bitcoin-inquisition, commit 8d513a0, validation.cpp L4300
[2] bitcoin-inquisition, commit 8d513a0, validation.cpp L2554
[3] https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/6
Le Wednesday, January 14, 2026 à 6:59:48 PM UTC, Murch a écrit :

> Ah right, the Merkle root is calculated based on the stripped 
> transaction, and therefore AJ’s idea works fine. Nevermind, carry on!
>
> Thanks,
> Murch
>
> On 2026-01-14 07:33, Antoine Poinsot wrote:
> > Thanks everyone for the comments.
> >
> > Sjors, transactions are serialized in modern blocks as described by 
> Murch.
> >
> > Murch, for the purpose of computing the Merkle root transactions are 
> serialized without witness data.
> >
> > Best,
> > Antoine
> >
> >
> >
> > On Wednesday, January 14th, 2026 at 5:23 AM, Sjors Provoost <
> sj...@sprovoost.nl> wrote:
> >
> >> Hi Murch,
> >>
> >> You're referring to the "serialization with witness data" defined in 
> BIP 141.
> >>
> >> But that's not how the transaction is serialised in a block, since the 
> witness is
> >> segregated.
> >>
> >>> The witness is committed in a tree that is nested into the block's 
> existing
> >> merkle root via the coinbase transaction for the purpose of making this 
> BIP
> >> soft fork compatible. A future hard fork can place this tree in its own 
> branch.
> >>
> >> As long as the miner doesn't touch the SegWit OP_RETURN , which also 
> commits
> >> to the coinbase witness, it can safely use the legacy transaction 
> serialisation.
> >>
> >> - Sjors
> >>
> >> [0] 
> https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id
> >>
> >>> Op 14 jan 2026, om 01:23 heeft Murch mu...@murch.one het volgende 
> geschreven:
> >>>
> >>> Hi Sjors,
> >>>
> >>> On 2026-01-08 00:30, Sjors Provoost wrote:
> >>>
> >>>> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN 
> output with
> >>>> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is 
> probably
> >>>> better, but not because like nLockTime it has a small hashing midstate
> >>>> benefit. It's easier to implement.
> >>>> I can’t access Delving right now to read AJ’s comment, but a small 
> nit on the idea of using an additional output: BIP 141 requires coinbase 
> transaction inputs to have a 32-byte witness. Since the witness section 
> follows the outputs in the serialization, the bytes before the `nLocktime` 
> in a coinbase transaction are the witness of the coinbase input, not the 
> last output script.
> >>> -Murch
> >> --
> >> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> >> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> >> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/e758af9b-72fc-4fdd-8e07-e1126635780an%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 9237 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2026-01-19  1:11  4%                 ` Pepe Hodler
@ 2026-01-23  3:45  1%                   ` Chris Riley
  2026-01-23 13:55  4%                   ` Galois Field
  1 sibling, 0 replies; 200+ results
From: Chris Riley @ 2026-01-23  3:45 UTC (permalink / raw)
  To: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 28809 bytes --]

Hi,

The issue with defining all non-monetary data as spam is that it eliminates
functionality Bitcoin has relied on since inception. Bitcoin was designed
from v0.1 as a distributed timestamp server and ordering system, not solely
as a payment processor. The genesis block contains non-monetary data, and
early Proof-of-Existence uses pre-dated OP_RETURN.

Time-locked contracts (nLockTime) have existed since v0.1 and underpin
CLTV/CSV-based constructions, including the Lightning Network, DLCs, and
off-chain adjudication. Sidechain anchoring and systems like
OpenTimestamps depend
on Bitcoin’s immutability as a distributed order of events. Protocol
upgrades themselves rely on non-monetary signaling via version bits and
miner flags.

As stated in the whitepaper, the proof-of-work chain is a solution to
distributed timestamping and majority decision-making. Monetary
transactions depend on this ordering. If all non-monetary data is defined
as spam, Bitcoin cannot function as Bitcoin. The opcodes in v0.1 clearly
show that it was intended to do more than "Send X from A->B"-and they
weren't disabled due to philosophical opposition, but DOS, consensus etc
concerns.  Please note, this does not imply that bulk data storage belongs
on L1, merely that "spam is easy to define as anything non-monetary" isn't
as easy as one might think.

Have a good one :-)

On Thu, Jan 22, 2026 at 4:54 PM Pepe Hodler <pepehodler@gmail.com> wrote:

> Hi list.
>
> Which brings me to my disagreement, which I know is not shared by a number
> of contributors here: just as it is hard to define spam on Bitcoin
>
> I don't understand how anyone could be confused about the concept of spam
> on bitcoin. Bitcoins is "A Peer-to-Peer Electronic Cash System" according
> to the white paper. As such, anything not intended as a monetary
> transaction is spam.
>
> The use of fake pubkeys to store data on chain, that is an unsupported and
> unsanctioned use of bitcoin. That is spam, and an attack, not a monetary
> transaction.
>
> Same with fake scripthash used to store arbitrary data, unsupported and
> unsanctioned use of bitcoin. That is spam, and an attack, not a monetary
> transaction.
>
> And the same goes for the Segwit exploit and the Taproot exploit. That is
> exploiting bitcoin to store arbitrary data in an unsanctioned way, spam, an
> attack on bitcoin.
>
> When Segwit and Taproot were implemented, nobody, absolutely nobody was
> welcoming those upgrades as a way to store jpegs and other garbage on
> chain. That is not what bitcoin, Segwit, and Taproot were built for.
>
> If you are making use of OpenRelay and/or SlipStream to bypass the policy
> of the majority of nodes, you are a spammer and an attacker, not a bitcoiner.
> You are trying to skirt the only use case of bitcoin.
>
> When there are blocks like this one:
> https://mempool.space/block/00000000000000000000ed962f87a0c350b1401fe546db60e6d78e34ab549378 .
> Over 60% of the transactions in that block are not sending or receiving a
> single sat. It's all op_returns with no sats in them. That is not what
> bitcoin was designed or sanctioned for.
>
> These people are not users, they are attackers and spammers. How can you
> look at inscriptions, runes, ordinals, fake pubkeys, fake scripthash,
> stamps, and op_return with 0 sats in them and wonder if those are legit
> bitcoin monetary transactions?
> Now, some have tried to claim "My ordinal is a consensus valid
> transaction". And of course it is, otherwise it would not have been added
> to a block. But that's like saying the Nigerian prince email followed all
> the SMTP and POP protocols of email, therefore it's not spam.  Some spam
> defenders have tried to claim they have paid their miner fee. Of course
> they did, but that's like saying the sender of the Nigerian prince email
> paid his internet, therefore it's not spam.
>
> If you are confused about what constitutes spam on bitcoin, please
> explain. While I'm sure there are some transactions that could be tricky
> and controversial to identify as spam, I"m sure we can all agree that
> inscriptions, stamps, jpegs, fake pubkeys, fake scripthash, unusually large
> Segwit data, ordinals, runes, etc, are all clearly spam.
>
> it's also very hard to define it in a discussion forum like this one.
>
>
> I just did it, see above. It really wasn't that hard. How are you confused
> about the definition of spam as it pertains to bitcoin? Because bitcoin is
> money, they have to obfuscate their spam to make it look like a legitimate
> monetary transaction to the system. So you could make the case that it's
> harder to distinguish spam from a real monetary transaction. But defining
> spam on it's own is pretty easy.
>
> But ultimately, it does not belong to devs to decide what is spam. Don't
> think that just because we know C++, that somehow gives us authority to
> decide what direction bitcoin should be taking, and what spam is.
>
> That decision belongs to the nodes. And it's clear that the nodes are not
> given the tools to decide for themselves what spam is or what spam isn't,
> with comprehensive user configurable spam filters.
>
> Notions of motivation of contributors (such as they are paid by such and
> such a company) should not be relevant.
>
>
> Are you suggesting that conflict of interest is not a thing? If someone is
> advocating against any and all measures against spam, I would really like
> to know where their interests lie.
>
> Everything should be open to discussion which is implementation-technical
> (so obviously not e.g. threats of violence or things that bring legal
> liability to participants or have zero relevance to Bitcoin's technical
> development) even if it's philosophy-motivated. And blocking should be
> reserved either as an anti-DOS measure if volume gets out of control, or if
> it brings dangers as per the previous parenthetical.
>
>
> This comes across as a thinly veiled attempt to censor anyone who wants to
> combat spam, and their employees/employers. This idea of censoring
> "confiscatory" proposals never came up when someone proposed confiscation
> though what he called "demorage" or when someone proposed seizing Satoshi's
> coin.
>
> If you want to buy or sell pancakes, or JPEgs, or anything else for that
> matter, bitcoin is here to serve you. But your pancakes and your JPEGs
> don't belong on the bitcoin chain.
>
> Disclaimer: I own bitcoin, I run a bitcoin business in El Salvador. I own
> no inscriptions or spam of any kind, and I don't profit from any spam
> related companies.
>
> 40% of the UTXO set is dust spam UTXOs that contains less than 0.0017% of
> the total bitcoin issued. This constitutes an attack on bitcoin. I think we
> all should start acknowledging the problem, and stop asking ourselves
> dismissive questions like "What is spam anyways?" and use that question as
> an excuse to pretend there is no problem.
>
> Cheers, Pepe
>
>
>
> On Tuesday, 30 December 2025 at 08:51:56 UTC-6 Antoine Riard wrote:
>
> Hi list,
>
> > Which brings me to my disagreement, which I know is not shared by a
> number of contributors here: just as it is hard to define spam on Bitcoin,
> it's also very hard to define it in a discussion forum like this one.
> Making suggestions which *I* think are terrible, or detrimental, on a list
> like this, should never be disallowed here. Notions of motivation of
> contributors (such as they are paid by such and such a company) should not
> be relevant. Everything should be open to discussion which is
> implementation-technical (so obviously not e.g. threats of violence or
> things that bring legal liability to participants or have zero relevance to
> Bitcoin's technical development) even if it's philosophy-motivated. And
> blocking should be reserved either as an anti-DOS measure if volume gets
> out of control, or if it brings dangers as per the previous parenthetical.
>
> I'm fully sharing waxwing reasonable opinion. While I can understand
> gmax's sentiment being fed
> up with poor coin confiscation proposals again and again on the mailing
> list, the cure would be
> worst than the disease. Maybe, I'm very voltairean here, but you don't
> fight ill-founded opinions.
> by persecuting their authors (--otherwise, down the road you take the risk
> of seeing the bastille
> popped up). Rather than you fight them back by doing the work to persuade
> and to convince those
> ideas you find stupid are indeed *objectively* stupid.
>
> To me, it's a sign of strength and confidence that Bitcoin and its
> development process can
> withstand and endure the most "outrageous" controversies. For sure, I have
> been enough times
> in the shoes of someone who has to champion controversial changes (cf.
> `mempoolfullrbf`) to not
> negate that the strength of the process is kinda traded on the back of the
> devs, but this is not
> altering my mind on what I think should be *ideally* the development
> process in terms of openess
> and publicity.
>
> My humble opinion only, as we said.
>
> Best,
> Antoine
> OTS hash: 5c1c19f589a61787dbf483cd6814f094c3b24888d6d189c5f4d776bda558e1ce
> Le mercredi 24 décembre 2025 à 17:23:48 UTC, waxwing/ AdamISZ a écrit :
>
> Hi Greg, list:
>
> > I think the list should adopt a 1 year ban on parties *and their*
> employer(s) (if known) for any coin confiscation proposal on the list going
> forward (after, of course, making the rule clear on the signup page).  It's
> tiresome and beyond being a waste of time risks undermining public
> confidence in Bitcoin to see the constant trickle of these
> outrageous proposals in venues where they previously understood that
> serious discussions were to be had. People are, of course, free to discuss
> whatever ill-founded concepts they want but they're not entitled to the
> time and the reputation of the participants here for offensively misguided
> proposals.
>
> I'm a huge agree-er with the motivation of this comment and a huge
> disagree-er with the suggestion itself.
>
> Actual confiscation, whatever the reason, hugely undermines Bitcoin's
> value to humanity - note I am not saying its financial value, but value as
> a project (and if we didn't see such value what the hell are we doing
> here). Of course those two types of value are very closely linked, but they
> are still distinct. I hold that same belief even when we are talking about
> other suggestions of confiscation, such as to address a quantum threat -
> something that has recently been discussed here, extensively.
>
> Which brings me to my disagreement, which I know is not shared by a number
> of contributors here: just as it is hard to define spam on Bitcoin, it's
> also very hard to define it in a discussion forum like this one. Making
> suggestions which *I* think are terrible, or detrimental, on a list like
> this, should never be disallowed here. Notions of motivation of
> contributors (such as they are paid by such and such a company) should not
> be relevant. Everything should be open to discussion which is
> implementation-technical (so obviously not e.g. threats of violence or
> things that bring legal liability to participants or have zero relevance to
> Bitcoin's technical development) even if it's philosophy-motivated. And
> blocking should be reserved either as an anti-DOS measure if volume gets
> out of control, or if it brings dangers as per the previous parenthetical.
>
> Just my opinion of course, I know that moderation of lists is not a simple
> matter.
>
> Cheers,
> AdamISZ/waxwing
> On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:
>
> The 'dust threshold' isn't a consensus parameter, it's just a number
> pulled out of the air that didn't seem unreasonable based on average fee
> behavior.  But in any particular block transactions may need no particular
> fee level at all, including zero fees.  And in some cases it may be very
> economically advantageous to spend an output even if its face value doesn't
> support it, NFT's being a one such example (although one I consider pretty
> dumb).
>
> This proposal also appears to have ignored the prior discussion
> particularly where it was pointed out that 'deleting' outputs will not
> achieve the goal of deleting the tokens connected to them (so won't
> eliminate the incentive), or that txouts which are predictably not going to
> be accessed (as this proposal claims applies to the txouts it targets)
> don't have as significant performance implications (because they don't need
> to be cached in ram).  It also appears to be uninformed by advances like
> utxotree which makes the absolute size of the txout set much less
> important, but would make mass removals such as that described
> here expensive.  Nor has it considered that given the level of fee spending
> on NFT traffic a requirement to keep it over some (reasonable) threshold
> would not likely discourage it, or the fact that existent NFT outputs are
> generally over the dust limit in any case (so the proposals failure to meet
> the opcat proponents' delusional goals is already clear).
>
> I think the list should adopt a 1 year ban on parties *and their*
> employer(s) (if known) for any coin confiscation proposal on the list going
> forward (after, of course, making the rule clear on the signup page).  It's
> tiresome and beyond being a waste of time risks undermining public
> confidence in Bitcoin to see the constant trickle of these
> outrageous proposals in venues where they previously understood that
> serious discussions were to be had. People are, of course, free to discuss
> whatever ill-founded concepts they want but they're not entitled to the
> time and the reputation of the participants here for offensively misguided
> proposals.
>
>
> On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:
>
> Good evening all,
>
> Here is a related proposal by Matteo Pellegrini
> @matteopelleg
>
>
>
> Lynx.
>
> Abstract
> This proposal introduces a periodic, consensus-enforced mechanism for
> rendering UTXOs below the network's dust threshold permanently unspendable.
> At each halving block, UTXOs that have remained below the dust threshold
> since the previous halving become unspendable. These UTXOs become
> unspendable and may be pruned from the UTXO set entirely, reducing node
> storage requirements and eliminating the economic model that incentivizes
> their creation.
>
> Motivation
> The Bitcoin UTXO set has grown substantially due to various factors,
> including inscription protocols, spam attacks, and general dust
> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO
> Cleanup) by @ostrom72158
>   have attempted to address this by creating lists of specific UTXOs to
> render unspendable, identified by external protocol indexers.
>
> The Cat's approach has a fatal flaw: it relies on a list.
>
> Using a curated list of "non-monetary UTXOs" introduces several problems:
>
> 1) External dependency: The Cat requires reference indexers (Ord, Stamps,
> etc.) to define which UTXOs qualify. This introduces consensus-level
> dependency on external, non-Bitcoin software that can change, have bugs, or
> interpret protocols differently.
>
> 2) Protocol targeting: By specifically identifying inscription and stamp
> outputs, the proposal makes subjective judgments about which Bitcoin uses
> are legitimate. This sets a precedent for protocol-level discrimination.
>
> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes
> workarounds. If Ordinals dust is targeted, protocols will adapt to create
> dust that doesn't match the list criteria.
>
> 4) Static snapshot: A one-time list cleanup provides temporary relief but
> does nothing for future UTXO accumulation.
>
> 5) Political vulnerability: Any list-based approach requires ongoing
> governance decisions about what belongs on the list, creating a permanent
> political attack surface.
>
> A better approach targets the economic reality, not the use case.
>
> UTXOs below the dust threshold are, by definition, economically irrational
> to spend under normal fee conditions. The dust limit exists precisely
> because spending these outputs costs more in fees than the output is worth.
> These UTXOs are already "dead" in practice; this proposal simply makes that
> reality explicit at the consensus layer.
>
> By using a threshold rather than a list, Lynx:
>
> - Requires no external indexers
> - Makes no judgment about why a UTXO is small
> - Applies equally to all participants
> - Provides ongoing, predictable maintenance
> - Removes political discretion from the process
>
> Impact on Inscription Protocols
>
> The typical Ordinals inscription is stored in a UTXO containing exactly
> 546 sats; the minimum required to meet the dust limit for P2PKH addresses
> and ensure transferability across all address types. This "postage" amount
> is standard across inscription tooling and marketplaces.
>
> A threshold of 999 sats captures the vast majority of inscription UTXOs
> without requiring any protocol-specific targeting. The economic model of
> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks
> that model through neutral, threshold-based rules rather than list-based
> discrimination.
>
> Specification
>
> Definitions
>
> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is
> subject to Lynx enforcement.
>
> - Halving block: A block at height N * 210,000 where N ≥ 1.
>
> -  Snapshot block: A halving block at which the current dust threshold and
> qualifying UTXOs are recorded.
>
> -  Enforcement block: The halving block following a snapshot block (i.e.,
> snapshot block + 210,000 blocks).
>
> Lynx UTXOs:
> - Existed at the snapshot block
> - Had a value less than 999 sats
> - Remained unspent through the enforcement period (~4 years)
>
> Consensus Rules
> After activation, the following rules apply:
>
> 1) Snapshot: At each halving block H, record the set of all UTXOs with
> value < 999 sats.
>
> 2) Enforcement: At halving block H + 210,000:
> - Any UTXO that was in the snapshot set and remains unspent becomes
> permanently unspendable
> - Transactions attempting to spend these UTXOs are invalid
>
> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their local
> UTXO set. Transactions referencing unknown outpoints are already rejected
> as invalid; pruned Lynx UTXOs are simply treated as if they were already
> spent.
>
> 4) Grace period: The ~4 year window between snapshot and enforcement
> provides ample time for holders to consolidate sub-dust UTXOs if they wish
> to preserve the value.
>
> Activation
>
> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as
> determined by community consensus)
>
> Recommended first snapshot: The halving following activation lock-in
>
> Rationale
>
> Why a fixed threshold?
>
> Using a fixed threshold of 999 sats rather than referencing the dynamic
> relay dust limit provides:
>
> - Simplicity: One number, no script-type variations, no need to query
> policy settings
>
> - Predictability: Everyone knows exactly what qualifies, forever
>
> - Consensus clarity: No ambiguity about which outputs are affected.
>
> Why tie to the halving?
>
> The halving is Bitcoin's most recognized Schelling point, using it
> provides:
>
> - Predictability: Everyone knows exactly when halvings occur
> - Sufficient notice: ~4 years is generous warning for any cleanup action
> - Aligned incentives: As block rewards decrease, fee revenue and UTXO
> efficiency become more critical to network sustainability
> - Natural cadence: The halving already represents a moment of network-wide
> coordination
>
> Why not a one-time cleanup?
>
> A one-time cleanup (as proposed by The Cat) provides temporary relief but
> creates no ongoing pressure against dust accumulation. Periodic enforcement:
>
> - Establishes a permanent, predictable norm
> - Removes any expectation that dust UTXOs have indefinite longevity
> - Discourages business models built on dust creation
> - Provides continuous UTXO set maintenance
>
> Why pruning works without a list
>
> A key insight enables pruning without maintaining a separate list: Bitcoin
> nodes already reject transactions that reference unknown outpoints. When a
> node receives a transaction spending an outpoint not in its UTXO set, it
> rejects it as invalid — the node doesn't need to know why the outpoint is
> missing (spent? never existed? pruned?).
>
> After enforcement, a Lynx UTXO is functionally equivalent to a spent
> output. Nodes can simply delete it from the UTXO set. Any future
> transaction attempting to spend it will reference an outpoint the node
> doesn't recognize, and will be rejected through existing validation logic.
>
> This means:
>
> - No separate "Lynx list" is required
> - No new validation logic is needed
> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
> - The UTXO set shrinks naturally as nodes prune
>
> Why 999 sats?
>
> The threshold of 999 sats is chosen because:
>
> - Above all dust limits: Captures UTXOs at or below the dust limit for all
> script types (P2PKH: 546, P2TR: 330, etc.)
> - Captures all standard inscriptions: Typical inscription UTXOs contain
> exactly 546 sats as "postage"; well under 999
> - Simple and memorable: A clean number that's easy to communicate and
> reason about
>
> Backward Compatibility
>
> This is a soft fork. Nodes that do not upgrade will:
>
> - Continue to consider all historical transactions valid
> - Accept blocks that exclude spends of Lynx UTXOs
> - Eventually converge with upgraded nodes (as upgraded miners will not
> include invalid spends)
>
> Wallets & Services should:
>
> - Warn users holding sub-threshold UTXOs after a snapshot block
> - Provide consolidation tools during the grace period
> - Update UTXO selection algorithms to deprioritize or exclude
> sub-threshold outputs approaching a snapshot
>
> Security Considerations
>
> No confiscation
>
> This proposal does not transfer value to any party. Sub-threshold UTXOs
> become unspendable, similar to:
>
> - Lost private keys
> - Provably unspendable OP_RETURN outputs
> - Satoshi's untouched coinbase rewards
>
> The bitcoin supply cap remains unchanged; the affected outputs simply
> become irrecoverable. Holders receive ~4 years notice to consolidate if
> they value the sats.
>
> Lightning Network
>
> Some Lightning implementations create small HTLCs and dust outputs during
> channel operations. Analysis is needed to determine:
>
> - Whether current dust thresholds affect normal LN operations
> - If LN implementations need adjustment before activation
> - Whether channel close scenarios create sub-threshold outputs
>
> Preliminary assessment: LN dust limits are already set conservatively
> above relay dust limits, so impact should be minimal. However, this
> requires verification from LN implementers.
>
> Fixed threshold vs. future fee markets
>
> The 999 satoshi threshold is fixed in consensus rules and does not adjust
> based on fee market conditions.
> This is intentional:
>
> - A fixed threshold provides certainty for users and developers
> - If fee markets change dramatically, a future soft fork could adjust the
> threshold
> - The ~4 year grace period allows the community to observe and adapt
>
> If Bitcoin's fee market evolves such that 999 sats becomes economically
> significant to spend, this would indicate broader success of the network;
> and the community could choose to lower or eliminate the threshold through
> a subsequent proposal.
>
> Acknowledgments
> This proposal builds on the problem identification in "The Cat"
> (Non-monetary UTXO Cleanup) while proposing a list-free alternative
> mechanism. The Cat correctly identifies UTXO bloat as a problem worth
> solving; Lynx offers a more neutral solution.
>
>
> https://x.com/matteopelleg/status/2000602318346334449
> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>
> I received no prior response from you, so I suspect the issue is on your
> end-- since if you sent one I would normally have been directly copied.
>
> In any case, your message makes no sense. If an output is provably
> unspendable then it is unspendable.  No amount of "clever steganography"
> can change that.   If you're imagining that perhaps they are *presumed* to
> be unspendable but actually *are* spendable, then sure that would be an
> issue but with any change to consensus relevant code great care must be
> taken to not introduce errors.  Actually *making* a consensus change would
> only increase the potential for mistakes.
>
> These costs are just another reason why this hysteria over a non-issue is
> misplaced.
>
> But in any case it is better that (any) implementations that care about
> stamps put in the effort to define their exclusions in ways that are safe
> than to burden everyone with a consensus change that doesn't care about it.
>
>
> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>
> This is my third attempt to respond to this. Idk what is going wrong here.
>
> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without a
> consensus change is that a clever use of steganography could cause one of
> those otherwise unspendable outputs to be spendable, thus causing a fork
> between those nodes that adopted the Stamp pruning method and those that
> did not once one of those steganographic Stamps is spent. Though this is
> unlikely, it is still technically possible, and I would not put it past the
> denizens of the Internet to stir up trouble just for its own sake.
>
> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>
> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>
> Since the Bitcoin Stamps outputs are already unspendable, it makes perfect
> sense to mark and drop them from the UTXO set.
>
>
> There is no consensus change involved in not storing a provably
> unspendable output, it's just an implementation detail with no
> interoperability implications and doesn't need a BIP.  Bitcoin core has
> long done so for several types of unspendable outputs, e.g. outputs over
> 10kb and ones starting with OP_RETURN.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/cf39fdca-e996-43be-ab52-573aedd619d5n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/cf39fdca-e996-43be-ab52-573aedd619d5n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAL5BAw0RV8A_Ny3GSoR1gCSEHxdfkWu%2BsLQCp7KJCet0Sf%3DJuQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 35987 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2026-01-19  1:11  4%                 ` Pepe Hodler
  2026-01-23  3:45  1%                   ` Chris Riley
@ 2026-01-23 13:55  4%                   ` Galois Field
  1 sibling, 0 replies; 200+ results
From: Galois Field @ 2026-01-23 13:55 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 28677 bytes --]

Hello everyone,

I don't respond regularly, but I can't let this go.

> I don't understand how anyone could be confused about the concept of spam 
on bitcoin

The problem is that you're redefining "spam" to mean "transactions I don't 
like" rather than using the technical definition: transactions that DoS the 
network.

Inscriptions, ordinals, OP_RETURN: these are consensus-valid transactions 
that pay fees. Miners choose to include them. That's not spam, that's the 
fee market working. You can disagree with the use case, but calling it an 
"attack" is disingenuous.

Your email spam analogy is backwards: email spam is unwanted by the 
recipient. Here, miners ARE the recipients, and they're explicitly 
accepting these transactions by including them in blocks.

Bitcoin is agnostic about UTXO content. It's not up to developers to decide 
what's a "legitimate monetary transaction" based on the white paper. The 
protocol is defined by consensus rules in the code, not by our 
interpretation of Satoshi's intent.

Spam prevention in the codebase (like the witness data checks in 
validation.cpp) exists to prevent DoS vectors, not to judge transaction 
purpose. That's the actual definition of spam we should be using.

Filter whatever you want on your node. That's your right and policy rules 
exist for this. But advocating for protocol-level censorship of 
consensus-valid, fee-paying transactions because you don't like what 
they're used for is far more dangerous than any jpeg in witness data.

Best,
Galois
Le jeudi 22 janvier 2026 à 22:54:24 UTC+1, Pepe Hodler a écrit :

> Hi list. 
>
> Which brings me to my disagreement, which I know is not shared by a number 
> of contributors here: just as it is hard to define spam on Bitcoin 
>
> I don't understand how anyone could be confused about the concept of spam 
> on bitcoin. Bitcoins is "A Peer-to-Peer Electronic Cash System" according 
> to the white paper. As such, anything not intended as a monetary 
> transaction is spam.
>
> The use of fake pubkeys to store data on chain, that is an unsupported and 
> unsanctioned use of bitcoin. That is spam, and an attack, not a monetary 
> transaction.
>
> Same with fake scripthash used to store arbitrary data, unsupported and 
> unsanctioned use of bitcoin. That is spam, and an attack, not a monetary 
> transaction.
>
> And the same goes for the Segwit exploit and the Taproot exploit. That is 
> exploiting bitcoin to store arbitrary data in an unsanctioned way, spam, an 
> attack on bitcoin. 
>
> When Segwit and Taproot were implemented, nobody, absolutely nobody was 
> welcoming those upgrades as a way to store jpegs and other garbage on 
> chain. That is not what bitcoin, Segwit, and Taproot were built for.
>
> If you are making use of OpenRelay and/or SlipStream to bypass the policy 
> of the majority of nodes, you are a spammer and an attacker, not a bitcoiner. 
> You are trying to skirt the only use case of bitcoin. 
>
> When there are blocks like this one: 
> https://mempool.space/block/00000000000000000000ed962f87a0c350b1401fe546db60e6d78e34ab549378 . 
> Over 60% of the transactions in that block are not sending or receiving a 
> single sat. It's all op_returns with no sats in them. That is not what 
> bitcoin was designed or sanctioned for.
>
> These people are not users, they are attackers and spammers. How can you 
> look at inscriptions, runes, ordinals, fake pubkeys, fake scripthash, 
> stamps, and op_return with 0 sats in them and wonder if those are legit 
> bitcoin monetary transactions?
> Now, some have tried to claim "My ordinal is a consensus valid 
> transaction". And of course it is, otherwise it would not have been added 
> to a block. But that's like saying the Nigerian prince email followed all 
> the SMTP and POP protocols of email, therefore it's not spam.  Some spam 
> defenders have tried to claim they have paid their miner fee. Of course 
> they did, but that's like saying the sender of the Nigerian prince email 
> paid his internet, therefore it's not spam.    
>
> If you are confused about what constitutes spam on bitcoin, please 
> explain. While I'm sure there are some transactions that could be tricky 
> and controversial to identify as spam, I"m sure we can all agree that 
> inscriptions, stamps, jpegs, fake pubkeys, fake scripthash, unusually large 
> Segwit data, ordinals, runes, etc, are all clearly spam. 
>
>
> it's also very hard to define it in a discussion forum like this one.  
>
>
> I just did it, see above. It really wasn't that hard. How are you confused 
> about the definition of spam as it pertains to bitcoin? Because bitcoin is 
> money, they have to obfuscate their spam to make it look like a legitimate 
> monetary transaction to the system. So you could make the case that it's 
> harder to distinguish spam from a real monetary transaction. But defining 
> spam on it's own is pretty easy.  
>
> But ultimately, it does not belong to devs to decide what is spam. Don't 
> think that just because we know C++, that somehow gives us authority to 
> decide what direction bitcoin should be taking, and what spam is. 
>
> That decision belongs to the nodes. And it's clear that the nodes are not 
> given the tools to decide for themselves what spam is or what spam isn't, 
> with comprehensive user configurable spam filters. 
>
> Notions of motivation of contributors (such as they are paid by such and 
> such a company) should not be relevant. 
>
>
> Are you suggesting that conflict of interest is not a thing? If someone is 
> advocating against any and all measures against spam, I would really like 
> to know where their interests lie. 
>
> Everything should be open to discussion which is implementation-technical 
> (so obviously not e.g. threats of violence or things that bring legal 
> liability to participants or have zero relevance to Bitcoin's technical 
> development) even if it's philosophy-motivated. And blocking should be 
> reserved either as an anti-DOS measure if volume gets out of control, or if 
> it brings dangers as per the previous parenthetical. 
>
>
> This comes across as a thinly veiled attempt to censor anyone who wants to 
> combat spam, and their employees/employers. This idea of censoring 
> "confiscatory" proposals never came up when someone proposed confiscation 
> though what he called "demorage" or when someone proposed seizing Satoshi's 
> coin. 
>
> If you want to buy or sell pancakes, or JPEgs, or anything else for that 
> matter, bitcoin is here to serve you. But your pancakes and your JPEGs 
> don't belong on the bitcoin chain.
>
> Disclaimer: I own bitcoin, I run a bitcoin business in El Salvador. I own 
> no inscriptions or spam of any kind, and I don't profit from any spam 
> related companies.
>
> 40% of the UTXO set is dust spam UTXOs that contains less than 0.0017% of 
> the total bitcoin issued. This constitutes an attack on bitcoin. I think we 
> all should start acknowledging the problem, and stop asking ourselves 
> dismissive questions like "What is spam anyways?" and use that question as 
> an excuse to pretend there is no problem.
>
> Cheers, Pepe 
>
>
>
> On Tuesday, 30 December 2025 at 08:51:56 UTC-6 Antoine Riard wrote:
>
> Hi list,
>
> > Which brings me to my disagreement, which I know is not shared by a 
> number of contributors here: just as it is hard to define spam on Bitcoin, 
> it's also very hard to define it in a discussion forum like this one. 
> Making suggestions which *I* think are terrible, or detrimental, on a list 
> like this, should never be disallowed here. Notions of motivation of 
> contributors (such as they are paid by such and such a company) should not 
> be relevant. Everything should be open to discussion which is 
> implementation-technical (so obviously not e.g. threats of violence or 
> things that bring legal liability to participants or have zero relevance to 
> Bitcoin's technical development) even if it's philosophy-motivated. And 
> blocking should be reserved either as an anti-DOS measure if volume gets 
> out of control, or if it brings dangers as per the previous parenthetical.
>
> I'm fully sharing waxwing reasonable opinion. While I can understand 
> gmax's sentiment being fed
> up with poor coin confiscation proposals again and again on the mailing 
> list, the cure would be
> worst than the disease. Maybe, I'm very voltairean here, but you don't 
> fight ill-founded opinions.
> by persecuting their authors (--otherwise, down the road you take the risk 
> of seeing the bastille
> popped up). Rather than you fight them back by doing the work to persuade 
> and to convince those
> ideas you find stupid are indeed *objectively* stupid.
>
> To me, it's a sign of strength and confidence that Bitcoin and its 
> development process can
> withstand and endure the most "outrageous" controversies. For sure, I have 
> been enough times
> in the shoes of someone who has to champion controversial changes (cf. 
> `mempoolfullrbf`) to not
> negate that the strength of the process is kinda traded on the back of the 
> devs, but this is not
> altering my mind on what I think should be *ideally* the development 
> process in terms of openess
> and publicity.
>
> My humble opinion only, as we said.
>
> Best,
> Antoine
> OTS hash: 5c1c19f589a61787dbf483cd6814f094c3b24888d6d189c5f4d776bda558e1ce
> Le mercredi 24 décembre 2025 à 17:23:48 UTC, waxwing/ AdamISZ a écrit :
>
> Hi Greg, list:
>
> > I think the list should adopt a 1 year ban on parties *and their* 
> employer(s) (if known) for any coin confiscation proposal on the list going 
> forward (after, of course, making the rule clear on the signup page).  It's 
> tiresome and beyond being a waste of time risks undermining public 
> confidence in Bitcoin to see the constant trickle of these 
> outrageous proposals in venues where they previously understood that 
> serious discussions were to be had. People are, of course, free to discuss 
> whatever ill-founded concepts they want but they're not entitled to the 
> time and the reputation of the participants here for offensively misguided 
> proposals. 
>
> I'm a huge agree-er with the motivation of this comment and a huge 
> disagree-er with the suggestion itself.
>
> Actual confiscation, whatever the reason, hugely undermines Bitcoin's 
> value to humanity - note I am not saying its financial value, but value as 
> a project (and if we didn't see such value what the hell are we doing 
> here). Of course those two types of value are very closely linked, but they 
> are still distinct. I hold that same belief even when we are talking about 
> other suggestions of confiscation, such as to address a quantum threat - 
> something that has recently been discussed here, extensively.
>
> Which brings me to my disagreement, which I know is not shared by a number 
> of contributors here: just as it is hard to define spam on Bitcoin, it's 
> also very hard to define it in a discussion forum like this one. Making 
> suggestions which *I* think are terrible, or detrimental, on a list like 
> this, should never be disallowed here. Notions of motivation of 
> contributors (such as they are paid by such and such a company) should not 
> be relevant. Everything should be open to discussion which is 
> implementation-technical (so obviously not e.g. threats of violence or 
> things that bring legal liability to participants or have zero relevance to 
> Bitcoin's technical development) even if it's philosophy-motivated. And 
> blocking should be reserved either as an anti-DOS measure if volume gets 
> out of control, or if it brings dangers as per the previous parenthetical.
>
> Just my opinion of course, I know that moderation of lists is not a simple 
> matter.
>
> Cheers,
> AdamISZ/waxwing
> On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:
>
> The 'dust threshold' isn't a consensus parameter, it's just a number 
> pulled out of the air that didn't seem unreasonable based on average fee 
> behavior.  But in any particular block transactions may need no particular 
> fee level at all, including zero fees.  And in some cases it may be very 
> economically advantageous to spend an output even if its face value doesn't 
> support it, NFT's being a one such example (although one I consider pretty 
> dumb).
>  
> This proposal also appears to have ignored the prior discussion 
> particularly where it was pointed out that 'deleting' outputs will not 
> achieve the goal of deleting the tokens connected to them (so won't 
> eliminate the incentive), or that txouts which are predictably not going to 
> be accessed (as this proposal claims applies to the txouts it targets) 
> don't have as significant performance implications (because they don't need 
> to be cached in ram).  It also appears to be uninformed by advances like 
> utxotree which makes the absolute size of the txout set much less 
> important, but would make mass removals such as that described 
> here expensive.  Nor has it considered that given the level of fee spending 
> on NFT traffic a requirement to keep it over some (reasonable) threshold 
> would not likely discourage it, or the fact that existent NFT outputs are 
> generally over the dust limit in any case (so the proposals failure to meet 
> the opcat proponents' delusional goals is already clear).
>
> I think the list should adopt a 1 year ban on parties *and their* 
> employer(s) (if known) for any coin confiscation proposal on the list going 
> forward (after, of course, making the rule clear on the signup page).  It's 
> tiresome and beyond being a waste of time risks undermining public 
> confidence in Bitcoin to see the constant trickle of these 
> outrageous proposals in venues where they previously understood that 
> serious discussions were to be had. People are, of course, free to discuss 
> whatever ill-founded concepts they want but they're not entitled to the 
> time and the reputation of the participants here for offensively misguided 
> proposals. 
>
>
> On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:
>
> Good evening all,
>
> Here is a related proposal by Matteo Pellegrini
> @matteopelleg
>
>
>
> Lynx.
>
> Abstract
> This proposal introduces a periodic, consensus-enforced mechanism for 
> rendering UTXOs below the network's dust threshold permanently unspendable. 
> At each halving block, UTXOs that have remained below the dust threshold 
> since the previous halving become unspendable. These UTXOs become 
> unspendable and may be pruned from the UTXO set entirely, reducing node 
> storage requirements and eliminating the economic model that incentivizes 
> their creation.
>
> Motivation
> The Bitcoin UTXO set has grown substantially due to various factors, 
> including inscription protocols, spam attacks, and general dust 
> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
> Cleanup) by @ostrom72158
>   have attempted to address this by creating lists of specific UTXOs to 
> render unspendable, identified by external protocol indexers.
>
> The Cat's approach has a fatal flaw: it relies on a list.
>
> Using a curated list of "non-monetary UTXOs" introduces several problems:
>
> 1) External dependency: The Cat requires reference indexers (Ord, Stamps, 
> etc.) to define which UTXOs qualify. This introduces consensus-level 
> dependency on external, non-Bitcoin software that can change, have bugs, or 
> interpret protocols differently.
>
> 2) Protocol targeting: By specifically identifying inscription and stamp 
> outputs, the proposal makes subjective judgments about which Bitcoin uses 
> are legitimate. This sets a precedent for protocol-level discrimination.
>
> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
> workarounds. If Ordinals dust is targeted, protocols will adapt to create 
> dust that doesn't match the list criteria.
>
> 4) Static snapshot: A one-time list cleanup provides temporary relief but 
> does nothing for future UTXO accumulation.
>
> 5) Political vulnerability: Any list-based approach requires ongoing 
> governance decisions about what belongs on the list, creating a permanent 
> political attack surface.
>
> A better approach targets the economic reality, not the use case.
>
> UTXOs below the dust threshold are, by definition, economically irrational 
> to spend under normal fee conditions. The dust limit exists precisely 
> because spending these outputs costs more in fees than the output is worth. 
> These UTXOs are already "dead" in practice; this proposal simply makes that 
> reality explicit at the consensus layer.
>
> By using a threshold rather than a list, Lynx:
>
> - Requires no external indexers
> - Makes no judgment about why a UTXO is small
> - Applies equally to all participants
> - Provides ongoing, predictable maintenance
> - Removes political discretion from the process
>
> Impact on Inscription Protocols
>
> The typical Ordinals inscription is stored in a UTXO containing exactly 
> 546 sats; the minimum required to meet the dust limit for P2PKH addresses 
> and ensure transferability across all address types. This "postage" amount 
> is standard across inscription tooling and marketplaces.
>
> A threshold of 999 sats captures the vast majority of inscription UTXOs 
> without requiring any protocol-specific targeting. The economic model of 
> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
> that model through neutral, threshold-based rules rather than list-based 
> discrimination.
>
> Specification
>
> Definitions
>
> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is 
> subject to Lynx enforcement.
>
> - Halving block: A block at height N * 210,000 where N ≥ 1.
>
> -  Snapshot block: A halving block at which the current dust threshold and 
> qualifying UTXOs are recorded.
>
> -  Enforcement block: The halving block following a snapshot block (i.e., 
> snapshot block + 210,000 blocks).
>
> Lynx UTXOs:
> - Existed at the snapshot block
> - Had a value less than 999 sats
> - Remained unspent through the enforcement period (~4 years)
>
> Consensus Rules
> After activation, the following rules apply:
>
> 1) Snapshot: At each halving block H, record the set of all UTXOs with 
> value < 999 sats.
>
> 2) Enforcement: At halving block H + 210,000:
> - Any UTXO that was in the snapshot set and remains unspent becomes 
> permanently unspendable
> - Transactions attempting to spend these UTXOs are invalid
>
> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their local 
> UTXO set. Transactions referencing unknown outpoints are already rejected 
> as invalid; pruned Lynx UTXOs are simply treated as if they were already 
> spent.
>
> 4) Grace period: The ~4 year window between snapshot and enforcement 
> provides ample time for holders to consolidate sub-dust UTXOs if they wish 
> to preserve the value.
>
> Activation
>
> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
> determined by community consensus)
>
> Recommended first snapshot: The halving following activation lock-in
>
> Rationale
>
> Why a fixed threshold?
>
> Using a fixed threshold of 999 sats rather than referencing the dynamic 
> relay dust limit provides:
>
> - Simplicity: One number, no script-type variations, no need to query 
> policy settings
>
> - Predictability: Everyone knows exactly what qualifies, forever
>
> - Consensus clarity: No ambiguity about which outputs are affected.
>
> Why tie to the halving?
>
> The halving is Bitcoin's most recognized Schelling point, using it 
> provides:
>
> - Predictability: Everyone knows exactly when halvings occur
> - Sufficient notice: ~4 years is generous warning for any cleanup action
> - Aligned incentives: As block rewards decrease, fee revenue and UTXO 
> efficiency become more critical to network sustainability
> - Natural cadence: The halving already represents a moment of network-wide 
> coordination
>
> Why not a one-time cleanup?
>
> A one-time cleanup (as proposed by The Cat) provides temporary relief but 
> creates no ongoing pressure against dust accumulation. Periodic enforcement:
>
> - Establishes a permanent, predictable norm
> - Removes any expectation that dust UTXOs have indefinite longevity
> - Discourages business models built on dust creation
> - Provides continuous UTXO set maintenance
>
> Why pruning works without a list
>
> A key insight enables pruning without maintaining a separate list: Bitcoin 
> nodes already reject transactions that reference unknown outpoints. When a 
> node receives a transaction spending an outpoint not in its UTXO set, it 
> rejects it as invalid — the node doesn't need to know why the outpoint is 
> missing (spent? never existed? pruned?).
>
> After enforcement, a Lynx UTXO is functionally equivalent to a spent 
> output. Nodes can simply delete it from the UTXO set. Any future 
> transaction attempting to spend it will reference an outpoint the node 
> doesn't recognize, and will be rejected through existing validation logic.
>
> This means:
>
> - No separate "Lynx list" is required
> - No new validation logic is needed
> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
> - The UTXO set shrinks naturally as nodes prune
>
> Why 999 sats?
>
> The threshold of 999 sats is chosen because:
>
> - Above all dust limits: Captures UTXOs at or below the dust limit for all 
> script types (P2PKH: 546, P2TR: 330, etc.)
> - Captures all standard inscriptions: Typical inscription UTXOs contain 
> exactly 546 sats as "postage"; well under 999
> - Simple and memorable: A clean number that's easy to communicate and 
> reason about
>
> Backward Compatibility
>
> This is a soft fork. Nodes that do not upgrade will:
>
> - Continue to consider all historical transactions valid
> - Accept blocks that exclude spends of Lynx UTXOs
> - Eventually converge with upgraded nodes (as upgraded miners will not 
> include invalid spends)
>
> Wallets & Services should:
>
> - Warn users holding sub-threshold UTXOs after a snapshot block
> - Provide consolidation tools during the grace period
> - Update UTXO selection algorithms to deprioritize or exclude 
> sub-threshold outputs approaching a snapshot
>
> Security Considerations
>
> No confiscation
>
> This proposal does not transfer value to any party. Sub-threshold UTXOs 
> become unspendable, similar to:
>
> - Lost private keys
> - Provably unspendable OP_RETURN outputs
> - Satoshi's untouched coinbase rewards
>
> The bitcoin supply cap remains unchanged; the affected outputs simply 
> become irrecoverable. Holders receive ~4 years notice to consolidate if 
> they value the sats.
>
> Lightning Network
>
> Some Lightning implementations create small HTLCs and dust outputs during 
> channel operations. Analysis is needed to determine:
>
> - Whether current dust thresholds affect normal LN operations
> - If LN implementations need adjustment before activation
> - Whether channel close scenarios create sub-threshold outputs
>
> Preliminary assessment: LN dust limits are already set conservatively 
> above relay dust limits, so impact should be minimal. However, this 
> requires verification from LN implementers.
>
> Fixed threshold vs. future fee markets
>
> The 999 satoshi threshold is fixed in consensus rules and does not adjust 
> based on fee market conditions. 
> This is intentional:
>
> - A fixed threshold provides certainty for users and developers
> - If fee markets change dramatically, a future soft fork could adjust the 
> threshold
> - The ~4 year grace period allows the community to observe and adapt
>
> If Bitcoin's fee market evolves such that 999 sats becomes economically 
> significant to spend, this would indicate broader success of the network; 
> and the community could choose to lower or eliminate the threshold through 
> a subsequent proposal.
>
> Acknowledgments
> This proposal builds on the problem identification in "The Cat" 
> (Non-monetary UTXO Cleanup) while proposing a list-free alternative 
> mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
> solving; Lynx offers a more neutral solution.
>
>
> https://x.com/matteopelleg/status/2000602318346334449
> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>
> I received no prior response from you, so I suspect the issue is on your 
> end-- since if you sent one I would normally have been directly copied. 
>
> In any case, your message makes no sense. If an output is provably 
> unspendable then it is unspendable.  No amount of "clever steganography" 
> can change that.   If you're imagining that perhaps they are *presumed* to 
> be unspendable but actually *are* spendable, then sure that would be an 
> issue but with any change to consensus relevant code great care must be 
> taken to not introduce errors.  Actually *making* a consensus change would 
> only increase the potential for mistakes.
>
> These costs are just another reason why this hysteria over a non-issue is 
> misplaced.
>
> But in any case it is better that (any) implementations that care about 
> stamps put in the effort to define their exclusions in ways that are safe 
> than to burden everyone with a consensus change that doesn't care about it.
>
>
> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>
> This is my third attempt to respond to this. Idk what is going wrong here.
>
> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without a 
> consensus change is that a clever use of steganography could cause one of 
> those otherwise unspendable outputs to be spendable, thus causing a fork 
> between those nodes that adopted the Stamp pruning method and those that 
> did not once one of those steganographic Stamps is spent. Though this is 
> unlikely, it is still technically possible, and I would not put it past the 
> denizens of the Internet to stir up trouble just for its own sake.
>
> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>
> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>
> Since the Bitcoin Stamps outputs are already unspendable, it makes perfect 
> sense to mark and drop them from the UTXO set.
>
>
> There is no consensus change involved in not storing a provably 
> unspendable output, it's just an implementation detail with no 
> interoperability implications and doesn't need a BIP.  Bitcoin core has 
> long done so for several types of unspendable outputs, e.g. outputs over 
> 10kb and ones starting with OP_RETURN.
>
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f66300d3-1606-41ec-9530-30a3731ea045n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 35328 bytes --]

^ permalink raw reply	[relevance 4%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-30 14:36  1%               ` Antoine Riard
@ 2026-01-19  1:11  4%                 ` Pepe Hodler
  2026-01-23  3:45  1%                   ` Chris Riley
  2026-01-23 13:55  4%                   ` Galois Field
  2026-01-22  1:14  1%                 ` Claire Ostrom
  1 sibling, 2 replies; 200+ results
From: Pepe Hodler @ 2026-01-19  1:11 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 26038 bytes --]

 Hi list. 

Which brings me to my disagreement, which I know is not shared by a number 
of contributors here: just as it is hard to define spam on Bitcoin 

I don't understand how anyone could be confused about the concept of spam 
on bitcoin. Bitcoins is "A Peer-to-Peer Electronic Cash System" according 
to the white paper. As such, anything not intended as a monetary 
transaction is spam.

The use of fake pubkeys to store data on chain, that is an unsupported and 
unsanctioned use of bitcoin. That is spam, and an attack, not a monetary 
transaction.

Same with fake scripthash used to store arbitrary data, unsupported and 
unsanctioned use of bitcoin. That is spam, and an attack, not a monetary 
transaction.

And the same goes for the Segwit exploit and the Taproot exploit. That is 
exploiting bitcoin to store arbitrary data in an unsanctioned way, spam, an 
attack on bitcoin. 

When Segwit and Taproot were implemented, nobody, absolutely nobody was 
welcoming those upgrades as a way to store jpegs and other garbage on 
chain. That is not what bitcoin, Segwit, and Taproot were built for.

If you are making use of OpenRelay and/or SlipStream to bypass the policy 
of the majority of nodes, you are a spammer and an attacker, not a bitcoiner. 
You are trying to skirt the only use case of bitcoin. 

When there are blocks like this one: 
https://mempool.space/block/00000000000000000000ed962f87a0c350b1401fe546db60e6d78e34ab549378 . 
Over 60% of the transactions in that block are not sending or receiving a 
single sat. It's all op_returns with no sats in them. That is not what 
bitcoin was designed or sanctioned for.

These people are not users, they are attackers and spammers. How can you 
look at inscriptions, runes, ordinals, fake pubkeys, fake scripthash, 
stamps, and op_return with 0 sats in them and wonder if those are legit 
bitcoin monetary transactions?
Now, some have tried to claim "My ordinal is a consensus valid 
transaction". And of course it is, otherwise it would not have been added 
to a block. But that's like saying the Nigerian prince email followed all 
the SMTP and POP protocols of email, therefore it's not spam.  Some spam 
defenders have tried to claim they have paid their miner fee. Of course 
they did, but that's like saying the sender of the Nigerian prince email 
paid his internet, therefore it's not spam.    

If you are confused about what constitutes spam on bitcoin, please explain. 
While I'm sure there are some transactions that could be tricky and 
controversial to identify as spam, I"m sure we can all agree that 
inscriptions, stamps, jpegs, fake pubkeys, fake scripthash, unusually large 
Segwit data, ordinals, runes, etc, are all clearly spam. 

it's also very hard to define it in a discussion forum like this one.  


I just did it, see above. It really wasn't that hard. How are you confused 
about the definition of spam as it pertains to bitcoin? Because bitcoin is 
money, they have to obfuscate their spam to make it look like a legitimate 
monetary transaction to the system. So you could make the case that it's 
harder to distinguish spam from a real monetary transaction. But defining 
spam on it's own is pretty easy.  

But ultimately, it does not belong to devs to decide what is spam. Don't 
think that just because we know C++, that somehow gives us authority to 
decide what direction bitcoin should be taking, and what spam is. 

That decision belongs to the nodes. And it's clear that the nodes are not 
given the tools to decide for themselves what spam is or what spam isn't, 
with comprehensive user configurable spam filters. 

Notions of motivation of contributors (such as they are paid by such and 
such a company) should not be relevant. 


Are you suggesting that conflict of interest is not a thing? If someone is 
advocating against any and all measures against spam, I would really like 
to know where their interests lie. 

Everything should be open to discussion which is implementation-technical 
(so obviously not e.g. threats of violence or things that bring legal 
liability to participants or have zero relevance to Bitcoin's technical 
development) even if it's philosophy-motivated. And blocking should be 
reserved either as an anti-DOS measure if volume gets out of control, or if 
it brings dangers as per the previous parenthetical. 


This comes across as a thinly veiled attempt to censor anyone who wants to 
combat spam, and their employees/employers. This idea of censoring 
"confiscatory" proposals never came up when someone proposed confiscation 
though what he called "demorage" or when someone proposed seizing Satoshi's 
coin. 

If you want to buy or sell pancakes, or JPEgs, or anything else for that 
matter, bitcoin is here to serve you. But your pancakes and your JPEGs 
don't belong on the bitcoin chain.

Disclaimer: I own bitcoin, I run a bitcoin business in El Salvador. I own 
no inscriptions or spam of any kind, and I don't profit from any spam 
related companies.

40% of the UTXO set is dust spam UTXOs that contains less than 0.0017% of 
the total bitcoin issued. This constitutes an attack on bitcoin. I think we 
all should start acknowledging the problem, and stop asking ourselves 
dismissive questions like "What is spam anyways?" and use that question as 
an excuse to pretend there is no problem.

Cheers, Pepe 



On Tuesday, 30 December 2025 at 08:51:56 UTC-6 Antoine Riard wrote:

Hi list,

> Which brings me to my disagreement, which I know is not shared by a 
number of contributors here: just as it is hard to define spam on Bitcoin, 
it's also very hard to define it in a discussion forum like this one. 
Making suggestions which *I* think are terrible, or detrimental, on a list 
like this, should never be disallowed here. Notions of motivation of 
contributors (such as they are paid by such and such a company) should not 
be relevant. Everything should be open to discussion which is 
implementation-technical (so obviously not e.g. threats of violence or 
things that bring legal liability to participants or have zero relevance to 
Bitcoin's technical development) even if it's philosophy-motivated. And 
blocking should be reserved either as an anti-DOS measure if volume gets 
out of control, or if it brings dangers as per the previous parenthetical.

I'm fully sharing waxwing reasonable opinion. While I can understand gmax's 
sentiment being fed
up with poor coin confiscation proposals again and again on the mailing 
list, the cure would be
worst than the disease. Maybe, I'm very voltairean here, but you don't 
fight ill-founded opinions.
by persecuting their authors (--otherwise, down the road you take the risk 
of seeing the bastille
popped up). Rather than you fight them back by doing the work to persuade 
and to convince those
ideas you find stupid are indeed *objectively* stupid.

To me, it's a sign of strength and confidence that Bitcoin and its 
development process can
withstand and endure the most "outrageous" controversies. For sure, I have 
been enough times
in the shoes of someone who has to champion controversial changes (cf. 
`mempoolfullrbf`) to not
negate that the strength of the process is kinda traded on the back of the 
devs, but this is not
altering my mind on what I think should be *ideally* the development 
process in terms of openess
and publicity.

My humble opinion only, as we said.

Best,
Antoine
OTS hash: 5c1c19f589a61787dbf483cd6814f094c3b24888d6d189c5f4d776bda558e1ce
Le mercredi 24 décembre 2025 à 17:23:48 UTC, waxwing/ AdamISZ a écrit :

Hi Greg, list:

> I think the list should adopt a 1 year ban on parties *and their* 
employer(s) (if known) for any coin confiscation proposal on the list going 
forward (after, of course, making the rule clear on the signup page).  It's 
tiresome and beyond being a waste of time risks undermining public 
confidence in Bitcoin to see the constant trickle of these 
outrageous proposals in venues where they previously understood that 
serious discussions were to be had. People are, of course, free to discuss 
whatever ill-founded concepts they want but they're not entitled to the 
time and the reputation of the participants here for offensively misguided 
proposals. 

I'm a huge agree-er with the motivation of this comment and a huge 
disagree-er with the suggestion itself.

Actual confiscation, whatever the reason, hugely undermines Bitcoin's value 
to humanity - note I am not saying its financial value, but value as a 
project (and if we didn't see such value what the hell are we doing here). 
Of course those two types of value are very closely linked, but they are 
still distinct. I hold that same belief even when we are talking about 
other suggestions of confiscation, such as to address a quantum threat - 
something that has recently been discussed here, extensively.

Which brings me to my disagreement, which I know is not shared by a number 
of contributors here: just as it is hard to define spam on Bitcoin, it's 
also very hard to define it in a discussion forum like this one. Making 
suggestions which *I* think are terrible, or detrimental, on a list like 
this, should never be disallowed here. Notions of motivation of 
contributors (such as they are paid by such and such a company) should not 
be relevant. Everything should be open to discussion which is 
implementation-technical (so obviously not e.g. threats of violence or 
things that bring legal liability to participants or have zero relevance to 
Bitcoin's technical development) even if it's philosophy-motivated. And 
blocking should be reserved either as an anti-DOS measure if volume gets 
out of control, or if it brings dangers as per the previous parenthetical.

Just my opinion of course, I know that moderation of lists is not a simple 
matter.

Cheers,
AdamISZ/waxwing
On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:

The 'dust threshold' isn't a consensus parameter, it's just a number pulled 
out of the air that didn't seem unreasonable based on average fee 
behavior.  But in any particular block transactions may need no particular 
fee level at all, including zero fees.  And in some cases it may be very 
economically advantageous to spend an output even if its face value doesn't 
support it, NFT's being a one such example (although one I consider pretty 
dumb).
 
This proposal also appears to have ignored the prior discussion 
particularly where it was pointed out that 'deleting' outputs will not 
achieve the goal of deleting the tokens connected to them (so won't 
eliminate the incentive), or that txouts which are predictably not going to 
be accessed (as this proposal claims applies to the txouts it targets) 
don't have as significant performance implications (because they don't need 
to be cached in ram).  It also appears to be uninformed by advances like 
utxotree which makes the absolute size of the txout set much less 
important, but would make mass removals such as that described 
here expensive.  Nor has it considered that given the level of fee spending 
on NFT traffic a requirement to keep it over some (reasonable) threshold 
would not likely discourage it, or the fact that existent NFT outputs are 
generally over the dust limit in any case (so the proposals failure to meet 
the opcat proponents' delusional goals is already clear).

I think the list should adopt a 1 year ban on parties *and their* 
employer(s) (if known) for any coin confiscation proposal on the list going 
forward (after, of course, making the rule clear on the signup page).  It's 
tiresome and beyond being a waste of time risks undermining public 
confidence in Bitcoin to see the constant trickle of these 
outrageous proposals in venues where they previously understood that 
serious discussions were to be had. People are, of course, free to discuss 
whatever ill-founded concepts they want but they're not entitled to the 
time and the reputation of the participants here for offensively misguided 
proposals. 


On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:

Good evening all,

Here is a related proposal by Matteo Pellegrini
@matteopelleg



Lynx.

Abstract
This proposal introduces a periodic, consensus-enforced mechanism for 
rendering UTXOs below the network's dust threshold permanently unspendable. 
At each halving block, UTXOs that have remained below the dust threshold 
since the previous halving become unspendable. These UTXOs become 
unspendable and may be pruned from the UTXO set entirely, reducing node 
storage requirements and eliminating the economic model that incentivizes 
their creation.

Motivation
The Bitcoin UTXO set has grown substantially due to various factors, 
including inscription protocols, spam attacks, and general dust 
accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
Cleanup) by @ostrom72158
  have attempted to address this by creating lists of specific UTXOs to 
render unspendable, identified by external protocol indexers.

The Cat's approach has a fatal flaw: it relies on a list.

Using a curated list of "non-monetary UTXOs" introduces several problems:

1) External dependency: The Cat requires reference indexers (Ord, Stamps, 
etc.) to define which UTXOs qualify. This introduces consensus-level 
dependency on external, non-Bitcoin software that can change, have bugs, or 
interpret protocols differently.

2) Protocol targeting: By specifically identifying inscription and stamp 
outputs, the proposal makes subjective judgments about which Bitcoin uses 
are legitimate. This sets a precedent for protocol-level discrimination.

3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
workarounds. If Ordinals dust is targeted, protocols will adapt to create 
dust that doesn't match the list criteria.

4) Static snapshot: A one-time list cleanup provides temporary relief but 
does nothing for future UTXO accumulation.

5) Political vulnerability: Any list-based approach requires ongoing 
governance decisions about what belongs on the list, creating a permanent 
political attack surface.

A better approach targets the economic reality, not the use case.

UTXOs below the dust threshold are, by definition, economically irrational 
to spend under normal fee conditions. The dust limit exists precisely 
because spending these outputs costs more in fees than the output is worth. 
These UTXOs are already "dead" in practice; this proposal simply makes that 
reality explicit at the consensus layer.

By using a threshold rather than a list, Lynx:

- Requires no external indexers
- Makes no judgment about why a UTXO is small
- Applies equally to all participants
- Provides ongoing, predictable maintenance
- Removes political discretion from the process

Impact on Inscription Protocols

The typical Ordinals inscription is stored in a UTXO containing exactly 546 
sats; the minimum required to meet the dust limit for P2PKH addresses and 
ensure transferability across all address types. This "postage" amount is 
standard across inscription tooling and marketplaces.

A threshold of 999 sats captures the vast majority of inscription UTXOs 
without requiring any protocol-specific targeting. The economic model of 
inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
that model through neutral, threshold-based rules rather than list-based 
discrimination.

Specification

Definitions

-  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is 
subject to Lynx enforcement.

- Halving block: A block at height N * 210,000 where N ≥ 1.

-  Snapshot block: A halving block at which the current dust threshold and 
qualifying UTXOs are recorded.

-  Enforcement block: The halving block following a snapshot block (i.e., 
snapshot block + 210,000 blocks).

Lynx UTXOs:
- Existed at the snapshot block
- Had a value less than 999 sats
- Remained unspent through the enforcement period (~4 years)

Consensus Rules
After activation, the following rules apply:

1) Snapshot: At each halving block H, record the set of all UTXOs with 
value < 999 sats.

2) Enforcement: At halving block H + 210,000:
- Any UTXO that was in the snapshot set and remains unspent becomes 
permanently unspendable
- Transactions attempting to spend these UTXOs are invalid

3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their local 
UTXO set. Transactions referencing unknown outpoints are already rejected 
as invalid; pruned Lynx UTXOs are simply treated as if they were already 
spent.

4) Grace period: The ~4 year window between snapshot and enforcement 
provides ample time for holders to consolidate sub-dust UTXOs if they wish 
to preserve the value.

Activation

Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
determined by community consensus)

Recommended first snapshot: The halving following activation lock-in

Rationale

Why a fixed threshold?

Using a fixed threshold of 999 sats rather than referencing the dynamic 
relay dust limit provides:

- Simplicity: One number, no script-type variations, no need to query 
policy settings

- Predictability: Everyone knows exactly what qualifies, forever

- Consensus clarity: No ambiguity about which outputs are affected.

Why tie to the halving?

The halving is Bitcoin's most recognized Schelling point, using it provides:

- Predictability: Everyone knows exactly when halvings occur
- Sufficient notice: ~4 years is generous warning for any cleanup action
- Aligned incentives: As block rewards decrease, fee revenue and UTXO 
efficiency become more critical to network sustainability
- Natural cadence: The halving already represents a moment of network-wide 
coordination

Why not a one-time cleanup?

A one-time cleanup (as proposed by The Cat) provides temporary relief but 
creates no ongoing pressure against dust accumulation. Periodic enforcement:

- Establishes a permanent, predictable norm
- Removes any expectation that dust UTXOs have indefinite longevity
- Discourages business models built on dust creation
- Provides continuous UTXO set maintenance

Why pruning works without a list

A key insight enables pruning without maintaining a separate list: Bitcoin 
nodes already reject transactions that reference unknown outpoints. When a 
node receives a transaction spending an outpoint not in its UTXO set, it 
rejects it as invalid — the node doesn't need to know why the outpoint is 
missing (spent? never existed? pruned?).

After enforcement, a Lynx UTXO is functionally equivalent to a spent 
output. Nodes can simply delete it from the UTXO set. Any future 
transaction attempting to spend it will reference an outpoint the node 
doesn't recognize, and will be rejected through existing validation logic.

This means:

- No separate "Lynx list" is required
- No new validation logic is needed
- Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
- The UTXO set shrinks naturally as nodes prune

Why 999 sats?

The threshold of 999 sats is chosen because:

- Above all dust limits: Captures UTXOs at or below the dust limit for all 
script types (P2PKH: 546, P2TR: 330, etc.)
- Captures all standard inscriptions: Typical inscription UTXOs contain 
exactly 546 sats as "postage"; well under 999
- Simple and memorable: A clean number that's easy to communicate and 
reason about

Backward Compatibility

This is a soft fork. Nodes that do not upgrade will:

- Continue to consider all historical transactions valid
- Accept blocks that exclude spends of Lynx UTXOs
- Eventually converge with upgraded nodes (as upgraded miners will not 
include invalid spends)

Wallets & Services should:

- Warn users holding sub-threshold UTXOs after a snapshot block
- Provide consolidation tools during the grace period
- Update UTXO selection algorithms to deprioritize or exclude sub-threshold 
outputs approaching a snapshot

Security Considerations

No confiscation

This proposal does not transfer value to any party. Sub-threshold UTXOs 
become unspendable, similar to:

- Lost private keys
- Provably unspendable OP_RETURN outputs
- Satoshi's untouched coinbase rewards

The bitcoin supply cap remains unchanged; the affected outputs simply 
become irrecoverable. Holders receive ~4 years notice to consolidate if 
they value the sats.

Lightning Network

Some Lightning implementations create small HTLCs and dust outputs during 
channel operations. Analysis is needed to determine:

- Whether current dust thresholds affect normal LN operations
- If LN implementations need adjustment before activation
- Whether channel close scenarios create sub-threshold outputs

Preliminary assessment: LN dust limits are already set conservatively above 
relay dust limits, so impact should be minimal. However, this requires 
verification from LN implementers.

Fixed threshold vs. future fee markets

The 999 satoshi threshold is fixed in consensus rules and does not adjust 
based on fee market conditions. 
This is intentional:

- A fixed threshold provides certainty for users and developers
- If fee markets change dramatically, a future soft fork could adjust the 
threshold
- The ~4 year grace period allows the community to observe and adapt

If Bitcoin's fee market evolves such that 999 sats becomes economically 
significant to spend, this would indicate broader success of the network; 
and the community could choose to lower or eliminate the threshold through 
a subsequent proposal.

Acknowledgments
This proposal builds on the problem identification in "The Cat" 
(Non-monetary UTXO Cleanup) while proposing a list-free alternative 
mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
solving; Lynx offers a more neutral solution.


https://x.com/matteopelleg/status/2000602318346334449
On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:

I received no prior response from you, so I suspect the issue is on your 
end-- since if you sent one I would normally have been directly copied. 

In any case, your message makes no sense. If an output is provably 
unspendable then it is unspendable.  No amount of "clever steganography" 
can change that.   If you're imagining that perhaps they are *presumed* to 
be unspendable but actually *are* spendable, then sure that would be an 
issue but with any change to consensus relevant code great care must be 
taken to not introduce errors.  Actually *making* a consensus change would 
only increase the potential for mistakes.

These costs are just another reason why this hysteria over a non-issue is 
misplaced.

But in any case it is better that (any) implementations that care about 
stamps put in the effort to define their exclusions in ways that are safe 
than to burden everyone with a consensus change that doesn't care about it.


On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:

This is my third attempt to respond to this. Idk what is going wrong here.

The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without a 
consensus change is that a clever use of steganography could cause one of 
those otherwise unspendable outputs to be spendable, thus causing a fork 
between those nodes that adopted the Stamp pruning method and those that 
did not once one of those steganographic Stamps is spent. Though this is 
unlikely, it is still technically possible, and I would not put it past the 
denizens of the Internet to stir up trouble just for its own sake.

On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:

On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:

Since the Bitcoin Stamps outputs are already unspendable, it makes perfect 
sense to mark and drop them from the UTXO set.


There is no consensus change involved in not storing a provably unspendable 
output, it's just an implementation detail with no interoperability 
implications and doesn't need a BIP.  Bitcoin core has long done so for 
several types of unspendable outputs, e.g. outputs over 10kb and ones 
starting with OP_RETURN.

-- 
You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com.

To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
<https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com.

To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com 
<https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/cf39fdca-e996-43be-ab52-573aedd619d5n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 32530 bytes --]

^ permalink raw reply	[relevance 4%]

* [bitcoindev] Garbled Circuit and Channel Jamming
@ 2026-01-22  6:41  1% Antoine Riard
  2026-05-14  1:38  0% ` [bitcoindev] " Antoine Riard
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-01-22  6:41 UTC (permalink / raw)
  To: Bitcoin Development Mailing List; +Cc: btc

[-- Attachment #1: Type: text/plain, Size: 8684 bytes --]

Hi,

Recently, before the EoY vacation to be more precise, I gave a talk on the
BitVm
flavors and their advances, which was the opportunity to browse back a bit
the
old cryptographic primitive underpinning the claimed advances. One of such
primitive
is indeed the old idea of "garbled circuits" and how to order knowledge
transfer
among two distrusted parties [0].

What it's interesting for this class of cryptographic protocol is the wide
class
of secure multi-party game that can be built from it, and a bit of analysis
lets
you modelize quite easily channel jamming as a multi-party game (Alice,
Bob, Caroll
the next hop and the blockchain). Few years ago, when with Gleb Naumenko,
we studied
the solution design space for jamming, we briefly mentioned how "smart
contract"
(a.k.a something something covenant for more expressivity), could be a
potential
solution [1] [2].

Looking more on "garbled circuits" made me realize that actually we might
have already
the primitives to envision "native contract-based" solutions to the channel
jamming
problem, and this with no consensus change. I.e beyond the known "monetary
solutions"
and "reputation-based" solutions [3]

This is not the intent of this short post to discuss the merits of the
current
reputation-measured channel mitigation, which still have a lot of good
properties
like local vs global, monadic vs consensus, non-fungible vs fungible and
lightning-endogenous vs exogenous on some scarce ressource. Rather than
it's to
bring some prolegomena of a solution to the problem of a channel jamming,
as it has
been said elegantly and succintly:

"The holy grail? is indeed charging fees as a function of the time the HTLC
was held.
As for now, we are not aware of a reasonable way to do this. There is no
universal
clock, and there is no way for me to prove that a message was sent to you,
and you
decided to pretend you didn’t. It can easily happen that the fee for a
two-week
unresolved HTLC is higher than the fee for a quickly resolving one". [4]

Solving this problem, in my view, means to reconciliate the off-chain notion
of shared time among the 2 Lightning state machines with the on-chain
imperative
notion of time. A effective notion of time enabling one to determine
objectively
if an event did happen or not (e.g a message exchange) [0]. All the
difficulty
being that off-chain there is no such notion of shared time.

Let's start with a strawman protocol, that is moving one step closer to an
effective notion of shared time among 2 Lightnig state machines.

One way to solve channel jamming would be to have a (taproot) tree of
scripts
covering the whole time range for which the funds are locked in the offered
HTLC (so `<cltv_expiry>`). I.e for each block belonging to the cltv_expiry
range,
Bob pays Alice a penalty from his `counterparty_balance` (on Alice's
commitment_tx)
where "local channel time" is ticked by some monotonic counter. This tree of
scripts would become valid to be spend after some timelock enforced grace
delay.

It should be noted, that if the HTLC routing is extending beyond the reach
of
Bob, Bob has no guarantee that he will get the HTLC secret before the upper
bound of Alice's cover penaly script is reached on the Alice - Bob channel,
e.g
time T + 200

As soon as the offered HTLC has been committed on both parties commitment
transactions (Alice is the latest's one to receive the RAA), Alice and Bob
starts to exchange ping-pong messages where each message is increasing the
monotonic counter. Those messages might have as a data payload the preimage
for which the Alice to Bob offered HTLC is pending.

While Bob might have received the HTLC secret from Caroll at absolute
blockchain
time T + 100, and give it to Alice at time T + 110 i.e before the
expiration of
the hard `cltv_expiry`, Alice is always in a position to equivocate and
said she
never received the preimage from Bob ping-pong message.

So this strawman protocol is obviously broken.

Let's consider the same protocol, with few differences, the ping-pong
messages
between Alice and Bob are scheduled on some hearbeat rythm, so message
happens
every X, in way that Alice cannot guess if yes or no, a secret exchange did
happen
between Bob and Caroll about the next hop HTLC secret.

The penalty scripts are also modified where Bob can now prove a ping message
at time T + 110 has been viewed by Alice, with the correct HTLC secret. So
Alice would make a claim by broadcasting a transaction to claim the output,
and Bob would be able to dismiss the penaly with a valid proof of preimage
transfer.

Other modification, all ping-ping messages sent by Bob from Alice would be
now an oblivious transfer, where Alice would sign all the pongs and the
incremented counter [6], among those pongs would be a ciphered HTLC secret.
This mechanism allows Bob to obtain an off-chain proof (e.g go to unblind
the
signed HTLC secret) that Alice has seen a preimage at time T + 110, and they
can now update the HTLC commitment txn, back to the normal flow. If Alice
stucks
the channel, she "knows" that she would loss the proving game with Bob.

However, this strawman protocol still present 2 bottlenecks, that are
described
in their main lines.

One, there is no guarantee that Alice engage in the heartbeat protocol, so
the HTLC commitment transaction should present some scripting path where the
ping-pong messages are numbered, and if this has not reach some threshold
before the `cltv_expiry`, she got punished on her local balance. One
counterparty
should always engaged in the "amnesic" knowledge transfer, under the risk of
on-chain punishment.

Two, Alice and Caroll can always collude to have Bob never getting the HTLC
secret and as such being penalized with the highest fee on the Alice - Bob
channel. Somehow, Bob should be able to produce a proof proving that the
heartbeat protocol has played out in integrality on the Bob-Caroll channel
and that no HTLC secret was ever learn from Caroll. That's where "garbled
circuits" might be useful in minimizing the amount of knowledge leaked from
Bob-Caroll channel to Alice, while still ensuring fairness [7].

To conclude, this short post is advancing the idea that oblivious transfer
class of protocol, might be able to solve the channel jamming issue where
the messages are exchanged without all the parties "knowing" what has been
exchanged, and being punished by on-chain scripts, if the equivocate from
the knowledge transfer they engage into. I'm not making the claim that this
strawman protocol is fully sound game-theoretic wise, though I found if a
shared notions of time can be enforced among 2 Lightning channel
counterparties,
the implications are wider than just solving channel jamming.

Anyway, I don't have time to flush more the ideas exposed here [8], though I
was eager to mention them if some people are bored and wish to play with
interesting cryptographic primitives actually solving real-world lightning
problems.

Cheers,
Antoine
OTS hash: 98c12f58d4e39e85427cca156cc548d225b2ecb45296be70a93d3534b77aa1c7

[0] "How to Generate and Exchange Secrets" - Andrew Yao, 1986.
[1] See "Chapter 4 - Solution Design Space" - "Solving channel jamming
issue of the lightning network", Naumenko / Riard, 2022
[2] As the joking goes "Oh a workable solution to a bitcoin problem
involving
a consensus change, that's a very ice theoretical paper you've here, sir!".
[4] See for more - "Unjamming Lightning: A Systematic Approach",
Clara Shikhelman and Sergei Tikhomirov, 2022.
[4]
https://delvingbitcoin.org/t/fee-based-spam-prevention-for-lightning/1524/2
[5] "If a tree falls in the forest and no one is around to hear it, does it
make a sound ?" "A Network of Micropayments Channels Can Solve Scalability"
-
Lightning Network paper.
[6] E.g counter could fit in a nSequence field.
[7] I'm wawing aside the biggest witness trace that Lightning nodes might
have to pay, as one downside of this kind of solution compared to the other
ones.
[8] Yes, the subject would have deserved a real research paper, but writing
your
own bitcoin full-node it's real work, no kidding.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BGadRVjaRE%3DP7eVoPBA606-CkWP1erxCVQ%3DkPvN6zNJOg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 9556 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-30 14:36  1%               ` Antoine Riard
  2026-01-19  1:11  4%                 ` Pepe Hodler
@ 2026-01-22  1:14  1%                 ` Claire Ostrom
  1 sibling, 0 replies; 200+ results
From: Claire Ostrom @ 2026-01-22  1:14 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 30685 bytes --]

Hi list,

I’m reposting the reply below that I wrote on Dec 11. I later discovered I 
had accidentally emailed it directly to Greg instead of sending it to the 
list, and I wrongly inferred that it was being blocked. I then made public 
comments implying censorship, an embarrassing mistake that was entirely my 
own.

My apologies to the moderators, Greg, and anyone misled by that. I’m 
participating in good faith and want to keep the focus on the technical 
merits.

Here is the message as originally sent:

Hi Greg, 

When you say I misunderstood your quote, are you referring to the notion 
that you thought we should try to shape behavior? You also said your reason 
for caring about motivation in the first place was because you didn't want 
to give the wrong impression about what was "kosher". Both you and Sipa 
(who also stated in that thread "The problem is that people may see this as 
a legitimation of the storage in the first place, and encourage doing so 
even more.") seemed to be primarily motivated by the social signals that 
would be sent by allowing even a small amount of data to be used 
arbitrarily in the protocol, but felt (from my reading) that it may be 
worth the trade-off for, as you said, shaping users to more conservative 
needs.

I certainly appreciate your larger point here, where you state that current 
use has nullified previously effective means of curbing this behavior, and 
as you say, sometimes even further increasing it. This is precisely why my 
proposal exists as it does. It acknowledges that these attempts to "stop" 
the behavior are not effective against strong financial incentives to 
overcome them. They would also eventually lead to more harmful abuse; 
typically this filter discussion lands at the threat of fake pubkey use, 
which has generally been seen as the most harmful way to include data in 
the system.

My proposal attempts to destroy trust in those markets, to reduce the 
desire to spam in the first place. 

*"Were such a proposal seriously advanced it would likely cause a new flood 
of transactions both to move to evade it directly and as a result of NFT 
indexer changes to just "wormhole" the tokens to new outputs after the fact 
(and a new marketing opportunity for the NFT gifters).  NFTs are just an 
imaginary parallel world that don't depend on the network to validate their 
activity, so they don't really care about the network's rules, and as such 
the network's rules have pretty limited effect.  "*

I understand why you feel that way, but this is not the only way to look at 
it, and I'm glad we're able to have this discussion. I am not so naive 
about the behavior of these communities and have some experience with them 
in the past. You're right: every crypto asset is essentially a narrative.

Where I feel you don't give me enough credit is when you dismiss that the 
buyers of those narratives are apathetic towards them. One of the largest 
debates in the ordinal world was the value that the actual numbering system 
should have at all. The entire point of ordinal theory is that they number 
and value specific satoshi as non-fungible assets themselves. To suggest 
that they would be content to assign a new satoshi with their key, I think, 
underestimates how sentimental they are about their rules. It may seem like 
a silly delusion, but they obviously value them or they wouldn't spend so 
much on them. 

I think this would be a very effective measure against the types of trends 
we are seeing today, and materially reduce the UTXO set either way.

*"The proposed gain is some negligible one time reduction in utxo disk 
space. You motivated it by claiming this is a 'memory usage' reduction, but 
it's not-- it's just full node storage in particular as the txouts in 
question are normally sized and largely quiescent already-- so the savings 
is pretty insignificant. "*

I have a lot to learn, because reading this is a significant challenge to 
my worldview. I have been under the impression that bloat to the live state 
(chainstate) is one of the most harmful aspects of things like the 
fakepubkey threat. This becomes more nuanced when we think of future 
implementations that don't have a separate chainstate at all, but ignoring 
those, one of the central reasons stated for removing the recent OP_RETURN 
limits was to reduce potential UTXO bloat from applications like Citrea. 
There are several proposals now to address this bloat, and this is the 
first time I'm hearing someone consider 40% of the current state to be a 
*negligible *amount.

*"And moreover the proposal would intentionally and knowingly confiscate 
millions of dollars in funds.  This is outright theft, and I believe it 
makes the idea a total non-starter."*

Millions of dollars certainly seems like a lot of money, but these UTXOs 
are less than $1 on average. It is only due to the massive size of the 
stated problem that they collectively represent such a significant amount 
of funds. It's my contention that the users of these satoshi are not 
intending to use them for their satoshi value whatsoever. They are simply 
using these as data points tracked in a database to facilitate a gambling 
trend.

I don't say that to judge the behavior for moral reasons, but to highlight 
an abuse of the incentives in the Bitcoin network. The defense against dust 
spam in Bitcoin is the use of a fee market. This is a very effective 
incentive that makes it expensive and usually pointless to create a lot of 
smaller UTXOs rather than a few large ones. The problem with the abuse we 
see from schemes like ord is that they ignore this dynamic by adding an 
external incentive that pays much more than the satoshi themselves are 
worth, sidestepping the filter and creating a dynamic that was never 
imagined by the design.

As an open system, this kind of abuse is hard to stop once it starts. My 
proposal stands as a way to address it and add new dynamics that aim to 
reduce the demand for such behavior by understanding it and addressing it 
in a way specific to its creation, which is to destroy trust in the markets 
that cause them. I presume you would not even be okay with the potential 
burning of a single satoshi even if it meant clearing up something people 
felt was a material problem to the network, so of course you'll certainly 
take issue with this. It is thanks in part to your uncompromising culture 
that protects what Bitcoin is in the first place. 

*"As an aside, since the idea fails so easily on basic principled grounds 
it's a disrespectful waste of participants time to advance a proposal at 
such length and *technobabbly* depth which could have been floated with a 
single sentence "How would people feel about a proposal to discourage NFTs 
by identifying a snapshot of existing dust-value NFT outputs and making 
spending them consensus invalid?"  or similar.   Much of the opposition to 
LLM use in the field of BIP discussion has been due to widespread misuse of 
LLMs to create thickets of dense language and obscure non-starter, trivial, 
or ill considered proposals making them much more costly to deal with and 
discouraging serious and thoughtful review of *all* ongoing discussion."*

This is a very fair point; in hindsight I feel my proposal was much too 
detailed for this stage of discussion. To be honest, I felt intimidated 
proposing to this list and wanted to be sure that I had put in enough work 
to demonstrate the seriousness of my idea. I think I could have done it 
with a summary that linked to additional details instead.

I did not use an LLM to create my proposal, though I do use LLMs as a tool 
for research and occasional formatting. I do not think LLMs should be used 
in place of human ideas. My proposal was written by me (and the friends who 
helped me) in every part, and only edited for style or grammar by a machine.

On Tuesday, December 30, 2025 at 9:51:56 AM UTC-5 Antoine Riard wrote:

> Hi list,
>
> > Which brings me to my disagreement, which I know is not shared by a 
> number of contributors here: just as it is hard to define spam on Bitcoin, 
> it's also very hard to define it in a discussion forum like this one. 
> Making suggestions which *I* think are terrible, or detrimental, on a list 
> like this, should never be disallowed here. Notions of motivation of 
> contributors (such as they are paid by such and such a company) should not 
> be relevant. Everything should be open to discussion which is 
> implementation-technical (so obviously not e.g. threats of violence or 
> things that bring legal liability to participants or have zero relevance to 
> Bitcoin's technical development) even if it's philosophy-motivated. And 
> blocking should be reserved either as an anti-DOS measure if volume gets 
> out of control, or if it brings dangers as per the previous parenthetical.
>
> I'm fully sharing waxwing reasonable opinion. While I can understand 
> gmax's sentiment being fed
> up with poor coin confiscation proposals again and again on the mailing 
> list, the cure would be
> worst than the disease. Maybe, I'm very voltairean here, but you don't 
> fight ill-founded opinions.
> by persecuting their authors (--otherwise, down the road you take the risk 
> of seeing the bastille
> popped up). Rather than you fight them back by doing the work to persuade 
> and to convince those
> ideas you find stupid are indeed *objectively* stupid.
>
> To me, it's a sign of strength and confidence that Bitcoin and its 
> development process can
> withstand and endure the most "outrageous" controversies. For sure, I have 
> been enough times
> in the shoes of someone who has to champion controversial changes (cf. 
> `mempoolfullrbf`) to not
> negate that the strength of the process is kinda traded on the back of the 
> devs, but this is not
> altering my mind on what I think should be *ideally* the development 
> process in terms of openess
> and publicity.
>
> My humble opinion only, as we said.
>
> Best,
> Antoine
> OTS hash: 5c1c19f589a61787dbf483cd6814f094c3b24888d6d189c5f4d776bda558e1ce
> Le mercredi 24 décembre 2025 à 17:23:48 UTC, waxwing/ AdamISZ a écrit :
>
>> Hi Greg, list:
>>
>> > I think the list should adopt a 1 year ban on parties *and their* 
>> employer(s) (if known) for any coin confiscation proposal on the list going 
>> forward (after, of course, making the rule clear on the signup page).  It's 
>> tiresome and beyond being a waste of time risks undermining public 
>> confidence in Bitcoin to see the constant trickle of these 
>> outrageous proposals in venues where they previously understood that 
>> serious discussions were to be had. People are, of course, free to discuss 
>> whatever ill-founded concepts they want but they're not entitled to the 
>> time and the reputation of the participants here for offensively misguided 
>> proposals. 
>>
>> I'm a huge agree-er with the motivation of this comment and a huge 
>> disagree-er with the suggestion itself.
>>
>> Actual confiscation, whatever the reason, hugely undermines Bitcoin's 
>> value to humanity - note I am not saying its financial value, but value as 
>> a project (and if we didn't see such value what the hell are we doing 
>> here). Of course those two types of value are very closely linked, but they 
>> are still distinct. I hold that same belief even when we are talking about 
>> other suggestions of confiscation, such as to address a quantum threat - 
>> something that has recently been discussed here, extensively.
>>
>> Which brings me to my disagreement, which I know is not shared by a 
>> number of contributors here: just as it is hard to define spam on Bitcoin, 
>> it's also very hard to define it in a discussion forum like this one. 
>> Making suggestions which *I* think are terrible, or detrimental, on a list 
>> like this, should never be disallowed here. Notions of motivation of 
>> contributors (such as they are paid by such and such a company) should not 
>> be relevant. Everything should be open to discussion which is 
>> implementation-technical (so obviously not e.g. threats of violence or 
>> things that bring legal liability to participants or have zero relevance to 
>> Bitcoin's technical development) even if it's philosophy-motivated. And 
>> blocking should be reserved either as an anti-DOS measure if volume gets 
>> out of control, or if it brings dangers as per the previous parenthetical.
>>
>> Just my opinion of course, I know that moderation of lists is not a 
>> simple matter.
>>
>> Cheers,
>> AdamISZ/waxwing
>> On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:
>>
>>> The 'dust threshold' isn't a consensus parameter, it's just a number 
>>> pulled out of the air that didn't seem unreasonable based on average fee 
>>> behavior.  But in any particular block transactions may need no particular 
>>> fee level at all, including zero fees.  And in some cases it may be very 
>>> economically advantageous to spend an output even if its face value doesn't 
>>> support it, NFT's being a one such example (although one I consider pretty 
>>> dumb).
>>>  
>>> This proposal also appears to have ignored the prior discussion 
>>> particularly where it was pointed out that 'deleting' outputs will not 
>>> achieve the goal of deleting the tokens connected to them (so won't 
>>> eliminate the incentive), or that txouts which are predictably not going to 
>>> be accessed (as this proposal claims applies to the txouts it targets) 
>>> don't have as significant performance implications (because they don't need 
>>> to be cached in ram).  It also appears to be uninformed by advances like 
>>> utxotree which makes the absolute size of the txout set much less 
>>> important, but would make mass removals such as that described 
>>> here expensive.  Nor has it considered that given the level of fee spending 
>>> on NFT traffic a requirement to keep it over some (reasonable) threshold 
>>> would not likely discourage it, or the fact that existent NFT outputs are 
>>> generally over the dust limit in any case (so the proposals failure to meet 
>>> the opcat proponents' delusional goals is already clear).
>>>
>>> I think the list should adopt a 1 year ban on parties *and their* 
>>> employer(s) (if known) for any coin confiscation proposal on the list going 
>>> forward (after, of course, making the rule clear on the signup page).  It's 
>>> tiresome and beyond being a waste of time risks undermining public 
>>> confidence in Bitcoin to see the constant trickle of these 
>>> outrageous proposals in venues where they previously understood that 
>>> serious discussions were to be had. People are, of course, free to discuss 
>>> whatever ill-founded concepts they want but they're not entitled to the 
>>> time and the reputation of the participants here for offensively misguided 
>>> proposals. 
>>>
>>>
>>> On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:
>>>
>>>> Good evening all,
>>>>
>>>> Here is a related proposal by Matteo Pellegrini
>>>> @matteopelleg
>>>>
>>>>
>>>>
>>>> Lynx.
>>>>
>>>> Abstract
>>>> This proposal introduces a periodic, consensus-enforced mechanism for 
>>>> rendering UTXOs below the network's dust threshold permanently unspendable. 
>>>> At each halving block, UTXOs that have remained below the dust threshold 
>>>> since the previous halving become unspendable. These UTXOs become 
>>>> unspendable and may be pruned from the UTXO set entirely, reducing node 
>>>> storage requirements and eliminating the economic model that incentivizes 
>>>> their creation.
>>>>
>>>> Motivation
>>>> The Bitcoin UTXO set has grown substantially due to various factors, 
>>>> including inscription protocols, spam attacks, and general dust 
>>>> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
>>>> Cleanup) by @ostrom72158
>>>>   have attempted to address this by creating lists of specific UTXOs to 
>>>> render unspendable, identified by external protocol indexers.
>>>>
>>>> The Cat's approach has a fatal flaw: it relies on a list.
>>>>
>>>> Using a curated list of "non-monetary UTXOs" introduces several 
>>>> problems:
>>>>
>>>> 1) External dependency: The Cat requires reference indexers (Ord, 
>>>> Stamps, etc.) to define which UTXOs qualify. This introduces 
>>>> consensus-level dependency on external, non-Bitcoin software that can 
>>>> change, have bugs, or interpret protocols differently.
>>>>
>>>> 2) Protocol targeting: By specifically identifying inscription and 
>>>> stamp outputs, the proposal makes subjective judgments about which Bitcoin 
>>>> uses are legitimate. This sets a precedent for protocol-level 
>>>> discrimination.
>>>>
>>>> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
>>>> workarounds. If Ordinals dust is targeted, protocols will adapt to create 
>>>> dust that doesn't match the list criteria.
>>>>
>>>> 4) Static snapshot: A one-time list cleanup provides temporary relief 
>>>> but does nothing for future UTXO accumulation.
>>>>
>>>> 5) Political vulnerability: Any list-based approach requires ongoing 
>>>> governance decisions about what belongs on the list, creating a permanent 
>>>> political attack surface.
>>>>
>>>> A better approach targets the economic reality, not the use case.
>>>>
>>>> UTXOs below the dust threshold are, by definition, economically 
>>>> irrational to spend under normal fee conditions. The dust limit exists 
>>>> precisely because spending these outputs costs more in fees than the output 
>>>> is worth. These UTXOs are already "dead" in practice; this proposal simply 
>>>> makes that reality explicit at the consensus layer.
>>>>
>>>> By using a threshold rather than a list, Lynx:
>>>>
>>>> - Requires no external indexers
>>>> - Makes no judgment about why a UTXO is small
>>>> - Applies equally to all participants
>>>> - Provides ongoing, predictable maintenance
>>>> - Removes political discretion from the process
>>>>
>>>> Impact on Inscription Protocols
>>>>
>>>> The typical Ordinals inscription is stored in a UTXO containing exactly 
>>>> 546 sats; the minimum required to meet the dust limit for P2PKH addresses 
>>>> and ensure transferability across all address types. This "postage" amount 
>>>> is standard across inscription tooling and marketplaces.
>>>>
>>>> A threshold of 999 sats captures the vast majority of inscription UTXOs 
>>>> without requiring any protocol-specific targeting. The economic model of 
>>>> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
>>>> that model through neutral, threshold-based rules rather than list-based 
>>>> discrimination.
>>>>
>>>> Specification
>>>>
>>>> Definitions
>>>>
>>>> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats 
>>>> is subject to Lynx enforcement.
>>>>
>>>> - Halving block: A block at height N * 210,000 where N ≥ 1.
>>>>
>>>> -  Snapshot block: A halving block at which the current dust threshold 
>>>> and qualifying UTXOs are recorded.
>>>>
>>>> -  Enforcement block: The halving block following a snapshot block 
>>>> (i.e., snapshot block + 210,000 blocks).
>>>>
>>>> Lynx UTXOs:
>>>> - Existed at the snapshot block
>>>> - Had a value less than 999 sats
>>>> - Remained unspent through the enforcement period (~4 years)
>>>>
>>>> Consensus Rules
>>>> After activation, the following rules apply:
>>>>
>>>> 1) Snapshot: At each halving block H, record the set of all UTXOs with 
>>>> value < 999 sats.
>>>>
>>>> 2) Enforcement: At halving block H + 210,000:
>>>> - Any UTXO that was in the snapshot set and remains unspent becomes 
>>>> permanently unspendable
>>>> - Transactions attempting to spend these UTXOs are invalid
>>>>
>>>> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their 
>>>> local UTXO set. Transactions referencing unknown outpoints are already 
>>>> rejected as invalid; pruned Lynx UTXOs are simply treated as if they were 
>>>> already spent.
>>>>
>>>> 4) Grace period: The ~4 year window between snapshot and enforcement 
>>>> provides ample time for holders to consolidate sub-dust UTXOs if they wish 
>>>> to preserve the value.
>>>>
>>>> Activation
>>>>
>>>> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
>>>> determined by community consensus)
>>>>
>>>> Recommended first snapshot: The halving following activation lock-in
>>>>
>>>> Rationale
>>>>
>>>> Why a fixed threshold?
>>>>
>>>> Using a fixed threshold of 999 sats rather than referencing the dynamic 
>>>> relay dust limit provides:
>>>>
>>>> - Simplicity: One number, no script-type variations, no need to query 
>>>> policy settings
>>>>
>>>> - Predictability: Everyone knows exactly what qualifies, forever
>>>>
>>>> - Consensus clarity: No ambiguity about which outputs are affected.
>>>>
>>>> Why tie to the halving?
>>>>
>>>> The halving is Bitcoin's most recognized Schelling point, using it 
>>>> provides:
>>>>
>>>> - Predictability: Everyone knows exactly when halvings occur
>>>> - Sufficient notice: ~4 years is generous warning for any cleanup action
>>>> - Aligned incentives: As block rewards decrease, fee revenue and UTXO 
>>>> efficiency become more critical to network sustainability
>>>> - Natural cadence: The halving already represents a moment of 
>>>> network-wide coordination
>>>>
>>>> Why not a one-time cleanup?
>>>>
>>>> A one-time cleanup (as proposed by The Cat) provides temporary relief 
>>>> but creates no ongoing pressure against dust accumulation. Periodic 
>>>> enforcement:
>>>>
>>>> - Establishes a permanent, predictable norm
>>>> - Removes any expectation that dust UTXOs have indefinite longevity
>>>> - Discourages business models built on dust creation
>>>> - Provides continuous UTXO set maintenance
>>>>
>>>> Why pruning works without a list
>>>>
>>>> A key insight enables pruning without maintaining a separate list: 
>>>> Bitcoin nodes already reject transactions that reference unknown outpoints. 
>>>> When a node receives a transaction spending an outpoint not in its UTXO 
>>>> set, it rejects it as invalid — the node doesn't need to know why the 
>>>> outpoint is missing (spent? never existed? pruned?).
>>>>
>>>> After enforcement, a Lynx UTXO is functionally equivalent to a spent 
>>>> output. Nodes can simply delete it from the UTXO set. Any future 
>>>> transaction attempting to spend it will reference an outpoint the node 
>>>> doesn't recognize, and will be rejected through existing validation logic.
>>>>
>>>> This means:
>>>>
>>>> - No separate "Lynx list" is required
>>>> - No new validation logic is needed
>>>> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
>>>> - The UTXO set shrinks naturally as nodes prune
>>>>
>>>> Why 999 sats?
>>>>
>>>> The threshold of 999 sats is chosen because:
>>>>
>>>> - Above all dust limits: Captures UTXOs at or below the dust limit for 
>>>> all script types (P2PKH: 546, P2TR: 330, etc.)
>>>> - Captures all standard inscriptions: Typical inscription UTXOs contain 
>>>> exactly 546 sats as "postage"; well under 999
>>>> - Simple and memorable: A clean number that's easy to communicate and 
>>>> reason about
>>>>
>>>> Backward Compatibility
>>>>
>>>> This is a soft fork. Nodes that do not upgrade will:
>>>>
>>>> - Continue to consider all historical transactions valid
>>>> - Accept blocks that exclude spends of Lynx UTXOs
>>>> - Eventually converge with upgraded nodes (as upgraded miners will not 
>>>> include invalid spends)
>>>>
>>>> Wallets & Services should:
>>>>
>>>> - Warn users holding sub-threshold UTXOs after a snapshot block
>>>> - Provide consolidation tools during the grace period
>>>> - Update UTXO selection algorithms to deprioritize or exclude 
>>>> sub-threshold outputs approaching a snapshot
>>>>
>>>> Security Considerations
>>>>
>>>> No confiscation
>>>>
>>>> This proposal does not transfer value to any party. Sub-threshold UTXOs 
>>>> become unspendable, similar to:
>>>>
>>>> - Lost private keys
>>>> - Provably unspendable OP_RETURN outputs
>>>> - Satoshi's untouched coinbase rewards
>>>>
>>>> The bitcoin supply cap remains unchanged; the affected outputs simply 
>>>> become irrecoverable. Holders receive ~4 years notice to consolidate if 
>>>> they value the sats.
>>>>
>>>> Lightning Network
>>>>
>>>> Some Lightning implementations create small HTLCs and dust outputs 
>>>> during channel operations. Analysis is needed to determine:
>>>>
>>>> - Whether current dust thresholds affect normal LN operations
>>>> - If LN implementations need adjustment before activation
>>>> - Whether channel close scenarios create sub-threshold outputs
>>>>
>>>> Preliminary assessment: LN dust limits are already set conservatively 
>>>> above relay dust limits, so impact should be minimal. However, this 
>>>> requires verification from LN implementers.
>>>>
>>>> Fixed threshold vs. future fee markets
>>>>
>>>> The 999 satoshi threshold is fixed in consensus rules and does not 
>>>> adjust based on fee market conditions. 
>>>> This is intentional:
>>>>
>>>> - A fixed threshold provides certainty for users and developers
>>>> - If fee markets change dramatically, a future soft fork could adjust 
>>>> the threshold
>>>> - The ~4 year grace period allows the community to observe and adapt
>>>>
>>>> If Bitcoin's fee market evolves such that 999 sats becomes economically 
>>>> significant to spend, this would indicate broader success of the network; 
>>>> and the community could choose to lower or eliminate the threshold through 
>>>> a subsequent proposal.
>>>>
>>>> Acknowledgments
>>>> This proposal builds on the problem identification in "The Cat" 
>>>> (Non-monetary UTXO Cleanup) while proposing a list-free alternative 
>>>> mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
>>>> solving; Lynx offers a more neutral solution.
>>>>
>>>>
>>>> https://x.com/matteopelleg/status/2000602318346334449
>>>> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>>>>
>>>>> I received no prior response from you, so I suspect the issue is on 
>>>>> your end-- since if you sent one I would normally have been directly 
>>>>> copied. 
>>>>>
>>>>> In any case, your message makes no sense. If an output is provably 
>>>>> unspendable then it is unspendable.  No amount of "clever steganography" 
>>>>> can change that.   If you're imagining that perhaps they are *presumed* to 
>>>>> be unspendable but actually *are* spendable, then sure that would be an 
>>>>> issue but with any change to consensus relevant code great care must be 
>>>>> taken to not introduce errors.  Actually *making* a consensus change would 
>>>>> only increase the potential for mistakes.
>>>>>
>>>>> These costs are just another reason why this hysteria over a non-issue 
>>>>> is misplaced.
>>>>>
>>>>> But in any case it is better that (any) implementations that care 
>>>>> about stamps put in the effort to define their exclusions in ways that are 
>>>>> safe than to burden everyone with a consensus change that doesn't care 
>>>>> about it.
>>>>>
>>>>>
>>>>> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> 
>>>>> wrote:
>>>>>
>>>>>> This is my third attempt to respond to this. Idk what is going wrong 
>>>>>> here.
>>>>>>
>>>>>> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set 
>>>>>> without a consensus change is that a clever use of steganography could 
>>>>>> cause one of those otherwise unspendable outputs to be spendable, thus 
>>>>>> causing a fork between those nodes that adopted the Stamp pruning method 
>>>>>> and those that did not once one of those steganographic Stamps is spent. 
>>>>>> Though this is unlikely, it is still technically possible, and I would not 
>>>>>> put it past the denizens of the Internet to stir up trouble just for its 
>>>>>> own sake.
>>>>>>
>>>>>> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>>>>>>
>>>>>>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> 
>>>>>>> wrote:
>>>>>>>
>>>>>>>> Since the Bitcoin Stamps outputs are already unspendable, it makes 
>>>>>>>> perfect sense to mark and drop them from the UTXO set.
>>>>>>>
>>>>>>>
>>>>>>> There is no consensus change involved in not storing a provably 
>>>>>>> unspendable output, it's just an implementation detail with no 
>>>>>>> interoperability implications and doesn't need a BIP.  Bitcoin core has 
>>>>>>> long done so for several types of unspendable outputs, e.g. outputs over 
>>>>>>> 10kb and ones starting with OP_RETURN.
>>>>>>>
>>>>>>> -- 
>>>>>> You received this message because you are subscribed to the Google 
>>>>>> Groups "Bitcoin Development Mailing List" group.
>>>>>> To unsubscribe from this group and stop receiving emails from it, 
>>>>>> send an email to bitcoindev+...@googlegroups.com.
>>>>>>
>>>>> To view this discussion visit 
>>>>>> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
>>>>>> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>>>> .
>>>>>>
>>>>> -- 
>>>> You received this message because you are subscribed to the Google 
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send 
>>>> an email to bitcoindev+...@googlegroups.com.
>>>>
>>> To view this discussion visit 
>>>> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com 
>>>> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>> .
>>>>
>>>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/521249b0-a9a8-4fc1-b975-c6c80b8ddb01n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 33778 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-14 15:33  0%         ` 'Antoine Poinsot' via Bitcoin Development Mailing List
@ 2026-01-14 18:58  0%           ` Murch
  2026-01-30  4:08  1%             ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: Murch @ 2026-01-14 18:58 UTC (permalink / raw)
  To: Antoine Poinsot, Sjors Provoost; +Cc: bitcoindev

Ah right, the Merkle root is calculated based on the stripped 
transaction, and therefore AJ’s idea works fine. Nevermind, carry on!

Thanks,
Murch

On 2026-01-14 07:33, Antoine Poinsot wrote:
> Thanks everyone for the comments.
>
> Sjors, transactions are serialized in modern blocks as described by Murch.
>
> Murch, for the purpose of computing the Merkle root transactions are serialized without witness data.
>
> Best,
> Antoine
>
>
>
> On Wednesday, January 14th, 2026 at 5:23 AM, Sjors Provoost <sjors@sprovoost.nl> wrote:
>
>> Hi Murch,
>>
>> You're referring to the "serialization with witness data" defined in BIP 141.
>>
>> But that's not how the transaction is serialised in a block, since the witness is
>> segregated.
>>
>>> The witness is committed in a tree that is nested into the block's existing
>> merkle root via the coinbase transaction for the purpose of making this BIP
>> soft fork compatible. A future hard fork can place this tree in its own branch.
>>
>> As long as the miner doesn't touch the SegWit OP_RETURN , which also commits
>> to the coinbase witness, it can safely use the legacy transaction serialisation.
>>
>> - Sjors
>>
>> [0] https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id
>>
>>> Op 14 jan 2026, om 01:23 heeft Murch murch@murch.one het volgende geschreven:
>>>
>>> Hi Sjors,
>>>
>>> On 2026-01-08 00:30, Sjors Provoost wrote:
>>>
>>>> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
>>>> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
>>>> better, but not because like nLockTime it has a small hashing midstate
>>>> benefit. It's easier to implement.
>>>> I can’t access Delving right now to read AJ’s comment, but a small nit on the idea of using an additional output: BIP 141 requires coinbase transaction inputs to have a 32-byte witness. Since the witness section follows the outputs in the serialization, the bytes before the `nLocktime` in a coinbase transaction are the witness of the coinbase input, not the last output script.
>>> -Murch
>> --
>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1dd74f45-bd0a-4fd7-bf80-56a3b2a44128%40murch.one.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-14 10:15  1%       ` Sjors Provoost
@ 2026-01-14 15:33  0%         ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  2026-01-14 18:58  0%           ` Murch
  0 siblings, 1 reply; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2026-01-14 15:33 UTC (permalink / raw)
  To: Murch, Sjors Provoost; +Cc: bitcoindev

Thanks everyone for the comments.

Sjors, transactions are serialized in modern blocks as described by Murch.

Murch, for the purpose of computing the Merkle root transactions are serialized without witness data.

Best,
Antoine



On Wednesday, January 14th, 2026 at 5:23 AM, Sjors Provoost <sjors@sprovoost.nl> wrote:

> 
> 
> Hi Murch,
> 
> You're referring to the "serialization with witness data" defined in BIP 141.
> 
> But that's not how the transaction is serialised in a block, since the witness is
> segregated.
> 
> > The witness is committed in a tree that is nested into the block's existing
> 
> merkle root via the coinbase transaction for the purpose of making this BIP
> soft fork compatible. A future hard fork can place this tree in its own branch.
> 
> As long as the miner doesn't touch the SegWit OP_RETURN , which also commits
> to the coinbase witness, it can safely use the legacy transaction serialisation.
> 
> - Sjors
> 
> [0] https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id
> 
> > Op 14 jan 2026, om 01:23 heeft Murch murch@murch.one het volgende geschreven:
> > 
> > Hi Sjors,
> > 
> > On 2026-01-08 00:30, Sjors Provoost wrote:
> > 
> > > The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
> > > padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
> > > better, but not because like nLockTime it has a small hashing midstate
> > > benefit. It's easier to implement.
> > > I can’t access Delving right now to read AJ’s comment, but a small nit on the idea of using an additional output: BIP 141 requires coinbase transaction inputs to have a 32-byte witness. Since the witness section follows the outputs in the serialization, the bytes before the `nLocktime` in a coinbase transaction are the witness of the coinbase input, not the last output script.
> > 
> > -Murch
> 
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/_C0iWeaJ-v24dZgcdCnKZKEgK9E493DmpG_-wD1NZnOAuECi97dZpVLuZxkONIfZjTe7km_TWFdSFfmSzVWfJ5Lkz6JTc8JwDOTg9XAInVo%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-14  0:23  0%     ` Murch
@ 2026-01-14 10:15  1%       ` Sjors Provoost
  2026-01-14 15:33  0%         ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Sjors Provoost @ 2026-01-14 10:15 UTC (permalink / raw)
  To: bitcoindev; +Cc: Murch

Hi Murch,

You're referring to the "serialization with witness data" defined in BIP 141.

But that's not how the transaction is serialised in a block, since the witness is
segregated.

> The witness is committed in a tree that is nested into the block's existing
merkle root via the coinbase transaction for the purpose of making this BIP
soft fork compatible. A future hard fork can place this tree in its own branch.

As long as the miner doesn't touch the SegWit OP_RETURN , which also commits
to the coinbase witness, it can safely use the legacy transaction serialisation.

- Sjors

[0] https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-id

> Op 14 jan 2026, om 01:23 heeft Murch <murch@murch.one> het volgende geschreven:
> 
> Hi Sjors,
> 
> On 2026-01-08 00:30, Sjors Provoost wrote:
>> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
>> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
>> better, but not because like nLockTime it has a small hashing midstate
>> benefit. It's easier to implement.
> I can’t access Delving right now to read AJ’s comment, but a small nit on the idea of using an additional output: BIP 141 requires coinbase transaction inputs to have a 32-byte witness. Since the witness section follows the outputs in the serialization, the bytes before the `nLocktime` in a coinbase transaction are the witness of the coinbase input, not the last output script.
> 
> -Murch

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1B807731-DC2A-4E59-B462-5C210EF1FB73%40sprovoost.nl.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-08  8:30  1%   ` [bitcoindev] " Sjors Provoost
                       ` (2 preceding siblings ...)
  2026-01-13  1:49  1%     ` Antoine Riard
@ 2026-01-14  0:23  0%     ` Murch
  2026-01-14 10:15  1%       ` Sjors Provoost
  3 siblings, 1 reply; 200+ results
From: Murch @ 2026-01-14  0:23 UTC (permalink / raw)
  To: bitcoindev; +Cc: Sjors Provoost

Hi Sjors,

On 2026-01-08 00:30, Sjors Provoost wrote:
> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
> better, but not because like nLockTime it has a small hashing midstate
> benefit. It's easier to implement.
I can’t access Delving right now to read AJ’s comment, but a small nit 
on the idea of using an additional output: BIP 141 requires coinbase 
transaction inputs to have a 32-byte witness. Since the witness section 
follows the outputs in the serialization, the bytes before the 
`nLocktime` in a coinbase transaction are the witness of the coinbase 
input, not the last output script.

-Murch

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/492f9bba-8a1f-4fa2-8618-98bd564a6178%40murch.one.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-13  2:16  0%       ` Antoine Riard
@ 2026-01-13 16:59  0%         ` Mubarek Juhar
  0 siblings, 0 replies; 200+ results
From: Mubarek Juhar @ 2026-01-13 16:59 UTC (permalink / raw)
  To: Antoine Riard
  Cc: Matt Corallo, Sjors Provoost, Bitcoin Development Mailing List,
	Antoine Poinsot

[-- Attachment #1: Type: text/plain, Size: 8242 bytes --]

Subject
Re: Coinbase extranonce and nLockTime
Hi all, thanks for the clarifications. While the coinbase scriptSig is
consensus-limited to 100 bytes, it still provides more than enough entropy
when combined with nTime, nVersion (BIP310), and the header nonce, so
search space exhaustion is not a practical concern today. Although
nLockTime is attractive as a fixed-offset field, it is not free to roll due
to its consensus semantics and limited validity window, which likely
explains why it hasn’t seen adoption in the wild. In practice, extranonce
handling already occurs at the controller or proxy level under Stratum
v1/v2, meaning serialization complexity exists regardless of which coinbase
field is varied. Given that current approaches scale to existing hash
rates, this feels less like a performance issue and more like a
future-proofing and design-hygiene discussion, where preserving flexibility
in the coinbase seems prudent.
Best,
Mubarek

On Tue, Jan 13, 2026, 5:55 AM Antoine Riard <antoine.riard@gmail.com> wrote:

> Hi Corallo,
>
> > Assuming some future change to stratum v1/v2 to allow for this (which I
> think is basically a "never
> > going to happen"), its worth noting that you can't just roll it for free.
>
> This is not like there have been a multitude of pooling protocols deployed
> in the past, all with
> their awful long-polling mechanisms and other tricks. Saying we should
> only consider stratum
> v1/v2 in matters of consensus-design it can be a bit blindsighted imho. As
> of today block
> height, considering the situation where it's height-based locktime, that
> would be 19-bit
> that you could use as an extranonce, if my measurements are correct.
>
> On the other hand, making the coinbase transaction with an always valid
> coinbase's nLocktime
> transaction, this opens the door in terms of off-chain protocols and
> use-case design (e.g
> proof-of-work swap), where now you can use the consensus mandatory check
> of the coinbase
> nLocktime's field as a novel building block primitive.
>
> Best,
> Antoine
> OTS hash: 45f28303770b376e2ae8f9e0072ae236d2b42aa4c84036f87ec9903a74a385b3
>
> Le jeu. 8 janv. 2026 à 16:36, Matt Corallo <lf-lists@mattcorallo.com> a
> écrit :
>
>>
>>
>> On 1/8/26 3:30 AM, Sjors Provoost wrote:
>> > Hello Riard,
>> >
>> >> Thanks for the update. If I'm understanding correctly Luke's concern,
>> >> currently the coinbase's scriptSig is used to store an extranonce. One
>> >> has to observe first there is no consensus limit on the size of a
>> >> transaction, which holds for the coinbase tx too, a fortiori there is
>> >> no limit on the extranonce size a miner could fit in the scriptSig.
>> >
>> >
>> > The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as
>> to
>> > why [1].
>> >
>> > The main issue I see is complexity of implementation. The nLockTime is
>> always
>> > the last 4 bytes of a transaction, so an ASIC can roll it without
>> having to
>> > understand anything about serialisation.
>>
>> Assuming some future change to stratum v1/v2 to allow for this (which I
>> think is basically a "never
>> going to happen"), its worth noting that you can't just roll it for free.
>> Its already the case that
>> nLockTime has consensus meaning on the coinbase transaction - its
>> enforced like any other block. So
>> there's relatively little rolling you can do until you get to the current
>> block height and have to
>> go do something else (I imagine this is why its not been used for this
>> purpose in the past, at least
>> in part). So the ASIC actually has to understand quite a bit to roll this.
>>
>> Instead, in practice, ASICs (or their controllers) roll nTime, which is
>> even better cause its in the
>> header and you know you can ~always roll it once a second. Then rolling a
>> nonce in the coinbase is
>> easy cause you can just do it in the controller and get plenty of
>> headroom on the ASIC itself with
>> nTime and a few midstates.
>>
>> > The scriptSig OTOH is variable length, so it needs to read the length
>> byte in
>> > order to figure out which 4 bytes are at the end. The pool or proxy
>> then also
>> > needs to ensure those 4 bytes are pre-initialised*.
>> >
>> > The approach suggested by Towns [4] of appending a 0-sat OP_RETURN
>> output with
>> > padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is
>> probably
>> > better, but not because like nLockTime it has a small hashing midstate
>> > benefit. It's easier to implement.
>> >
>> > Compared to varying the end of the scriptSig, this can be easier for an
>> ASIC
>> > because it can update a fixed 4-byte field at a known offset from the
>> end,
>> > rather than having to parse variable-length fields (notably the
>> scriptSig
>> > length) to locate the bytes to roll.
>> >
>> > I think that extra complexity is doable and justifiable, but I've never
>> built an ASIC.
>> >
>> > Note that today Stratum v1 simply splits the scriptSig [5] into two
>> parts, as does
>> > Stratum v2 [3], but presumably that's all done by the control board and
>> it makes
>> > sense to want to push rolling functionally into the ASIC silicon, where
>> even
>> > simple concatenation might be too involved - but updating bytes at known
>> > positions is easy.
>> >
>> >> The point being made is that the nLocktime field of the coinbase
>> >> transaction could be used as a more efficient extra nonce due to
>> >> the positional location of nLocktime in a serialized coinbase being
>> >> one of the latest message block to be processed [0].
>> >>
>> >> Nothing prevent a miner in already doing this and draw a speed
>> advantage
>> >> from the diminished computational work. I have not looked into CGminer
>> code
>> >> or one of its derivative forks, if there is an implemented option to
>> do that,
>> >> but yes there could be non-published existing mining firmware doing
>> it. IIUC,
>> >> BIP54 would nullify this theoretical "speed advantage" for all miners.
>> >
>> > I don't think there's currently a speed advantage, so I wouldn't expect
>> to observe
>> > this behaviour in the wild just yet. The combination of rolling nVersion
>> > (BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.
>> >
>> > Beyond that an ASIC will need to touch the coinbase.
>> >
>> > - Sjors
>> >
>> > [0]
>> https://github.com/bitcoin/bitcoin/blob/v30.1/src/consensus/tx_check.cpp#L47-L51
>> > [1]
>> https://bitcoin.stackexchange.com/questions/35455/why-bother-having-limitations-on-bitcoin-coinbase-transaction-scriptsigs
>> > [2] https://github.com/bitcoin/bips/blob/master/bip-0310.mediawiki
>> > [3]
>> https://github.com/stratum-mining/sv2-spec/blob/main/05-Mining-Protocol.md#511-standard-job
>> > [4]
>> https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/88?u=sjors
>> > [5] https://en.bitcoin.it/wiki/Stratum_mining_protocol#mining.notify
>> >
>> > * = otherwise the ASIC needs to know how to extend it, know that it
>> can't be
>> > more than 100 bytes, and that it can't touch the BIP34 part, or really
>> any
>> > subsequent bytes that a future soft fork might constrain
>> >
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BFf_L84d8LssCZWSBM0HPvfc5Z88jCGe0PBvExX7FxZaw%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BFf_L84d8LssCZWSBM0HPvfc5Z88jCGe0PBvExX7FxZaw%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAOCjFt9QktYQ%2B9Z-peYJHaXSgJuHwCZGZHiWyMbm2LwK5ztUKg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 10507 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-08 16:36  0%     ` Matt Corallo
@ 2026-01-13  2:16  0%       ` Antoine Riard
  2026-01-13 16:59  0%         ` Mubarek Juhar
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2026-01-13  2:16 UTC (permalink / raw)
  To: Matt Corallo
  Cc: Sjors Provoost, Bitcoin Development Mailing List, Antoine Poinsot

[-- Attachment #1: Type: text/plain, Size: 6440 bytes --]

Hi Corallo,

> Assuming some future change to stratum v1/v2 to allow for this (which I
think is basically a "never
> going to happen"), its worth noting that you can't just roll it for free.

This is not like there have been a multitude of pooling protocols deployed
in the past, all with
their awful long-polling mechanisms and other tricks. Saying we should only
consider stratum
v1/v2 in matters of consensus-design it can be a bit blindsighted imho. As
of today block
height, considering the situation where it's height-based locktime, that
would be 19-bit
that you could use as an extranonce, if my measurements are correct.

On the other hand, making the coinbase transaction with an always valid
coinbase's nLocktime
transaction, this opens the door in terms of off-chain protocols and
use-case design (e.g
proof-of-work swap), where now you can use the consensus mandatory check of
the coinbase
nLocktime's field as a novel building block primitive.

Best,
Antoine
OTS hash: 45f28303770b376e2ae8f9e0072ae236d2b42aa4c84036f87ec9903a74a385b3

Le jeu. 8 janv. 2026 à 16:36, Matt Corallo <lf-lists@mattcorallo.com> a
écrit :

>
>
> On 1/8/26 3:30 AM, Sjors Provoost wrote:
> > Hello Riard,
> >
> >> Thanks for the update. If I'm understanding correctly Luke's concern,
> >> currently the coinbase's scriptSig is used to store an extranonce. One
> >> has to observe first there is no consensus limit on the size of a
> >> transaction, which holds for the coinbase tx too, a fortiori there is
> >> no limit on the extranonce size a miner could fit in the scriptSig.
> >
> >
> > The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as
> to
> > why [1].
> >
> > The main issue I see is complexity of implementation. The nLockTime is
> always
> > the last 4 bytes of a transaction, so an ASIC can roll it without having
> to
> > understand anything about serialisation.
>
> Assuming some future change to stratum v1/v2 to allow for this (which I
> think is basically a "never
> going to happen"), its worth noting that you can't just roll it for free.
> Its already the case that
> nLockTime has consensus meaning on the coinbase transaction - its enforced
> like any other block. So
> there's relatively little rolling you can do until you get to the current
> block height and have to
> go do something else (I imagine this is why its not been used for this
> purpose in the past, at least
> in part). So the ASIC actually has to understand quite a bit to roll this.
>
> Instead, in practice, ASICs (or their controllers) roll nTime, which is
> even better cause its in the
> header and you know you can ~always roll it once a second. Then rolling a
> nonce in the coinbase is
> easy cause you can just do it in the controller and get plenty of headroom
> on the ASIC itself with
> nTime and a few midstates.
>
> > The scriptSig OTOH is variable length, so it needs to read the length
> byte in
> > order to figure out which 4 bytes are at the end. The pool or proxy then
> also
> > needs to ensure those 4 bytes are pre-initialised*.
> >
> > The approach suggested by Towns [4] of appending a 0-sat OP_RETURN
> output with
> > padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is
> probably
> > better, but not because like nLockTime it has a small hashing midstate
> > benefit. It's easier to implement.
> >
> > Compared to varying the end of the scriptSig, this can be easier for an
> ASIC
> > because it can update a fixed 4-byte field at a known offset from the
> end,
> > rather than having to parse variable-length fields (notably the scriptSig
> > length) to locate the bytes to roll.
> >
> > I think that extra complexity is doable and justifiable, but I've never
> built an ASIC.
> >
> > Note that today Stratum v1 simply splits the scriptSig [5] into two
> parts, as does
> > Stratum v2 [3], but presumably that's all done by the control board and
> it makes
> > sense to want to push rolling functionally into the ASIC silicon, where
> even
> > simple concatenation might be too involved - but updating bytes at known
> > positions is easy.
> >
> >> The point being made is that the nLocktime field of the coinbase
> >> transaction could be used as a more efficient extra nonce due to
> >> the positional location of nLocktime in a serialized coinbase being
> >> one of the latest message block to be processed [0].
> >>
> >> Nothing prevent a miner in already doing this and draw a speed advantage
> >> from the diminished computational work. I have not looked into CGminer
> code
> >> or one of its derivative forks, if there is an implemented option to do
> that,
> >> but yes there could be non-published existing mining firmware doing it.
> IIUC,
> >> BIP54 would nullify this theoretical "speed advantage" for all miners.
> >
> > I don't think there's currently a speed advantage, so I wouldn't expect
> to observe
> > this behaviour in the wild just yet. The combination of rolling nVersion
> > (BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.
> >
> > Beyond that an ASIC will need to touch the coinbase.
> >
> > - Sjors
> >
> > [0]
> https://github.com/bitcoin/bitcoin/blob/v30.1/src/consensus/tx_check.cpp#L47-L51
> > [1]
> https://bitcoin.stackexchange.com/questions/35455/why-bother-having-limitations-on-bitcoin-coinbase-transaction-scriptsigs
> > [2] https://github.com/bitcoin/bips/blob/master/bip-0310.mediawiki
> > [3]
> https://github.com/stratum-mining/sv2-spec/blob/main/05-Mining-Protocol.md#511-standard-job
> > [4]
> https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/88?u=sjors
> > [5] https://en.bitcoin.it/wiki/Stratum_mining_protocol#mining.notify
> >
> > * = otherwise the ASIC needs to know how to extend it, know that it
> can't be
> > more than 100 bytes, and that it can't touch the BIP34 part, or really
> any
> > subsequent bytes that a future soft fork might constrain
> >
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BFf_L84d8LssCZWSBM0HPvfc5Z88jCGe0PBvExX7FxZaw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8276 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-08  8:30  1%   ` [bitcoindev] " Sjors Provoost
  2026-01-08 16:36  0%     ` Matt Corallo
  2026-01-08 16:40  0%     ` Matt Corallo
@ 2026-01-13  1:49  1%     ` Antoine Riard
  2026-01-14  0:23  0%     ` Murch
  3 siblings, 0 replies; 200+ results
From: Antoine Riard @ 2026-01-13  1:49 UTC (permalink / raw)
  To: Sjors Provoost; +Cc: Bitcoin Development Mailing List, Antoine Poinsot

[-- Attachment #1: Type: text/plain, Size: 6653 bytes --]

Hi Sjors,

Thanks for the reminder that the coinbase transaction has a 100 bytes
limit, checked IsCoinbase(), but I didn't CheckTransaction() again. So with
a 100 bytes limit, there are still 2^100 extra permutations in addition to
the
128 bits already available from the nonce, and the bits from the version
fields.

It is true that the coinbase nLocktime is a fixed-size field, so an ASIC can
roll it without having it ot understand anything about serialization, while
on
the other hand the scriptSig is as you're noting variable-length (well you
can
make assumptions on the var_int fixed-size). I don't think that that
whatever
your ASIC design, the chip has to be aware of the serialization subtleties,
this can be done at the proxy-level, and you just feed an unified iterable
bits field (version + scriptSig + coinbase, whatever you use as an
extranonce).

I see the idea of appending a 0-sat OP_RETURN output with padding so a
4-byte
nonce is fitting in the data payload of the OP_RETURN. But I don't see how
you avoid the unserialization problem for the proxy of knowing the OP_RETURN
data payload selected size (--I guess register loads and CPU cycles saved
at the architecture levels for the unser buffer mem allocation can be wins
for the proxy). So it might be easier to implement, but not necessarily
faster.

Never built an ASIC, but to have studied instruction level architecture, if
you
wish optimal performance the question starts to be the size of you're
high-level
cache (the ones the nearest of your roll-and-hash-logic) and what is the
byte-length
words those caches are working on. Unless you're iterating on 4 MB words
fractional
power of 2 of it, but I don't think so.

I'm not aware this behaviour is done in the wild, but in theory if you can
serialize / unserialize on fixed-size data fields for the proxy, it's faster
(just one less one memory allocator call...).

Without digging more on the necessities for current 280 TH/s, this can be
fine for
now to just roll the nVersion header field which is a fixed-size too,
though I do think
Luke's concern of letting the coinbase as a reserved field for now is not
without ground
(of course the nLocktime can be valid today, but what is the worthiness as
the nSequence
can be set to disable it, i.e IsFinal()'s semantic).

Best,
Antoine
OTS hash: 6c1f83a60642ef43c911dd57b4b9aaf084cf80445d0af72b1f92f910581f6ead

Le jeu. 8 janv. 2026 à 08:30, Sjors Provoost <sjors@sprovoost.nl> a écrit :

> Hello Riard,
>
> > Thanks for the update. If I'm understanding correctly Luke's concern,
> > currently the coinbase's scriptSig is used to store an extranonce. One
> > has to observe first there is no consensus limit on the size of a
> > transaction, which holds for the coinbase tx too, a fortiori there is
> > no limit on the extranonce size a miner could fit in the scriptSig.
>
>
> The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as to
> why [1].
>
> The main issue I see is complexity of implementation. The nLockTime is
> always
> the last 4 bytes of a transaction, so an ASIC can roll it without having to
> understand anything about serialisation.
>
> The scriptSig OTOH is variable length, so it needs to read the length byte
> in
> order to figure out which 4 bytes are at the end. The pool or proxy then
> also
> needs to ensure those 4 bytes are pre-initialised*.
>
> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output
> with
> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is
> probably
> better, but not because like nLockTime it has a small hashing midstate
> benefit. It's easier to implement.
>
> Compared to varying the end of the scriptSig, this can be easier for an
> ASIC
> because it can update a fixed 4-byte field at a known offset from the end,
> rather than having to parse variable-length fields (notably the scriptSig
> length) to locate the bytes to roll.
>
> I think that extra complexity is doable and justifiable, but I've never
> built an ASIC.
>
> Note that today Stratum v1 simply splits the scriptSig [5] into two parts,
> as does
> Stratum v2 [3], but presumably that's all done by the control board and it
> makes
> sense to want to push rolling functionally into the ASIC silicon, where
> even
> simple concatenation might be too involved - but updating bytes at known
> positions is easy.
>
> > The point being made is that the nLocktime field of the coinbase
> > transaction could be used as a more efficient extra nonce due to
> > the positional location of nLocktime in a serialized coinbase being
> > one of the latest message block to be processed [0].
> >
> > Nothing prevent a miner in already doing this and draw a speed advantage
> > from the diminished computational work. I have not looked into CGminer
> code
> > or one of its derivative forks, if there is an implemented option to do
> that,
> > but yes there could be non-published existing mining firmware doing it.
> IIUC,
> > BIP54 would nullify this theoretical "speed advantage" for all miners.
>
> I don't think there's currently a speed advantage, so I wouldn't expect to
> observe
> this behaviour in the wild just yet. The combination of rolling nVersion
> (BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.
>
> Beyond that an ASIC will need to touch the coinbase.
>
> - Sjors
>
> [0]
> https://github.com/bitcoin/bitcoin/blob/v30.1/src/consensus/tx_check.cpp#L47-L51
> [1]
> https://bitcoin.stackexchange.com/questions/35455/why-bother-having-limitations-on-bitcoin-coinbase-transaction-scriptsigs
> [2] https://github.com/bitcoin/bips/blob/master/bip-0310.mediawiki
> [3]
> https://github.com/stratum-mining/sv2-spec/blob/main/05-Mining-Protocol.md#511-standard-job
> [4]
> https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/88?u=sjors
> [5] https://en.bitcoin.it/wiki/Stratum_mining_protocol#mining.notify
>
> * = otherwise the ASIC needs to know how to extend it, know that it can't
> be
> more than 100 bytes, and that it can't touch the BIP34 part, or really any
> subsequent bytes that a future soft fork might constrain

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALZpt%2BFyPWsbvNOo3jpSoBR08a-LXoZi40yaP5VFEaKm%3DNYRPw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8301 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-08  8:30  1%   ` [bitcoindev] " Sjors Provoost
  2026-01-08 16:36  0%     ` Matt Corallo
@ 2026-01-08 16:40  0%     ` Matt Corallo
  2026-01-13  1:49  1%     ` Antoine Riard
  2026-01-14  0:23  0%     ` Murch
  3 siblings, 0 replies; 200+ results
From: Matt Corallo @ 2026-01-08 16:40 UTC (permalink / raw)
  To: Sjors Provoost, Antoine Riard
  Cc: Bitcoin Development Mailing List, Antoine Poinsot



On 1/8/26 3:30 AM, Sjors Provoost wrote:
> Hello Riard,
> 
>> Thanks for the update. If I'm understanding correctly Luke's concern,
>> currently the coinbase's scriptSig is used to store an extranonce. One
>> has to observe first there is no consensus limit on the size of a
>> transaction, which holds for the coinbase tx too, a fortiori there is
>> no limit on the extranonce size a miner could fit in the scriptSig.
> 
> 
> The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as to
> why [1].
> 
> The main issue I see is complexity of implementation. The nLockTime is always
> the last 4 bytes of a transaction, so an ASIC can roll it without having to
> understand anything about serialisation.
> 
> The scriptSig OTOH is variable length, so it needs to read the length byte in
> order to figure out which 4 bytes are at the end. The pool or proxy then also
> needs to ensure those 4 bytes are pre-initialised*.
> 
> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
> better, but not because like nLockTime it has a small hashing midstate
> benefit. It's easier to implement.
> 
> Compared to varying the end of the scriptSig, this can be easier for an ASIC
> because it can update a fixed 4-byte field at a known offset from the end,
> rather than having to parse variable-length fields (notably the scriptSig
> length) to locate the bytes to roll.
> 
> I think that extra complexity is doable and justifiable, but I've never built an ASIC.
> 
> Note that today Stratum v1 simply splits the scriptSig [5] into two parts, as does
> Stratum v2 [3], but presumably that's all done by the control board and it makes
> sense to want to push rolling functionally into the ASIC silicon, where even
> simple concatenation might be too involved - but updating bytes at known
> positions is easy.
> 
>> The point being made is that the nLocktime field of the coinbase
>> transaction could be used as a more efficient extra nonce due to
>> the positional location of nLocktime in a serialized coinbase being
>> one of the latest message block to be processed [0].
>>
>> Nothing prevent a miner in already doing this and draw a speed advantage
>> from the diminished computational work. I have not looked into CGminer code
>> or one of its derivative forks, if there is an implemented option to do that,
>> but yes there could be non-published existing mining firmware doing it. IIUC,
>> BIP54 would nullify this theoretical "speed advantage" for all miners.
> 
> I don't think there's currently a speed advantage, so I wouldn't expect to observe
> this behaviour in the wild just yet. The combination of rolling nVersion
> (BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.
> 
> Beyond that an ASIC will need to touch the coinbase.

Oops, missed this part. Honestly we should just reserve another 8 bits out of the version for 
rolling. 8 bits for signaling is more than enough, and 72PH/2 aught to be enough for a relatively 
large ASIC for quite a while :). Then this entire rolling discussion nearly entirely goes away.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f68d7c20-5119-4159-8e42-f7c10597a789%40mattcorallo.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  2026-01-08  8:30  1%   ` [bitcoindev] " Sjors Provoost
@ 2026-01-08 16:36  0%     ` Matt Corallo
  2026-01-13  2:16  0%       ` Antoine Riard
  2026-01-08 16:40  0%     ` Matt Corallo
                       ` (2 subsequent siblings)
  3 siblings, 1 reply; 200+ results
From: Matt Corallo @ 2026-01-08 16:36 UTC (permalink / raw)
  To: Sjors Provoost, Antoine Riard
  Cc: Bitcoin Development Mailing List, Antoine Poinsot



On 1/8/26 3:30 AM, Sjors Provoost wrote:
> Hello Riard,
> 
>> Thanks for the update. If I'm understanding correctly Luke's concern,
>> currently the coinbase's scriptSig is used to store an extranonce. One
>> has to observe first there is no consensus limit on the size of a
>> transaction, which holds for the coinbase tx too, a fortiori there is
>> no limit on the extranonce size a miner could fit in the scriptSig.
> 
> 
> The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as to
> why [1].
> 
> The main issue I see is complexity of implementation. The nLockTime is always
> the last 4 bytes of a transaction, so an ASIC can roll it without having to
> understand anything about serialisation.

Assuming some future change to stratum v1/v2 to allow for this (which I think is basically a "never 
going to happen"), its worth noting that you can't just roll it for free. Its already the case that 
nLockTime has consensus meaning on the coinbase transaction - its enforced like any other block. So 
there's relatively little rolling you can do until you get to the current block height and have to 
go do something else (I imagine this is why its not been used for this purpose in the past, at least 
in part). So the ASIC actually has to understand quite a bit to roll this.

Instead, in practice, ASICs (or their controllers) roll nTime, which is even better cause its in the 
header and you know you can ~always roll it once a second. Then rolling a nonce in the coinbase is 
easy cause you can just do it in the controller and get plenty of headroom on the ASIC itself with 
nTime and a few midstates.

> The scriptSig OTOH is variable length, so it needs to read the length byte in
> order to figure out which 4 bytes are at the end. The pool or proxy then also
> needs to ensure those 4 bytes are pre-initialised*.
> 
> The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
> padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
> better, but not because like nLockTime it has a small hashing midstate
> benefit. It's easier to implement.
> 
> Compared to varying the end of the scriptSig, this can be easier for an ASIC
> because it can update a fixed 4-byte field at a known offset from the end,
> rather than having to parse variable-length fields (notably the scriptSig
> length) to locate the bytes to roll.
> 
> I think that extra complexity is doable and justifiable, but I've never built an ASIC.
> 
> Note that today Stratum v1 simply splits the scriptSig [5] into two parts, as does
> Stratum v2 [3], but presumably that's all done by the control board and it makes
> sense to want to push rolling functionally into the ASIC silicon, where even
> simple concatenation might be too involved - but updating bytes at known
> positions is easy.
> 
>> The point being made is that the nLocktime field of the coinbase
>> transaction could be used as a more efficient extra nonce due to
>> the positional location of nLocktime in a serialized coinbase being
>> one of the latest message block to be processed [0].
>>
>> Nothing prevent a miner in already doing this and draw a speed advantage
>> from the diminished computational work. I have not looked into CGminer code
>> or one of its derivative forks, if there is an implemented option to do that,
>> but yes there could be non-published existing mining firmware doing it. IIUC,
>> BIP54 would nullify this theoretical "speed advantage" for all miners.
> 
> I don't think there's currently a speed advantage, so I wouldn't expect to observe
> this behaviour in the wild just yet. The combination of rolling nVersion
> (BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.
> 
> Beyond that an ASIC will need to touch the coinbase.
> 
> - Sjors
> 
> [0] https://github.com/bitcoin/bitcoin/blob/v30.1/src/consensus/tx_check.cpp#L47-L51
> [1] https://bitcoin.stackexchange.com/questions/35455/why-bother-having-limitations-on-bitcoin-coinbase-transaction-scriptsigs
> [2] https://github.com/bitcoin/bips/blob/master/bip-0310.mediawiki
> [3] https://github.com/stratum-mining/sv2-spec/blob/main/05-Mining-Protocol.md#511-standard-job
> [4] https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/88?u=sjors
> [5] https://en.bitcoin.it/wiki/Stratum_mining_protocol#mining.notify
> 
> * = otherwise the ASIC needs to know how to extend it, know that it can't be
> more than 100 bytes, and that it can't touch the BIP34 part, or really any
> subsequent bytes that a future soft fork might constrain
> 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/33ffd6c4-6395-4f6c-a6e8-8b43220cdb00%40mattcorallo.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] BIP Idea: incrementalrelayfee in feefilter?
  2026-01-07 18:50  0% ` Murch
@ 2026-01-08 18:13  1%   ` Matthew Husák
  0 siblings, 0 replies; 200+ results
From: Matthew Husák @ 2026-01-08 18:13 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5032 bytes --]

Hi Murch!

thanks for such quick response.

I think that we've been one of the first wallets to support such lower 
fees, so we faced the initial "pain" to find peers with the lower 
minrelaytxfee. That kinda made me feel that this has to change, because 
when we solved the peers config (with our desired minrelaytxfee setting) we 
realized that many nodes (before the update)  forgot to change the 
minincrementalfee policy and since you can't check for peer's 
minincrementalfee it makes the adoption even harder, because it's almost 
impossible to find peers on your own (you could sign a RBF tx bumped up to 
fee under 1sat/vb and try to send it to different peers, but thats far from 
ideal :-D).

I'm not sure if lowering the defaults will ever happen again, but I believe 
that you should be able to see under what conditions other nodes relay, so 
that you don't spam them with tx they don't want and so that the adoption 
is easier.

I haven’t seen BIP 153 before, so I’ll read it and try to understand it. 
That said, I have two ideas: the simplest is to expose 
 incrementalrelayfee , and the second (I’d love your opinion on this) is 
adding the ability to configure the node to actively seek peers meeting 
specific  minrelaytxfee  and  minincrementalfee  thresholds—since AFAIK it 
currently settles for ~10 outbound nodes of any config, this would let it 
target at least 2 high-quality peers with those minimums during discovery.

(or I could be totally off with my ideas :-D but I hope its not that case)

Thanks!
Matt


Dne středa 7. ledna 2026 v 20:54:11 UTC+1 uživatel Murch napsal:

> Hi Matt,
>
> The feerate policy change was rolled out not just with the Bitcoin Core 
> 30.0 release, but also backported to Bitcoin Core 29.1. According to 
> e.g., Clark Moody’s dashboard, that means that over 30% of listening 
> nodes already use the lower incremental feerate (assuming they use the 
> default value). Per a quick calculation even non-listening nodes with 
> only eight connections should have an over 94% chance to have at least 
> one peer that accepts and rebroadcasts such a replacement 
> transaction—and rising.
>
> Meanwhile, very few wallets so far support creating transactions with 
> lower feerates or implement replacements with the lower 
> incrementalrelayfee. Presumably the wallet adoption will continue to 
> trail the node policy adoption in this regard, exactly due to the 
> current unreliable state.
>
> I am not convinced that special handling for the incrementalrelayfee is 
> necessary at this time, and either way, a more general approach such as 
> the recently proposed BIP 153: SENDTEMPLATE (PR: 
> https://github.com/bitcoin/bips/pull/1937) would feel like a bigger bang 
> for the buck in that regard.
>
> Best,
> Murch
>
> On 2026-01-06 17:36, Matthew Husák wrote:
> > Hi all!
> >
> > Core 30.0 defaults both minrelaytxfee and incrementalrelayfee to 0.1 
> > sat/vB now, but lots of nodes still run 1 sat/vB for 
> > incrementalrelayfee (or other settings).
> >
> > *Problem 1*: You send RBF tx → your node accepts → peers reject 
> > replacements → dead end.
> > *Problem 2*: You can't see what min RBF fee peers have.
> >
> > The obvious fix is to manually connect to peers with matching 
> > incrementalrelayfee, which is impossible because this policy isn't 
> > exposed over P2P. BIP133 feefilter only signals minrelaytxfee.
> >
> > *Proposal*: Extend feefilter with incrementalrelayfee field (parallel 
> > to minrelaytxfee). Peers can then filter out un-bumpable RBF invs, 
> > reducing spam and improving propagation.
> >
> > *Benefits*:
> > - spam protection: your node stops spamming peers with un-bumpable RBFs
> > - transparency: you can see what RBF policy other nodes use, thus you 
> > can find miner node which you can add as manual peer
> > - pure policy change, no consensus risk
> >
> > *WDYT guys?*
> >
> > Happy to prototype or draft a BIP if there's interest.
> >
> > Cheers,
> > Matt.
> > -- 
> > You received this message because you are subscribed to the Google 
> > Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> > an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> > 
> https://groups.google.com/d/msgid/bitcoindev/d3ddaf1c-44c9-4ebd-98fe-88e03a84891en%40googlegroups.com 
> > <
> https://groups.google.com/d/msgid/bitcoindev/d3ddaf1c-44c9-4ebd-98fe-88e03a84891en%40googlegroups.com?utm_medium=email&utm_source=footer
> >.
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/a02be21c-2483-4753-b6db-4bd159e8c4e0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 7100 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Addressing remaining points on BIP 54
  @ 2026-01-08  8:30  1%   ` Sjors Provoost
  2026-01-08 16:36  0%     ` Matt Corallo
                       ` (3 more replies)
  0 siblings, 4 replies; 200+ results
From: Sjors Provoost @ 2026-01-08  8:30 UTC (permalink / raw)
  To: Antoine Riard; +Cc: Bitcoin Development Mailing List, Antoine Poinsot

Hello Riard,

> Thanks for the update. If I'm understanding correctly Luke's concern,
> currently the coinbase's scriptSig is used to store an extranonce. One
> has to observe first there is no consensus limit on the size of a
> transaction, which holds for the coinbase tx too, a fortiori there is
> no limit on the extranonce size a miner could fit in the scriptSig.


The coinbase scriptSig is limited to 100 bytes [0]. Some speculation as to
why [1].

The main issue I see is complexity of implementation. The nLockTime is always
the last 4 bytes of a transaction, so an ASIC can roll it without having to
understand anything about serialisation.

The scriptSig OTOH is variable length, so it needs to read the length byte in
order to figure out which 4 bytes are at the end. The pool or proxy then also
needs to ensure those 4 bytes are pre-initialised*.

The approach suggested by Towns [4] of appending a 0-sat OP_RETURN output with
padding so a 4-byte nonce lands in the final 64-byte SHA256 chunk is probably
better, but not because like nLockTime it has a small hashing midstate
benefit. It's easier to implement.

Compared to varying the end of the scriptSig, this can be easier for an ASIC
because it can update a fixed 4-byte field at a known offset from the end,
rather than having to parse variable-length fields (notably the scriptSig
length) to locate the bytes to roll.

I think that extra complexity is doable and justifiable, but I've never built an ASIC.

Note that today Stratum v1 simply splits the scriptSig [5] into two parts, as does
Stratum v2 [3], but presumably that's all done by the control board and it makes
sense to want to push rolling functionally into the ASIC silicon, where even
simple concatenation might be too involved - but updating bytes at known
positions is easy.

> The point being made is that the nLocktime field of the coinbase
> transaction could be used as a more efficient extra nonce due to
> the positional location of nLocktime in a serialized coinbase being
> one of the latest message block to be processed [0].
> 
> Nothing prevent a miner in already doing this and draw a speed advantage
> from the diminished computational work. I have not looked into CGminer code
> or one of its derivative forks, if there is an implemented option to do that,
> but yes there could be non-published existing mining firmware doing it. IIUC,
> BIP54 would nullify this theoretical "speed advantage" for all miners.

I don't think there's currently a speed advantage, so I wouldn't expect to observe
this behaviour in the wild just yet. The combination of rolling nVersion
(BIP310) [2] and updating nTime every second, works fine up to 280 TH/s.

Beyond that an ASIC will need to touch the coinbase.

- Sjors

[0] https://github.com/bitcoin/bitcoin/blob/v30.1/src/consensus/tx_check.cpp#L47-L51
[1] https://bitcoin.stackexchange.com/questions/35455/why-bother-having-limitations-on-bitcoin-coinbase-transaction-scriptsigs
[2] https://github.com/bitcoin/bips/blob/master/bip-0310.mediawiki
[3] https://github.com/stratum-mining/sv2-spec/blob/main/05-Mining-Protocol.md#511-standard-job
[4] https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710/88?u=sjors
[5] https://en.bitcoin.it/wiki/Stratum_mining_protocol#mining.notify

* = otherwise the ASIC needs to know how to extend it, know that it can't be
more than 100 bytes, and that it can't touch the BIP34 part, or really any
subsequent bytes that a future soft fork might constrain

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/9C946151-D6DD-4CB7-B524-15FD9F625D9D%40sprovoost.nl.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] BIP Idea: incrementalrelayfee in feefilter?
  2026-01-07  1:36  1% [bitcoindev] BIP Idea: incrementalrelayfee in feefilter? Matthew Husák
@ 2026-01-07 18:50  0% ` Murch
  2026-01-08 18:13  1%   ` Matthew Husák
  0 siblings, 1 reply; 200+ results
From: Murch @ 2026-01-07 18:50 UTC (permalink / raw)
  To: bitcoindev

Hi Matt,

The feerate policy change was rolled out not just with the Bitcoin Core 
30.0 release, but also backported to Bitcoin Core 29.1. According to 
e.g., Clark Moody’s dashboard, that means that over 30% of listening 
nodes already use the lower incremental feerate (assuming they use the 
default value). Per a quick calculation even non-listening nodes with 
only eight connections should have an over 94% chance to have at least 
one peer that accepts and rebroadcasts such a replacement 
transaction—and rising.

Meanwhile, very few wallets so far support creating transactions with 
lower feerates or implement replacements with the lower 
incrementalrelayfee. Presumably the wallet adoption will continue to 
trail the node policy adoption in this regard, exactly due to the 
current unreliable state.

I am not convinced that special handling for the incrementalrelayfee is 
necessary at this time, and either way, a more general approach such as 
the recently proposed BIP 153: SENDTEMPLATE (PR: 
https://github.com/bitcoin/bips/pull/1937) would feel like a bigger bang 
for the buck in that regard.

Best,
Murch

On 2026-01-06 17:36, Matthew Husák wrote:
> Hi all!
>
> Core 30.0 defaults both minrelaytxfee and incrementalrelayfee to 0.1 
> sat/vB now, but lots of nodes still run 1 sat/vB for 
> incrementalrelayfee (or other settings).
>
> *Problem 1*: You send RBF tx → your node accepts → peers reject 
> replacements → dead end.
> *Problem 2*: You can't see what min RBF fee peers have.
>
> The obvious fix is to manually connect to peers with matching 
> incrementalrelayfee, which is impossible because this policy isn't 
> exposed over P2P. BIP133 feefilter only signals minrelaytxfee.
>
> *Proposal*: Extend feefilter with incrementalrelayfee field (parallel 
> to minrelaytxfee). Peers can then filter out un-bumpable RBF invs, 
> reducing spam and improving propagation.
>
> *Benefits*:
> - spam protection: your node stops spamming peers with un-bumpable RBFs
> - transparency: you can see what RBF policy other nodes use, thus you 
> can find miner node which you can add as manual peer
> - pure policy change, no consensus risk
>
> *WDYT guys?*
>
> Happy to prototype or draft a BIP if there's interest.
>
> Cheers,
> Matt.
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/d3ddaf1c-44c9-4ebd-98fe-88e03a84891en%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/d3ddaf1c-44c9-4ebd-98fe-88e03a84891en%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/7992d314-c068-4bea-b3da-03d65ea2d334%40murch.one.


^ permalink raw reply	[relevance 0%]

* [bitcoindev] BIP Idea: incrementalrelayfee in feefilter?
@ 2026-01-07  1:36  1% Matthew Husák
  2026-01-07 18:50  0% ` Murch
  0 siblings, 1 reply; 200+ results
From: Matthew Husák @ 2026-01-07  1:36 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 1451 bytes --]

Hi all! 

Core 30.0 defaults both minrelaytxfee and incrementalrelayfee to 0.1 sat/vB 
now, but lots of nodes still run 1 sat/vB for incrementalrelayfee (or other 
settings).

*Problem 1*: You send RBF tx → your node accepts → peers reject 
replacements → dead end.
*Problem 2*: You can't see what min RBF fee peers have.

The obvious fix is to manually connect to peers with matching 
incrementalrelayfee, which is impossible because this policy isn't exposed 
over P2P. BIP133 feefilter only signals minrelaytxfee.

*Proposal*: Extend feefilter with incrementalrelayfee field (parallel to 
minrelaytxfee). Peers can then filter out un-bumpable RBF invs, reducing 
spam and improving propagation.

*Benefits*:
- spam protection: your node stops spamming peers with un-bumpable RBFs
- transparency: you can see what RBF policy other nodes use, thus you can 
find miner node which you can add as manual peer
- pure policy change, no consensus risk

*WDYT guys?*

Happy to prototype or draft a BIP if there's interest.

Cheers,
Matt.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d3ddaf1c-44c9-4ebd-98fe-88e03a84891en%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 1958 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-24 17:19  1%             ` waxwing/ AdamISZ
@ 2025-12-30 14:36  1%               ` Antoine Riard
  2026-01-19  1:11  4%                 ` Pepe Hodler
  2026-01-22  1:14  1%                 ` Claire Ostrom
  0 siblings, 2 replies; 200+ results
From: Antoine Riard @ 2025-12-30 14:36 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 22054 bytes --]

Hi list,

> Which brings me to my disagreement, which I know is not shared by a 
number of contributors here: just as it is hard to define spam on Bitcoin, 
it's also very hard to define it in a discussion forum like this one. 
Making suggestions which *I* think are terrible, or detrimental, on a list 
like this, should never be disallowed here. Notions of motivation of 
contributors (such as they are paid by such and such a company) should not 
be relevant. Everything should be open to discussion which is 
implementation-technical (so obviously not e.g. threats of violence or 
things that bring legal liability to participants or have zero relevance to 
Bitcoin's technical development) even if it's philosophy-motivated. And 
blocking should be reserved either as an anti-DOS measure if volume gets 
out of control, or if it brings dangers as per the previous parenthetical.

I'm fully sharing waxwing reasonable opinion. While I can understand gmax's 
sentiment being fed
up with poor coin confiscation proposals again and again on the mailing 
list, the cure would be
worst than the disease. Maybe, I'm very voltairean here, but you don't 
fight ill-founded opinions.
by persecuting their authors (--otherwise, down the road you take the risk 
of seeing the bastille
popped up). Rather than you fight them back by doing the work to persuade 
and to convince those
ideas you find stupid are indeed *objectively* stupid.

To me, it's a sign of strength and confidence that Bitcoin and its 
development process can
withstand and endure the most "outrageous" controversies. For sure, I have 
been enough times
in the shoes of someone who has to champion controversial changes (cf. 
`mempoolfullrbf`) to not
negate that the strength of the process is kinda traded on the back of the 
devs, but this is not
altering my mind on what I think should be *ideally* the development 
process in terms of openess
and publicity.

My humble opinion only, as we said.

Best,
Antoine
OTS hash: 5c1c19f589a61787dbf483cd6814f094c3b24888d6d189c5f4d776bda558e1ce
Le mercredi 24 décembre 2025 à 17:23:48 UTC, waxwing/ AdamISZ a écrit :

> Hi Greg, list:
>
> > I think the list should adopt a 1 year ban on parties *and their* 
> employer(s) (if known) for any coin confiscation proposal on the list going 
> forward (after, of course, making the rule clear on the signup page).  It's 
> tiresome and beyond being a waste of time risks undermining public 
> confidence in Bitcoin to see the constant trickle of these 
> outrageous proposals in venues where they previously understood that 
> serious discussions were to be had. People are, of course, free to discuss 
> whatever ill-founded concepts they want but they're not entitled to the 
> time and the reputation of the participants here for offensively misguided 
> proposals. 
>
> I'm a huge agree-er with the motivation of this comment and a huge 
> disagree-er with the suggestion itself.
>
> Actual confiscation, whatever the reason, hugely undermines Bitcoin's 
> value to humanity - note I am not saying its financial value, but value as 
> a project (and if we didn't see such value what the hell are we doing 
> here). Of course those two types of value are very closely linked, but they 
> are still distinct. I hold that same belief even when we are talking about 
> other suggestions of confiscation, such as to address a quantum threat - 
> something that has recently been discussed here, extensively.
>
> Which brings me to my disagreement, which I know is not shared by a number 
> of contributors here: just as it is hard to define spam on Bitcoin, it's 
> also very hard to define it in a discussion forum like this one. Making 
> suggestions which *I* think are terrible, or detrimental, on a list like 
> this, should never be disallowed here. Notions of motivation of 
> contributors (such as they are paid by such and such a company) should not 
> be relevant. Everything should be open to discussion which is 
> implementation-technical (so obviously not e.g. threats of violence or 
> things that bring legal liability to participants or have zero relevance to 
> Bitcoin's technical development) even if it's philosophy-motivated. And 
> blocking should be reserved either as an anti-DOS measure if volume gets 
> out of control, or if it brings dangers as per the previous parenthetical.
>
> Just my opinion of course, I know that moderation of lists is not a simple 
> matter.
>
> Cheers,
> AdamISZ/waxwing
> On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:
>
>> The 'dust threshold' isn't a consensus parameter, it's just a number 
>> pulled out of the air that didn't seem unreasonable based on average fee 
>> behavior.  But in any particular block transactions may need no particular 
>> fee level at all, including zero fees.  And in some cases it may be very 
>> economically advantageous to spend an output even if its face value doesn't 
>> support it, NFT's being a one such example (although one I consider pretty 
>> dumb).
>>  
>> This proposal also appears to have ignored the prior discussion 
>> particularly where it was pointed out that 'deleting' outputs will not 
>> achieve the goal of deleting the tokens connected to them (so won't 
>> eliminate the incentive), or that txouts which are predictably not going to 
>> be accessed (as this proposal claims applies to the txouts it targets) 
>> don't have as significant performance implications (because they don't need 
>> to be cached in ram).  It also appears to be uninformed by advances like 
>> utxotree which makes the absolute size of the txout set much less 
>> important, but would make mass removals such as that described 
>> here expensive.  Nor has it considered that given the level of fee spending 
>> on NFT traffic a requirement to keep it over some (reasonable) threshold 
>> would not likely discourage it, or the fact that existent NFT outputs are 
>> generally over the dust limit in any case (so the proposals failure to meet 
>> the opcat proponents' delusional goals is already clear).
>>
>> I think the list should adopt a 1 year ban on parties *and their* 
>> employer(s) (if known) for any coin confiscation proposal on the list going 
>> forward (after, of course, making the rule clear on the signup page).  It's 
>> tiresome and beyond being a waste of time risks undermining public 
>> confidence in Bitcoin to see the constant trickle of these 
>> outrageous proposals in venues where they previously understood that 
>> serious discussions were to be had. People are, of course, free to discuss 
>> whatever ill-founded concepts they want but they're not entitled to the 
>> time and the reputation of the participants here for offensively misguided 
>> proposals. 
>>
>>
>> On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:
>>
>>> Good evening all,
>>>
>>> Here is a related proposal by Matteo Pellegrini
>>> @matteopelleg
>>>
>>>
>>>
>>> Lynx.
>>>
>>> Abstract
>>> This proposal introduces a periodic, consensus-enforced mechanism for 
>>> rendering UTXOs below the network's dust threshold permanently unspendable. 
>>> At each halving block, UTXOs that have remained below the dust threshold 
>>> since the previous halving become unspendable. These UTXOs become 
>>> unspendable and may be pruned from the UTXO set entirely, reducing node 
>>> storage requirements and eliminating the economic model that incentivizes 
>>> their creation.
>>>
>>> Motivation
>>> The Bitcoin UTXO set has grown substantially due to various factors, 
>>> including inscription protocols, spam attacks, and general dust 
>>> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
>>> Cleanup) by @ostrom72158
>>>   have attempted to address this by creating lists of specific UTXOs to 
>>> render unspendable, identified by external protocol indexers.
>>>
>>> The Cat's approach has a fatal flaw: it relies on a list.
>>>
>>> Using a curated list of "non-monetary UTXOs" introduces several problems:
>>>
>>> 1) External dependency: The Cat requires reference indexers (Ord, 
>>> Stamps, etc.) to define which UTXOs qualify. This introduces 
>>> consensus-level dependency on external, non-Bitcoin software that can 
>>> change, have bugs, or interpret protocols differently.
>>>
>>> 2) Protocol targeting: By specifically identifying inscription and stamp 
>>> outputs, the proposal makes subjective judgments about which Bitcoin uses 
>>> are legitimate. This sets a precedent for protocol-level discrimination.
>>>
>>> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
>>> workarounds. If Ordinals dust is targeted, protocols will adapt to create 
>>> dust that doesn't match the list criteria.
>>>
>>> 4) Static snapshot: A one-time list cleanup provides temporary relief 
>>> but does nothing for future UTXO accumulation.
>>>
>>> 5) Political vulnerability: Any list-based approach requires ongoing 
>>> governance decisions about what belongs on the list, creating a permanent 
>>> political attack surface.
>>>
>>> A better approach targets the economic reality, not the use case.
>>>
>>> UTXOs below the dust threshold are, by definition, economically 
>>> irrational to spend under normal fee conditions. The dust limit exists 
>>> precisely because spending these outputs costs more in fees than the output 
>>> is worth. These UTXOs are already "dead" in practice; this proposal simply 
>>> makes that reality explicit at the consensus layer.
>>>
>>> By using a threshold rather than a list, Lynx:
>>>
>>> - Requires no external indexers
>>> - Makes no judgment about why a UTXO is small
>>> - Applies equally to all participants
>>> - Provides ongoing, predictable maintenance
>>> - Removes political discretion from the process
>>>
>>> Impact on Inscription Protocols
>>>
>>> The typical Ordinals inscription is stored in a UTXO containing exactly 
>>> 546 sats; the minimum required to meet the dust limit for P2PKH addresses 
>>> and ensure transferability across all address types. This "postage" amount 
>>> is standard across inscription tooling and marketplaces.
>>>
>>> A threshold of 999 sats captures the vast majority of inscription UTXOs 
>>> without requiring any protocol-specific targeting. The economic model of 
>>> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
>>> that model through neutral, threshold-based rules rather than list-based 
>>> discrimination.
>>>
>>> Specification
>>>
>>> Definitions
>>>
>>> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is 
>>> subject to Lynx enforcement.
>>>
>>> - Halving block: A block at height N * 210,000 where N ≥ 1.
>>>
>>> -  Snapshot block: A halving block at which the current dust threshold 
>>> and qualifying UTXOs are recorded.
>>>
>>> -  Enforcement block: The halving block following a snapshot block 
>>> (i.e., snapshot block + 210,000 blocks).
>>>
>>> Lynx UTXOs:
>>> - Existed at the snapshot block
>>> - Had a value less than 999 sats
>>> - Remained unspent through the enforcement period (~4 years)
>>>
>>> Consensus Rules
>>> After activation, the following rules apply:
>>>
>>> 1) Snapshot: At each halving block H, record the set of all UTXOs with 
>>> value < 999 sats.
>>>
>>> 2) Enforcement: At halving block H + 210,000:
>>> - Any UTXO that was in the snapshot set and remains unspent becomes 
>>> permanently unspendable
>>> - Transactions attempting to spend these UTXOs are invalid
>>>
>>> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their 
>>> local UTXO set. Transactions referencing unknown outpoints are already 
>>> rejected as invalid; pruned Lynx UTXOs are simply treated as if they were 
>>> already spent.
>>>
>>> 4) Grace period: The ~4 year window between snapshot and enforcement 
>>> provides ample time for holders to consolidate sub-dust UTXOs if they wish 
>>> to preserve the value.
>>>
>>> Activation
>>>
>>> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
>>> determined by community consensus)
>>>
>>> Recommended first snapshot: The halving following activation lock-in
>>>
>>> Rationale
>>>
>>> Why a fixed threshold?
>>>
>>> Using a fixed threshold of 999 sats rather than referencing the dynamic 
>>> relay dust limit provides:
>>>
>>> - Simplicity: One number, no script-type variations, no need to query 
>>> policy settings
>>>
>>> - Predictability: Everyone knows exactly what qualifies, forever
>>>
>>> - Consensus clarity: No ambiguity about which outputs are affected.
>>>
>>> Why tie to the halving?
>>>
>>> The halving is Bitcoin's most recognized Schelling point, using it 
>>> provides:
>>>
>>> - Predictability: Everyone knows exactly when halvings occur
>>> - Sufficient notice: ~4 years is generous warning for any cleanup action
>>> - Aligned incentives: As block rewards decrease, fee revenue and UTXO 
>>> efficiency become more critical to network sustainability
>>> - Natural cadence: The halving already represents a moment of 
>>> network-wide coordination
>>>
>>> Why not a one-time cleanup?
>>>
>>> A one-time cleanup (as proposed by The Cat) provides temporary relief 
>>> but creates no ongoing pressure against dust accumulation. Periodic 
>>> enforcement:
>>>
>>> - Establishes a permanent, predictable norm
>>> - Removes any expectation that dust UTXOs have indefinite longevity
>>> - Discourages business models built on dust creation
>>> - Provides continuous UTXO set maintenance
>>>
>>> Why pruning works without a list
>>>
>>> A key insight enables pruning without maintaining a separate list: 
>>> Bitcoin nodes already reject transactions that reference unknown outpoints. 
>>> When a node receives a transaction spending an outpoint not in its UTXO 
>>> set, it rejects it as invalid — the node doesn't need to know why the 
>>> outpoint is missing (spent? never existed? pruned?).
>>>
>>> After enforcement, a Lynx UTXO is functionally equivalent to a spent 
>>> output. Nodes can simply delete it from the UTXO set. Any future 
>>> transaction attempting to spend it will reference an outpoint the node 
>>> doesn't recognize, and will be rejected through existing validation logic.
>>>
>>> This means:
>>>
>>> - No separate "Lynx list" is required
>>> - No new validation logic is needed
>>> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
>>> - The UTXO set shrinks naturally as nodes prune
>>>
>>> Why 999 sats?
>>>
>>> The threshold of 999 sats is chosen because:
>>>
>>> - Above all dust limits: Captures UTXOs at or below the dust limit for 
>>> all script types (P2PKH: 546, P2TR: 330, etc.)
>>> - Captures all standard inscriptions: Typical inscription UTXOs contain 
>>> exactly 546 sats as "postage"; well under 999
>>> - Simple and memorable: A clean number that's easy to communicate and 
>>> reason about
>>>
>>> Backward Compatibility
>>>
>>> This is a soft fork. Nodes that do not upgrade will:
>>>
>>> - Continue to consider all historical transactions valid
>>> - Accept blocks that exclude spends of Lynx UTXOs
>>> - Eventually converge with upgraded nodes (as upgraded miners will not 
>>> include invalid spends)
>>>
>>> Wallets & Services should:
>>>
>>> - Warn users holding sub-threshold UTXOs after a snapshot block
>>> - Provide consolidation tools during the grace period
>>> - Update UTXO selection algorithms to deprioritize or exclude 
>>> sub-threshold outputs approaching a snapshot
>>>
>>> Security Considerations
>>>
>>> No confiscation
>>>
>>> This proposal does not transfer value to any party. Sub-threshold UTXOs 
>>> become unspendable, similar to:
>>>
>>> - Lost private keys
>>> - Provably unspendable OP_RETURN outputs
>>> - Satoshi's untouched coinbase rewards
>>>
>>> The bitcoin supply cap remains unchanged; the affected outputs simply 
>>> become irrecoverable. Holders receive ~4 years notice to consolidate if 
>>> they value the sats.
>>>
>>> Lightning Network
>>>
>>> Some Lightning implementations create small HTLCs and dust outputs 
>>> during channel operations. Analysis is needed to determine:
>>>
>>> - Whether current dust thresholds affect normal LN operations
>>> - If LN implementations need adjustment before activation
>>> - Whether channel close scenarios create sub-threshold outputs
>>>
>>> Preliminary assessment: LN dust limits are already set conservatively 
>>> above relay dust limits, so impact should be minimal. However, this 
>>> requires verification from LN implementers.
>>>
>>> Fixed threshold vs. future fee markets
>>>
>>> The 999 satoshi threshold is fixed in consensus rules and does not 
>>> adjust based on fee market conditions. 
>>> This is intentional:
>>>
>>> - A fixed threshold provides certainty for users and developers
>>> - If fee markets change dramatically, a future soft fork could adjust 
>>> the threshold
>>> - The ~4 year grace period allows the community to observe and adapt
>>>
>>> If Bitcoin's fee market evolves such that 999 sats becomes economically 
>>> significant to spend, this would indicate broader success of the network; 
>>> and the community could choose to lower or eliminate the threshold through 
>>> a subsequent proposal.
>>>
>>> Acknowledgments
>>> This proposal builds on the problem identification in "The Cat" 
>>> (Non-monetary UTXO Cleanup) while proposing a list-free alternative 
>>> mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
>>> solving; Lynx offers a more neutral solution.
>>>
>>>
>>> https://x.com/matteopelleg/status/2000602318346334449
>>> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>>>
>>>> I received no prior response from you, so I suspect the issue is on 
>>>> your end-- since if you sent one I would normally have been directly 
>>>> copied. 
>>>>
>>>> In any case, your message makes no sense. If an output is provably 
>>>> unspendable then it is unspendable.  No amount of "clever steganography" 
>>>> can change that.   If you're imagining that perhaps they are *presumed* to 
>>>> be unspendable but actually *are* spendable, then sure that would be an 
>>>> issue but with any change to consensus relevant code great care must be 
>>>> taken to not introduce errors.  Actually *making* a consensus change would 
>>>> only increase the potential for mistakes.
>>>>
>>>> These costs are just another reason why this hysteria over a non-issue 
>>>> is misplaced.
>>>>
>>>> But in any case it is better that (any) implementations that care about 
>>>> stamps put in the effort to define their exclusions in ways that are safe 
>>>> than to burden everyone with a consensus change that doesn't care about it.
>>>>
>>>>
>>>> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>>>>
>>>>> This is my third attempt to respond to this. Idk what is going wrong 
>>>>> here.
>>>>>
>>>>> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set 
>>>>> without a consensus change is that a clever use of steganography could 
>>>>> cause one of those otherwise unspendable outputs to be spendable, thus 
>>>>> causing a fork between those nodes that adopted the Stamp pruning method 
>>>>> and those that did not once one of those steganographic Stamps is spent. 
>>>>> Though this is unlikely, it is still technically possible, and I would not 
>>>>> put it past the denizens of the Internet to stir up trouble just for its 
>>>>> own sake.
>>>>>
>>>>> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>>>>>
>>>>>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> 
>>>>>> wrote:
>>>>>>
>>>>>>> Since the Bitcoin Stamps outputs are already unspendable, it makes 
>>>>>>> perfect sense to mark and drop them from the UTXO set.
>>>>>>
>>>>>>
>>>>>> There is no consensus change involved in not storing a provably 
>>>>>> unspendable output, it's just an implementation detail with no 
>>>>>> interoperability implications and doesn't need a BIP.  Bitcoin core has 
>>>>>> long done so for several types of unspendable outputs, e.g. outputs over 
>>>>>> 10kb and ones starting with OP_RETURN.
>>>>>>
>>>>>> -- 
>>>>> You received this message because you are subscribed to the Google 
>>>>> Groups "Bitcoin Development Mailing List" group.
>>>>> To unsubscribe from this group and stop receiving emails from it, send 
>>>>> an email to bitcoindev+...@googlegroups.com.
>>>>>
>>>> To view this discussion visit 
>>>>> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
>>>>> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>>> .
>>>>>
>>>> -- 
>>> You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com.
>>>
>> To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com 
>>> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c87a50a4-1a1b-4aee-bc1f-bd1c91d675d1n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 24895 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-23 19:12  0%           ` Greg Maxwell
@ 2025-12-24 17:19  1%             ` waxwing/ AdamISZ
  2025-12-30 14:36  1%               ` Antoine Riard
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2025-12-24 17:19 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 19415 bytes --]

Hi Greg, list:

> I think the list should adopt a 1 year ban on parties *and their* 
employer(s) (if known) for any coin confiscation proposal on the list going 
forward (after, of course, making the rule clear on the signup page).  It's 
tiresome and beyond being a waste of time risks undermining public 
confidence in Bitcoin to see the constant trickle of these 
outrageous proposals in venues where they previously understood that 
serious discussions were to be had. People are, of course, free to discuss 
whatever ill-founded concepts they want but they're not entitled to the 
time and the reputation of the participants here for offensively misguided 
proposals. 

I'm a huge agree-er with the motivation of this comment and a huge 
disagree-er with the suggestion itself.

Actual confiscation, whatever the reason, hugely undermines Bitcoin's value 
to humanity - note I am not saying its financial value, but value as a 
project (and if we didn't see such value what the hell are we doing here). 
Of course those two types of value are very closely linked, but they are 
still distinct. I hold that same belief even when we are talking about 
other suggestions of confiscation, such as to address a quantum threat - 
something that has recently been discussed here, extensively.

Which brings me to my disagreement, which I know is not shared by a number 
of contributors here: just as it is hard to define spam on Bitcoin, it's 
also very hard to define it in a discussion forum like this one. Making 
suggestions which *I* think are terrible, or detrimental, on a list like 
this, should never be disallowed here. Notions of motivation of 
contributors (such as they are paid by such and such a company) should not 
be relevant. Everything should be open to discussion which is 
implementation-technical (so obviously not e.g. threats of violence or 
things that bring legal liability to participants or have zero relevance to 
Bitcoin's technical development) even if it's philosophy-motivated. And 
blocking should be reserved either as an anti-DOS measure if volume gets 
out of control, or if it brings dangers as per the previous parenthetical.

Just my opinion of course, I know that moderation of lists is not a simple 
matter.

Cheers,
AdamISZ/waxwing
On Tuesday, December 23, 2025 at 10:26:16 PM UTC-3 Greg Maxwell wrote:

> The 'dust threshold' isn't a consensus parameter, it's just a number 
> pulled out of the air that didn't seem unreasonable based on average fee 
> behavior.  But in any particular block transactions may need no particular 
> fee level at all, including zero fees.  And in some cases it may be very 
> economically advantageous to spend an output even if its face value doesn't 
> support it, NFT's being a one such example (although one I consider pretty 
> dumb).
>  
> This proposal also appears to have ignored the prior discussion 
> particularly where it was pointed out that 'deleting' outputs will not 
> achieve the goal of deleting the tokens connected to them (so won't 
> eliminate the incentive), or that txouts which are predictably not going to 
> be accessed (as this proposal claims applies to the txouts it targets) 
> don't have as significant performance implications (because they don't need 
> to be cached in ram).  It also appears to be uninformed by advances like 
> utxotree which makes the absolute size of the txout set much less 
> important, but would make mass removals such as that described 
> here expensive.  Nor has it considered that given the level of fee spending 
> on NFT traffic a requirement to keep it over some (reasonable) threshold 
> would not likely discourage it, or the fact that existent NFT outputs are 
> generally over the dust limit in any case (so the proposals failure to meet 
> the opcat proponents' delusional goals is already clear).
>
> I think the list should adopt a 1 year ban on parties *and their* 
> employer(s) (if known) for any coin confiscation proposal on the list going 
> forward (after, of course, making the rule clear on the signup page).  It's 
> tiresome and beyond being a waste of time risks undermining public 
> confidence in Bitcoin to see the constant trickle of these 
> outrageous proposals in venues where they previously understood that 
> serious discussions were to be had. People are, of course, free to discuss 
> whatever ill-founded concepts they want but they're not entitled to the 
> time and the reputation of the participants here for offensively misguided 
> proposals. 
>
>
> On Tue, Dec 23, 2025 at 6:27 PM John <johnpenn...@gmail.com> wrote:
>
>> Good evening all,
>>
>> Here is a related proposal by Matteo Pellegrini
>> @matteopelleg
>>
>>
>>
>> Lynx.
>>
>> Abstract
>> This proposal introduces a periodic, consensus-enforced mechanism for 
>> rendering UTXOs below the network's dust threshold permanently unspendable. 
>> At each halving block, UTXOs that have remained below the dust threshold 
>> since the previous halving become unspendable. These UTXOs become 
>> unspendable and may be pruned from the UTXO set entirely, reducing node 
>> storage requirements and eliminating the economic model that incentivizes 
>> their creation.
>>
>> Motivation
>> The Bitcoin UTXO set has grown substantially due to various factors, 
>> including inscription protocols, spam attacks, and general dust 
>> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
>> Cleanup) by @ostrom72158
>>   have attempted to address this by creating lists of specific UTXOs to 
>> render unspendable, identified by external protocol indexers.
>>
>> The Cat's approach has a fatal flaw: it relies on a list.
>>
>> Using a curated list of "non-monetary UTXOs" introduces several problems:
>>
>> 1) External dependency: The Cat requires reference indexers (Ord, Stamps, 
>> etc.) to define which UTXOs qualify. This introduces consensus-level 
>> dependency on external, non-Bitcoin software that can change, have bugs, or 
>> interpret protocols differently.
>>
>> 2) Protocol targeting: By specifically identifying inscription and stamp 
>> outputs, the proposal makes subjective judgments about which Bitcoin uses 
>> are legitimate. This sets a precedent for protocol-level discrimination.
>>
>> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
>> workarounds. If Ordinals dust is targeted, protocols will adapt to create 
>> dust that doesn't match the list criteria.
>>
>> 4) Static snapshot: A one-time list cleanup provides temporary relief but 
>> does nothing for future UTXO accumulation.
>>
>> 5) Political vulnerability: Any list-based approach requires ongoing 
>> governance decisions about what belongs on the list, creating a permanent 
>> political attack surface.
>>
>> A better approach targets the economic reality, not the use case.
>>
>> UTXOs below the dust threshold are, by definition, economically 
>> irrational to spend under normal fee conditions. The dust limit exists 
>> precisely because spending these outputs costs more in fees than the output 
>> is worth. These UTXOs are already "dead" in practice; this proposal simply 
>> makes that reality explicit at the consensus layer.
>>
>> By using a threshold rather than a list, Lynx:
>>
>> - Requires no external indexers
>> - Makes no judgment about why a UTXO is small
>> - Applies equally to all participants
>> - Provides ongoing, predictable maintenance
>> - Removes political discretion from the process
>>
>> Impact on Inscription Protocols
>>
>> The typical Ordinals inscription is stored in a UTXO containing exactly 
>> 546 sats; the minimum required to meet the dust limit for P2PKH addresses 
>> and ensure transferability across all address types. This "postage" amount 
>> is standard across inscription tooling and marketplaces.
>>
>> A threshold of 999 sats captures the vast majority of inscription UTXOs 
>> without requiring any protocol-specific targeting. The economic model of 
>> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
>> that model through neutral, threshold-based rules rather than list-based 
>> discrimination.
>>
>> Specification
>>
>> Definitions
>>
>> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is 
>> subject to Lynx enforcement.
>>
>> - Halving block: A block at height N * 210,000 where N ≥ 1.
>>
>> -  Snapshot block: A halving block at which the current dust threshold 
>> and qualifying UTXOs are recorded.
>>
>> -  Enforcement block: The halving block following a snapshot block (i.e., 
>> snapshot block + 210,000 blocks).
>>
>> Lynx UTXOs:
>> - Existed at the snapshot block
>> - Had a value less than 999 sats
>> - Remained unspent through the enforcement period (~4 years)
>>
>> Consensus Rules
>> After activation, the following rules apply:
>>
>> 1) Snapshot: At each halving block H, record the set of all UTXOs with 
>> value < 999 sats.
>>
>> 2) Enforcement: At halving block H + 210,000:
>> - Any UTXO that was in the snapshot set and remains unspent becomes 
>> permanently unspendable
>> - Transactions attempting to spend these UTXOs are invalid
>>
>> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their 
>> local UTXO set. Transactions referencing unknown outpoints are already 
>> rejected as invalid; pruned Lynx UTXOs are simply treated as if they were 
>> already spent.
>>
>> 4) Grace period: The ~4 year window between snapshot and enforcement 
>> provides ample time for holders to consolidate sub-dust UTXOs if they wish 
>> to preserve the value.
>>
>> Activation
>>
>> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
>> determined by community consensus)
>>
>> Recommended first snapshot: The halving following activation lock-in
>>
>> Rationale
>>
>> Why a fixed threshold?
>>
>> Using a fixed threshold of 999 sats rather than referencing the dynamic 
>> relay dust limit provides:
>>
>> - Simplicity: One number, no script-type variations, no need to query 
>> policy settings
>>
>> - Predictability: Everyone knows exactly what qualifies, forever
>>
>> - Consensus clarity: No ambiguity about which outputs are affected.
>>
>> Why tie to the halving?
>>
>> The halving is Bitcoin's most recognized Schelling point, using it 
>> provides:
>>
>> - Predictability: Everyone knows exactly when halvings occur
>> - Sufficient notice: ~4 years is generous warning for any cleanup action
>> - Aligned incentives: As block rewards decrease, fee revenue and UTXO 
>> efficiency become more critical to network sustainability
>> - Natural cadence: The halving already represents a moment of 
>> network-wide coordination
>>
>> Why not a one-time cleanup?
>>
>> A one-time cleanup (as proposed by The Cat) provides temporary relief but 
>> creates no ongoing pressure against dust accumulation. Periodic enforcement:
>>
>> - Establishes a permanent, predictable norm
>> - Removes any expectation that dust UTXOs have indefinite longevity
>> - Discourages business models built on dust creation
>> - Provides continuous UTXO set maintenance
>>
>> Why pruning works without a list
>>
>> A key insight enables pruning without maintaining a separate list: 
>> Bitcoin nodes already reject transactions that reference unknown outpoints. 
>> When a node receives a transaction spending an outpoint not in its UTXO 
>> set, it rejects it as invalid — the node doesn't need to know why the 
>> outpoint is missing (spent? never existed? pruned?).
>>
>> After enforcement, a Lynx UTXO is functionally equivalent to a spent 
>> output. Nodes can simply delete it from the UTXO set. Any future 
>> transaction attempting to spend it will reference an outpoint the node 
>> doesn't recognize, and will be rejected through existing validation logic.
>>
>> This means:
>>
>> - No separate "Lynx list" is required
>> - No new validation logic is needed
>> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
>> - The UTXO set shrinks naturally as nodes prune
>>
>> Why 999 sats?
>>
>> The threshold of 999 sats is chosen because:
>>
>> - Above all dust limits: Captures UTXOs at or below the dust limit for 
>> all script types (P2PKH: 546, P2TR: 330, etc.)
>> - Captures all standard inscriptions: Typical inscription UTXOs contain 
>> exactly 546 sats as "postage"; well under 999
>> - Simple and memorable: A clean number that's easy to communicate and 
>> reason about
>>
>> Backward Compatibility
>>
>> This is a soft fork. Nodes that do not upgrade will:
>>
>> - Continue to consider all historical transactions valid
>> - Accept blocks that exclude spends of Lynx UTXOs
>> - Eventually converge with upgraded nodes (as upgraded miners will not 
>> include invalid spends)
>>
>> Wallets & Services should:
>>
>> - Warn users holding sub-threshold UTXOs after a snapshot block
>> - Provide consolidation tools during the grace period
>> - Update UTXO selection algorithms to deprioritize or exclude 
>> sub-threshold outputs approaching a snapshot
>>
>> Security Considerations
>>
>> No confiscation
>>
>> This proposal does not transfer value to any party. Sub-threshold UTXOs 
>> become unspendable, similar to:
>>
>> - Lost private keys
>> - Provably unspendable OP_RETURN outputs
>> - Satoshi's untouched coinbase rewards
>>
>> The bitcoin supply cap remains unchanged; the affected outputs simply 
>> become irrecoverable. Holders receive ~4 years notice to consolidate if 
>> they value the sats.
>>
>> Lightning Network
>>
>> Some Lightning implementations create small HTLCs and dust outputs during 
>> channel operations. Analysis is needed to determine:
>>
>> - Whether current dust thresholds affect normal LN operations
>> - If LN implementations need adjustment before activation
>> - Whether channel close scenarios create sub-threshold outputs
>>
>> Preliminary assessment: LN dust limits are already set conservatively 
>> above relay dust limits, so impact should be minimal. However, this 
>> requires verification from LN implementers.
>>
>> Fixed threshold vs. future fee markets
>>
>> The 999 satoshi threshold is fixed in consensus rules and does not adjust 
>> based on fee market conditions. 
>> This is intentional:
>>
>> - A fixed threshold provides certainty for users and developers
>> - If fee markets change dramatically, a future soft fork could adjust the 
>> threshold
>> - The ~4 year grace period allows the community to observe and adapt
>>
>> If Bitcoin's fee market evolves such that 999 sats becomes economically 
>> significant to spend, this would indicate broader success of the network; 
>> and the community could choose to lower or eliminate the threshold through 
>> a subsequent proposal.
>>
>> Acknowledgments
>> This proposal builds on the problem identification in "The Cat" 
>> (Non-monetary UTXO Cleanup) while proposing a list-free alternative 
>> mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
>> solving; Lynx offers a more neutral solution.
>>
>>
>> https://x.com/matteopelleg/status/2000602318346334449
>> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>>
>>> I received no prior response from you, so I suspect the issue is on your 
>>> end-- since if you sent one I would normally have been directly copied. 
>>>
>>> In any case, your message makes no sense. If an output is provably 
>>> unspendable then it is unspendable.  No amount of "clever steganography" 
>>> can change that.   If you're imagining that perhaps they are *presumed* to 
>>> be unspendable but actually *are* spendable, then sure that would be an 
>>> issue but with any change to consensus relevant code great care must be 
>>> taken to not introduce errors.  Actually *making* a consensus change would 
>>> only increase the potential for mistakes.
>>>
>>> These costs are just another reason why this hysteria over a non-issue 
>>> is misplaced.
>>>
>>> But in any case it is better that (any) implementations that care about 
>>> stamps put in the effort to define their exclusions in ways that are safe 
>>> than to burden everyone with a consensus change that doesn't care about it.
>>>
>>>
>>> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>>>
>>>> This is my third attempt to respond to this. Idk what is going wrong 
>>>> here.
>>>>
>>>> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set 
>>>> without a consensus change is that a clever use of steganography could 
>>>> cause one of those otherwise unspendable outputs to be spendable, thus 
>>>> causing a fork between those nodes that adopted the Stamp pruning method 
>>>> and those that did not once one of those steganographic Stamps is spent. 
>>>> Though this is unlikely, it is still technically possible, and I would not 
>>>> put it past the denizens of the Internet to stir up trouble just for its 
>>>> own sake.
>>>>
>>>> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>>>>
>>>>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> 
>>>>> wrote:
>>>>>
>>>>>> Since the Bitcoin Stamps outputs are already unspendable, it makes 
>>>>>> perfect sense to mark and drop them from the UTXO set.
>>>>>
>>>>>
>>>>> There is no consensus change involved in not storing a provably 
>>>>> unspendable output, it's just an implementation detail with no 
>>>>> interoperability implications and doesn't need a BIP.  Bitcoin core has 
>>>>> long done so for several types of unspendable outputs, e.g. outputs over 
>>>>> 10kb and ones starting with OP_RETURN.
>>>>>
>>>>> -- 
>>>> You received this message because you are subscribed to the Google 
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send 
>>>> an email to bitcoindev+...@googlegroups.com.
>>>>
>>> To view this discussion visit 
>>>> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
>>>> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>> .
>>>>
>>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/213ed021-c57e-40b6-8357-c797f52c7d34n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 22495 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-21  5:07  3%         ` John
@ 2025-12-23 19:12  0%           ` Greg Maxwell
  2025-12-24 17:19  1%             ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-12-23 19:12 UTC (permalink / raw)
  To: John; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 16493 bytes --]

The 'dust threshold' isn't a consensus parameter, it's just a number pulled
out of the air that didn't seem unreasonable based on average fee
behavior.  But in any particular block transactions may need no particular
fee level at all, including zero fees.  And in some cases it may be very
economically advantageous to spend an output even if its face value doesn't
support it, NFT's being a one such example (although one I consider pretty
dumb).

This proposal also appears to have ignored the prior discussion
particularly where it was pointed out that 'deleting' outputs will not
achieve the goal of deleting the tokens connected to them (so won't
eliminate the incentive), or that txouts which are predictably not going to
be accessed (as this proposal claims applies to the txouts it targets)
don't have as significant performance implications (because they don't need
to be cached in ram).  It also appears to be uninformed by advances like
utxotree which makes the absolute size of the txout set much less
important, but would make mass removals such as that described
here expensive.  Nor has it considered that given the level of fee spending
on NFT traffic a requirement to keep it over some (reasonable) threshold
would not likely discourage it, or the fact that existent NFT outputs are
generally over the dust limit in any case (so the proposals failure to meet
the opcat proponents' delusional goals is already clear).

I think the list should adopt a 1 year ban on parties *and their*
employer(s) (if known) for any coin confiscation proposal on the list going
forward (after, of course, making the rule clear on the signup page).  It's
tiresome and beyond being a waste of time risks undermining public
confidence in Bitcoin to see the constant trickle of these
outrageous proposals in venues where they previously understood that
serious discussions were to be had. People are, of course, free to discuss
whatever ill-founded concepts they want but they're not entitled to the
time and the reputation of the participants here for offensively misguided
proposals.


On Tue, Dec 23, 2025 at 6:27 PM John <johnpenner151516@gmail.com> wrote:

> Good evening all,
>
> Here is a related proposal by Matteo Pellegrini
> @matteopelleg
>
>
>
> Lynx.
>
> Abstract
> This proposal introduces a periodic, consensus-enforced mechanism for
> rendering UTXOs below the network's dust threshold permanently unspendable.
> At each halving block, UTXOs that have remained below the dust threshold
> since the previous halving become unspendable. These UTXOs become
> unspendable and may be pruned from the UTXO set entirely, reducing node
> storage requirements and eliminating the economic model that incentivizes
> their creation.
>
> Motivation
> The Bitcoin UTXO set has grown substantially due to various factors,
> including inscription protocols, spam attacks, and general dust
> accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO
> Cleanup) by @ostrom72158
>   have attempted to address this by creating lists of specific UTXOs to
> render unspendable, identified by external protocol indexers.
>
> The Cat's approach has a fatal flaw: it relies on a list.
>
> Using a curated list of "non-monetary UTXOs" introduces several problems:
>
> 1) External dependency: The Cat requires reference indexers (Ord, Stamps,
> etc.) to define which UTXOs qualify. This introduces consensus-level
> dependency on external, non-Bitcoin software that can change, have bugs, or
> interpret protocols differently.
>
> 2) Protocol targeting: By specifically identifying inscription and stamp
> outputs, the proposal makes subjective judgments about which Bitcoin uses
> are legitimate. This sets a precedent for protocol-level discrimination.
>
> 3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes
> workarounds. If Ordinals dust is targeted, protocols will adapt to create
> dust that doesn't match the list criteria.
>
> 4) Static snapshot: A one-time list cleanup provides temporary relief but
> does nothing for future UTXO accumulation.
>
> 5) Political vulnerability: Any list-based approach requires ongoing
> governance decisions about what belongs on the list, creating a permanent
> political attack surface.
>
> A better approach targets the economic reality, not the use case.
>
> UTXOs below the dust threshold are, by definition, economically irrational
> to spend under normal fee conditions. The dust limit exists precisely
> because spending these outputs costs more in fees than the output is worth.
> These UTXOs are already "dead" in practice; this proposal simply makes that
> reality explicit at the consensus layer.
>
> By using a threshold rather than a list, Lynx:
>
> - Requires no external indexers
> - Makes no judgment about why a UTXO is small
> - Applies equally to all participants
> - Provides ongoing, predictable maintenance
> - Removes political discretion from the process
>
> Impact on Inscription Protocols
>
> The typical Ordinals inscription is stored in a UTXO containing exactly
> 546 sats; the minimum required to meet the dust limit for P2PKH addresses
> and ensure transferability across all address types. This "postage" amount
> is standard across inscription tooling and marketplaces.
>
> A threshold of 999 sats captures the vast majority of inscription UTXOs
> without requiring any protocol-specific targeting. The economic model of
> inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks
> that model through neutral, threshold-based rules rather than list-based
> discrimination.
>
> Specification
>
> Definitions
>
> -  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is
> subject to Lynx enforcement.
>
> - Halving block: A block at height N * 210,000 where N ≥ 1.
>
> -  Snapshot block: A halving block at which the current dust threshold and
> qualifying UTXOs are recorded.
>
> -  Enforcement block: The halving block following a snapshot block (i.e.,
> snapshot block + 210,000 blocks).
>
> Lynx UTXOs:
> - Existed at the snapshot block
> - Had a value less than 999 sats
> - Remained unspent through the enforcement period (~4 years)
>
> Consensus Rules
> After activation, the following rules apply:
>
> 1) Snapshot: At each halving block H, record the set of all UTXOs with
> value < 999 sats.
>
> 2) Enforcement: At halving block H + 210,000:
> - Any UTXO that was in the snapshot set and remains unspent becomes
> permanently unspendable
> - Transactions attempting to spend these UTXOs are invalid
>
> 3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their local
> UTXO set. Transactions referencing unknown outpoints are already rejected
> as invalid; pruned Lynx UTXOs are simply treated as if they were already
> spent.
>
> 4) Grace period: The ~4 year window between snapshot and enforcement
> provides ample time for holders to consolidate sub-dust UTXOs if they wish
> to preserve the value.
>
> Activation
>
> Activation method: TBD (Speedy Trial, BIP8, or other mechanism as
> determined by community consensus)
>
> Recommended first snapshot: The halving following activation lock-in
>
> Rationale
>
> Why a fixed threshold?
>
> Using a fixed threshold of 999 sats rather than referencing the dynamic
> relay dust limit provides:
>
> - Simplicity: One number, no script-type variations, no need to query
> policy settings
>
> - Predictability: Everyone knows exactly what qualifies, forever
>
> - Consensus clarity: No ambiguity about which outputs are affected.
>
> Why tie to the halving?
>
> The halving is Bitcoin's most recognized Schelling point, using it
> provides:
>
> - Predictability: Everyone knows exactly when halvings occur
> - Sufficient notice: ~4 years is generous warning for any cleanup action
> - Aligned incentives: As block rewards decrease, fee revenue and UTXO
> efficiency become more critical to network sustainability
> - Natural cadence: The halving already represents a moment of network-wide
> coordination
>
> Why not a one-time cleanup?
>
> A one-time cleanup (as proposed by The Cat) provides temporary relief but
> creates no ongoing pressure against dust accumulation. Periodic enforcement:
>
> - Establishes a permanent, predictable norm
> - Removes any expectation that dust UTXOs have indefinite longevity
> - Discourages business models built on dust creation
> - Provides continuous UTXO set maintenance
>
> Why pruning works without a list
>
> A key insight enables pruning without maintaining a separate list: Bitcoin
> nodes already reject transactions that reference unknown outpoints. When a
> node receives a transaction spending an outpoint not in its UTXO set, it
> rejects it as invalid — the node doesn't need to know why the outpoint is
> missing (spent? never existed? pruned?).
>
> After enforcement, a Lynx UTXO is functionally equivalent to a spent
> output. Nodes can simply delete it from the UTXO set. Any future
> transaction attempting to spend it will reference an outpoint the node
> doesn't recognize, and will be rejected through existing validation logic.
>
> This means:
>
> - No separate "Lynx list" is required
> - No new validation logic is needed
> - Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
> - The UTXO set shrinks naturally as nodes prune
>
> Why 999 sats?
>
> The threshold of 999 sats is chosen because:
>
> - Above all dust limits: Captures UTXOs at or below the dust limit for all
> script types (P2PKH: 546, P2TR: 330, etc.)
> - Captures all standard inscriptions: Typical inscription UTXOs contain
> exactly 546 sats as "postage"; well under 999
> - Simple and memorable: A clean number that's easy to communicate and
> reason about
>
> Backward Compatibility
>
> This is a soft fork. Nodes that do not upgrade will:
>
> - Continue to consider all historical transactions valid
> - Accept blocks that exclude spends of Lynx UTXOs
> - Eventually converge with upgraded nodes (as upgraded miners will not
> include invalid spends)
>
> Wallets & Services should:
>
> - Warn users holding sub-threshold UTXOs after a snapshot block
> - Provide consolidation tools during the grace period
> - Update UTXO selection algorithms to deprioritize or exclude
> sub-threshold outputs approaching a snapshot
>
> Security Considerations
>
> No confiscation
>
> This proposal does not transfer value to any party. Sub-threshold UTXOs
> become unspendable, similar to:
>
> - Lost private keys
> - Provably unspendable OP_RETURN outputs
> - Satoshi's untouched coinbase rewards
>
> The bitcoin supply cap remains unchanged; the affected outputs simply
> become irrecoverable. Holders receive ~4 years notice to consolidate if
> they value the sats.
>
> Lightning Network
>
> Some Lightning implementations create small HTLCs and dust outputs during
> channel operations. Analysis is needed to determine:
>
> - Whether current dust thresholds affect normal LN operations
> - If LN implementations need adjustment before activation
> - Whether channel close scenarios create sub-threshold outputs
>
> Preliminary assessment: LN dust limits are already set conservatively
> above relay dust limits, so impact should be minimal. However, this
> requires verification from LN implementers.
>
> Fixed threshold vs. future fee markets
>
> The 999 satoshi threshold is fixed in consensus rules and does not adjust
> based on fee market conditions.
> This is intentional:
>
> - A fixed threshold provides certainty for users and developers
> - If fee markets change dramatically, a future soft fork could adjust the
> threshold
> - The ~4 year grace period allows the community to observe and adapt
>
> If Bitcoin's fee market evolves such that 999 sats becomes economically
> significant to spend, this would indicate broader success of the network;
> and the community could choose to lower or eliminate the threshold through
> a subsequent proposal.
>
> Acknowledgments
> This proposal builds on the problem identification in "The Cat"
> (Non-monetary UTXO Cleanup) while proposing a list-free alternative
> mechanism. The Cat correctly identifies UTXO bloat as a problem worth
> solving; Lynx offers a more neutral solution.
>
>
> https://x.com/matteopelleg/status/2000602318346334449
> On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:
>
>> I received no prior response from you, so I suspect the issue is on your
>> end-- since if you sent one I would normally have been directly copied.
>>
>> In any case, your message makes no sense. If an output is provably
>> unspendable then it is unspendable.  No amount of "clever steganography"
>> can change that.   If you're imagining that perhaps they are *presumed* to
>> be unspendable but actually *are* spendable, then sure that would be an
>> issue but with any change to consensus relevant code great care must be
>> taken to not introduce errors.  Actually *making* a consensus change would
>> only increase the potential for mistakes.
>>
>> These costs are just another reason why this hysteria over a non-issue is
>> misplaced.
>>
>> But in any case it is better that (any) implementations that care about
>> stamps put in the effort to define their exclusions in ways that are safe
>> than to burden everyone with a consensus change that doesn't care about it.
>>
>>
>> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>>
>>> This is my third attempt to respond to this. Idk what is going wrong
>>> here.
>>>
>>> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without
>>> a consensus change is that a clever use of steganography could cause one of
>>> those otherwise unspendable outputs to be spendable, thus causing a fork
>>> between those nodes that adopted the Stamp pruning method and those that
>>> did not once one of those steganographic Stamps is spent. Though this is
>>> unlikely, it is still technically possible, and I would not put it past the
>>> denizens of the Internet to stir up trouble just for its own sake.
>>>
>>> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>>>
>>>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>>>>
>>>>> Since the Bitcoin Stamps outputs are already unspendable, it makes
>>>>> perfect sense to mark and drop them from the UTXO set.
>>>>
>>>>
>>>> There is no consensus change involved in not storing a provably
>>>> unspendable output, it's just an implementation detail with no
>>>> interoperability implications and doesn't need a BIP.  Bitcoin core has
>>>> long done so for several types of unspendable outputs, e.g. outputs over
>>>> 10kb and ones starting with OP_RETURN.
>>>>
>>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>>
>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com
>>> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgSB9tymGr_cddWSRkg36NvQqoAq%2B7%3DXkpvkbP_VpuCLJg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 18843 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-19  3:31  0%       ` Greg Maxwell
@ 2025-12-21  5:07  3%         ` John
  2025-12-23 19:12  0%           ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: John @ 2025-12-21  5:07 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 13327 bytes --]

Good evening all,

Here is a related proposal by Matteo Pellegrini
@matteopelleg



Lynx.

Abstract
This proposal introduces a periodic, consensus-enforced mechanism for 
rendering UTXOs below the network's dust threshold permanently unspendable. 
At each halving block, UTXOs that have remained below the dust threshold 
since the previous halving become unspendable. These UTXOs become 
unspendable and may be pruned from the UTXO set entirely, reducing node 
storage requirements and eliminating the economic model that incentivizes 
their creation.

Motivation
The Bitcoin UTXO set has grown substantially due to various factors, 
including inscription protocols, spam attacks, and general dust 
accumulation. Recent proposals such as "The Cat" (Non-monetary UTXO 
Cleanup) by @ostrom72158
  have attempted to address this by creating lists of specific UTXOs to 
render unspendable, identified by external protocol indexers.

The Cat's approach has a fatal flaw: it relies on a list.

Using a curated list of "non-monetary UTXOs" introduces several problems:

1) External dependency: The Cat requires reference indexers (Ord, Stamps, 
etc.) to define which UTXOs qualify. This introduces consensus-level 
dependency on external, non-Bitcoin software that can change, have bugs, or 
interpret protocols differently.

2) Protocol targeting: By specifically identifying inscription and stamp 
outputs, the proposal makes subjective judgments about which Bitcoin uses 
are legitimate. This sets a precedent for protocol-level discrimination.

3) Cat-and-mouse dynamics: Targeting specific protocols incentivizes 
workarounds. If Ordinals dust is targeted, protocols will adapt to create 
dust that doesn't match the list criteria.

4) Static snapshot: A one-time list cleanup provides temporary relief but 
does nothing for future UTXO accumulation.

5) Political vulnerability: Any list-based approach requires ongoing 
governance decisions about what belongs on the list, creating a permanent 
political attack surface.

A better approach targets the economic reality, not the use case.

UTXOs below the dust threshold are, by definition, economically irrational 
to spend under normal fee conditions. The dust limit exists precisely 
because spending these outputs costs more in fees than the output is worth. 
These UTXOs are already "dead" in practice; this proposal simply makes that 
reality explicit at the consensus layer.

By using a threshold rather than a list, Lynx:

- Requires no external indexers
- Makes no judgment about why a UTXO is small
- Applies equally to all participants
- Provides ongoing, predictable maintenance
- Removes political discretion from the process

Impact on Inscription Protocols

The typical Ordinals inscription is stored in a UTXO containing exactly 546 
sats; the minimum required to meet the dust limit for P2PKH addresses and 
ensure transferability across all address types. This "postage" amount is 
standard across inscription tooling and marketplaces.

A threshold of 999 sats captures the vast majority of inscription UTXOs 
without requiring any protocol-specific targeting. The economic model of 
inscriptions depends on these dust-level UTXOs being spendable; Lynx breaks 
that model through neutral, threshold-based rules rather than list-based 
discrimination.

Specification

Definitions

-  Dust threshold: 999 sats. Any UTXO with a value less than 999 sats is 
subject to Lynx enforcement.

- Halving block: A block at height N * 210,000 where N ≥ 1.

-  Snapshot block: A halving block at which the current dust threshold and 
qualifying UTXOs are recorded.

-  Enforcement block: The halving block following a snapshot block (i.e., 
snapshot block + 210,000 blocks).

Lynx UTXOs:
- Existed at the snapshot block
- Had a value less than 999 sats
- Remained unspent through the enforcement period (~4 years)

Consensus Rules
After activation, the following rules apply:

1) Snapshot: At each halving block H, record the set of all UTXOs with 
value < 999 sats.

2) Enforcement: At halving block H + 210,000:
- Any UTXO that was in the snapshot set and remains unspent becomes 
permanently unspendable
- Transactions attempting to spend these UTXOs are invalid

3) Pruning: After enforcement, nodes MAY prune Lynx UTXOs from their local 
UTXO set. Transactions referencing unknown outpoints are already rejected 
as invalid; pruned Lynx UTXOs are simply treated as if they were already 
spent.

4) Grace period: The ~4 year window between snapshot and enforcement 
provides ample time for holders to consolidate sub-dust UTXOs if they wish 
to preserve the value.

Activation

Activation method: TBD (Speedy Trial, BIP8, or other mechanism as 
determined by community consensus)

Recommended first snapshot: The halving following activation lock-in

Rationale

Why a fixed threshold?

Using a fixed threshold of 999 sats rather than referencing the dynamic 
relay dust limit provides:

- Simplicity: One number, no script-type variations, no need to query 
policy settings

- Predictability: Everyone knows exactly what qualifies, forever

- Consensus clarity: No ambiguity about which outputs are affected.

Why tie to the halving?

The halving is Bitcoin's most recognized Schelling point, using it provides:

- Predictability: Everyone knows exactly when halvings occur
- Sufficient notice: ~4 years is generous warning for any cleanup action
- Aligned incentives: As block rewards decrease, fee revenue and UTXO 
efficiency become more critical to network sustainability
- Natural cadence: The halving already represents a moment of network-wide 
coordination

Why not a one-time cleanup?

A one-time cleanup (as proposed by The Cat) provides temporary relief but 
creates no ongoing pressure against dust accumulation. Periodic enforcement:

- Establishes a permanent, predictable norm
- Removes any expectation that dust UTXOs have indefinite longevity
- Discourages business models built on dust creation
- Provides continuous UTXO set maintenance

Why pruning works without a list

A key insight enables pruning without maintaining a separate list: Bitcoin 
nodes already reject transactions that reference unknown outpoints. When a 
node receives a transaction spending an outpoint not in its UTXO set, it 
rejects it as invalid — the node doesn't need to know why the outpoint is 
missing (spent? never existed? pruned?).

After enforcement, a Lynx UTXO is functionally equivalent to a spent 
output. Nodes can simply delete it from the UTXO set. Any future 
transaction attempting to spend it will reference an outpoint the node 
doesn't recognize, and will be rejected through existing validation logic.

This means:

- No separate "Lynx list" is required
- No new validation logic is needed
- Pruning is optional; nodes MAY keep Lynx UTXOs if they wish
- The UTXO set shrinks naturally as nodes prune

Why 999 sats?

The threshold of 999 sats is chosen because:

- Above all dust limits: Captures UTXOs at or below the dust limit for all 
script types (P2PKH: 546, P2TR: 330, etc.)
- Captures all standard inscriptions: Typical inscription UTXOs contain 
exactly 546 sats as "postage"; well under 999
- Simple and memorable: A clean number that's easy to communicate and 
reason about

Backward Compatibility

This is a soft fork. Nodes that do not upgrade will:

- Continue to consider all historical transactions valid
- Accept blocks that exclude spends of Lynx UTXOs
- Eventually converge with upgraded nodes (as upgraded miners will not 
include invalid spends)

Wallets & Services should:

- Warn users holding sub-threshold UTXOs after a snapshot block
- Provide consolidation tools during the grace period
- Update UTXO selection algorithms to deprioritize or exclude sub-threshold 
outputs approaching a snapshot

Security Considerations

No confiscation

This proposal does not transfer value to any party. Sub-threshold UTXOs 
become unspendable, similar to:

- Lost private keys
- Provably unspendable OP_RETURN outputs
- Satoshi's untouched coinbase rewards

The bitcoin supply cap remains unchanged; the affected outputs simply 
become irrecoverable. Holders receive ~4 years notice to consolidate if 
they value the sats.

Lightning Network

Some Lightning implementations create small HTLCs and dust outputs during 
channel operations. Analysis is needed to determine:

- Whether current dust thresholds affect normal LN operations
- If LN implementations need adjustment before activation
- Whether channel close scenarios create sub-threshold outputs

Preliminary assessment: LN dust limits are already set conservatively above 
relay dust limits, so impact should be minimal. However, this requires 
verification from LN implementers.

Fixed threshold vs. future fee markets

The 999 satoshi threshold is fixed in consensus rules and does not adjust 
based on fee market conditions. 
This is intentional:

- A fixed threshold provides certainty for users and developers
- If fee markets change dramatically, a future soft fork could adjust the 
threshold
- The ~4 year grace period allows the community to observe and adapt

If Bitcoin's fee market evolves such that 999 sats becomes economically 
significant to spend, this would indicate broader success of the network; 
and the community could choose to lower or eliminate the threshold through 
a subsequent proposal.

Acknowledgments
This proposal builds on the problem identification in "The Cat" 
(Non-monetary UTXO Cleanup) while proposing a list-free alternative 
mechanism. The Cat correctly identifies UTXO bloat as a problem worth 
solving; Lynx offers a more neutral solution.


https://x.com/matteopelleg/status/2000602318346334449
On Thursday, 18 December 2025 at 21:36:14 UTC-6 Greg Maxwell wrote:

> I received no prior response from you, so I suspect the issue is on your 
> end-- since if you sent one I would normally have been directly copied. 
>
> In any case, your message makes no sense. If an output is provably 
> unspendable then it is unspendable.  No amount of "clever steganography" 
> can change that.   If you're imagining that perhaps they are *presumed* to 
> be unspendable but actually *are* spendable, then sure that would be an 
> issue but with any change to consensus relevant code great care must be 
> taken to not introduce errors.  Actually *making* a consensus change would 
> only increase the potential for mistakes.
>
> These costs are just another reason why this hysteria over a non-issue is 
> misplaced.
>
> But in any case it is better that (any) implementations that care about 
> stamps put in the effort to define their exclusions in ways that are safe 
> than to burden everyone with a consensus change that doesn't care about it.
>
>
> On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98...@gmail.com> wrote:
>
>> This is my third attempt to respond to this. Idk what is going wrong here.
>>
>> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without 
>> a consensus change is that a clever use of steganography could cause one of 
>> those otherwise unspendable outputs to be spendable, thus causing a fork 
>> between those nodes that adopted the Stamp pruning method and those that 
>> did not once one of those steganographic Stamps is spent. Though this is 
>> unlikely, it is still technically possible, and I would not put it past the 
>> denizens of the Internet to stir up trouble just for its own sake.
>>
>> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>>
>>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>>>
>>>> Since the Bitcoin Stamps outputs are already unspendable, it makes 
>>>> perfect sense to mark and drop them from the UTXO set.
>>>
>>>
>>> There is no consensus change involved in not storing a provably 
>>> unspendable output, it's just an implementation detail with no 
>>> interoperability implications and doesn't need a BIP.  Bitcoin core has 
>>> long done so for several types of unspendable outputs, e.g. outputs over 
>>> 10kb and ones starting with OP_RETURN.
>>>
>>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/959c8b53-2055-4de2-8a93-1fd169f1a159n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 16058 bytes --]

^ permalink raw reply	[relevance 3%]

* Re: [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-22 19:06  0%     ` Murch
@ 2025-12-22 19:33  0%       ` Defenwycke
  0 siblings, 0 replies; 200+ results
From: Defenwycke @ 2025-12-22 19:33 UTC (permalink / raw)
  To: Murch; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 16817 bytes --]

Hello Murch.


Thanks for taking the time to follow up and for spelling out the incentive
concerns so clearly.


You’re right - the recent reduction of the default minimum relay feerate to
0.1 sat/vB materially changes the economic backdrop I was assuming. Under
those conditions, most consolidation is already cheap enough that a
protocol- or policy-level mechanism no longer makes sense, and the
remaining friction is better addressed at the wallet/UX layer rather than
through miner or relay rules.


I agree with your point that Bitcoin policy should not rely on miners
selling blockspace below market value, and that any mechanism that only
encourages behavior without enforceable constraints is unlikely to be
justified.


I’m going to step back from this direction and reconsider the problem in a
different scope. I appreciate the careful read and the candid feedback. it
was helpful in clarifying where the real boundary lies.


Kind regards


Defenwycke



On Mon, 22 Dec 2025 at 19:06, Murch <murch@murch.one> wrote:

> Hi Defenwycke,
>
> You replied to every line of my email, except the most relevant one.
>
> Murch wrote:
>  > All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH
> input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB
> P2TR input costs 6 sats.
>
> Your proposal prescribes an entire new class of transactions that are
> managed by separate rules in a separate data structure. You propose to
> charge 5 sats per input for those transactions, and prescribe that
> miners should include such transactions even when they lose money by
> doing so: at elevated feerates. Especially at high feerates, it is
> irrational for miners to follow your proposal of selling blockspace
> below value.
>
> This idea is made completely obsolete by the recent lowering of the new
> minimum feerate. The most common inputs (P2WPKH) only cost <7 sats at
> the new minimum feerate, and the ones that make up the biggest portion
> of the UTXO set only costs <6 sats at the new minimum feerate. At low
> feerates, your proposal provides negligible benefits to senders compared
> to the status quo.
>
> Defenwycke wrote:
>  > Using current standard input sizes (≈68 vB for P2WPKH, ≈57.5 vB for
> P2TR keypath, ≈148 vB for P2PKH), the break-even spend cost quickly
> rises into the hundreds of sats once fee rates exceed a few sat/vB. At
> more common feerates (≈5–10 sat/vB), outputs below roughly 500–1500 sats
> are rationally abandoned depending on script type.
>
> The mempool has been routinely clearing down to 0.2 s/vB in the past
> months. Inputs spending low amount P2TR UTXOs of “500–1500 sats” cost
> 0.8–2.4% of their value at such feerates. I don’t see how getting back
> ~98% of the value translates to “it being rational to abandon such UTXOs”.
>
> This proposal seems rather laborious and complex, and I sincerely cannot
> see much benefit. If you want to incentivize people to consolidate their
> UTXOs, you have to design something where the incentives work out for
> both the producers and the consumers of blockspace. FWIW, it seems to me
> that people would already have a financial incentive to do so right now,
> so, perhaps you should first try to find out why they don’t already.
>
> Murch
>
>
> On 2025-12-13 06:56, defenwycke wrote:
> > Hello Murch,
> >
> > Thanks for the thoughtful response. Please find my response below.
> >
> >  > What does “dust-class” mean? Are you using the Bitcoin Core dust
> > limit or talking about small amounts in general? I don’t have figures
> > off the top of my head, but I would assume that there are relatively few
> > UTXOs smaller than BitcoinCore’s dust limit.
> >
> > I’m not referring to Bitcoin Core’s relay dust limits here. By “dust-
> > class” I mean outputs that are economically irrational to spend under
> > typical fee conditions, even though they remain technically valid. Using
> > current standard input sizes (≈68 vB for P2WPKH, ≈57.5 vB for P2TR
> > keypath, ≈148 vB for P2PKH), the break-even spend cost quickly rises
> > into the hundreds of sats once fee rates exceed a few sat/vB. At more
> > common feerates (≈5–10 sat/vB), outputs below roughly 500–1500 sats are
> > rationally abandoned depending on script type. So this is an economic
> > classification, not a relay-policy one.
> >
> >  > You might want to clarify that you mean only P2TR KP inputs. Or would
> > P2TR SP be permitted?
> >
> > Yes — only P2TR key-path spends would be permitted. Script-path spends
> > would be excluded. I’ll make that explicit.
> >
> >  > It would be a lot of work to have a separate pool for this, and I
> > don’t see a reason why they couldn’t just go in the regular mempool.
> >
> > Agreed. A physically separate mempool is not required. The intent is
> > simply that these transactions sit at the very bottom of the normal
> > mempool’s priority ordering and are treated as lowest priority for
> > eviction and inclusion
> >
> >  > That said, at 50% full, there are still around ~30 blocks worth of
> > transactions waiting in the mempool that pay fees, …
> >
> > Right - and DustSweep is not intended to provide any liveness guarantees
> > in that situation. These transactions are explicitly opportunistic and
> > are expected to idle or expire during sustained congestion. That
> > behaviour is acceptable and consistent with the goal of ensuring they
> > never compete with fee-paying transactions. The 50% figure was meant as
> > an illustrative policy threshold, not a claim that blockspace is
> > otherwise unused.
> >
> >  > …the only ones I have seen lately are miners using a minimum feerate
> > of 1 s/vB for their block templates.
> >
> > That aligns with the intent. DustSweep transactions would only ever be
> > eligible after normal block assembly, and only in templates that already
> > include all available fee-paying transactions.
> >
> >  > I assume the intention is to only relay these transactions when there
> > are blocks that aren’t full, to limit the bandwidth-wasting vector this
> > feature introduces, but overall it seems to me that it would be most
> > likely for such transactions to sit in nodes’ memory until they expire.
> >
> > That’s a fair characterization, and it matches the design goals. To
> > further limit policy complexity and relay churn, DustSweep transactions
> > would also be constrained to:
> >
> > - Confirmed inputs only (no unconfirmed ancestors
> >
> > - RBF disabled (no replacement or package churn)
> >
> > - No CPFP assumptions
> >
> > This keeps them cheap to reason about for node operators, and expiry
> > without confirmation is an expected outcome rather than a failure mode.
> > Importantly, these constraints mean DustSweep transactions require no
> > additional mempool state tracking, package evaluation, or replacement
> > logic beyond what nodes already implement today.
> >
> >  > It doesn’t seem obvious to me that saving a few dozen sats would
> > greatly foster the users’ urge to consolidate. It feels like a lot of
> > overhead for such a small incentive to the users, and relying on the
> > miners to give away blockspace below market value feels a bit optimistic
> > as well.
> >
> > I agree that the incentive is not primarily about recovering value.
> > Empirically, outputs in this range represent a large number of UTXOs but
> > very little aggregate bitcoin value. Even aggressive consolidation would
> > recover well under a single BTC in total. The motivation is instead
> > about long-term UTXO set hygiene: providing a narrow, predictable
> > mechanism for compacting outputs that are otherwise rationally
> > abandoned, without displacing market transactions or altering fee
> > dynamics. Because the economic value involved is small, the mechanism is
> > intentionally constrained to avoid creating meaningful incentives for
> > either users or miners to game block construction or relay policy. The
> > benefit is therefore not measured in recovered bitcoin value, but in
> > avoided long-term UTXO growth and reduced steady-state resource costs
> > for nodes.
> >
> > Separately (and not a dependency of this proposal), public analysis of
> > inscription-related activity shows that a significant share of UTXO
> > growth is tied to metadata-heavy patterns. Future work on segregated
> > data lanes could allow voluntary compaction of those UTXOs while
> > preserving metadata, but that’s orthogonal to DustSweep itself.
> >
> > Kind regards,
> >
> > Defenwycke
> >
> >
> > On Friday, December 12, 2025 at 11:19:17 PM UTC Murch wrote:
> >
> >     Hey Defenwycke,
> >
> >      > all inputs are “dust-class” UTXOs
> >
> >     What does “dust-class” mean? Are you using the Bitcoin Core dust
> limit
> >     or talking about small amounts in general? I don’t have figures off
> the
> >     top of my head, but I would assume that there are relatively few
> UTXOs
> >     smaller than Bitcoin Core’s dust limit.
> >
> >      > only standard scripts (P2PKH / P2WPKH / P2TR)
> >
> >     You might want to clarify that you mean only P2TR KP inputs. Or would
> >     P2TR SP be permitted?
> >
> >      > Nodes place these in a small, separate sub-mempool. They’re only
> >      > accepted when the normal mempool is <50% full, and they’re
> >      > automatically evicted if normal mempool usage hits 95%.
> >
> >     It would be a lot of work to have a separate pool for this, and I
> don’t
> >     see a reason why they couldn’t just go in the regular mempool. If the
> >     mempool fills up, they’d have the lowest feerates and they’d get
> kicked
> >     out first anyway. That said, at 50% full, there are still around ~30
> >     blocks worth of transactions waiting in the mempool that pay fees, …
> >
> >      > Miners can include them up to a small weight fraction (I suggest
> >     ~5%)
> >     but only after filling the block with regular fee-paying
> transactions.
> >
> >     … so if they are only considered in blocks that aren’t full, the only
> >     ones I have seen lately are miners using a minimum feerate of 1 s/vB
> >     for
> >     their block templates. Looking at some popular mempool statistic
> sites,
> >     in the past 32 months, there would have only been organically
> non-full
> >     blocks between April and August this year.
> >
> >     I assume the intention is to only relay these transactions when there
> >     are blocks that aren’t full, to limit the bandwidth-wasting vector
> this
> >     feature introduces, but overall it seems to me that it would be most
> >     likely for such transactions to sit in nodes’ memory until they
> expire.
> >
> >     All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH
> >     input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB
> >     P2TR input costs 6 sats. It doesn’t seem obvious to me that saving a
> >     few
> >     dozen sats would greatly foster the users’ urge to consolidate. It
> >     feels
> >     like a lot of overhead for such a small incentive to the users, and
> >     relying on the miners to give away blockspace below market value
> >     feels a
> >     bit optimistic as well.
> >
> >     Cheers,
> >     Murch
> >
> >     On 2025-12-11 04:53, defenwycke wrote:
> >      > Hello list,
> >      >
> >      > I’ve been working on a small policy proposal that aims to address
> >     one
> >      > very specific problem: the long-term accumulation of uneconomical
> >     dust
> >      > in the UTXO set.
> >      >
> >      > The idea is intentionally narrow. I’m calling it DustSweep, and it
> >      > defines a strict, non-abusable class of transactions that nodes
> may
> >      > relay and miners may include only when the mempool and block
> >     space are
> >      > underutilised. The goal is to give wallets a predictable way to
> >     compact
> >      > dust without introducing new spam vectors or touching consensus.
> >      >
> >      > A DustSweep transaction has the following properties:
> >      >
> >      > *
> >      >
> >      > all inputs are “dust-class” UTXOs
> >      >
> >      > *
> >      >
> >      > only standard scripts (P2PKH / P2WPKH / P2TR)
> >      >
> >      > *
> >      >
> >      > exactly one output
> >      >
> >      > *
> >      >
> >      > no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
> >      >
> >      > *
> >      >
> >      > minimum of 5 inputs (to ensure meaningful UTXO reduction)
> >      >
> >      > *
> >      >
> >      > size capped
> >      >
> >      > *
> >      >
> >      > it pays a flat 1 sat per input fee
> >      >
> >      > Nodes place these in a small, separate sub-mempool. They’re only
> >      > accepted when the normal mempool is <50% full, and they’re
> >     automatically
> >      > evicted if normal mempool usage hits 95%. Miners can include them
> >     up to
> >      > a small weight fraction (I suggest ~5%) but only after filling
> >     the block
> >      > with regular fee-paying transactions. The intention is that
> >     DustSweep
> >      > never competes with the fee market and only uses blockspace that
> >     would
> >      > otherwise go unused.
> >      >
> >      > This is all policy-level. No consensus changes, no new transaction
> >      > format, nothing that affects validation. Nodes that don’t
> >     implement it
> >      > simply treat these as low-fee transactions and drop them.
> >      >
> >      > The motivation is straightforward: we don’t currently have a safe,
> >      > structured way to compact dust, and the UTXO set continues to
> >     grow from
> >      > outputs that are effectively unspendable under normal fee
> >     conditions.
> >      > DustSweep tries to offer a predictable, opt-in mechanism for
> >     wallets to
> >      > clean that up without creating any new attack surface.
> >      >
> >      > Full draft BIP and supporting documents are here:
> >      >
> >      > https://github.com/defenwycke/bip-dust-sweep <https://github.com/
> >     defenwycke/bip-dust-sweep>
> >      >
> >      > I’d appreciate feedback on the policy details, thresholds, and
> >     whether
> >      > this fits within what node operators and wallet developers would
> >      > actually want to use. Happy to adjust parameters if there’s a
> better
> >      > balance point.
> >      >
> >      > Kind regards,
> >      >
> >      > Defenwycke
> >      >
> >      > --
> >      > You received this message because you are subscribed to the Google
> >      > Groups "Bitcoin Development Mailing List" group.
> >      > To unsubscribe from this group and stop receiving emails from it,
> >     send
> >      > an email to bitcoindev+...@googlegroups.com
> >      > <mailto:bitcoindev+...@googlegroups.com>.
> >      > To view this discussion visit https://groups.google.com/d/msgid/
> >     <https://groups.google.com/d/msgid/>
> >      > bitcoindev/b47aa182-bca7-44d7-bed1-
> >     f3cc2df30ef5n%40googlegroups.com <http://40googlegroups.com>
> >      > <https://groups.google.com/d/msgid/bitcoindev/b47aa182-bca7-44d7-
> >     bed1- <https://groups.google.com/d/msgid/bitcoindev/b47aa182-
> >     bca7-44d7-bed1->
> >      > f3cc2df30ef5n%40googlegroups.com?
> >     utm_medium=email&utm_source=footer <http://40googlegroups.com?
> >     utm_medium=email&utm_source=footer>>.
> >
> > --
> > You received this message because you are subscribed to the Google
> > Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> > an email to bitcoindev+unsubscribe@googlegroups.com
> > <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> > To view this discussion visit https://groups.google.com/d/msgid/
> > bitcoindev/841d6882-9853-4d96-84e8-c4742e17e969n%40googlegroups.com
> > <https://groups.google.com/d/msgid/bitcoindev/841d6882-9853-4d96-84e8-
> > c4742e17e969n%40googlegroups.com?utm_medium=email&utm_source=footer>.
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAOj3_X8cJLJChvv3-QSGA8j5MVwgYxn1BAUeugTTgiqUWzEK_Q%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 25894 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-13 14:56  1%   ` defenwycke
@ 2025-12-22 19:06  0%     ` Murch
  2025-12-22 19:33  0%       ` Defenwycke
  0 siblings, 1 reply; 200+ results
From: Murch @ 2025-12-22 19:06 UTC (permalink / raw)
  To: defenwycke, Bitcoin Development Mailing List

Hi Defenwycke,

You replied to every line of my email, except the most relevant one.

Murch wrote:
 > All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH 
input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB 
P2TR input costs 6 sats.

Your proposal prescribes an entire new class of transactions that are 
managed by separate rules in a separate data structure. You propose to 
charge 5 sats per input for those transactions, and prescribe that 
miners should include such transactions even when they lose money by 
doing so: at elevated feerates. Especially at high feerates, it is 
irrational for miners to follow your proposal of selling blockspace 
below value.

This idea is made completely obsolete by the recent lowering of the new 
minimum feerate. The most common inputs (P2WPKH) only cost <7 sats at 
the new minimum feerate, and the ones that make up the biggest portion 
of the UTXO set only costs <6 sats at the new minimum feerate. At low 
feerates, your proposal provides negligible benefits to senders compared 
to the status quo.

Defenwycke wrote:
 > Using current standard input sizes (≈68 vB for P2WPKH, ≈57.5 vB for 
P2TR keypath, ≈148 vB for P2PKH), the break-even spend cost quickly 
rises into the hundreds of sats once fee rates exceed a few sat/vB. At 
more common feerates (≈5–10 sat/vB), outputs below roughly 500–1500 sats 
are rationally abandoned depending on script type.

The mempool has been routinely clearing down to 0.2 s/vB in the past 
months. Inputs spending low amount P2TR UTXOs of “500–1500 sats” cost 
0.8–2.4% of their value at such feerates. I don’t see how getting back 
~98% of the value translates to “it being rational to abandon such UTXOs”.

This proposal seems rather laborious and complex, and I sincerely cannot 
see much benefit. If you want to incentivize people to consolidate their 
UTXOs, you have to design something where the incentives work out for 
both the producers and the consumers of blockspace. FWIW, it seems to me 
that people would already have a financial incentive to do so right now, 
so, perhaps you should first try to find out why they don’t already.

Murch


On 2025-12-13 06:56, defenwycke wrote:
> Hello Murch,
> 
> Thanks for the thoughtful response. Please find my response below.
> 
>  > What does “dust-class” mean? Are you using the Bitcoin Core dust 
> limit or talking about small amounts in general? I don’t have figures 
> off the top of my head, but I would assume that there are relatively few 
> UTXOs smaller than BitcoinCore’s dust limit.
> 
> I’m not referring to Bitcoin Core’s relay dust limits here. By “dust- 
> class” I mean outputs that are economically irrational to spend under 
> typical fee conditions, even though they remain technically valid. Using 
> current standard input sizes (≈68 vB for P2WPKH, ≈57.5 vB for P2TR 
> keypath, ≈148 vB for P2PKH), the break-even spend cost quickly rises 
> into the hundreds of sats once fee rates exceed a few sat/vB. At more 
> common feerates (≈5–10 sat/vB), outputs below roughly 500–1500 sats are 
> rationally abandoned depending on script type. So this is an economic 
> classification, not a relay-policy one.
> 
>  > You might want to clarify that you mean only P2TR KP inputs. Or would 
> P2TR SP be permitted?
> 
> Yes — only P2TR key-path spends would be permitted. Script-path spends 
> would be excluded. I’ll make that explicit.
> 
>  > It would be a lot of work to have a separate pool for this, and I 
> don’t see a reason why they couldn’t just go in the regular mempool.
> 
> Agreed. A physically separate mempool is not required. The intent is 
> simply that these transactions sit at the very bottom of the normal 
> mempool’s priority ordering and are treated as lowest priority for 
> eviction and inclusion
> 
>  > That said, at 50% full, there are still around ~30 blocks worth of 
> transactions waiting in the mempool that pay fees, …
> 
> Right - and DustSweep is not intended to provide any liveness guarantees 
> in that situation. These transactions are explicitly opportunistic and 
> are expected to idle or expire during sustained congestion. That 
> behaviour is acceptable and consistent with the goal of ensuring they 
> never compete with fee-paying transactions. The 50% figure was meant as 
> an illustrative policy threshold, not a claim that blockspace is 
> otherwise unused.
> 
>  > …the only ones I have seen lately are miners using a minimum feerate 
> of 1 s/vB for their block templates.
> 
> That aligns with the intent. DustSweep transactions would only ever be 
> eligible after normal block assembly, and only in templates that already 
> include all available fee-paying transactions.
> 
>  > I assume the intention is to only relay these transactions when there 
> are blocks that aren’t full, to limit the bandwidth-wasting vector this 
> feature introduces, but overall it seems to me that it would be most 
> likely for such transactions to sit in nodes’ memory until they expire.
> 
> That’s a fair characterization, and it matches the design goals. To 
> further limit policy complexity and relay churn, DustSweep transactions 
> would also be constrained to:
> 
> - Confirmed inputs only (no unconfirmed ancestors
> 
> - RBF disabled (no replacement or package churn)
> 
> - No CPFP assumptions
> 
> This keeps them cheap to reason about for node operators, and expiry 
> without confirmation is an expected outcome rather than a failure mode. 
> Importantly, these constraints mean DustSweep transactions require no 
> additional mempool state tracking, package evaluation, or replacement 
> logic beyond what nodes already implement today.
> 
>  > It doesn’t seem obvious to me that saving a few dozen sats would 
> greatly foster the users’ urge to consolidate. It feels like a lot of 
> overhead for such a small incentive to the users, and relying on the 
> miners to give away blockspace below market value feels a bit optimistic 
> as well.
> 
> I agree that the incentive is not primarily about recovering value. 
> Empirically, outputs in this range represent a large number of UTXOs but 
> very little aggregate bitcoin value. Even aggressive consolidation would 
> recover well under a single BTC in total. The motivation is instead 
> about long-term UTXO set hygiene: providing a narrow, predictable 
> mechanism for compacting outputs that are otherwise rationally 
> abandoned, without displacing market transactions or altering fee 
> dynamics. Because the economic value involved is small, the mechanism is 
> intentionally constrained to avoid creating meaningful incentives for 
> either users or miners to game block construction or relay policy. The 
> benefit is therefore not measured in recovered bitcoin value, but in 
> avoided long-term UTXO growth and reduced steady-state resource costs 
> for nodes.
> 
> Separately (and not a dependency of this proposal), public analysis of 
> inscription-related activity shows that a significant share of UTXO 
> growth is tied to metadata-heavy patterns. Future work on segregated 
> data lanes could allow voluntary compaction of those UTXOs while 
> preserving metadata, but that’s orthogonal to DustSweep itself.
> 
> Kind regards,
> 
> Defenwycke
> 
> 
> On Friday, December 12, 2025 at 11:19:17 PM UTC Murch wrote:
> 
>     Hey Defenwycke,
> 
>      > all inputs are “dust-class” UTXOs
> 
>     What does “dust-class” mean? Are you using the Bitcoin Core dust limit
>     or talking about small amounts in general? I don’t have figures off the
>     top of my head, but I would assume that there are relatively few UTXOs
>     smaller than Bitcoin Core’s dust limit.
> 
>      > only standard scripts (P2PKH / P2WPKH / P2TR)
> 
>     You might want to clarify that you mean only P2TR KP inputs. Or would
>     P2TR SP be permitted?
> 
>      > Nodes place these in a small, separate sub-mempool. They’re only
>      > accepted when the normal mempool is <50% full, and they’re
>      > automatically evicted if normal mempool usage hits 95%.
> 
>     It would be a lot of work to have a separate pool for this, and I don’t
>     see a reason why they couldn’t just go in the regular mempool. If the
>     mempool fills up, they’d have the lowest feerates and they’d get kicked
>     out first anyway. That said, at 50% full, there are still around ~30
>     blocks worth of transactions waiting in the mempool that pay fees, …
> 
>      > Miners can include them up to a small weight fraction (I suggest
>     ~5%)
>     but only after filling the block with regular fee-paying transactions.
> 
>     … so if they are only considered in blocks that aren’t full, the only
>     ones I have seen lately are miners using a minimum feerate of 1 s/vB
>     for
>     their block templates. Looking at some popular mempool statistic sites,
>     in the past 32 months, there would have only been organically non-full
>     blocks between April and August this year.
> 
>     I assume the intention is to only relay these transactions when there
>     are blocks that aren’t full, to limit the bandwidth-wasting vector this
>     feature introduces, but overall it seems to me that it would be most
>     likely for such transactions to sit in nodes’ memory until they expire.
> 
>     All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH
>     input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB
>     P2TR input costs 6 sats. It doesn’t seem obvious to me that saving a
>     few
>     dozen sats would greatly foster the users’ urge to consolidate. It
>     feels
>     like a lot of overhead for such a small incentive to the users, and
>     relying on the miners to give away blockspace below market value
>     feels a
>     bit optimistic as well.
> 
>     Cheers,
>     Murch
> 
>     On 2025-12-11 04:53, defenwycke wrote:
>      > Hello list,
>      >
>      > I’ve been working on a small policy proposal that aims to address
>     one
>      > very specific problem: the long-term accumulation of uneconomical
>     dust
>      > in the UTXO set.
>      >
>      > The idea is intentionally narrow. I’m calling it DustSweep, and it
>      > defines a strict, non-abusable class of transactions that nodes may
>      > relay and miners may include only when the mempool and block
>     space are
>      > underutilised. The goal is to give wallets a predictable way to
>     compact
>      > dust without introducing new spam vectors or touching consensus.
>      >
>      > A DustSweep transaction has the following properties:
>      >
>      > *
>      >
>      > all inputs are “dust-class” UTXOs
>      >
>      > *
>      >
>      > only standard scripts (P2PKH / P2WPKH / P2TR)
>      >
>      > *
>      >
>      > exactly one output
>      >
>      > *
>      >
>      > no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
>      >
>      > *
>      >
>      > minimum of 5 inputs (to ensure meaningful UTXO reduction)
>      >
>      > *
>      >
>      > size capped
>      >
>      > *
>      >
>      > it pays a flat 1 sat per input fee
>      >
>      > Nodes place these in a small, separate sub-mempool. They’re only
>      > accepted when the normal mempool is <50% full, and they’re
>     automatically
>      > evicted if normal mempool usage hits 95%. Miners can include them
>     up to
>      > a small weight fraction (I suggest ~5%) but only after filling
>     the block
>      > with regular fee-paying transactions. The intention is that
>     DustSweep
>      > never competes with the fee market and only uses blockspace that
>     would
>      > otherwise go unused.
>      >
>      > This is all policy-level. No consensus changes, no new transaction
>      > format, nothing that affects validation. Nodes that don’t
>     implement it
>      > simply treat these as low-fee transactions and drop them.
>      >
>      > The motivation is straightforward: we don’t currently have a safe,
>      > structured way to compact dust, and the UTXO set continues to
>     grow from
>      > outputs that are effectively unspendable under normal fee
>     conditions.
>      > DustSweep tries to offer a predictable, opt-in mechanism for
>     wallets to
>      > clean that up without creating any new attack surface.
>      >
>      > Full draft BIP and supporting documents are here:
>      >
>      > https://github.com/defenwycke/bip-dust-sweep <https://github.com/
>     defenwycke/bip-dust-sweep>
>      >
>      > I’d appreciate feedback on the policy details, thresholds, and
>     whether
>      > this fits within what node operators and wallet developers would
>      > actually want to use. Happy to adjust parameters if there’s a better
>      > balance point.
>      >
>      > Kind regards,
>      >
>      > Defenwycke
>      >
>      > --
>      > You received this message because you are subscribed to the Google
>      > Groups "Bitcoin Development Mailing List" group.
>      > To unsubscribe from this group and stop receiving emails from it,
>     send
>      > an email to bitcoindev+...@googlegroups.com
>      > <mailto:bitcoindev+...@googlegroups.com>.
>      > To view this discussion visit https://groups.google.com/d/msgid/
>     <https://groups.google.com/d/msgid/>
>      > bitcoindev/b47aa182-bca7-44d7-bed1-
>     f3cc2df30ef5n%40googlegroups.com <http://40googlegroups.com>
>      > <https://groups.google.com/d/msgid/bitcoindev/b47aa182-bca7-44d7-
>     bed1- <https://groups.google.com/d/msgid/bitcoindev/b47aa182-
>     bca7-44d7-bed1->
>      > f3cc2df30ef5n%40googlegroups.com?
>     utm_medium=email&utm_source=footer <http://40googlegroups.com?
>     utm_medium=email&utm_source=footer>>.
> 
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com 
> <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> To view this discussion visit https://groups.google.com/d/msgid/ 
> bitcoindev/841d6882-9853-4d96-84e8-c4742e17e969n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/841d6882-9853-4d96-84e8- 
> c4742e17e969n%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/3344ee13-ccd9-4f72-baa8-f420f74199b3%40murch.one.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-17 16:22  0%     ` Jonathan Voss
@ 2025-12-19  3:31  0%       ` Greg Maxwell
  2025-12-21  5:07  3%         ` John
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-12-19  3:31 UTC (permalink / raw)
  To: Jonathan Voss; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 3224 bytes --]

I received no prior response from you, so I suspect the issue is on your
end-- since if you sent one I would normally have been directly copied.

In any case, your message makes no sense. If an output is provably
unspendable then it is unspendable.  No amount of "clever steganography"
can change that.   If you're imagining that perhaps they are *presumed* to
be unspendable but actually *are* spendable, then sure that would be an
issue but with any change to consensus relevant code great care must be
taken to not introduce errors.  Actually *making* a consensus change would
only increase the potential for mistakes.

These costs are just another reason why this hysteria over a non-issue is
misplaced.

But in any case it is better that (any) implementations that care about
stamps put in the effort to define their exclusions in ways that are safe
than to burden everyone with a consensus change that doesn't care about it.


On Fri, Dec 19, 2025 at 1:49 AM Jonathan Voss <k98kurz@gmail.com> wrote:

> This is my third attempt to respond to this. Idk what is going wrong here.
>
> The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without a
> consensus change is that a clever use of steganography could cause one of
> those otherwise unspendable outputs to be spendable, thus causing a fork
> between those nodes that adopted the Stamp pruning method and those that
> did not once one of those steganographic Stamps is spent. Though this is
> unlikely, it is still technically possible, and I would not put it past the
> denizens of the Internet to stir up trouble just for its own sake.
>
> On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:
>
>> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>>
>>> Since the Bitcoin Stamps outputs are already unspendable, it makes
>>> perfect sense to mark and drop them from the UTXO set.
>>
>>
>> There is no consensus change involved in not storing a provably
>> unspendable output, it's just an implementation detail with no
>> interoperability implications and doesn't need a BIP.  Bitcoin core has
>> long done so for several types of unspendable outputs, e.g. outputs over
>> 10kb and ones starting with OP_RETURN.
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgSEX0dcg73qnrj5uP64Xaw%3Dukj7fhzng_1gT3BntjocNQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 4529 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] The Cat, BIP draft discussion.
  @ 2025-12-14  1:51  1%       ` Pepe Hodler
  2025-12-15 10:35  1%       ` Nona YoBidnes
  1 sibling, 0 replies; 200+ results
From: Pepe Hodler @ 2025-12-14  1:51 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3422 bytes --]



>> The proposed gain is some negligible one time reduction in utxo disk 
space.

The current UTXO set contains around 40-50% of dust outputs in spam UTXOs. 
The Cat would remove all of them from the UTXO set. I hardly think that's 
negligible. And The Cat would further signal to spammers we are no longer 
tolerating them on bitcoin, which would further prevent future UTXO bloat.

>> Were such a proposal seriously advanced it would likely cause a new 
flood of transactions both to move to evade it directly and as a result of 
NFT indexer changes to just "wormhole" the tokens to new outputs after the 
fact

Yes indeed, that would not be convenient for spammers, which is the entire 
point of The Cat. No one who is not a spammer would suffer. 

>> And moreover the proposal would intentionally and knowingly confiscate 
millions of dollars in funds.  

Only spammy UTXOs with below dust limit sats would be affected. And that 
you think it would result in millions of dollars lost to spammers speaks 
volume to how bad a problem spam is becoming.

>> This is outright theft, and I believe it makes the idea a total 
non-starter.

That is false. They would keep their precious spam intact on chain, they 
just would not be able to move it or transfer it to anyone else, which 
would severely diminish their profit incentives.   

>> No, just the Bitcoin-- but you indirectly make a fine point that it 
probably ought to be considered too.   

I don't think we should be considering the value or price of this spam. I 
don;t care if a jpeg is worth 1 cent or 1$ million, I don't want it on my 
bitcoin. If spammers lose any profit, that's the entire point of The Cat.

>> It's fine that you or I agree that NFT crap isn't appropriate to bitcoin 
but those harmed aren't beholden to your or my *opinion* and will 
absolutely seek redress through any and all means for the damage caused to 
them.

If you advocate that we should cater to spammers, and be 'nice' to them, 
the problem will only get worth. Let them rage quit. 



On Saturday, 13 December 2025 at 08:20:25 UTC-7 Greg Maxwell wrote:

> On Sat, Dec 13, 2025 at 10:05 AM TwoLargePizzas <zar...@gmail.com> wrote:
>
>> If the rules don't matter, they won't be bothered if the rules change. 
>>
>
> No, that kind of mutual exclusion is often not how things work and isn't 
> how they work here. They absolutely will be valued by this proposal 
> stealing their bitcoins,  but their NFT grifting will not ultimately be 
> effected otherwise.
>
> When you say "millions of dollars in funds" are you including the value of 
>> the NFTs tied to those sats
>>
>
> No, just the Bitcoin-- but you indirectly make a fine point that it 
> probably ought to be considered too.   It's fine that you or I agree that 
> NFT crap isn't appropriate to bitcoin but those harmed aren't beholden to 
> your or my *opinion* and will absolutely seek redress through any and all 
> means for the damage caused to them.
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/46652fac-ca26-4103-8ce4-67356f21adcan%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 4848 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] Re: Hash-Based Signatures for Bitcoin's Post-Quantum Future
  @ 2025-12-18 18:45  1% ` Erik Aronesty
  0 siblings, 0 replies; 200+ results
From: Erik Aronesty @ 2025-12-18 18:45 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5271 bytes --]

hi, check this out.  two simple new opcodes without requiring massive 
hash-based signatures and gets you all the quantum resistance you need.   

the trick is.. commit to a secret in one block, and reveal in a later 
block.  you use time-asymmetry to solve the information-asymmetry problem 
without needing a full signature.

anchor-gated, template-bound spend using OP_CTV (BIP119) plus one new 
opcode for on-chain anchor validation.  

https://gist.github.com/earonesty/ea086aa995be1a860af093f93bd45bf2

two new opcodes needd:

OP_CTV : commit to a spending template ( well tested already)
OP_CHECKTXIDDEPTHVERIFY: check that a tx exists a given depth and contains 
an op_return with specific value:

none of these are slow or expensive... and they are radically simpler than 
quantum signature schemes, while still giving the spending limitations 
needed for bitcoin

On Monday, December 8, 2025 at 12:47:49 PM UTC-8 Mikhail Kudinov wrote:

Hi everyone,

We'd like to share our analysis of post-quantum options for Bitcoin, 
focusing specifically on hash-based schemes. The Bitcoin community has 
already discussed SPHINCS+ adoption in previous mailing list threads. We 
also looked at this option. A detailed technical report exploring these 
schemes, parameter selections, security analysis, and implementation 
considerations is available at https://eprint.iacr.org/2025/2203.pdf. This 
report can also serve as a gentle introduction into hash-based schemes, 
covering the recent optimization techniques. The scripts that support this 
report are available at 
https://github.com/BlockstreamResearch/SPHINCS-Parameters .
Below, we give a quick summary of our findings.

We find hash-based signatures to be a compelling post-quantum solution for 
several reasons. They rely solely on the security of hash functions 
(Bitcoin already depends on the collision resistance of SHA-256) and are 
conceptually simple. Moreover, these schemes have undergone extensive 
cryptanalysis during the NIST post-quantum standardization process, adding 
confidence in their robustness.

One of the biggest drawbacks is the signature sizes. Standard SPHINCS+ 
signatures are almost 8KB. An important observation is that SPHINCS+ is 
designed to support up to 2^64 signatures. We argue that this bound can be 
set lower for Bitcoin use-cases. Moreover, there are several different 
optimizations (like WOTS+C, FORS+C, PORS+FP) to the standard SPHINCS+ 
scheme, that can reduce the signature size even more. 
For example, with these optimizations and a bound on 2^40 signatures we can 
get signatures of size 4036 bytes. For 2^30 signatures, we can achieve 3440 
bytes, and for 2^20, one can get 3128 bytes, while keeping the signing time 
reasonable. 

We should not forget that for Bitcoin, it is important that the size of the 
public key plus the size of the signature remains small. Hash-based schemes 
have one of the smallest sizes of public keys, which can be around 256 
bits. For comparison, ML-DSA pk+sig size is at least 3732 bytes.

Verification cost per byte is comparable to current Schnorr signatures, 
alleviating concerns about blockchain validation overhead. 

As for security targets, we argue that NIST Level 1 (128-bit security) 
provides sufficient protection. Quantum attacks require not just O(2^64) 
operations but approximately 2^78 Toffoli depth operations in practice, 
with limited parallelization benefits.

One of the key design decisions for Bitcoin is whether to rely exclusively 
on stateless schemes (where the secret key need not be updated for each 
signature) or whether stateful schemes could be viable. Stateful schemes 
introduce operational complexity in key management but can offer better 
performance.

We explored the possibilities of using hash-based schemes with Hierarchical 
Deterministic Wallets. The public child key derivation does not seem to be 
efficiently achievable. The hardened derivation is naturally possible for 
hash-based schemes. 

If we look at multi/distributed/threshold-signatures, we find that current 
approaches either don't give much gains compared to plain usage of multiple 
signatures, or require a trusted dealer, which drastically limits the 
use-cases. 

We welcome community feedback on this approach and hope to contribute to 
the broader discourse on ensuring Bitcoin's long-term security in the 
post-quantum era. In particular, we are interested in your thoughts on the 
following questions:
1) What are the concrete performance requirements across various hardware, 
including low-power devices?
2) Should multiple schemes with different signature limits be standardized?
3) Is there value in supporting stateful schemes alongside stateless ones?

Best regards,
Mikhail Kudinov and Jonas Nick
Blockstream Research

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/60d61084-f1aa-4911-a615-77d8597645c0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 5953 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-12 22:49  0% ` [bitcoindev] " Murch
@ 2025-12-13 14:56  1%   ` defenwycke
  2025-12-22 19:06  0%     ` Murch
  0 siblings, 1 reply; 200+ results
From: defenwycke @ 2025-12-13 14:56 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 11112 bytes --]



Hello Murch,

Thanks for the thoughtful response. Please find my response below.

> What does “dust-class” mean? Are you using the Bitcoin Core dust limit or 
talking about small amounts in general? I don’t have figures off the top of 
my head, but I would assume that there are relatively few UTXOs smaller 
than BitcoinCore’s dust limit.

I’m not referring to Bitcoin Core’s relay dust limits here. By “dust-class” 
I mean outputs that are economically irrational to spend under typical fee 
conditions, even though they remain technically valid. Using current 
standard input sizes (≈68 vB for P2WPKH, ≈57.5 vB for P2TR keypath, ≈148 vB 
for P2PKH), the break-even spend cost quickly rises into the hundreds of 
sats once fee rates exceed a few sat/vB. At more common feerates (≈5–10 
sat/vB), outputs below roughly 500–1500 sats are rationally abandoned 
depending on script type. So this is an economic classification, not a 
relay-policy one.

> You might want to clarify that you mean only P2TR KP inputs. Or would 
P2TR SP be permitted?

Yes — only P2TR key-path spends would be permitted. Script-path spends 
would be excluded. I’ll make that explicit.

> It would be a lot of work to have a separate pool for this, and I don’t 
see a reason why they couldn’t just go in the regular mempool.

Agreed. A physically separate mempool is not required. The intent is simply 
that these transactions sit at the very bottom of the normal mempool’s 
priority ordering and are treated as lowest priority for eviction and 
inclusion

> That said, at 50% full, there are still around ~30 blocks worth of 
transactions waiting in the mempool that pay fees, …

Right - and DustSweep is not intended to provide any liveness guarantees in 
that situation. These transactions are explicitly opportunistic and are 
expected to idle or expire during sustained congestion. That behaviour is 
acceptable and consistent with the goal of ensuring they never compete with 
fee-paying transactions. The 50% figure was meant as an illustrative policy 
threshold, not a claim that blockspace is otherwise unused.

> …the only ones I have seen lately are miners using a minimum feerate of 1 
s/vB for their block templates.

That aligns with the intent. DustSweep transactions would only ever be 
eligible after normal block assembly, and only in templates that already 
include all available fee-paying transactions.

> I assume the intention is to only relay these transactions when there are 
blocks that aren’t full, to limit the bandwidth-wasting vector this feature 
introduces, but overall it seems to me that it would be most likely for 
such transactions to sit in nodes’ memory until they expire.

That’s a fair characterization, and it matches the design goals. To further 
limit policy complexity and relay churn, DustSweep transactions would also 
be constrained to:

- Confirmed inputs only (no unconfirmed ancestors

- RBF disabled (no replacement or package churn)

- No CPFP assumptions

This keeps them cheap to reason about for node operators, and expiry 
without confirmation is an expected outcome rather than a failure mode. 
Importantly, these constraints mean DustSweep transactions require no 
additional mempool state tracking, package evaluation, or replacement logic 
beyond what nodes already implement today. 

> It doesn’t seem obvious to me that saving a few dozen sats would greatly 
foster the users’ urge to consolidate. It feels like a lot of overhead for 
such a small incentive to the users, and relying on the miners to give away 
blockspace below market value feels a bit optimistic as well.

I agree that the incentive is not primarily about recovering value. 
Empirically, outputs in this range represent a large number of UTXOs but 
very little aggregate bitcoin value. Even aggressive consolidation would 
recover well under a single BTC in total. The motivation is instead about 
long-term UTXO set hygiene: providing a narrow, predictable mechanism for 
compacting outputs that are otherwise rationally abandoned, without 
displacing market transactions or altering fee dynamics. Because the 
economic value involved is small, the mechanism is intentionally 
constrained to avoid creating meaningful incentives for either users or 
miners to game block construction or relay policy. The benefit is therefore 
not measured in recovered bitcoin value, but in avoided long-term UTXO 
growth and reduced steady-state resource costs for nodes. 

Separately (and not a dependency of this proposal), public analysis of 
inscription-related activity shows that a significant share of UTXO growth 
is tied to metadata-heavy patterns. Future work on segregated data lanes 
could allow voluntary compaction of those UTXOs while preserving metadata, 
but that’s orthogonal to DustSweep itself.

Kind regards,

Defenwycke

On Friday, December 12, 2025 at 11:19:17 PM UTC Murch wrote:

> Hey Defenwycke,
>
> > all inputs are “dust-class” UTXOs
>
> What does “dust-class” mean? Are you using the Bitcoin Core dust limit 
> or talking about small amounts in general? I don’t have figures off the 
> top of my head, but I would assume that there are relatively few UTXOs 
> smaller than Bitcoin Core’s dust limit.
>
> > only standard scripts (P2PKH / P2WPKH / P2TR)
>
> You might want to clarify that you mean only P2TR KP inputs. Or would 
> P2TR SP be permitted?
>
> > Nodes place these in a small, separate sub-mempool. They’re only
> > accepted when the normal mempool is <50% full, and they’re
> > automatically evicted if normal mempool usage hits 95%.
>
> It would be a lot of work to have a separate pool for this, and I don’t 
> see a reason why they couldn’t just go in the regular mempool. If the 
> mempool fills up, they’d have the lowest feerates and they’d get kicked 
> out first anyway. That said, at 50% full, there are still around ~30 
> blocks worth of transactions waiting in the mempool that pay fees, …
>
> > Miners can include them up to a small weight fraction (I suggest ~5%) 
> but only after filling the block with regular fee-paying transactions.
>
> … so if they are only considered in blocks that aren’t full, the only 
> ones I have seen lately are miners using a minimum feerate of 1 s/vB for 
> their block templates. Looking at some popular mempool statistic sites, 
> in the past 32 months, there would have only been organically non-full 
> blocks between April and August this year.
>
> I assume the intention is to only relay these transactions when there 
> are blocks that aren’t full, to limit the bandwidth-wasting vector this 
> feature introduces, but overall it seems to me that it would be most 
> likely for such transactions to sit in nodes’ memory until they expire.
>
> All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH 
> input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB 
> P2TR input costs 6 sats. It doesn’t seem obvious to me that saving a few 
> dozen sats would greatly foster the users’ urge to consolidate. It feels 
> like a lot of overhead for such a small incentive to the users, and 
> relying on the miners to give away blockspace below market value feels a 
> bit optimistic as well.
>
> Cheers,
> Murch
>
> On 2025-12-11 04:53, defenwycke wrote:
> > Hello list,
> > 
> > I’ve been working on a small policy proposal that aims to address one 
> > very specific problem: the long-term accumulation of uneconomical dust 
> > in the UTXO set.
> > 
> > The idea is intentionally narrow. I’m calling it DustSweep, and it 
> > defines a strict, non-abusable class of transactions that nodes may 
> > relay and miners may include only when the mempool and block space are 
> > underutilised. The goal is to give wallets a predictable way to compact 
> > dust without introducing new spam vectors or touching consensus.
> > 
> > A DustSweep transaction has the following properties:
> > 
> > *
> > 
> > all inputs are “dust-class” UTXOs
> > 
> > *
> > 
> > only standard scripts (P2PKH / P2WPKH / P2TR)
> > 
> > *
> > 
> > exactly one output
> > 
> > *
> > 
> > no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
> > 
> > *
> > 
> > minimum of 5 inputs (to ensure meaningful UTXO reduction)
> > 
> > *
> > 
> > size capped
> > 
> > *
> > 
> > it pays a flat 1 sat per input fee
> > 
> > Nodes place these in a small, separate sub-mempool. They’re only 
> > accepted when the normal mempool is <50% full, and they’re automatically 
> > evicted if normal mempool usage hits 95%. Miners can include them up to 
> > a small weight fraction (I suggest ~5%) but only after filling the block 
> > with regular fee-paying transactions. The intention is that DustSweep 
> > never competes with the fee market and only uses blockspace that would 
> > otherwise go unused.
> > 
> > This is all policy-level. No consensus changes, no new transaction 
> > format, nothing that affects validation. Nodes that don’t implement it 
> > simply treat these as low-fee transactions and drop them.
> > 
> > The motivation is straightforward: we don’t currently have a safe, 
> > structured way to compact dust, and the UTXO set continues to grow from 
> > outputs that are effectively unspendable under normal fee conditions. 
> > DustSweep tries to offer a predictable, opt-in mechanism for wallets to 
> > clean that up without creating any new attack surface.
> > 
> > Full draft BIP and supporting documents are here:
> > 
> > https://github.com/defenwycke/bip-dust-sweep
> > 
> > I’d appreciate feedback on the policy details, thresholds, and whether 
> > this fits within what node operators and wallet developers would 
> > actually want to use. Happy to adjust parameters if there’s a better 
> > balance point.
> > 
> > Kind regards,
> > 
> > Defenwycke
> > 
> > -- 
> > You received this message because you are subscribed to the Google 
> > Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> > an email to bitcoindev+...@googlegroups.com 
> > <mailto:bitcoindev+...@googlegroups.com>.
> > To view this discussion visit https://groups.google.com/d/msgid/ 
> > bitcoindev/b47aa182-bca7-44d7-bed1-f3cc2df30ef5n%40googlegroups.com 
> > <https://groups.google.com/d/msgid/bitcoindev/b47aa182-bca7-44d7-bed1- 
> > f3cc2df30ef5n%40googlegroups.com?utm_medium=email&utm_source=footer>.
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/841d6882-9853-4d96-84e8-c4742e17e969n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 13726 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-12 23:40  1%   ` Greg Maxwell
  2025-12-13  3:54  2%     ` Melvin Carvalho
  2025-12-13  7:07  1%     ` Ataraxia 009
@ 2025-12-17 16:22  0%     ` Jonathan Voss
  2025-12-19  3:31  0%       ` Greg Maxwell
  2 siblings, 1 reply; 200+ results
From: Jonathan Voss @ 2025-12-17 16:22 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 1614 bytes --]

This is my third attempt to respond to this. Idk what is going wrong here.

The problem with dropping Bitcoin Stamps UTXOs from the UTXO set without a 
consensus change is that a clever use of steganography could cause one of 
those otherwise unspendable outputs to be spendable, thus causing a fork 
between those nodes that adopted the Stamp pruning method and those that 
did not once one of those steganographic Stamps is spent. Though this is 
unlikely, it is still technically possible, and I would not put it past the 
denizens of the Internet to stir up trouble just for its own sake.

On Friday, December 12, 2025 at 6:49:41 PM UTC-5 Greg Maxwell wrote:

> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98...@gmail.com> wrote:
>
>> Since the Bitcoin Stamps outputs are already unspendable, it makes 
>> perfect sense to mark and drop them from the UTXO set.
>
>
> There is no consensus change involved in not storing a provably 
> unspendable output, it's just an implementation detail with no 
> interoperability implications and doesn't need a BIP.  Bitcoin core has 
> long done so for several types of unspendable outputs, e.g. outputs over 
> 10kb and ones starting with OP_RETURN.
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/4e947f47-b43d-4ec3-ac6a-aa66ea0cfb79n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 2436 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] The Cat, BIP draft discussion.
  2025-12-15 10:35  1%       ` Nona YoBidnes
@ 2025-12-15 16:04  1%         ` Greg Maxwell
  0 siblings, 0 replies; 200+ results
From: Greg Maxwell @ 2025-12-15 16:04 UTC (permalink / raw)
  To: Nona YoBidnes; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 8747 bytes --]

On Mon, Dec 15, 2025 at 10:35 AM Nona YoBidnes <pepehodler@gmail.com> wrote:

> Here, your argument runs completely opposite of the claim that "the miner
> fees are the filter". You appear to be claiming that dping nothing about
> spam, making it easier for spammers and being more accommodating to them is
> the way to go. Unfortunately, that's the approach we have taken for the
> last 3 years while spam only gets worst.
>

On what basis do you claim that spam has 'only gotten worse'--  the
existing setup is incredibly effective against spam, essentially blocking
all forms of pointless data storage that aren't made more valuable by the
limitations.  What does go in, goes in at extremely high costs to the
spammer.

Of what concern is this residual traffic to Bitcoin use?  It doesn't
increase node resource use as that's governed by the capacity limits, in
fact because it's generally much easier to process it speeds up block
processing.  It's substantially a non-issue.

The proposed gain is some negligible one time reduction in utxo disk space.
>
>
> Between 40 and 50% of the UTXO set is comprised of spam UTXOs with dust
> amounts. Even more conservative estimates put it at 30%. The Cat would
> remove those spam NMUs from the UTXO set. I hardly view that as negligible.
>

It is negligible-- it's just a one time constant fraction.  It will not
increase the set of devices that can run a node in any meaningful sense.
What improvement it provides could also be alternatively achieved through
local only technical changes like changing how the data is stored.

Furthermore, The Cat would send a strong signal to spammers: you are not
> welcomed on Bitcoin, we are rugging you, and we might do it again. This
> likely would reduce future spam activity on Bitcoin, further protecting the
> UTXO set.
>

As I've pointed out, it won't stop their NFTs.  They'll simply make a new
rule in their NFT indexers that says that deleted NFT X will be owned by
the first output created with the same (or cryptographically related)
scriptPubKey.  Doing so will give them free press-- probably the most
valuable thing that could possibly be done for them--, cause them to make
additional txn, and send a message that their NFTs are _unblockable_
because they are.

Moreover, it would send a message to the whole world that your Bitcoin
aren't safe.  That an angry mob might confiscate them from you if you
became unpopular enough in their eyes.  That would be entirely at odds with
the ethos of Bitcoin--  Bitcoin is money for enemies.  Your ownership of
Bitcoin shouldn't be up to popular vote-- if you're okay with money that
operates at popular whim then you're better off with the fiat of a major
democracy.  Because of this this proposal just won't fly and this
discussion is a waste of time and energy that could be otherwise used to
actually improve Bitcoin.


> Were such a proposal seriously advanced it would likely cause a new flood
> of transactions both to move to evade it directly and as a result of NFT
> indexer changes to just "wormhole" the tokens to new outputs after the fact
> (and a new marketing opportunity for the NFT gifters).
>
>
>  As Claire already explained, with millions of cases of spam, this would
> cause a massive block space demand increase and a large fee spike which
> would prove very costly to spammers. And retaking a new snapshot would
> force them to do it again. Someone needs to feed the poor miners!
>

Existing data embedding traffic is already definitionally the tiny residual
interest which is not particularly price sensitive or they wouldn't be on
Bitcoin at all.  In the case of NFTs the limitation makes their tokens more
valuable by creating a limited supply or an otherwise endless asset class.
"Claire"'s explanation is just false as it assumes they'd reembed the NFTs,
but there is no reason for them to do that as the existence of an NFT isn't
governed by Bitcoin's consensus rules but rather by the behavior of NFT
indexers-- and they don't pay any attention to the UTXO set at all but
rather watch the blockchain and maintain their own indexes.  So post this
proposal when you want to transfer your 'deleted' NFT you simply make one
transaction paying your old scriptPubKey (or some related one, as per the
revised NFT spec) and then pay that output to the new owner-- the extra
cost to the NFT jockie is one extra in/out pair at their first transfer
post 'deletion'.  And god knows they may find a way to even reduce that
further, my example is just the extremely obvious response and not whatever
improved idea someone would come up with after actually thinking about it.


> NFTs are just an imaginary parallel world that don't depend on the network
> to validate their activity, so they don't really care about the network's
> rules, and as such the network's rules have pretty limited effect.
>
> So here, you are saying The Cat would be noneffective at reducing spam.
>
> And moreover the proposal would intentionally and knowingly confiscate
> millions of dollars in funds.
>
>
> You just finished telling us "the network rules have a pretty limited
> effect" and now you tell us The Cat would result in the confiscation of
> millions of dollars in funds.  That sounds conflicting and contradictory to
> me.
>

The consensus rules govern the operations of *bitcoins* not NFTs.  This
proposal would delete their Bitcoins, based on the published figures (and
the percentages in your post) it would be confiscate on the order of 358
Bitcoin.

It wouldn't, however, confiscate their NFTs.

Furthermore, dropping the spam UTXOs from the UTXO set would not delete any
> spam, they still would have ownership of it, they just wouldn't be able to
> sell it or transfer it to anyone else on L1.
>

It would steal their Bitcoin's but leave them able to continue transferring
their NFTs.


> Furthermore, those are all dust UTXOs. An unbelievably high amount of them
> would have to be on chain to amount to "millions of dollars in funds".
>
Yes, but that is exactly what this proposal is claiming-- They're almost
all >=546 satoshi in value. There are 164 million txouts, you and the
proposals are saying 40-50% would be confiscated.  Do the math.

If they lose "millions of dollars in funds" as you claim, thus making their
> business must less profitable, I would call that a success, not ineffective
> at all.
>
I hope you step back and think carefully about what you're saying here.

I, and many others, consider the aggressive anti-'spammers' to be a threat
to Bitcoin in a way that some NFT nuisance traffic could never be due to
the quick recourse to confiscation and censorship and the constant baiting
of government interference by proposing technical means for transaction
censorship and confiscation. Should I propose to confiscate the funds of
Opsosoft and Ocean Mining (and you personally, of course) in order to
discourage the continued efforts to screw with Bitcoin's central properties?

It would be much more effective against you than it is against the NFT
jockeys because at least the NFT degens would get to keep and continue to
trade their NFTs.

Fortunately for you (and everyone!) that just isn't how Bitcoin works:
confiscation proposals are non-starters.  But it says something significant
about the level of derangement suffered by its advocates that someone had
to tell someone who isn't a total Bitcoin newbie that it was a non-starter.

You, presumably, do not consider yourself and your comrades a threat to
Bitcoin, but nor do the NFT degens.  Such determinations are highly
subjective, and Bitcoins design and purpose was to minimize human judgement
over how people get to store and use their own coins.  An inherent
consequence of that is that there will always be users and users we
strongly disapprove of personally.  Having seen the alternative in dollars
and paypal and whatnot this is an acceptable cost.

We should all still feel empowered to fight that which we think harms the
world-- but the place for that kind of battle is outside of the Bitcoin
protocol.  Bitcoin is valuable because it strives to eliminate third party
judgement from the ownership and usage by consenting parties.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQLKD1-DomvniTHLTvw52yeaKmOG-K__TnZeYJ%2Bc2hYFA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 12167 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] The Cat, BIP draft discussion.
    2025-12-14  1:51  1%       ` Pepe Hodler
@ 2025-12-15 10:35  1%       ` Nona YoBidnes
  2025-12-15 16:04  1%         ` Greg Maxwell
  1 sibling, 1 reply; 200+ results
From: Nona YoBidnes @ 2025-12-15 10:35 UTC (permalink / raw)
  To: Greg Maxwell, bitcoindev

[-- Attachment #1: Type: text/plain, Size: 5151 bytes --]

Hi Greg and list,

    Techniques to minimize usage are well understood, widely deployed,
    and the cost of storing data that way is very high so none happens
    except by those who are very motivated and financially capable (and
    that motivation and means results in speed bumps having little
    effect, -- or even positive effect, as the remaining abuses appear
    to find bitcoin's costs/restrictions highly desirable to create
    scarcity for their tokens).


Here, your argument runs completely opposite of the claim that "the 
miner fees are the filter". You appear to be claiming that dping nothing 
about spam, making it easier for spammers and being more accommodating 
to them is the way to go. Unfortunately, that's the approach we have 
taken for the last 3 years while spam only gets worst.

The reality is that making it harder, more costly, and less convenient 
for spammers to keep going will result in less spam, not more. While 
it's possible that the remaining spam might be valued higher by the 
market, I don't really care about the price of spam, I only care to 
reduce the amount of it, not the price. Less spam is the objective here. 
I'm not concerned with the price of spam, only the quantity of spam.

You seem to approach spam like a bullied kid, afraid that if we fight 
back against spam, the big mean spam bully might spam us harder. I can't 
accept this kind of approach. Bitcoin requires and adversarial mindset, 
not one of compliance and submission when faced with an attacker.

    The proposed gain is some negligible one time reduction in utxo disk
    space.


Between 40 and 50% of the UTXO set is comprised of spam UTXOs with dust 
amounts. Even more conservative estimates put it at 30%. The Cat would 
remove those spam NMUs from the UTXO set. I hardly view that as 
negligible. Furthermore, The Cat would send a strong signal to spammers: 
you are not welcomed on Bitcoin, we are rugging you, and we might do it 
again. This likely would reduce future spam activity on Bitcoin, further 
protecting the UTXO set.

    Were such a proposal seriously advanced it would likely cause a new
    flood of transactions both to move to evade it directly and as a
    result of NFT indexer changes to just "wormhole" the tokens to new
    outputs after the fact (and a new marketing opportunity for the NFT
    gifters).


As Claire already explained, with millions of cases of spam, this would 
cause a massive block space demand increase and a large fee spike which 
would prove very costly to spammers. And retaking a new snapshot would 
force them to do it again. Someone needs to feed the poor miners!

> NFTs are just an imaginary parallel world that don't depend on the 
> network to validate their activity, so they don't really care about 
> the network's rules, and as such the network's rules have pretty 
> limited effect. 

So here, you are saying The Cat would be noneffective at reducing spam.

> And moreover the proposal would intentionally and knowingly confiscate 
> millions of dollars in funds. 

You just finished telling us "the network rules have a pretty limited 
effect" and now you tell us The Cat would result in the confiscation of 
millions of dollars in funds.  That sounds conflicting and contradictory 
to me. Furthermore, dropping the spam UTXOs from the UTXO set would not 
delete any spam, they still would have ownership of it, they just 
wouldn't be able to sell it or transfer it to anyone else on L1.

Furthermore, those are all dust UTXOs. An unbelievably high amount of 
them would have to be on chain to amount to "millions of dollars in 
funds". This should give us a clue about the scale of the problem. I 
hope you get on board with The Cat now, not in a few years when it will 
be a much bigger problem in the billions of dollars in funds, not mere 
millions.

> This is outright theft, and I believe it makes the idea a total 
> non-starter.

Not confiscation, not theft, as they spam would remain on chain, they 
simply would not be able to sell their spam on Bitcoin, therefore The 
Cat would deincintivize them from profiting on Bitcoin. Furthermore, 
they could opt to consolidate they multiple dust UTXOs and avoid losing 
their bitcoin, prior to activation of The Cat.

> They absolutely will be valued by this proposal stealing their 
> bitcoins,  but their NFT grifting will not ultimately be effected 
> otherwise.

If they lose "millions of dollars in funds" as you claim, thus making 
their business must less profitable, I would call that a success, not 
ineffective at all.


Thank you, I am the founder and CEO of Opsosoft S.A de S.V. , coder, and 
bitcoiner since 2016.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ae116ad9-1295-4220-891c-12ec9969ca05%40gmail.com.

[-- Attachment #2: Type: text/html, Size: 7893 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] The Cat, BIP draft discussion.
       [not found]     ` <CAAS2fgRR77nZj3-rJo70dnxe8Lma88-C9JqdVTYfXGHRgFu3pA@mail.gmail.com>
@ 2025-12-11 20:54  2%   ` Bitcoin Mechanic
  2025-12-12  1:49  0%   ` TwoLargePizzas
  1 sibling, 0 replies; 200+ results
From: Bitcoin Mechanic @ 2025-12-11 20:54 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 53687 bytes --]

Hi Greg, (for response to Claire, list, please scroll down)

>The situation today is entirely different: Techniques to minimize usage 
are well understood, widely deployed, and the cost of storing data that way 
is very high so none happens except by those who are very motivated and 
financially capable (and that motivation and means results in speed bumps 
having little effect...

This isn't true. It's the classic "survivorship bias" mistake that gets 
made constantly throughout the general discussion about arbitrary data. 
You're trying to count road traffic accidents that didn't occur due to the 
existence of said speed bumps which can only be done through indirect 
analysis for obvious reasons. Every time this comes up, people can point to 
things as minimal as a tweet from someone influential with the Bitcoin 
space saying something to the tune of "I don't like spam" that results in 
some scam built on top of Bitcoin tanking to zero and its ecosystem dying. 
The easiest example is always Vitalik explaining his decision to make ETH 
elsewhere and not on Bitcoin due - in part - to spam filters which today 
you all decided "don't work" despite having demonstrably helped in keeping 
Bitcoin separate from that dumpster fire - 
https://x.com/VitalikButerin/status/929805462052229120

tldr: It doesn't matter if anti-spam mechanisms are not water-tight. You 
acknowledging that "they have little effect" is an admission of the fact 
that they have *some* effect which is fine - assuming the tradeoffs are 
acceptable. I am certainly happy to work within those confines - and indeed 
have been for this entire discussion. Spam mitigation cannot come at too 
great of a detriment to other aspects of Bitcoin and "The Cat" is certainly 
reasonable to consider over the line (though I'm not sure where I stand yet 
- so I appreciate any further discussion on the topic.)

Philosophically UTXO deletion is counter to Bitcoin's ethos, no one would 
deny it. Practically speaking however, we all know that's it's perfectly 
reasonable to dismiss a large % of the UTXO set as junk (regardless of if 
The Cat or similar were to activate).

>>negligible one time reduction in utxo disk space

I would never have considered The Cat if such a large % wasn't garbage. But 
at present, it looks to be somewhere between 40-50% of it - and deleting 
that would not be negligible. For a maximally pruned node that's a 50% 
reduction in disk space and when people run vast arrays of nodes in the 
cloud (large miners do this for obvious reasons) the savings quickly become 
non-negligible.

>NFTs are just an imaginary parallel world that don't depend on the network 
to validate their activity, so they don't really care about the network's 
rules, and as such the network's rules have pretty limited effect.  

"Stamps" are unspendable anyway by design and thus, we'd just be saving 
some disk space for ourselves - true. It would have no effect on what 
they're doing, we're just cleaning up their essentially abandoned trash.

For other spam however, they do in fact need their outputs to remain 
spendable. Making their "art" unspendable would massively disrupt that 
activity. For any serious protocol that wants to trick Bitcoin nodes into 
storing useless data (from the perspective of monetary users of Bitcoin) 
they can always be pushed to asking themselves "why don't we do this on 
another network that isn't going to delete our ability to spend our 'art'?"

Again, it doesn't matter how dissuasive an effect this conversation - or 
even activation of The Cat or any other spam-mitigation - has. If it has 
*some* effect then it's just a question of making sure the tradeoffs are 
worth it. That is all you can ever hope for in reducing spam on any 
protocol.

I don't think it's at all reasonable to say that making an eight figure 
amount of NFTs/Inscriptions etc unspendable would have more than a "pretty 
limited effect".

>This is outright theft

No it isn't. It's more akin to "destruction of property". No one acquires 
this "stolen property" as it ceases to exist.

>AI

It really isn't relevant. This is sadly becoming a trope, to just complain 
that proposals people don't like are "written by AI". I did suggest that 
people should declare to what extent AI was/wasn't used in an effort to 
update etiquette to current circumstances. I don't find the proposal 
ridiculous, though also not prepared to fully endorse it either as I'll go 
into below.

I replied with my stance on The Cat below if you're interested.

---

Hi Claire, list,

I don't wish for this to be taken as strong support or advocacy as I 
genuinely am not that "Crossing the Rubicon" with UTXO deletion is worth 
it, though I also find concerns that I have encountered on social media 
about precedent to be overblown. Mechanisms for UTXO deletion exist within 
Bitcoin regardless of if The Cat were to activate or not. The motivation to 
employ them does not necessarily extend to government blacklisting simply 
by virtue of them having been utilized to delete the UTXOs that this 
specific proposal would target.

I think anyone of capable of the slightest discernment can tell the 
difference between what this proposal dubs "NMUs" versus genuine UTXOs, and 
that it would succeed in its goal of making it far more difficult to 
convince suckers to buy some future Bitcoin-using-NFT given the network's 
exercised ability and willingness to throw what they're doing in the 
garbage.

I have been aware of this proposal for a couple of weeks, and it started 
getting discussed on social media prior to here.

Not once in this time have I had the sinking feeling that if this were to 
succeed, that it'd call my UTXOs into question as I just do not for a 
minute believe people running Bitcoin nodes would ever activate a fork that 
targeted anything more than what "The Cat" seeks to eliminate, *or similar*.

Many are aware of my position on spam filtration. Spam filters reject 
"valid transactions" as is happily pointed out by supposed ideologues who 
have no understanding of how nodes typically function or indeed how they 
must continue to operate. I am, for the record, in favour of nodes 
rejecting abusive activity, regardless of their protocol validity and 
consider this trivially moral for those who believe in property rights.

The Cat calls property rights into question by deleting UTXOs. I don't 
consider it unreasonable for Bitcoin users to do this if they see fit as 
the UTXO set is something that they must contribute resources to 
maintaining in perpetuity, as opposed to simply leaving unmolested and 
ignored. (And interestingly, the "property" the spammers claim to be 
concerned with is the data itself, not the ability to move it, and that's 
maintained even post "The Cat" save for, though I don't want to 
misrepresent what their intention is - the only reason they're interested 
in owning this "art" is so that they can sell it and The Cat would make 
them unable to sell it without having to route around Bitcoin rug-pulling 
their ability to do so.)

Therefore I see no relevant philosophical difference between filtering 
"valid transactions" and deleting "valid UTXOs" if the discernment required 
in separating egregious abuse of the network from intended usage is minimal 
- which it certainly is with regard to the current spam. It's almost all 
sitting conveniently at the various dust limits with glaringly obvious 
footprints, necessarily publicly indexed on websites/explorers with well 
known software made for the purposes of interacting with those ecosystems 
that can be recreated for the purposes of slating their associated UTXOs 
for deletion.

(Philosophical tidbit: both filtration and UTXO-deletion get characterized 
as 'censorship', which of course is false in both cases: Bitcoin users are 
not acting on behalf of a government and instead simply doing what's in 
their best interest.)

In practice, and far more importantly, the difference between spam 
filtration and deleting NMUS is the fact that a bad spam filter is no big 
deal. It can be routed around and simply fixed if necessary and there's no 
getting rid of them from nodes anyway.

Mistaken UTXO deletion on the other hand would be disastrous. Recovery from 
that would be a mess to say the least.

So the snapshot taken by "The Cat" would need to be extremely well vetted 
which I believe the proposal actually covers extremely well as my natural 
concern would be a too small a % of the Bitcoin community verifying its 
contents and thus trusting third parties to have indexed all these junk 
UTXOs accurately. I cannot believe people would be so sloppy in that regard 
given that their UTXOs could be what end up in that list so hopefully - as 
the proposal itself states - that should become a motivation for a huge 
number of people verifying the contents of the list.

So in summary, my concerns with The Cat are too few independently indexing 
and attesting to the NMU list which again, the proposal addresses 
satisfactorily in my opinion.

I remain unwilling to advocate for this proposal any more strongly than I 
have done here, but would appreciate more substantial push back from others 
who dislike it because as it stands currently, I would not be unhappy if 
this ended up successfully activating.

Kind regards,
Bitcoin Mechanic











On Thursday, December 11, 2025 at 7:30:56 AM UTC-8 Greg Maxwell wrote:

> You misunderstood my message that you've quoted-- understandable because 
> today Bitcoin usage today is very different than back then.  In September 
> 2013 the average bitcoin blocksize was 120 kbytes and, as a result, there 
> was no meaningful market competition for block space at the time.  As a 
> result there was essentially no incentive to minimize data usage in 
> transactions and there was fairly little awareness of the potential means 
> to do so, beyond simple limits like things not relaying.  The situation 
> today is entirely different: Techniques to minimize usage are well 
> understood, widely deployed, and the cost of storing data that way is very 
> high so none happens except by those who are very motivated and financially 
> capable (and that motivation and means results in speed bumps having little 
> effect, -- or even positive effect, as the remaining abuses appear to find 
> bitcoin's costs/restrictions highly desirable to create scarcity for their 
> tokens).
>
> On your proposal,
>
> The proposed gain is some negligible one time reduction in utxo disk 
> space. You motivated it by claiming this is a 'memory usage' reduction, but 
> it's not-- it's just full node storage in particular as the txouts in 
> question are normally sized and largely quiescent already-- so the savings 
> is pretty insignificant.  Were such a proposal seriously advanced it would 
> likely cause a new flood of transactions both to move to evade it directly 
> and as a result of NFT indexer changes to just "wormhole" the tokens to new 
> outputs after the fact (and a new marketing opportunity for the NFT 
> gifters).  NFTs are just an imaginary parallel world that don't depend on 
> the network to validate their activity, so they don't really care about the 
> network's rules, and as such the network's rules have pretty limited 
> effect.  
>
> And moreover the proposal would intentionally and knowingly confiscate 
> millions of dollars in funds.  This is outright theft, and I believe it 
> makes the idea a total non-starter.
>
> As an aside, since the idea fails so easily on basic principled grounds 
> it's a disrespectful waste of participants time to advance a proposal at 
> such length and technobabbly depth which could have been floated with a 
> single sentence "How would people feel about a proposal to discourage NFTs 
> by identifying a snapshot of existing dust-value NFT outputs and making 
> spending them consensus invalid?"  or similar.   Much of the opposition to 
> LLM use in the field of BIP discussion has been due to widespread misuse of 
> LLMs to create thickets of dense language and obscure non-starter, trivial, 
> or ill considered proposals making them much more costly to deal with and 
> discouraging serious and thoughtful review of *all* ongoing discussion.
>
>
>
>
> On Wed, Dec 10, 2025 at 6:12 PM Claire Ostrom <ostromcl...@gmail.com> 
> wrote:
>
>> Dear Bitcoin-dev,
>>
>> Given recent discussions surrounding the malincentives of spam and the 
>> perceived futility in addressing these issues, I felt it necessary to 
>> propose a working solution. For those interested, I have written a brief 
>> history of the problem; please skip to “The BIP” below if you are only 
>> interested in the proposal.
>>
>> Bitcoin is a peer to peer open source monetary network created to 
>> facilitate online payments between individuals without trust in a third 
>> party. By its nature as an open protocol, and its censorship-resistant 
>> design with no single authority maintaining its operation, we have to rely 
>> on incentives and culture for network stewardship. Historically, we saw 
>> many trends emerge which threatened Bitcoin’s primary use as a monetary 
>> network. They were successfully dealt with by introducing OP_Return with a 
>> small limit as a more efficient and limited way of directing non-monetary 
>> data to a provably non-spendable space that could more easily be pruned 
>> from nodes and, importantly, not pollute the UTXO set.
>>
>> Legendary Bitcoin developer Gregory Maxwell said at the time, “Part of 
>> the idea here is shaping behavior towards conservative needs.” 
>> <https://github.com/bitcoin/bitcoin/pull/2738#issuecomment-25017368>
>>
>> This was enforced through standardness filters, which are a way of 
>> discouraging certain types of transactions that, while technically 
>> consensus valid, we have agreed as a community are usually not used in 
>> standard practice and are potentially harmful.
>>
>> In recent years, these trends have come back into focus with the creation 
>> of schemes like Ordinal theory and its associated inscriptions, and Bitcoin 
>> Stamps, which are techniques for embedding non-monetary data (like images 
>> or tokens) into Bitcoin transactions. Ordinals typically hide data in the 
>> Taproot witness field (benefiting from a weight “discount”), while Stamps 
>> encode data in unspendable outputs (e.g., fake bare multisig addresses). 
>> These practices turn the blockchain into a data storage system rather than 
>> purely a payments network. As anyone familiar with basic economics knows, 
>> what you subsidize, you get more of.
>>
>> Critically, many Ordinal inscription and Stamp transactions create dust 
>> outputs (tiny UTXOs of only a few hundred sats) that remain unspent 
>> indefinitely, bloating the UTXO set. Because Stamp outputs are expected to 
>> remain unspent indefinitely, they persist in the UTXO set forever.
>>
>> Veteran Bitcoin developer Mark “Murch” Erhardt has described the stamps 
>> UTXO issue as “probably, from a technical perspective, one of the more 
>> egregious uses of blockchain." 
>> <https://bitcoinops.org/en/podcast/2023/12/21/>
>>
>> [image: Screenshot 2025-12-01 212654.png]
>>
>> Over roughly 14 years (2009-early 2023), Bitcoin’s UTXO set grew 
>> gradually to around 80-90 million entries. Then, in less than a year, it 
>> doubled to more than 160 million by late 2023, a historic anomaly driven 
>> largely by the Ordinals and Stamps craze. Analyses suggest that by 
>> mid-2025, over 30% of all UTXOs were tied to Ordinal inscriptions. Nearly 
>> half of all UTXOs (around 49%) now contain less than 1,000 satoshis, 
>> strongly indicating they are spammy dust outputs used for data embedding 
>> rather than normal economic activity. Many of these are Taproot outputs or 
>> outputs sitting exactly at the standard dust threshold, consistent with 
>> algorithmic spam creation. In short, UTXO spam now accounts for tens of 
>> millions of entries and represents an unprecedented explosion of UTXO bloat.
>>
>> The UTXO database (chainstate) has ballooned alongside this spam. Before 
>> 2023, the chainstate was on the order of 4-5 GB; by early 2024 it exceeded 
>> 11 GB, meaning the disk footprint required to hold the unspent set roughly 
>> doubled in about a year, in line with Ordinals and BRC-20 mania. Over the 
>> same period, the full blockchain grew by about 93 GB in 2023 alone, versus 
>> roughly 55 GB per year previously, largely due to inscription data filling 
>> blocks. While pruned nodes can discard old block data, they cannot discard 
>> UTXOs: every unspent output, even spam, must remain in the chainstate until 
>> it is spent or explicitly removed by a protocol change. This makes UTXO 
>> spam a permanent, compounding burden on full nodes. As Bitcoin developers 
>> have noted, techniques that deliberately embed data in UTXOs are among the 
>> most egregious abuses of the system, precisely because they clutter the 
>> UTXO set with junk that cannot be pruned away under current rules.
>>
>> Bitcoin’s design includes some anti-spam measures, but spammers have 
>> continually evolved “cat-and-mouse” tactics to bypass them.
>>
>> This is where our proposal comes in.
>>
>> THE BIP: The Cat.
>>
>>
>> Recent attempts to reduce spam have focused on the supply side, trying to 
>> stop spam through policy and standardness rules. These efforts have had 
>> limited success. The Cat instead looks to economics, removing or reducing 
>> the financial incentive for creating spam outputs in the first place. It 
>> targets the demand side by making designated Non-Monetary UTXOs (NMUs) 
>> permanently unspendable, which in turn reduces market demand for those 
>> assets.
>>
>>
>> The Cat defines a fixed, reproducible set of “NMUs” using established 
>> external indexers, and makes them permanently unspendable by consensus, so 
>> that such data cannot be monetized or transacted, only archived. Once 
>> rendered unspendable, we will be removing these UTXOs made unspendable by 
>> consensus under this proposal, from the UTXO set, materially reducing the 
>> current resource requirement for nodes (likely on the order of tens of 
>> millions of UTXOs, roughly ~30% of the set, subject to measurement). The 
>> NMU classification itself is encoded in a compact membership structure (a 
>> Binary Fuse Filter plus a false-positive exclusion list) that ships with 
>> the binary and does not require any node to reindex or re-download the 
>> chain.
>>
>>
>>
>> Draft Specification
>>
>>
>> Status: Discussion draft. A formal BIP, compliant with BIP 0003 and the 
>> usual BIP process, will be prepared if there is interest in pursuing this 
>> direction.
>>
>>
>> 1. Definitions
>>
>>
>> Non-Monetary UTXO (NMU):
>>
>>
>> A UTXO that is classified as containing inscription-style or stamp-style 
>> data according to the procedure in §2 and that satisfies the value and 
>> creation-height constraints below.
>>
>>
>> NMU bit:
>>
>>
>> A single Boolean flag (0 or 1) stored alongside each UTXO in the node’s 
>> UTXO database:
>>
>>
>>
>>    - 
>>    
>>    NMU = 1 -> UTXO is non-monetary and may not be spent.
>>    
>>
>>
>>    - 
>>    
>>    NMU = 0 -> UTXO is monetary (normal behavior).
>>    
>>
>> Conceptually, NMU = 1 means “this outpoint is in NMUSet_snap as defined 
>> by this BIP.” Implementations MAY choose to compute this bit on the fly 
>> from the membership structure rather than store it explicitly; see §3.
>>
>>
>> NMU value threshold:
>>
>>
>> A consensus constant VALUE_MAX_NMU = 1000 satoshis. Only UTXOs with value 
>> strictly less than VALUE_MAX_NMU are eligible to be classified as NMU. 
>> UTXOs with value greater than or equal to VALUE_MAX_NMU MUST be treated as 
>> monetary (NMU = 0) for all time under this BIP, even if external tools 
>> associate inscriptions or stamps with some of their satoshis.
>>
>>
>> NMU creation-height window:
>>
>>
>> This proposal intentionally restricts NMU classification to UTXOs created 
>> between:
>>
>>
>> H_min_NMU: the earliest block height at which the reference indexers (Ord 
>> 0.24.0 and the specified Stamps version) first recognize any 
>> inscription-style or stamp-style NMU, and
>>
>>
>> H_snap: the snapshot height defined in §2.4.
>>
>>
>> Both H_min_NMU and H_snap are consensus constants fixed before 
>> activation. Any UTXO created at height < H_min_NMU or > H_snap MUST be 
>> treated as monetary (NMU = 0) regardless of filter results.
>>
>>
>> NMU membership structure (NMU_DATA):
>>
>>
>> A static, exact membership structure that encodes NMUSet_snap using:
>>
>>
>>
>>    - 
>>    
>>    A Binary Fuse Filter (BFF-8) constructed from all eligible NMU 
>>    outpoints; and
>>    
>>
>>
>>    - 
>>    
>>    A false positive exclusion list (FP_EXCLUDE) that contains all 
>>    non-NMU outpoints at H_snap that would otherwise match the filter.
>>    
>>
>> NMU_DATA is distributed as a single binary blob, together with a 
>> consensus constant NMU_DATA_HASH = SHA256d(NMU_DATA) which all compliant 
>> implementations MUST verify before using it for consensus validation (see 
>> §3.3).
>>
>>
>> Activation height (H_cat):
>>
>>
>> A consensus constant H_cat, the block height at which the NMU spending 
>> rule in §4 first becomes eligible for enforcement. The exact value and 
>> deployment mechanism for H_cat are out of scope for this draft and would be 
>> specified in a formal BIP.
>>
>>
>> 2. NMU classification (reproducible list)
>>
>>
>> The normative consensus object introduced by this BIP is the set 
>> NMUSet_snap: a fixed set of outpoints classified as non-monetary at 
>> snapshot height H_snap on the best chain, after applying the value and 
>> height restrictions in §1 and §2.3.
>>
>>
>> Consensus enforcement of The Cat only depends on whether an outpoint is 
>> in NMUSet_snap or not; it does not depend on how any particular node 
>> obtained that set.
>>
>>
>> To define NMUSet_snap in a precise and reproducible way, this BIP 
>> specifies two reference classification rule sets that operate purely on 
>> Bitcoin chain data, as implemented in:
>>
>>
>>
>>    - 
>>    
>>    Ord 0.24.0 at commit 5d2fbbe64b362cd6c30d6901e50cbe80084761f8
>>    
>>
>>
>>    - 
>>    
>>    Stamps - [exact version/commit to be pinned before any activation]
>>    
>>
>> These reference implementations define the inscription-style and 
>> stamp-style classification rules in terms of Bitcoin chain data. They are 
>> cited here as normative descriptions of how to decide whether a given 
>> outpoint carries an inscription or a stamp at height H_snap.
>>
>>
>> Implementations that wish to independently derive or verify NMUSet_snap 
>> MAY:
>>
>>
>>
>>    - 
>>    
>>    Execute these reference implementations from genesis up to H_snap, or
>>    
>>
>>
>>    - 
>>    
>>    Independently re-implement the same classification rules and confirm 
>>    that the resulting set of outpoints matches the NMU set implied by NMU_DATA.
>>    
>>
>> Running Ord or Stamps is not required for ordinary full-node operation 
>> under this BIP; they are simply the canonical specification of the 
>> classification logic.
>>
>>
>> This section uses the consensus constants H_cat, H_snap, and H_min_NMU as 
>> defined in §1.
>>
>>
>> 2.1 Ord NMU set
>>
>>
>> According to the classification rules implemented in Ord 0.24.0 at commit 
>> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is parsed for 
>> “inscription envelopes” and each recognized inscription is associated with 
>> a particular outpoint (txid, vout) on the best chain at height H_snap.
>>
>>
>> Define OrdNMUSet as the set of all outpoints that, when those Ord 0.24.0 
>> rules are applied to the best chain up to H_snap, are classified as 
>> carrying inscriptions at H_snap. Concretely, for each inscription that Ord 
>> 0.24.0 would associate with a specific outpoint (txid, vout) on that chain, 
>> that outpoint is included in OrdNMUSet.
>>
>>
>> This includes, for example, inscription UTXOs used by protocols such as 
>> BRC-20, but the BIP makes no protocol-level distinction; they are all 
>> treated as “NMU” if they meet the value and height thresholds in §2.3.
>>
>>
>> An implementation may obtain OrdNMUSet by actually running Ord 0.24.0, or 
>> by re-implementing its published classification rules and applying them to 
>> the chain.
>>
>>
>> 2.2 Stamps NMU set
>>
>>
>> According to the classification rules implemented in the specified BTC 
>> Stamps indexer (version/commit TBD), Counterparty metadata and Bitcoin 
>> transactions are parsed to identify “stamp-style” embedded assets and 
>> associate them with one or more bare multisig outputs on the best chain at 
>> height H_snap.
>>
>>
>> Define StampsNMUSet as the set of all outpoints that, when those Stamps 
>> rules are applied to the best chain up to H_snap, are classified as 
>> containing a stamp at H_snap. For each stamp that the reference Stamps 
>> implementation would associate with a specific outpoint (txid, vout) on 
>> that chain, that outpoint is included in StampsNMUSet.
>>
>>
>> As with Ord, an implementation may obtain StampsNMUSet either by running 
>> the reference Stamps indexer or by independently implementing the same 
>> classification rules and applying them to the chain.
>>
>>
>> 2.3 Combined NMU set + value & height thresholds
>>
>>
>> The initial raw NMU set at snapshot height is:
>>
>>
>> NMUSet_raw = OrdNMUSet ∪ StampsNMUSet
>>
>>
>> Apply both the NMU value threshold and the creation-height window:
>>
>>
>> NMUSet_snap = { u ∈ NMUSet_raw | value(u) < VALUE_MAX_NMU and H_min_NMU ≤ 
>> height(u) ≤ H_snap }
>>
>>
>> where value(u) is the number of satoshis in UTXO u, and height(u) is the 
>> height of the block that created that UTXO.
>>
>>
>> Every UTXO in NMUSet_snap MUST be treated as having NMU = 1 under the new 
>> consensus rule (see §4). Nodes MAY realize this either by pre-seeding an 
>> NMU bit in their UTXO database or by computing it dynamically via the 
>> membership query in §3.3.
>>
>>
>> Notes:
>>
>>
>> Running Ord or Stamps is only required for those who wish to 
>> independently derive and verify NMUSet_snap; it is not a requirement for 
>> ordinary full node operation under The Cat.
>>
>>
>> The value threshold is intended to avoid classifying large, mixed-use 
>> UTXOs as NMUs when a small number of inscribed satoshis have been combined 
>> with otherwise monetary funds.
>>
>>
>> Restricting to height(u) ≥ H_min_NMU reflects the historical fact that 
>> these protocols appeared only after a certain point, and it trivially 
>> avoids misclassification of very old UTXOs.
>>
>>
>> This proposal intentionally does not specify any new in-client 
>> classification rule for discovering future NMU formats. It explicitly 
>> targets non-monetary UTXOs identifiable via Ord 0.24.0 and Stamps at the 
>> time of snapshot.
>>
>>
>> 2.4 Snapshot block commitment and reorg behaviour
>>
>>
>> This BIP commits to a specific chain history at the snapshot height 
>> H_snap by introducing a new consensus constant:
>>
>>
>> SNAP_BLOCK_HASH: a 32-byte value equal to the block hash at height H_snap 
>> on the chain from which NMUSet_snap was originally derived.
>>
>>
>> A node MUST only enforce the NMU consensus rule from §4 if, for its 
>> current best chain:
>>
>>
>> There exists a block at height H_snap, and
>>
>>
>> The hash of that block is exactly equal to SNAP_BLOCK_HASH.
>>
>>
>> If, for the node’s current best chain, the block at height H_snap has a 
>> different hash, the node MUST treat all UTXOs as monetary (NMU = 0) for the 
>> purposes of consensus validation, and MUST NOT reject any transaction or 
>> block on the basis of the NMU rule.
>>
>>
>> In particular, if a reorganization occurs that replaces the block at 
>> height H_snap with a different block (i.e., a reorg deeper than H_snap), 
>> enforcement of The Cat is automatically disabled until and unless the best 
>> chain once again has SNAP_BLOCK_HASH at height H_snap. Any desire to apply 
>> NMU classification to a different chain history would require a new 
>> consensus commitment (for example, a new SNAP_BLOCK_HASH defined by a 
>> subsequent BIP and activation process).
>>
>>
>> 3. NMU bit storage, membership structure, and activation
>>
>>
>> 3.1 NMU bit storage model
>>
>>
>> Consensus only cares about which UTXOs are NMU, not how the bit is stored 
>> or computed. Implementations MAY:
>>
>>
>>
>>    - 
>>    
>>    Store the NMU bit as an extra bit in the UTXO database (e.g., in the 
>>    Coin structure).
>>    
>>
>>
>>    - 
>>    
>>    Store NMUs in a separate structure keyed by outpoint.
>>    
>>
>>
>>    - 
>>    
>>    Compute NMU on the fly at validation time using the NMU_DATA 
>>    membership structure from §3.3, optionally caching results.
>>    
>>
>> The only consensus requirement is: given the same chain, compliant 
>> implementations must converge on the same NMU classification for all UTXOs. 
>> Conceptually, for a UTXO u with value(u) and height(u), NMU(u) is defined 
>> as:
>>
>>
>>
>>    - 
>>    
>>    1 if:
>>    
>>
>>
>>    - 
>>    
>>    H_min_NMU ≤ height(u) ≤ H_snap, and
>>    
>>
>>
>>    - 
>>    
>>    value(u) < VALUE_MAX_NMU, and
>>    
>>
>>
>>    - 
>>    
>>    u ∈ NMUSet_snap (as tested via §3.3),
>>    
>>
>>
>>    - 
>>    
>>    0 otherwise.
>>    
>>
>> 3.2 Activation
>>
>>
>> At activation height H_cat:
>>
>>
>> Nodes must have:
>>
>>
>>
>>    - 
>>    
>>    Fully validated the chain up to at least H_snap.
>>    
>>
>>
>>    - 
>>    
>>    Loaded and verified NMU_DATA (see §3.3).
>>    
>>
>> From the first block at or after H_cat for which the snapshot block 
>> commitment condition in §2.4 holds, nodes MUST enforce the consensus rule 
>> in §4, using the NMU classification defined above. No reindex or UTXO 
>> rewrite is required for activation; NMU classification can be applied as an 
>> overlay on top of the existing UTXO database.
>>
>>
>> Implementations MAY, as an optimization, perform a one-time pass over 
>> their UTXO set after activation to:
>>
>>
>>
>>    - 
>>    
>>    Set Coin.NMU = 1 for all UTXOs that satisfy the NMU predicate; and/or
>>    
>>
>>
>>    - 
>>    
>>    Physically delete such UTXOs from the UTXO database (see §5).
>>    
>>
>> Such a pass is a local optimization and not required for consensus, 
>> provided the on-the-fly NMU classification via NMU_DATA would yield the 
>> same results.
>>
>>
>> 3.3 NMU membership structure: Binary Fuse Filter + exclusion list
>>
>>
>> This BIP does not require nodes to redo initial block download or reindex 
>> the chain in order to enforce NMU classification. Instead, it commits to a 
>> canonical membership structure NMU_DATA which encodes NMUSet_snap in a 
>> compact form.
>>
>>
>> 3.3.1 Canonical outpoint encoding
>>
>>
>> For all purposes related to NMU_DATA (filter construction, querying, and 
>> the exclusion list), an outpoint (txid, vout) is encoded as a fixed 36-byte 
>> key.
>>
>>
>> txid_le (bytes 0–31): the 32-byte transaction ID in little-endian order, 
>> matching the internal uint256 representation used by Bitcoin Core and 
>> similar implementations.
>>
>> vout_le (bytes 32–35): the 4-byte output index, serialized as a 
>> little-endian unsigned 32-bit integer (e.g. 0 -> 00 00 00 00, 1 -> 01 00 00 
>> 00, 256 -> 00 01 00 00).
>>
>>
>> This encoding is normative for NMU_DATA. All compliant implementations 
>> MUST use exactly this encoding when querying the filter or the exclusion 
>> list.
>>
>>
>> 3.3.2 NMU_DATA serialization
>>
>>
>> NMU_DATA is a single binary blob. All integer fields are little-endian 
>> and appear in the following order:
>>
>>
>>
>>    - 
>>    
>>    MAGIC (4 bytes): ASCII string "NMU1".
>>    - 
>>    
>>    VERSION (1 byte): format version (initially 0x01).
>>    - 
>>    
>>    SNAP_HEIGHT (4 bytes): block height H_snap.
>>    - 
>>    
>>    SNAP_HASH (32 bytes): block hash at H_snap (must match 
>>    SNAP_BLOCK_HASH from section §2.4).
>>    - 
>>    
>>    FILTER_SEED (8 bytes): 64-bit seed used by the Binary Fuse Filter 
>>    hash functions.
>>    - 
>>    
>>    FILTER_LEN (4 bytes): length in bytes of FILTER_DATA.
>>    - 
>>    
>>    FILTER_DATA (FILTER_LEN bytes): raw Binary Fuse Filter data.
>>    - 
>>    
>>    FP_COUNT (4 bytes): number of false-positive entries.
>>    - 
>>    
>>    FP_ENTRIES (FP_COUNT × 36 bytes): lexicographically sorted array of 
>>    canonical 36-byte outpoint encodings that are not in NMUSet_snap but would 
>>    otherwise match the filter.
>>    - 
>>    
>>    CHECKSUM (32 bytes): SHA256d of all preceding bytes from MAGIC 
>>    through the last FP_ENTRY.
>>    
>>
>> The SHA256d of the entire NMU_DATA blob is called NMU_DATA_HASH and is 
>> treated as a consensus constant compiled into node software.
>>
>>
>> A node MUST NOT enforce the NMU consensus rule unless NMU_DATA passes its 
>> internal CHECKSUM validation and SHA256d(NMU_DATA) equals NMU_DATA_HASH.
>>
>>
>> 3.3.3 Binary Fuse Filter query
>>
>>
>> The filter is a static Binary Fuse Filter over 36-byte keys with 8-bit 
>> fingerprints, giving an approximate false-positive rate of about 1/256.
>>
>>
>> For a given key, a deterministic hash function derived from FILTER_SEED 
>> maps the 36-byte key to three byte positions inside FILTER_DATA and to an 
>> 8-bit fingerprint. A membership query reads the three bytes at those 
>> positions, XORs them, and compares the result to the fingerprint. If they 
>> match, the filter reports the key as “probably present”.
>>
>>
>> The exact mapping from a 36-byte key to three positions and an 8-bit 
>> fingerprint, and the interpretation of FILTER_DATA, MUST follow a single, 
>> fully specified algorithm (for example, a pinned “binary fuse filter” 
>> reference implementation). How FILTER_DATA was constructed is not 
>> consensus-critical; only the query algorithm and the fixed contents of 
>> NMU_DATA are consensus-critical.
>>
>>
>> 3.3.4 False positive exclusion list
>>
>>
>> Because the Binary Fuse Filter is probabilistic, some UTXOs that are not 
>> in NMUSet_snap will still be reported as present at H_snap. During snapshot 
>> construction, the false positive exclusion list FP_EXCLUDE is computed by 
>> enumerating all UTXOs at H_snap that are not in NMUSet_snap, testing each 
>> with the filter, collecting those that match, and sorting their 36-byte 
>> keys lexicographically to form FP_ENTRIES.
>>
>>
>> At runtime, FP_EXCLUDE is treated as an override: if an outpoint’s 
>> canonical key appears in FP_EXCLUDE, that outpoint MUST be treated as 
>> non-NMU, regardless of the filter result.
>>
>>
>> 3.3.5 Membership query (is_nmu)
>>
>>
>> Given a UTXO u at outpoint (txid, vout), with value(u) and height(u), 
>> nodes evaluate the NMU membership predicate is_nmu(u) as follows.
>>
>>
>> First, UTXOs outside the NMU window are never NMUs. If height(u) is less 
>> than H_min_NMU or greater than H_snap, is_nmu(u) is false.
>>
>>
>> Second, very large UTXOs are always treated as monetary. If value(u) is 
>> greater than or equal to VALUE_MAX_NMU, is_nmu(u) is false.
>>
>>
>> For the remaining UTXOs, the node computes key = canonical_encode(txid, 
>> vout) using the 36-byte encoding defined in section 3.3.1. If key appears 
>> in FP_EXCLUDE (using binary search over the sorted FP_ENTRIES array), 
>> is_nmu(u) is false. Otherwise, the node queries the Binary Fuse Filter with 
>> key. If and only if the filter reports the key as present, is_nmu(u) is 
>> true.
>>
>>
>> Within the domain H_min_NMU ≤ height(u) ≤ H_snap and value(u) < 
>> VALUE_MAX_NMU, this predicate exactly matches membership in NMUSet_snap: 
>> every UTXO in NMUSet_snap is reported as NMU, and every UTXO outside 
>> NMUSet_snap is reported as non-NMU, with no false positives and no false 
>> negatives.
>>
>>
>> 4. New consensus rule
>>
>>
>> The rule in this section is enforced only when the snapshot block 
>> commitment condition from §2.4 holds and NMU_DATA has been successfully 
>> verified.
>>
>>
>> From the first block at or after H_cat that follows activation:
>>
>>
>> Rule: Forbidden spending of NMUs
>>
>>
>> A transaction is invalid if any of its inputs refers to an outpoint 
>> (txid, vout) such that the corresponding UTXO u satisfies is_nmu(u) = true 
>> as defined in §3.3.5 (equivalently, has NMU = 1).
>>
>>
>> Formally, when validating a transaction input:
>>
>>
>>
>>    - 
>>    
>>    Let (txid, vout) be the input outpoint.
>>    
>>
>>
>>    - 
>>    
>>    Let u = Coin(txid, vout) be the referenced UTXO as seen by the node 
>>    at the time of validation.
>>    
>>
>>
>>    - 
>>    
>>    If u does not exist: reject as usual (unchanged behavior).
>>    
>>
>>
>>    - 
>>    
>>    Otherwise, if is_nmu(u) = true, then the transaction MUST be rejected 
>>    as invalid.
>>    
>>
>> This rule applies:
>>
>>
>>
>>    - 
>>    
>>    To mempool acceptance.
>>    
>>
>>
>>    - 
>>    
>>    To block validation.
>>    
>>
>>
>>    - 
>>    
>>    To all future reorg scenarios, provided the snapshot commitment in 
>>    §2.4 remains satisfied.
>>    
>>
>> 5. UTXO set removal and pruning
>>
>>
>> Because NMUs are permanently unspendable after activation, they can be 
>> dropped from the spendable UTXO set.
>>
>>
>> 5.1 Logical removal
>>
>>
>> Implementations MUST treat UTXOs with is_nmu(u) = true (or NMU = 1) as 
>> non-existent for the purpose of:
>>
>>
>>
>>    - 
>>    
>>    Satisfying transaction inputs (they can never be used).
>>    
>>
>>
>>    - 
>>    
>>    Fee calculations, coin selection, wallet balances, etc.
>>    
>>
>> 5.2 Physical pruning (optional)
>>
>>
>> Nodes that operate with -prune=1 (or similar backwards-compatible pruning 
>> configuration) MAY:
>>
>>
>>
>>    - 
>>    
>>    Omit NMUs from the on-disk UTXO set.
>>    
>>
>>
>>    - 
>>    
>>    Remove any previously persisted NMUs during a compaction / cleanup 
>>    pass by running is_nmu(u) on each UTXO and deleting those that return true.
>>    
>>
>> This proposal does not require pruned nodes to discard raw historical 
>> blocks. It only authorizes pruning of UTXO entries that are permanently 
>> unspendable due to the NMU rule.
>>
>>
>> Non-pruned nodes (full archival nodes) MAY continue to store historical 
>> blocks and full transaction data as usual. This preserves archival access 
>> to inscription / stamp data while still neutralizing it economically.
>>
>>
>> Rationale
>>
>>
>> This BIP makes minimal changes to the consensus surface. It adds no new 
>> opcodes and does not expand Bitcoin’s scripting language or 
>> programmability. Instead, it introduces a single new consensus concept: a 
>> binary classification that marks some existing UTXOs as permanently 
>> unspendable Non-Monetary UTXOs (NMUs). In that sense, it is closer to a 
>> one-time reclassification of a subset of UTXOs than an ongoing change to 
>> Bitcoin’s programming model.
>>
>>
>> External indexers, determinism, and reproducibility
>>
>>
>> Instead of re-implementing complex inscription and stamp classification 
>> rules in Bitcoin clients, this BIP relies on mature tools that are already 
>> used by the non-monetary data community, specifically Ord and Stamps. Exact 
>> versions of these indexers are specified and pinned by commit so that their 
>> behavior is deterministic. The NMU set is defined in terms of chain data as 
>> seen through these specified indexers, rather than as an arbitrary 
>> hard-coded list of UTXOs. This keeps the consensus rule grounded in 
>> chain-derived information while avoiding the need to embed inscription 
>> logic directly in Bitcoin client software.
>>
>>
>> Fixed snapshot vs future formats
>>
>>
>> By scoping the NMU classification to what Ord 0.24.0 and Stamps (at a 
>> pinned commit) can see at the snapshot height H_snap, this proposal 
>> neutralizes the existing inscription and stamp economy on day one without 
>> importing evolving, open-ended classification rules into consensus. It 
>> treats the snapshot as a fixed historical boundary and leaves future NMU 
>> formats and mitigation strategies as a separate question for policy or for 
>> future BIPs. If further action is desired on post-snapshot NMU formats, the 
>> community can consider additional updates or separate proposals without 
>> expanding the scope of this one.
>>
>>
>> UTXO set size and overhead
>>
>>
>> Because all NMUs become permanently unspendable under this proposal, they 
>> can be removed from the UTXO set, which reduces its size. The new storage 
>> overhead introduced by The Cat is dominated by the global membership 
>> structure NMU_DATA, which consists of a Binary Fuse Filter over NMUSet_snap 
>> plus a correction list of false positives. For a plausible NMU count on the 
>> order of 50 million, the filter occupies roughly 9 bits per element (≈ 56 
>> MB), and the exclusion list adds around 15–20 MB before compression, for an 
>> uncompressed size on the order of 70–80 MB and an expected compressed size 
>> of roughly 40–50 MB.
>>
>>
>> This is small relative to typical UTXO set sizes and to the on-disk 
>> savings from pruning tens of millions of dust-sized NMUs. Per-UTXO storage 
>> overhead remains a single NMU bit if implementations choose to materialize 
>> it in the database; the rest of the classification data is stored once per 
>> node.
>>
>>
>> Censorship resistance and scope
>>
>>
>> Bitcoin’s censorship resistance is primarily concerned with the ability 
>> to move monetary value without trusted intermediaries. This proposal 
>> intentionally targets non-monetary uses of the chain (inscriptions, stamps, 
>> and similar schemes) and leaves ordinary monetary transfers untouched. 
>> Reasonable people may still describe permanently disabling some UTXOs as a 
>> form of censorship; the distinction this BIP draws is between money and 
>> arbitrary data storage.
>>
>>
>> The same type of mechanism could in principle be abused to target 
>> arbitrary UTXOs, which is why this proposal deliberately scopes itself to a 
>> one-time, transparently derived set of dust-sized non-monetary outputs. Any 
>> attempt to apply similar techniques to ordinary monetary UTXOs would be 
>> highly contentious and would require explicit social consensus from users, 
>> miners, and economic nodes. In other words, this mechanism does not lower 
>> the technical or social barriers to censoring ordinary monetary activity; 
>> any such censorship would still require its own explicit, contentious 
>> change in consensus rules.
>>
>>
>> The classification rules on which The Cat relies are deliberately narrow 
>> and mechanical. An output is marked as an NMU only if it is (a) identified 
>> by the pinned Ord/Stamps rules as carrying a non-monetary artifact at 
>> H_snap, (b) dust-sized, below the VALUE_MAX_NMU threshold, and (c) within 
>> the defined height window. The intent is that no ordinary monetary UTXOs 
>> fall into NMUSet_snap; any such inclusion would be treated as an error in 
>> the snapshot construction and grounds to regenerate NMU_DATA before 
>> activation, not as an acceptable trade-off. The 1,000-sat value limit 
>> serves as an additional hard guardrail against accidentally classifying 
>> normally-sized wallet outputs.
>>
>>
>> Centralization and trust model for NMU generation
>>
>>
>> Anyone can independently generate the list of NMUs. It is incumbent on 
>> people to do so if they wish to minimize the trust required to run a fully 
>> validating node. The criteria for which outputs are designated as NMUs are 
>> necessarily known and established by virtue of how prevalent and open the 
>> targeted data protocols are.
>>
>>
>> It is valid to worry that fewer than 100% of node runners will regenerate 
>> the NMU list themselves, somewhat increasing the overall trust placed in 
>> third parties compared to today. However, this concern applies specifically 
>> to a “blacklist of UTXOs,” which is precisely the area where scrutiny is 
>> highest. That scrutiny should help ensure that enough independent parties 
>> index and attest to the contents of NMUSet_snap to exceed any reasonable 
>> threshold of credulity.
>>
>>
>> A useful analogy is the GUIX-based reproducible build process. Bitcoiners 
>> accept that many users will only run node binaries they download, rather 
>> than compiling from source and independently verifying the code. Compiled 
>> binaries must exist for Bitcoin to maintain decentralization in practice. 
>> This is an aspect of trust inherent in Bitcoin: we accept some technical 
>> limitations of users and employ a practical, trust-minimized workaround 
>> that, while not perfect, is better than the alternative.
>>
>>
>> If there were to be an issue with widely used binaries, it would become 
>> ubiquitously known very quickly. Similarly, if The Cat were flawed and 
>> began targeting monetary UTXOs, this would be detected well before 
>> activation, and the necessary fixes applied, with any distortion of its 
>> motivation exposed and corrected.
>>
>>
>> Backward compatibility
>>
>>
>> This proposal is a consensus-changing soft fork. Legacy nodes that do not 
>> implement The Cat will continue to accept blocks that spend NMUs as valid, 
>> while nodes that do implement The Cat will reject such blocks as invalid. 
>> As with any soft fork, activation requires clear opt-in from miners and 
>> from economic nodes. After activation, miners and other block proposers 
>> must avoid including transactions that spend NMUs, because such blocks will 
>> be rejected by upgraded nodes. Wallets and applications that track 
>> inscriptions, BRC-20 assets, and related schemes will observe that NMUs 
>> become permanently unspendable under The Cat and that balances associated 
>> with those UTXOs are no longer movable under the activated ruleset.
>>
>>
>> FAQ
>>
>>
>> Do node operators need to run Ord or Stamps?
>>
>>
>> No. The Cat does not require ordinary node operators to run Ord or 
>> Stamps, or to understand their rules in detail. Those indexers are cited as 
>> normative references for the inscription and stamp classification logic 
>> used to derive NMUSet_snap. In practice, nodes only need the canonical 
>> NMU_DATA blob and its hash NMU_DATA_HASH to enforce the consensus rule.
>>
>>
>> Anyone who wishes to independently verify NMUSet_snap can:
>>
>>
>> inspect the open-source Ord and Stamps code,
>>
>>
>> or re-implement equivalent classification rules,
>>
>>
>> and confirm that the derived set of NMU outpoints matches the set encoded 
>> in NMU_DATA (i.e., the blob whose hash is NMU_DATA_HASH).
>>
>>
>> What rules do the reference indexers actually use to decide which UTXOs 
>> are NMUs?
>>
>>
>> This BIP does not re-specify the full Ord and Stamps protocols, but in 
>> broad terms:
>>
>>
>> Ord 0.24.0 (inscriptions).
>>
>> According to the classification rules implemented in Ord 0.24.0 at commit 
>> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is scanned for 
>> “inscription envelopes” in Taproot script paths. An inscription envelope is 
>> an OP_FALSE OP_IF … OP_ENDIF block containing data pushes that start with 
>> the ASCII tag ord and encode a content type and body. When those rules are 
>> applied to the best chain up to height H_snap, each recognized inscription 
>> is associated with a particular outpoint (txid, vout) (typically the first 
>> satoshi of a reveal transaction input, or as directed by the pointer field 
>> in the protocol). OrdNMUSet is defined as the set of outpoints that Ord 
>> 0.24.0 would classify as carrying inscriptions at H_snap under these rules.
>>
>>
>> Stamps (BTC Stamps).
>>
>> According to the classification rules implemented in the pinned BTC 
>> Stamps indexer, Counterparty transactions are inspected for a 
>> STAMP:-prefixed base64 string in the description field, which encodes image 
>> data. The Stamps rules then map this metadata to specific dust-sized bare 
>> multisig outputs in the underlying Bitcoin transactions. When those rules 
>> are applied to the best chain up to height H_snap, each recognized stamp is 
>> associated with one or more outpoints (txid, vout). StampsNMUSet is defined 
>> as the set of outpoints that this reference Stamps implementation would 
>> classify as containing such stamp-style embedded assets at H_snap.
>>
>>
>> Won’t spammers just make workarounds and spam anyway?
>>
>>
>> The Cat targets the financial incentive to create spam. It is almost 
>> impossible to stop a determined user from adding data to Bitcoin. The more 
>> realistic mitigation is to remove the ability to reliably trade these 
>> embedded assets as if they were durable, on-chain economic objects. Once 
>> the existing inscription and stamp economies are neutralized and their 
>> dust-sized carrier UTXOs are fenced off, the motivation to spam the chain 
>> in the same way is greatly reduced.
>>
>>
>> Can’t users just spend their NMUs after the snapshot, removing them from 
>> the list?
>>
>>
>> Yes, a user can attempt to evade The Cat by spending an NMU after the 
>> snapshot. However, there are tens of millions of such outputs. It would be 
>> extremely costly, in aggregate fees, to move them all. If large-scale 
>> evasion occurs before activation, it is straightforward to take a new 
>> snapshot, forcing evaders to pay again if they want to continue. This is 
>> the nature of the cat-and-mouse game: attempts to pre-empt the snapshot by 
>> moving large numbers of NMUs impose substantial costs on those outputs, 
>> while the network can respond by choosing an appropriate snapshot height if 
>> necessary.
>>
>>
>> What if some of my UTXOs contain “rare sats”? Won’t those get “Catted”?
>>
>>
>> In this BIP, “rare sats” can be understood as satoshis that Ord and 
>> similar indexers are treating as non-monetary artifacts. The Cat does not 
>> look at individual sat numbers or “rarity” directly; it only classifies 
>> whole UTXOs via the is_nmu(u) predicate, using NMUSet_snap and a simple 
>> value/height guardrail.
>>
>>
>> A UTXO can only be classified as an NMU if all of the following are true:
>>
>>
>>
>>    - 
>>    
>>    it falls inside the NMU height window,
>>    
>>
>>
>>    - 
>>    
>>    its value is strictly below VALUE_MAX_NMU (currently 1,000 sats), and
>>    
>>
>>
>>    - 
>>    
>>    its outpoint appears in NMUSet_snap as identified by Ord/Stamps at 
>>    the snapshot.
>>    
>>
>> Anything at or above VALUE_MAX_NMU is always treated as a normal monetary 
>> output, regardless of what Ord says about the sats inside it.
>>
>>
>> In practice, if you once interacted with Ord and those “rare sats” now 
>> live inside a normal-sized wallet UTXO (1,000 sats or more), this proposal 
>> does not touch that UTXO at all. It remains fully spendable under the 
>> ordinary rules. The only “rare sats” that get Catted are those deliberately 
>> parked in tiny dust outputs below the VALUE_MAX_NMU threshold, and that Ord 
>> (or Stamps) is already treating as non-monetary artifacts at H_snap. Those 
>> dust UTXOs are precisely the objects this proposal is targeting to fence 
>> off from the monetary UTXO set.
>>
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/32f8c689-314d-4a5e-9af6-2e3e704582e6n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/32f8c689-314d-4a5e-9af6-2e3e704582e6n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c541315d-a3d1-4416-9bf4-77f1f7d8f12en%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 137297 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] The Cat, BIP draft discussion.
       [not found]     ` <CAAS2fgRR77nZj3-rJo70dnxe8Lma88-C9JqdVTYfXGHRgFu3pA@mail.gmail.com>
  2025-12-11 20:54  2%   ` [bitcoindev] The Cat, BIP draft discussion Bitcoin Mechanic
@ 2025-12-12  1:49  0%   ` TwoLargePizzas
    1 sibling, 1 reply; 200+ results
From: TwoLargePizzas @ 2025-12-12  1:49 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 46081 bytes --]

>  The proposed gain is some negligible one time reduction in utxo disk 
space.

Is it though? My understanding is that this proposal would disincentivize 
this kind of use of the UTXO set which would significantly reduce these 
types of transactions going forward. That's not a one time reduction and 
it's certainly not negligible.

>  Were such a proposal seriously advanced it would likely cause a new 
flood of transactions both to move to evade it directly

Maybe, but that's speculation at best. One could also speculate that even 
the existence of this BIP proposal would likely cause those types of 
transactions to move elsewhere. If the "marketing opportunity" for the NFT 
grifters is to say the transactions could be worthless going forward, then 
yes, I agree.

>  NFTs are just an imaginary parallel world that don't depend on the 
network to validate their activity, so they don't really care about the 
network's rules, and as such the network's rules have pretty limited 
effect.  

If the rules don't matter, they won't be bothered if the rules change. 

>  the proposal would intentionally and knowingly confiscate millions of 
dollars in funds.  This is outright theft, and I believe it makes the idea 
a total non-starter.

When you say "millions of dollars in funds" are you including the value of 
the NFTs tied to those sats or the just the total sum of all the 
unspendable dust? It would seem a little contradictory to call NFTs an 
imaginary in one breath and worth millions of dollars in the next. To be 
clear, I'm not advocating for confiscation, just trying to understand 
exactly where the millions of dollars in funds comes from.

To me this proposal is more about sending a message that UTXO bloat is not 
welcome. I don't agree with direct confiscation of funds but at the same 
time I hold the position that encouraging the NFT grifters is only going to 
lead to more NFT gifters.
On Friday, 12 December 2025 at 1:30:56 am UTC+10 Greg Maxwell wrote:

> You misunderstood my message that you've quoted-- understandable because 
> today Bitcoin usage today is very different than back then.  In September 
> 2013 the average bitcoin blocksize was 120 kbytes and, as a result, there 
> was no meaningful market competition for block space at the time.  As a 
> result there was essentially no incentive to minimize data usage in 
> transactions and there was fairly little awareness of the potential means 
> to do so, beyond simple limits like things not relaying.  The situation 
> today is entirely different: Techniques to minimize usage are well 
> understood, widely deployed, and the cost of storing data that way is very 
> high so none happens except by those who are very motivated and financially 
> capable (and that motivation and means results in speed bumps having little 
> effect, -- or even positive effect, as the remaining abuses appear to find 
> bitcoin's costs/restrictions highly desirable to create scarcity for their 
> tokens).
>
> On your proposal,
>
> The proposed gain is some negligible one time reduction in utxo disk 
> space. You motivated it by claiming this is a 'memory usage' reduction, but 
> it's not-- it's just full node storage in particular as the txouts in 
> question are normally sized and largely quiescent already-- so the savings 
> is pretty insignificant.  Were such a proposal seriously advanced it would 
> likely cause a new flood of transactions both to move to evade it directly 
> and as a result of NFT indexer changes to just "wormhole" the tokens to new 
> outputs after the fact (and a new marketing opportunity for the NFT 
> gifters).  NFTs are just an imaginary parallel world that don't depend on 
> the network to validate their activity, so they don't really care about the 
> network's rules, and as such the network's rules have pretty limited 
> effect.  
>
> And moreover the proposal would intentionally and knowingly confiscate 
> millions of dollars in funds.  This is outright theft, and I believe it 
> makes the idea a total non-starter.
>
> As an aside, since the idea fails so easily on basic principled grounds 
> it's a disrespectful waste of participants time to advance a proposal at 
> such length and technobabbly depth which could have been floated with a 
> single sentence "How would people feel about a proposal to discourage NFTs 
> by identifying a snapshot of existing dust-value NFT outputs and making 
> spending them consensus invalid?"  or similar.   Much of the opposition to 
> LLM use in the field of BIP discussion has been due to widespread misuse of 
> LLMs to create thickets of dense language and obscure non-starter, trivial, 
> or ill considered proposals making them much more costly to deal with and 
> discouraging serious and thoughtful review of *all* ongoing discussion.
>
>
>
>
> On Wed, Dec 10, 2025 at 6:12 PM Claire Ostrom <ostromcl...@gmail.com> 
> wrote:
>
>> Dear Bitcoin-dev,
>>
>> Given recent discussions surrounding the malincentives of spam and the 
>> perceived futility in addressing these issues, I felt it necessary to 
>> propose a working solution. For those interested, I have written a brief 
>> history of the problem; please skip to “The BIP” below if you are only 
>> interested in the proposal.
>>
>> Bitcoin is a peer to peer open source monetary network created to 
>> facilitate online payments between individuals without trust in a third 
>> party. By its nature as an open protocol, and its censorship-resistant 
>> design with no single authority maintaining its operation, we have to rely 
>> on incentives and culture for network stewardship. Historically, we saw 
>> many trends emerge which threatened Bitcoin’s primary use as a monetary 
>> network. They were successfully dealt with by introducing OP_Return with a 
>> small limit as a more efficient and limited way of directing non-monetary 
>> data to a provably non-spendable space that could more easily be pruned 
>> from nodes and, importantly, not pollute the UTXO set.
>>
>> Legendary Bitcoin developer Gregory Maxwell said at the time, “Part of 
>> the idea here is shaping behavior towards conservative needs.” 
>> <https://github.com/bitcoin/bitcoin/pull/2738#issuecomment-25017368>
>>
>> This was enforced through standardness filters, which are a way of 
>> discouraging certain types of transactions that, while technically 
>> consensus valid, we have agreed as a community are usually not used in 
>> standard practice and are potentially harmful.
>>
>> In recent years, these trends have come back into focus with the creation 
>> of schemes like Ordinal theory and its associated inscriptions, and Bitcoin 
>> Stamps, which are techniques for embedding non-monetary data (like images 
>> or tokens) into Bitcoin transactions. Ordinals typically hide data in the 
>> Taproot witness field (benefiting from a weight “discount”), while Stamps 
>> encode data in unspendable outputs (e.g., fake bare multisig addresses). 
>> These practices turn the blockchain into a data storage system rather than 
>> purely a payments network. As anyone familiar with basic economics knows, 
>> what you subsidize, you get more of.
>>
>> Critically, many Ordinal inscription and Stamp transactions create dust 
>> outputs (tiny UTXOs of only a few hundred sats) that remain unspent 
>> indefinitely, bloating the UTXO set. Because Stamp outputs are expected to 
>> remain unspent indefinitely, they persist in the UTXO set forever.
>>
>> Veteran Bitcoin developer Mark “Murch” Erhardt has described the stamps 
>> UTXO issue as “probably, from a technical perspective, one of the more 
>> egregious uses of blockchain." 
>> <https://bitcoinops.org/en/podcast/2023/12/21/>
>>
>> [image: Screenshot 2025-12-01 212654.png]
>>
>> Over roughly 14 years (2009-early 2023), Bitcoin’s UTXO set grew 
>> gradually to around 80-90 million entries. Then, in less than a year, it 
>> doubled to more than 160 million by late 2023, a historic anomaly driven 
>> largely by the Ordinals and Stamps craze. Analyses suggest that by 
>> mid-2025, over 30% of all UTXOs were tied to Ordinal inscriptions. Nearly 
>> half of all UTXOs (around 49%) now contain less than 1,000 satoshis, 
>> strongly indicating they are spammy dust outputs used for data embedding 
>> rather than normal economic activity. Many of these are Taproot outputs or 
>> outputs sitting exactly at the standard dust threshold, consistent with 
>> algorithmic spam creation. In short, UTXO spam now accounts for tens of 
>> millions of entries and represents an unprecedented explosion of UTXO bloat.
>>
>> The UTXO database (chainstate) has ballooned alongside this spam. Before 
>> 2023, the chainstate was on the order of 4-5 GB; by early 2024 it exceeded 
>> 11 GB, meaning the disk footprint required to hold the unspent set roughly 
>> doubled in about a year, in line with Ordinals and BRC-20 mania. Over the 
>> same period, the full blockchain grew by about 93 GB in 2023 alone, versus 
>> roughly 55 GB per year previously, largely due to inscription data filling 
>> blocks. While pruned nodes can discard old block data, they cannot discard 
>> UTXOs: every unspent output, even spam, must remain in the chainstate until 
>> it is spent or explicitly removed by a protocol change. This makes UTXO 
>> spam a permanent, compounding burden on full nodes. As Bitcoin developers 
>> have noted, techniques that deliberately embed data in UTXOs are among the 
>> most egregious abuses of the system, precisely because they clutter the 
>> UTXO set with junk that cannot be pruned away under current rules.
>>
>> Bitcoin’s design includes some anti-spam measures, but spammers have 
>> continually evolved “cat-and-mouse” tactics to bypass them.
>>
>> This is where our proposal comes in.
>>
>> THE BIP: The Cat.
>>
>>
>> Recent attempts to reduce spam have focused on the supply side, trying to 
>> stop spam through policy and standardness rules. These efforts have had 
>> limited success. The Cat instead looks to economics, removing or reducing 
>> the financial incentive for creating spam outputs in the first place. It 
>> targets the demand side by making designated Non-Monetary UTXOs (NMUs) 
>> permanently unspendable, which in turn reduces market demand for those 
>> assets.
>>
>>
>> The Cat defines a fixed, reproducible set of “NMUs” using established 
>> external indexers, and makes them permanently unspendable by consensus, so 
>> that such data cannot be monetized or transacted, only archived. Once 
>> rendered unspendable, we will be removing these UTXOs made unspendable by 
>> consensus under this proposal, from the UTXO set, materially reducing the 
>> current resource requirement for nodes (likely on the order of tens of 
>> millions of UTXOs, roughly ~30% of the set, subject to measurement). The 
>> NMU classification itself is encoded in a compact membership structure (a 
>> Binary Fuse Filter plus a false-positive exclusion list) that ships with 
>> the binary and does not require any node to reindex or re-download the 
>> chain.
>>
>>
>>
>> Draft Specification
>>
>>
>> Status: Discussion draft. A formal BIP, compliant with BIP 0003 and the 
>> usual BIP process, will be prepared if there is interest in pursuing this 
>> direction.
>>
>>
>> 1. Definitions
>>
>>
>> Non-Monetary UTXO (NMU):
>>
>>
>> A UTXO that is classified as containing inscription-style or stamp-style 
>> data according to the procedure in §2 and that satisfies the value and 
>> creation-height constraints below.
>>
>>
>> NMU bit:
>>
>>
>> A single Boolean flag (0 or 1) stored alongside each UTXO in the node’s 
>> UTXO database:
>>
>>
>>
>>    - 
>>    
>>    NMU = 1 -> UTXO is non-monetary and may not be spent.
>>    
>>
>>
>>    - 
>>    
>>    NMU = 0 -> UTXO is monetary (normal behavior).
>>    
>>
>> Conceptually, NMU = 1 means “this outpoint is in NMUSet_snap as defined 
>> by this BIP.” Implementations MAY choose to compute this bit on the fly 
>> from the membership structure rather than store it explicitly; see §3.
>>
>>
>> NMU value threshold:
>>
>>
>> A consensus constant VALUE_MAX_NMU = 1000 satoshis. Only UTXOs with value 
>> strictly less than VALUE_MAX_NMU are eligible to be classified as NMU. 
>> UTXOs with value greater than or equal to VALUE_MAX_NMU MUST be treated as 
>> monetary (NMU = 0) for all time under this BIP, even if external tools 
>> associate inscriptions or stamps with some of their satoshis.
>>
>>
>> NMU creation-height window:
>>
>>
>> This proposal intentionally restricts NMU classification to UTXOs created 
>> between:
>>
>>
>> H_min_NMU: the earliest block height at which the reference indexers (Ord 
>> 0.24.0 and the specified Stamps version) first recognize any 
>> inscription-style or stamp-style NMU, and
>>
>>
>> H_snap: the snapshot height defined in §2.4.
>>
>>
>> Both H_min_NMU and H_snap are consensus constants fixed before 
>> activation. Any UTXO created at height < H_min_NMU or > H_snap MUST be 
>> treated as monetary (NMU = 0) regardless of filter results.
>>
>>
>> NMU membership structure (NMU_DATA):
>>
>>
>> A static, exact membership structure that encodes NMUSet_snap using:
>>
>>
>>
>>    - 
>>    
>>    A Binary Fuse Filter (BFF-8) constructed from all eligible NMU 
>>    outpoints; and
>>    
>>
>>
>>    - 
>>    
>>    A false positive exclusion list (FP_EXCLUDE) that contains all 
>>    non-NMU outpoints at H_snap that would otherwise match the filter.
>>    
>>
>> NMU_DATA is distributed as a single binary blob, together with a 
>> consensus constant NMU_DATA_HASH = SHA256d(NMU_DATA) which all compliant 
>> implementations MUST verify before using it for consensus validation (see 
>> §3.3).
>>
>>
>> Activation height (H_cat):
>>
>>
>> A consensus constant H_cat, the block height at which the NMU spending 
>> rule in §4 first becomes eligible for enforcement. The exact value and 
>> deployment mechanism for H_cat are out of scope for this draft and would be 
>> specified in a formal BIP.
>>
>>
>> 2. NMU classification (reproducible list)
>>
>>
>> The normative consensus object introduced by this BIP is the set 
>> NMUSet_snap: a fixed set of outpoints classified as non-monetary at 
>> snapshot height H_snap on the best chain, after applying the value and 
>> height restrictions in §1 and §2.3.
>>
>>
>> Consensus enforcement of The Cat only depends on whether an outpoint is 
>> in NMUSet_snap or not; it does not depend on how any particular node 
>> obtained that set.
>>
>>
>> To define NMUSet_snap in a precise and reproducible way, this BIP 
>> specifies two reference classification rule sets that operate purely on 
>> Bitcoin chain data, as implemented in:
>>
>>
>>
>>    - 
>>    
>>    Ord 0.24.0 at commit 5d2fbbe64b362cd6c30d6901e50cbe80084761f8
>>    
>>
>>
>>    - 
>>    
>>    Stamps - [exact version/commit to be pinned before any activation]
>>    
>>
>> These reference implementations define the inscription-style and 
>> stamp-style classification rules in terms of Bitcoin chain data. They are 
>> cited here as normative descriptions of how to decide whether a given 
>> outpoint carries an inscription or a stamp at height H_snap.
>>
>>
>> Implementations that wish to independently derive or verify NMUSet_snap 
>> MAY:
>>
>>
>>
>>    - 
>>    
>>    Execute these reference implementations from genesis up to H_snap, or
>>    
>>
>>
>>    - 
>>    
>>    Independently re-implement the same classification rules and confirm 
>>    that the resulting set of outpoints matches the NMU set implied by NMU_DATA.
>>    
>>
>> Running Ord or Stamps is not required for ordinary full-node operation 
>> under this BIP; they are simply the canonical specification of the 
>> classification logic.
>>
>>
>> This section uses the consensus constants H_cat, H_snap, and H_min_NMU as 
>> defined in §1.
>>
>>
>> 2.1 Ord NMU set
>>
>>
>> According to the classification rules implemented in Ord 0.24.0 at commit 
>> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is parsed for 
>> “inscription envelopes” and each recognized inscription is associated with 
>> a particular outpoint (txid, vout) on the best chain at height H_snap.
>>
>>
>> Define OrdNMUSet as the set of all outpoints that, when those Ord 0.24.0 
>> rules are applied to the best chain up to H_snap, are classified as 
>> carrying inscriptions at H_snap. Concretely, for each inscription that Ord 
>> 0.24.0 would associate with a specific outpoint (txid, vout) on that chain, 
>> that outpoint is included in OrdNMUSet.
>>
>>
>> This includes, for example, inscription UTXOs used by protocols such as 
>> BRC-20, but the BIP makes no protocol-level distinction; they are all 
>> treated as “NMU” if they meet the value and height thresholds in §2.3.
>>
>>
>> An implementation may obtain OrdNMUSet by actually running Ord 0.24.0, or 
>> by re-implementing its published classification rules and applying them to 
>> the chain.
>>
>>
>> 2.2 Stamps NMU set
>>
>>
>> According to the classification rules implemented in the specified BTC 
>> Stamps indexer (version/commit TBD), Counterparty metadata and Bitcoin 
>> transactions are parsed to identify “stamp-style” embedded assets and 
>> associate them with one or more bare multisig outputs on the best chain at 
>> height H_snap.
>>
>>
>> Define StampsNMUSet as the set of all outpoints that, when those Stamps 
>> rules are applied to the best chain up to H_snap, are classified as 
>> containing a stamp at H_snap. For each stamp that the reference Stamps 
>> implementation would associate with a specific outpoint (txid, vout) on 
>> that chain, that outpoint is included in StampsNMUSet.
>>
>>
>> As with Ord, an implementation may obtain StampsNMUSet either by running 
>> the reference Stamps indexer or by independently implementing the same 
>> classification rules and applying them to the chain.
>>
>>
>> 2.3 Combined NMU set + value & height thresholds
>>
>>
>> The initial raw NMU set at snapshot height is:
>>
>>
>> NMUSet_raw = OrdNMUSet ∪ StampsNMUSet
>>
>>
>> Apply both the NMU value threshold and the creation-height window:
>>
>>
>> NMUSet_snap = { u ∈ NMUSet_raw | value(u) < VALUE_MAX_NMU and H_min_NMU ≤ 
>> height(u) ≤ H_snap }
>>
>>
>> where value(u) is the number of satoshis in UTXO u, and height(u) is the 
>> height of the block that created that UTXO.
>>
>>
>> Every UTXO in NMUSet_snap MUST be treated as having NMU = 1 under the new 
>> consensus rule (see §4). Nodes MAY realize this either by pre-seeding an 
>> NMU bit in their UTXO database or by computing it dynamically via the 
>> membership query in §3.3.
>>
>>
>> Notes:
>>
>>
>> Running Ord or Stamps is only required for those who wish to 
>> independently derive and verify NMUSet_snap; it is not a requirement for 
>> ordinary full node operation under The Cat.
>>
>>
>> The value threshold is intended to avoid classifying large, mixed-use 
>> UTXOs as NMUs when a small number of inscribed satoshis have been combined 
>> with otherwise monetary funds.
>>
>>
>> Restricting to height(u) ≥ H_min_NMU reflects the historical fact that 
>> these protocols appeared only after a certain point, and it trivially 
>> avoids misclassification of very old UTXOs.
>>
>>
>> This proposal intentionally does not specify any new in-client 
>> classification rule for discovering future NMU formats. It explicitly 
>> targets non-monetary UTXOs identifiable via Ord 0.24.0 and Stamps at the 
>> time of snapshot.
>>
>>
>> 2.4 Snapshot block commitment and reorg behaviour
>>
>>
>> This BIP commits to a specific chain history at the snapshot height 
>> H_snap by introducing a new consensus constant:
>>
>>
>> SNAP_BLOCK_HASH: a 32-byte value equal to the block hash at height H_snap 
>> on the chain from which NMUSet_snap was originally derived.
>>
>>
>> A node MUST only enforce the NMU consensus rule from §4 if, for its 
>> current best chain:
>>
>>
>> There exists a block at height H_snap, and
>>
>>
>> The hash of that block is exactly equal to SNAP_BLOCK_HASH.
>>
>>
>> If, for the node’s current best chain, the block at height H_snap has a 
>> different hash, the node MUST treat all UTXOs as monetary (NMU = 0) for the 
>> purposes of consensus validation, and MUST NOT reject any transaction or 
>> block on the basis of the NMU rule.
>>
>>
>> In particular, if a reorganization occurs that replaces the block at 
>> height H_snap with a different block (i.e., a reorg deeper than H_snap), 
>> enforcement of The Cat is automatically disabled until and unless the best 
>> chain once again has SNAP_BLOCK_HASH at height H_snap. Any desire to apply 
>> NMU classification to a different chain history would require a new 
>> consensus commitment (for example, a new SNAP_BLOCK_HASH defined by a 
>> subsequent BIP and activation process).
>>
>>
>> 3. NMU bit storage, membership structure, and activation
>>
>>
>> 3.1 NMU bit storage model
>>
>>
>> Consensus only cares about which UTXOs are NMU, not how the bit is stored 
>> or computed. Implementations MAY:
>>
>>
>>
>>    - 
>>    
>>    Store the NMU bit as an extra bit in the UTXO database (e.g., in the 
>>    Coin structure).
>>    
>>
>>
>>    - 
>>    
>>    Store NMUs in a separate structure keyed by outpoint.
>>    
>>
>>
>>    - 
>>    
>>    Compute NMU on the fly at validation time using the NMU_DATA 
>>    membership structure from §3.3, optionally caching results.
>>    
>>
>> The only consensus requirement is: given the same chain, compliant 
>> implementations must converge on the same NMU classification for all UTXOs. 
>> Conceptually, for a UTXO u with value(u) and height(u), NMU(u) is defined 
>> as:
>>
>>
>>
>>    - 
>>    
>>    1 if:
>>    
>>
>>
>>    - 
>>    
>>    H_min_NMU ≤ height(u) ≤ H_snap, and
>>    
>>
>>
>>    - 
>>    
>>    value(u) < VALUE_MAX_NMU, and
>>    
>>
>>
>>    - 
>>    
>>    u ∈ NMUSet_snap (as tested via §3.3),
>>    
>>
>>
>>    - 
>>    
>>    0 otherwise.
>>    
>>
>> 3.2 Activation
>>
>>
>> At activation height H_cat:
>>
>>
>> Nodes must have:
>>
>>
>>
>>    - 
>>    
>>    Fully validated the chain up to at least H_snap.
>>    
>>
>>
>>    - 
>>    
>>    Loaded and verified NMU_DATA (see §3.3).
>>    
>>
>> From the first block at or after H_cat for which the snapshot block 
>> commitment condition in §2.4 holds, nodes MUST enforce the consensus rule 
>> in §4, using the NMU classification defined above. No reindex or UTXO 
>> rewrite is required for activation; NMU classification can be applied as an 
>> overlay on top of the existing UTXO database.
>>
>>
>> Implementations MAY, as an optimization, perform a one-time pass over 
>> their UTXO set after activation to:
>>
>>
>>
>>    - 
>>    
>>    Set Coin.NMU = 1 for all UTXOs that satisfy the NMU predicate; and/or
>>    
>>
>>
>>    - 
>>    
>>    Physically delete such UTXOs from the UTXO database (see §5).
>>    
>>
>> Such a pass is a local optimization and not required for consensus, 
>> provided the on-the-fly NMU classification via NMU_DATA would yield the 
>> same results.
>>
>>
>> 3.3 NMU membership structure: Binary Fuse Filter + exclusion list
>>
>>
>> This BIP does not require nodes to redo initial block download or reindex 
>> the chain in order to enforce NMU classification. Instead, it commits to a 
>> canonical membership structure NMU_DATA which encodes NMUSet_snap in a 
>> compact form.
>>
>>
>> 3.3.1 Canonical outpoint encoding
>>
>>
>> For all purposes related to NMU_DATA (filter construction, querying, and 
>> the exclusion list), an outpoint (txid, vout) is encoded as a fixed 36-byte 
>> key.
>>
>>
>> txid_le (bytes 0–31): the 32-byte transaction ID in little-endian order, 
>> matching the internal uint256 representation used by Bitcoin Core and 
>> similar implementations.
>>
>> vout_le (bytes 32–35): the 4-byte output index, serialized as a 
>> little-endian unsigned 32-bit integer (e.g. 0 -> 00 00 00 00, 1 -> 01 00 00 
>> 00, 256 -> 00 01 00 00).
>>
>>
>> This encoding is normative for NMU_DATA. All compliant implementations 
>> MUST use exactly this encoding when querying the filter or the exclusion 
>> list.
>>
>>
>> 3.3.2 NMU_DATA serialization
>>
>>
>> NMU_DATA is a single binary blob. All integer fields are little-endian 
>> and appear in the following order:
>>
>>
>>
>>    - 
>>    
>>    MAGIC (4 bytes): ASCII string "NMU1".
>>    - 
>>    
>>    VERSION (1 byte): format version (initially 0x01).
>>    - 
>>    
>>    SNAP_HEIGHT (4 bytes): block height H_snap.
>>    - 
>>    
>>    SNAP_HASH (32 bytes): block hash at H_snap (must match 
>>    SNAP_BLOCK_HASH from section §2.4).
>>    - 
>>    
>>    FILTER_SEED (8 bytes): 64-bit seed used by the Binary Fuse Filter 
>>    hash functions.
>>    - 
>>    
>>    FILTER_LEN (4 bytes): length in bytes of FILTER_DATA.
>>    - 
>>    
>>    FILTER_DATA (FILTER_LEN bytes): raw Binary Fuse Filter data.
>>    - 
>>    
>>    FP_COUNT (4 bytes): number of false-positive entries.
>>    - 
>>    
>>    FP_ENTRIES (FP_COUNT × 36 bytes): lexicographically sorted array of 
>>    canonical 36-byte outpoint encodings that are not in NMUSet_snap but would 
>>    otherwise match the filter.
>>    - 
>>    
>>    CHECKSUM (32 bytes): SHA256d of all preceding bytes from MAGIC 
>>    through the last FP_ENTRY.
>>    
>>
>> The SHA256d of the entire NMU_DATA blob is called NMU_DATA_HASH and is 
>> treated as a consensus constant compiled into node software.
>>
>>
>> A node MUST NOT enforce the NMU consensus rule unless NMU_DATA passes its 
>> internal CHECKSUM validation and SHA256d(NMU_DATA) equals NMU_DATA_HASH.
>>
>>
>> 3.3.3 Binary Fuse Filter query
>>
>>
>> The filter is a static Binary Fuse Filter over 36-byte keys with 8-bit 
>> fingerprints, giving an approximate false-positive rate of about 1/256.
>>
>>
>> For a given key, a deterministic hash function derived from FILTER_SEED 
>> maps the 36-byte key to three byte positions inside FILTER_DATA and to an 
>> 8-bit fingerprint. A membership query reads the three bytes at those 
>> positions, XORs them, and compares the result to the fingerprint. If they 
>> match, the filter reports the key as “probably present”.
>>
>>
>> The exact mapping from a 36-byte key to three positions and an 8-bit 
>> fingerprint, and the interpretation of FILTER_DATA, MUST follow a single, 
>> fully specified algorithm (for example, a pinned “binary fuse filter” 
>> reference implementation). How FILTER_DATA was constructed is not 
>> consensus-critical; only the query algorithm and the fixed contents of 
>> NMU_DATA are consensus-critical.
>>
>>
>> 3.3.4 False positive exclusion list
>>
>>
>> Because the Binary Fuse Filter is probabilistic, some UTXOs that are not 
>> in NMUSet_snap will still be reported as present at H_snap. During snapshot 
>> construction, the false positive exclusion list FP_EXCLUDE is computed by 
>> enumerating all UTXOs at H_snap that are not in NMUSet_snap, testing each 
>> with the filter, collecting those that match, and sorting their 36-byte 
>> keys lexicographically to form FP_ENTRIES.
>>
>>
>> At runtime, FP_EXCLUDE is treated as an override: if an outpoint’s 
>> canonical key appears in FP_EXCLUDE, that outpoint MUST be treated as 
>> non-NMU, regardless of the filter result.
>>
>>
>> 3.3.5 Membership query (is_nmu)
>>
>>
>> Given a UTXO u at outpoint (txid, vout), with value(u) and height(u), 
>> nodes evaluate the NMU membership predicate is_nmu(u) as follows.
>>
>>
>> First, UTXOs outside the NMU window are never NMUs. If height(u) is less 
>> than H_min_NMU or greater than H_snap, is_nmu(u) is false.
>>
>>
>> Second, very large UTXOs are always treated as monetary. If value(u) is 
>> greater than or equal to VALUE_MAX_NMU, is_nmu(u) is false.
>>
>>
>> For the remaining UTXOs, the node computes key = canonical_encode(txid, 
>> vout) using the 36-byte encoding defined in section 3.3.1. If key appears 
>> in FP_EXCLUDE (using binary search over the sorted FP_ENTRIES array), 
>> is_nmu(u) is false. Otherwise, the node queries the Binary Fuse Filter with 
>> key. If and only if the filter reports the key as present, is_nmu(u) is 
>> true.
>>
>>
>> Within the domain H_min_NMU ≤ height(u) ≤ H_snap and value(u) < 
>> VALUE_MAX_NMU, this predicate exactly matches membership in NMUSet_snap: 
>> every UTXO in NMUSet_snap is reported as NMU, and every UTXO outside 
>> NMUSet_snap is reported as non-NMU, with no false positives and no false 
>> negatives.
>>
>>
>> 4. New consensus rule
>>
>>
>> The rule in this section is enforced only when the snapshot block 
>> commitment condition from §2.4 holds and NMU_DATA has been successfully 
>> verified.
>>
>>
>> From the first block at or after H_cat that follows activation:
>>
>>
>> Rule: Forbidden spending of NMUs
>>
>>
>> A transaction is invalid if any of its inputs refers to an outpoint 
>> (txid, vout) such that the corresponding UTXO u satisfies is_nmu(u) = true 
>> as defined in §3.3.5 (equivalently, has NMU = 1).
>>
>>
>> Formally, when validating a transaction input:
>>
>>
>>
>>    - 
>>    
>>    Let (txid, vout) be the input outpoint.
>>    
>>
>>
>>    - 
>>    
>>    Let u = Coin(txid, vout) be the referenced UTXO as seen by the node 
>>    at the time of validation.
>>    
>>
>>
>>    - 
>>    
>>    If u does not exist: reject as usual (unchanged behavior).
>>    
>>
>>
>>    - 
>>    
>>    Otherwise, if is_nmu(u) = true, then the transaction MUST be rejected 
>>    as invalid.
>>    
>>
>> This rule applies:
>>
>>
>>
>>    - 
>>    
>>    To mempool acceptance.
>>    
>>
>>
>>    - 
>>    
>>    To block validation.
>>    
>>
>>
>>    - 
>>    
>>    To all future reorg scenarios, provided the snapshot commitment in 
>>    §2.4 remains satisfied.
>>    
>>
>> 5. UTXO set removal and pruning
>>
>>
>> Because NMUs are permanently unspendable after activation, they can be 
>> dropped from the spendable UTXO set.
>>
>>
>> 5.1 Logical removal
>>
>>
>> Implementations MUST treat UTXOs with is_nmu(u) = true (or NMU = 1) as 
>> non-existent for the purpose of:
>>
>>
>>
>>    - 
>>    
>>    Satisfying transaction inputs (they can never be used).
>>    
>>
>>
>>    - 
>>    
>>    Fee calculations, coin selection, wallet balances, etc.
>>    
>>
>> 5.2 Physical pruning (optional)
>>
>>
>> Nodes that operate with -prune=1 (or similar backwards-compatible pruning 
>> configuration) MAY:
>>
>>
>>
>>    - 
>>    
>>    Omit NMUs from the on-disk UTXO set.
>>    
>>
>>
>>    - 
>>    
>>    Remove any previously persisted NMUs during a compaction / cleanup 
>>    pass by running is_nmu(u) on each UTXO and deleting those that return true.
>>    
>>
>> This proposal does not require pruned nodes to discard raw historical 
>> blocks. It only authorizes pruning of UTXO entries that are permanently 
>> unspendable due to the NMU rule.
>>
>>
>> Non-pruned nodes (full archival nodes) MAY continue to store historical 
>> blocks and full transaction data as usual. This preserves archival access 
>> to inscription / stamp data while still neutralizing it economically.
>>
>>
>> Rationale
>>
>>
>> This BIP makes minimal changes to the consensus surface. It adds no new 
>> opcodes and does not expand Bitcoin’s scripting language or 
>> programmability. Instead, it introduces a single new consensus concept: a 
>> binary classification that marks some existing UTXOs as permanently 
>> unspendable Non-Monetary UTXOs (NMUs). In that sense, it is closer to a 
>> one-time reclassification of a subset of UTXOs than an ongoing change to 
>> Bitcoin’s programming model.
>>
>>
>> External indexers, determinism, and reproducibility
>>
>>
>> Instead of re-implementing complex inscription and stamp classification 
>> rules in Bitcoin clients, this BIP relies on mature tools that are already 
>> used by the non-monetary data community, specifically Ord and Stamps. Exact 
>> versions of these indexers are specified and pinned by commit so that their 
>> behavior is deterministic. The NMU set is defined in terms of chain data as 
>> seen through these specified indexers, rather than as an arbitrary 
>> hard-coded list of UTXOs. This keeps the consensus rule grounded in 
>> chain-derived information while avoiding the need to embed inscription 
>> logic directly in Bitcoin client software.
>>
>>
>> Fixed snapshot vs future formats
>>
>>
>> By scoping the NMU classification to what Ord 0.24.0 and Stamps (at a 
>> pinned commit) can see at the snapshot height H_snap, this proposal 
>> neutralizes the existing inscription and stamp economy on day one without 
>> importing evolving, open-ended classification rules into consensus. It 
>> treats the snapshot as a fixed historical boundary and leaves future NMU 
>> formats and mitigation strategies as a separate question for policy or for 
>> future BIPs. If further action is desired on post-snapshot NMU formats, the 
>> community can consider additional updates or separate proposals without 
>> expanding the scope of this one.
>>
>>
>> UTXO set size and overhead
>>
>>
>> Because all NMUs become permanently unspendable under this proposal, they 
>> can be removed from the UTXO set, which reduces its size. The new storage 
>> overhead introduced by The Cat is dominated by the global membership 
>> structure NMU_DATA, which consists of a Binary Fuse Filter over NMUSet_snap 
>> plus a correction list of false positives. For a plausible NMU count on the 
>> order of 50 million, the filter occupies roughly 9 bits per element (≈ 56 
>> MB), and the exclusion list adds around 15–20 MB before compression, for an 
>> uncompressed size on the order of 70–80 MB and an expected compressed size 
>> of roughly 40–50 MB.
>>
>>
>> This is small relative to typical UTXO set sizes and to the on-disk 
>> savings from pruning tens of millions of dust-sized NMUs. Per-UTXO storage 
>> overhead remains a single NMU bit if implementations choose to materialize 
>> it in the database; the rest of the classification data is stored once per 
>> node.
>>
>>
>> Censorship resistance and scope
>>
>>
>> Bitcoin’s censorship resistance is primarily concerned with the ability 
>> to move monetary value without trusted intermediaries. This proposal 
>> intentionally targets non-monetary uses of the chain (inscriptions, stamps, 
>> and similar schemes) and leaves ordinary monetary transfers untouched. 
>> Reasonable people may still describe permanently disabling some UTXOs as a 
>> form of censorship; the distinction this BIP draws is between money and 
>> arbitrary data storage.
>>
>>
>> The same type of mechanism could in principle be abused to target 
>> arbitrary UTXOs, which is why this proposal deliberately scopes itself to a 
>> one-time, transparently derived set of dust-sized non-monetary outputs. Any 
>> attempt to apply similar techniques to ordinary monetary UTXOs would be 
>> highly contentious and would require explicit social consensus from users, 
>> miners, and economic nodes. In other words, this mechanism does not lower 
>> the technical or social barriers to censoring ordinary monetary activity; 
>> any such censorship would still require its own explicit, contentious 
>> change in consensus rules.
>>
>>
>> The classification rules on which The Cat relies are deliberately narrow 
>> and mechanical. An output is marked as an NMU only if it is (a) identified 
>> by the pinned Ord/Stamps rules as carrying a non-monetary artifact at 
>> H_snap, (b) dust-sized, below the VALUE_MAX_NMU threshold, and (c) within 
>> the defined height window. The intent is that no ordinary monetary UTXOs 
>> fall into NMUSet_snap; any such inclusion would be treated as an error in 
>> the snapshot construction and grounds to regenerate NMU_DATA before 
>> activation, not as an acceptable trade-off. The 1,000-sat value limit 
>> serves as an additional hard guardrail against accidentally classifying 
>> normally-sized wallet outputs.
>>
>>
>> Centralization and trust model for NMU generation
>>
>>
>> Anyone can independently generate the list of NMUs. It is incumbent on 
>> people to do so if they wish to minimize the trust required to run a fully 
>> validating node. The criteria for which outputs are designated as NMUs are 
>> necessarily known and established by virtue of how prevalent and open the 
>> targeted data protocols are.
>>
>>
>> It is valid to worry that fewer than 100% of node runners will regenerate 
>> the NMU list themselves, somewhat increasing the overall trust placed in 
>> third parties compared to today. However, this concern applies specifically 
>> to a “blacklist of UTXOs,” which is precisely the area where scrutiny is 
>> highest. That scrutiny should help ensure that enough independent parties 
>> index and attest to the contents of NMUSet_snap to exceed any reasonable 
>> threshold of credulity.
>>
>>
>> A useful analogy is the GUIX-based reproducible build process. Bitcoiners 
>> accept that many users will only run node binaries they download, rather 
>> than compiling from source and independently verifying the code. Compiled 
>> binaries must exist for Bitcoin to maintain decentralization in practice. 
>> This is an aspect of trust inherent in Bitcoin: we accept some technical 
>> limitations of users and employ a practical, trust-minimized workaround 
>> that, while not perfect, is better than the alternative.
>>
>>
>> If there were to be an issue with widely used binaries, it would become 
>> ubiquitously known very quickly. Similarly, if The Cat were flawed and 
>> began targeting monetary UTXOs, this would be detected well before 
>> activation, and the necessary fixes applied, with any distortion of its 
>> motivation exposed and corrected.
>>
>>
>> Backward compatibility
>>
>>
>> This proposal is a consensus-changing soft fork. Legacy nodes that do not 
>> implement The Cat will continue to accept blocks that spend NMUs as valid, 
>> while nodes that do implement The Cat will reject such blocks as invalid. 
>> As with any soft fork, activation requires clear opt-in from miners and 
>> from economic nodes. After activation, miners and other block proposers 
>> must avoid including transactions that spend NMUs, because such blocks will 
>> be rejected by upgraded nodes. Wallets and applications that track 
>> inscriptions, BRC-20 assets, and related schemes will observe that NMUs 
>> become permanently unspendable under The Cat and that balances associated 
>> with those UTXOs are no longer movable under the activated ruleset.
>>
>>
>> FAQ
>>
>>
>> Do node operators need to run Ord or Stamps?
>>
>>
>> No. The Cat does not require ordinary node operators to run Ord or 
>> Stamps, or to understand their rules in detail. Those indexers are cited as 
>> normative references for the inscription and stamp classification logic 
>> used to derive NMUSet_snap. In practice, nodes only need the canonical 
>> NMU_DATA blob and its hash NMU_DATA_HASH to enforce the consensus rule.
>>
>>
>> Anyone who wishes to independently verify NMUSet_snap can:
>>
>>
>> inspect the open-source Ord and Stamps code,
>>
>>
>> or re-implement equivalent classification rules,
>>
>>
>> and confirm that the derived set of NMU outpoints matches the set encoded 
>> in NMU_DATA (i.e., the blob whose hash is NMU_DATA_HASH).
>>
>>
>> What rules do the reference indexers actually use to decide which UTXOs 
>> are NMUs?
>>
>>
>> This BIP does not re-specify the full Ord and Stamps protocols, but in 
>> broad terms:
>>
>>
>> Ord 0.24.0 (inscriptions).
>>
>> According to the classification rules implemented in Ord 0.24.0 at commit 
>> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is scanned for 
>> “inscription envelopes” in Taproot script paths. An inscription envelope is 
>> an OP_FALSE OP_IF … OP_ENDIF block containing data pushes that start with 
>> the ASCII tag ord and encode a content type and body. When those rules are 
>> applied to the best chain up to height H_snap, each recognized inscription 
>> is associated with a particular outpoint (txid, vout) (typically the first 
>> satoshi of a reveal transaction input, or as directed by the pointer field 
>> in the protocol). OrdNMUSet is defined as the set of outpoints that Ord 
>> 0.24.0 would classify as carrying inscriptions at H_snap under these rules.
>>
>>
>> Stamps (BTC Stamps).
>>
>> According to the classification rules implemented in the pinned BTC 
>> Stamps indexer, Counterparty transactions are inspected for a 
>> STAMP:-prefixed base64 string in the description field, which encodes image 
>> data. The Stamps rules then map this metadata to specific dust-sized bare 
>> multisig outputs in the underlying Bitcoin transactions. When those rules 
>> are applied to the best chain up to height H_snap, each recognized stamp is 
>> associated with one or more outpoints (txid, vout). StampsNMUSet is defined 
>> as the set of outpoints that this reference Stamps implementation would 
>> classify as containing such stamp-style embedded assets at H_snap.
>>
>>
>> Won’t spammers just make workarounds and spam anyway?
>>
>>
>> The Cat targets the financial incentive to create spam. It is almost 
>> impossible to stop a determined user from adding data to Bitcoin. The more 
>> realistic mitigation is to remove the ability to reliably trade these 
>> embedded assets as if they were durable, on-chain economic objects. Once 
>> the existing inscription and stamp economies are neutralized and their 
>> dust-sized carrier UTXOs are fenced off, the motivation to spam the chain 
>> in the same way is greatly reduced.
>>
>>
>> Can’t users just spend their NMUs after the snapshot, removing them from 
>> the list?
>>
>>
>> Yes, a user can attempt to evade The Cat by spending an NMU after the 
>> snapshot. However, there are tens of millions of such outputs. It would be 
>> extremely costly, in aggregate fees, to move them all. If large-scale 
>> evasion occurs before activation, it is straightforward to take a new 
>> snapshot, forcing evaders to pay again if they want to continue. This is 
>> the nature of the cat-and-mouse game: attempts to pre-empt the snapshot by 
>> moving large numbers of NMUs impose substantial costs on those outputs, 
>> while the network can respond by choosing an appropriate snapshot height if 
>> necessary.
>>
>>
>> What if some of my UTXOs contain “rare sats”? Won’t those get “Catted”?
>>
>>
>> In this BIP, “rare sats” can be understood as satoshis that Ord and 
>> similar indexers are treating as non-monetary artifacts. The Cat does not 
>> look at individual sat numbers or “rarity” directly; it only classifies 
>> whole UTXOs via the is_nmu(u) predicate, using NMUSet_snap and a simple 
>> value/height guardrail.
>>
>>
>> A UTXO can only be classified as an NMU if all of the following are true:
>>
>>
>>
>>    - 
>>    
>>    it falls inside the NMU height window,
>>    
>>
>>
>>    - 
>>    
>>    its value is strictly below VALUE_MAX_NMU (currently 1,000 sats), and
>>    
>>
>>
>>    - 
>>    
>>    its outpoint appears in NMUSet_snap as identified by Ord/Stamps at 
>>    the snapshot.
>>    
>>
>> Anything at or above VALUE_MAX_NMU is always treated as a normal monetary 
>> output, regardless of what Ord says about the sats inside it.
>>
>>
>> In practice, if you once interacted with Ord and those “rare sats” now 
>> live inside a normal-sized wallet UTXO (1,000 sats or more), this proposal 
>> does not touch that UTXO at all. It remains fully spendable under the 
>> ordinary rules. The only “rare sats” that get Catted are those deliberately 
>> parked in tiny dust outputs below the VALUE_MAX_NMU threshold, and that Ord 
>> (or Stamps) is already treating as non-monetary artifacts at H_snap. Those 
>> dust UTXOs are precisely the objects this proposal is targeting to fence 
>> off from the monetary UTXO set.
>>
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/32f8c689-314d-4a5e-9af6-2e3e704582e6n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/32f8c689-314d-4a5e-9af6-2e3e704582e6n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/2ebbf019-a562-427d-93af-b88f0cf5658an%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 129132 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-12 23:40  1%   ` Greg Maxwell
@ 2025-12-13  3:54  2%     ` Melvin Carvalho
  2025-12-13  7:07  1%     ` Ataraxia 009
  2025-12-17 16:22  0%     ` Jonathan Voss
  2 siblings, 0 replies; 200+ results
From: Melvin Carvalho @ 2025-12-13  3:54 UTC (permalink / raw)
  To: Greg Maxwell; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 1740 bytes --]

so 13. 12. 2025 v 0:49 odesílatel Greg Maxwell <gmaxwell@gmail.com> napsal:

> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98kurz@gmail.com> wrote:
>
>> Since the Bitcoin Stamps outputs are already unspendable, it makes
>> perfect sense to mark and drop them from the UTXO set.
>
>
> There is no consensus change involved in not storing a provably
> unspendable output, it's just an implementation detail with no
> interoperability implications and doesn't need a BIP.  Bitcoin core has
> long done so for several types of unspendable outputs, e.g. outputs over
> 10kb and ones starting with OP_RETURN.
>

Alternative to confiscation: what if miners simply required 100+ sats/vbyte
to include transactions spending inscription UTXOs?


>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTjF_e5vLEzp672_jmF82jDUre0wcZKHB5my8kTdFOGgw%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTjF_e5vLEzp672_jmF82jDUre0wcZKHB5my8kTdFOGgw%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2B9HFKVDXdkkgsBeW0aq7mWVvpzZ9iy%3DX8%2B%3D6t%2BiCswuA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 2959 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] Re: Reducing RAM requirements with dynamic dust
  2025-12-10 20:44  0%     ` Eric Voskuil
@ 2025-12-12 22:22  1%       ` 'uuowwpevskfcordh' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'uuowwpevskfcordh' via Bitcoin Development Mailing List @ 2025-12-12 22:22 UTC (permalink / raw)
  To: Eric Voskuil; +Cc: bitcoindev@googlegroups.com

Thanks both Eric and Erik for the replies. I can't answer whether RAM requirements due to UTXO would indeed be a problem or not. I think a worse-case performance could be considered assuming a "no-RAM" environment.

This being said, I wanted to share some insights still related to the dynamic dust mechanism (the essay).

1. This proposal could be named "dynamic dust" plus "dust sweeping". Dynamic dust refers to the dust level being defined by the controller at every epoch, and dust sweeping refers to deprecation of utxos below that dust threshold.

2. The grace period for the sweep, individual for each transaction, allows for a new perspective. This is, again, better portrayed by Grok:

## Annex: Addressing Concerns of Confiscation in UTXO Deprecation

While the proposed PID-inspired mechanism for UTXO set management offers a pathway to enhanced scalability, it has elicited valid criticisms, particularly regarding its confiscatory nature. Deprecating low-value UTXOs could be perceived as an involuntary seizure of assets, undermining Bitcoin's principles of ownership and immutability. This concern merits careful consideration, as any protocol change must preserve user trust and avoid arbitrary interventions.

The proposal maintains a degree of neutrality by evaluating UTXOs solely based on their satoshi (SAT) value, without interpreting their content or purpose. This objective criterion minimizes subjective judgments, applying uniformly across all outputs regardless of their origin or use case.

A key mitigating factor lies in the incorporation of a grace period—typically spanning 6 to 12 months—during which owners of affected UTXOs can consolidate or spend them without direct penalty. This window transforms the deprecation process from outright confiscation into a dynamic incentive structure, favoring resource allocation in a constrained system. In Bitcoin's ecosystem, users already incur ongoing costs for participation, such as transaction fees, which can render low-value UTXOs economically immobile if fees rise persistently. Such "frozen" outputs are not labeled as confiscated but rather as subject to market realities.

From this perspective, low-value (or "dust") UTXOs enter a "renting" state upon falling below the dynamic dust floor. Owners, including those engaging in high-volume, low-value activities (e.g., data inscription or sidechain anchoring), can extend their usability by periodically transacting them—paying the requisite fees to "renew" the grace period. Failure to do so results in expiration and deprecation, mirroring the fee-based prioritization inherent in Bitcoin's design rather than imposing an immediate punitive forfeiture.

This framework may inadvertently benefit miners, as sustained renewal activities could increase block occupancy, elevating average fees and bolstering network security through heightened hashrate incentives. By channeling resources toward productive on-chain operations, the mechanism redirects potential inefficiencies into contributions that enhance overall system resilience.

In summary, while the confiscatory nature and risks are acknowledged, the grace period and value-based neutrality recast deprecation as an extension of Bitcoin's economic model, promoting efficient resource use without compromising core tenets.

Best regards,


On Wednesday, December 10th, 2025 at 8:52 PM, Eric Voskuil <eric@voskuil.org> wrote:

> Hi Erik,
> 
> It's a good idea, that's why we did it.
> 
> Libbitcoin is a set of libraries, libbitcoin-database being one of 4 that make up node (system, network, database, and node). (libbitcoin-server is an additional library that adds comprehensive set of client-server interfaces, making the node useful.) libbitcoin-database is an implementation of a simple query interface (defined as a c++ class) over a backing store. The store is a templated collection of tables. The tables are mmap-based head and body files used to construct multimaps, hashmaps, arraymaps, arrays, and blobs. We mock the tables using std::vector<uint8_t>, mock the store using the the mocked tables, and test most of the query interface using the mock store. The structure is highly relational, and surrogate keys are exposed to the caller for optimized navigation.
> 
> This is an isolated and clear storage abstraction layer. All validation is performed within the chain:: classes (e.g. block, header, tx, input, script, etc.) defined in the base level libbitcoin-system. There is no validator coupling to the store. The store retains chain objects, indexes, and validation state for headers/blocks and txs as they progress through a state machine. There is no utxo table, just natural relations between objects, indexed and related. Validation correctness of course requires store fidelity, but is totally decoupled from it. We validate blocks concurrently, queueing up 50,000 blocks at a time by default (e.g. with 50k threads we would validate all at the same time).
> 
> The store could be replaced with no impact to the query interface (as we already do in testing). So it's not really accurate to imply that libbitcoin's validation is tied to mmap or even append-only. Pruning could be implemented in the existing model for example. The existing store could be replaced with something simple and light like SQLite, or a full RDBMS. We had some interns working the SQLite approach last summer. That would be more specialized for low performance scenarios, where the custom database targets ultra high performance.
> 
> With sufficient RAM there is never SSD access. The store can sync up and just live in RAM, never touching a disk. Since it is append only, it's very low impact on SSDs. As the store builds, no table body byte is ever re-written. Table heads are hashmaps buckets, small and dynamic. It performs live automated/manual snapshotting, automatic fault detection/recovery on restart, automated disk-full pause/restart, and supports hot backup. Query performance is phenomenal. A warm node can query the full 5.2 million output Electrum query (very complex relations) in 15 seconds on my 2.1GHz workstation. But at the low end, an off-the-shelf store is sufficient. A clear interface and swappable store makes a lot of sense.
> 
> A large utxo set makes no difference in this design. There are no operational problems associated with it. Given the recent fuss about it, I figured it was worth putting some detail behind it here. This is not theoretical, at this point we are only working on server (client-server interfaces). The utxo set size is a complete non-issue.
> 
> e
> 
> On Wednesday, December 10, 2025 at 2:48:43 PM UTC-5 Erik Aronesty wrote:
> 
> > Core: Keep UTXO lookups in RAM as much as possible. This gives predictable validation under adversarial load and trades memory for protection from pathological disk latency.
> > Libbitcoin: Represent history in append-only, memory-mapped files. Let the operating system decide what stays hot. Accept more disk I/O in return for simpler concurrency and no explicit UTXO map.
> > 
> > To create 200 million outputs as an attack, the cost is roughly 48 BTC based on eight vb per output at low feerates.
> > 
> > Given the operational problems that a very large UTXO set creates, it may be worthwhile to develop a clear storage abstraction layer.
> > 
> > The goal would be to ensure that validation correctness does not depend on the transitional behavior of a specific storage engine.
> > 
> > Once the validator has a well defined storage contract, alternate backends such as a libbitcoin style layout could exist as storage formats while still benefiting from the reliability of the rest of the Bitcoin implementation.
> > 
> > (I would be interested in something like this.)
> > 
> > 
> > On Wed, Dec 10, 2025 at 10:34 AM Eric Voskuil <er...@voskuil.org> wrote:
> > 
> > > > Given the increasing RAM requirements, due to the increasing UTXO set
> > > 
> > > I have been assured multiple times recently that this problem does not exist in Bitcoin Core. I'm not sure about that, but I can say for sure that this is not a problem in Libbitcoin and is therefore not problem with the Bitcoin protocol.
> > > 
> > > Best,
> > > Eric
> > > 
> > > On Wednesday, December 10, 2025 at 1:12:31 PM UTC-5 uuowwpevskfcordh wrote:
> > > 
> > > > Given the increasing RAM requirements, due to the increasing UTXO set, I suggest seeing the UTXO set size as a controlled variable. A feedback mechanism sets a dynamic dust level, below from which UTXOs are removed/discarded and thus freeing RAM.
> > > > 
> > > > Below is an overview essay better expressed by grok, which can also be seen in here:
> > > > https://hackmd.io/P-2lzGb8TiC86IOE3OGiYA?view
> > > > 
> > > > # Enhancing Bitcoin's Scalability: A PID-Inspired Approach to Managing UTXO Set Growth
> > > > 
> > > > ## Abstract
> > > > 
> > > > Bitcoin’s UTXO set is currently an unbounded accumulator that risks long-term centralization as node RAM requirements grow without limit. Existing fee incentives have proven insufficient against sustained low-value output creation (e.g., inscriptions, tokenized assets, dust-heavy protocols). This article proposes a soft-fork mechanism that treats UTXO set size as a controlled variable: a slowly rising target size is defined, and a PID-style feedback controller, updated every difficulty epoch, dynamically raises a minimum-value floor beneath which old UTXOs become unspendable. The result is bounded, predictable growth of the UTXO set with ample warning periods, no hard caps on monetary use, and strong resistance to bloat attacks—all while remaining fully compatible with a soft-fork deployment.
> > > > 
> > > > ## Introduction
> > > > 
> > > > Bitcoin, the pioneering decentralized digital currency, operates as a complex dynamic system governed by consensus rules that ensure security, immutability, and permissionless participation. At its core, Bitcoin maintains a distributed ledger known as the blockchain, which records all transactions in a sequence of blocks. Each transaction involves inputs and outputs: inputs reference previously unspent outputs from prior transactions, while outputs create new spendable units called Unspent Transaction Outputs (UTXOs). The UTXO set represents the aggregate state of all currently spendable coins in the network, serving as a critical component for transaction validation and wallet management.
> > > > 
> > > > As Bitcoin has evolved, the UTXO set has grown significantly, influenced by increasing adoption and diverse usage patterns. This growth, while indicative of the network's vitality, poses challenges to its long-term scalability and decentralization. Nodes—computers that validate and relay transactions—must store and process the entire UTXO set in memory for efficient operation, which can strain resources such as random access memory (RAM). Unchecked expansion could lead to higher barriers for running full nodes, potentially centralizing control among fewer, well-resourced participants. This article explores a proposed mechanism to address these concerns: an adaptive control system inspired by Proportional-Integral-Derivative (PID) feedback principles, designed to impose bounded growth on the UTXO set while preserving Bitcoin's foundational properties.
> > > > 
> > > > ## Motivations for UTXO Set Management
> > > > 
> > > > To appreciate the need for enhanced UTXO management, it is essential to understand the current status quo and its vulnerabilities. Bitcoin's design prioritizes efficiency and security through mechanisms like block size limits, which cap the amount of data added per block (approximately 1 MB base size, expandable to about 4 MB with Segregated Witness). These limits help control the overall blockchain size, ensuring predictable hardware requirements for storage on hard disk drives (HDDs). Similarly, the difficulty adjustment algorithm maintains a consistent block production rate of roughly one every 10 minutes by dynamically scaling the computational challenge for miners based on network hashrate.
> > > > 
> > > > However, the UTXO set lacks comparable built-in constraints. It accumulates as users create new outputs—often in small denominations—without a mandatory mechanism to consolidate or prune them. This can result from various activities, including high-frequency microtransactions, the embedding of non-monetary data (such as through protocols like Ordinals, which inscribe arbitrary information onto satoshis, Bitcoin's smallest unit), or the anchoring of sidechain or tokenized assets that leverage Bitcoin's security but operate externally. While these innovations expand Bitcoin's utility, they can inadvertently increase the UTXO count disproportionately to their economic value, elevating transaction fees during congestion and raising operational costs for nodes.
> > > > 
> > > > Existing incentives, such as transaction fees, partially mitigate this by encouraging users to consolidate low-value UTXOs to avoid higher costs. Yet, these market-driven forces are insufficient against sustained patterns of low-value output creation, particularly when driven by external systems that do not bear the full cost of network maintenance. Over time, this leads to bloat: as of recent estimates, the UTXO set exceeds several gigabytes when loaded into memory, complicating node synchronization and validation. Without intervention, projected growth could undermine decentralization, as fewer individuals or entities might afford to participate fully in the network.
> > > > 
> > > > The motivation for reform, therefore, stems from a desire to balance innovation with sustainability. An ideal solution would allow gradual UTXO expansion to accommodate genuine monetary usage while introducing feedback to curb excessive accumulation, all without compromising Bitcoin's permissionless nature or requiring a hard fork that could fragment the community.
> > > > 
> > > > ## A PID-Inspired Feedback Controller for UTXO Control
> > > > 
> > > > Drawing from control theory, which studies how systems maintain desired behaviors through feedback, this proposal introduces a dynamic mechanism to regulate UTXO set size. PID controllers, widely used in engineering for processes like temperature regulation or autopilot systems, combine three terms: Proportional \(P\) for immediate response to errors, Integral (I) for correcting persistent deviations, and Derivative (D) for anticipating changes based on trends. In Bitcoin's context, we adapt this framework to compute a minimum value threshold—or "floor"—below which UTXOs become ineligible for spending, effectively deprecating them over time.
> > > > 
> > > > Importantly, this deprecation rule constitutes a soft fork: it restricts the set of valid transactions to a subset of those previously allowed, without introducing new capabilities. Upgraded nodes enforce the rule, rejecting deprecated UTXOs as invalid inputs, ensuring backward compatibility and minimizing disruption.
> > > > 
> > > > ### Mechanism Overview
> > > > 
> > > > The controller activates at each difficulty adjustment epoch, approximately every two weeks (2016 blocks), aligning with Bitcoin's existing periodic recalibrations for predictability.
> > > > 
> > > > 1. **Define a Target UTXO Size Trajectory**: Establish an increasing maximum target for the UTXO set size, denoted as $T(t)$, where $t$ represents the epoch number. This could grow sublinearly with time or blockchain height to reflect organic adoption— for instance, $T(t) = U_0 \cdot (1 + r)^t$, with $U_0$ as the initial size and $r$ a small annual growth rate (e.g., less than 1%). This permits expansion while preventing unbounded divergence.
> > > > 
> > > > 2. **Measure the Error**: At each epoch, compute the error $e(t) = S(t) - T(t)$, where $S(t)$ is the current UTXO set size (measured by count or aggregate data footprint).
> > > > 
> > > > 3. **Compute the Floor Adjustment**: Apply the PID formula to adjust the value floor $F(t)$:
> > > > 
> > > > $$ \Delta F(t) = K_p \cdot e(t) + K_i \cdot \sum_{k=0}^{t} e(k) + K_d \cdot \frac{e(t) - e(t-1)}{\Delta t} $$
> > > > 
> > > > Here, $K_p, K_i, K_d$ are tunable gains, selected conservatively through simulations to ensure stability (e.g., using root locus analysis to avoid oscillatory or unstable roots in the system's characteristic equation). The floor $F(t)$ increases only if $e(t) > 0$, applying to UTXOs below this threshold.
> > > > 
> > > > 4. **Deprecation Process**: UTXOs with values below $F(t)$ are marked as unspendable in future transactions. To provide fairness and predictability, implement a grace period (e.g., 4-12 months) during which owners can consolidate affected UTXOs.
> > > > 
> > > > 5. **Safeguards and Tuning**: Incorporate clamps on $\Delta F(t)$ (similar to Bitcoin's difficulty adjustment limits) to prevent abrupt changes that might cause network congestion from mass consolidations. Periodic reviews of gains and targets via community governance would adapt the system to evolving conditions.
> > > > 
> > > > ### Stability and Dynamics Considerations
> > > > 
> > > > In dynamic systems terms, the UTXO set can be modeled as an integrator accumulating outputs minus expenditures. The PID controller introduces negative feedback to dampen this accumulation, driving $S(t)$ toward $T(t)$ with minimal overshoot. Simulations would verify robustness against adversarial scenarios, such as deliberate UTXO spam, ensuring the system's poles remain in the stable region of the complex plane.
> > > > 
> > > > Potential benefits include reduced node resource demands, lower fees during normal operation, and enhanced decentralization. Risks, such as over-deprecation affecting small holders, can be mitigated through careful gain selection.
> > > > 
> > > > ## Conclusion
> > > > 
> > > > This PID-inspired approach offers a principled path to managing Bitcoin's UTXO set, fostering sustainable growth while upholding core principles. By integrating feedback control, Bitcoin can evolve as a resilient dynamic system, better equipped for widespread adoption. Further research, including detailed modeling and community discourse, is essential to refine and potentially implement such enhancements.
> > > > 
> > 
> > > --
> > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com.
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/97065ca0-662b-4a5d-90c5-7607db41ba2fn%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ASHweqfTSVKBPOY2P4UCyK7k7C28OWcQx2SfP9Ovqv2xifZo6SJYpwYLQTjvXTuf7lCa6fqeP92n47L6EokhlA7gHguLLgzHBQMY87rQDQk%3D%40proton.me.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-12 23:40  1%   ` Greg Maxwell
  2025-12-13  3:54  2%     ` Melvin Carvalho
@ 2025-12-13  7:07  1%     ` Ataraxia 009
  2025-12-17 16:22  0%     ` Jonathan Voss
  2 siblings, 0 replies; 200+ results
From: Ataraxia 009 @ 2025-12-13  7:07 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 2001 bytes --]

Yes there is no need to add consensus changes to filter out unspendable
outputs from the UTXO set, thats just a protocol upgrade.

The second point with the Ordinals:
Whether it's a transaction validation rule or not, what you're planning to
do is differentiate between utxos on a consensus level. Which is the worst
path that you could go down. This will break bitcoin more than any spam
ever will.

On Sat, Dec 13, 2025 at 5:19 AM Greg Maxwell <gmaxwell@gmail.com> wrote:

> On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98kurz@gmail.com> wrote:
>
>> Since the Bitcoin Stamps outputs are already unspendable, it makes
>> perfect sense to mark and drop them from the UTXO set.
>
>
> There is no consensus change involved in not storing a provably
> unspendable output, it's just an implementation detail with no
> interoperability implications and doesn't need a BIP.  Bitcoin core has
> long done so for several types of unspendable outputs, e.g. outputs over
> 10kb and ones starting with OP_RETURN.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTjF_e5vLEzp672_jmF82jDUre0wcZKHB5my8kTdFOGgw%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTjF_e5vLEzp672_jmF82jDUre0wcZKHB5my8kTdFOGgw%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAADX_vKftpgPfr7FgQGsQQ%2B6EtEdsZu-fUOWVq-ZQPoLoP8zkQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 2981 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: The Cat, BIP draft discussion.
  2025-12-12 17:13  2% ` [bitcoindev] " Jonathan Voss
@ 2025-12-12 23:40  1%   ` Greg Maxwell
  2025-12-13  3:54  2%     ` Melvin Carvalho
                       ` (2 more replies)
  0 siblings, 3 replies; 200+ results
From: Greg Maxwell @ 2025-12-12 23:40 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 921 bytes --]

On Fri, Dec 12, 2025 at 9:26 PM Jonathan Voss <k98kurz@gmail.com> wrote:

> Since the Bitcoin Stamps outputs are already unspendable, it makes perfect
> sense to mark and drop them from the UTXO set.


There is no consensus change involved in not storing a provably unspendable
output, it's just an implementation detail with no interoperability
implications and doesn't need a BIP.  Bitcoin core has long done so for
several types of unspendable outputs, e.g. outputs over 10kb and ones
starting with OP_RETURN.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTjF_e5vLEzp672_jmF82jDUre0wcZKHB5my8kTdFOGgw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 1495 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-11 12:53  3% [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction defenwycke
  2025-12-12 18:10  0% ` [bitcoindev] " Jonathan Voss
@ 2025-12-12 22:49  0% ` Murch
  2025-12-13 14:56  1%   ` defenwycke
  1 sibling, 1 reply; 200+ results
From: Murch @ 2025-12-12 22:49 UTC (permalink / raw)
  To: bitcoindev


[-- Attachment #1.1.1: Type: text/plain, Size: 5847 bytes --]

Hey Defenwycke,

 > all inputs are “dust-class” UTXOs

What does “dust-class” mean? Are you using the Bitcoin Core dust limit 
or talking about small amounts in general? I don’t have figures off the 
top of my head, but I would assume that there are relatively few UTXOs 
smaller than Bitcoin Core’s dust limit.

 > only standard scripts (P2PKH / P2WPKH / P2TR)

You might want to clarify that you mean only P2TR KP inputs. Or would 
P2TR SP be permitted?

 > Nodes place these in a small, separate sub-mempool. They’re only
 > accepted when the normal mempool is <50% full, and they’re
 > automatically evicted if normal mempool usage hits 95%.

It would be a lot of work to have a separate pool for this, and I don’t 
see a reason why they couldn’t just go in the regular mempool. If the 
mempool fills up, they’d have the lowest feerates and they’d get kicked 
out first anyway. That said, at 50% full, there are still around ~30 
blocks worth of transactions waiting in the mempool that pay fees, …

 > Miners can include them up to a small weight fraction (I suggest ~5%) 
but only after filling the block with regular fee-paying transactions.

… so if they are only considered in blocks that aren’t full, the only 
ones I have seen lately are miners using a minimum feerate of 1 s/vB for 
their block templates. Looking at some popular mempool statistic sites, 
in the past 32 months, there would have only been organically non-full 
blocks between April and August this year.

I assume the intention is to only relay these transactions when there 
are blocks that aren’t full, to limit the bandwidth-wasting vector this 
feature introduces, but overall it seems to me that it would be most 
likely for such transactions to sit in nodes’ memory until they expire.

All that said, at the new minimum feerate of 0.1 s/vB, a 148 vB P2PKH 
input costs 15 sats, a 68 vB P2WPKH input costs 7 sats, and a 57.5 vB 
P2TR input costs 6 sats. It doesn’t seem obvious to me that saving a few 
dozen sats would greatly foster the users’ urge to consolidate. It feels 
like a lot of overhead for such a small incentive to the users, and 
relying on the miners to give away blockspace below market value feels a 
bit optimistic as well.

Cheers,
Murch

On 2025-12-11 04:53, defenwycke wrote:
> Hello list,
> 
> I’ve been working on a small policy proposal that aims to address one 
> very specific problem: the long-term accumulation of uneconomical dust 
> in the UTXO set.
> 
> The idea is intentionally narrow. I’m calling it DustSweep, and it 
> defines a strict, non-abusable class of transactions that nodes may 
> relay and miners may include only when the mempool and block space are 
> underutilised. The goal is to give wallets a predictable way to compact 
> dust without introducing new spam vectors or touching consensus.
> 
> A DustSweep transaction has the following properties:
> 
>   *
> 
>     all inputs are “dust-class” UTXOs
> 
>   *
> 
>     only standard scripts (P2PKH / P2WPKH / P2TR)
> 
>   *
> 
>     exactly one output
> 
>   *
> 
>     no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
> 
>   *
> 
>     minimum of 5 inputs (to ensure meaningful UTXO reduction)
> 
>   *
> 
>     size capped
> 
>   *
> 
>     it pays a flat 1 sat per input fee
> 
> Nodes place these in a small, separate sub-mempool. They’re only 
> accepted when the normal mempool is <50% full, and they’re automatically 
> evicted if normal mempool usage hits 95%. Miners can include them up to 
> a small weight fraction (I suggest ~5%) but only after filling the block 
> with regular fee-paying transactions. The intention is that DustSweep 
> never competes with the fee market and only uses blockspace that would 
> otherwise go unused.
> 
> This is all policy-level. No consensus changes, no new transaction 
> format, nothing that affects validation. Nodes that don’t implement it 
> simply treat these as low-fee transactions and drop them.
> 
> The motivation is straightforward: we don’t currently have a safe, 
> structured way to compact dust, and the UTXO set continues to grow from 
> outputs that are effectively unspendable under normal fee conditions. 
> DustSweep tries to offer a predictable, opt-in mechanism for wallets to 
> clean that up without creating any new attack surface.
> 
> Full draft BIP and supporting documents are here:
> 
> https://github.com/defenwycke/bip-dust-sweep
> 
> I’d appreciate feedback on the policy details, thresholds, and whether 
> this fits within what node operators and wallet developers would 
> actually want to use. Happy to adjust parameters if there’s a better 
> balance point.
> 
> Kind regards,
> 
> Defenwycke
> 
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com 
> <mailto:bitcoindev+unsubscribe@googlegroups.com>.
> To view this discussion visit https://groups.google.com/d/msgid/ 
> bitcoindev/b47aa182-bca7-44d7-bed1-f3cc2df30ef5n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/b47aa182-bca7-44d7-bed1- 
> f3cc2df30ef5n%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/02d7368e-95d3-4185-b70f-3aa9b5df1e1d%40murch.one.

[-- Attachment #1.1.2: OpenPGP public key --]
[-- Type: application/pgp-keys, Size: 17583 bytes --]

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: The Cat, BIP draft discussion.
       [not found]     <32f8c689-314d-4a5e-9af6-2e3e704582e6n@googlegroups.com>
       [not found]     ` <CAAS2fgRR77nZj3-rJo70dnxe8Lma88-C9JqdVTYfXGHRgFu3pA@mail.gmail.com>
@ 2025-12-12 17:13  2% ` Jonathan Voss
  2025-12-12 23:40  1%   ` Greg Maxwell
  1 sibling, 1 reply; 200+ results
From: Jonathan Voss @ 2025-12-12 17:13 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 40537 bytes --]

Since the Bitcoin Stamps outputs are already unspendable, it makes perfect 
sense to mark and drop them from the UTXO set. The outputs marked by Ord as 
containing the sats associated with a witness Inscription, on the other 
hand, are inherently spendable; freezing those outputs would be direct 
confiscation, which is conceptually antithetical to the purpose of Bitcoin *per 
se*. However, a transaction validation rule that requires that the number 
of outputs of a transaction containing those sats must be lower than the 
number of inputs would damage the utility of Ordinals without confiscating 
the underlying bitcoins. This would require separately defining the 
unspendable Stamp outputs and the abusive spam Ordinal outputs; the latter 
could be simplified by just specifying that any transaction containing an 
input of less than 1,000 sats must have fewer outputs than inputs, greatly 
reducing the complexity of the consensus change while still achieving 
long-term UTXO set size reduction.

On Wednesday, December 10, 2025 at 1:12:31 PM UTC-5 Claire Ostrom wrote:

> Dear Bitcoin-dev,
>
> Given recent discussions surrounding the malincentives of spam and the 
> perceived futility in addressing these issues, I felt it necessary to 
> propose a working solution. For those interested, I have written a brief 
> history of the problem; please skip to “The BIP” below if you are only 
> interested in the proposal.
>
> Bitcoin is a peer to peer open source monetary network created to 
> facilitate online payments between individuals without trust in a third 
> party. By its nature as an open protocol, and its censorship-resistant 
> design with no single authority maintaining its operation, we have to rely 
> on incentives and culture for network stewardship. Historically, we saw 
> many trends emerge which threatened Bitcoin’s primary use as a monetary 
> network. They were successfully dealt with by introducing OP_Return with a 
> small limit as a more efficient and limited way of directing non-monetary 
> data to a provably non-spendable space that could more easily be pruned 
> from nodes and, importantly, not pollute the UTXO set.
>
> Legendary Bitcoin developer Gregory Maxwell said at the time, “Part of 
> the idea here is shaping behavior towards conservative needs.” 
> <https://github.com/bitcoin/bitcoin/pull/2738#issuecomment-25017368>
>
> This was enforced through standardness filters, which are a way of 
> discouraging certain types of transactions that, while technically 
> consensus valid, we have agreed as a community are usually not used in 
> standard practice and are potentially harmful.
>
> In recent years, these trends have come back into focus with the creation 
> of schemes like Ordinal theory and its associated inscriptions, and Bitcoin 
> Stamps, which are techniques for embedding non-monetary data (like images 
> or tokens) into Bitcoin transactions. Ordinals typically hide data in the 
> Taproot witness field (benefiting from a weight “discount”), while Stamps 
> encode data in unspendable outputs (e.g., fake bare multisig addresses). 
> These practices turn the blockchain into a data storage system rather than 
> purely a payments network. As anyone familiar with basic economics knows, 
> what you subsidize, you get more of.
>
> Critically, many Ordinal inscription and Stamp transactions create dust 
> outputs (tiny UTXOs of only a few hundred sats) that remain unspent 
> indefinitely, bloating the UTXO set. Because Stamp outputs are expected to 
> remain unspent indefinitely, they persist in the UTXO set forever.
>
> Veteran Bitcoin developer Mark “Murch” Erhardt has described the stamps 
> UTXO issue as “probably, from a technical perspective, one of the more 
> egregious uses of blockchain." 
> <https://bitcoinops.org/en/podcast/2023/12/21/>
>
> [image: Screenshot 2025-12-01 212654.png]
>
> Over roughly 14 years (2009-early 2023), Bitcoin’s UTXO set grew gradually 
> to around 80-90 million entries. Then, in less than a year, it doubled to 
> more than 160 million by late 2023, a historic anomaly driven largely by 
> the Ordinals and Stamps craze. Analyses suggest that by mid-2025, over 30% 
> of all UTXOs were tied to Ordinal inscriptions. Nearly half of all UTXOs 
> (around 49%) now contain less than 1,000 satoshis, strongly indicating they 
> are spammy dust outputs used for data embedding rather than normal economic 
> activity. Many of these are Taproot outputs or outputs sitting exactly at 
> the standard dust threshold, consistent with algorithmic spam creation. In 
> short, UTXO spam now accounts for tens of millions of entries and 
> represents an unprecedented explosion of UTXO bloat.
>
> The UTXO database (chainstate) has ballooned alongside this spam. Before 
> 2023, the chainstate was on the order of 4-5 GB; by early 2024 it exceeded 
> 11 GB, meaning the disk footprint required to hold the unspent set roughly 
> doubled in about a year, in line with Ordinals and BRC-20 mania. Over the 
> same period, the full blockchain grew by about 93 GB in 2023 alone, versus 
> roughly 55 GB per year previously, largely due to inscription data filling 
> blocks. While pruned nodes can discard old block data, they cannot discard 
> UTXOs: every unspent output, even spam, must remain in the chainstate until 
> it is spent or explicitly removed by a protocol change. This makes UTXO 
> spam a permanent, compounding burden on full nodes. As Bitcoin developers 
> have noted, techniques that deliberately embed data in UTXOs are among the 
> most egregious abuses of the system, precisely because they clutter the 
> UTXO set with junk that cannot be pruned away under current rules.
>
> Bitcoin’s design includes some anti-spam measures, but spammers have 
> continually evolved “cat-and-mouse” tactics to bypass them.
>
> This is where our proposal comes in.
>
> THE BIP: The Cat.
>
>
> Recent attempts to reduce spam have focused on the supply side, trying to 
> stop spam through policy and standardness rules. These efforts have had 
> limited success. The Cat instead looks to economics, removing or reducing 
> the financial incentive for creating spam outputs in the first place. It 
> targets the demand side by making designated Non-Monetary UTXOs (NMUs) 
> permanently unspendable, which in turn reduces market demand for those 
> assets.
>
>
> The Cat defines a fixed, reproducible set of “NMUs” using established 
> external indexers, and makes them permanently unspendable by consensus, so 
> that such data cannot be monetized or transacted, only archived. Once 
> rendered unspendable, we will be removing these UTXOs made unspendable by 
> consensus under this proposal, from the UTXO set, materially reducing the 
> current resource requirement for nodes (likely on the order of tens of 
> millions of UTXOs, roughly ~30% of the set, subject to measurement). The 
> NMU classification itself is encoded in a compact membership structure (a 
> Binary Fuse Filter plus a false-positive exclusion list) that ships with 
> the binary and does not require any node to reindex or re-download the 
> chain.
>
>
>
> Draft Specification
>
>
> Status: Discussion draft. A formal BIP, compliant with BIP 0003 and the 
> usual BIP process, will be prepared if there is interest in pursuing this 
> direction.
>
>
> 1. Definitions
>
>
> Non-Monetary UTXO (NMU):
>
>
> A UTXO that is classified as containing inscription-style or stamp-style 
> data according to the procedure in §2 and that satisfies the value and 
> creation-height constraints below.
>
>
> NMU bit:
>
>
> A single Boolean flag (0 or 1) stored alongside each UTXO in the node’s 
> UTXO database:
>
>
>
>    - 
>    
>    NMU = 1 -> UTXO is non-monetary and may not be spent.
>    
>
>
>    - 
>    
>    NMU = 0 -> UTXO is monetary (normal behavior).
>    
>
> Conceptually, NMU = 1 means “this outpoint is in NMUSet_snap as defined by 
> this BIP.” Implementations MAY choose to compute this bit on the fly from 
> the membership structure rather than store it explicitly; see §3.
>
>
> NMU value threshold:
>
>
> A consensus constant VALUE_MAX_NMU = 1000 satoshis. Only UTXOs with value 
> strictly less than VALUE_MAX_NMU are eligible to be classified as NMU. 
> UTXOs with value greater than or equal to VALUE_MAX_NMU MUST be treated as 
> monetary (NMU = 0) for all time under this BIP, even if external tools 
> associate inscriptions or stamps with some of their satoshis.
>
>
> NMU creation-height window:
>
>
> This proposal intentionally restricts NMU classification to UTXOs created 
> between:
>
>
> H_min_NMU: the earliest block height at which the reference indexers (Ord 
> 0.24.0 and the specified Stamps version) first recognize any 
> inscription-style or stamp-style NMU, and
>
>
> H_snap: the snapshot height defined in §2.4.
>
>
> Both H_min_NMU and H_snap are consensus constants fixed before activation. 
> Any UTXO created at height < H_min_NMU or > H_snap MUST be treated as 
> monetary (NMU = 0) regardless of filter results.
>
>
> NMU membership structure (NMU_DATA):
>
>
> A static, exact membership structure that encodes NMUSet_snap using:
>
>
>
>    - 
>    
>    A Binary Fuse Filter (BFF-8) constructed from all eligible NMU 
>    outpoints; and
>    
>
>
>    - 
>    
>    A false positive exclusion list (FP_EXCLUDE) that contains all non-NMU 
>    outpoints at H_snap that would otherwise match the filter.
>    
>
> NMU_DATA is distributed as a single binary blob, together with a consensus 
> constant NMU_DATA_HASH = SHA256d(NMU_DATA) which all compliant 
> implementations MUST verify before using it for consensus validation (see 
> §3.3).
>
>
> Activation height (H_cat):
>
>
> A consensus constant H_cat, the block height at which the NMU spending 
> rule in §4 first becomes eligible for enforcement. The exact value and 
> deployment mechanism for H_cat are out of scope for this draft and would be 
> specified in a formal BIP.
>
>
> 2. NMU classification (reproducible list)
>
>
> The normative consensus object introduced by this BIP is the set 
> NMUSet_snap: a fixed set of outpoints classified as non-monetary at 
> snapshot height H_snap on the best chain, after applying the value and 
> height restrictions in §1 and §2.3.
>
>
> Consensus enforcement of The Cat only depends on whether an outpoint is in 
> NMUSet_snap or not; it does not depend on how any particular node obtained 
> that set.
>
>
> To define NMUSet_snap in a precise and reproducible way, this BIP 
> specifies two reference classification rule sets that operate purely on 
> Bitcoin chain data, as implemented in:
>
>
>
>    - 
>    
>    Ord 0.24.0 at commit 5d2fbbe64b362cd6c30d6901e50cbe80084761f8
>    
>
>
>    - 
>    
>    Stamps - [exact version/commit to be pinned before any activation]
>    
>
> These reference implementations define the inscription-style and 
> stamp-style classification rules in terms of Bitcoin chain data. They are 
> cited here as normative descriptions of how to decide whether a given 
> outpoint carries an inscription or a stamp at height H_snap.
>
>
> Implementations that wish to independently derive or verify NMUSet_snap 
> MAY:
>
>
>
>    - 
>    
>    Execute these reference implementations from genesis up to H_snap, or
>    
>
>
>    - 
>    
>    Independently re-implement the same classification rules and confirm 
>    that the resulting set of outpoints matches the NMU set implied by NMU_DATA.
>    
>
> Running Ord or Stamps is not required for ordinary full-node operation 
> under this BIP; they are simply the canonical specification of the 
> classification logic.
>
>
> This section uses the consensus constants H_cat, H_snap, and H_min_NMU as 
> defined in §1.
>
>
> 2.1 Ord NMU set
>
>
> According to the classification rules implemented in Ord 0.24.0 at commit 
> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is parsed for 
> “inscription envelopes” and each recognized inscription is associated with 
> a particular outpoint (txid, vout) on the best chain at height H_snap.
>
>
> Define OrdNMUSet as the set of all outpoints that, when those Ord 0.24.0 
> rules are applied to the best chain up to H_snap, are classified as 
> carrying inscriptions at H_snap. Concretely, for each inscription that Ord 
> 0.24.0 would associate with a specific outpoint (txid, vout) on that chain, 
> that outpoint is included in OrdNMUSet.
>
>
> This includes, for example, inscription UTXOs used by protocols such as 
> BRC-20, but the BIP makes no protocol-level distinction; they are all 
> treated as “NMU” if they meet the value and height thresholds in §2.3.
>
>
> An implementation may obtain OrdNMUSet by actually running Ord 0.24.0, or 
> by re-implementing its published classification rules and applying them to 
> the chain.
>
>
> 2.2 Stamps NMU set
>
>
> According to the classification rules implemented in the specified BTC 
> Stamps indexer (version/commit TBD), Counterparty metadata and Bitcoin 
> transactions are parsed to identify “stamp-style” embedded assets and 
> associate them with one or more bare multisig outputs on the best chain at 
> height H_snap.
>
>
> Define StampsNMUSet as the set of all outpoints that, when those Stamps 
> rules are applied to the best chain up to H_snap, are classified as 
> containing a stamp at H_snap. For each stamp that the reference Stamps 
> implementation would associate with a specific outpoint (txid, vout) on 
> that chain, that outpoint is included in StampsNMUSet.
>
>
> As with Ord, an implementation may obtain StampsNMUSet either by running 
> the reference Stamps indexer or by independently implementing the same 
> classification rules and applying them to the chain.
>
>
> 2.3 Combined NMU set + value & height thresholds
>
>
> The initial raw NMU set at snapshot height is:
>
>
> NMUSet_raw = OrdNMUSet ∪ StampsNMUSet
>
>
> Apply both the NMU value threshold and the creation-height window:
>
>
> NMUSet_snap = { u ∈ NMUSet_raw | value(u) < VALUE_MAX_NMU and H_min_NMU ≤ 
> height(u) ≤ H_snap }
>
>
> where value(u) is the number of satoshis in UTXO u, and height(u) is the 
> height of the block that created that UTXO.
>
>
> Every UTXO in NMUSet_snap MUST be treated as having NMU = 1 under the new 
> consensus rule (see §4). Nodes MAY realize this either by pre-seeding an 
> NMU bit in their UTXO database or by computing it dynamically via the 
> membership query in §3.3.
>
>
> Notes:
>
>
> Running Ord or Stamps is only required for those who wish to independently 
> derive and verify NMUSet_snap; it is not a requirement for ordinary full 
> node operation under The Cat.
>
>
> The value threshold is intended to avoid classifying large, mixed-use 
> UTXOs as NMUs when a small number of inscribed satoshis have been combined 
> with otherwise monetary funds.
>
>
> Restricting to height(u) ≥ H_min_NMU reflects the historical fact that 
> these protocols appeared only after a certain point, and it trivially 
> avoids misclassification of very old UTXOs.
>
>
> This proposal intentionally does not specify any new in-client 
> classification rule for discovering future NMU formats. It explicitly 
> targets non-monetary UTXOs identifiable via Ord 0.24.0 and Stamps at the 
> time of snapshot.
>
>
> 2.4 Snapshot block commitment and reorg behaviour
>
>
> This BIP commits to a specific chain history at the snapshot height H_snap 
> by introducing a new consensus constant:
>
>
> SNAP_BLOCK_HASH: a 32-byte value equal to the block hash at height H_snap 
> on the chain from which NMUSet_snap was originally derived.
>
>
> A node MUST only enforce the NMU consensus rule from §4 if, for its 
> current best chain:
>
>
> There exists a block at height H_snap, and
>
>
> The hash of that block is exactly equal to SNAP_BLOCK_HASH.
>
>
> If, for the node’s current best chain, the block at height H_snap has a 
> different hash, the node MUST treat all UTXOs as monetary (NMU = 0) for the 
> purposes of consensus validation, and MUST NOT reject any transaction or 
> block on the basis of the NMU rule.
>
>
> In particular, if a reorganization occurs that replaces the block at 
> height H_snap with a different block (i.e., a reorg deeper than H_snap), 
> enforcement of The Cat is automatically disabled until and unless the best 
> chain once again has SNAP_BLOCK_HASH at height H_snap. Any desire to apply 
> NMU classification to a different chain history would require a new 
> consensus commitment (for example, a new SNAP_BLOCK_HASH defined by a 
> subsequent BIP and activation process).
>
>
> 3. NMU bit storage, membership structure, and activation
>
>
> 3.1 NMU bit storage model
>
>
> Consensus only cares about which UTXOs are NMU, not how the bit is stored 
> or computed. Implementations MAY:
>
>
>
>    - 
>    
>    Store the NMU bit as an extra bit in the UTXO database (e.g., in the 
>    Coin structure).
>    
>
>
>    - 
>    
>    Store NMUs in a separate structure keyed by outpoint.
>    
>
>
>    - 
>    
>    Compute NMU on the fly at validation time using the NMU_DATA 
>    membership structure from §3.3, optionally caching results.
>    
>
> The only consensus requirement is: given the same chain, compliant 
> implementations must converge on the same NMU classification for all UTXOs. 
> Conceptually, for a UTXO u with value(u) and height(u), NMU(u) is defined 
> as:
>
>
>
>    - 
>    
>    1 if:
>    
>
>
>    - 
>    
>    H_min_NMU ≤ height(u) ≤ H_snap, and
>    
>
>
>    - 
>    
>    value(u) < VALUE_MAX_NMU, and
>    
>
>
>    - 
>    
>    u ∈ NMUSet_snap (as tested via §3.3),
>    
>
>
>    - 
>    
>    0 otherwise.
>    
>
> 3.2 Activation
>
>
> At activation height H_cat:
>
>
> Nodes must have:
>
>
>
>    - 
>    
>    Fully validated the chain up to at least H_snap.
>    
>
>
>    - 
>    
>    Loaded and verified NMU_DATA (see §3.3).
>    
>
> From the first block at or after H_cat for which the snapshot block 
> commitment condition in §2.4 holds, nodes MUST enforce the consensus rule 
> in §4, using the NMU classification defined above. No reindex or UTXO 
> rewrite is required for activation; NMU classification can be applied as an 
> overlay on top of the existing UTXO database.
>
>
> Implementations MAY, as an optimization, perform a one-time pass over 
> their UTXO set after activation to:
>
>
>
>    - 
>    
>    Set Coin.NMU = 1 for all UTXOs that satisfy the NMU predicate; and/or
>    
>
>
>    - 
>    
>    Physically delete such UTXOs from the UTXO database (see §5).
>    
>
> Such a pass is a local optimization and not required for consensus, 
> provided the on-the-fly NMU classification via NMU_DATA would yield the 
> same results.
>
>
> 3.3 NMU membership structure: Binary Fuse Filter + exclusion list
>
>
> This BIP does not require nodes to redo initial block download or reindex 
> the chain in order to enforce NMU classification. Instead, it commits to a 
> canonical membership structure NMU_DATA which encodes NMUSet_snap in a 
> compact form.
>
>
> 3.3.1 Canonical outpoint encoding
>
>
> For all purposes related to NMU_DATA (filter construction, querying, and 
> the exclusion list), an outpoint (txid, vout) is encoded as a fixed 36-byte 
> key.
>
>
> txid_le (bytes 0–31): the 32-byte transaction ID in little-endian order, 
> matching the internal uint256 representation used by Bitcoin Core and 
> similar implementations.
>
> vout_le (bytes 32–35): the 4-byte output index, serialized as a 
> little-endian unsigned 32-bit integer (e.g. 0 -> 00 00 00 00, 1 -> 01 00 00 
> 00, 256 -> 00 01 00 00).
>
>
> This encoding is normative for NMU_DATA. All compliant implementations 
> MUST use exactly this encoding when querying the filter or the exclusion 
> list.
>
>
> 3.3.2 NMU_DATA serialization
>
>
> NMU_DATA is a single binary blob. All integer fields are little-endian and 
> appear in the following order:
>
>
>
>    - 
>    
>    MAGIC (4 bytes): ASCII string "NMU1".
>    - 
>    
>    VERSION (1 byte): format version (initially 0x01).
>    - 
>    
>    SNAP_HEIGHT (4 bytes): block height H_snap.
>    - 
>    
>    SNAP_HASH (32 bytes): block hash at H_snap (must match SNAP_BLOCK_HASH 
>    from section §2.4).
>    - 
>    
>    FILTER_SEED (8 bytes): 64-bit seed used by the Binary Fuse Filter hash 
>    functions.
>    - 
>    
>    FILTER_LEN (4 bytes): length in bytes of FILTER_DATA.
>    - 
>    
>    FILTER_DATA (FILTER_LEN bytes): raw Binary Fuse Filter data.
>    - 
>    
>    FP_COUNT (4 bytes): number of false-positive entries.
>    - 
>    
>    FP_ENTRIES (FP_COUNT × 36 bytes): lexicographically sorted array of 
>    canonical 36-byte outpoint encodings that are not in NMUSet_snap but would 
>    otherwise match the filter.
>    - 
>    
>    CHECKSUM (32 bytes): SHA256d of all preceding bytes from MAGIC through 
>    the last FP_ENTRY.
>    
>
> The SHA256d of the entire NMU_DATA blob is called NMU_DATA_HASH and is 
> treated as a consensus constant compiled into node software.
>
>
> A node MUST NOT enforce the NMU consensus rule unless NMU_DATA passes its 
> internal CHECKSUM validation and SHA256d(NMU_DATA) equals NMU_DATA_HASH.
>
>
> 3.3.3 Binary Fuse Filter query
>
>
> The filter is a static Binary Fuse Filter over 36-byte keys with 8-bit 
> fingerprints, giving an approximate false-positive rate of about 1/256.
>
>
> For a given key, a deterministic hash function derived from FILTER_SEED 
> maps the 36-byte key to three byte positions inside FILTER_DATA and to an 
> 8-bit fingerprint. A membership query reads the three bytes at those 
> positions, XORs them, and compares the result to the fingerprint. If they 
> match, the filter reports the key as “probably present”.
>
>
> The exact mapping from a 36-byte key to three positions and an 8-bit 
> fingerprint, and the interpretation of FILTER_DATA, MUST follow a single, 
> fully specified algorithm (for example, a pinned “binary fuse filter” 
> reference implementation). How FILTER_DATA was constructed is not 
> consensus-critical; only the query algorithm and the fixed contents of 
> NMU_DATA are consensus-critical.
>
>
> 3.3.4 False positive exclusion list
>
>
> Because the Binary Fuse Filter is probabilistic, some UTXOs that are not 
> in NMUSet_snap will still be reported as present at H_snap. During snapshot 
> construction, the false positive exclusion list FP_EXCLUDE is computed by 
> enumerating all UTXOs at H_snap that are not in NMUSet_snap, testing each 
> with the filter, collecting those that match, and sorting their 36-byte 
> keys lexicographically to form FP_ENTRIES.
>
>
> At runtime, FP_EXCLUDE is treated as an override: if an outpoint’s 
> canonical key appears in FP_EXCLUDE, that outpoint MUST be treated as 
> non-NMU, regardless of the filter result.
>
>
> 3.3.5 Membership query (is_nmu)
>
>
> Given a UTXO u at outpoint (txid, vout), with value(u) and height(u), 
> nodes evaluate the NMU membership predicate is_nmu(u) as follows.
>
>
> First, UTXOs outside the NMU window are never NMUs. If height(u) is less 
> than H_min_NMU or greater than H_snap, is_nmu(u) is false.
>
>
> Second, very large UTXOs are always treated as monetary. If value(u) is 
> greater than or equal to VALUE_MAX_NMU, is_nmu(u) is false.
>
>
> For the remaining UTXOs, the node computes key = canonical_encode(txid, 
> vout) using the 36-byte encoding defined in section 3.3.1. If key appears 
> in FP_EXCLUDE (using binary search over the sorted FP_ENTRIES array), 
> is_nmu(u) is false. Otherwise, the node queries the Binary Fuse Filter with 
> key. If and only if the filter reports the key as present, is_nmu(u) is 
> true.
>
>
> Within the domain H_min_NMU ≤ height(u) ≤ H_snap and value(u) < 
> VALUE_MAX_NMU, this predicate exactly matches membership in NMUSet_snap: 
> every UTXO in NMUSet_snap is reported as NMU, and every UTXO outside 
> NMUSet_snap is reported as non-NMU, with no false positives and no false 
> negatives.
>
>
> 4. New consensus rule
>
>
> The rule in this section is enforced only when the snapshot block 
> commitment condition from §2.4 holds and NMU_DATA has been successfully 
> verified.
>
>
> From the first block at or after H_cat that follows activation:
>
>
> Rule: Forbidden spending of NMUs
>
>
> A transaction is invalid if any of its inputs refers to an outpoint (txid, 
> vout) such that the corresponding UTXO u satisfies is_nmu(u) = true as 
> defined in §3.3.5 (equivalently, has NMU = 1).
>
>
> Formally, when validating a transaction input:
>
>
>
>    - 
>    
>    Let (txid, vout) be the input outpoint.
>    
>
>
>    - 
>    
>    Let u = Coin(txid, vout) be the referenced UTXO as seen by the node at 
>    the time of validation.
>    
>
>
>    - 
>    
>    If u does not exist: reject as usual (unchanged behavior).
>    
>
>
>    - 
>    
>    Otherwise, if is_nmu(u) = true, then the transaction MUST be rejected 
>    as invalid.
>    
>
> This rule applies:
>
>
>
>    - 
>    
>    To mempool acceptance.
>    
>
>
>    - 
>    
>    To block validation.
>    
>
>
>    - 
>    
>    To all future reorg scenarios, provided the snapshot commitment in 
>    §2.4 remains satisfied.
>    
>
> 5. UTXO set removal and pruning
>
>
> Because NMUs are permanently unspendable after activation, they can be 
> dropped from the spendable UTXO set.
>
>
> 5.1 Logical removal
>
>
> Implementations MUST treat UTXOs with is_nmu(u) = true (or NMU = 1) as 
> non-existent for the purpose of:
>
>
>
>    - 
>    
>    Satisfying transaction inputs (they can never be used).
>    
>
>
>    - 
>    
>    Fee calculations, coin selection, wallet balances, etc.
>    
>
> 5.2 Physical pruning (optional)
>
>
> Nodes that operate with -prune=1 (or similar backwards-compatible pruning 
> configuration) MAY:
>
>
>
>    - 
>    
>    Omit NMUs from the on-disk UTXO set.
>    
>
>
>    - 
>    
>    Remove any previously persisted NMUs during a compaction / cleanup 
>    pass by running is_nmu(u) on each UTXO and deleting those that return true.
>    
>
> This proposal does not require pruned nodes to discard raw historical 
> blocks. It only authorizes pruning of UTXO entries that are permanently 
> unspendable due to the NMU rule.
>
>
> Non-pruned nodes (full archival nodes) MAY continue to store historical 
> blocks and full transaction data as usual. This preserves archival access 
> to inscription / stamp data while still neutralizing it economically.
>
>
> Rationale
>
>
> This BIP makes minimal changes to the consensus surface. It adds no new 
> opcodes and does not expand Bitcoin’s scripting language or 
> programmability. Instead, it introduces a single new consensus concept: a 
> binary classification that marks some existing UTXOs as permanently 
> unspendable Non-Monetary UTXOs (NMUs). In that sense, it is closer to a 
> one-time reclassification of a subset of UTXOs than an ongoing change to 
> Bitcoin’s programming model.
>
>
> External indexers, determinism, and reproducibility
>
>
> Instead of re-implementing complex inscription and stamp classification 
> rules in Bitcoin clients, this BIP relies on mature tools that are already 
> used by the non-monetary data community, specifically Ord and Stamps. Exact 
> versions of these indexers are specified and pinned by commit so that their 
> behavior is deterministic. The NMU set is defined in terms of chain data as 
> seen through these specified indexers, rather than as an arbitrary 
> hard-coded list of UTXOs. This keeps the consensus rule grounded in 
> chain-derived information while avoiding the need to embed inscription 
> logic directly in Bitcoin client software.
>
>
> Fixed snapshot vs future formats
>
>
> By scoping the NMU classification to what Ord 0.24.0 and Stamps (at a 
> pinned commit) can see at the snapshot height H_snap, this proposal 
> neutralizes the existing inscription and stamp economy on day one without 
> importing evolving, open-ended classification rules into consensus. It 
> treats the snapshot as a fixed historical boundary and leaves future NMU 
> formats and mitigation strategies as a separate question for policy or for 
> future BIPs. If further action is desired on post-snapshot NMU formats, the 
> community can consider additional updates or separate proposals without 
> expanding the scope of this one.
>
>
> UTXO set size and overhead
>
>
> Because all NMUs become permanently unspendable under this proposal, they 
> can be removed from the UTXO set, which reduces its size. The new storage 
> overhead introduced by The Cat is dominated by the global membership 
> structure NMU_DATA, which consists of a Binary Fuse Filter over NMUSet_snap 
> plus a correction list of false positives. For a plausible NMU count on the 
> order of 50 million, the filter occupies roughly 9 bits per element (≈ 56 
> MB), and the exclusion list adds around 15–20 MB before compression, for an 
> uncompressed size on the order of 70–80 MB and an expected compressed size 
> of roughly 40–50 MB.
>
>
> This is small relative to typical UTXO set sizes and to the on-disk 
> savings from pruning tens of millions of dust-sized NMUs. Per-UTXO storage 
> overhead remains a single NMU bit if implementations choose to materialize 
> it in the database; the rest of the classification data is stored once per 
> node.
>
>
> Censorship resistance and scope
>
>
> Bitcoin’s censorship resistance is primarily concerned with the ability to 
> move monetary value without trusted intermediaries. This proposal 
> intentionally targets non-monetary uses of the chain (inscriptions, stamps, 
> and similar schemes) and leaves ordinary monetary transfers untouched. 
> Reasonable people may still describe permanently disabling some UTXOs as a 
> form of censorship; the distinction this BIP draws is between money and 
> arbitrary data storage.
>
>
> The same type of mechanism could in principle be abused to target 
> arbitrary UTXOs, which is why this proposal deliberately scopes itself to a 
> one-time, transparently derived set of dust-sized non-monetary outputs. Any 
> attempt to apply similar techniques to ordinary monetary UTXOs would be 
> highly contentious and would require explicit social consensus from users, 
> miners, and economic nodes. In other words, this mechanism does not lower 
> the technical or social barriers to censoring ordinary monetary activity; 
> any such censorship would still require its own explicit, contentious 
> change in consensus rules.
>
>
> The classification rules on which The Cat relies are deliberately narrow 
> and mechanical. An output is marked as an NMU only if it is (a) identified 
> by the pinned Ord/Stamps rules as carrying a non-monetary artifact at 
> H_snap, (b) dust-sized, below the VALUE_MAX_NMU threshold, and (c) within 
> the defined height window. The intent is that no ordinary monetary UTXOs 
> fall into NMUSet_snap; any such inclusion would be treated as an error in 
> the snapshot construction and grounds to regenerate NMU_DATA before 
> activation, not as an acceptable trade-off. The 1,000-sat value limit 
> serves as an additional hard guardrail against accidentally classifying 
> normally-sized wallet outputs.
>
>
> Centralization and trust model for NMU generation
>
>
> Anyone can independently generate the list of NMUs. It is incumbent on 
> people to do so if they wish to minimize the trust required to run a fully 
> validating node. The criteria for which outputs are designated as NMUs are 
> necessarily known and established by virtue of how prevalent and open the 
> targeted data protocols are.
>
>
> It is valid to worry that fewer than 100% of node runners will regenerate 
> the NMU list themselves, somewhat increasing the overall trust placed in 
> third parties compared to today. However, this concern applies specifically 
> to a “blacklist of UTXOs,” which is precisely the area where scrutiny is 
> highest. That scrutiny should help ensure that enough independent parties 
> index and attest to the contents of NMUSet_snap to exceed any reasonable 
> threshold of credulity.
>
>
> A useful analogy is the GUIX-based reproducible build process. Bitcoiners 
> accept that many users will only run node binaries they download, rather 
> than compiling from source and independently verifying the code. Compiled 
> binaries must exist for Bitcoin to maintain decentralization in practice. 
> This is an aspect of trust inherent in Bitcoin: we accept some technical 
> limitations of users and employ a practical, trust-minimized workaround 
> that, while not perfect, is better than the alternative.
>
>
> If there were to be an issue with widely used binaries, it would become 
> ubiquitously known very quickly. Similarly, if The Cat were flawed and 
> began targeting monetary UTXOs, this would be detected well before 
> activation, and the necessary fixes applied, with any distortion of its 
> motivation exposed and corrected.
>
>
> Backward compatibility
>
>
> This proposal is a consensus-changing soft fork. Legacy nodes that do not 
> implement The Cat will continue to accept blocks that spend NMUs as valid, 
> while nodes that do implement The Cat will reject such blocks as invalid. 
> As with any soft fork, activation requires clear opt-in from miners and 
> from economic nodes. After activation, miners and other block proposers 
> must avoid including transactions that spend NMUs, because such blocks will 
> be rejected by upgraded nodes. Wallets and applications that track 
> inscriptions, BRC-20 assets, and related schemes will observe that NMUs 
> become permanently unspendable under The Cat and that balances associated 
> with those UTXOs are no longer movable under the activated ruleset.
>
>
> FAQ
>
>
> Do node operators need to run Ord or Stamps?
>
>
> No. The Cat does not require ordinary node operators to run Ord or Stamps, 
> or to understand their rules in detail. Those indexers are cited as 
> normative references for the inscription and stamp classification logic 
> used to derive NMUSet_snap. In practice, nodes only need the canonical 
> NMU_DATA blob and its hash NMU_DATA_HASH to enforce the consensus rule.
>
>
> Anyone who wishes to independently verify NMUSet_snap can:
>
>
> inspect the open-source Ord and Stamps code,
>
>
> or re-implement equivalent classification rules,
>
>
> and confirm that the derived set of NMU outpoints matches the set encoded 
> in NMU_DATA (i.e., the blob whose hash is NMU_DATA_HASH).
>
>
> What rules do the reference indexers actually use to decide which UTXOs 
> are NMUs?
>
>
> This BIP does not re-specify the full Ord and Stamps protocols, but in 
> broad terms:
>
>
> Ord 0.24.0 (inscriptions).
>
> According to the classification rules implemented in Ord 0.24.0 at commit 
> 5d2fbbe64b362cd6c30d6901e50cbe80084761f8, witness data is scanned for 
> “inscription envelopes” in Taproot script paths. An inscription envelope is 
> an OP_FALSE OP_IF … OP_ENDIF block containing data pushes that start with 
> the ASCII tag ord and encode a content type and body. When those rules are 
> applied to the best chain up to height H_snap, each recognized inscription 
> is associated with a particular outpoint (txid, vout) (typically the first 
> satoshi of a reveal transaction input, or as directed by the pointer field 
> in the protocol). OrdNMUSet is defined as the set of outpoints that Ord 
> 0.24.0 would classify as carrying inscriptions at H_snap under these rules.
>
>
> Stamps (BTC Stamps).
>
> According to the classification rules implemented in the pinned BTC Stamps 
> indexer, Counterparty transactions are inspected for a STAMP:-prefixed 
> base64 string in the description field, which encodes image data. The 
> Stamps rules then map this metadata to specific dust-sized bare multisig 
> outputs in the underlying Bitcoin transactions. When those rules are 
> applied to the best chain up to height H_snap, each recognized stamp is 
> associated with one or more outpoints (txid, vout). StampsNMUSet is defined 
> as the set of outpoints that this reference Stamps implementation would 
> classify as containing such stamp-style embedded assets at H_snap.
>
>
> Won’t spammers just make workarounds and spam anyway?
>
>
> The Cat targets the financial incentive to create spam. It is almost 
> impossible to stop a determined user from adding data to Bitcoin. The more 
> realistic mitigation is to remove the ability to reliably trade these 
> embedded assets as if they were durable, on-chain economic objects. Once 
> the existing inscription and stamp economies are neutralized and their 
> dust-sized carrier UTXOs are fenced off, the motivation to spam the chain 
> in the same way is greatly reduced.
>
>
> Can’t users just spend their NMUs after the snapshot, removing them from 
> the list?
>
>
> Yes, a user can attempt to evade The Cat by spending an NMU after the 
> snapshot. However, there are tens of millions of such outputs. It would be 
> extremely costly, in aggregate fees, to move them all. If large-scale 
> evasion occurs before activation, it is straightforward to take a new 
> snapshot, forcing evaders to pay again if they want to continue. This is 
> the nature of the cat-and-mouse game: attempts to pre-empt the snapshot by 
> moving large numbers of NMUs impose substantial costs on those outputs, 
> while the network can respond by choosing an appropriate snapshot height if 
> necessary.
>
>
> What if some of my UTXOs contain “rare sats”? Won’t those get “Catted”?
>
>
> In this BIP, “rare sats” can be understood as satoshis that Ord and 
> similar indexers are treating as non-monetary artifacts. The Cat does not 
> look at individual sat numbers or “rarity” directly; it only classifies 
> whole UTXOs via the is_nmu(u) predicate, using NMUSet_snap and a simple 
> value/height guardrail.
>
>
> A UTXO can only be classified as an NMU if all of the following are true:
>
>
>
>    - 
>    
>    it falls inside the NMU height window,
>    
>
>
>    - 
>    
>    its value is strictly below VALUE_MAX_NMU (currently 1,000 sats), and
>    
>
>
>    - 
>    
>    its outpoint appears in NMUSet_snap as identified by Ord/Stamps at the 
>    snapshot.
>    
>
> Anything at or above VALUE_MAX_NMU is always treated as a normal monetary 
> output, regardless of what Ord says about the sats inside it.
>
>
> In practice, if you once interacted with Ord and those “rare sats” now 
> live inside a normal-sized wallet UTXO (1,000 sats or more), this proposal 
> does not touch that UTXO at all. It remains fully spendable under the 
> ordinary rules. The only “rare sats” that get Catted are those deliberately 
> parked in tiny dust outputs below the VALUE_MAX_NMU threshold, and that Ord 
> (or Stamps) is already treating as non-monetary artifacts at H_snap. Those 
> dust UTXOs are precisely the objects this proposal is targeting to fence 
> off from the monetary UTXO set.
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/e3658771-128f-4e45-9465-860baf466ee4n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 123547 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] Re: Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-12 18:10  0% ` [bitcoindev] " Jonathan Voss
@ 2025-12-12 20:17  0%   ` Defenwycke
  0 siblings, 0 replies; 200+ results
From: Defenwycke @ 2025-12-12 20:17 UTC (permalink / raw)
  To: Jonathan Voss; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 5466 bytes --]

Hello Jonathan,

Thanks for the thoughtful feedback — that makes sense.

I started with a very narrow definition mostly to make the invariant
obvious and easy to reason about. Every DustSweep tx should monotonically
reduce the UTXO set and never meaningfully compete with the fee market. As
long as that holds, I’m not particularly attached to any one parameter.

I agree that requiring 100% dust inputs and exactly one output is probably
overly strict in practice. A majority dust requirement and an output/input
ratio cap seem like reasonable ways to preserve the incentive (net UTXO
reduction) while making it more usable for real wallets.

My main goal here is to give operators something that’s safe to run and
predictable in behaviour — cheap, bounded, and only active when blockspace
would otherwise go unused. I’m happy to adjust thresholds or relax
constraints as long as those properties remain intact.

Appreciate you taking the time to look at it.

Kind regards,

Defenwycke

On Fri, Dec 12, 2025 at 6:16 PM Jonathan Voss <k98kurz@gmail.com> wrote:

> Interesting proposal. Something like that would be helpful, but perhaps it
> would be more useful if it was not quite so narrowly defined. For example,
> instead of requiring all inputs be dust-class UTXO, it could require a
> minimum of 80% dust-class inputs; instead of exactly one output, it could
> be max_outputs = floor(n_inputs / 5) to keep a maximum output/input ratio
> of 1/5. This could allow for better aggregation of dust outputs into
> economically meaningful, monetary outputs than the narrower definition
> while maintaining the incentives for meaningfully reducing UTXO set size.
>
> I would run this policy on my node. Hashers should ultimately be okay with
> this policy since someone among them also has to run full nodes, and it
> would provide an additional (albeit very small) fee source when block space
> demand is low.
>
> On Thursday, December 11, 2025 at 8:34:16 AM UTC-5 defenwycke wrote:
>
>> Hello list,
>>
>> I’ve been working on a small policy proposal that aims to address one
>> very specific problem: the long-term accumulation of uneconomical dust in
>> the UTXO set.
>>
>> The idea is intentionally narrow. I’m calling it DustSweep, and it
>> defines a strict, non-abusable class of transactions that nodes may relay
>> and miners may include only when the mempool and block space are
>> underutilised. The goal is to give wallets a predictable way to compact
>> dust without introducing new spam vectors or touching consensus.
>>
>> A DustSweep transaction has the following properties:
>>
>>    -
>>
>>    all inputs are “dust-class” UTXOs
>>    -
>>
>>    only standard scripts (P2PKH / P2WPKH / P2TR)
>>    -
>>
>>    exactly one output
>>    -
>>
>>    no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
>>    -
>>
>>    minimum of 5 inputs (to ensure meaningful UTXO reduction)
>>    -
>>
>>    size capped
>>    -
>>
>>    it pays a flat 1 sat per input fee
>>
>> Nodes place these in a small, separate sub-mempool. They’re only accepted
>> when the normal mempool is <50% full, and they’re automatically evicted if
>> normal mempool usage hits 95%. Miners can include them up to a small weight
>> fraction (I suggest ~5%) but only after filling the block with regular
>> fee-paying transactions. The intention is that DustSweep never competes
>> with the fee market and only uses blockspace that would otherwise go unused.
>>
>> This is all policy-level. No consensus changes, no new transaction
>> format, nothing that affects validation. Nodes that don’t implement it
>> simply treat these as low-fee transactions and drop them.
>>
>> The motivation is straightforward: we don’t currently have a safe,
>> structured way to compact dust, and the UTXO set continues to grow from
>> outputs that are effectively unspendable under normal fee conditions.
>> DustSweep tries to offer a predictable, opt-in mechanism for wallets to
>> clean that up without creating any new attack surface.
>>
>> Full draft BIP and supporting documents are here:
>>
>> https://github.com/defenwycke/bip-dust-sweep
>>
>> I’d appreciate feedback on the policy details, thresholds, and whether
>> this fits within what node operators and wallet developers would actually
>> want to use. Happy to adjust parameters if there’s a better balance point.
>>
>> Kind regards,
>>
>> Defenwycke
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/382cefe0-4ac0-43d7-919b-c56fad0a9b27n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/382cefe0-4ac0-43d7-919b-c56fad0a9b27n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAOj3_X8GtJtAgcvvPZW2Ovxt31CzGtn9tssqTSZ4BeQ_bL6pxg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 6401 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: Draft BIP: DustSweep – policy-only UTXO dust compaction
  2025-12-11 12:53  3% [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction defenwycke
@ 2025-12-12 18:10  0% ` Jonathan Voss
  2025-12-12 20:17  0%   ` Defenwycke
  2025-12-12 22:49  0% ` [bitcoindev] " Murch
  1 sibling, 1 reply; 200+ results
From: Jonathan Voss @ 2025-12-12 18:10 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3781 bytes --]

Interesting proposal. Something like that would be helpful, but perhaps it 
would be more useful if it was not quite so narrowly defined. For example, 
instead of requiring all inputs be dust-class UTXO, it could require a 
minimum of 80% dust-class inputs; instead of exactly one output, it could 
be max_outputs = floor(n_inputs / 5) to keep a maximum output/input ratio 
of 1/5. This could allow for better aggregation of dust outputs into 
economically meaningful, monetary outputs than the narrower definition 
while maintaining the incentives for meaningfully reducing UTXO set size.

I would run this policy on my node. Hashers should ultimately be okay with 
this policy since someone among them also has to run full nodes, and it 
would provide an additional (albeit very small) fee source when block space 
demand is low.

On Thursday, December 11, 2025 at 8:34:16 AM UTC-5 defenwycke wrote:

> Hello list,
>
> I’ve been working on a small policy proposal that aims to address one very 
> specific problem: the long-term accumulation of uneconomical dust in the 
> UTXO set.
>
> The idea is intentionally narrow. I’m calling it DustSweep, and it defines 
> a strict, non-abusable class of transactions that nodes may relay and 
> miners may include only when the mempool and block space are underutilised. 
> The goal is to give wallets a predictable way to compact dust without 
> introducing new spam vectors or touching consensus.
>
> A DustSweep transaction has the following properties:
>
>    - 
>    
>    all inputs are “dust-class” UTXOs
>    - 
>    
>    only standard scripts (P2PKH / P2WPKH / P2TR)
>    - 
>    
>    exactly one output
>    - 
>    
>    no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
>    - 
>    
>    minimum of 5 inputs (to ensure meaningful UTXO reduction)
>    - 
>    
>    size capped
>    - 
>    
>    it pays a flat 1 sat per input fee
>    
> Nodes place these in a small, separate sub-mempool. They’re only accepted 
> when the normal mempool is <50% full, and they’re automatically evicted if 
> normal mempool usage hits 95%. Miners can include them up to a small weight 
> fraction (I suggest ~5%) but only after filling the block with regular 
> fee-paying transactions. The intention is that DustSweep never competes 
> with the fee market and only uses blockspace that would otherwise go unused.
>
> This is all policy-level. No consensus changes, no new transaction format, 
> nothing that affects validation. Nodes that don’t implement it simply treat 
> these as low-fee transactions and drop them.
>
> The motivation is straightforward: we don’t currently have a safe, 
> structured way to compact dust, and the UTXO set continues to grow from 
> outputs that are effectively unspendable under normal fee conditions. 
> DustSweep tries to offer a predictable, opt-in mechanism for wallets to 
> clean that up without creating any new attack surface.
>
> Full draft BIP and supporting documents are here:
>
> https://github.com/defenwycke/bip-dust-sweep
>
> I’d appreciate feedback on the policy details, thresholds, and whether 
> this fits within what node operators and wallet developers would actually 
> want to use. Happy to adjust parameters if there’s a better balance point.
>
> Kind regards,
>
> Defenwycke
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/382cefe0-4ac0-43d7-919b-c56fad0a9b27n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 4272 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction
@ 2025-12-11 12:53  3% defenwycke
  2025-12-12 18:10  0% ` [bitcoindev] " Jonathan Voss
  2025-12-12 22:49  0% ` [bitcoindev] " Murch
  0 siblings, 2 replies; 200+ results
From: defenwycke @ 2025-12-11 12:53 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 2740 bytes --]

Hello list,

I’ve been working on a small policy proposal that aims to address one very 
specific problem: the long-term accumulation of uneconomical dust in the 
UTXO set.

The idea is intentionally narrow. I’m calling it DustSweep, and it defines 
a strict, non-abusable class of transactions that nodes may relay and 
miners may include only when the mempool and block space are underutilised. 
The goal is to give wallets a predictable way to compact dust without 
introducing new spam vectors or touching consensus.

A DustSweep transaction has the following properties:

   - 
   
   all inputs are “dust-class” UTXOs
   - 
   
   only standard scripts (P2PKH / P2WPKH / P2TR)
   - 
   
   exactly one output
   - 
   
   no metadata at all (no OP_RETURN, inscriptions, TLVs, etc.)
   - 
   
   minimum of 5 inputs (to ensure meaningful UTXO reduction)
   - 
   
   size capped
   - 
   
   it pays a flat 1 sat per input fee
   
Nodes place these in a small, separate sub-mempool. They’re only accepted 
when the normal mempool is <50% full, and they’re automatically evicted if 
normal mempool usage hits 95%. Miners can include them up to a small weight 
fraction (I suggest ~5%) but only after filling the block with regular 
fee-paying transactions. The intention is that DustSweep never competes 
with the fee market and only uses blockspace that would otherwise go unused.

This is all policy-level. No consensus changes, no new transaction format, 
nothing that affects validation. Nodes that don’t implement it simply treat 
these as low-fee transactions and drop them.

The motivation is straightforward: we don’t currently have a safe, 
structured way to compact dust, and the UTXO set continues to grow from 
outputs that are effectively unspendable under normal fee conditions. 
DustSweep tries to offer a predictable, opt-in mechanism for wallets to 
clean that up without creating any new attack surface.

Full draft BIP and supporting documents are here:

https://github.com/defenwycke/bip-dust-sweep

I’d appreciate feedback on the policy details, thresholds, and whether this 
fits within what node operators and wallet developers would actually want 
to use. Happy to adjust parameters if there’s a better balance point.

Kind regards,

Defenwycke

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/b47aa182-bca7-44d7-bed1-f3cc2df30ef5n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 3129 bytes --]

^ permalink raw reply	[relevance 3%]

* Re: [bitcoindev] Re: Reducing RAM requirements with dynamic dust
  2025-12-10 19:33  0%   ` Erik Aronesty
@ 2025-12-10 20:44  0%     ` Eric Voskuil
  2025-12-12 22:22  1%       ` 'uuowwpevskfcordh' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Eric Voskuil @ 2025-12-10 20:44 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 16411 bytes --]

Hi Erik,

It's a good idea, that's why we did it.

Libbitcoin is a set of libraries, libbitcoin-database being one of 4 that 
make up node (system, network, database, and node).  (libbitcoin-server is 
an additional library that adds comprehensive set of client-server 
interfaces, making the node useful.) libbitcoin-database is an 
implementation of a simple query interface (defined as a c++ class) over a 
backing store. The store is a templated collection of tables. The tables 
are mmap-based head and body files used to construct multimaps, hashmaps, 
arraymaps, arrays, and blobs. We mock the tables using 
std::vector<uint8_t>, mock the store using the the mocked tables, and test 
most of the query interface using the mock store. The structure is highly 
relational, and surrogate keys are exposed to the caller for optimized 
navigation.

This is an isolated and clear storage abstraction layer. All validation is 
performed within the chain:: classes (e.g. block, header, tx, input, 
script, etc.) defined in the base level libbitcoin-system. There is no 
validator coupling to the store. The store retains chain objects, indexes, 
and validation state for headers/blocks and txs as they progress through a 
state machine. There is no utxo table, just natural relations between 
objects, indexed and related. Validation correctness of course requires 
store fidelity, but is totally decoupled from it. We validate blocks 
concurrently, queueing up 50,000 blocks at a time by default (e.g. with 50k 
threads we would validate all at the same time).

The store could be replaced with no impact to the query interface (as we 
already do in testing). So it's not really accurate to imply that 
libbitcoin's validation is tied to mmap or even append-only. Pruning could 
be implemented in the existing model for example. The existing store could 
be replaced with something simple and light like SQLite, or a full RDBMS. 
We had some interns working the SQLite approach last summer. That would be 
more specialized for low performance scenarios, where the custom database 
targets ultra high performance. 

With sufficient RAM there is never SSD access. The store can sync up and 
just live in RAM, never touching a disk. Since it is append only, it's very 
low impact on SSDs. As the store builds, no table body byte is ever 
re-written. Table heads are hashmaps buckets, small and dynamic. It 
performs live automated/manual snapshotting, automatic fault 
detection/recovery on restart, automated disk-full pause/restart, and 
supports hot backup. Query performance is phenomenal. A warm node can query 
the full 5.2 million output Electrum query (very complex relations) in 15 
seconds on my 2.1GHz workstation. But at the low end, an off-the-shelf 
store is sufficient. A clear interface and swappable store makes a lot of 
sense.

A large utxo set makes no difference in this design. There are no 
operational problems associated with it. Given the recent fuss about it, I 
figured it was worth putting some detail behind it here. This is not 
theoretical, at this point we are only working on server (client-server 
interfaces). The utxo set size is a complete non-issue.

e

On Wednesday, December 10, 2025 at 2:48:43 PM UTC-5 Erik Aronesty wrote:

> Core: Keep UTXO lookups in RAM as much as possible. This gives predictable 
> validation under adversarial load and trades memory for protection from 
> pathological disk latency.
> Libbitcoin: Represent history in append-only, memory-mapped files. Let the 
> operating system decide what stays hot. Accept more disk I/O in return for 
> simpler concurrency and no explicit UTXO map.
>
> To create 200 million outputs as an attack, the cost is roughly 48 BTC 
> based on eight vb per output at low feerates.
>
> Given the operational problems that a very large UTXO set creates, it may 
> be worthwhile to develop a clear storage abstraction layer. 
>
> The goal would be to ensure that validation correctness does not depend on 
> the transitional behavior of a specific storage engine. 
>
> Once the validator has a well defined storage contract, alternate backends 
> such as a libbitcoin style layout could exist as storage formats while 
> still benefiting from the reliability of the rest of the Bitcoin 
> implementation.
> (I would be interested in something like this.)
>
> On Wed, Dec 10, 2025 at 10:34 AM Eric Voskuil <er...@voskuil.org> wrote:
>
>> > Given the increasing RAM requirements, due to the increasing UTXO set
>>
>> I have been assured multiple times recently that this problem does not 
>> exist in Bitcoin Core. I'm not sure about that, but I can say for sure that 
>> this is not a problem in Libbitcoin and is therefore not problem with the 
>> Bitcoin protocol.
>>
>> Best,
>> Eric
>>
>> On Wednesday, December 10, 2025 at 1:12:31 PM UTC-5 uuowwpevskfcordh 
>> wrote:
>>
>>> Given the increasing RAM requirements, due to the increasing UTXO set, I 
>>> suggest seeing the UTXO set size as a controlled variable. A feedback 
>>> mechanism sets a dynamic dust level, below from which UTXOs are 
>>> removed/discarded and thus freeing RAM.
>>>
>>> Below is an overview essay better expressed by grok, which can also be 
>>> seen in here:
>>> https://hackmd.io/P-2lzGb8TiC86IOE3OGiYA?view
>>>
>>> # Enhancing Bitcoin's Scalability: A PID-Inspired Approach to Managing 
>>> UTXO Set Growth
>>>
>>> ## Abstract
>>>
>>> Bitcoin’s UTXO set is currently an unbounded accumulator that risks 
>>> long-term centralization as node RAM requirements grow without limit. 
>>> Existing fee incentives have proven insufficient against sustained 
>>> low-value output creation (e.g., inscriptions, tokenized assets, dust-heavy 
>>> protocols). This article proposes a soft-fork mechanism that treats UTXO 
>>> set size as a controlled variable: a slowly rising target size is defined, 
>>> and a PID-style feedback controller, updated every difficulty epoch, 
>>> dynamically raises a minimum-value floor beneath which old UTXOs become 
>>> unspendable. The result is bounded, predictable growth of the UTXO set with 
>>> ample warning periods, no hard caps on monetary use, and strong resistance 
>>> to bloat attacks—all while remaining fully compatible with a soft-fork 
>>> deployment.
>>>
>>> ## Introduction
>>>
>>> Bitcoin, the pioneering decentralized digital currency, operates as a 
>>> complex dynamic system governed by consensus rules that ensure security, 
>>> immutability, and permissionless participation. At its core, Bitcoin 
>>> maintains a distributed ledger known as the blockchain, which records all 
>>> transactions in a sequence of blocks. Each transaction involves inputs and 
>>> outputs: inputs reference previously unspent outputs from prior 
>>> transactions, while outputs create new spendable units called Unspent 
>>> Transaction Outputs (UTXOs). The UTXO set represents the aggregate state of 
>>> all currently spendable coins in the network, serving as a critical 
>>> component for transaction validation and wallet management.
>>>
>>> As Bitcoin has evolved, the UTXO set has grown significantly, influenced 
>>> by increasing adoption and diverse usage patterns. This growth, while 
>>> indicative of the network's vitality, poses challenges to its long-term 
>>> scalability and decentralization. Nodes—computers that validate and relay 
>>> transactions—must store and process the entire UTXO set in memory for 
>>> efficient operation, which can strain resources such as random access 
>>> memory (RAM). Unchecked expansion could lead to higher barriers for running 
>>> full nodes, potentially centralizing control among fewer, well-resourced 
>>> participants. This article explores a proposed mechanism to address these 
>>> concerns: an adaptive control system inspired by 
>>> Proportional-Integral-Derivative (PID) feedback principles, designed to 
>>> impose bounded growth on the UTXO set while preserving Bitcoin's 
>>> foundational properties.
>>>
>>> ## Motivations for UTXO Set Management
>>>
>>> To appreciate the need for enhanced UTXO management, it is essential to 
>>> understand the current status quo and its vulnerabilities. Bitcoin's design 
>>> prioritizes efficiency and security through mechanisms like block size 
>>> limits, which cap the amount of data added per block (approximately 1 MB 
>>> base size, expandable to about 4 MB with Segregated Witness). These limits 
>>> help control the overall blockchain size, ensuring predictable hardware 
>>> requirements for storage on hard disk drives (HDDs). Similarly, the 
>>> difficulty adjustment algorithm maintains a consistent block production 
>>> rate of roughly one every 10 minutes by dynamically scaling the 
>>> computational challenge for miners based on network hashrate.
>>>
>>> However, the UTXO set lacks comparable built-in constraints. It 
>>> accumulates as users create new outputs—often in small 
>>> denominations—without a mandatory mechanism to consolidate or prune them. 
>>> This can result from various activities, including high-frequency 
>>> microtransactions, the embedding of non-monetary data (such as through 
>>> protocols like Ordinals, which inscribe arbitrary information onto 
>>> satoshis, Bitcoin's smallest unit), or the anchoring of sidechain or 
>>> tokenized assets that leverage Bitcoin's security but operate externally. 
>>> While these innovations expand Bitcoin's utility, they can inadvertently 
>>> increase the UTXO count disproportionately to their economic value, 
>>> elevating transaction fees during congestion and raising operational costs 
>>> for nodes.
>>>
>>> Existing incentives, such as transaction fees, partially mitigate this 
>>> by encouraging users to consolidate low-value UTXOs to avoid higher costs. 
>>> Yet, these market-driven forces are insufficient against sustained patterns 
>>> of low-value output creation, particularly when driven by external systems 
>>> that do not bear the full cost of network maintenance. Over time, this 
>>> leads to bloat: as of recent estimates, the UTXO set exceeds several 
>>> gigabytes when loaded into memory, complicating node synchronization and 
>>> validation. Without intervention, projected growth could undermine 
>>> decentralization, as fewer individuals or entities might afford to 
>>> participate fully in the network.
>>>
>>> The motivation for reform, therefore, stems from a desire to balance 
>>> innovation with sustainability. An ideal solution would allow gradual UTXO 
>>> expansion to accommodate genuine monetary usage while introducing feedback 
>>> to curb excessive accumulation, all without compromising Bitcoin's 
>>> permissionless nature or requiring a hard fork that could fragment the 
>>> community.
>>>
>>> ## A PID-Inspired Feedback Controller for UTXO Control
>>>
>>> Drawing from control theory, which studies how systems maintain desired 
>>> behaviors through feedback, this proposal introduces a dynamic mechanism to 
>>> regulate UTXO set size. PID controllers, widely used in engineering for 
>>> processes like temperature regulation or autopilot systems, combine three 
>>> terms: Proportional \(P\) for immediate response to errors, Integral (I) 
>>> for correcting persistent deviations, and Derivative (D) for anticipating 
>>> changes based on trends. In Bitcoin's context, we adapt this framework to 
>>> compute a minimum value threshold—or "floor"—below which UTXOs become 
>>> ineligible for spending, effectively deprecating them over time.
>>>
>>> Importantly, this deprecation rule constitutes a soft fork: it restricts 
>>> the set of valid transactions to a subset of those previously allowed, 
>>> without introducing new capabilities. Upgraded nodes enforce the rule, 
>>> rejecting deprecated UTXOs as invalid inputs, ensuring backward 
>>> compatibility and minimizing disruption.
>>>
>>> ### Mechanism Overview
>>>
>>> The controller activates at each difficulty adjustment epoch, 
>>> approximately every two weeks (2016 blocks), aligning with Bitcoin's 
>>> existing periodic recalibrations for predictability.
>>>
>>> 1. **Define a Target UTXO Size Trajectory**: Establish an increasing 
>>> maximum target for the UTXO set size, denoted as $T(t)$, where $t$ 
>>> represents the epoch number. This could grow sublinearly with time or 
>>> blockchain height to reflect organic adoption— for instance, $T(t) = U_0 
>>> \cdot (1 + r)^t$, with $U_0$ as the initial size and $r$ a small annual 
>>> growth rate (e.g., less than 1%). This permits expansion while preventing 
>>> unbounded divergence.
>>>
>>> 2. **Measure the Error**: At each epoch, compute the error $e(t) = S(t) 
>>> - T(t)$, where $S(t)$ is the current UTXO set size (measured by count or 
>>> aggregate data footprint).
>>>
>>> 3. **Compute the Floor Adjustment**: Apply the PID formula to adjust the 
>>> value floor $F(t)$:
>>>    
>>>     $$  \Delta F(t) = K_p \cdot e(t) + K_i \cdot \sum_{k=0}^{t} e(k) + 
>>> K_d \cdot \frac{e(t) - e(t-1)}{\Delta t} $$
>>>    
>>>    Here, $K_p, K_i, K_d$ are tunable gains, selected conservatively 
>>> through simulations to ensure stability (e.g., using root locus analysis to 
>>> avoid oscillatory or unstable roots in the system's characteristic 
>>> equation). The floor $F(t)$ increases only if $e(t) > 0$, applying to UTXOs 
>>> below this threshold.
>>>
>>> 4. **Deprecation Process**: UTXOs with values below $F(t)$ are marked as 
>>> unspendable in future transactions. To provide fairness and predictability, 
>>> implement a grace period (e.g., 4-12 months) during which owners can 
>>> consolidate affected UTXOs.
>>>
>>> 5. **Safeguards and Tuning**: Incorporate clamps on $\Delta F(t)$ 
>>> (similar to Bitcoin's difficulty adjustment limits) to prevent abrupt 
>>> changes that might cause network congestion from mass consolidations. 
>>> Periodic reviews of gains and targets via community governance would adapt 
>>> the system to evolving conditions.
>>>
>>> ### Stability and Dynamics Considerations
>>>
>>> In dynamic systems terms, the UTXO set can be modeled as an integrator 
>>> accumulating outputs minus expenditures. The PID controller introduces 
>>> negative feedback to dampen this accumulation, driving $S(t)$ toward $T(t)$ 
>>> with minimal overshoot. Simulations would verify robustness against 
>>> adversarial scenarios, such as deliberate UTXO spam, ensuring the system's 
>>> poles remain in the stable region of the complex plane.
>>>
>>> Potential benefits include reduced node resource demands, lower fees 
>>> during normal operation, and enhanced decentralization. Risks, such as 
>>> over-deprecation affecting small holders, can be mitigated through careful 
>>> gain selection.
>>>
>>> ## Conclusion
>>>
>>> This PID-inspired approach offers a principled path to managing 
>>> Bitcoin's UTXO set, fostering sustainable growth while upholding core 
>>> principles. By integrating feedback control, Bitcoin can evolve as a 
>>> resilient dynamic system, better equipped for widespread adoption. Further 
>>> research, including detailed modeling and community discourse, is essential 
>>> to refine and potentially implement such enhancements.
>>>
>>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/97065ca0-662b-4a5d-90c5-7607db41ba2fn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 18917 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: Reducing RAM requirements with dynamic dust
  2025-12-10 18:30  0% ` [bitcoindev] " Eric Voskuil
@ 2025-12-10 19:33  0%   ` Erik Aronesty
  2025-12-10 20:44  0%     ` Eric Voskuil
  0 siblings, 1 reply; 200+ results
From: Erik Aronesty @ 2025-12-10 19:33 UTC (permalink / raw)
  To: Eric Voskuil; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 12716 bytes --]

Core: Keep UTXO lookups in RAM as much as possible. This gives predictable
validation under adversarial load and trades memory for protection from
pathological disk latency.
Libbitcoin: Represent history in append-only, memory-mapped files. Let the
operating system decide what stays hot. Accept more disk I/O in return for
simpler concurrency and no explicit UTXO map.

To create 200 million outputs as an attack, the cost is roughly 48 BTC
based on eight vb per output at low feerates.

Given the operational problems that a very large UTXO set creates, it may
be worthwhile to develop a clear storage abstraction layer.

The goal would be to ensure that validation correctness does not depend on
the transitional behavior of a specific storage engine.

Once the validator has a well defined storage contract, alternate backends
such as a libbitcoin style layout could exist as storage formats while
still benefiting from the reliability of the rest of the Bitcoin
implementation.
(I would be interested in something like this.)

On Wed, Dec 10, 2025 at 10:34 AM Eric Voskuil <eric@voskuil.org> wrote:

> > Given the increasing RAM requirements, due to the increasing UTXO set
>
> I have been assured multiple times recently that this problem does not
> exist in Bitcoin Core. I'm not sure about that, but I can say for sure that
> this is not a problem in Libbitcoin and is therefore not problem with the
> Bitcoin protocol.
>
> Best,
> Eric
>
> On Wednesday, December 10, 2025 at 1:12:31 PM UTC-5 uuowwpevskfcordh wrote:
>
>> Given the increasing RAM requirements, due to the increasing UTXO set, I
>> suggest seeing the UTXO set size as a controlled variable. A feedback
>> mechanism sets a dynamic dust level, below from which UTXOs are
>> removed/discarded and thus freeing RAM.
>>
>> Below is an overview essay better expressed by grok, which can also be
>> seen in here:
>> https://hackmd.io/P-2lzGb8TiC86IOE3OGiYA?view
>>
>> # Enhancing Bitcoin's Scalability: A PID-Inspired Approach to Managing
>> UTXO Set Growth
>>
>> ## Abstract
>>
>> Bitcoin’s UTXO set is currently an unbounded accumulator that risks
>> long-term centralization as node RAM requirements grow without limit.
>> Existing fee incentives have proven insufficient against sustained
>> low-value output creation (e.g., inscriptions, tokenized assets, dust-heavy
>> protocols). This article proposes a soft-fork mechanism that treats UTXO
>> set size as a controlled variable: a slowly rising target size is defined,
>> and a PID-style feedback controller, updated every difficulty epoch,
>> dynamically raises a minimum-value floor beneath which old UTXOs become
>> unspendable. The result is bounded, predictable growth of the UTXO set with
>> ample warning periods, no hard caps on monetary use, and strong resistance
>> to bloat attacks—all while remaining fully compatible with a soft-fork
>> deployment.
>>
>> ## Introduction
>>
>> Bitcoin, the pioneering decentralized digital currency, operates as a
>> complex dynamic system governed by consensus rules that ensure security,
>> immutability, and permissionless participation. At its core, Bitcoin
>> maintains a distributed ledger known as the blockchain, which records all
>> transactions in a sequence of blocks. Each transaction involves inputs and
>> outputs: inputs reference previously unspent outputs from prior
>> transactions, while outputs create new spendable units called Unspent
>> Transaction Outputs (UTXOs). The UTXO set represents the aggregate state of
>> all currently spendable coins in the network, serving as a critical
>> component for transaction validation and wallet management.
>>
>> As Bitcoin has evolved, the UTXO set has grown significantly, influenced
>> by increasing adoption and diverse usage patterns. This growth, while
>> indicative of the network's vitality, poses challenges to its long-term
>> scalability and decentralization. Nodes—computers that validate and relay
>> transactions—must store and process the entire UTXO set in memory for
>> efficient operation, which can strain resources such as random access
>> memory (RAM). Unchecked expansion could lead to higher barriers for running
>> full nodes, potentially centralizing control among fewer, well-resourced
>> participants. This article explores a proposed mechanism to address these
>> concerns: an adaptive control system inspired by
>> Proportional-Integral-Derivative (PID) feedback principles, designed to
>> impose bounded growth on the UTXO set while preserving Bitcoin's
>> foundational properties.
>>
>> ## Motivations for UTXO Set Management
>>
>> To appreciate the need for enhanced UTXO management, it is essential to
>> understand the current status quo and its vulnerabilities. Bitcoin's design
>> prioritizes efficiency and security through mechanisms like block size
>> limits, which cap the amount of data added per block (approximately 1 MB
>> base size, expandable to about 4 MB with Segregated Witness). These limits
>> help control the overall blockchain size, ensuring predictable hardware
>> requirements for storage on hard disk drives (HDDs). Similarly, the
>> difficulty adjustment algorithm maintains a consistent block production
>> rate of roughly one every 10 minutes by dynamically scaling the
>> computational challenge for miners based on network hashrate.
>>
>> However, the UTXO set lacks comparable built-in constraints. It
>> accumulates as users create new outputs—often in small
>> denominations—without a mandatory mechanism to consolidate or prune them.
>> This can result from various activities, including high-frequency
>> microtransactions, the embedding of non-monetary data (such as through
>> protocols like Ordinals, which inscribe arbitrary information onto
>> satoshis, Bitcoin's smallest unit), or the anchoring of sidechain or
>> tokenized assets that leverage Bitcoin's security but operate externally.
>> While these innovations expand Bitcoin's utility, they can inadvertently
>> increase the UTXO count disproportionately to their economic value,
>> elevating transaction fees during congestion and raising operational costs
>> for nodes.
>>
>> Existing incentives, such as transaction fees, partially mitigate this by
>> encouraging users to consolidate low-value UTXOs to avoid higher costs.
>> Yet, these market-driven forces are insufficient against sustained patterns
>> of low-value output creation, particularly when driven by external systems
>> that do not bear the full cost of network maintenance. Over time, this
>> leads to bloat: as of recent estimates, the UTXO set exceeds several
>> gigabytes when loaded into memory, complicating node synchronization and
>> validation. Without intervention, projected growth could undermine
>> decentralization, as fewer individuals or entities might afford to
>> participate fully in the network.
>>
>> The motivation for reform, therefore, stems from a desire to balance
>> innovation with sustainability. An ideal solution would allow gradual UTXO
>> expansion to accommodate genuine monetary usage while introducing feedback
>> to curb excessive accumulation, all without compromising Bitcoin's
>> permissionless nature or requiring a hard fork that could fragment the
>> community.
>>
>> ## A PID-Inspired Feedback Controller for UTXO Control
>>
>> Drawing from control theory, which studies how systems maintain desired
>> behaviors through feedback, this proposal introduces a dynamic mechanism to
>> regulate UTXO set size. PID controllers, widely used in engineering for
>> processes like temperature regulation or autopilot systems, combine three
>> terms: Proportional \(P\) for immediate response to errors, Integral (I)
>> for correcting persistent deviations, and Derivative (D) for anticipating
>> changes based on trends. In Bitcoin's context, we adapt this framework to
>> compute a minimum value threshold—or "floor"—below which UTXOs become
>> ineligible for spending, effectively deprecating them over time.
>>
>> Importantly, this deprecation rule constitutes a soft fork: it restricts
>> the set of valid transactions to a subset of those previously allowed,
>> without introducing new capabilities. Upgraded nodes enforce the rule,
>> rejecting deprecated UTXOs as invalid inputs, ensuring backward
>> compatibility and minimizing disruption.
>>
>> ### Mechanism Overview
>>
>> The controller activates at each difficulty adjustment epoch,
>> approximately every two weeks (2016 blocks), aligning with Bitcoin's
>> existing periodic recalibrations for predictability.
>>
>> 1. **Define a Target UTXO Size Trajectory**: Establish an increasing
>> maximum target for the UTXO set size, denoted as $T(t)$, where $t$
>> represents the epoch number. This could grow sublinearly with time or
>> blockchain height to reflect organic adoption— for instance, $T(t) = U_0
>> \cdot (1 + r)^t$, with $U_0$ as the initial size and $r$ a small annual
>> growth rate (e.g., less than 1%). This permits expansion while preventing
>> unbounded divergence.
>>
>> 2. **Measure the Error**: At each epoch, compute the error $e(t) = S(t) -
>> T(t)$, where $S(t)$ is the current UTXO set size (measured by count or
>> aggregate data footprint).
>>
>> 3. **Compute the Floor Adjustment**: Apply the PID formula to adjust the
>> value floor $F(t)$:
>>
>>     $$  \Delta F(t) = K_p \cdot e(t) + K_i \cdot \sum_{k=0}^{t} e(k) +
>> K_d \cdot \frac{e(t) - e(t-1)}{\Delta t} $$
>>
>>    Here, $K_p, K_i, K_d$ are tunable gains, selected conservatively
>> through simulations to ensure stability (e.g., using root locus analysis to
>> avoid oscillatory or unstable roots in the system's characteristic
>> equation). The floor $F(t)$ increases only if $e(t) > 0$, applying to UTXOs
>> below this threshold.
>>
>> 4. **Deprecation Process**: UTXOs with values below $F(t)$ are marked as
>> unspendable in future transactions. To provide fairness and predictability,
>> implement a grace period (e.g., 4-12 months) during which owners can
>> consolidate affected UTXOs.
>>
>> 5. **Safeguards and Tuning**: Incorporate clamps on $\Delta F(t)$
>> (similar to Bitcoin's difficulty adjustment limits) to prevent abrupt
>> changes that might cause network congestion from mass consolidations.
>> Periodic reviews of gains and targets via community governance would adapt
>> the system to evolving conditions.
>>
>> ### Stability and Dynamics Considerations
>>
>> In dynamic systems terms, the UTXO set can be modeled as an integrator
>> accumulating outputs minus expenditures. The PID controller introduces
>> negative feedback to dampen this accumulation, driving $S(t)$ toward $T(t)$
>> with minimal overshoot. Simulations would verify robustness against
>> adversarial scenarios, such as deliberate UTXO spam, ensuring the system's
>> poles remain in the stable region of the complex plane.
>>
>> Potential benefits include reduced node resource demands, lower fees
>> during normal operation, and enhanced decentralization. Risks, such as
>> over-deprecation affecting small holders, can be mitigated through careful
>> gain selection.
>>
>> ## Conclusion
>>
>> This PID-inspired approach offers a principled path to managing Bitcoin's
>> UTXO set, fostering sustainable growth while upholding core principles. By
>> integrating feedback control, Bitcoin can evolve as a resilient dynamic
>> system, better equipped for widespread adoption. Further research,
>> including detailed modeling and community discourse, is essential to refine
>> and potentially implement such enhancements.
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2B6%3D%3Dq%3DWa4LRWRHdiOfcV6RPtYdCzVjY%2BJJrmEgbR6c2A%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 14712 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: Reducing RAM requirements with dynamic dust
  2025-12-06 16:08  1% [bitcoindev] Reducing RAM requirements with dynamic dust 'uuowwpevskfcordh' via Bitcoin Development Mailing List
@ 2025-12-10 18:30  0% ` Eric Voskuil
  2025-12-10 19:33  0%   ` Erik Aronesty
  0 siblings, 1 reply; 200+ results
From: Eric Voskuil @ 2025-12-10 18:30 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10949 bytes --]

> Given the increasing RAM requirements, due to the increasing UTXO set

I have been assured multiple times recently that this problem does not 
exist in Bitcoin Core. I'm not sure about that, but I can say for sure that 
this is not a problem in Libbitcoin and is therefore not problem with the 
Bitcoin protocol.

Best,
Eric

On Wednesday, December 10, 2025 at 1:12:31 PM UTC-5 uuowwpevskfcordh wrote:

> Given the increasing RAM requirements, due to the increasing UTXO set, I 
> suggest seeing the UTXO set size as a controlled variable. A feedback 
> mechanism sets a dynamic dust level, below from which UTXOs are 
> removed/discarded and thus freeing RAM.
>
> Below is an overview essay better expressed by grok, which can also be 
> seen in here:
> https://hackmd.io/P-2lzGb8TiC86IOE3OGiYA?view
>
> # Enhancing Bitcoin's Scalability: A PID-Inspired Approach to Managing 
> UTXO Set Growth
>
> ## Abstract
>
> Bitcoin’s UTXO set is currently an unbounded accumulator that risks 
> long-term centralization as node RAM requirements grow without limit. 
> Existing fee incentives have proven insufficient against sustained 
> low-value output creation (e.g., inscriptions, tokenized assets, dust-heavy 
> protocols). This article proposes a soft-fork mechanism that treats UTXO 
> set size as a controlled variable: a slowly rising target size is defined, 
> and a PID-style feedback controller, updated every difficulty epoch, 
> dynamically raises a minimum-value floor beneath which old UTXOs become 
> unspendable. The result is bounded, predictable growth of the UTXO set with 
> ample warning periods, no hard caps on monetary use, and strong resistance 
> to bloat attacks—all while remaining fully compatible with a soft-fork 
> deployment.
>
> ## Introduction
>
> Bitcoin, the pioneering decentralized digital currency, operates as a 
> complex dynamic system governed by consensus rules that ensure security, 
> immutability, and permissionless participation. At its core, Bitcoin 
> maintains a distributed ledger known as the blockchain, which records all 
> transactions in a sequence of blocks. Each transaction involves inputs and 
> outputs: inputs reference previously unspent outputs from prior 
> transactions, while outputs create new spendable units called Unspent 
> Transaction Outputs (UTXOs). The UTXO set represents the aggregate state of 
> all currently spendable coins in the network, serving as a critical 
> component for transaction validation and wallet management.
>
> As Bitcoin has evolved, the UTXO set has grown significantly, influenced 
> by increasing adoption and diverse usage patterns. This growth, while 
> indicative of the network's vitality, poses challenges to its long-term 
> scalability and decentralization. Nodes—computers that validate and relay 
> transactions—must store and process the entire UTXO set in memory for 
> efficient operation, which can strain resources such as random access 
> memory (RAM). Unchecked expansion could lead to higher barriers for running 
> full nodes, potentially centralizing control among fewer, well-resourced 
> participants. This article explores a proposed mechanism to address these 
> concerns: an adaptive control system inspired by 
> Proportional-Integral-Derivative (PID) feedback principles, designed to 
> impose bounded growth on the UTXO set while preserving Bitcoin's 
> foundational properties.
>
> ## Motivations for UTXO Set Management
>
> To appreciate the need for enhanced UTXO management, it is essential to 
> understand the current status quo and its vulnerabilities. Bitcoin's design 
> prioritizes efficiency and security through mechanisms like block size 
> limits, which cap the amount of data added per block (approximately 1 MB 
> base size, expandable to about 4 MB with Segregated Witness). These limits 
> help control the overall blockchain size, ensuring predictable hardware 
> requirements for storage on hard disk drives (HDDs). Similarly, the 
> difficulty adjustment algorithm maintains a consistent block production 
> rate of roughly one every 10 minutes by dynamically scaling the 
> computational challenge for miners based on network hashrate.
>
> However, the UTXO set lacks comparable built-in constraints. It 
> accumulates as users create new outputs—often in small 
> denominations—without a mandatory mechanism to consolidate or prune them. 
> This can result from various activities, including high-frequency 
> microtransactions, the embedding of non-monetary data (such as through 
> protocols like Ordinals, which inscribe arbitrary information onto 
> satoshis, Bitcoin's smallest unit), or the anchoring of sidechain or 
> tokenized assets that leverage Bitcoin's security but operate externally. 
> While these innovations expand Bitcoin's utility, they can inadvertently 
> increase the UTXO count disproportionately to their economic value, 
> elevating transaction fees during congestion and raising operational costs 
> for nodes.
>
> Existing incentives, such as transaction fees, partially mitigate this by 
> encouraging users to consolidate low-value UTXOs to avoid higher costs. 
> Yet, these market-driven forces are insufficient against sustained patterns 
> of low-value output creation, particularly when driven by external systems 
> that do not bear the full cost of network maintenance. Over time, this 
> leads to bloat: as of recent estimates, the UTXO set exceeds several 
> gigabytes when loaded into memory, complicating node synchronization and 
> validation. Without intervention, projected growth could undermine 
> decentralization, as fewer individuals or entities might afford to 
> participate fully in the network.
>
> The motivation for reform, therefore, stems from a desire to balance 
> innovation with sustainability. An ideal solution would allow gradual UTXO 
> expansion to accommodate genuine monetary usage while introducing feedback 
> to curb excessive accumulation, all without compromising Bitcoin's 
> permissionless nature or requiring a hard fork that could fragment the 
> community.
>
> ## A PID-Inspired Feedback Controller for UTXO Control
>
> Drawing from control theory, which studies how systems maintain desired 
> behaviors through feedback, this proposal introduces a dynamic mechanism to 
> regulate UTXO set size. PID controllers, widely used in engineering for 
> processes like temperature regulation or autopilot systems, combine three 
> terms: Proportional \(P\) for immediate response to errors, Integral (I) 
> for correcting persistent deviations, and Derivative (D) for anticipating 
> changes based on trends. In Bitcoin's context, we adapt this framework to 
> compute a minimum value threshold—or "floor"—below which UTXOs become 
> ineligible for spending, effectively deprecating them over time.
>
> Importantly, this deprecation rule constitutes a soft fork: it restricts 
> the set of valid transactions to a subset of those previously allowed, 
> without introducing new capabilities. Upgraded nodes enforce the rule, 
> rejecting deprecated UTXOs as invalid inputs, ensuring backward 
> compatibility and minimizing disruption.
>
> ### Mechanism Overview
>
> The controller activates at each difficulty adjustment epoch, 
> approximately every two weeks (2016 blocks), aligning with Bitcoin's 
> existing periodic recalibrations for predictability.
>
> 1. **Define a Target UTXO Size Trajectory**: Establish an increasing 
> maximum target for the UTXO set size, denoted as $T(t)$, where $t$ 
> represents the epoch number. This could grow sublinearly with time or 
> blockchain height to reflect organic adoption— for instance, $T(t) = U_0 
> \cdot (1 + r)^t$, with $U_0$ as the initial size and $r$ a small annual 
> growth rate (e.g., less than 1%). This permits expansion while preventing 
> unbounded divergence.
>
> 2. **Measure the Error**: At each epoch, compute the error $e(t) = S(t) - 
> T(t)$, where $S(t)$ is the current UTXO set size (measured by count or 
> aggregate data footprint).
>
> 3. **Compute the Floor Adjustment**: Apply the PID formula to adjust the 
> value floor $F(t)$:
>    
>     $$  \Delta F(t) = K_p \cdot e(t) + K_i \cdot \sum_{k=0}^{t} e(k) + K_d 
> \cdot \frac{e(t) - e(t-1)}{\Delta t} $$
>    
>    Here, $K_p, K_i, K_d$ are tunable gains, selected conservatively 
> through simulations to ensure stability (e.g., using root locus analysis to 
> avoid oscillatory or unstable roots in the system's characteristic 
> equation). The floor $F(t)$ increases only if $e(t) > 0$, applying to UTXOs 
> below this threshold.
>
> 4. **Deprecation Process**: UTXOs with values below $F(t)$ are marked as 
> unspendable in future transactions. To provide fairness and predictability, 
> implement a grace period (e.g., 4-12 months) during which owners can 
> consolidate affected UTXOs.
>
> 5. **Safeguards and Tuning**: Incorporate clamps on $\Delta F(t)$ (similar 
> to Bitcoin's difficulty adjustment limits) to prevent abrupt changes that 
> might cause network congestion from mass consolidations. Periodic reviews 
> of gains and targets via community governance would adapt the system to 
> evolving conditions.
>
> ### Stability and Dynamics Considerations
>
> In dynamic systems terms, the UTXO set can be modeled as an integrator 
> accumulating outputs minus expenditures. The PID controller introduces 
> negative feedback to dampen this accumulation, driving $S(t)$ toward $T(t)$ 
> with minimal overshoot. Simulations would verify robustness against 
> adversarial scenarios, such as deliberate UTXO spam, ensuring the system's 
> poles remain in the stable region of the complex plane.
>
> Potential benefits include reduced node resource demands, lower fees 
> during normal operation, and enhanced decentralization. Risks, such as 
> over-deprecation affecting small holders, can be mitigated through careful 
> gain selection.
>
> ## Conclusion
>
> This PID-inspired approach offers a principled path to managing Bitcoin's 
> UTXO set, fostering sustainable growth while upholding core principles. By 
> integrating feedback control, Bitcoin can evolve as a resilient dynamic 
> system, better equipped for widespread adoption. Further research, 
> including detailed modeling and community discourse, is essential to refine 
> and potentially implement such enhancements.
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/049858f4-28ba-4ffb-8966-f8bef09035b7n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 12734 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] A safe way to remove objectionable content from the blockchain (now on GitHub)
@ 2025-12-06  6:41  1% Lazy Fair
  0 siblings, 0 replies; 200+ results
From: Lazy Fair @ 2025-12-06  6:41 UTC (permalink / raw)
  To: Bitcoin Development Mailing List
  Cc: erik, ekaggata, pete, saintwenhao, eth3rs, gmaxwell

[-- Attachment #1: Type: text/plain, Size: 4166 bytes --]

I've started putting together some ideas around how to remove objectionable
content from the blockchain. The very early work-in-progress description is
on GitHub: https://github.com/laissez-faire-btc/safe-remove

I won't include all the details here, because there's necessarily a lot to
cover, but the basic design goals I've aimed to address are something like
this:

* optional - each node gets to decide what to remove, if anything
* safe - provably no harm is done to those not choosing to use it, and any
cost or risk to those using it is well understood, minimal, and mitigated
* full node functionality - a node that does remove content can still do
everything it could have done otherwise, without relying on anyone else
* retrospective - content that exists on the blockchain today
(pre-implementation) can be removed later (post-implementation)
* trustless, verifiable, permissionless - control messages enabling data to
be removed are simple verifiable statements of fact that can be written by
anybody
* lightweight - minimal changes and impact to policy, consensus,
implementation, usage, the economy
* granularity, associativity, commutability, idempotence - the least
possible data is removed, and ordering is inconsequential
* transferable - nodes that choose to remove objectionable content can
share those blocks (with content removed) with others who hold the same
objection, so that the receiver may never even momentarily hold the
objectionable content

Being design goals, these are probably not all achievable. I'll need your
help to work through all the details.

I have some more notes I just haven't written up yet, so I'm keen for your
input please, on what direction I should take, questions I should answer,
aspects I should consider or detail further, etc.

In the absence of any feedback, I'll be proceeding with either documenting
the threat model, or a bit of a literature review - starting with the
following, which I've found but not yet dived into:
* "Redactable Blockchain in the Permissionless Setting", Deuber et al,
2019, https://arxiv.org/abs/1901.03206
* "Redactable Blockchain: Comprehensive Review, Mechanisms, Challenges,
Open Issues and Future Research Directions", Abd Ali et al, 2023,
https://www.mdpi.com/1999-5903/15/1/35

P.S: I've had some issues with this mailing list. I emailed a few weeks
back and my first email got through (
https://groups.google.com/g/bitcoindev/c/sn3-Uc1yPx4), but my second and
third didn't. I think Google has labelled me a spammer (or, hopefully, just
the previous thread, as spam). There was one obvious spam message to the
thread (most people won't have seen it because it will definitely have
failed at moderation, but I did get it because it was reply-all - not just
to the mailing list). From what I can see, Gmail classifies spam only at
the conversation / thread level, not the individual email level - it's all
or nothing. I found this out myself when I tried to mark that one email as
spam, and the entire thread (including my original email) got marked as
spam and moved to my spam folder. So it's possible others in the
conversation unintentional marked my email as spam. Regardless of specific,
my emails under that thread are certainly being blocked somehow. If anyone
knows more about this, please reach out. Hopefully this email isn't a waste
of time - but if it doesn't show up on the mailing list archive, I guess
I'll have to create a new email address and try again.

I've cc'd others from that thread, into this new one. Thank you to those
who provided feedback there. You may not have seen my replies, but please
know that I was paying attention! Certainly, you'll see the design is
significantly changed and improved.

Laissez faire, laissez passer.

Let it be, let it go.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CABHzxrjfvyBRD7sG9rngvDhr9cfzLEQibn4bup_J8pz7UHQpqA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 5398 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] Reducing RAM requirements with dynamic dust
@ 2025-12-06 16:08  1% 'uuowwpevskfcordh' via Bitcoin Development Mailing List
  2025-12-10 18:30  0% ` [bitcoindev] " Eric Voskuil
  0 siblings, 1 reply; 200+ results
From: 'uuowwpevskfcordh' via Bitcoin Development Mailing List @ 2025-12-06 16:08 UTC (permalink / raw)
  To: bitcoindev@googlegroups.com

[-- Attachment #1: Type: text/plain, Size: 10005 bytes --]

Given the increasing RAM requirements, due to the increasing UTXO set, I suggest seeing the UTXO set size as a controlled variable. A feedback mechanism sets a dynamic dust level, below from which UTXOs are removed/discarded and thus freeing RAM.

Below is an overview essay better expressed by grok, which can also be seen in here:
https://hackmd.io/P-2lzGb8TiC86IOE3OGiYA?view

# Enhancing Bitcoin's Scalability: A PID-Inspired Approach to Managing UTXO Set Growth

## Abstract

Bitcoin’s UTXO set is currently an unbounded accumulator that risks long-term centralization as node RAM requirements grow without limit. Existing fee incentives have proven insufficient against sustained low-value output creation (e.g., inscriptions, tokenized assets, dust-heavy protocols). This article proposes a soft-fork mechanism that treats UTXO set size as a controlled variable: a slowly rising target size is defined, and a PID-style feedback controller, updated every difficulty epoch, dynamically raises a minimum-value floor beneath which old UTXOs become unspendable. The result is bounded, predictable growth of the UTXO set with ample warning periods, no hard caps on monetary use, and strong resistance to bloat attacks—all while remaining fully compatible with a soft-fork deployment.

## Introduction

Bitcoin, the pioneering decentralized digital currency, operates as a complex dynamic system governed by consensus rules that ensure security, immutability, and permissionless participation. At its core, Bitcoin maintains a distributed ledger known as the blockchain, which records all transactions in a sequence of blocks. Each transaction involves inputs and outputs: inputs reference previously unspent outputs from prior transactions, while outputs create new spendable units called Unspent Transaction Outputs (UTXOs). The UTXO set represents the aggregate state of all currently spendable coins in the network, serving as a critical component for transaction validation and wallet management.

As Bitcoin has evolved, the UTXO set has grown significantly, influenced by increasing adoption and diverse usage patterns. This growth, while indicative of the network's vitality, poses challenges to its long-term scalability and decentralization. Nodes—computers that validate and relay transactions—must store and process the entire UTXO set in memory for efficient operation, which can strain resources such as random access memory (RAM). Unchecked expansion could lead to higher barriers for running full nodes, potentially centralizing control among fewer, well-resourced participants. This article explores a proposed mechanism to address these concerns: an adaptive control system inspired by Proportional-Integral-Derivative (PID) feedback principles, designed to impose bounded growth on the UTXO set while preserving Bitcoin's foundational properties.

## Motivations for UTXO Set Management

To appreciate the need for enhanced UTXO management, it is essential to understand the current status quo and its vulnerabilities. Bitcoin's design prioritizes efficiency and security through mechanisms like block size limits, which cap the amount of data added per block (approximately 1 MB base size, expandable to about 4 MB with Segregated Witness). These limits help control the overall blockchain size, ensuring predictable hardware requirements for storage on hard disk drives (HDDs). Similarly, the difficulty adjustment algorithm maintains a consistent block production rate of roughly one every 10 minutes by dynamically scaling the computational challenge for miners based on network hashrate.

However, the UTXO set lacks comparable built-in constraints. It accumulates as users create new outputs—often in small denominations—without a mandatory mechanism to consolidate or prune them. This can result from various activities, including high-frequency microtransactions, the embedding of non-monetary data (such as through protocols like Ordinals, which inscribe arbitrary information onto satoshis, Bitcoin's smallest unit), or the anchoring of sidechain or tokenized assets that leverage Bitcoin's security but operate externally. While these innovations expand Bitcoin's utility, they can inadvertently increase the UTXO count disproportionately to their economic value, elevating transaction fees during congestion and raising operational costs for nodes.

Existing incentives, such as transaction fees, partially mitigate this by encouraging users to consolidate low-value UTXOs to avoid higher costs. Yet, these market-driven forces are insufficient against sustained patterns of low-value output creation, particularly when driven by external systems that do not bear the full cost of network maintenance. Over time, this leads to bloat: as of recent estimates, the UTXO set exceeds several gigabytes when loaded into memory, complicating node synchronization and validation. Without intervention, projected growth could undermine decentralization, as fewer individuals or entities might afford to participate fully in the network.

The motivation for reform, therefore, stems from a desire to balance innovation with sustainability. An ideal solution would allow gradual UTXO expansion to accommodate genuine monetary usage while introducing feedback to curb excessive accumulation, all without compromising Bitcoin's permissionless nature or requiring a hard fork that could fragment the community.

## A PID-Inspired Feedback Controller for UTXO Control

Drawing from control theory, which studies how systems maintain desired behaviors through feedback, this proposal introduces a dynamic mechanism to regulate UTXO set size. PID controllers, widely used in engineering for processes like temperature regulation or autopilot systems, combine three terms: Proportional \(P\) for immediate response to errors, Integral (I) for correcting persistent deviations, and Derivative (D) for anticipating changes based on trends. In Bitcoin's context, we adapt this framework to compute a minimum value threshold—or "floor"—below which UTXOs become ineligible for spending, effectively deprecating them over time.

Importantly, this deprecation rule constitutes a soft fork: it restricts the set of valid transactions to a subset of those previously allowed, without introducing new capabilities. Upgraded nodes enforce the rule, rejecting deprecated UTXOs as invalid inputs, ensuring backward compatibility and minimizing disruption.

### Mechanism Overview

The controller activates at each difficulty adjustment epoch, approximately every two weeks (2016 blocks), aligning with Bitcoin's existing periodic recalibrations for predictability.

1. **Define a Target UTXO Size Trajectory**: Establish an increasing maximum target for the UTXO set size, denoted as $T(t)$, where $t$ represents the epoch number. This could grow sublinearly with time or blockchain height to reflect organic adoption— for instance, $T(t) = U_0 \cdot (1 + r)^t$, with $U_0$ as the initial size and $r$ a small annual growth rate (e.g., less than 1%). This permits expansion while preventing unbounded divergence.

2. **Measure the Error**: At each epoch, compute the error $e(t) = S(t) - T(t)$, where $S(t)$ is the current UTXO set size (measured by count or aggregate data footprint).

3. **Compute the Floor Adjustment**: Apply the PID formula to adjust the value floor $F(t)$:

$$ \Delta F(t) = K_p \cdot e(t) + K_i \cdot \sum_{k=0}^{t} e(k) + K_d \cdot \frac{e(t) - e(t-1)}{\Delta t} $$

Here, $K_p, K_i, K_d$ are tunable gains, selected conservatively through simulations to ensure stability (e.g., using root locus analysis to avoid oscillatory or unstable roots in the system's characteristic equation). The floor $F(t)$ increases only if $e(t) > 0$, applying to UTXOs below this threshold.

4. **Deprecation Process**: UTXOs with values below $F(t)$ are marked as unspendable in future transactions. To provide fairness and predictability, implement a grace period (e.g., 4-12 months) during which owners can consolidate affected UTXOs.

5. **Safeguards and Tuning**: Incorporate clamps on $\Delta F(t)$ (similar to Bitcoin's difficulty adjustment limits) to prevent abrupt changes that might cause network congestion from mass consolidations. Periodic reviews of gains and targets via community governance would adapt the system to evolving conditions.

### Stability and Dynamics Considerations

In dynamic systems terms, the UTXO set can be modeled as an integrator accumulating outputs minus expenditures. The PID controller introduces negative feedback to dampen this accumulation, driving $S(t)$ toward $T(t)$ with minimal overshoot. Simulations would verify robustness against adversarial scenarios, such as deliberate UTXO spam, ensuring the system's poles remain in the stable region of the complex plane.

Potential benefits include reduced node resource demands, lower fees during normal operation, and enhanced decentralization. Risks, such as over-deprecation affecting small holders, can be mitigated through careful gain selection.

## Conclusion
This PID-inspired approach offers a principled path to managing Bitcoin's UTXO set, fostering sustainable growth while upholding core principles. By integrating feedback control, Bitcoin can evolve as a resilient dynamic system, better equipped for widespread adoption. Further research, including detailed modeling and community discourse, is essential to refine and potentially implement such enhancements.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/Q4RLVZW6OK88aVcalvUK7KJJIKOXckKhB7a5zTN7LTxA-jzal3587k4yUiIMjcIBoqLI0eK4uQLZtjJGsbj1R8zsfaMDM-RGSw2V9KI6AAw%3D%40proton.me.

[-- Attachment #2: Type: text/html, Size: 11984 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-12-09 14:24  1%             ` waxwing/ AdamISZ
@ 2025-12-09 19:32  1%               ` Boris Nagaev
  0 siblings, 0 replies; 200+ results
From: Boris Nagaev @ 2025-12-09 19:32 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 8365 bytes --]

Hi waxwing/AdamISZ,

On incentives: agreed that "good" only matters if it's an equilibrium. The 
aim is to shape early design choices so the incentive-compatible 
equilibrium includes DA and forced publication, rather than slipping into a 
DA-weak equilibrium where only a few parties hold full data.

> what if mining was done just on an accumulator over the utxo set, instead 
of the utxo set itself?

If miners and nodes only see an UTXO accumulator, how do HTLCs survive? The 
HTLC success spend path needs the preimage to be revealed and readable. How 
does this fit in an accumulator-only mining model, and what forces 
publication so the payer can claim its incoming HTLC?

Best,
Boris

On Tuesday, December 9, 2025 at 11:29:24 AM UTC-3 waxwing/ AdamISZ wrote:

Hi Boris,

> To Peter: rather than trying to "defeat ZKP," maybe the pragmatic path 
is to shape any ZK/succinctness work so that the design itself carries 
the necessary data (e.g., preimages must be published on-chain and 
retrievable) and ships with strong data-availability guarantees (so 
raw tx/block data stays broadly accessible, not just proofs). If the 
"good" ZK system makes data availability a built-in feature, it can 
occupy the niche and leave less room for alternative designs that drop 
those guarantees. 

re: "a good ZK system makes data availability a built-in feature", I think 
this concept of "good" is not very relevant if it's counter to incentives 
(hence my earlier "Hmm" comment; incentives matter).
Meanwhile I find myself reflecting more on Peter's original point (how 
spectacularly deleterious to mining this could be, let alone the data 
availability stuff), and I'm wondering if we can just go radically in the 
opposite direction: what if mining was done just on an accumulator over the 
utxo set, instead of the utxo set itself? Complete redesign of the 
protocol, but .. possible, I think? Tx inputs would have to have set 
membership proofs. I wonder if anyone's done this particular analysis.

Cheers,
waxwing/AdamISZ

On Monday, December 8, 2025 at 2:59:14 PM UTC-3 Nagaev Boris wrote:

Hi waxwing/ AdamISZ, 

Peter's main concern is that ZKP-only validation can break HTLCs: if a 
spend is proven valid with a ZK proof but the actual transaction data 
(including the preimage) never needs to be revealed on-chain, the HTLC 
payer (the counterparty relying on that preimage) can't learn it and 
can't claim its incoming HTLC. That undermines Lightning's security 
because "proof of publication" collapses into "proof of validity 
without data availability." Any succinctness/ZK approach for Bitcoin 
has to preserve the guarantee that the preimage is actually published 
and readable. 

Related, if the network drifts toward relying on ZK proofs without 
simultaneously guaranteeing open access to raw blocks and 
transactions, block data can become gated by a few data providers. 
That is a data-availability risk that comes with any ZK deployment 
that omits strong DA, and it would erode self-sovereignty for routing 
nodes. Any practical ZK/succinctness design for Bitcoin needs strong 
data availability, so anyone can fetch raw transactions, not just 
validity proofs. 

To Peter: rather than trying to "defeat ZKP," maybe the pragmatic path 
is to shape any ZK/succinctness work so that the design itself carries 
the necessary data (e.g., preimages must be published on-chain and 
retrievable) and ships with strong data-availability guarantees (so 
raw tx/block data stays broadly accessible, not just proofs). If the 
"good" ZK system makes data availability a built-in feature, it can 
occupy the niche and leave less room for alternative designs that drop 
those guarantees. 

Best, 
Boris 

On Tue, Dec 2, 2025 at 10:05 AM waxwing/ AdamISZ <ekag...@gmail.com> wrote: 
> 
> (apologies to OP; we've drifted off topic here). Answers inline. 
> 
> 
> On Monday, December 1, 2025 at 5:36:55 AM UTC-3 Peter Todd wrote: 
> 
> On Sat, Nov 29, 2025 at 05:54:13AM -0800, waxwing/ AdamISZ wrote: 
> > Hi Peter, list, 
> > 
> > Interesting! 
> > 
> > One thought that springs to mind: attempts to ameliorate IBD with ZKP 
> > should not forget one thing: what we actually want here is 
succinctness, 
> > and not so much ZK. Think SNARK instead of ZkSNARK. 
> > Which is important; without the requirement for an actual ZK property 
for 
> > the protocol, you can have it have attached witness that is not secret. 
> 
> The Zero-Knowledge part is important to the goal in this specific 
use-case: 
> trying to prevent all arbitrary data publication. 
> 
> 
> Yes agreed. (with the strange caveat: the ZK property itself allows 
data-embedding almost by force; the reason Schnorr has a data embedding 
channel and BLS does not is precisely that BLS does not have a ZK property, 
which itself relates to the fact that it's deterministic (think: no nonce = 
no channel) .. the caveat is not super relevant to some kind of ZK-ed IBD 
thing, though, since that's compressing an unfathomable amount). 
> 
> <snip> 
> 
> 
> It's quite possible that ZKP's are, in the context of decentralized 
> blockchains, an exploit that will prove to be impossible to patch. 
Similar to 
> how merge mining is an economic exploit that may well be impossible to 
patch. 
> 
> Sometimes seemingly good ideas are ultimately killed by clever exploits. 
> 
> 
> I have a sneaking suspicion you're wrong here, but I can't justify it. 
(Hence 'interesting!'). Would love to hear others opinion on the topic. 
> 
> 
> > Take as contrast the opentimestamps model, where having proof 
> > that something was published, is the main functionality 
offered/required. 
> 
> Nope. OpenTimestamps does not use proof of publication at all. 
OpenTimestamps 
> is a commitment operation: proof that if A was changed, B would have to 
change 
> too. The vast majority of OTS timestamps are for private data that is 
never 
> published in any way. OTS simply shows that data *existed*. 
> 
> That seems like a good correction. So, tamper protection, using binding 
property of commitments .. and "proof of existence" is *one* possible 
function? Is that fair? 
> 
> 
> > I 
> > suppose there is another way to say it: the channel counterparty needs 
> > "proof of future publication" in contract setup. That's fair enough but 
> > it's a very different thing than getting a proof that something *was* 
> > published. 
> 
> It is not a meaningfully different thing. An HTLC is proof that in the 
event of 
> an uncooperative redemption, publication will happen. Slightly changing 
the 
> time it takes is irrelevant to the general concept. 
> 
> Concretely: unless you can propose a technical innovation that somehow 
turns 
> this pedantic nuance into a meaningfully different implementation, so 
what? 
> 
> 
> On reflection I don't see it as strange to make the distinction between 
the two: 1/ proof that something was published in the past and 2/ proof 
that conditional on event X occurring, data Y will be published. I guess 1/ 
is just, most realistically, a case of publishing raw, unhashed data on a 
blockchain, then the proof that that event occurred in the past is the 
onchain txs ( using op_return or w/e) themselves. As you pointed out, 
that's not what OTS is doing. Nor is it what an HTLC is doing, that's 2/. 
> 
> 
> -- 
> https://petertodd.org 'peter'[:-1]@petertodd.org 
> 
> -- 
> You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group. 
> To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com. 
> To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/91a40bf7-fe9e-43a1-85d1-5889d4b31a7fn%40googlegroups.com. 




-- 
Best regards, 
Boris Nagaev 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ec60219f-f2c7-4639-8c45-d3f3938241b7n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 10278 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-12-08 17:34  0%           ` Nagaev Boris
@ 2025-12-09 14:24  1%             ` waxwing/ AdamISZ
  2025-12-09 19:32  1%               ` Boris Nagaev
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2025-12-09 14:24 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 7574 bytes --]

Hi Boris,

> To Peter: rather than trying to "defeat ZKP," maybe the pragmatic path 
is to shape any ZK/succinctness work so that the design itself carries 
the necessary data (e.g., preimages must be published on-chain and 
retrievable) and ships with strong data-availability guarantees (so 
raw tx/block data stays broadly accessible, not just proofs). If the 
"good" ZK system makes data availability a built-in feature, it can 
occupy the niche and leave less room for alternative designs that drop 
those guarantees. 

re: "a good ZK system makes data availability a built-in feature", I think 
this concept of "good" is not very relevant if it's counter to incentives 
(hence my earlier "Hmm" comment; incentives matter).
Meanwhile I find myself reflecting more on Peter's original point (how 
spectacularly deleterious to mining this could be, let alone the data 
availability stuff), and I'm wondering if we can just go radically in the 
opposite direction: what if mining was done just on an accumulator over the 
utxo set, instead of the utxo set itself? Complete redesign of the 
protocol, but .. possible, I think? Tx inputs would have to have set 
membership proofs. I wonder if anyone's done this particular analysis.

Cheers,
waxwing/AdamISZ

On Monday, December 8, 2025 at 2:59:14 PM UTC-3 Nagaev Boris wrote:

Hi waxwing/ AdamISZ, 

Peter's main concern is that ZKP-only validation can break HTLCs: if a 
spend is proven valid with a ZK proof but the actual transaction data 
(including the preimage) never needs to be revealed on-chain, the HTLC 
payer (the counterparty relying on that preimage) can't learn it and 
can't claim its incoming HTLC. That undermines Lightning's security 
because "proof of publication" collapses into "proof of validity 
without data availability." Any succinctness/ZK approach for Bitcoin 
has to preserve the guarantee that the preimage is actually published 
and readable. 

Related, if the network drifts toward relying on ZK proofs without 
simultaneously guaranteeing open access to raw blocks and 
transactions, block data can become gated by a few data providers. 
That is a data-availability risk that comes with any ZK deployment 
that omits strong DA, and it would erode self-sovereignty for routing 
nodes. Any practical ZK/succinctness design for Bitcoin needs strong 
data availability, so anyone can fetch raw transactions, not just 
validity proofs. 

To Peter: rather than trying to "defeat ZKP," maybe the pragmatic path 
is to shape any ZK/succinctness work so that the design itself carries 
the necessary data (e.g., preimages must be published on-chain and 
retrievable) and ships with strong data-availability guarantees (so 
raw tx/block data stays broadly accessible, not just proofs). If the 
"good" ZK system makes data availability a built-in feature, it can 
occupy the niche and leave less room for alternative designs that drop 
those guarantees. 

Best, 
Boris 

On Tue, Dec 2, 2025 at 10:05 AM waxwing/ AdamISZ <ekag...@gmail.com> wrote: 
> 
> (apologies to OP; we've drifted off topic here). Answers inline. 
> 
> 
> On Monday, December 1, 2025 at 5:36:55 AM UTC-3 Peter Todd wrote: 
> 
> On Sat, Nov 29, 2025 at 05:54:13AM -0800, waxwing/ AdamISZ wrote: 
> > Hi Peter, list, 
> > 
> > Interesting! 
> > 
> > One thought that springs to mind: attempts to ameliorate IBD with ZKP 
> > should not forget one thing: what we actually want here is 
succinctness, 
> > and not so much ZK. Think SNARK instead of ZkSNARK. 
> > Which is important; without the requirement for an actual ZK property 
for 
> > the protocol, you can have it have attached witness that is not secret. 
> 
> The Zero-Knowledge part is important to the goal in this specific 
use-case: 
> trying to prevent all arbitrary data publication. 
> 
> 
> Yes agreed. (with the strange caveat: the ZK property itself allows 
data-embedding almost by force; the reason Schnorr has a data embedding 
channel and BLS does not is precisely that BLS does not have a ZK property, 
which itself relates to the fact that it's deterministic (think: no nonce = 
no channel) .. the caveat is not super relevant to some kind of ZK-ed IBD 
thing, though, since that's compressing an unfathomable amount). 
> 
> <snip> 
> 
> 
> It's quite possible that ZKP's are, in the context of decentralized 
> blockchains, an exploit that will prove to be impossible to patch. 
Similar to 
> how merge mining is an economic exploit that may well be impossible to 
patch. 
> 
> Sometimes seemingly good ideas are ultimately killed by clever exploits. 
> 
> 
> I have a sneaking suspicion you're wrong here, but I can't justify it. 
(Hence 'interesting!'). Would love to hear others opinion on the topic. 
> 
> 
> > Take as contrast the opentimestamps model, where having proof 
> > that something was published, is the main functionality 
offered/required. 
> 
> Nope. OpenTimestamps does not use proof of publication at all. 
OpenTimestamps 
> is a commitment operation: proof that if A was changed, B would have to 
change 
> too. The vast majority of OTS timestamps are for private data that is 
never 
> published in any way. OTS simply shows that data *existed*. 
> 
> That seems like a good correction. So, tamper protection, using binding 
property of commitments .. and "proof of existence" is *one* possible 
function? Is that fair? 
> 
> 
> > I 
> > suppose there is another way to say it: the channel counterparty needs 
> > "proof of future publication" in contract setup. That's fair enough but 
> > it's a very different thing than getting a proof that something *was* 
> > published. 
> 
> It is not a meaningfully different thing. An HTLC is proof that in the 
event of 
> an uncooperative redemption, publication will happen. Slightly changing 
the 
> time it takes is irrelevant to the general concept. 
> 
> Concretely: unless you can propose a technical innovation that somehow 
turns 
> this pedantic nuance into a meaningfully different implementation, so 
what? 
> 
> 
> On reflection I don't see it as strange to make the distinction between 
the two: 1/ proof that something was published in the past and 2/ proof 
that conditional on event X occurring, data Y will be published. I guess 1/ 
is just, most realistically, a case of publishing raw, unhashed data on a 
blockchain, then the proof that that event occurred in the past is the 
onchain txs ( using op_return or w/e) themselves. As you pointed out, 
that's not what OTS is doing. Nor is it what an HTLC is doing, that's 2/. 
> 
> 
> -- 
> https://petertodd.org 'peter'[:-1]@petertodd.org 
> 
> -- 
> You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group. 
> To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com. 
> To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/91a40bf7-fe9e-43a1-85d1-5889d4b31a7fn%40googlegroups.com. 




-- 
Best regards, 
Boris Nagaev 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d5eebd82-7f8f-4245-9bb6-fb77020dad72n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 9231 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] Request for early peer review of two BIP drafts (BUDS and segOP)
@ 2025-12-08 21:52  1% Callum
  0 siblings, 0 replies; 200+ results
From: Callum @ 2025-12-08 21:52 UTC (permalink / raw)
  To: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 1167 bytes --]

Hello all,

I would appreciate early peer review on two BIP drafts I have published:

   1.

   BUDS (Bitcoin Unified Data Standard) — an informational BIP defining a
   neutral, non-consensus taxonomy for describing transaction data.

   Draft and reference materials:
   https://github.com/defenwycke/bip-buds
   2.

   segOP (Segregated OP_RETURN) — a consensus proposal describing a
   structured TLV data section and corresponding commitment output.

   Draft and reference materials:
   https://github.com/defenwycke/bip-segop

Both drafts are small and self-contained. Feedback on clarity, correctness,
structure, or missing considerations would be very welcome.

Thank you for your time.

Kind regards,

Defenwycke

08.12.2025

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAOj3_X-WjPYaiTj5NQnAFp%2Bdf%2B4qWCT8oG_c9DsS-TZ47SjZow%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 2528 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-12-02 12:33  1%         ` waxwing/ AdamISZ
@ 2025-12-08 17:34  0%           ` Nagaev Boris
  2025-12-09 14:24  1%             ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Nagaev Boris @ 2025-12-08 17:34 UTC (permalink / raw)
  To: waxwing/ AdamISZ, Peter Todd; +Cc: Bitcoin Development Mailing List

Hi waxwing/ AdamISZ,

Peter's main concern is that ZKP-only validation can break HTLCs: if a
spend is proven valid with a ZK proof but the actual transaction data
(including the preimage) never needs to be revealed on-chain, the HTLC
payer (the counterparty relying on that preimage) can't learn it and
can't claim its incoming HTLC. That undermines Lightning's security
because "proof of publication" collapses into "proof of validity
without data availability." Any succinctness/ZK approach for Bitcoin
has to preserve the guarantee that the preimage is actually published
and readable.

Related, if the network drifts toward relying on ZK proofs without
simultaneously guaranteeing open access to raw blocks and
transactions, block data can become gated by a few data providers.
That is a data-availability risk that comes with any ZK deployment
that omits strong DA, and it would erode self-sovereignty for routing
nodes. Any practical ZK/succinctness design for Bitcoin needs strong
data availability, so anyone can fetch raw transactions, not just
validity proofs.

To Peter: rather than trying to "defeat ZKP," maybe the pragmatic path
is to shape any ZK/succinctness work so that the design itself carries
the necessary data (e.g., preimages must be published on-chain and
retrievable) and ships with strong data-availability guarantees (so
raw tx/block data stays broadly accessible, not just proofs). If the
"good" ZK system makes data availability a built-in feature, it can
occupy the niche and leave less room for alternative designs that drop
those guarantees.

Best,
Boris

On Tue, Dec 2, 2025 at 10:05 AM waxwing/ AdamISZ <ekaggata@gmail.com> wrote:
>
> (apologies to OP; we've drifted off topic here). Answers inline.
>
>
> On Monday, December 1, 2025 at 5:36:55 AM UTC-3 Peter Todd wrote:
>
> On Sat, Nov 29, 2025 at 05:54:13AM -0800, waxwing/ AdamISZ wrote:
> > Hi Peter, list,
> >
> > Interesting!
> >
> > One thought that springs to mind: attempts to ameliorate IBD with ZKP
> > should not forget one thing: what we actually want here is succinctness,
> > and not so much ZK. Think SNARK instead of ZkSNARK.
> > Which is important; without the requirement for an actual ZK property for
> > the protocol, you can have it have attached witness that is not secret.
>
> The Zero-Knowledge part is important to the goal in this specific use-case:
> trying to prevent all arbitrary data publication.
>
>
> Yes agreed. (with the strange caveat: the ZK property itself allows data-embedding almost by force; the reason Schnorr has a data embedding channel and BLS does not is precisely that BLS does not have a ZK property, which itself relates to the fact that it's deterministic (think: no nonce = no channel) .. the caveat is not super relevant to some kind of ZK-ed IBD thing, though, since that's compressing an unfathomable amount).
>
> <snip>
>
>
> It's quite possible that ZKP's are, in the context of decentralized
> blockchains, an exploit that will prove to be impossible to patch. Similar to
> how merge mining is an economic exploit that may well be impossible to patch.
>
> Sometimes seemingly good ideas are ultimately killed by clever exploits.
>
>
> I have a sneaking suspicion you're wrong here, but I can't justify it. (Hence 'interesting!'). Would love to hear others opinion on the topic.
>
>
> > Take as contrast the opentimestamps model, where having proof
> > that something was published, is the main functionality offered/required.
>
> Nope. OpenTimestamps does not use proof of publication at all. OpenTimestamps
> is a commitment operation: proof that if A was changed, B would have to change
> too. The vast majority of OTS timestamps are for private data that is never
> published in any way. OTS simply shows that data *existed*.
>
> That seems like a good correction. So, tamper protection, using binding property of commitments .. and "proof of existence" is *one* possible function? Is that fair?
>
>
> > I
> > suppose there is another way to say it: the channel counterparty needs
> > "proof of future publication" in contract setup. That's fair enough but
> > it's a very different thing than getting a proof that something *was*
> > published.
>
> It is not a meaningfully different thing. An HTLC is proof that in the event of
> an uncooperative redemption, publication will happen. Slightly changing the
> time it takes is irrelevant to the general concept.
>
> Concretely: unless you can propose a technical innovation that somehow turns
> this pedantic nuance into a meaningfully different implementation, so what?
>
>
> On reflection I don't see it as strange to make the distinction between the two: 1/ proof that something was published in the past and 2/ proof that conditional on event X occurring, data Y will be published. I guess 1/ is just, most realistically, a case of publishing raw, unhashed data on a blockchain, then the proof that that event occurred in the past is the onchain txs ( using op_return or w/e) themselves. As you pointed out, that's not what OTS is doing. Nor is it what an HTLC is doing, that's 2/.
>
>
> --
> https://petertodd.org 'peter'[:-1]@petertodd.org
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/91a40bf7-fe9e-43a1-85d1-5889d4b31a7fn%40googlegroups.com.



-- 
Best regards,
Boris Nagaev

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAFC_Vt6HMRoB2xWYUJKLn4Ve8n6MPod6KuTZf87S1Sj%2BGVKQmA%40mail.gmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  @ 2025-12-02 12:33  1%         ` waxwing/ AdamISZ
  2025-12-08 17:34  0%           ` Nagaev Boris
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2025-12-02 12:33 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3898 bytes --]

(apologies to OP; we've drifted off topic here). Answers inline.


On Monday, December 1, 2025 at 5:36:55 AM UTC-3 Peter Todd wrote:

On Sat, Nov 29, 2025 at 05:54:13AM -0800, waxwing/ AdamISZ wrote: 
> Hi Peter, list, 
> 
> Interesting! 
> 
> One thought that springs to mind: attempts to ameliorate IBD with ZKP 
> should not forget one thing: what we actually want here is succinctness, 
> and not so much ZK. Think SNARK instead of ZkSNARK. 
> Which is important; without the requirement for an actual ZK property for 
> the protocol, you can have it have attached witness that is not secret. 

The Zero-Knowledge part is important to the goal in this specific use-case: 
trying to prevent all arbitrary data publication. 


Yes agreed. (with the strange caveat: the ZK property itself allows 
data-embedding almost by force; the reason Schnorr has a data embedding 
channel and BLS does not is precisely that BLS does not have a ZK property, 
which itself relates to the fact that it's deterministic (think: no nonce = 
no channel) .. the caveat is not super relevant to some kind of ZK-ed IBD 
thing, though, since that's compressing an unfathomable amount).
 
<snip>
 

It's quite possible that ZKP's are, in the context of decentralized 
blockchains, an exploit that will prove to be impossible to patch. Similar 
to 
how merge mining is an economic exploit that may well be impossible to 
patch. 

Sometimes seemingly good ideas are ultimately killed by clever exploits. 


I have a sneaking suspicion you're wrong here, but I can't justify it. 
(Hence 'interesting!'). Would love to hear others opinion on the topic.
 

> Take as contrast the opentimestamps model, where having proof 
> that something was published, is the main functionality offered/required. 

Nope. OpenTimestamps does not use proof of publication at all. 
OpenTimestamps 
is a commitment operation: proof that if A was changed, B would have to 
change 
too. The vast majority of OTS timestamps are for private data that is never 
published in any way. OTS simply shows that data *existed*. 

That seems like a good correction. So, tamper protection, using binding 
property of commitments .. and "proof of existence" is *one* possible 
function? Is that fair?
 

> I 
> suppose there is another way to say it: the channel counterparty needs 
> "proof of future publication" in contract setup. That's fair enough but 
> it's a very different thing than getting a proof that something *was* 
> published. 

It is not a meaningfully different thing. An HTLC is proof that in the 
event of 
an uncooperative redemption, publication will happen. Slightly changing the 
time it takes is irrelevant to the general concept. 

Concretely: unless you can propose a technical innovation that somehow 
turns 
this pedantic nuance into a meaningfully different implementation, so what? 


On reflection I don't see it as strange to make the distinction between the 
two: 1/ proof that something was published in the past and 2/ proof that 
conditional on event X occurring, data Y will be published. I guess 1/ is 
just, most realistically, a case of publishing raw, unhashed data on a 
blockchain, then the proof that that event occurred in the past is the 
onchain txs ( using op_return or w/e) themselves. As you pointed out, 
that's not what OTS is doing. Nor is it what an HTLC is doing, that's 2/.


-- 
https://petertodd.org 'peter'[:-1]@petertodd.org 

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/91a40bf7-fe9e-43a1-85d1-5889d4b31a7fn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 5313 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-29 18:15  0%             ` Greg Maxwell
@ 2025-11-29 18:52  0%               ` waxwing/ AdamISZ
  0 siblings, 0 replies; 200+ results
From: waxwing/ AdamISZ @ 2025-11-29 18:52 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 14809 bytes --]

Erik,

> In practice, the system fixes a BLS12-381 public key `PK_root` and a 
one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is 
then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an 
arbitrary index and the hash-to-curve map is a standard indifferentiable 
encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ, 
g) = e(H(S), PK_root)` once, and thereafter reject any public key whose 
curve point does not equal the canonical hash-to-curve output for some 
disclosed index `i`. Because the signer never chooses curve points—and 
because hash-to-curve eliminates degrees of freedom—no entropy remains to 
smuggle bits into the key, satisfying the same non-malleability criteria 
used in anti-steganographic constructions.

Oh, I confess when you said "BLS" I didn't read the details and then just 
went off on the assumption you were talking about a replacement of secp 
with a BLS curve and then outputs being (BLS pubkey, BLS sig) i.e. an 
attached PoK of the key. But now I do actually read what you specifically 
meant, I realize I don't understand it: if the secp key is 
Hash-to-curve(sigma, i) then you don't have the private key of that pubkey. 
How could that be used? I don't get it. Maybe it's because I don't know 
what S is, in this scheme, or maybe not.

Lloyd and I rejected the idea of still using secp but attaching a BLS sig 
to it. That feels unworkable (mapping keys across groups or w/e), you'd 
need to just switch to a BLS curve entirely, I think.

AdamISZ/waxwing

On Saturday, November 29, 2025 at 3:16:34 PM UTC-3 Greg Maxwell wrote:

> You cannot perform pairing on secp256k1 as the DDH is hard in that group, 
> so no BLS signature.  You may find that you make fewer technical errors if 
> you refrain from misrepresenting other people's ideas as your own original 
> work.
>
>
> On Sat, Nov 29, 2025 at 5:17 PM Erik Aronesty <er...@q32.com> wrote:
>
>> there is no fundamental change to the cryptography.  The beacon proofs 
>> are only used for "proof of not spam".  The proven Bitcoin key is the same 
>> secp256k1 key and spending is unchanged.  uxto proofs are not terribly 
>> unreasonable given the cost of UTXOs 
>>
>> On Sat, Nov 29, 2025, 8:15 AM waxwing/ AdamISZ <ekag...@gmail.com> wrote:
>>
>>> Hi Erik,
>>>
>>> > You can stop arbitrary data encoding in public keys by requiring every 
>>> key to be the **unique hash-to-curve output** of a publicly verifiable BLS 
>>> root signature, rather than a user-chosen point on secp256k1. 
>>>
>>> Indeed, absolutely correct (afaik!), I had recently been discussing this 
>>> a bit with Lloyd Fournier on nostr. I think at a theoretical level this is 
>>> a very important observation, but at a practical level not so much. It's 
>>> also worth noting that something like RSA FDH or hash based signatures, 
>>> since they're deterministic (think "no nonce" and no technical ZK property) 
>>> could technically do the same thing, but BLS is far and away better than 
>>> those.
>>>
>>> Theoretical not practical: I think there's no way such a thing would 
>>> happen on bitcoin (IMO! could be wrong!) because it's an absolutely huge 
>>> change to the crypto without improving quantum resistance (performance 
>>> issues are I guess an open question, considering batching properties vs raw 
>>> performance of a single pairing being bad). And the other reason: no point 
>>> going this far without attempting to patch *every* hole that allows data 
>>> that is not trivial. You could argue these holes are trivial: amount data, 
>>> locktimes (both nLockTime and nSequence), in/out sequencing not being 
>>> deterministic, and grinding curve points. The obviously much more relevant 
>>> and non-trivial issue is Script, generally, and sort of peripheral to 
>>> script stuff like control block in taproot etc. Since you'd have to 
>>> "address" (that is to say, gut) Bitcoin's scripting before these other 
>>> things like deterministic signatures become relevant, it does seem all very 
>>> theoretical, if interesting.
>>>
>>> I guess this would have been better in the "On (in)ability to embed data 
>>> in Schnorr" thread but w/e it's all kind of connected I guess!
>>>
>>> Cheers,
>>> AdamISZ/waxwing
>>>
>>> On Saturday, November 29, 2025 at 12:43:56 PM UTC-3 Erik Aronesty wrote:
>>>
>>>> You can stop arbitrary data encoding in public keys by requiring every 
>>>> key to be the **unique hash-to-curve output** of a publicly verifiable BLS 
>>>> root signature, rather than a user-chosen point on secp256k1. 
>>>>
>>>> Because a BLS signature is checkable via a pairing equation, verifiers 
>>>> can confirm that each public key was deterministically forced by the root 
>>>> certificate and not selected to embed arbitrary bits. Under this 
>>>> construction, public keys become outputs of a constrained randomness beacon 
>>>> rather than an open steganographic channel.
>>>>
>>>> In practice, the system fixes a BLS12-381 public key `PK_root` and a 
>>>> one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is 
>>>> then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an 
>>>> arbitrary index and the hash-to-curve map is a standard indifferentiable 
>>>> encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ, 
>>>> g) = e(H(S), PK_root)` once, and thereafter reject any public key whose 
>>>> curve point does not equal the canonical hash-to-curve output for some 
>>>> disclosed index `i`. Because the signer never chooses curve points—and 
>>>> because hash-to-curve eliminates degrees of freedom—no entropy remains to 
>>>> smuggle bits into the key, satisfying the same non-malleability criteria 
>>>> used in anti-steganographic constructions.
>>>>
>>>> This “forced randomness” model parallels techniques in the literature 
>>>> on steganographic resistance and extractable commitments, particularly 
>>>> Hopper–Langford–von Ahn’s work on *provably secure steganography* and 
>>>> Bellare–Ristenpart–Tessaro’s analyses of *channel indistinguishability* in 
>>>> public-key spaces. 
>>>>
>>>> The underlying idea is identical: eliminate sender choice over 
>>>> high-entropy objects so the objects cannot become covert storage.
>>>>
>>>>
>>>> On Sat, Nov 29, 2025, 5:57 AM waxwing/ AdamISZ <ekag...@gmail.com> 
>>>> wrote:
>>>>
>>>>> Hi Peter, list,
>>>>>
>>>>> Interesting!
>>>>>
>>>>> One thought that springs to mind: attempts to ameliorate IBD with ZKP 
>>>>> should not forget one thing: what we actually want here is succinctness, 
>>>>> and not so much ZK. Think SNARK instead of ZkSNARK.
>>>>> Which is important; without the requirement for an actual ZK property 
>>>>> for the protocol, you can have it have attached witness that is not secret.
>>>>>
>>>>> Then a counter-thought strikes, that any version of these protocols 
>>>>> that requires more data/bandwidth probably loses out to versions that have 
>>>>> less data/bandwidth. Hmm.
>>>>>
>>>>>  It seems to demonstrate, to me, that some kind of "data carrying" is 
>>>>> required in the "state" (cf the "history"). Ironically recent discussion 
>>>>> (see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of 
>>>>> "discussions" on the internet about filtering and spam...) has just 
>>>>> re-emphasized that the utxo set can inevitably carry data (I guess that's 
>>>>> obvious).
>>>>>
>>>>> I do think, long term that ZKP over history is correct, and that (see 
>>>>> typical rollup design) data carrying in state can do the job that you are 
>>>>> (correctly) insisting, must be done.
>>>>> (And the corollary: "harmful data on the blockchain" is a wrong mental 
>>>>> model and should be abandoned, irrespective of architecture.)
>>>>>
>>>>> Aside from your *main* concept here, I think the idea that HTLCs 
>>>>> require *proof* of publication is wrong. What they require is publication. 
>>>>> A wronged channel party needs to read the preimage, not have proof that it 
>>>>> can be read. Take as contrast the opentimestamps model, where having proof 
>>>>> that something was published, is the main functionality offered/required. I 
>>>>> suppose there is another way to say it: the channel counterparty needs 
>>>>> "proof of future publication" in contract setup. That's fair enough but 
>>>>> it's a very different thing than getting a proof that something *was* 
>>>>> published.
>>>>>
>>>>> Cheers,
>>>>> AdamISZ/waxwing
>>>>>
>>>>> On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:
>>>>>
>>>>>> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote: 
>>>>>> > I'm not convinced your hash function approach fully does what you 
>>>>>> want it 
>>>>>> > to, although it does seem doable with some additional constraints. 
>>>>>> > 
>>>>>> > There is a solution that does everything you want it and more, 
>>>>>> ZKPs. 
>>>>>> > 
>>>>>> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to 
>>>>>> some hash 
>>>>>> > output Y while keeping the actual value X secret. Thus, everyone 
>>>>>> can be 
>>>>>> > convinced that H(X) = Y even if X is deleted and no one knows what 
>>>>>> the 
>>>>>> > value X was. 
>>>>>> > 
>>>>>> > Even more exciting, ZKPs can prove the correctness and validity of 
>>>>>> the 
>>>>>> > entire Bitcoin blockchain. Thus storing old transactions is 
>>>>>> > no longer needed to convince others that the chain is correct. This 
>>>>>> would 
>>>>>> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's 
>>>>>> blockchain 
>>>>>> > into a 800 KB proof [0] which is constant size regardless of the 
>>>>>> number of 
>>>>>> > transactions or bytes compressed. This approach does not require 
>>>>>> any 
>>>>>> > changes to Bitcoin and you could implement a Bitcoin full node 
>>>>>> today that 
>>>>>> > supports this. 
>>>>>> > 
>>>>>> > We have a solution to solve the problem of harmful data on the 
>>>>>> blockchain 
>>>>>> > since 2017. It just requires time, money and motivated people to 
>>>>>> work on it. 
>>>>>>
>>>>>> Rather than being a solution, the technology behind Zerosync is a 
>>>>>> potential 
>>>>>> threat to Bitcoin. The problem is that Bitcoin fundamentally requires 
>>>>>> proof-of-publication to be decentralized and censorship resistant; a 
>>>>>> related 
>>>>>> problem is that HTLCs (and thus Lightning) fundamentally requires 
>>>>>> proof-of-publication to work at all. 
>>>>>>
>>>>>> For Bitcoin mining to remain decentralized, blocks need to be widely 
>>>>>> propagated 
>>>>>> in a form suitable for creating new blocks. ZKP/Zerosync makes it 
>>>>>> possible to 
>>>>>> prove that a block hash and all prior blocks follow the protocol 
>>>>>> rules and were 
>>>>>> thus valid. However, valid block hashes alone are insufficient to 
>>>>>> mine on top 
>>>>>> of because they do not contain the UTXO set data necessary to mine a 
>>>>>> new block. 
>>>>>>
>>>>>> Why do miners have an incentive to distribute the blocks they find? 
>>>>>> Ultimately 
>>>>>> because doing so is necessary for the coins they mined to be 
>>>>>> valuable. But if 
>>>>>> full nodes can be convinced of the validity of coins without full 
>>>>>> block 
>>>>>> contents --- thus allowing those coins to be sold --- that weakens 
>>>>>> the 
>>>>>> incentives to distribute block data in a form that allows other 
>>>>>> miners to mine. 
>>>>>>
>>>>>>
>>>>>> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication 
>>>>>> to be 
>>>>>> secure: for the HTLC to be redeemed, the redeemer *must* publish the 
>>>>>> pre-image 
>>>>>> in the Bitcoin chain, allowing the other party relying on the HTLC to 
>>>>>> recover 
>>>>>> the pre-image. Again, ZKP/Zerosync weakens this security, as the 
>>>>>> validity of 
>>>>>> the transaction spending the HTLC can be proven without actually 
>>>>>> making the 
>>>>>> pre-image available. 
>>>>>>
>>>>>>
>>>>>> Rather than presenting ZKP/Zerosync as a solution to the "harmful 
>>>>>> data" 
>>>>>> problem, we should in fact be researching ways to defeat ZKP/Zerosync 
>>>>>> entirely. 
>>>>>> We need a consensus protocol where the only way to fully validate a 
>>>>>> block is to 
>>>>>> actually have the entire block contents. 
>>>>>>
>>>>>> As for "harmful data", that is a challenge to be solved 
>>>>>> legally/politically. 
>>>>>>
>>>>>> -- 
>>>>>> https://petertodd.org 'peter'[:-1]@petertodd.org 
>>>>>>
>>>>> -- 
>>>>>
>>>> You received this message because you are subscribed to the Google 
>>>>> Groups "Bitcoin Development Mailing List" group.
>>>>> To unsubscribe from this group and stop receiving emails from it, send 
>>>>> an email to bitcoindev+...@googlegroups.com.
>>>>>
>>>> To view this discussion visit 
>>>>> https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com 
>>>>> <https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>>> .
>>>>>
>>>> -- 
>>> You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com.
>>> To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com 
>>> <https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BNuZcowZhKvTH9Dij-8eiM0pueX8Ym8RbqUHOfE5Nbjg%40mail.gmail.com 
>> <https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BNuZcowZhKvTH9Dij-8eiM0pueX8Ym8RbqUHOfE5Nbjg%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/03f19c1a-ef1b-40c9-9864-ce84e6b5ddbdn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 18605 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-29 17:03  1%           ` Erik Aronesty
@ 2025-11-29 18:15  0%             ` Greg Maxwell
  2025-11-29 18:52  0%               ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-11-29 18:15 UTC (permalink / raw)
  To: Erik Aronesty; +Cc: waxwing/ AdamISZ, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 12714 bytes --]

You cannot perform pairing on secp256k1 as the DDH is hard in that group,
so no BLS signature.  You may find that you make fewer technical errors if
you refrain from misrepresenting other people's ideas as your own original
work.


On Sat, Nov 29, 2025 at 5:17 PM Erik Aronesty <erik@q32.com> wrote:

> there is no fundamental change to the cryptography.  The beacon proofs are
> only used for "proof of not spam".  The proven Bitcoin key is the same
> secp256k1 key and spending is unchanged.  uxto proofs are not terribly
> unreasonable given the cost of UTXOs
>
> On Sat, Nov 29, 2025, 8:15 AM waxwing/ AdamISZ <ekaggata@gmail.com> wrote:
>
>> Hi Erik,
>>
>> > You can stop arbitrary data encoding in public keys by requiring every
>> key to be the **unique hash-to-curve output** of a publicly verifiable BLS
>> root signature, rather than a user-chosen point on secp256k1.
>>
>> Indeed, absolutely correct (afaik!), I had recently been discussing this
>> a bit with Lloyd Fournier on nostr. I think at a theoretical level this is
>> a very important observation, but at a practical level not so much. It's
>> also worth noting that something like RSA FDH or hash based signatures,
>> since they're deterministic (think "no nonce" and no technical ZK property)
>> could technically do the same thing, but BLS is far and away better than
>> those.
>>
>> Theoretical not practical: I think there's no way such a thing would
>> happen on bitcoin (IMO! could be wrong!) because it's an absolutely huge
>> change to the crypto without improving quantum resistance (performance
>> issues are I guess an open question, considering batching properties vs raw
>> performance of a single pairing being bad). And the other reason: no point
>> going this far without attempting to patch *every* hole that allows data
>> that is not trivial. You could argue these holes are trivial: amount data,
>> locktimes (both nLockTime and nSequence), in/out sequencing not being
>> deterministic, and grinding curve points. The obviously much more relevant
>> and non-trivial issue is Script, generally, and sort of peripheral to
>> script stuff like control block in taproot etc. Since you'd have to
>> "address" (that is to say, gut) Bitcoin's scripting before these other
>> things like deterministic signatures become relevant, it does seem all very
>> theoretical, if interesting.
>>
>> I guess this would have been better in the "On (in)ability to embed data
>> in Schnorr" thread but w/e it's all kind of connected I guess!
>>
>> Cheers,
>> AdamISZ/waxwing
>>
>> On Saturday, November 29, 2025 at 12:43:56 PM UTC-3 Erik Aronesty wrote:
>>
>>> You can stop arbitrary data encoding in public keys by requiring every
>>> key to be the **unique hash-to-curve output** of a publicly verifiable BLS
>>> root signature, rather than a user-chosen point on secp256k1.
>>>
>>> Because a BLS signature is checkable via a pairing equation, verifiers
>>> can confirm that each public key was deterministically forced by the root
>>> certificate and not selected to embed arbitrary bits. Under this
>>> construction, public keys become outputs of a constrained randomness beacon
>>> rather than an open steganographic channel.
>>>
>>> In practice, the system fixes a BLS12-381 public key `PK_root` and a
>>> one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is
>>> then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an
>>> arbitrary index and the hash-to-curve map is a standard indifferentiable
>>> encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ,
>>> g) = e(H(S), PK_root)` once, and thereafter reject any public key whose
>>> curve point does not equal the canonical hash-to-curve output for some
>>> disclosed index `i`. Because the signer never chooses curve points—and
>>> because hash-to-curve eliminates degrees of freedom—no entropy remains to
>>> smuggle bits into the key, satisfying the same non-malleability criteria
>>> used in anti-steganographic constructions.
>>>
>>> This “forced randomness” model parallels techniques in the literature on
>>> steganographic resistance and extractable commitments, particularly
>>> Hopper–Langford–von Ahn’s work on *provably secure steganography* and
>>> Bellare–Ristenpart–Tessaro’s analyses of *channel indistinguishability* in
>>> public-key spaces.
>>>
>>> The underlying idea is identical: eliminate sender choice over
>>> high-entropy objects so the objects cannot become covert storage.
>>>
>>>
>>> On Sat, Nov 29, 2025, 5:57 AM waxwing/ AdamISZ <ekag...@gmail.com>
>>> wrote:
>>>
>>>> Hi Peter, list,
>>>>
>>>> Interesting!
>>>>
>>>> One thought that springs to mind: attempts to ameliorate IBD with ZKP
>>>> should not forget one thing: what we actually want here is succinctness,
>>>> and not so much ZK. Think SNARK instead of ZkSNARK.
>>>> Which is important; without the requirement for an actual ZK property
>>>> for the protocol, you can have it have attached witness that is not secret.
>>>>
>>>> Then a counter-thought strikes, that any version of these protocols
>>>> that requires more data/bandwidth probably loses out to versions that have
>>>> less data/bandwidth. Hmm.
>>>>
>>>>  It seems to demonstrate, to me, that some kind of "data carrying" is
>>>> required in the "state" (cf the "history"). Ironically recent discussion
>>>> (see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of
>>>> "discussions" on the internet about filtering and spam...) has just
>>>> re-emphasized that the utxo set can inevitably carry data (I guess that's
>>>> obvious).
>>>>
>>>> I do think, long term that ZKP over history is correct, and that (see
>>>> typical rollup design) data carrying in state can do the job that you are
>>>> (correctly) insisting, must be done.
>>>> (And the corollary: "harmful data on the blockchain" is a wrong mental
>>>> model and should be abandoned, irrespective of architecture.)
>>>>
>>>> Aside from your *main* concept here, I think the idea that HTLCs
>>>> require *proof* of publication is wrong. What they require is publication.
>>>> A wronged channel party needs to read the preimage, not have proof that it
>>>> can be read. Take as contrast the opentimestamps model, where having proof
>>>> that something was published, is the main functionality offered/required. I
>>>> suppose there is another way to say it: the channel counterparty needs
>>>> "proof of future publication" in contract setup. That's fair enough but
>>>> it's a very different thing than getting a proof that something *was*
>>>> published.
>>>>
>>>> Cheers,
>>>> AdamISZ/waxwing
>>>>
>>>> On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:
>>>>
>>>>> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote:
>>>>> > I'm not convinced your hash function approach fully does what you
>>>>> want it
>>>>> > to, although it does seem doable with some additional constraints.
>>>>> >
>>>>> > There is a solution that does everything you want it and more, ZKPs.
>>>>> >
>>>>> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to
>>>>> some hash
>>>>> > output Y while keeping the actual value X secret. Thus, everyone can
>>>>> be
>>>>> > convinced that H(X) = Y even if X is deleted and no one knows what
>>>>> the
>>>>> > value X was.
>>>>> >
>>>>> > Even more exciting, ZKPs can prove the correctness and validity of
>>>>> the
>>>>> > entire Bitcoin blockchain. Thus storing old transactions is
>>>>> > no longer needed to convince others that the chain is correct. This
>>>>> would
>>>>> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's
>>>>> blockchain
>>>>> > into a 800 KB proof [0] which is constant size regardless of the
>>>>> number of
>>>>> > transactions or bytes compressed. This approach does not require any
>>>>> > changes to Bitcoin and you could implement a Bitcoin full node today
>>>>> that
>>>>> > supports this.
>>>>> >
>>>>> > We have a solution to solve the problem of harmful data on the
>>>>> blockchain
>>>>> > since 2017. It just requires time, money and motivated people to
>>>>> work on it.
>>>>>
>>>>> Rather than being a solution, the technology behind Zerosync is a
>>>>> potential
>>>>> threat to Bitcoin. The problem is that Bitcoin fundamentally requires
>>>>> proof-of-publication to be decentralized and censorship resistant; a
>>>>> related
>>>>> problem is that HTLCs (and thus Lightning) fundamentally requires
>>>>> proof-of-publication to work at all.
>>>>>
>>>>> For Bitcoin mining to remain decentralized, blocks need to be widely
>>>>> propagated
>>>>> in a form suitable for creating new blocks. ZKP/Zerosync makes it
>>>>> possible to
>>>>> prove that a block hash and all prior blocks follow the protocol rules
>>>>> and were
>>>>> thus valid. However, valid block hashes alone are insufficient to mine
>>>>> on top
>>>>> of because they do not contain the UTXO set data necessary to mine a
>>>>> new block.
>>>>>
>>>>> Why do miners have an incentive to distribute the blocks they find?
>>>>> Ultimately
>>>>> because doing so is necessary for the coins they mined to be valuable.
>>>>> But if
>>>>> full nodes can be convinced of the validity of coins without full
>>>>> block
>>>>> contents --- thus allowing those coins to be sold --- that weakens the
>>>>> incentives to distribute block data in a form that allows other miners
>>>>> to mine.
>>>>>
>>>>>
>>>>> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication
>>>>> to be
>>>>> secure: for the HTLC to be redeemed, the redeemer *must* publish the
>>>>> pre-image
>>>>> in the Bitcoin chain, allowing the other party relying on the HTLC to
>>>>> recover
>>>>> the pre-image. Again, ZKP/Zerosync weakens this security, as the
>>>>> validity of
>>>>> the transaction spending the HTLC can be proven without actually
>>>>> making the
>>>>> pre-image available.
>>>>>
>>>>>
>>>>> Rather than presenting ZKP/Zerosync as a solution to the "harmful
>>>>> data"
>>>>> problem, we should in fact be researching ways to defeat ZKP/Zerosync
>>>>> entirely.
>>>>> We need a consensus protocol where the only way to fully validate a
>>>>> block is to
>>>>> actually have the entire block contents.
>>>>>
>>>>> As for "harmful data", that is a challenge to be solved
>>>>> legally/politically.
>>>>>
>>>>> --
>>>>> https://petertodd.org 'peter'[:-1]@petertodd.org
>>>>>
>>>> --
>>>>
>>> You received this message because you are subscribed to the Google
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>> an email to bitcoindev+...@googlegroups.com.
>>>>
>>> To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com
>>>> <https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>>> .
>>>>
>>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com
>> <https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BNuZcowZhKvTH9Dij-8eiM0pueX8Ym8RbqUHOfE5Nbjg%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BNuZcowZhKvTH9Dij-8eiM0pueX8Ym8RbqUHOfE5Nbjg%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQfmSsvFwm5n2v7XjV3cc4KUxqpSwCoa30YXPDVEqj1Fg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 15320 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-29 15:56  0%         ` waxwing/ AdamISZ
@ 2025-11-29 17:03  1%           ` Erik Aronesty
  2025-11-29 18:15  0%             ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: Erik Aronesty @ 2025-11-29 17:03 UTC (permalink / raw)
  To: waxwing/ AdamISZ; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 11573 bytes --]

there is no fundamental change to the cryptography.  The beacon proofs are
only used for "proof of not spam".  The proven Bitcoin key is the same
secp256k1 key and spending is unchanged.  uxto proofs are not terribly
unreasonable given the cost of UTXOs

On Sat, Nov 29, 2025, 8:15 AM waxwing/ AdamISZ <ekaggata@gmail.com> wrote:

> Hi Erik,
>
> > You can stop arbitrary data encoding in public keys by requiring every
> key to be the **unique hash-to-curve output** of a publicly verifiable BLS
> root signature, rather than a user-chosen point on secp256k1.
>
> Indeed, absolutely correct (afaik!), I had recently been discussing this a
> bit with Lloyd Fournier on nostr. I think at a theoretical level this is a
> very important observation, but at a practical level not so much. It's also
> worth noting that something like RSA FDH or hash based signatures, since
> they're deterministic (think "no nonce" and no technical ZK property) could
> technically do the same thing, but BLS is far and away better than those.
>
> Theoretical not practical: I think there's no way such a thing would
> happen on bitcoin (IMO! could be wrong!) because it's an absolutely huge
> change to the crypto without improving quantum resistance (performance
> issues are I guess an open question, considering batching properties vs raw
> performance of a single pairing being bad). And the other reason: no point
> going this far without attempting to patch *every* hole that allows data
> that is not trivial. You could argue these holes are trivial: amount data,
> locktimes (both nLockTime and nSequence), in/out sequencing not being
> deterministic, and grinding curve points. The obviously much more relevant
> and non-trivial issue is Script, generally, and sort of peripheral to
> script stuff like control block in taproot etc. Since you'd have to
> "address" (that is to say, gut) Bitcoin's scripting before these other
> things like deterministic signatures become relevant, it does seem all very
> theoretical, if interesting.
>
> I guess this would have been better in the "On (in)ability to embed data
> in Schnorr" thread but w/e it's all kind of connected I guess!
>
> Cheers,
> AdamISZ/waxwing
>
> On Saturday, November 29, 2025 at 12:43:56 PM UTC-3 Erik Aronesty wrote:
>
>> You can stop arbitrary data encoding in public keys by requiring every
>> key to be the **unique hash-to-curve output** of a publicly verifiable BLS
>> root signature, rather than a user-chosen point on secp256k1.
>>
>> Because a BLS signature is checkable via a pairing equation, verifiers
>> can confirm that each public key was deterministically forced by the root
>> certificate and not selected to embed arbitrary bits. Under this
>> construction, public keys become outputs of a constrained randomness beacon
>> rather than an open steganographic channel.
>>
>> In practice, the system fixes a BLS12-381 public key `PK_root` and a
>> one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is
>> then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an
>> arbitrary index and the hash-to-curve map is a standard indifferentiable
>> encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ,
>> g) = e(H(S), PK_root)` once, and thereafter reject any public key whose
>> curve point does not equal the canonical hash-to-curve output for some
>> disclosed index `i`. Because the signer never chooses curve points—and
>> because hash-to-curve eliminates degrees of freedom—no entropy remains to
>> smuggle bits into the key, satisfying the same non-malleability criteria
>> used in anti-steganographic constructions.
>>
>> This “forced randomness” model parallels techniques in the literature on
>> steganographic resistance and extractable commitments, particularly
>> Hopper–Langford–von Ahn’s work on *provably secure steganography* and
>> Bellare–Ristenpart–Tessaro’s analyses of *channel indistinguishability* in
>> public-key spaces.
>>
>> The underlying idea is identical: eliminate sender choice over
>> high-entropy objects so the objects cannot become covert storage.
>>
>>
>> On Sat, Nov 29, 2025, 5:57 AM waxwing/ AdamISZ <ekag...@gmail.com> wrote:
>>
>>> Hi Peter, list,
>>>
>>> Interesting!
>>>
>>> One thought that springs to mind: attempts to ameliorate IBD with ZKP
>>> should not forget one thing: what we actually want here is succinctness,
>>> and not so much ZK. Think SNARK instead of ZkSNARK.
>>> Which is important; without the requirement for an actual ZK property
>>> for the protocol, you can have it have attached witness that is not secret.
>>>
>>> Then a counter-thought strikes, that any version of these protocols that
>>> requires more data/bandwidth probably loses out to versions that have less
>>> data/bandwidth. Hmm.
>>>
>>>  It seems to demonstrate, to me, that some kind of "data carrying" is
>>> required in the "state" (cf the "history"). Ironically recent discussion
>>> (see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of
>>> "discussions" on the internet about filtering and spam...) has just
>>> re-emphasized that the utxo set can inevitably carry data (I guess that's
>>> obvious).
>>>
>>> I do think, long term that ZKP over history is correct, and that (see
>>> typical rollup design) data carrying in state can do the job that you are
>>> (correctly) insisting, must be done.
>>> (And the corollary: "harmful data on the blockchain" is a wrong mental
>>> model and should be abandoned, irrespective of architecture.)
>>>
>>> Aside from your *main* concept here, I think the idea that HTLCs require
>>> *proof* of publication is wrong. What they require is publication. A
>>> wronged channel party needs to read the preimage, not have proof that it
>>> can be read. Take as contrast the opentimestamps model, where having proof
>>> that something was published, is the main functionality offered/required. I
>>> suppose there is another way to say it: the channel counterparty needs
>>> "proof of future publication" in contract setup. That's fair enough but
>>> it's a very different thing than getting a proof that something *was*
>>> published.
>>>
>>> Cheers,
>>> AdamISZ/waxwing
>>>
>>> On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:
>>>
>>>> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote:
>>>> > I'm not convinced your hash function approach fully does what you
>>>> want it
>>>> > to, although it does seem doable with some additional constraints.
>>>> >
>>>> > There is a solution that does everything you want it and more, ZKPs.
>>>> >
>>>> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to some
>>>> hash
>>>> > output Y while keeping the actual value X secret. Thus, everyone can
>>>> be
>>>> > convinced that H(X) = Y even if X is deleted and no one knows what
>>>> the
>>>> > value X was.
>>>> >
>>>> > Even more exciting, ZKPs can prove the correctness and validity of
>>>> the
>>>> > entire Bitcoin blockchain. Thus storing old transactions is
>>>> > no longer needed to convince others that the chain is correct. This
>>>> would
>>>> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's
>>>> blockchain
>>>> > into a 800 KB proof [0] which is constant size regardless of the
>>>> number of
>>>> > transactions or bytes compressed. This approach does not require any
>>>> > changes to Bitcoin and you could implement a Bitcoin full node today
>>>> that
>>>> > supports this.
>>>> >
>>>> > We have a solution to solve the problem of harmful data on the
>>>> blockchain
>>>> > since 2017. It just requires time, money and motivated people to work
>>>> on it.
>>>>
>>>> Rather than being a solution, the technology behind Zerosync is a
>>>> potential
>>>> threat to Bitcoin. The problem is that Bitcoin fundamentally requires
>>>> proof-of-publication to be decentralized and censorship resistant; a
>>>> related
>>>> problem is that HTLCs (and thus Lightning) fundamentally requires
>>>> proof-of-publication to work at all.
>>>>
>>>> For Bitcoin mining to remain decentralized, blocks need to be widely
>>>> propagated
>>>> in a form suitable for creating new blocks. ZKP/Zerosync makes it
>>>> possible to
>>>> prove that a block hash and all prior blocks follow the protocol rules
>>>> and were
>>>> thus valid. However, valid block hashes alone are insufficient to mine
>>>> on top
>>>> of because they do not contain the UTXO set data necessary to mine a
>>>> new block.
>>>>
>>>> Why do miners have an incentive to distribute the blocks they find?
>>>> Ultimately
>>>> because doing so is necessary for the coins they mined to be valuable.
>>>> But if
>>>> full nodes can be convinced of the validity of coins without full block
>>>> contents --- thus allowing those coins to be sold --- that weakens the
>>>> incentives to distribute block data in a form that allows other miners
>>>> to mine.
>>>>
>>>>
>>>> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication to
>>>> be
>>>> secure: for the HTLC to be redeemed, the redeemer *must* publish the
>>>> pre-image
>>>> in the Bitcoin chain, allowing the other party relying on the HTLC to
>>>> recover
>>>> the pre-image. Again, ZKP/Zerosync weakens this security, as the
>>>> validity of
>>>> the transaction spending the HTLC can be proven without actually making
>>>> the
>>>> pre-image available.
>>>>
>>>>
>>>> Rather than presenting ZKP/Zerosync as a solution to the "harmful data"
>>>> problem, we should in fact be researching ways to defeat ZKP/Zerosync
>>>> entirely.
>>>> We need a consensus protocol where the only way to fully validate a
>>>> block is to
>>>> actually have the entire block contents.
>>>>
>>>> As for "harmful data", that is a challenge to be solved
>>>> legally/politically.
>>>>
>>>> --
>>>> https://petertodd.org 'peter'[:-1]@petertodd.org
>>>>
>>> --
>>>
>> You received this message because you are subscribed to the Google Groups
>>> "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>>
>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com
>>> <https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BNuZcowZhKvTH9Dij-8eiM0pueX8Ym8RbqUHOfE5Nbjg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 13900 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-29 15:41  0%       ` Erik Aronesty
@ 2025-11-29 15:56  0%         ` waxwing/ AdamISZ
  2025-11-29 17:03  1%           ` Erik Aronesty
  0 siblings, 1 reply; 200+ results
From: waxwing/ AdamISZ @ 2025-11-29 15:56 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10571 bytes --]

Hi Erik,

> You can stop arbitrary data encoding in public keys by requiring every 
key to be the **unique hash-to-curve output** of a publicly verifiable BLS 
root signature, rather than a user-chosen point on secp256k1. 

Indeed, absolutely correct (afaik!), I had recently been discussing this a 
bit with Lloyd Fournier on nostr. I think at a theoretical level this is a 
very important observation, but at a practical level not so much. It's also 
worth noting that something like RSA FDH or hash based signatures, since 
they're deterministic (think "no nonce" and no technical ZK property) could 
technically do the same thing, but BLS is far and away better than those.

Theoretical not practical: I think there's no way such a thing would happen 
on bitcoin (IMO! could be wrong!) because it's an absolutely huge change to 
the crypto without improving quantum resistance (performance issues are I 
guess an open question, considering batching properties vs raw performance 
of a single pairing being bad). And the other reason: no point going this 
far without attempting to patch *every* hole that allows data that is not 
trivial. You could argue these holes are trivial: amount data, locktimes 
(both nLockTime and nSequence), in/out sequencing not being deterministic, 
and grinding curve points. The obviously much more relevant and non-trivial 
issue is Script, generally, and sort of peripheral to script stuff like 
control block in taproot etc. Since you'd have to "address" (that is to 
say, gut) Bitcoin's scripting before these other things like deterministic 
signatures become relevant, it does seem all very theoretical, if 
interesting.

I guess this would have been better in the "On (in)ability to embed data in 
Schnorr" thread but w/e it's all kind of connected I guess!

Cheers,
AdamISZ/waxwing

On Saturday, November 29, 2025 at 12:43:56 PM UTC-3 Erik Aronesty wrote:

> You can stop arbitrary data encoding in public keys by requiring every key 
> to be the **unique hash-to-curve output** of a publicly verifiable BLS root 
> signature, rather than a user-chosen point on secp256k1. 
>
> Because a BLS signature is checkable via a pairing equation, verifiers can 
> confirm that each public key was deterministically forced by the root 
> certificate and not selected to embed arbitrary bits. Under this 
> construction, public keys become outputs of a constrained randomness beacon 
> rather than an open steganographic channel.
>
> In practice, the system fixes a BLS12-381 public key `PK_root` and a 
> one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is 
> then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an 
> arbitrary index and the hash-to-curve map is a standard indifferentiable 
> encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ, 
> g) = e(H(S), PK_root)` once, and thereafter reject any public key whose 
> curve point does not equal the canonical hash-to-curve output for some 
> disclosed index `i`. Because the signer never chooses curve points—and 
> because hash-to-curve eliminates degrees of freedom—no entropy remains to 
> smuggle bits into the key, satisfying the same non-malleability criteria 
> used in anti-steganographic constructions.
>
> This “forced randomness” model parallels techniques in the literature on 
> steganographic resistance and extractable commitments, particularly 
> Hopper–Langford–von Ahn’s work on *provably secure steganography* and 
> Bellare–Ristenpart–Tessaro’s analyses of *channel indistinguishability* in 
> public-key spaces. 
>
> The underlying idea is identical: eliminate sender choice over 
> high-entropy objects so the objects cannot become covert storage.
>
>
> On Sat, Nov 29, 2025, 5:57 AM waxwing/ AdamISZ <ekag...@gmail.com> wrote:
>
>> Hi Peter, list,
>>
>> Interesting!
>>
>> One thought that springs to mind: attempts to ameliorate IBD with ZKP 
>> should not forget one thing: what we actually want here is succinctness, 
>> and not so much ZK. Think SNARK instead of ZkSNARK.
>> Which is important; without the requirement for an actual ZK property for 
>> the protocol, you can have it have attached witness that is not secret.
>>
>> Then a counter-thought strikes, that any version of these protocols that 
>> requires more data/bandwidth probably loses out to versions that have less 
>> data/bandwidth. Hmm.
>>
>>  It seems to demonstrate, to me, that some kind of "data carrying" is 
>> required in the "state" (cf the "history"). Ironically recent discussion 
>> (see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of 
>> "discussions" on the internet about filtering and spam...) has just 
>> re-emphasized that the utxo set can inevitably carry data (I guess that's 
>> obvious).
>>
>> I do think, long term that ZKP over history is correct, and that (see 
>> typical rollup design) data carrying in state can do the job that you are 
>> (correctly) insisting, must be done.
>> (And the corollary: "harmful data on the blockchain" is a wrong mental 
>> model and should be abandoned, irrespective of architecture.)
>>
>> Aside from your *main* concept here, I think the idea that HTLCs require 
>> *proof* of publication is wrong. What they require is publication. A 
>> wronged channel party needs to read the preimage, not have proof that it 
>> can be read. Take as contrast the opentimestamps model, where having proof 
>> that something was published, is the main functionality offered/required. I 
>> suppose there is another way to say it: the channel counterparty needs 
>> "proof of future publication" in contract setup. That's fair enough but 
>> it's a very different thing than getting a proof that something *was* 
>> published.
>>
>> Cheers,
>> AdamISZ/waxwing
>>
>> On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:
>>
>>> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote: 
>>> > I'm not convinced your hash function approach fully does what you want 
>>> it 
>>> > to, although it does seem doable with some additional constraints. 
>>> > 
>>> > There is a solution that does everything you want it and more, ZKPs. 
>>> > 
>>> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to some 
>>> hash 
>>> > output Y while keeping the actual value X secret. Thus, everyone can 
>>> be 
>>> > convinced that H(X) = Y even if X is deleted and no one knows what the 
>>> > value X was. 
>>> > 
>>> > Even more exciting, ZKPs can prove the correctness and validity of the 
>>> > entire Bitcoin blockchain. Thus storing old transactions is 
>>> > no longer needed to convince others that the chain is correct. This 
>>> would 
>>> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's 
>>> blockchain 
>>> > into a 800 KB proof [0] which is constant size regardless of the 
>>> number of 
>>> > transactions or bytes compressed. This approach does not require any 
>>> > changes to Bitcoin and you could implement a Bitcoin full node today 
>>> that 
>>> > supports this. 
>>> > 
>>> > We have a solution to solve the problem of harmful data on the 
>>> blockchain 
>>> > since 2017. It just requires time, money and motivated people to work 
>>> on it. 
>>>
>>> Rather than being a solution, the technology behind Zerosync is a 
>>> potential 
>>> threat to Bitcoin. The problem is that Bitcoin fundamentally requires 
>>> proof-of-publication to be decentralized and censorship resistant; a 
>>> related 
>>> problem is that HTLCs (and thus Lightning) fundamentally requires 
>>> proof-of-publication to work at all. 
>>>
>>> For Bitcoin mining to remain decentralized, blocks need to be widely 
>>> propagated 
>>> in a form suitable for creating new blocks. ZKP/Zerosync makes it 
>>> possible to 
>>> prove that a block hash and all prior blocks follow the protocol rules 
>>> and were 
>>> thus valid. However, valid block hashes alone are insufficient to mine 
>>> on top 
>>> of because they do not contain the UTXO set data necessary to mine a new 
>>> block. 
>>>
>>> Why do miners have an incentive to distribute the blocks they find? 
>>> Ultimately 
>>> because doing so is necessary for the coins they mined to be valuable. 
>>> But if 
>>> full nodes can be convinced of the validity of coins without full block 
>>> contents --- thus allowing those coins to be sold --- that weakens the 
>>> incentives to distribute block data in a form that allows other miners 
>>> to mine. 
>>>
>>>
>>> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication to 
>>> be 
>>> secure: for the HTLC to be redeemed, the redeemer *must* publish the 
>>> pre-image 
>>> in the Bitcoin chain, allowing the other party relying on the HTLC to 
>>> recover 
>>> the pre-image. Again, ZKP/Zerosync weakens this security, as the 
>>> validity of 
>>> the transaction spending the HTLC can be proven without actually making 
>>> the 
>>> pre-image available. 
>>>
>>>
>>> Rather than presenting ZKP/Zerosync as a solution to the "harmful data" 
>>> problem, we should in fact be researching ways to defeat ZKP/Zerosync 
>>> entirely. 
>>> We need a consensus protocol where the only way to fully validate a 
>>> block is to 
>>> actually have the entire block contents. 
>>>
>>> As for "harmful data", that is a challenge to be solved 
>>> legally/politically. 
>>>
>>> -- 
>>> https://petertodd.org 'peter'[:-1]@petertodd.org 
>>>
>> -- 
>>
> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1d1c5d9c-9b36-4e4b-930c-d23b2f562052n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 13105 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-29 13:54  1%     ` waxwing/ AdamISZ
@ 2025-11-29 15:41  0%       ` Erik Aronesty
  2025-11-29 15:56  0%         ` waxwing/ AdamISZ
    1 sibling, 1 reply; 200+ results
From: Erik Aronesty @ 2025-11-29 15:41 UTC (permalink / raw)
  To: waxwing/ AdamISZ; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 8320 bytes --]

You can stop arbitrary data encoding in public keys by requiring every key
to be the **unique hash-to-curve output** of a publicly verifiable BLS root
signature, rather than a user-chosen point on secp256k1.

Because a BLS signature is checkable via a pairing equation, verifiers can
confirm that each public key was deterministically forced by the root
certificate and not selected to embed arbitrary bits. Under this
construction, public keys become outputs of a constrained randomness beacon
rather than an open steganographic channel.

In practice, the system fixes a BLS12-381 public key `PK_root` and a
one-time BLS signature `σ = Sign_root(S)`. Any allowed secp256k1 key is
then defined as `P_i = HashToCurve_secp256k1(σ || i)`, where `i` is an
arbitrary index and the hash-to-curve map is a standard indifferentiable
encoding (e.g., IETF RFC 9380). Verifiers check the pairing equation `e(σ,
g) = e(H(S), PK_root)` once, and thereafter reject any public key whose
curve point does not equal the canonical hash-to-curve output for some
disclosed index `i`. Because the signer never chooses curve points—and
because hash-to-curve eliminates degrees of freedom—no entropy remains to
smuggle bits into the key, satisfying the same non-malleability criteria
used in anti-steganographic constructions.

This “forced randomness” model parallels techniques in the literature on
steganographic resistance and extractable commitments, particularly
Hopper–Langford–von Ahn’s work on *provably secure steganography* and
Bellare–Ristenpart–Tessaro’s analyses of *channel indistinguishability* in
public-key spaces.

The underlying idea is identical: eliminate sender choice over high-entropy
objects so the objects cannot become covert storage.


On Sat, Nov 29, 2025, 5:57 AM waxwing/ AdamISZ <ekaggata@gmail.com> wrote:

> Hi Peter, list,
>
> Interesting!
>
> One thought that springs to mind: attempts to ameliorate IBD with ZKP
> should not forget one thing: what we actually want here is succinctness,
> and not so much ZK. Think SNARK instead of ZkSNARK.
> Which is important; without the requirement for an actual ZK property for
> the protocol, you can have it have attached witness that is not secret.
>
> Then a counter-thought strikes, that any version of these protocols that
> requires more data/bandwidth probably loses out to versions that have less
> data/bandwidth. Hmm.
>
>  It seems to demonstrate, to me, that some kind of "data carrying" is
> required in the "state" (cf the "history"). Ironically recent discussion
> (see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of
> "discussions" on the internet about filtering and spam...) has just
> re-emphasized that the utxo set can inevitably carry data (I guess that's
> obvious).
>
> I do think, long term that ZKP over history is correct, and that (see
> typical rollup design) data carrying in state can do the job that you are
> (correctly) insisting, must be done.
> (And the corollary: "harmful data on the blockchain" is a wrong mental
> model and should be abandoned, irrespective of architecture.)
>
> Aside from your *main* concept here, I think the idea that HTLCs require
> *proof* of publication is wrong. What they require is publication. A
> wronged channel party needs to read the preimage, not have proof that it
> can be read. Take as contrast the opentimestamps model, where having proof
> that something was published, is the main functionality offered/required. I
> suppose there is another way to say it: the channel counterparty needs
> "proof of future publication" in contract setup. That's fair enough but
> it's a very different thing than getting a proof that something *was*
> published.
>
> Cheers,
> AdamISZ/waxwing
>
> On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:
>
>> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote:
>> > I'm not convinced your hash function approach fully does what you want
>> it
>> > to, although it does seem doable with some additional constraints.
>> >
>> > There is a solution that does everything you want it and more, ZKPs.
>> >
>> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to some
>> hash
>> > output Y while keeping the actual value X secret. Thus, everyone can be
>> > convinced that H(X) = Y even if X is deleted and no one knows what the
>> > value X was.
>> >
>> > Even more exciting, ZKPs can prove the correctness and validity of the
>> > entire Bitcoin blockchain. Thus storing old transactions is
>> > no longer needed to convince others that the chain is correct. This
>> would
>> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's
>> blockchain
>> > into a 800 KB proof [0] which is constant size regardless of the number
>> of
>> > transactions or bytes compressed. This approach does not require any
>> > changes to Bitcoin and you could implement a Bitcoin full node today
>> that
>> > supports this.
>> >
>> > We have a solution to solve the problem of harmful data on the
>> blockchain
>> > since 2017. It just requires time, money and motivated people to work
>> on it.
>>
>> Rather than being a solution, the technology behind Zerosync is a
>> potential
>> threat to Bitcoin. The problem is that Bitcoin fundamentally requires
>> proof-of-publication to be decentralized and censorship resistant; a
>> related
>> problem is that HTLCs (and thus Lightning) fundamentally requires
>> proof-of-publication to work at all.
>>
>> For Bitcoin mining to remain decentralized, blocks need to be widely
>> propagated
>> in a form suitable for creating new blocks. ZKP/Zerosync makes it
>> possible to
>> prove that a block hash and all prior blocks follow the protocol rules
>> and were
>> thus valid. However, valid block hashes alone are insufficient to mine on
>> top
>> of because they do not contain the UTXO set data necessary to mine a new
>> block.
>>
>> Why do miners have an incentive to distribute the blocks they find?
>> Ultimately
>> because doing so is necessary for the coins they mined to be valuable.
>> But if
>> full nodes can be convinced of the validity of coins without full block
>> contents --- thus allowing those coins to be sold --- that weakens the
>> incentives to distribute block data in a form that allows other miners to
>> mine.
>>
>>
>> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication to
>> be
>> secure: for the HTLC to be redeemed, the redeemer *must* publish the
>> pre-image
>> in the Bitcoin chain, allowing the other party relying on the HTLC to
>> recover
>> the pre-image. Again, ZKP/Zerosync weakens this security, as the validity
>> of
>> the transaction spending the HTLC can be proven without actually making
>> the
>> pre-image available.
>>
>>
>> Rather than presenting ZKP/Zerosync as a solution to the "harmful data"
>> problem, we should in fact be researching ways to defeat ZKP/Zerosync
>> entirely.
>> We need a consensus protocol where the only way to fully validate a block
>> is to
>> actually have the entire block contents.
>>
>> As for "harmful data", that is a challenge to be solved
>> legally/politically.
>>
>> --
>> https://petertodd.org 'peter'[:-1]@petertodd.org
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2B4DjP-c%3D0MJbZC1cTRU_RisRr7-dS%3Di7c4ir4fSngvXw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 9827 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  @ 2025-11-29 13:54  1%     ` waxwing/ AdamISZ
  2025-11-29 15:41  0%       ` Erik Aronesty
    0 siblings, 2 replies; 200+ results
From: waxwing/ AdamISZ @ 2025-11-29 13:54 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5738 bytes --]

Hi Peter, list,

Interesting!

One thought that springs to mind: attempts to ameliorate IBD with ZKP 
should not forget one thing: what we actually want here is succinctness, 
and not so much ZK. Think SNARK instead of ZkSNARK.
Which is important; without the requirement for an actual ZK property for 
the protocol, you can have it have attached witness that is not secret.

Then a counter-thought strikes, that any version of these protocols that 
requires more data/bandwidth probably loses out to versions that have less 
data/bandwidth. Hmm.

 It seems to demonstrate, to me, that some kind of "data carrying" is 
required in the "state" (cf the "history"). Ironically recent discussion 
(see 'On (in)ability to embed data into Schnorr' but yeah a googolplex of 
"discussions" on the internet about filtering and spam...) has just 
re-emphasized that the utxo set can inevitably carry data (I guess that's 
obvious).

I do think, long term that ZKP over history is correct, and that (see 
typical rollup design) data carrying in state can do the job that you are 
(correctly) insisting, must be done.
(And the corollary: "harmful data on the blockchain" is a wrong mental 
model and should be abandoned, irrespective of architecture.)

Aside from your *main* concept here, I think the idea that HTLCs require 
*proof* of publication is wrong. What they require is publication. A 
wronged channel party needs to read the preimage, not have proof that it 
can be read. Take as contrast the opentimestamps model, where having proof 
that something was published, is the main functionality offered/required. I 
suppose there is another way to say it: the channel counterparty needs 
"proof of future publication" in contract setup. That's fair enough but 
it's a very different thing than getting a proof that something *was* 
published.

Cheers,
AdamISZ/waxwing

On Saturday, November 29, 2025 at 8:32:21 AM UTC-3 Peter Todd wrote:

> On Thu, Nov 20, 2025 at 04:21:33PM -0500, Ethan Heilman wrote:
> > I'm not convinced your hash function approach fully does what you want it
> > to, although it does seem doable with some additional constraints.
> > 
> > There is a solution that does everything you want it and more, ZKPs.
> > 
> > ZKP (Zero Knowledge Proofs) can prove that some data X hashes to some 
> hash
> > output Y while keeping the actual value X secret. Thus, everyone can be
> > convinced that H(X) = Y even if X is deleted and no one knows what the
> > value X was.
> > 
> > Even more exciting, ZKPs can prove the correctness and validity of the
> > entire Bitcoin blockchain. Thus storing old transactions is
> > no longer needed to convince others that the chain is correct. This would
> > remove any harmful data. Zerosync in 2017 compressed Bitcoin's blockchain
> > into a 800 KB proof [0] which is constant size regardless of the number 
> of
> > transactions or bytes compressed. This approach does not require any
> > changes to Bitcoin and you could implement a Bitcoin full node today that
> > supports this.
> > 
> > We have a solution to solve the problem of harmful data on the blockchain
> > since 2017. It just requires time, money and motivated people to work on 
> it.
>
> Rather than being a solution, the technology behind Zerosync is a potential
> threat to Bitcoin. The problem is that Bitcoin fundamentally requires
> proof-of-publication to be decentralized and censorship resistant; a 
> related
> problem is that HTLCs (and thus Lightning) fundamentally requires
> proof-of-publication to work at all.
>
> For Bitcoin mining to remain decentralized, blocks need to be widely 
> propagated
> in a form suitable for creating new blocks. ZKP/Zerosync makes it possible 
> to
> prove that a block hash and all prior blocks follow the protocol rules and 
> were
> thus valid. However, valid block hashes alone are insufficient to mine on 
> top
> of because they do not contain the UTXO set data necessary to mine a new 
> block.
>
> Why do miners have an incentive to distribute the blocks they find? 
> Ultimately
> because doing so is necessary for the coins they mined to be valuable. But 
> if
> full nodes can be convinced of the validity of coins without full block
> contents --- thus allowing those coins to be sold --- that weakens the
> incentives to distribute block data in a form that allows other miners to 
> mine.
>
>
> With regard to HTLCs/Lightning, HTLCs rely on a proof-of-publication to be
> secure: for the HTLC to be redeemed, the redeemer *must* publish the 
> pre-image
> in the Bitcoin chain, allowing the other party relying on the HTLC to 
> recover
> the pre-image. Again, ZKP/Zerosync weakens this security, as the validity 
> of
> the transaction spending the HTLC can be proven without actually making the
> pre-image available.
>
>
> Rather than presenting ZKP/Zerosync as a solution to the "harmful data"
> problem, we should in fact be researching ways to defeat ZKP/Zerosync 
> entirely.
> We need a consensus protocol where the only way to fully validate a block 
> is to
> actually have the entire block contents.
>
> As for "harmful data", that is a challenge to be solved 
> legally/politically.
>
> -- 
> https://petertodd.org 'peter'[:-1]@petertodd.org
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f5cf7fb8-61ce-437b-b26b-241d47b3fcb5n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 6999 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-20 18:45  0% ` Greg Maxwell
@ 2025-11-23  6:37  0%   ` Saint Wenhao
  0 siblings, 0 replies; 200+ results
From: Saint Wenhao @ 2025-11-23  6:37 UTC (permalink / raw)
  To: Greg Maxwell; +Cc: Lazy Fair, bitcoindev

[-- Attachment #1: Type: text/plain, Size: 10503 bytes --]

> allowing attackers access to manipulate a hash's midstate is dubious from
a security perspective

It is unsafe, because the attacker can pick anything as the "middle state",
run it through SHA-256, and get a valid result. For example: the hash of
the Genesis Block is computed in this way:

hash0: 6a09e667 bb67ae85 3c6ef372 a54ff53a 510e527f 9b05688c 1f83d9ab
5be0cd19

01000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 3ba3edfd 7a7b12b2 7ac72c3e
67768f61 7fc81bc3 888a5132 3a9fb8aa

hash1: bc909a33 6358bff0 90ccac7d 1e59caa8 c3c8d8e9 4f0103c8 96b18736
4719f91b

4b1e5e4a 29ab5f49 ffff001d 1dac2b7c
80000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000280

hash2: af42031e 805ff493 a07341e2 f74ff581 49d22ab9 ba19f613 43e2c86c
71c5d66d

hash0: 6a09e667 bb67ae85 3c6ef372 a54ff53a 510e527f 9b05688c 1f83d9ab
5be0cd19

af42031e 805ff493 a07341e2 f74ff581
49d22ab9 ba19f613 43e2c86c 71c5d66d
80000000 00000000 00000000 00000000
00000000 00000000 00000000 00000100

hash4: 6fe28c0a b6f1b372 c1a6a246 ae63f74f 931e8365 e15a089c 68d61900
00000000

And now, let's assume that we want to skip the first 64 bytes. We get "bc909a33
6358bff0 90ccac7d 1e59caa8 c3c8d8e9 4f0103c8 96b18736 4719f91b" from the
network, receive "af42031e 805ff493 a07341e2 f74ff581 49d22ab9 ba19f613
43e2c86c 71c5d66d" as a result, so we can think, that our last data chunk
is set to "4b1e5e4a 29ab5f49 ffff001d 1dac2b7c". However:

fake0: 189dcde9 da998d89 12414f36 fb7a1edd d48a4c3b c0237088 6beec03e
46b7bafb

4b1e5e4a 29ab5f49 ffff001d 1dac2b7c
80000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000280

fake1: 189dcde9 da998d89 12414f36 fb7a1edd d48a4c3b c0237088 6beec03e
46b7bafb

So, the attacker can pick some data, and compute any two hashes, which will
go through that initialization vector, and leave it unchanged. And then,
instead of shrinking data, they can be expanded into infinite size.

Also, computing any difference between hashes is possible as well. For
example: if we want to get a hash, which will be incremented by one:

fake2: f530fddf 74afe6c6 6004c3c0 c230b193 853774a9 6ab4c304 9d09ddde
d9982546

4b1e5e4a 29ab5f49 ffff001d 1dac2b7c
80000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000280

fake3: f530fddf 74afe6c6 6004c3c0 c230b193 853774a9 6ab4c304 9d09ddde
d9982547

Other attacks are possible as well. So, I wouldn't trust middle hashes that
much, unless you have a strong cryptographic proof, that they are safe in a
given context.

sob., 22 lis 2025 o 00:25 Greg Maxwell <gmaxwell@gmail.com> napisał(a):

> If you find blindly trusting miners acceptable, just run SPV and then you
> don't store anything but block headers.
>
> Aside, allowing attackers access to manipulate a hash's midstate is
> dubious from a security perspective-- at the very least it's outside of the
> scope normally analyzed for security.
>
> On Thu, Nov 20, 2025 at 9:49 AM Lazy Fair <laissez.faire.btc@gmail.com>
> wrote:
>
>> I propose two changes to Bitcoin, one at the consensus level, and one at
>> the client level. The purpose of this is to support filtering of
>> objectionable content after the content has been mined, allowing each node
>> operator to maintain only that data they find agreeable. In so doing, my
>> hope is that we can satisfy all users, and deal with their greatest
>> concerns.
>>
>> I do however acknowledge those people that want to stop miners from
>> mining non-monetary transactions, because of the data storage and
>> processing cost, and I recognised that this proposal does nothing to
>> address those concerns.
>>
>> *** Motivation ***
>>
>> You can't just change or delete some data from the blockchain, because a
>> hash of everything in a block is included in the next block. If you change
>> the data, you change the hash. The design presented here is an attempt to
>> achieve a compromise, where a person can have all of the benefits of
>> running a full node, including the integrity of the ledger, yet without
>> storing the objectionable content - and importantly without even being able
>> to recreate that objectionable content from what data they still have.
>>
>> *** Preliminary ***
>>
>> Objectionable content is defined here as whatever you want it to be, and
>> two users don't have to share the same views. One person might object to
>> copyrighted material used without permission, another a negative depiction
>> of the prophet Muhammad, and another video of the sexual abuse of children.
>> The design presented below lets each person decide what to remove for
>> themself (if anything), while those who want everything can still have it
>> all.
>>
>> The design lets a user remove any data, and deals with the impact on the
>> matching of block hashes, data integrity and malleability.
>>
>> In the case of OP_RETURN data, the result should be no functional effect
>> at all. Whether that's also possible for other data elements will depend on
>> the semantics of that data.
>>
>> *** Solution ***
>>
>> This solution is based on two ideas, both aimed at maintaining data
>> integrity through hashing, while removing some of the hash's input data
>> stream.
>>
>> *** First Idea ***
>>
>> When performing a hash of some data (D), each chunk of data that's
>> processed updates an internal state (S) of the hashing algorithm. If you
>> know what the internal state is at point A and then at point B, then you
>> can compute the final hash of D even without the data between A and B. This
>> is the first idea. First you need to know what S(A) and S(B) are, and once
>> you do, you can compute the hash of D, without the data between A and B.
>> You run the hashing algorithm normally up to A, then you update the
>> internal state from S(A) to S(B), then you continue hashing from B to the
>> end of D.
>>
>> The hash still works as an integrity check for the data before A, and the
>> data after B: change any of this, and the final hash will change. Now you
>> can safely change or delete the data in between, without breaking the
>> integrity of the blockchain and proof of work - but only if you can
>> securely obtain S(A) and S(B), and only if you don't need the data between
>> A and B for anything else.
>>
>> The easiest way to obtain S(A) and S(B) is to calculate them yourself,
>> but that requires that you hold the objectionable data, at least for a
>> time. That also requires finding someone else that holds the objectionable
>> data. But what if instead, we could share S(A) and S(B) across the network,
>> do it securely, and in a way where up to 100% of nodes could choose to drop
>> the data in between, permanently, without breaking anything?
>>
>> *** Second idea ***
>>
>> It may seem like there is no one you can trust to tell you what S(A) and
>> S(B) are. There is only one source of data that a Bitcoin node can trust,
>> and that is the blockchain, as mined by miners, with the most proof of
>> work, and verified locally. Therefore, the second idea is that S(A) and
>> S(B) are trusted if (and only if) they are written into the blockchain, and
>> verified by the network.
>>
>> For example, we write data to the semantic effect of "In Transaction X:
>> at byte offset A, the internal state of the hash function is S1; at byte
>> offset B, the internal state of the hash function is S2." Miners then mine
>> this statement into a block, and verifiers confirm that it is
>> cryptographically accurate with respect to the data in Transaction X as
>> described - or else they drop the new block as invalid.
>>
>> At this point, any node can choose to delete the data between S1 and S2.
>> This can now be done with confidence because they can double check the
>> accuracy, and the impact on the ledger, before they delete the data. After
>> that they may also be able to share (with the agreement of the receiving
>> node) this modified transaction as part of initial block downloads, along
>> with S1 and S2 - to any other nodes that don't want this objectionable
>> content. The receiving nodes wouldn't immediately and necessarily be able
>> to trust S1 and S2, but they would eventually, once they have the full
>> blockchain.
>>
>> *** Conclusion ***
>>
>> This isn't a concrete proposal - it's not even close - but perhaps it
>> might be the start of a fruitful conversation. I have more to say, but this
>> email is long enough already. Email me if you're interested in discussing
>> or developing these ideas together. I have a private Discord server, but
>> I'm open to other suggestions, or just further discussion here.
>>
>> Laissez faire, laissez passer.
>>
>> Let it be, let it go.
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgRX3PJEy%2B7GRyANDea2ZFfkWRGr%2B4q9YEV90zhtgv2Bag%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgRX3PJEy%2B7GRyANDea2ZFfkWRGr%2B4q9YEV90zhtgv2Bag%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CACgYNO%2B3sWojtgoZLi7j28VDKBSPO3YEWNyxryQvoAKmaPqFBg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 12687 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-20  1:57  1% [bitcoindev] A safe way to remove objectionable content from the blockchain Lazy Fair
@ 2025-11-20 18:45  0% ` Greg Maxwell
  2025-11-23  6:37  0%   ` Saint Wenhao
  2025-11-20 21:21  0% ` Ethan Heilman
  1 sibling, 1 reply; 200+ results
From: Greg Maxwell @ 2025-11-20 18:45 UTC (permalink / raw)
  To: Lazy Fair; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 7013 bytes --]

If you find blindly trusting miners acceptable, just run SPV and then you
don't store anything but block headers.

Aside, allowing attackers access to manipulate a hash's midstate is dubious
from a security perspective-- at the very least it's outside of the scope
normally analyzed for security.

On Thu, Nov 20, 2025 at 9:49 AM Lazy Fair <laissez.faire.btc@gmail.com>
wrote:

> I propose two changes to Bitcoin, one at the consensus level, and one at
> the client level. The purpose of this is to support filtering of
> objectionable content after the content has been mined, allowing each node
> operator to maintain only that data they find agreeable. In so doing, my
> hope is that we can satisfy all users, and deal with their greatest
> concerns.
>
> I do however acknowledge those people that want to stop miners from mining
> non-monetary transactions, because of the data storage and processing cost,
> and I recognised that this proposal does nothing to address those concerns.
>
> *** Motivation ***
>
> You can't just change or delete some data from the blockchain, because a
> hash of everything in a block is included in the next block. If you change
> the data, you change the hash. The design presented here is an attempt to
> achieve a compromise, where a person can have all of the benefits of
> running a full node, including the integrity of the ledger, yet without
> storing the objectionable content - and importantly without even being able
> to recreate that objectionable content from what data they still have.
>
> *** Preliminary ***
>
> Objectionable content is defined here as whatever you want it to be, and
> two users don't have to share the same views. One person might object to
> copyrighted material used without permission, another a negative depiction
> of the prophet Muhammad, and another video of the sexual abuse of children.
> The design presented below lets each person decide what to remove for
> themself (if anything), while those who want everything can still have it
> all.
>
> The design lets a user remove any data, and deals with the impact on the
> matching of block hashes, data integrity and malleability.
>
> In the case of OP_RETURN data, the result should be no functional effect
> at all. Whether that's also possible for other data elements will depend on
> the semantics of that data.
>
> *** Solution ***
>
> This solution is based on two ideas, both aimed at maintaining data
> integrity through hashing, while removing some of the hash's input data
> stream.
>
> *** First Idea ***
>
> When performing a hash of some data (D), each chunk of data that's
> processed updates an internal state (S) of the hashing algorithm. If you
> know what the internal state is at point A and then at point B, then you
> can compute the final hash of D even without the data between A and B. This
> is the first idea. First you need to know what S(A) and S(B) are, and once
> you do, you can compute the hash of D, without the data between A and B.
> You run the hashing algorithm normally up to A, then you update the
> internal state from S(A) to S(B), then you continue hashing from B to the
> end of D.
>
> The hash still works as an integrity check for the data before A, and the
> data after B: change any of this, and the final hash will change. Now you
> can safely change or delete the data in between, without breaking the
> integrity of the blockchain and proof of work - but only if you can
> securely obtain S(A) and S(B), and only if you don't need the data between
> A and B for anything else.
>
> The easiest way to obtain S(A) and S(B) is to calculate them yourself, but
> that requires that you hold the objectionable data, at least for a time.
> That also requires finding someone else that holds the objectionable data.
> But what if instead, we could share S(A) and S(B) across the network, do it
> securely, and in a way where up to 100% of nodes could choose to drop the
> data in between, permanently, without breaking anything?
>
> *** Second idea ***
>
> It may seem like there is no one you can trust to tell you what S(A) and
> S(B) are. There is only one source of data that a Bitcoin node can trust,
> and that is the blockchain, as mined by miners, with the most proof of
> work, and verified locally. Therefore, the second idea is that S(A) and
> S(B) are trusted if (and only if) they are written into the blockchain, and
> verified by the network.
>
> For example, we write data to the semantic effect of "In Transaction X: at
> byte offset A, the internal state of the hash function is S1; at byte
> offset B, the internal state of the hash function is S2." Miners then mine
> this statement into a block, and verifiers confirm that it is
> cryptographically accurate with respect to the data in Transaction X as
> described - or else they drop the new block as invalid.
>
> At this point, any node can choose to delete the data between S1 and S2.
> This can now be done with confidence because they can double check the
> accuracy, and the impact on the ledger, before they delete the data. After
> that they may also be able to share (with the agreement of the receiving
> node) this modified transaction as part of initial block downloads, along
> with S1 and S2 - to any other nodes that don't want this objectionable
> content. The receiving nodes wouldn't immediately and necessarily be able
> to trust S1 and S2, but they would eventually, once they have the full
> blockchain.
>
> *** Conclusion ***
>
> This isn't a concrete proposal - it's not even close - but perhaps it
> might be the start of a fruitful conversation. I have more to say, but this
> email is long enough already. Email me if you're interested in discussing
> or developing these ideas together. I have a private Discord server, but
> I'm open to other suggestions, or just further discussion here.
>
> Laissez faire, laissez passer.
>
> Let it be, let it go.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgRX3PJEy%2B7GRyANDea2ZFfkWRGr%2B4q9YEV90zhtgv2Bag%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8527 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] A safe way to remove objectionable content from the blockchain
  2025-11-20  1:57  1% [bitcoindev] A safe way to remove objectionable content from the blockchain Lazy Fair
  2025-11-20 18:45  0% ` Greg Maxwell
@ 2025-11-20 21:21  0% ` Ethan Heilman
    1 sibling, 1 reply; 200+ results
From: Ethan Heilman @ 2025-11-20 21:21 UTC (permalink / raw)
  To: Lazy Fair; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 7974 bytes --]

I'm not convinced your hash function approach fully does what you want it
to, although it does seem doable with some additional constraints.

There is a solution that does everything you want it and more, ZKPs.

ZKP (Zero Knowledge Proofs) can prove that some data X hashes to some hash
output Y while keeping the actual value X secret. Thus, everyone can be
convinced that H(X) = Y even if X is deleted and no one knows what the
value X was.

Even more exciting, ZKPs can prove the correctness and validity of the
entire Bitcoin blockchain. Thus storing old transactions is
no longer needed to convince others that the chain is correct. This would
remove any harmful data. Zerosync in 2017 compressed Bitcoin's blockchain
into a 800 KB proof [0] which is constant size regardless of the number of
transactions or bytes compressed. This approach does not require any
changes to Bitcoin and you could implement a Bitcoin full node today that
supports this.

We have a solution to solve the problem of harmful data on the blockchain
since 2017. It just requires time, money and motivated people to work on it.

[0]:  Robin Linus and Lukas George,  ZeroSync: Introducing Validity Proofs
to Bitcoin, 2017, https://zerosync.com/zerosync.pdf

On Thu, Nov 20, 2025 at 4:49 AM Lazy Fair <laissez.faire.btc@gmail.com>
wrote:

> I propose two changes to Bitcoin, one at the consensus level, and one at
> the client level. The purpose of this is to support filtering of
> objectionable content after the content has been mined, allowing each node
> operator to maintain only that data they find agreeable. In so doing, my
> hope is that we can satisfy all users, and deal with their greatest
> concerns.
>
> I do however acknowledge those people that want to stop miners from mining
> non-monetary transactions, because of the data storage and processing cost,
> and I recognised that this proposal does nothing to address those concerns.
>
> *** Motivation ***
>
> You can't just change or delete some data from the blockchain, because a
> hash of everything in a block is included in the next block. If you change
> the data, you change the hash. The design presented here is an attempt to
> achieve a compromise, where a person can have all of the benefits of
> running a full node, including the integrity of the ledger, yet without
> storing the objectionable content - and importantly without even being able
> to recreate that objectionable content from what data they still have.
>
> *** Preliminary ***
>
> Objectionable content is defined here as whatever you want it to be, and
> two users don't have to share the same views. One person might object to
> copyrighted material used without permission, another a negative depiction
> of the prophet Muhammad, and another video of the sexual abuse of children.
> The design presented below lets each person decide what to remove for
> themself (if anything), while those who want everything can still have it
> all.
>
> The design lets a user remove any data, and deals with the impact on the
> matching of block hashes, data integrity and malleability.
>
> In the case of OP_RETURN data, the result should be no functional effect
> at all. Whether that's also possible for other data elements will depend on
> the semantics of that data.
>
> *** Solution ***
>
> This solution is based on two ideas, both aimed at maintaining data
> integrity through hashing, while removing some of the hash's input data
> stream.
>
> *** First Idea ***
>
> When performing a hash of some data (D), each chunk of data that's
> processed updates an internal state (S) of the hashing algorithm. If you
> know what the internal state is at point A and then at point B, then you
> can compute the final hash of D even without the data between A and B. This
> is the first idea. First you need to know what S(A) and S(B) are, and once
> you do, you can compute the hash of D, without the data between A and B.
> You run the hashing algorithm normally up to A, then you update the
> internal state from S(A) to S(B), then you continue hashing from B to the
> end of D.
>
> The hash still works as an integrity check for the data before A, and the
> data after B: change any of this, and the final hash will change. Now you
> can safely change or delete the data in between, without breaking the
> integrity of the blockchain and proof of work - but only if you can
> securely obtain S(A) and S(B), and only if you don't need the data between
> A and B for anything else.
>
> The easiest way to obtain S(A) and S(B) is to calculate them yourself, but
> that requires that you hold the objectionable data, at least for a time.
> That also requires finding someone else that holds the objectionable data.
> But what if instead, we could share S(A) and S(B) across the network, do it
> securely, and in a way where up to 100% of nodes could choose to drop the
> data in between, permanently, without breaking anything?
>
> *** Second idea ***
>
> It may seem like there is no one you can trust to tell you what S(A) and
> S(B) are. There is only one source of data that a Bitcoin node can trust,
> and that is the blockchain, as mined by miners, with the most proof of
> work, and verified locally. Therefore, the second idea is that S(A) and
> S(B) are trusted if (and only if) they are written into the blockchain, and
> verified by the network.
>
> For example, we write data to the semantic effect of "In Transaction X: at
> byte offset A, the internal state of the hash function is S1; at byte
> offset B, the internal state of the hash function is S2." Miners then mine
> this statement into a block, and verifiers confirm that it is
> cryptographically accurate with respect to the data in Transaction X as
> described - or else they drop the new block as invalid.
>
> At this point, any node can choose to delete the data between S1 and S2.
> This can now be done with confidence because they can double check the
> accuracy, and the impact on the ledger, before they delete the data. After
> that they may also be able to share (with the agreement of the receiving
> node) this modified transaction as part of initial block downloads, along
> with S1 and S2 - to any other nodes that don't want this objectionable
> content. The receiving nodes wouldn't immediately and necessarily be able
> to trust S1 and S2, but they would eventually, once they have the full
> blockchain.
>
> *** Conclusion ***
>
> This isn't a concrete proposal - it's not even close - but perhaps it
> might be the start of a fruitful conversation. I have more to say, but this
> email is long enough already. Email me if you're interested in discussing
> or developing these ideas together. I have a private Discord server, but
> I'm open to other suggestions, or just further discussion here.
>
> Laissez faire, laissez passer.
>
> Let it be, let it go.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAEM%3Dy%2BXFMXHf7SrCy2NfA4U%2By-fsjL_b2Xb%2B1Fc8Y0wCmYr3NA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 9531 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] A safe way to remove objectionable content from the blockchain
@ 2025-11-20  1:57  1% Lazy Fair
  2025-11-20 18:45  0% ` Greg Maxwell
  2025-11-20 21:21  0% ` Ethan Heilman
  0 siblings, 2 replies; 200+ results
From: Lazy Fair @ 2025-11-20  1:57 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 5741 bytes --]

I propose two changes to Bitcoin, one at the consensus level, and one at
the client level. The purpose of this is to support filtering of
objectionable content after the content has been mined, allowing each node
operator to maintain only that data they find agreeable. In so doing, my
hope is that we can satisfy all users, and deal with their greatest
concerns.

I do however acknowledge those people that want to stop miners from mining
non-monetary transactions, because of the data storage and processing cost,
and I recognised that this proposal does nothing to address those concerns.

*** Motivation ***

You can't just change or delete some data from the blockchain, because a
hash of everything in a block is included in the next block. If you change
the data, you change the hash. The design presented here is an attempt to
achieve a compromise, where a person can have all of the benefits of
running a full node, including the integrity of the ledger, yet without
storing the objectionable content - and importantly without even being able
to recreate that objectionable content from what data they still have.

*** Preliminary ***

Objectionable content is defined here as whatever you want it to be, and
two users don't have to share the same views. One person might object to
copyrighted material used without permission, another a negative depiction
of the prophet Muhammad, and another video of the sexual abuse of children.
The design presented below lets each person decide what to remove for
themself (if anything), while those who want everything can still have it
all.

The design lets a user remove any data, and deals with the impact on the
matching of block hashes, data integrity and malleability.

In the case of OP_RETURN data, the result should be no functional effect at
all. Whether that's also possible for other data elements will depend on
the semantics of that data.

*** Solution ***

This solution is based on two ideas, both aimed at maintaining data
integrity through hashing, while removing some of the hash's input data
stream.

*** First Idea ***

When performing a hash of some data (D), each chunk of data that's
processed updates an internal state (S) of the hashing algorithm. If you
know what the internal state is at point A and then at point B, then you
can compute the final hash of D even without the data between A and B. This
is the first idea. First you need to know what S(A) and S(B) are, and once
you do, you can compute the hash of D, without the data between A and B.
You run the hashing algorithm normally up to A, then you update the
internal state from S(A) to S(B), then you continue hashing from B to the
end of D.

The hash still works as an integrity check for the data before A, and the
data after B: change any of this, and the final hash will change. Now you
can safely change or delete the data in between, without breaking the
integrity of the blockchain and proof of work - but only if you can
securely obtain S(A) and S(B), and only if you don't need the data between
A and B for anything else.

The easiest way to obtain S(A) and S(B) is to calculate them yourself, but
that requires that you hold the objectionable data, at least for a time.
That also requires finding someone else that holds the objectionable data.
But what if instead, we could share S(A) and S(B) across the network, do it
securely, and in a way where up to 100% of nodes could choose to drop the
data in between, permanently, without breaking anything?

*** Second idea ***

It may seem like there is no one you can trust to tell you what S(A) and
S(B) are. There is only one source of data that a Bitcoin node can trust,
and that is the blockchain, as mined by miners, with the most proof of
work, and verified locally. Therefore, the second idea is that S(A) and
S(B) are trusted if (and only if) they are written into the blockchain, and
verified by the network.

For example, we write data to the semantic effect of "In Transaction X: at
byte offset A, the internal state of the hash function is S1; at byte
offset B, the internal state of the hash function is S2." Miners then mine
this statement into a block, and verifiers confirm that it is
cryptographically accurate with respect to the data in Transaction X as
described - or else they drop the new block as invalid.

At this point, any node can choose to delete the data between S1 and S2.
This can now be done with confidence because they can double check the
accuracy, and the impact on the ledger, before they delete the data. After
that they may also be able to share (with the agreement of the receiving
node) this modified transaction as part of initial block downloads, along
with S1 and S2 - to any other nodes that don't want this objectionable
content. The receiving nodes wouldn't immediately and necessarily be able
to trust S1 and S2, but they would eventually, once they have the full
blockchain.

*** Conclusion ***

This isn't a concrete proposal - it's not even close - but perhaps it might
be the start of a fruitful conversation. I have more to say, but this email
is long enough already. Email me if you're interested in discussing or
developing these ideas together. I have a private Discord server, but I'm
open to other suggestions, or just further discussion here.

Laissez faire, laissez passer.

Let it be, let it go.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CABHzxrgbxG1qy3geyNHshA-q6tv0uNNwx5uiswUmAGDDxQjoHg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 7090 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-11  7:43  0%                         ` 'Bitcoin Eagle' via Bitcoin Development Mailing List
@ 2025-11-11 16:23  0%                           ` Greg Maxwell
  0 siblings, 0 replies; 200+ results
From: Greg Maxwell @ 2025-11-11 16:23 UTC (permalink / raw)
  To: Bitcoin Eagle; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 22622 bytes --]

Presigned transactions are quite real and are used by people, e.g. for
inheritance so you can allow your inheritors (or you) to recover your coins
in the future via a more accessible file, while securing the wallet that
can immediately spend to a level that might otherwise cause accidental
funds loss.   They're more flexible than having to stick a recovery
alternative in script and though a relative locktime would be more
reliable, unfortunately they can't be set much into the future under
current consensus rules.

Not everyone is luke-jr whose security practices are to keep a copy of his
'offline' wallet on an online system with a copy of the passphrase for it
just stored in a file next to it.  Had that file had presigned transactions
set a couple years out, he probably wouldn't have turned into an
involuntary nocoiner more interested in getting his way that preserving
Bitcoin's value and stability and we wouldn't need to debate a proposal
that lobotomizes Bitcoin's functionality and will seize users funds just to
further his vanity project.

Not everyone is eager to go into details about their own assets and
security practices, potentially compromising their privacy and safety.  --
and likely most impacted people have no idea of the risk it has for them,
especially when the schemes author is online outright lying about its
properties: https://x.com/LukeDashjr/status/1987267143612703150

(He could debate the degree of confiscation risk,-- though I know for a
fact that it's a certainty-- but saying there is *none* is just a toxic lie
that should cause us to reject his proposal on the principle that the
proposals true creator is outright deceiving the public about it)


On Tue, Nov 11, 2025 at 8:28 AM 'Bitcoin Eagle' via Bitcoin Development
Mailing List <bitcoindev@googlegroups.com> wrote:

> "Okay, if you or anyone can show me an example of a "boring and
> unconcerning thing" that involves pre-signed transactions that use
> deep/OP_IF-containing Taptrees and timelocks, which predates the original
> softfork proposal, I will be happy to update the BIP. Saying "someone might
> be doing this" is simply frivolous obstructionism which, again, could be
> used to stop any attempt to change the consensus rules."
>
> If we skip the pontential strawman of presigned transaction let's describe
> realistic problem.
>
>    1. You have sensible multisig wallet which breaks one of the OP_IF or
>    merklepath restrictions. And you don't even know how it works inside.
>    2. To avoid confiscation you need to create a new wallet which is
>    designed in compliance with BIP444. Is there new miniscript compiler
>    available in time?
>    3. Migrate all UTXOs to new wallet
>    4. The real risk of confiscation are change addresses. After
>    activation spending will work thanks to one time whitelist. But it creates
>    a change which will be new UTXO unspendable
>
>
> On Monday, November 10, 2025 at 6:34:39 AM UTC+7 dath...@proton.me wrote:
>
>> Hi Greg -
>>
>> >It's not speculative-- nlocktime is a day one feature which *is* used in
>> Bitcoin.
>>
>> Correct, I have not claimed otherwise.
>>
>> >Sure someone could footgun themselves by intentionally using a
>> transaction field which is expressly intended for forward compatibility and
>> get themselves burned-- but they'd have to be trying, not just doing a
>> boring and unconcerning thing because those fields don't do anything so the
>> only reason to use them would be an outright error or intentionally trying
>> to break themselves.
>>
>> Okay, if you or anyone can show me an example of a "boring and
>> unconcerning thing" that involves pre-signed transactions that use
>> deep/OP_IF-containing Taptrees and timelocks, which predates the
>> original softfork proposal, I will be happy to update the BIP. Saying
>> "someone might be doing this" is simply frivolous obstructionism which,
>> again, could be used to stop any attempt to change the consensus rules.
>>
>> >This is also not a new concern being raised for your proposal, every
>> softfork post P2SH has been analyzed under this lens so it's quite
>> concerning to see the proposal here simply ignore the concern.
>>
>> I believe the utility of the strategy of "don't break any use cases, no
>> matter how pathological" has finally worn out. The longer we continue down
>> this path, the more likely it is that Bitcoin will become *entirely*
>> pathological use cases.
>>
>> Accordingly, this BIP *intentionally* disrupts all of the most harmful
>> use cases, because they are making Bitcoin worse money and the problem is
>> accelerating. But as stated before, the proposal also takes great pains not
>> to disrupt any non-pathological use cases, and again I'm open to revising
>> the spec if a concrete example that would be harmed by this softfork is
>> found.
>>
>> >And indeed I haven't read a new version because your prior message
>> provided no reference to it
>>
>> It is attached as a file to my email. Does your email client not support
>> attachments? I'll be sure to include a browser-friendly link next time if
>> that's the case.
>>
>> >I was responding to the summary.
>>
>> The summary mentioned that I had removed all references to legal risks.
>>
>> >Now looking at it, I see that you are still limiting scriptpubkey sizes
>> strictly-- this will absolutely confiscate funds as was pointed out and not
>> responded to even before your proposal. (because luke-jr proposed just that
>> limit first-- actually a more relaxed version, then simply dishonestly
>> insisted there was no opposition to it, even though opposition was
>> immediately raised on the list).
>>
>> If you're referring to Andrew Poelstra's message here
>> <https://groups.google.com/g/bitcoindev/c/YO8ZwnG_ISs/m/4KvpvYNEAgAJ>,
>> that doesn't strike me as "opposition", and besides, note that this
>> proposal implements a very similar mitigation suggestion, which was:
>>
>> >In any case, if confiscation is a worry, as always we can exempt the
>> current UTXO set from the rule -- if you are only spending outputs that
>> existed prior to the new rule, your new UTXOs are allowed to be large.
>>
>> The current proposal exempts *inputs* that spend from the current UTXO
>> set, but does not allow such transactions to create outputs that violate
>> the new rules. This should be fine, since the funds can just be sent to a
>> different wallet, (assuming there is actually wallet software somewhere
>> that habitually creates outputs with scriptPubKeys larger than 34 bytes).
>>
>> Please let me know if this is not the "opposition" you were referring to;
>> I searched for a while but it's possible I missed something. Again, I am
>> eager to address all valid technical objections to this proposal, and so
>> far I haven't seen any.
>>
>> >I think your proposal continues to have no serious prospect of activation
>>
>> I disagree. I think Bitcoin users are fed up with data spam and ready to
>> coordinate to say "enough is enough".
>>
>> >should it activate in any form it will just be forked against
>>
>> That would be incredibly risky, but of course people are welcome to run
>> whatever software they choose.
>>
>> >and its authors will likely find themselves mired in litigation by
>> people harmed by it
>>
>> Just to clarify, are you saying that anyone who doesn't support the URSF
>> will face legal risks?
>>
>> >I think you'll find that almost every significant bitcoin developer will
>> stand against such a change and will not work on a fork that adopts them, I
>> also doubt the market would value your fork with such significant
>> limitations very highly.
>>
>> I think you are mistaken. The Bitcoin community wants Bitcoin to be
>> money, not data storage.
>>
>> Best,
>>
>> Dathon
>> On Saturday, November 8th, 2025 at 3:58 PM, Greg Maxwell <
>> gmax...@gmail.com> wrote:
>>
>> It's not speculative-- nlocktime is a day one feature which *is* used in
>> Bitcoin.
>>
>> Sure someone could footgun themselves by intentionally using a
>> transaction field which is expressly intended for forward compatibility and
>> get themselves burned-- but they'd have to be trying, not just doing a
>> boring and unconcerning thing because those fields don't do anything so the
>> only reason to use them would be an outright error or intentionally trying
>> to break themselves.
>>
>> This is also not a new concern being raised for your proposal, every
>> softfork post P2SH has been analyzed under this lens so it's quite
>> concerning to see the proposal here simply ignore the concern.
>>
>> Even the intentional forward compat features have caused some lack of
>> comfort in the past in this respect, which is why tapscript OP_SUCCESS
>> works the way it does: so that any script that prematurely uses a 'success'
>> opcode would be inherently completely insecure-- an important improvement
>> in upgradability that your proposal permanently destroys without you even
>> understanding why it existed in the first place.
>>
>> And indeed I haven't read a new version because your prior message
>> provided no reference to it-- it said you were requested to update the list
>> and then you only provided a summary. I was responding to the summary.
>>
>> Now looking at it, I see that you are still limiting scriptpubkey sizes
>> strictly-- this will absolutely confiscate funds as was pointed out and not
>> responded to even before your proposal. (because luke-jr proposed just that
>> limit first-- actually a more relaxed version, then simply dishonestly
>> insisted there was no opposition to it, even though opposition was
>> immediately raised on the list).
>>
>> I think your proposal continues to have no serious prospect of
>> activation, and should it activate in any form it will just be forked
>> against and its authors will likely find themselves mired in litigation by
>> people harmed by it. I think you'll find that almost every significant
>> bitcoin developer will stand against such a change and will not work on a
>> fork that adopts them, I also doubt the market would value your fork with
>> such significant limitations very highly.
>>
>>
>> On Sat, Nov 8, 2025 at 9:02 PM <dath...@proton.me> wrote:
>>
>>> Hi Greg -
>>>
>>> >That doesn't address the confiscation problem (although any reduction
>>> in the restriction does reduce it), as there likely exist chains of not yet
>>> confirmed (and potentially timelocked) transactions that involve violations
>>> of this rule. Those would appear to the network to be outputs created at a
>>> later time, although they really weren't. It's unclear to me why you
>>> haven't yet understood this point.
>>>
>>> While I completely agree that "confiscation" is a precedent we must
>>> avoid setting, I think my proposal neither confiscates funds nor sets a bad
>>> precedent, as it takes pains to avoid causing problems for all known use
>>> cases. I don't think it is reasonable never to create problems for all
>>> *unknown* use cases, as this would necessarily imply permanent
>>> ossification.
>>>
>>> To illustrate the point: it is possible to design off-chain systems that
>>> "use" any given feature of the Bitcoin protocol, including, for example,
>>> OP_NOPs. Funds locked in such UTXOs would be "confiscated" by the softfork
>>> proposal that redefines the OP_NOP. That is, anyone could intentionally
>>> lock funds into a pathological construction in order to obstruct any given
>>> softfork.
>>>
>>> Thus, if taken to the extreme, the argument that no one should ever have
>>> funds "confiscated", or even temporarily frozen, means that we can never
>>> upgrade Bitcoin again. So, in the interest of avoiding permanent
>>> ossification, it seems wise for us to compromise somewhere in the middle. I
>>> think my proposal strikes a good balance.
>>>
>>> Of course, if people are reporting that there are known,
>>> non-pathological use cases with significant funds locked into pre-signed
>>> transactions, then of course I will modify the proposal to accommodate them.
>>>
>>> >Another issue raised which you have not mentioned is that prior to you
>>> making this proposal I received minutes from a meeting which noted that
>>> Ocean Mining was the true author of this proposal and would be presenting
>>> it under a false identity in order to conceal their involvement. Will you
>>> be correcting the record on the true authorship of this work and on whose
>>> behalf its being performed?
>>>
>>> It sounds like you have fallen victim to some false rumors.
>>>
>>> I already attempted to correct the record on this, both here on this
>>> mailing list and on the BIP PR, but both times my messages were suppressed
>>> by moderators.
>>>
>>> I humbly request that moderators let the public see my response this
>>> time, otherwise I'm not sure how the record will ever be corrected:
>>>
>>> Though I am in direct communication with some Ocean employees (and the
>>> BIP was originally drafted by one of them), *I am not affiliated with
>>> Ocean in any way*. I am just a Bitcoin dev who is concerned about the
>>> implications of Core 30 having been released and gaining adoption.
>>>
>>> *I am acting solely on my own behalf and on the behalf of the Bitcoin
>>> community*, because I and most Bitcoiners I know are concerned about
>>> Bitcoin's future if it embraces data storage as a supported use case.
>>>
>>> This proposal is also a significant departure from the original BIP
>>> draft.
>>>
>>> >Would you then agree that this proposal will fail at its stated
>>> purpose, particularly with respect to concerns about potentially 'unlawful'
>>> material?
>>>
>>> No, I think this proposal is the best way to achieve its stated purpose,
>>> which is to reject the standardization of data storage as a supported use
>>> case, at the consensus level.
>>>
>>> It sounds like you haven't read the new version of the BIP, nor my
>>> summary above. I attached the document in my previous email message if you
>>> are interested. It removes all references to legal risks.
>>>
>>> For those who prefer viewing the proposal in a browser, I have pushed a
>>> copy of it to a non-PR branch, since the PR is still locked:
>>> https://github.com/dathonohm/bips/blob/reduced-data-v2/bip-%3F%3F%3F%3F.mediawiki
>>>
>>> >As that concern as expressed has a threshold of "any at all" and could
>>> just as well be performed via a "less commonly abused" path? Would you also
>>> agree the same for essentially all other forms-- that they'd simply made a
>>> few line of code changes and then evade these restrictions?
>>>
>>> Again, this is no longer applicable to the proposal. The new draft makes
>>> significant changes.
>>>
>>> >In light of that, how would the very real and significant reductions in
>>> intentional functionality (such as efficient "few of dozens" multisigs or
>>> other such constructs) be justified? How could the confiscation risk be
>>> justified? How could the deployment costs be justified? How could the
>>> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in
>>> to an endless sequences of 'update' blocking actions, each carrying its own
>>> risk and disruptions)
>>>
>>> I don't see this softfork as an "update-blocking action"; on the
>>> contrary, I see it as an update-enabling one. As I stated previously,
>>> attempting to never disrupt any use cases, no matter how pathological, is
>>> the fastest path to ossification.
>>>
>>> Indeed, Bitcoin has failed to make any consensus upgrades at all since
>>> Taproot in 2021. The community has been going in circles now for two years
>>> because of pathological use cases introduced by that fork, and this
>>> proposal allows Bitcoiners to say "enough is enough", re-affirm that
>>> Bitcoin is *money* rather than *data storage* by disabling all the most
>>> popular methods of data abuse, and move on to more exciting things. We
>>> could have new upgrades in one year if Bitcoiners focus on building them
>>> over the following months.
>>>
>>> I honestly don't see a better way out of this morass, but please let me
>>> know your reasoning if you disagree. Inaction is not going to solve this.
>>>
>>> >I don't think your suggested revisions will move your proposal off from
>>> having essentially zero risk of adoption, and if it were adopted (which I
>>> think is unlikely)
>>>
>>> I don't see much reason *not* to adopt it, besides fear of softforks in
>>> general, but I'm listening.
>>>
>>> >I think it's a certainty that there would be a countering fork to
>>> continue a Bitcoin without these poorly justified (even essentially
>>> useless) restrictions.
>>>
>>> I don't see why anyone in their right mind would choose to bet on the
>>> old fork where Bitcoin is filled with spam and confused about whether it
>>> might want to just be a database, over the new one where Bitcoin is money.
>>>
>>> Best regards,
>>>
>>> Dathon
>>> On Saturday, November 8th, 2025 at 9:48 AM, Greg Maxwell <
>>> gmax...@gmail.com> wrote:
>>>
>>> On Sat, Nov 8, 2025 at 12:58 AM dathonohm via Bitcoin Development
>>> Mailing List <bitco...@googlegroups.com> wrote:
>>>
>>>>
>>>>    1. "Funds confiscation": due to the presence of UTXOs that would be
>>>>    made temporarily unspendable by this proposal, commenters were concerned
>>>>    that this would set a precedent of "confiscation". This new draft resolves
>>>>    this concern by adding a UTXO height check to make sure *only UTXOs
>>>>    that are created while the softfork is active will be made temporarily
>>>>    unspendable*. The "OP_IF in Tapscript" and "257-byte control block
>>>>    limit" were the two main proposed rule changes that caused concern here.
>>>>
>>>>
>>> That doesn't address the confiscation problem (although any reduction in
>>> the restriction does reduce it), as there likely exist chains of not yet
>>> confirmed (and potentially timelocked) transactions that involve violations
>>> of this rule. Those would appear to the network to be outputs created at a
>>> later time, although they really weren't. It's unclear to me why you
>>> haven't yet understood this point.
>>>
>>> I don't think this concern was in any way limited to the control block
>>> of op_if components either, essentially every aspect of the proposal has
>>> confiscation issues.
>>>
>>> Another issue raised which you have not mentioned is that prior to you
>>> making this proposal I received minutes from a meeting which noted that
>>> Ocean Mining was the true author of this proposal and would be presenting
>>> it under a false identity in order to conceal their involvement. Will you
>>> be correcting the record on the true authorship of this work and on whose
>>> behalf its being performed?
>>>
>>> > "This doesn't block all possible methods of arbitrary data
>>> insertion": This was already addressed in the previous draft, but to
>>> reiterate: this proposal's goal is not to block *all* methods of
>>> arbitary data insertion, just the most commonly abused ones.
>>>
>>> Would you then agree that this proposal will fail at its stated purpose,
>>> particularly with respect to concerns about potentially 'unlawful'
>>> material? As that concern as expressed has a threshold of "any at all" and
>>> could just as well be performed via a "less commonly abused" path? Would
>>> you also agree the same for essentially all other forms-- that they'd
>>> simply made a few line of code changes and then evade these restrictions?
>>>
>>> In light of that, how would the very real and significant reductions in
>>> intentional functionality (such as efficient "few of dozens" multisigs or
>>> other such constructs) be justified? How could the confiscation risk be
>>> justified? How could the deployment costs be justified? How could the
>>> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in
>>> to an endless sequences of 'update' blocking actions, each carrying its own
>>> risk and disruptions)
>>>
>>> Although your description of changes is vague and it's not possible to
>>> tell for sure without seeing the actual updates-- I don't think your
>>> suggested revisions will move your proposal off from having essentially
>>> zero risk of adoption, and if it were adopted (which I think is unlikely) I
>>> think it's a certainty that there would be a countering fork to continue a
>>> Bitcoin without these poorly justified (even essentially useless)
>>> restrictions.
>>>
>>>
>>>
>>>
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQy%2BqiRv%3DwGHB5_5Hgxmj9kbJiT9PXpd1VbiUFPwATg-g%40mail.gmail.com
>>> .
>>>
>>>
>>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+...@googlegroups.com.
>>
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTCFx2yvvUu9YWwcm-SSojT530Uwzi0b3sOG0%2BVZEcaAw%40mail.gmail.com
>> .
>>
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/86d11552-36d8-46d7-998c-ed6875a5a84bn%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/86d11552-36d8-46d7-998c-ed6875a5a84bn%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgR7wKyV3vgwTrqidhyDz6CAU%3D4aGCT%3D6jr8fDM6UMQbrw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 38339 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-09 20:07  1%                       ` dathonohm via Bitcoin Development Mailing List
@ 2025-11-11  7:43  0%                         ` 'Bitcoin Eagle' via Bitcoin Development Mailing List
  2025-11-11 16:23  0%                           ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: 'Bitcoin Eagle' via Bitcoin Development Mailing List @ 2025-11-11  7:43 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 19997 bytes --]

"Okay, if you or anyone can show me an example of a "boring and 
unconcerning thing" that involves pre-signed transactions that use 
deep/OP_IF-containing Taptrees and timelocks, which predates the original 
softfork proposal, I will be happy to update the BIP. Saying "someone might 
be doing this" is simply frivolous obstructionism which, again, could be 
used to stop any attempt to change the consensus rules."

If we skip the pontential strawman of presigned transaction let's describe 
realistic problem.

   1. You have sensible multisig wallet which breaks one of the OP_IF or 
   merklepath restrictions. And you don't even know how it works inside.
   2. To avoid confiscation you need to create a new wallet which is 
   designed in compliance with BIP444. Is there new miniscript compiler 
   available in time? 
   3. Migrate all UTXOs to new wallet
   4. The real risk of confiscation are change addresses. After activation 
   spending will work thanks to one time whitelist. But it creates a change 
   which will be new UTXO unspendable


On Monday, November 10, 2025 at 6:34:39 AM UTC+7 dath...@proton.me wrote:

> Hi Greg -
>
> >It's not speculative-- nlocktime is a day one feature which *is* used in 
> Bitcoin.
>
> Correct, I have not claimed otherwise.
>
> >Sure someone could footgun themselves by intentionally using a 
> transaction field which is expressly intended for forward compatibility and 
> get themselves burned-- but they'd have to be trying, not just doing a 
> boring and unconcerning thing because those fields don't do anything so the 
> only reason to use them would be an outright error or intentionally trying 
> to break themselves.
>
> Okay, if you or anyone can show me an example of a "boring and 
> unconcerning thing" that involves pre-signed transactions that use 
> deep/OP_IF-containing Taptrees and timelocks, which predates the original 
> softfork proposal, I will be happy to update the BIP. Saying "someone 
> might be doing this" is simply frivolous obstructionism which, again, could 
> be used to stop any attempt to change the consensus rules.
>
> >This is also not a new concern being raised for your proposal, every 
> softfork post P2SH has been analyzed under this lens so it's quite 
> concerning to see the proposal here simply ignore the concern.
>
> I believe the utility of the strategy of "don't break any use cases, no 
> matter how pathological" has finally worn out. The longer we continue down 
> this path, the more likely it is that Bitcoin will become *entirely* 
> pathological use cases.
>
> Accordingly, this BIP *intentionally* disrupts all of the most harmful 
> use cases, because they are making Bitcoin worse money and the problem is 
> accelerating. But as stated before, the proposal also takes great pains not 
> to disrupt any non-pathological use cases, and again I'm open to revising 
> the spec if a concrete example that would be harmed by this softfork is 
> found.
>
> >And indeed I haven't read a new version because your prior message 
> provided no reference to it
>
> It is attached as a file to my email. Does your email client not support 
> attachments? I'll be sure to include a browser-friendly link next time if 
> that's the case.
>
> >I was responding to the summary.
>
> The summary mentioned that I had removed all references to legal risks.
>
> >Now looking at it, I see that you are still limiting scriptpubkey sizes 
> strictly-- this will absolutely confiscate funds as was pointed out and not 
> responded to even before your proposal. (because luke-jr proposed just that 
> limit first-- actually a more relaxed version, then simply dishonestly 
> insisted there was no opposition to it, even though opposition was 
> immediately raised on the list).
>
> If you're referring to Andrew Poelstra's message here 
> <https://groups.google.com/g/bitcoindev/c/YO8ZwnG_ISs/m/4KvpvYNEAgAJ>, 
> that doesn't strike me as "opposition", and besides, note that this 
> proposal implements a very similar mitigation suggestion, which was:
>
> >In any case, if confiscation is a worry, as always we can exempt the 
> current UTXO set from the rule -- if you are only spending outputs that 
> existed prior to the new rule, your new UTXOs are allowed to be large.
>
> The current proposal exempts *inputs* that spend from the current UTXO 
> set, but does not allow such transactions to create outputs that violate 
> the new rules. This should be fine, since the funds can just be sent to a 
> different wallet, (assuming there is actually wallet software somewhere 
> that habitually creates outputs with scriptPubKeys larger than 34 bytes).
>
> Please let me know if this is not the "opposition" you were referring to; 
> I searched for a while but it's possible I missed something. Again, I am 
> eager to address all valid technical objections to this proposal, and so 
> far I haven't seen any.
>
> >I think your proposal continues to have no serious prospect of activation
>
> I disagree. I think Bitcoin users are fed up with data spam and ready to 
> coordinate to say "enough is enough".
>
> >should it activate in any form it will just be forked against
>
> That would be incredibly risky, but of course people are welcome to run 
> whatever software they choose.
>
> >and its authors will likely find themselves mired in litigation by people 
> harmed by it
>
> Just to clarify, are you saying that anyone who doesn't support the URSF 
> will face legal risks?
>
> >I think you'll find that almost every significant bitcoin developer will 
> stand against such a change and will not work on a fork that adopts them, I 
> also doubt the market would value your fork with such significant 
> limitations very highly.
>
> I think you are mistaken. The Bitcoin community wants Bitcoin to be money, 
> not data storage.
>
> Best,
>
> Dathon
> On Saturday, November 8th, 2025 at 3:58 PM, Greg Maxwell <
> gmax...@gmail.com> wrote:
>
> It's not speculative-- nlocktime is a day one feature which *is* used in 
> Bitcoin.
>
> Sure someone could footgun themselves by intentionally using a transaction 
> field which is expressly intended for forward compatibility and get 
> themselves burned-- but they'd have to be trying, not just doing a boring 
> and unconcerning thing because those fields don't do anything so the only 
> reason to use them would be an outright error or intentionally trying to 
> break themselves.
>
> This is also not a new concern being raised for your proposal, every 
> softfork post P2SH has been analyzed under this lens so it's quite 
> concerning to see the proposal here simply ignore the concern.
>
> Even the intentional forward compat features have caused some lack of 
> comfort in the past in this respect, which is why tapscript OP_SUCCESS 
> works the way it does: so that any script that prematurely uses a 'success' 
> opcode would be inherently completely insecure-- an important improvement 
> in upgradability that your proposal permanently destroys without you even 
> understanding why it existed in the first place.
>
> And indeed I haven't read a new version because your prior message 
> provided no reference to it-- it said you were requested to update the list 
> and then you only provided a summary. I was responding to the summary.
>
> Now looking at it, I see that you are still limiting scriptpubkey sizes 
> strictly-- this will absolutely confiscate funds as was pointed out and not 
> responded to even before your proposal. (because luke-jr proposed just that 
> limit first-- actually a more relaxed version, then simply dishonestly 
> insisted there was no opposition to it, even though opposition was 
> immediately raised on the list).
>
> I think your proposal continues to have no serious prospect of activation, 
> and should it activate in any form it will just be forked against and its 
> authors will likely find themselves mired in litigation by people harmed by 
> it. I think you'll find that almost every significant bitcoin developer 
> will stand against such a change and will not work on a fork that adopts 
> them, I also doubt the market would value your fork with such significant 
> limitations very highly.
>
>
> On Sat, Nov 8, 2025 at 9:02 PM <dath...@proton.me> wrote:
>
>> Hi Greg -
>>
>> >That doesn't address the confiscation problem (although any reduction in 
>> the restriction does reduce it), as there likely exist chains of not yet 
>> confirmed (and potentially timelocked) transactions that involve violations 
>> of this rule. Those would appear to the network to be outputs created at a 
>> later time, although they really weren't. It's unclear to me why you 
>> haven't yet understood this point.
>>
>> While I completely agree that "confiscation" is a precedent we must avoid 
>> setting, I think my proposal neither confiscates funds nor sets a bad 
>> precedent, as it takes pains to avoid causing problems for all known use 
>> cases. I don't think it is reasonable never to create problems for all 
>> *unknown* use cases, as this would necessarily imply permanent 
>> ossification.
>>
>> To illustrate the point: it is possible to design off-chain systems that 
>> "use" any given feature of the Bitcoin protocol, including, for example, 
>> OP_NOPs. Funds locked in such UTXOs would be "confiscated" by the softfork 
>> proposal that redefines the OP_NOP. That is, anyone could intentionally 
>> lock funds into a pathological construction in order to obstruct any given 
>> softfork.
>>
>> Thus, if taken to the extreme, the argument that no one should ever have 
>> funds "confiscated", or even temporarily frozen, means that we can never 
>> upgrade Bitcoin again. So, in the interest of avoiding permanent 
>> ossification, it seems wise for us to compromise somewhere in the middle. I 
>> think my proposal strikes a good balance.
>>
>> Of course, if people are reporting that there are known, non-pathological 
>> use cases with significant funds locked into pre-signed transactions, then 
>> of course I will modify the proposal to accommodate them.
>>
>> >Another issue raised which you have not mentioned is that prior to you 
>> making this proposal I received minutes from a meeting which noted that 
>> Ocean Mining was the true author of this proposal and would be presenting 
>> it under a false identity in order to conceal their involvement. Will you 
>> be correcting the record on the true authorship of this work and on whose 
>> behalf its being performed?
>>
>> It sounds like you have fallen victim to some false rumors.
>>
>> I already attempted to correct the record on this, both here on this 
>> mailing list and on the BIP PR, but both times my messages were suppressed 
>> by moderators.
>>
>> I humbly request that moderators let the public see my response this 
>> time, otherwise I'm not sure how the record will ever be corrected:
>>
>> Though I am in direct communication with some Ocean employees (and the 
>> BIP was originally drafted by one of them), *I am not affiliated with 
>> Ocean in any way*. I am just a Bitcoin dev who is concerned about the 
>> implications of Core 30 having been released and gaining adoption.
>>
>> *I am acting solely on my own behalf and on the behalf of the Bitcoin 
>> community*, because I and most Bitcoiners I know are concerned about 
>> Bitcoin's future if it embraces data storage as a supported use case.
>>
>> This proposal is also a significant departure from the original BIP draft.
>>
>> >Would you then agree that this proposal will fail at its stated purpose, 
>> particularly with respect to concerns about potentially 'unlawful' material?
>>
>> No, I think this proposal is the best way to achieve its stated purpose, 
>> which is to reject the standardization of data storage as a supported use 
>> case, at the consensus level.
>>
>> It sounds like you haven't read the new version of the BIP, nor my 
>> summary above. I attached the document in my previous email message if you 
>> are interested. It removes all references to legal risks.
>>
>> For those who prefer viewing the proposal in a browser, I have pushed a 
>> copy of it to a non-PR branch, since the PR is still locked: 
>> https://github.com/dathonohm/bips/blob/reduced-data-v2/bip-%3F%3F%3F%3F.mediawiki
>>
>> >As that concern as expressed has a threshold of "any at all" and could 
>> just as well be performed via a "less commonly abused" path? Would you also 
>> agree the same for essentially all other forms-- that they'd simply made a 
>> few line of code changes and then evade these restrictions?
>>
>> Again, this is no longer applicable to the proposal. The new draft makes 
>> significant changes.
>>
>> >In light of that, how would the very real and significant reductions in 
>> intentional functionality (such as efficient "few of dozens" multisigs or 
>> other such constructs) be justified? How could the confiscation risk be 
>> justified? How could the deployment costs be justified? How could the 
>> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in 
>> to an endless sequences of 'update' blocking actions, each carrying its own 
>> risk and disruptions)
>>
>> I don't see this softfork as an "update-blocking action"; on the 
>> contrary, I see it as an update-enabling one. As I stated previously, 
>> attempting to never disrupt any use cases, no matter how pathological, is 
>> the fastest path to ossification.
>>
>> Indeed, Bitcoin has failed to make any consensus upgrades at all since 
>> Taproot in 2021. The community has been going in circles now for two years 
>> because of pathological use cases introduced by that fork, and this 
>> proposal allows Bitcoiners to say "enough is enough", re-affirm that 
>> Bitcoin is *money* rather than *data storage* by disabling all the most 
>> popular methods of data abuse, and move on to more exciting things. We 
>> could have new upgrades in one year if Bitcoiners focus on building them 
>> over the following months.
>>
>> I honestly don't see a better way out of this morass, but please let me 
>> know your reasoning if you disagree. Inaction is not going to solve this.
>>
>> >I don't think your suggested revisions will move your proposal off from 
>> having essentially zero risk of adoption, and if it were adopted (which I 
>> think is unlikely)
>>
>> I don't see much reason *not* to adopt it, besides fear of softforks in 
>> general, but I'm listening.
>>
>> >I think it's a certainty that there would be a countering fork to 
>> continue a Bitcoin without these poorly justified (even essentially 
>> useless) restrictions.
>>
>> I don't see why anyone in their right mind would choose to bet on the old 
>> fork where Bitcoin is filled with spam and confused about whether it might 
>> want to just be a database, over the new one where Bitcoin is money.
>>
>> Best regards,
>>
>> Dathon
>> On Saturday, November 8th, 2025 at 9:48 AM, Greg Maxwell <
>> gmax...@gmail.com> wrote:
>>
>> On Sat, Nov 8, 2025 at 12:58 AM dathonohm via Bitcoin Development Mailing 
>> List <bitco...@googlegroups.com> wrote:
>>
>>>
>>>    1. "Funds confiscation": due to the presence of UTXOs that would be 
>>>    made temporarily unspendable by this proposal, commenters were concerned 
>>>    that this would set a precedent of "confiscation". This new draft resolves 
>>>    this concern by adding a UTXO height check to make sure *only UTXOs 
>>>    that are created while the softfork is active will be made temporarily 
>>>    unspendable*. The "OP_IF in Tapscript" and "257-byte control block 
>>>    limit" were the two main proposed rule changes that caused concern here.
>>>
>>>
>> That doesn't address the confiscation problem (although any reduction in 
>> the restriction does reduce it), as there likely exist chains of not yet 
>> confirmed (and potentially timelocked) transactions that involve violations 
>> of this rule. Those would appear to the network to be outputs created at a 
>> later time, although they really weren't. It's unclear to me why you 
>> haven't yet understood this point.
>>
>> I don't think this concern was in any way limited to the control block of 
>> op_if components either, essentially every aspect of the proposal has 
>> confiscation issues.
>>
>> Another issue raised which you have not mentioned is that prior to you 
>> making this proposal I received minutes from a meeting which noted that 
>> Ocean Mining was the true author of this proposal and would be presenting 
>> it under a false identity in order to conceal their involvement. Will you 
>> be correcting the record on the true authorship of this work and on whose 
>> behalf its being performed?
>>
>> > "This doesn't block all possible methods of arbitrary data insertion": 
>> This was already addressed in the previous draft, but to reiterate: this 
>> proposal's goal is not to block *all* methods of arbitary data 
>> insertion, just the most commonly abused ones.
>>
>> Would you then agree that this proposal will fail at its stated purpose, 
>> particularly with respect to concerns about potentially 'unlawful' 
>> material? As that concern as expressed has a threshold of "any at all" and 
>> could just as well be performed via a "less commonly abused" path? Would 
>> you also agree the same for essentially all other forms-- that they'd 
>> simply made a few line of code changes and then evade these restrictions?
>>
>> In light of that, how would the very real and significant reductions in 
>> intentional functionality (such as efficient "few of dozens" multisigs or 
>> other such constructs) be justified? How could the confiscation risk be 
>> justified? How could the deployment costs be justified? How could the 
>> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in 
>> to an endless sequences of 'update' blocking actions, each carrying its own 
>> risk and disruptions)
>>
>> Although your description of changes is vague and it's not possible to 
>> tell for sure without seeing the actual updates-- I don't think your 
>> suggested revisions will move your proposal off from having essentially 
>> zero risk of adoption, and if it were adopted (which I think is unlikely) I 
>> think it's a certainty that there would be a countering fork to continue a 
>> Bitcoin without these poorly justified (even essentially useless) 
>> restrictions.
>>
>>
>>
>>
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQy%2BqiRv%3DwGHB5_5Hgxmj9kbJiT9PXpd1VbiUFPwATg-g%40mail.gmail.com
>> .
>>
>>
>> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTCFx2yvvUu9YWwcm-SSojT530Uwzi0b3sOG0%2BVZEcaAw%40mail.gmail.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/86d11552-36d8-46d7-998c-ed6875a5a84bn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 36323 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-08 21:39  0%                     ` Greg Maxwell
@ 2025-11-09 20:07  1%                       ` dathonohm via Bitcoin Development Mailing List
  2025-11-11  7:43  0%                         ` 'Bitcoin Eagle' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: dathonohm via Bitcoin Development Mailing List @ 2025-11-09 20:07 UTC (permalink / raw)
  To: Greg Maxwell
  Cc: Erik Aronesty, Antoine Riard, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 17874 bytes --]

Hi Greg -

>It's not speculative-- nlocktime is a day one feature which *is* used in Bitcoin.

Correct, I have not claimed otherwise.

>Sure someone could footgun themselves by intentionally using a transaction field which is expressly intended for forward compatibility and get themselves burned-- but they'd have to be trying, not just doing a boring and unconcerning thing because those fields don't do anything so the only reason to use them would be an outright error or intentionally trying to break themselves.

Okay, if you or anyone can show me an example of a "boring and unconcerning thing" that involves pre-signed transactions that use deep/OP_IF-containing Taptrees and timelocks, which predates the original softfork proposal, I will be happy to update the BIP. Saying "someone might be doing this" is simply frivolous obstructionism which, again, could be used to stop any attempt to change the consensus rules.

>This is also not a new concern being raised for your proposal, every softfork post P2SH has been analyzed under this lens so it's quite concerning to see the proposal here simply ignore the concern.

I believe the utility of the strategy of "don't break any use cases, no matter how pathological" has finally worn out. The longer we continue down this path, the more likely it is that Bitcoin will become entirely pathological use cases.

Accordingly, this BIP intentionally disrupts all of the most harmful use cases, because they are making Bitcoin worse money and the problem is accelerating. But as stated before, the proposal also takes great pains not to disrupt any non-pathological use cases, and again I'm open to revising the spec if a concrete example that would be harmed by this softfork is found.

>And indeed I haven't read a new version because your prior message provided no reference to it

It is attached as a file to my email. Does your email client not support attachments? I'll be sure to include a browser-friendly link next time if that's the case.

>I was responding to the summary.

The summary mentioned that I had removed all references to legal risks.

>Now looking at it, I see that you are still limiting scriptpubkey sizes strictly-- this will absolutely confiscate funds as was pointed out and not responded to even before your proposal. (because luke-jr proposed just that limit first-- actually a more relaxed version, then simply dishonestly insisted there was no opposition to it, even though opposition was immediately raised on the list).

If you're referring to [Andrew Poelstra's message here](https://groups.google.com/g/bitcoindev/c/YO8ZwnG_ISs/m/4KvpvYNEAgAJ), that doesn't strike me as "opposition", and besides, note that this proposal implements a very similar mitigation suggestion, which was:

>In any case, if confiscation is a worry, as always we can exempt the
current UTXO set from the rule -- if you are only spending outputs that
existed prior to the new rule, your new UTXOs are allowed to be large.

The current proposal exempts inputs that spend from the current UTXO set, but does not allow such transactions to create outputs that violate the new rules. This should be fine, since the funds can just be sent to a different wallet, (assuming there is actually wallet software somewhere that habitually creates outputs with scriptPubKeys larger than 34 bytes).

Please let me know if this is not the "opposition" you were referring to; I searched for a while but it's possible I missed something. Again, I am eager to address all valid technical objections to this proposal, and so far I haven't seen any.

>I think your proposal continues to have no serious prospect of activation

I disagree. I think Bitcoin users are fed up with data spam and ready to coordinate to say "enough is enough".

>should it activate in any form it will just be forked against

That would be incredibly risky, but of course people are welcome to run whatever software they choose.

>and its authors will likely find themselves mired in litigation by people harmed by it

Just to clarify, are you saying that anyone who doesn't support the URSF will face legal risks?

>I think you'll find that almost every significant bitcoin developer will stand against such a change and will not work on a fork that adopts them, I also doubt the market would value your fork with such significant limitations very highly.

I think you are mistaken. The Bitcoin community wants Bitcoin to be money, not data storage.

Best,

Dathon
On Saturday, November 8th, 2025 at 3:58 PM, Greg Maxwell <gmaxwell@gmail.com> wrote:

> It's not speculative-- nlocktime is a day one feature which *is* used in Bitcoin.
>
> Sure someone could footgun themselves by intentionally using a transaction field which is expressly intended for forward compatibility and get themselves burned-- but they'd have to be trying, not just doing a boring and unconcerning thing because those fields don't do anything so the only reason to use them would be an outright error or intentionally trying to break themselves.
>
> This is also not a new concern being raised for your proposal, every softfork post P2SH has been analyzed under this lens so it's quite concerning to see the proposal here simply ignore the concern.
> Even the intentional forward compat features have caused some lack of comfort in the past in this respect, which is why tapscript OP_SUCCESS works the way it does: so that any script that prematurely uses a 'success' opcode would be inherently completely insecure-- an important improvement in upgradability that your proposal permanently destroys without you even understanding why it existed in the first place.
>
> And indeed I haven't read a new version because your prior message provided no reference to it-- it said you were requested to update the list and then you only provided a summary. I was responding to the summary.
>
> Now looking at it, I see that you are still limiting scriptpubkey sizes strictly-- this will absolutely confiscate funds as was pointed out and not responded to even before your proposal. (because luke-jr proposed just that limit first-- actually a more relaxed version, then simply dishonestly insisted there was no opposition to it, even though opposition was immediately raised on the list).
>
> I think your proposal continues to have no serious prospect of activation, and should it activate in any form it will just be forked against and its authors will likely find themselves mired in litigation by people harmed by it. I think you'll find that almost every significant bitcoin developer will stand against such a change and will not work on a fork that adopts them, I also doubt the market would value your fork with such significant limitations very highly.
>
> On Sat, Nov 8, 2025 at 9:02 PM <dathonohm@proton.me> wrote:
>
>> Hi Greg -
>>
>>>That doesn't address the confiscation problem (although any reduction in the restriction does reduce it), as there likely exist chains of not yet confirmed (and potentially timelocked) transactions that involve violations of this rule. Those would appear to the network to be outputs created at a later time, although they really weren't. It's unclear to me why you haven't yet understood this point.
>>
>> While I completely agree that "confiscation" is a precedent we must avoid setting, I think my proposal neither confiscates funds nor sets a bad precedent, as it takes pains to avoid causing problems for all known use cases. I don't think it is reasonable never to create problems for all unknown use cases, as this would necessarily imply permanent ossification.
>>
>> To illustrate the point: it is possible to design off-chain systems that "use" any given feature of the Bitcoin protocol, including, for example, OP_NOPs. Funds locked in such UTXOs would be "confiscated" by the softfork proposal that redefines the OP_NOP. That is, anyone could intentionally lock funds into a pathological construction in order to obstruct any given softfork.
>>
>> Thus, if taken to the extreme, the argument that no one should ever have funds "confiscated", or even temporarily frozen, means that we can never upgrade Bitcoin again. So, in the interest of avoiding permanent ossification, it seems wise for us to compromise somewhere in the middle. I think my proposal strikes a good balance.
>>
>> Of course, if people are reporting that there are known, non-pathological use cases with significant funds locked into pre-signed transactions, then of course I will modify the proposal to accommodate them.
>>
>>>Another issue raised which you have not mentioned is that prior to you making this proposal I received minutes from a meeting which noted that Ocean Mining was the true author of this proposal and would be presenting it under a false identity in order to conceal their involvement. Will you be correcting the record on the true authorship of this work and on whose behalf its being performed?
>>
>> It sounds like you have fallen victim to some false rumors.
>>
>> I already attempted to correct the record on this, both here on this mailing list and on the BIP PR, but both times my messages were suppressed by moderators.
>>
>> I humbly request that moderators let the public see my response this time, otherwise I'm not sure how the record will ever be corrected:
>>
>> Though I am in direct communication with some Ocean employees (and the BIP was originally drafted by one of them), I am not affiliated with Ocean in any way. I am just a Bitcoin dev who is concerned about the implications of Core 30 having been released and gaining adoption.
>>
>> I am acting solely on my own behalf and on the behalf of the Bitcoin community, because I and most Bitcoiners I know are concerned about Bitcoin's future if it embraces data storage as a supported use case.
>>
>> This proposal is also a significant departure from the original BIP draft.
>>
>>>Would you then agree that this proposal will fail at its stated purpose, particularly with respect to concerns about potentially 'unlawful' material?
>>
>> No, I think this proposal is the best way to achieve its stated purpose, which is to reject the standardization of data storage as a supported use case, at the consensus level.
>>
>> It sounds like you haven't read the new version of the BIP, nor my summary above. I attached the document in my previous email message if you are interested. It removes all references to legal risks.
>>
>> For those who prefer viewing the proposal in a browser, I have pushed a copy of it to a non-PR branch, since the PR is still locked: https://github.com/dathonohm/bips/blob/reduced-data-v2/bip-%3F%3F%3F%3F.mediawiki
>>
>>>As that concern as expressed has a threshold of "any at all" and could just as well be performed via a "less commonly abused" path? Would you also agree the same for essentially all other forms-- that they'd simply made a few line of code changes and then evade these restrictions?
>>
>> Again, this is no longer applicable to the proposal. The new draft makes significant changes.
>>
>>>In light of that, how would the very real and significant reductions in intentional functionality (such as efficient "few of dozens" multisigs or other such constructs) be justified? How could the confiscation risk be justified? How could the deployment costs be justified? How could the "policy risk" be justified? (E.g. that bitcoin could be driven or forced in to an endless sequences of 'update' blocking actions, each carrying its own risk and disruptions)
>>
>> I don't see this softfork as an "update-blocking action"; on the contrary, I see it as an update-enabling one. As I stated previously, attempting to never disrupt any use cases, no matter how pathological, is the fastest path to ossification.
>>
>> Indeed, Bitcoin has failed to make any consensus upgrades at all since Taproot in 2021. The community has been going in circles now for two years because of pathological use cases introduced by that fork, and this proposal allows Bitcoiners to say "enough is enough", re-affirm that Bitcoin is money rather than data storage by disabling all the most popular methods of data abuse, and move on to more exciting things. We could have new upgrades in one year if Bitcoiners focus on building them over the following months.
>>
>> I honestly don't see a better way out of this morass, but please let me know your reasoning if you disagree. Inaction is not going to solve this.
>>
>>>I don't think your suggested revisions will move your proposal off from having essentially zero risk of adoption, and if it were adopted (which I think is unlikely)
>>
>> I don't see much reason not to adopt it, besides fear of softforks in general, but I'm listening.
>>
>>>I think it's a certainty that there would be a countering fork to continue a Bitcoin without these poorly justified (even essentially useless) restrictions.
>>
>> I don't see why anyone in their right mind would choose to bet on the old fork where Bitcoin is filled with spam and confused about whether it might want to just be a database, over the new one where Bitcoin is money.
>>
>> Best regards,
>>
>> Dathon
>> On Saturday, November 8th, 2025 at 9:48 AM, Greg Maxwell <gmaxwell@gmail.com> wrote:
>>
>>> On Sat, Nov 8, 2025 at 12:58 AM dathonohm via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> wrote:
>>>
>>>> - "Funds confiscation": due to the presence of UTXOs that would be made temporarily unspendable by this proposal, commenters were concerned that this would set a precedent of "confiscation". This new draft resolves this concern by adding a UTXO height check to make sure only UTXOs that are created while the softfork is active will be made temporarily unspendable. The "OP_IF in Tapscript" and "257-byte control block limit" were the two main proposed rule changes that caused concern here.
>>>
>>> That doesn't address the confiscation problem (although any reduction in the restriction does reduce it), as there likely exist chains of not yet confirmed (and potentially timelocked) transactions that involve violations of this rule. Those would appear to the network to be outputs created at a later time, although they really weren't. It's unclear to me why you haven't yet understood this point.
>>>
>>> I don't think this concern was in any way limited to the control block of op_if components either, essentially every aspect of the proposal has confiscation issues.
>>>
>>> Another issue raised which you have not mentioned is that prior to you making this proposal I received minutes from a meeting which noted that Ocean Mining was the true author of this proposal and would be presenting it under a false identity in order to conceal their involvement. Will you be correcting the record on the true authorship of this work and on whose behalf its being performed?
>>>
>>>> "This doesn't block all possible methods of arbitrary data insertion": This was already addressed in the previous draft, but to reiterate: this proposal's goal is not to block all methods of arbitary data insertion, just the most commonly abused ones.
>>>
>>> Would you then agree that this proposal will fail at its stated purpose, particularly with respect to concerns about potentially 'unlawful' material? As that concern as expressed has a threshold of "any at all" and could just as well be performed via a "less commonly abused" path? Would you also agree the same for essentially all other forms-- that they'd simply made a few line of code changes and then evade these restrictions?
>>>
>>> In light of that, how would the very real and significant reductions in intentional functionality (such as efficient "few of dozens" multisigs or other such constructs) be justified? How could the confiscation risk be justified? How could the deployment costs be justified? How could the "policy risk" be justified? (E.g. that bitcoin could be driven or forced in to an endless sequences of 'update' blocking actions, each carrying its own risk and disruptions)
>>>
>>> Although your description of changes is vague and it's not possible to tell for sure without seeing the actual updates-- I don't think your suggested revisions will move your proposal off from having essentially zero risk of adoption, and if it were adopted (which I think is unlikely) I think it's a certainty that there would be a countering fork to continue a Bitcoin without these poorly justified (even essentially useless) restrictions.
>>>
>>> --
>>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
>>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQy%2BqiRv%3DwGHB5_5Hgxmj9kbJiT9PXpd1VbiUFPwATg-g%40mail.gmail.com.
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTCFx2yvvUu9YWwcm-SSojT530Uwzi0b3sOG0%2BVZEcaAw%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/4LP7J-1Vq3jwrB8i7nBZPo7KBwS0Dc-RfmBxAT5JNqM3vG45RS3SxLYhws88ezXAMCT17blNOQSQRnuxLXquQci12-9uiPPqte4XOqoE8OY%3D%40proton.me.

[-- Attachment #2: Type: text/html, Size: 33909 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-08  0:51  1%               ` dathonohm via Bitcoin Development Mailing List
  @ 2025-11-09 21:34  1%                 ` Peter Todd
  1 sibling, 0 replies; 200+ results
From: Peter Todd @ 2025-11-09 21:34 UTC (permalink / raw)
  To: dathonohm; +Cc: Erik Aronesty, Antoine Riard, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 3377 bytes --]

On Sat, Nov 08, 2025 at 12:51:49AM +0000, dathonohm via Bitcoin Development Mailing List wrote:
> Hi all -
> 
> BIP repo maintainers [requested](https://github.com/bitcoin/bips/pull/2017#issuecomment-3462134337) that I update this list before pushing a significant change, so I am doing that now.
> 
> Please consider this my formal request for the BIP PR to be unlocked so that discussion can resume.

I see that a block-height-based activation date has been proposed,
approximately Feb 1st 2026 depending on how fast blocks are mined.

Your BIP does not discuss the fact that such a UASF activation is highly likely
to lead to two different coins, the unmodified chain accepted by the majority
of hash power, and the minority hash power fork. If you thought you could get
supermajority hashpower support, you would have simply proposed a hash-power
activation, e.g. the 95% treshold used by my own BIP-65 soft-fork,
CheckLockTimeVerify. Clearly you do not believe you can get supermajority
hashpower support.

Even without commenting on the desirability of such a fork, you need to openly
discuss it in your BIP and explain how the community will be able to deal with
it. For example, how wallets can safely "split" coins between either side of
the fork, and how you intend to modify Bitcoin addresses so people don't
accidentally send coins to the wrong side.

Of course - again without commenting on the desirability of this fork - I
personally believe that such a short timeframe is utterly absurd for a UASF
with no miner activation mechanism at all.


> This update addresses several concerns from the previous draft:

The BIP continues to fail to answer obvious questions. For example the very
first paragraph in your technical rational states:

> ''Why limit scriptPubKeys to 34 bytes?'''
>
> scriptPubKeys must be stored indefinitely in quick-access memory (often RAM) by all fully validating nodes.
> It generally cannot be pruned.
> It is also a direct cost to the sender rather than the receiver. For these reasons, modern usage is all 34 bytes or smaller in practice:
> actual spending conditions have been moved to the witness, and the scriptPubKey simply commits to them in advance with a hash.

Obviously, entities that actually need to publish data in scriptPubKey's will
simply use more of them instead of OP_Return. You write this section as though
your argument is an actual rationale. But clearly, this rational is simply
bogus.

You're actual rationale appears to be simply a moral one: you want to put
restrictions on transactions to send a *message* that use of Bitcoin for data
publishing is wrong. Even though otherwise you appear to admit that this BIP
will not in fact provide any real technical obstacle to publishing data in
Bitcoin (as me publishing the previous draft in the chain itself proved).

Unless you have an actual technical justification, arguments such as the above
are highly dishonest and need to be removed from your BIP.

-- 
https://petertodd.org 'peter'[:-1]@petertodd.org

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aREI6ZdvJmsZ-J6U%40petertodd.org.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-08 21:02  1%                   ` dathonohm via Bitcoin Development Mailing List
@ 2025-11-08 21:39  0%                     ` Greg Maxwell
  2025-11-09 20:07  1%                       ` dathonohm via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-11-08 21:39 UTC (permalink / raw)
  To: dathonohm; +Cc: Erik Aronesty, Antoine Riard, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 13116 bytes --]

It's not speculative-- nlocktime is a day one feature which *is* used in
Bitcoin.

Sure someone could footgun themselves by intentionally using a transaction
field which is expressly intended for forward compatibility and get
themselves burned-- but they'd have to be trying, not just doing a boring
and unconcerning thing because those fields don't do anything so the only
reason to use them would be an outright error or intentionally trying to
break themselves.

This is also not a new concern being raised for your proposal, every
softfork post P2SH has been analyzed under this lens so it's quite
concerning to see the proposal here simply ignore the concern.

Even the intentional forward compat features have caused some lack of
comfort in the past in this respect, which is why tapscript OP_SUCCESS
works the way it does:  so that any script that prematurely uses a
'success' opcode would be inherently completely insecure-- an important
improvement in upgradability that your proposal permanently destroys
without you even understanding why it existed in the first place.

And indeed I haven't read a new version because your prior message provided
no reference to it-- it said you were requested to update the list and then
you only provided a summary. I was responding to the summary.

Now looking at it, I see that you are still limiting scriptpubkey sizes
strictly-- this will absolutely confiscate funds as was pointed out and not
responded to even before your proposal. (because luke-jr proposed just that
limit first-- actually a more relaxed version, then simply dishonestly
insisted there was no opposition to it, even though opposition was
immediately raised on the list).

I think your proposal continues to have no serious prospect of activation,
and should it activate in any form it will just be forked against and its
authors will likely find themselves mired in litigation by people harmed by
it.  I think you'll find that almost every significant bitcoin developer
will stand against such a change and will not work on a fork that adopts
them, I also doubt the market would value your fork with such significant
limitations very highly.


On Sat, Nov 8, 2025 at 9:02 PM <dathonohm@proton.me> wrote:

> Hi Greg -
>
> >That doesn't address the confiscation problem (although any reduction in
> the restriction does reduce it), as there likely exist chains of not yet
> confirmed (and potentially timelocked) transactions that involve violations
> of this rule. Those would appear to the network to be outputs created at a
> later time, although they really weren't. It's unclear to me why you
> haven't yet understood this point.
>
> While I completely agree that "confiscation" is a precedent we must avoid
> setting, I think my proposal neither confiscates funds nor sets a bad
> precedent, as it takes pains to avoid causing problems for all known use
> cases. I don't think it is reasonable never to create problems for all
> *unknown* use cases, as this would necessarily imply permanent
> ossification.
>
> To illustrate the point: it is possible to design off-chain systems that
> "use" any given feature of the Bitcoin protocol, including, for example,
> OP_NOPs. Funds locked in such UTXOs would be "confiscated" by the softfork
> proposal that redefines the OP_NOP. That is, anyone could intentionally
> lock funds into a pathological construction in order to obstruct any given
> softfork.
>
> Thus, if taken to the extreme, the argument that no one should ever have
> funds "confiscated", or even temporarily frozen, means that we can never
> upgrade Bitcoin again. So, in the interest of avoiding permanent
> ossification, it seems wise for us to compromise somewhere in the middle. I
> think my proposal strikes a good balance.
>
> Of course, if people are reporting that there are known, non-pathological
> use cases with significant funds locked into pre-signed transactions, then
> of course I will modify the proposal to accommodate them.
>
> >Another issue raised which you have not mentioned is that prior to you
> making this proposal I received minutes from a meeting which noted that
> Ocean Mining was the true author of this proposal and would be presenting
> it under a false identity in order to conceal their involvement. Will you
> be correcting the record on the true authorship of this work and on whose
> behalf its being performed?
>
> It sounds like you have fallen victim to some false rumors.
>
> I already attempted to correct the record on this, both here on this
> mailing list and on the BIP PR, but both times my messages were suppressed
> by moderators.
>
> I humbly request that moderators let the public see my response this time,
> otherwise I'm not sure how the record will ever be corrected:
>
> Though I am in direct communication with some Ocean employees (and the BIP
> was originally drafted by one of them), *I am not affiliated with Ocean
> in any way*. I am just a Bitcoin dev who is concerned about the
> implications of Core 30 having been released and gaining adoption.
>
> *I am acting solely on my own behalf and on the behalf of the Bitcoin
> community*, because I and most Bitcoiners I know are concerned about
> Bitcoin's future if it embraces data storage as a supported use case.
>
> This proposal is also a significant departure from the original BIP draft.
>
> >Would you then agree that this proposal will fail at its stated purpose,
> particularly with respect to concerns about potentially 'unlawful' material?
>
> No, I think this proposal is the best way to achieve its stated purpose,
> which is to reject the standardization of data storage as a supported use
> case, at the consensus level.
>
> It sounds like you haven't read the new version of the BIP, nor my summary
> above. I attached the document in my previous email message if you are
> interested. It removes all references to legal risks.
>
> For those who prefer viewing the proposal in a browser, I have pushed a
> copy of it to a non-PR branch, since the PR is still locked:
> https://github.com/dathonohm/bips/blob/reduced-data-v2/bip-%3F%3F%3F%3F.mediawiki
>
> >As that concern as expressed has a threshold of "any at all" and could
> just as well be performed via a "less commonly abused" path? Would you also
> agree the same for essentially all other forms-- that they'd simply made a
> few line of code changes and then evade these restrictions?
>
> Again, this is no longer applicable to the proposal. The new draft makes
> significant changes.
>
> >In light of that, how would the very real and significant reductions in
> intentional functionality (such as efficient "few of dozens" multisigs or
> other such constructs) be justified? How could the confiscation risk be
> justified? How could the deployment costs be justified? How could the
> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in
> to an endless sequences of 'update' blocking actions, each carrying its own
> risk and disruptions)
>
> I don't see this softfork as an "update-blocking action"; on the contrary,
> I see it as an update-enabling one. As I stated previously, attempting to
> never disrupt any use cases, no matter how pathological, is the fastest
> path to ossification.
>
> Indeed, Bitcoin has failed to make any consensus upgrades at all since
> Taproot in 2021. The community has been going in circles now for two years
> because of pathological use cases introduced by that fork, and this
> proposal allows Bitcoiners to say "enough is enough", re-affirm that
> Bitcoin is *money* rather than *data storage* by disabling all the most
> popular methods of data abuse, and move on to more exciting things. We
> could have new upgrades in one year if Bitcoiners focus on building them
> over the following months.
>
> I honestly don't see a better way out of this morass, but please let me
> know your reasoning if you disagree. Inaction is not going to solve this.
>
> >I don't think your suggested revisions will move your proposal off from
> having essentially zero risk of adoption, and if it were adopted (which I
> think is unlikely)
>
> I don't see much reason *not* to adopt it, besides fear of softforks in
> general, but I'm listening.
>
> >I think it's a certainty that there would be a countering fork to
> continue a Bitcoin without these poorly justified (even essentially
> useless) restrictions.
>
> I don't see why anyone in their right mind would choose to bet on the old
> fork where Bitcoin is filled with spam and confused about whether it might
> want to just be a database, over the new one where Bitcoin is money.
>
> Best regards,
>
> Dathon
> On Saturday, November 8th, 2025 at 9:48 AM, Greg Maxwell <
> gmaxwell@gmail.com> wrote:
>
> On Sat, Nov 8, 2025 at 12:58 AM dathonohm via Bitcoin Development Mailing
> List <bitcoindev@googlegroups.com> wrote:
>
>>
>>    1. "Funds confiscation": due to the presence of UTXOs that would be
>>    made temporarily unspendable by this proposal, commenters were concerned
>>    that this would set a precedent of "confiscation". This new draft resolves
>>    this concern by adding a UTXO height check to make sure *only UTXOs
>>    that are created while the softfork is active will be made temporarily
>>    unspendable*. The "OP_IF in Tapscript" and "257-byte control block
>>    limit" were the two main proposed rule changes that caused concern here.
>>
>>
> That doesn't address the confiscation problem (although any reduction in
> the restriction does reduce it), as there likely exist chains of not yet
> confirmed (and potentially timelocked) transactions that involve violations
> of this rule. Those would appear to the network to be outputs created at a
> later time, although they really weren't. It's unclear to me why you
> haven't yet understood this point.
>
> I don't think this concern was in any way limited to the control block of
> op_if components either, essentially every aspect of the proposal has
> confiscation issues.
>
> Another issue raised which you have not mentioned is that prior to you
> making this proposal I received minutes from a meeting which noted that
> Ocean Mining was the true author of this proposal and would be presenting
> it under a false identity in order to conceal their involvement. Will you
> be correcting the record on the true authorship of this work and on whose
> behalf its being performed?
>
> > "This doesn't block all possible methods of arbitrary data insertion":
> This was already addressed in the previous draft, but to reiterate: this
> proposal's goal is not to block *all* methods of arbitary data insertion,
> just the most commonly abused ones.
>
> Would you then agree that this proposal will fail at its stated purpose,
> particularly with respect to concerns about potentially 'unlawful'
> material? As that concern as expressed has a threshold of "any at all" and
> could just as well be performed via a "less commonly abused" path? Would
> you also agree the same for essentially all other forms-- that they'd
> simply made a few line of code changes and then evade these restrictions?
>
> In light of that, how would the very real and significant reductions in
> intentional functionality (such as efficient "few of dozens" multisigs or
> other such constructs) be justified? How could the confiscation risk be
> justified? How could the deployment costs be justified? How could the
> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in
> to an endless sequences of 'update' blocking actions, each carrying its own
> risk and disruptions)
>
> Although your description of changes is vague and it's not possible to
> tell for sure without seeing the actual updates-- I don't think your
> suggested revisions will move your proposal off from having essentially
> zero risk of adoption, and if it were adopted (which I think is unlikely) I
> think it's a certainty that there would be a countering fork to continue a
> Bitcoin without these poorly justified (even essentially useless)
> restrictions.
>
>
>
>
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQy%2BqiRv%3DwGHB5_5Hgxmj9kbJiT9PXpd1VbiUFPwATg-g%40mail.gmail.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTCFx2yvvUu9YWwcm-SSojT530Uwzi0b3sOG0%2BVZEcaAw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 21818 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
    2025-11-08 16:40  1%                   ` Daniel Buchner
@ 2025-11-08 21:02  1%                   ` dathonohm via Bitcoin Development Mailing List
  2025-11-08 21:39  0%                     ` Greg Maxwell
  1 sibling, 1 reply; 200+ results
From: dathonohm via Bitcoin Development Mailing List @ 2025-11-08 21:02 UTC (permalink / raw)
  To: Greg Maxwell
  Cc: Erik Aronesty, Antoine Riard, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 10392 bytes --]

Hi Greg -

>That doesn't address the confiscation problem (although any reduction in the restriction does reduce it), as there likely exist chains of not yet confirmed (and potentially timelocked) transactions that involve violations of this rule. Those would appear to the network to be outputs created at a later time, although they really weren't. It's unclear to me why you haven't yet understood this point.

While I completely agree that "confiscation" is a precedent we must avoid setting, I think my proposal neither confiscates funds nor sets a bad precedent, as it takes pains to avoid causing problems for all known use cases. I don't think it is reasonable never to create problems for all unknown use cases, as this would necessarily imply permanent ossification.

To illustrate the point: it is possible to design off-chain systems that "use" any given feature of the Bitcoin protocol, including, for example, OP_NOPs. Funds locked in such UTXOs would be "confiscated" by the softfork proposal that redefines the OP_NOP. That is, anyone could intentionally lock funds into a pathological construction in order to obstruct any given softfork.

Thus, if taken to the extreme, the argument that no one should ever have funds "confiscated", or even temporarily frozen, means that we can never upgrade Bitcoin again. So, in the interest of avoiding permanent ossification, it seems wise for us to compromise somewhere in the middle. I think my proposal strikes a good balance.

Of course, if people are reporting that there are known, non-pathological use cases with significant funds locked into pre-signed transactions, then of course I will modify the proposal to accommodate them.

>Another issue raised which you have not mentioned is that prior to you making this proposal I received minutes from a meeting which noted that Ocean Mining was the true author of this proposal and would be presenting it under a false identity in order to conceal their involvement. Will you be correcting the record on the true authorship of this work and on whose behalf its being performed?

It sounds like you have fallen victim to some false rumors.

I already attempted to correct the record on this, both here on this mailing list and on the BIP PR, but both times my messages were suppressed by moderators.

I humbly request that moderators let the public see my response this time, otherwise I'm not sure how the record will ever be corrected:

Though I am in direct communication with some Ocean employees (and the BIP was originally drafted by one of them), I am not affiliated with Ocean in any way. I am just a Bitcoin dev who is concerned about the implications of Core 30 having been released and gaining adoption.

I am acting solely on my own behalf and on the behalf of the Bitcoin community, because I and most Bitcoiners I know are concerned about Bitcoin's future if it embraces data storage as a supported use case.

This proposal is also a significant departure from the original BIP draft.

>Would you then agree that this proposal will fail at its stated purpose, particularly with respect to concerns about potentially 'unlawful' material?

No, I think this proposal is the best way to achieve its stated purpose, which is to reject the standardization of data storage as a supported use case, at the consensus level.

It sounds like you haven't read the new version of the BIP, nor my summary above. I attached the document in my previous email message if you are interested. It removes all references to legal risks.

For those who prefer viewing the proposal in a browser, I have pushed a copy of it to a non-PR branch, since the PR is still locked: https://github.com/dathonohm/bips/blob/reduced-data-v2/bip-%3F%3F%3F%3F.mediawiki

>As that concern as expressed has a threshold of "any at all" and could just as well be performed via a "less commonly abused" path? Would you also agree the same for essentially all other forms-- that they'd simply made a few line of code changes and then evade these restrictions?

Again, this is no longer applicable to the proposal. The new draft makes significant changes.

>In light of that, how would the very real and significant reductions in intentional functionality (such as efficient "few of dozens" multisigs or other such constructs) be justified? How could the confiscation risk be justified? How could the deployment costs be justified? How could the "policy risk" be justified? (E.g. that bitcoin could be driven or forced in to an endless sequences of 'update' blocking actions, each carrying its own risk and disruptions)

I don't see this softfork as an "update-blocking action"; on the contrary, I see it as an update-enabling one. As I stated previously, attempting to never disrupt any use cases, no matter how pathological, is the fastest path to ossification.

Indeed, Bitcoin has failed to make any consensus upgrades at all since Taproot in 2021. The community has been going in circles now for two years because of pathological use cases introduced by that fork, and this proposal allows Bitcoiners to say "enough is enough", re-affirm that Bitcoin is money rather than data storage by disabling all the most popular methods of data abuse, and move on to more exciting things. We could have new upgrades in one year if Bitcoiners focus on building them over the following months.

I honestly don't see a better way out of this morass, but please let me know your reasoning if you disagree. Inaction is not going to solve this.

>I don't think your suggested revisions will move your proposal off from having essentially zero risk of adoption, and if it were adopted (which I think is unlikely)

I don't see much reason not to adopt it, besides fear of softforks in general, but I'm listening.

>I think it's a certainty that there would be a countering fork to continue a Bitcoin without these poorly justified (even essentially useless) restrictions.

I don't see why anyone in their right mind would choose to bet on the old fork where Bitcoin is filled with spam and confused about whether it might want to just be a database, over the new one where Bitcoin is money.

Best regards,

Dathon
On Saturday, November 8th, 2025 at 9:48 AM, Greg Maxwell <gmaxwell@gmail.com> wrote:

> On Sat, Nov 8, 2025 at 12:58 AM dathonohm via Bitcoin Development Mailing List <bitcoindev@googlegroups.com> wrote:
>
>> - "Funds confiscation": due to the presence of UTXOs that would be made temporarily unspendable by this proposal, commenters were concerned that this would set a precedent of "confiscation". This new draft resolves this concern by adding a UTXO height check to make sure only UTXOs that are created while the softfork is active will be made temporarily unspendable. The "OP_IF in Tapscript" and "257-byte control block limit" were the two main proposed rule changes that caused concern here.
>
> That doesn't address the confiscation problem (although any reduction in the restriction does reduce it), as there likely exist chains of not yet confirmed (and potentially timelocked) transactions that involve violations of this rule. Those would appear to the network to be outputs created at a later time, although they really weren't. It's unclear to me why you haven't yet understood this point.
>
> I don't think this concern was in any way limited to the control block of op_if components either, essentially every aspect of the proposal has confiscation issues.
>
> Another issue raised which you have not mentioned is that prior to you making this proposal I received minutes from a meeting which noted that Ocean Mining was the true author of this proposal and would be presenting it under a false identity in order to conceal their involvement. Will you be correcting the record on the true authorship of this work and on whose behalf its being performed?
>
>> "This doesn't block all possible methods of arbitrary data insertion": This was already addressed in the previous draft, but to reiterate: this proposal's goal is not to block all methods of arbitary data insertion, just the most commonly abused ones.
>
> Would you then agree that this proposal will fail at its stated purpose, particularly with respect to concerns about potentially 'unlawful' material? As that concern as expressed has a threshold of "any at all" and could just as well be performed via a "less commonly abused" path? Would you also agree the same for essentially all other forms-- that they'd simply made a few line of code changes and then evade these restrictions?
>
> In light of that, how would the very real and significant reductions in intentional functionality (such as efficient "few of dozens" multisigs or other such constructs) be justified? How could the confiscation risk be justified? How could the deployment costs be justified? How could the "policy risk" be justified? (E.g. that bitcoin could be driven or forced in to an endless sequences of 'update' blocking actions, each carrying its own risk and disruptions)
>
> Although your description of changes is vague and it's not possible to tell for sure without seeing the actual updates-- I don't think your suggested revisions will move your proposal off from having essentially zero risk of adoption, and if it were adopted (which I think is unlikely) I think it's a certainty that there would be a countering fork to continue a Bitcoin without these poorly justified (even essentially useless) restrictions.
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQy%2BqiRv%3DwGHB5_5Hgxmj9kbJiT9PXpd1VbiUFPwATg-g%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/MQv8-Ejvo7ZUcCOQkmtFo8hOATgSrKWvtG25JqUgWXKNGYHbCkVc-IawuPcRN_BebLTLQr3QtTTaA1iWrWgs0fFwI45jnQFi5_ORnAbsP_k%3D%40proton.me.

[-- Attachment #2: Type: text/html, Size: 19592 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-11-08 16:40  1%                   ` Daniel Buchner
@ 2025-11-08 17:55  1%                     ` Chris Riley
  0 siblings, 0 replies; 200+ results
From: Chris Riley @ 2025-11-08 17:55 UTC (permalink / raw)
  To: Daniel Buchner, Greg Maxwell; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 5338 bytes --]

Hi,
From what I have read so far there is not a clear, quantifiable,
agreed-upon set of criteria defining what constitutes “spam.”  Some
describe it as a "large non-monetary data embedded in transactions" but
what counts as large?  Are lightning HTLCs (etc.) "monetary" or are
they merely monetary adjacent?  What specifically defines "non-monetary"?
I've also seen things like “undesirable extra load” or “not following best
practices” but again what qualifies as "undesirable"  and what is "best
practices"?  Ideally, I'd like to see something that says: "a transaction
is spam if it meets criteria X, Y, and Z."

In my view, the inability to create a precise, objective definition makes
such rules essentially impossible to specify or enforce consistently,
leading to endless whack-a-mole changes. That in turn highlights why this
proposal seems problematic: any attempt to codify “spam” without a rigorous
definition risks both social and technical fragmentation — continual
revisions under external pressures, and a probable fork if implemented.

Have a nice weekend,
Chris



On Sat, Nov 8, 2025 at 11:43 AM Daniel Buchner <danieljb2@gmail.com> wrote:

> I agree with Greg, 0 quantification of what defines success has been
> provided for the generally expressed intention of reducing spam. If one
> admits any decentralized system that allows user-derived public keys /
> hashes fundamentally includes the ability to embed spurious data in place
> of those values, eliminating the spamming of those values is effectively
> impossible. That leaves us with the question: given the goal is simply
> 'reduction of spam', what defines success and what are the limiting
> principles? If success is 'reduce spam as much as possible', that would
> implicitly mean one should remove virtually all OP codes and leave Bitcoin
> with only basic send/receive that utilizes as few public keys and hashes as
> possible. Through this rational, empirical lens, I just don't see how this
> PR's seemingly arbitrary modifications of Bitcoin's protocol rules 1)
> actually reduce spam (likely will just result in spammers using different
> constructions), and 2) achieve mitigation of the hazy legal concerns that
> were a primary driver of this initiative.
>
> Can you please quantify what amounts/measurables you are targeting, and
> explain why this PR will achieve reductions to those level, such that they
> deliver on desired outcomes? Please connect whatever realistically
> achievable level reductions you believe will occur to the real world
> effects you believe they will deliver, such as "If we can just ensure no
> block can contain more than X bytes of spam, the Three-Letter Agency Y will
> not come after us because Z rule/limit/law/regulation says so". I am just
> providing an example of linking action to outcome delivery, so if you don't
> like that one, please provide whatever you feel best conveys it.
>
> Would you then agree that this proposal will fail at its stated purpose,
> particularly with respect to concerns about potentially 'unlawful'
> material?  As that concern as expressed has a threshold of "any at all" and
> could just as well be performed via a "less commonly abused" path?  Would
> you also agree the same for essentially all other forms-- that they'd
> simply made a few line of code changes and then evade these restrictions?
>
> In light of that, how would the very real and significant reductions in
> intentional functionality (such as efficient "few of dozens" multisigs or
> other such constructs) be justified? How could the confiscation risk be
> justified?  How could the deployment costs be justified?  How could the
> "policy risk" be justified? (E.g. that bitcoin could be driven or forced in
> to an endless sequences of 'update' blocking actions, each carrying its own
> risk and disruptions)
>
> Although your description of changes is vague and it's not possible to
> tell for sure without seeing the actual updates-- I don't think your
> suggested revisions will move your proposal off from having essentially
> zero risk of adoption, and if it were adopted (which I think is unlikely) I
> think it's a certainty that there would be a countering fork to continue a
> Bitcoin without these poorly justified (even essentially useless)
> restrictions.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/c385373b-a307-43b3-b958-fadb5866e3d9n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/c385373b-a307-43b3-b958-fadb5866e3d9n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAL5BAw054-GONdLcRWN3Fpv24WeYV%2BOKUiWhVsyArqznO-yZ7A%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 6612 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  @ 2025-11-08 16:40  1%                   ` Daniel Buchner
  2025-11-08 17:55  1%                     ` Chris Riley
  2025-11-08 21:02  1%                   ` dathonohm via Bitcoin Development Mailing List
  1 sibling, 1 reply; 200+ results
From: Daniel Buchner @ 2025-11-08 16:40 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3464 bytes --]

I agree with Greg, 0 quantification of what defines success has been 
provided for the generally expressed intention of reducing spam. If one 
admits any decentralized system that allows user-derived public keys / 
hashes fundamentally includes the ability to embed spurious data in place 
of those values, eliminating the spamming of those values is effectively 
impossible. That leaves us with the question: given the goal is simply 
'reduction of spam', what defines success and what are the limiting 
principles? If success is 'reduce spam as much as possible', that would 
implicitly mean one should remove virtually all OP codes and leave Bitcoin 
with only basic send/receive that utilizes as few public keys and hashes as 
possible. Through this rational, empirical lens, I just don't see how this 
PR's seemingly arbitrary modifications of Bitcoin's protocol rules 1) 
actually reduce spam (likely will just result in spammers using different 
constructions), and 2) achieve mitigation of the hazy legal concerns that 
were a primary driver of this initiative.

Can you please quantify what amounts/measurables you are targeting, and 
explain why this PR will achieve reductions to those level, such that they 
deliver on desired outcomes? Please connect whatever realistically 
achievable level reductions you believe will occur to the real world 
effects you believe they will deliver, such as "If we can just ensure no 
block can contain more than X bytes of spam, the Three-Letter Agency Y will 
not come after us because Z rule/limit/law/regulation says so". I am just 
providing an example of linking action to outcome delivery, so if you don't 
like that one, please provide whatever you feel best conveys it.

Would you then agree that this proposal will fail at its stated purpose, 
particularly with respect to concerns about potentially 'unlawful' 
material?  As that concern as expressed has a threshold of "any at all" and 
could just as well be performed via a "less commonly abused" path?  Would 
you also agree the same for essentially all other forms-- that they'd 
simply made a few line of code changes and then evade these restrictions?

In light of that, how would the very real and significant reductions in 
intentional functionality (such as efficient "few of dozens" multisigs or 
other such constructs) be justified? How could the confiscation risk be 
justified?  How could the deployment costs be justified?  How could the 
"policy risk" be justified? (E.g. that bitcoin could be driven or forced in 
to an endless sequences of 'update' blocking actions, each carrying its own 
risk and disruptions)

Although your description of changes is vague and it's not possible to tell 
for sure without seeing the actual updates-- I don't think your suggested 
revisions will move your proposal off from having essentially zero risk of 
adoption, and if it were adopted (which I think is unlikely) I think it's a 
certainty that there would be a countering fork to continue a Bitcoin 
without these poorly justified (even essentially useless) restrictions.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c385373b-a307-43b3-b958-fadb5866e3d9n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 4067 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  @ 2025-11-08  0:51  1%               ` dathonohm via Bitcoin Development Mailing List
    2025-11-09 21:34  1%                 ` Peter Todd
  0 siblings, 2 replies; 200+ results
From: dathonohm via Bitcoin Development Mailing List @ 2025-11-08  0:51 UTC (permalink / raw)
  To: Erik Aronesty; +Cc: Antoine Riard, Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5122 bytes --]

Hi all -

BIP repo maintainers [requested](https://github.com/bitcoin/bips/pull/2017#issuecomment-3462134337) that I update this list before pushing a significant change, so I am doing that now.

Please consider this my formal request for the BIP PR to be unlocked so that discussion can resume.

This update addresses several concerns from the previous draft:

- "Funds confiscation": due to the presence of UTXOs that would be made temporarily unspendable by this proposal, commenters were concerned that this would set a precedent of "confiscation". This new draft resolves this concern by adding a UTXO height check to make sure only UTXOs that are created while the softfork is active will be made temporarily unspendable. The "OP_IF in Tapscript" and "257-byte control block limit" were the two main proposed rule changes that caused concern here.
- "This doesn't block all possible methods of arbitrary data insertion": This was already addressed in the previous draft, but to reiterate: this proposal's goal is not to block all​ methods of arbitary data insertion, just the most commonly abused ones.
- "Blocks other softfork upgrades while active": This was also addressed in the original draft, but to reiterate: it's unlikely that any softfork upgrades will be ready to activate within one year anyway, so this doesn't matter much. But also, the fact that this softfork expires creates an opportunity to activate a more permanent and elegant upgrade that turns on what the community wants, while continuing to reject data storage as a supported use case, after one year.
- "Reactive deployment risks": These concerns have been addressed by removing the reactive deployment method entirely. I still think activating this softfork is a matter of some urgency, but I think it still achieves its goals if we move steadily towards activation within a few months.
- "Missing code": The code is now public here: https://github.com/UASF/bitcoin/tree/29.2.knots20251010%2BBIP444 (please note that, while there are references to "BIP-444" in the code, that is just a placeholder and I will update it to whatever number the BIP editors decide).
- "Temporary expiry risks": "Requires another consensus change before expiry or rules lapse": Yes, as stated in <3>, the community will have to come together in a year either to extend these rules (which shouldn't be difficult), or to activate something more permanent and less blunt. The expiry will not be a hardfork, contrary to some claims I've seen, because opting into this deployment means opting into the expiry as well, so old nodes will follow new ones onto the unrestricted chain
- "Legal/process/conflict-of-interest concerns": all language about legal risks has been stripped from the BIP.

I welcome any and all feedback, as I think this proposal or something similar to it stands an excellent chance of gaining consensus and activating, and I think if that happens, it could be curative for the Bitcoin community.

Thanks again for all of your feedback and support, it means a lot.

Sincerely,

Dathon
On Wednesday, October 29th, 2025 at 8:57 PM, Erik Aronesty <erik@q32.com> wrote:

>> Case law in the USA regarding illegal content has always rested squarely on those who:
>
> 1 - provide broad public access, in this case a company like OpenSEA (which has had to block content)
> 2 - the original author
>
> if punishing "relays" was a thing, then every CISCO router, SMTP relay and DISCORD server that provided access would be in court all day long
>
> instead, it's the users of the illegal data and the publishers that actually wind up in trouble - not the internet providers
>
> the bitcoin ledger is neither a browser or web server, nor is it an image uploader. there is zero ability to view images built into the system
>
> and even if it was
>
> the purpose of this software is to be a distributed and effectively uncensorable ledger.
>
> hopefully it doesn't change because someone launched a meme campaign with vague threats of legal action
>
> if a transaction has /no reasonable expectation of being mined/ (too expensive to validate, too large, too low fees), there's also no reason to relay it
>
> this is probably the best way to set policy
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKgKBBa%2BvD%3D5X0VMV2OFiBBM23Ok6nmvfoLTr8fia141%3DFQ%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/bJL7UshcsXUpiQiC85dQeafQrRvtovH1aRcUxggjD1S09Md9qWHi9GpJOBdcPGq2NNQMK2XK-REMVlWjHLkh3aKUIktnYQccUWqg0DHgNXc%3D%40proton.me.

[-- Attachment #1.2: Type: text/html, Size: 8190 bytes --]

[-- Attachment #2: bip-????.mediawiki --]
[-- Type: application/octet-stream, Size: 16887 bytes --]

<pre>
  BIP: ?
  Layer: Consensus (soft fork)
  Title: Reduced Data Temporary Softfork
  Author: Dathon Ohm <dathonohm+bip@proton.me>
  Comments-Summary: No comments yet.
  Comments-URI: https://github.com/bitcoin/bips/wiki/Comments:BIP-?
  Status: Draft
  Type: Standards Track
  Created: 2025-10-24
  License: BSD-3-Clause
  Post-History: https://gnusha.org/pi/bitcoindev/aN_u-xB2ogn2D834@erisian.com.au/T/#mb71350c5dfb119efeb92c5ee738b6c8225bf15b6
</pre>

==Abstract==

Temporarily limit the size of data fields at the consensus level.

==Copyright==

This document is licensed under the 3-clause BSD license.

==Specification==

Blocks with a height from 934864 until and including 987424 are checked with these additional rules:

# New output scriptPubKeys exceeding 34 bytes are invalid, unless the first opcode is OP_RETURN, in which case up to 83 bytes are valid.
# OP_PUSHDATA* with payloads larger than 256 bytes are invalid, except for the redeemScript push in BIP16 scriptSigs.
# Spending undefined witness (or Tapleaf) versions (ie, not Witness v0/BIP 141 nor Taproot/BIP 341) is invalid.
# Witness stacks with a Taproot annex are invalid.
# Taproot control blocks larger than 257 bytes (a merkle tree with 128 script leaves) are invalid.
# Tapscripts including OP_SUCCESS* opcodes anywhere (even unexecuted) are invalid.
# Tapscripts executing the OP_IF or OP_NOTIF instruction (regardless of result) are invalid.

Inputs spending UTXOs that were created before the activation height are exempt from the new rules.
Once the softfork expires, UTXOs of all heights are once again unrestricted.

==Motivation==

To reduce arbitrary data stored on nodes, and to reject the standardization of data storage as a supported use case at the consensus level.

==Rationale==

===Specification nuance===

'''Why limit scriptPubKeys to 34 bytes?'''

scriptPubKeys must be stored indefinitely in quick-access memory (often RAM) by all fully validating nodes.
It generally cannot be pruned.
It is also a direct cost to the sender rather than the receiver. For these reasons, modern usage is all 34 bytes or smaller in practice:
actual spending conditions have been moved to the witness, and the scriptPubKey simply commits to them in advance with a hash.

'''What about OP_RETURN? Why not get rid of it entirely?'''

OP_RETURN outputs are provably unspendable, and nodes do not need to store them in the UTXO set.
Historically, up to 83 bytes have been tolerated only to avoid unprovably unspendable spam in other output scripts, and no legitimate uses have ever been found.
With the advent of pay-to-contract and Taproot, it is now also possible to commit to external data in the Taptree, making even hypothetical use of OP_RETURN deprecated.
However, to avoid breaking legacy protocols that still include such outputs, this proposal allows these outputs.

'''Why limit other data to 256/257 bytes?'''

With modern compression, it is plausible to represent images in as few as 300-400 bytes. Images are likely the most harmful use case for data storage, as they have huge demand and supporting them can engender high fees and UTXO-set bloat, as well as content that a large majority of node operators might object to.

256 bytes (2048 bits) is also more than sufficient for reasonably large numbers that might be potentially needed in legitimate cryptography, reinforcing Bitcoin's intended purpose as a monetary network.

'''Won't spammers just spread their data over multiple fields?'''

While it is impossible to fully prevent steganography, limiting data sizes ensures such abuses are non-contiguous and obfuscated within another intended meaning (script code, structure, etc).
As far as Bitcoin is concerned, the data has some meaning other than the spammers' misinterpretation, and any external code to "reassemble" the unintended data is responsible for producing it
(it is possible to write code that transforms *any* data into any other data - what matters is that Bitcoin has a well-defined meaning that is distinct from the unsupported one).
This proposal also sends a clear message that data storage abuses in general are unwelcome rather than sanctioned or supported.

'''Why is there an exception for BIP16 redeemScripts?'''

The content of redeemScripts are another script, which is then executed.
Its contents are then also subject to the same OP_PUSHDATA* restrictions.
Restricting it is not only unnecessary, but would reduce the ability to make use of the intended script capabilities, and could impact legitimate real-world usage.

'''Why make spending undefined witness/Tapleaf versions invalid?'''

Since they are undefined, witness stacks spending these versions are completely unlimited currently to allow maximum flexibility in future upgrades.
Any future upgrade, however, would need more than a year of coordination, so this softfork will not actually restrict it, and only safeguards against abuse in the meantime.

'''Why not make it invalid to send to undefined witness versions?'''

This would require the senders of transactions to check the witness version prior to sending, and require additional coordination when a new witness version is intended to become used.

'''Why not allow spending undefined witness versions with an empty witness?'''

This has no use case, but would require nodes to track these UTXOs in case of potential spending.
By making spending invalid, it is possible for nodes to store them instead in slow memory not needed until this softfork expires.
(With proper planning, it also makes it possible for a future softfork making use of these witness versions to allow users to receive with an upgraded wallet even prior to activation of the upgrade.)

'''Why make the Taproot annex invalid?'''

The annex is currently undefined data with unlimited size.
It exists for future upgrades, but has no legitimate usage today.
Any future upgrade, however, would need more than a year of coordination, so this softfork will not actually restrict it, and only safeguards against abuse in the meantime.

'''Why is the Taproot control block limited to 257 bytes instead of 256?'''

The control block is a series of hashes proving the Tapscript is part of the Taptree, plus a single byte with the leaf version and parity bit.
See BIP 341 for details.

'''Why make OP_SUCCESS* invalid?'''

OP_SUCCESS* is meant for future upgrades. See above regarding undefined witness versions.

'''Why make OP_IF/OP_NOTIF invalid?'''

OP_IF/OP_NOTIF originated in pre-Taproot Bitcoin script language as a way to execute different subscripts based on a condition.
With Taproot, the conditions can instead be evaluated off-chain, revealing only the intended verification execution path.
Furthermore, when the conditions are met, the intent is that the keypath spend path should be used instead, avoiding publishing any scripts at all.

OP_IF is not only redundant for Tapscript, it is also commonly abused today to inject spam that gets skipped at execution.
While it is impossible to fully prevent steganography, closing this gap eliminates one common abuse today basically for free, and sends a message that such abuses are not welcome.

'''Why is the proposal so simple?'''

A more complicated proposal could be envisioned that better balances innovation with safety, but implementing this properly would require extensive refactoring and review, delaying deployment when there is already no time to wait.
The rules proposed herein have been intentionally kept very simple to minimise review time and avoid unnecessary risks of overlooking unexpected side effects.

'''Why is this softfork temporary?'''

The impact of these restrictions would severely constrain future upgrades, potentially forcing them to be designed as a hardfork instead of a softfork.
Some restrictions are also not ideal, but an improved limit would be more complicated to develop and test -
by deploying these simpler restrictions now, we avoid making the perfect the enemy of the good enough, while still allowing for upgrading the limits to better variants in the future.

Over the next year, interested developers can implement and propose a longer-term solution to address the needs of the protocol without the tradeoffs or blunt/simplified changes.

===Tradeoffs===

'''Are there any tradeoffs?'''

Yes:

# Limiting Taproot control blocks to 257 bytes directly constrains the size of the on-chain, consensus-enforced script tree. This could complicate or possibly even impede advanced smart contracting like BitVM, which relies on a large number of executable scripts. In the worst case scenario, these use cases may just need to wait until this softfork expires. As they are still in early development, testnet and sidechains should be sufficient for the next year while a more scalable rule is implemented.
# Upgrade hooks are not available for other softforks. As softforks need at least a year to activate, this shouldn't be a practical issue.
# Some wallet software such as Miniscript habitually create Tapleaves containing OP_IF. To mitigate the risk of freezing these funds for a year, this proposal exempts inputs that spend outputs that were created before activation.

'''Isn't the limit on Taproot control blocks too restrictive?'''

Possibly.
The previous limit allows for 340,282,366,920,938,463,463,374,607,431,768,211,456 scripts, which is obviously way more than anyone could ever need.
257 bytes allows for 128 scripts, which is sufficient for modern and complex transactions.
However, it may prove too limiting for advanced off-chain functionality such as used by BitVM.
This is an unfortunate tradeoff that (if this softfork is accepted) we have chosen to accept in the short-term for the immediate benefits of this softfork.
The intent is to relax this restriction later, when this softfork expires, with a new approach allowing larger trees, yet to be developed.

Do note that non-script (or non-Bitcoin-L1 scripts) usage of the taptree does not have this same limitation:
just a single of the 128 leaves could very well be an extension of the merkle tree to greater depths than enforced by this softfork.

'''Aren't Taptrees intended to be unbalanced?'''

While it is true that optimal use of Taptrees may often be unbalanced to favour more-likely-executed scripts, this is optional, and the full capacity (in this case, 128 scripts) can still be used if needed.
Additionally, in ideal/ordinary circumstances, neither the Taptree nor a merkle branch through it is ever published:
all counterparties ought to evaluate the conditions for spending off-chain and rebroadcast the transaction using the keypath spending.
Tapscripts are intended to only be used when one or more parties is unreachable or uncooperative; their existence mainly only serves to deter intentional non-cooperation by making it pointless.

===Alternatives / Alsos===
'''Why not let the fee market manage data storage?'''

The fee market is designed to prioritize transactions based on economic urgency.

However, the market for data storage on the blockchain is a completely different market from the market for payments, with completely different incentives.

Specifically, the fee for a monetary transaction incentivises a miner to include the transaction in a block, representing a one-time transfer of one or more UTXOs. The miner thus provides the one-time service of securing a payment, for a one-time fee.

Once the payment is secured, the payor does not receive any additional benefit from the Bitcoin network, besides the integrity of Bitcoin's transaction history (a service to which all node operators are happy to contribute, because Bitcoin would not function as money otherwise).

Conversely, the fee for a data storage transaction still goes only to the miner who includes the data in a block, but the burden of storing the data falls on all node operators, who never received even a part of the fee, yet are forced to continue downloading, storing, and serving the data forever.

In this case, the miner accepts a one-time fee, and in exchange, the priceless service of highly-available, uncensorable data storage is provided in perpetuity ''for free'' by node operators.

The problem becomes even worse when the data is objectionable to node operators, as this represents an even larger, unexpected cost for them.

'''How about OP_RETURN2/"blobspace" making the data optional for nodes?'''

This has been attempted multiple times in the past.
There is perhaps no harm in trying yet again, and this proposal does not prevent doing so,
but ultimately these schemes depend on the cooperation of the sender, who usually wants to explicitly force the content on non-consenting node operators
(or they would be using other existing distribution methods already).
These other ideas also do not solve the problem of objectionable content.

'''Shouldn't spam be fought in policy? Does this proposal affirm that policy is ineffective?'''

It remains true that policy is still the best place to fight spam.
However, it is also true that policy cannot guarantee 100% effectiveness, particularly against bad actors who are mining.
This softfork minimises the impact of such malicious miners, closing the worst-case risks.

'''Does this proposal solve spam completely?'''

No.
It is impossible to solve spam completely, and typically spam is best fought with policy/filters, not consensus.
What this softfork does is require users wanting to store large unencrypted files in the blockchain to disguise the data as financial data and/or break it up into multiple data pushes. Obviously doing so is considered an abuse of bitcoin and should be avoided, but if it does happen, this BIP strengthens the argument that data storage is not a supported use case.

'''Why doesn't this proposal address non-Bitcoin tokens?'''

There are a wide variety of non-Bitcoin tokens, mostly scams, that a significant portion of the community considers spam.
However, these schemes are best countered in policy rather than consensus, and besides, this proposal does not aim to eliminate spam entirely.

'''Is this a slippery slope? If we make rules against data today, will we start banning use cases we don't like tomorrow?'''

No.
These rules may be new at the consensus level, but they are merely enshrining long-standing principles of Bitcoin, as necessary to address a threat to the decentralization of the network and its usability for monetary purposes.

This softfork does not attempt to impose restrictions on monetary activity or the validity of monetary transactions themselves.
By restricting the data storage use case as much as possible, this proposal reinforces Bitcoin's guarantee of sound, permissionless money for the long-term.
This clear distinction between mitigating a systemic risk from non-monetary data abuse and interfering with actual monetary use cases provides a strong barrier against future overreach.

The explicitly temporary nature of the softfork further reinforces that this is a targeted intervention to mitigate a specific crisis, not a commitment or proposal of a new direction of development.
If no further action is taken by you, it will expire in a year.
Even if a followup softfork is proposed for that time, you retain the right to reject it.

'''Why not reduce the block weight/size limit too?'''

It is possible this softfork may activate before miners have fully upgraded.
To ensure continuity of Bitcoin through a potentially low-hashrate period, we must assume there's a possibility of each block taking 10 times as long as intended (ie, ~2 hours per block), which would mean 4 MWU per block would be a mere 333 kWU per 10 minutes.

If there is community support for reducing block sizes, it should therefore be done separately and calmly, after the network has settled down.

'''Why not activate CTV at the same time?'''

CTV is still controversial with a minority of the community, and bundling it with this softfork could be seen as an attempt to trick/force it on the network.

However, this softfork does "set the stage" for a followup softfork in a year, which would be an ideal stage to include CTV if the community deems it appropriate.

==Backwards compatibility==

Any UTXOs confirmed before activation will be spendable while this deployment is active; only outputs that are created ''during'' the deployment will have to wait until it expires in order to be spendable.

==Reference implementation==

https://github.com/bitcoinknots/bitcoin/compare/29.x-knots...UASF:bitcoin:29.2.knots20251010+BIP444?expand=1

==Deployment==

We propose a flag day startheight of 934864 (2026-02-01), with mandatory signaling leading up to activation. This implies an expiry day stopheight of 987424 (2027-02-01). These heights were extrapolated from block 920464 which occurred near 00:00 UTC on 2025-10-24.

==Credits==

Original draft and advice: Luke-Jr

^ permalink raw reply	[relevance 1%]

* [bitcoindev] LNHANCE a soft-fork package
@ 2025-11-03 23:05  1% 'moonsettler' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'moonsettler' via Bitcoin Development Mailing List @ 2025-11-03 23:05 UTC (permalink / raw)
  To: Bitcoin Development Mailing List

Dear List,

We propose to introduce a soft-fork package named LNHANCE Bitcoin, which is made up of 4 opcodes:

OP_CHECKTEMPLATEVERIFY (CTV): https://github.com/bitcoin/bips/tree/master/bip-0119.mediawiki
OP_CHECKSIGFROMSTACK (CSFS): https://github.com/bitcoin/bips/blob/master/bip-0348.md
OP_INTERNALKEY (IKEY): https://github.com/bitcoin/bips/blob/master/bip-0349.md
OP_PAIRCOMMIT (PC): https://github.com/lnhance/bips/blob/paircommit/bip-0442.md

Soft-fork Implementation:
https://github.com/lnhance/bitcoin/pulls

Website:
https://lnhance.org

It would be possible to replace CTV with TEMPLATEHASH (TH) and PC with CAT. I would not be opposed to that personally.

However these 4 opcodes were selected to reduce the unintended consequences as much as possible, while still give us an
efficient LN-Symmetry (formerly eltoo) implementation. (see BIP-442 for details!)

The following behaviors are out of scope for LNHANCE and should not be enabled as a side effect without explicit consensus:

- Fine-grained introspection
- State-carrying covenants
- Bigint operations
- New arithmetic capabilities using lookup tables

Q: Why not CAT instead of PC?
A: CAT enables introspection, including parent transaction introspection, state carrying and script intractable exogenous asset protocols.
This was way out of scope for the intended changes and possibly way out of the comfort zone of many bitcoiners.

Q: Why CTV and not TEMPLATEHASH?
A: We don't see anything technically wrong with TH, makes an even more efficient LN-Symmetry implementation possible.
The main contention by some of us is that by committing to the annex, it provides a motivation to start relaying non-empty annex.

Q: Why not use the annex?
A: Unstructured annex is the perfect place for any inscription or exogenous asset protocol payload.
We wished to avoid introducing additional social trauma resulting from new token hype cycles.

Q: Is TH+IKEY+CSFS an acceptable alternative to LNHANCE?
A: Supports most of the target use cases. It is a viable alternative.

Q: Is there a signet?
A: Not currently, we are working on setting it up this month.

Q: Will you open a PR to core?
A: That has been tried in the past and proven to be a dead end.

Q: Is there an activation client?
A: Yes, code is maintained, however it is way under reviewed. No binary releases for now. If you can build it, you can run it!

Q: What kind of activation are we talking about?
A: Modified BIP-9 with LOT=true and MUST_SIGNAL phase added. But whatever people want, that part is not so interesting.
Proposed params: https://github.com/lnhance/bitcoin/commit/193e34e2fef9111308251af85a6a122425960c36

Q: Paul Sztorc said the Lightning Network (LN) is a fraud, are you trying to perpetuate a fraud?
A: Maybe. We believe this package would make LN and LN adjacent other L2s (covenant pools, timeout trees, Ark, etc.) better and more scalable.

Q: How can I help?
A: Code reviews are most needed. We have structured the commits so, that you can focus on the changes most interesting to you.

Q: Who is sponsoring this work?
A: We accept anonymous donations with no strings attached.

BR,
moonsettler



-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/g66Df5xz1qORjBz4xirSJNBBCUPo8mWf7InVGww1nRqk_gyJE0utZ-EB_VyT9GN6l1yaxbXHl27y6ii6aK6aAoal4vA2ArU7kQg5LzPs93w%3D%40protonmail.com.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [Pre-BIP Discussion] Bitcoin Node Repository Consensus-Policy Separation
  @ 2025-11-01 17:54  1%             ` 'Antoine Poinsot' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'Antoine Poinsot' via Bitcoin Development Mailing List @ 2025-11-01 17:54 UTC (permalink / raw)
  To: Juan Aleman; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 12922 bytes --]

Juan,

Bitcoin Core only sets default for those users who choose to run it.

You may disagree with Bitcoin Core users' choice of software, but your failure to persuade them to run something else does not entitle you to force authors of the software they run to make undesirable changes by fantasizing about their public workplace.

You know who ultimately controls the bitcoin/bitcoin repo? Microsoft. Bitcoin would be completely uninteresting if this had any bearing on the definition of the system.

The bitcoin-dev mailing list is an appropriate venue to share your work on an alternative approach to developing a Bitcoin client. It is not one for spamming all subscribers to this list with a demagogic attempt at redefining the voluntary nature of Bitcoin.
Antoine Poinsot

On Saturday, November 1st, 2025 at 12:58 PM, Juan Aleman <bitcoindev@juanaleman.com> wrote:

> Hello Antoine,
>
> Nice to meet you. The main issue here is with the bitcoin/bitcoin repo itself. A single authority with too much influence, now escalating to the point of a fork over defaults.
>
> The power of defaults.
>
> I don't know how you feel about this whole situation, but for me, it's quite uncomfortable to be in deep conflicts with peers, and even friends. But "CoreDevs" seem way too invested to remain unbiased, clearly missing the forest for the trees.
>
> Glad to learn that bitcoin/bitcoin-core already has some headway, seems like libbitcoinkernel could eventually be integral in this new consensus-focused repo I'm proposing bitcoin/bitcoin be repurposed to. But for a v1, we can K.I.S.S.:
>
> - bitcoin/bitcoin-node continues as an exact duplicate of the current bitcoin/bitcoin (heading into using the NEW core, eventually)
> - bitcoin/bitcoin is renamed to bitcoin/bitcoin-core, and can start fat-trimming (heading into libbitcoinkernel integration, apparently)
>
> Or we can just [revert](https://github.com/bitcoin/bitcoin/pull/33682) defaults.
>
> Let's be adults. Do you really want to continue fighting? There's this thing called the golden rule, and Core broke it. Accept it, let's fix what we can, and move on.
>
> I anticipate this whole situation has been very educational for many, and it is actually GOOD to have the option to use multiple OP_RETURNs instead of burn outputs. But a 1000x increase of non-transactional arbitrary data by default, is undeniably abusive and risky. Which we are experiencing the consequences of... Let's stop the escalation!
>
> On Friday, October 31, 2025 at 8:09:25 PM UTC-4 Antoine Riard wrote:
>
>> Hi Juan,
>>
>> Confirming you that libbitcoinkernel is mature enough to hack on it.
>>
>> Completely split out the mempool from the validation engine on bitcoinbackbone.org.
>>
>> ```
>> block-daemon:
>> cargo build --bin block_relayd
>> cp target/debug/block_relayd block_relayd
>>
>> addr-daemon:
>> cargo build --bin addr_relayd
>> cp target/debug/addr_relayd addr_relayd
>>
>> tx-daemon:
>> cargo build --bin tx_relayd
>> cp target/debug/tx_relayd tx_relayd
>>
>> topo-daemon:
>> cargo build --bin topo_mngrd
>> cp target/debug/topo_mngrd topo_relayd
>>
>> mempool-daemon:
>> cargo build --bin mempool_mngrd
>> cp target/debug/mempool_mngrd mempool_mngrd
>>
>> txcontroller-daemon:
>> cargo build --bin tx_controllerd
>> cp target/debug/tx_controllerd tx_controllerd
>>
>> backbone-cli:
>> rm -f backbone-cli
>> cargo build --bin backbone-cli
>> cp target/debug/backbone-cli backbone-cli
>>
>> ```
>>
>> Now I can be the Staline of my own relay policy, and I'm very happy with that.
>>
>> Define "power" seriously, I read almost the integrality of Michel Foucault, and I don't get you.
>>
>> Best,
>> Antoine
>> OTS hash: 3f4d81c217237a38d5f47457d51c9e6990068e47
>> Le vendredi 31 octobre 2025 à 19:14:30 UTC, Juan Aleman a écrit :
>>
>>> Greg I actually agree there should be no "official" anything. That is why I purposefully always use "quotes" around it.
>>>
>>> Unfortunately for both of us, this is not a reflection of reality. "Official Bitcoin Core" has become itself the power grab.
>>>
>>> My proposal is about bringing this to the forefront. Most discussions I see revolve around who can win an argument. All these are distractions IMO, the issue here IS with the structure we have "trusted" for so many years is no longer viable.
>>>
>>> On Friday, October 31, 2025 at 2:48:48 PM UTC-4 Greg Maxwell wrote:
>>>
>>>> Other people don't do what you want because they believe it would harm Bitcoin and they have no interest in spending their efforts trying to harm something they love just to satisfy other people who disagree with them. Maybe they are wrong, but fortunately you have the freedom to go your own way. There is no 'official' anything. Continuing to try to coerce others to do what you want when they think it would be wrong and harmful is a bad choice which will make enemies out of people who otherwise would be indifferent to your efforts that they regard as misguided.
>>>>
>>>> On Fri, Oct 31, 2025 at 6:41 PM Juan Aleman <bitco...@juanaleman.com> wrote:
>>>>
>>>>> Hello Greg, thanks for your feedback. I am already starting to do [something](https://github.com/jotapea/bitcoin/commit/97d61c4b8eb0c044b06e1a8d5f280b17a6d7b5aa), but the main point IS about the centralization risks of the "official" repo...
>>>>>
>>>>> On Friday, October 31, 2025 at 2:24:36 PM UTC-4 Greg Maxwell wrote:
>>>>>
>>>>>> If you want that and think it would be valuable, feel free to create it. No one will stop you and you don't need anyone's permission.
>>>>>>
>>>>>> On Fri, Oct 31, 2025 at 6:20 PM Juan Aleman <bitco...@juanaleman.com> wrote:
>>>>>>
>>>>>>> Hello bitcoin developers,
>>>>>>>
>>>>>>> My name is Juan Alemán, and this is my first post to the mailing list. But I've been involved with Bitcoin since 2017. First only as a hard money investor, but later also as a developer, specially fascinated by this permanent medium. I hope this proposal can be appreciated by all perspectives as a pragmatic (maybe unorthodox, but timely) solution to move forward in agreement.
>>>>>>>
>>>>>>> The changes in v30 defaults got my attention (similar to many of you), as they are completely opposite to what has historically been "standard" practice. A highly controversial change that surfaces the influence over default policy in the network, escalating to the point of a [fork proposal](https://github.com/bitcoin/bips/pull/2017).
>>>>>>>
>>>>>>> First, it must be reminded that a fork should be unnecessary if defaults are simply [reverted](https://github.com/bitcoin/bitcoin/pull/33682), while still allowing all policy possibilities.
>>>>>>>
>>>>>>> After my second [PR](https://github.com/bitcoin/bitcoin/pull/33690) attempt was (also) closed (and I was blocked from the repo), I realized that the main issue here is social-political, not technical. It's about the powerful influence the "Official Reference Implementation" centralized node software repository has.
>>>>>>>
>>>>>>> This needs a different kind of solution. I'd like to propose a high-level structural change to the "Official Bitcoin Repository": Separating consensus code from policy-based node distribution.
>>>>>>>
>>>>>>> Problem Statement:
>>>>>>>
>>>>>>> The "official" Bitcoin Core node repository (https://github.com/bitcoin/bitcoin) maintains consensus code while also defining default relay and mining policies, among all other node functionalities, in a single piece of software. This concentration of responsibilities leads to elevating this single repository to a "pedestal", thus a point of centralization, giving a few too much influence.
>>>>>>>
>>>>>>> This kind of influence can be considered "harm" when abrupt default policy changes (like v30's shift toward permissive data carrying) disrupt "standard" network practices and its users.
>>>>>>>
>>>>>>> However, the v30 release itself may have caused a point of no return, where "globally agreed standardness" is no longer a realistic expectation. Bitcoin's hidden limits are being revealed.
>>>>>>>
>>>>>>> Proposal:
>>>>>>>
>>>>>>> To address humans' flaws, I suggest reorganizing the repository structure to better safeguard against unwarranted political (policy) influence.
>>>>>>>
>>>>>>> 1. Rename and Refocus Core Repo:
>>>>>>>
>>>>>>> Rename (github.com/)bitcoin/bitcoin to bitcoin/bitcoin-core. This repo would focus mainly on consensus rules, removing arbitrary or non-critical policies from its scope. It becomes a neutral base for ALL node implementations, emphasizing on hardening and testing consensus without policy distractions.
>>>>>>>
>>>>>>> 2. Introduce Node Client Repo(s):
>>>>>>>
>>>>>>> Create a separate repository for the full-featured node client, starting with (github.com/)bitcoin/bitcoin-node as the foundational template. This would effectively serve as the direct replacement for the current bitcoin/bitcoin node software. This repository embeds the consensus-focused bitcoin-core (objective), while including "current core devs"-recommended default policies (subjective). Other clients would use this as their foundation, to customize policy and beyond. (Also, there is nothing preventing multiple bitcoin-node-<type> existing in parallel, best addressing default-bias concerns.)
>>>>>>>
>>>>>>> The initial implementation of this separation might not be elegant, but future releases can progressively refactor based on this new reorganization, potentially incorporating more modularity (where beneficial).
>>>>>>>
>>>>>>> For a smooth transition that resolves ongoing tensions, the suggested first release of bitcoin/bitcoin-node should revert to pre-v30 defaults. Then, a subsequent release could adopt v30 defaults, with the home README clearly documenting options/alternatives (e.g. "For legacy Money-First policies, use X").
>>>>>>>
>>>>>>> (But STILL the simplest solution is just to allow something like [this](https://github.com/bitcoin/bitcoin/pull/33682). And let's just move on! Open-Data is out of the bag anyway.)
>>>>>>>
>>>>>>> This proposal attempts to find a compromise where no side feels "forced to comply", and represents a more neutral position from the "Official Reference Implementation" repository in this new era.
>>>>>>>
>>>>>>> Benefits:
>>>>>>>
>>>>>>> - Bitcoin-Core reaches its epitome, focusing on a hardened consensus core that serves all clients, regardless of policy.
>>>>>>> - Reduction of the "official" repo's influence on default policy, better aligning with Bitcoin's decentralization principles.
>>>>>>>
>>>>>>> Drawbacks:
>>>>>>>
>>>>>>> - Breaks existing infrastructure tied to github.com/bitcoin/bitcoin. However, bitcoin/bitcoin-node is a 1-to-1 replacement, mitigating deep disruptions (which some will see as a benefit, forcing a conscious choice about what node software to run moving forward).
>>>>>>> - Also, there must be caution of not using the original github.com/bitcoin/bitcoin name for anything else, as that would break automatic GitHub url redirects.
>>>>>>>
>>>>>>> Thank you for your time. This is just an idea I wanted to share for discussion, and I would appreciate any thoughts.
>>>>>>>
>>>>>>> Juan
>>>>>>
>>>>>>> --
>>>>>>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>>>>>>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
>>>>>>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/d397e2e1-3d5b-473a-b915-aca2cfc9da32n%40googlegroups.com.
>>>>>
>>>>> --
>>>>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>>>>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
>>>>
>>>>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/55b43fac-0794-45cb-86d7-535d965f3a74n%40googlegroups.com.
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f60a2f77-ab31-4bde-ad5b-736a0f19a915n%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/fofKj6a1afiS_xE53RaeN6ipreL9rkpHda8IV2ihSIJKP2Y4vn3nyjYB0ogyq9H0AOJbkSc9AHlOlcQHMBdCOXOc5d3Qd62836mtWW0w8cc%3D%40protonmail.com.

[-- Attachment #2: Type: text/html, Size: 19996 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-30 19:35  1%             ` Martin Habovštiak
@ 2025-10-31  6:31  1%               ` Melvin Carvalho
  0 siblings, 0 replies; 200+ results
From: Melvin Carvalho @ 2025-10-31  6:31 UTC (permalink / raw)
  To: Martin Habovštiak
  Cc: Greg Maxwell, yes_please, Russell O'Connor, TokyoBitcoiner,
	Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 13893 bytes --]

čt 30. 10. 2025 v 20:35 odesílatel Martin Habovštiak <
martin.habovstiak@gmail.com> napsal:

> "Honest" only refers to miners not trying to reverse the transactions by
> making an alternative chain. It has nothing to do with your subjective
> evaluation of the transactions worth trying to censor the "bad ones".
>

Hi Martin,

Small clarification per the white paper: "honest" isn’t only about
reversing transactions. Section 8 of the white paper also discusses honest
nodes and which transactions are accepted into blocks.

Satoshi further clarified standardness:
"The design supports a broad range of transaction types that are possible,
but not all are standard. Standard transactions are the ones that are
designed to be used for the common case."
-- June 2010

Per Section 11, the white paper's security model shows honest miners (e.g.
following standard operation) outpacing alternatives. In practice, miners
following a standardness agreement or soft fork for OP_RETURN would, on
affected blocks, earn around $100,000 more, than under a mixed policy,
making prioritizing standard transactions the economically optimal strategy.

This is because there are a finite number of blocks before each halving, so
the opportunity cost of non-standard payloads is half the subsidy, which is
more than enough economic upside to offset fees. A standardness agreement
soft fork is therefore economically compelling for miners: it aligns with
long-standing practice and provides long-term incentives.

Best,
Melvin


>
> Bitcoin was specifically designed to prevent censorship of transactions
> that follow the consensus rules. Trying to go against it makes you a fool
> at best or an attacker at worst.
>
> Dňa št 30. 10. 2025, 18:37 Melvin Carvalho <melvincarvalho@gmail.com>
> napísal(a):
>
>>
>>
>> čt 30. 10. 2025 v 3:16 odesílatel Greg Maxwell <gmaxwell@gmail.com>
>> napsal:
>>
>>> I searched for the source of your quotation and am unable to find it,
>>> but its author appears to be confused or missing a complete understanding.
>>>
>>> The particular size isn't motivated by application but because major
>>> miners had already removed the rule completely.  As such no lesser setting
>>> would achieve the goal of matching relay to what will actually get mined
>>> and completely solve the bad situation created by the mismatch.
>>>
>>> If you consider this regrettable it's worthwhile to consider that a
>>> failure to increase it previously (on several prior proposals) and even a
>>> failure to discuss and evaluate it was likely due to the unprofessional and
>>> relentless harassment of Luke-jr.  Had that not occurred perhaps the limit
>>> would have been incrementally increased previously before major miners on
>>> their own found it to be in their interest to simply remove it (as removing
>>> it is much easier than twiddling it).  The consequence of failing to be
>>> pragmatic is the loss of that nudge.
>>>
>>> That said, the economics and incentives of bitcoin are such that the
>>> removal was inevitable once people were willing to pay for it-- and I would
>>> have happily told you this in 2014 or whenever back when op_return was
>>> reallowed for relay.  Beyond the current situation with the rule completely
>>> bypassed this inevitably favors removal once the policy has started
>>> eroding.  Even if miners had only bypassed to a few kilobytes or whatnot
>>> moving to match that would only result in repeated cycles of transactions
>>> that will get mined failing to relay, each cycle favoring private
>>> submission mechanisms and promoting mining centralization.  Policy is only
>>> at best a nudge and a fragile one.
>>>
>>> I think in many people's view-- certainly in mine-- cirtia or whatever
>>> was irrelevant to the discussion except as a concrete example of a fake
>>> pubkey user that would rather not do that-- and one that wasn't some random
>>> NFT thing that we'd all rather not be using Bitcoin at all. In other words,
>>> that the benefit of avoiding more utxo bloat wasn't speculative.
>>>
>>
>> While much of this discussion has focused on policy, there’s also an
>> incentive perspective.
>>
>> Section 11 of the white paper notes that consensus holds *iff* honest
>> nodes outpace dishonest ones.
>>
>> If we interpret *honest* as mining blocks consistent with standard
>> monetary use, excluding large OP_RETURN payloads, then miners who do so are
>> likely to earn more.
>>
>> When fees from arbitrary data are smaller than roughly half the block
>> reward, standard ("honest") miners are effectively producing
>> *double-value* blocks each epoch: they gain both the reward and a more
>> secure, stable fee market over time.
>> That economic feedback alone could be enough to restore convergence back
>> to standard size OP_RETURNs. Of course, setting back the default helps here
>> too.
>>
>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> On Thu, Oct 30, 2025 at 1:15 AM yes_please <caucasianjazz12@gmail.com>
>>> wrote:
>>>
>>>> Hi all,
>>>>
>>>> Perhaps we can find a meeting point if we focus on the max size of
>>>> OP_return ?
>>>> The increase from 83 to 100'000 bytes has been motivated as "probably
>>>> we will have to increase it again in the future, it requires energy and
>>>> time for code maintenance, so we'd rather increase it now to 100'000 bytes
>>>> and be done with it". While these are valid points, the unknown
>>>> consequences that might manifest with such a drastic increase all at once
>>>> may not be the most prudent approach.
>>>> Considering also that "the canary in the coal mine", namely Citrea use
>>>> case, requires only 144 bytes to utilize op_return instead of more harmful
>>>> ways, the increase to 100'000 bytes appears disproportionate given the
>>>> circumstances, and again non-prudent enough (which is what I suspect is
>>>> creating most of the debate at hand).
>>>>
>>>> caucasianjazz12
>>>>
>>>> On Wed, Oct 29, 2025 at 4:38 PM 'Russell O'Connor' via Bitcoin
>>>> Development Mailing List <bitcoindev@googlegroups.com> wrote:
>>>>
>>>>> On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com>
>>>>> wrote:
>>>>>
>>>>>> Questions reacting to text in reply of Russell O'Connor:
>>>>>>
>>>>>>    - *" there exist some protocols that require":*
>>>>>>       - Which protocols?
>>>>>>
>>>>>> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I
>>>>> don't know anything about their protocol beyond that.
>>>>>
>>>>>
>>>>>>
>>>>>>    -
>>>>>>       - Why does bitcoin need to cater to their needs?
>>>>>>
>>>>>> If we don't support these in OP_RETURNs, Citrea, and other folks like
>>>>> them, will use something like bare multisigs instead, which will be a
>>>>> little more expensive for them and much more expensive for every other
>>>>> Bitcoin node operator on the planet because those (likely) unspendable UTXO
>>>>> will have to remain in the UTXO set forever because they will be
>>>>> indistinguishable from legitimate bare multisigs.
>>>>>
>>>>>>
>>>>>>    -
>>>>>>       - Do we cater to any protocol that comes along?
>>>>>>          - How do we choose which to enable, and which to discourage?
>>>>>>
>>>>>> Clamping down on OP_RETURNs won't discourage the use of these
>>>>> Citrea-like protocols.  Instead it will encourage them to instead use
>>>>> uncensorable publication channels such as bare multisigs, which will bloat
>>>>> the UTXO set and drive up costs for every Bitcoin node operator on the
>>>>> planet.
>>>>>
>>>>>>
>>>>>>    - *"the folks using these protocols will simply have no choice"*:
>>>>>>       - Did we *force* them to use bitcoin for their project?
>>>>>>       - It sounds like "if you don't change the code to enable my
>>>>>>       project, I will be forced to trash your project." Is this wrong?
>>>>>>
>>>>>> By "force" I mean in the sense that when a recent KDE upgrade dropped
>>>>> the ability to specify some command to be run whenever the screen is
>>>>> locked, KDE "forced" me to write a systemd service to run dbus-monitor to
>>>>> watch for screen locking events instead.  Fortunately, in the case of KDE,
>>>>> being "forced" to work around their changes only makes my life worse.
>>>>> However in the case of limiting OP_RETURNs, users who are "forced" to find
>>>>> workarounds for their proof of publication protocols  will ultimately lead
>>>>> to them using the uncensorable data channel of bare-multisigs, or similar,
>>>>> which have consequences not only for themselves but every other Bitcoin
>>>>> node operator on the planet.
>>>>>
>>>>> It is specifically the externalities caused by the bare-multisig
>>>>> workaround that we need to address. If these externalities didn't exist,
>>>>> then I, and presumably others, wouldn't care so much.
>>>>>
>>>>>>
>>>>>>    - *"any attempt to cap OP_RETURN outputs will force those users"*
>>>>>>    :
>>>>>>       - Again, *force* is a form of coercion. Is the bitcoin code
>>>>>>       with it's current setting *forcing* anyone to do anything?
>>>>>>       - Are the external protocol designers the victims here?
>>>>>>
>>>>>> The victims will be every node operator on the planet who has to deal
>>>>> with the unprunable UTXO bloat caused by users posting their
>>>>> proof-of-publication data via the uncensorable bare-multisig avenue.  This
>>>>> collective cost will actually be much higher than the cost to the external
>>>>> protocol designers who only have to pay a few more pennies for their
>>>>> transactions.
>>>>>
>>>>>
>>>>>>
>>>>>>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>>>>>>       - What problem?
>>>>>>
>>>>>> The problem is a combination of protocols that require using
>>>>> proof-of-publication choosing to use uncensorable bare-multisigs instead,
>>>>> and/or, so long as this proposal isn't adopted, the problem of users
>>>>> bypassing the network to get their OP_RETURN transactions mined which leads
>>>>> to poor quality block reconstruction and poor quality fee estimates and the
>>>>> like.
>>>>>
>>>>>>
>>>>>>    -
>>>>>>       - Is the bitcoin code responsible for fulfilling the needs of
>>>>>>       an external project or protocol?
>>>>>>          - If yes, why?
>>>>>>
>>>>>> Again the victims here wouldn't be the external protocol designers.
>>>>> They will just pay the extra pennies to publish using bare-multisig.  The
>>>>> victims would be every Bitcoin node operator on the planet.  And while the
>>>>> core developers have no warranties or responsibilities attached to their
>>>>> open source code, I think we would agree that "costs borne by every Bitcoin
>>>>> node operator on the planet", is something they ought to bear in mind in
>>>>> their work.
>>>>>
>>>>>
>>>>>>
>>>>>> I hope you will take these questions seriously. I really want to
>>>>>> understand your thinking.
>>>>>>
>>>>>
>>>>> Hope this helps.
>>>>>
>>>>> --
>>>>> You received this message because you are subscribed to the Google
>>>>> Groups "Bitcoin Development Mailing List" group.
>>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>>>> To view this discussion visit
>>>>> https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com
>>>>> <https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>>>> .
>>>>>
>>>> --
>>>> You received this message because you are subscribed to the Google
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>>> To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com
>>>> <https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>>> .
>>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com
>>> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2BD9y6r0RZJPAGY08KSc1s%2BxUZ9UY4fR2f%3DdDc0joXEfQ%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2BD9y6r0RZJPAGY08KSc1s%2BxUZ9UY4fR2f%3DdDc0joXEfQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAKaEYhKdhJ1vP5BBYNAMF7557M9dSoQx8_uqjdAzRM3DgA6ajg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 17882 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30 16:10  1%                     ` Tom Harding
@ 2025-10-30 22:15  0%                       ` Doctor Buzz
  0 siblings, 0 replies; 200+ results
From: Doctor Buzz @ 2025-10-30 22:15 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 27313 bytes --]

> We should reflect on the goal of minimizing UTXO set size.  Would we as 
easily say we should minimize the number of people/entities who hold L1 
coins, or the number of ways each person/entity can hold them?
> The dire concern with UTXO set size was born with the optimization of the 
core bitcoin software for mining, rather than for holding and transfers, in 
2012.  Some geniuses were involved with that change.  Satoshi was not one 
of them.

The goal isn’t to minimize UTXOs themselves or discourage people from 
self-custodying coins on L1. We should minimize *non-monetary UTXOs* (those 
created only for file storage, dusting-type tracking, etc.), not those used 
for transferring or holding value, as intended.

Minimizing *unnecessary resource usage* that doesn’t serve the 
“peer-to-peer money” purpose helps everyone that has that purpose as a goal:
– Everyday users who want to store their savings securely.
– Active users who want to spend and settle efficiently.
– Node runners who keep the network decentralized and verifiable.

Bitcoin should take all steps to avoid unnecessary bloat (which has led to 
an extra ~30 GB/yr of immutable data storage since Feb 2023 and completely 
sidetracked any REAL improvements / security upgrades that should've been 
leading discussions).  Then perhaps in just a few years, every new phone 
could comfortably run its own fully-verifying node with no trusted servers 
or light-clients... enabling efficient, permissionless monetary use on both 
L1 or L2.  Self-hosted LN nodes cannot compete with those who want file 
storage that lasts longer than the user itself.

Since you brought it up... I have a proposal to limit "bulk dust" (defined 
as a Tx with >= ~20 "Tiny" outputs &&  >= ~70% of the outputs are "Tiny", 
which starts at 4096 sats but halves every epoch, beginning at block 
1,260,000).

It should be difficult to use Bitcoin for data storage and sending tiny Txs 
for that purpose, which has harmful effects on not just the UTXO set, but 
also the network... which is precisely what IsDust() and IsStandard() were 
designed to do.  Changing consensus rules is less than ideal, but for 
everyone that says "filters don't work", consensus changes would appear to 
be the only "default solutions" they'll accept, to actually identify 
certain Txs or patterns as invalid.
See:  Limit "Bulk Dust" with a default filter or 
consensus... https://groups.google.com/g/bitcoindev/c/mW_zR01joiY

On Thursday, October 30, 2025 at 12:37:03 PM UTC-5 Tom Harding wrote:

> We should reflect on the goal of minimizing UTXO set size.  Would we as 
> easily say we should minimize the number of people/entities who hold L1 
> coins, or the number of ways each person/entity can hold them?
>
> The dire concern with UTXO set size was born with the optimization of the 
> core bitcoin software for mining, rather than for holding and transfers, in 
> 2012.  Some geniuses were involved with that change.  Satoshi was not one 
> of them. 
>
>
> On Wednesday, October 29, 2025 at 7:32:10 PM UTC-7 Greg Maxwell wrote:
>
> "A few bytes" might be on the order of forever 10% increase in the UTXO 
> set size, plus a full from-network resync of all pruned nodes and a full 
> (e.g. most of day outage) reindex of all unpruned nodes.  Not 
> insignificant but also not nothing.  Such a portion of the existing utxo 
> size is not from outputs over 520 bytes in size, so as a scheme for utxo 
> set size reduction the addition of MHT tracking would probably make it a 
> failure.
>
> Also some risk of creating some new scarce asset class, txouts consisting 
> of primordial coins that aren't subject to the new rules... sounds like the 
> sort of thing that NFT degens would absolutely love.  That might not be an 
> issue *generally* for some change with confiscation risk, but for a change 
> that is specifically intended to lobotomize bitcoin to make it less useful 
> to NFT degens, maybe not such a great idea. :P
>
> I mentioned it at all because I thought it could potentially be of some 
> use, I'm just more skeptical of it for the current context.  Also luke-jr 
> and crew has moved on to actually propose even more invasive changes than 
> just limiting the script size, which I anticipated, and has much more 
> significant issues.  Just size limiting outputs likely doesn't harm any 
> interests or usages-- and so probably could be viable if the confiscation 
> issue was addressed, but it also doesn't stick it to people transacting in 
> ways the priests of ocean mining dislike. 
>
> > I believe you're pointing out the idea of non economically-rational 
> spammers?
>
> I think it's a mistake to conclude the spammers are economically 
> irrational-- they're often just responding to different economics which may 
> be less legible to your analysis.  In particular, NFT degens prefer the 
> high cost of transactions as a thing that makes their tokens scarce and 
> gives them value.  -- otherwise they wouldn't be swapping for one less 
> efficient encoding for another, they're just be using another blockchain 
> (perhaps their own) entirely.
>
>
>
>
> On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com> 
> wrote:
>
> > MRH tracking might make that acceptable, but comes at a high cost which 
> I think would clearly not be justified.
>
> Greg, I want to ask/challenge how bad this is, this seems like a generally 
> reusable primitive that could make other upgrades more feasible that also 
> have the same strict confiscation risk profile.
> IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?
>
> Poelstra,
>
> > I don't think this is a great idea -- it would be technically hard to
> implement and slow deployment indefinitely.
>
> I would like to know how much of a deal breaker this is in your opinion. 
> Is MRH tracking off the table? In terms of the hypothetical presigned 
> transactions that may exist using P2MS, is this a hard enough reason to 
> require a MRH idea?
>
> Greg,
>
> > So, paradoxically this limit might increase the amount of non-prunable 
> data
>
> I believe you're pointing out the idea of non economically-rational 
> spammers? We already see actors ignoring cheaper witness inscription 
> methods. If spam shifts to many sub-520 fake pubkey outputs (which I 
> believe is less harmful than stamps), that imo is a separate UTXO cost 
> discussion. (like a SF to add weight to outputs). Anywho, this point alone 
> doesn't seem sufficient to add as a clear negative reason for someone 
> opposed to the proposal.
>
> Thanks,
> Tidwell
> On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:
>
> > Confiscation is a problem because of presigned transactions 
>
> Allow 10000 bytes of total scriptPubKey size in each block counting only 
> those outputs that are larger than x (520 as proposed). 
> The code change is pretty minimal from the most obvious implementation of 
> the original rule. 
>
> That makes it technically non-confiscatory. Still non-standard, but if 
> anyone out there so obnoxiously foot-gunned themselves, they can't claim 
> they were rugged by the devs. 
>
> BR, 
> moonsettler 
>
> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io> 
> wrote: 
>
> > Hey, 
> > 
> > First, thank you to everyone who responded, and please continue to do 
> so. There were many thought provoking responses and this did shift my 
> perspective quite a bit from the original post, which in of itself was the 
> goal to a degree. 
> > 
> > I am currently only going to respond to all of the current concerns. 
> Acks; though I like them will be ignored unless new discoveries are 
> included. 
> > 
> > Tl;dr (Portlands Perspective) 
> > - Confiscation is a problem because of presigned transactions 
> > - DoS mitigation could also occur through marking UTXOs as unspendable 
> if > 520 bytes, this would preserve the proof of publication. 
> > - Timeout / Sunset logic is compelling 
> > - The (n) value of acceptable needed bytes is contentious with the lower 
> suggested limit being 67 
> > - Congestion control is worth a look? 
> > 
> > Next Step: 
> > - Deeper discussion at the individual level: Antoine Poinsot and GCC 
> overlap? 
> > - Write an implementation. 
> > - Decide to pursue BIP 
> > 
> > Responses 
> > 
> > Andrew Poelstra: 
> > > There is a risk of confiscation of coins which have pre-signed but 
> > > unpublished transactions spending them to new outputs with large 
> > > scriptPubKeys. Due to long-standing standardness rules, and the 
> presence 
> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any 
> > > such transactions exist. 
> > 
> > PortlandHODL: This is a risk that can be incurred and likely not 
> possible to mitigate as there could be possible chains of transactions so 
> even when recursively iterating over a chain there is a chance that a 
> presigned breaks this rule. Every idea I have had from block redemption 
> limits on prevouts seems to just be a coverage issue where you can make the 
> confiscation less likely but not completely mitigated. 
> > 
> > Second, there are already TXs that effectively have been confiscated at 
> the policy level (P2SH Cleanstack violation) where the user can not find 
> any miner with a policy to accept these into their mempool. (3 years) 
> > 
> > /dev /fd0 
> > > so it would be great if this was restricted to OP_RETURN 
> > 
> > PortlandHODL: I reject this completely as this would remove the UTXOset 
> omission for the scriptPubkey and encourage miners to subvert the OP_RETURN 
> restriction and instead just use another op_code, this also do not hit on 
> some of the most important factors such as DoS mitigation and legacy script 
> attack surface reduction. 
> > 
> > Peter Todd 
> > > NACK ... 
> > 
> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
> without including any additional context or reasoning. 
> > 
> > jeremy 
> > > I think that this type of rule is OK if we do it as a "sunsetting" 
> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
> years, 5 years, 10 years). 
> > 
> > If action is taken, this is the most reasonable approach. Alleviating 
> confiscatory concerns through deferral. 
> > 
> > > You can argue against this example probably, but it is worth 
> considering that absence of evidence of use is not evidence of absence of 
> use and I myself feel that overall our understanding of Bitcoin transaction 
> programming possibilities is still early. If you don't like this example, I 
> can give you others (probably). 
> > 
> > Agreed and this also falls into the reasoning for deciding to utilize 
> point 1 in your response. My thoughts on this would be along the lines of 
> proof of publication as this change only has the effect of stripping away 
> the executable portion of a script between 521 and 10_000 bytes or the 
> published data portion if > 10_000 bytes which the same data could likely 
> be published in chunked segments using outpoints. 
> > 
> > Andrew Poelstra: 
> > > Aside from proof-of-publication (i.e. data storage directly in the 
> UTXO 
> > > set) there is no usage of script which can't be equally (or better) 
> > > accomplished by using a Segwit v0 or Taproot script. 
> > 
> > This sums up the majority of future usecase concern 
> > 
> > Anthony Towns: 
> > > (If you restricted the change to only applying to scripts that used 
> > non-push operators, that would probably still provide upgrade 
> flexibility 
> > while also preventing potential script abuses. But it wouldn't do 
> anything 
> > to prevent publishing data) 
> > 
> > Could this not be done as segments in multiple outpoints using a 
> coordination outpoint? I fail to see why publication proof must be in a 
> single chunk. This does though however bring another alternative to mind, 
> just making these outpoints unspendable but not invalidate the block 
> through inclusion... 
> > 
> > > As far as the "but contiguous data will be regulated more strictly" 
> > argument goes; I don't think "your honour, my offensive content has 
> > strings of 4d0802 every 520 bytes 
> > 
> > Correct, this was never meant to resolve this issue. 
> > 
> > Luke Dashjr: 
> > > If we're going this route, we should just close all the gaps for the 
> immediate future: 
> > 
> > To put it nicely, this is completely beyond the scope of what is being 
> proposed. 
> > 
> > Guus Ellenkamp: 
> > > If there are really so few OP_RETURN outputs more than 144 bytes, then 
> > why increase the limit if that change is so controversial? It seems 
> > people who want to use a larger OP_RETURN size do it anyway, even with 
> > the current default limits. 
> > 
> > Completely off topic and irrelevant 
> > 
> > Greg Tonoski: 
> > > Limiting the maximum size of the scriptPubKey of a transaction to 67 
> bytes. 
> > 
> > This leave no room to deal with broken hashing algorithms and very 
> little future upgradability for hooks. The rest of these points should be 
> merged with Lukes response and either hijack my thread or start a new one 
> with the increased scope, any approach I take will only be related to the 
> ScriptPubkey 
> > 
> > Keagan McClelland: 
> > > Hard NACK on capping the witness size as that would effectively ban 
> large scripts even in the P2SH wrapper which undermines Bitcoin's ability 
> to be an effectively programmable money. 
> > 
> > This has nothing to do with the witness size or even the P2SH wrapper 
> > 
> > Casey Rodarmor: 
> > > I think that "Bitcoin could need it in the future?" might be a good 
> enough 
> > reason not to do this. 
> > 
> > > Script pubkeys are the only variable-length transaction fields which 
> can be 
> > covered by input signatures, which might make them useful for future 
> soft 
> > forks. I can imagine confidential asset schemes or post-quantum coin 
> recovery 
> > schemes requiring large proofs in the outputs, where the validity of the 
> proof 
> > determined whether or not the transaction is valid, and thus require the 
> > proofs to be in the outputs, and not just a hash commitment. 
> > 
> > Would the ability to publish the data alone be enough? Example make the 
> output unspendable but allow for the existence of the bytes to be covered 
> through the signature? 
> > 
> > 
> > Antoine Poinsot: 
> > > Limiting the size of created scriptPubKeys is not a sufficient 
> mitigation on its own 
> > I fail to see how this would not be sufficient? To DoS you need 2 things 
> inputs with ScriptPubkey redemptions + heavy op_codes that require unique 
> checks. Example DUPing stack element again and again doesn't work. This 
> then leads to the next part is you could get up to unique complex 
> operations with the current (n) limit included per input. 
> > 
> > > One of the goal of BIP54 is to address objections to Matt's earlier 
> proposal, notably the (in my 
> > opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
> Limiting the size of 
> > scriptPubKeys would in this regard be moving in the opposite direction. 
> > 
> > Some notes is I would actually go as far as to say the confiscation risk 
> is higher with the TX limit proposed in BIP54 as we actually have proof of 
> redemption of TXs that break that rule and the input set to do this already 
> exists on-chain no need to even wonder about the whole presigned. 
> bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08 
> > 
> > Please let me know if I am incorrect on any of this. 
> > 
> > > Furthermore, it's always possible to get the biggest bang for our buck 
> in a first step 
> > 
> > Agreed on bang for the buck regarding DoS. 
> > 
> > My final point here would be that I would like to discuss more, and this 
> is response is from the initial view of your response and could be 
> incomplete or incorrect, This is just my in the moment response. 
> > 
> > Antoine Riard: 
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
> favor of prioritizing 
> > a timewarp fix and limiting dosy spends by old redeem scripts 
> > 
> > The idea of congestion control is interesting, but this solution should 
> significantly reduce the total DoS severity of known vectors. 
> > 
> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote: 
> > 
> > > Limits on block construction that cross transactions make it harder to 
> accurately estimate fees and greatly complicate optimal block 
> construction-- the latter being important because smarter and more computer 
> powered mining code generating higher profits is a pro centralization 
> factor. 
> > > 
> > > In terms of effectiveness the "spam" will just make itself 
> indistinguishable from the most common transaction traffic from the 
> perspective of such metrics-- and might well drive up "spam" levels because 
> the higher embedding cost may make some of them use more transactions. The 
> competition for these buckets by other traffic could make it effectively a 
> block size reduction even against very boring ordinary transactions. ... 
> which is probably not what most people want. 
> > > 
> > > I think it's important to keep in mind that bitcoin fee levels even at 
> 0.1s/vb are far beyond what other hosting services and other blockchains 
> cost-- so anyone still embedding data in bitcoin *really* want to be there 
> for some reason and aren't too fee sensitive or else they'd already be 
> using something else... some are even in favor of higher costs since the 
> high fees are what create the scarcity needed for their seigniorage. 
> > > 
> > > But yeah I think your comments on priorities are correct. 
> > > 
> > > 
> > > 
> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> 
> wrote: 
> > > 
> > > > Hi list, 
> > > > 
> > > > Thanks to the annex covered by the signature, I don't see how the 
> concern about limiting 
> > > > the extensibility of bitcoin script with future (post-quantum) 
> cryptographic schemes. 
> > > > Previous proposal of the annex were deliberately designed with 
> variable-length fields 
> > > > to flexibly accomodate a wide range of things. 
> > > > 
> > > > I believe there is one thing that has not been proposed to limit 
> unpredictable utterance 
> > > > of spams on the blockchain, namely congestion control of categories 
> of outputs (e.g "fat" 
> > > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey 
> and L a limiting 
> > > > threshold for the number of T occurences during the period P. Beyond 
> the L threshold, any 
> > > > additional T scriptpubkey is making the block invalid. Or 
> alternatively, any additional 
> > > > T generating / spending transaction must pay some weight penalty... 
> > > > 
> > > > Congestion control, which of course comes with its lot of 
> shenanigans, is not very a novel 
> > > > idea as I believe it has been floated few times in the context of 
> lightning to solve mass 
> > > > closure, where channels out-priced at current feerate would have 
> their safety timelocks scale 
> > > > ups. 
> > > > 
> > > > No need anymore to come to social consensus on what is quantitative 
> "spam" or not. The blockchain 
> > > > would automatically throttle out the block space spamming 
> transaction. Qualitative spam it's another 
> > > > question, for anyone who has ever read shannon's theory of 
> communication only effective thing can 
> > > > be to limit the size of data payload. But probably we're kickly back 
> to a non-mathematically solvable 
> > > > linguistical question again [0]. 
> > > > 
> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
> favor of prioritizing 
> > > > a timewarp fix and limiting dosy spends by old redeem scripts, 
> rather than engaging in shooting 
> > > > ourselves in the foot with ill-designed "spam" consensus 
> mitigations. 
> > > > 
> > > > [0] If you have a soul of logician, it would be an interesting 
> demonstration to come with 
> > > > to establish that we cannot come up with mathematically or 
> cryptographically consensus means 
> > > > to solve qualitative "spam", which in a very pure sense is a 
> linguistical issue. 
> > > > 
> > > > Best, 
> > > > Antoine 
> > > > OTS hash: 
> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999 
> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a 
> écrit : 
> > > > 
> > > > > Hi, 
> > > > > 
> > > > > This approach was discussed last year when evaluating the best way 
> to mitigate DoS blocks in terms 
> > > > > of gains compared to confiscatory surface. Limiting the size of 
> created scriptPubKeys is not a 
> > > > > sufficient mitigation on its own, and has a non-trivial 
> confiscatory surface. 
> > > > > 
> > > > > One of the goal of BIP54 is to address objections to Matt's 
> earlier proposal, notably the (in my 
> > > > > opinion reasonable) confiscation concerns voiced by Russell 
> O'Connor. Limiting the size of 
> > > > > scriptPubKeys would in this regard be moving in the opposite 
> direction. 
> > > > > 
> > > > > Various approaches of limiting the size of spent scriptPubKeys 
> were discussed, in forms that would 
> > > > > mitigate the confiscatory surface, to adopt in addition to (what 
> eventually became) the BIP54 sigops 
> > > > > limit. However i decided against including this additional measure 
> in BIP54 because: 
> > > > > - of the inherent complexity of the discussed schemes, which would 
> make it hard to reason about 
> > > > > constructing transactions spending legacy inputs, and equally hard 
> to evaluate the reduction of 
> > > > > the confiscatory surface; 
> > > > > - more importantly, there is steep diminishing returns to piling 
> on more mitigations. The BIP54 
> > > > > limit on its own prevents an externally-motivated attacker from 
> *unevenly* stalling the network 
> > > > > for dozens of minutes, and a revenue-maximizing miner from 
> regularly stalling its competitions 
> > > > > for dozens of seconds, at a minimized cost in confiscatory 
> surface. Additional mitigations reduce 
> > > > > the worst case validation time by a smaller factor at a higher 
> cost in terms of confiscatory 
> > > > > surface. It "feels right" to further reduce those numbers, but 
> it's less clear what the tangible 
> > > > > gains would be. 
> > > > > 
> > > > > Furthermore, it's always possible to get the biggest bang for our 
> buck in a first step and going the 
> > > > > extra mile in a later, more controversial, soft fork. I previously 
> floated the idea of a "cleanup 
> > > > > v2" in private discussions, and i think besides a reduction of the 
> maximum scriptPubKey size it 
> > > > > should feature a consensus-enforced maximum transaction size for 
> the reasons stated here: 
> > > > > 
> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
> I wouldn't hold my 
> > > > > breath on such a "cleanup v2", but it may be useful to have it 
> documented somewhere. 
> > > > > 
> > > > > I'm trying to not go into much details regarding which mitigations 
> were considered in designing 
> > > > > BIP54, because they are tightly related to the design of various 
> DoS blocks. But i'm always happy to 
> > > > > rehash the decisions made there and (re-)consider alternative 
> approaches on the semi-private Delving 
> > > > > thread [0] dedicated to this purpose. Feel free to ping me to get 
> access if i know you. 
> > > > > 
> > > > > Best, 
> > > > > Antoine Poinsot 
> > > > > 
> > > > > [0]: 
> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711 
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
> fre...@reardencode.com> wrote: 
> > > > > 
> > > > > > 
> > > > > > 
> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote: 
> > > > > > 
> > > > > > > But also given that there are essentially no violations and no 
> reason to 
> > > > > > > expect any I'm not sure the proposal is worth time relative to 
> fixes of 
> > > > > > > actual moderately serious DOS attack issues. 
> > > > > > 
> > > > > > 
> > > > > > I believe this limit would also stop most (all?) of 
> PortlandHODL's 
> > > > > > DoSblocks without having to make some of the other changes in 
> GCC. I 
> > > > > > think it's worthwhile to compare this approach to those proposed 
> by 
> > > > > > Antoine in solving these DoS vectors. 
> > > > > > 
> > > > > > Best, 
> > > > > > 
> > > > > > --Brandon 
> > > > > > 
> > > > > > -- 
> > > > > > You received this message because you are subscribed to the 
> Google Groups "Bitcoin Development Mailing List" group. 
> > > > > > To unsubscribe from this group and stop receiving emails from 
> it, send an email to bitcoindev+...@googlegroups.com. 
> > > > > > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console. 
> > > > 
> > > > -- 
> > > > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group. 
> > > > To unsubscribe from this group and stop receiving emails from it, 
> send an email to bitcoindev+...@googlegroups.com. 
> > > 
> > > > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com. 
>
> > 
> > -- 
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group. 
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com. 
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com. 
>
>
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/73793fc0-29d8-4b79-b7bf-048e459c928bn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 32758 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: segOP potential BIP discussion
  2025-10-29 23:40  1% [bitcoindev] segOP potential BIP discussion defenwycke
@ 2025-10-30 21:25  2% ` defenwycke
  0 siblings, 0 replies; 200+ results
From: defenwycke @ 2025-10-30 21:25 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 33450 bytes --]

Hi all,

I thought more about this today. Please see update below. Open to ideas and 
discussion. 

KR

Defenwycke

# segOP : Segregated OP_RETURN # A Structured and Fee-Fair Data Extension 
for Bitcoin ## Technical Paper — October 2025 ## Author : Defenwycke ## 
Abstract Bitcoin’s four-million-weight-unit block limit was meant to price 
blockspace fairly, yet Segregated Witness introduced an asymmetry: witness 
bytes cost one weight unit while base bytes cost four. That 
discount—intended for signatures—has become a subsidy for arbitrary data. 
Large image and metadata “inscriptions” now fill much of each block while 
paying a fraction of what monetary transactions pay. The result is a 
distorted fee market: blocks remain full but miners earn less and real 
users queue longer. segOP (Segregated OP_RETURN) restores balance without a 
hard fork. It defines a structured, priced data lane inside the 
transaction—full fee rate, capped at 100 KB, TLV-encoded and 
Merkle-verifiable. Each payload pays the same 4 WU per byte as ordinary 
transaction data. Economic modelling shows miner revenue roughly doubling 
and genuine payment throughput increasing about 75 %, while spam falls 
naturally. The proposal is soft-fork safe, easily pruned, and backward 
compatible. ## 1 Introduction ### 1.1 Why This Matters Bitcoin’s strength 
lies in simplicity: every byte competes equally for limited space. Since 
2017, witness discounting has broken that symmetry. A 1 MB batch of 
signatures or data in the witness section now costs only ¼ of what it would 
in the base section. That imbalance has turned the witness into a 
subsidised data store. Ordinary users fund cheap on-chain storage for 
unrelated content, miners lose fees, and block propagation slows. ### 1.2 
Goal of segOP segOP re-introduces equal pricing. It doesn’t forbid data; it 
merely isolates and meters it properly. Like SegWit separated signatures 
for malleability reasons, segOP separates arbitrary data for economic 
fairness. Every byte again pays its way. ## 2 Problem Statement ### 2.1 The 
Fee Distortion | Rule | Current Value | Impact | 
|----------------------|------------------|----------------------| | Block 
weight limit | 4 000 000 WU | Hard cap | | Witness discount | ¼ WU / B | 
Data cheap | | Max script element | 520 B | Protects validation | | UTXO 
retention | Permanent | Growing state | Because witness data is so cheap, 
100 KB of arbitrary content weighs 100 000 WU instead of 400 000 WU. Miners 
still fill blocks to 4 M WU, but earn less; users compete against 
discounted junk. The imbalance is economic, not cryptographic. ### 2.2 
Consequences Fee market signal blurred — cheap spam masks real demand. 
Throughput loss — genuine tx count falls ≈ 40–60 %. Revenue loss — full 
blocks yield low fees. Propagation load — bigger blocks take longer to 
relay. Without change, history repeats: larger chain, lower income, weaker 
incentives. ## 3 Proposal — segOP (Segregated OP_RETURN) segOP introduces a 
new optional section after the witness. It carries arbitrary structured 
data at full cost (4 WU/B) and is capped at 100 KB per transaction. 
Presence is signalled by a new flag bit (0x02). Legacy nodes ignore it; 
upgraded nodes parse and charge for it. ### 3.1 Design Summary | Parameter 
| Rule | Purpose | 
|----------------|-------------------------|-----------------------------| 
| Encoding | TLV (Type-Length-Value) | Self-describing, extensible | | 
Maximum size | 100 000 B | Stops bloat | | Cost per byte | 4 WU | Restores 
parity | | Witness limit | 520 B | Protects execution | | Placement | After 
witness | Deterministic layout | | Compatibility | Soft-fork safe | Old 
nodes ignore | ### 3.2 Why Equal Pricing Matters You can’t legislate away 
spam; you fix it by removing its subsidy. segOP ends the discount, making 
large data pay the same rate as payments. Abuse becomes uneconomic—no 
blacklists or heuristics needed. ### 3.3 Compatibility Old nodes ignore bit 
0x02. txid excludes segOP data → no malleability risk. Deployment via 
version-bits or miner policy. ### 3.4 Analogy SegWit separated signatures 
for security; segOP separates data for fairness. Both reduce friction 
between innovation and consensus. ## 4. Economic Model segOP changes the 
economics of blockspace by removing the discount that allows data to 
underpay for its size. To understand its impact, we can model the block in 
three parts: normal transactions, discounted data (today’s reality), and 
segOP data (the proposed model). ### 4.1 Variables and Setup Let: - `Wb` = 
block weight limit → 4,000,000 weight units - `Wtx` = average transaction 
weight → 600 weight units - `S` = segOP payload size → 100,000 bytes - 
`WsegOP` = segOP weight = 4 × S = 400,000 weight units - `f` = fee rate in 
satoshis per virtual byte (sat/vB) We define the following relationships: 
FsegOP = f × S T = (Wb - 400,000 × n) / Wtx Fblock = n × FsegOP + T × (f × 
150) Where: - `n` is the number of segOP payloads in a block. - `FsegOP` is 
the fee paid by one segOP transaction. - `Fblock` is the total fee income 
for the block. This gives a rough but useful estimate of how miner revenue 
scales when blocks contain different mixes of segOP data and normal 
transactions. ### 4.2 Scenario A — Current Situation (Discounted Witness 
Data) In the current network, around sixty percent of block weight can be 
consumed by discounted witness data. That data pays only one quarter of the 
fee rate that normal bytes would, so the block fills up faster but 
generates less revenue. A typical block might contain about 2,600 normal 
transactions and yield around 0.006 BTC in fees. The network looks busy, 
but most of the block is effectively subsidised storage. ### 4.3 Scenario B 
— segOP Introduced (Full-Fee Data Lane) With segOP active, arbitrary data 
still fits on-chain, but it now pays the same four weight units per byte as 
everything else. Assume three segOP payloads of 100 KB each per block. 
Under these conditions, the block includes roughly 4,600 normal 
transactions and produces around 0.013 BTC in total fees. Miners earn more, 
users see more legitimate transactions confirmed, and blockspace pricing 
becomes honest again. ### 4.4 Scenario C — No Discounted Data If the 
network were used purely for monetary transactions, a full block would 
contain roughly 6,600 standard transactions at an average total fee of 
about 0.010 BTC. This represents the upper bound for throughput but not 
necessarily the most balanced use of blockspace. ### 4.5 Interpretation 
Spam deterrence: Data becomes too expensive to abuse; only purposeful data 
remains. Fair market: Each byte competes equally, eliminating hidden 
discounts. Higher throughput: More monetary transactions per block because 
junk is no longer cheap. Miner incentive: Full blocks now pay full rewards; 
revenue rises naturally. Stable propagation: Blocks remain smaller and more 
predictable in structure, improving relay speed. segOP doesn’t require a 
new policy or central coordination—it simply restores the natural balance 
of the fee market through equal pricing. ## 5 Behavioural and Economic 
Implications Spam deterrence — once data costs full rate, stuffing blocks 
is uneconomic. Fair market — every byte competes equally. Higher throughput 
— fewer bloated transactions. Better miner income — full blocks now mean 
full fees. Predictable propagation — smaller, uniform payloads reduce 
latency. It’s a market fix, not a ban list. ## 6 Security and Consensus ### 
6.1 Considerations segOP changes accounting, not consensus. Validation 
logic stays deterministic; legacy nodes remain valid peers. | Risk | 
Mitigation | 
|-------------------------|------------------------------------------------| 
| Soft-fork compatibility | Unrecognised flag ignored by old nodes | | 
Malleability | segOP excluded from txid | | Script safety | 520 B element 
limit unchanged | | Resource load | ≤ 100 KB per tx caps memory | | Replay 
risk | Flag bit isolated from version | ### 6.2 Validation Flow 
(pseudocode) ```python def validate_tx(tx): check_structure(tx) 
check_inputs_outputs(tx) if tx.flag & 0x01: # SegWit validate_witness(tx) 
for w in tx.witness: for item in w: if len(item) > 520: raise 
ScriptError("witness element too large") if tx.flag & 0x02: # segOP seg = 
tx.segop if seg.length > 100_000: raise PolicyError("segOP payload too 
large") charge_weight(seg.length * 4) validate_tlv(seg.tlv) ``` The logic 
is simple: include data, pay for data. ## 7 Implementation and Flag 
Structure | Flag Bit | Meaning | Present In | Cost Model | 
|-----------|---------------------|-------------|-----------------------------| 
| 0x00 | Legacy (no witness) | Pre-SegWit | 4 WU/B | | 0x01 | SegWit only | 
Post-2017 | 1 WU witness | | 0x02 | segOP only | Future | 4 WU segOP | | 
0x03 | SegWit + segOP | Mixed | 1 WU witness + 4 WU segOP | Older software 
ignores 0x02, so segOP deploys as a soft fork with zero disruption. ## 8 
Transaction Encoding ### 8.1 Example (segOP Flag + P2SOP) A working example 
showing how segOP coexists with SegWit, commented line-by-line. ```jsonc { 
"version": 2, // transaction version "flag": 3, // 0x01 = SegWit, 0x02 = 
segOP → 0x03 = both "vin": [ { "txid": "aa...aa", // previous transaction 
hash "vout": 0, // output index "scriptSig": "", // empty for SegWit spend 
"sequence": 4294967295 } ], "vout": [ { "value": 0.01000000, // spendable 
output "scriptPubKey": { "type": "witness_v0_keyhash", "hex": 
"0014abcdef..." } }, { "value": 0.00000000, // zero-value marker 
"scriptPubKey": { "type": "nulldata", "asm": "OP_RETURN OP_SEGOP", // 
Pay-to-segOP marker "hex": "6a045345474f50" // ASCII “SEGOP” } } ], 
"witness": [ [ "3045...01", "02ab...cd" ] // standard sig + pubkey ], 
"segop": { "length": 1024, // total segOP bytes (≤100 000) "tlv": [ { 
"type": 1, // data hash "len": 32, "value": "d4d95998b5...e3" }, { "type": 
2, // declared data length "len": 2, "value": "03e8" // 1000 bytes }, { 
"type": 3, // optional Merkle root "len": 32, "value": "12ab...9f" } ] }, 
"locktime": 0 } ``` ### 8.2 Validation flow: 1. Detect flag & 0x02. 2. 
Reject if segop.length > 100 000. 3. Weight = segop.length × 4. 4. Witness 
elements ≤ 520 B. 5. Fee = (base_vbytes + segop.length) × feerate. ### 8.3 
segOP Field definitions | Field | Purpose | Effect | 
|-----------|-----------------------|--------------------------| | flag:3 | 
SegWit + segOP active | Full-price accounting | | vout[1] | P2SOP output | 
Marker only | | segop | Structured payload | TLV encoded | | length | Total 
bytes | Hard cap enforced | | tlv | Typed entries | Verifiable meta | ## 9 
Long-Term Storage and Pruning Strategy ### 9.1 Background A node only needs 
the UTXO set and headers to enforce consensus; it doesn’t need to host 
everyone’s history forever. Bitcoin Core already prunes full blocks to save 
space but cannot surgically drop arbitrary data inside them. segOP fixes 
that: since its data are self-contained and fully paid, they can be 
forgotten safely once validated. ### 9.2 Pruning Process Validate segOP 
payload and hash. Record its type, length, hash commitment. Delete payload 
after chosen horizon. Keep headers and commitments for audit. The node 
remains consensus-equivalent but disk-light. ### 9.3 Selective Retention | 
TLV Type | Example | Keep? | Reason | 
|-----------|---------------------|-------|----------------| | 1 | Hash or 
Merkle root | Yes | Audit proof | | 2 | Declared length | Yes | Accounting 
| | 10 | Raw payload | No | Space saving | ### 9.4 Policy Flags | Flag | 
Value | Description | |------|--------|-------------| | `-prunesegop` | 1 | 
Enable segOP pruning | | `-prunesegopheight` | 2016 | Start pruning after 
2016 blocks | | `-prunewitness` | 1 | Enable witness pruning | | 
`-prunewitnessheight` | 2016 | Start pruning after 2016 blocks | | 
`-keepsegopcommitments` | 1 | Preserve segOP Merkle commitments | ### 9.5 
Storage Projection To understand the long-term effect of segOP on storage, 
it helps to model three realistic futures: the monetary-only baseline, the 
current discounted-data situation, and a segOP-priced and pruned network. 
In a **monetary-only scenario**, blocks average around 1 megabyte of actual 
transaction data. At roughly 52,560 blocks per year, that equals about 52 
gigabytes annually or roughly 525 gigabytes per decade. This represents the 
"clean" Bitcoin model — payments only, no arbitrary data. It’s the lower 
bound for full-node storage. In the **discounted-data future** (the 
situation we already see today with Ordinals and similar use cases), most 
blocks reach 2.5 megabytes on average once the witness discount is 
exploited. That comes to around 1.3 terabytes per decade, and it keeps 
climbing if large cheap data continues to fill every block. In this world, 
node operators are forced to host other people’s content indefinitely while 
earning less from fees — unsustainable for the long term. In the 
**segOP-priced and pruned model**, blocks still carry roughly 1 megabyte of 
payment data, but they may also include up to 1 megabyte of segOP payloads. 
The key difference is that segOP data is fully paid for and can be safely 
pruned after validation. A node that keeps a two-week rolling window of 
segOP data (about 2,000 blocks) would only need an additional 2 gigabytes 
of temporary disk space. After pruning, the total long-term requirement 
stabilises near the same 525-gigabyte range as the monetary-only case — 
effectively holding the line on growth. In short, segOP allows Bitcoin to 
support data-rich use cases **without** forcing every node to store 
terabytes of history. Heavy users pay for their data, and those who want to 
keep it can, while everyone else can prune and move on. ### 9.6 Integrity 
After Pruning Payloads may go, but commitments stay : block hashes still 
cover segOP roots, headers prove existence, archives can re-serve data 
verifiable by hash. ### 9.7 Data Retention Layers ``` 
┌─────────────────────────────────────────────┐ │ BITCOIN NODE │ 
└─────────────────────────────────────────────┘ │ ▼ 
┌─────────────────────────────────────────────┐ │ CORE CONSENSUS (UTXO + 
Headers) │ └─────────────────────────────────────────────┘ │ ▼ 
┌─────────────────────────────────────────────┐ │ RECENT WINDOW (Blocks + 
Witness + segOP) │ └─────────────────────────────────────────────┘ │ ▼ 
┌─────────────────────────────────────────────┐ │ PRUNED HISTORY (Old 
payloads deleted) │ └─────────────────────────────────────────────┘ │ ▼ 
┌─────────────────────────────────────────────┐ │ ARCHIVE / ORACLE NODE 
(optional history) │ └─────────────────────────────────────────────┘ ``` 
### 9.8 Pruning Economics 10-year pruned node ≈ 500 GB. 10-year archive ≈ 
1–3 TB. Only voluntary archives bear that cost— not everyone. ### 9.9 Data 
Ownership and Access Model Under current rules, full nodes host other 
people’s junk indefinitely. segOP changes that by making data 
self-contained and prunable. After validation, nodes may drop payloads 
while keeping hashes and lengths. They stay in consensus without carrying 
unwanted content. Those who want the data keep it; those who don’t prune 
it. Archive (or oracle) nodes voluntarily retain all segOP payloads and 
offer them through APIs or Lightning-paywalled endpoints. Because every 
payload carries its own Merkle root or SHA-256 hash, clients can verify 
authenticity independently. No node is forced to store other people’s data; 
each operator chooses their own weight class. It’s fee fairness at 
inclusion and storage fairness after confirmation — a complete economic 
loop. ## 10 Operational Profiles ### 10.1 Profile A — Home Node Light 
validation on small hardware. `-prune=550` `-prunesegop=1` 
`-prunesegopheight=2016` Keeps two weeks of history; fully validating; tiny 
disk footprint. ### 10.2 Profile B — Mining / Economic Node `-prune=20000` 
`-prunesegop=1` `-prunesegopheight=8064` `-keepsegopcommitments=1` Keeps 3 
months of segOP for fee analysis and template testing. ### 10.3 Profile C — 
Archive / Oracle Node `-prune=0` `-prunesegop=0` `-keepsegopcommitments=1` 
Stores everything, serves API or Lightning requests, earns sats for data. 
### 10.4 Profile D — Enterprise / Auditor `-prune=0` `-prunesegop=1` 
`-prunesegopheight=40320` Keeps 9 months of segOP for audit; drops old 
payloads. ### 10.5 Summary Table | Profile | Purpose | SegOP Policy | 
Storage | Notes | 
|----------|------------|----------------------|---------------------------|-------------------| 
| A | Home | Prune after 2 weeks | Approx. 500 GB (decade) | Light + 
private | | B | Miner | Keep 2–3 months | Approx. 1 TB (decade) | Analytics 
| | C | Archive | Keep forever | Approx. 1–3 TB (decade) | Monetisable | | 
D | Enterprise | Keep 9 months | Approx. 1 TB (decade) | Compliance | ### 
10.6 Network Equilibrium Before segOP, every node bloats together. After 
segOP, the network diversifies but remains coherent: light nodes stay 
light, heavy nodes get paid, everyone shares the same rules. ## 11 
Limitations and Future Work Standardisation: define TLV type registry. 
Miner policy: optional feerate minimum for segOP data. Tooling: RPC & GUI 
support for segOP construction. Pruning: implement -prunesegop flag for 
disk control. Testing: run signet experiments on fee behaviour. Extensions: 
explore Lightning-anchored retrieval oracles. ## 12 Conclusion segOP 
restores honest pricing to blockspace. It changes nothing about Bitcoin’s 
monetary rules—just how data is metered. By isolating large payloads into a 
capped, fully-priced lane, it removes spam incentives while keeping 
on-chain creativity alive. Keep the 520 B limit for signatures. Let data 
live in segOP, pay full rate, and prune it later. That’s all. The outcome: 
smaller chainstate, stronger miners, faster propagation, and fairer 
economics - Bitcoin doing what it was designed to do. ## References [1] P. 
Wuille et al., BIP-141: Segregated Witness (Consensus Layer), 2017. [2] 
Bitcoin Core Source Code, MAX_SCRIPT_ELEMENT_SIZE = 520, 2012. [3] S. 
Nakamoto, Bitcoin: A Peer-to-Peer Electronic Cash System, 2008. [4] M. 
Murch, Understanding the Mempool and Fee Market, 2020. [5] Defenwycke, 
BIP-FAIR: Fair Fee Accounting for On-Chain Data (Draft), 2025.

On Wednesday, October 29, 2025 at 11:55:52 PM UTC defenwycke wrote:

> Hi all,
>
> I attempted to propose a BIP earlier today. I was notified of my incorrect 
> actions versus core procedures.
>
> See attached or below - my proposal for discussion.
>
> Regards
>
> Defenwycke.
>
> ---
>
> A proposed discussion of segOP
> Author: Defenwycke / defen...@icloud.com
> 29.10.2025
>
> segOP (Segregated OP_RETURN)
>
>     A proposed extension to Bitcoin transactions. It introduces a 
> dedicated, structured, full-fee data lane for on-chain data, without 
> disrupting existing transaction rules. Think of it like this - segOP is to 
> arbitrary data what SegWit was to signatures — a clean, isolated, 
> forward-compatible path that preserves old-node harmony while restoring fee 
> fairness.
>
> Abstract:
>
>     segOP defines a new segregated data section for Bitcoin transactions, 
> cryptographically committed via OP_SUCCESS184. It standardizes on-chain 
> metadata storage by enforcing full fees, structured TLV encoding, and a 100 
> KB cap, while remaining backward-compatible with legacy nodes.
>
> It is not:
>
>     - A replacement for OP_RETURN
>     - An off-chain mechanism
>     - A hard fork
>
> It is:
>
>     - A soft-fork-safe, future-proof, SegWit-style data section
>     - Full-fee (4 weight units per byte)
>     - Structured (TLV + Merkle-root verified)
>     - Limited to 100 KB per transaction
>
> What issues could segOP rectify?:
>
>     1. Ordinals abuse witness discount. segOP will apply full fee rate for 
> large data.
>     2. No structured metadata lane. segOP introduces TLV-encoded + 
> Merkle-verified section.
>     3. Witness discount abused for megabytes. segOP Enforces 100 KB cap.
>     4. OP_RETURN unstructured & limited. segOP = structured + verifiable.
>     5. Spam cheap storage. segOP deters spam with fees.
>
>     In short - segOP restores fairness — data pays its real weight cost, 
> preserving block space for financial use.
>
> Where segOP lives:
>
>     Transaction Layout (Post-segOP)
>     Transaction
>     ├── nVersion
>     ├── vin (inputs)
>     ├── vout (outputs)
>     │   └── P2SOP Output ← segOP anchor
>     ├── witness (if any)
>     ├── segOP marker (0xFA)
>     ├── segOP section (if present)
>     │   ├── chunk_count (varint)
>     │   ├── TLV chunk 1
>     │   ├── TLV chunk 2
>     │   └── ...
>     └── nLockTime
>
> Activation rules:
>
>     - segOP section only appears if at least one P2SOP output exists.
>     - Old nodes ignore unknown post-witness data → transaction valid 
> (soft-fork safe).
>     - New nodes validate the segOP section against the Merkle root in the 
> P2SOP output.
>
> How segOP works:
>
>     segOP extends the Bitcoin transaction format by adding a new optional 
> section after the witness field.
>     This section is linked cryptographically to a special output type — 
> the P2SOP output — whose script commits to the Merkle root of the segOP 
> data.
>
>     The design mirrors SegWit: a segregated data structure, excluded from 
> txid but included in wtxid, ensuring backward compatibility.
>
>         1. Transaction Creation
>
>             When a wallet or protocol wants to include on-chain structured 
> data (for example, a document hash, timestamp, or proof set), it performs 
> the following steps:
>
>                 a. Build TLV Chunks
>
>                     Each data element is encoded in Type-Length-Value 
> (TLV) format:
>
>                         - type (varint)
>                         - length (varint)
>                         - value (bytes)
>
>                     Each type defines a data meaning (e.g., type=1: 
> manifest, type=2: payload, type=3: metadata, etc.). This allows future 
> extensions without breaking parsers.
>
>                 b. Construct the Merkle Tree
>
>                     Each TLV is hashed as:
>
>                     leaf = dsha256(0x00 || TLV)
>                     and combined recursively:
>                     node = dsha256(0x01 || left || right)
>
>                     until a single Merkle root is produced. This root 
> uniquely commits to all TLV data while allowing compact partial proofs.
>
>                 c. Commit to the Root (P2SOP Output)
>
>                     The wallet then inserts a special output into the 
> transaction: scriptPubKey = OP_SUCCESS184 0x20 <32-byte Merkle root> 
> (OP_SUCCESS184 is reserved for soft-fork activation).
>                     Legacy nodes treat it as “always true,” so the 
> transaction remains spendable under pre-segOP rules.
>                     The 32-byte push commits to the root of the segOP 
> section.
>                     Multiple P2SOP outputs may exist if a transaction 
> carries multiple data trees, but each must be validated independently.
>
>                 d. Serialize the segOP Section
>
>                     After the witness data, a segOP marker (0xFA) signals 
> presence, followed by the serialized data:
>
>                     0xFA
>                     varint: chunk_count
>                     [TLV #1]
>                     [TLV #2]
>                     ...
>
>                     This section is included in the wtxid but not the 
> txid, keeping legacy hashes unchanged (soft-fork compatible).
>
>         2. Transaction Relay and Policy
>
>             segOP transactions are relayed like any other, with a few 
> policy rules:
>
>                 - Size limit: The total size of segOP data (plus OP_RETURN 
> + witness data >520 B) must not exceed 100,000 bytes. This prevents block 
> bloat.
>                 - Fee treatment: segOP data counts at 4 weight units per 
> byte (no discount), restoring parity between data and signatures.
>                 - Standardness check: Non-mining nodes enforce segOP as a 
> standard policy rule (like SegWit’s P2WSH), rejecting noncompliant data 
> from mempool relay.
>
>                 These are policy rules, not consensus, but miners 
> enforcing them makes segOP behavior uniform across the network.
>
>         3. Validation (Node-Level)
>
>             When a segOP transaction reaches a full node, validation 
> happens in three stages:
>
>                 a. Detect segOP Presence
>
>                     - If any output script begins with OP_SUCCESS184, the 
> node checks for a corresponding segOP section at the end of the transaction 
> serialization.
>                     - If no segOP section is found → transaction invalid 
> under segOP rules.
>
>                 b. Verify Size and Fee
>
>                     The node computes total data size:
>                         - All OP_RETURN payloads
>                         - All segOP TLVs
>                         - All witness items >520 bytes (these count as 
> “data”)
>                         - If this exceeds 100 KB, the transaction is 
> invalid.
>                         - The total weight is adjusted to include all 
> segOP bytes at full cost.
>
>                 c. Verify Merkle Root
>
>                     - The node rebuilds the TLV Merkle tree and ensures:
>                     - calculated_root == <root in P2SOP output>
>                     - If the root mismatches → reject.
>                     - This makes segOP cryptographically bound to the 
> transaction body, just like Taproot commits to script paths.
>
>         4. Inclusion in a Block
>
>             - Miners include segOP transactions normally.
>             - When calculating block weight: segOP bytes count fully (4 
> WU/byte).
>             - segOP does not alter the legacy 4M weight limit but competes 
> fairly for space.
>             - Miners can optionally expose segOP data through RPC or 
> indexing APIs (e.g., gettxoutdata), similar to how they expose witness data.
>
>         5. Verification by Light Clients
>
>             - Because segOP uses a Merkle structure: SPV clients or 
> oracles can request proofs for individual TLVs without downloading full 
> data. For example, a timestamp verifier can request: getsegopproof <txid> 
> <chunk_type> and receive the TLV + Merkle proof + root verification path. 
> This makes segOP efficient for decentralized proof storage or timestamping 
> protocols.
>
>         6. Spending a P2SOP Output
>
>             - Spending a P2SOP output works like spending an OP_SUCCESS 
> output: Until activation, it behaves as anyone-can-spend, ensuring 
> soft-fork safety. After activation, future consensus rules can restrict or 
> redefine P2SOP redemption scripts.
>             - Example forward path: A future BIP may define OP_SUCCESS184 
> redemption to require proof of segOP validity or special conditions (e.g., 
> hash preimage commitments). Until then, nodes treat these outputs as valid 
> spends, ensuring no forks.
>
>         7. Post-Activation Behavior
>
>             - After segOP activation: All upgraded nodes enforce the 100 
> KB cap and Merkle root validation.
>             - Legacy nodes still accept the transactions, unaware of segOP 
> structure.
>             - Any mismatch between segOP section and root simply makes the 
> tx invalid for upgraded miners — thus ensuring consensus alignment.
>
> Examples of segOP:
>
>     Example 1: Timestamp a Document (50 KB)
>         TLV #1: Type = 1, Manifest (JSON)
>         TLV #2: Type = 2, PDF payload (50 KB)
>         Build Merkle root → abc123...
>         Create output:
>         OP_SUCCESS184 0x20 abc123...
>         segOP section:
>         0x02  # chunk count
>         <TLV1> <TLV2>
>         Fee: ≈ $30 at current full-fee rates
>         Permanent, verifiable, structured.
>
>     Example 2: Ordinals Tries 3.8 MB
>         data_size = 3.8 MB → REJECTED (exceeds 100 KB cap)
>         Attempt in witness → REJECTED (data > 520 B → full fee policy → 
> cap still enforced)
>
>     Example 3: Normal BTC Send
>         No P2SOP output : No segOP section
>         Fee Unchanged (~$0.09)
>         Normal transactions unaffected.
>
> How to Use segOP:
>
>     Build a segOP Transaction (Python)
>
>         # 1. Prepare TLV chunks
>         manifest = b'{"type":"proof","size":50000}'
>         payload  = b'50 KB of data...'
>         tlv1 = varint(1) + varint(len(manifest)) + manifest
>         tlv2 = varint(2) + varint(len(payload)) + payload
>
>         # 2. Build Merkle root
>         def dsha256(x): return sha256(sha256(x)).digest()
>         leaf1 = dsha256(b'\x00' + tlv1)
>         leaf2 = dsha256(b'\x00' + tlv2)
>         root  = dsha256(b'\x01' + leaf1 + leaf2)
>
>         # 3. Create P2SOP output
>         p2sop = b'\xb8\x20' + root
>
>         # 4. Build segOP section
>         segop = b'\xFA' + varint(2) + tlv1 + tlv2  # 0xFA marker
>
>         # 5. Attach to tx
>         tx.vout.append(CTxOut(0, CScript(p2sop)))
>         tx.segop_section = segop
>
>     Validation Logic (C++ Pseudocode):
>
>         bool CheckSegOP(const CTransaction& tx) {
>             size_t total_data = 0;
>
>             for (const auto& out : tx.vout) {
>                 if (out.scriptPubKey[0] == OP_SUCCESS184) {
>                     // segOP output detected
>                     if (!tx.HasSegOPSection()) return false;
>                     total_data += tx.segOPSectionSize();
>                 }
>                 if (out.scriptPubKey[0] == OP_RETURN && 
> out.scriptPubKey.size() > 1) {
>                     total_data += out.scriptPubKey.size() - 1;
>                 }
>             }
>
>             for (const auto& in : tx.vin) {
>                 for (const auto& item : in.scriptWitness.stack) {
>                     if (item.size() > 520)
>                         total_data += item.size(); // witness data counts 
> fully
>                 }
>             }
>
>             if (total_data > 100000) return false; // 100 KB consensus cap
>
>             // Apply full weight to data for fee calc
>             tx.virtual_size += total_data;
>             return true;
>         }
>
> Soft Fork Proof:
>
>     - Old node: Ignores segOP
>     - New node: Validates segOP
>     - No chain split
>     - Backward compatible
>     - Miner-activated soft fork possible via versionbits
>
> Developer Q&A:
>
>     Where is segOP serialized? : After witness, before nLockTime
>     Does it affect txid? : No - only wtxid
>     Can old nodes parse it? : Yes (ignored like witness)
>     Max size? : 100 KB total data
>     Fee rate? : Full fee (4 WU/byte)
>     Can I use OP_RETURN too? : Yes — total combined data ≤ 100 KB
>     Future extensions? : TLV unknown types ignored (safe forward-compat)
>     How do I signal presence? : 0xFA marker after witness
>
>
> Conclusion:
>
>     - On-chain
>     - Structured (TLV + Merkle)
>     - Full-fee and fair
>     - Soft-fork safe
>     - Future-proof
>
>     segOP introduces the clean, capped, verifiable data lane Bitcoin needs 
> — ending witness discount abuse while preserving freedom for legitimate 
> metadata.
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/a5ec8a97-3884-40eb-9276-8536f664c0e0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 75845 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-30 15:04  1%           ` Melvin Carvalho
@ 2025-10-30 19:35  1%             ` Martin Habovštiak
  2025-10-31  6:31  1%               ` Melvin Carvalho
  0 siblings, 1 reply; 200+ results
From: Martin Habovštiak @ 2025-10-30 19:35 UTC (permalink / raw)
  To: Melvin Carvalho
  Cc: Greg Maxwell, yes_please, Russell O'Connor, TokyoBitcoiner,
	Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 12295 bytes --]

"Honest" only refers to miners not trying to reverse the transactions by
making an alternative chain. It has nothing to do with your subjective
evaluation of the transactions worth trying to censor the "bad ones".

Bitcoin was specifically designed to prevent censorship of transactions
that follow the consensus rules. Trying to go against it makes you a fool
at best or an attacker at worst.

Dňa št 30. 10. 2025, 18:37 Melvin Carvalho <melvincarvalho@gmail.com>
napísal(a):

>
>
> čt 30. 10. 2025 v 3:16 odesílatel Greg Maxwell <gmaxwell@gmail.com>
> napsal:
>
>> I searched for the source of your quotation and am unable to find it, but
>> its author appears to be confused or missing a complete understanding.
>>
>> The particular size isn't motivated by application but because major
>> miners had already removed the rule completely.  As such no lesser setting
>> would achieve the goal of matching relay to what will actually get mined
>> and completely solve the bad situation created by the mismatch.
>>
>> If you consider this regrettable it's worthwhile to consider that a
>> failure to increase it previously (on several prior proposals) and even a
>> failure to discuss and evaluate it was likely due to the unprofessional and
>> relentless harassment of Luke-jr.  Had that not occurred perhaps the limit
>> would have been incrementally increased previously before major miners on
>> their own found it to be in their interest to simply remove it (as removing
>> it is much easier than twiddling it).  The consequence of failing to be
>> pragmatic is the loss of that nudge.
>>
>> That said, the economics and incentives of bitcoin are such that the
>> removal was inevitable once people were willing to pay for it-- and I would
>> have happily told you this in 2014 or whenever back when op_return was
>> reallowed for relay.  Beyond the current situation with the rule completely
>> bypassed this inevitably favors removal once the policy has started
>> eroding.  Even if miners had only bypassed to a few kilobytes or whatnot
>> moving to match that would only result in repeated cycles of transactions
>> that will get mined failing to relay, each cycle favoring private
>> submission mechanisms and promoting mining centralization.  Policy is only
>> at best a nudge and a fragile one.
>>
>> I think in many people's view-- certainly in mine-- cirtia or whatever
>> was irrelevant to the discussion except as a concrete example of a fake
>> pubkey user that would rather not do that-- and one that wasn't some random
>> NFT thing that we'd all rather not be using Bitcoin at all. In other words,
>> that the benefit of avoiding more utxo bloat wasn't speculative.
>>
>
> While much of this discussion has focused on policy, there’s also an
> incentive perspective.
>
> Section 11 of the white paper notes that consensus holds *iff* honest
> nodes outpace dishonest ones.
>
> If we interpret *honest* as mining blocks consistent with standard
> monetary use, excluding large OP_RETURN payloads, then miners who do so are
> likely to earn more.
>
> When fees from arbitrary data are smaller than roughly half the block
> reward, standard ("honest") miners are effectively producing
> *double-value* blocks each epoch: they gain both the reward and a more
> secure, stable fee market over time.
> That economic feedback alone could be enough to restore convergence back
> to standard size OP_RETURNs. Of course, setting back the default helps here
> too.
>
>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>> On Thu, Oct 30, 2025 at 1:15 AM yes_please <caucasianjazz12@gmail.com>
>> wrote:
>>
>>> Hi all,
>>>
>>> Perhaps we can find a meeting point if we focus on the max size of
>>> OP_return ?
>>> The increase from 83 to 100'000 bytes has been motivated as "probably we
>>> will have to increase it again in the future, it requires energy and time
>>> for code maintenance, so we'd rather increase it now to 100'000 bytes and
>>> be done with it". While these are valid points, the unknown consequences
>>> that might manifest with such a drastic increase all at once may not be the
>>> most prudent approach.
>>> Considering also that "the canary in the coal mine", namely Citrea use
>>> case, requires only 144 bytes to utilize op_return instead of more harmful
>>> ways, the increase to 100'000 bytes appears disproportionate given the
>>> circumstances, and again non-prudent enough (which is what I suspect is
>>> creating most of the debate at hand).
>>>
>>> caucasianjazz12
>>>
>>> On Wed, Oct 29, 2025 at 4:38 PM 'Russell O'Connor' via Bitcoin
>>> Development Mailing List <bitcoindev@googlegroups.com> wrote:
>>>
>>>> On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com>
>>>> wrote:
>>>>
>>>>> Questions reacting to text in reply of Russell O'Connor:
>>>>>
>>>>>    - *" there exist some protocols that require":*
>>>>>       - Which protocols?
>>>>>
>>>>> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I
>>>> don't know anything about their protocol beyond that.
>>>>
>>>>
>>>>>
>>>>>    -
>>>>>       - Why does bitcoin need to cater to their needs?
>>>>>
>>>>> If we don't support these in OP_RETURNs, Citrea, and other folks like
>>>> them, will use something like bare multisigs instead, which will be a
>>>> little more expensive for them and much more expensive for every other
>>>> Bitcoin node operator on the planet because those (likely) unspendable UTXO
>>>> will have to remain in the UTXO set forever because they will be
>>>> indistinguishable from legitimate bare multisigs.
>>>>
>>>>>
>>>>>    -
>>>>>       - Do we cater to any protocol that comes along?
>>>>>          - How do we choose which to enable, and which to discourage?
>>>>>
>>>>> Clamping down on OP_RETURNs won't discourage the use of these
>>>> Citrea-like protocols.  Instead it will encourage them to instead use
>>>> uncensorable publication channels such as bare multisigs, which will bloat
>>>> the UTXO set and drive up costs for every Bitcoin node operator on the
>>>> planet.
>>>>
>>>>>
>>>>>    - *"the folks using these protocols will simply have no choice"*:
>>>>>       - Did we *force* them to use bitcoin for their project?
>>>>>       - It sounds like "if you don't change the code to enable my
>>>>>       project, I will be forced to trash your project." Is this wrong?
>>>>>
>>>>> By "force" I mean in the sense that when a recent KDE upgrade dropped
>>>> the ability to specify some command to be run whenever the screen is
>>>> locked, KDE "forced" me to write a systemd service to run dbus-monitor to
>>>> watch for screen locking events instead.  Fortunately, in the case of KDE,
>>>> being "forced" to work around their changes only makes my life worse.
>>>> However in the case of limiting OP_RETURNs, users who are "forced" to find
>>>> workarounds for their proof of publication protocols  will ultimately lead
>>>> to them using the uncensorable data channel of bare-multisigs, or similar,
>>>> which have consequences not only for themselves but every other Bitcoin
>>>> node operator on the planet.
>>>>
>>>> It is specifically the externalities caused by the bare-multisig
>>>> workaround that we need to address. If these externalities didn't exist,
>>>> then I, and presumably others, wouldn't care so much.
>>>>
>>>>>
>>>>>    - *"any attempt to cap OP_RETURN outputs will force those users"*:
>>>>>       - Again, *force* is a form of coercion. Is the bitcoin code
>>>>>       with it's current setting *forcing* anyone to do anything?
>>>>>       - Are the external protocol designers the victims here?
>>>>>
>>>>> The victims will be every node operator on the planet who has to deal
>>>> with the unprunable UTXO bloat caused by users posting their
>>>> proof-of-publication data via the uncensorable bare-multisig avenue.  This
>>>> collective cost will actually be much higher than the cost to the external
>>>> protocol designers who only have to pay a few more pennies for their
>>>> transactions.
>>>>
>>>>
>>>>>
>>>>>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>>>>>       - What problem?
>>>>>
>>>>> The problem is a combination of protocols that require using
>>>> proof-of-publication choosing to use uncensorable bare-multisigs instead,
>>>> and/or, so long as this proposal isn't adopted, the problem of users
>>>> bypassing the network to get their OP_RETURN transactions mined which leads
>>>> to poor quality block reconstruction and poor quality fee estimates and the
>>>> like.
>>>>
>>>>>
>>>>>    -
>>>>>       - Is the bitcoin code responsible for fulfilling the needs of
>>>>>       an external project or protocol?
>>>>>          - If yes, why?
>>>>>
>>>>> Again the victims here wouldn't be the external protocol designers.
>>>> They will just pay the extra pennies to publish using bare-multisig.  The
>>>> victims would be every Bitcoin node operator on the planet.  And while the
>>>> core developers have no warranties or responsibilities attached to their
>>>> open source code, I think we would agree that "costs borne by every Bitcoin
>>>> node operator on the planet", is something they ought to bear in mind in
>>>> their work.
>>>>
>>>>
>>>>>
>>>>> I hope you will take these questions seriously. I really want to
>>>>> understand your thinking.
>>>>>
>>>>
>>>> Hope this helps.
>>>>
>>>> --
>>>> You received this message because you are subscribed to the Google
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>>> To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com
>>>> <https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>>> .
>>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com
>>> <https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2BD9y6r0RZJPAGY08KSc1s%2BxUZ9UY4fR2f%3DdDc0joXEfQ%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2BD9y6r0RZJPAGY08KSc1s%2BxUZ9UY4fR2f%3DdDc0joXEfQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALkkCJYEQAnj4MVVXnr5ufNz_SXFTg5s4JW5Uud2wipzzfQrXQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 15983 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30  8:55  1%                         ` Bitcoin Error Log
@ 2025-10-30 17:40  0%                           ` Greg Maxwell
  0 siblings, 0 replies; 200+ results
From: Greg Maxwell @ 2025-10-30 17:40 UTC (permalink / raw)
  To: Bitcoin Error Log; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 31898 bytes --]

Fullrbf change in core only occurred *after* substantive miners had already
made the change, and core updated largely with regret to reflect reality
and not contribute to compound harm.  This was clear enough from even a few
minutes read on the history, so I'm unclear as to why you're suggesting
otherwise here.



On Thu, Oct 30, 2025 at 11:39 AM Bitcoin Error Log <
bitcoinerrorlog@gmail.com> wrote:

> Greg,
>
> One correction. Bitcoin has significantly restricted a proven use case
> with policy in the past. Maybe you won't think this qualifies, but it
> happened while you were away so I am curious about your assessment.
>
> During the change to mempoolfullrbf policy, I, with support from the
> original author of the change, and with support of multiple Core devs, and
> with the support of multiple businesses providing data on how they provided
> zero-conf as a service to users via risk management, tried to stop Bitcoin
> from killing first-seen policy, which had been stable for all of the
> history of Bitcoin. The change was at least clearly demonstrated as
> controversial, and lacking real consensus.
>
> I'm happy to admit that no policy is enforceable, and that zero-conf was
> "never safe", but we had a system that worked and made Bitcoin more useful
> to people that used it that way. The businesses simply monitored for
> doublespends, imposed exposure limits per block, and gated actual delivery
> separately from checkout UX. It worked and now it does not and the only
> reason was a policy change.
>
> The problem with claiming that policy is not a means of change, is that
> you must also admit the lack of need for any RBF flags at all, or for
> arguing about data spam relay, or for any wide policy to be a concern of
> Bitcoin Core at all. (particularly when speculatively / subjectively
> applied) .
>
> Thank you, and sorry for the side topic.
>
> ~John
>
>
> On Thursday, October 30, 2025 at 6:40:10 AM UTC Greg Maxwell wrote:
>
> Prior softforks have stuck to using the more explicit "forward
> compatibility" mechanisms, so -- e.g. if you use OP_NOP3 or a higher
> transaction version number or whatever that had no purpose (and would
> literally do nothing), saw ~no use, and was non-standard, or scripts that
> just anyone could have immediately taken at any time (e.g. funds free for
> the collecting rather than something secure)... then in that case I think
> people have felt that the long discussion leading up to a softfork was
> enough to acceptably mitigate the risk.  Tapscript was specifically
> designed to make upgrades even safer and easier by making it so that the
> mere presence of any forward compat opcode (OP_SUCCESSn) makes the whole
> script insecure until that opcode is in use.
>
> The proposal to limit scriptpubkey size is worse because longer scripts
> had purposes and use (e.g. larger multisigs) and unlike some NOP3 or
> txversions where you could be argued to deserve issues if you did something
> so weird and abused a forward compat mechanism, people running into a 520
> limit could have been pretty boring (and I see my own watching wallets have
> some scriptpubkeys beyond that size (big multisigs), in fact-- though I
> don't *think* any are still in use, but even I'm not absolutely sure that
> such a restriction wouldn't confiscate some of my own funds--- and it's a
> pain in the rear to check, having to bring offline stuff online, etc).
>
> Confiscation isn't just limited to timelocks, since the victims of it may
> just not know about the consensus change and while they could move their
> coins they don't.  One of the big advantages many people see in Bitcoin is
> that you can put your keys in a time capsule in the foundation of your home
> and trust that they're still going to be there and you'll be able to use
> your coins a decade later. ... that you don't have to watch out for banks
> drilling your safe deposit boxes or people putting public notices in
> classified ads laying claim to your property.
>
> I don't even think bitcoin has ever policy restricted something that was
> in active use, much less softforked out something like that.  I wouldn't
> say it was impossible but I think on the balance it would favor a notice
> period so that any reasonable person could have taken notice, taken action,
> or at least spoke up.  But since there is no requirement to monitor and
> that's part of bitcoin's value prop the amount of time to consider
> reasonable ought to be quite long.  Which also is at odds with the
> emergency measures position being taken by proponents of such changes.
>
> (which also, I think are just entirely unjustified, even if you accept the
> worst version of their narrative with the historical chain being made
> _illegal_, one could simply produce node software that starts from a well
> known embedded utxo snapshot and doesn't process historical blocks.   Such
> a thing would be in principle a reduction in the security model, but
> balances against the practical and realistic impact of potentially
> confiscating coins I think it looks pretty fine by comparison.  It would
> also be fully consensus compatible, assuming no reorg below that point, and
> can be done right now by anyone who cares in a totally permissionless and
> coercion free manner)
>
>
>
> On Thu, Oct 30, 2025 at 5:13 AM Michael Tidwell <mtidw...@gmail.com>
> wrote:
>
> Greg,
>
> > Also some risk of creating a new scarce asset class.
>
> Well, Casey Rodarmor is in the thread, so lol maybe.
>
> Anyway, point taken. I want to be 100% sure I understand the
> hypotheticals: there could be an off-chain, presigned, transactions that
> needs more than 520 bytes for the scriptPubKey and, as Poelstra said, could
> even form a chain of presigned transactions under some complex, previously
> unknown, scheme that only becomes public after this change is made. Can you
> confirm?
>
> Would it also be a worry that a chain of transactions using said utxo
> could commit to some bizarre scheme, for instance a taproot transaction
> utxo that later is presigned committed back to P2MS larger than 520 bytes?
> If so, I think I get it, you're saying to essentially guarantee no
> confiscation we'd never be able to upgrade old UTXOs and we'd need to track
> them forever to prevent unlikely edge cases?
> Does the presigned chain at least stop needing to be tracked once the
> given UTXO co-mingles with a post-update coinbase utxo?
>
> If so, this is indeed complex! This seems pretty insane both for the
> complexity of implementing and the unlikely edge cases. Has Core ever made
> a decision of (acceptable risk) to upgrade with protection of onchain utxos
> but not hypothetical unpublished ones?
> Aren't we going to run into the same situation if we do an op code clean
> up in the future if we had people presign/commit to op codes that are no
> longer consensus valid?
>
> Tidwell
>
> On Wednesday, October 29, 2025 at 10:32:10 PM UTC-4 Greg Maxwell wrote:
>
> "A few bytes" might be on the order of forever 10% increase in the UTXO
> set size, plus a full from-network resync of all pruned nodes and a full
> (e.g. most of day outage) reindex of all unpruned nodes.  Not
> insignificant but also not nothing.  Such a portion of the existing utxo
> size is not from outputs over 520 bytes in size, so as a scheme for utxo
> set size reduction the addition of MHT tracking would probably make it a
> failure.
>
> Also some risk of creating some new scarce asset class, txouts consisting
> of primordial coins that aren't subject to the new rules... sounds like the
> sort of thing that NFT degens would absolutely love.  That might not be an
> issue *generally* for some change with confiscation risk, but for a change
> that is specifically intended to lobotomize bitcoin to make it less useful
> to NFT degens, maybe not such a great idea. :P
>
> I mentioned it at all because I thought it could potentially be of some
> use, I'm just more skeptical of it for the current context.  Also luke-jr
> and crew has moved on to actually propose even more invasive changes than
> just limiting the script size, which I anticipated, and has much more
> significant issues.  Just size limiting outputs likely doesn't harm any
> interests or usages-- and so probably could be viable if the confiscation
> issue was addressed, but it also doesn't stick it to people transacting in
> ways the priests of ocean mining dislike.
>
> > I believe you're pointing out the idea of non economically-rational
> spammers?
>
> I think it's a mistake to conclude the spammers are economically
> irrational-- they're often just responding to different economics which may
> be less legible to your analysis.  In particular, NFT degens prefer the
> high cost of transactions as a thing that makes their tokens scarce and
> gives them value.  -- otherwise they wouldn't be swapping for one less
> efficient encoding for another, they're just be using another blockchain
> (perhaps their own) entirely.
>
>
>
>
> On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com>
> wrote:
>
> > MRH tracking might make that acceptable, but comes at a high cost which
> I think would clearly not be justified.
>
> Greg, I want to ask/challenge how bad this is, this seems like a generally
> reusable primitive that could make other upgrades more feasible that also
> have the same strict confiscation risk profile.
> IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?
>
> Poelstra,
>
> > I don't think this is a great idea -- it would be technically hard to
> implement and slow deployment indefinitely.
>
> I would like to know how much of a deal breaker this is in your opinion.
> Is MRH tracking off the table? In terms of the hypothetical presigned
> transactions that may exist using P2MS, is this a hard enough reason to
> require a MRH idea?
>
> Greg,
>
> > So, paradoxically this limit might increase the amount of non-prunable
> data
>
> I believe you're pointing out the idea of non economically-rational
> spammers? We already see actors ignoring cheaper witness inscription
> methods. If spam shifts to many sub-520 fake pubkey outputs (which I
> believe is less harmful than stamps), that imo is a separate UTXO cost
> discussion. (like a SF to add weight to outputs). Anywho, this point alone
> doesn't seem sufficient to add as a clear negative reason for someone
> opposed to the proposal.
>
> Thanks,
> Tidwell
> On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:
>
> > Confiscation is a problem because of presigned transactions
>
> Allow 10000 bytes of total scriptPubKey size in each block counting only
> those outputs that are larger than x (520 as proposed).
> The code change is pretty minimal from the most obvious implementation of
> the original rule.
>
> That makes it technically non-confiscatory. Still non-standard, but if
> anyone out there so obnoxiously foot-gunned themselves, they can't claim
> they were rugged by the devs.
>
> BR,
> moonsettler
>
> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io>
> wrote:
>
> > Hey,
> >
> > First, thank you to everyone who responded, and please continue to do
> so. There were many thought provoking responses and this did shift my
> perspective quite a bit from the original post, which in of itself was the
> goal to a degree.
> >
> > I am currently only going to respond to all of the current concerns.
> Acks; though I like them will be ignored unless new discoveries are
> included.
> >
> > Tl;dr (Portlands Perspective)
> > - Confiscation is a problem because of presigned transactions
> > - DoS mitigation could also occur through marking UTXOs as unspendable
> if > 520 bytes, this would preserve the proof of publication.
> > - Timeout / Sunset logic is compelling
> > - The (n) value of acceptable needed bytes is contentious with the lower
> suggested limit being 67
> > - Congestion control is worth a look?
> >
> > Next Step:
> > - Deeper discussion at the individual level: Antoine Poinsot and GCC
> overlap?
> > - Write an implementation.
> > - Decide to pursue BIP
> >
> > Responses
> >
> > Andrew Poelstra:
> > > There is a risk of confiscation of coins which have pre-signed but
> > > unpublished transactions spending them to new outputs with large
> > > scriptPubKeys. Due to long-standing standardness rules, and the
> presence
> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any
> > > such transactions exist.
> >
> > PortlandHODL: This is a risk that can be incurred and likely not
> possible to mitigate as there could be possible chains of transactions so
> even when recursively iterating over a chain there is a chance that a
> presigned breaks this rule. Every idea I have had from block redemption
> limits on prevouts seems to just be a coverage issue where you can make the
> confiscation less likely but not completely mitigated.
> >
> > Second, there are already TXs that effectively have been confiscated at
> the policy level (P2SH Cleanstack violation) where the user can not find
> any miner with a policy to accept these into their mempool. (3 years)
> >
> > /dev /fd0
> > > so it would be great if this was restricted to OP_RETURN
> >
> > PortlandHODL: I reject this completely as this would remove the UTXOset
> omission for the scriptPubkey and encourage miners to subvert the OP_RETURN
> restriction and instead just use another op_code, this also do not hit on
> some of the most important factors such as DoS mitigation and legacy script
> attack surface reduction.
> >
> > Peter Todd
> > > NACK ...
> >
> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP,
> without including any additional context or reasoning.
> >
> > jeremy
> > > I think that this type of rule is OK if we do it as a "sunsetting"
> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2
> years, 5 years, 10 years).
> >
> > If action is taken, this is the most reasonable approach. Alleviating
> confiscatory concerns through deferral.
> >
> > > You can argue against this example probably, but it is worth
> considering that absence of evidence of use is not evidence of absence of
> use and I myself feel that overall our understanding of Bitcoin transaction
> programming possibilities is still early. If you don't like this example, I
> can give you others (probably).
> >
> > Agreed and this also falls into the reasoning for deciding to utilize
> point 1 in your response. My thoughts on this would be along the lines of
> proof of publication as this change only has the effect of stripping away
> the executable portion of a script between 521 and 10_000 bytes or the
> published data portion if > 10_000 bytes which the same data could likely
> be published in chunked segments using outpoints.
> >
> > Andrew Poelstra:
> > > Aside from proof-of-publication (i.e. data storage directly in the
> UTXO
> > > set) there is no usage of script which can't be equally (or better)
> > > accomplished by using a Segwit v0 or Taproot script.
> >
> > This sums up the majority of future usecase concern
> >
> > Anthony Towns:
> > > (If you restricted the change to only applying to scripts that used
> > non-push operators, that would probably still provide upgrade
> flexibility
> > while also preventing potential script abuses. But it wouldn't do
> anything
> > to prevent publishing data)
> >
> > Could this not be done as segments in multiple outpoints using a
> coordination outpoint? I fail to see why publication proof must be in a
> single chunk. This does though however bring another alternative to mind,
> just making these outpoints unspendable but not invalidate the block
> through inclusion...
> >
> > > As far as the "but contiguous data will be regulated more strictly"
> > argument goes; I don't think "your honour, my offensive content has
> > strings of 4d0802 every 520 bytes
> >
> > Correct, this was never meant to resolve this issue.
> >
> > Luke Dashjr:
> > > If we're going this route, we should just close all the gaps for the
> immediate future:
> >
> > To put it nicely, this is completely beyond the scope of what is being
> proposed.
> >
> > Guus Ellenkamp:
> > > If there are really so few OP_RETURN outputs more than 144 bytes, then
> > why increase the limit if that change is so controversial? It seems
> > people who want to use a larger OP_RETURN size do it anyway, even with
> > the current default limits.
> >
> > Completely off topic and irrelevant
> >
> > Greg Tonoski:
> > > Limiting the maximum size of the scriptPubKey of a transaction to 67
> bytes.
> >
> > This leave no room to deal with broken hashing algorithms and very
> little future upgradability for hooks. The rest of these points should be
> merged with Lukes response and either hijack my thread or start a new one
> with the increased scope, any approach I take will only be related to the
> ScriptPubkey
> >
> > Keagan McClelland:
> > > Hard NACK on capping the witness size as that would effectively ban
> large scripts even in the P2SH wrapper which undermines Bitcoin's ability
> to be an effectively programmable money.
> >
> > This has nothing to do with the witness size or even the P2SH wrapper
> >
> > Casey Rodarmor:
> > > I think that "Bitcoin could need it in the future?" might be a good
> enough
> > reason not to do this.
> >
> > > Script pubkeys are the only variable-length transaction fields which
> can be
> > covered by input signatures, which might make them useful for future
> soft
> > forks. I can imagine confidential asset schemes or post-quantum coin
> recovery
> > schemes requiring large proofs in the outputs, where the validity of the
> proof
> > determined whether or not the transaction is valid, and thus require the
> > proofs to be in the outputs, and not just a hash commitment.
> >
> > Would the ability to publish the data alone be enough? Example make the
> output unspendable but allow for the existence of the bytes to be covered
> through the signature?
> >
> >
> > Antoine Poinsot:
> > > Limiting the size of created scriptPubKeys is not a sufficient
> mitigation on its own
> > I fail to see how this would not be sufficient? To DoS you need 2 things
> inputs with ScriptPubkey redemptions + heavy op_codes that require unique
> checks. Example DUPing stack element again and again doesn't work. This
> then leads to the next part is you could get up to unique complex
> operations with the current (n) limit included per input.
> >
> > > One of the goal of BIP54 is to address objections to Matt's earlier
> proposal, notably the (in my
> > opinion reasonable) confiscation concerns voiced by Russell O'Connor.
> Limiting the size of
> > scriptPubKeys would in this regard be moving in the opposite direction.
> >
> > Some notes is I would actually go as far as to say the confiscation risk
> is higher with the TX limit proposed in BIP54 as we actually have proof of
> redemption of TXs that break that rule and the input set to do this already
> exists on-chain no need to even wonder about the whole presigned.
> bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
> >
> > Please let me know if I am incorrect on any of this.
> >
> > > Furthermore, it's always possible to get the biggest bang for our buck
> in a first step
> >
> > Agreed on bang for the buck regarding DoS.
> >
> > My final point here would be that I would like to discuss more, and this
> is response is from the initial view of your response and could be
> incomplete or incorrect, This is just my in the moment response.
> >
> > Antoine Riard:
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
> favor of prioritizing
> > a timewarp fix and limiting dosy spends by old redeem scripts
> >
> > The idea of congestion control is interesting, but this solution should
> significantly reduce the total DoS severity of known vectors.
> >
> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
> >
> > > Limits on block construction that cross transactions make it harder to
> accurately estimate fees and greatly complicate optimal block
> construction-- the latter being important because smarter and more computer
> powered mining code generating higher profits is a pro centralization
> factor.
> > >
> > > In terms of effectiveness the "spam" will just make itself
> indistinguishable from the most common transaction traffic from the
> perspective of such metrics-- and might well drive up "spam" levels because
> the higher embedding cost may make some of them use more transactions. The
> competition for these buckets by other traffic could make it effectively a
> block size reduction even against very boring ordinary transactions. ...
> which is probably not what most people want.
> > >
> > > I think it's important to keep in mind that bitcoin fee levels even at
> 0.1s/vb are far beyond what other hosting services and other blockchains
> cost-- so anyone still embedding data in bitcoin *really* want to be there
> for some reason and aren't too fee sensitive or else they'd already be
> using something else... some are even in favor of higher costs since the
> high fees are what create the scarcity needed for their seigniorage.
> > >
> > > But yeah I think your comments on priorities are correct.
> > >
> > >
> > >
> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com>
> wrote:
> > >
> > > > Hi list,
> > > >
> > > > Thanks to the annex covered by the signature, I don't see how the
> concern about limiting
> > > > the extensibility of bitcoin script with future (post-quantum)
> cryptographic schemes.
> > > > Previous proposal of the annex were deliberately designed with
> variable-length fields
> > > > to flexibly accomodate a wide range of things.
> > > >
> > > > I believe there is one thing that has not been proposed to limit
> unpredictable utterance
> > > > of spams on the blockchain, namely congestion control of categories
> of outputs (e.g "fat"
> > > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey
> and L a limiting
> > > > threshold for the number of T occurences during the period P. Beyond
> the L threshold, any
> > > > additional T scriptpubkey is making the block invalid. Or
> alternatively, any additional
> > > > T generating / spending transaction must pay some weight penalty...
> > > >
> > > > Congestion control, which of course comes with its lot of
> shenanigans, is not very a novel
> > > > idea as I believe it has been floated few times in the context of
> lightning to solve mass
> > > > closure, where channels out-priced at current feerate would have
> their safety timelocks scale
> > > > ups.
> > > >
> > > > No need anymore to come to social consensus on what is quantitative
> "spam" or not. The blockchain
> > > > would automatically throttle out the block space spamming
> transaction. Qualitative spam it's another
> > > > question, for anyone who has ever read shannon's theory of
> communication only effective thing can
> > > > be to limit the size of data payload. But probably we're kickly back
> to a non-mathematically solvable
> > > > linguistical question again [0].
> > > >
> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
> favor of prioritizing
> > > > a timewarp fix and limiting dosy spends by old redeem scripts,
> rather than engaging in shooting
> > > > ourselves in the foot with ill-designed "spam" consensus
> mitigations.
> > > >
> > > > [0] If you have a soul of logician, it would be an interesting
> demonstration to come with
> > > > to establish that we cannot come up with mathematically or
> cryptographically consensus means
> > > > to solve qualitative "spam", which in a very pure sense is a
> linguistical issue.
> > > >
> > > > Best,
> > > > Antoine
> > > > OTS hash:
> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a
> écrit :
> > > >
> > > > > Hi,
> > > > >
> > > > > This approach was discussed last year when evaluating the best way
> to mitigate DoS blocks in terms
> > > > > of gains compared to confiscatory surface. Limiting the size of
> created scriptPubKeys is not a
> > > > > sufficient mitigation on its own, and has a non-trivial
> confiscatory surface.
> > > > >
> > > > > One of the goal of BIP54 is to address objections to Matt's
> earlier proposal, notably the (in my
> > > > > opinion reasonable) confiscation concerns voiced by Russell
> O'Connor. Limiting the size of
> > > > > scriptPubKeys would in this regard be moving in the opposite
> direction.
> > > > >
> > > > > Various approaches of limiting the size of spent scriptPubKeys
> were discussed, in forms that would
> > > > > mitigate the confiscatory surface, to adopt in addition to (what
> eventually became) the BIP54 sigops
> > > > > limit. However i decided against including this additional measure
> in BIP54 because:
> > > > > - of the inherent complexity of the discussed schemes, which would
> make it hard to reason about
> > > > > constructing transactions spending legacy inputs, and equally hard
> to evaluate the reduction of
> > > > > the confiscatory surface;
> > > > > - more importantly, there is steep diminishing returns to piling
> on more mitigations. The BIP54
> > > > > limit on its own prevents an externally-motivated attacker from
> *unevenly* stalling the network
> > > > > for dozens of minutes, and a revenue-maximizing miner from
> regularly stalling its competitions
> > > > > for dozens of seconds, at a minimized cost in confiscatory
> surface. Additional mitigations reduce
> > > > > the worst case validation time by a smaller factor at a higher
> cost in terms of confiscatory
> > > > > surface. It "feels right" to further reduce those numbers, but
> it's less clear what the tangible
> > > > > gains would be.
> > > > >
> > > > > Furthermore, it's always possible to get the biggest bang for our
> buck in a first step and going the
> > > > > extra mile in a later, more controversial, soft fork. I previously
> floated the idea of a "cleanup
> > > > > v2" in private discussions, and i think besides a reduction of the
> maximum scriptPubKey size it
> > > > > should feature a consensus-enforced maximum transaction size for
> the reasons stated here:
> > > > >
> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8.
> I wouldn't hold my
> > > > > breath on such a "cleanup v2", but it may be useful to have it
> documented somewhere.
> > > > >
> > > > > I'm trying to not go into much details regarding which mitigations
> were considered in designing
> > > > > BIP54, because they are tightly related to the design of various
> DoS blocks. But i'm always happy to
> > > > > rehash the decisions made there and (re-)consider alternative
> approaches on the semi-private Delving
> > > > > thread [0] dedicated to this purpose. Feel free to ping me to get
> access if i know you.
> > > > >
> > > > > Best,
> > > > > Antoine Poinsot
> > > > >
> > > > > [0]:
> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
> > > > >
> > > > >
> > > > >
> > > > >
> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
> fre...@reardencode.com> wrote:
> > > > >
> > > > > >
> > > > > >
> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
> > > > > >
> > > > > > > But also given that there are essentially no violations and no
> reason to
> > > > > > > expect any I'm not sure the proposal is worth time relative to
> fixes of
> > > > > > > actual moderately serious DOS attack issues.
> > > > > >
> > > > > >
> > > > > > I believe this limit would also stop most (all?) of
> PortlandHODL's
> > > > > > DoSblocks without having to make some of the other changes in
> GCC. I
> > > > > > think it's worthwhile to compare this approach to those proposed
> by
> > > > > > Antoine in solving these DoS vectors.
> > > > > >
> > > > > > Best,
> > > > > >
> > > > > > --Brandon
> > > > > >
> > > > > > --
> > > > > > You received this message because you are subscribed to the
> Google Groups "Bitcoin Development Mailing List" group.
> > > > > > To unsubscribe from this group and stop receiving emails from
> it, send an email to bitcoindev+...@googlegroups.com.
> > > > > > To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
> > > >
> > > > --
> > > > You received this message because you are subscribed to the Google
> Groups "Bitcoin Development Mailing List" group.
> > > > To unsubscribe from this group and stop receiving emails from it,
> send an email to bitcoindev+...@googlegroups.com.
> > >
> > > > To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com.
>
> >
> > --
> > You received this message because you are subscribed to the Google
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com.
>
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/09d0aa74-1305-45bd-8da9-03d1506f5784n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/09d0aa74-1305-45bd-8da9-03d1506f5784n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTKf4wyfnhep7LsmAEad7HRsg5S5VguX9rDrdMUrkkrXQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 37267 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-30  2:10  1%         ` Greg Maxwell
@ 2025-10-30 15:04  1%           ` Melvin Carvalho
  2025-10-30 19:35  1%             ` Martin Habovštiak
  0 siblings, 1 reply; 200+ results
From: Melvin Carvalho @ 2025-10-30 15:04 UTC (permalink / raw)
  To: Greg Maxwell
  Cc: yes_please, Russell O'Connor, TokyoBitcoiner,
	Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 10981 bytes --]

čt 30. 10. 2025 v 3:16 odesílatel Greg Maxwell <gmaxwell@gmail.com> napsal:

> I searched for the source of your quotation and am unable to find it, but
> its author appears to be confused or missing a complete understanding.
>
> The particular size isn't motivated by application but because major
> miners had already removed the rule completely.  As such no lesser setting
> would achieve the goal of matching relay to what will actually get mined
> and completely solve the bad situation created by the mismatch.
>
> If you consider this regrettable it's worthwhile to consider that a
> failure to increase it previously (on several prior proposals) and even a
> failure to discuss and evaluate it was likely due to the unprofessional and
> relentless harassment of Luke-jr.  Had that not occurred perhaps the limit
> would have been incrementally increased previously before major miners on
> their own found it to be in their interest to simply remove it (as removing
> it is much easier than twiddling it).  The consequence of failing to be
> pragmatic is the loss of that nudge.
>
> That said, the economics and incentives of bitcoin are such that the
> removal was inevitable once people were willing to pay for it-- and I would
> have happily told you this in 2014 or whenever back when op_return was
> reallowed for relay.  Beyond the current situation with the rule completely
> bypassed this inevitably favors removal once the policy has started
> eroding.  Even if miners had only bypassed to a few kilobytes or whatnot
> moving to match that would only result in repeated cycles of transactions
> that will get mined failing to relay, each cycle favoring private
> submission mechanisms and promoting mining centralization.  Policy is only
> at best a nudge and a fragile one.
>
> I think in many people's view-- certainly in mine-- cirtia or whatever was
> irrelevant to the discussion except as a concrete example of a fake pubkey
> user that would rather not do that-- and one that wasn't some random NFT
> thing that we'd all rather not be using Bitcoin at all. In other words,
> that the benefit of avoiding more utxo bloat wasn't speculative.
>

While much of this discussion has focused on policy, there’s also an
incentive perspective.

Section 11 of the white paper notes that consensus holds *iff* honest nodes
outpace dishonest ones.

If we interpret *honest* as mining blocks consistent with standard monetary
use, excluding large OP_RETURN payloads, then miners who do so are likely
to earn more.

When fees from arbitrary data are smaller than roughly half the block
reward, standard ("honest") miners are effectively producing *double-value*
blocks each epoch: they gain both the reward and a more secure, stable fee
market over time.
That economic feedback alone could be enough to restore convergence back to
standard size OP_RETURNs. Of course, setting back the default helps here
too.


>
>
>
>
>
>
>
>
>
>
> On Thu, Oct 30, 2025 at 1:15 AM yes_please <caucasianjazz12@gmail.com>
> wrote:
>
>> Hi all,
>>
>> Perhaps we can find a meeting point if we focus on the max size of
>> OP_return ?
>> The increase from 83 to 100'000 bytes has been motivated as "probably we
>> will have to increase it again in the future, it requires energy and time
>> for code maintenance, so we'd rather increase it now to 100'000 bytes and
>> be done with it". While these are valid points, the unknown consequences
>> that might manifest with such a drastic increase all at once may not be the
>> most prudent approach.
>> Considering also that "the canary in the coal mine", namely Citrea use
>> case, requires only 144 bytes to utilize op_return instead of more harmful
>> ways, the increase to 100'000 bytes appears disproportionate given the
>> circumstances, and again non-prudent enough (which is what I suspect is
>> creating most of the debate at hand).
>>
>> caucasianjazz12
>>
>> On Wed, Oct 29, 2025 at 4:38 PM 'Russell O'Connor' via Bitcoin
>> Development Mailing List <bitcoindev@googlegroups.com> wrote:
>>
>>> On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com>
>>> wrote:
>>>
>>>> Questions reacting to text in reply of Russell O'Connor:
>>>>
>>>>    - *" there exist some protocols that require":*
>>>>       - Which protocols?
>>>>
>>>> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I
>>> don't know anything about their protocol beyond that.
>>>
>>>
>>>>
>>>>    -
>>>>       - Why does bitcoin need to cater to their needs?
>>>>
>>>> If we don't support these in OP_RETURNs, Citrea, and other folks like
>>> them, will use something like bare multisigs instead, which will be a
>>> little more expensive for them and much more expensive for every other
>>> Bitcoin node operator on the planet because those (likely) unspendable UTXO
>>> will have to remain in the UTXO set forever because they will be
>>> indistinguishable from legitimate bare multisigs.
>>>
>>>>
>>>>    -
>>>>       - Do we cater to any protocol that comes along?
>>>>          - How do we choose which to enable, and which to discourage?
>>>>
>>>> Clamping down on OP_RETURNs won't discourage the use of these
>>> Citrea-like protocols.  Instead it will encourage them to instead use
>>> uncensorable publication channels such as bare multisigs, which will bloat
>>> the UTXO set and drive up costs for every Bitcoin node operator on the
>>> planet.
>>>
>>>>
>>>>    - *"the folks using these protocols will simply have no choice"*:
>>>>       - Did we *force* them to use bitcoin for their project?
>>>>       - It sounds like "if you don't change the code to enable my
>>>>       project, I will be forced to trash your project." Is this wrong?
>>>>
>>>> By "force" I mean in the sense that when a recent KDE upgrade dropped
>>> the ability to specify some command to be run whenever the screen is
>>> locked, KDE "forced" me to write a systemd service to run dbus-monitor to
>>> watch for screen locking events instead.  Fortunately, in the case of KDE,
>>> being "forced" to work around their changes only makes my life worse.
>>> However in the case of limiting OP_RETURNs, users who are "forced" to find
>>> workarounds for their proof of publication protocols  will ultimately lead
>>> to them using the uncensorable data channel of bare-multisigs, or similar,
>>> which have consequences not only for themselves but every other Bitcoin
>>> node operator on the planet.
>>>
>>> It is specifically the externalities caused by the bare-multisig
>>> workaround that we need to address. If these externalities didn't exist,
>>> then I, and presumably others, wouldn't care so much.
>>>
>>>>
>>>>    - *"any attempt to cap OP_RETURN outputs will force those users"*:
>>>>       - Again, *force* is a form of coercion. Is the bitcoin code with
>>>>       it's current setting *forcing* anyone to do anything?
>>>>       - Are the external protocol designers the victims here?
>>>>
>>>> The victims will be every node operator on the planet who has to deal
>>> with the unprunable UTXO bloat caused by users posting their
>>> proof-of-publication data via the uncensorable bare-multisig avenue.  This
>>> collective cost will actually be much higher than the cost to the external
>>> protocol designers who only have to pay a few more pennies for their
>>> transactions.
>>>
>>>
>>>>
>>>>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>>>>       - What problem?
>>>>
>>>> The problem is a combination of protocols that require using
>>> proof-of-publication choosing to use uncensorable bare-multisigs instead,
>>> and/or, so long as this proposal isn't adopted, the problem of users
>>> bypassing the network to get their OP_RETURN transactions mined which leads
>>> to poor quality block reconstruction and poor quality fee estimates and the
>>> like.
>>>
>>>>
>>>>    -
>>>>       - Is the bitcoin code responsible for fulfilling the needs of an
>>>>       external project or protocol?
>>>>          - If yes, why?
>>>>
>>>> Again the victims here wouldn't be the external protocol designers.
>>> They will just pay the extra pennies to publish using bare-multisig.  The
>>> victims would be every Bitcoin node operator on the planet.  And while the
>>> core developers have no warranties or responsibilities attached to their
>>> open source code, I think we would agree that "costs borne by every Bitcoin
>>> node operator on the planet", is something they ought to bear in mind in
>>> their work.
>>>
>>>
>>>>
>>>> I hope you will take these questions seriously. I really want to
>>>> understand your thinking.
>>>>
>>>
>>> Hope this helps.
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+unsubscribe@googlegroups.com.
>>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com
>>> <https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAKaEYh%2BD9y6r0RZJPAGY08KSc1s%2BxUZ9UY4fR2f%3DdDc0joXEfQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 14256 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30  2:26  0%                   ` Greg Maxwell
  2025-10-30  3:36  0%                     ` Michael Tidwell
@ 2025-10-30 16:10  1%                     ` Tom Harding
  2025-10-30 22:15  0%                       ` Doctor Buzz
  1 sibling, 1 reply; 200+ results
From: Tom Harding @ 2025-10-30 16:10 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 23666 bytes --]

We should reflect on the goal of minimizing UTXO set size.  Would we as 
easily say we should minimize the number of people/entities who hold L1 
coins, or the number of ways each person/entity can hold them?

The dire concern with UTXO set size was born with the optimization of the 
core bitcoin software for mining, rather than for holding and transfers, in 
2012.  Some geniuses were involved with that change.  Satoshi was not one 
of them. 


On Wednesday, October 29, 2025 at 7:32:10 PM UTC-7 Greg Maxwell wrote:

"A few bytes" might be on the order of forever 10% increase in the UTXO set 
size, plus a full from-network resync of all pruned nodes and a full (e.g. 
most of day outage) reindex of all unpruned nodes.  Not insignificant but 
also not nothing.  Such a portion of the existing utxo size is not from 
outputs over 520 bytes in size, so as a scheme for utxo set size reduction 
the addition of MHT tracking would probably make it a failure.

Also some risk of creating some new scarce asset class, txouts consisting 
of primordial coins that aren't subject to the new rules... sounds like the 
sort of thing that NFT degens would absolutely love.  That might not be an 
issue *generally* for some change with confiscation risk, but for a change 
that is specifically intended to lobotomize bitcoin to make it less useful 
to NFT degens, maybe not such a great idea. :P

I mentioned it at all because I thought it could potentially be of some 
use, I'm just more skeptical of it for the current context.  Also luke-jr 
and crew has moved on to actually propose even more invasive changes than 
just limiting the script size, which I anticipated, and has much more 
significant issues.  Just size limiting outputs likely doesn't harm any 
interests or usages-- and so probably could be viable if the confiscation 
issue was addressed, but it also doesn't stick it to people transacting in 
ways the priests of ocean mining dislike. 

> I believe you're pointing out the idea of non economically-rational 
spammers?

I think it's a mistake to conclude the spammers are economically 
irrational-- they're often just responding to different economics which may 
be less legible to your analysis.  In particular, NFT degens prefer the 
high cost of transactions as a thing that makes their tokens scarce and 
gives them value.  -- otherwise they wouldn't be swapping for one less 
efficient encoding for another, they're just be using another blockchain 
(perhaps their own) entirely.




On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com> wrote:

> MRH tracking might make that acceptable, but comes at a high cost which I 
think would clearly not be justified.

Greg, I want to ask/challenge how bad this is, this seems like a generally 
reusable primitive that could make other upgrades more feasible that also 
have the same strict confiscation risk profile.
IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?

Poelstra,

> I don't think this is a great idea -- it would be technically hard to
implement and slow deployment indefinitely.

I would like to know how much of a deal breaker this is in your opinion. Is 
MRH tracking off the table? In terms of the hypothetical presigned 
transactions that may exist using P2MS, is this a hard enough reason to 
require a MRH idea?

Greg,

> So, paradoxically this limit might increase the amount of non-prunable 
data

I believe you're pointing out the idea of non economically-rational 
spammers? We already see actors ignoring cheaper witness inscription 
methods. If spam shifts to many sub-520 fake pubkey outputs (which I 
believe is less harmful than stamps), that imo is a separate UTXO cost 
discussion. (like a SF to add weight to outputs). Anywho, this point alone 
doesn't seem sufficient to add as a clear negative reason for someone 
opposed to the proposal.

Thanks,
Tidwell
On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:

> Confiscation is a problem because of presigned transactions 

Allow 10000 bytes of total scriptPubKey size in each block counting only 
those outputs that are larger than x (520 as proposed). 
The code change is pretty minimal from the most obvious implementation of 
the original rule. 

That makes it technically non-confiscatory. Still non-standard, but if 
anyone out there so obnoxiously foot-gunned themselves, they can't claim 
they were rugged by the devs. 

BR, 
moonsettler 

On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io> 
wrote: 

> Hey, 
> 
> First, thank you to everyone who responded, and please continue to do so. 
There were many thought provoking responses and this did shift my 
perspective quite a bit from the original post, which in of itself was the 
goal to a degree. 
> 
> I am currently only going to respond to all of the current concerns. 
Acks; though I like them will be ignored unless new discoveries are 
included. 
> 
> Tl;dr (Portlands Perspective) 
> - Confiscation is a problem because of presigned transactions 
> - DoS mitigation could also occur through marking UTXOs as unspendable if 
> 520 bytes, this would preserve the proof of publication. 
> - Timeout / Sunset logic is compelling 
> - The (n) value of acceptable needed bytes is contentious with the lower 
suggested limit being 67 
> - Congestion control is worth a look? 
> 
> Next Step: 
> - Deeper discussion at the individual level: Antoine Poinsot and GCC 
overlap? 
> - Write an implementation. 
> - Decide to pursue BIP 
> 
> Responses 
> 
> Andrew Poelstra: 
> > There is a risk of confiscation of coins which have pre-signed but 
> > unpublished transactions spending them to new outputs with large 
> > scriptPubKeys. Due to long-standing standardness rules, and the 
presence 
> > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any 
> > such transactions exist. 
> 
> PortlandHODL: This is a risk that can be incurred and likely not possible 
to mitigate as there could be possible chains of transactions so even when 
recursively iterating over a chain there is a chance that a presigned 
breaks this rule. Every idea I have had from block redemption limits on 
prevouts seems to just be a coverage issue where you can make the 
confiscation less likely but not completely mitigated. 
> 
> Second, there are already TXs that effectively have been confiscated at 
the policy level (P2SH Cleanstack violation) where the user can not find 
any miner with a policy to accept these into their mempool. (3 years) 
> 
> /dev /fd0 
> > so it would be great if this was restricted to OP_RETURN 
> 
> PortlandHODL: I reject this completely as this would remove the UTXOset 
omission for the scriptPubkey and encourage miners to subvert the OP_RETURN 
restriction and instead just use another op_code, this also do not hit on 
some of the most important factors such as DoS mitigation and legacy script 
attack surface reduction. 
> 
> Peter Todd 
> > NACK ... 
> 
> PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
without including any additional context or reasoning. 
> 
> jeremy 
> > I think that this type of rule is OK if we do it as a "sunsetting" 
restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
years, 5 years, 10 years). 
> 
> If action is taken, this is the most reasonable approach. Alleviating 
confiscatory concerns through deferral. 
> 
> > You can argue against this example probably, but it is worth 
considering that absence of evidence of use is not evidence of absence of 
use and I myself feel that overall our understanding of Bitcoin transaction 
programming possibilities is still early. If you don't like this example, I 
can give you others (probably). 
> 
> Agreed and this also falls into the reasoning for deciding to utilize 
point 1 in your response. My thoughts on this would be along the lines of 
proof of publication as this change only has the effect of stripping away 
the executable portion of a script between 521 and 10_000 bytes or the 
published data portion if > 10_000 bytes which the same data could likely 
be published in chunked segments using outpoints. 
> 
> Andrew Poelstra: 
> > Aside from proof-of-publication (i.e. data storage directly in the UTXO 
> > set) there is no usage of script which can't be equally (or better) 
> > accomplished by using a Segwit v0 or Taproot script. 
> 
> This sums up the majority of future usecase concern 
> 
> Anthony Towns: 
> > (If you restricted the change to only applying to scripts that used 
> non-push operators, that would probably still provide upgrade flexibility 
> while also preventing potential script abuses. But it wouldn't do 
anything 
> to prevent publishing data) 
> 
> Could this not be done as segments in multiple outpoints using a 
coordination outpoint? I fail to see why publication proof must be in a 
single chunk. This does though however bring another alternative to mind, 
just making these outpoints unspendable but not invalidate the block 
through inclusion... 
> 
> > As far as the "but contiguous data will be regulated more strictly" 
> argument goes; I don't think "your honour, my offensive content has 
> strings of 4d0802 every 520 bytes 
> 
> Correct, this was never meant to resolve this issue. 
> 
> Luke Dashjr: 
> > If we're going this route, we should just close all the gaps for the 
immediate future: 
> 
> To put it nicely, this is completely beyond the scope of what is being 
proposed. 
> 
> Guus Ellenkamp: 
> > If there are really so few OP_RETURN outputs more than 144 bytes, then 
> why increase the limit if that change is so controversial? It seems 
> people who want to use a larger OP_RETURN size do it anyway, even with 
> the current default limits. 
> 
> Completely off topic and irrelevant 
> 
> Greg Tonoski: 
> > Limiting the maximum size of the scriptPubKey of a transaction to 67 
bytes. 
> 
> This leave no room to deal with broken hashing algorithms and very little 
future upgradability for hooks. The rest of these points should be merged 
with Lukes response and either hijack my thread or start a new one with the 
increased scope, any approach I take will only be related to the 
ScriptPubkey 
> 
> Keagan McClelland: 
> > Hard NACK on capping the witness size as that would effectively ban 
large scripts even in the P2SH wrapper which undermines Bitcoin's ability 
to be an effectively programmable money. 
> 
> This has nothing to do with the witness size or even the P2SH wrapper 
> 
> Casey Rodarmor: 
> > I think that "Bitcoin could need it in the future?" might be a good 
enough 
> reason not to do this. 
> 
> > Script pubkeys are the only variable-length transaction fields which 
can be 
> covered by input signatures, which might make them useful for future soft 
> forks. I can imagine confidential asset schemes or post-quantum coin 
recovery 
> schemes requiring large proofs in the outputs, where the validity of the 
proof 
> determined whether or not the transaction is valid, and thus require the 
> proofs to be in the outputs, and not just a hash commitment. 
> 
> Would the ability to publish the data alone be enough? Example make the 
output unspendable but allow for the existence of the bytes to be covered 
through the signature? 
> 
> 
> Antoine Poinsot: 
> > Limiting the size of created scriptPubKeys is not a sufficient 
mitigation on its own 
> I fail to see how this would not be sufficient? To DoS you need 2 things 
inputs with ScriptPubkey redemptions + heavy op_codes that require unique 
checks. Example DUPing stack element again and again doesn't work. This 
then leads to the next part is you could get up to unique complex 
operations with the current (n) limit included per input. 
> 
> > One of the goal of BIP54 is to address objections to Matt's earlier 
proposal, notably the (in my 
> opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
Limiting the size of 
> scriptPubKeys would in this regard be moving in the opposite direction. 
> 
> Some notes is I would actually go as far as to say the confiscation risk 
is higher with the TX limit proposed in BIP54 as we actually have proof of 
redemption of TXs that break that rule and the input set to do this already 
exists on-chain no need to even wonder about the whole presigned. 
bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08 
> 
> Please let me know if I am incorrect on any of this. 
> 
> > Furthermore, it's always possible to get the biggest bang for our buck 
in a first step 
> 
> Agreed on bang for the buck regarding DoS. 
> 
> My final point here would be that I would like to discuss more, and this 
is response is from the initial view of your response and could be 
incomplete or incorrect, This is just my in the moment response. 
> 
> Antoine Riard: 
> > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
favor of prioritizing 
> a timewarp fix and limiting dosy spends by old redeem scripts 
> 
> The idea of congestion control is interesting, but this solution should 
significantly reduce the total DoS severity of known vectors. 
> 
> On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote: 
> 
> > Limits on block construction that cross transactions make it harder to 
accurately estimate fees and greatly complicate optimal block 
construction-- the latter being important because smarter and more computer 
powered mining code generating higher profits is a pro centralization 
factor. 
> > 
> > In terms of effectiveness the "spam" will just make itself 
indistinguishable from the most common transaction traffic from the 
perspective of such metrics-- and might well drive up "spam" levels because 
the higher embedding cost may make some of them use more transactions. The 
competition for these buckets by other traffic could make it effectively a 
block size reduction even against very boring ordinary transactions. ... 
which is probably not what most people want. 
> > 
> > I think it's important to keep in mind that bitcoin fee levels even at 
0.1s/vb are far beyond what other hosting services and other blockchains 
cost-- so anyone still embedding data in bitcoin *really* want to be there 
for some reason and aren't too fee sensitive or else they'd already be 
using something else... some are even in favor of higher costs since the 
high fees are what create the scarcity needed for their seigniorage. 
> > 
> > But yeah I think your comments on priorities are correct. 
> > 
> > 
> > 
> > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> 
wrote: 
> > 
> > > Hi list, 
> > > 
> > > Thanks to the annex covered by the signature, I don't see how the 
concern about limiting 
> > > the extensibility of bitcoin script with future (post-quantum) 
cryptographic schemes. 
> > > Previous proposal of the annex were deliberately designed with 
variable-length fields 
> > > to flexibly accomodate a wide range of things. 
> > > 
> > > I believe there is one thing that has not been proposed to limit 
unpredictable utterance 
> > > of spams on the blockchain, namely congestion control of categories 
of outputs (e.g "fat" 
> > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey 
and L a limiting 
> > > threshold for the number of T occurences during the period P. Beyond 
the L threshold, any 
> > > additional T scriptpubkey is making the block invalid. Or 
alternatively, any additional 
> > > T generating / spending transaction must pay some weight penalty... 
> > > 
> > > Congestion control, which of course comes with its lot of 
shenanigans, is not very a novel 
> > > idea as I believe it has been floated few times in the context of 
lightning to solve mass 
> > > closure, where channels out-priced at current feerate would have 
their safety timelocks scale 
> > > ups. 
> > > 
> > > No need anymore to come to social consensus on what is quantitative 
"spam" or not. The blockchain 
> > > would automatically throttle out the block space spamming 
transaction. Qualitative spam it's another 
> > > question, for anyone who has ever read shannon's theory of 
communication only effective thing can 
> > > be to limit the size of data payload. But probably we're kickly back 
to a non-mathematically solvable 
> > > linguistical question again [0]. 
> > > 
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
favor of prioritizing 
> > > a timewarp fix and limiting dosy spends by old redeem scripts, rather 
than engaging in shooting 
> > > ourselves in the foot with ill-designed "spam" consensus mitigations. 
> > > 
> > > [0] If you have a soul of logician, it would be an interesting 
demonstration to come with 
> > > to establish that we cannot come up with mathematically or 
cryptographically consensus means 
> > > to solve qualitative "spam", which in a very pure sense is a 
linguistical issue. 
> > > 
> > > Best, 
> > > Antoine 
> > > OTS hash: 
6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999 
> > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit 
: 
> > > 
> > > > Hi, 
> > > > 
> > > > This approach was discussed last year when evaluating the best way 
to mitigate DoS blocks in terms 
> > > > of gains compared to confiscatory surface. Limiting the size of 
created scriptPubKeys is not a 
> > > > sufficient mitigation on its own, and has a non-trivial 
confiscatory surface. 
> > > > 
> > > > One of the goal of BIP54 is to address objections to Matt's earlier 
proposal, notably the (in my 
> > > > opinion reasonable) confiscation concerns voiced by Russell 
O'Connor. Limiting the size of 
> > > > scriptPubKeys would in this regard be moving in the opposite 
direction. 
> > > > 
> > > > Various approaches of limiting the size of spent scriptPubKeys were 
discussed, in forms that would 
> > > > mitigate the confiscatory surface, to adopt in addition to (what 
eventually became) the BIP54 sigops 
> > > > limit. However i decided against including this additional measure 
in BIP54 because: 
> > > > - of the inherent complexity of the discussed schemes, which would 
make it hard to reason about 
> > > > constructing transactions spending legacy inputs, and equally hard 
to evaluate the reduction of 
> > > > the confiscatory surface; 
> > > > - more importantly, there is steep diminishing returns to piling on 
more mitigations. The BIP54 
> > > > limit on its own prevents an externally-motivated attacker from 
*unevenly* stalling the network 
> > > > for dozens of minutes, and a revenue-maximizing miner from 
regularly stalling its competitions 
> > > > for dozens of seconds, at a minimized cost in confiscatory surface. 
Additional mitigations reduce 
> > > > the worst case validation time by a smaller factor at a higher cost 
in terms of confiscatory 
> > > > surface. It "feels right" to further reduce those numbers, but it's 
less clear what the tangible 
> > > > gains would be. 
> > > > 
> > > > Furthermore, it's always possible to get the biggest bang for our 
buck in a first step and going the 
> > > > extra mile in a later, more controversial, soft fork. I previously 
floated the idea of a "cleanup 
> > > > v2" in private discussions, and i think besides a reduction of the 
maximum scriptPubKey size it 
> > > > should feature a consensus-enforced maximum transaction size for 
the reasons stated here: 
> > > > 
https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
I wouldn't hold my 
> > > > breath on such a "cleanup v2", but it may be useful to have it 
documented somewhere. 
> > > > 
> > > > I'm trying to not go into much details regarding which mitigations 
were considered in designing 
> > > > BIP54, because they are tightly related to the design of various 
DoS blocks. But i'm always happy to 
> > > > rehash the decisions made there and (re-)consider alternative 
approaches on the semi-private Delving 
> > > > thread [0] dedicated to this purpose. Feel free to ping me to get 
access if i know you. 
> > > > 
> > > > Best, 
> > > > Antoine Poinsot 
> > > > 
> > > > [0]: 
https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711 
> > > > 
> > > > 
> > > > 
> > > > 
> > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
fre...@reardencode.com> wrote: 
> > > > 
> > > > > 
> > > > > 
> > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote: 
> > > > > 
> > > > > > But also given that there are essentially no violations and no 
reason to 
> > > > > > expect any I'm not sure the proposal is worth time relative to 
fixes of 
> > > > > > actual moderately serious DOS attack issues. 
> > > > > 
> > > > > 
> > > > > I believe this limit would also stop most (all?) of 
PortlandHODL's 
> > > > > DoSblocks without having to make some of the other changes in 
GCC. I 
> > > > > think it's worthwhile to compare this approach to those proposed 
by 
> > > > > Antoine in solving these DoS vectors. 
> > > > > 
> > > > > Best, 
> > > > > 
> > > > > --Brandon 
> > > > > 
> > > > > -- 
> > > > > You received this message because you are subscribed to the 
Google Groups "Bitcoin Development Mailing List" group. 
> > > > > To unsubscribe from this group and stop receiving emails from it, 
send an email to bitcoindev+...@googlegroups.com. 
> > > > > To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console. 
> > > 
> > > -- 
> > > You received this message because you are subscribed to the Google 
Groups "Bitcoin Development Mailing List" group. 
> > > To unsubscribe from this group and stop receiving emails from it, 
send an email to bitcoindev+...@googlegroups.com. 
> > 
> > > To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com. 

> 
> -- 
> You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group. 
> To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com. 
> To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com. 


-- 
You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com.

To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com 
<https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/793073a7-84b2-4b42-a531-e03e30f89ddcn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 28781 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] Re: By: Doctorbuzz1 {GitHub} Limit "Bulk Dust" with a default filter or consensus.
  2025-10-30  1:02  0% ` [bitcoindev] " Doctor Buzz
@ 2025-10-30 14:14  1%   ` Doctor Buzz
  0 siblings, 0 replies; 200+ results
From: Doctor Buzz @ 2025-10-30 14:14 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 12555 bytes --]

A preemptive response to those who might say that a conservative 
"tiny_count" of 100 "wouldn't do anything":

The point is to add friction without inhibiting any non-data Txs. The image 
of Pepe pumping iron with "UTXO" on top was stored in 1,859 fake pubkeys / 
UTXOs. The proposed tiny_count of 100 would split that particular image 
across at least 19 Txs (likely a lot more if on-chain indexing were used), 
which only adds at least +6% to fees, but it does ruin "atomicity" (images 
all-in-one Tx) by adding complexity of needing some type of index to link 
them, causes confirmation risk, & pushes data abusers toward OP_RETURN or 
witness space.

Changing the 100 tiny_count to 50 ≈ +11% fees; to 30 ≈ +16% fees; & to 20 ≈ 
+24% fees (this only takes into account an extra 200 bytes per additional 
input Tx and does not consider any additional indexing needs) . Perhaps a 
tiny_count could be 20 with a higher ratio of 70%?? ~24% extra fees + added 
complexity could definitely prevent a lot of UTXO abuse.  I was obviously 
just trying to avoid ALL false positives, but there definitely seems like 
there's room to move the tiny_count lower.

On Wednesday, October 29, 2025 at 8:15:08 PM UTC-5 Doctor Buzz wrote:

> Thanks!  I came here to post it myself.  I just want to point out that 
> it's awfully discouraging for a GitHub mod to "close" my 90% developed 
> code, asking me to post it elsewhere... but anyway!
>
> Original GitHub post here:
> https://github.com/bitcoin/bitcoin/issues/33737#issuecomment-3465288829
>
> The first concept of this with static definition of a "tiny" Tx was posted 
> here (with no responses):  
> https://bitcoin.stackexchange.com/questions/129139/would-a-bulk-dust-relay-consensus-rule-limiting-100-sub-1-000-sat-outputs-p
>
> Pastebin code probably looks better here than what I can see in the OP of 
> this thread:  https://pastebin.com/9qdQCH83
> On Wednesday, October 29, 2025 at 7:47:08 PM UTC-5 Frenchanfry wrote:
>
>> A proposal on GitHub I found Highly interesting and a better improvement, 
>> dealing with spammers/congestion.
>>
>> I’m exploring a potential default filter or consensus-level rule (since a 
>> large number of people believe that default filters don't work) to 
>> discourage UTXO-bloat patterns without touching Script, witness data, or 
>> the block size limit.
>>
>> The idea is to target “bulk dust” transactions — those that create large 
>> numbers of extremely small outputs — which are the main cause of long-term 
>> UTXO set growth.
>>
>> These types of "bulk dust" transactions have been the No. 1 reason cited 
>> for wanting to expand the default OP_RETURN limit... and removing that 
>> limit obviously influenced BIP 444. So it appears to me that there is 
>> overwhelming majority support for limiting these types of "bulk dust" 
>> transactions, as they do present a legitimate concern for node runners.
>>
>> Concept
>>
>> Flag a transaction as “bulk dust” if:
>>
>>    - It has >=100 outputs each below a dynamically defined TinyTx 
>>    threshold, and
>>    - Those tiny outputs make up >=60% of all outputs in the transaction.
>>
>> When flagged, it would be considered nonstandard (relay policy) or 
>> invalid (if soft-forked into consensus).
>>
>> TinyTx threshold (dynamic halving schedule)
>>
>> I originally considered a constant definition of what was a "tiny" Tx to 
>> be 1,000 sats... but some might still just use 1,001 sats, right? Plus 
>> there very likely will be a time where there is a valid use-case of >100 
>> outputs under 1,000 sats.
>>
>> Rather than fixing the “tiny” threshold to a constant like 1,000 sats, 
>> the rule defines it as a decreasing function of block height, starting high 
>> and gradually tightening over time.
>>
>>    - Starts at 4096 sats when activated (target ~2028).
>>    - Halves every 210,000 blocks (~4 years).
>>    - Never falls below 1 sat (hard floor).
>>
>> Year ---- Block Height -- TinyTx Threshold
>> 2028 --- ~activation ---- 4096 sats
>> 2032 --- ~1,260,000 ---- 2048 sats
>> 2036 --- ~1,470,000 ---- 1024 sats
>> 2040 --- ~1,680,000 ---- 512 sats
>> … -- every 210,000 blocks -- … until 1 sat floor
>>
>> This gradual halving ensures the definition of "tiny" stays relevant as 
>> Bitcoin’s value rises.
>> For example, if 1 sat = $1 someday, having 100 outputs worth <1,000 sats 
>> each would no longer represent spam — but rather normal payments.
>> By then, the TinyTx limit would already have adjusted down automatically.
>>
>> Patterns this would limit
>>
>>    - Fake pubkeys or scripts used to embed data via many UTXOs
>>    - Bitcoin STAMPS / UTXO-art spreading payloads across thousands of 
>>    dust outputs
>>    - BRC-20 batch mints with 100s of "tiny" sat fan-outs
>>    - Some Ordinal or state inscription schemes that distribute data 
>>    across many tiny outputs
>>    - Dust bombing (UTXO tracking or chain spam)
>>    - Mass micro-airdrops below the "tiny" sat range
>>
>> These use cases rely on cheap, numerous outputs — making them several 
>> times more costly under this rule.
>>
>> Non-goals / unaffected
>>
>>    - Normal user transactions, LN channel opens, and multisig spends
>>    - Batched exchange payouts (they typically have > 40% large-value 
>>    outputs)
>>    - Single/few-output inscriptions using witness data (not affected)
>>    - Any legitimate pattern where most outputs are above the threshold
>>
>> Why a ratio and a count?
>>
>> Requiring both (tiny_count >= 100) and (tiny_ratio >= 60%) helps avoid 
>> false positives, such as legitimate custodial payouts or consolidation 
>> transactions with mixed values.
>> It specifically filters transactions that are mostly dust, rather than 
>> merely containing some.
>>
>> Inquiry
>>
>>    - Are there credible, non-spam use cases that truly require >=100 
>>    sub-4k-sat outputs (or equivalent at later eras) and a >=60% tiny ratio?
>>    - Could this affect fee market behavior or any privacy tools in 
>>    unintended ways?
>>    - Any concern with the 100 tiny_count limit or 60% tiny_ratio?
>>    - Any other unintended consequences?
>>    - Any objections in general?? What are they?
>>
>> Intent
>>
>> This proposal doesn’t censor any monetary transaction or prevent 
>> inscriptions; it simply prices storage according to resource cost.
>> It keeps the chain “light and nimble” for everyday payments while 
>> allowing future flexibility — because the TinyTx definition decreases 
>> automatically in line with halvings and Bitcoin’s long-term value growth.
>>
>> CODE SKETCHES
>> (with minimal syntax highlighting here: https://pastebin.com/9qdQCH83)
>>
>> RELAY POLICY FILTER sketch —
>> // Place in src/policy/policy.cpp, and call from within IsStandardTx() 
>> before returning: // if (IsBulkDust(tx, reason)) // return false; // reject 
>> as nonstandard // 
>> ========================================================================================================== 
>> bool IsBulkDust(const CTransaction& tx, std::string& reason) { static 
>> constexpr int MAX_TINY_OUTPUTS = 100; // >=100 tiny outputs triggers ratio 
>> check static constexpr double TINY_RATIO_THRESHOLD = 0.6; // >=60% of all 
>> outputs tiny → reject static constexpr CAmount BASE_TINY_THRESHOLD = 4096; 
>> // starting tiny threshold (sats) static constexpr int64_t 
>> FIRST_TINY_HALVING_H = 1260000; // first halving of tiny threshold static 
>> constexpr int64_t HALVING_INTERVAL = 210000; // blocks per subsequent 
>> halving static constexpr CAmount MIN_TINY_FLOOR = 1; // never below 1 sat 
>> const int total = tx.vout.size(); if (total == 0) return false; int 
>> currentHeight = chainActive.Tip() ? chainActive.Tip()->nHeight : 0; // Era 
>> index for TinyTx threshold, anchored at FIRST_TINY_HALVING_H (not subsidy 
>> eras) int era = 0; if (currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
>> static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
>> HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; // 
>> halve per era if (tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; 
>> int tiny = 0; for (const auto& out : tx.vout) { if (out.nValue < 
>> tinyThresh) ++tiny; } if (tiny >= MAX_TINY_OUTPUTS && 
>> (static_cast<double>(tiny) / total) >= TINY_RATIO_THRESHOLD) { reason = 
>> strprintf("too-many-tiny-outputs(%d of %d, %.2f%%, tiny<%d)", tiny, total, 
>> 100.0 * tiny / total, tinyThresh); return true; // flag as bulk dust 
>> (nonstandard) } return false; } 
>>
>> CONSENSUS (soft-fork, hybrid activation) sketch —
>> // Helpers in src/consensus/tx_check.cpp; activation/enforcement in 
>> src/validation.cpp // Also define deployment in: src/consensus/params.h, 
>> src/chainparams.cpp, src/versionbits.* // 
>> ========================================================================================================== 
>> // ----------------------------------------------------------------------- 
>> // --- In src/consensus/tx_check.cpp (helper only; no params needed) --- // 
>> ----------------------------------------------------------------------- 
>> static constexpr CAmount BASE_TINY_THRESHOLD = 4096; static constexpr 
>> int64_t FIRST_TINY_HALVING_H = 1260000; static constexpr int64_t 
>> HALVING_INTERVAL = 210000; static constexpr int MAX_TINY_OUTPUTS = 100; 
>> static constexpr double TINY_RATIO_THRESHOLD = 0.6; static constexpr 
>> CAmount MIN_TINY_FLOOR = 1; bool IsBulkDust(const CTransaction& tx, int 
>> currentHeight) // expose via tx_check.h if needed { const int total = 
>> tx.vout.size(); if (total == 0) return false; int era = 0; if 
>> (currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
>> static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
>> HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; if 
>> (tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; int tiny = 0; 
>> for (const auto& out : tx.vout) { if (out.nValue < tinyThresh) ++tiny; } if 
>> (tiny >= MAX_TINY_OUTPUTS && (static_cast<double>(tiny) / total) >= 
>> TINY_RATIO_THRESHOLD) return true; return false; } // 
>> ----------------------------------------------------------------------- // 
>> --- In src/validation.cpp (enforcement with hybrid activation) --- // 
>> ----------------------------------------------------------------------- 
>> #include <consensus/tx_check.h> #include <versionbits.h> const 
>> Consensus::Params& params = chainparams.GetConsensus(); int currentHeight = 
>> chainActive.Tip() ? chainActive.Tip()->nHeight : 0; const bool 
>> bulk_dust_active = DeploymentActiveAtTip(params, 
>> Consensus::DEPLOYMENT_BULK_DUST_LIMIT) || (currentHeight >= 
>> params.BulkDustActivationHeight); if (bulk_dust_active) { if 
>> (IsBulkDust(tx, currentHeight)) { return 
>> state.Invalid(TxValidationResult::TX_CONSENSUS, "too-many-tiny-outputs"); } 
>> } // 
>> ----------------------------------------------------------------------- // 
>> --- In src/consensus/params.h --- // 
>> ----------------------------------------------------------------------- 
>> enum DeploymentPos { // ... DEPLOYMENT_BULK_DUST_LIMIT, 
>> MAX_VERSION_BITS_DEPLOYMENTS }; struct Params { // ... int 
>> BulkDustActivationHeight; // height flag-day fallback }; // 
>> ----------------------------------------------------------------------- // 
>> --- In src/chainparams.cpp (per-network values; examples only) --- // 
>> ----------------------------------------------------------------------- 
>> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].bit = 12; 
>> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nStartTime = 
>> 1767225600; // 2026-01-01 UTC 
>> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nTimeout = 
>> 1838160000; // 2028-04-01 UTC 
>> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].min_activation_height 
>> = 969696; consensus.BulkDustActivationHeight = 1021021; // flag-day fallback
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/15849db6-67af-4a03-86a4-bb5a288b9ad1n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 28754 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30  6:15  0%                       ` Greg Maxwell
@ 2025-10-30  8:55  1%                         ` Bitcoin Error Log
  2025-10-30 17:40  0%                           ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: Bitcoin Error Log @ 2025-10-30  8:55 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 30197 bytes --]

Greg,

One correction. Bitcoin has significantly restricted a proven use case with 
policy in the past. Maybe you won't think this qualifies, but it happened 
while you were away so I am curious about your assessment. 

During the change to mempoolfullrbf policy, I, with support from the 
original author of the change, and with support of multiple Core devs, and 
with the support of multiple businesses providing data on how they provided 
zero-conf as a service to users via risk management, tried to stop Bitcoin 
from killing first-seen policy, which had been stable for all of the 
history of Bitcoin. The change was at least clearly demonstrated as 
controversial, and lacking real consensus. 

I'm happy to admit that no policy is enforceable, and that zero-conf was 
"never safe", but we had a system that worked and made Bitcoin more useful 
to people that used it that way. The businesses simply monitored for 
doublespends, imposed exposure limits per block, and gated actual delivery 
separately from checkout UX. It worked and now it does not and the only 
reason was a policy change.

The problem with claiming that policy is not a means of change, is that you 
must also admit the lack of need for any RBF flags at all, or for arguing 
about data spam relay, or for any wide policy to be a concern of Bitcoin 
Core at all. (particularly when speculatively / subjectively applied) .

Thank you, and sorry for the side topic.

~John


On Thursday, October 30, 2025 at 6:40:10 AM UTC Greg Maxwell wrote:

Prior softforks have stuck to using the more explicit "forward 
compatibility" mechanisms, so -- e.g. if you use OP_NOP3 or a higher 
transaction version number or whatever that had no purpose (and would 
literally do nothing), saw ~no use, and was non-standard, or scripts that 
just anyone could have immediately taken at any time (e.g. funds free for 
the collecting rather than something secure)... then in that case I think 
people have felt that the long discussion leading up to a softfork was 
enough to acceptably mitigate the risk.  Tapscript was specifically 
designed to make upgrades even safer and easier by making it so that the 
mere presence of any forward compat opcode (OP_SUCCESSn) makes the whole 
script insecure until that opcode is in use. 

The proposal to limit scriptpubkey size is worse because longer scripts had 
purposes and use (e.g. larger multisigs) and unlike some NOP3 or txversions 
where you could be argued to deserve issues if you did something so weird 
and abused a forward compat mechanism, people running into a 520 limit 
could have been pretty boring (and I see my own watching wallets have some 
scriptpubkeys beyond that size (big multisigs), in fact-- though I don't 
*think* any are still in use, but even I'm not absolutely sure that such a 
restriction wouldn't confiscate some of my own funds--- and it's a pain in 
the rear to check, having to bring offline stuff online, etc).

Confiscation isn't just limited to timelocks, since the victims of it may 
just not know about the consensus change and while they could move their 
coins they don't.  One of the big advantages many people see in Bitcoin is 
that you can put your keys in a time capsule in the foundation of your home 
and trust that they're still going to be there and you'll be able to use 
your coins a decade later. ... that you don't have to watch out for banks 
drilling your safe deposit boxes or people putting public notices in 
classified ads laying claim to your property.

I don't even think bitcoin has ever policy restricted something that was in 
active use, much less softforked out something like that.  I wouldn't say 
it was impossible but I think on the balance it would favor a notice period 
so that any reasonable person could have taken notice, taken action, or at 
least spoke up.  But since there is no requirement to monitor and that's 
part of bitcoin's value prop the amount of time to consider reasonable 
ought to be quite long.  Which also is at odds with the emergency measures 
position being taken by proponents of such changes.

(which also, I think are just entirely unjustified, even if you accept the 
worst version of their narrative with the historical chain being made 
_illegal_, one could simply produce node software that starts from a well 
known embedded utxo snapshot and doesn't process historical blocks.   Such 
a thing would be in principle a reduction in the security model, but 
balances against the practical and realistic impact of potentially 
confiscating coins I think it looks pretty fine by comparison.  It would 
also be fully consensus compatible, assuming no reorg below that point, and 
can be done right now by anyone who cares in a totally permissionless and 
coercion free manner)



On Thu, Oct 30, 2025 at 5:13 AM Michael Tidwell <mtidw...@gmail.com> wrote:

Greg,

> Also some risk of creating a new scarce asset class.

Well, Casey Rodarmor is in the thread, so lol maybe.

Anyway, point taken. I want to be 100% sure I understand the hypotheticals: 
there could be an off-chain, presigned, transactions that needs more than 
520 bytes for the scriptPubKey and, as Poelstra said, could even form a 
chain of presigned transactions under some complex, previously unknown, 
scheme that only becomes public after this change is made. Can you confirm?

Would it also be a worry that a chain of transactions using said utxo could 
commit to some bizarre scheme, for instance a taproot transaction utxo that 
later is presigned committed back to P2MS larger than 520 bytes? If so, I 
think I get it, you're saying to essentially guarantee no confiscation we'd 
never be able to upgrade old UTXOs and we'd need to track them forever to 
prevent unlikely edge cases? 
Does the presigned chain at least stop needing to be tracked once the given 
UTXO co-mingles with a post-update coinbase utxo?

If so, this is indeed complex! This seems pretty insane both for the 
complexity of implementing and the unlikely edge cases. Has Core ever made 
a decision of (acceptable risk) to upgrade with protection of onchain utxos 
but not hypothetical unpublished ones? 
Aren't we going to run into the same situation if we do an op code clean up 
in the future if we had people presign/commit to op codes that are no 
longer consensus valid?

Tidwell

On Wednesday, October 29, 2025 at 10:32:10 PM UTC-4 Greg Maxwell wrote:

"A few bytes" might be on the order of forever 10% increase in the UTXO set 
size, plus a full from-network resync of all pruned nodes and a full (e.g. 
most of day outage) reindex of all unpruned nodes.  Not insignificant but 
also not nothing.  Such a portion of the existing utxo size is not from 
outputs over 520 bytes in size, so as a scheme for utxo set size reduction 
the addition of MHT tracking would probably make it a failure.

Also some risk of creating some new scarce asset class, txouts consisting 
of primordial coins that aren't subject to the new rules... sounds like the 
sort of thing that NFT degens would absolutely love.  That might not be an 
issue *generally* for some change with confiscation risk, but for a change 
that is specifically intended to lobotomize bitcoin to make it less useful 
to NFT degens, maybe not such a great idea. :P

I mentioned it at all because I thought it could potentially be of some 
use, I'm just more skeptical of it for the current context.  Also luke-jr 
and crew has moved on to actually propose even more invasive changes than 
just limiting the script size, which I anticipated, and has much more 
significant issues.  Just size limiting outputs likely doesn't harm any 
interests or usages-- and so probably could be viable if the confiscation 
issue was addressed, but it also doesn't stick it to people transacting in 
ways the priests of ocean mining dislike. 

> I believe you're pointing out the idea of non economically-rational 
spammers?

I think it's a mistake to conclude the spammers are economically 
irrational-- they're often just responding to different economics which may 
be less legible to your analysis.  In particular, NFT degens prefer the 
high cost of transactions as a thing that makes their tokens scarce and 
gives them value.  -- otherwise they wouldn't be swapping for one less 
efficient encoding for another, they're just be using another blockchain 
(perhaps their own) entirely.




On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com> wrote:

> MRH tracking might make that acceptable, but comes at a high cost which I 
think would clearly not be justified.

Greg, I want to ask/challenge how bad this is, this seems like a generally 
reusable primitive that could make other upgrades more feasible that also 
have the same strict confiscation risk profile.
IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?

Poelstra,

> I don't think this is a great idea -- it would be technically hard to
implement and slow deployment indefinitely.

I would like to know how much of a deal breaker this is in your opinion. Is 
MRH tracking off the table? In terms of the hypothetical presigned 
transactions that may exist using P2MS, is this a hard enough reason to 
require a MRH idea?

Greg,

> So, paradoxically this limit might increase the amount of non-prunable 
data

I believe you're pointing out the idea of non economically-rational 
spammers? We already see actors ignoring cheaper witness inscription 
methods. If spam shifts to many sub-520 fake pubkey outputs (which I 
believe is less harmful than stamps), that imo is a separate UTXO cost 
discussion. (like a SF to add weight to outputs). Anywho, this point alone 
doesn't seem sufficient to add as a clear negative reason for someone 
opposed to the proposal.

Thanks,
Tidwell
On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:

> Confiscation is a problem because of presigned transactions 

Allow 10000 bytes of total scriptPubKey size in each block counting only 
those outputs that are larger than x (520 as proposed). 
The code change is pretty minimal from the most obvious implementation of 
the original rule. 

That makes it technically non-confiscatory. Still non-standard, but if 
anyone out there so obnoxiously foot-gunned themselves, they can't claim 
they were rugged by the devs. 

BR, 
moonsettler 

On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io> 
wrote: 

> Hey, 
> 
> First, thank you to everyone who responded, and please continue to do so. 
There were many thought provoking responses and this did shift my 
perspective quite a bit from the original post, which in of itself was the 
goal to a degree. 
> 
> I am currently only going to respond to all of the current concerns. 
Acks; though I like them will be ignored unless new discoveries are 
included. 
> 
> Tl;dr (Portlands Perspective) 
> - Confiscation is a problem because of presigned transactions 
> - DoS mitigation could also occur through marking UTXOs as unspendable if 
> 520 bytes, this would preserve the proof of publication. 
> - Timeout / Sunset logic is compelling 
> - The (n) value of acceptable needed bytes is contentious with the lower 
suggested limit being 67 
> - Congestion control is worth a look? 
> 
> Next Step: 
> - Deeper discussion at the individual level: Antoine Poinsot and GCC 
overlap? 
> - Write an implementation. 
> - Decide to pursue BIP 
> 
> Responses 
> 
> Andrew Poelstra: 
> > There is a risk of confiscation of coins which have pre-signed but 
> > unpublished transactions spending them to new outputs with large 
> > scriptPubKeys. Due to long-standing standardness rules, and the 
presence 
> > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any 
> > such transactions exist. 
> 
> PortlandHODL: This is a risk that can be incurred and likely not possible 
to mitigate as there could be possible chains of transactions so even when 
recursively iterating over a chain there is a chance that a presigned 
breaks this rule. Every idea I have had from block redemption limits on 
prevouts seems to just be a coverage issue where you can make the 
confiscation less likely but not completely mitigated. 
> 
> Second, there are already TXs that effectively have been confiscated at 
the policy level (P2SH Cleanstack violation) where the user can not find 
any miner with a policy to accept these into their mempool. (3 years) 
> 
> /dev /fd0 
> > so it would be great if this was restricted to OP_RETURN 
> 
> PortlandHODL: I reject this completely as this would remove the UTXOset 
omission for the scriptPubkey and encourage miners to subvert the OP_RETURN 
restriction and instead just use another op_code, this also do not hit on 
some of the most important factors such as DoS mitigation and legacy script 
attack surface reduction. 
> 
> Peter Todd 
> > NACK ... 
> 
> PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
without including any additional context or reasoning. 
> 
> jeremy 
> > I think that this type of rule is OK if we do it as a "sunsetting" 
restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
years, 5 years, 10 years). 
> 
> If action is taken, this is the most reasonable approach. Alleviating 
confiscatory concerns through deferral. 
> 
> > You can argue against this example probably, but it is worth 
considering that absence of evidence of use is not evidence of absence of 
use and I myself feel that overall our understanding of Bitcoin transaction 
programming possibilities is still early. If you don't like this example, I 
can give you others (probably). 
> 
> Agreed and this also falls into the reasoning for deciding to utilize 
point 1 in your response. My thoughts on this would be along the lines of 
proof of publication as this change only has the effect of stripping away 
the executable portion of a script between 521 and 10_000 bytes or the 
published data portion if > 10_000 bytes which the same data could likely 
be published in chunked segments using outpoints. 
> 
> Andrew Poelstra: 
> > Aside from proof-of-publication (i.e. data storage directly in the UTXO 
> > set) there is no usage of script which can't be equally (or better) 
> > accomplished by using a Segwit v0 or Taproot script. 
> 
> This sums up the majority of future usecase concern 
> 
> Anthony Towns: 
> > (If you restricted the change to only applying to scripts that used 
> non-push operators, that would probably still provide upgrade flexibility 
> while also preventing potential script abuses. But it wouldn't do 
anything 
> to prevent publishing data) 
> 
> Could this not be done as segments in multiple outpoints using a 
coordination outpoint? I fail to see why publication proof must be in a 
single chunk. This does though however bring another alternative to mind, 
just making these outpoints unspendable but not invalidate the block 
through inclusion... 
> 
> > As far as the "but contiguous data will be regulated more strictly" 
> argument goes; I don't think "your honour, my offensive content has 
> strings of 4d0802 every 520 bytes 
> 
> Correct, this was never meant to resolve this issue. 
> 
> Luke Dashjr: 
> > If we're going this route, we should just close all the gaps for the 
immediate future: 
> 
> To put it nicely, this is completely beyond the scope of what is being 
proposed. 
> 
> Guus Ellenkamp: 
> > If there are really so few OP_RETURN outputs more than 144 bytes, then 
> why increase the limit if that change is so controversial? It seems 
> people who want to use a larger OP_RETURN size do it anyway, even with 
> the current default limits. 
> 
> Completely off topic and irrelevant 
> 
> Greg Tonoski: 
> > Limiting the maximum size of the scriptPubKey of a transaction to 67 
bytes. 
> 
> This leave no room to deal with broken hashing algorithms and very little 
future upgradability for hooks. The rest of these points should be merged 
with Lukes response and either hijack my thread or start a new one with the 
increased scope, any approach I take will only be related to the 
ScriptPubkey 
> 
> Keagan McClelland: 
> > Hard NACK on capping the witness size as that would effectively ban 
large scripts even in the P2SH wrapper which undermines Bitcoin's ability 
to be an effectively programmable money. 
> 
> This has nothing to do with the witness size or even the P2SH wrapper 
> 
> Casey Rodarmor: 
> > I think that "Bitcoin could need it in the future?" might be a good 
enough 
> reason not to do this. 
> 
> > Script pubkeys are the only variable-length transaction fields which 
can be 
> covered by input signatures, which might make them useful for future soft 
> forks. I can imagine confidential asset schemes or post-quantum coin 
recovery 
> schemes requiring large proofs in the outputs, where the validity of the 
proof 
> determined whether or not the transaction is valid, and thus require the 
> proofs to be in the outputs, and not just a hash commitment. 
> 
> Would the ability to publish the data alone be enough? Example make the 
output unspendable but allow for the existence of the bytes to be covered 
through the signature? 
> 
> 
> Antoine Poinsot: 
> > Limiting the size of created scriptPubKeys is not a sufficient 
mitigation on its own 
> I fail to see how this would not be sufficient? To DoS you need 2 things 
inputs with ScriptPubkey redemptions + heavy op_codes that require unique 
checks. Example DUPing stack element again and again doesn't work. This 
then leads to the next part is you could get up to unique complex 
operations with the current (n) limit included per input. 
> 
> > One of the goal of BIP54 is to address objections to Matt's earlier 
proposal, notably the (in my 
> opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
Limiting the size of 
> scriptPubKeys would in this regard be moving in the opposite direction. 
> 
> Some notes is I would actually go as far as to say the confiscation risk 
is higher with the TX limit proposed in BIP54 as we actually have proof of 
redemption of TXs that break that rule and the input set to do this already 
exists on-chain no need to even wonder about the whole presigned. 
bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08 
> 
> Please let me know if I am incorrect on any of this. 
> 
> > Furthermore, it's always possible to get the biggest bang for our buck 
in a first step 
> 
> Agreed on bang for the buck regarding DoS. 
> 
> My final point here would be that I would like to discuss more, and this 
is response is from the initial view of your response and could be 
incomplete or incorrect, This is just my in the moment response. 
> 
> Antoine Riard: 
> > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
favor of prioritizing 
> a timewarp fix and limiting dosy spends by old redeem scripts 
> 
> The idea of congestion control is interesting, but this solution should 
significantly reduce the total DoS severity of known vectors. 
> 
> On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote: 
> 
> > Limits on block construction that cross transactions make it harder to 
accurately estimate fees and greatly complicate optimal block 
construction-- the latter being important because smarter and more computer 
powered mining code generating higher profits is a pro centralization 
factor. 
> > 
> > In terms of effectiveness the "spam" will just make itself 
indistinguishable from the most common transaction traffic from the 
perspective of such metrics-- and might well drive up "spam" levels because 
the higher embedding cost may make some of them use more transactions. The 
competition for these buckets by other traffic could make it effectively a 
block size reduction even against very boring ordinary transactions. ... 
which is probably not what most people want. 
> > 
> > I think it's important to keep in mind that bitcoin fee levels even at 
0.1s/vb are far beyond what other hosting services and other blockchains 
cost-- so anyone still embedding data in bitcoin *really* want to be there 
for some reason and aren't too fee sensitive or else they'd already be 
using something else... some are even in favor of higher costs since the 
high fees are what create the scarcity needed for their seigniorage. 
> > 
> > But yeah I think your comments on priorities are correct. 
> > 
> > 
> > 
> > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> 
wrote: 
> > 
> > > Hi list, 
> > > 
> > > Thanks to the annex covered by the signature, I don't see how the 
concern about limiting 
> > > the extensibility of bitcoin script with future (post-quantum) 
cryptographic schemes. 
> > > Previous proposal of the annex were deliberately designed with 
variable-length fields 
> > > to flexibly accomodate a wide range of things. 
> > > 
> > > I believe there is one thing that has not been proposed to limit 
unpredictable utterance 
> > > of spams on the blockchain, namely congestion control of categories 
of outputs (e.g "fat" 
> > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey 
and L a limiting 
> > > threshold for the number of T occurences during the period P. Beyond 
the L threshold, any 
> > > additional T scriptpubkey is making the block invalid. Or 
alternatively, any additional 
> > > T generating / spending transaction must pay some weight penalty... 
> > > 
> > > Congestion control, which of course comes with its lot of 
shenanigans, is not very a novel 
> > > idea as I believe it has been floated few times in the context of 
lightning to solve mass 
> > > closure, where channels out-priced at current feerate would have 
their safety timelocks scale 
> > > ups. 
> > > 
> > > No need anymore to come to social consensus on what is quantitative 
"spam" or not. The blockchain 
> > > would automatically throttle out the block space spamming 
transaction. Qualitative spam it's another 
> > > question, for anyone who has ever read shannon's theory of 
communication only effective thing can 
> > > be to limit the size of data payload. But probably we're kickly back 
to a non-mathematically solvable 
> > > linguistical question again [0]. 
> > > 
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
favor of prioritizing 
> > > a timewarp fix and limiting dosy spends by old redeem scripts, rather 
than engaging in shooting 
> > > ourselves in the foot with ill-designed "spam" consensus mitigations. 
> > > 
> > > [0] If you have a soul of logician, it would be an interesting 
demonstration to come with 
> > > to establish that we cannot come up with mathematically or 
cryptographically consensus means 
> > > to solve qualitative "spam", which in a very pure sense is a 
linguistical issue. 
> > > 
> > > Best, 
> > > Antoine 
> > > OTS hash: 
6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999 
> > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit 
: 
> > > 
> > > > Hi, 
> > > > 
> > > > This approach was discussed last year when evaluating the best way 
to mitigate DoS blocks in terms 
> > > > of gains compared to confiscatory surface. Limiting the size of 
created scriptPubKeys is not a 
> > > > sufficient mitigation on its own, and has a non-trivial 
confiscatory surface. 
> > > > 
> > > > One of the goal of BIP54 is to address objections to Matt's earlier 
proposal, notably the (in my 
> > > > opinion reasonable) confiscation concerns voiced by Russell 
O'Connor. Limiting the size of 
> > > > scriptPubKeys would in this regard be moving in the opposite 
direction. 
> > > > 
> > > > Various approaches of limiting the size of spent scriptPubKeys were 
discussed, in forms that would 
> > > > mitigate the confiscatory surface, to adopt in addition to (what 
eventually became) the BIP54 sigops 
> > > > limit. However i decided against including this additional measure 
in BIP54 because: 
> > > > - of the inherent complexity of the discussed schemes, which would 
make it hard to reason about 
> > > > constructing transactions spending legacy inputs, and equally hard 
to evaluate the reduction of 
> > > > the confiscatory surface; 
> > > > - more importantly, there is steep diminishing returns to piling on 
more mitigations. The BIP54 
> > > > limit on its own prevents an externally-motivated attacker from 
*unevenly* stalling the network 
> > > > for dozens of minutes, and a revenue-maximizing miner from 
regularly stalling its competitions 
> > > > for dozens of seconds, at a minimized cost in confiscatory surface. 
Additional mitigations reduce 
> > > > the worst case validation time by a smaller factor at a higher cost 
in terms of confiscatory 
> > > > surface. It "feels right" to further reduce those numbers, but it's 
less clear what the tangible 
> > > > gains would be. 
> > > > 
> > > > Furthermore, it's always possible to get the biggest bang for our 
buck in a first step and going the 
> > > > extra mile in a later, more controversial, soft fork. I previously 
floated the idea of a "cleanup 
> > > > v2" in private discussions, and i think besides a reduction of the 
maximum scriptPubKey size it 
> > > > should feature a consensus-enforced maximum transaction size for 
the reasons stated here: 
> > > > 
https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
I wouldn't hold my 
> > > > breath on such a "cleanup v2", but it may be useful to have it 
documented somewhere. 
> > > > 
> > > > I'm trying to not go into much details regarding which mitigations 
were considered in designing 
> > > > BIP54, because they are tightly related to the design of various 
DoS blocks. But i'm always happy to 
> > > > rehash the decisions made there and (re-)consider alternative 
approaches on the semi-private Delving 
> > > > thread [0] dedicated to this purpose. Feel free to ping me to get 
access if i know you. 
> > > > 
> > > > Best, 
> > > > Antoine Poinsot 
> > > > 
> > > > [0]: 
https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711 
> > > > 
> > > > 
> > > > 
> > > > 
> > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
fre...@reardencode.com> wrote: 
> > > > 
> > > > > 
> > > > > 
> > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote: 
> > > > > 
> > > > > > But also given that there are essentially no violations and no 
reason to 
> > > > > > expect any I'm not sure the proposal is worth time relative to 
fixes of 
> > > > > > actual moderately serious DOS attack issues. 
> > > > > 
> > > > > 
> > > > > I believe this limit would also stop most (all?) of 
PortlandHODL's 
> > > > > DoSblocks without having to make some of the other changes in 
GCC. I 
> > > > > think it's worthwhile to compare this approach to those proposed 
by 
> > > > > Antoine in solving these DoS vectors. 
> > > > > 
> > > > > Best, 
> > > > > 
> > > > > --Brandon 
> > > > > 
> > > > > -- 
> > > > > You received this message because you are subscribed to the 
Google Groups "Bitcoin Development Mailing List" group. 
> > > > > To unsubscribe from this group and stop receiving emails from it, 
send an email to bitcoindev+...@googlegroups.com. 
> > > > > To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console. 
> > > 
> > > -- 
> > > You received this message because you are subscribed to the Google 
Groups "Bitcoin Development Mailing List" group. 
> > > To unsubscribe from this group and stop receiving emails from it, 
send an email to bitcoindev+...@googlegroups.com. 
> > 
> > > To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com. 

> 
> -- 
> You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group. 
> To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com. 
> To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com. 


-- 
You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com.

To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com 
<https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups 
"Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to bitcoindev+...@googlegroups.com.

To view this discussion visit 
https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com 
<https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/09d0aa74-1305-45bd-8da9-03d1506f5784n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 36103 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30  3:36  0%                     ` Michael Tidwell
@ 2025-10-30  6:15  0%                       ` Greg Maxwell
  2025-10-30  8:55  1%                         ` Bitcoin Error Log
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-10-30  6:15 UTC (permalink / raw)
  To: Michael Tidwell; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 30733 bytes --]

Prior softforks have stuck to using the more explicit "forward
compatibility" mechanisms, so -- e.g. if you use OP_NOP3 or a higher
transaction version number or whatever that had no purpose (and would
literally do nothing), saw ~no use, and was non-standard, or scripts that
just anyone could have immediately taken at any time (e.g. funds free for
the collecting rather than something secure)... then in that case I think
people have felt that the long discussion leading up to a softfork was
enough to acceptably mitigate the risk.  Tapscript was specifically
designed to make upgrades even safer and easier by making it so that the
mere presence of any forward compat opcode (OP_SUCCESSn) makes the whole
script insecure until that opcode is in use.

The proposal to limit scriptpubkey size is worse because longer scripts had
purposes and use (e.g. larger multisigs) and unlike some NOP3 or txversions
where you could be argued to deserve issues if you did something so weird
and abused a forward compat mechanism, people running into a 520 limit
could have been pretty boring (and I see my own watching wallets have some
scriptpubkeys beyond that size (big multisigs), in fact-- though I don't
*think* any are still in use, but even I'm not absolutely sure that such a
restriction wouldn't confiscate some of my own funds--- and it's a pain in
the rear to check, having to bring offline stuff online, etc).

Confiscation isn't just limited to timelocks, since the victims of it may
just not know about the consensus change and while they could move their
coins they don't.  One of the big advantages many people see in Bitcoin is
that you can put your keys in a time capsule in the foundation of your home
and trust that they're still going to be there and you'll be able to use
your coins a decade later. ... that you don't have to watch out for banks
drilling your safe deposit boxes or people putting public notices in
classified ads laying claim to your property.

I don't even think bitcoin has ever policy restricted something that was in
active use, much less softforked out something like that.  I wouldn't say
it was impossible but I think on the balance it would favor a notice period
so that any reasonable person could have taken notice, taken action, or at
least spoke up.  But since there is no requirement to monitor and that's
part of bitcoin's value prop the amount of time to consider reasonable
ought to be quite long.  Which also is at odds with the emergency measures
position being taken by proponents of such changes.

(which also, I think are just entirely unjustified, even if you accept the
worst version of their narrative with the historical chain being made
_illegal_, one could simply produce node software that starts from a well
known embedded utxo snapshot and doesn't process historical blocks.   Such
a thing would be in principle a reduction in the security model, but
balances against the practical and realistic impact of potentially
confiscating coins I think it looks pretty fine by comparison.  It would
also be fully consensus compatible, assuming no reorg below that point, and
can be done right now by anyone who cares in a totally permissionless and
coercion free manner)



On Thu, Oct 30, 2025 at 5:13 AM Michael Tidwell <mtidwell021@gmail.com>
wrote:

> Greg,
>
> > Also some risk of creating a new scarce asset class.
>
> Well, Casey Rodarmor is in the thread, so lol maybe.
>
> Anyway, point taken. I want to be 100% sure I understand the
> hypotheticals: there could be an off-chain, presigned, transactions that
> needs more than 520 bytes for the scriptPubKey and, as Poelstra said, could
> even form a chain of presigned transactions under some complex, previously
> unknown, scheme that only becomes public after this change is made. Can you
> confirm?
>
> Would it also be a worry that a chain of transactions using said utxo
> could commit to some bizarre scheme, for instance a taproot transaction
> utxo that later is presigned committed back to P2MS larger than 520 bytes?
> If so, I think I get it, you're saying to essentially guarantee no
> confiscation we'd never be able to upgrade old UTXOs and we'd need to track
> them forever to prevent unlikely edge cases?
> Does the presigned chain at least stop needing to be tracked once the
> given UTXO co-mingles with a post-update coinbase utxo?
>
> If so, this is indeed complex! This seems pretty insane both for the
> complexity of implementing and the unlikely edge cases. Has Core ever made
> a decision of (acceptable risk) to upgrade with protection of onchain utxos
> but not hypothetical unpublished ones?
> Aren't we going to run into the same situation if we do an op code clean
> up in the future if we had people presign/commit to op codes that are no
> longer consensus valid?
>
> Tidwell
>
> On Wednesday, October 29, 2025 at 10:32:10 PM UTC-4 Greg Maxwell wrote:
>
>> "A few bytes" might be on the order of forever 10% increase in the UTXO
>> set size, plus a full from-network resync of all pruned nodes and a full
>> (e.g. most of day outage) reindex of all unpruned nodes.  Not
>> insignificant but also not nothing.  Such a portion of the existing utxo
>> size is not from outputs over 520 bytes in size, so as a scheme for utxo
>> set size reduction the addition of MHT tracking would probably make it a
>> failure.
>>
>> Also some risk of creating some new scarce asset class, txouts consisting
>> of primordial coins that aren't subject to the new rules... sounds like the
>> sort of thing that NFT degens would absolutely love.  That might not be an
>> issue *generally* for some change with confiscation risk, but for a change
>> that is specifically intended to lobotomize bitcoin to make it less useful
>> to NFT degens, maybe not such a great idea. :P
>>
>> I mentioned it at all because I thought it could potentially be of some
>> use, I'm just more skeptical of it for the current context.  Also luke-jr
>> and crew has moved on to actually propose even more invasive changes than
>> just limiting the script size, which I anticipated, and has much more
>> significant issues.  Just size limiting outputs likely doesn't harm any
>> interests or usages-- and so probably could be viable if the confiscation
>> issue was addressed, but it also doesn't stick it to people transacting in
>> ways the priests of ocean mining dislike.
>>
>> > I believe you're pointing out the idea of non economically-rational
>> spammers?
>>
>> I think it's a mistake to conclude the spammers are economically
>> irrational-- they're often just responding to different economics which may
>> be less legible to your analysis.  In particular, NFT degens prefer the
>> high cost of transactions as a thing that makes their tokens scarce and
>> gives them value.  -- otherwise they wouldn't be swapping for one less
>> efficient encoding for another, they're just be using another blockchain
>> (perhaps their own) entirely.
>>
>>
>>
>>
>> On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com>
>> wrote:
>>
>>> > MRH tracking might make that acceptable, but comes at a high cost
>>> which I think would clearly not be justified.
>>>
>>> Greg, I want to ask/challenge how bad this is, this seems like a
>>> generally reusable primitive that could make other upgrades more feasible
>>> that also have the same strict confiscation risk profile.
>>> IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?
>>>
>>> Poelstra,
>>>
>>> > I don't think this is a great idea -- it would be technically hard to
>>> implement and slow deployment indefinitely.
>>>
>>> I would like to know how much of a deal breaker this is in your opinion.
>>> Is MRH tracking off the table? In terms of the hypothetical presigned
>>> transactions that may exist using P2MS, is this a hard enough reason to
>>> require a MRH idea?
>>>
>>> Greg,
>>>
>>> > So, paradoxically this limit might increase the amount of non-prunable
>>> data
>>>
>>> I believe you're pointing out the idea of non economically-rational
>>> spammers? We already see actors ignoring cheaper witness inscription
>>> methods. If spam shifts to many sub-520 fake pubkey outputs (which I
>>> believe is less harmful than stamps), that imo is a separate UTXO cost
>>> discussion. (like a SF to add weight to outputs). Anywho, this point alone
>>> doesn't seem sufficient to add as a clear negative reason for someone
>>> opposed to the proposal.
>>>
>>> Thanks,
>>> Tidwell
>>> On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:
>>>
>>>> > Confiscation is a problem because of presigned transactions
>>>>
>>>> Allow 10000 bytes of total scriptPubKey size in each block counting
>>>> only those outputs that are larger than x (520 as proposed).
>>>> The code change is pretty minimal from the most obvious implementation
>>>> of the original rule.
>>>>
>>>> That makes it technically non-confiscatory. Still non-standard, but if
>>>> anyone out there so obnoxiously foot-gunned themselves, they can't claim
>>>> they were rugged by the devs.
>>>>
>>>> BR,
>>>> moonsettler
>>>>
>>>> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <
>>>> ad...@qrsnap.io> wrote:
>>>>
>>>> > Hey,
>>>> >
>>>> > First, thank you to everyone who responded, and please continue to do
>>>> so. There were many thought provoking responses and this did shift my
>>>> perspective quite a bit from the original post, which in of itself was the
>>>> goal to a degree.
>>>> >
>>>> > I am currently only going to respond to all of the current concerns.
>>>> Acks; though I like them will be ignored unless new discoveries are
>>>> included.
>>>> >
>>>> > Tl;dr (Portlands Perspective)
>>>> > - Confiscation is a problem because of presigned transactions
>>>> > - DoS mitigation could also occur through marking UTXOs as
>>>> unspendable if > 520 bytes, this would preserve the proof of publication.
>>>> > - Timeout / Sunset logic is compelling
>>>> > - The (n) value of acceptable needed bytes is contentious with the
>>>> lower suggested limit being 67
>>>> > - Congestion control is worth a look?
>>>> >
>>>> > Next Step:
>>>> > - Deeper discussion at the individual level: Antoine Poinsot and GCC
>>>> overlap?
>>>> > - Write an implementation.
>>>> > - Decide to pursue BIP
>>>> >
>>>> > Responses
>>>> >
>>>> > Andrew Poelstra:
>>>> > > There is a risk of confiscation of coins which have pre-signed but
>>>> > > unpublished transactions spending them to new outputs with large
>>>> > > scriptPubKeys. Due to long-standing standardness rules, and the
>>>> presence
>>>> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that
>>>> any
>>>> > > such transactions exist.
>>>> >
>>>> > PortlandHODL: This is a risk that can be incurred and likely not
>>>> possible to mitigate as there could be possible chains of transactions so
>>>> even when recursively iterating over a chain there is a chance that a
>>>> presigned breaks this rule. Every idea I have had from block redemption
>>>> limits on prevouts seems to just be a coverage issue where you can make the
>>>> confiscation less likely but not completely mitigated.
>>>> >
>>>> > Second, there are already TXs that effectively have been confiscated
>>>> at the policy level (P2SH Cleanstack violation) where the user can not find
>>>> any miner with a policy to accept these into their mempool. (3 years)
>>>> >
>>>> > /dev /fd0
>>>> > > so it would be great if this was restricted to OP_RETURN
>>>> >
>>>> > PortlandHODL: I reject this completely as this would remove the
>>>> UTXOset omission for the scriptPubkey and encourage miners to subvert the
>>>> OP_RETURN restriction and instead just use another op_code, this also do
>>>> not hit on some of the most important factors such as DoS mitigation and
>>>> legacy script attack surface reduction.
>>>> >
>>>> > Peter Todd
>>>> > > NACK ...
>>>> >
>>>> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP,
>>>> without including any additional context or reasoning.
>>>> >
>>>> > jeremy
>>>> > > I think that this type of rule is OK if we do it as a "sunsetting"
>>>> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2
>>>> years, 5 years, 10 years).
>>>> >
>>>> > If action is taken, this is the most reasonable approach. Alleviating
>>>> confiscatory concerns through deferral.
>>>> >
>>>> > > You can argue against this example probably, but it is worth
>>>> considering that absence of evidence of use is not evidence of absence of
>>>> use and I myself feel that overall our understanding of Bitcoin transaction
>>>> programming possibilities is still early. If you don't like this example, I
>>>> can give you others (probably).
>>>> >
>>>> > Agreed and this also falls into the reasoning for deciding to utilize
>>>> point 1 in your response. My thoughts on this would be along the lines of
>>>> proof of publication as this change only has the effect of stripping away
>>>> the executable portion of a script between 521 and 10_000 bytes or the
>>>> published data portion if > 10_000 bytes which the same data could likely
>>>> be published in chunked segments using outpoints.
>>>> >
>>>> > Andrew Poelstra:
>>>> > > Aside from proof-of-publication (i.e. data storage directly in the
>>>> UTXO
>>>> > > set) there is no usage of script which can't be equally (or better)
>>>> > > accomplished by using a Segwit v0 or Taproot script.
>>>> >
>>>> > This sums up the majority of future usecase concern
>>>> >
>>>> > Anthony Towns:
>>>> > > (If you restricted the change to only applying to scripts that used
>>>> > non-push operators, that would probably still provide upgrade
>>>> flexibility
>>>> > while also preventing potential script abuses. But it wouldn't do
>>>> anything
>>>> > to prevent publishing data)
>>>> >
>>>> > Could this not be done as segments in multiple outpoints using a
>>>> coordination outpoint? I fail to see why publication proof must be in a
>>>> single chunk. This does though however bring another alternative to mind,
>>>> just making these outpoints unspendable but not invalidate the block
>>>> through inclusion...
>>>> >
>>>> > > As far as the "but contiguous data will be regulated more strictly"
>>>> > argument goes; I don't think "your honour, my offensive content has
>>>> > strings of 4d0802 every 520 bytes
>>>> >
>>>> > Correct, this was never meant to resolve this issue.
>>>> >
>>>> > Luke Dashjr:
>>>> > > If we're going this route, we should just close all the gaps for
>>>> the immediate future:
>>>> >
>>>> > To put it nicely, this is completely beyond the scope of what is
>>>> being proposed.
>>>> >
>>>> > Guus Ellenkamp:
>>>> > > If there are really so few OP_RETURN outputs more than 144 bytes,
>>>> then
>>>> > why increase the limit if that change is so controversial? It seems
>>>> > people who want to use a larger OP_RETURN size do it anyway, even
>>>> with
>>>> > the current default limits.
>>>> >
>>>> > Completely off topic and irrelevant
>>>> >
>>>> > Greg Tonoski:
>>>> > > Limiting the maximum size of the scriptPubKey of a transaction to
>>>> 67 bytes.
>>>> >
>>>> > This leave no room to deal with broken hashing algorithms and very
>>>> little future upgradability for hooks. The rest of these points should be
>>>> merged with Lukes response and either hijack my thread or start a new one
>>>> with the increased scope, any approach I take will only be related to the
>>>> ScriptPubkey
>>>> >
>>>> > Keagan McClelland:
>>>> > > Hard NACK on capping the witness size as that would effectively ban
>>>> large scripts even in the P2SH wrapper which undermines Bitcoin's ability
>>>> to be an effectively programmable money.
>>>> >
>>>> > This has nothing to do with the witness size or even the P2SH wrapper
>>>> >
>>>> > Casey Rodarmor:
>>>> > > I think that "Bitcoin could need it in the future?" might be a good
>>>> enough
>>>> > reason not to do this.
>>>> >
>>>> > > Script pubkeys are the only variable-length transaction fields
>>>> which can be
>>>> > covered by input signatures, which might make them useful for future
>>>> soft
>>>> > forks. I can imagine confidential asset schemes or post-quantum coin
>>>> recovery
>>>> > schemes requiring large proofs in the outputs, where the validity of
>>>> the proof
>>>> > determined whether or not the transaction is valid, and thus require
>>>> the
>>>> > proofs to be in the outputs, and not just a hash commitment.
>>>> >
>>>> > Would the ability to publish the data alone be enough? Example make
>>>> the output unspendable but allow for the existence of the bytes to be
>>>> covered through the signature?
>>>> >
>>>> >
>>>> > Antoine Poinsot:
>>>> > > Limiting the size of created scriptPubKeys is not a sufficient
>>>> mitigation on its own
>>>> > I fail to see how this would not be sufficient? To DoS you need 2
>>>> things inputs with ScriptPubkey redemptions + heavy op_codes that require
>>>> unique checks. Example DUPing stack element again and again doesn't work.
>>>> This then leads to the next part is you could get up to unique complex
>>>> operations with the current (n) limit included per input.
>>>> >
>>>> > > One of the goal of BIP54 is to address objections to Matt's earlier
>>>> proposal, notably the (in my
>>>> > opinion reasonable) confiscation concerns voiced by Russell O'Connor.
>>>> Limiting the size of
>>>> > scriptPubKeys would in this regard be moving in the opposite
>>>> direction.
>>>> >
>>>> > Some notes is I would actually go as far as to say the confiscation
>>>> risk is higher with the TX limit proposed in BIP54 as we actually have
>>>> proof of redemption of TXs that break that rule and the input set to do
>>>> this already exists on-chain no need to even wonder about the whole
>>>> presigned. bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
>>>> >
>>>> > Please let me know if I am incorrect on any of this.
>>>> >
>>>> > > Furthermore, it's always possible to get the biggest bang for our
>>>> buck in a first step
>>>> >
>>>> > Agreed on bang for the buck regarding DoS.
>>>> >
>>>> > My final point here would be that I would like to discuss more, and
>>>> this is response is from the initial view of your response and could be
>>>> incomplete or incorrect, This is just my in the moment response.
>>>> >
>>>> > Antoine Riard:
>>>> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
>>>> favor of prioritizing
>>>> > a timewarp fix and limiting dosy spends by old redeem scripts
>>>> >
>>>> > The idea of congestion control is interesting, but this solution
>>>> should significantly reduce the total DoS severity of known vectors.
>>>> >
>>>> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
>>>> >
>>>> > > Limits on block construction that cross transactions make it harder
>>>> to accurately estimate fees and greatly complicate optimal block
>>>> construction-- the latter being important because smarter and more computer
>>>> powered mining code generating higher profits is a pro centralization
>>>> factor.
>>>> > >
>>>> > > In terms of effectiveness the "spam" will just make itself
>>>> indistinguishable from the most common transaction traffic from the
>>>> perspective of such metrics-- and might well drive up "spam" levels because
>>>> the higher embedding cost may make some of them use more transactions. The
>>>> competition for these buckets by other traffic could make it effectively a
>>>> block size reduction even against very boring ordinary transactions. ...
>>>> which is probably not what most people want.
>>>> > >
>>>> > > I think it's important to keep in mind that bitcoin fee levels even
>>>> at 0.1s/vb are far beyond what other hosting services and other blockchains
>>>> cost-- so anyone still embedding data in bitcoin *really* want to be there
>>>> for some reason and aren't too fee sensitive or else they'd already be
>>>> using something else... some are even in favor of higher costs since the
>>>> high fees are what create the scarcity needed for their seigniorage.
>>>> > >
>>>> > > But yeah I think your comments on priorities are correct.
>>>> > >
>>>> > >
>>>> > >
>>>> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com>
>>>> wrote:
>>>> > >
>>>> > > > Hi list,
>>>> > > >
>>>> > > > Thanks to the annex covered by the signature, I don't see how the
>>>> concern about limiting
>>>> > > > the extensibility of bitcoin script with future (post-quantum)
>>>> cryptographic schemes.
>>>> > > > Previous proposal of the annex were deliberately designed with
>>>> variable-length fields
>>>> > > > to flexibly accomodate a wide range of things.
>>>> > > >
>>>> > > > I believe there is one thing that has not been proposed to limit
>>>> unpredictable utterance
>>>> > > > of spams on the blockchain, namely congestion control of
>>>> categories of outputs (e.g "fat"
>>>> > > > scriptpubkeys). Let's say P a block period, T a type of
>>>> scriptpubkey and L a limiting
>>>> > > > threshold for the number of T occurences during the period P.
>>>> Beyond the L threshold, any
>>>> > > > additional T scriptpubkey is making the block invalid. Or
>>>> alternatively, any additional
>>>> > > > T generating / spending transaction must pay some weight
>>>> penalty...
>>>> > > >
>>>> > > > Congestion control, which of course comes with its lot of
>>>> shenanigans, is not very a novel
>>>> > > > idea as I believe it has been floated few times in the context of
>>>> lightning to solve mass
>>>> > > > closure, where channels out-priced at current feerate would have
>>>> their safety timelocks scale
>>>> > > > ups.
>>>> > > >
>>>> > > > No need anymore to come to social consensus on what is
>>>> quantitative "spam" or not. The blockchain
>>>> > > > would automatically throttle out the block space spamming
>>>> transaction. Qualitative spam it's another
>>>> > > > question, for anyone who has ever read shannon's theory of
>>>> communication only effective thing can
>>>> > > > be to limit the size of data payload. But probably we're kickly
>>>> back to a non-mathematically solvable
>>>> > > > linguistical question again [0].
>>>> > > >
>>>> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more
>>>> in favor of prioritizing
>>>> > > > a timewarp fix and limiting dosy spends by old redeem scripts,
>>>> rather than engaging in shooting
>>>> > > > ourselves in the foot with ill-designed "spam" consensus
>>>> mitigations.
>>>> > > >
>>>> > > > [0] If you have a soul of logician, it would be an interesting
>>>> demonstration to come with
>>>> > > > to establish that we cannot come up with mathematically or
>>>> cryptographically consensus means
>>>> > > > to solve qualitative "spam", which in a very pure sense is a
>>>> linguistical issue.
>>>> > > >
>>>> > > > Best,
>>>> > > > Antoine
>>>> > > > OTS hash:
>>>> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
>>>> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a
>>>> écrit :
>>>> > > >
>>>> > > > > Hi,
>>>> > > > >
>>>> > > > > This approach was discussed last year when evaluating the best
>>>> way to mitigate DoS blocks in terms
>>>> > > > > of gains compared to confiscatory surface. Limiting the size of
>>>> created scriptPubKeys is not a
>>>> > > > > sufficient mitigation on its own, and has a non-trivial
>>>> confiscatory surface.
>>>> > > > >
>>>> > > > > One of the goal of BIP54 is to address objections to Matt's
>>>> earlier proposal, notably the (in my
>>>> > > > > opinion reasonable) confiscation concerns voiced by Russell
>>>> O'Connor. Limiting the size of
>>>> > > > > scriptPubKeys would in this regard be moving in the opposite
>>>> direction.
>>>> > > > >
>>>> > > > > Various approaches of limiting the size of spent scriptPubKeys
>>>> were discussed, in forms that would
>>>> > > > > mitigate the confiscatory surface, to adopt in addition to
>>>> (what eventually became) the BIP54 sigops
>>>> > > > > limit. However i decided against including this additional
>>>> measure in BIP54 because:
>>>> > > > > - of the inherent complexity of the discussed schemes, which
>>>> would make it hard to reason about
>>>> > > > > constructing transactions spending legacy inputs, and equally
>>>> hard to evaluate the reduction of
>>>> > > > > the confiscatory surface;
>>>> > > > > - more importantly, there is steep diminishing returns to
>>>> piling on more mitigations. The BIP54
>>>> > > > > limit on its own prevents an externally-motivated attacker from
>>>> *unevenly* stalling the network
>>>> > > > > for dozens of minutes, and a revenue-maximizing miner from
>>>> regularly stalling its competitions
>>>> > > > > for dozens of seconds, at a minimized cost in confiscatory
>>>> surface. Additional mitigations reduce
>>>> > > > > the worst case validation time by a smaller factor at a higher
>>>> cost in terms of confiscatory
>>>> > > > > surface. It "feels right" to further reduce those numbers, but
>>>> it's less clear what the tangible
>>>> > > > > gains would be.
>>>> > > > >
>>>> > > > > Furthermore, it's always possible to get the biggest bang for
>>>> our buck in a first step and going the
>>>> > > > > extra mile in a later, more controversial, soft fork. I
>>>> previously floated the idea of a "cleanup
>>>> > > > > v2" in private discussions, and i think besides a reduction of
>>>> the maximum scriptPubKey size it
>>>> > > > > should feature a consensus-enforced maximum transaction size
>>>> for the reasons stated here:
>>>> > > > >
>>>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8.
>>>> I wouldn't hold my
>>>> > > > > breath on such a "cleanup v2", but it may be useful to have it
>>>> documented somewhere.
>>>> > > > >
>>>> > > > > I'm trying to not go into much details regarding which
>>>> mitigations were considered in designing
>>>> > > > > BIP54, because they are tightly related to the design of
>>>> various DoS blocks. But i'm always happy to
>>>> > > > > rehash the decisions made there and (re-)consider alternative
>>>> approaches on the semi-private Delving
>>>> > > > > thread [0] dedicated to this purpose. Feel free to ping me to
>>>> get access if i know you.
>>>> > > > >
>>>> > > > > Best,
>>>> > > > > Antoine Poinsot
>>>> > > > >
>>>> > > > > [0]:
>>>> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
>>>> > > > >
>>>> > > > >
>>>> > > > >
>>>> > > > >
>>>> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>>>> fre...@reardencode.com> wrote:
>>>> > > > >
>>>> > > > > >
>>>> > > > > >
>>>> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
>>>> > > > > >
>>>> > > > > > > But also given that there are essentially no violations and
>>>> no reason to
>>>> > > > > > > expect any I'm not sure the proposal is worth time relative
>>>> to fixes of
>>>> > > > > > > actual moderately serious DOS attack issues.
>>>> > > > > >
>>>> > > > > >
>>>> > > > > > I believe this limit would also stop most (all?) of
>>>> PortlandHODL's
>>>> > > > > > DoSblocks without having to make some of the other changes in
>>>> GCC. I
>>>> > > > > > think it's worthwhile to compare this approach to those
>>>> proposed by
>>>> > > > > > Antoine in solving these DoS vectors.
>>>> > > > > >
>>>> > > > > > Best,
>>>> > > > > >
>>>> > > > > > --Brandon
>>>> > > > > >
>>>> > > > > > --
>>>> > > > > > You received this message because you are subscribed to the
>>>> Google Groups "Bitcoin Development Mailing List" group.
>>>> > > > > > To unsubscribe from this group and stop receiving emails from
>>>> it, send an email to bitcoindev+...@googlegroups.com.
>>>> > > > > > To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
>>>>
>>>> > > >
>>>> > > > --
>>>> > > > You received this message because you are subscribed to the
>>>> Google Groups "Bitcoin Development Mailing List" group.
>>>> > > > To unsubscribe from this group and stop receiving emails from it,
>>>> send an email to bitcoindev+...@googlegroups.com.
>>>> > >
>>>> > > > To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com.
>>>>
>>>> >
>>>> > --
>>>> > You received this message because you are subscribed to the Google
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> > To unsubscribe from this group and stop receiving emails from it,
>>>> send an email to bitcoindev+...@googlegroups.com.
>>>> > To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com.
>>>>
>>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>>
>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com
>>> <https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgSNtO6kpfm0XaBCufyExjJnxg87ttLGUgpUU9pkemZTig%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 34266 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-30  2:26  0%                   ` Greg Maxwell
@ 2025-10-30  3:36  0%                     ` Michael Tidwell
  2025-10-30  6:15  0%                       ` Greg Maxwell
  2025-10-30 16:10  1%                     ` Tom Harding
  1 sibling, 1 reply; 200+ results
From: Michael Tidwell @ 2025-10-30  3:36 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 26714 bytes --]



Greg,

> Also some risk of creating a new scarce asset class.

Well, Casey Rodarmor is in the thread, so lol maybe.

Anyway, point taken. I want to be 100% sure I understand the hypotheticals: 
there could be an off-chain, presigned, transactions that needs more than 
520 bytes for the scriptPubKey and, as Poelstra said, could even form a 
chain of presigned transactions under some complex, previously unknown, 
scheme that only becomes public after this change is made. Can you confirm?

Would it also be a worry that a chain of transactions using said utxo could 
commit to some bizarre scheme, for instance a taproot transaction utxo that 
later is presigned committed back to P2MS larger than 520 bytes? If so, I 
think I get it, you're saying to essentially guarantee no confiscation we'd 
never be able to upgrade old UTXOs and we'd need to track them forever to 
prevent unlikely edge cases? 
Does the presigned chain at least stop needing to be tracked once the given 
UTXO co-mingles with a post-update coinbase utxo?

If so, this is indeed complex! This seems pretty insane both for the 
complexity of implementing and the unlikely edge cases. Has Core ever made 
a decision of (acceptable risk) to upgrade with protection of onchain utxos 
but not hypothetical unpublished ones? 
Aren't we going to run into the same situation if we do an op code clean up 
in the future if we had people presign/commit to op codes that are no 
longer consensus valid?

Tidwell

On Wednesday, October 29, 2025 at 10:32:10 PM UTC-4 Greg Maxwell wrote:

> "A few bytes" might be on the order of forever 10% increase in the UTXO 
> set size, plus a full from-network resync of all pruned nodes and a full 
> (e.g. most of day outage) reindex of all unpruned nodes.  Not 
> insignificant but also not nothing.  Such a portion of the existing utxo 
> size is not from outputs over 520 bytes in size, so as a scheme for utxo 
> set size reduction the addition of MHT tracking would probably make it a 
> failure.
>
> Also some risk of creating some new scarce asset class, txouts consisting 
> of primordial coins that aren't subject to the new rules... sounds like the 
> sort of thing that NFT degens would absolutely love.  That might not be an 
> issue *generally* for some change with confiscation risk, but for a change 
> that is specifically intended to lobotomize bitcoin to make it less useful 
> to NFT degens, maybe not such a great idea. :P
>
> I mentioned it at all because I thought it could potentially be of some 
> use, I'm just more skeptical of it for the current context.  Also luke-jr 
> and crew has moved on to actually propose even more invasive changes than 
> just limiting the script size, which I anticipated, and has much more 
> significant issues.  Just size limiting outputs likely doesn't harm any 
> interests or usages-- and so probably could be viable if the confiscation 
> issue was addressed, but it also doesn't stick it to people transacting in 
> ways the priests of ocean mining dislike. 
>
> > I believe you're pointing out the idea of non economically-rational 
> spammers?
>
> I think it's a mistake to conclude the spammers are economically 
> irrational-- they're often just responding to different economics which may 
> be less legible to your analysis.  In particular, NFT degens prefer the 
> high cost of transactions as a thing that makes their tokens scarce and 
> gives them value.  -- otherwise they wouldn't be swapping for one less 
> efficient encoding for another, they're just be using another blockchain 
> (perhaps their own) entirely.
>
>
>
>
> On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidw...@gmail.com> 
> wrote:
>
>> > MRH tracking might make that acceptable, but comes at a high cost which 
>> I think would clearly not be justified.
>>
>> Greg, I want to ask/challenge how bad this is, this seems like a 
>> generally reusable primitive that could make other upgrades more feasible 
>> that also have the same strict confiscation risk profile.
>> IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?
>>
>> Poelstra,
>>
>> > I don't think this is a great idea -- it would be technically hard to
>> implement and slow deployment indefinitely.
>>
>> I would like to know how much of a deal breaker this is in your opinion. 
>> Is MRH tracking off the table? In terms of the hypothetical presigned 
>> transactions that may exist using P2MS, is this a hard enough reason to 
>> require a MRH idea?
>>
>> Greg,
>>
>> > So, paradoxically this limit might increase the amount of non-prunable 
>> data
>>
>> I believe you're pointing out the idea of non economically-rational 
>> spammers? We already see actors ignoring cheaper witness inscription 
>> methods. If spam shifts to many sub-520 fake pubkey outputs (which I 
>> believe is less harmful than stamps), that imo is a separate UTXO cost 
>> discussion. (like a SF to add weight to outputs). Anywho, this point alone 
>> doesn't seem sufficient to add as a clear negative reason for someone 
>> opposed to the proposal.
>>
>> Thanks,
>> Tidwell
>> On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:
>>
>>> > Confiscation is a problem because of presigned transactions 
>>>
>>> Allow 10000 bytes of total scriptPubKey size in each block counting only 
>>> those outputs that are larger than x (520 as proposed). 
>>> The code change is pretty minimal from the most obvious implementation 
>>> of the original rule. 
>>>
>>> That makes it technically non-confiscatory. Still non-standard, but if 
>>> anyone out there so obnoxiously foot-gunned themselves, they can't claim 
>>> they were rugged by the devs. 
>>>
>>> BR, 
>>> moonsettler 
>>>
>>> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <
>>> ad...@qrsnap.io> wrote: 
>>>
>>> > Hey, 
>>> > 
>>> > First, thank you to everyone who responded, and please continue to do 
>>> so. There were many thought provoking responses and this did shift my 
>>> perspective quite a bit from the original post, which in of itself was the 
>>> goal to a degree. 
>>> > 
>>> > I am currently only going to respond to all of the current concerns. 
>>> Acks; though I like them will be ignored unless new discoveries are 
>>> included. 
>>> > 
>>> > Tl;dr (Portlands Perspective) 
>>> > - Confiscation is a problem because of presigned transactions 
>>> > - DoS mitigation could also occur through marking UTXOs as unspendable 
>>> if > 520 bytes, this would preserve the proof of publication. 
>>> > - Timeout / Sunset logic is compelling 
>>> > - The (n) value of acceptable needed bytes is contentious with the 
>>> lower suggested limit being 67 
>>> > - Congestion control is worth a look? 
>>> > 
>>> > Next Step: 
>>> > - Deeper discussion at the individual level: Antoine Poinsot and GCC 
>>> overlap? 
>>> > - Write an implementation. 
>>> > - Decide to pursue BIP 
>>> > 
>>> > Responses 
>>> > 
>>> > Andrew Poelstra: 
>>> > > There is a risk of confiscation of coins which have pre-signed but 
>>> > > unpublished transactions spending them to new outputs with large 
>>> > > scriptPubKeys. Due to long-standing standardness rules, and the 
>>> presence 
>>> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that 
>>> any 
>>> > > such transactions exist. 
>>> > 
>>> > PortlandHODL: This is a risk that can be incurred and likely not 
>>> possible to mitigate as there could be possible chains of transactions so 
>>> even when recursively iterating over a chain there is a chance that a 
>>> presigned breaks this rule. Every idea I have had from block redemption 
>>> limits on prevouts seems to just be a coverage issue where you can make the 
>>> confiscation less likely but not completely mitigated. 
>>> > 
>>> > Second, there are already TXs that effectively have been confiscated 
>>> at the policy level (P2SH Cleanstack violation) where the user can not find 
>>> any miner with a policy to accept these into their mempool. (3 years) 
>>> > 
>>> > /dev /fd0 
>>> > > so it would be great if this was restricted to OP_RETURN 
>>> > 
>>> > PortlandHODL: I reject this completely as this would remove the 
>>> UTXOset omission for the scriptPubkey and encourage miners to subvert the 
>>> OP_RETURN restriction and instead just use another op_code, this also do 
>>> not hit on some of the most important factors such as DoS mitigation and 
>>> legacy script attack surface reduction. 
>>> > 
>>> > Peter Todd 
>>> > > NACK ... 
>>> > 
>>> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
>>> without including any additional context or reasoning. 
>>> > 
>>> > jeremy 
>>> > > I think that this type of rule is OK if we do it as a "sunsetting" 
>>> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
>>> years, 5 years, 10 years). 
>>> > 
>>> > If action is taken, this is the most reasonable approach. Alleviating 
>>> confiscatory concerns through deferral. 
>>> > 
>>> > > You can argue against this example probably, but it is worth 
>>> considering that absence of evidence of use is not evidence of absence of 
>>> use and I myself feel that overall our understanding of Bitcoin transaction 
>>> programming possibilities is still early. If you don't like this example, I 
>>> can give you others (probably). 
>>> > 
>>> > Agreed and this also falls into the reasoning for deciding to utilize 
>>> point 1 in your response. My thoughts on this would be along the lines of 
>>> proof of publication as this change only has the effect of stripping away 
>>> the executable portion of a script between 521 and 10_000 bytes or the 
>>> published data portion if > 10_000 bytes which the same data could likely 
>>> be published in chunked segments using outpoints. 
>>> > 
>>> > Andrew Poelstra: 
>>> > > Aside from proof-of-publication (i.e. data storage directly in the 
>>> UTXO 
>>> > > set) there is no usage of script which can't be equally (or better) 
>>> > > accomplished by using a Segwit v0 or Taproot script. 
>>> > 
>>> > This sums up the majority of future usecase concern 
>>> > 
>>> > Anthony Towns: 
>>> > > (If you restricted the change to only applying to scripts that used 
>>> > non-push operators, that would probably still provide upgrade 
>>> flexibility 
>>> > while also preventing potential script abuses. But it wouldn't do 
>>> anything 
>>> > to prevent publishing data) 
>>> > 
>>> > Could this not be done as segments in multiple outpoints using a 
>>> coordination outpoint? I fail to see why publication proof must be in a 
>>> single chunk. This does though however bring another alternative to mind, 
>>> just making these outpoints unspendable but not invalidate the block 
>>> through inclusion... 
>>> > 
>>> > > As far as the "but contiguous data will be regulated more strictly" 
>>> > argument goes; I don't think "your honour, my offensive content has 
>>> > strings of 4d0802 every 520 bytes 
>>> > 
>>> > Correct, this was never meant to resolve this issue. 
>>> > 
>>> > Luke Dashjr: 
>>> > > If we're going this route, we should just close all the gaps for the 
>>> immediate future: 
>>> > 
>>> > To put it nicely, this is completely beyond the scope of what is being 
>>> proposed. 
>>> > 
>>> > Guus Ellenkamp: 
>>> > > If there are really so few OP_RETURN outputs more than 144 bytes, 
>>> then 
>>> > why increase the limit if that change is so controversial? It seems 
>>> > people who want to use a larger OP_RETURN size do it anyway, even with 
>>> > the current default limits. 
>>> > 
>>> > Completely off topic and irrelevant 
>>> > 
>>> > Greg Tonoski: 
>>> > > Limiting the maximum size of the scriptPubKey of a transaction to 67 
>>> bytes. 
>>> > 
>>> > This leave no room to deal with broken hashing algorithms and very 
>>> little future upgradability for hooks. The rest of these points should be 
>>> merged with Lukes response and either hijack my thread or start a new one 
>>> with the increased scope, any approach I take will only be related to the 
>>> ScriptPubkey 
>>> > 
>>> > Keagan McClelland: 
>>> > > Hard NACK on capping the witness size as that would effectively ban 
>>> large scripts even in the P2SH wrapper which undermines Bitcoin's ability 
>>> to be an effectively programmable money. 
>>> > 
>>> > This has nothing to do with the witness size or even the P2SH wrapper 
>>> > 
>>> > Casey Rodarmor: 
>>> > > I think that "Bitcoin could need it in the future?" might be a good 
>>> enough 
>>> > reason not to do this. 
>>> > 
>>> > > Script pubkeys are the only variable-length transaction fields which 
>>> can be 
>>> > covered by input signatures, which might make them useful for future 
>>> soft 
>>> > forks. I can imagine confidential asset schemes or post-quantum coin 
>>> recovery 
>>> > schemes requiring large proofs in the outputs, where the validity of 
>>> the proof 
>>> > determined whether or not the transaction is valid, and thus require 
>>> the 
>>> > proofs to be in the outputs, and not just a hash commitment. 
>>> > 
>>> > Would the ability to publish the data alone be enough? Example make 
>>> the output unspendable but allow for the existence of the bytes to be 
>>> covered through the signature? 
>>> > 
>>> > 
>>> > Antoine Poinsot: 
>>> > > Limiting the size of created scriptPubKeys is not a sufficient 
>>> mitigation on its own 
>>> > I fail to see how this would not be sufficient? To DoS you need 2 
>>> things inputs with ScriptPubkey redemptions + heavy op_codes that require 
>>> unique checks. Example DUPing stack element again and again doesn't work. 
>>> This then leads to the next part is you could get up to unique complex 
>>> operations with the current (n) limit included per input. 
>>> > 
>>> > > One of the goal of BIP54 is to address objections to Matt's earlier 
>>> proposal, notably the (in my 
>>> > opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
>>> Limiting the size of 
>>> > scriptPubKeys would in this regard be moving in the opposite 
>>> direction. 
>>> > 
>>> > Some notes is I would actually go as far as to say the confiscation 
>>> risk is higher with the TX limit proposed in BIP54 as we actually have 
>>> proof of redemption of TXs that break that rule and the input set to do 
>>> this already exists on-chain no need to even wonder about the whole 
>>> presigned. bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08 
>>> > 
>>> > Please let me know if I am incorrect on any of this. 
>>> > 
>>> > > Furthermore, it's always possible to get the biggest bang for our 
>>> buck in a first step 
>>> > 
>>> > Agreed on bang for the buck regarding DoS. 
>>> > 
>>> > My final point here would be that I would like to discuss more, and 
>>> this is response is from the initial view of your response and could be 
>>> incomplete or incorrect, This is just my in the moment response. 
>>> > 
>>> > Antoine Riard: 
>>> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
>>> favor of prioritizing 
>>> > a timewarp fix and limiting dosy spends by old redeem scripts 
>>> > 
>>> > The idea of congestion control is interesting, but this solution 
>>> should significantly reduce the total DoS severity of known vectors. 
>>> > 
>>> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote: 
>>> > 
>>> > > Limits on block construction that cross transactions make it harder 
>>> to accurately estimate fees and greatly complicate optimal block 
>>> construction-- the latter being important because smarter and more computer 
>>> powered mining code generating higher profits is a pro centralization 
>>> factor. 
>>> > > 
>>> > > In terms of effectiveness the "spam" will just make itself 
>>> indistinguishable from the most common transaction traffic from the 
>>> perspective of such metrics-- and might well drive up "spam" levels because 
>>> the higher embedding cost may make some of them use more transactions. The 
>>> competition for these buckets by other traffic could make it effectively a 
>>> block size reduction even against very boring ordinary transactions. ... 
>>> which is probably not what most people want. 
>>> > > 
>>> > > I think it's important to keep in mind that bitcoin fee levels even 
>>> at 0.1s/vb are far beyond what other hosting services and other blockchains 
>>> cost-- so anyone still embedding data in bitcoin *really* want to be there 
>>> for some reason and aren't too fee sensitive or else they'd already be 
>>> using something else... some are even in favor of higher costs since the 
>>> high fees are what create the scarcity needed for their seigniorage. 
>>> > > 
>>> > > But yeah I think your comments on priorities are correct. 
>>> > > 
>>> > > 
>>> > > 
>>> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> 
>>> wrote: 
>>> > > 
>>> > > > Hi list, 
>>> > > > 
>>> > > > Thanks to the annex covered by the signature, I don't see how the 
>>> concern about limiting 
>>> > > > the extensibility of bitcoin script with future (post-quantum) 
>>> cryptographic schemes. 
>>> > > > Previous proposal of the annex were deliberately designed with 
>>> variable-length fields 
>>> > > > to flexibly accomodate a wide range of things. 
>>> > > > 
>>> > > > I believe there is one thing that has not been proposed to limit 
>>> unpredictable utterance 
>>> > > > of spams on the blockchain, namely congestion control of 
>>> categories of outputs (e.g "fat" 
>>> > > > scriptpubkeys). Let's say P a block period, T a type of 
>>> scriptpubkey and L a limiting 
>>> > > > threshold for the number of T occurences during the period P. 
>>> Beyond the L threshold, any 
>>> > > > additional T scriptpubkey is making the block invalid. Or 
>>> alternatively, any additional 
>>> > > > T generating / spending transaction must pay some weight 
>>> penalty... 
>>> > > > 
>>> > > > Congestion control, which of course comes with its lot of 
>>> shenanigans, is not very a novel 
>>> > > > idea as I believe it has been floated few times in the context of 
>>> lightning to solve mass 
>>> > > > closure, where channels out-priced at current feerate would have 
>>> their safety timelocks scale 
>>> > > > ups. 
>>> > > > 
>>> > > > No need anymore to come to social consensus on what is 
>>> quantitative "spam" or not. The blockchain 
>>> > > > would automatically throttle out the block space spamming 
>>> transaction. Qualitative spam it's another 
>>> > > > question, for anyone who has ever read shannon's theory of 
>>> communication only effective thing can 
>>> > > > be to limit the size of data payload. But probably we're kickly 
>>> back to a non-mathematically solvable 
>>> > > > linguistical question again [0]. 
>>> > > > 
>>> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more 
>>> in favor of prioritizing 
>>> > > > a timewarp fix and limiting dosy spends by old redeem scripts, 
>>> rather than engaging in shooting 
>>> > > > ourselves in the foot with ill-designed "spam" consensus 
>>> mitigations. 
>>> > > > 
>>> > > > [0] If you have a soul of logician, it would be an interesting 
>>> demonstration to come with 
>>> > > > to establish that we cannot come up with mathematically or 
>>> cryptographically consensus means 
>>> > > > to solve qualitative "spam", which in a very pure sense is a 
>>> linguistical issue. 
>>> > > > 
>>> > > > Best, 
>>> > > > Antoine 
>>> > > > OTS hash: 
>>> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999 
>>> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a 
>>> écrit : 
>>> > > > 
>>> > > > > Hi, 
>>> > > > > 
>>> > > > > This approach was discussed last year when evaluating the best 
>>> way to mitigate DoS blocks in terms 
>>> > > > > of gains compared to confiscatory surface. Limiting the size of 
>>> created scriptPubKeys is not a 
>>> > > > > sufficient mitigation on its own, and has a non-trivial 
>>> confiscatory surface. 
>>> > > > > 
>>> > > > > One of the goal of BIP54 is to address objections to Matt's 
>>> earlier proposal, notably the (in my 
>>> > > > > opinion reasonable) confiscation concerns voiced by Russell 
>>> O'Connor. Limiting the size of 
>>> > > > > scriptPubKeys would in this regard be moving in the opposite 
>>> direction. 
>>> > > > > 
>>> > > > > Various approaches of limiting the size of spent scriptPubKeys 
>>> were discussed, in forms that would 
>>> > > > > mitigate the confiscatory surface, to adopt in addition to (what 
>>> eventually became) the BIP54 sigops 
>>> > > > > limit. However i decided against including this additional 
>>> measure in BIP54 because: 
>>> > > > > - of the inherent complexity of the discussed schemes, which 
>>> would make it hard to reason about 
>>> > > > > constructing transactions spending legacy inputs, and equally 
>>> hard to evaluate the reduction of 
>>> > > > > the confiscatory surface; 
>>> > > > > - more importantly, there is steep diminishing returns to piling 
>>> on more mitigations. The BIP54 
>>> > > > > limit on its own prevents an externally-motivated attacker from 
>>> *unevenly* stalling the network 
>>> > > > > for dozens of minutes, and a revenue-maximizing miner from 
>>> regularly stalling its competitions 
>>> > > > > for dozens of seconds, at a minimized cost in confiscatory 
>>> surface. Additional mitigations reduce 
>>> > > > > the worst case validation time by a smaller factor at a higher 
>>> cost in terms of confiscatory 
>>> > > > > surface. It "feels right" to further reduce those numbers, but 
>>> it's less clear what the tangible 
>>> > > > > gains would be. 
>>> > > > > 
>>> > > > > Furthermore, it's always possible to get the biggest bang for 
>>> our buck in a first step and going the 
>>> > > > > extra mile in a later, more controversial, soft fork. I 
>>> previously floated the idea of a "cleanup 
>>> > > > > v2" in private discussions, and i think besides a reduction of 
>>> the maximum scriptPubKey size it 
>>> > > > > should feature a consensus-enforced maximum transaction size for 
>>> the reasons stated here: 
>>> > > > > 
>>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
>>> I wouldn't hold my 
>>> > > > > breath on such a "cleanup v2", but it may be useful to have it 
>>> documented somewhere. 
>>> > > > > 
>>> > > > > I'm trying to not go into much details regarding which 
>>> mitigations were considered in designing 
>>> > > > > BIP54, because they are tightly related to the design of various 
>>> DoS blocks. But i'm always happy to 
>>> > > > > rehash the decisions made there and (re-)consider alternative 
>>> approaches on the semi-private Delving 
>>> > > > > thread [0] dedicated to this purpose. Feel free to ping me to 
>>> get access if i know you. 
>>> > > > > 
>>> > > > > Best, 
>>> > > > > Antoine Poinsot 
>>> > > > > 
>>> > > > > [0]: 
>>> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711 
>>> > > > > 
>>> > > > > 
>>> > > > > 
>>> > > > > 
>>> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>>> fre...@reardencode.com> wrote: 
>>> > > > > 
>>> > > > > > 
>>> > > > > > 
>>> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote: 
>>> > > > > > 
>>> > > > > > > But also given that there are essentially no violations and 
>>> no reason to 
>>> > > > > > > expect any I'm not sure the proposal is worth time relative 
>>> to fixes of 
>>> > > > > > > actual moderately serious DOS attack issues. 
>>> > > > > > 
>>> > > > > > 
>>> > > > > > I believe this limit would also stop most (all?) of 
>>> PortlandHODL's 
>>> > > > > > DoSblocks without having to make some of the other changes in 
>>> GCC. I 
>>> > > > > > think it's worthwhile to compare this approach to those 
>>> proposed by 
>>> > > > > > Antoine in solving these DoS vectors. 
>>> > > > > > 
>>> > > > > > Best, 
>>> > > > > > 
>>> > > > > > --Brandon 
>>> > > > > > 
>>> > > > > > -- 
>>> > > > > > You received this message because you are subscribed to the 
>>> Google Groups "Bitcoin Development Mailing List" group. 
>>> > > > > > To unsubscribe from this group and stop receiving emails from 
>>> it, send an email to bitcoindev+...@googlegroups.com. 
>>> > > > > > To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console. 
>>>
>>> > > > 
>>> > > > -- 
>>> > > > You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group. 
>>> > > > To unsubscribe from this group and stop receiving emails from it, 
>>> send an email to bitcoindev+...@googlegroups.com. 
>>> > > 
>>> > > > To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com. 
>>>
>>> > 
>>> > -- 
>>> > You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group. 
>>> > To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com. 
>>> > To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com. 
>>>
>>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c208e054-b85a-4a5c-9193-c28ef0d225c5n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 31212 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-27 23:44  2%                 ` Michael Tidwell
@ 2025-10-30  2:26  0%                   ` Greg Maxwell
  2025-10-30  3:36  0%                     ` Michael Tidwell
  2025-10-30 16:10  1%                     ` Tom Harding
  0 siblings, 2 replies; 200+ results
From: Greg Maxwell @ 2025-10-30  2:26 UTC (permalink / raw)
  To: Michael Tidwell; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 24093 bytes --]

"A few bytes" might be on the order of forever 10% increase in the UTXO set
size, plus a full from-network resync of all pruned nodes and a full (e.g.
most of day outage) reindex of all unpruned nodes.  Not insignificant but
also not nothing.  Such a portion of the existing utxo size is not from
outputs over 520 bytes in size, so as a scheme for utxo set size reduction
the addition of MHT tracking would probably make it a failure.

Also some risk of creating some new scarce asset class, txouts consisting
of primordial coins that aren't subject to the new rules... sounds like the
sort of thing that NFT degens would absolutely love.  That might not be an
issue *generally* for some change with confiscation risk, but for a change
that is specifically intended to lobotomize bitcoin to make it less useful
to NFT degens, maybe not such a great idea. :P

I mentioned it at all because I thought it could potentially be of some
use, I'm just more skeptical of it for the current context.  Also luke-jr
and crew has moved on to actually propose even more invasive changes than
just limiting the script size, which I anticipated, and has much more
significant issues.  Just size limiting outputs likely doesn't harm any
interests or usages-- and so probably could be viable if the confiscation
issue was addressed, but it also doesn't stick it to people transacting in
ways the priests of ocean mining dislike.

> I believe you're pointing out the idea of non economically-rational
spammers?

I think it's a mistake to conclude the spammers are economically
irrational-- they're often just responding to different economics which may
be less legible to your analysis.  In particular, NFT degens prefer the
high cost of transactions as a thing that makes their tokens scarce and
gives them value.  -- otherwise they wouldn't be swapping for one less
efficient encoding for another, they're just be using another blockchain
(perhaps their own) entirely.




On Thu, Oct 30, 2025 at 1:16 AM Michael Tidwell <mtidwell021@gmail.com>
wrote:

> > MRH tracking might make that acceptable, but comes at a high cost which
> I think would clearly not be justified.
>
> Greg, I want to ask/challenge how bad this is, this seems like a generally
> reusable primitive that could make other upgrades more feasible that also
> have the same strict confiscation risk profile.
> IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?
>
> Poelstra,
>
> > I don't think this is a great idea -- it would be technically hard to
> implement and slow deployment indefinitely.
>
> I would like to know how much of a deal breaker this is in your opinion.
> Is MRH tracking off the table? In terms of the hypothetical presigned
> transactions that may exist using P2MS, is this a hard enough reason to
> require a MRH idea?
>
> Greg,
>
> > So, paradoxically this limit might increase the amount of non-prunable
> data
>
> I believe you're pointing out the idea of non economically-rational
> spammers? We already see actors ignoring cheaper witness inscription
> methods. If spam shifts to many sub-520 fake pubkey outputs (which I
> believe is less harmful than stamps), that imo is a separate UTXO cost
> discussion. (like a SF to add weight to outputs). Anywho, this point alone
> doesn't seem sufficient to add as a clear negative reason for someone
> opposed to the proposal.
>
> Thanks,
> Tidwell
> On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:
>
>> > Confiscation is a problem because of presigned transactions
>>
>> Allow 10000 bytes of total scriptPubKey size in each block counting only
>> those outputs that are larger than x (520 as proposed).
>> The code change is pretty minimal from the most obvious implementation of
>> the original rule.
>>
>> That makes it technically non-confiscatory. Still non-standard, but if
>> anyone out there so obnoxiously foot-gunned themselves, they can't claim
>> they were rugged by the devs.
>>
>> BR,
>> moonsettler
>>
>> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io>
>> wrote:
>>
>> > Hey,
>> >
>> > First, thank you to everyone who responded, and please continue to do
>> so. There were many thought provoking responses and this did shift my
>> perspective quite a bit from the original post, which in of itself was the
>> goal to a degree.
>> >
>> > I am currently only going to respond to all of the current concerns.
>> Acks; though I like them will be ignored unless new discoveries are
>> included.
>> >
>> > Tl;dr (Portlands Perspective)
>> > - Confiscation is a problem because of presigned transactions
>> > - DoS mitigation could also occur through marking UTXOs as unspendable
>> if > 520 bytes, this would preserve the proof of publication.
>> > - Timeout / Sunset logic is compelling
>> > - The (n) value of acceptable needed bytes is contentious with the
>> lower suggested limit being 67
>> > - Congestion control is worth a look?
>> >
>> > Next Step:
>> > - Deeper discussion at the individual level: Antoine Poinsot and GCC
>> overlap?
>> > - Write an implementation.
>> > - Decide to pursue BIP
>> >
>> > Responses
>> >
>> > Andrew Poelstra:
>> > > There is a risk of confiscation of coins which have pre-signed but
>> > > unpublished transactions spending them to new outputs with large
>> > > scriptPubKeys. Due to long-standing standardness rules, and the
>> presence
>> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that
>> any
>> > > such transactions exist.
>> >
>> > PortlandHODL: This is a risk that can be incurred and likely not
>> possible to mitigate as there could be possible chains of transactions so
>> even when recursively iterating over a chain there is a chance that a
>> presigned breaks this rule. Every idea I have had from block redemption
>> limits on prevouts seems to just be a coverage issue where you can make the
>> confiscation less likely but not completely mitigated.
>> >
>> > Second, there are already TXs that effectively have been confiscated at
>> the policy level (P2SH Cleanstack violation) where the user can not find
>> any miner with a policy to accept these into their mempool. (3 years)
>> >
>> > /dev /fd0
>> > > so it would be great if this was restricted to OP_RETURN
>> >
>> > PortlandHODL: I reject this completely as this would remove the UTXOset
>> omission for the scriptPubkey and encourage miners to subvert the OP_RETURN
>> restriction and instead just use another op_code, this also do not hit on
>> some of the most important factors such as DoS mitigation and legacy script
>> attack surface reduction.
>> >
>> > Peter Todd
>> > > NACK ...
>> >
>> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP,
>> without including any additional context or reasoning.
>> >
>> > jeremy
>> > > I think that this type of rule is OK if we do it as a "sunsetting"
>> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2
>> years, 5 years, 10 years).
>> >
>> > If action is taken, this is the most reasonable approach. Alleviating
>> confiscatory concerns through deferral.
>> >
>> > > You can argue against this example probably, but it is worth
>> considering that absence of evidence of use is not evidence of absence of
>> use and I myself feel that overall our understanding of Bitcoin transaction
>> programming possibilities is still early. If you don't like this example, I
>> can give you others (probably).
>> >
>> > Agreed and this also falls into the reasoning for deciding to utilize
>> point 1 in your response. My thoughts on this would be along the lines of
>> proof of publication as this change only has the effect of stripping away
>> the executable portion of a script between 521 and 10_000 bytes or the
>> published data portion if > 10_000 bytes which the same data could likely
>> be published in chunked segments using outpoints.
>> >
>> > Andrew Poelstra:
>> > > Aside from proof-of-publication (i.e. data storage directly in the
>> UTXO
>> > > set) there is no usage of script which can't be equally (or better)
>> > > accomplished by using a Segwit v0 or Taproot script.
>> >
>> > This sums up the majority of future usecase concern
>> >
>> > Anthony Towns:
>> > > (If you restricted the change to only applying to scripts that used
>> > non-push operators, that would probably still provide upgrade
>> flexibility
>> > while also preventing potential script abuses. But it wouldn't do
>> anything
>> > to prevent publishing data)
>> >
>> > Could this not be done as segments in multiple outpoints using a
>> coordination outpoint? I fail to see why publication proof must be in a
>> single chunk. This does though however bring another alternative to mind,
>> just making these outpoints unspendable but not invalidate the block
>> through inclusion...
>> >
>> > > As far as the "but contiguous data will be regulated more strictly"
>> > argument goes; I don't think "your honour, my offensive content has
>> > strings of 4d0802 every 520 bytes
>> >
>> > Correct, this was never meant to resolve this issue.
>> >
>> > Luke Dashjr:
>> > > If we're going this route, we should just close all the gaps for the
>> immediate future:
>> >
>> > To put it nicely, this is completely beyond the scope of what is being
>> proposed.
>> >
>> > Guus Ellenkamp:
>> > > If there are really so few OP_RETURN outputs more than 144 bytes,
>> then
>> > why increase the limit if that change is so controversial? It seems
>> > people who want to use a larger OP_RETURN size do it anyway, even with
>> > the current default limits.
>> >
>> > Completely off topic and irrelevant
>> >
>> > Greg Tonoski:
>> > > Limiting the maximum size of the scriptPubKey of a transaction to 67
>> bytes.
>> >
>> > This leave no room to deal with broken hashing algorithms and very
>> little future upgradability for hooks. The rest of these points should be
>> merged with Lukes response and either hijack my thread or start a new one
>> with the increased scope, any approach I take will only be related to the
>> ScriptPubkey
>> >
>> > Keagan McClelland:
>> > > Hard NACK on capping the witness size as that would effectively ban
>> large scripts even in the P2SH wrapper which undermines Bitcoin's ability
>> to be an effectively programmable money.
>> >
>> > This has nothing to do with the witness size or even the P2SH wrapper
>> >
>> > Casey Rodarmor:
>> > > I think that "Bitcoin could need it in the future?" might be a good
>> enough
>> > reason not to do this.
>> >
>> > > Script pubkeys are the only variable-length transaction fields which
>> can be
>> > covered by input signatures, which might make them useful for future
>> soft
>> > forks. I can imagine confidential asset schemes or post-quantum coin
>> recovery
>> > schemes requiring large proofs in the outputs, where the validity of
>> the proof
>> > determined whether or not the transaction is valid, and thus require
>> the
>> > proofs to be in the outputs, and not just a hash commitment.
>> >
>> > Would the ability to publish the data alone be enough? Example make the
>> output unspendable but allow for the existence of the bytes to be covered
>> through the signature?
>> >
>> >
>> > Antoine Poinsot:
>> > > Limiting the size of created scriptPubKeys is not a sufficient
>> mitigation on its own
>> > I fail to see how this would not be sufficient? To DoS you need 2
>> things inputs with ScriptPubkey redemptions + heavy op_codes that require
>> unique checks. Example DUPing stack element again and again doesn't work.
>> This then leads to the next part is you could get up to unique complex
>> operations with the current (n) limit included per input.
>> >
>> > > One of the goal of BIP54 is to address objections to Matt's earlier
>> proposal, notably the (in my
>> > opinion reasonable) confiscation concerns voiced by Russell O'Connor.
>> Limiting the size of
>> > scriptPubKeys would in this regard be moving in the opposite direction.
>> >
>> > Some notes is I would actually go as far as to say the confiscation
>> risk is higher with the TX limit proposed in BIP54 as we actually have
>> proof of redemption of TXs that break that rule and the input set to do
>> this already exists on-chain no need to even wonder about the whole
>> presigned. bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
>> >
>> > Please let me know if I am incorrect on any of this.
>> >
>> > > Furthermore, it's always possible to get the biggest bang for our
>> buck in a first step
>> >
>> > Agreed on bang for the buck regarding DoS.
>> >
>> > My final point here would be that I would like to discuss more, and
>> this is response is from the initial view of your response and could be
>> incomplete or incorrect, This is just my in the moment response.
>> >
>> > Antoine Riard:
>> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
>> favor of prioritizing
>> > a timewarp fix and limiting dosy spends by old redeem scripts
>> >
>> > The idea of congestion control is interesting, but this solution should
>> significantly reduce the total DoS severity of known vectors.
>> >
>> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
>> >
>> > > Limits on block construction that cross transactions make it harder
>> to accurately estimate fees and greatly complicate optimal block
>> construction-- the latter being important because smarter and more computer
>> powered mining code generating higher profits is a pro centralization
>> factor.
>> > >
>> > > In terms of effectiveness the "spam" will just make itself
>> indistinguishable from the most common transaction traffic from the
>> perspective of such metrics-- and might well drive up "spam" levels because
>> the higher embedding cost may make some of them use more transactions. The
>> competition for these buckets by other traffic could make it effectively a
>> block size reduction even against very boring ordinary transactions. ...
>> which is probably not what most people want.
>> > >
>> > > I think it's important to keep in mind that bitcoin fee levels even
>> at 0.1s/vb are far beyond what other hosting services and other blockchains
>> cost-- so anyone still embedding data in bitcoin *really* want to be there
>> for some reason and aren't too fee sensitive or else they'd already be
>> using something else... some are even in favor of higher costs since the
>> high fees are what create the scarcity needed for their seigniorage.
>> > >
>> > > But yeah I think your comments on priorities are correct.
>> > >
>> > >
>> > >
>> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com>
>> wrote:
>> > >
>> > > > Hi list,
>> > > >
>> > > > Thanks to the annex covered by the signature, I don't see how the
>> concern about limiting
>> > > > the extensibility of bitcoin script with future (post-quantum)
>> cryptographic schemes.
>> > > > Previous proposal of the annex were deliberately designed with
>> variable-length fields
>> > > > to flexibly accomodate a wide range of things.
>> > > >
>> > > > I believe there is one thing that has not been proposed to limit
>> unpredictable utterance
>> > > > of spams on the blockchain, namely congestion control of categories
>> of outputs (e.g "fat"
>> > > > scriptpubkeys). Let's say P a block period, T a type of
>> scriptpubkey and L a limiting
>> > > > threshold for the number of T occurences during the period P.
>> Beyond the L threshold, any
>> > > > additional T scriptpubkey is making the block invalid. Or
>> alternatively, any additional
>> > > > T generating / spending transaction must pay some weight penalty...
>> > > >
>> > > > Congestion control, which of course comes with its lot of
>> shenanigans, is not very a novel
>> > > > idea as I believe it has been floated few times in the context of
>> lightning to solve mass
>> > > > closure, where channels out-priced at current feerate would have
>> their safety timelocks scale
>> > > > ups.
>> > > >
>> > > > No need anymore to come to social consensus on what is quantitative
>> "spam" or not. The blockchain
>> > > > would automatically throttle out the block space spamming
>> transaction. Qualitative spam it's another
>> > > > question, for anyone who has ever read shannon's theory of
>> communication only effective thing can
>> > > > be to limit the size of data payload. But probably we're kickly
>> back to a non-mathematically solvable
>> > > > linguistical question again [0].
>> > > >
>> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
>> favor of prioritizing
>> > > > a timewarp fix and limiting dosy spends by old redeem scripts,
>> rather than engaging in shooting
>> > > > ourselves in the foot with ill-designed "spam" consensus
>> mitigations.
>> > > >
>> > > > [0] If you have a soul of logician, it would be an interesting
>> demonstration to come with
>> > > > to establish that we cannot come up with mathematically or
>> cryptographically consensus means
>> > > > to solve qualitative "spam", which in a very pure sense is a
>> linguistical issue.
>> > > >
>> > > > Best,
>> > > > Antoine
>> > > > OTS hash:
>> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
>> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a
>> écrit :
>> > > >
>> > > > > Hi,
>> > > > >
>> > > > > This approach was discussed last year when evaluating the best
>> way to mitigate DoS blocks in terms
>> > > > > of gains compared to confiscatory surface. Limiting the size of
>> created scriptPubKeys is not a
>> > > > > sufficient mitigation on its own, and has a non-trivial
>> confiscatory surface.
>> > > > >
>> > > > > One of the goal of BIP54 is to address objections to Matt's
>> earlier proposal, notably the (in my
>> > > > > opinion reasonable) confiscation concerns voiced by Russell
>> O'Connor. Limiting the size of
>> > > > > scriptPubKeys would in this regard be moving in the opposite
>> direction.
>> > > > >
>> > > > > Various approaches of limiting the size of spent scriptPubKeys
>> were discussed, in forms that would
>> > > > > mitigate the confiscatory surface, to adopt in addition to (what
>> eventually became) the BIP54 sigops
>> > > > > limit. However i decided against including this additional
>> measure in BIP54 because:
>> > > > > - of the inherent complexity of the discussed schemes, which
>> would make it hard to reason about
>> > > > > constructing transactions spending legacy inputs, and equally
>> hard to evaluate the reduction of
>> > > > > the confiscatory surface;
>> > > > > - more importantly, there is steep diminishing returns to piling
>> on more mitigations. The BIP54
>> > > > > limit on its own prevents an externally-motivated attacker from
>> *unevenly* stalling the network
>> > > > > for dozens of minutes, and a revenue-maximizing miner from
>> regularly stalling its competitions
>> > > > > for dozens of seconds, at a minimized cost in confiscatory
>> surface. Additional mitigations reduce
>> > > > > the worst case validation time by a smaller factor at a higher
>> cost in terms of confiscatory
>> > > > > surface. It "feels right" to further reduce those numbers, but
>> it's less clear what the tangible
>> > > > > gains would be.
>> > > > >
>> > > > > Furthermore, it's always possible to get the biggest bang for our
>> buck in a first step and going the
>> > > > > extra mile in a later, more controversial, soft fork. I
>> previously floated the idea of a "cleanup
>> > > > > v2" in private discussions, and i think besides a reduction of
>> the maximum scriptPubKey size it
>> > > > > should feature a consensus-enforced maximum transaction size for
>> the reasons stated here:
>> > > > >
>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8.
>> I wouldn't hold my
>> > > > > breath on such a "cleanup v2", but it may be useful to have it
>> documented somewhere.
>> > > > >
>> > > > > I'm trying to not go into much details regarding which
>> mitigations were considered in designing
>> > > > > BIP54, because they are tightly related to the design of various
>> DoS blocks. But i'm always happy to
>> > > > > rehash the decisions made there and (re-)consider alternative
>> approaches on the semi-private Delving
>> > > > > thread [0] dedicated to this purpose. Feel free to ping me to get
>> access if i know you.
>> > > > >
>> > > > > Best,
>> > > > > Antoine Poinsot
>> > > > >
>> > > > > [0]:
>> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
>> > > > >
>> > > > >
>> > > > >
>> > > > >
>> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>> fre...@reardencode.com> wrote:
>> > > > >
>> > > > > >
>> > > > > >
>> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
>> > > > > >
>> > > > > > > But also given that there are essentially no violations and
>> no reason to
>> > > > > > > expect any I'm not sure the proposal is worth time relative
>> to fixes of
>> > > > > > > actual moderately serious DOS attack issues.
>> > > > > >
>> > > > > >
>> > > > > > I believe this limit would also stop most (all?) of
>> PortlandHODL's
>> > > > > > DoSblocks without having to make some of the other changes in
>> GCC. I
>> > > > > > think it's worthwhile to compare this approach to those
>> proposed by
>> > > > > > Antoine in solving these DoS vectors.
>> > > > > >
>> > > > > > Best,
>> > > > > >
>> > > > > > --Brandon
>> > > > > >
>> > > > > > --
>> > > > > > You received this message because you are subscribed to the
>> Google Groups "Bitcoin Development Mailing List" group.
>> > > > > > To unsubscribe from this group and stop receiving emails from
>> it, send an email to bitcoindev+...@googlegroups.com.
>> > > > > > To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
>> > > >
>> > > > --
>> > > > You received this message because you are subscribed to the Google
>> Groups "Bitcoin Development Mailing List" group.
>> > > > To unsubscribe from this group and stop receiving emails from it,
>> send an email to bitcoindev+...@googlegroups.com.
>> > >
>> > > > To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com.
>>
>> >
>> > --
>> > You received this message because you are subscribed to the Google
>> Groups "Bitcoin Development Mailing List" group.
>> > To unsubscribe from this group and stop receiving emails from it, send
>> an email to bitcoindev+...@googlegroups.com.
>> > To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com.
>>
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgSUqFs-74m-we6sb5oY2%3D9R6LDVN_iFqtX%2Bz_d3hx0nnw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 27784 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-27  3:41  1%   ` Jal Toorey
@ 2025-10-27 17:27  1%     ` Max
  0 siblings, 0 replies; 200+ results
From: Max @ 2025-10-27 17:27 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 3596 bytes --]

Why don't we just quickly soft fork to disallow large OP_RETURN outputs 
(i.e. keep them capped to 80 bytes) only, with forward-looking activation 
(no retroactive block invalidation)? This would give the market a clear and 
simple way to decide whether such transactions are acceptable or not. It 
wouldn't have any of the issues mentioned so far in the discussion like 
creating an incentive to put CSAM or other illegal content to attempt a 
reorg double spend due to the complex deployment mechanism proposed in 
BIP-444 or like putting in jeopardy existing Taproot functionality by 
touching other primitives. We don't actually need to remove all the 
mechanisms that can be used for embedding data (which has been demonstrated 
to be impossible). Rather what we need is to give users the opportunity to 
signal whether arbitrary data is welcome or not.

If the legal concerns are compelling enough to warrant consensus changes, 
miners should support a clean soft fork immediately. If the market quickly 
adopts the new consensus-level OP_RETURN restrictions it would announce 
sufficiently clearly to the world that arbitrary data is not welcome and 
deter future attempts to bring that to Bitcoin by showing the network's 
readiness to resist such efforts. I believe that this PR is too dramatic 
and needlessly complicated for what we need: letting the market decide 
whether to accept or reject the explicit invitation for arbitrary data 
storage that Core v30 has created. Technical changes should be limited to 
this question only and simple enough for people to make a decision without 
being distracted or overwhelmed by adjacent issues.

On Monday, October 27, 2025 at 10:53:31 AM UTC-6 Jal Toorey wrote:

> "bitcoin is money"
>
> The definition of what is money is extremely subjective.  The history of 
> it shows this (not the history saifedean paints). Trying to direct the 
> development to capture a definition of money opens a huge attack vector. 
> It's not different than trying to decide what is spam. 
>
> Also what is the difference between the bashers slogan that bitcoin is p2p 
> money and "bitcoin is money"  They seem like the same thing? 
> On Sunday, October 26, 2025 at 3:43:26 PM UTC-7 Peter Todd wrote:
>
>> On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin 
>> Development Mailing List wrote: 
>> > Hi list - 
>> > 
>> > Due to Bitcoin Core v30 gaining in popularity, it has become necessary 
>> to move forward on [luke-jr's ML proposal](
>> https://github.com/bitcoin/bips/pull/2017) to temporarily limit 
>> arbitrary data at the consensus level, which so far has 3 weeks with no 
>> objections: 
>> > 
>> > https://github.com/bitcoin/bips/pull/2017 
>>
>> Transaction 
>> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c 
>> contains the full text of this BIP as of writing(1), while simultaneously 
>> being 
>> compliant with that BIP. 
>>
>> Clearly, this approach is ineffective. 
>>
>> 1) 
>> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki 
>>
>> -- 
>> https://petertodd.org 'peter'[:-1]@petertodd.org 
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/2774a0b5-fd65-494b-ac23-f3726754eda7n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 5688 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-29 16:10  1%       ` yes_please
@ 2025-10-30  2:10  1%         ` Greg Maxwell
  2025-10-30 15:04  1%           ` Melvin Carvalho
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-10-30  2:10 UTC (permalink / raw)
  To: yes_please
  Cc: Russell O'Connor, TokyoBitcoiner,
	Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 9320 bytes --]

I searched for the source of your quotation and am unable to find it, but
its author appears to be confused or missing a complete understanding.

The particular size isn't motivated by application but because major miners
had already removed the rule completely.  As such no lesser setting would
achieve the goal of matching relay to what will actually get mined and
completely solve the bad situation created by the mismatch.

If you consider this regrettable it's worthwhile to consider that a failure
to increase it previously (on several prior proposals) and even a failure
to discuss and evaluate it was likely due to the unprofessional and
relentless harassment of Luke-jr.  Had that not occurred perhaps the limit
would have been incrementally increased previously before major miners on
their own found it to be in their interest to simply remove it (as removing
it is much easier than twiddling it).  The consequence of failing to be
pragmatic is the loss of that nudge.

That said, the economics and incentives of bitcoin are such that the
removal was inevitable once people were willing to pay for it-- and I would
have happily told you this in 2014 or whenever back when op_return was
reallowed for relay.  Beyond the current situation with the rule completely
bypassed this inevitably favors removal once the policy has started
eroding.  Even if miners had only bypassed to a few kilobytes or whatnot
moving to match that would only result in repeated cycles of transactions
that will get mined failing to relay, each cycle favoring private
submission mechanisms and promoting mining centralization.  Policy is only
at best a nudge and a fragile one.

I think in many people's view-- certainly in mine-- cirtia or whatever was
irrelevant to the discussion except as a concrete example of a fake pubkey
user that would rather not do that-- and one that wasn't some random NFT
thing that we'd all rather not be using Bitcoin at all. In other words,
that the benefit of avoiding more utxo bloat wasn't speculative.










On Thu, Oct 30, 2025 at 1:15 AM yes_please <caucasianjazz12@gmail.com>
wrote:

> Hi all,
>
> Perhaps we can find a meeting point if we focus on the max size of
> OP_return ?
> The increase from 83 to 100'000 bytes has been motivated as "probably we
> will have to increase it again in the future, it requires energy and time
> for code maintenance, so we'd rather increase it now to 100'000 bytes and
> be done with it". While these are valid points, the unknown consequences
> that might manifest with such a drastic increase all at once may not be the
> most prudent approach.
> Considering also that "the canary in the coal mine", namely Citrea use
> case, requires only 144 bytes to utilize op_return instead of more harmful
> ways, the increase to 100'000 bytes appears disproportionate given the
> circumstances, and again non-prudent enough (which is what I suspect is
> creating most of the debate at hand).
>
> caucasianjazz12
>
> On Wed, Oct 29, 2025 at 4:38 PM 'Russell O'Connor' via Bitcoin Development
> Mailing List <bitcoindev@googlegroups.com> wrote:
>
>> On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com>
>> wrote:
>>
>>> Questions reacting to text in reply of Russell O'Connor:
>>>
>>>    - *" there exist some protocols that require":*
>>>       - Which protocols?
>>>
>>> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I
>> don't know anything about their protocol beyond that.
>>
>>
>>>
>>>    -
>>>       - Why does bitcoin need to cater to their needs?
>>>
>>> If we don't support these in OP_RETURNs, Citrea, and other folks like
>> them, will use something like bare multisigs instead, which will be a
>> little more expensive for them and much more expensive for every other
>> Bitcoin node operator on the planet because those (likely) unspendable UTXO
>> will have to remain in the UTXO set forever because they will be
>> indistinguishable from legitimate bare multisigs.
>>
>>>
>>>    -
>>>       - Do we cater to any protocol that comes along?
>>>          - How do we choose which to enable, and which to discourage?
>>>
>>> Clamping down on OP_RETURNs won't discourage the use of these
>> Citrea-like protocols.  Instead it will encourage them to instead use
>> uncensorable publication channels such as bare multisigs, which will bloat
>> the UTXO set and drive up costs for every Bitcoin node operator on the
>> planet.
>>
>>>
>>>    - *"the folks using these protocols will simply have no choice"*:
>>>       - Did we *force* them to use bitcoin for their project?
>>>       - It sounds like "if you don't change the code to enable my
>>>       project, I will be forced to trash your project." Is this wrong?
>>>
>>> By "force" I mean in the sense that when a recent KDE upgrade dropped
>> the ability to specify some command to be run whenever the screen is
>> locked, KDE "forced" me to write a systemd service to run dbus-monitor to
>> watch for screen locking events instead.  Fortunately, in the case of KDE,
>> being "forced" to work around their changes only makes my life worse.
>> However in the case of limiting OP_RETURNs, users who are "forced" to find
>> workarounds for their proof of publication protocols  will ultimately lead
>> to them using the uncensorable data channel of bare-multisigs, or similar,
>> which have consequences not only for themselves but every other Bitcoin
>> node operator on the planet.
>>
>> It is specifically the externalities caused by the bare-multisig
>> workaround that we need to address. If these externalities didn't exist,
>> then I, and presumably others, wouldn't care so much.
>>
>>>
>>>    - *"any attempt to cap OP_RETURN outputs will force those users"*:
>>>       - Again, *force* is a form of coercion. Is the bitcoin code with
>>>       it's current setting *forcing* anyone to do anything?
>>>       - Are the external protocol designers the victims here?
>>>
>>> The victims will be every node operator on the planet who has to deal
>> with the unprunable UTXO bloat caused by users posting their
>> proof-of-publication data via the uncensorable bare-multisig avenue.  This
>> collective cost will actually be much higher than the cost to the external
>> protocol designers who only have to pay a few more pennies for their
>> transactions.
>>
>>
>>>
>>>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>>>       - What problem?
>>>
>>> The problem is a combination of protocols that require using
>> proof-of-publication choosing to use uncensorable bare-multisigs instead,
>> and/or, so long as this proposal isn't adopted, the problem of users
>> bypassing the network to get their OP_RETURN transactions mined which leads
>> to poor quality block reconstruction and poor quality fee estimates and the
>> like.
>>
>>>
>>>    -
>>>       - Is the bitcoin code responsible for fulfilling the needs of an
>>>       external project or protocol?
>>>          - If yes, why?
>>>
>>> Again the victims here wouldn't be the external protocol designers.
>> They will just pay the extra pennies to publish using bare-multisig.  The
>> victims would be every Bitcoin node operator on the planet.  And while the
>> core developers have no warranties or responsibilities attached to their
>> open source code, I think we would agree that "costs borne by every Bitcoin
>> node operator on the planet", is something they ought to bear in mind in
>> their work.
>>
>>
>>>
>>> I hope you will take these questions seriously. I really want to
>>> understand your thinking.
>>>
>>
>> Hope this helps.
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTBNYUA%2Bu6qhywK7-hC1CB%2BzqWSU9a8JsOG8nd-WsDLCQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 12123 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-22  8:07  0%               ` 'moonsettler' via Bitcoin Development Mailing List
@ 2025-10-27 23:44  2%                 ` Michael Tidwell
  2025-10-30  2:26  0%                   ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: Michael Tidwell @ 2025-10-27 23:44 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 21174 bytes --]

> MRH tracking might make that acceptable, but comes at a high cost which I 
think would clearly not be justified.

Greg, I want to ask/challenge how bad this is, this seems like a generally 
reusable primitive that could make other upgrades more feasible that also 
have the same strict confiscation risk profile.
IIUC, the major pain is, 1 big reindex cost + a few bytes per utxo?

Poelstra,

> I don't think this is a great idea -- it would be technically hard to
implement and slow deployment indefinitely.

I would like to know how much of a deal breaker this is in your opinion. Is 
MRH tracking off the table? In terms of the hypothetical presigned 
transactions that may exist using P2MS, is this a hard enough reason to 
require a MRH idea?

Greg,

> So, paradoxically this limit might increase the amount of non-prunable 
data

I believe you're pointing out the idea of non economically-rational 
spammers? We already see actors ignoring cheaper witness inscription 
methods. If spam shifts to many sub-520 fake pubkey outputs (which I 
believe is less harmful than stamps), that imo is a separate UTXO cost 
discussion. (like a SF to add weight to outputs). Anywho, this point alone 
doesn't seem sufficient to add as a clear negative reason for someone 
opposed to the proposal.

Thanks,
Tidwell
On Wednesday, October 22, 2025 at 5:55:58 AM UTC-4 moonsettler wrote:

> > Confiscation is a problem because of presigned transactions
>
> Allow 10000 bytes of total scriptPubKey size in each block counting only 
> those outputs that are larger than x (520 as proposed).
> The code change is pretty minimal from the most obvious implementation of 
> the original rule.
>
> That makes it technically non-confiscatory. Still non-standard, but if 
> anyone out there so obnoxiously foot-gunned themselves, they can't claim 
> they were rugged by the devs.
>
> BR,
> moonsettler
>
> On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <ad...@qrsnap.io> 
> wrote:
>
> > Hey,
> > 
> > First, thank you to everyone who responded, and please continue to do 
> so. There were many thought provoking responses and this did shift my 
> perspective quite a bit from the original post, which in of itself was the 
> goal to a degree.
> > 
> > I am currently only going to respond to all of the current concerns. 
> Acks; though I like them will be ignored unless new discoveries are 
> included.
> > 
> > Tl;dr (Portlands Perspective)
> > - Confiscation is a problem because of presigned transactions
> > - DoS mitigation could also occur through marking UTXOs as unspendable 
> if > 520 bytes, this would preserve the proof of publication.
> > - Timeout / Sunset logic is compelling
> > - The (n) value of acceptable needed bytes is contentious with the lower 
> suggested limit being 67
> > - Congestion control is worth a look?
> > 
> > Next Step:
> > - Deeper discussion at the individual level: Antoine Poinsot and GCC 
> overlap?
> > - Write an implementation.
> > - Decide to pursue BIP
> > 
> > Responses
> > 
> > Andrew Poelstra:
> > > There is a risk of confiscation of coins which have pre-signed but
> > > unpublished transactions spending them to new outputs with large
> > > scriptPubKeys. Due to long-standing standardness rules, and the 
> presence
> > > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any
> > > such transactions exist.
> > 
> > PortlandHODL: This is a risk that can be incurred and likely not 
> possible to mitigate as there could be possible chains of transactions so 
> even when recursively iterating over a chain there is a chance that a 
> presigned breaks this rule. Every idea I have had from block redemption 
> limits on prevouts seems to just be a coverage issue where you can make the 
> confiscation less likely but not completely mitigated.
> > 
> > Second, there are already TXs that effectively have been confiscated at 
> the policy level (P2SH Cleanstack violation) where the user can not find 
> any miner with a policy to accept these into their mempool. (3 years)
> > 
> > /dev /fd0
> > > so it would be great if this was restricted to OP_RETURN
> > 
> > PortlandHODL: I reject this completely as this would remove the UTXOset 
> omission for the scriptPubkey and encourage miners to subvert the OP_RETURN 
> restriction and instead just use another op_code, this also do not hit on 
> some of the most important factors such as DoS mitigation and legacy script 
> attack surface reduction.
> > 
> > Peter Todd
> > > NACK ...
> > 
> > PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
> without including any additional context or reasoning.
> > 
> > jeremy
> > > I think that this type of rule is OK if we do it as a "sunsetting" 
> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
> years, 5 years, 10 years).
> > 
> > If action is taken, this is the most reasonable approach. Alleviating 
> confiscatory concerns through deferral.
> > 
> > > You can argue against this example probably, but it is worth 
> considering that absence of evidence of use is not evidence of absence of 
> use and I myself feel that overall our understanding of Bitcoin transaction 
> programming possibilities is still early. If you don't like this example, I 
> can give you others (probably).
> > 
> > Agreed and this also falls into the reasoning for deciding to utilize 
> point 1 in your response. My thoughts on this would be along the lines of 
> proof of publication as this change only has the effect of stripping away 
> the executable portion of a script between 521 and 10_000 bytes or the 
> published data portion if > 10_000 bytes which the same data could likely 
> be published in chunked segments using outpoints.
> > 
> > Andrew Poelstra:
> > > Aside from proof-of-publication (i.e. data storage directly in the UTXO
> > > set) there is no usage of script which can't be equally (or better)
> > > accomplished by using a Segwit v0 or Taproot script.
> > 
> > This sums up the majority of future usecase concern
> > 
> > Anthony Towns:
> > > (If you restricted the change to only applying to scripts that used
> > non-push operators, that would probably still provide upgrade flexibility
> > while also preventing potential script abuses. But it wouldn't do 
> anything
> > to prevent publishing data)
> > 
> > Could this not be done as segments in multiple outpoints using a 
> coordination outpoint? I fail to see why publication proof must be in a 
> single chunk. This does though however bring another alternative to mind, 
> just making these outpoints unspendable but not invalidate the block 
> through inclusion...
> > 
> > > As far as the "but contiguous data will be regulated more strictly"
> > argument goes; I don't think "your honour, my offensive content has
> > strings of 4d0802 every 520 bytes
> > 
> > Correct, this was never meant to resolve this issue.
> > 
> > Luke Dashjr:
> > > If we're going this route, we should just close all the gaps for the 
> immediate future:
> > 
> > To put it nicely, this is completely beyond the scope of what is being 
> proposed.
> > 
> > Guus Ellenkamp:
> > > If there are really so few OP_RETURN outputs more than 144 bytes, then
> > why increase the limit if that change is so controversial? It seems
> > people who want to use a larger OP_RETURN size do it anyway, even with
> > the current default limits.
> > 
> > Completely off topic and irrelevant
> > 
> > Greg Tonoski:
> > > Limiting the maximum size of the scriptPubKey of a transaction to 67 
> bytes.
> > 
> > This leave no room to deal with broken hashing algorithms and very 
> little future upgradability for hooks. The rest of these points should be 
> merged with Lukes response and either hijack my thread or start a new one 
> with the increased scope, any approach I take will only be related to the 
> ScriptPubkey
> > 
> > Keagan McClelland:
> > > Hard NACK on capping the witness size as that would effectively ban 
> large scripts even in the P2SH wrapper which undermines Bitcoin's ability 
> to be an effectively programmable money.
> > 
> > This has nothing to do with the witness size or even the P2SH wrapper
> > 
> > Casey Rodarmor:
> > > I think that "Bitcoin could need it in the future?" might be a good 
> enough
> > reason not to do this.
> > 
> > > Script pubkeys are the only variable-length transaction fields which 
> can be
> > covered by input signatures, which might make them useful for future soft
> > forks. I can imagine confidential asset schemes or post-quantum coin 
> recovery
> > schemes requiring large proofs in the outputs, where the validity of the 
> proof
> > determined whether or not the transaction is valid, and thus require the
> > proofs to be in the outputs, and not just a hash commitment.
> > 
> > Would the ability to publish the data alone be enough? Example make the 
> output unspendable but allow for the existence of the bytes to be covered 
> through the signature?
> > 
> > 
> > Antoine Poinsot:
> > > Limiting the size of created scriptPubKeys is not a sufficient 
> mitigation on its own
> > I fail to see how this would not be sufficient? To DoS you need 2 things 
> inputs with ScriptPubkey redemptions + heavy op_codes that require unique 
> checks. Example DUPing stack element again and again doesn't work. This 
> then leads to the next part is you could get up to unique complex 
> operations with the current (n) limit included per input.
> > 
> > > One of the goal of BIP54 is to address objections to Matt's earlier 
> proposal, notably the (in my
> > opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
> Limiting the size of
> > scriptPubKeys would in this regard be moving in the opposite direction.
> > 
> > Some notes is I would actually go as far as to say the confiscation risk 
> is higher with the TX limit proposed in BIP54 as we actually have proof of 
> redemption of TXs that break that rule and the input set to do this already 
> exists on-chain no need to even wonder about the whole presigned. 
> bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
> > 
> > Please let me know if I am incorrect on any of this.
> > 
> > > Furthermore, it's always possible to get the biggest bang for our buck 
> in a first step
> > 
> > Agreed on bang for the buck regarding DoS.
> > 
> > My final point here would be that I would like to discuss more, and this 
> is response is from the initial view of your response and could be 
> incomplete or incorrect, This is just my in the moment response.
> > 
> > Antoine Riard:
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
> favor of prioritizing
> > a timewarp fix and limiting dosy spends by old redeem scripts
> > 
> > The idea of congestion control is interesting, but this solution should 
> significantly reduce the total DoS severity of known vectors.
> > 
> > On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
> > 
> > > Limits on block construction that cross transactions make it harder to 
> accurately estimate fees and greatly complicate optimal block 
> construction-- the latter being important because smarter and more computer 
> powered mining code generating higher profits is a pro centralization 
> factor.
> > > 
> > > In terms of effectiveness the "spam" will just make itself 
> indistinguishable from the most common transaction traffic from the 
> perspective of such metrics-- and might well drive up "spam" levels because 
> the higher embedding cost may make some of them use more transactions. The 
> competition for these buckets by other traffic could make it effectively a 
> block size reduction even against very boring ordinary transactions. ... 
> which is probably not what most people want.
> > > 
> > > I think it's important to keep in mind that bitcoin fee levels even at 
> 0.1s/vb are far beyond what other hosting services and other blockchains 
> cost-- so anyone still embedding data in bitcoin *really* want to be there 
> for some reason and aren't too fee sensitive or else they'd already be 
> using something else... some are even in favor of higher costs since the 
> high fees are what create the scarcity needed for their seigniorage.
> > > 
> > > But yeah I think your comments on priorities are correct.
> > > 
> > > 
> > > 
> > > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> 
> wrote:
> > > 
> > > > Hi list,
> > > > 
> > > > Thanks to the annex covered by the signature, I don't see how the 
> concern about limiting
> > > > the extensibility of bitcoin script with future (post-quantum) 
> cryptographic schemes.
> > > > Previous proposal of the annex were deliberately designed with 
> variable-length fields
> > > > to flexibly accomodate a wide range of things.
> > > > 
> > > > I believe there is one thing that has not been proposed to limit 
> unpredictable utterance
> > > > of spams on the blockchain, namely congestion control of categories 
> of outputs (e.g "fat"
> > > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey 
> and L a limiting
> > > > threshold for the number of T occurences during the period P. Beyond 
> the L threshold, any
> > > > additional T scriptpubkey is making the block invalid. Or 
> alternatively, any additional
> > > > T generating / spending transaction must pay some weight penalty...
> > > > 
> > > > Congestion control, which of course comes with its lot of 
> shenanigans, is not very a novel
> > > > idea as I believe it has been floated few times in the context of 
> lightning to solve mass
> > > > closure, where channels out-priced at current feerate would have 
> their safety timelocks scale
> > > > ups.
> > > > 
> > > > No need anymore to come to social consensus on what is quantitative 
> "spam" or not. The blockchain
> > > > would automatically throttle out the block space spamming 
> transaction. Qualitative spam it's another
> > > > question, for anyone who has ever read shannon's theory of 
> communication only effective thing can
> > > > be to limit the size of data payload. But probably we're kickly back 
> to a non-mathematically solvable
> > > > linguistical question again [0].
> > > > 
> > > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in 
> favor of prioritizing
> > > > a timewarp fix and limiting dosy spends by old redeem scripts, 
> rather than engaging in shooting
> > > > ourselves in the foot with ill-designed "spam" consensus mitigations.
> > > > 
> > > > [0] If you have a soul of logician, it would be an interesting 
> demonstration to come with
> > > > to establish that we cannot come up with mathematically or 
> cryptographically consensus means
> > > > to solve qualitative "spam", which in a very pure sense is a 
> linguistical issue.
> > > > 
> > > > Best,
> > > > Antoine
> > > > OTS hash: 
> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
> > > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a 
> écrit :
> > > > 
> > > > > Hi,
> > > > > 
> > > > > This approach was discussed last year when evaluating the best way 
> to mitigate DoS blocks in terms
> > > > > of gains compared to confiscatory surface. Limiting the size of 
> created scriptPubKeys is not a
> > > > > sufficient mitigation on its own, and has a non-trivial 
> confiscatory surface.
> > > > > 
> > > > > One of the goal of BIP54 is to address objections to Matt's 
> earlier proposal, notably the (in my
> > > > > opinion reasonable) confiscation concerns voiced by Russell 
> O'Connor. Limiting the size of
> > > > > scriptPubKeys would in this regard be moving in the opposite 
> direction.
> > > > > 
> > > > > Various approaches of limiting the size of spent scriptPubKeys 
> were discussed, in forms that would
> > > > > mitigate the confiscatory surface, to adopt in addition to (what 
> eventually became) the BIP54 sigops
> > > > > limit. However i decided against including this additional measure 
> in BIP54 because:
> > > > > - of the inherent complexity of the discussed schemes, which would 
> make it hard to reason about
> > > > > constructing transactions spending legacy inputs, and equally hard 
> to evaluate the reduction of
> > > > > the confiscatory surface;
> > > > > - more importantly, there is steep diminishing returns to piling 
> on more mitigations. The BIP54
> > > > > limit on its own prevents an externally-motivated attacker from 
> *unevenly* stalling the network
> > > > > for dozens of minutes, and a revenue-maximizing miner from 
> regularly stalling its competitions
> > > > > for dozens of seconds, at a minimized cost in confiscatory 
> surface. Additional mitigations reduce
> > > > > the worst case validation time by a smaller factor at a higher 
> cost in terms of confiscatory
> > > > > surface. It "feels right" to further reduce those numbers, but 
> it's less clear what the tangible
> > > > > gains would be.
> > > > > 
> > > > > Furthermore, it's always possible to get the biggest bang for our 
> buck in a first step and going the
> > > > > extra mile in a later, more controversial, soft fork. I previously 
> floated the idea of a "cleanup
> > > > > v2" in private discussions, and i think besides a reduction of the 
> maximum scriptPubKey size it
> > > > > should feature a consensus-enforced maximum transaction size for 
> the reasons stated here:
> > > > > 
> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
> I wouldn't hold my
> > > > > breath on such a "cleanup v2", but it may be useful to have it 
> documented somewhere.
> > > > > 
> > > > > I'm trying to not go into much details regarding which mitigations 
> were considered in designing
> > > > > BIP54, because they are tightly related to the design of various 
> DoS blocks. But i'm always happy to
> > > > > rehash the decisions made there and (re-)consider alternative 
> approaches on the semi-private Delving
> > > > > thread [0] dedicated to this purpose. Feel free to ping me to get 
> access if i know you.
> > > > > 
> > > > > Best,
> > > > > Antoine Poinsot
> > > > > 
> > > > > [0]: 
> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
> > > > > 
> > > > > 
> > > > > 
> > > > > 
> > > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
> fre...@reardencode.com> wrote:
> > > > > 
> > > > > >
> > > > > >
> > > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
> > > > > >
> > > > > > > But also given that there are essentially no violations and no 
> reason to
> > > > > > > expect any I'm not sure the proposal is worth time relative to 
> fixes of
> > > > > > > actual moderately serious DOS attack issues.
> > > > > >
> > > > > >
> > > > > > I believe this limit would also stop most (all?) of 
> PortlandHODL's
> > > > > > DoSblocks without having to make some of the other changes in 
> GCC. I
> > > > > > think it's worthwhile to compare this approach to those proposed 
> by
> > > > > > Antoine in solving these DoS vectors.
> > > > > >
> > > > > > Best,
> > > > > >
> > > > > > --Brandon
> > > > > >
> > > > > > --
> > > > > > You received this message because you are subscribed to the 
> Google Groups "Bitcoin Development Mailing List" group.
> > > > > > To unsubscribe from this group and stop receiving emails from 
> it, send an email to bitcoindev+...@googlegroups.com.
> > > > > > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
> > > > 
> > > > --
> > > > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > > > To unsubscribe from this group and stop receiving emails from it, 
> send an email to bitcoindev+...@googlegroups.com.
> > > 
> > > > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com
> .
> > 
> > --
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f4755fb6-b031-4c60-b304-f123ba2ff473n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 25830 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-27 19:56  0%       ` Greg Maxwell
  2025-10-28  5:13  0%         ` dathonohm via Bitcoin Development Mailing List
@ 2025-10-28  9:16  1%         ` /dev /fd0
  1 sibling, 0 replies; 200+ results
From: /dev /fd0 @ 2025-10-28  9:16 UTC (permalink / raw)
  To: Greg Maxwell; +Cc: Kyle Stout, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 9718 bytes --]

Hi Greg,

> There are also proposals such as BIP 337:
https://github.com/bitcoin/bips/blob/master/bip-0337.mediawiki  none of
these things are consensus changes-- many aren't even bippable because they
don't have interoperability considerations (e.g. representations on
disk/memory).

[Compression][0] of raw transactions is interesting although it won't be
helpful in this case. I had reviewed the pull request that implemented BIP
337 in bitcoin core and was closed. Maybe we can add it in knots.

> Forget for a moment the (un)likelyhood that the concerns being discussed
are meaningfully modulated by exactly how data is represented in p2p,
memory, rpc, disk, etc.. for assumption just assume they are.

> If so, the correct move would be to change those encodings rather than
any consensus rule change--- particularly because any consensus rule method
will simply be evaded, and can't provide the level of swizzling that
changing the encoding can accomplish.  Encoding changes are also
substantially non-coercive: people who think they're valuable can adopt
them and leave other people alone.

I am not sure if encoding or encryption would be the right approach but
this is worth trying. I have opened an [issue][1] in knots repository to
discuss these ideas and also created a web [page][2] that shows the binary
for OP_RETURN in a transaction.

[0[: https://github.com/bitcoin/bitcoin/pull/29134
[1]: https://github.com/bitcoinknots/bitcoin/issues/229
[2]: https://opreturn01.github.io/

/dev/fd0
floppy disk guy

On Tue, Oct 28, 2025 at 1:28 AM Greg Maxwell <gmaxwell@gmail.com> wrote:

> The only consensus normative data encoding in Bitcoin is the order data
> goes into hashes.  The representations in memory, rpc, in the p2p network,
> etc. are already different and could be made arbitrarily different without
> any consensus change.  Case in point:  the data is now normally encrypted
> on disk and in P2P.  There are also proposals such as BIP 337:
> https://github.com/bitcoin/bips/blob/master/bip-0337.mediawiki  none of
> these things are consensus changes-- many aren't even bippable because they
> don't have interoperability considerations (e.g. representations on
> disk/memory).
>
> Forget for a moment the (un)likelyhood that the concerns being discussed
> are meaningfully modulated by exactly how data is represented in p2p,
> memory, rpc, disk, etc.. for assumption just assume they are.
>
> If so, the correct move would be to change those encodings rather than any
> consensus rule change--- particularly because any consensus rule method
> will simply be evaded, and can't provide the level of swizzling that
> changing the encoding can accomplish.  Encoding changes are also
> substantially non-coercive: people who think they're valuable can adopt
> them and leave other people alone.
>
> Good news for everyone except those who consider coercing others to be a
> terminal goal.
>
>
>
> On Mon, Oct 27, 2025 at 6:35 PM Kyle Stout <kylestout85@gmail.com> wrote:
>
>> Dathon,
>>
>> > if Bitcoin provides an officially supported method of storing arbitrary
>> data (i.e., OP_RETURN), and the capacity of that method is large enough to
>> store hazardous content in a contiguous format (an increase to 100kB is
>> currently underway as Bitcoin Core 30 gains adoption), then one does not
>> need to misinterpret the data in order to view the content.
>>
>> This seems to be the crux of your argument. I believe it is misleading
>> and technically unsound. It's technical theater that creates a distinction
>> without any meaningful difference.
>>
>> First, Bitcoin has no concept of a file viewer. To interpret *any*
>> embedded data other to validate it against Bitcoin's rules, you must use a
>> third party tool. Practically speaking, the differences are negligible in
>> terms of technical difficulty, as humorously demonstrated here:
>> https://x.com/rot13maxi/status/1963318690759192622 . Contiguous or not,
>> you're file carving.
>>
>> Second, by definition, you're misinterpreting the data vis-a-vis Bitcoin
>> since it has no native concept of 'image', 'video', etc. Arbitrary bytes
>> are meaningless. The purpose of having OP_RETURN as a standard output is to
>> protect the UTXO set from being abused. It isn't some kind of 'blessing' to
>> store files. That's absurd. As you admit, it's impossible to stop people
>> from writing arbitrary bytes to the blockchain, so this is damage
>> mitigation, not an invitation.
>>
>> Third, contiguity is not a legally meaningful predicate. "Your honor, we
>> tried to limit the contiguous bytes!" is simply not going to fly. The bytes
>> exist either way, and they must be interpreted by third party software
>> either way. If anything, this path is going to represent a voluntary
>> self-policing that will result in more culpability. Right now, arbitrary
>> bytes don't mean anything in Bitcoin. If it's valid, it's valid. Nodes
>> relay opaque protocol data. If you insist on only accepting 'approved'
>> arbitrary bytes, you're opening the door to a knowledge/intent accusation.
>>
>> Regards,
>>
>> Kyle
>>
>>
>>
>> On Monday, October 27, 2025 at 1:36:33 AM UTC-4 dath...@proton.me wrote:
>>
>>> Peter -
>>>
>>> Thank you for demonstrating what non-contiguous data looks like.
>>>
>>> I trust you when you say that you can parse the BIP's contents from this
>>> transaction, but all it looks like to me (and the Bitcoin network) is a
>>> UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length
>>> OP_RETURN, sending all ~100 USD in fees to the miner.
>>>
>>> Since legally hazardous content can be generated from any input data,
>>> including your 30-input consolidation transaction (as long as the correct
>>> third-party program is used), it would not make sense to hold node
>>> operators legally responsible for storing and distributing such input data.
>>>
>>> However, if Bitcoin provides an officially supported method of storing
>>> arbitrary data (i.e., OP_RETURN), and the capacity of that method is large
>>> enough to store hazardous content in a contiguous format (an increase to
>>> 100kB is currently underway as Bitcoin Core 30 gains adoption), then one
>>> does not need to misinterpret the data in order to view the content. In
>>> that case, node operators could conceivably be held responsible for
>>> possession and distribution.
>>>
>>> Since arbitrary data storage does nothing to benefit Bitcoin as
>>> permissionless money, there is no good reason to force this additional
>>> legal risk on node operators, who already face enough challenges as it is.
>>>
>>> Best,
>>>
>>> Dathon
>>>
>>>
>>> On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <
>>> pe...@petertodd.org> wrote:
>>>
>>> > On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin
>>> Development Mailing List wrote:
>>> >
>>> > > Hi list -
>>> > >
>>> > > Due to Bitcoin Core v30 gaining in popularity, it has become
>>> necessary to move forward on luke-jr's ML proposal to temporarily limit
>>> arbitrary data at the consensus level, which so far has 3 weeks with no
>>> objections:
>>> > >
>>> > > https://github.com/bitcoin/bips/pull/2017
>>> >
>>> >
>>> > Transaction
>>> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
>>> > contains the full text of this BIP as of writing(1), while
>>> simultaneously being
>>> > compliant with that BIP.
>>> >
>>> > Clearly, this approach is ineffective.
>>> >
>>> > 1)
>>> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
>>> >
>>> > --
>>> > https://petertodd.org 'peter'[:-1]@petertodd.org
>>> >
>>> > --
>>> > You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> > To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>> > To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org.
>>>
>>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com
>> <https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQRQWwX76o8QHjt8FoLxJiq1B-FgP%2BpehOL8PYhWgewbg%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQRQWwX76o8QHjt8FoLxJiq1B-FgP%2BpehOL8PYhWgewbg%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALiT-ZrT%2BR7ApsQJOtKM5h5xTThGL-WMyCRDwt29sXmt4AA%2BRg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 12349 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-29 15:03  1%     ` 'Russell O'Connor' via Bitcoin Development Mailing List
@ 2025-10-29 16:10  1%       ` yes_please
  2025-10-30  2:10  1%         ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: yes_please @ 2025-10-29 16:10 UTC (permalink / raw)
  To: Russell O'Connor; +Cc: TokyoBitcoiner, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 6429 bytes --]

Hi all,

Perhaps we can find a meeting point if we focus on the max size of
OP_return ?
The increase from 83 to 100'000 bytes has been motivated as "probably we
will have to increase it again in the future, it requires energy and time
for code maintenance, so we'd rather increase it now to 100'000 bytes and
be done with it". While these are valid points, the unknown consequences
that might manifest with such a drastic increase all at once may not be the
most prudent approach.
Considering also that "the canary in the coal mine", namely Citrea use
case, requires only 144 bytes to utilize op_return instead of more harmful
ways, the increase to 100'000 bytes appears disproportionate given the
circumstances, and again non-prudent enough (which is what I suspect is
creating most of the debate at hand).

caucasianjazz12

On Wed, Oct 29, 2025 at 4:38 PM 'Russell O'Connor' via Bitcoin Development
Mailing List <bitcoindev@googlegroups.com> wrote:

> On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com>
> wrote:
>
>> Questions reacting to text in reply of Russell O'Connor:
>>
>>    - *" there exist some protocols that require":*
>>       - Which protocols?
>>
>> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I don't
> know anything about their protocol beyond that.
>
>
>>
>>    -
>>       - Why does bitcoin need to cater to their needs?
>>
>> If we don't support these in OP_RETURNs, Citrea, and other folks like
> them, will use something like bare multisigs instead, which will be a
> little more expensive for them and much more expensive for every other
> Bitcoin node operator on the planet because those (likely) unspendable UTXO
> will have to remain in the UTXO set forever because they will be
> indistinguishable from legitimate bare multisigs.
>
>>
>>    -
>>       - Do we cater to any protocol that comes along?
>>          - How do we choose which to enable, and which to discourage?
>>
>> Clamping down on OP_RETURNs won't discourage the use of these Citrea-like
> protocols.  Instead it will encourage them to instead use uncensorable
> publication channels such as bare multisigs, which will bloat the UTXO set
> and drive up costs for every Bitcoin node operator on the planet.
>
>>
>>    - *"the folks using these protocols will simply have no choice"*:
>>       - Did we *force* them to use bitcoin for their project?
>>       - It sounds like "if you don't change the code to enable my
>>       project, I will be forced to trash your project." Is this wrong?
>>
>> By "force" I mean in the sense that when a recent KDE upgrade dropped the
> ability to specify some command to be run whenever the screen is locked,
> KDE "forced" me to write a systemd service to run dbus-monitor to watch for
> screen locking events instead.  Fortunately, in the case of KDE, being
> "forced" to work around their changes only makes my life worse.  However in
> the case of limiting OP_RETURNs, users who are "forced" to find workarounds
> for their proof of publication protocols  will ultimately lead to them
> using the uncensorable data channel of bare-multisigs, or similar, which
> have consequences not only for themselves but every other Bitcoin node
> operator on the planet.
>
> It is specifically the externalities caused by the bare-multisig
> workaround that we need to address. If these externalities didn't exist,
> then I, and presumably others, wouldn't care so much.
>
>>
>>    - *"any attempt to cap OP_RETURN outputs will force those users"*:
>>       - Again, *force* is a form of coercion. Is the bitcoin code with
>>       it's current setting *forcing* anyone to do anything?
>>       - Are the external protocol designers the victims here?
>>
>> The victims will be every node operator on the planet who has to deal
> with the unprunable UTXO bloat caused by users posting their
> proof-of-publication data via the uncensorable bare-multisig avenue.  This
> collective cost will actually be much higher than the cost to the external
> protocol designers who only have to pay a few more pennies for their
> transactions.
>
>
>>
>>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>>       - What problem?
>>
>> The problem is a combination of protocols that require using
> proof-of-publication choosing to use uncensorable bare-multisigs instead,
> and/or, so long as this proposal isn't adopted, the problem of users
> bypassing the network to get their OP_RETURN transactions mined which leads
> to poor quality block reconstruction and poor quality fee estimates and the
> like.
>
>>
>>    -
>>       - Is the bitcoin code responsible for fulfilling the needs of an
>>       external project or protocol?
>>          - If yes, why?
>>
>> Again the victims here wouldn't be the external protocol designers.  They
> will just pay the extra pennies to publish using bare-multisig.  The
> victims would be every Bitcoin node operator on the planet.  And while the
> core developers have no warranties or responsibilities attached to their
> open source code, I think we would agree that "costs borne by every Bitcoin
> node operator on the planet", is something they ought to bear in mind in
> their work.
>
>
>>
>> I hope you will take these questions seriously. I really want to
>> understand your thinking.
>>
>
> Hope this helps.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAPDT2SSC4p97xpDUKGE%2BwsRe3vw1%3D1q6-72UJHvzMPoTau7A7g%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8742 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] Re: By: Doctorbuzz1 {GitHub} Limit "Bulk Dust" with a default filter or consensus.
  2025-10-30  0:03  3% [bitcoindev] By: Doctorbuzz1 {GitHub} Limit "Bulk Dust" with a default filter or consensus Frenchanfry
@ 2025-10-30  1:02  0% ` Doctor Buzz
  2025-10-30 14:14  1%   ` Doctor Buzz
  0 siblings, 1 reply; 200+ results
From: Doctor Buzz @ 2025-10-30  1:02 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 11086 bytes --]

Thanks!  I came here to post it myself.  I just want to point out that it's 
awfully discouraging for a GitHub mod to "close" my 90% developed code, 
asking me to post it elsewhere... but anyway!

Original GitHub post here:
https://github.com/bitcoin/bitcoin/issues/33737#issuecomment-3465288829

The first concept of this with static definition of a "tiny" Tx was posted 
here (with no responses):  
https://bitcoin.stackexchange.com/questions/129139/would-a-bulk-dust-relay-consensus-rule-limiting-100-sub-1-000-sat-outputs-p

Pastebin code probably looks better here than what I can see in the OP of 
this thread:  https://pastebin.com/9qdQCH83
On Wednesday, October 29, 2025 at 7:47:08 PM UTC-5 Frenchanfry wrote:

> A proposal on GitHub I found Highly interesting and a better improvement, 
> dealing with spammers/congestion.
>
> I’m exploring a potential default filter or consensus-level rule (since a 
> large number of people believe that default filters don't work) to 
> discourage UTXO-bloat patterns without touching Script, witness data, or 
> the block size limit.
>
> The idea is to target “bulk dust” transactions — those that create large 
> numbers of extremely small outputs — which are the main cause of long-term 
> UTXO set growth.
>
> These types of "bulk dust" transactions have been the No. 1 reason cited 
> for wanting to expand the default OP_RETURN limit... and removing that 
> limit obviously influenced BIP 444. So it appears to me that there is 
> overwhelming majority support for limiting these types of "bulk dust" 
> transactions, as they do present a legitimate concern for node runners.
>
> Concept
>
> Flag a transaction as “bulk dust” if:
>
>    - It has >=100 outputs each below a dynamically defined TinyTx 
>    threshold, and
>    - Those tiny outputs make up >=60% of all outputs in the transaction.
>
> When flagged, it would be considered nonstandard (relay policy) or invalid 
> (if soft-forked into consensus).
>
> TinyTx threshold (dynamic halving schedule)
>
> I originally considered a constant definition of what was a "tiny" Tx to 
> be 1,000 sats... but some might still just use 1,001 sats, right? Plus 
> there very likely will be a time where there is a valid use-case of >100 
> outputs under 1,000 sats.
>
> Rather than fixing the “tiny” threshold to a constant like 1,000 sats, the 
> rule defines it as a decreasing function of block height, starting high and 
> gradually tightening over time.
>
>    - Starts at 4096 sats when activated (target ~2028).
>    - Halves every 210,000 blocks (~4 years).
>    - Never falls below 1 sat (hard floor).
>
> Year ---- Block Height -- TinyTx Threshold
> 2028 --- ~activation ---- 4096 sats
> 2032 --- ~1,260,000 ---- 2048 sats
> 2036 --- ~1,470,000 ---- 1024 sats
> 2040 --- ~1,680,000 ---- 512 sats
> … -- every 210,000 blocks -- … until 1 sat floor
>
> This gradual halving ensures the definition of "tiny" stays relevant as 
> Bitcoin’s value rises.
> For example, if 1 sat = $1 someday, having 100 outputs worth <1,000 sats 
> each would no longer represent spam — but rather normal payments.
> By then, the TinyTx limit would already have adjusted down automatically.
>
> Patterns this would limit
>
>    - Fake pubkeys or scripts used to embed data via many UTXOs
>    - Bitcoin STAMPS / UTXO-art spreading payloads across thousands of 
>    dust outputs
>    - BRC-20 batch mints with 100s of "tiny" sat fan-outs
>    - Some Ordinal or state inscription schemes that distribute data 
>    across many tiny outputs
>    - Dust bombing (UTXO tracking or chain spam)
>    - Mass micro-airdrops below the "tiny" sat range
>
> These use cases rely on cheap, numerous outputs — making them several 
> times more costly under this rule.
>
> Non-goals / unaffected
>
>    - Normal user transactions, LN channel opens, and multisig spends
>    - Batched exchange payouts (they typically have > 40% large-value 
>    outputs)
>    - Single/few-output inscriptions using witness data (not affected)
>    - Any legitimate pattern where most outputs are above the threshold
>
> Why a ratio and a count?
>
> Requiring both (tiny_count >= 100) and (tiny_ratio >= 60%) helps avoid 
> false positives, such as legitimate custodial payouts or consolidation 
> transactions with mixed values.
> It specifically filters transactions that are mostly dust, rather than 
> merely containing some.
>
> Inquiry
>
>    - Are there credible, non-spam use cases that truly require >=100 
>    sub-4k-sat outputs (or equivalent at later eras) and a >=60% tiny ratio?
>    - Could this affect fee market behavior or any privacy tools in 
>    unintended ways?
>    - Any concern with the 100 tiny_count limit or 60% tiny_ratio?
>    - Any other unintended consequences?
>    - Any objections in general?? What are they?
>
> Intent
>
> This proposal doesn’t censor any monetary transaction or prevent 
> inscriptions; it simply prices storage according to resource cost.
> It keeps the chain “light and nimble” for everyday payments while allowing 
> future flexibility — because the TinyTx definition decreases automatically 
> in line with halvings and Bitcoin’s long-term value growth.
>
> CODE SKETCHES
> (with minimal syntax highlighting here: https://pastebin.com/9qdQCH83)
>
> RELAY POLICY FILTER sketch —
> // Place in src/policy/policy.cpp, and call from within IsStandardTx() 
> before returning: // if (IsBulkDust(tx, reason)) // return false; // reject 
> as nonstandard // 
> ========================================================================================================== 
> bool IsBulkDust(const CTransaction& tx, std::string& reason) { static 
> constexpr int MAX_TINY_OUTPUTS = 100; // >=100 tiny outputs triggers ratio 
> check static constexpr double TINY_RATIO_THRESHOLD = 0.6; // >=60% of all 
> outputs tiny → reject static constexpr CAmount BASE_TINY_THRESHOLD = 4096; 
> // starting tiny threshold (sats) static constexpr int64_t 
> FIRST_TINY_HALVING_H = 1260000; // first halving of tiny threshold static 
> constexpr int64_t HALVING_INTERVAL = 210000; // blocks per subsequent 
> halving static constexpr CAmount MIN_TINY_FLOOR = 1; // never below 1 sat 
> const int total = tx.vout.size(); if (total == 0) return false; int 
> currentHeight = chainActive.Tip() ? chainActive.Tip()->nHeight : 0; // Era 
> index for TinyTx threshold, anchored at FIRST_TINY_HALVING_H (not subsidy 
> eras) int era = 0; if (currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
> static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
> HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; // 
> halve per era if (tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; 
> int tiny = 0; for (const auto& out : tx.vout) { if (out.nValue < 
> tinyThresh) ++tiny; } if (tiny >= MAX_TINY_OUTPUTS && 
> (static_cast<double>(tiny) / total) >= TINY_RATIO_THRESHOLD) { reason = 
> strprintf("too-many-tiny-outputs(%d of %d, %.2f%%, tiny<%d)", tiny, total, 
> 100.0 * tiny / total, tinyThresh); return true; // flag as bulk dust 
> (nonstandard) } return false; } 
>
> CONSENSUS (soft-fork, hybrid activation) sketch —
> // Helpers in src/consensus/tx_check.cpp; activation/enforcement in 
> src/validation.cpp // Also define deployment in: src/consensus/params.h, 
> src/chainparams.cpp, src/versionbits.* // 
> ========================================================================================================== 
> // ----------------------------------------------------------------------- 
> // --- In src/consensus/tx_check.cpp (helper only; no params needed) --- // 
> ----------------------------------------------------------------------- 
> static constexpr CAmount BASE_TINY_THRESHOLD = 4096; static constexpr 
> int64_t FIRST_TINY_HALVING_H = 1260000; static constexpr int64_t 
> HALVING_INTERVAL = 210000; static constexpr int MAX_TINY_OUTPUTS = 100; 
> static constexpr double TINY_RATIO_THRESHOLD = 0.6; static constexpr 
> CAmount MIN_TINY_FLOOR = 1; bool IsBulkDust(const CTransaction& tx, int 
> currentHeight) // expose via tx_check.h if needed { const int total = 
> tx.vout.size(); if (total == 0) return false; int era = 0; if 
> (currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
> static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
> HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; if 
> (tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; int tiny = 0; 
> for (const auto& out : tx.vout) { if (out.nValue < tinyThresh) ++tiny; } if 
> (tiny >= MAX_TINY_OUTPUTS && (static_cast<double>(tiny) / total) >= 
> TINY_RATIO_THRESHOLD) return true; return false; } // 
> ----------------------------------------------------------------------- // 
> --- In src/validation.cpp (enforcement with hybrid activation) --- // 
> ----------------------------------------------------------------------- 
> #include <consensus/tx_check.h> #include <versionbits.h> const 
> Consensus::Params& params = chainparams.GetConsensus(); int currentHeight = 
> chainActive.Tip() ? chainActive.Tip()->nHeight : 0; const bool 
> bulk_dust_active = DeploymentActiveAtTip(params, 
> Consensus::DEPLOYMENT_BULK_DUST_LIMIT) || (currentHeight >= 
> params.BulkDustActivationHeight); if (bulk_dust_active) { if 
> (IsBulkDust(tx, currentHeight)) { return 
> state.Invalid(TxValidationResult::TX_CONSENSUS, "too-many-tiny-outputs"); } 
> } // 
> ----------------------------------------------------------------------- // 
> --- In src/consensus/params.h --- // 
> ----------------------------------------------------------------------- 
> enum DeploymentPos { // ... DEPLOYMENT_BULK_DUST_LIMIT, 
> MAX_VERSION_BITS_DEPLOYMENTS }; struct Params { // ... int 
> BulkDustActivationHeight; // height flag-day fallback }; // 
> ----------------------------------------------------------------------- // 
> --- In src/chainparams.cpp (per-network values; examples only) --- // 
> ----------------------------------------------------------------------- 
> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].bit = 12; 
> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nStartTime = 
> 1767225600; // 2026-01-01 UTC 
> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nTimeout = 
> 1838160000; // 2028-04-01 UTC 
> consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].min_activation_height 
> = 969696; consensus.BulkDustActivationHeight = 1021021; // flag-day fallback
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/71b4d969-8c0d-4ff2-a177-244aa86ca57an%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 26267 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] By: Doctorbuzz1 {GitHub} Limit "Bulk Dust" with a default filter or consensus.
@ 2025-10-30  0:03  3% Frenchanfry
  2025-10-30  1:02  0% ` [bitcoindev] " Doctor Buzz
  0 siblings, 1 reply; 200+ results
From: Frenchanfry @ 2025-10-30  0:03 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 10004 bytes --]

A proposal on GitHub I found Highly interesting and a better improvement, 
dealing with spammers/congestion.

I’m exploring a potential default filter or consensus-level rule (since a 
large number of people believe that default filters don't work) to 
discourage UTXO-bloat patterns without touching Script, witness data, or 
the block size limit.

The idea is to target “bulk dust” transactions — those that create large 
numbers of extremely small outputs — which are the main cause of long-term 
UTXO set growth.

These types of "bulk dust" transactions have been the No. 1 reason cited 
for wanting to expand the default OP_RETURN limit... and removing that 
limit obviously influenced BIP 444. So it appears to me that there is 
overwhelming majority support for limiting these types of "bulk dust" 
transactions, as they do present a legitimate concern for node runners.

Concept

Flag a transaction as “bulk dust” if:

   - It has >=100 outputs each below a dynamically defined TinyTx 
   threshold, and
   - Those tiny outputs make up >=60% of all outputs in the transaction.

When flagged, it would be considered nonstandard (relay policy) or invalid 
(if soft-forked into consensus).

TinyTx threshold (dynamic halving schedule)

I originally considered a constant definition of what was a "tiny" Tx to be 
1,000 sats... but some might still just use 1,001 sats, right? Plus there 
very likely will be a time where there is a valid use-case of >100 outputs 
under 1,000 sats.

Rather than fixing the “tiny” threshold to a constant like 1,000 sats, the 
rule defines it as a decreasing function of block height, starting high and 
gradually tightening over time.

   - Starts at 4096 sats when activated (target ~2028).
   - Halves every 210,000 blocks (~4 years).
   - Never falls below 1 sat (hard floor).

Year ---- Block Height -- TinyTx Threshold
2028 --- ~activation ---- 4096 sats
2032 --- ~1,260,000 ---- 2048 sats
2036 --- ~1,470,000 ---- 1024 sats
2040 --- ~1,680,000 ---- 512 sats
… -- every 210,000 blocks -- … until 1 sat floor

This gradual halving ensures the definition of "tiny" stays relevant as 
Bitcoin’s value rises.
For example, if 1 sat = $1 someday, having 100 outputs worth <1,000 sats 
each would no longer represent spam — but rather normal payments.
By then, the TinyTx limit would already have adjusted down automatically.

Patterns this would limit

   - Fake pubkeys or scripts used to embed data via many UTXOs
   - Bitcoin STAMPS / UTXO-art spreading payloads across thousands of dust 
   outputs
   - BRC-20 batch mints with 100s of "tiny" sat fan-outs
   - Some Ordinal or state inscription schemes that distribute data across 
   many tiny outputs
   - Dust bombing (UTXO tracking or chain spam)
   - Mass micro-airdrops below the "tiny" sat range

These use cases rely on cheap, numerous outputs — making them several times 
more costly under this rule.

Non-goals / unaffected

   - Normal user transactions, LN channel opens, and multisig spends
   - Batched exchange payouts (they typically have > 40% large-value 
   outputs)
   - Single/few-output inscriptions using witness data (not affected)
   - Any legitimate pattern where most outputs are above the threshold

Why a ratio and a count?

Requiring both (tiny_count >= 100) and (tiny_ratio >= 60%) helps avoid 
false positives, such as legitimate custodial payouts or consolidation 
transactions with mixed values.
It specifically filters transactions that are mostly dust, rather than 
merely containing some.

Inquiry

   - Are there credible, non-spam use cases that truly require >=100 
   sub-4k-sat outputs (or equivalent at later eras) and a >=60% tiny ratio?
   - Could this affect fee market behavior or any privacy tools in 
   unintended ways?
   - Any concern with the 100 tiny_count limit or 60% tiny_ratio?
   - Any other unintended consequences?
   - Any objections in general?? What are they?

Intent

This proposal doesn’t censor any monetary transaction or prevent 
inscriptions; it simply prices storage according to resource cost.
It keeps the chain “light and nimble” for everyday payments while allowing 
future flexibility — because the TinyTx definition decreases automatically 
in line with halvings and Bitcoin’s long-term value growth.

CODE SKETCHES
(with minimal syntax highlighting here: https://pastebin.com/9qdQCH83)

RELAY POLICY FILTER sketch —
// Place in src/policy/policy.cpp, and call from within IsStandardTx() 
before returning: // if (IsBulkDust(tx, reason)) // return false; // reject 
as nonstandard // 
========================================================================================================== 
bool IsBulkDust(const CTransaction& tx, std::string& reason) { static 
constexpr int MAX_TINY_OUTPUTS = 100; // >=100 tiny outputs triggers ratio 
check static constexpr double TINY_RATIO_THRESHOLD = 0.6; // >=60% of all 
outputs tiny → reject static constexpr CAmount BASE_TINY_THRESHOLD = 4096; 
// starting tiny threshold (sats) static constexpr int64_t 
FIRST_TINY_HALVING_H = 1260000; // first halving of tiny threshold static 
constexpr int64_t HALVING_INTERVAL = 210000; // blocks per subsequent 
halving static constexpr CAmount MIN_TINY_FLOOR = 1; // never below 1 sat 
const int total = tx.vout.size(); if (total == 0) return false; int 
currentHeight = chainActive.Tip() ? chainActive.Tip()->nHeight : 0; // Era 
index for TinyTx threshold, anchored at FIRST_TINY_HALVING_H (not subsidy 
eras) int era = 0; if (currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; // 
halve per era if (tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; 
int tiny = 0; for (const auto& out : tx.vout) { if (out.nValue < 
tinyThresh) ++tiny; } if (tiny >= MAX_TINY_OUTPUTS && 
(static_cast<double>(tiny) / total) >= TINY_RATIO_THRESHOLD) { reason = 
strprintf("too-many-tiny-outputs(%d of %d, %.2f%%, tiny<%d)", tiny, total, 
100.0 * tiny / total, tinyThresh); return true; // flag as bulk dust 
(nonstandard) } return false; } 

CONSENSUS (soft-fork, hybrid activation) sketch —
// Helpers in src/consensus/tx_check.cpp; activation/enforcement in 
src/validation.cpp // Also define deployment in: src/consensus/params.h, 
src/chainparams.cpp, src/versionbits.* // 
========================================================================================================== 
// ----------------------------------------------------------------------- 
// --- In src/consensus/tx_check.cpp (helper only; no params needed) --- // 
----------------------------------------------------------------------- 
static constexpr CAmount BASE_TINY_THRESHOLD = 4096; static constexpr 
int64_t FIRST_TINY_HALVING_H = 1260000; static constexpr int64_t 
HALVING_INTERVAL = 210000; static constexpr int MAX_TINY_OUTPUTS = 100; 
static constexpr double TINY_RATIO_THRESHOLD = 0.6; static constexpr 
CAmount MIN_TINY_FLOOR = 1; bool IsBulkDust(const CTransaction& tx, int 
currentHeight) // expose via tx_check.h if needed { const int total = 
tx.vout.size(); if (total == 0) return false; int era = 0; if 
(currentHeight >= FIRST_TINY_HALVING_H) { era = 1 + 
static_cast<int>((currentHeight - FIRST_TINY_HALVING_H) / 
HALVING_INTERVAL); } CAmount tinyThresh = BASE_TINY_THRESHOLD >> era; if 
(tinyThresh < MIN_TINY_FLOOR) tinyThresh = MIN_TINY_FLOOR; int tiny = 0; 
for (const auto& out : tx.vout) { if (out.nValue < tinyThresh) ++tiny; } if 
(tiny >= MAX_TINY_OUTPUTS && (static_cast<double>(tiny) / total) >= 
TINY_RATIO_THRESHOLD) return true; return false; } // 
----------------------------------------------------------------------- // 
--- In src/validation.cpp (enforcement with hybrid activation) --- // 
----------------------------------------------------------------------- 
#include <consensus/tx_check.h> #include <versionbits.h> const 
Consensus::Params& params = chainparams.GetConsensus(); int currentHeight = 
chainActive.Tip() ? chainActive.Tip()->nHeight : 0; const bool 
bulk_dust_active = DeploymentActiveAtTip(params, 
Consensus::DEPLOYMENT_BULK_DUST_LIMIT) || (currentHeight >= 
params.BulkDustActivationHeight); if (bulk_dust_active) { if 
(IsBulkDust(tx, currentHeight)) { return 
state.Invalid(TxValidationResult::TX_CONSENSUS, "too-many-tiny-outputs"); } 
} // 
----------------------------------------------------------------------- // 
--- In src/consensus/params.h --- // 
----------------------------------------------------------------------- 
enum DeploymentPos { // ... DEPLOYMENT_BULK_DUST_LIMIT, 
MAX_VERSION_BITS_DEPLOYMENTS }; struct Params { // ... int 
BulkDustActivationHeight; // height flag-day fallback }; // 
----------------------------------------------------------------------- // 
--- In src/chainparams.cpp (per-network values; examples only) --- // 
----------------------------------------------------------------------- 
consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].bit = 12; 
consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nStartTime = 
1767225600; // 2026-01-01 UTC 
consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].nTimeout = 
1838160000; // 2028-04-01 UTC 
consensus.vDeployments[Consensus::DEPLOYMENT_BULK_DUST_LIMIT].min_activation_height 
= 969696; consensus.BulkDustActivationHeight = 1021021; // flag-day fallback

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/b0dee827-c2fe-4a68-9b41-f1447ba3c1d3n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 26631 bytes --]

^ permalink raw reply	[relevance 3%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-28  5:13  0%         ` dathonohm via Bitcoin Development Mailing List
@ 2025-10-30  0:31  0%           ` Antoine Riard
    0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2025-10-30  0:31 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 12245 bytes --]

Hi Dathon Ohm,

I did a cursory review of your BIP proposal, not on the technical matter as 
there
is no reference implementation available, but I did one on the legalities 
raised
in the text (grep'ing the word "legal" one can find 15 references versus 
only 2
references to the word "technical").

Under European law, there is a clearly established line of jurisprudences 
exonerating
internet service providers or hosting operators to have to install a system 
for
filtering all electronic communications passing via its services which would
apply indiscriminately to all its users for any kind of content (CJUE, 
24-11-2011,
aff C-70/10 Scarlet Extended SA c/ SABAM, CJUE, 16-02-2012, aff C-260/10 
SABAM c/ Netlog).
Rather to engage in generic filtering on the burden of services providers, 
courts
have generally yielded decisions asking for fine-grained deletion of a 
specific content,
as a safeguard of other interest at stake, notably users's right to privacy 
[0].

Further, in the eventuality of an extended filtering system would have to 
be put
in place by a service provider, and if said filtering system design would 
be unable
to dissociate between legal content and illegal content, the introduction 
of this
filtering system would consistute an infringement of the freedom of 
expression and
information (CJUE, 26-04-2022, aff C‑401/19). Those judicial decisions are 
litteraly
encompassing peer-to-peer softwares in their scope, as somehow before 
Bitcoin, they
was something called Bittorent.

Moreover, this line of jurisprudence underlights that any interference with 
one's
fundamental right of expression should be lay down under clear and precise 
rules
governing the scope of the interference. This is not a mere formality, as 
again
and again too restrictives measures are strike down (CEDH, 02-02-2016, 
Index.hu/Hungary,
aff. n° 22947/13). As far as I know, I'm not aware of any European 
continental
country that has made a legislation on how one is allowed to use his right 
to
the freedom of expression in the context of publishing stuff in a Bitcoin 
block.

Under the US law, I won't risk making legal comment for now, as for anyone 
who is
following the work of the Electronic Frontier Foundation from times to 
times, there
is a pending case in front of the US Supreme Court, Cox Communications, Inc 
vs. Sony
Music Entertainment specifically on the liability of Internet service 
providers. But
culturally the US are even more protective on the freedom of expression, 
which puts
an even higher legal bar for any restriction of it.

I concur with Gregory Maxwell. There is zero need to change the consensus 
rules.

In the idea one would like to limit one's responsability arising from how 
bitcoin
consensus data can be encoded or decoded to "obviously" "illegal" content 
(as strictly
defined by a specific national legislation) [1], fuzzy encoders and 
decoders for
end-to-end or point-to-point communication could be formalized as BIP 
documents,
that would put an asymmetric cost on the decoders, with the upper bound 
being the
impossibility of decoding.

Fuzzy algorithms is not sci-fi tech it's actually what is used for 
Minisketch.

Best,
Antoine
OTS hash: f0e10776d4e4d32873ca319daf3b76c8e645a0d510a6bb803bb8685292c119d4

[0] "Those addresses are protected personal data because they allow those 
users to be precisely identified"
[1] This is not a mere technicality, under information theory, one could 
come up with
a alphanumeric encoding algorithm that could certainly yield text-based 
religious blaspheme
in a lot of countries in the world from years-old un-reorgable historical 
blockchain data.
We're all used to "The Times 03 Jan..." in the genesis block, but it's just 
picking hex
as a decoding algorithm...

Le mardi 28 octobre 2025 à 05:14:47 UTC, dath...@proton.me a écrit :

> Hi list -
>
> Thanks for all of the feedback everyone!
>
> I am working on a new draft of the BIP that will hopefully address 
> everyone's concerns and avoid the misunderstandings that have arisen.
>
> I apologize for not being able to respond to all of you, but know that I 
> did indeed read your messages.
>
> Best,
>
> Dathon
> On Monday, October 27th, 2025 at 1:58 PM, Greg Maxwell <gmax...@gmail.com> 
> wrote:
>
> The only consensus normative data encoding in Bitcoin is the order data 
> goes into hashes. The representations in memory, rpc, in the p2p network, 
> etc. are already different and could be made arbitrarily different without 
> any consensus change. Case in point: the data is now normally encrypted on 
> disk and in P2P. There are also proposals such as BIP 337: 
> https://github.com/bitcoin/bips/blob/master/bip-0337.mediawiki none of 
> these things are consensus changes-- many aren't even bippable because they 
> don't have interoperability considerations (e.g. representations on 
> disk/memory).
>
> Forget for a moment the (un)likelyhood that the concerns being discussed 
> are meaningfully modulated by exactly how data is represented in p2p, 
> memory, rpc, disk, etc.. for assumption just assume they are.
>
> If so, the correct move would be to change those encodings rather than any 
> consensus rule change--- particularly because any consensus rule method 
> will simply be evaded, and can't provide the level of swizzling that 
> changing the encoding can accomplish. Encoding changes are also 
> substantially non-coercive: people who think they're valuable can adopt 
> them and leave other people alone.
>
> Good news for everyone except those who consider coercing others to be a 
> terminal goal. 
>
>
>
> On Mon, Oct 27, 2025 at 6:35 PM Kyle Stout <kyles...@gmail.com> wrote:
>
>> Dathon,
>>
>> > if Bitcoin provides an officially supported method of storing arbitrary 
>> data (i.e., OP_RETURN), and the capacity of that method is large enough to 
>> store hazardous content in a contiguous format (an increase to 100kB is 
>> currently underway as Bitcoin Core 30 gains adoption), then one does not 
>> need to misinterpret the data in order to view the content.
>>
>> This seems to be the crux of your argument. I believe it is misleading 
>> and technically unsound. It's technical theater that creates a distinction 
>> without any meaningful difference.
>>
>> First, Bitcoin has no concept of a file viewer. To interpret *any* 
>> embedded data other to validate it against Bitcoin's rules, you must use a 
>> third party tool. Practically speaking, the differences are negligible in 
>> terms of technical difficulty, as humorously demonstrated here: 
>> https://x.com/rot13maxi/status/1963318690759192622 . Contiguous or not, 
>> you're file carving. 
>>
>> Second, by definition, you're misinterpreting the data vis-a-vis Bitcoin 
>> since it has no native concept of 'image', 'video', etc. Arbitrary bytes 
>> are meaningless. The purpose of having OP_RETURN as a standard output is to 
>> protect the UTXO set from being abused. It isn't some kind of 'blessing' to 
>> store files. That's absurd. As you admit, it's impossible to stop people 
>> from writing arbitrary bytes to the blockchain, so this is damage 
>> mitigation, not an invitation.
>>
>> Third, contiguity is not a legally meaningful predicate. "Your honor, we 
>> tried to limit the contiguous bytes!" is simply not going to fly. The bytes 
>> exist either way, and they must be interpreted by third party software 
>> either way. If anything, this path is going to represent a voluntary 
>> self-policing that will result in more culpability. Right now, arbitrary 
>> bytes don't mean anything in Bitcoin. If it's valid, it's valid. Nodes 
>> relay opaque protocol data. If you insist on only accepting 'approved' 
>> arbitrary bytes, you're opening the door to a knowledge/intent accusation.
>>
>> Regards,
>>
>> Kyle
>>
>>
>>
>> On Monday, October 27, 2025 at 1:36:33 AM UTC-4 dath...@proton.me wrote:
>>
>>> Peter - 
>>>
>>> Thank you for demonstrating what non-contiguous data looks like. 
>>>
>>> I trust you when you say that you can parse the BIP's contents from this 
>>> transaction, but all it looks like to me (and the Bitcoin network) is a 
>>> UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length 
>>> OP_RETURN, sending all ~100 USD in fees to the miner. 
>>>
>>> Since legally hazardous content can be generated from any input data, 
>>> including your 30-input consolidation transaction (as long as the correct 
>>> third-party program is used), it would not make sense to hold node 
>>> operators legally responsible for storing and distributing such input data. 
>>>
>>> However, if Bitcoin provides an officially supported method of storing 
>>> arbitrary data (i.e., OP_RETURN), and the capacity of that method is large 
>>> enough to store hazardous content in a contiguous format (an increase to 
>>> 100kB is currently underway as Bitcoin Core 30 gains adoption), then one 
>>> does not need to misinterpret the data in order to view the content. In 
>>> that case, node operators could conceivably be held responsible for 
>>> possession and distribution. 
>>>
>>> Since arbitrary data storage does nothing to benefit Bitcoin as 
>>> permissionless money, there is no good reason to force this additional 
>>> legal risk on node operators, who already face enough challenges as it is. 
>>>
>>> Best, 
>>>
>>> Dathon 
>>>
>>>
>>> On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <
>>> pe...@petertodd.org> wrote: 
>>>
>>> > On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin 
>>> Development Mailing List wrote: 
>>> > 
>>> > > Hi list - 
>>> > > 
>>> > > Due to Bitcoin Core v30 gaining in popularity, it has become 
>>> necessary to move forward on luke-jr's ML proposal to temporarily limit 
>>> arbitrary data at the consensus level, which so far has 3 weeks with no 
>>> objections: 
>>> > > 
>>> > > https://github.com/bitcoin/bips/pull/2017 
>>> > 
>>> > 
>>> > Transaction 
>>> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c 
>>> > contains the full text of this BIP as of writing(1), while 
>>> simultaneously being 
>>> > compliant with that BIP. 
>>> > 
>>> > Clearly, this approach is ineffective. 
>>> > 
>>> > 1) 
>>> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki 
>>> > 
>>> > -- 
>>> > https://petertodd.org 'peter'[:-1]@petertodd.org 
>>> > 
>>> > -- 
>>> > You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group. 
>>> > To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com. 
>>> > To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org. 
>>>
>>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com
>> .
>>
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQRQWwX76o8QHjt8FoLxJiq1B-FgP%2BpehOL8PYhWgewbg%40mail.gmail.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f07bc89c-fcf0-4e3c-85ab-593a509c1265n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 18233 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] segOP potential BIP discussion
@ 2025-10-29 23:40  1% defenwycke
  2025-10-30 21:25  2% ` [bitcoindev] " defenwycke
  0 siblings, 1 reply; 200+ results
From: defenwycke @ 2025-10-29 23:40 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 13060 bytes --]

Hi all,

I attempted to propose a BIP earlier today. I was notified of my incorrect 
actions versus core procedures.

See attached or below - my proposal for discussion.

Regards

Defenwycke.

---

A proposed discussion of segOP
Author: Defenwycke / defenwycke@icloud.com
29.10.2025

segOP (Segregated OP_RETURN)

    A proposed extension to Bitcoin transactions. It introduces a 
dedicated, structured, full-fee data lane for on-chain data, without 
disrupting existing transaction rules. Think of it like this - segOP is to 
arbitrary data what SegWit was to signatures — a clean, isolated, 
forward-compatible path that preserves old-node harmony while restoring fee 
fairness.

Abstract:

    segOP defines a new segregated data section for Bitcoin transactions, 
cryptographically committed via OP_SUCCESS184. It standardizes on-chain 
metadata storage by enforcing full fees, structured TLV encoding, and a 100 
KB cap, while remaining backward-compatible with legacy nodes.

It is not:

    - A replacement for OP_RETURN
    - An off-chain mechanism
    - A hard fork

It is:

    - A soft-fork-safe, future-proof, SegWit-style data section
    - Full-fee (4 weight units per byte)
    - Structured (TLV + Merkle-root verified)
    - Limited to 100 KB per transaction

What issues could segOP rectify?:

    1. Ordinals abuse witness discount. segOP will apply full fee rate for 
large data.
    2. No structured metadata lane. segOP introduces TLV-encoded + 
Merkle-verified section.
    3. Witness discount abused for megabytes. segOP Enforces 100 KB cap.
    4. OP_RETURN unstructured & limited. segOP = structured + verifiable.
    5. Spam cheap storage. segOP deters spam with fees.

    In short - segOP restores fairness — data pays its real weight cost, 
preserving block space for financial use.

Where segOP lives:

    Transaction Layout (Post-segOP)
    Transaction
    ├── nVersion
    ├── vin (inputs)
    ├── vout (outputs)
    │   └── P2SOP Output ← segOP anchor
    ├── witness (if any)
    ├── segOP marker (0xFA)
    ├── segOP section (if present)
    │   ├── chunk_count (varint)
    │   ├── TLV chunk 1
    │   ├── TLV chunk 2
    │   └── ...
    └── nLockTime

Activation rules:

    - segOP section only appears if at least one P2SOP output exists.
    - Old nodes ignore unknown post-witness data → transaction valid 
(soft-fork safe).
    - New nodes validate the segOP section against the Merkle root in the 
P2SOP output.

How segOP works:

    segOP extends the Bitcoin transaction format by adding a new optional 
section after the witness field.
    This section is linked cryptographically to a special output type — the 
P2SOP output — whose script commits to the Merkle root of the segOP data.

    The design mirrors SegWit: a segregated data structure, excluded from 
txid but included in wtxid, ensuring backward compatibility.

        1. Transaction Creation

            When a wallet or protocol wants to include on-chain structured 
data (for example, a document hash, timestamp, or proof set), it performs 
the following steps:

                a. Build TLV Chunks

                    Each data element is encoded in Type-Length-Value (TLV) 
format:

                        - type (varint)
                        - length (varint)
                        - value (bytes)

                    Each type defines a data meaning (e.g., type=1: 
manifest, type=2: payload, type=3: metadata, etc.). This allows future 
extensions without breaking parsers.

                b. Construct the Merkle Tree

                    Each TLV is hashed as:

                    leaf = dsha256(0x00 || TLV)
                    and combined recursively:
                    node = dsha256(0x01 || left || right)

                    until a single Merkle root is produced. This root 
uniquely commits to all TLV data while allowing compact partial proofs.

                c. Commit to the Root (P2SOP Output)

                    The wallet then inserts a special output into the 
transaction: scriptPubKey = OP_SUCCESS184 0x20 <32-byte Merkle root> 
(OP_SUCCESS184 is reserved for soft-fork activation).
                    Legacy nodes treat it as “always true,” so the 
transaction remains spendable under pre-segOP rules.
                    The 32-byte push commits to the root of the segOP 
section.
                    Multiple P2SOP outputs may exist if a transaction 
carries multiple data trees, but each must be validated independently.

                d. Serialize the segOP Section

                    After the witness data, a segOP marker (0xFA) signals 
presence, followed by the serialized data:

                    0xFA
                    varint: chunk_count
                    [TLV #1]
                    [TLV #2]
                    ...

                    This section is included in the wtxid but not the txid, 
keeping legacy hashes unchanged (soft-fork compatible).

        2. Transaction Relay and Policy

            segOP transactions are relayed like any other, with a few 
policy rules:

                - Size limit: The total size of segOP data (plus OP_RETURN 
+ witness data >520 B) must not exceed 100,000 bytes. This prevents block 
bloat.
                - Fee treatment: segOP data counts at 4 weight units per 
byte (no discount), restoring parity between data and signatures.
                - Standardness check: Non-mining nodes enforce segOP as a 
standard policy rule (like SegWit’s P2WSH), rejecting noncompliant data 
from mempool relay.

                These are policy rules, not consensus, but miners enforcing 
them makes segOP behavior uniform across the network.

        3. Validation (Node-Level)

            When a segOP transaction reaches a full node, validation 
happens in three stages:

                a. Detect segOP Presence

                    - If any output script begins with OP_SUCCESS184, the 
node checks for a corresponding segOP section at the end of the transaction 
serialization.
                    - If no segOP section is found → transaction invalid 
under segOP rules.

                b. Verify Size and Fee

                    The node computes total data size:
                        - All OP_RETURN payloads
                        - All segOP TLVs
                        - All witness items >520 bytes (these count as 
“data”)
                        - If this exceeds 100 KB, the transaction is 
invalid.
                        - The total weight is adjusted to include all segOP 
bytes at full cost.

                c. Verify Merkle Root

                    - The node rebuilds the TLV Merkle tree and ensures:
                    - calculated_root == <root in P2SOP output>
                    - If the root mismatches → reject.
                    - This makes segOP cryptographically bound to the 
transaction body, just like Taproot commits to script paths.

        4. Inclusion in a Block

            - Miners include segOP transactions normally.
            - When calculating block weight: segOP bytes count fully (4 
WU/byte).
            - segOP does not alter the legacy 4M weight limit but competes 
fairly for space.
            - Miners can optionally expose segOP data through RPC or 
indexing APIs (e.g., gettxoutdata), similar to how they expose witness data.

        5. Verification by Light Clients

            - Because segOP uses a Merkle structure: SPV clients or oracles 
can request proofs for individual TLVs without downloading full data. For 
example, a timestamp verifier can request: getsegopproof <txid> 
<chunk_type> and receive the TLV + Merkle proof + root verification path. 
This makes segOP efficient for decentralized proof storage or timestamping 
protocols.

        6. Spending a P2SOP Output

            - Spending a P2SOP output works like spending an OP_SUCCESS 
output: Until activation, it behaves as anyone-can-spend, ensuring 
soft-fork safety. After activation, future consensus rules can restrict or 
redefine P2SOP redemption scripts.
            - Example forward path: A future BIP may define OP_SUCCESS184 
redemption to require proof of segOP validity or special conditions (e.g., 
hash preimage commitments). Until then, nodes treat these outputs as valid 
spends, ensuring no forks.

        7. Post-Activation Behavior

            - After segOP activation: All upgraded nodes enforce the 100 KB 
cap and Merkle root validation.
            - Legacy nodes still accept the transactions, unaware of segOP 
structure.
            - Any mismatch between segOP section and root simply makes the 
tx invalid for upgraded miners — thus ensuring consensus alignment.

Examples of segOP:

    Example 1: Timestamp a Document (50 KB)
        TLV #1: Type = 1, Manifest (JSON)
        TLV #2: Type = 2, PDF payload (50 KB)
        Build Merkle root → abc123...
        Create output:
        OP_SUCCESS184 0x20 abc123...
        segOP section:
        0x02  # chunk count
        <TLV1> <TLV2>
        Fee: ≈ $30 at current full-fee rates
        Permanent, verifiable, structured.

    Example 2: Ordinals Tries 3.8 MB
        data_size = 3.8 MB → REJECTED (exceeds 100 KB cap)
        Attempt in witness → REJECTED (data > 520 B → full fee policy → cap 
still enforced)

    Example 3: Normal BTC Send
        No P2SOP output : No segOP section
        Fee Unchanged (~$0.09)
        Normal transactions unaffected.

How to Use segOP:

    Build a segOP Transaction (Python)

        # 1. Prepare TLV chunks
        manifest = b'{"type":"proof","size":50000}'
        payload  = b'50 KB of data...'
        tlv1 = varint(1) + varint(len(manifest)) + manifest
        tlv2 = varint(2) + varint(len(payload)) + payload

        # 2. Build Merkle root
        def dsha256(x): return sha256(sha256(x)).digest()
        leaf1 = dsha256(b'\x00' + tlv1)
        leaf2 = dsha256(b'\x00' + tlv2)
        root  = dsha256(b'\x01' + leaf1 + leaf2)

        # 3. Create P2SOP output
        p2sop = b'\xb8\x20' + root

        # 4. Build segOP section
        segop = b'\xFA' + varint(2) + tlv1 + tlv2  # 0xFA marker

        # 5. Attach to tx
        tx.vout.append(CTxOut(0, CScript(p2sop)))
        tx.segop_section = segop

    Validation Logic (C++ Pseudocode):

        bool CheckSegOP(const CTransaction& tx) {
            size_t total_data = 0;

            for (const auto& out : tx.vout) {
                if (out.scriptPubKey[0] == OP_SUCCESS184) {
                    // segOP output detected
                    if (!tx.HasSegOPSection()) return false;
                    total_data += tx.segOPSectionSize();
                }
                if (out.scriptPubKey[0] == OP_RETURN && 
out.scriptPubKey.size() > 1) {
                    total_data += out.scriptPubKey.size() - 1;
                }
            }

            for (const auto& in : tx.vin) {
                for (const auto& item : in.scriptWitness.stack) {
                    if (item.size() > 520)
                        total_data += item.size(); // witness data counts 
fully
                }
            }

            if (total_data > 100000) return false; // 100 KB consensus cap

            // Apply full weight to data for fee calc
            tx.virtual_size += total_data;
            return true;
        }

Soft Fork Proof:

    - Old node: Ignores segOP
    - New node: Validates segOP
    - No chain split
    - Backward compatible
    - Miner-activated soft fork possible via versionbits

Developer Q&A:

    Where is segOP serialized? : After witness, before nLockTime
    Does it affect txid? : No - only wtxid
    Can old nodes parse it? : Yes (ignored like witness)
    Max size? : 100 KB total data
    Fee rate? : Full fee (4 WU/byte)
    Can I use OP_RETURN too? : Yes — total combined data ≤ 100 KB
    Future extensions? : TLV unknown types ignored (safe forward-compat)
    How do I signal presence? : 0xFA marker after witness


Conclusion:

    - On-chain
    - Structured (TLV + Merkle)
    - Full-fee and fair
    - Soft-fork safe
    - Future-proof

    segOP introduces the clean, capped, verifiable data lane Bitcoin needs 
— ending witness discount abuse while preserving freedom for legitimate 
metadata.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c38d00f7-a42b-4f7b-899e-11e823a43d7dn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 57496 bytes --]

[-- Attachment #2: A proposed discussion of segOP.txt --]
[-- Type: text/plain, Size: 12339 bytes --]

A proposed discussion of segOP
Author: Defenwycke / defenwycke@icloud.com
29.10.2025

segOP (Segregated OP_RETURN)

    A proposed extension to Bitcoin transactions. It introduces a dedicated, structured, full-fee data lane for on-chain data, without disrupting existing transaction rules. Think of it like this - segOP is to arbitrary data what SegWit was to signatures — a clean, isolated, forward-compatible path that preserves old-node harmony while restoring fee fairness.

Abstract:

    segOP defines a new segregated data section for Bitcoin transactions, cryptographically committed via OP_SUCCESS184. It standardizes on-chain metadata storage by enforcing full fees, structured TLV encoding, and a 100 KB cap, while remaining backward-compatible with legacy nodes.

It is not:

    - A replacement for OP_RETURN
    - An off-chain mechanism
    - A hard fork

It is:

    - A soft-fork-safe, future-proof, SegWit-style data section
    - Full-fee (4 weight units per byte)
    - Structured (TLV + Merkle-root verified)
    - Limited to 100 KB per transaction

What issues could segOP rectify?:

    1. Ordinals abuse witness discount. segOP will apply full fee rate for large data.
    2. No structured metadata lane. segOP introduces TLV-encoded + Merkle-verified section.
    3. Witness discount abused for megabytes. segOP	Enforces 100 KB cap.
    4. OP_RETURN unstructured & limited. segOP = structured + verifiable.
    5. Spam cheap storage. segOP deters spam with fees.

    In short - segOP restores fairness — data pays its real weight cost, preserving block space for financial use.

Where segOP lives:

    Transaction Layout (Post-segOP)
    Transaction
    ├── nVersion
    ├── vin (inputs)
    ├── vout (outputs)
    │   └── P2SOP Output ← segOP anchor
    ├── witness (if any)
    ├── segOP marker (0xFA)
    ├── segOP section (if present)
    │   ├── chunk_count (varint)
    │   ├── TLV chunk 1
    │   ├── TLV chunk 2
    │   └── ...
    └── nLockTime

Activation rules:

    - segOP section only appears if at least one P2SOP output exists.
    - Old nodes ignore unknown post-witness data → transaction valid (soft-fork safe).
    - New nodes validate the segOP section against the Merkle root in the P2SOP output.

How segOP works:

    segOP extends the Bitcoin transaction format by adding a new optional section after the witness field.
    This section is linked cryptographically to a special output type — the P2SOP output — whose script commits to the Merkle root of the segOP data.

    The design mirrors SegWit: a segregated data structure, excluded from txid but included in wtxid, ensuring backward compatibility.

        1. Transaction Creation

            When a wallet or protocol wants to include on-chain structured data (for example, a document hash, timestamp, or proof set), it performs the following steps:

                a. Build TLV Chunks

                    Each data element is encoded in Type-Length-Value (TLV) format:

                        - type (varint)
                        - length (varint)
                        - value (bytes)

                    Each type defines a data meaning (e.g., type=1: manifest, type=2: payload, type=3: metadata, etc.). This allows future extensions without breaking parsers.

                b. Construct the Merkle Tree

                    Each TLV is hashed as:

                    leaf = dsha256(0x00 || TLV)
                    and combined recursively:
                    node = dsha256(0x01 || left || right)

                    until a single Merkle root is produced. This root uniquely commits to all TLV data while allowing compact partial proofs.

                c. Commit to the Root (P2SOP Output)

                    The wallet then inserts a special output into the transaction: scriptPubKey = OP_SUCCESS184 0x20 <32-byte Merkle root> (OP_SUCCESS184 is reserved for soft-fork activation).
                    Legacy nodes treat it as “always true,” so the transaction remains spendable under pre-segOP rules.
                    The 32-byte push commits to the root of the segOP section.
                    Multiple P2SOP outputs may exist if a transaction carries multiple data trees, but each must be validated independently.

                d. Serialize the segOP Section

                    After the witness data, a segOP marker (0xFA) signals presence, followed by the serialized data:

                    0xFA
                    varint: chunk_count
                    [TLV #1]
                    [TLV #2]
                    ...

                    This section is included in the wtxid but not the txid, keeping legacy hashes unchanged (soft-fork compatible).

        2. Transaction Relay and Policy

            segOP transactions are relayed like any other, with a few policy rules:

                - Size limit: The total size of segOP data (plus OP_RETURN + witness data >520 B) must not exceed 100,000 bytes. This prevents block bloat.
                - Fee treatment: segOP data counts at 4 weight units per byte (no discount), restoring parity between data and signatures.
                - Standardness check: Non-mining nodes enforce segOP as a standard policy rule (like SegWit’s P2WSH), rejecting noncompliant data from mempool relay.

                These are policy rules, not consensus, but miners enforcing them makes segOP behavior uniform across the network.

        3. Validation (Node-Level)

            When a segOP transaction reaches a full node, validation happens in three stages:

                a. Detect segOP Presence

                    - If any output script begins with OP_SUCCESS184, the node checks for a corresponding segOP section at the end of the transaction serialization.
                    - If no segOP section is found → transaction invalid under segOP rules.

                b. Verify Size and Fee

                    The node computes total data size:
                        - All OP_RETURN payloads
                        - All segOP TLVs
                        - All witness items >520 bytes (these count as “data”)
                        - If this exceeds 100 KB, the transaction is invalid.
                        - The total weight is adjusted to include all segOP bytes at full cost.

                c. Verify Merkle Root

                    - The node rebuilds the TLV Merkle tree and ensures:
                    - calculated_root == <root in P2SOP output>
                    - If the root mismatches → reject.
                    - This makes segOP cryptographically bound to the transaction body, just like Taproot commits to script paths.

        4. Inclusion in a Block

            - Miners include segOP transactions normally.
            - When calculating block weight: segOP bytes count fully (4 WU/byte).
            - segOP does not alter the legacy 4M weight limit but competes fairly for space.
            - Miners can optionally expose segOP data through RPC or indexing APIs (e.g., gettxoutdata), similar to how they expose witness data.

        5. Verification by Light Clients

            - Because segOP uses a Merkle structure: SPV clients or oracles can request proofs for individual TLVs without downloading full data. For example, a timestamp verifier can request: getsegopproof <txid> <chunk_type> and receive the TLV + Merkle proof + root verification path. This makes segOP efficient for decentralized proof storage or timestamping protocols.

        6. Spending a P2SOP Output

            - Spending a P2SOP output works like spending an OP_SUCCESS output: Until activation, it behaves as anyone-can-spend, ensuring soft-fork safety. After activation, future consensus rules can restrict or redefine P2SOP redemption scripts.
            - Example forward path: A future BIP may define OP_SUCCESS184 redemption to require proof of segOP validity or special conditions (e.g., hash preimage commitments). Until then, nodes treat these outputs as valid spends, ensuring no forks.

        7. Post-Activation Behavior

            - After segOP activation: All upgraded nodes enforce the 100 KB cap and Merkle root validation.
            - Legacy nodes still accept the transactions, unaware of segOP structure.
            - Any mismatch between segOP section and root simply makes the tx invalid for upgraded miners — thus ensuring consensus alignment.

Examples of segOP:

    Example 1: Timestamp a Document (50 KB)
        TLV #1: Type = 1, Manifest (JSON)
        TLV #2: Type = 2, PDF payload (50 KB)
        Build Merkle root → abc123...
        Create output:
        OP_SUCCESS184 0x20 abc123...
        segOP section:
        0x02  # chunk count
        <TLV1> <TLV2>
        Fee: ≈ $30 at current full-fee rates
        Permanent, verifiable, structured.

    Example 2: Ordinals Tries 3.8 MB
        data_size = 3.8 MB → REJECTED (exceeds 100 KB cap)
        Attempt in witness → REJECTED (data > 520 B → full fee policy → cap still enforced)

    Example 3: Normal BTC Send
        No P2SOP output	: No segOP section
        Fee	Unchanged (~$0.09)
        Normal transactions unaffected.

How to Use segOP:

    Build a segOP Transaction (Python)

        # 1. Prepare TLV chunks
        manifest = b'{"type":"proof","size":50000}'
        payload  = b'50 KB of data...'
        tlv1 = varint(1) + varint(len(manifest)) + manifest
        tlv2 = varint(2) + varint(len(payload)) + payload

        # 2. Build Merkle root
        def dsha256(x): return sha256(sha256(x)).digest()
        leaf1 = dsha256(b'\x00' + tlv1)
        leaf2 = dsha256(b'\x00' + tlv2)
        root  = dsha256(b'\x01' + leaf1 + leaf2)

        # 3. Create P2SOP output
        p2sop = b'\xb8\x20' + root

        # 4. Build segOP section
        segop = b'\xFA' + varint(2) + tlv1 + tlv2  # 0xFA marker

        # 5. Attach to tx
        tx.vout.append(CTxOut(0, CScript(p2sop)))
        tx.segop_section = segop

    Validation Logic (C++ Pseudocode):

        bool CheckSegOP(const CTransaction& tx) {
            size_t total_data = 0;

            for (const auto& out : tx.vout) {
                if (out.scriptPubKey[0] == OP_SUCCESS184) {
                    // segOP output detected
                    if (!tx.HasSegOPSection()) return false;
                    total_data += tx.segOPSectionSize();
                }
                if (out.scriptPubKey[0] == OP_RETURN && out.scriptPubKey.size() > 1) {
                    total_data += out.scriptPubKey.size() - 1;
                }
            }

            for (const auto& in : tx.vin) {
                for (const auto& item : in.scriptWitness.stack) {
                    if (item.size() > 520)
                        total_data += item.size(); // witness data counts fully
                }
            }

            if (total_data > 100000) return false; // 100 KB consensus cap

            // Apply full weight to data for fee calc
            tx.virtual_size += total_data; 
            return true;
        }

Soft Fork Proof:

    - Old node: Ignores segOP
    - New node: Validates segOP
    - No chain split
    - Backward compatible
    - Miner-activated soft fork possible via versionbits

Developer Q&A:

    Where is segOP serialized? : After witness, before nLockTime
    Does it affect txid? : No - only wtxid
    Can old nodes parse it?	: Yes (ignored like witness)
    Max size? : 100 KB total data
    Fee rate? : Full fee (4 WU/byte)
    Can I use OP_RETURN too? : Yes — total combined data ≤ 100 KB
    Future extensions? : TLV unknown types ignored (safe forward-compat)
    How do I signal presence? : 0xFA marker after witness


Conclusion:

    - On-chain
    - Structured (TLV + Merkle)
    - Full-fee and fair
    - Soft-fork safe
    - Future-proof

    segOP introduces the clean, capped, verifiable data lane Bitcoin needs — ending witness discount abuse while preserving freedom for legitimate metadata.



^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-29  9:39  1%   ` TokyoBitcoiner
@ 2025-10-29 15:03  1%     ` 'Russell O'Connor' via Bitcoin Development Mailing List
  2025-10-29 16:10  1%       ` yes_please
  0 siblings, 1 reply; 200+ results
From: 'Russell O'Connor' via Bitcoin Development Mailing List @ 2025-10-29 15:03 UTC (permalink / raw)
  To: TokyoBitcoiner, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 4730 bytes --]

On Wed, Oct 29, 2025 at 5:45 AM TokyoBitcoiner <arthurmyer@gmail.com> wrote:

> Questions reacting to text in reply of Russell O'Connor:
>
>    - *" there exist some protocols that require":*
>       - Which protocols?
>
> Citrea’s Clementine bridge, which needs 144 bytes for zk-proofs.  I don't
know anything about their protocol beyond that.


>
>    -
>       - Why does bitcoin need to cater to their needs?
>
> If we don't support these in OP_RETURNs, Citrea, and other folks like
them, will use something like bare multisigs instead, which will be a
little more expensive for them and much more expensive for every other
Bitcoin node operator on the planet because those (likely) unspendable UTXO
will have to remain in the UTXO set forever because they will be
indistinguishable from legitimate bare multisigs.

>
>    -
>       - Do we cater to any protocol that comes along?
>          - How do we choose which to enable, and which to discourage?
>
> Clamping down on OP_RETURNs won't discourage the use of these Citrea-like
protocols.  Instead it will encourage them to instead use uncensorable
publication channels such as bare multisigs, which will bloat the UTXO set
and drive up costs for every Bitcoin node operator on the planet.

>
>    - *"the folks using these protocols will simply have no choice"*:
>       - Did we *force* them to use bitcoin for their project?
>       - It sounds like "if you don't change the code to enable my
>       project, I will be forced to trash your project." Is this wrong?
>
> By "force" I mean in the sense that when a recent KDE upgrade dropped the
ability to specify some command to be run whenever the screen is locked,
KDE "forced" me to write a systemd service to run dbus-monitor to watch for
screen locking events instead.  Fortunately, in the case of KDE, being
"forced" to work around their changes only makes my life worse.  However in
the case of limiting OP_RETURNs, users who are "forced" to find workarounds
for their proof of publication protocols  will ultimately lead to them
using the uncensorable data channel of bare-multisigs, or similar, which
have consequences not only for themselves but every other Bitcoin node
operator on the planet.

It is specifically the externalities caused by the bare-multisig workaround
that we need to address. If these externalities didn't exist, then I, and
presumably others, wouldn't care so much.

>
>    - *"any attempt to cap OP_RETURN outputs will force those users"*:
>       - Again, *force* is a form of coercion. Is the bitcoin code with
>       it's current setting *forcing* anyone to do anything?
>       - Are the external protocol designers the victims here?
>
> The victims will be every node operator on the planet who has to deal with
the unprunable UTXO bloat caused by users posting their
proof-of-publication data via the uncensorable bare-multisig avenue.  This
collective cost will actually be much higher than the cost to the external
protocol designers who only have to pay a few more pennies for their
transactions.


>
>    - *"Bitcoin Core 30 is *fixing* an existing problem"*:
>       - What problem?
>
> The problem is a combination of protocols that require using
proof-of-publication choosing to use uncensorable bare-multisigs instead,
and/or, so long as this proposal isn't adopted, the problem of users
bypassing the network to get their OP_RETURN transactions mined which leads
to poor quality block reconstruction and poor quality fee estimates and the
like.

>
>    -
>       - Is the bitcoin code responsible for fulfilling the needs of an
>       external project or protocol?
>          - If yes, why?
>
> Again the victims here wouldn't be the external protocol designers.  They
will just pay the extra pennies to publish using bare-multisig.  The
victims would be every Bitcoin node operator on the planet.  And while the
core developers have no warranties or responsibilities attached to their
open source code, I think we would agree that "costs borne by every Bitcoin
node operator on the planet", is something they ought to bear in mind in
their work.


>
> I hope you will take these questions seriously. I really want to
> understand your thinking.
>

Hope this helps.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAMZUoK%3DuAxX_UGb7MBJZubiNWuHza4E1eKbiW7cG21%2BDg%2Bi3uA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 6657 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-28 17:38  2% ` 'Russell O'Connor' via Bitcoin Development Mailing List
@ 2025-10-29  9:39  1%   ` TokyoBitcoiner
  2025-10-29 15:03  1%     ` 'Russell O'Connor' via Bitcoin Development Mailing List
  0 siblings, 1 reply; 200+ results
From: TokyoBitcoiner @ 2025-10-29  9:39 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 7916 bytes --]

Questions reacting to text in reply of Russell O'Connor:

   - *" there exist some protocols that require":* 
      - Which protocols? 
      - Why does bitcoin need to cater to their needs? 
      - Do we cater to any protocol that comes along?
         - How do we choose which to enable, and which to discourage?
      - *"the folks using these protocols will simply have no choice"*: 
      - Did we *force* them to use bitcoin for their project? 
      - It sounds like "if you don't change the code to enable my project, 
      I will be forced to trash your project." Is this wrong?
   - *"any attempt to cap OP_RETURN outputs will force those users"*: 
      - Again, *force* is a form of coercion. Is the bitcoin code with it's 
      current setting *forcing* anyone to do anything? 
      - Are the external protocol designers the victims here?
   - *"Bitcoin Core 30 is *fixing* an existing problem"*: 
      - What problem? 
      - Is the bitcoin code responsible for fulfilling the needs of an 
      external project or protocol? 
         - If yes, why?
      

I hope you will take these questions seriously. I really want to understand 
your thinking.

On Wednesday, October 29, 2025 at 4:18:06 AM UTC+9 Russell O'Connor wrote:

> This proposal isn't a compromise at all.
>
> The entire problem was kicked off by noting that there exist some 
> protocols that require the revealing of data that is somewhat longer than 
> 80 bytes long (on the order of hundreds of bytes if I recall correctly).  
> If we cap the OP_RETURN outputs to 80 bytes and 1 per transaction, the 
> folks using these protocols will simply have no choice but to instead place 
> their data for publication into bare multisig outputs.  This outcome would 
> be objectively worse for everyone involved.  The protocol users will have 
> to pay someone higher fees.  Everyone's UTXO sets will be bloated with 
> these unspendable transactions, and, unlike with OP_RETURN, there will be 
> no way to decide which bare multisigs are being used as a poor man's 
> bulletin board, and which ones are legitimate.
>
> In fact, any attempt to cap OP_RETURN outputs will force those users to 
> use bare multisigs instead, or perhaps use non OP_RETURN methods, such as 
> OP_O OP_VERIFY, or whatever, which would be just worse for everyone 
> involved.
>
> Bitcoin Core 30 is *fixing* an existing problem, and trying to roll things 
> back would unsolve the problem.  In fact, such a softfork would make the 
> problem much worse by transforming a block reconstruction problem into a 
> deliberate push towards having user who need to publish data into using 
> uncensorable bare multisig outputs instead.
>
> On Tue, Oct 28, 2025 at 12:09 PM Majorian <major...@gmail.com> wrote:
>
>> Dear Bitcoin Development Mailing List,
>>
>> I hope this email finds you well. I am Majorian, and I've been active in 
>> the bitcoin space since 2017. 
>>
>> I'm not a programmer or technical expert by any means; I'm just someone 
>> who has seen Bitcoin evolve over the years and wants to see it thrive 
>> without unnecessary division.
>>
>> I'm writing today to propose a simple compromise that I believe could 
>> help bridge the gap between the various sides in the ongoing controversies 
>> in the Bitcoin community following Core 30's release.
>>
>> As many of you know, these debates have created a rift in the community. 
>> My proposal isn't aimed at fully solving broader issues—that's a bigger 
>> challenge requiring more comprehensive solutions. Instead, it seeks to 
>> return Bitcoin to the de facto operational state it has maintained for over 
>> a decade, where OP_RETURN has been used sparingly and responsibly for 
>> metadata. The core goal is to codify at the consensus level the historical 
>> node relay norms that have guided Bitcoin's operation effectively for 
>> years, elevating these longstanding practices from policy to enforceable 
>> rules to ensure consistency and stability across the network.The 
>> Proposal: OP_RETURN Cap Soft ForkI suggest a backwards-compatible soft 
>> fork that introduces the following consensus rules:
>>    
>>    - Cap OP_RETURN data size at 83 bytes: This aligns closely with 
>>    historical norms (e.g., the 80-byte standard relay policy) This means that 
>>    OP_RETURN can be at most 83 bytes: 1 byte for the opcode, 1-2 bytes for the 
>>    data push, and 80 bytes of data. By enforcing this at consensus, we simply 
>>    make permanent the relay standards that nodes have followed in practice for 
>>    much of Bitcoin's history.
>>    - Limit to 1 OP_RETURN output per transaction: This ensures 
>>    transactions adhere to traditional patterns, reducing potential abuse 
>>    without disrupting standard usage.
>>
>> This approach codifies the proven, historical relay policies into 
>> consensus rules, preserving Bitcoin's operational heritage.Why This 
>> Compromise?
>>    
>>    - Simplicity: The rules are straightforward to implement and verify, 
>>    with minimal code changes required.
>>    - Bridging the Divide: It addresses concerns of new attack vectors by 
>>    tightening OP_RETURN usage to match historical norms, while being agnostic 
>>    on 'spam.'
>>    - Apolitical and Restorative: This proposal is deliberately 
>>    apolitical, aiming simply to return Bitcoin to the state it was in roughly 
>>    a few weeks ago, before recent debates intensified. It takes no sides 
>>    regarding specific implementations like Core, Knots, or others. While large 
>>    OP_RETURNs have been possible at the consensus level for a long time, 
>>    they've seldom been used in this manner until very recently. By capping 
>>    them, we principally address concerns about OP_RETURN being used as an 
>>    attack vector on Bitcoin, codifying the relay norms that have kept such 
>>    usage in check.
>>    - Plausible Deniability: Enforcing these limits provides plausible 
>>    deniability, declaring firmly that Bitcoin is not designed or intended as a 
>>    peer-to-peer file sharing and storage protocol in the context of OP_RETURN. 
>>    This might be somewhat controversial, but I am including this anyway.
>>    - Community Healing: By focusing on a modest, consensus-building 
>>    change, we can hopefully repair the current rift and refocus on bitcoin's 
>>    future.
>>
>> If this idea gains traction on the list, I'd love to see it formalized as 
>> a Bitcoin Improvement Proposal (BIP). I'm not equipped to write the code 
>> myself, but I can contribute to the discussion and help rally community 
>> support. What do you all think? Is this a viable middle ground? Are 
>> there technical pitfalls I'm missing? Feedback from experts like you would 
>> be invaluable. 
>>
>> Thank you for your time and dedication to Bitcoin.
>>
>> Best regards,
>> Majorian
>>
>> -- 
>>
> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/0f35a624-92bd-4bdb-933b-a6fb28b91bd0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 17560 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-28 16:01  2% [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies Majorian
  2025-10-28 16:37  1% ` Martin Habovštiak
  2025-10-28 16:50  5% ` Erik Aronesty
@ 2025-10-28 17:38  2% ` 'Russell O'Connor' via Bitcoin Development Mailing List
  2025-10-29  9:39  1%   ` TokyoBitcoiner
  2 siblings, 1 reply; 200+ results
From: 'Russell O'Connor' via Bitcoin Development Mailing List @ 2025-10-28 17:38 UTC (permalink / raw)
  To: Majorian, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 6452 bytes --]

This proposal isn't a compromise at all.

The entire problem was kicked off by noting that there exist some protocols
that require the revealing of data that is somewhat longer than 80 bytes
long (on the order of hundreds of bytes if I recall correctly).  If we cap
the OP_RETURN outputs to 80 bytes and 1 per transaction, the folks using
these protocols will simply have no choice but to instead place their data
for publication into bare multisig outputs.  This outcome would be
objectively worse for everyone involved.  The protocol users will have to
pay someone higher fees.  Everyone's UTXO sets will be bloated with these
unspendable transactions, and, unlike with OP_RETURN, there will be no way
to decide which bare multisigs are being used as a poor man's
bulletin board, and which ones are legitimate.

In fact, any attempt to cap OP_RETURN outputs will force those users to use
bare multisigs instead, or perhaps use non OP_RETURN methods, such as OP_O
OP_VERIFY, or whatever, which would be just worse for everyone involved.

Bitcoin Core 30 is *fixing* an existing problem, and trying to roll things
back would unsolve the problem.  In fact, such a softfork would make the
problem much worse by transforming a block reconstruction problem into a
deliberate push towards having user who need to publish data into using
uncensorable bare multisig outputs instead.

On Tue, Oct 28, 2025 at 12:09 PM Majorian <majorianbtc@gmail.com> wrote:

> Dear Bitcoin Development Mailing List,
>
> I hope this email finds you well. I am Majorian, and I've been active in
> the bitcoin space since 2017.
>
> I'm not a programmer or technical expert by any means; I'm just someone
> who has seen Bitcoin evolve over the years and wants to see it thrive
> without unnecessary division.
>
> I'm writing today to propose a simple compromise that I believe could help
> bridge the gap between the various sides in the ongoing controversies in
> the Bitcoin community following Core 30's release.
>
> As many of you know, these debates have created a rift in the community.
> My proposal isn't aimed at fully solving broader issues—that's a bigger
> challenge requiring more comprehensive solutions. Instead, it seeks to
> return Bitcoin to the de facto operational state it has maintained for over
> a decade, where OP_RETURN has been used sparingly and responsibly for
> metadata. The core goal is to codify at the consensus level the historical
> node relay norms that have guided Bitcoin's operation effectively for
> years, elevating these longstanding practices from policy to enforceable
> rules to ensure consistency and stability across the network.The
> Proposal: OP_RETURN Cap Soft ForkI suggest a backwards-compatible soft
> fork that introduces the following consensus rules:
>
>    - Cap OP_RETURN data size at 83 bytes: This aligns closely with
>    historical norms (e.g., the 80-byte standard relay policy) This means that
>    OP_RETURN can be at most 83 bytes: 1 byte for the opcode, 1-2 bytes for the
>    data push, and 80 bytes of data. By enforcing this at consensus, we simply
>    make permanent the relay standards that nodes have followed in practice for
>    much of Bitcoin's history.
>    - Limit to 1 OP_RETURN output per transaction: This ensures
>    transactions adhere to traditional patterns, reducing potential abuse
>    without disrupting standard usage.
>
> This approach codifies the proven, historical relay policies into
> consensus rules, preserving Bitcoin's operational heritage.Why This
> Compromise?
>
>    - Simplicity: The rules are straightforward to implement and verify,
>    with minimal code changes required.
>    - Bridging the Divide: It addresses concerns of new attack vectors by
>    tightening OP_RETURN usage to match historical norms, while being agnostic
>    on 'spam.'
>    - Apolitical and Restorative: This proposal is deliberately
>    apolitical, aiming simply to return Bitcoin to the state it was in roughly
>    a few weeks ago, before recent debates intensified. It takes no sides
>    regarding specific implementations like Core, Knots, or others. While large
>    OP_RETURNs have been possible at the consensus level for a long time,
>    they've seldom been used in this manner until very recently. By capping
>    them, we principally address concerns about OP_RETURN being used as an
>    attack vector on Bitcoin, codifying the relay norms that have kept such
>    usage in check.
>    - Plausible Deniability: Enforcing these limits provides plausible
>    deniability, declaring firmly that Bitcoin is not designed or intended as a
>    peer-to-peer file sharing and storage protocol in the context of OP_RETURN.
>    This might be somewhat controversial, but I am including this anyway.
>    - Community Healing: By focusing on a modest, consensus-building
>    change, we can hopefully repair the current rift and refocus on bitcoin's
>    future.
>
> If this idea gains traction on the list, I'd love to see it formalized as
> a Bitcoin Improvement Proposal (BIP). I'm not equipped to write the code
> myself, but I can contribute to the discussion and help rally community
> support. What do you all think? Is this a viable middle ground? Are there
> technical pitfalls I'm missing? Feedback from experts like you would be
> invaluable.
>
> Thank you for your time and dedication to Bitcoin.
>
> Best regards,
> Majorian
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAMZUoKmi8VUrpjggJ7GmmiV%3Dp114NuY8vWQdFnw99ppK%2B%2BPtaw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 15370 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-28 16:01  2% [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies Majorian
  2025-10-28 16:37  1% ` Martin Habovštiak
@ 2025-10-28 16:50  5% ` Erik Aronesty
  2025-10-28 17:38  2% ` 'Russell O'Connor' via Bitcoin Development Mailing List
  2 siblings, 0 replies; 200+ results
From: Erik Aronesty @ 2025-10-28 16:50 UTC (permalink / raw)
  To: Majorian; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 6101 bytes --]

OP_RETURN is strictly better than any other mechanism for spamming the
chain.   Why would I, as a node runner, prefer spammers to waste UTXOs when
OP_RETURN would suffice?   Nearly half the UTXOs are now spam, and this is
the main expense for running a node.

Lets look at root causes for this problem,

 - Block space is cheap, allowing for trivial wastes of space
 - OP_RETURN doesn't relay well over 83 bytes, so its easier for me to spam
with OP_PUSH (inscriptions)

If we're seriously considering a soft fork for spam, lets consider a block
size reduction coupled with UTXO-sharing opcodes, like CTV.

 - UTXO sharing is good for node runners and decentralization
 - Smaller blocks are good for node runners and decentralization
 - Smaller blocks make Bitcoin strictly less useful for spammers
 - UTXO sharing doesn't help spammers at all
 - If spammers want to store data somewhere else and use Bitcoin to
represent ownership, there's nothing we can do to stop them.   But at least
this gets the spam off the chain.




On Tue, Oct 28, 2025 at 9:09 AM Majorian <majorianbtc@gmail.com> wrote:

> Dear Bitcoin Development Mailing List,
>
> I hope this email finds you well. I am Majorian, and I've been active in
> the bitcoin space since 2017.
>
> I'm not a programmer or technical expert by any means; I'm just someone
> who has seen Bitcoin evolve over the years and wants to see it thrive
> without unnecessary division.
>
> I'm writing today to propose a simple compromise that I believe could help
> bridge the gap between the various sides in the ongoing controversies in
> the Bitcoin community following Core 30's release.
>
> As many of you know, these debates have created a rift in the community.
> My proposal isn't aimed at fully solving broader issues—that's a bigger
> challenge requiring more comprehensive solutions. Instead, it seeks to
> return Bitcoin to the de facto operational state it has maintained for over
> a decade, where OP_RETURN has been used sparingly and responsibly for
> metadata. The core goal is to codify at the consensus level the historical
> node relay norms that have guided Bitcoin's operation effectively for
> years, elevating these longstanding practices from policy to enforceable
> rules to ensure consistency and stability across the network.The
> Proposal: OP_RETURN Cap Soft ForkI suggest a backwards-compatible soft
> fork that introduces the following consensus rules:
>
>    - Cap OP_RETURN data size at 83 bytes: This aligns closely with
>    historical norms (e.g., the 80-byte standard relay policy) This means that
>    OP_RETURN can be at most 83 bytes: 1 byte for the opcode, 1-2 bytes for the
>    data push, and 80 bytes of data. By enforcing this at consensus, we simply
>    make permanent the relay standards that nodes have followed in practice for
>    much of Bitcoin's history.
>    - Limit to 1 OP_RETURN output per transaction: This ensures
>    transactions adhere to traditional patterns, reducing potential abuse
>    without disrupting standard usage.
>
> This approach codifies the proven, historical relay policies into
> consensus rules, preserving Bitcoin's operational heritage.Why This
> Compromise?
>
>    - Simplicity: The rules are straightforward to implement and verify,
>    with minimal code changes required.
>    - Bridging the Divide: It addresses concerns of new attack vectors by
>    tightening OP_RETURN usage to match historical norms, while being agnostic
>    on 'spam.'
>    - Apolitical and Restorative: This proposal is deliberately
>    apolitical, aiming simply to return Bitcoin to the state it was in roughly
>    a few weeks ago, before recent debates intensified. It takes no sides
>    regarding specific implementations like Core, Knots, or others. While large
>    OP_RETURNs have been possible at the consensus level for a long time,
>    they've seldom been used in this manner until very recently. By capping
>    them, we principally address concerns about OP_RETURN being used as an
>    attack vector on Bitcoin, codifying the relay norms that have kept such
>    usage in check.
>    - Plausible Deniability: Enforcing these limits provides plausible
>    deniability, declaring firmly that Bitcoin is not designed or intended as a
>    peer-to-peer file sharing and storage protocol in the context of OP_RETURN.
>    This might be somewhat controversial, but I am including this anyway.
>    - Community Healing: By focusing on a modest, consensus-building
>    change, we can hopefully repair the current rift and refocus on bitcoin's
>    future.
>
> If this idea gains traction on the list, I'd love to see it formalized as
> a Bitcoin Improvement Proposal (BIP). I'm not equipped to write the code
> myself, but I can contribute to the discussion and help rally community
> support. What do you all think? Is this a viable middle ground? Are there
> technical pitfalls I'm missing? Feedback from experts like you would be
> invaluable.
>
> Thank you for your time and dedication to Bitcoin.
>
> Best regards,
> Majorian
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKgJoB%3DbDXtY8k%2BHJnA35bOTg5ZLabw5VQ3X4WnXDFs%3DEDw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 15085 bytes --]

^ permalink raw reply	[relevance 5%]

* Re: [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
  2025-10-28 16:01  2% [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies Majorian
@ 2025-10-28 16:37  1% ` Martin Habovštiak
  2025-10-28 16:50  5% ` Erik Aronesty
  2025-10-28 17:38  2% ` 'Russell O'Connor' via Bitcoin Development Mailing List
  2 siblings, 0 replies; 200+ results
From: Martin Habovštiak @ 2025-10-28 16:37 UTC (permalink / raw)
  To: Majorian; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 5526 bytes --]

Hi,

Since you seem to be respectful, I decided to reply to you. Unfortunately,
doing this would make things worse by forcing data longer than 83B to go
into unspendable outs - that means it'd be never possible to remove them,
including in case of pruned nodes.

If the contiguous data argument was valid then restricting it to something
like 200B would make some sense, but even that is invalid for several
reasons.

I hope you find this message helpful.

Martin

Dňa ut 28. 10. 2025, 17:09 Majorian <majorianbtc@gmail.com> napísal(a):

> Dear Bitcoin Development Mailing List,
>
> I hope this email finds you well. I am Majorian, and I've been active in
> the bitcoin space since 2017.
>
> I'm not a programmer or technical expert by any means; I'm just someone
> who has seen Bitcoin evolve over the years and wants to see it thrive
> without unnecessary division.
>
> I'm writing today to propose a simple compromise that I believe could help
> bridge the gap between the various sides in the ongoing controversies in
> the Bitcoin community following Core 30's release.
>
> As many of you know, these debates have created a rift in the community.
> My proposal isn't aimed at fully solving broader issues—that's a bigger
> challenge requiring more comprehensive solutions. Instead, it seeks to
> return Bitcoin to the de facto operational state it has maintained for over
> a decade, where OP_RETURN has been used sparingly and responsibly for
> metadata. The core goal is to codify at the consensus level the historical
> node relay norms that have guided Bitcoin's operation effectively for
> years, elevating these longstanding practices from policy to enforceable
> rules to ensure consistency and stability across the network.The
> Proposal: OP_RETURN Cap Soft ForkI suggest a backwards-compatible soft
> fork that introduces the following consensus rules:
>
>    - Cap OP_RETURN data size at 83 bytes: This aligns closely with
>    historical norms (e.g., the 80-byte standard relay policy) This means that
>    OP_RETURN can be at most 83 bytes: 1 byte for the opcode, 1-2 bytes for the
>    data push, and 80 bytes of data. By enforcing this at consensus, we simply
>    make permanent the relay standards that nodes have followed in practice for
>    much of Bitcoin's history.
>    - Limit to 1 OP_RETURN output per transaction: This ensures
>    transactions adhere to traditional patterns, reducing potential abuse
>    without disrupting standard usage.
>
> This approach codifies the proven, historical relay policies into
> consensus rules, preserving Bitcoin's operational heritage.Why This
> Compromise?
>
>    - Simplicity: The rules are straightforward to implement and verify,
>    with minimal code changes required.
>    - Bridging the Divide: It addresses concerns of new attack vectors by
>    tightening OP_RETURN usage to match historical norms, while being agnostic
>    on 'spam.'
>    - Apolitical and Restorative: This proposal is deliberately
>    apolitical, aiming simply to return Bitcoin to the state it was in roughly
>    a few weeks ago, before recent debates intensified. It takes no sides
>    regarding specific implementations like Core, Knots, or others. While large
>    OP_RETURNs have been possible at the consensus level for a long time,
>    they've seldom been used in this manner until very recently. By capping
>    them, we principally address concerns about OP_RETURN being used as an
>    attack vector on Bitcoin, codifying the relay norms that have kept such
>    usage in check.
>    - Plausible Deniability: Enforcing these limits provides plausible
>    deniability, declaring firmly that Bitcoin is not designed or intended as a
>    peer-to-peer file sharing and storage protocol in the context of OP_RETURN.
>    This might be somewhat controversial, but I am including this anyway.
>    - Community Healing: By focusing on a modest, consensus-building
>    change, we can hopefully repair the current rift and refocus on bitcoin's
>    future.
>
> If this idea gains traction on the list, I'd love to see it formalized as
> a Bitcoin Improvement Proposal (BIP). I'm not equipped to write the code
> myself, but I can contribute to the discussion and help rally community
> support. What do you all think? Is this a viable middle ground? Are there
> technical pitfalls I'm missing? Feedback from experts like you would be
> invaluable.
>
> Thank you for your time and dedication to Bitcoin.
>
> Best regards,
> Majorian
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALkkCJa1uswSje_mm9h3FOhSaa7Ff8MGupMt9Xc9%3DGr5SmDJzw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 14614 bytes --]

^ permalink raw reply	[relevance 1%]

* [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies
@ 2025-10-28 16:01  2% Majorian
  2025-10-28 16:37  1% ` Martin Habovštiak
                   ` (2 more replies)
  0 siblings, 3 replies; 200+ results
From: Majorian @ 2025-10-28 16:01 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 4318 bytes --]

Dear Bitcoin Development Mailing List,

I hope this email finds you well. I am Majorian, and I've been active in 
the bitcoin space since 2017. 

I'm not a programmer or technical expert by any means; I'm just someone who 
has seen Bitcoin evolve over the years and wants to see it thrive without 
unnecessary division.

I'm writing today to propose a simple compromise that I believe could help 
bridge the gap between the various sides in the ongoing controversies in 
the Bitcoin community following Core 30's release.

As many of you know, these debates have created a rift in the community. My 
proposal isn't aimed at fully solving broader issues—that's a bigger 
challenge requiring more comprehensive solutions. Instead, it seeks to 
return Bitcoin to the de facto operational state it has maintained for over 
a decade, where OP_RETURN has been used sparingly and responsibly for 
metadata. The core goal is to codify at the consensus level the historical 
node relay norms that have guided Bitcoin's operation effectively for 
years, elevating these longstanding practices from policy to enforceable 
rules to ensure consistency and stability across the network.The Proposal: 
OP_RETURN Cap Soft ForkI suggest a backwards-compatible soft fork that 
introduces the following consensus rules:
   
   - Cap OP_RETURN data size at 83 bytes: This aligns closely with 
   historical norms (e.g., the 80-byte standard relay policy) This means that 
   OP_RETURN can be at most 83 bytes: 1 byte for the opcode, 1-2 bytes for the 
   data push, and 80 bytes of data. By enforcing this at consensus, we simply 
   make permanent the relay standards that nodes have followed in practice for 
   much of Bitcoin's history.
   - Limit to 1 OP_RETURN output per transaction: This ensures transactions 
   adhere to traditional patterns, reducing potential abuse without disrupting 
   standard usage.

This approach codifies the proven, historical relay policies into consensus 
rules, preserving Bitcoin's operational heritage.Why This Compromise?
   
   - Simplicity: The rules are straightforward to implement and verify, 
   with minimal code changes required.
   - Bridging the Divide: It addresses concerns of new attack vectors by 
   tightening OP_RETURN usage to match historical norms, while being agnostic 
   on 'spam.'
   - Apolitical and Restorative: This proposal is deliberately apolitical, 
   aiming simply to return Bitcoin to the state it was in roughly a few weeks 
   ago, before recent debates intensified. It takes no sides regarding 
   specific implementations like Core, Knots, or others. While large 
   OP_RETURNs have been possible at the consensus level for a long time, 
   they've seldom been used in this manner until very recently. By capping 
   them, we principally address concerns about OP_RETURN being used as an 
   attack vector on Bitcoin, codifying the relay norms that have kept such 
   usage in check.
   - Plausible Deniability: Enforcing these limits provides plausible 
   deniability, declaring firmly that Bitcoin is not designed or intended as a 
   peer-to-peer file sharing and storage protocol in the context of OP_RETURN. 
   This might be somewhat controversial, but I am including this anyway.
   - Community Healing: By focusing on a modest, consensus-building change, 
   we can hopefully repair the current rift and refocus on bitcoin's future.

If this idea gains traction on the list, I'd love to see it formalized as a 
Bitcoin Improvement Proposal (BIP). I'm not equipped to write the code 
myself, but I can contribute to the discussion and help rally community 
support. What do you all think? Is this a viable middle ground? Are there 
technical pitfalls I'm missing? Feedback from experts like you would be 
invaluable. 

Thank you for your time and dedication to Bitcoin.

Best regards,
Majorian

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/f513d0af-90d1-43ee-ac8e-df55760674dan%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 13280 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-27 19:56  0%       ` Greg Maxwell
@ 2025-10-28  5:13  0%         ` dathonohm via Bitcoin Development Mailing List
  2025-10-30  0:31  0%           ` Antoine Riard
  2025-10-28  9:16  1%         ` /dev /fd0
  1 sibling, 1 reply; 200+ results
From: dathonohm via Bitcoin Development Mailing List @ 2025-10-28  5:13 UTC (permalink / raw)
  To: Greg Maxwell; +Cc: Kyle Stout, Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 7880 bytes --]

Hi list -

Thanks for all of the feedback everyone!

I am working on a new draft of the BIP that will hopefully address everyone's concerns and avoid the misunderstandings that have arisen.

I apologize for not being able to respond to all of you, but know that I did indeed read your messages.

Best,

Dathon
On Monday, October 27th, 2025 at 1:58 PM, Greg Maxwell <gmaxwell@gmail.com> wrote:

> The only consensus normative data encoding in Bitcoin is the order data goes into hashes. The representations in memory, rpc, in the p2p network, etc. are already different and could be made arbitrarily different without any consensus change. Case in point: the data is now normally encrypted on disk and in P2P. There are also proposals such as BIP 337: https://github.com/bitcoin/bips/blob/master/bip-0337.mediawiki none of these things are consensus changes-- many aren't even bippable because they don't have interoperability considerations (e.g. representations on disk/memory).
>
> Forget for a moment the (un)likelyhood that the concerns being discussed are meaningfully modulated by exactly how data is represented in p2p, memory, rpc, disk, etc.. for assumption just assume they are.
>
> If so, the correct move would be to change those encodings rather than any consensus rule change--- particularly because any consensus rule method will simply be evaded, and can't provide the level of swizzling that changing the encoding can accomplish. Encoding changes are also substantially non-coercive: people who think they're valuable can adopt them and leave other people alone.
>
> Good news for everyone except those who consider coercing others to be a terminal goal.
>
> On Mon, Oct 27, 2025 at 6:35 PM Kyle Stout <kylestout85@gmail.com> wrote:
>
>> Dathon,
>>
>>> if Bitcoin provides an officially supported method of storing arbitrary data (i.e., OP_RETURN), and the capacity of that method is large enough to store hazardous content in a contiguous format (an increase to 100kB is currently underway as Bitcoin Core 30 gains adoption), then one does not need to misinterpret the data in order to view the content.
>>
>> This seems to be the crux of your argument. I believe it is misleading and technically unsound. It's technical theater that creates a distinction without any meaningful difference.
>>
>> First, Bitcoin has no concept of a file viewer. To interpret any embedded data other to validate it against Bitcoin's rules, you must use a third party tool. Practically speaking, the differences are negligible in terms of technical difficulty, as humorously demonstrated here: https://x.com/rot13maxi/status/1963318690759192622 . Contiguous or not, you're file carving.
>>
>> Second, by definition, you're misinterpreting the data vis-a-vis Bitcoin since it has no native concept of 'image', 'video', etc. Arbitrary bytes are meaningless. The purpose of having OP_RETURN as a standard output is to protect the UTXO set from being abused. It isn't some kind of 'blessing' to store files. That's absurd. As you admit, it's impossible to stop people from writing arbitrary bytes to the blockchain, so this is damage mitigation, not an invitation.
>>
>> Third, contiguity is not a legally meaningful predicate. "Your honor, we tried to limit the contiguous bytes!" is simply not going to fly. The bytes exist either way, and they must be interpreted by third party software either way. If anything, this path is going to represent a voluntary self-policing that will result in more culpability. Right now, arbitrary bytes don't mean anything in Bitcoin. If it's valid, it's valid. Nodes relay opaque protocol data. If you insist on only accepting 'approved' arbitrary bytes, you're opening the door to a knowledge/intent accusation.
>>
>> Regards,
>>
>> Kyle
>>
>> On Monday, October 27, 2025 at 1:36:33 AM UTC-4 dath...@proton.me wrote:
>>
>>> Peter -
>>>
>>> Thank you for demonstrating what non-contiguous data looks like.
>>>
>>> I trust you when you say that you can parse the BIP's contents from this transaction, but all it looks like to me (and the Bitcoin network) is a UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length OP_RETURN, sending all ~100 USD in fees to the miner.
>>>
>>> Since legally hazardous content can be generated from any input data, including your 30-input consolidation transaction (as long as the correct third-party program is used), it would not make sense to hold node operators legally responsible for storing and distributing such input data.
>>>
>>> However, if Bitcoin provides an officially supported method of storing arbitrary data (i.e., OP_RETURN), and the capacity of that method is large enough to store hazardous content in a contiguous format (an increase to 100kB is currently underway as Bitcoin Core 30 gains adoption), then one does not need to misinterpret the data in order to view the content. In that case, node operators could conceivably be held responsible for possession and distribution.
>>>
>>> Since arbitrary data storage does nothing to benefit Bitcoin as permissionless money, there is no good reason to force this additional legal risk on node operators, who already face enough challenges as it is.
>>>
>>> Best,
>>>
>>> Dathon
>>>
>>> On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <pe...@petertodd.org> wrote:
>>>
>>>> On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin Development Mailing List wrote:
>>>>
>>>> > Hi list -
>>>> >
>>>> > Due to Bitcoin Core v30 gaining in popularity, it has become necessary to move forward on luke-jr's ML proposal to temporarily limit arbitrary data at the consensus level, which so far has 3 weeks with no objections:
>>>> >
>>>> > https://github.com/bitcoin/bips/pull/2017
>>>>
>>>>
>>>> Transaction 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
>>>> contains the full text of this BIP as of writing(1), while simultaneously being
>>>> compliant with that BIP.
>>>>
>>>> Clearly, this approach is ineffective.
>>>>
>>>> 1) https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
>>>>
>>>> --
>>>> https://petertodd.org 'peter'[:-1]@petertodd.org
>>>>
>>>> --
>>>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
>>>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org.
>>
>> --
>> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com.
>
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQRQWwX76o8QHjt8FoLxJiq1B-FgP%2BpehOL8PYhWgewbg%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/XFyaw5Bf4-4bAO3wBt3Wk2aSclxSGQ8n-uT4BR6ga864yMCf5Fe-xFQ8VnlYHH6bQ3s5jSQrfs02E-MNJbAXVmq3_vlQpgNcsOmiYTFwmcg%3D%40proton.me.

[-- Attachment #2: Type: text/html, Size: 12243 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-27 18:29  1%     ` Kyle Stout
@ 2025-10-27 19:56  0%       ` Greg Maxwell
  2025-10-28  5:13  0%         ` dathonohm via Bitcoin Development Mailing List
  2025-10-28  9:16  1%         ` /dev /fd0
  0 siblings, 2 replies; 200+ results
From: Greg Maxwell @ 2025-10-27 19:56 UTC (permalink / raw)
  To: Kyle Stout; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 7334 bytes --]

The only consensus normative data encoding in Bitcoin is the order data
goes into hashes.  The representations in memory, rpc, in the p2p network,
etc. are already different and could be made arbitrarily different without
any consensus change.  Case in point:  the data is now normally encrypted
on disk and in P2P.  There are also proposals such as BIP 337:
https://github.com/bitcoin/bips/blob/master/bip-0337.mediawiki  none of
these things are consensus changes-- many aren't even bippable because they
don't have interoperability considerations (e.g. representations on
disk/memory).

Forget for a moment the (un)likelyhood that the concerns being discussed
are meaningfully modulated by exactly how data is represented in p2p,
memory, rpc, disk, etc.. for assumption just assume they are.

If so, the correct move would be to change those encodings rather than any
consensus rule change--- particularly because any consensus rule method
will simply be evaded, and can't provide the level of swizzling that
changing the encoding can accomplish.  Encoding changes are also
substantially non-coercive: people who think they're valuable can adopt
them and leave other people alone.

Good news for everyone except those who consider coercing others to be a
terminal goal.



On Mon, Oct 27, 2025 at 6:35 PM Kyle Stout <kylestout85@gmail.com> wrote:

> Dathon,
>
> > if Bitcoin provides an officially supported method of storing arbitrary
> data (i.e., OP_RETURN), and the capacity of that method is large enough to
> store hazardous content in a contiguous format (an increase to 100kB is
> currently underway as Bitcoin Core 30 gains adoption), then one does not
> need to misinterpret the data in order to view the content.
>
> This seems to be the crux of your argument. I believe it is misleading and
> technically unsound. It's technical theater that creates a distinction
> without any meaningful difference.
>
> First, Bitcoin has no concept of a file viewer. To interpret *any*
> embedded data other to validate it against Bitcoin's rules, you must use a
> third party tool. Practically speaking, the differences are negligible in
> terms of technical difficulty, as humorously demonstrated here:
> https://x.com/rot13maxi/status/1963318690759192622 . Contiguous or not,
> you're file carving.
>
> Second, by definition, you're misinterpreting the data vis-a-vis Bitcoin
> since it has no native concept of 'image', 'video', etc. Arbitrary bytes
> are meaningless. The purpose of having OP_RETURN as a standard output is to
> protect the UTXO set from being abused. It isn't some kind of 'blessing' to
> store files. That's absurd. As you admit, it's impossible to stop people
> from writing arbitrary bytes to the blockchain, so this is damage
> mitigation, not an invitation.
>
> Third, contiguity is not a legally meaningful predicate. "Your honor, we
> tried to limit the contiguous bytes!" is simply not going to fly. The bytes
> exist either way, and they must be interpreted by third party software
> either way. If anything, this path is going to represent a voluntary
> self-policing that will result in more culpability. Right now, arbitrary
> bytes don't mean anything in Bitcoin. If it's valid, it's valid. Nodes
> relay opaque protocol data. If you insist on only accepting 'approved'
> arbitrary bytes, you're opening the door to a knowledge/intent accusation.
>
> Regards,
>
> Kyle
>
>
>
> On Monday, October 27, 2025 at 1:36:33 AM UTC-4 dath...@proton.me wrote:
>
>> Peter -
>>
>> Thank you for demonstrating what non-contiguous data looks like.
>>
>> I trust you when you say that you can parse the BIP's contents from this
>> transaction, but all it looks like to me (and the Bitcoin network) is a
>> UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length
>> OP_RETURN, sending all ~100 USD in fees to the miner.
>>
>> Since legally hazardous content can be generated from any input data,
>> including your 30-input consolidation transaction (as long as the correct
>> third-party program is used), it would not make sense to hold node
>> operators legally responsible for storing and distributing such input data.
>>
>> However, if Bitcoin provides an officially supported method of storing
>> arbitrary data (i.e., OP_RETURN), and the capacity of that method is large
>> enough to store hazardous content in a contiguous format (an increase to
>> 100kB is currently underway as Bitcoin Core 30 gains adoption), then one
>> does not need to misinterpret the data in order to view the content. In
>> that case, node operators could conceivably be held responsible for
>> possession and distribution.
>>
>> Since arbitrary data storage does nothing to benefit Bitcoin as
>> permissionless money, there is no good reason to force this additional
>> legal risk on node operators, who already face enough challenges as it is.
>>
>> Best,
>>
>> Dathon
>>
>>
>> On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <pe...@petertodd.org>
>> wrote:
>>
>> > On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin
>> Development Mailing List wrote:
>> >
>> > > Hi list -
>> > >
>> > > Due to Bitcoin Core v30 gaining in popularity, it has become
>> necessary to move forward on luke-jr's ML proposal to temporarily limit
>> arbitrary data at the consensus level, which so far has 3 weeks with no
>> objections:
>> > >
>> > > https://github.com/bitcoin/bips/pull/2017
>> >
>> >
>> > Transaction
>> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
>> > contains the full text of this BIP as of writing(1), while
>> simultaneously being
>> > compliant with that BIP.
>> >
>> > Clearly, this approach is ineffective.
>> >
>> > 1)
>> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
>> >
>> > --
>> > https://petertodd.org 'peter'[:-1]@petertodd.org
>> >
>> > --
>> > You received this message because you are subscribed to the Google
>> Groups "Bitcoin Development Mailing List" group.
>> > To unsubscribe from this group and stop receiving emails from it, send
>> an email to bitcoindev+...@googlegroups.com.
>> > To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org.
>>
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQRQWwX76o8QHjt8FoLxJiq1B-FgP%2BpehOL8PYhWgewbg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 9347 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  2025-10-27  4:08  1%   ` dathonohm via Bitcoin Development Mailing List
@ 2025-10-27 18:29  1%     ` Kyle Stout
  2025-10-27 19:56  0%       ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: Kyle Stout @ 2025-10-27 18:29 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 5303 bytes --]

Dathon,

> if Bitcoin provides an officially supported method of storing arbitrary 
data (i.e., OP_RETURN), and the capacity of that method is large enough to 
store hazardous content in a contiguous format (an increase to 100kB is 
currently underway as Bitcoin Core 30 gains adoption), then one does not 
need to misinterpret the data in order to view the content.

This seems to be the crux of your argument. I believe it is misleading and 
technically unsound. It's technical theater that creates a distinction 
without any meaningful difference.

First, Bitcoin has no concept of a file viewer. To interpret *any* embedded 
data other to validate it against Bitcoin's rules, you must use a third 
party tool. Practically speaking, the differences are negligible in terms 
of technical difficulty, as humorously demonstrated here: 
https://x.com/rot13maxi/status/1963318690759192622 . Contiguous or not, 
you're file carving. 

Second, by definition, you're misinterpreting the data vis-a-vis Bitcoin 
since it has no native concept of 'image', 'video', etc. Arbitrary bytes 
are meaningless. The purpose of having OP_RETURN as a standard output is to 
protect the UTXO set from being abused. It isn't some kind of 'blessing' to 
store files. That's absurd. As you admit, it's impossible to stop people 
from writing arbitrary bytes to the blockchain, so this is damage 
mitigation, not an invitation.

Third, contiguity is not a legally meaningful predicate. "Your honor, we 
tried to limit the contiguous bytes!" is simply not going to fly. The bytes 
exist either way, and they must be interpreted by third party software 
either way. If anything, this path is going to represent a voluntary 
self-policing that will result in more culpability. Right now, arbitrary 
bytes don't mean anything in Bitcoin. If it's valid, it's valid. Nodes 
relay opaque protocol data. If you insist on only accepting 'approved' 
arbitrary bytes, you're opening the door to a knowledge/intent accusation.

Regards,

Kyle

 

On Monday, October 27, 2025 at 1:36:33 AM UTC-4 dath...@proton.me wrote:

> Peter -
>
> Thank you for demonstrating what non-contiguous data looks like.
>
> I trust you when you say that you can parse the BIP's contents from this 
> transaction, but all it looks like to me (and the Bitcoin network) is a 
> UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length 
> OP_RETURN, sending all ~100 USD in fees to the miner.
>
> Since legally hazardous content can be generated from any input data, 
> including your 30-input consolidation transaction (as long as the correct 
> third-party program is used), it would not make sense to hold node 
> operators legally responsible for storing and distributing such input data.
>
> However, if Bitcoin provides an officially supported method of storing 
> arbitrary data (i.e., OP_RETURN), and the capacity of that method is large 
> enough to store hazardous content in a contiguous format (an increase to 
> 100kB is currently underway as Bitcoin Core 30 gains adoption), then one 
> does not need to misinterpret the data in order to view the content. In 
> that case, node operators could conceivably be held responsible for 
> possession and distribution.
>
> Since arbitrary data storage does nothing to benefit Bitcoin as 
> permissionless money, there is no good reason to force this additional 
> legal risk on node operators, who already face enough challenges as it is.
>
> Best,
>
> Dathon
>
>
> On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <pe...@petertodd.org> 
> wrote:
>
> > On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin 
> Development Mailing List wrote:
> > 
> > > Hi list -
> > > 
> > > Due to Bitcoin Core v30 gaining in popularity, it has become necessary 
> to move forward on luke-jr's ML proposal to temporarily limit arbitrary 
> data at the consensus level, which so far has 3 weeks with no objections:
> > > 
> > > https://github.com/bitcoin/bips/pull/2017
> > 
> > 
> > Transaction 
> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
> > contains the full text of this BIP as of writing(1), while 
> simultaneously being
> > compliant with that BIP.
> > 
> > Clearly, this approach is ineffective.
> > 
> > 1) 
> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
> > 
> > --
> > https://petertodd.org 'peter'[:-1]@petertodd.org
> > 
> > --
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/7abf7055-6b85-492f-ada2-e0a517e93cf9n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 7611 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] op_return spam is beneficial
       [not found]     ` <CAGvrRVK7hO9RQ==Q1_5xH7_HYar-EGPL_d3-wJ5q82vNDRHBiA@mail.gmail.com>
@ 2025-10-27  3:39  2%   ` Erik Aronesty
  0 siblings, 0 replies; 200+ results
From: Erik Aronesty @ 2025-10-27  3:39 UTC (permalink / raw)
  To: nt yl, bitcoindev

[-- Attachment #1: Type: text/plain, Size: 3499 bytes --]

when blocks aren't full, fees are negligible, miners aren't sufficiently
rewarded, and we risk hashpower decline

if they remain not full, we should probably reduce the block size

and improve the ability to securely share UTXOs so more people can use them

On Sun, Oct 26, 2025, 5:52 PM nt yl <wrapperband@googlemail.com> wrote:

> Hi Erik
>
> As far as I understand -
>
> Bitcoin blocks aren’t all the same size -  they only share a maximum size
> limit.
>
> OP_RETURN outputs don’t actually “save” UTXOs; they just create
> unspendable outputs that never enter the UTXO set, while still adding to
> the permanent blockchain size.
>
> That reduces memory load slightly but increases disk and bandwidth
> requirements. So it’s not a free trade-off, and it’s misleading to suggest
> OP_RETURN use has no decentralization cost.
>
> Dr D
>
> On Sun, Oct 26, 2025 at 7:46 PM Erik Aronesty <erik@q32.com> wrote:
>
>> There is a strictly limited supply of money available for spam.  (
>> Because if we don't assume this, then we have to assume that all financial
>> transactions will get crowded out by infinite funds. )
>>
>> Every time OP_RETURN is used, instead of other UTXO bearing transactions,
>> at least one UTXO is saved.  UTXO spam is dangerous for decentralization
>> (blockchain spam isn't since blocks are always the same size)
>>
>> Since spam funds are limited, this is money spent to boost hashpower, and
>> removes money from the spam pool that would otherwise create UTXO bloat.
>>
>> Therefore it's irrational to prevent large (or at least multiple) being
>> used for spam.
>>
>> The only reason to limit this opcode is to "virtue signal that Bitcoin is
>> not intended to store data".
>>
>> And while this may have some benefits in the short term given the ongoing
>> social attack against core maintainers, in the long term I think it might
>> have very negative repercussions to cave to a social attack that has little
>> technical merit.
>>
>> However there is a serious issue with contiguous scriptlubkey data that
>> doesn't have to do with government censorship.
>>
>> Apparently it is possible to produce L2 protocols that rely on the relay
>> network and unconfirmed transactions.
>>
>> We need to be sure that minimum transaction fees are set quite high so
>> that nodes are not relaying transactions that have no intention of being
>> mined or paid for.
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2B9EA%3Dg-i2QeTZYiOW%3D%3D3AY0qihyPVdqJNtS910u7WzcA%40mail.gmail.com
>> <https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2B9EA%3Dg-i2QeTZYiOW%3D%3D3AY0qihyPVdqJNtS910u7WzcA%40mail.gmail.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2BYzdfq%2B7fW0AVDxZ3HLe7UbPoOUeh6ejScaqqC%3DzdFrw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 5257 bytes --]

^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  @ 2025-10-27  3:41  1%   ` Jal Toorey
  2025-10-27 17:27  1%     ` Max
  2025-10-27  4:08  1%   ` dathonohm via Bitcoin Development Mailing List
  1 sibling, 1 reply; 200+ results
From: Jal Toorey @ 2025-10-27  3:41 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 1784 bytes --]

"bitcoin is money"

The definition of what is money is extremely subjective.  The history of it 
shows this (not the history saifedean paints). Trying to direct the 
development to capture a definition of money opens a huge attack vector. 
It's not different than trying to decide what is spam. 

Also what is the difference between the bashers slogan that bitcoin is p2p 
money and "bitcoin is money"  They seem like the same thing? 
On Sunday, October 26, 2025 at 3:43:26 PM UTC-7 Peter Todd wrote:

> On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin 
> Development Mailing List wrote:
> > Hi list -
> > 
> > Due to Bitcoin Core v30 gaining in popularity, it has become necessary 
> to move forward on [luke-jr's ML proposal](
> https://github.com/bitcoin/bips/pull/2017) to temporarily limit arbitrary 
> data at the consensus level, which so far has 3 weeks with no objections:
> > 
> > https://github.com/bitcoin/bips/pull/2017
>
> Transaction 
> 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
> contains the full text of this BIP as of writing(1), while simultaneously 
> being
> compliant with that BIP.
>
> Clearly, this approach is ineffective.
>
> 1) 
> https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
>
> -- 
> https://petertodd.org 'peter'[:-1]@petertodd.org
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5ddcfb0f-665e-4f0e-987e-80b9bb77ff5bn%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 3751 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
  @ 2025-10-27 16:35  1%     ` TheWrlck
  0 siblings, 0 replies; 200+ results
From: TheWrlck @ 2025-10-27 16:35 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 4422 bytes --]

I’m not convinced that restricting or discouraging non-transactional data 
is the right approach. While limiting data size may reduce certain abuses, 
it also constrains legitimate use cases that leverage Bitcoin’s 
data-carrying capabilities (e.g. commitments, metadata, or novel 
protocols). From a consensus-layer perspective, Bitcoin should remain 
neutral about how data is interpreted or used, as long as it follows the 
defined rules and pays the required fees. Imposing normative judgments 
about "spam" risks introducing subjective policy where objective validation 
should suffice.
Il giorno lunedì 27 ottobre 2025 alle 06:36:37 UTC+1 dath...@proton.me ha 
scritto:

> Jameson -
>
> You mention "technical concerns" but don't give any examples. Would you 
> mind sharing one?
>
> You also mention "the underlying implication of using legal coercion to 
> require miners and other network participants to comply with arbitrary 
> legal and moral frameworks", but I don't think the BIP implies this at all.
>
> The BIP merely highlights a legal risk Bitcoin Core 30 has created for 
> node operators for no good reason, and attempts to eliminate it. No 
> "coercion" is implied. You and anyone else who are fine shouldering this 
> risk are free to stay on the old data-friendly chain. I doubt you will have 
> much company, though.
>
> Best,
>
> Dathon
>
> On Sunday, October 26th, 2025 at 2:49 PM, Jameson Lopp <
> jameso...@gmail.com> wrote:
>
> It's quite clear from the PR discussion that there are a multitude of 
> contentious issues at play with this proposal.
>
> Even aside from all of the technical concerns, the underlying implication 
> of using legal coercion to require miners and other network participants to 
> comply with arbitrary legal and moral frameworks makes it a non-starter in 
> my opinion.
>
> On Sun, Oct 26, 2025 at 3:43 PM dathonohm via Bitcoin Development Mailing 
> List <bitco...@googlegroups.com> wrote:
>
>> Hi list -
>>
>> Due to Bitcoin Core v30 gaining in popularity, it has become necessary to 
>> move forward on luke-jr's ML proposal 
>> <https://github.com/bitcoin/bips/pull/2017> to temporarily limit 
>> arbitrary data at the consensus level, which so far has 3 weeks with no 
>> objections:
>> https://github.com/bitcoin/bips/pull/2017
>>
>> The idea is to strongly re-affirm in consensus that bitcoin is money, not 
>> data storage. It is implemented as a temporary softfork that can activate 
>> in one of two different ways: proactive, or reactive.
>>
>> After a year, the soft fork expires, giving us time to come up with a 
>> more permanent solution.
>>
>> The timeline is a bit tight, but I think everyone has incentives to 
>> support a quick and orderly activation.
>>
>> Please feel free to leave a comment on the PR or reach out to me over 
>> email with any feedback. 
>>
>> There is much work still to do, so if you have some technical skills and 
>> would like to join in the effort with dev/testing, please reach out as well.
>>
>> Bitcoin is money.
>>
>> Sincerely,
>>
>> Dathon Ohm 
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/AWiF9dIo9yjUF9RAs_NLwYdGK11BF8C8oEArR6Cys-rbcZ8_qs3RoJURqK3CqwCCWM_zwGFn5n3RECW_j5hGS01ntGzPLptqcOyOejunYsU%3D%40proton.me
>> .
>>
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to bitcoindev+...@googlegroups.com.
>
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/CADL_X_caKFvypdDa2k-Hhy1QCMJgnb6Rc8i0vBRW9%3Dyoq4h2ZA%40mail.gmail.com
> .
>
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/c81c7dc0-d96e-4d29-bbeb-6c06aba21ef7n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 9092 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork
    2025-10-27  3:41  1%   ` Jal Toorey
@ 2025-10-27  4:08  1%   ` dathonohm via Bitcoin Development Mailing List
  2025-10-27 18:29  1%     ` Kyle Stout
  1 sibling, 1 reply; 200+ results
From: dathonohm via Bitcoin Development Mailing List @ 2025-10-27  4:08 UTC (permalink / raw)
  To: Peter Todd; +Cc: bitcoindev@googlegroups.com

Peter -

Thank you for demonstrating what non-contiguous data looks like.

I trust you when you say that you can parse the BIP's contents from this transaction, but all it looks like to me (and the Bitcoin network) is a UTXO broken into 31 pieces then (mostly) re-consolidated into a 0-length OP_RETURN, sending all ~100 USD in fees to the miner.

Since legally hazardous content can be generated from any input data, including your 30-input consolidation transaction (as long as the correct third-party program is used), it would not make sense to hold node operators legally responsible for storing and distributing such input data.

However, if Bitcoin provides an officially supported method of storing arbitrary data (i.e., OP_RETURN), and the capacity of that method is large enough to store hazardous content in a contiguous format (an increase to 100kB is currently underway as Bitcoin Core 30 gains adoption), then one does not need to misinterpret the data in order to view the content. In that case, node operators could conceivably be held responsible for possession and distribution.

Since arbitrary data storage does nothing to benefit Bitcoin as permissionless money, there is no good reason to force this additional legal risk on node operators, who already face enough challenges as it is.

Best,

Dathon


On Sunday, October 26th, 2025 at 4:43 PM, Peter Todd <pete@petertodd.org> wrote:

> On Sat, Oct 25, 2025 at 08:43:11PM +0000, dathonohm via Bitcoin Development Mailing List wrote:
> 
> > Hi list -
> > 
> > Due to Bitcoin Core v30 gaining in popularity, it has become necessary to move forward on luke-jr's ML proposal to temporarily limit arbitrary data at the consensus level, which so far has 3 weeks with no objections:
> > 
> > https://github.com/bitcoin/bips/pull/2017
> 
> 
> Transaction 8e2ee13d2a19951c2777bb3a54f0cb69a2f76dae8baa954cd86149ed1138cb6c
> contains the full text of this BIP as of writing(1), while simultaneously being
> compliant with that BIP.
> 
> Clearly, this approach is ineffective.
> 
> 1) https://github.com/bitcoin/bips/blob/3c718237072c107ced8c3531a487354fbdae55df/bip-%3F%3F%3F%3F.mediawiki
> 
> --
> https://petertodd.org 'peter'[:-1]@petertodd.org
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aP6gYSnte7J86g0p%40petertodd.org.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/7U8YuMopR73k4XRYBA8DjhaGLJkyKPuXpxW9p7vmH45JHEyIj_oE_t4xk99hrNdvMGghpmooAMXOmWGaZ4UkwHPndzrpzIL0SX2SoTf0l3w%3D%40proton.me.


^ permalink raw reply	[relevance 1%]

* [bitcoindev] op_return spam is beneficial
@ 2025-10-19 13:01  3% Erik Aronesty
       [not found]     ` <CAGvrRVK7hO9RQ==Q1_5xH7_HYar-EGPL_d3-wJ5q82vNDRHBiA@mail.gmail.com>
  0 siblings, 1 reply; 200+ results
From: Erik Aronesty @ 2025-10-19 13:01 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 1783 bytes --]

There is a strictly limited supply of money available for spam.  ( Because
if we don't assume this, then we have to assume that all financial
transactions will get crowded out by infinite funds. )

Every time OP_RETURN is used, instead of other UTXO bearing transactions,
at least one UTXO is saved.  UTXO spam is dangerous for decentralization
(blockchain spam isn't since blocks are always the same size)

Since spam funds are limited, this is money spent to boost hashpower, and
removes money from the spam pool that would otherwise create UTXO bloat.

Therefore it's irrational to prevent large (or at least multiple) being
used for spam.

The only reason to limit this opcode is to "virtue signal that Bitcoin is
not intended to store data".

And while this may have some benefits in the short term given the ongoing
social attack against core maintainers, in the long term I think it might
have very negative repercussions to cave to a social attack that has little
technical merit.

However there is a serious issue with contiguous scriptlubkey data that
doesn't have to do with government censorship.

Apparently it is possible to produce L2 protocols that rely on the relay
network and unconfirmed transactions.

We need to be sure that minimum transaction fees are set quite high so that
nodes are not relaying transactions that have no intention of being mined
or paid for.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAJowKg%2B9EA%3Dg-i2QeTZYiOW%3D%3D3AY0qihyPVdqJNtS910u7WzcA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 2866 bytes --]

^ permalink raw reply	[relevance 3%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-18 12:06  1%             ` PortlandHODL
  2025-10-18 16:54  0%               ` /dev /fd0
@ 2025-10-22  8:07  0%               ` 'moonsettler' via Bitcoin Development Mailing List
  2025-10-27 23:44  2%                 ` Michael Tidwell
  1 sibling, 1 reply; 200+ results
From: 'moonsettler' via Bitcoin Development Mailing List @ 2025-10-22  8:07 UTC (permalink / raw)
  To: PortlandHODL; +Cc: Bitcoin Development Mailing List

> Confiscation is a problem because of presigned transactions

Allow 10000 bytes of total scriptPubKey size in each block counting only those outputs that are larger than x (520 as proposed).
The code change is pretty minimal from the most obvious implementation of the original rule.

That makes it technically non-confiscatory. Still non-standard, but if anyone out there so obnoxiously foot-gunned themselves, they can't claim they were rugged by the devs.

BR,
moonsettler

On Saturday, October 18th, 2025 at 3:15 PM, PortlandHODL <admin@qrsnap.io> wrote:

> Hey,
> 
> First, thank you to everyone who responded, and please continue to do so. There were many thought provoking responses and this did shift my perspective quite a bit from the original post, which in of itself was the goal to a degree.
> 
> I am currently only going to respond to all of the current concerns. Acks; though I like them will be ignored unless new discoveries are included.
> 
> Tl;dr (Portlands Perspective)
> - Confiscation is a problem because of presigned transactions
> - DoS mitigation could also occur through marking UTXOs as unspendable if > 520 bytes, this would preserve the proof of publication.
> - Timeout / Sunset logic is compelling
> - The (n) value of acceptable needed bytes is contentious with the lower suggested limit being 67
> - Congestion control is worth a look?
> 
> Next Step:
> - Deeper discussion at the individual level: Antoine Poinsot and GCC overlap?
> - Write an implementation.
> - Decide to pursue BIP
> 
> Responses
> 
> Andrew Poelstra:
> > There is a risk of confiscation of coins which have pre-signed but
> > unpublished transactions spending them to new outputs with large
> > scriptPubKeys. Due to long-standing standardness rules, and the presence
> > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any
> > such transactions exist.
> 
> PortlandHODL: This is a risk that can be incurred and likely not possible to mitigate as there could be possible chains of transactions so even when recursively iterating over a chain there is a chance that a presigned breaks this rule. Every idea I have had from block redemption limits on prevouts seems to just be a coverage issue where you can make the confiscation less likely but not completely mitigated.
> 
> Second, there are already TXs that effectively have been confiscated at the policy level (P2SH Cleanstack violation) where the user can not find any miner with a policy to accept these into their mempool. (3 years)
> 
> /dev /fd0
> > so it would be great if this was restricted to OP_RETURN
> 
> PortlandHODL: I reject this completely as this would remove the UTXOset omission for the scriptPubkey and encourage miners to subvert the OP_RETURN restriction and instead just use another op_code, this also do not hit on some of the most important factors such as DoS mitigation and legacy script attack surface reduction.
> 
> Peter Todd
> > NACK ...
> 
> PortlandHODL: You NACK'd for the same reasons that I stated in my OP, without including any additional context or reasoning.
> 
> jeremy
> > I think that this type of rule is OK if we do it as a "sunsetting" restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 years, 5 years, 10 years).
> 
> If action is taken, this is the most reasonable approach. Alleviating confiscatory concerns through deferral.
> 
> > You can argue against this example probably, but it is worth considering that absence of evidence of use is not evidence of absence of use and I myself feel that overall our understanding of Bitcoin transaction programming possibilities is still early. If you don't like this example, I can give you others (probably).
> 
> Agreed and this also falls into the reasoning for deciding to utilize point 1 in your response. My thoughts on this would be along the lines of proof of publication as this change only has the effect of stripping away the executable portion of a script between 521 and 10_000 bytes or the published data portion if > 10_000 bytes which the same data could likely be published in chunked segments using outpoints.
> 
> Andrew Poelstra:
> > Aside from proof-of-publication (i.e. data storage directly in the UTXO
> > set) there is no usage of script which can't be equally (or better)
> > accomplished by using a Segwit v0 or Taproot script.
> 
> This sums up the majority of future usecase concern
> 
> Anthony Towns:
> > (If you restricted the change to only applying to scripts that used
> non-push operators, that would probably still provide upgrade flexibility
> while also preventing potential script abuses. But it wouldn't do anything
> to prevent publishing data)
> 
> Could this not be done as segments in multiple outpoints using a coordination outpoint? I fail to see why publication proof must be in a single chunk. This does though however bring another alternative to mind, just making these outpoints unspendable but not invalidate the block through inclusion...
> 
> > As far as the "but contiguous data will be regulated more strictly"
> argument goes; I don't think "your honour, my offensive content has
> strings of 4d0802 every 520 bytes
> 
> Correct, this was never meant to resolve this issue.
> 
> Luke Dashjr:
> > If we're going this route, we should just close all the gaps for the immediate future:
> 
> To put it nicely, this is completely beyond the scope of what is being proposed.
> 
> Guus Ellenkamp:
> > If there are really so few OP_RETURN outputs more than 144 bytes, then
> why increase the limit if that change is so controversial? It seems
> people who want to use a larger OP_RETURN size do it anyway, even with
> the current default limits.
> 
> Completely off topic and irrelevant
> 
> Greg Tonoski:
> > Limiting the maximum size of the scriptPubKey of a transaction to 67 bytes.
> 
> This leave no room to deal with broken hashing algorithms and very little future upgradability for hooks. The rest of these points should be merged with Lukes response and either hijack my thread or start a new one with the increased scope, any approach I take will only be related to the ScriptPubkey
> 
> Keagan McClelland:
> > Hard NACK on capping the witness size as that would effectively ban large scripts even in the P2SH wrapper which undermines Bitcoin's ability to be an effectively programmable money.
> 
> This has nothing to do with the witness size or even the P2SH wrapper
> 
> Casey Rodarmor:
> > I think that "Bitcoin could need it in the future?" might be a good enough
> reason not to do this.
> 
> > Script pubkeys are the only variable-length transaction fields which can be
> covered by input signatures, which might make them useful for future soft
> forks. I can imagine confidential asset schemes or post-quantum coin recovery
> schemes requiring large proofs in the outputs, where the validity of the proof
> determined whether or not the transaction is valid, and thus require the
> proofs to be in the outputs, and not just a hash commitment.
> 
> Would the ability to publish the data alone be enough? Example make the output unspendable but allow for the existence of the bytes to be covered through the signature?
> 
> 
> Antoine Poinsot:
> > Limiting the size of created scriptPubKeys is not a sufficient mitigation on its own
> I fail to see how this would not be sufficient? To DoS you need 2 things inputs with ScriptPubkey redemptions + heavy op_codes that require unique checks. Example DUPing stack element again and again doesn't work. This then leads to the next part is you could get up to unique complex operations with the current (n) limit included per input.
> 
> > One of the goal of BIP54 is to address objections to Matt's earlier proposal, notably the (in my
> opinion reasonable) confiscation concerns voiced by Russell O'Connor. Limiting the size of
> scriptPubKeys would in this regard be moving in the opposite direction.
> 
> Some notes is I would actually go as far as to say the confiscation risk is higher with the TX limit proposed in BIP54 as we actually have proof of redemption of TXs that break that rule and the input set to do this already exists on-chain no need to even wonder about the whole presigned. bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
> 
> Please let me know if I am incorrect on any of this.
> 
> > Furthermore, it's always possible to get the biggest bang for our buck in a first step
> 
> Agreed on bang for the buck regarding DoS.
> 
> My final point here would be that I would like to discuss more, and this is response is from the initial view of your response and could be incomplete or incorrect, This is just my in the moment response.
> 
> Antoine Riard:
> > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor of prioritizing
> a timewarp fix and limiting dosy spends by old redeem scripts
> 
> The idea of congestion control is interesting, but this solution should significantly reduce the total DoS severity of known vectors.
> 
> On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
> 
> > Limits on block construction that cross transactions make it harder to accurately estimate fees and greatly complicate optimal block construction-- the latter being important because smarter and more computer powered mining code generating higher profits is a pro centralization factor.
> > 
> > In terms of effectiveness the "spam" will just make itself indistinguishable from the most common transaction traffic from the perspective of such metrics-- and might well drive up "spam" levels because the higher embedding cost may make some of them use more transactions. The competition for these buckets by other traffic could make it effectively a block size reduction even against very boring ordinary transactions. ... which is probably not what most people want.
> > 
> > I think it's important to keep in mind that bitcoin fee levels even at 0.1s/vb are far beyond what other hosting services and other blockchains cost-- so anyone still embedding data in bitcoin *really* want to be there for some reason and aren't too fee sensitive or else they'd already be using something else... some are even in favor of higher costs since the high fees are what create the scarcity needed for their seigniorage.
> > 
> > But yeah I think your comments on priorities are correct.
> > 
> > 
> > 
> > On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> wrote:
> > 
> > > Hi list,
> > > 
> > > Thanks to the annex covered by the signature, I don't see how the concern about limiting
> > > the extensibility of bitcoin script with future (post-quantum) cryptographic schemes.
> > > Previous proposal of the annex were deliberately designed with variable-length fields
> > > to flexibly accomodate a wide range of things.
> > > 
> > > I believe there is one thing that has not been proposed to limit unpredictable utterance
> > > of spams on the blockchain, namely congestion control of categories of outputs (e.g "fat"
> > > scriptpubkeys). Let's say P a block period, T a type of scriptpubkey and L a limiting
> > > threshold for the number of T occurences during the period P. Beyond the L threshold, any
> > > additional T scriptpubkey is making the block invalid. Or alternatively, any additional
> > > T generating / spending transaction must pay some weight penalty...
> > > 
> > > Congestion control, which of course comes with its lot of shenanigans, is not very a novel
> > > idea as I believe it has been floated few times in the context of lightning to solve mass
> > > closure, where channels out-priced at current feerate would have their safety timelocks scale
> > > ups.
> > > 
> > > No need anymore to come to social consensus on what is quantitative "spam" or not. The blockchain
> > > would automatically throttle out the block space spamming transaction. Qualitative spam it's another
> > > question, for anyone who has ever read shannon's theory of communication only effective thing can
> > > be to limit the size of data payload. But probably we're kickly back to a non-mathematically solvable
> > > linguistical question again [0].
> > > 
> > > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor of prioritizing
> > > a timewarp fix and limiting dosy spends by old redeem scripts, rather than engaging in shooting
> > > ourselves in the foot with ill-designed "spam" consensus mitigations.
> > > 
> > > [0] If you have a soul of logician, it would be an interesting demonstration to come with
> > > to establish that we cannot come up with mathematically or cryptographically consensus means
> > > to solve qualitative "spam", which in a very pure sense is a linguistical issue.
> > > 
> > > Best,
> > > Antoine
> > > OTS hash: 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
> > > Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit :
> > > 
> > > > Hi,
> > > > 
> > > > This approach was discussed last year when evaluating the best way to mitigate DoS blocks in terms
> > > > of gains compared to confiscatory surface. Limiting the size of created scriptPubKeys is not a
> > > > sufficient mitigation on its own, and has a non-trivial confiscatory surface.
> > > > 
> > > > One of the goal of BIP54 is to address objections to Matt's earlier proposal, notably the (in my
> > > > opinion reasonable) confiscation concerns voiced by Russell O'Connor. Limiting the size of
> > > > scriptPubKeys would in this regard be moving in the opposite direction.
> > > > 
> > > > Various approaches of limiting the size of spent scriptPubKeys were discussed, in forms that would
> > > > mitigate the confiscatory surface, to adopt in addition to (what eventually became) the BIP54 sigops
> > > > limit. However i decided against including this additional measure in BIP54 because:
> > > > - of the inherent complexity of the discussed schemes, which would make it hard to reason about
> > > > constructing transactions spending legacy inputs, and equally hard to evaluate the reduction of
> > > > the confiscatory surface;
> > > > - more importantly, there is steep diminishing returns to piling on more mitigations. The BIP54
> > > > limit on its own prevents an externally-motivated attacker from *unevenly* stalling the network
> > > > for dozens of minutes, and a revenue-maximizing miner from regularly stalling its competitions
> > > > for dozens of seconds, at a minimized cost in confiscatory surface. Additional mitigations reduce
> > > > the worst case validation time by a smaller factor at a higher cost in terms of confiscatory
> > > > surface. It "feels right" to further reduce those numbers, but it's less clear what the tangible
> > > > gains would be.
> > > > 
> > > > Furthermore, it's always possible to get the biggest bang for our buck in a first step and going the
> > > > extra mile in a later, more controversial, soft fork. I previously floated the idea of a "cleanup
> > > > v2" in private discussions, and i think besides a reduction of the maximum scriptPubKey size it
> > > > should feature a consensus-enforced maximum transaction size for the reasons stated here:
> > > > https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. I wouldn't hold my
> > > > breath on such a "cleanup v2", but it may be useful to have it documented somewhere.
> > > > 
> > > > I'm trying to not go into much details regarding which mitigations were considered in designing
> > > > BIP54, because they are tightly related to the design of various DoS blocks. But i'm always happy to
> > > > rehash the decisions made there and (re-)consider alternative approaches on the semi-private Delving
> > > > thread [0] dedicated to this purpose. Feel free to ping me to get access if i know you.
> > > > 
> > > > Best,
> > > > Antoine Poinsot
> > > > 
> > > > [0]: https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
> > > > 
> > > > 
> > > > 
> > > > 
> > > > On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <fre...@reardencode.com> wrote:
> > > > 
> > > > >
> > > > >
> > > > > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
> > > > >
> > > > > > But also given that there are essentially no violations and no reason to
> > > > > > expect any I'm not sure the proposal is worth time relative to fixes of
> > > > > > actual moderately serious DOS attack issues.
> > > > >
> > > > >
> > > > > I believe this limit would also stop most (all?) of PortlandHODL's
> > > > > DoSblocks without having to make some of the other changes in GCC. I
> > > > > think it's worthwhile to compare this approach to those proposed by
> > > > > Antoine in solving these DoS vectors.
> > > > >
> > > > > Best,
> > > > >
> > > > > --Brandon
> > > > >
> > > > > --
> > > > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > > > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
> > > 
> > > --
> > > You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> > > To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+...@googlegroups.com.
> > 
> > > To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com.
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/o5Ewtxc0zflnX5G_CXkntdAO8ZRi_seKPovZ-bJs8Lq-CY-ClLMyINd-eQ0vcIETWMdD5fCE_31HbTBy3U7iEopZjT0H5LNTXTc3eAL6hLE%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-18 12:06  1%             ` PortlandHODL
@ 2025-10-18 16:54  0%               ` /dev /fd0
  2025-10-22  8:07  0%               ` 'moonsettler' via Bitcoin Development Mailing List
  1 sibling, 0 replies; 200+ results
From: /dev /fd0 @ 2025-10-18 16:54 UTC (permalink / raw)
  To: PortlandHODL; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 19322 bytes --]

Hi portlandhold,

> PortlandHODL: I reject this completely as this would remove the UTXOset
omission for the scriptPubkey

Your proposed solution would affect the UTXO set negatively if someone is
really motivated to use scriptpubkey for arbitrary data. They will use
multiple outputs as people do with [DNS records][0].

> and encourage miners to subvert the OP_RETURN restriction and instead
just use another op_code

What would motivate users to follow this approach, considering that storing
data in the witness is cheaper?

[0]: https://asherfalcon.com/blog/posts/2
[1]: https://docs.ordinals.com/guides/batch-inscribing.html

/dev/fd0
floppy disk guy


On Sat, Oct 18, 2025 at 6:45 PM PortlandHODL <admin@qrsnap.io> wrote:

> Hey,
>
> First, thank you to everyone who responded, and please continue to do so.
> There were many thought provoking responses and this did shift my
> perspective quite a bit from the original post, which in of itself was the
> goal to a degree.
>
> I am currently only going to respond to all of the current concerns. Acks;
> though I like them will be ignored unless new discoveries are included.
>
> Tl;dr (Portlands Perspective)
>  - Confiscation is a problem because of presigned transactions
>  - DoS mitigation could also occur through marking UTXOs as unspendable if
> > 520 bytes, this would preserve the proof of publication.
>  - Timeout / Sunset logic is compelling
>  - The (n) value of acceptable needed bytes is contentious with the lower
> suggested limit being 67
>  - Congestion control is worth a look?
>
> Next Step:
>  - Deeper discussion at the individual level: Antoine Poinsot and GCC
> overlap?
>  - Write an implementation.
>  - Decide to pursue BIP
>
> Responses
>
> Andrew Poelstra:
> > There is a risk of confiscation of coins which have pre-signed but
> > unpublished transactions spending them to new outputs with large
> > scriptPubKeys. Due to long-standing standardness rules, and the presence
> > of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any
> > such transactions exist.
>
> PortlandHODL: This is a risk that can be incurred and likely not possible
> to mitigate as there could be possible chains of transactions so even when
> recursively iterating over a chain there is a chance that a presigned
> breaks this rule. Every idea I have had from block redemption limits on
> prevouts seems to just be a coverage issue where you can make the
> confiscation less likely but not completely mitigated.
>
> Second, there are already TXs that effectively have been confiscated at
> the policy level (P2SH Cleanstack violation) where the user can not find
> any miner with a policy to accept these into their mempool. (3 years)
>
> /dev /fd0
> >  so it would be great if this was restricted to OP_RETURN
>
> PortlandHODL: I reject this completely as this would remove the UTXOset
> omission for the scriptPubkey and encourage miners to subvert the OP_RETURN
> restriction and instead just use another op_code, this also do not hit on
> some of the most important factors such as DoS mitigation and legacy script
> attack surface reduction.
>
> Peter Todd
> > NACK ...
>
> PortlandHODL: You NACK'd for the same reasons that I stated in my OP,
> without including any additional context or reasoning.
>
> jeremy
> > I think that this type of rule is OK if we do it as a "sunsetting"
> restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2
> years, 5 years, 10 years).
>
> If action is taken, this is the most reasonable approach. Alleviating
> confiscatory concerns through deferral.
>
> > You can argue against this example probably, but it is worth considering
> that absence of evidence of use is not evidence of absence of use and I
> myself feel that overall our understanding of Bitcoin transaction
> programming possibilities is still early.  If you don't like this example,
> I can give you others (probably).
>
> Agreed and this also falls into the reasoning for deciding to utilize
> point 1 in your response. My thoughts on this would be along the lines of
> proof of publication as this change only has the effect of stripping away
> the executable portion of a script between 521 and 10_000 bytes or the
> published data portion if > 10_000 bytes which the same data could likely
> be published in chunked segments using outpoints.
>
> Andrew Poelstra:
> > Aside from proof-of-publication (i.e. data storage directly in the UTXO
> > set) there is no usage of script which can't be equally (or better)
> > accomplished by using a Segwit v0 or Taproot script.
>
> This sums up the majority of future usecase concern
>
> Anthony Towns:
> > (If you restricted the change to only applying to scripts that used
> non-push operators, that would probably still provide upgrade flexibility
> while also preventing potential script abuses. But it wouldn't do anything
> to prevent publishing data)
>
> Could this not be done as segments in multiple outpoints using a
> coordination outpoint? I fail to see why publication proof must be in a
> single chunk. This does though however bring another alternative to mind,
> just making these outpoints unspendable but not invalidate the block
> through inclusion...
>
> > As far as the "but contiguous data will be regulated more strictly"
> argument goes; I don't think "your honour, my offensive content has
> strings of 4d0802 every 520 bytes
>
> Correct, this was never meant to resolve this issue.
>
> Luke Dashjr:
> > If we're going this route, we should just close all the gaps for the
> immediate future:
>
> To put it nicely, this is completely beyond the scope of what is being
> proposed.
>
> Guus Ellenkamp:
> > If there are really so few OP_RETURN outputs more than 144 bytes, then
> why increase the limit if that change is so controversial? It seems
> people who want to use a larger OP_RETURN size do it anyway, even with
> the current default limits.
>
> Completely off topic and irrelevant
>
> Greg Tonoski:
> > Limiting the maximum size of the scriptPubKey of a transaction to 67
> bytes.
>
> This leave no room to deal with broken hashing algorithms and very little
> future upgradability for hooks. The rest of these points should be merged
> with Lukes response and either hijack my thread or start a new one with the
> increased scope, any approach I take will only be related to the
> ScriptPubkey
>
> Keagan McClelland:
> > Hard NACK on capping the witness size as that would effectively ban
> large scripts even in the P2SH wrapper which undermines Bitcoin's ability
> to be an effectively programmable money.
>
> This has nothing to do with the witness size or even the P2SH wrapper
>
> Casey Rodarmor:
> > I think that "Bitcoin could need it in the future?" might be a good
> enough
> reason not to do this.
>
> > Script pubkeys are the only variable-length transaction fields which can
> be
> covered by input signatures, which might make them useful for future soft
> forks. I can imagine confidential asset schemes or post-quantum coin
> recovery
> schemes requiring large proofs in the outputs, where the validity of the
> proof
> determined whether or not the transaction is valid, and thus require the
> proofs to be in the outputs, and not just a hash commitment.
>
> Would the ability to publish the data alone be enough? Example make the
> output unspendable but allow for the existence of the bytes to be covered
> through the signature?
>
>
> Antoine Poinsot:
> > Limiting the size of created scriptPubKeys is not a sufficient
> mitigation on its own
> I fail to see how this would not be sufficient? To DoS you need 2 things
> inputs with ScriptPubkey redemptions + heavy op_codes that require unique
> checks. Example DUPing stack element again and again doesn't work. This
> then leads to the next part is you could get up to unique complex
> operations with the current (n) limit included per input.
>
> > One of the goal of BIP54 is to address objections to Matt's earlier
> proposal, notably the (in my
> opinion reasonable) confiscation concerns voiced by Russell O'Connor.
> Limiting the size of
> scriptPubKeys would in this regard be moving in the opposite direction.
>
> Some notes is I would actually go as far as to say the confiscation risk
> is higher with the TX limit proposed in BIP54 as we actually have proof of
> redemption of TXs that break that rule and the input set to do this already
> exists on-chain no need to even wonder about the whole presigned.
> bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
>
> Please let me know if I am incorrect on any of this.
>
> > Furthermore, it's always possible to get the biggest bang for our buck
> in a first step
>
> Agreed on bang for the buck regarding DoS.
>
> My final point here would be that I would like to discuss more, and this
> is response is from the initial view of your response and could be
> incomplete or incorrect, This is just my in the moment response.
>
> Antoine Riard:
> > Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
> favor of prioritizing
> a timewarp fix and limiting dosy spends by old redeem scripts
>
> The idea of congestion control is interesting, but this solution should
> significantly reduce the total DoS severity of known vectors.
>
> On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:
>
>> Limits on block construction that cross transactions make it harder to
>> accurately estimate fees and greatly complicate optimal block
>> construction--  the latter being important because smarter and more
>> computer powered mining code generating higher profits is a pro
>> centralization factor.
>>
>> In terms of effectiveness the "spam" will just make itself
>> indistinguishable from the most common transaction traffic from the
>> perspective of such metrics--  and might well drive up "spam" levels
>> because the higher embedding cost may make some of them use more
>> transactions.  The competition for these buckets by other traffic could
>> make it effectively a block size reduction even against very boring
>> ordinary transactions.  ... which is probably not what most people want.
>>
>> I think it's important to keep in mind that bitcoin fee levels even at
>> 0.1s/vb are far beyond what other hosting services and other blockchains
>> cost-- so anyone still embedding data in bitcoin *really* want to be there
>> for some reason and aren't too fee sensitive or else they'd already be
>> using something else... some are even in favor of higher costs since the
>> high fees are what create the scarcity needed for their seigniorage.
>>
>> But yeah I think your comments on priorities are correct.
>>
>>
>> On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com>
>> wrote:
>>
>>> Hi list,
>>>
>>> Thanks to the annex covered by the signature, I don't see how the
>>> concern about limiting
>>> the extensibility of bitcoin script with future (post-quantum)
>>> cryptographic schemes.
>>> Previous proposal of the annex were deliberately designed with
>>> variable-length fields
>>> to flexibly accomodate a wide range of things.
>>>
>>> I believe there is one thing that has not been proposed to limit
>>> unpredictable utterance
>>> of spams on the blockchain, namely congestion control of categories of
>>> outputs (e.g "fat"
>>> scriptpubkeys). Let's say P a block period, T a type of scriptpubkey and
>>> L a limiting
>>> threshold for the number of T occurences during the period P. Beyond the
>>> L threshold, any
>>> additional T scriptpubkey is making the block invalid. Or alternatively,
>>> any additional
>>> T generating / spending transaction must pay some weight penalty...
>>>
>>> Congestion control, which of course comes with its lot of shenanigans,
>>> is not very a novel
>>> idea as I believe it has been floated few times in the context of
>>> lightning to solve mass
>>> closure, where channels out-priced at current feerate would have their
>>> safety timelocks scale
>>> ups.
>>>
>>> No need anymore to come to social consensus on what is quantitative
>>> "spam" or not. The blockchain
>>> would automatically throttle out the block space spamming transaction.
>>> Qualitative spam it's another
>>> question, for anyone who has ever read shannon's theory of communication
>>> only effective thing can
>>> be to limit the size of data payload. But probably we're kickly back to
>>> a non-mathematically solvable
>>> linguistical question again [0].
>>>
>>> Anyway, in the sleeping pond of consensus fixes fishes, I'm more in
>>> favor of prioritizing
>>> a timewarp fix and limiting dosy spends by old redeem scripts, rather
>>> than engaging in shooting
>>> ourselves in the foot with ill-designed "spam" consensus mitigations.
>>>
>>> [0] If you have a soul of logician, it would be an interesting
>>> demonstration to come with
>>> to establish that we cannot come up with mathematically or
>>> cryptographically consensus means
>>> to solve qualitative "spam", which in a very pure sense is a
>>> linguistical issue.
>>>
>>> Best,
>>> Antoine
>>> OTS hash:
>>> 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
>>> Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit :
>>>
>>>> Hi,
>>>>
>>>> This approach was discussed last year when evaluating the best way to
>>>> mitigate DoS blocks in terms
>>>> of gains compared to confiscatory surface. Limiting the size of created
>>>> scriptPubKeys is not a
>>>> sufficient mitigation on its own, and has a non-trivial confiscatory
>>>> surface.
>>>>
>>>> One of the goal of BIP54 is to address objections to Matt's earlier
>>>> proposal, notably the (in my
>>>> opinion reasonable) confiscation concerns voiced by Russell O'Connor.
>>>> Limiting the size of
>>>> scriptPubKeys would in this regard be moving in the opposite direction.
>>>>
>>>> Various approaches of limiting the size of spent scriptPubKeys were
>>>> discussed, in forms that would
>>>> mitigate the confiscatory surface, to adopt in addition to (what
>>>> eventually became) the BIP54 sigops
>>>> limit. However i decided against including this additional measure in
>>>> BIP54 because:
>>>> - of the inherent complexity of the discussed schemes, which would make
>>>> it hard to reason about
>>>> constructing transactions spending legacy inputs, and equally hard to
>>>> evaluate the reduction of
>>>> the confiscatory surface;
>>>> - more importantly, there is steep diminishing returns to piling on
>>>> more mitigations. The BIP54
>>>> limit on its own prevents an externally-motivated attacker from
>>>> *unevenly* stalling the network
>>>> for dozens of minutes, and a revenue-maximizing miner from regularly
>>>> stalling its competitions
>>>> for dozens of seconds, at a minimized cost in confiscatory surface.
>>>> Additional mitigations reduce
>>>> the worst case validation time by a smaller factor at a higher cost in
>>>> terms of confiscatory
>>>> surface. It "feels right" to further reduce those numbers, but it's
>>>> less clear what the tangible
>>>> gains would be.
>>>>
>>>> Furthermore, it's always possible to get the biggest bang for our buck
>>>> in a first step and going the
>>>> extra mile in a later, more controversial, soft fork. I previously
>>>> floated the idea of a "cleanup
>>>> v2" in private discussions, and i think besides a reduction of the
>>>> maximum scriptPubKey size it
>>>> should feature a consensus-enforced maximum transaction size for the
>>>> reasons stated here:
>>>>
>>>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8.
>>>> I wouldn't hold my
>>>> breath on such a "cleanup v2", but it may be useful to have it
>>>> documented somewhere.
>>>>
>>>> I'm trying to not go into much details regarding which mitigations were
>>>> considered in designing
>>>> BIP54, because they are tightly related to the design of various DoS
>>>> blocks. But i'm always happy to
>>>> rehash the decisions made there and (re-)consider alternative
>>>> approaches on the semi-private Delving
>>>> thread [0] dedicated to this purpose. Feel free to ping me to get
>>>> access if i know you.
>>>>
>>>> Best,
>>>> Antoine Poinsot
>>>>
>>>> [0]:
>>>> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
>>>>
>>>>
>>>>
>>>>
>>>> On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>>>> fre...@reardencode.com> wrote:
>>>>
>>>> >
>>>> >
>>>> > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
>>>> >
>>>> > > But also given that there are essentially no violations and no
>>>> reason to
>>>> > > expect any I'm not sure the proposal is worth time relative to
>>>> fixes of
>>>> > > actual moderately serious DOS attack issues.
>>>> >
>>>> >
>>>> > I believe this limit would also stop most (all?) of PortlandHODL's
>>>> > DoSblocks without having to make some of the other changes in GCC. I
>>>> > think it's worthwhile to compare this approach to those proposed by
>>>> > Antoine in solving these DoS vectors.
>>>> >
>>>> > Best,
>>>> >
>>>> > --Brandon
>>>> >
>>>> > --
>>>> > You received this message because you are subscribed to the Google
>>>> Groups "Bitcoin Development Mailing List" group.
>>>> > To unsubscribe from this group and stop receiving emails from it,
>>>> send an email to bitcoindev+...@googlegroups.com.
>>>> > To view this discussion visit
>>>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
>>>>
>>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Bitcoin Development Mailing List" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to bitcoindev+...@googlegroups.com.
>>>
>> To view this discussion visit
>>> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com
>>> <https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com?utm_medium=email&utm_source=footer>
>>> .
>>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALiT-ZpYav87WPn-hrFEcSrvLet95_B%3DMPzqi6kk%3D_nSnQj1VQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 21517 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-18  4:03  1%           ` Greg Maxwell
@ 2025-10-18 12:06  1%             ` PortlandHODL
  2025-10-18 16:54  0%               ` /dev /fd0
  2025-10-22  8:07  0%               ` 'moonsettler' via Bitcoin Development Mailing List
  0 siblings, 2 replies; 200+ results
From: PortlandHODL @ 2025-10-18 12:06 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 17644 bytes --]

Hey, 

First, thank you to everyone who responded, and please continue to do so. 
There were many thought provoking responses and this did shift my 
perspective quite a bit from the original post, which in of itself was the 
goal to a degree.

I am currently only going to respond to all of the current concerns. Acks; 
though I like them will be ignored unless new discoveries are included.

Tl;dr (Portlands Perspective)
 - Confiscation is a problem because of presigned transactions
 - DoS mitigation could also occur through marking UTXOs as unspendable if 
> 520 bytes, this would preserve the proof of publication.
 - Timeout / Sunset logic is compelling
 - The (n) value of acceptable needed bytes is contentious with the lower 
suggested limit being 67
 - Congestion control is worth a look?

Next Step:
 - Deeper discussion at the individual level: Antoine Poinsot and GCC 
overlap? 
 - Write an implementation.
 - Decide to pursue BIP

Responses

Andrew Poelstra: 
> There is a risk of confiscation of coins which have pre-signed but
> unpublished transactions spending them to new outputs with large
> scriptPubKeys. Due to long-standing standardness rules, and the presence
> of P2SH (and now P2WSH) for well over a decade, I'm skeptical that any
> such transactions exist.

PortlandHODL: This is a risk that can be incurred and likely not possible 
to mitigate as there could be possible chains of transactions so even when 
recursively iterating over a chain there is a chance that a presigned 
breaks this rule. Every idea I have had from block redemption limits on 
prevouts seems to just be a coverage issue where you can make the 
confiscation less likely but not completely mitigated.

Second, there are already TXs that effectively have been confiscated at the 
policy level (P2SH Cleanstack violation) where the user can not find any 
miner with a policy to accept these into their mempool. (3 years)

/dev /fd0
>  so it would be great if this was restricted to OP_RETURN

PortlandHODL: I reject this completely as this would remove the UTXOset 
omission for the scriptPubkey and encourage miners to subvert the OP_RETURN 
restriction and instead just use another op_code, this also do not hit on 
some of the most important factors such as DoS mitigation and legacy script 
attack surface reduction.

Peter Todd
> NACK ...

PortlandHODL: You NACK'd for the same reasons that I stated in my OP, 
without including any additional context or reasoning. 

jeremy
> I think that this type of rule is OK if we do it as a "sunsetting" 
restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
years, 5 years, 10 years).

If action is taken, this is the most reasonable approach. Alleviating 
confiscatory concerns through deferral. 

> You can argue against this example probably, but it is worth considering 
that absence of evidence of use is not evidence of absence of use and I 
myself feel that overall our understanding of Bitcoin transaction 
programming possibilities is still early.  If you don't like this example, 
I can give you others (probably).

Agreed and this also falls into the reasoning for deciding to utilize point 
1 in your response. My thoughts on this would be along the lines of proof 
of publication as this change only has the effect of stripping away the 
executable portion of a script between 521 and 10_000 bytes or the 
published data portion if > 10_000 bytes which the same data could likely 
be published in chunked segments using outpoints.

Andrew Poelstra:
> Aside from proof-of-publication (i.e. data storage directly in the UTXO
> set) there is no usage of script which can't be equally (or better)
> accomplished by using a Segwit v0 or Taproot script.

This sums up the majority of future usecase concern

Anthony Towns:
> (If you restricted the change to only applying to scripts that used
non-push operators, that would probably still provide upgrade flexibility
while also preventing potential script abuses. But it wouldn't do anything
to prevent publishing data)

Could this not be done as segments in multiple outpoints using a 
coordination outpoint? I fail to see why publication proof must be in a 
single chunk. This does though however bring another alternative to mind, 
just making these outpoints unspendable but not invalidate the block 
through inclusion... 

> As far as the "but contiguous data will be regulated more strictly"
argument goes; I don't think "your honour, my offensive content has
strings of 4d0802 every 520 bytes

Correct, this was never meant to resolve this issue.

Luke Dashjr:
> If we're going this route, we should just close all the gaps for the 
immediate future:

To put it nicely, this is completely beyond the scope of what is being 
proposed.

Guus Ellenkamp:
> If there are really so few OP_RETURN outputs more than 144 bytes, then
why increase the limit if that change is so controversial? It seems
people who want to use a larger OP_RETURN size do it anyway, even with
the current default limits.

Completely off topic and irrelevant

Greg Tonoski:
> Limiting the maximum size of the scriptPubKey of a transaction to 67 
bytes.

This leave no room to deal with broken hashing algorithms and very little 
future upgradability for hooks. The rest of these points should be merged 
with Lukes response and either hijack my thread or start a new one with the 
increased scope, any approach I take will only be related to the 
ScriptPubkey

Keagan McClelland:
> Hard NACK on capping the witness size as that would effectively ban large 
scripts even in the P2SH wrapper which undermines Bitcoin's ability to be 
an effectively programmable money.

This has nothing to do with the witness size or even the P2SH wrapper

Casey Rodarmor:
> I think that "Bitcoin could need it in the future?" might be a good enough
reason not to do this.

> Script pubkeys are the only variable-length transaction fields which can 
be
covered by input signatures, which might make them useful for future soft
forks. I can imagine confidential asset schemes or post-quantum coin 
recovery
schemes requiring large proofs in the outputs, where the validity of the 
proof
determined whether or not the transaction is valid, and thus require the
proofs to be in the outputs, and not just a hash commitment.

Would the ability to publish the data alone be enough? Example make the 
output unspendable but allow for the existence of the bytes to be covered 
through the signature?


Antoine Poinsot:
> Limiting the size of created scriptPubKeys is not a sufficient mitigation 
on its own
I fail to see how this would not be sufficient? To DoS you need 2 things 
inputs with ScriptPubkey redemptions + heavy op_codes that require unique 
checks. Example DUPing stack element again and again doesn't work. This 
then leads to the next part is you could get up to unique complex 
operations with the current (n) limit included per input.

> One of the goal of BIP54 is to address objections to Matt's earlier 
proposal, notably the (in my
opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
Limiting the size of
scriptPubKeys would in this regard be moving in the opposite direction.

Some notes is I would actually go as far as to say the confiscation risk is 
higher with the TX limit proposed in BIP54 as we actually have proof of 
redemption of TXs that break that rule and the input set to do this already 
exists on-chain no need to even wonder about the whole presigned. 
bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08

Please let me know if I am incorrect on any of this.

> Furthermore, it's always possible to get the biggest bang for our buck in 
a first step 

Agreed on bang for the buck regarding DoS. 

My final point here would be that I would like to discuss more, and this is 
response is from the initial view of your response and could be incomplete 
or incorrect, This is just my in the moment response.

Antoine Riard:
> Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor 
of prioritizing
a timewarp fix and limiting dosy spends by old redeem scripts

The idea of congestion control is interesting, but this solution should 
significantly reduce the total DoS severity of known vectors. 

On Saturday, October 18, 2025 at 2:25:18 AM UTC-7 Greg Maxwell wrote:

> Limits on block construction that cross transactions make it harder to 
> accurately estimate fees and greatly complicate optimal block 
> construction--  the latter being important because smarter and more 
> computer powered mining code generating higher profits is a pro 
> centralization factor.
>
> In terms of effectiveness the "spam" will just make itself 
> indistinguishable from the most common transaction traffic from the 
> perspective of such metrics--  and might well drive up "spam" levels 
> because the higher embedding cost may make some of them use more 
> transactions.  The competition for these buckets by other traffic could 
> make it effectively a block size reduction even against very boring 
> ordinary transactions.  ... which is probably not what most people want.
>
> I think it's important to keep in mind that bitcoin fee levels even at 
> 0.1s/vb are far beyond what other hosting services and other blockchains 
> cost-- so anyone still embedding data in bitcoin *really* want to be there 
> for some reason and aren't too fee sensitive or else they'd already be 
> using something else... some are even in favor of higher costs since the 
> high fees are what create the scarcity needed for their seigniorage.
>
> But yeah I think your comments on priorities are correct.
>
>
> On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoin...@gmail.com> wrote:
>
>> Hi list,
>>
>> Thanks to the annex covered by the signature, I don't see how the concern 
>> about limiting
>> the extensibility of bitcoin script with future (post-quantum) 
>> cryptographic schemes.
>> Previous proposal of the annex were deliberately designed with 
>> variable-length fields
>> to flexibly accomodate a wide range of things.
>>
>> I believe there is one thing that has not been proposed to limit 
>> unpredictable utterance
>> of spams on the blockchain, namely congestion control of categories of 
>> outputs (e.g "fat"
>> scriptpubkeys). Let's say P a block period, T a type of scriptpubkey and 
>> L a limiting
>> threshold for the number of T occurences during the period P. Beyond the 
>> L threshold, any
>> additional T scriptpubkey is making the block invalid. Or alternatively, 
>> any additional
>> T generating / spending transaction must pay some weight penalty...
>>
>> Congestion control, which of course comes with its lot of shenanigans, is 
>> not very a novel
>> idea as I believe it has been floated few times in the context of 
>> lightning to solve mass
>> closure, where channels out-priced at current feerate would have their 
>> safety timelocks scale
>> ups.
>>
>> No need anymore to come to social consensus on what is quantitative 
>> "spam" or not. The blockchain
>> would automatically throttle out the block space spamming transaction. 
>> Qualitative spam it's another
>> question, for anyone who has ever read shannon's theory of communication 
>> only effective thing can
>> be to limit the size of data payload. But probably we're kickly back to a 
>> non-mathematically solvable
>> linguistical question again [0].
>>
>> Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor 
>> of prioritizing
>> a timewarp fix and limiting dosy spends by old redeem scripts, rather 
>> than engaging in shooting
>> ourselves in the foot with ill-designed "spam" consensus mitigations.
>>
>> [0] If you have a soul of logician, it would be an interesting 
>> demonstration to come with
>> to establish that we cannot come up with mathematically or 
>> cryptographically consensus means
>> to solve qualitative "spam", which in a very pure sense is a linguistical 
>> issue.
>>
>> Best,
>> Antoine
>> OTS hash: 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
>> Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit :
>>
>>> Hi, 
>>>
>>> This approach was discussed last year when evaluating the best way to 
>>> mitigate DoS blocks in terms 
>>> of gains compared to confiscatory surface. Limiting the size of created 
>>> scriptPubKeys is not a 
>>> sufficient mitigation on its own, and has a non-trivial confiscatory 
>>> surface. 
>>>
>>> One of the goal of BIP54 is to address objections to Matt's earlier 
>>> proposal, notably the (in my 
>>> opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
>>> Limiting the size of 
>>> scriptPubKeys would in this regard be moving in the opposite direction. 
>>>
>>> Various approaches of limiting the size of spent scriptPubKeys were 
>>> discussed, in forms that would 
>>> mitigate the confiscatory surface, to adopt in addition to (what 
>>> eventually became) the BIP54 sigops 
>>> limit. However i decided against including this additional measure in 
>>> BIP54 because: 
>>> - of the inherent complexity of the discussed schemes, which would make 
>>> it hard to reason about 
>>> constructing transactions spending legacy inputs, and equally hard to 
>>> evaluate the reduction of 
>>> the confiscatory surface; 
>>> - more importantly, there is steep diminishing returns to piling on more 
>>> mitigations. The BIP54 
>>> limit on its own prevents an externally-motivated attacker from 
>>> *unevenly* stalling the network 
>>> for dozens of minutes, and a revenue-maximizing miner from regularly 
>>> stalling its competitions 
>>> for dozens of seconds, at a minimized cost in confiscatory surface. 
>>> Additional mitigations reduce 
>>> the worst case validation time by a smaller factor at a higher cost in 
>>> terms of confiscatory 
>>> surface. It "feels right" to further reduce those numbers, but it's less 
>>> clear what the tangible 
>>> gains would be. 
>>>
>>> Furthermore, it's always possible to get the biggest bang for our buck 
>>> in a first step and going the 
>>> extra mile in a later, more controversial, soft fork. I previously 
>>> floated the idea of a "cleanup 
>>> v2" in private discussions, and i think besides a reduction of the 
>>> maximum scriptPubKey size it 
>>> should feature a consensus-enforced maximum transaction size for the 
>>> reasons stated here: 
>>>
>>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
>>> I wouldn't hold my 
>>> breath on such a "cleanup v2", but it may be useful to have it 
>>> documented somewhere. 
>>>
>>> I'm trying to not go into much details regarding which mitigations were 
>>> considered in designing 
>>> BIP54, because they are tightly related to the design of various DoS 
>>> blocks. But i'm always happy to 
>>> rehash the decisions made there and (re-)consider alternative approaches 
>>> on the semi-private Delving 
>>> thread [0] dedicated to this purpose. Feel free to ping me to get access 
>>> if i know you. 
>>>
>>> Best, 
>>> Antoine Poinsot 
>>>
>>> [0]: 
>>> https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711 
>>>
>>>
>>>
>>>
>>> On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>>> fre...@reardencode.com> wrote: 
>>>
>>> > 
>>> > 
>>> > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote: 
>>> > 
>>> > > But also given that there are essentially no violations and no 
>>> reason to 
>>> > > expect any I'm not sure the proposal is worth time relative to fixes 
>>> of 
>>> > > actual moderately serious DOS attack issues. 
>>> > 
>>> > 
>>> > I believe this limit would also stop most (all?) of PortlandHODL's 
>>> > DoSblocks without having to make some of the other changes in GCC. I 
>>> > think it's worthwhile to compare this approach to those proposed by 
>>> > Antoine in solving these DoS vectors. 
>>> > 
>>> > Best, 
>>> > 
>>> > --Brandon 
>>> > 
>>> > -- 
>>> > You received this message because you are subscribed to the Google 
>>> Groups "Bitcoin Development Mailing List" group. 
>>> > To unsubscribe from this group and stop receiving emails from it, send 
>>> an email to bitcoindev+...@googlegroups.com. 
>>> > To view this discussion visit 
>>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console. 
>>>
>>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/78475572-3e52-44e4-8116-8f1a917995a4n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 20637 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-18  1:01  1%         ` Antoine Riard
@ 2025-10-18  4:03  1%           ` Greg Maxwell
  2025-10-18 12:06  1%             ` PortlandHODL
  0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-10-18  4:03 UTC (permalink / raw)
  To: Antoine Riard; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 8778 bytes --]

Limits on block construction that cross transactions make it harder to
accurately estimate fees and greatly complicate optimal block
construction--  the latter being important because smarter and more
computer powered mining code generating higher profits is a pro
centralization factor.

In terms of effectiveness the "spam" will just make itself
indistinguishable from the most common transaction traffic from the
perspective of such metrics--  and might well drive up "spam" levels
because the higher embedding cost may make some of them use more
transactions.  The competition for these buckets by other traffic could
make it effectively a block size reduction even against very boring
ordinary transactions.  ... which is probably not what most people want.

I think it's important to keep in mind that bitcoin fee levels even at
0.1s/vb are far beyond what other hosting services and other blockchains
cost-- so anyone still embedding data in bitcoin *really* want to be there
for some reason and aren't too fee sensitive or else they'd already be
using something else... some are even in favor of higher costs since the
high fees are what create the scarcity needed for their seigniorage.

But yeah I think your comments on priorities are correct.


On Sat, Oct 18, 2025 at 1:20 AM Antoine Riard <antoine.riard@gmail.com>
wrote:

> Hi list,
>
> Thanks to the annex covered by the signature, I don't see how the concern
> about limiting
> the extensibility of bitcoin script with future (post-quantum)
> cryptographic schemes.
> Previous proposal of the annex were deliberately designed with
> variable-length fields
> to flexibly accomodate a wide range of things.
>
> I believe there is one thing that has not been proposed to limit
> unpredictable utterance
> of spams on the blockchain, namely congestion control of categories of
> outputs (e.g "fat"
> scriptpubkeys). Let's say P a block period, T a type of scriptpubkey and L
> a limiting
> threshold for the number of T occurences during the period P. Beyond the L
> threshold, any
> additional T scriptpubkey is making the block invalid. Or alternatively,
> any additional
> T generating / spending transaction must pay some weight penalty...
>
> Congestion control, which of course comes with its lot of shenanigans, is
> not very a novel
> idea as I believe it has been floated few times in the context of
> lightning to solve mass
> closure, where channels out-priced at current feerate would have their
> safety timelocks scale
> ups.
>
> No need anymore to come to social consensus on what is quantitative "spam"
> or not. The blockchain
> would automatically throttle out the block space spamming transaction.
> Qualitative spam it's another
> question, for anyone who has ever read shannon's theory of communication
> only effective thing can
> be to limit the size of data payload. But probably we're kickly back to a
> non-mathematically solvable
> linguistical question again [0].
>
> Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor
> of prioritizing
> a timewarp fix and limiting dosy spends by old redeem scripts, rather than
> engaging in shooting
> ourselves in the foot with ill-designed "spam" consensus mitigations.
>
> [0] If you have a soul of logician, it would be an interesting
> demonstration to come with
> to establish that we cannot come up with mathematically or
> cryptographically consensus means
> to solve qualitative "spam", which in a very pure sense is a linguistical
> issue.
>
> Best,
> Antoine
> OTS hash: 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
> Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit :
>
>> Hi,
>>
>> This approach was discussed last year when evaluating the best way to
>> mitigate DoS blocks in terms
>> of gains compared to confiscatory surface. Limiting the size of created
>> scriptPubKeys is not a
>> sufficient mitigation on its own, and has a non-trivial confiscatory
>> surface.
>>
>> One of the goal of BIP54 is to address objections to Matt's earlier
>> proposal, notably the (in my
>> opinion reasonable) confiscation concerns voiced by Russell O'Connor.
>> Limiting the size of
>> scriptPubKeys would in this regard be moving in the opposite direction.
>>
>> Various approaches of limiting the size of spent scriptPubKeys were
>> discussed, in forms that would
>> mitigate the confiscatory surface, to adopt in addition to (what
>> eventually became) the BIP54 sigops
>> limit. However i decided against including this additional measure in
>> BIP54 because:
>> - of the inherent complexity of the discussed schemes, which would make
>> it hard to reason about
>> constructing transactions spending legacy inputs, and equally hard to
>> evaluate the reduction of
>> the confiscatory surface;
>> - more importantly, there is steep diminishing returns to piling on more
>> mitigations. The BIP54
>> limit on its own prevents an externally-motivated attacker from
>> *unevenly* stalling the network
>> for dozens of minutes, and a revenue-maximizing miner from regularly
>> stalling its competitions
>> for dozens of seconds, at a minimized cost in confiscatory surface.
>> Additional mitigations reduce
>> the worst case validation time by a smaller factor at a higher cost in
>> terms of confiscatory
>> surface. It "feels right" to further reduce those numbers, but it's less
>> clear what the tangible
>> gains would be.
>>
>> Furthermore, it's always possible to get the biggest bang for our buck in
>> a first step and going the
>> extra mile in a later, more controversial, soft fork. I previously
>> floated the idea of a "cleanup
>> v2" in private discussions, and i think besides a reduction of the
>> maximum scriptPubKey size it
>> should feature a consensus-enforced maximum transaction size for the
>> reasons stated here:
>>
>> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8.
>> I wouldn't hold my
>> breath on such a "cleanup v2", but it may be useful to have it documented
>> somewhere.
>>
>> I'm trying to not go into much details regarding which mitigations were
>> considered in designing
>> BIP54, because they are tightly related to the design of various DoS
>> blocks. But i'm always happy to
>> rehash the decisions made there and (re-)consider alternative approaches
>> on the semi-private Delving
>> thread [0] dedicated to this purpose. Feel free to ping me to get access
>> if i know you.
>>
>> Best,
>> Antoine Poinsot
>>
>> [0]: https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
>>
>>
>>
>>
>> On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
>> fre...@reardencode.com> wrote:
>>
>> >
>> >
>> > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
>> >
>> > > But also given that there are essentially no violations and no reason
>> to
>> > > expect any I'm not sure the proposal is worth time relative to fixes
>> of
>> > > actual moderately serious DOS attack issues.
>> >
>> >
>> > I believe this limit would also stop most (all?) of PortlandHODL's
>> > DoSblocks without having to make some of the other changes in GCC. I
>> > think it's worthwhile to compare this approach to those proposed by
>> > Antoine in solving these DoS vectors.
>> >
>> > Best,
>> >
>> > --Brandon
>> >
>> > --
>> > You received this message because you are subscribed to the Google
>> Groups "Bitcoin Development Mailing List" group.
>> > To unsubscribe from this group and stop receiving emails from it, send
>> an email to bitcoindev+...@googlegroups.com.
>> > To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgTeerZWCJeMDFXF9sR4vowGsVcbp3M_FypDfSZW2qLZ%2BQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 10328 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  @ 2025-10-18  1:01  1%         ` Antoine Riard
  2025-10-18  4:03  1%           ` Greg Maxwell
  0 siblings, 1 reply; 200+ results
From: Antoine Riard @ 2025-10-18  1:01 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 6697 bytes --]

Hi list,

Thanks to the annex covered by the signature, I don't see how the concern 
about limiting
the extensibility of bitcoin script with future (post-quantum) 
cryptographic schemes.
Previous proposal of the annex were deliberately designed with 
variable-length fields
to flexibly accomodate a wide range of things.

I believe there is one thing that has not been proposed to limit 
unpredictable utterance
of spams on the blockchain, namely congestion control of categories of 
outputs (e.g "fat"
scriptpubkeys). Let's say P a block period, T a type of scriptpubkey and L 
a limiting
threshold for the number of T occurences during the period P. Beyond the L 
threshold, any
additional T scriptpubkey is making the block invalid. Or alternatively, 
any additional
T generating / spending transaction must pay some weight penalty...

Congestion control, which of course comes with its lot of shenanigans, is 
not very a novel
idea as I believe it has been floated few times in the context of lightning 
to solve mass
closure, where channels out-priced at current feerate would have their 
safety timelocks scale
ups.

No need anymore to come to social consensus on what is quantitative "spam" 
or not. The blockchain
would automatically throttle out the block space spamming transaction. 
Qualitative spam it's another
question, for anyone who has ever read shannon's theory of communication 
only effective thing can
be to limit the size of data payload. But probably we're kickly back to a 
non-mathematically solvable
linguistical question again [0].

Anyway, in the sleeping pond of consensus fixes fishes, I'm more in favor 
of prioritizing
a timewarp fix and limiting dosy spends by old redeem scripts, rather than 
engaging in shooting
ourselves in the foot with ill-designed "spam" consensus mitigations.

[0] If you have a soul of logician, it would be an interesting 
demonstration to come with
to establish that we cannot come up with mathematically or 
cryptographically consensus means
to solve qualitative "spam", which in a very pure sense is a linguistical 
issue.

Best,
Antoine
OTS hash: 6cb50fe36ca0ec5cb9a88517dd4ce9bb50dd6ad1d2d6a640dd4a31d72f0e4999
Le vendredi 17 octobre 2025 à 19:45:44 UTC+1, Antoine Poinsot a écrit :

> Hi,
>
> This approach was discussed last year when evaluating the best way to 
> mitigate DoS blocks in terms
> of gains compared to confiscatory surface. Limiting the size of created 
> scriptPubKeys is not a
> sufficient mitigation on its own, and has a non-trivial confiscatory 
> surface.
>
> One of the goal of BIP54 is to address objections to Matt's earlier 
> proposal, notably the (in my
> opinion reasonable) confiscation concerns voiced by Russell O'Connor. 
> Limiting the size of
> scriptPubKeys would in this regard be moving in the opposite direction.
>
> Various approaches of limiting the size of spent scriptPubKeys were 
> discussed, in forms that would
> mitigate the confiscatory surface, to adopt in addition to (what 
> eventually became) the BIP54 sigops
> limit. However i decided against including this additional measure in 
> BIP54 because:
> - of the inherent complexity of the discussed schemes, which would make it 
> hard to reason about
> constructing transactions spending legacy inputs, and equally hard to 
> evaluate the reduction of
> the confiscatory surface;
> - more importantly, there is steep diminishing returns to piling on more 
> mitigations. The BIP54
> limit on its own prevents an externally-motivated attacker from *unevenly* 
> stalling the network
> for dozens of minutes, and a revenue-maximizing miner from regularly 
> stalling its competitions
> for dozens of seconds, at a minimized cost in confiscatory surface. 
> Additional mitigations reduce
> the worst case validation time by a smaller factor at a higher cost in 
> terms of confiscatory
> surface. It "feels right" to further reduce those numbers, but it's less 
> clear what the tangible
> gains would be.
>
> Furthermore, it's always possible to get the biggest bang for our buck in 
> a first step and going the
> extra mile in a later, more controversial, soft fork. I previously floated 
> the idea of a "cleanup
> v2" in private discussions, and i think besides a reduction of the maximum 
> scriptPubKey size it
> should feature a consensus-enforced maximum transaction size for the 
> reasons stated here:
>
> https://delvingbitcoin.org/t/non-confiscatory-transaction-weight-limit/1732/8. 
> I wouldn't hold my
> breath on such a "cleanup v2", but it may be useful to have it documented 
> somewhere.
>
> I'm trying to not go into much details regarding which mitigations were 
> considered in designing
> BIP54, because they are tightly related to the design of various DoS 
> blocks. But i'm always happy to
> rehash the decisions made there and (re-)consider alternative approaches 
> on the semi-private Delving
> thread [0] dedicated to this purpose. Feel free to ping me to get access 
> if i know you.
>
> Best,
> Antoine Poinsot
>
> [0]: https://delvingbitcoin.org/t/worst-block-validation-time-inquiry/711
>
>
>
>
> On Friday, October 17th, 2025 at 1:12 PM, Brandon Black <
> fre...@reardencode.com> wrote:
>
> > 
> > 
> > On 2025-10-16 (Thu) at 00:06:41 +0000, Greg Maxwell wrote:
> > 
> > > But also given that there are essentially no violations and no reason 
> to
> > > expect any I'm not sure the proposal is worth time relative to fixes of
> > > actual moderately serious DOS attack issues.
> > 
> > 
> > I believe this limit would also stop most (all?) of PortlandHODL's
> > DoSblocks without having to make some of the other changes in GCC. I
> > think it's worthwhile to compare this approach to those proposed by
> > Antoine in solving these DoS vectors.
> > 
> > Best,
> > 
> > --Brandon
> > 
> > --
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/aPJ3w6bEoaye3WJ6%40console.
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/5135a031-a94e-49b9-ab31-a1eb48875ff2n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 8553 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-15 20:04  0% ` [bitcoindev] " Casey Rodarmor
@ 2025-10-16  0:06  0%   ` Greg Maxwell
    0 siblings, 1 reply; 200+ results
From: Greg Maxwell @ 2025-10-16  0:06 UTC (permalink / raw)
  To: Casey Rodarmor; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 4089 bytes --]

That concern is why the annex exists, I believe.  But taproot aside, that
is a point.

But also given that there are essentially no violations and no reason to
expect any I'm not sure the proposal is worth time relative to fixes of
actual moderately serious DOS attack issues.

I guess a fair point is that given the ongoing progress towards consensus
rules being the boundary of what gets mined, it would be nice to prevent
big outputs that would bloat the utxo set.  OTOH any output over 10k is
already pruned in implementations (as spending it is consensus invalid), so
the gap here is really just between 520 and 10k.

But even if jumbo outputs were being created today I think they'd still be
a less pressing issue than several of the other consensus cleanup issues.



On Wed, Oct 15, 2025 at 11:45 PM Casey Rodarmor <casey@rodarmor.com> wrote:

> I think that "Bitcoin could need it in the future?" might be a good enough
> reason not to do this.
>
> Script pubkeys are the only variable-length transaction fields which can be
> covered by input signatures, which might make them useful for future soft
> forks. I can imagine confidential asset schemes or post-quantum coin
> recovery
> schemes requiring large proofs in the outputs, where the validity of the
> proof
> determined whether or not the transaction is valid, and thus require the
> proofs to be in the outputs, and not just a hash commitment.
> On Thursday, October 2, 2025 at 2:59:24 PM UTC-7 PortlandHODL wrote:
>
>> Proposing: Softfork to after (n) block height; the creation of outpoints
>> with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
>>
>> This is my gathering of information per BIP 0002
>>
>> After doing some research into the number of outpoints that would have
>> violated the proposed rule there are exactly 169 outpoints. With only 8
>> being non OP_RETURN. I think after 15 years and not having discovered use
>> for 'large' ScriptPubkeys; the reward for not invalidating them at the
>> consensus level is lower than the risk of their abuse.
>>
>>    -
>> *Reasons for *
>>       - Makes DoS blocks likely impossible to create that would have any
>>       sufficient negative impact on the network.
>>       - Leaves enough room for hooks long term
>>       - Would substantially reduce the divergence between consensus  and
>>       relay policy
>>       - Incredibly little use onchain as evidenced above.
>>       - Could possibly reduce codebase complexity. Legacy Script is
>>       largely considered a mess though this isn't a complete disablement it
>>       should reduce the total surface that is problematic.
>>       - Would make it harder to use the ScriptPubkey as a 'large'
>>       datacarrier.
>>       - Possible UTXO set size bloat reduction.
>>
>>       - *Reasons Against *
>>       - Bitcoin could need it in the future? Quantum?
>>       - Users could just create more outpoints.
>>
>> Thoughts?
>>
>> source of onchain data
>> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>>
>> PortlandHODL
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/961e3c3a-a627-4a07-ae81-eb01f7a375a1n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/961e3c3a-a627-4a07-ae81-eb01f7a375a1n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAAS2fgQG%3DMT7MM-_LdWWepxisci1i%2B7TprBq0EH2PQ4mAs73Ew%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 5076 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
                     ` (3 preceding siblings ...)
  2025-10-03 20:02  0% ` Luke Dashjr
@ 2025-10-15 20:04  0% ` Casey Rodarmor
  2025-10-16  0:06  0%   ` Greg Maxwell
  4 siblings, 1 reply; 200+ results
From: Casey Rodarmor @ 2025-10-15 20:04 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 2622 bytes --]

I think that "Bitcoin could need it in the future?" might be a good enough
reason not to do this.

Script pubkeys are the only variable-length transaction fields which can be
covered by input signatures, which might make them useful for future soft
forks. I can imagine confidential asset schemes or post-quantum coin 
recovery
schemes requiring large proofs in the outputs, where the validity of the 
proof
determined whether or not the transaction is valid, and thus require the
proofs to be in the outputs, and not just a hash commitment.
On Thursday, October 2, 2025 at 2:59:24 PM UTC-7 PortlandHODL wrote:

> Proposing: Softfork to after (n) block height; the creation of outpoints 
> with greater than 520 bytes in the ScriptPubkey would be consensus invalid. 
>
> This is my gathering of information per BIP 0002
>
> After doing some research into the number of outpoints that would have 
> violated the proposed rule there are exactly 169 outpoints. With only 8 
> being non OP_RETURN. I think after 15 years and not having discovered use 
> for 'large' ScriptPubkeys; the reward for not invalidating them at the 
> consensus level is lower than the risk of their abuse. 
>
>    - 
> *Reasons for *
>       - Makes DoS blocks likely impossible to create that would have any 
>       sufficient negative impact on the network.
>       - Leaves enough room for hooks long term
>       - Would substantially reduce the divergence between consensus  and 
>       relay policy
>       - Incredibly little use onchain as evidenced above.
>       - Could possibly reduce codebase complexity. Legacy Script is 
>       largely considered a mess though this isn't a complete disablement it 
>       should reduce the total surface that is problematic.
>       - Would make it harder to use the ScriptPubkey as a 'large' 
>       datacarrier.
>       - Possible UTXO set size bloat reduction.
>       
>       - *Reasons Against *
>       - Bitcoin could need it in the future? Quantum?
>       - Users could just create more outpoints.
>    
> Thoughts?
>
> source of onchain data  
> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>
> PortlandHODL
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/961e3c3a-a627-4a07-ae81-eb01f7a375a1n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 3339 bytes --]

^ permalink raw reply	[relevance 0%]

* [bitcoindev] Bitcoin Core v30.0 Released
@ 2025-10-12  9:20  1% fanquake
  0 siblings, 0 replies; 200+ results
From: fanquake @ 2025-10-12  9:20 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 18534 bytes --]

Bitcoin Core version 30.0 is now available from: 

<https://bitcoincore.org/bin/bitcoin-core-30.0/> 

This release includes new features, various bug fixes and performance 
improvements, as well as updated translations. 

Please report bugs using the issue tracker at GitHub: 

<https://github.com/bitcoin/bitcoin/issues> 

To receive security and update notifications, please subscribe to: 

<https://bitcoincore.org/en/list/announcements/join/>

With the release of this new major version, versions `27.x` and
older are at "Maintenance End" and will no longer receive updates.

In accordance with the security policy, we will in two weeks disclose:

* Medium and high severity vulnerabilities fixed in `28.0`. There are none 
of these.

* Low severity vulnerabilities fixed in `30.0`. There are 5 of these.

How to Upgrade
==============

If you are running an older version, shut it down. Wait until it has 
completely
shut down (which might take a few minutes in some cases), then run the
installer (on Windows) or just copy over `/Applications/Bitcoin-Qt` (on 
macOS)
or `bitcoind`/`bitcoin-qt` (on Linux).

Upgrading directly from a version of Bitcoin Core that has reached its EOL 
is
possible, but it might take some time if the data directory needs to be 
migrated. Old
wallet versions of Bitcoin Core are generally supported.

Compatibility
==============

Bitcoin Core is supported and tested on operating systems using the
Linux Kernel 3.17+, macOS 13+, and Windows 10+. Bitcoin
Core should also work on most other Unix-like systems but is not as
frequently tested on them. It is not recommended to use Bitcoin Core on
unsupported systems.

Notable changes
===============

Policy
------

- The maximum number of potentially executed legacy signature operations in 
a
  single standard transaction is now limited to 2500. Signature operations 
in all
  previous output scripts, in all input scripts, as well as all P2SH redeem
  scripts (if there are any) are counted toward the limit. The new limit is
  assumed to not affect any known typically formed standard transactions. 
The
  change was done to prepare for a possible BIP54 deployment in the future. 
(#32521)

- `-datacarriersize` is increased to 100,000 by default, which effectively 
uncaps
  the limit (as the maximum transaction size limit will be hit first). It 
can be
  overridden with `-datacarriersize=83` to revert to the limit enforced in 
previous
  versions. (#32406)

- Multiple data carrier (OP_RETURN) outputs in a transaction are now 
permitted for
  relay and mining. The `-datacarriersize` limit applies to the aggregate 
size of
  the scriptPubKeys across all such outputs in a transaction, not including 
the
  scriptPubKey size itself. (#32406)

- The minimum block feerate (`-blockmintxfee`) has been changed to 0.001 
satoshi per
  vB. It can still be changed using the configuration option. This option 
can be used
  by miners to set a minimum feerate on packages added to block templates. 
(#33106)

- The default minimum relay feerate (`-minrelaytxfee`) and incremental 
relay feerate
  (`-incrementalrelayfee`) have been changed to 0.1 satoshis per vB. They 
can still
  be changed using their respective configuration options, but it is 
recommended to
  change both together if you decide to do so. (#33106)

  Other minimum feerates (e.g. the dust feerate, the minimum returned by 
the fee
  estimator, and all feerates used by the wallet) remain unchanged. The 
mempool minimum
  feerate still changes in response to high volume.

  Note that unless these lower defaults are widely adopted across the 
network, transactions
  created with lower fee rates are not guaranteed to propagate or confirm. 
The wallet
  feerates remain unchanged; `-mintxfee` must be changed before attempting 
to create
  transactions with lower feerates using the wallet. (#33106)

P2P and network changes
-----------------------

- Opportunistic 1-parent-1-child package relay has been improved to handle
  situations when the child already has unconfirmed parent(s) in the 
mempool.
  This means that 1p1c packages can be accepted and propagate, even if they 
are
  connected to broader topologies: multi-parent-1-child (where only 1 parent
  requires fee-bumping), grandparent-parent-child (where only parent 
requires
  fee-bumping) etc. (#31385)

- The transaction orphanage, which holds transactions with missing inputs 
temporarily
  while the node attempts to fetch its parents, now has improved Denial of 
Service protections.
  Previously, it enforced a maximum number of unique transactions (default 
100,
  configurable using `-maxorphantx`). Now, its limits are as follows: the 
number of
  entries (unique by wtxid and peer), plus each unique transaction's input 
count divided
  by 10, must not exceed 3,000. The total weight of unique transactions 
must not exceed
  `404,000` Wu multiplied by the number of peers. (#31829)

- The `-maxorphantx` option no longer has any effect, since the orphanage 
no longer
  limits the number of unique transactions. Users should remove this 
configuration
  option if they were using it, as the setting will cause an error in 
future versions
  when it is no longer recognized. (#31829)

New `bitcoin` command
---------------------

- A new `bitcoin` command line tool has been added to make features more 
discoverable
  and convenient to use. The `bitcoin` tool just calls other executables 
and does not
  implement any functionality on its own. Specifically `bitcoin node` is a 
synonym for
  `bitcoind`, `bitcoin gui` is a synonym for `bitcoin-qt`, and `bitcoin 
rpc` is a synonym
  for `bitcoin-cli -named`. Other commands and options can be listed with 
`bitcoin help`.
  The new `bitcoin` command is an alternative to calling other commands 
directly, but it
  doesn't replace them, and there are no plans to deprecate existing 
commands. (#31375)

External Signing
----------------

- Support for external signing on Windows has been re-enabled. (#29868)

IPC Mining Interface
--------------------

- The new `bitcoin` command does support one new feature: an (experimental) 
IPC Mining
  Interface that allows the node to work with Stratum v2 or other mining 
client software,
  see (#31098). When the node is started with `bitcoin -m node 
-ipcbind=unix` it will
  listen on a unix socket for IPC client connections, allowing clients to 
request block
  templates and submit mined blocks. The `-m` option launches a new 
internal binary
  (`bitcoin-node` instead of `bitcoind`) and is currently required but will 
become optional
  in the future (with #33229).

- IPC connectivity introduces new dependencies (see 
[multiprocess.md](https://github.com/bitcoin/bitcoin/blob/master/doc/multiprocess.md)),
  which can be turned off with the `-DENABLE_IPC=OFF` build option if you 
do not intend
  to use IPC. (#31802)

Install changes
---------------

- The `test_bitcoin` executable is now installed in `libexec/` instead of 
`bin/`.
  It can still be executed directly, or accessed through the new `bitcoin` 
command
  as `bitcoin test`. The `libexec/` directory also contains new 
`bitcoin-node` and
  `bitcoin-gui` binaries which support IPC features and are called through 
the
  `bitcoin` tool. In source builds only, `test_bitcoin-qt`, 
`bench_bitcoin`, and
  `bitcoin-chainstate` are also now installed to `libexec/` instead of 
`bin/` and
  can be accessed through the new `bitcoin` command. See `bitcoin help` 
output for
  details. (#31679)

- On Windows, the installer no longer adds a “(64-bit)” suffix to entries 
in the
  Start Menu (#32132), and it now automatically removes obsolete artifacts 
during
  upgrades (#33422).

Indexes
-------

- The implementation of coinstatsindex was changed to prevent an overflow 
bug that
  could already be observed on the default Signet. The new version of the 
index will
  need to be synced from scratch when starting the upgraded node for the 
first time.

  The new version is stored in `/indexes/coinstatsindex/` in contrast to 
the old version
  which was stored at `/indexes/coinstats/`. The old version of the index 
is not deleted
  by the upgraded node in case the user chooses to downgrade their node in 
the future.
  If the user does not plan to downgrade it is safe for them to remove 
`/indexes/coinstats/`
  from their datadir. A future release of Bitcoin Core may remove the old 
version of the
  index automatically. (#30469)

Logging
-------
- Unconditional logging to disk is now rate limited by giving each source 
location
  a quota of 1MiB per hour. Unconditional logging is any logging with a log 
level
  higher than debug, that is `info`, `warning`, and `error`. All logs will 
be
  prefixed with `[*]` if there is at least one source location that is 
currently
  being suppressed. (#32604)

- When `-logsourcelocations` is enabled, the log output now contains the 
entire
  function signature instead of just the function name. (#32604)

Updated RPCs
------------

- The `-paytxfee` startup option and the `settxfee` RPC are now deprecated 
and
  will be removed in Bitcoin Core 31.0. They allowed the user to set a 
static fee
  rate for wallet transactions, which could potentially lead to overpaying 
or underpaying.
  Users should instead rely on fee estimation or specify a fee rate per 
transaction
  using the `fee_rate` argument in RPCs such as `fundrawtransaction`, 
`sendtoaddress`,
  `send`, `sendall`, and `sendmany`. (#31278)

- Any RPC in which one of the parameters is a descriptor will throw an error
  if the provided descriptor contains a whitespace at the beginning or the 
end
  of the public key within a fragment - e.g. `pk( KEY)` or `pk(KEY )`. 
(#31603)

- The `submitpackage` RPC, which allows submissions of child-with-parents
  packages, no longer requires that all unconfirmed parents be present. The
  package may contain other in-mempool ancestors as well. (#31385)

- The `waitfornewblock` RPC now takes an optional `current_tip` argument. It
  is also no longer hidden. (#30635)

- The `waitforblock` and `waitforblockheight` RPCs are no longer hidden. 
 (#30635)

- The `psbtbumpfee` and `bumpfee` RPCs allow a replacement under fullrbf 
and no
  longer require BIP-125 signalling. (#31953)

- Transaction Script validation errors used to return the reason for the 
error
  prefixed by either `mandatory-script-verify-flag-failed` if it was a 
consensus
  error, or `non-mandatory-script-verify-flag` (without "-failed") if it 
was a
  standardness error. This has been changed to 
`block-script-verify-flag-failed`
  and `mempool-script-verify-flag-failed` for all block and mempool errors
  respectively. (#33183)

- The `getmininginfo` RPC now returns "blockmintxfee" result specifying the 
value of
  `-blockmintxfee` configuration. (#33189)

- The `getmempoolinfo` RPC now returns an additional "permitbaremultisig" 
and
  "maxdatacarriersize" field, reflecting the `-permitbaremultisig` and 
`-datacarriersize`
  config values. (#29954)

Changes to wallet-related RPCs can be found in the Wallet section below.

New RPCs
--------

- A new REST API endpoint (`/rest/spenttxouts/BLOCKHASH`) has been 
introduced for
  efficiently fetching spent transaction outputs using the block's undo 
data (#32540).

Build System
------------

Updated settings
----------------

- The `-maxmempool` and `-dbcache` startup parameters are now capped on 
32-bit systems
  to 500MB and 1GiB respectively. (#32530)

- The `-natpmp` option is now set to `1` by default. This means nodes with 
`-listen`
  enabled (the default) but running behind a firewall, such as a local 
network router,
  will be reachable if the firewall/router supports any of the `PCP` or 
`NAT-PMP`
  protocols. (#33004)

- The `-upnp` setting has now been fully removed. Use `-natpmp` instead. 
(#32500)

- Previously, `-proxy` specified the proxy for all networks (except I2P 
which
  uses `-i2psam`) and only the Tor proxy could have been specified 
separately
  via `-onion`. Now, the syntax of `-proxy` has been extended and it is 
possible
  to specify separately the proxy for IPv4, IPv6, Tor and CJDNS by 
appending `=`
  followed by the network name, for example `-proxy=127.0.0.1:5555=ipv6`
  configures a proxy only for IPv6. The `-proxy` option can be used multiple
  times to define different proxies for different networks, such as
  `-proxy=127.0.0.1:4444=ipv4 -proxy=10.0.0.1:6666=ipv6`. Later settings
  override earlier ones for the same network; this can be used to remove an
  earlier all-networks proxy and use direct connections only for a given
  network, for example `-proxy=127.0.0.1:5555 -proxy=0=cjdns`. (#32425)

- The `-blockmaxweight` startup option has been updated to be debug-only.
  It is still available to users, but now hidden from the default `-help` 
text
  and shown only in `-help-debug` (#32654).

Changes to GUI or wallet related settings can be found in the GUI or Wallet 
section below.

Wallet
------

- BDB legacy wallets can no longer be created or loaded. They can be 
migrated
  to the new descriptor wallet format. Refer to the `migratewallet` RPC for 
more
  details.

- The legacy wallet removal drops redundant options in the bitcoin-wallet 
tool,
  such as `-withinternalbdb`, `-legacy`, and `-descriptors`. Moreover, the
  legacy-only RPCs `addmultisigaddress`, `dumpprivkey`, `dumpwallet`,
  `importaddress`, `importmulti`, `importprivkey`, `importpubkey`,
  `importwallet`, `newkeypool`, `sethdseed`, and `upgradewallet`, are 
removed.
  (#32944, #28710, #32438, #31250)

- Support has been added for spending TRUC transactions received by the
  wallet, as well as creating TRUC transactions. The wallet ensures that
  TRUC policy rules are being met. The wallet will throw an error if the
  user is trying to spend TRUC utxos with utxos of other versions.
  Additionally, the wallet will treat unconfirmed TRUC sibling
  transactions as mempool conflicts. The wallet will also ensure that
  transactions spending TRUC utxos meet the required size restrictions. 
(#32896)

- Since descriptor wallets do not allow mixing watchonly and non-watchonly 
descriptors,
  the `include_watchonly` option (and its variants in naming) are removed 
from all RPCs
  that had it. (#32618)

- The `iswatchonly` field is removed from any RPCs that returned it. 
(#32618)

- `unloadwallet` - Return RPC_INVALID_PARAMETER when both the RPC wallet 
endpoint
  and wallet_name parameters are unspecified. Previously the RPC failed 
with a JSON
  parsing error. (#32845)

- `getdescriptoractivity` - Mark blockhashes and scanobjects arguments as 
required,
  so the user receives a clear help message when either is missing. As in 
`unloadwallet`,
  previously the RPC failed with a JSON parsing error. (#32845)

- `getwalletinfo` - Removes the fields `balance`, `immature_balance` and
  `unconfirmed_balance`. (#32721)

- `getunconfirmedbalance` - Removes this RPC command. You can query the 
`getbalances`
  RPC and inspect the `"mine"` `"untrusted_pending"` entry within the JSON
  response. (#32721)

- The following RPCs now contain a `version` parameter that allows
  the user to create transactions of any standard version number (1-3):
  - `createrawtransaction`
  - `createpsbt`
  - `send`
  - `sendall`
  - `walletcreatefundedpsbt`
  (#32896)

GUI changes
-----------

- The GUI has been migrated from Qt 5 to Qt 6. On Windows, dark mode is now 
supported.
  On macOS, the Metal backend is now used. (#30997)

- A transaction's fee bump is allowed under fullrbf and no longer requires
  BIP-125 signalling. (#31953)

- Custom column widths in the Transactions tab are reset as a side-effect 
of legacy
  wallet removal. (#32459)

Low-level changes
=================

- Logs now include which peer sent us a header. Additionally there are fewer
  redundant header log messages. A side-effect of this change is that for
  some untypical cases new headers aren't logged anymore, e.g. a direct
  `BLOCK` message with a previously unknown header and `submitheader` RPC. 
(#27826)

Credits
=======

Thanks to everyone who directly contributed to this release:

- 0xb10c
- amisha
- Andrew Toth
- Anthony Towns
- Antoine Poinsot
- Ava Chow
- benthecarman
- Brandon Odiwuor
- brunoerg
- Bue-von-hon
- Bufo
- Chandra Pratap
- Chris Stewart
- Cory Fields
- Daniel Pfeifer
- Daniela Brozzoni
- David Gumberg
- deadmanoz
- dennsikl
- dergoegge
- enoch
- Ethan Heilman
- Eugene Siegel
- Eunovo
- Eval EXEC
- Fabian Jahr
- fanquake
- Florian Schmaus
- fuder.eth
- furszy
- glozow
- Greg Sanders
- Hao Xu
- Haoran Peng
- Haowen Liu
- Hennadii Stepanov
- Hodlinator
- hoffman
- ishaanam
- ismaelsadeeq
- Jameson Lopp
- janb84
- Jiri Jakes
- John Bampton
- Jon Atack
- josibake
- jurraca
- kevkevin
- kevkevinpal
- kilavvy
- Kristaps Kaupe
- l0rinc
- laanwj
- leopardracer
- Lőrinc
- Luis Schwab
- Luke Dashjr
- MarcoFalke
- marcofleon
- Martin Zumsande
- Matt Corallo
- Matthew Zipkin
- Max Edwards
- monlovesmango
- Murch
- naiyoma
- nervana21
- Nicola Leonardo Susca
- Novo
- pablomartin4btc
- Peter Todd
- Pieter Wuille
- Pol Espinasa
- Prabhat Verma
- rkrux
- Roman Zeyde
- Ryan Ofsky
- Saikiran
- Salvatore Ingala
- Sebastian Falbesoner
- Sergi Delgado Segura
- Shunsuke Shimizu
- Sjors Provoost
- stickies-v
- stratospher
- stringintech
- strmfos
- stutxo
- tdb3
- TheCharlatan
- Tomás Andróil
- UdjinM6
- Vasil Dimov
- VolodymyrBg
- w0xlt
- will
- willcl-ark
- William Casarin
- woltx
- yancy
- zaidmstrr

As well as to everyone that helped with translations on
[Transifex](https://explore.transifex.com/bitcoin/bitcoin/).

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/715cfe5a-af73-48f5-a0d9-8b2f22ca6570n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 20502 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-08 15:03  1%   ` Greg Tonoski
@ 2025-10-08 18:15  1%     ` Keagan McClelland
  0 siblings, 0 replies; 200+ results
From: Keagan McClelland @ 2025-10-08 18:15 UTC (permalink / raw)
  To: Greg Tonoski; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 8427 bytes --]

Hard NACK on capping the witness size as that would effectively ban large
scripts even in the P2SH wrapper which undermines Bitcoin's ability to be
an effectively programmable money.

The issue is that if you do that then you effectively make script unusable
for complex scripting or anything related to ZKPs. At that point you may as
well just remove script altogether and just make Bitcoin a key-only
currency, which I think would be silly. I think making Bitcoin safely more
programmable should be the goal, not hamstringing what can be done with
script by capping the witness size. The "spam" (which I'll remind people is
an incoherent idea in a leaderless system) is a symptom of the inability
for a robust fee market to develop for block space.

I am hesitant to limit the scriptPubKey all the way down to 67 bytes.
Although it may be compelling to tighten it up as restrictively as
possible, if we find a reason to increase it again, it either has to be
done via a hard fork or via a significantly more complicated and subversive
mechanism. I think a gradual tightening based off of concrete observations
in the wild is a much more prudent approach.

Keags

On Wed, Oct 8, 2025 at 10:24 AM Greg Tonoski <greg.tonoski@gmail.com> wrote:

> I'm for all the consensus proposals below and would further specify:
> - limiting the maximum size of the scriptPubKey of a transaction to 67
> bytes (to keep supporting P2PK and avoid impacting usability/compatibility
> of old, deprecated software and risk of similar corner cases); good
> riddance to P2MS;
> - limit the maximum size of script data pushes to 73 bytes (for the same
> reason, i.e. keep supporting for P2PK input: signature with its encoding
> overhead; also P2PKH) "with an exception for BIP16 redeem scripts [which
> may embed multiple public keys for multisig]",
> - rule out "OP_FALSE OP_IF" (CVE-2023-50428),
> - discontinue P2SPAM (the one that repurposed the mnemonic OP_RETURN and
> was standardized in 2014, commit a79342479f577013f2fd2573fb32585d6f4981b3
> <https://github.com/bitcoinknots/bitcoin/commit/a79342479f577013f2fd2573fb32585d6f4981b3>
> ).
>
> BTW I think we should also consider consensus-wise limit on the maximum
> size of the so-called Witness field (3600 bytes max. by policy.h) along
> with max. size (80 bytes max. by policy.h) and max. count of its items (100
> by policy.h). Any suggestions, anybody?
>
> --
> Greg Tonoski
>
> On Fri, Oct 3, 2025 at 10:09 PM Luke Dashjr <luke@dashjr.org> wrote:
>
>> If we're going this route, we should just close all the gaps for the
>> immediate future:
>>
>> - Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't seem
>> terrible. UTXOs are a huge cost to nodes, we should always keep them as
>> small as possible. Anything else can be hashed (if SHA256 is broken, we
>> need a hardfork anyway).
>>
>> - Limit script data pushes to 256 bytes, with an exception for BIP16
>> redeem scripts.
>>
>> - Make undefined witness/taproot versions invalid, including the annex
>> and OP_SUCCESS*. To make any legitimate usage of them, we need a softfork
>> anyway (see below about expiring this).
>>
>> - Limit taproot control block to 257 bytes (128 scripts max), or at least
>> way less than it currently is. 340e36 scripts is completely unrealistic.
>>
>> - Make OP_IF invalid inside Tapscript. It should be unnecessary with
>> taproot, and has only(?) seen abuse.
>>
>> We can do these all together in a temporary softfork that self-expires
>> after a year or two. This would buy time to come up with longer-term
>> solutions, and observe how it impacts the real world. Since it expires,
>> other softforks making use of upgradable mechanisms can just wait it out
>> for those mechanisms to become available again - therefore we basically
>> lose nothing. (This is intended to buy us time, not as a permanent fix.)
>>
>> Alternatively, but much more complex, we could redesign the block weight
>> metric so the above limits could be exceeded, but at a higher
>> weight-per-byte; perhaps weigh data 25% more per byte beyond the expected
>> size. This could also be a temporary softfork, perhaps with a rolling
>> window, so future softforks could be free to lower weights should they be
>> needed.
>>
>> Another idea might be to increase the weight based on
>> coin-days-destroyed/coin-age, so rapid churn has a higher feerate than
>> occasional settlements. But this risks encouraging UTXO bloat, so needs
>> careful consideration to proceed further.
>>
>> Happy to throw together a BIP and/or code if there's community support
>> for this.
>>
>> Luke
>>
>>
>> On 10/2/25 16:42, PortlandHODL wrote:
>>
>> Proposing: Softfork to after (n) block height; the creation of outpoints
>> with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
>>
>> This is my gathering of information per BIP 0002
>>
>> After doing some research into the number of outpoints that would have
>> violated the proposed rule there are exactly 169 outpoints. With only 8
>> being non OP_RETURN. I think after 15 years and not having discovered use
>> for 'large' ScriptPubkeys; the reward for not invalidating them at the
>> consensus level is lower than the risk of their abuse.
>>
>>    -
>> *Reasons for *
>>       - Makes DoS blocks likely impossible to create that would have any
>>       sufficient negative impact on the network.
>>       - Leaves enough room for hooks long term
>>       - Would substantially reduce the divergence between consensus  and
>>       relay policy
>>       - Incredibly little use onchain as evidenced above.
>>       - Could possibly reduce codebase complexity. Legacy Script is
>>       largely considered a mess though this isn't a complete disablement it
>>       should reduce the total surface that is problematic.
>>       - Would make it harder to use the ScriptPubkey as a 'large'
>>       datacarrier.
>>       - Possible UTXO set size bloat reduction.
>>
>>       - *Reasons Against *
>>       - Bitcoin could need it in the future? Quantum?
>>       - Users could just create more outpoints.
>>
>> Thoughts?
>>
>> source of onchain data
>> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>>
>> PortlandHODL
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com
>> <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to bitcoindev+unsubscribe@googlegroups.com.
>> To view this discussion visit
>> https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org
>> <https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org?utm_medium=email&utm_source=footer>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/CAMHHROwJA5N%3DSfejF353oWFFsKVCtk5cpr9QkOv%2BZcqGDFz6oA%40mail.gmail.com
> <https://groups.google.com/d/msgid/bitcoindev/CAMHHROwJA5N%3DSfejF353oWFFsKVCtk5cpr9QkOv%2BZcqGDFz6oA%40mail.gmail.com?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALeFGL0PDjtRt2rfbY4gTkoc%2B5oNQ0mn_obraE7PrtHuNYFpQw%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 10586 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 20:02  0% ` Luke Dashjr
  2025-10-03 20:52  0%   ` /dev /fd0
@ 2025-10-08 15:03  1%   ` Greg Tonoski
  2025-10-08 18:15  1%     ` Keagan McClelland
  1 sibling, 1 reply; 200+ results
From: Greg Tonoski @ 2025-10-08 15:03 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 6432 bytes --]

I'm for all the consensus proposals below and would further specify:
- limiting the maximum size of the scriptPubKey of a transaction to 67
bytes (to keep supporting P2PK and avoid impacting usability/compatibility
of old, deprecated software and risk of similar corner cases); good
riddance to P2MS;
- limit the maximum size of script data pushes to 73 bytes (for the same
reason, i.e. keep supporting for P2PK input: signature with its encoding
overhead; also P2PKH) "with an exception for BIP16 redeem scripts [which
may embed multiple public keys for multisig]",
- rule out "OP_FALSE OP_IF" (CVE-2023-50428),
- discontinue P2SPAM (the one that repurposed the mnemonic OP_RETURN and
was standardized in 2014, commit a79342479f577013f2fd2573fb32585d6f4981b3
<https://github.com/bitcoinknots/bitcoin/commit/a79342479f577013f2fd2573fb32585d6f4981b3>
).

BTW I think we should also consider consensus-wise limit on the maximum
size of the so-called Witness field (3600 bytes max. by policy.h) along
with max. size (80 bytes max. by policy.h) and max. count of its items (100
by policy.h). Any suggestions, anybody?

-- 
Greg Tonoski

On Fri, Oct 3, 2025 at 10:09 PM Luke Dashjr <luke@dashjr.org> wrote:

> If we're going this route, we should just close all the gaps for the
> immediate future:
>
> - Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't seem terrible.
> UTXOs are a huge cost to nodes, we should always keep them as small as
> possible. Anything else can be hashed (if SHA256 is broken, we need a
> hardfork anyway).
>
> - Limit script data pushes to 256 bytes, with an exception for BIP16
> redeem scripts.
>
> - Make undefined witness/taproot versions invalid, including the annex and
> OP_SUCCESS*. To make any legitimate usage of them, we need a softfork
> anyway (see below about expiring this).
>
> - Limit taproot control block to 257 bytes (128 scripts max), or at least
> way less than it currently is. 340e36 scripts is completely unrealistic.
>
> - Make OP_IF invalid inside Tapscript. It should be unnecessary with
> taproot, and has only(?) seen abuse.
>
> We can do these all together in a temporary softfork that self-expires
> after a year or two. This would buy time to come up with longer-term
> solutions, and observe how it impacts the real world. Since it expires,
> other softforks making use of upgradable mechanisms can just wait it out
> for those mechanisms to become available again - therefore we basically
> lose nothing. (This is intended to buy us time, not as a permanent fix.)
>
> Alternatively, but much more complex, we could redesign the block weight
> metric so the above limits could be exceeded, but at a higher
> weight-per-byte; perhaps weigh data 25% more per byte beyond the expected
> size. This could also be a temporary softfork, perhaps with a rolling
> window, so future softforks could be free to lower weights should they be
> needed.
>
> Another idea might be to increase the weight based on
> coin-days-destroyed/coin-age, so rapid churn has a higher feerate than
> occasional settlements. But this risks encouraging UTXO bloat, so needs
> careful consideration to proceed further.
>
> Happy to throw together a BIP and/or code if there's community support for
> this.
>
> Luke
>
>
> On 10/2/25 16:42, PortlandHODL wrote:
>
> Proposing: Softfork to after (n) block height; the creation of outpoints
> with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
>
> This is my gathering of information per BIP 0002
>
> After doing some research into the number of outpoints that would have
> violated the proposed rule there are exactly 169 outpoints. With only 8
> being non OP_RETURN. I think after 15 years and not having discovered use
> for 'large' ScriptPubkeys; the reward for not invalidating them at the
> consensus level is lower than the risk of their abuse.
>
>    -
> *Reasons for *
>       - Makes DoS blocks likely impossible to create that would have any
>       sufficient negative impact on the network.
>       - Leaves enough room for hooks long term
>       - Would substantially reduce the divergence between consensus  and
>       relay policy
>       - Incredibly little use onchain as evidenced above.
>       - Could possibly reduce codebase complexity. Legacy Script is
>       largely considered a mess though this isn't a complete disablement it
>       should reduce the total surface that is problematic.
>       - Would make it harder to use the ScriptPubkey as a 'large'
>       datacarrier.
>       - Possible UTXO set size bloat reduction.
>
>       - *Reasons Against *
>       - Bitcoin could need it in the future? Quantum?
>       - Users could just create more outpoints.
>
> Thoughts?
>
> source of onchain data
> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>
> PortlandHODL
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org
> <https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CAMHHROwJA5N%3DSfejF353oWFFsKVCtk5cpr9QkOv%2BZcqGDFz6oA%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 8247 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] On (in)ability to embed data into Schnorr
  2025-10-07  8:22  2% ` Anthony Towns
@ 2025-10-07 12:05  1%   ` waxwing/ AdamISZ
  0 siblings, 0 replies; 200+ results
From: waxwing/ AdamISZ @ 2025-10-07 12:05 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 8898 bytes --]

Hi aj,

Interesting points! Answers inline.



On Tuesday, October 7, 2025 at 6:38:40 AM UTC-3 Anthony Towns wrote:

On Wed, Oct 01, 2025 at 07:24:50AM -0700, waxwing/ AdamISZ wrote: 
> I'm curious about the case of P, R, s published in utxos to prevent usage 
> of utxos as data. I think this answers in the half-affirmative: you can 
> only embed data by leaking the privkey so that it (can) immediately fall 
> out of the utxo set. 

I think you can attack the setup here. 

If you allow scriptPubKeys in the utxo set whose spending conditions 
are HTLC/atomic-swap-like: 

(pubkey A and preimage reveal of X) 
OR (pubkey B and block height > H) 

then you either set H to be arbitrarily far in the future and reveal 
B's privkey, or choose an NUMS X with no known preimage, and reveal 
A's privkey.


Yes. In the paper (and my OP email) I'm trying to narrow it down completely 
to a P, R, s structure. I guess if we try to be realistic about this 
"publish a signature in the output always" horrible scenario, it would have 
to just ditch the NUMS variant of taproot, and I agree, that is a very Bad 
Thing (TM). (uh sorry you discuss this in the next paragraph but, w/e).

Alternative examples like multisig or hash lock in script to get the data 
leakage without losing control of the output (necessarily) have been 
mentioned but I like your 2-branch setup as a good flexible example.


If you don't allow those things (eg, by requiring such constructions 
also have a (pubkey musig(A,B)) path) then I think you rule out NUMS-IPK 
constructions, and end up making things like vaults ("hotkey with delay, 
coldkey anytime") difficult to send to ("I have to sign with my cold 
key to request funds?"), or, depending on what the utxo R,s is signing, 
encourage key reuse. 

> (To emphasize, this is different to the earlier observations (including 
by 
> me!) that just say it is *possible* to leak data by leaking the private 
> key; here I'm trying to prove that there is *no other way*). 

That seems right to me. 

I think if the signature scheme supported pubkey recovery (ie, s*G = R + 
H(R,m)*P, and our "m" didn't commit to P as well), you could get around 
this by just having P be the data, with no one, including the "signer" 
able to recover the private key. 


Yes, basically. I discuss this in the paper w.r.t. ECDSA. Your description 
of the relevance of pubkey recovery is good, but there are some nuances. 
You can't quite (with ECDSA) get P to be the data and have a valid sig, but 
you can get 's' to be the data simply by backsolving for the private key x. 
Lack of "pubkey prefixing" in the very funky 'commitment to the nonce' in 
ECDSA causes that. And the second nuance, you did actually mention: you get 
"not leaking the key" for free, here. But it's still only a 32/96 bytes 
embedding rate though, the way I count it.
 

> However I still am probably in the large majority that thinks it's 
> appalling to imagine a sig attached to every pubkey onchain. 

I think the only thing achieved by embedding data in the utxo set (vs 
an OP_RETURN output or witness data) is to bloat the utxo set; and if 
that's the goal, it can equally easily be done with spendable outputs 
that the attacker simply chooses not to ever spend. So that doesn't seem 
like a terribly interesting solution to anything.


I think the logic of that is not quite right. Suppose I want to embed 
pictures into the unpruneable utxo set specifically (and not only 'in 
transactions'). The starting point here was me trying to write out how you 
can't embed data in known-privkey (Schnorr) P, R, s tuples.

And not only pictures; as Andrew pointed out above, there's always the 
concern of some kind of virus-y "naughty" data.
 



As far as embedding data in signatures goes, I think the following 
scheme would allow you to publish data in a cryptographically-secure way, 
with minimal lost funds: 

0) Setup secret keys p and q, and a 32-byte secret k. H(a,b,..) is sha256 
of a,b,.. concatenated. 

1) Split your data into N 31 byte blocks, a1, a2, .., aN. 

2) Calculate r0 as H(k*G). Calculate r1, .., rN as: 

r(i+1) = H(p, r(i)) + a(i) 

3) Sign N+1 transactions in a chain spending pubkey p*G, using rN, r(N-1), 
.., r1, r0 as nonces. All but the final tx should pay to a p*G output to 
continue the chain; the final output should pay to q*G instead. 

4) Once all transactions are sufficiently confirmed, spend the final 
output with k as the secret nonce (and hence R=k*G as the public 
nonce). 

Recover the data using the following process: 

1) From the final transaction, recover R=k*G, and calculate r0 as H(R). 
Recover p from the previous transaction, p = (s0-r0)/H(r0*G, P,mi). 

2) Recover ri from each signature; ri = si - H(Ri, P, mi)*p. Recover 
the data ai as ai = ri - H(p,r(i-1)). 

Dealing with the points being 32-bytes might require carrying over a 
sign-bit; but that should be possible in the spare ~7 bits since each 
block was only 31 bytes not 32 bytes. Left as an exercise for the 
reader, etc. 

I believe that the privkey p is secure prior to k*G being revealed, 
since all the nonces are distinct hashes seeded by that privkey; and q 
remains secure because k is never revealed. 

If you wanted to not reuse the pubkey p*G repeatedly, you could tweak it 
to be p0 = p, p(i+1) = p + H(k*G, p(i)), or similar. That would allow you 
to use an n-of-n multisig to get multiple blocks in a single transaction 
without seeming weird, eg. 

I believe the only way to distinguish this from a normal transaction 
pattern where a wallet has a change output, is via the final transaction 
that reveals k*G, and detecting the relationship between k*G and the 
spending conditions of the transaction that created the coin being spent. 
That's already somewhat expensive to check for every spend, but could 
be made more so by publishing k*G on some other medium (ie the data is 
in the blockchain, but you obtain the txid and key to find the data 
from elsewhere), or by revealing (k+x)*G where x is a random 20-bit 
(?) number, and a significant but tractable amount of grinding is needed 
to recover the desired k*G and decode the data -- the idea being that 
that is tractable for someone who knows there is data at that txid, 
but not tractable when performed on every signature in the blockchain 
in order to filter data publication. 

I think if you did 20 such transactions per block, each spending a single 
20-of-20 tapscript multisig, you'd get 12400 bytes of data per block 
(without violating standardness constraints), at a cost of ~11800vb, so 
much less efficient than inscriptions, but slightly more efficient than 
OP_RETURN, and significantly less detectable than either. I think Knots 
default policy currently allows up to 50-of-50 multisig in tapscript, 
which would give you 31kB of data in ~26.6kvB of tx weight in a block. 

If you're regularly making payments from a particular wallet, I think 
that procedure would allow you to encode data in your change outputs at 
the rate of 32B/tx for no additional cost. Though the data would only be 
recoverable once complete, and it's probably worth noting that I haven't 
provided any security proofs...


Very nice example. I am glad you took the trouble to write it out, because 
I agree that examples like that are worth working through because as you 
say they lean closer to being properly indistinguishable from ordinary 
transaction patterns.

My analysis was narrower: output-side embedding (in a theoretical future of 
P,R,s outputs). But that's a little confusing because (P, R, s) is still 
there whether some of it is put in witness or not. So everyone seems to 
agree that privkey reveal is necessary for that, but everyone is also 
pointing out that with Bitcoin's actual consensus scripting system, that 
doesn't quite mean what it seems! And the embedding rate is not very good. 
In this framing, not much has changed in your "chained" example: once the 
privkey p is revealed, you get the k value per chain link, so it's still 
roughly a 1/3 ratio, or more realistically, as you mention (and I did 
upthread), it's per *transaction* which is a much lower rate.

Your points about limits, standardness constraints are well taken; those 
are the kinds of things that do actually matter today, but I was not 
thinking about.


-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/e4d271ad-9ea3-41e5-96e2-6cb0118943e4n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 10567 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] On (in)ability to embed data into Schnorr
  @ 2025-10-07  8:22  2% ` Anthony Towns
  2025-10-07 12:05  1%   ` waxwing/ AdamISZ
  0 siblings, 1 reply; 200+ results
From: Anthony Towns @ 2025-10-07  8:22 UTC (permalink / raw)
  To: waxwing/ AdamISZ; +Cc: Bitcoin Development Mailing List

On Wed, Oct 01, 2025 at 07:24:50AM -0700, waxwing/ AdamISZ wrote:
> I'm curious about the case of P, R, s published in utxos to prevent usage
> of utxos as data. I think this answers in the half-affirmative: you can
> only embed data by leaking the privkey so that it (can) immediately fall
> out of the utxo set.

I think you can attack the setup here.

If you allow scriptPubKeys in the utxo set whose spending conditions
are HTLC/atomic-swap-like:

   (pubkey A and preimage reveal of X)
   OR (pubkey B and block height > H)

then you either set H to be arbitrarily far in the future and reveal
B's privkey, or choose an NUMS X with no known preimage, and reveal
A's privkey.

If you don't allow those things (eg, by requiring such constructions
also have a (pubkey musig(A,B)) path) then I think you rule out NUMS-IPK
constructions, and end up making things like vaults ("hotkey with delay,
coldkey anytime") difficult to send to ("I have to sign with my cold
key to request funds?"), or, depending on what the utxo R,s is signing,
encourage key reuse.

> (To emphasize, this is different to the earlier observations (including by
> me!) that just say it is *possible* to leak data by leaking the private
> key; here I'm trying to prove that there is *no other way*).

That seems right to me.

I think if the signature scheme supported pubkey recovery (ie, s*G = R +
H(R,m)*P, and our "m" didn't commit to P as well), you could get around
this by just having P be the data, with no one, including the "signer"
able to recover the private key.

> However I still am probably in the large majority that thinks it's
> appalling to imagine a sig attached to every pubkey onchain.

I think the only thing achieved by embedding data in the utxo set (vs
an OP_RETURN output or witness data) is to bloat the utxo set; and if
that's the goal, it can equally easily be done with spendable outputs
that the attacker simply chooses not to ever spend. So that doesn't seem
like a terribly interesting solution to anything.

As far as embedding data in signatures goes, I think the following
scheme would allow you to publish data in a cryptographically-secure way,
with minimal lost funds:

 0) Setup secret keys p and q, and a 32-byte secret k. H(a,b,..) is sha256
    of a,b,.. concatenated.

 1) Split your data into N 31 byte blocks, a1, a2, .., aN.

 2) Calculate r0 as H(k*G). Calculate r1, .., rN as:

      r(i+1) = H(p, r(i)) + a(i)

 3) Sign N+1 transactions in a chain spending pubkey p*G, using rN, r(N-1),
    .., r1, r0 as nonces. All but the final tx should pay to a p*G output to
    continue the chain; the final output should pay to q*G instead.

 4) Once all transactions are sufficiently confirmed, spend the final
    output with k as the secret nonce (and hence R=k*G as the public
    nonce).

Recover the data using the following process:

 1) From the final transaction, recover R=k*G, and calculate r0 as H(R).
    Recover p from the previous transaction, p = (s0-r0)/H(r0*G, P,mi).

 2) Recover ri from each signature; ri = si - H(Ri, P, mi)*p. Recover
    the data ai as ai = ri - H(p,r(i-1)).

Dealing with the points being 32-bytes might require carrying over a
sign-bit; but that should be possible in the spare ~7 bits since each
block was only 31 bytes not 32 bytes. Left as an exercise for the
reader, etc.

I believe that the privkey p is secure prior to k*G being revealed,
since all the nonces are distinct hashes seeded by that privkey; and q
remains secure because k is never revealed.

If you wanted to not reuse the pubkey p*G repeatedly, you could tweak it
to be p0 = p, p(i+1) = p + H(k*G, p(i)), or similar. That would allow you
to use an n-of-n multisig to get multiple blocks in a single transaction
without seeming weird, eg.

I believe the only way to distinguish this from a normal transaction
pattern where a wallet has a change output, is via the final transaction
that reveals k*G, and detecting the relationship between k*G and the
spending conditions of the transaction that created the coin being spent.
That's already somewhat expensive to check for every spend, but could
be made more so by publishing k*G on some other medium (ie the data is
in the blockchain, but you obtain the txid and key to find the data
from elsewhere), or by revealing (k+x)*G where x is a random 20-bit
(?) number, and a significant but tractable amount of grinding is needed
to recover the desired k*G and decode the data -- the idea being that
that is tractable for someone who knows there is data at that txid,
but not tractable when performed on every signature in the blockchain
in order to filter data publication.

I think if you did 20 such transactions per block, each spending a single
20-of-20 tapscript multisig, you'd get 12400 bytes of data per block
(without violating standardness constraints), at a cost of ~11800vb, so
much less efficient than inscriptions, but slightly more efficient than
OP_RETURN, and significantly less detectable than either. I think Knots
default policy currently allows up to 50-of-50 multisig in tapscript,
which would give you 31kB of data in ~26.6kvB of tx weight in a block.

If you're regularly making payments from a particular wallet, I think
that procedure would allow you to encode data in your change outputs at
the rate of 32B/tx for no additional cost. Though the data would only be
recoverable once complete, and it's probably worth noting that I haven't
provided any security proofs...

Cheers,
aj

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aOTNvteE8PCm6yDd%40erisian.com.au.


^ permalink raw reply	[relevance 2%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-04 23:12  0%     ` jeremy
@ 2025-10-05 10:59  0%       ` Luke Dashjr
  0 siblings, 0 replies; 200+ results
From: Luke Dashjr @ 2025-10-05 10:59 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 8353 bytes --]

Yes, sorry if I was unclear. The temporary restriction of 257 B is 
ultimately based on the size, which doesn't accommodate for that design 
ideal. It's a tradeoff until a better solution is implemented. While it 
might not be optimal in all cases to have 128 scripts, the fact remains 
that size/depth _allows for it_. (And 128 depth is still unrealistic, 
even if you don't like the script-count framing.)

Luke

On 10/4/25 19:12, jeremy wrote:
>
> - Limit taproot control block to 257 bytes (128 scripts max), or at 
> least way less than it currently is. 340e36 scripts is completely 
> unrealistic.
>
>
> this is a misunderstanding of taptree's depth purpose, which is not to 
> bound the number of elements directly.
>
> It's a bound on the huffman encoding to optimize for on-chain cost 
> with many scripts and known likelihood of execution.
>
> So the right way to constrain taproot is by bounding the minimum 
> probability of script execution. E.g., if it's one-in-4 billion chance 
> of executing, then you'd need depth 32.
>
> 128 depth was chosen because if a branch is (2^128 -1)/2^128 unlikely 
> to execute, then it's negligibly likely, the same order of probability 
> as being able to e.g. brute force a key.
>
> On Friday, October 3, 2025 at 6:46:16 PM UTC-4 /dev /fd0 wrote:
>
>     Hi Luke,
>
>     > We can do these all together in a temporary softfork that
>     self-expires after a year or two.
>
>     That sounds reasonable and it could work if we can agree on the
>     specifics of this proposal. As Jeremy also mentioned in his email,
>     we could set up an auto-renewing restriction lasting 1–2 years
>     with the option to remove it later if we decide we want to.
>
>     /dev/fd0
>     floppy disk guy
>
>     On Sat, Oct 4, 2025 at 1:39 AM Luke Dashjr <lu...@dashjr.org> wrote:
>
>         If we're going this route, we should just close all the gaps
>         for the immediate future:
>
>         - Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't
>         seem terrible. UTXOs are a huge cost to nodes, we should
>         always keep them as small as possible. Anything else can be
>         hashed (if SHA256 is broken, we need a hardfork anyway).
>
>         - Limit script data pushes to 256 bytes, with an exception for
>         BIP16 redeem scripts.
>
>         - Make undefined witness/taproot versions invalid, including
>         the annex and OP_SUCCESS*. To make any legitimate usage of
>         them, we need a softfork anyway (see below about expiring this).
>
>         - Limit taproot control block to 257 bytes (128 scripts max),
>         or at least way less than it currently is. 340e36 scripts is
>         completely unrealistic.
>
>         - Make OP_IF invalid inside Tapscript. It should be
>         unnecessary with taproot, and has only(?) seen abuse.
>
>         We can do these all together in a temporary softfork that
>         self-expires after a year or two. This would buy time to come
>         up with longer-term solutions, and observe how it impacts the
>         real world. Since it expires, other softforks making use of
>         upgradable mechanisms can just wait it out for those
>         mechanisms to become available again - therefore we basically
>         lose nothing. (This is intended to buy us time, not as a
>         permanent fix.)
>
>         Alternatively, but much more complex, we could redesign the
>         block weight metric so the above limits could be exceeded, but
>         at a higher weight-per-byte; perhaps weigh data 25% more per
>         byte beyond the expected size. This could also be a temporary
>         softfork, perhaps with a rolling window, so future softforks
>         could be free to lower weights should they be needed.
>
>         Another idea might be to increase the weight based on
>         coin-days-destroyed/coin-age, so rapid churn has a higher
>         feerate than occasional settlements. But this risks
>         encouraging UTXO bloat, so needs careful consideration to
>         proceed further.
>
>         Happy to throw together a BIP and/or code if there's community
>         support for this.
>
>         Luke
>
>
>         On 10/2/25 16:42, PortlandHODL wrote:
>>         Proposing: Softfork to after (n) block height; the creation
>>         of outpoints with greater than 520 bytes in the ScriptPubkey
>>         would be consensus invalid.
>>
>>         This is my gathering of information per BIP 0002
>>
>>         After doing some research into the number of outpoints that
>>         would have violated the proposed rule there are exactly 169
>>         outpoints. With only 8 being non OP_RETURN. I think after 15
>>         years and not having discovered use for 'large'
>>         ScriptPubkeys; the reward for not invalidating them at the
>>         consensus level is lower than the risk of their abuse.
>>
>>           * *Reasons for
>>             *
>>               o Makes DoS blocks likely impossible to create that
>>                 would have any sufficient negative impact on the network.
>>               o Leaves enough room for hooks long term
>>               o Would substantially reduce the divergence between
>>                 consensus  and relay policy
>>               o Incredibly little use onchain as evidenced above.
>>               o Could possibly reduce codebase complexity. Legacy
>>                 Script is largely considered a mess though this isn't
>>                 a complete disablement it should reduce the total
>>                 surface that is problematic.
>>               o Would make it harder to use the ScriptPubkey as a
>>                 'large' datacarrier.
>>               o Possible UTXO set size bloat reduction.
>>
>>           * *Reasons Against *
>>               o Bitcoin could need it in the future? Quantum?
>>               o Users could just create more outpoints.
>>
>>         Thoughts?
>>
>>         source of onchain data
>>         <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>>
>>         PortlandHODL
>>
>>         -- 
>>         You received this message because you are subscribed to the
>>         Google Groups "Bitcoin Development Mailing List" group.
>>         To unsubscribe from this group and stop receiving emails from
>>         it, send an email to bitcoindev+...@googlegroups.com.
>>         To view this discussion visit
>>         https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com
>>         <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>.
>         -- 
>         You received this message because you are subscribed to the
>         Google Groups "Bitcoin Development Mailing List" group.
>         To unsubscribe from this group and stop receiving emails from
>         it, send an email to bitcoindev+...@googlegroups.com.
>
>         To view this discussion visit
>         https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org
>         <https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org?utm_medium=email&utm_source=footer>.
>
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/1e0f9843-0f08-4dea-b037-24df38bf8ed0n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/1e0f9843-0f08-4dea-b037-24df38bf8ed0n%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/0585bba3-fb88-41d6-b86c-167774c14eb9%40dashjr.org.

[-- Attachment #2: Type: text/html, Size: 13348 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 16:15  1%         ` Anthony Towns
@ 2025-10-05  9:59  1%           ` Guus Ellenkamp
  0 siblings, 0 replies; 200+ results
From: Guus Ellenkamp @ 2025-10-05  9:59 UTC (permalink / raw)
  To: bitcoindev

If there are really so few OP_RETURN outputs more than 144 bytes, then 
why increase the limit if that change is so controversial? It seems 
people who want to use a larger OP_RETURN size do it anyway, even with 
the current default limits.


On 10/4/25 00:15, Anthony Towns wrote:
> On Fri, Oct 03, 2025 at 02:59:32PM +0000, Andrew Poelstra wrote:
>> If "it's cheaper to use witness data" were enough of a barrier, nobody
>> would be using OP_RETURN outputs today except for opentimestamps and
>> maybe some other super-low-load applications.
> It isn't chepaer to use witness data until you're publishing more than
> ~143 bytes of data, due to the overhead of the setup transaction. (It's
> also not cheaper if you want extremely easy proof of publication of
> the data)
>
> Excluding the couple of months between the topic of increasing the
> OP_RETURN limit was raised on this list and the increased limit was
> merged into Bitcoin Core master, there have, in fact, been very few
> OP_RETURN outputs generated that are above the ~143B size. In particular,
> between blocks 900k and 915,843 I get:
>
>    15,003,149 total OP_RETURN outputs
>           131 OP_RETURN outputs larger than 83 bytes
>            81 OP_RETURN outputs of 144 bytes or more
>        19,707 OP_RETURN outputs with non-zero value
>
> cf https://github.com/bitcoin/bitcoin/pull/33453#issuecomment-3341177765
>
> Cheers,
> aj
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/83c68b1f-7b92-4a28-a79a-02d56eff2c84%40activediscovery.net.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 20:52  0%   ` /dev /fd0
@ 2025-10-04 23:12  0%     ` jeremy
  2025-10-05 10:59  0%       ` Luke Dashjr
  0 siblings, 1 reply; 200+ results
From: jeremy @ 2025-10-04 23:12 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 6691 bytes --]



- Limit taproot control block to 257 bytes (128 scripts max), or at least 
way less than it currently is. 340e36 scripts is completely unrealistic.

this is a misunderstanding of taptree's depth purpose, which is not to 
bound the number of elements directly.

It's a bound on the huffman encoding to optimize for on-chain cost with 
many scripts and known likelihood of execution.

So the right way to constrain taproot is by bounding the minimum 
probability of script execution. E.g., if it's one-in-4 billion chance of 
executing, then you'd need depth 32.

128 depth was chosen because if a branch is (2^128 -1)/2^128 unlikely to 
execute, then it's negligibly likely, the same order of probability as 
being able to e.g. brute force a key. 

On Friday, October 3, 2025 at 6:46:16 PM UTC-4 /dev /fd0 wrote:

> Hi Luke,
>
> > We can do these all together in a temporary softfork that self-expires 
> after a year or two. 
>
> That sounds reasonable and it could work if we can agree on the specifics 
> of this proposal. As Jeremy also mentioned in his email, we could set up an 
> auto-renewing restriction lasting 1–2 years with the option to remove it 
> later if we decide we want to.
>
> /dev/fd0
> floppy disk guy
>
> On Sat, Oct 4, 2025 at 1:39 AM Luke Dashjr <lu...@dashjr.org> wrote:
>
>> If we're going this route, we should just close all the gaps for the 
>> immediate future:
>>
>> - Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't seem 
>> terrible. UTXOs are a huge cost to nodes, we should always keep them as 
>> small as possible. Anything else can be hashed (if SHA256 is broken, we 
>> need a hardfork anyway).
>>
>> - Limit script data pushes to 256 bytes, with an exception for BIP16 
>> redeem scripts.
>>
>> - Make undefined witness/taproot versions invalid, including the annex 
>> and OP_SUCCESS*. To make any legitimate usage of them, we need a softfork 
>> anyway (see below about expiring this).
>>
>> - Limit taproot control block to 257 bytes (128 scripts max), or at least 
>> way less than it currently is. 340e36 scripts is completely unrealistic.
>>
>> - Make OP_IF invalid inside Tapscript. It should be unnecessary with 
>> taproot, and has only(?) seen abuse.
>>
>> We can do these all together in a temporary softfork that self-expires 
>> after a year or two. This would buy time to come up with longer-term 
>> solutions, and observe how it impacts the real world. Since it expires, 
>> other softforks making use of upgradable mechanisms can just wait it out 
>> for those mechanisms to become available again - therefore we basically 
>> lose nothing. (This is intended to buy us time, not as a permanent fix.)
>>
>> Alternatively, but much more complex, we could redesign the block weight 
>> metric so the above limits could be exceeded, but at a higher 
>> weight-per-byte; perhaps weigh data 25% more per byte beyond the expected 
>> size. This could also be a temporary softfork, perhaps with a rolling 
>> window, so future softforks could be free to lower weights should they be 
>> needed.
>>
>> Another idea might be to increase the weight based on 
>> coin-days-destroyed/coin-age, so rapid churn has a higher feerate than 
>> occasional settlements. But this risks encouraging UTXO bloat, so needs 
>> careful consideration to proceed further.
>>
>> Happy to throw together a BIP and/or code if there's community support 
>> for this.
>>
>> Luke
>>
>>
>> On 10/2/25 16:42, PortlandHODL wrote:
>>
>> Proposing: Softfork to after (n) block height; the creation of outpoints 
>> with greater than 520 bytes in the ScriptPubkey would be consensus invalid. 
>>
>> This is my gathering of information per BIP 0002
>>
>> After doing some research into the number of outpoints that would have 
>> violated the proposed rule there are exactly 169 outpoints. With only 8 
>> being non OP_RETURN. I think after 15 years and not having discovered use 
>> for 'large' ScriptPubkeys; the reward for not invalidating them at the 
>> consensus level is lower than the risk of their abuse. 
>>
>>    - 
>> *Reasons for * 
>>       - Makes DoS blocks likely impossible to create that would have any 
>>       sufficient negative impact on the network. 
>>       - Leaves enough room for hooks long term
>>       - Would substantially reduce the divergence between consensus  and 
>>       relay policy 
>>       - Incredibly little use onchain as evidenced above. 
>>       - Could possibly reduce codebase complexity. Legacy Script is 
>>       largely considered a mess though this isn't a complete disablement it 
>>       should reduce the total surface that is problematic. 
>>       - Would make it harder to use the ScriptPubkey as a 'large' 
>>       datacarrier. 
>>       - Possible UTXO set size bloat reduction.
>>       
>>       - *Reasons Against * 
>>       - Bitcoin could need it in the future? Quantum?
>>       - Users could just create more outpoints. 
>>    
>> Thoughts?
>>
>> source of onchain data  
>> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>>
>> PortlandHODL
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com 
>> <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>
>> .
>>
>> -- 
>> You received this message because you are subscribed to the Google Groups 
>> "Bitcoin Development Mailing List" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to bitcoindev+...@googlegroups.com.
>>
> To view this discussion visit 
>> https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org 
>> <https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org?utm_medium=email&utm_source=footer>
>> .
>>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/1e0f9843-0f08-4dea-b037-24df38bf8ed0n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 9562 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 20:02  0% ` Luke Dashjr
@ 2025-10-03 20:52  0%   ` /dev /fd0
  2025-10-04 23:12  0%     ` jeremy
  2025-10-08 15:03  1%   ` Greg Tonoski
  1 sibling, 1 reply; 200+ results
From: /dev /fd0 @ 2025-10-03 20:52 UTC (permalink / raw)
  To: Luke Dashjr; +Cc: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 5674 bytes --]

Hi Luke,

> We can do these all together in a temporary softfork that self-expires
after a year or two.

That sounds reasonable and it could work if we can agree on the specifics
of this proposal. As Jeremy also mentioned in his email, we could set up an
auto-renewing restriction lasting 1–2 years with the option to remove it
later if we decide we want to.

/dev/fd0
floppy disk guy

On Sat, Oct 4, 2025 at 1:39 AM Luke Dashjr <luke@dashjr.org> wrote:

> If we're going this route, we should just close all the gaps for the
> immediate future:
>
> - Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't seem terrible.
> UTXOs are a huge cost to nodes, we should always keep them as small as
> possible. Anything else can be hashed (if SHA256 is broken, we need a
> hardfork anyway).
>
> - Limit script data pushes to 256 bytes, with an exception for BIP16
> redeem scripts.
>
> - Make undefined witness/taproot versions invalid, including the annex and
> OP_SUCCESS*. To make any legitimate usage of them, we need a softfork
> anyway (see below about expiring this).
>
> - Limit taproot control block to 257 bytes (128 scripts max), or at least
> way less than it currently is. 340e36 scripts is completely unrealistic.
>
> - Make OP_IF invalid inside Tapscript. It should be unnecessary with
> taproot, and has only(?) seen abuse.
>
> We can do these all together in a temporary softfork that self-expires
> after a year or two. This would buy time to come up with longer-term
> solutions, and observe how it impacts the real world. Since it expires,
> other softforks making use of upgradable mechanisms can just wait it out
> for those mechanisms to become available again - therefore we basically
> lose nothing. (This is intended to buy us time, not as a permanent fix.)
>
> Alternatively, but much more complex, we could redesign the block weight
> metric so the above limits could be exceeded, but at a higher
> weight-per-byte; perhaps weigh data 25% more per byte beyond the expected
> size. This could also be a temporary softfork, perhaps with a rolling
> window, so future softforks could be free to lower weights should they be
> needed.
>
> Another idea might be to increase the weight based on
> coin-days-destroyed/coin-age, so rapid churn has a higher feerate than
> occasional settlements. But this risks encouraging UTXO bloat, so needs
> careful consideration to proceed further.
>
> Happy to throw together a BIP and/or code if there's community support for
> this.
>
> Luke
>
>
> On 10/2/25 16:42, PortlandHODL wrote:
>
> Proposing: Softfork to after (n) block height; the creation of outpoints
> with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
>
> This is my gathering of information per BIP 0002
>
> After doing some research into the number of outpoints that would have
> violated the proposed rule there are exactly 169 outpoints. With only 8
> being non OP_RETURN. I think after 15 years and not having discovered use
> for 'large' ScriptPubkeys; the reward for not invalidating them at the
> consensus level is lower than the risk of their abuse.
>
>    -
> *Reasons for *
>       - Makes DoS blocks likely impossible to create that would have any
>       sufficient negative impact on the network.
>       - Leaves enough room for hooks long term
>       - Would substantially reduce the divergence between consensus  and
>       relay policy
>       - Incredibly little use onchain as evidenced above.
>       - Could possibly reduce codebase complexity. Legacy Script is
>       largely considered a mess though this isn't a complete disablement it
>       should reduce the total surface that is problematic.
>       - Would make it harder to use the ScriptPubkey as a 'large'
>       datacarrier.
>       - Possible UTXO set size bloat reduction.
>
>       - *Reasons Against *
>       - Bitcoin could need it in the future? Quantum?
>       - Users could just create more outpoints.
>
> Thoughts?
>
> source of onchain data
> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>
> PortlandHODL
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com
> <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org
> <https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org?utm_medium=email&utm_source=footer>
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALiT-Zo8wiZGCFeMwfd92zptw_cKz7ajMOjFWW%3DrdS9by3zYHQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 7414 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
                     ` (2 preceding siblings ...)
  2025-10-03 15:42  0% ` Anthony Towns
@ 2025-10-03 20:02  0% ` Luke Dashjr
  2025-10-03 20:52  0%   ` /dev /fd0
  2025-10-08 15:03  1%   ` Greg Tonoski
  2025-10-15 20:04  0% ` [bitcoindev] " Casey Rodarmor
  4 siblings, 2 replies; 200+ results
From: Luke Dashjr @ 2025-10-03 20:02 UTC (permalink / raw)
  To: bitcoindev

[-- Attachment #1: Type: text/plain, Size: 4620 bytes --]

If we're going this route, we should just close all the gaps for the 
immediate future:

- Limit (new) scriptPubKeys to 83 bytes or less. 34 doesn't seem 
terrible. UTXOs are a huge cost to nodes, we should always keep them as 
small as possible. Anything else can be hashed (if SHA256 is broken, we 
need a hardfork anyway).

- Limit script data pushes to 256 bytes, with an exception for BIP16 
redeem scripts.

- Make undefined witness/taproot versions invalid, including the annex 
and OP_SUCCESS*. To make any legitimate usage of them, we need a 
softfork anyway (see below about expiring this).

- Limit taproot control block to 257 bytes (128 scripts max), or at 
least way less than it currently is. 340e36 scripts is completely 
unrealistic.

- Make OP_IF invalid inside Tapscript. It should be unnecessary with 
taproot, and has only(?) seen abuse.

We can do these all together in a temporary softfork that self-expires 
after a year or two. This would buy time to come up with longer-term 
solutions, and observe how it impacts the real world. Since it expires, 
other softforks making use of upgradable mechanisms can just wait it out 
for those mechanisms to become available again - therefore we basically 
lose nothing. (This is intended to buy us time, not as a permanent fix.)

Alternatively, but much more complex, we could redesign the block weight 
metric so the above limits could be exceeded, but at a higher 
weight-per-byte; perhaps weigh data 25% more per byte beyond the 
expected size. This could also be a temporary softfork, perhaps with a 
rolling window, so future softforks could be free to lower weights 
should they be needed.

Another idea might be to increase the weight based on 
coin-days-destroyed/coin-age, so rapid churn has a higher feerate than 
occasional settlements. But this risks encouraging UTXO bloat, so needs 
careful consideration to proceed further.

Happy to throw together a BIP and/or code if there's community support 
for this.

Luke


On 10/2/25 16:42, PortlandHODL wrote:
> Proposing: Softfork to after (n) block height; the creation of 
> outpoints with greater than 520 bytes in the ScriptPubkey would be 
> consensus invalid.
>
> This is my gathering of information per BIP 0002
>
> After doing some research into the number of outpoints that would have 
> violated the proposed rule there are exactly 169 outpoints. With only 
> 8 being non OP_RETURN. I think after 15 years and not having 
> discovered use for 'large' ScriptPubkeys; the reward for not 
> invalidating them at the consensus level is lower than the risk of 
> their abuse.
>
>   * *Reasons for
>     *
>       o Makes DoS blocks likely impossible to create that would have
>         any sufficient negative impact on the network.
>       o Leaves enough room for hooks long term
>       o Would substantially reduce the divergence between consensus 
>         and relay policy
>       o Incredibly little use onchain as evidenced above.
>       o Could possibly reduce codebase complexity. Legacy Script is
>         largely considered a mess though this isn't a complete
>         disablement it should reduce the total surface that is
>         problematic.
>       o Would make it harder to use the ScriptPubkey as a 'large'
>         datacarrier.
>       o Possible UTXO set size bloat reduction.
>
>   * *Reasons Against *
>       o Bitcoin could need it in the future? Quantum?
>       o Users could just create more outpoints.
>
> Thoughts?
>
> source of onchain data 
> <https://github.com/portlandhodl/portlandhodl/blob/main/greater_520_pubkeys.csv>
>
> PortlandHODL
>
> -- 
> You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com 
> <https://groups.google.com/d/msgid/bitcoindev/6f6b570f-7f9d-40c0-a771-378eb2c0c701n%40googlegroups.com?utm_medium=email&utm_source=footer>.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/001afe1d-0282-4c68-8b1c-ebcc778f57b0%40dashjr.org.

[-- Attachment #2: Type: text/html, Size: 6147 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 13:21  1% ` [bitcoindev] " Peter Todd
@ 2025-10-03 16:52  0%   ` 'moonsettler' via Bitcoin Development Mailing List
  0 siblings, 0 replies; 200+ results
From: 'moonsettler' via Bitcoin Development Mailing List @ 2025-10-03 16:52 UTC (permalink / raw)
  To: Peter Todd; +Cc: PortlandHODL, Bitcoin Development Mailing List


> NACK, for exactly this reason. It's hard to predict what kind of math will be
> needed in the future for future signature algorithms. With taproot, we include
> bare pubkeys in scriptPubKeys for a good reason. It's quite possible that we'll
> want to do something similar with >520byte pubkeys for some future signature
> 
> algorithm (e.g. quantum hard) or some other difficult to predict technical
> upgrade (the spendableness of scriptPubKeys with >520bytes isn't relevant to
> 
> this discussion).

No matter how large a pubkey script you need, you can just delegate to the
witness if you have a cryptographically secure hash function.

Hard to even imagine needing anywhere near 4096 bits for that.

The going assumption for quantum algos is they could halve the bit strength of
a hash function, but SHA512 seems quiet robust even under worst assumptions.
And it's not enough to find ANY collision for a script or some Merkle root.

Putting the unlocking conditions into the UTXO set does not seem like a healthy
idea to me anyhow.

BR,
moonsettler

PS:
No hard opinion on temporary vs final restrictions. I wouldn't worry about it.


Sent with Proton Mail secure email.

On Friday, October 3rd, 2025 at 5:51 PM, Peter Todd <pete@petertodd.org> wrote:

> On Thu, Oct 02, 2025 at 01:42:06PM -0700, PortlandHODL wrote:
> 
> > Proposing: Softfork to after (n) block height; the creation of outpoints
> > with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
> > 
> > This is my gathering of information per BIP 0002
> > 
> > After doing some research into the number of outpoints that would have
> > violated the proposed rule there are exactly 169 outpoints. With only 8
> > being non OP_RETURN. I think after 15 years and not having discovered use
> > for 'large' ScriptPubkeys; the reward for not invalidating them at the
> > consensus level is lower than the risk of their abuse.
> > 
> > -
> > *Reasons for *
> > - Makes DoS blocks likely impossible to create that would have any
> > sufficient negative impact on the network.
> 
> 
> Further restricting v0 scripts is sufficient to achieve this goal. We do not
> need to actually prohibit >520 byte pushes.
> 
> > - Leaves enough room for hooks long term
> > - Would substantially reduce the divergence between consensus and
> > relay policy
> > - Incredibly little use onchain as evidenced above.
> > - Could possibly reduce codebase complexity. Legacy Script is largely
> > considered a mess though this isn't a complete disablement it should reduce
> > the total surface that is problematic.
> > - Would make it harder to use the ScriptPubkey as a 'large'
> > datacarrier.
> > - Possible UTXO set size bloat reduction.
> > 
> > - *Reasons Against *
> > - Bitcoin could need it in the future? Quantum?
> 
> 
> NACK, for exactly this reason. It's hard to predict what kind of math will be
> needed in the future for future signature algorithms. With taproot, we include
> bare pubkeys in scriptPubKeys for a good reason. It's quite possible that we'll
> want to do something similar with >520byte pubkeys for some future signature
> 
> algorithm (e.g. quantum hard) or some other difficult to predict technical
> upgrade (the spendableness of scriptPubKeys with >520bytes isn't relevant to
> 
> this discussion).
> 
> > - Users could just create more outpoints.
> 
> 
> The second reason for my NACK. It makes no significant difference whether or
> not data is contiguous or split across multiple outputs. All the same concerns
> about arbitrary data ("spam") exist and will continue to be argued over even if
> we do a soft-fork to prohibit this. All we'll done is have used up valuable dev
> and political resources.
> 
> --
> https://petertodd.org 'peter'[:-1]@petertodd.org
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_N4i4zZ5Dt8TdG%40petertodd.org.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ONFWceYdQT0aizGwn2vyyzdr2RZ9GlQ7vAfNfIRRO_IGsTaX-l3bghNiygjXmccG8UJO_7pxrAr2ZKbUrlvNrAZ83EfyPjzuAR26J7xp4bw%3D%40protonmail.com.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 14:59  1%       ` Andrew Poelstra
@ 2025-10-03 16:15  1%         ` Anthony Towns
  2025-10-05  9:59  1%           ` Guus Ellenkamp
  0 siblings, 1 reply; 200+ results
From: Anthony Towns @ 2025-10-03 16:15 UTC (permalink / raw)
  To: Andrew Poelstra, Bitcoin Development Mailing List

On Fri, Oct 03, 2025 at 02:59:32PM +0000, Andrew Poelstra wrote:
> If "it's cheaper to use witness data" were enough of a barrier, nobody
> would be using OP_RETURN outputs today except for opentimestamps and
> maybe some other super-low-load applications.

It isn't chepaer to use witness data until you're publishing more than
~143 bytes of data, due to the overhead of the setup transaction. (It's
also not cheaper if you want extremely easy proof of publication of
the data)

Excluding the couple of months between the topic of increasing the
OP_RETURN limit was raised on this list and the increased limit was
merged into Bitcoin Core master, there have, in fact, been very few
OP_RETURN outputs generated that are above the ~143B size. In particular,
between blocks 900k and 915,843 I get:

  15,003,149 total OP_RETURN outputs
         131 OP_RETURN outputs larger than 83 bytes
          81 OP_RETURN outputs of 144 bytes or more
      19,707 OP_RETURN outputs with non-zero value

cf https://github.com/bitcoin/bitcoin/pull/33453#issuecomment-3341177765

Cheers,
aj

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_2qZzAu9gxa1h0%40erisian.com.au.


^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
      2025-10-03 13:21  1% ` [bitcoindev] " Peter Todd
@ 2025-10-03 15:42  0% ` Anthony Towns
  2025-10-03 20:02  0% ` Luke Dashjr
  2025-10-15 20:04  0% ` [bitcoindev] " Casey Rodarmor
  4 siblings, 0 replies; 200+ results
From: Anthony Towns @ 2025-10-03 15:42 UTC (permalink / raw)
  To: PortlandHODL; +Cc: Bitcoin Development Mailing List

On Thu, Oct 02, 2025 at 01:42:06PM -0700, PortlandHODL wrote:
> Proposing: Softfork to after (n) block height; the creation of outpoints
> with greater than 520 bytes in the ScriptPubkey would be consensus invalid.

>       - Leaves enough room for hooks long term
>       - Bitcoin could need it in the future?

One place where large scriptPubKeys could be useful is in script caching.

Suppose we have a future where complicated smart contracts are common;
eg perhaps some future version of lightning implemented using opcodes
from the great-script-restoration has a 9,000 byte script that is
used for every uncooperative close, and that lightning is so prevelant,
uncooperative closes are common.

In that scenario, we might like to be able to cache the 9,000 byte
script, and just invoke it by reference. One way to do that would
be to hardcode that script into consensus and soft-fork it in as a
new opcode. A more flexible alternative, however, would be to put that
script in our existing database, ie the utxo set, and look it up via its
36 bit txid/vout reference. To avoid permanently bloating the utxo set,
we could make such outputs expire after perhaps 100k blocks, and perhaps
increase the "weight" of creating such utxos by 10x, so that it's only
economical if the script is going to be used ~40x before it expires.

Using the utxo set here rather than creating a new database makes upgrades
easier; you don't have to rescan blocks to populate the script cache
database once you upgrade to a node version supporting script caching.

So I think there's potential uses for this flexibility that it wouldn't
be wise to just throw away.

(If you restricted the change to only applying to scripts that used
non-push operators, that would probably still provide upgrade flexibility
while also preventing potential script abuses. But it wouldn't do anything
to prevent publishing data)

>       - Possible UTXO set size bloat reduction.

I don't think this works -- breaking up a scriptPubKey across multiple
utxos increases the utxo set bloat significantly, as in addition to the
scriptPubKey, each utxo includes a key (the 36 bytes for txid and vout),
an amount (8 bytes), a coinbase flag and a height (4 bytes), and likely
additional indexing data to keep lookups efficient.

If you're putting 10kB into the utxo set, then that's perhaps 50B of
overhead for a single entry (ie 0.5%); if you have to split it into 20x
500B entries with 50B overhead each, that's 1kB of overhead in total
(ie 10%).

>       - Would make it harder to use the ScriptPubkey as a 'large'
>         datacarrier.

This seems to be a bad goal to me; ie one that doesn't achieve anything
positive in reducing the bad things you want to prevent, but does make
things worse for other users you want to support. Breaking up data
and recovering it is straightforward, and already supported by various
Bitcoin-specific systems already; all breaking up the data achieves is
to use up slightly more resources. If the data being sent is already
economically marginal, that may result in less data being sent --
but only a similar reduction to what you'd get if fees increased at a
similar rate. When the data storage use case is not economically marginal,
it will instead just result in less resources remaining available for
whatever monetary activity is still taking place.

As far as the "but contiguous data will be regulated more strictly"
argument goes; I don't think "your honour, my offensive content has
strings of 4d0802 every 520 bytes, and as they say: if the data doesn't
flow, you must let me go" is an argument that will fly. Having the data
be separated by longer strings or otherwise structured differently isn't
a bigger difference between an image in a bmp, a jpg, or one dumped
in a zip file or mime-encoded, and none of those will let you avoid a
regulator's ire.

Cheers,
aj

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_u-xB2ogn2D834%40erisian.com.au.


^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 14:18  0%     ` /dev /fd0
@ 2025-10-03 14:59  1%       ` Andrew Poelstra
  2025-10-03 16:15  1%         ` Anthony Towns
  0 siblings, 1 reply; 200+ results
From: Andrew Poelstra @ 2025-10-03 14:59 UTC (permalink / raw)
  To: /dev /fd0; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 2873 bytes --]

On Fri, Oct 03, 2025 at 07:48:38PM +0530, /dev /fd0 wrote:
> Hi Andrew,
> 
> > Restricting it to OP_RETURN would have zero effect on people trying to
> use scriptpubkeys for data storage.
> 
> 1. The data shows that nobody is using scriptPubKeys for more than 520
> bytes. In fact, people have found new ways to encode data in transactions.
> Example: [Merkle path][0] in taproot control block
>

I'm relieved to hear this -- if you must embed data it is much cheaper
to do so in witness data, exactly because this data puts less load on
the network (in particular it does not need to be stored by non-archival
nodes).

Unfortunately, the evidence from the current "filters" debate, where in
the current 80-byte policy limit is filtering transactions that actually
appear in blocks, suggests that we just need to wait for the "on-chain
bitcoin spam" market to have a shift in sentiment before we have people
blowing past 520 bytes or beyond.

Adding a hard consensus limit seems harmless, and will put a hard
barrier against any such sentiment shifts.

If "it's cheaper to use witness data" were enough of a barrier, nobody
would be using OP_RETURN outputs today except for opentimestamps and
maybe some other super-low-load applications. 

> 2. If this applies to all scriptPubKeys, it could negatively affect the
> [UTXO set][1] size because multiple outputs is an alternative if someone
> really wants to use scriptPubKey for data.
>

Good point! But if they are forced to use multiple outputs this will
increase the cost for them even further (and force them to split up
their data, which may force some technical pain even if the network
fees aren't enough).

I'm no spammer sociologist, but at some point if we can force the cost
difference between witness spam and UTXO-set spam high enough, nobody
will choose the latter, right?

And if not -- one of the most serious problems with spam is that it
muscles out protocols like LN or Ark by out-spending them on block
space, preventing them from gaining the network effects they would
need to spend a comparable amount. Every marginal cost we add to
spammers increases the delta by which they need to out-spend.

> [0]:
> https://mempool.space/tx/c5714af322cd2ba94adf3d74325eb17f03d029ad2bf47dc54c3d929833c02628
> [1]: https://mainnet.observer/charts/utxoset-size/
> 

-- 
Andrew Poelstra
Director, Blockstream Research
Email: apoelstra at wpsoftware.net
Web:   https://www.wpsoftware.net/andrew

The sun is always shining in space
    -Justin Lewis-Webster

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_k1EAXZ0schWDs%40mail.wpsoftware.net.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
    2025-10-03 10:46  1%   ` 'moonsettler' via Bitcoin Development Mailing List
@ 2025-10-03 13:59  1%   ` Andrew Poelstra
  2025-10-03 14:18  0%     ` /dev /fd0
  1 sibling, 1 reply; 200+ results
From: Andrew Poelstra @ 2025-10-03 13:59 UTC (permalink / raw)
  To: /dev /fd0; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 1577 bytes --]

On Thu, Oct 02, 2025 at 06:21:18PM -0700, /dev /fd0 wrote:
> 
> We can't predict future usage,

Aside from proof-of-publication (i.e. data storage directly in the UTXO
set) there is no usage of script which can't be equally (or better)
accomplished by using a Segwit v0 or Taproot script.

> so it would be great if this was restricted 
> to OP_RETURN. While there is no real use for a scriptPubKey larger than 520 
> bytes as shown in the data you shared, it is possible that users may create 
> more OP_RETURN outputs after this change. It does not affect the UTXO set 
> but will cost more and economically discourage the use of multiple 
> OP_RETURN outputs. 
> 

Restricting it to OP_RETURN would have zero effect on people trying to
use scriptpubkeys for data storage. They would switch to any of the 65
or so other OP_RETURN equivalents, and failing that, switch to
OP_RESERVED, then to OP_FALSE, then to `0 1 EQVERIFY`, and so on. A
restriction that applies specifically to OP_RETURN outputs is no
restriction at all.


-- 
Andrew Poelstra
Director, Blockstream Research
Email: apoelstra at wpsoftware.net
Web:   https://www.wpsoftware.net/andrew

The sun is always shining in space
    -Justin Lewis-Webster

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_Wz5YbZ9NieQu0%40mail.wpsoftware.net.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 13:59  1%   ` Andrew Poelstra
@ 2025-10-03 14:18  0%     ` /dev /fd0
  2025-10-03 14:59  1%       ` Andrew Poelstra
  0 siblings, 1 reply; 200+ results
From: /dev /fd0 @ 2025-10-03 14:18 UTC (permalink / raw)
  To: Andrew Poelstra; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 2503 bytes --]

Hi Andrew,

> Restricting it to OP_RETURN would have zero effect on people trying to
use scriptpubkeys for data storage.

1. The data shows that nobody is using scriptPubKeys for more than 520
bytes. In fact, people have found new ways to encode data in transactions.
Example: [Merkle path][0] in taproot control block

2. If this applies to all scriptPubKeys, it could negatively affect the
[UTXO set][1] size because multiple outputs is an alternative if someone
really wants to use scriptPubKey for data.

[0]:
https://mempool.space/tx/c5714af322cd2ba94adf3d74325eb17f03d029ad2bf47dc54c3d929833c02628
[1]: https://mainnet.observer/charts/utxoset-size/

/dev/fd0
floppy disk guy

On Fri, Oct 3, 2025 at 7:29 PM Andrew Poelstra <apoelstra@wpsoftware.net>
wrote:

> On Thu, Oct 02, 2025 at 06:21:18PM -0700, /dev /fd0 wrote:
> >
> > We can't predict future usage,
>
> Aside from proof-of-publication (i.e. data storage directly in the UTXO
> set) there is no usage of script which can't be equally (or better)
> accomplished by using a Segwit v0 or Taproot script.
>
> > so it would be great if this was restricted
> > to OP_RETURN. While there is no real use for a scriptPubKey larger than
> 520
> > bytes as shown in the data you shared, it is possible that users may
> create
> > more OP_RETURN outputs after this change. It does not affect the UTXO
> set
> > but will cost more and economically discourage the use of multiple
> > OP_RETURN outputs.
> >
>
> Restricting it to OP_RETURN would have zero effect on people trying to
> use scriptpubkeys for data storage. They would switch to any of the 65
> or so other OP_RETURN equivalents, and failing that, switch to
> OP_RESERVED, then to OP_FALSE, then to `0 1 EQVERIFY`, and so on. A
> restriction that applies specifically to OP_RETURN outputs is no
> restriction at all.
>
>
> --
> Andrew Poelstra
> Director, Blockstream Research
> Email: apoelstra at wpsoftware.net
> Web:   https://www.wpsoftware.net/andrew
>
> The sun is always shining in space
>     -Justin Lewis-Webster
>
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALiT-ZpJ_F2UrvUwRjgMukxQJ%2Bs8GVzgDCHWt%3DzMR%2BHkMDDWWQ%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 3561 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 10:46  1%   ` 'moonsettler' via Bitcoin Development Mailing List
  2025-10-03 11:26  0%     ` /dev /fd0
@ 2025-10-03 13:35  0%     ` jeremy
  1 sibling, 0 replies; 200+ results
From: jeremy @ 2025-10-03 13:35 UTC (permalink / raw)
  To: Bitcoin Development Mailing List


[-- Attachment #1.1: Type: text/plain, Size: 4890 bytes --]

I think that this type of rule is OK if we do it as a "sunsetting" 
restriction -- e.g. a soft fork active for the next N blocks (N = e.g. 2 
years, 5 years, 10 years).

We may yet find a compelling use for larger scriptpubkeys, and to me the 
interactions between different key types is non-obvious.

An example of where big SPK is valuable v.s. e.g. Taproot, Segwit, P2SH is 
if there is one big script path required in a two-tx protocol, and the 
inclusion price must be paid by the proposed of the first tx. In this case, 
we'd want the inclusion guaranteed by the first tx and then the cost isn't 
paid (other than satisfaction cost).

You can argue against this example probably, but it is worth considering 
that absence of evidence of use is not evidence of absence of use and I 
myself feel that overall our understanding of Bitcoin transaction 
programming possibilities is still early.  If you don't like this example, 
I can give you others (probably).

As such, I'm NACK on a permanent restriction on what could be a valuable 
use. But I do think it could be reasonable to set up an auto-renewing 
restriction on a 1-2 year basis, and allow it to be removed if we later 
decide we want them.

(N.B. this differs from past temporary soft fork proposals as it's a 
restriction on something we think no one will do that we eventually lift, 
rather than removing after a time an opcode that we expect people would 
want to rely on.)

On Friday, October 3, 2025 at 7:03:09 AM UTC-4 moonsettler wrote:

> Hi Floppy,
>
> There are only weak arguments for this proposal to extend to OP_RETURN, at 
> least nothing I would normally entertain;
> but also there are weak arguments to make an exception for OP_RETURN 
> explicitly.
>
> People could just add many OP_RETURNs to a transaction, that makes it more 
> cumbersome and marginally more expensive.
>
> BR,
> moonsettler
>
>
> On Friday, October 3rd, 2025 at 10:58 AM, /dev /fd0 <alice...@gmail.com> 
> wrote:
>
> > Hi portlandhodl,
> > 
> > We can't predict future usage, so it would be great if this was 
> restricted to OP_RETURN. While there is no real use for a scriptPubKey 
> larger than 520 bytes as shown in the data you shared, it is possible that 
> users may create more OP_RETURN outputs after this change. It does not 
> affect the UTXO set but will cost more and economically discourage the use 
> of multiple OP_RETURN outputs.
> > 
> > /dev/fd0
> > floppy disk guy
> > On Friday, October 3, 2025 at 3:29:24 AM UTC+5:30 PortlandHODL wrote:
> > 
> > > Proposing: Softfork to after (n) block height; the creation of 
> outpoints with greater than 520 bytes in the ScriptPubkey would be 
> consensus invalid.
> > > 
> > > This is my gathering of information per BIP 0002
> > > 
> > > After doing some research into the number of outpoints that would have 
> violated the proposed rule there are exactly 169 outpoints. With only 8 
> being non OP_RETURN. I think after 15 years and not having discovered use 
> for 'large' ScriptPubkeys; the reward for not invalidating them at the 
> consensus level is lower than the risk of their abuse.
> > > 
> > > - Reasons for
> > > - Makes DoS blocks likely impossible to create that would have any 
> sufficient negative impact on the network.
> > > - Leaves enough room for hooks long term
> > > - Would substantially reduce the divergence between consensus and 
> relay policy
> > > - Incredibly little use onchain as evidenced above.
> > > - Could possibly reduce codebase complexity. Legacy Script is largely 
> considered a mess though this isn't a complete disablement it should reduce 
> the total surface that is problematic.
> > > - Would make it harder to use the ScriptPubkey as a 'large' 
> datacarrier.
> > > - Possible UTXO set size bloat reduction.
> > > 
> > > - Reasons Against
> > > - Bitcoin could need it in the future? Quantum?
> > > - Users could just create more outpoints.
> > > 
> > > Thoughts?
> > > 
> > > source of onchain data
> > > 
> > > PortlandHODL
> > 
> > --
> > You received this message because you are subscribed to the Google 
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send 
> an email to bitcoindev+...@googlegroups.com.
> > To view this discussion visit 
> https://groups.google.com/d/msgid/bitcoindev/842930fb-bede-408a-8380-776d4be4e094n%40googlegroups.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/63c19ec4-ab83-4280-a5b3-037ff1b1b126n%40googlegroups.com.

[-- Attachment #1.2: Type: text/html, Size: 6247 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
    @ 2025-10-03 13:21  1% ` Peter Todd
  2025-10-03 16:52  0%   ` 'moonsettler' via Bitcoin Development Mailing List
  2025-10-03 15:42  0% ` Anthony Towns
                   ` (2 subsequent siblings)
  4 siblings, 1 reply; 200+ results
From: Peter Todd @ 2025-10-03 13:21 UTC (permalink / raw)
  To: PortlandHODL; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 2848 bytes --]

On Thu, Oct 02, 2025 at 01:42:06PM -0700, PortlandHODL wrote:
> Proposing: Softfork to after (n) block height; the creation of outpoints 
> with greater than 520 bytes in the ScriptPubkey would be consensus invalid. 
> 
> This is my gathering of information per BIP 0002
> 
> After doing some research into the number of outpoints that would have 
> violated the proposed rule there are exactly 169 outpoints. With only 8 
> being non OP_RETURN. I think after 15 years and not having discovered use 
> for 'large' ScriptPubkeys; the reward for not invalidating them at the 
> consensus level is lower than the risk of their abuse. 
> 
>    - 
> *Reasons for *
>       - Makes DoS blocks likely impossible to create that would have any 
>       sufficient negative impact on the network.

Further restricting v0 scripts is sufficient to achieve this goal. We do not
need to actually prohibit >520 byte pushes.

>       - Leaves enough room for hooks long term
>       - Would substantially reduce the divergence between consensus  and 
>       relay policy
>       - Incredibly little use onchain as evidenced above.
>       - Could possibly reduce codebase complexity. Legacy Script is largely 
>       considered a mess though this isn't a complete disablement it should reduce 
>       the total surface that is problematic.
>       - Would make it harder to use the ScriptPubkey as a 'large' 
>       datacarrier.
>       - Possible UTXO set size bloat reduction.
>       
>       - *Reasons Against *
>       - Bitcoin could need it in the future? Quantum?

NACK, for exactly this reason. It's hard to predict what kind of math will be
needed in the future for future signature algorithms. With taproot, we include
bare pubkeys in scriptPubKeys for a good reason. It's quite possible that we'll
want to do something similar with >520byte pubkeys for some future signature
algorithm (e.g. quantum hard) or some other difficult to predict technical
upgrade (the spendableness of scriptPubKeys with >520bytes isn't relevant to
this discussion).

>       - Users could just create more outpoints.

The second reason for my NACK. It makes no significant difference whether or
not data is contiguous or split across multiple outputs. All the same concerns
about arbitrary data ("spam") exist and will continue to be argued over even if
we do a soft-fork to prohibit this. All we'll done is have used up valuable dev
and political resources. 

-- 
https://petertodd.org 'peter'[:-1]@petertodd.org

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/aN_N4i4zZ5Dt8TdG%40petertodd.org.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

^ permalink raw reply	[relevance 1%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  2025-10-03 10:46  1%   ` 'moonsettler' via Bitcoin Development Mailing List
@ 2025-10-03 11:26  0%     ` /dev /fd0
  2025-10-03 13:35  0%     ` jeremy
  1 sibling, 0 replies; 200+ results
From: /dev /fd0 @ 2025-10-03 11:26 UTC (permalink / raw)
  To: moonsettler; +Cc: Bitcoin Development Mailing List

[-- Attachment #1: Type: text/plain, Size: 3806 bytes --]

Hi moonsettler,

> People could just add many OP_RETURNs to a transaction, that makes it
more cumbersome and marginally more expensive.

This is exactly what I wrote in my email and I consider it a positive
thing. I think we are just looking at this proposal from different
perspectives.

/dev/fd0
floppy disk guy

On Fri, Oct 3, 2025 at 4:16 PM moonsettler <moonsettler@protonmail.com>
wrote:

> Hi Floppy,
>
> There are only weak arguments for this proposal to extend to OP_RETURN, at
> least nothing I would normally entertain;
> but also there are weak arguments to make an exception for OP_RETURN
> explicitly.
>
> People could just add many OP_RETURNs to a transaction, that makes it more
> cumbersome and marginally more expensive.
>
> BR,
> moonsettler
>
>
> On Friday, October 3rd, 2025 at 10:58 AM, /dev /fd0 <alicexbtong@gmail.com>
> wrote:
>
> > Hi portlandhodl,
> >
> > We can't predict future usage, so it would be great if this was
> restricted to OP_RETURN. While there is no real use for a scriptPubKey
> larger than 520 bytes as shown in the data you shared, it is possible that
> users may create more OP_RETURN outputs after this change. It does not
> affect the UTXO set but will cost more and economically discourage the use
> of multiple OP_RETURN outputs.
> >
> > /dev/fd0
> > floppy disk guy
> > On Friday, October 3, 2025 at 3:29:24 AM UTC+5:30 PortlandHODL wrote:
> >
> > > Proposing: Softfork to after (n) block height; the creation of
> outpoints with greater than 520 bytes in the ScriptPubkey would be
> consensus invalid.
> > >
> > > This is my gathering of information per BIP 0002
> > >
> > > After doing some research into the number of outpoints that would have
> violated the proposed rule there are exactly 169 outpoints. With only 8
> being non OP_RETURN. I think after 15 years and not having discovered use
> for 'large' ScriptPubkeys; the reward for not invalidating them at the
> consensus level is lower than the risk of their abuse.
> > >
> > > -   Reasons for
> > >     -   Makes DoS blocks likely impossible to create that would have
> any sufficient negative impact on the network.
> > >     -   Leaves enough room for hooks long term
> > >     -   Would substantially reduce the divergence between consensus
> and relay policy
> > >     -   Incredibly little use onchain as evidenced above.
> > >     -   Could possibly reduce codebase complexity. Legacy Script is
> largely considered a mess though this isn't a complete disablement it
> should reduce the total surface that is problematic.
> > >     -   Would make it harder to use the ScriptPubkey as a 'large'
> datacarrier.
> > >     -   Possible UTXO set size bloat reduction.
> > >
> > > -   Reasons Against
> > >     -   Bitcoin could need it in the future? Quantum?
> > >     -   Users could just create more outpoints.
> > >
> > > Thoughts?
> > >
> > > source of onchain data
> > >
> > > PortlandHODL
> >
> > --
> > You received this message because you are subscribed to the Google
> Groups "Bitcoin Development Mailing List" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> an email to bitcoindev+unsubscribe@googlegroups.com.
> > To view this discussion visit
> https://groups.google.com/d/msgid/bitcoindev/842930fb-bede-408a-8380-776d4be4e094n%40googlegroups.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/CALiT-Zop43oiYxz1qaLm8RGZHOrd-_antFksY2VfgpzrKqPzCg%40mail.gmail.com.

[-- Attachment #2: Type: text/html, Size: 5075 bytes --]

^ permalink raw reply	[relevance 0%]

* Re: [bitcoindev] Re: [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus.
  @ 2025-10-03 10:46  1%   ` 'moonsettler' via Bitcoin Development Mailing List
  2025-10-03 11:26  0%     ` /dev /fd0
  2025-10-03 13:35  0%     ` jeremy
  2025-10-03 13:59  1%   ` Andrew Poelstra
  1 sibling, 2 replies; 200+ results
From: 'moonsettler' via Bitcoin Development Mailing List @ 2025-10-03 10:46 UTC (permalink / raw)
  To: /dev /fd0; +Cc: Bitcoin Development Mailing List

Hi Floppy,

There are only weak arguments for this proposal to extend to OP_RETURN, at least nothing I would normally entertain;
but also there are weak arguments to make an exception for OP_RETURN explicitly.

People could just add many OP_RETURNs to a transaction, that makes it more cumbersome and marginally more expensive.

BR,
moonsettler


On Friday, October 3rd, 2025 at 10:58 AM, /dev /fd0 <alicexbtong@gmail.com> wrote:

> Hi portlandhodl,
> 
> We can't predict future usage, so it would be great if this was restricted to OP_RETURN. While there is no real use for a scriptPubKey larger than 520 bytes as shown in the data you shared, it is possible that users may create more OP_RETURN outputs after this change. It does not affect the UTXO set but will cost more and economically discourage the use of multiple OP_RETURN outputs.
> 
> /dev/fd0
> floppy disk guy
> On Friday, October 3, 2025 at 3:29:24 AM UTC+5:30 PortlandHODL wrote:
> 
> > Proposing: Softfork to after (n) block height; the creation of outpoints with greater than 520 bytes in the ScriptPubkey would be consensus invalid.
> > 
> > This is my gathering of information per BIP 0002
> > 
> > After doing some research into the number of outpoints that would have violated the proposed rule there are exactly 169 outpoints. With only 8 being non OP_RETURN. I think after 15 years and not having discovered use for 'large' ScriptPubkeys; the reward for not invalidating them at the consensus level is lower than the risk of their abuse.
> > 
> > -   Reasons for
> >     -   Makes DoS blocks likely impossible to create that would have any sufficient negative impact on the network.
> >     -   Leaves enough room for hooks long term
> >     -   Would substantially reduce the divergence between consensus and relay policy
> >     -   Incredibly little use onchain as evidenced above.
> >     -   Could possibly reduce codebase complexity. Legacy Script is largely considered a mess though this isn't a complete disablement it should reduce the total surface that is problematic.
> >     -   Would make it harder to use the ScriptPubkey as a 'large' datacarrier.
> >     -   Possible UTXO set size bloat reduction.
> >         
> > -   Reasons Against
> >     -   Bitcoin could need it in the future? Quantum?
> >     -   Users could just create more outpoints.
> > 
> > Thoughts?
> > 
> > source of onchain data
> > 
> > PortlandHODL
> 
> --
> You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/842930fb-bede-408a-8380-776d4be4e094n%40googlegroups.com.

-- 
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/MH0kp4ehOxe8iikzhdxmFXM7GmIzpHGzGFujVeAdyUF_usOKf_CkToIBGSM2fB75TugGLsebVk8gM4OlS2VLHpGKIgmjkWDQuOwZeIr-F-E%3D%40protonmail.com.


^ permalink raw reply	[relevance 1%]

Results 1-200 of ~3000   | reverse | options above
-- pct% links below jump to the message on this page, permalinks otherwise --
2025-08-04 21:18     [bitcoindev] [BIP Proposal] No burn, Quantum Migration Proposal, Quantum Secure Asset Verification & Escrow (QSAVE) 'James T' via Bitcoin Development Mailing List
2025-08-09  1:33     ` [bitcoindev] " 'conduition' via Bitcoin Development Mailing List
2025-08-14 21:26       ` 'James T' via Bitcoin Development Mailing List
2025-08-19 10:43         ` Javier Mateos
2025-08-24 22:24           ` 'James T' via Bitcoin Development Mailing List
2025-09-15 16:52             ` 'conduition' via Bitcoin Development Mailing List
2026-09-21 23:23  0%           ` 'James T' via Bitcoin Development Mailing List
2025-10-01 14:24     [bitcoindev] On (in)ability to embed data into Schnorr waxwing/ AdamISZ
2025-10-07  8:22  2% ` Anthony Towns
2025-10-07 12:05  1%   ` waxwing/ AdamISZ
2025-10-02 20:42     [bitcoindev] [BIP Proposal] Limit ScriptPubkey Size >= 520 Bytes Consensus PortlandHODL
2025-10-03  1:21     ` [bitcoindev] " /dev /fd0
2025-10-03 10:46  1%   ` 'moonsettler' via Bitcoin Development Mailing List
2025-10-03 11:26  0%     ` /dev /fd0
2025-10-03 13:35  0%     ` jeremy
2025-10-03 13:59  1%   ` Andrew Poelstra
2025-10-03 14:18  0%     ` /dev /fd0
2025-10-03 14:59  1%       ` Andrew Poelstra
2025-10-03 16:15  1%         ` Anthony Towns
2025-10-05  9:59  1%           ` Guus Ellenkamp
2025-10-03 13:21  1% ` [bitcoindev] " Peter Todd
2025-10-03 16:52  0%   ` 'moonsettler' via Bitcoin Development Mailing List
2025-10-03 15:42  0% ` Anthony Towns
2025-10-03 20:02  0% ` Luke Dashjr
2025-10-03 20:52  0%   ` /dev /fd0
2025-10-04 23:12  0%     ` jeremy
2025-10-05 10:59  0%       ` Luke Dashjr
2025-10-08 15:03  1%   ` Greg Tonoski
2025-10-08 18:15  1%     ` Keagan McClelland
2025-10-15 20:04  0% ` [bitcoindev] " Casey Rodarmor
2025-10-16  0:06  0%   ` Greg Maxwell
2025-10-17 17:07         ` Brandon Black
2025-10-17 18:05           ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2025-10-18  1:01  1%         ` Antoine Riard
2025-10-18  4:03  1%           ` Greg Maxwell
2025-10-18 12:06  1%             ` PortlandHODL
2025-10-18 16:54  0%               ` /dev /fd0
2025-10-22  8:07  0%               ` 'moonsettler' via Bitcoin Development Mailing List
2025-10-27 23:44  2%                 ` Michael Tidwell
2025-10-30  2:26  0%                   ` Greg Maxwell
2025-10-30  3:36  0%                     ` Michael Tidwell
2025-10-30  6:15  0%                       ` Greg Maxwell
2025-10-30  8:55  1%                         ` Bitcoin Error Log
2025-10-30 17:40  0%                           ` Greg Maxwell
2025-10-30 16:10  1%                     ` Tom Harding
2025-10-30 22:15  0%                       ` Doctor Buzz
2025-10-12  9:20  1% [bitcoindev] Bitcoin Core v30.0 Released fanquake
2025-10-19 13:01  3% [bitcoindev] op_return spam is beneficial Erik Aronesty
     [not found]     ` <CAGvrRVK7hO9RQ==Q1_5xH7_HYar-EGPL_d3-wJ5q82vNDRHBiA@mail.gmail.com>
2025-10-27  3:39  2%   ` Erik Aronesty
2025-10-25 20:43     [bitcoindev] [BIP Proposal] Reduced Data Temporary Softfork dathonohm via Bitcoin Development Mailing List
2025-10-26 20:47     ` Jameson Lopp
2025-10-27  4:22       ` dathonohm via Bitcoin Development Mailing List
2025-10-27 16:35  1%     ` TheWrlck
2025-10-26 22:27     ` Peter Todd
2025-10-27  3:41  1%   ` Jal Toorey
2025-10-27 17:27  1%     ` Max
2025-10-27  4:08  1%   ` dathonohm via Bitcoin Development Mailing List
2025-10-27 18:29  1%     ` Kyle Stout
2025-10-27 19:56  0%       ` Greg Maxwell
2025-10-28  5:13  0%         ` dathonohm via Bitcoin Development Mailing List
2025-10-30  0:31  0%           ` Antoine Riard
2025-10-30  2:43                 ` Erik Aronesty
2025-11-08  0:51  1%               ` dathonohm via Bitcoin Development Mailing List
2025-11-08 15:38                     ` Greg Maxwell
2025-11-08 16:40  1%                   ` Daniel Buchner
2025-11-08 17:55  1%                     ` Chris Riley
2025-11-08 21:02  1%                   ` dathonohm via Bitcoin Development Mailing List
2025-11-08 21:39  0%                     ` Greg Maxwell
2025-11-09 20:07  1%                       ` dathonohm via Bitcoin Development Mailing List
2025-11-11  7:43  0%                         ` 'Bitcoin Eagle' via Bitcoin Development Mailing List
2025-11-11 16:23  0%                           ` Greg Maxwell
2025-11-09 21:34  1%                 ` Peter Todd
2025-10-28  9:16  1%         ` /dev /fd0
2025-10-28 16:01  2% [bitcoindev] [BIP Proposal] Soft Fork Compromise on op_return to Resolve Current Bitcoin Controversies Majorian
2025-10-28 16:37  1% ` Martin Habovštiak
2025-10-28 16:50  5% ` Erik Aronesty
2025-10-28 17:38  2% ` 'Russell O'Connor' via Bitcoin Development Mailing List
2025-10-29  9:39  1%   ` TokyoBitcoiner
2025-10-29 15:03  1%     ` 'Russell O'Connor' via Bitcoin Development Mailing List
2025-10-29 16:10  1%       ` yes_please
2025-10-30  2:10  1%         ` Greg Maxwell
2025-10-30 15:04  1%           ` Melvin Carvalho
2025-10-30 19:35  1%             ` Martin Habovštiak
2025-10-31  6:31  1%               ` Melvin Carvalho
2025-10-29 23:40  1% [bitcoindev] segOP potential BIP discussion defenwycke
2025-10-30 21:25  2% ` [bitcoindev] " defenwycke
2025-10-30  0:03  3% [bitcoindev] By: Doctorbuzz1 {GitHub} Limit "Bulk Dust" with a default filter or consensus Frenchanfry
2025-10-30  1:02  0% ` [bitcoindev] " Doctor Buzz
2025-10-30 14:14  1%   ` Doctor Buzz
2025-10-31 17:54     [bitcoindev] [Pre-BIP Discussion] Bitcoin Node Repository Consensus-Policy Separation Juan Aleman
2025-10-31 18:21     ` Greg Maxwell
2025-10-31 18:32       ` Juan Aleman
2025-10-31 18:47         ` Greg Maxwell
2025-10-31 18:56           ` Juan Aleman
2025-10-31 22:59             ` Antoine Riard
2025-11-01 15:59               ` Juan Aleman
2025-11-01 17:54  1%             ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2025-11-03 23:05  1% [bitcoindev] LNHANCE a soft-fork package 'moonsettler' via Bitcoin Development Mailing List
2025-11-20  1:57  1% [bitcoindev] A safe way to remove objectionable content from the blockchain Lazy Fair
2025-11-20 18:45  0% ` Greg Maxwell
2025-11-23  6:37  0%   ` Saint Wenhao
2025-11-20 21:21  0% ` Ethan Heilman
2025-11-29  9:25       ` Peter Todd
2025-11-29 13:54  1%     ` waxwing/ AdamISZ
2025-11-29 15:41  0%       ` Erik Aronesty
2025-11-29 15:56  0%         ` waxwing/ AdamISZ
2025-11-29 17:03  1%           ` Erik Aronesty
2025-11-29 18:15  0%             ` Greg Maxwell
2025-11-29 18:52  0%               ` waxwing/ AdamISZ
2025-11-30 14:39           ` Peter Todd
2025-12-02 12:33  1%         ` waxwing/ AdamISZ
2025-12-08 17:34  0%           ` Nagaev Boris
2025-12-09 14:24  1%             ` waxwing/ AdamISZ
2025-12-09 19:32  1%               ` Boris Nagaev
2025-12-06  6:41  1% [bitcoindev] A safe way to remove objectionable content from the blockchain (now on GitHub) Lazy Fair
2025-12-06 16:08  1% [bitcoindev] Reducing RAM requirements with dynamic dust 'uuowwpevskfcordh' via Bitcoin Development Mailing List
2025-12-10 18:30  0% ` [bitcoindev] " Eric Voskuil
2025-12-10 19:33  0%   ` Erik Aronesty
2025-12-10 20:44  0%     ` Eric Voskuil
2025-12-12 22:22  1%       ` 'uuowwpevskfcordh' via Bitcoin Development Mailing List
2025-12-08 20:28     [bitcoindev] Hash-Based Signatures for Bitcoin's Post-Quantum Future 'Mikhail Kudinov' via Bitcoin Development Mailing List
2025-12-18 18:45  1% ` [bitcoindev] " Erik Aronesty
2025-12-08 21:52  1% [bitcoindev] Request for early peer review of two BIP drafts (BUDS and segOP) Callum
2025-12-11 12:53  3% [bitcoindev] Draft BIP: DustSweep – policy-only UTXO dust compaction defenwycke
2025-12-12 18:10  0% ` [bitcoindev] " Jonathan Voss
2025-12-12 20:17  0%   ` Defenwycke
2025-12-12 22:49  0% ` [bitcoindev] " Murch
2025-12-13 14:56  1%   ` defenwycke
2025-12-22 19:06  0%     ` Murch
2025-12-22 19:33  0%       ` Defenwycke
     [not found]     <32f8c689-314d-4a5e-9af6-2e3e704582e6n@googlegroups.com>
     [not found]     ` <CAAS2fgRR77nZj3-rJo70dnxe8Lma88-C9JqdVTYfXGHRgFu3pA@mail.gmail.com>
2025-12-11 20:54  2%   ` [bitcoindev] The Cat, BIP draft discussion Bitcoin Mechanic
2025-12-12  1:49  0%   ` TwoLargePizzas
2025-12-13 15:02         ` Greg Maxwell
2025-12-14  1:51  1%       ` Pepe Hodler
2025-12-15 10:35  1%       ` Nona YoBidnes
2025-12-15 16:04  1%         ` Greg Maxwell
2025-12-12 17:13  2% ` [bitcoindev] " Jonathan Voss
2025-12-12 23:40  1%   ` Greg Maxwell
2025-12-13  3:54  2%     ` Melvin Carvalho
2025-12-13  7:07  1%     ` Ataraxia 009
2025-12-17 16:22  0%     ` Jonathan Voss
2025-12-19  3:31  0%       ` Greg Maxwell
2025-12-21  5:07  3%         ` John
2025-12-23 19:12  0%           ` Greg Maxwell
2025-12-24 17:19  1%             ` waxwing/ AdamISZ
2025-12-30 14:36  1%               ` Antoine Riard
2026-01-19  1:11  4%                 ` Pepe Hodler
2026-01-23  3:45  1%                   ` Chris Riley
2026-01-23 13:55  4%                   ` Galois Field
2026-01-22  1:14  1%                 ` Claire Ostrom
2025-12-30 15:59     [bitcoindev] Addressing remaining points on BIP 54 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-01-08  4:29     ` [bitcoindev] " Antoine Riard
2026-01-08  8:30  1%   ` [bitcoindev] " Sjors Provoost
2026-01-08 16:36  0%     ` Matt Corallo
2026-01-13  2:16  0%       ` Antoine Riard
2026-01-13 16:59  0%         ` Mubarek Juhar
2026-01-08 16:40  0%     ` Matt Corallo
2026-01-13  1:49  1%     ` Antoine Riard
2026-01-14  0:23  0%     ` Murch
2026-01-14 10:15  1%       ` Sjors Provoost
2026-01-14 15:33  0%         ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-01-14 18:58  0%           ` Murch
2026-01-30  4:08  1%             ` Antoine Riard
2026-02-05 22:48  0%               ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-02-12  3:57  0%                 ` Antoine Riard
2026-01-07  1:36  1% [bitcoindev] BIP Idea: incrementalrelayfee in feefilter? Matthew Husák
2026-01-07 18:50  0% ` Murch
2026-01-08 18:13  1%   ` Matthew Husák
2026-01-22  6:41  1% [bitcoindev] Garbled Circuit and Channel Jamming Antoine Riard
2026-05-14  1:38  0% ` [bitcoindev] " Antoine Riard
2026-02-26 22:12     [bitcoindev] [BIP Draft] 24 bits for nVersion nonce space instead of 16 Matt Corallo
2026-03-28 11:58     ` Anthony Towns
2026-04-08 16:16  1%   ` Sjors Provoost
2026-04-08 20:11  0%     ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-03-16 16:10  1% [bitcoindev] [Draft BIP proposal] Ladder script defenwycke
2026-03-30 18:34  1% [bitcoindev] [BIP Draft] Dust UTXO Disposal Protocol 'bubb1es' via Bitcoin Development Mailing List
2026-04-06 16:18  0% ` Murch
2026-04-06 18:11  0%   ` STEVEN SLATER
2026-04-06 20:45  0%     ` Murch
2026-04-10  2:23  0%       ` 'bubb1es' via Bitcoin Development Mailing List
2026-04-10  2:14  1%   ` 'bubb1es' via Bitcoin Development Mailing List
2026-04-14 22:39  0%     ` Murch
2026-04-16 22:02  0%       ` 'bubb1es' via Bitcoin Development Mailing List
2026-04-06 20:30  1% [bitcoindev] A slight change proposed on Committing to quantum resistance: a slow defence for Bitcoin against a fast quantum computing attack PYM
2026-04-11 17:09  0% ` [bitcoindev] " Daniel Buchner
2026-04-07  3:13  1% [bitcoindev] New bitcoin backbone code release: addr / tx relay mngt + multiproces support layout Antoine Riard
2026-04-20  7:22  1% [bitcoindev] BIP-322: Add type prefix, change PoF serialization, PSBT-based signing Oliver
2026-04-20 14:47  1% ` [bitcoindev] " Thomas Suau
2026-04-21  9:16  0%   ` Oliver
2026-04-21 13:13  0%     ` [bitcoindev] " thomas s.
2026-05-05 11:38  1% [bitcoindev] The Bitcoin Lost and Found Light
2026-05-05 13:23  0% ` [bitcoindev] " waxwing/ AdamISZ
2026-05-05 15:36     [bitcoindev] [BIP Draft] P2P UTXO Set Sharing 'Fabian' via Bitcoin Development Mailing List
2026-05-05 16:01     ` [bitcoindev] " Eric Voskuil
2026-05-07 21:34       ` 'Fabian' via Bitcoin Development Mailing List
2026-05-12 15:56         ` eric
2026-05-15 23:08           ` Anthony Towns
2026-05-16  0:58  1%         ` eric
2026-05-16 17:58  0%           ` Saint Wenhao
2026-05-16 21:48  0%             ` 'Fabian' via Bitcoin Development Mailing List
2026-05-27  0:17     [bitcoindev] [BIP Proposal] Hybrid SPHINCS+ / secp256k1 Key Derivation for Quantum-Resistant Paper Wallets '3D' via Bitcoin Development Mailing List
2026-05-27  0:51  1% ` 'conduition' via Bitcoin Development Mailing List
2026-06-02 11:24     [bitcoindev] [BIP Draft] Testnet 5 'Pol Espinasa' via Bitcoin Development Mailing List
2026-06-02 15:02  1% ` Saint Wenhao
2026-06-02 15:29  0%   ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-06-02 16:22  0%   ` Garlo Nicon
2026-06-02 16:48  0%     ` 'Pol Espinasa' via Bitcoin Development Mailing List
2026-06-02 16:37  0%   ` 'Pol Espinasa' via Bitcoin Development Mailing List
2026-06-03 23:12     [bitcoindev] Aligning privacy incentives in P2MR 'conduition' via Bitcoin Development Mailing List
2026-06-05 19:56     ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-06-05 22:52       ` 'conduition' via Bitcoin Development Mailing List
2026-06-06  4:29         ` Pieter Wuille
2026-06-06 19:33  2%       ` 'conduition' via Bitcoin Development Mailing List
2026-06-25 17:42     [bitcoindev] Giving teeth to expected EC disabling: P2XX(-T)(-ML) Pieter Wuille
2026-06-26  3:40     ` Nagaev Boris
2026-06-26 14:10       ` Pieter Wuille
2026-06-26 18:20  1%     ` 'conduition' via Bitcoin Development Mailing List
2026-07-03 21:23  1%       ` Pieter Wuille
2026-07-04 11:57  1%         ` Sjors Provoost
2026-07-05 21:55  0%           ` Antoine Riard
2026-08-13  3:28  0%             ` waxwing/ AdamISZ
2026-08-14 18:33  0%               ` 'conduition' via Bitcoin Development Mailing List
2026-08-15 14:49  0%                 ` waxwing/ AdamISZ
2026-08-15 16:52  0%                   ` 'conduition' via Bitcoin Development Mailing List
2026-08-15 18:06  0%                     ` waxwing/ AdamISZ
2026-08-16 19:30  1%                       ` 'conduition' via Bitcoin Development Mailing List
2026-08-18 14:36  1%                         ` waxwing/ AdamISZ
2026-08-18 17:20                               ` Pieter Wuille
2026-08-19  2:32  1%                             ` 'conduition' via Bitcoin Development Mailing List
2026-08-19 15:18  1%                               ` waxwing/ AdamISZ
2026-08-19 22:16  1%                               ` Pieter Wuille
2026-07-29 17:21  1% [bitcoindev] [BIP Proposal] Stale Tip Relay Ram
2026-08-11 13:51  0% ` Edil Guimarães de Medeiros
2026-08-13 18:53  0%   ` Ram
2026-11-05 23:19  0% ` 'Antoine Poinsot' via Bitcoin Development Mailing List
2026-08-09 18:29     [bitcoindev] Motion to remove Luke Dashjr from BIP Editors Murch
2026-08-09 19:48     ` Matt Corallo
2026-08-09 20:42       ` Michael Tidwell
2026-08-10  1:40  1%     ` Antoine Riard
2026-08-19 22:27  1% [bitcoindev] post-quantum: solution ideas to "tripwire"game-theory issues + a certificate-based rescue protocol Antoine Riard
2026-08-20 16:33  0% ` 'conduition' via Bitcoin Development Mailing List
2026-08-26 21:54  0%   ` Antoine Riard
2026-08-20 21:30  1% [bitcoindev] DropKick ⚽️ - A minimal commit/reveal PQ " 'conduition' via Bitcoin Development Mailing List
2026-08-22 17:46  0% ` Alex
2026-08-23 23:28  0%   ` 'conduition' via Bitcoin Development Mailing List
2026-09-18 16:51  0%     ` Antoine Riard
2026-10-04  0:52  1%       ` 'conduition' via Bitcoin Development Mailing List
2026-09-02  9:52  1% [bitcoindev] Silent payments light clients: measurements and index commitments Rob Segers
2026-10-28 15:45  1% [bitcoindev] Bitcoin Core v32.1 Released fanquake
2026-11-09 18:14  1% [bitcoindev] Testnet 5 launch Anthony Towns

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox