Apply go fmt changes and cleanup

libraries/shared/factories/storage/transformer.go

@@ -47,11 +47,9 @@ func (transformer Transformer) Execute(row utils.StorageDiffRow) error {
 	if lookupErr != nil {
 		return lookupErr
 	}
-	//packed storage slots return a slice of decoded values
 	value, decodeErr := utils.Decode(row, metadata)
 	if decodeErr != nil {
 		return decodeErr
 	}
-
 	return transformer.Repository.Create(row.BlockHeight, row.BlockHash.Hex(), metadata, value)
 }

libraries/shared/mocks/storage_repository.go

@@ -33,7 +33,6 @@ func (repository *MockStorageRepository) Create(blockNumber int, blockHash strin
 	repository.PassedBlockNumber = blockNumber
 	repository.PassedBlockHash = blockHash
 	repository.PassedMetadata = metadata
-
 	repository.PassedValue = value
 	return repository.CreateErr
 }

libraries/shared/storage/utils/decoder.go

@@ -18,8 +18,9 @@ package utils
 
 import (
 	"fmt"
-	"github.com/ethereum/go-ethereum/common"
 	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
 )
 
 func Decode(row StorageDiffRow, metadata StorageValueMetadata) (interface{}, error) {
@@ -61,25 +62,29 @@ func decodeAddress(raw []byte) string {
 }
 
 func decodePackedSlot(raw []byte, packedTypes map[int]ValueType) map[int]string {
-	storageSlot := raw
+	storageSlotData := raw
-	var results = map[int]string{}
+	decodedStorageSlotItems := map[int]string{}
-
-	//the reason we're using a map and not a slice is that golang doesn't guarantee the order of a slice
 	numberOfTypes := len(packedTypes)
-	for position := 0; position < numberOfTypes; position++ {
-		valueType := packedTypes[position]
-		lengthOfStorageSlot := len(storageSlot)
-		lengthOfItem := getNumberOfBytes(valueType)
-		itemStartingIndex := lengthOfStorageSlot - lengthOfItem
-		value := storageSlot[itemStartingIndex:]
-		decodedValue := decodeIndividualItems(value, valueType)
-		results[position] = decodedValue
 
-		//pop last item off slot before moving on
+	for position := 0; position < numberOfTypes; position++ {
-		storageSlot = storageSlot[0:itemStartingIndex]
+		//get length of remaining storage date
+		lengthOfStorageData := len(storageSlotData)
+
+		//get item details (type, length, starting index, value bytes)
+		itemType := packedTypes[position]
+		lengthOfItem := getNumberOfBytes(itemType)
+		itemStartingIndex := lengthOfStorageData - lengthOfItem
+		itemValueBytes := storageSlotData[itemStartingIndex:]
+
+		//decode item's bytes and set in results map
+		decodedValue := decodeIndividualItems(itemValueBytes, itemType)
+		decodedStorageSlotItems[position] = decodedValue
+
+		//pop last item off raw slot data before moving on
+		storageSlotData = storageSlotData[0:itemStartingIndex]
 	}
 
-	return results
+	return decodedStorageSlotItems
 }
 
 func decodeIndividualItems(itemBytes []byte, valueType ValueType) string {

libraries/shared/storage/utils/decoder_test.go

@@ -17,10 +17,11 @@
 package utils_test
 
 import (
+	"math/big"
+
 	"github.com/ethereum/go-ethereum/common"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"math/big"
 
 	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
 )

libraries/shared/storage/utils/value.go

@@ -33,8 +33,8 @@ type StorageValueMetadata struct {
 	Name        string
 	Keys        map[Key]string
 	Type        ValueType
-	PackedNames map[int]string    //name of each item packed and their order
+	PackedNames map[int]string    //position in map (zero indexed) => name of packed item
-	PackedTypes map[int]ValueType //type of each item packed and their order
+	PackedTypes map[int]ValueType //position in map (zero indexed)=> type of packed item
 }
 
 func GetStorageValueMetadata(name string, keys map[Key]string, valueType ValueType) StorageValueMetadata {