diff --git a/cmd/hack/hack.go b/cmd/hack/hack.go
index af60221cd0fa962bd61420497bce5a306be8f20d..cd39804299ca30d2d5b47516ff2276b3ef145eb6 100644
--- a/cmd/hack/hack.go
+++ b/cmd/hack/hack.go
@@ -1076,7 +1076,7 @@ func readAccount(chaindata string, account common.Address, block uint64, rewind
if v != nil {
err = changeset.StorageChangeSetBytes(v).Walk(func(key, value []byte) error {
if bytes.HasPrefix(key, secKey) {
- incarnation := ^binary.BigEndian.Uint64(key[common.HashLength : common.HashLength+common.IncarnationLength])
+ incarnation := binary.BigEndian.Uint64(key[common.HashLength : common.HashLength+common.IncarnationLength])
if !printed {
fmt.Printf("Changes for block %d\n", timestamp)
printed = true
@@ -1123,7 +1123,7 @@ func nextIncarnation(chaindata string, addrHash common.Hash) {
return
}
if found {
- fmt.Printf("Incarnation: %d\n", (^binary.BigEndian.Uint64(incarnationBytes[:]))+1)
+ fmt.Printf("Incarnation: %d\n", (binary.BigEndian.Uint64(incarnationBytes[:]))+1)
return
}
fmt.Printf("Incarnation(f): %d\n", state.FirstContractIncarnation)
diff --git a/cmd/rpcdaemon/commands/state_reader.go b/cmd/rpcdaemon/commands/state_reader.go
index d589c201aea5e9028d497c8f2b29a987a24f5ea3..d28f416f6d89a0a79ac9f73ac99bf53098d559c4 100644
--- a/cmd/rpcdaemon/commands/state_reader.go
+++ b/cmd/rpcdaemon/commands/state_reader.go
@@ -175,7 +175,7 @@ func (r *StateReader) ForEachStorage(addr common.Address, start []byte, cb func(
if err := acc.DecodeForStorage(accData); err != nil {
return fmt.Errorf("decoding account %x: %w", addr, err)
}
- binary.BigEndian.PutUint64(s[common.AddressLength:], ^acc.Incarnation)
+ binary.BigEndian.PutUint64(s[common.AddressLength:], acc.Incarnation)
copy(s[common.AddressLength+common.IncarnationLength:], start)
var lastKey common.Hash
overrideCounter := 0
diff --git a/cmd/rpctest/proofs.go b/cmd/rpctest/proofs.go
index 3796b3c78a13fc8c6f9dc92122d7d11ee9c6b86b..c54f04f284e63b95ef5e58a88e5cef2385de1944 100644
--- a/cmd/rpctest/proofs.go
+++ b/cmd/rpctest/proofs.go
@@ -214,7 +214,7 @@ func fixState(chaindata string, url string) {
sl := trie.NewSubTrieLoader(blockNum)
contractPrefix := make([]byte, common.HashLength+common.IncarnationLength)
copy(contractPrefix, addrHash[:])
- binary.BigEndian.PutUint64(contractPrefix[common.HashLength:], ^account.Incarnation)
+ binary.BigEndian.PutUint64(contractPrefix[common.HashLength:], account.Incarnation)
rl := trie.NewRetainList(0)
subTries, err1 := sl.LoadSubTries(stateDb, blockNum, rl, nil /* HashCollector */, [][]byte{contractPrefix}, []int{8 * len(contractPrefix)}, false)
if err1 != nil || subTries.Hashes[0] != account.Root {
@@ -244,7 +244,7 @@ func fixState(chaindata string, url string) {
for key, entry := range sm {
var cKey [common.HashLength + common.IncarnationLength + common.HashLength]byte
copy(cKey[:], addrHash[:])
- binary.BigEndian.PutUint64(cKey[common.HashLength:], ^account.Incarnation)
+ binary.BigEndian.PutUint64(cKey[common.HashLength:], account.Incarnation)
copy(cKey[common.HashLength+common.IncarnationLength:], key[:])
dbValue, _ := stateDb.Get(dbutils.CurrentStateBucket, cKey[:])
value := bytes.TrimLeft(entry.Value[:], "\x00")
@@ -257,7 +257,7 @@ func fixState(chaindata string, url string) {
}
var cKey [common.HashLength + common.IncarnationLength + common.HashLength]byte
copy(cKey[:], addrHash[:])
- binary.BigEndian.PutUint64(cKey[common.HashLength:], ^account.Incarnation)
+ binary.BigEndian.PutUint64(cKey[common.HashLength:], account.Incarnation)
if err := stateDb.Walk(dbutils.CurrentStateBucket, cKey[:], 8*(common.HashLength+common.IncarnationLength), func(k, v []byte) (bool, error) {
var kh common.Hash
copy(kh[:], k[common.HashLength+common.IncarnationLength:])
diff --git a/cmd/state/stateless/state_snapshot.go b/cmd/state/stateless/state_snapshot.go
index dcc92c60af6cdaf2b8bc337b22f8119bb072fd0d..a7315dc425a4034a10319e3c2a502c14920c923a 100644
--- a/cmd/state/stateless/state_snapshot.go
+++ b/cmd/state/stateless/state_snapshot.go
@@ -291,7 +291,7 @@ func checkRoots(stateDb ethdb.Database, rootHash common.Hash, blockNum uint64) {
sl := trie.NewSubTrieLoader(blockNum)
contractPrefix := make([]byte, common.HashLength+common.IncarnationLength)
copy(contractPrefix, addrHash[:])
- binary.BigEndian.PutUint64(contractPrefix[common.HashLength:], ^account.Incarnation)
+ binary.BigEndian.PutUint64(contractPrefix[common.HashLength:], account.Incarnation)
rl := trie.NewRetainList(0)
subTries, err := sl.LoadSubTries(stateDb, blockNum, rl, nil /* HashCollector */, [][]byte{contractPrefix}, []int{8 * len(contractPrefix)}, false)
if err != nil {
diff --git a/common/changeset/storage_changeset_utils.go b/common/changeset/storage_changeset_utils.go
index 941e1bd27cd04bb195cf9bd5f3f794e7ea42fb5c..cce2b02e992c84275570e48974077aeeb021f267 100644
--- a/common/changeset/storage_changeset_utils.go
+++ b/common/changeset/storage_changeset_utils.go
@@ -58,7 +58,7 @@ func encodeStorage(s *ChangeSet, keyPrefixLen uint32) ([]byte, error) {
currentKey := -1
for i, change := range s.Changes {
addrBytes := change.Key[0:keyPrefixLen] // hash or raw address
- incarnation := ^binary.BigEndian.Uint64(change.Key[keyPrefixLen:])
+ incarnation := binary.BigEndian.Uint64(change.Key[keyPrefixLen:])
keyBytes := change.Key[keyPrefixLen+common.IncarnationLength : keyPrefixLen+common.HashLength+common.IncarnationLength] // hash or raw key
//found new contract address
if i == 0 || !bytes.Equal(currentContract.AddrBytes, addrBytes) || currentContract.Incarnation != incarnation {
@@ -68,7 +68,7 @@ func encodeStorage(s *ChangeSet, keyPrefixLen uint32) ([]byte, error) {
//add to incarnations part only if it's not default
if incarnation != DefaultIncarnation {
binary.BigEndian.PutUint32(b[0:], uint32(currentKey))
- binary.BigEndian.PutUint64(b[4:], ^incarnation)
+ binary.BigEndian.PutUint64(b[4:], incarnation)
notDefaultIncarnationsBytes = append(notDefaultIncarnationsBytes, b...)
nonDefaultIncarnationCounter++
}
@@ -203,7 +203,7 @@ func decodeStorage(b []byte, keyPrefixLen int, cs *ChangeSet) error {
if numOfNotDefaultIncarnations > 0 {
for i := 0; i < numOfNotDefaultIncarnations; i++ {
id := binary.BigEndian.Uint32(b[incarnationsStart+i*12:])
- keys[id].Incarnation = ^binary.BigEndian.Uint64(b[incarnationsStart+i*12+4:])
+ keys[id].Incarnation = binary.BigEndian.Uint64(b[incarnationsStart+i*12+4:])
}
}
@@ -223,7 +223,7 @@ func decodeStorage(b []byte, keyPrefixLen int, cs *ChangeSet) error {
for i := range v.Keys {
k := make([]byte, keyPrefixLen+common.IncarnationLength+common.HashLength)
copy(k[:keyPrefixLen], v.AddrBytes)
- binary.BigEndian.PutUint64(k[keyPrefixLen:], ^v.Incarnation)
+ binary.BigEndian.PutUint64(k[keyPrefixLen:], v.Incarnation)
copy(k[keyPrefixLen+common.IncarnationLength:keyPrefixLen+common.HashLength+common.IncarnationLength], v.Keys[i])
val, innerErr := findValue(b[valsInfoStart:], id)
if innerErr != nil {
@@ -304,7 +304,7 @@ func walkStorageChangeSet(b []byte, keyPrefixLen int, f func(k, v []byte) error)
notDefaultIncarnations := make(map[uint32]uint64, numOfNotDefaultIncarnations)
if numOfNotDefaultIncarnations > 0 {
for i := 0; i < numOfNotDefaultIncarnations; i++ {
- notDefaultIncarnations[binary.BigEndian.Uint32(b[incarnatonsStart+i*12:])] = ^binary.BigEndian.Uint64(b[incarnatonsStart+i*12+4:])
+ notDefaultIncarnations[binary.BigEndian.Uint32(b[incarnatonsStart+i*12:])] = binary.BigEndian.Uint64(b[incarnatonsStart+i*12+4:])
}
}
@@ -333,7 +333,7 @@ func walkStorageChangeSet(b []byte, keyPrefixLen int, f func(k, v []byte) error)
for j := startKeys; j < endKeys; j++ {
copy(k[:keyPrefixLen], addrBytes[:keyPrefixLen])
- binary.BigEndian.PutUint64(k[keyPrefixLen:], ^incarnation)
+ binary.BigEndian.PutUint64(k[keyPrefixLen:], incarnation)
copy(k[keyPrefixLen+common.IncarnationLength:keyPrefixLen+common.HashLength+common.IncarnationLength], b[keysStart+j*common.HashLength:])
val, innerErr := findValue(b[valsInfoStart:], id)
if innerErr != nil {
@@ -357,7 +357,7 @@ func findInStorageChangeSet(b []byte, keyPrefixLen int, k []byte) ([]byte, error
keyPrefixLen,
k[0:keyPrefixLen],
k[keyPrefixLen+common.IncarnationLength:keyPrefixLen+common.HashLength+common.IncarnationLength],
- ^binary.BigEndian.Uint64(k[keyPrefixLen:]), /* incarnation */
+ binary.BigEndian.Uint64(k[keyPrefixLen:]), /* incarnation */
)
}
@@ -429,7 +429,7 @@ func doSearch(
})
var foundIncarnation uint64 = DefaultIncarnation
if incIndex < numOfNotDefaultIncarnations && int(binary.BigEndian.Uint32(b[incarnationsStart+12*incIndex:])) == addrID {
- foundIncarnation = ^binary.BigEndian.Uint64(b[incarnationsStart+12*incIndex+4:])
+ foundIncarnation = binary.BigEndian.Uint64(b[incarnationsStart+12*incIndex+4:])
}
if foundIncarnation == incarnation {
diff --git a/common/dbutils/composite_keys.go b/common/dbutils/composite_keys.go
index e6df205f57abeee5b49003300feaefac76e38980..9a1bd3bff6eeb7ed9afb9ce5a01bc11c09eb057e 100644
--- a/common/dbutils/composite_keys.go
+++ b/common/dbutils/composite_keys.go
@@ -104,7 +104,7 @@ func GenerateCompositeTrieKey(addressHash common.Hash, seckey common.Hash) []byt
// AddrHash + incarnation + KeyHash
// For contract storage
func GenerateCompositeStorageKey(addressHash common.Hash, incarnation uint64, seckey common.Hash) []byte {
- compositeKey := make([]byte, 0, common.HashLength+8+common.HashLength)
+ compositeKey := make([]byte, 0, common.HashLength+common.IncarnationLength+common.HashLength)
compositeKey = append(compositeKey, GenerateStoragePrefix(addressHash[:], incarnation)...)
compositeKey = append(compositeKey, seckey[:]...)
return compositeKey
@@ -121,10 +121,10 @@ func ParseCompositeStorageKey(compositeKey []byte) (common.Hash, uint64, common.
// AddrHash + incarnation + KeyHash
// For contract storage (for plain state)
func PlainGenerateCompositeStorageKey(address common.Address, incarnation uint64, key common.Hash) []byte {
- compositeKey := make([]byte, common.AddressLength+8+common.HashLength)
+ compositeKey := make([]byte, common.AddressLength+common.IncarnationLength+common.HashLength)
copy(compositeKey, address[:])
- binary.BigEndian.PutUint64(compositeKey[common.AddressLength:], ^incarnation)
- copy(compositeKey[common.AddressLength+8:], key[:])
+ binary.BigEndian.PutUint64(compositeKey[common.AddressLength:], incarnation)
+ copy(compositeKey[common.AddressLength+common.IncarnationLength:], key[:])
return compositeKey
}
@@ -138,10 +138,10 @@ func PlainParseCompositeStorageKey(compositeKey []byte) (common.Address, uint64,
// AddrHash + incarnation + StorageHashPrefix
func GenerateCompositeStoragePrefix(addressHash []byte, incarnation uint64, storageHashPrefix []byte) []byte {
- key := make([]byte, common.HashLength+8+len(storageHashPrefix))
+ key := make([]byte, common.HashLength+common.IncarnationLength+len(storageHashPrefix))
copy(key, addressHash)
- binary.BigEndian.PutUint64(key[common.HashLength:], ^incarnation)
- copy(key[common.HashLength+8:], storageHashPrefix)
+ binary.BigEndian.PutUint64(key[common.HashLength:], incarnation)
+ copy(key[common.HashLength+common.IncarnationLength:], storageHashPrefix)
return key
}
@@ -149,7 +149,7 @@ func GenerateCompositeStoragePrefix(addressHash []byte, incarnation uint64, stor
func GenerateStoragePrefix(addressHash []byte, incarnation uint64) []byte {
prefix := make([]byte, common.HashLength+8)
copy(prefix, addressHash)
- binary.BigEndian.PutUint64(prefix[common.HashLength:], ^incarnation)
+ binary.BigEndian.PutUint64(prefix[common.HashLength:], incarnation)
return prefix
}
@@ -157,44 +157,24 @@ func GenerateStoragePrefix(addressHash []byte, incarnation uint64) []byte {
func PlainGenerateStoragePrefix(address []byte, incarnation uint64) []byte {
prefix := make([]byte, common.AddressLength+8)
copy(prefix, address)
- binary.BigEndian.PutUint64(prefix[common.AddressLength:], ^incarnation)
+ binary.BigEndian.PutUint64(prefix[common.AddressLength:], incarnation)
return prefix
}
func PlainParseStoragePrefix(prefix []byte) (common.Address, uint64) {
var addr common.Address
copy(addr[:], prefix[:common.AddressLength])
- inc := ^binary.BigEndian.Uint64(prefix[common.AddressLength : common.AddressLength+common.IncarnationLength])
+ inc := binary.BigEndian.Uint64(prefix[common.AddressLength : common.AddressLength+common.IncarnationLength])
return addr, inc
}
func ParseStoragePrefix(prefix []byte) (common.Hash, uint64) {
var addrHash common.Hash
copy(addrHash[:], prefix[:common.HashLength])
- inc := ^binary.BigEndian.Uint64(prefix[common.HashLength : common.HashLength+common.IncarnationLength])
+ inc := binary.BigEndian.Uint64(prefix[common.HashLength : common.HashLength+common.IncarnationLength])
return addrHash, inc
}
-func DecodeIncarnation(buf []byte) uint64 {
- incarnation := binary.BigEndian.Uint64(buf)
- return incarnation ^ ^uint64(0)
-}
-
-func EncodeIncarnation(incarnation uint64, buf []byte) {
- binary.BigEndian.PutUint64(buf, ^incarnation)
-}
-
-func RemoveIncarnationFromKey(key []byte, out *[]byte) {
- tmp := (*out)[:0]
- if len(key) <= common.HashLength {
- tmp = append(tmp, key...)
- } else {
- tmp = append(tmp, key[:common.HashLength]...)
- tmp = append(tmp, key[common.HashLength+8:]...)
- }
- *out = tmp
-}
-
// Key + blockNum
func CompositeKeySuffix(key []byte, timestamp uint64) (composite, encodedTS []byte) {
encodedTS = EncodeTimestamp(timestamp)
diff --git a/common/dbutils/history_index_test.go b/common/dbutils/history_index_test.go
index 49531bc31242fb99fbd70e8d0a1fe3d1d9333163..4b70a798be21635860a670359d6f243d7f441994 100644
--- a/common/dbutils/history_index_test.go
+++ b/common/dbutils/history_index_test.go
@@ -1,14 +1,12 @@
package dbutils
import (
- "fmt"
"reflect"
"testing"
)
func TestHistoryIndex_Search1(t *testing.T) {
index := NewHistoryIndex().Append(3, false).Append(5, false).Append(8, false)
- fmt.Println(index.Decode())
v, _, _ := index.Search(1)
if v != 3 {
t.Fatal("must be 3 but", v)
diff --git a/core/generate_index.go b/core/generate_index.go
index f136472cee7297c7aeaef905aae91ecf3216718e..8bc5d9b0258623ec63c98865ecc36634515f57c4 100644
--- a/core/generate_index.go
+++ b/core/generate_index.go
@@ -157,9 +157,6 @@ func loadFunc(k []byte, value []byte, state etl.State, next etl.LoadNextFunc) er
return errors.New("incorrect value")
}
k = common.CopyBytes(k)
- if len(k) >= 28 {
- binary.BigEndian.PutUint64(k[common.AddressLength:], ^binary.BigEndian.Uint64(k[common.AddressLength:]))
- }
currentChunkKey := dbutils.IndexChunkKey(k, ^uint64(0))
indexBytes, err1 := state.Get(currentChunkKey)
if err1 != nil && !errors.Is(err1, ethdb.ErrKeyNotFound) {
@@ -203,9 +200,6 @@ func getExtractFunc(bytes2walker func([]byte) changeset.Walker) etl.ExtractFunc
blockNum, _ := dbutils.DecodeTimestamp(dbKey)
return bytes2walker(dbValue).Walk(func(changesetKey, changesetValue []byte) error {
key := common.CopyBytes(changesetKey)
- if len(key) >= 28 {
- binary.BigEndian.PutUint64(key[common.AddressLength:], ^binary.BigEndian.Uint64(key[common.AddressLength:]))
- }
v := make([]byte, 9)
binary.BigEndian.PutUint64(v, blockNum)
if len(changesetValue) == 0 {
diff --git a/core/generate_index_test.go b/core/generate_index_test.go
index 65cbb28317b155eeed5d6f27263a05ffc17d5318..d793c1083fd490aaf52cc0c1577f5a9e843a7e15 100644
--- a/core/generate_index_test.go
+++ b/core/generate_index_test.go
@@ -175,7 +175,7 @@ func generateTestData(t *testing.T, db ethdb.Database, csBucket []byte, numOfBlo
}
defaultIncarnation := make([]byte, 8)
- binary.BigEndian.PutUint64(defaultIncarnation, ^uint64(1))
+ binary.BigEndian.PutUint64(defaultIncarnation, uint64(1))
for i := range addrs {
addrs[i] = append(addrs[i], defaultIncarnation...)
addrs[i] = append(addrs[i], keys[i]...)
diff --git a/core/genesis.go b/core/genesis.go
index 09c14311a6bee960eace5226c32344318324e0bc..d21982ede2a9978f11852804a65f679ded65fbc3 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -270,7 +270,7 @@ func (g *Genesis) ToBlock(db ethdb.Database, history bool) (*types.Block, *state
if len(account.Code) == 0 && len(account.Storage) > 0 {
// Special case for weird tests - inaccessible storage
var b [8]byte
- binary.BigEndian.PutUint64(b[:], 1)
+ binary.BigEndian.PutUint64(b[:], state.FirstContractIncarnation)
if err := db.Put(dbutils.IncarnationMapBucket, addr[:], b[:]); err != nil {
return nil, nil, nil, err
}
diff --git a/core/state/database.go b/core/state/database.go
index 799ec8c403219707add76af409db4c7104ecc28e..106df469d80a6ca8e6c3c1d9a78b38b5e49aa2ce 100644
--- a/core/state/database.go
+++ b/core/state/database.go
@@ -411,7 +411,7 @@ func (tds *TrieDbState) buildStorageWrites() (common.StorageKeys, [][]byte) {
for keyHash := range m {
var storageKey common.StorageKey
copy(storageKey[:], addrHash[:])
- binary.BigEndian.PutUint64(storageKey[common.HashLength:], ^tds.aggregateBuffer.storageIncarnation[addrHash])
+ binary.BigEndian.PutUint64(storageKey[common.HashLength:], tds.aggregateBuffer.storageIncarnation[addrHash])
copy(storageKey[common.HashLength+common.IncarnationLength:], keyHash[:])
storageTouches = append(storageTouches, storageKey)
}
@@ -553,7 +553,7 @@ func (tds *TrieDbState) resolveAccountAndStorageTouches(accountTouches common.Ha
nibbles[i*2] = b / 16
nibbles[i*2+1] = b % 16
}
- binary.BigEndian.PutUint64(bytes8[:], ^incarnation)
+ binary.BigEndian.PutUint64(bytes8[:], incarnation)
for i, b := range bytes8[:] {
nibbles[2*common.HashLength+i*2] = b / 16
nibbles[2*common.HashLength+i*2+1] = b % 16
@@ -882,7 +882,7 @@ func (tds *TrieDbState) UnwindTo(blockNr uint64) error {
m = make(map[common.Hash][]byte)
b.storageUpdates[addrHash] = m
}
- b.storageIncarnation[addrHash] = ^binary.BigEndian.Uint64([]byte(key)[common.HashLength:])
+ b.storageIncarnation[addrHash] = binary.BigEndian.Uint64([]byte(key)[common.HashLength:])
var storageKey common.StorageKey
copy(storageKey[:], []byte(key))
b.storageReads[storageKey] = struct{}{}
diff --git a/core/state/plain_readonly.go b/core/state/plain_readonly.go
index 74a8b8123b602d9ffae0395399168f40ac00c2e8..43189d91b282e445beae9589d6e62042e15660a1 100644
--- a/core/state/plain_readonly.go
+++ b/core/state/plain_readonly.go
@@ -21,6 +21,7 @@ import (
"context"
"encoding/binary"
"errors"
+ "github.com/ledgerwatch/turbo-geth/common/changeset"
"math/big"
"github.com/holiman/uint256"
@@ -67,7 +68,7 @@ func (dbs *PlainDBState) ForEachStorage(addr common.Address, start []byte, cb fu
log.Error("Error decoding account", "error", err)
return err
}
- binary.BigEndian.PutUint64(s[common.AddressLength:], ^acc.Incarnation)
+ binary.BigEndian.PutUint64(s[common.AddressLength:], acc.Incarnation)
copy(s[common.AddressLength+common.IncarnationLength:], start)
var lastKey common.Hash
overrideCounter := 0
@@ -263,8 +264,8 @@ func (dbs *PlainDBState) CreateContract(address common.Address) error {
func (dbs *PlainDBState) WalkStorageRange(addrHash common.Hash, prefix trie.Keybytes, maxItems int, walker func(common.Hash, big.Int)) (bool, error) {
startkey := make([]byte, common.HashLength+common.IncarnationLength+common.HashLength)
copy(startkey, addrHash[:])
- // TODO: [Issue 99] Support incarnations
- binary.BigEndian.PutUint64(startkey[common.HashLength:], ^uint64(1))
+
+ binary.BigEndian.PutUint64(startkey[common.HashLength:], changeset.DefaultIncarnation)
copy(startkey[common.HashLength+common.IncarnationLength:], prefix.Data)
fixedbits := (common.HashLength + common.IncarnationLength + len(prefix.Data)) * 8
diff --git a/core/state/readonly.go b/core/state/readonly.go
index 23374a7ccb051fdbfc9338ec8d2c5d1f77f2e624..0e4a4a6a3ebf0aa72586a663466d11c6e482a337 100644
--- a/core/state/readonly.go
+++ b/core/state/readonly.go
@@ -21,6 +21,7 @@ import (
"context"
"encoding/binary"
"fmt"
+ "github.com/ledgerwatch/turbo-geth/common/changeset"
"math/big"
"github.com/holiman/uint256"
@@ -86,7 +87,7 @@ func (dbs *DbState) ForEachStorage(addr common.Address, start []byte, cb func(ke
log.Error("Error decoding account", "error", err)
return err
}
- binary.BigEndian.PutUint64(s[common.HashLength:], ^acc.Incarnation)
+ binary.BigEndian.PutUint64(s[common.HashLength:], acc.Incarnation)
copy(s[common.HashLength+common.IncarnationLength:], start)
var lastSecKey common.Hash
overrideCounter := 0
@@ -292,7 +293,7 @@ func (dbs *DbState) WalkStorageRange(addrHash common.Hash, prefix trie.Keybytes,
startkey := make([]byte, common.HashLength+common.IncarnationLength+common.HashLength)
copy(startkey, addrHash[:])
// TODO: [Issue 99] Support incarnations
- binary.BigEndian.PutUint64(startkey[common.HashLength:], ^uint64(1))
+ binary.BigEndian.PutUint64(startkey[common.HashLength:], changeset.DefaultIncarnation)
copy(startkey[common.HashLength+common.IncarnationLength:], prefix.Data)
fixedbits := (common.HashLength + common.IncarnationLength + len(prefix.Data)) * 8
diff --git a/trie/flatdb_sub_trie_loader.go b/trie/flatdb_sub_trie_loader.go
index 91074a7d2baba95e224e185a41e1052bf67c8cde..290e41ba29e885fc1682922700166b69e648bd5f 100644
--- a/trie/flatdb_sub_trie_loader.go
+++ b/trie/flatdb_sub_trie_loader.go
@@ -301,7 +301,7 @@ func (fstl *FlatDbSubTrieLoader) iteration(c, ih ethdb.Cursor, first bool) error
return fmt.Errorf("fail DecodeForStorage: %w", err)
}
copy(fstl.accAddrHashWithInc[:], fstl.k)
- binary.BigEndian.PutUint64(fstl.accAddrHashWithInc[32:], ^fstl.accountValue.Incarnation)
+ binary.BigEndian.PutUint64(fstl.accAddrHashWithInc[32:], fstl.accountValue.Incarnation)
// Now we know the correct incarnation of the account, and we can skip all irrelevant storage records
// Since 0 incarnation if 0xfff...fff, and we do not expect any records like that, this automatically
diff --git a/trie/flatdb_sub_trie_loader_test.go b/trie/flatdb_sub_trie_loader_test.go
index fe50c0702f53d047cf57a908bb1660cbefa835c2..7d7dad220937f46aa1cd7a34425547dc634fcf35 100644
--- a/trie/flatdb_sub_trie_loader_test.go
+++ b/trie/flatdb_sub_trie_loader_test.go
@@ -357,7 +357,7 @@ func TestApiDetails(t *testing.T) {
{ // storage loader
loader := NewSubTrieLoader(0)
rl := NewRetainList(0)
- binary.BigEndian.PutUint64(bytes8[:], ^uint64(2))
+ binary.BigEndian.PutUint64(bytes8[:], uint64(2))
for i, b := range bytes8[:] {
bytes16[i*2] = b / 16
bytes16[i*2+1] = b % 16
@@ -495,7 +495,7 @@ func TestCreateLoadingPrefixes(t *testing.T) {
tr := New(common.Hash{})
kAcc1 := common.FromHex("0001cf1ce0664746d39af9f6db99dc3370282f1d9d48df7f804b7e6499558c83")
kInc := make([]byte, 8)
- binary.BigEndian.PutUint64(kInc, ^uint64(1))
+ binary.BigEndian.PutUint64(kInc, uint64(1))
ks1 := common.FromHex("0000000000000000000000000000000000000000000000000000000000000001")
acc1 := accounts.NewAccount()
acc1.Balance.SetUint64(12345)
@@ -524,7 +524,7 @@ func TestCreateLoadingPrefixes(t *testing.T) {
rs.AddKey(concat(concat(kAcc2, kInc...), ks2...))
rs.AddKey(concat(concat(kAcc2, kInc...), ks22...))
dbPrefixes, fixedbits, hooks := tr.FindSubTriesToLoad(rs)
- assert.Equal("[0001cf1ce0664746d39af9f6db99dc3370282f1d9d48df7f804b7e6499558c83fffffffffffffffe 0002cf1ce0664746d39af9f6db99dc3370282f1d9d48df7f804b7e6499558c83fffffffffffffffe]", fmt.Sprintf("%x", dbPrefixes))
+ assert.Equal("[0001cf1ce0664746d39af9f6db99dc3370282f1d9d48df7f804b7e6499558c830000000000000001 0002cf1ce0664746d39af9f6db99dc3370282f1d9d48df7f804b7e6499558c830000000000000001]", fmt.Sprintf("%x", dbPrefixes))
assert.Equal("[320 320]", fmt.Sprintf("%d", fixedbits))
assert.Equal("[000000010c0f010c0e000606040704060d03090a0f090f060d0b09090d0c030307000208020f010d090d04080d0f070f0800040b070e060409090505080c0803 000000020c0f010c0e000606040704060d03090a0f090f060d0b09090d0c030307000208020f010d090d04080d0f070f0800040b070e060409090505080c0803]", fmt.Sprintf("%x", hooks))
diff --git a/trie/stream.go b/trie/stream.go
index 9d123b7adf9a5f6f452c24e68863f8be71f2adc8..47245727fd9fae7d620b177d818dbecd43f854f7 100644
--- a/trie/stream.go
+++ b/trie/stream.go
@@ -186,7 +186,7 @@ func (it *Iterator) Next() (itemType StreamItem, hex1 []byte, aValue *accounts.A
fmt.Printf("accountNode %x\n", hex)
}
if v.storage != nil {
- binary.BigEndian.PutUint64(bytes8[:], ^v.Incarnation)
+ binary.BigEndian.PutUint64(bytes8[:], v.Incarnation)
// Add decompressed incarnation to the hex
for i, b := range bytes8[:] {
bytes16[i*2] = b / 16
@@ -412,7 +412,7 @@ func (it *Iterator) Next() (itemType StreamItem, hex1 []byte, aValue *accounts.A
fmt.Printf("accountNode %x\n", hex)
}
if n.storage != nil {
- binary.BigEndian.PutUint64(bytes8[:], ^n.Incarnation)
+ binary.BigEndian.PutUint64(bytes8[:], n.Incarnation)
// Add decompressed incarnation to the hex
for i, b := range bytes8[:] {
bytes16[i*2] = b / 16
diff --git a/trie/structural_test.go b/trie/structural_test.go
index 47f1da2b3f5fdb1d2a52da1e86c2392eefa0d07c..625bb9d7eb05fdabd46bcf0c4b63b3e974cdd211 100644
--- a/trie/structural_test.go
+++ b/trie/structural_test.go
@@ -188,7 +188,7 @@ func TestEmbeddedStorage(t *testing.T) {
var accountAddress = common.Address{3, 4, 5, 6}
addrHash := crypto.Keccak256(accountAddress[:])
incarnation := make([]byte, 8)
- binary.BigEndian.PutUint64(incarnation, ^uint64(2))
+ binary.BigEndian.PutUint64(incarnation, uint64(2))
var location1 = common.Hash{1}
locationKey1 := append(append([]byte{}, addrHash...), crypto.Keccak256(location1[:])...)
var location2 = common.Hash{2}
diff --git a/trie/trie.go b/trie/trie.go
index 6beee84de15f1d483c97963b94957ce17a82130c..93498ac9075865d016c40fbdda6391c1857138a1 100644
--- a/trie/trie.go
+++ b/trie/trie.go
@@ -502,7 +502,7 @@ func findSubTriesToLoad(nd node, nibblePath []byte, hook []byte, rl RetainDecide
if n.storage == nil {
return prefixes, fixedbits, hooks
}
- binary.BigEndian.PutUint64(bytes8[:], ^n.Incarnation)
+ binary.BigEndian.PutUint64(bytes8[:], n.Incarnation)
dbPrefix = append(dbPrefix, bytes8[:]...)
// Add decompressed incarnation to the nibblePath
for i, b := range bytes8[:] {