Optimize encoding of dictionaries

Switch from CBOR map to CBOR array to improve speed and preserve
ordering.

Remove key strings from encoding.

Remove old backwards-compatibility decoding code.

Add tests, including round-trip for decoding old format and encoding new
format.

Closes onflow#743

runtime/interpreter/decode.go

@@ -20,7 +20,6 @@ package interpreter
 
 import (
 	"bytes"
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"io"
@@ -305,7 +304,7 @@ func (d *DecoderV4) decodeArray(v []interface{}, path []string) (*ArrayValue, er
 }
 
 func (d *DecoderV4) decodeDictionary(v interface{}, path []string) (*DictionaryValue, error) {
-	encoded, ok := v.(map[interface{}]interface{})
+	encoded, ok := v.([]interface{})
 	if !ok {
 		return nil, fmt.Errorf(
 			"invalid dictionary encoding (@ %s): %T",
@@ -335,7 +334,7 @@ func (d *DecoderV4) decodeDictionary(v interface{}, path []string) (*DictionaryV
 	}
 
 	entriesField := encoded[encodedDictionaryValueEntriesFieldKey]
-	encodedEntries, ok := entriesField.(map[interface{}]interface{})
+	encodedEntries, ok := entriesField.([]interface{})
 	if !ok {
 		return nil, fmt.Errorf(
 			"invalid dictionary entries encoding (@ %s): %T",
@@ -347,57 +346,6 @@ func (d *DecoderV4) decodeDictionary(v interface{}, path []string) (*DictionaryV
 	keyCount := keys.Count()
 	entryCount := len(encodedEntries)
 
-	// In versions <= 2, the dictionary key string function
-	// was accidentally, temporarily changed without a version change.
-	//
-	// The key string format for address values is:
-	// prefix the address with 0x, encode in hex, and strip leading zeros.
-	//
-	// Temporarily and accidentally the format was:
-	// no 0x prefix, and encode and in full length hex.
-	//
-	// Detect this temporary format and correct it
-
-	var hasAddressValueKeyInWrongPre3Format bool
-
-	if d.version <= 2 {
-		for _, keyValue := range keys.Values {
-			keyAddressValue, ok := keyValue.(AddressValue)
-			if !ok {
-				continue
-			}
-
-			currentKeyString := keyAddressValue.KeyString()
-			wrongKeyString := hex.EncodeToString(keyAddressValue[:])
-
-			// Is there a value stored with the current format?
-			// Then no migration is necessary.
-
-			if encodedEntries[currentKeyString] != nil {
-				continue
-			}
-
-			// Is there at least a value stored in the wrong key string format?
-
-			if encodedEntries[wrongKeyString] == nil {
-
-				return nil, fmt.Errorf(
-					"invalid dictionary address value key: "+
-						"could neither find entry for wrong format key %s, nor for current format key %s",
-					wrongKeyString,
-					currentKeyString,
-				)
-			}
-
-			// Migrate the value from the wrong format to the current format
-
-			hasAddressValueKeyInWrongPre3Format = true
-
-			encodedEntries[currentKeyString] = encodedEntries[wrongKeyString]
-			delete(encodedEntries, wrongKeyString)
-		}
-	}
-
 	// The number of entries must either match the number of keys,
 	// or be zero in case the values are deferred
 
@@ -424,13 +372,6 @@ func (d *DecoderV4) decodeDictionary(v interface{}, path []string) (*DictionaryV
 
 	if isDeferred {
 
-		if hasAddressValueKeyInWrongPre3Format {
-			return nil, fmt.Errorf(
-				"invalid dictionary (@ %s): dictionary with address values in pre-3 format and deferred values",
-				strings.Join(path, "."),
-			)
-		}
-
 		deferred = orderedmap.NewStringStructOrderedMap()
 		deferredOwner = d.owner
 		deferredStorageKeyBase = joinPath(append(path[:], dictionaryValuePathPrefix))
@@ -455,15 +396,8 @@ func (d *DecoderV4) decodeDictionary(v interface{}, path []string) (*DictionaryV
 			}
 
 			keyString := keyStringValue.KeyString()
-			value, ok := encodedEntries[keyString]
-			if !ok {
-				return nil, fmt.Errorf(
-					"missing dictionary value for key (@ %s, %d): %s",
-					strings.Join(path, "."),
-					index,
-					keyString,
-				)
-			}
+
+			value := encodedEntries[index]
 
 			valuePath := append(path[:], dictionaryValuePathPrefix, keyString)
 			decodedValue, err := d.decodeValue(value, valuePath)

runtime/interpreter/encode.go

@@ -31,6 +31,8 @@ import (
 	"github.com/onflow/cadence/runtime/common"
 )
 
+type cborArray = []interface{}
+
 type cborMap = map[uint64]interface{}
 
 // Cadence needs to encode different kinds of objects in CBOR, for instance,
@@ -667,7 +669,6 @@ const (
 const dictionaryKeyPathPrefix = "k"
 const dictionaryValuePathPrefix = "v"
 
-// TODO: optimize: use CBOR map, but unclear how to preserve ordering
 func (e *Encoder) prepareDictionaryValue(
 	v *DictionaryValue,
 	path []string,
@@ -683,7 +684,8 @@ func (e *Encoder) prepareDictionaryValue(
 		return nil, err
 	}
 
-	entries := make(map[string]interface{}, v.Entries.Len())
+	// Use CBOR array for entry value to preserve ordering and improve speed.
+	entries := make([]interface{}, 0, v.Entries.Len())
 
 	// Deferring the encoding of values is only supported if all
 	// values are resources: resource typed dictionaries are moved
@@ -755,13 +757,13 @@ func (e *Encoder) prepareDictionaryValue(
 			if err != nil {
 				return nil, err
 			}
-			entries[key] = prepared
+			entries = append(entries, prepared)
 		}
 	}
 
 	return cbor.Tag{
 		Number: cborTagDictionaryValue,
-		Content: cborMap{
+		Content: cborArray{
 			encodedDictionaryValueKeysFieldKey:    keys,
 			encodedDictionaryValueEntriesFieldKey: entries,
 		},