Re: [bitcoin-dev] Stamping transaction

[Mostafa Sedaghat joo <mostafa.sedaghat@gmail.com>]

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

Good day ZmnSCPxj

Thank you so much for your time to read my proposal.
About your comments, I do agree with some of them but maybe we need to
discuss more about them.
You might agree that any changes (especially a fundamental change like
stamping transactions) comes with advantages and probably some
disadvantages. I believe the advantages of stamping transactions are worth
having it.


*The main point of stamping transactions is decoupling transactions from
the block. *

*Blockchain size matters*
SegWit is a good witness that shows blockchain size matters. Nowadays, Data
storage is cheap and easy, but that doesn't mean it's a simple matter. If
you need to have a data-center to keep a copy of a blockchain, then you are
far from a decentralization system.

*A Solution*
Stamping transaction is a simple idea to keep the size of the blockchain as
small as possible. The question that I was looking to answer is how we can
decouple the transaction from the blocks.
Who cares about the transaction that happened 10 years ago. In the real
world you may go to your bank and ask them to give you transaction history.
But they probably have limits. They might say we just only keep the last 3
months in our system.

*Implementation*

> First off, the proposed mechanism can be made into a softfork by using an
unspendable `scriptPubKey` with 0 output value.
SoftFork is not possible here. Because the transaction will not be saved
inside the block (only tx hashes). Block format needs to be changed.
Therefore the block will be invalid.

> Engineering-wise, block validation now needs to memorize the last N block
hashes.
I don't think we need to memorize the last N block hashes.  We can have
something like:
```
Current_Height - Height_Of(tx.stamp) <= N
```
*Incentives*
I think Stamping transactions have nothing to do with the
incentivization mechanism.  Forgive me if I couldn't get your point.

*Mempool*
It's bad of me that I don't really know how mempool works in Bitcoin. My
assumption is that there are some junk transactions (transactions that are
valid but have very low or zero fees) inside the mempool. Stamping
transactions might help to get rid of them time to time.

Best Regards,
Mostafa


On Sun, Jun 7, 2020 at 8:40 AM ZmnSCPxj <ZmnSCPxj@protonmail.com> wrote:

> Good morning Mostafa,
>
> First off, the proposed mechanism can be made into a softfork by using an
> unspendable `scriptPubKey` with 0 output value.
>
> For example, a stamp could by convention be any 0-value output whose
> `scriptPubKey` is `<blockhash> OP_0`, which should be unspendable.
>
> Post-softfork nodes would reject blocks where some transaction is stamped
> and the stamped `<blockhash>` is not within the last N blocks.
> Pre-softfork nodes would not see anything special about the unspendable
> `scriptPubKey` and would just accept it (but would not relay such
> transactions due to standardness).
>
> Engineering-wise, block validation now needs to memorize the last N block
> hashes.
>
> The mempool design currently assumes that a transaction that enters the
> mempool is always valid unless any UTXOs it spends have been removed.
> This is important since miner block selection algorithms assume the
> mempool contains transactions that are currently valid.
> Thus, there is the additional need to drop transactions from the mempool
> if they are stamped with a block that has dropped from the stamp TTL.
>
> Another issue is incentives.
> The stamp takes up blockchain space that is paid for by the creator of the
> transaction.
> Further, the creator of the transaction gains no advantage from the
> stamped transaction; it is others who gain an advantage (the stamped
> transaction is more likely to be dropped from the mempool).
> Discounting the stamp somehow will probably make this into a hardfork.
> It might be sneaked into the witness somehow by adding it as a field
> somewhere in the new parts of Taproot (there is, a new block of data in
> Taproot that can be used for this), but note that the cost will still be
> non-zero (and users of this feature will still have a disadvantage in that
> their transactions are more likely to be dropped from the mempool).
>
> Finally, it is expected to increase bandwidth use since a dropped stamped
> transaction will probably be rebroadcast with a new stamp, so effectively
> the transaction is retransmitted again with a different stamp.
>
>
> Regards,
> ZmnSCPxj
>

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