adhjustments to work with statediffing geth v1.10-alpha.2

libraries/shared/fetcher/geth_rpc_storage_fetcher.go

@@ -65,11 +65,11 @@ func (fetcher GethRPCStorageFetcher) FetchStorageDiffs(out chan<- utils.StorageD
 		accounts := utils.GetAccountsFromDiff(*stateDiff)
 		logrus.Trace(fmt.Sprintf("iterating through %d accounts on stateDiff for block %d", len(accounts), stateDiff.BlockNumber))
 		for _, account := range accounts {
-			logrus.Trace(fmt.Sprintf("iterating through %d Storage values on account with key %s", len(account.Storage), common.BytesToHash(account.Key).Hex()))
+			logrus.Trace(fmt.Sprintf("iterating through %d Storage values on account with key %s", len(account.Storage), common.BytesToHash(account.LeafKey).Hex()))
 			for _, storage := range account.Storage {
 				diff, formatErr := utils.FromGethStateDiff(account, stateDiff, storage)
 				if formatErr != nil {
-					logrus.Error("failed to format utils.StorageDiff from storage with key: ", common.BytesToHash(storage.Key), "from account with key: ", common.BytesToHash(account.Key))
+					logrus.Error("failed to format utils.StorageDiff from storage with key: ", common.BytesToHash(storage.LeafKey), "from account with key: ", common.BytesToHash(account.LeafKey))
 					errs <- formatErr
 					continue
 				}

libraries/shared/storage/backfiller.go

@@ -127,11 +127,11 @@ func (bf *backFiller) backFillRange(blockHeights []uint64, diffChan chan utils.S
 		}
 		accounts := utils.GetAccountsFromDiff(*stateDiff)
 		for _, account := range accounts {
-			logrus.Trace(fmt.Sprintf("iterating through %d Storage values on account with key %s", len(account.Storage), common.BytesToHash(account.Key).Hex()))
+			logrus.Trace(fmt.Sprintf("iterating through %d Storage values on account with key %s", len(account.Storage), common.BytesToHash(account.LeafKey).Hex()))
 			for _, storage := range account.Storage {
 				diff, formatErr := utils.FromGethStateDiff(account, stateDiff, storage)
 				if formatErr != nil {
-					logrus.Error("failed to format utils.StorageDiff from storage with key: ", common.BytesToHash(storage.Key), "from account with key: ", common.BytesToHash(account.Key))
+					logrus.Error("failed to format utils.StorageDiff from storage with key: ", common.BytesToHash(storage.LeafKey), "from account with key: ", common.BytesToHash(account.LeafKey))
 					errChan <- formatErr
 					continue
 				}

libraries/shared/storage/utils/diff.go

@@ -59,16 +59,16 @@ func FromParityCsvRow(csvRow []string) (StorageDiffInput, error) {
 
 func FromGethStateDiff(account statediff.AccountDiff, stateDiff *statediff.StateDiff, storage statediff.StorageDiff) (StorageDiffInput, error) {
 	var decodedValue []byte
-	err := rlp.DecodeBytes(storage.Value, &decodedValue)
+	err := rlp.DecodeBytes(storage.NodeValue, &decodedValue)
 	if err != nil {
 		return StorageDiffInput{}, err
 	}
 
 	return StorageDiffInput{
-		HashedAddress: common.BytesToHash(account.Key),
+		HashedAddress: common.BytesToHash(account.LeafKey),
 		BlockHash:     stateDiff.BlockHash,
 		BlockHeight:   int(stateDiff.BlockNumber.Int64()),
-		StorageKey:    common.BytesToHash(storage.Key),
+		StorageKey:    common.BytesToHash(storage.LeafKey),
 		StorageValue:  common.BytesToHash(decodedValue),
 	}, nil
 }

libraries/shared/storage/utils/diff_test.go

@@ -67,7 +67,7 @@ var _ = Describe("Storage row parsing", func() {
 
 	Describe("FromGethStateDiff", func() {
 		var (
-			accountDiff = statediff.AccountDiff{Key: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}
+			accountDiff = statediff.AccountDiff{LeafKey: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}
 			stateDiff   = &statediff.StateDiff{
 				BlockNumber: big.NewInt(rand.Int63()),
 				BlockHash:   fakes.FakeHash,
@@ -80,19 +80,20 @@ var _ = Describe("Storage row parsing", func() {
 			Expect(encodeErr).NotTo(HaveOccurred())
 
 			storageDiff := statediff.StorageDiff{
-				Key:   []byte{0, 9, 8, 7, 6, 5, 4, 3, 2, 1},
-				Value: storageValueRlp,
+				LeafKey:   []byte{0, 9, 8, 7, 6, 5, 4, 3, 2, 1},
+				NodeValue: storageValueRlp,
+				NodeType:  statediff.Leaf,
 			}
 
 			result, err := utils.FromGethStateDiff(accountDiff, stateDiff, storageDiff)
 			Expect(err).NotTo(HaveOccurred())
 
-			expectedAddress := common.BytesToHash(accountDiff.Key)
+			expectedAddress := common.BytesToHash(accountDiff.LeafKey)
 			Expect(result.HashedAddress).To(Equal(expectedAddress))
 			Expect(result.BlockHash).To(Equal(fakes.FakeHash))
 			expectedBlockHeight := int(stateDiff.BlockNumber.Int64())
 			Expect(result.BlockHeight).To(Equal(expectedBlockHeight))
-			expectedStorageKey := common.BytesToHash(storageDiff.Key)
+			expectedStorageKey := common.BytesToHash(storageDiff.LeafKey)
 			Expect(result.StorageKey).To(Equal(expectedStorageKey))
 			expectedStorageValue := common.BytesToHash(storageValueBytes)
 			Expect(result.StorageValue).To(Equal(expectedStorageValue))
@@ -104,8 +105,9 @@ var _ = Describe("Storage row parsing", func() {
 			Expect(encodeErr).NotTo(HaveOccurred())
 
 			storageDiff := statediff.StorageDiff{
-				Key:   []byte{0, 9, 8, 7, 6, 5, 4, 3, 2, 1},
-				Value: storageValueRlp,
+				LeafKey:   []byte{0, 9, 8, 7, 6, 5, 4, 3, 2, 1},
+				NodeValue: storageValueRlp,
+				NodeType:  statediff.Leaf,
 			}
 
 			result, err := utils.FromGethStateDiff(accountDiff, stateDiff, storageDiff)

libraries/shared/test_data/statediff.go

@@ -41,22 +41,24 @@ var (
 	SmallStorageValue       = common.Hex2Bytes("03")
 	SmallStorageValueRlp, _ = rlp.EncodeToBytes(SmallStorageValue)
 	storageWithSmallValue   = []statediff.StorageDiff{{
-		Key:   StorageKey,
-		Value: SmallStorageValueRlp,
-		Path:  StoragePath,
-		Proof: [][]byte{},
+		LeafKey:   StorageKey,
+		NodeValue: SmallStorageValueRlp,
+		NodeType:  statediff.Leaf,
+		Path:      StoragePath,
 	}}
 	LargeStorageValue       = common.Hex2Bytes("00191b53778c567b14b50ba0000")
 	LargeStorageValueRlp, _ = rlp.EncodeToBytes(LargeStorageValue)
 	storageWithLargeValue   = []statediff.StorageDiff{{
-		Key:   StorageKey,
-		Value: LargeStorageValueRlp,
-		Path:  StoragePath,
-		Proof: [][]byte{},
+		LeafKey:   StorageKey,
+		NodeValue: LargeStorageValueRlp,
+		Path:      StoragePath,
+		NodeType:  statediff.Leaf,
 	}}
 	StorageWithBadValue = statediff.StorageDiff{
-		Key:   StorageKey,
-		Value: []byte{0, 1, 2},
+		LeafKey:   StorageKey,
+		NodeValue: []byte{0, 1, 2},
+		NodeType:  statediff.Leaf,
+		Path:      StoragePath,
 		// this storage value will fail to be decoded as an RLP with the following error message:
 		// "input contains more than one value"
 	}
@@ -74,27 +76,27 @@ var (
 	valueBytes, _       = rlp.EncodeToBytes(testAccount)
 	CreatedAccountDiffs = []statediff.AccountDiff{
 		{
-			Key:     ContractLeafKey.Bytes(),
-			Value:   valueBytes,
-			Storage: storageWithSmallValue,
+			LeafKey:   ContractLeafKey.Bytes(),
+			NodeValue: valueBytes,
+			Storage:   storageWithSmallValue,
 		},
 	}
 
 	UpdatedAccountDiffs = []statediff.AccountDiff{{
-		Key:     AnotherContractLeafKey.Bytes(),
-		Value:   valueBytes,
-		Storage: storageWithLargeValue,
+		LeafKey:   AnotherContractLeafKey.Bytes(),
+		NodeValue: valueBytes,
+		Storage:   storageWithLargeValue,
 	}}
 	UpdatedAccountDiffs2 = []statediff.AccountDiff{{
-		Key:     AnotherContractLeafKey.Bytes(),
-		Value:   valueBytes,
-		Storage: storageWithSmallValue,
+		LeafKey:   AnotherContractLeafKey.Bytes(),
+		NodeValue: valueBytes,
+		Storage:   storageWithSmallValue,
 	}}
 
 	DeletedAccountDiffs = []statediff.AccountDiff{{
-		Key:     AnotherContractLeafKey.Bytes(),
-		Value:   valueBytes,
-		Storage: storageWithSmallValue,
+		LeafKey:   AnotherContractLeafKey.Bytes(),
+		NodeValue: valueBytes,
+		Storage:   storageWithSmallValue,
 	}}
 
 	MockStateDiff = statediff.StateDiff{