[Feature Request] Lightweight transaction execution proofs

[piersy]

Network

zkSync Era

Provide a brief description of the feature you would like to see implemented.

The ability to prove in a lightweight manner to a third party that your transaction was executed on the L2. Something similar to how simplified payment verification (spv) works on ethereum. It seems like this could be achieved by adding to batches a merkle root of transactions belonging to a batch. Then users could prove their transaction execution to a third party by sending the transaction and merkle path for that transaction to the third party, the third party could then verify the merkle path using the stored batch info on the L1.

From my research it seems that currently the mechanism with the least reliance on the L2 to prove transaction execution to a third party would be as follows:

• Have the third party use the L1 to recreate the state up to but not including the batch in which the tx to be proven resides.
• Have the third party execute the batch with the tx to be proven (the batch could be sent by the tx originator or the third party would need to request the batch from the L2)
• The third party checks that the state root they calculated matches the state root of the batch on L1.

Who does this feature request benefit the most (users, developers, protocol, etc.)?

Its beneficial to anyone who want's to check transaction inclusion without having to run their own L2 node, so I'd say that covers both developers and users.

Additional Details

No response

[StanislavBreadless]

Hey, it is technically possible, we already calculate hashes of transactions internally, so we'll just have to create a merkle tree of those (we already do something similar with L2->L1 messaging).

But:

• It is an additional feature (I would say mid-sized) to implement and maintain.
• As all new features it needs to be audited.

So it is just a matter of priorities. We could potentially add it in case we see enough demand for it from the community. It is just that usually someone that needs to track transactions, usually needs to track all of those.

[mm-zk]

As @StanislavBreadless mentioned - this is technically possible (even today) - but without contract changes, it can be very slow.

In order to prove that transaction X, belongs to miniblock Y, that belongs to batch Z, you'll need:

• miniblock hash is produced by concatenation of previous block and all transactions within the block. So you can prove that X belongs to Y.
• to prove that Y belongs to Z - we store the last 256 miniblock hashes in the state, which you can get from L1, and verify.

so TL;DR - today you can verify that transaction was really included in L2, but you need a collaborative L2 sequencer (that actually answers your queries), and some tooling (that I've described above, but we didn't implement yet).

[Arlo118]

Through ETH Cancun upgrade, lightweight verification of transaction execution on L2 can be carried out, reducing various gas costs without the need to run nodes, benefiting the entire ecosystem