AVM: Adding sumhash and falcon_verify

[jannotti]

This should allow the AVM to check state proofs and/or create PQ safe Algorand accounts

AVM state proof checking would still be a lot of work. State proofs are really big, so the verification would have to be incremental, by feeding in parts of the proof a little at a time.

It should be possible to create PQ safe accounts today with falcon_verify by creating a logicsig that approves if the logicsig args conatin a falcon signature of the transaction. An extra precaution would be to ensure that the logicsig address (formed by hash of program) is an invalid ed25519 public key.

There is at least a little interest in sumhash512 on its own as well, since it is a zk friendly hash.

These opcodes would be kept "experimental" (always one version beyond mainnet) until they are proven sufficient for something useful.

[codecov]

Codecov Report

Attention: 2 lines in your changes are missing coverage. Please review.

Comparison is base (e7aa0d4) 55.95% compared to head (175401e) 55.92%.

Files	Patch %	Lines
data/transactions/logic/crypto.go	89.47%	1 Missing and 1 partial ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #5599      +/-   ##
==========================================
- Coverage   55.95%   55.92%   -0.03%     
==========================================
  Files         477      477              
  Lines       67436    67455      +19     
==========================================
- Hits        37736    37727       -9     
- Misses      27149    27168      +19     
- Partials     2551     2560       +9     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[jannotti]

It is likely that a state proof checking AVM contract would also need access to this:

// LnIntApproximation returns a uint64 approximation
func LnIntApproximation(x uint64) (uint64, error) {
	if x == 0 {
		return 0, ErrIllegalInputForLnApprox
	}
	result := math.Log(float64(x))
	precision := uint64(1 << precisionBits)
	expandWithPrecision := result * float64(precision)
	return uint64(math.Ceil(expandWithPrecision)), nil
}

as an opcode.

[HashMapsData2Value]

Out of curiosity would this enable:

1. Trustless bridging from an Algorand co-chain (or anything making use of state proofs) to Algorand, without having to snarkify the state proof?

2. The ability to prove to Algorand today that something, a transaction, took place in its distance past (beyond the 1000 block limit)?

[jannotti]

The intention was to allow 1. But this is a low priority thing I did for fun one day. We'd need someone to put in the effort to show it could be done before pushing this into mainnet.

I don't think it gives you 2, unless you implement fast catch-up by going through state proofs in an AVM contract. Maybe?