Here's the code for their implementation: github.com/TECDSA/ecdsa...

Here's a link to the repository and its documentation:

Repository: github.com/primefactor-...
Documentation: pkg.go.dev/github.com/p...

To maximize learning I constrained myself to only depend on the standard library and zero 3rd party dependencies.

The whole code is covered with various tests which you can use to see how the implementation can be used in practice.

I also had to do a lot of pen-and-paper math to figure out how everything works.

I'm super happy that it's finally out there! I also learned a ton while working on this which is valuable in and of itself.

Implementing the Verifiable Timed Commitment scheme was definitely a hard nut to crack.

I started working on this late last year, but there were a lot of missing pieces I had to put in place (e.g. implement the Linearly Homomorphic Time-Lock Puzzle first).

One could use this in 2/2 multisigs (e.g. Payment Channels).

Before funding the multisig, we could create a signed refund transaction which is timelocked via a VTC.

The VTC can be opened after time t which allows one to refund themselves if the co-signer doesn't cooperate.

Using this, timelock capabilities can be brought to Blockchains that don't have a scripting language.

It furthermore increases privacy as no data regarding the timelock is stored on-chain (the VTC is shared off-chain).

This construction has various applications, but the one I'm focusing on is refund transactions.

Rather than using the Blockchain's scripting language you can share an encrypted signature over a refund transaction off-chain.

This signature can then be recovered after time t.

The VTC implementation described in the paper is really elegant as it uses Linearly Homomorphic Time-Lock Puzzles to implement the proof via a cut-and-choose mechanism.

I highly recommend you read the paper or watch this presentation to learn more: www.youtube.com/watch?v=X4vO...

Verifiability is implemented via a proof which guarantees that the value that can be decrypted after time t is the one that was committed to.

In our example we could provide the public key and the proof guarantees that the encrypted private key corresponds to the public key.

A Verifiable Timed Commitment (VTC) allows one to commit to a value that's encrypted "into the future".

For example, I can commit to and encrypt a private key in such a way that it can only be decrypted after time t.

Paper: eprint.iacr.org/2020/1563.pdf
Repository: github.com/primefactor-...
Documentation: pkg.go.dev/github.com/p...

That would be awesome!

For me first thing in the morning is checking the new publications on eprint.iacr.org (also followed arxiv.org/list/cs.CR/recent but there’s too much noise IMHO).