optimize historical range

[rrazvan1]

Why this should be merged

Direct optimization:

• how combined changes are computed between 2 roots
• getting changes to a specific root
• changes iterator using startKey and/or prefix

Indirect optimization

• change proofs
• range proofs
• view changes iterator

Fixes:

• getChangesToGetToRoot(..) no-ops being removed from output

How this works

• changeSummary struct has a new field for having the changed keys in a sorted slice
• getChangesToGetToRoot(..) -> by having the sortedKeys, we can search (binary search) for the startKey, and also easily stop iterating when we are after endKey.
• getValueChanges(..) -> we can easily get change values between startRoot and endRoot, with keys within [startKey, endKey] in the following way:
  1. init a minheap where we store a root traverse information: changes, insertNumber and index. Min => the root with the min key and min insertNumber (in this way, by popping out of the minheap, we traverse all the keys in ASC order by [key, insertNumber])
  2. iterate through each root's changes, and find (binary search) the index of the first key within [startKey, endKey], and push that initial state of each root into the heap (or not, if there are no keys inside that interval).
  3. pop elements out of minheap, and while the key is same, we merge the changes and store the final combined change.

IMPORTANT improvement for getValueChanges(..): we can stop whenever there are maxLength key changes found.

How this was tested

Using the existing unit tests.
Adding new unit tests, or modifying existing ones to properly cover the new code.